static int filter_ext(struct vf_instance *vf, struct mp_image *mpi)
{
struct vf_priv_s *p = vf->priv;
int ret = 0;
if (!p->out_node) {
talloc_free(mpi);
return -1;
}
MPSWAP(struct mp_image *, p->next_image, mpi);
if (!mpi)
return 0;
// Turn PTS into frame duration (the pts field is abused for storing it)
if (p->prev_pts == MP_NOPTS_VALUE)
p->prev_pts = mpi->pts;
mpi->pts = p->next_image ? p->next_image->pts - mpi->pts : 0;
// Try to get new frames until we get rid of the input mpi.
pthread_mutex_lock(&p->lock);
while (1) {
// Not sure what we do on errors, but at least don't deadlock.
if (p->failed) {
p->failed = false;
talloc_free(mpi);
ret = -1;
break;
}
if (mpi && p->num_buffered < MP_TALLOC_ELEMS(p->buffered)) {
p->buffered[p->num_buffered++] = talloc_steal(p->buffered, mpi);
mpi = NULL;
pthread_cond_broadcast(&p->wakeup);
}
if (p->got_frame) {
vf_add_output_frame(vf, p->got_frame);
p->got_frame = NULL;
}
if (!p->getting_frame) {
// Note: this assumes getFrameAsync() will never call infiltGetFrame
// (if it does, we would deadlock)
p->getting_frame = true;
p->failed = false;
p->vsapi->getFrameAsync(p->out_frameno++, p->out_node,
vs_frame_done, vf);
}
if (!mpi)
break;
pthread_cond_wait(&p->wakeup, &p->lock);
}
pthread_mutex_unlock(&p->lock);
return ret;
}
static int filter_ext(struct vf_instance *vf, struct mp_image *mpi)
{
VdpStatus vdp_st;
struct vf_priv_s *p = vf->priv;
struct mp_vdpau_ctx *ctx = p->ctx;
struct vdp_functions *vdp = &ctx->vdp;
if (!mpi) {
return 0;
}
// Pass-through anything that's not been decoded by VDPAU
if (mpi->imgfmt != IMGFMT_VDPAU) {
vf_add_output_frame(vf, mpi);
return 0;
}
if (mp_vdpau_mixed_frame_get(mpi)) {
MP_ERR(vf, "Can't apply vdpaurb filter after vdpaupp filter.\n");
mp_image_unrefp(&mpi);
return -1;
}
struct mp_image *out = vf_alloc_out_image(vf);
if (!out) {
mp_image_unrefp(&mpi);
return -1;
}
mp_image_copy_attributes(out, mpi);
VdpVideoSurface surface = (uintptr_t)mpi->planes[3];
assert(surface > 0);
vdp_st = vdp->video_surface_get_bits_y_cb_cr(surface,
VDP_YCBCR_FORMAT_NV12,
(void * const *)out->planes,
out->stride);
CHECK_VDP_WARNING(vf, "Error when calling vdp_output_surface_get_bits_y_cb_cr");
vf_add_output_frame(vf, out);
mp_image_unrefp(&mpi);
return 0;
}
static int filter_ext(struct vf_instance *vf, struct mp_image *mpi)
{
struct vf_priv_s *p = vf->priv;
if (mpi) {
if (p->num_queued == p->cfg_num) {
vf_add_output_frame(vf, p->queued[p->num_queued - 1]);
p->num_queued--;
}
p->num_queued++;
for (int n = p->num_queued - 1; n > 0; n--)
p->queued[n] = p->queued[n - 1];
p->queued[0] = mpi;
} else {
// EOF
while (p->num_queued) {
vf_add_output_frame(vf, p->queued[p->num_queued - 1]);
p->num_queued--;
}
}
return 0;
}
// Return true if progress was made.
static bool locked_read_output(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
bool r = false;
// Move finished frames from the request slots to the vf output queue.
while (p->requested[0] && p->requested[0] != &dummy_img) {
struct mp_image *out = p->requested[0];
if (out->pts != MP_NOPTS_VALUE) {
double duration = out->pts;
out->pts = p->out_pts;
p->out_pts += duration;
}
vf_add_output_frame(vf, out);
for (int n = 0; n < p->max_requests - 1; n++)
p->requested[n] = p->requested[n + 1];
p->requested[p->max_requests - 1] = NULL;
p->out_frameno++;
r = true;
}
// Don't request frames if we haven't sent any input yet.
if (p->num_buffered + p->in_frameno == 0)
return r;
// Request new future frames as far as possible.
for (int n = 0; n < p->max_requests; n++) {
if (!p->requested[n]) {
// Note: this assumes getFrameAsync() will never call
// infiltGetFrame (if it does, we would deadlock)
p->requested[n] = (struct mp_image *)&dummy_img;
p->failed = false;
MP_TRACE(vf, "requesting frame %d (%d)\n", p->out_frameno + n, n);
p->vsapi->getFrameAsync(p->out_frameno + n, p->out_node,
vs_frame_done, vf);
}
}
return r;
}
static int recreate_video_proc(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
HRESULT hr;
destroy_video_proc(vf);
D3D11_VIDEO_PROCESSOR_CONTENT_DESC vpdesc = {
.InputFrameFormat = p->d3d_frame_format,
.InputWidth = p->c_w,
.InputHeight = p->c_h,
.OutputWidth = p->params.w,
.OutputHeight = p->params.h,
};
hr = ID3D11VideoDevice_CreateVideoProcessorEnumerator(p->video_dev, &vpdesc,
&p->vp_enum);
if (FAILED(hr))
goto fail;
D3D11_VIDEO_PROCESSOR_CAPS caps;
hr = ID3D11VideoProcessorEnumerator_GetVideoProcessorCaps(p->vp_enum, &caps);
if (FAILED(hr))
goto fail;
MP_VERBOSE(vf, "Found %d rate conversion caps. Looking for caps=0x%x.\n",
(int)caps.RateConversionCapsCount, p->mode);
int rindex = -1;
for (int n = 0; n < caps.RateConversionCapsCount; n++) {
D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS rcaps;
hr = ID3D11VideoProcessorEnumerator_GetVideoProcessorRateConversionCaps
(p->vp_enum, n, &rcaps);
if (FAILED(hr))
goto fail;
MP_VERBOSE(vf, " - %d: 0x%08x\n", n, (unsigned)rcaps.ProcessorCaps);
if (rcaps.ProcessorCaps & p->mode) {
MP_VERBOSE(vf, " (matching)\n");
if (rindex < 0)
rindex = n;
}
}
if (rindex < 0) {
MP_WARN(vf, "No fitting video processor found, picking #0.\n");
rindex = 0;
}
// TOOD: so, how do we select which rate conversion mode the processor uses?
hr = ID3D11VideoDevice_CreateVideoProcessor(p->video_dev, p->vp_enum, rindex,
&p->video_proc);
if (FAILED(hr)) {
MP_ERR(vf, "Failed to create D3D11 video processor.\n");
goto fail;
}
// Note: libavcodec does not support cropping left/top with hwaccel.
RECT src_rc = {
.right = p->params.w,
.bottom = p->params.h,
};
ID3D11VideoContext_VideoProcessorSetStreamSourceRect(p->video_ctx,
p->video_proc,
0, TRUE, &src_rc);
// This is supposed to stop drivers from f*****g up the video quality.
ID3D11VideoContext_VideoProcessorSetStreamAutoProcessingMode(p->video_ctx,
p->video_proc,
0, FALSE);
ID3D11VideoContext_VideoProcessorSetStreamOutputRate(p->video_ctx,
p->video_proc,
0,
D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL,
FALSE, 0);
D3D11_VIDEO_PROCESSOR_COLOR_SPACE csp = {
.YCbCr_Matrix = p->params.color.space != MP_CSP_BT_601,
.Nominal_Range = p->params.color.levels == MP_CSP_LEVELS_TV ? 1 : 2,
};
ID3D11VideoContext_VideoProcessorSetStreamColorSpace(p->video_ctx,
p->video_proc,
0, &csp);
if (p->out_rgb) {
if (p->params.color.space != MP_CSP_BT_601 &&
p->params.color.space != MP_CSP_BT_709)
{
MP_WARN(vf, "Unsupported video colorspace (%s/%s). Consider "
"disabling hardware decoding, or using "
"--hwdec=d3d11va-copy to get correct output.\n",
m_opt_choice_str(mp_csp_names, p->params.color.space),
m_opt_choice_str(mp_csp_levels_names, p->params.color.levels));
}
} else {
ID3D11VideoContext_VideoProcessorSetOutputColorSpace(p->video_ctx,
p->video_proc,
&csp);
}
return 0;
fail:
destroy_video_proc(vf);
return -1;
}
static int render(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
int res = -1;
HRESULT hr;
ID3D11VideoProcessorInputView *in_view = NULL;
ID3D11VideoProcessorOutputView *out_view = NULL;
struct mp_image *in = NULL, *out = NULL;
out = mp_image_pool_get(p->pool, p->out_params.imgfmt, p->params.w, p->params.h);
if (!out)
goto cleanup;
ID3D11Texture2D *d3d_out_tex = (void *)out->planes[1];
in = mp_refqueue_get(p->queue, 0);
if (!in)
goto cleanup;
ID3D11Texture2D *d3d_tex = (void *)in->planes[1];
int d3d_subindex = (intptr_t)in->planes[2];
mp_image_copy_attributes(out, in);
D3D11_VIDEO_FRAME_FORMAT d3d_frame_format;
if (!mp_refqueue_should_deint(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
} else if (mp_refqueue_top_field_first(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST;
} else {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST;
}
D3D11_TEXTURE2D_DESC texdesc;
ID3D11Texture2D_GetDesc(d3d_tex, &texdesc);
if (!p->video_proc || p->c_w != texdesc.Width || p->c_h != texdesc.Height ||
p->d3d_frame_format != d3d_frame_format)
{
p->c_w = texdesc.Width;
p->c_h = texdesc.Height;
p->d3d_frame_format = d3d_frame_format;
if (recreate_video_proc(vf) < 0)
goto cleanup;
}
if (!mp_refqueue_should_deint(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE;
} else if (mp_refqueue_is_top_field(p->queue)) {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST;
} else {
d3d_frame_format = D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST;
}
ID3D11VideoContext_VideoProcessorSetStreamFrameFormat(p->video_ctx,
p->video_proc,
0, d3d_frame_format);
D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC indesc = {
.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D,
.Texture2D = {
.ArraySlice = d3d_subindex,
},
};
hr = ID3D11VideoDevice_CreateVideoProcessorInputView(p->video_dev,
(ID3D11Resource *)d3d_tex,
p->vp_enum, &indesc,
&in_view);
if (FAILED(hr)) {
MP_ERR(vf, "Could not create ID3D11VideoProcessorInputView\n");
goto cleanup;
}
D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC outdesc = {
.ViewDimension = D3D11_VPOV_DIMENSION_TEXTURE2D,
};
hr = ID3D11VideoDevice_CreateVideoProcessorOutputView(p->video_dev,
(ID3D11Resource *)d3d_out_tex,
p->vp_enum, &outdesc,
&out_view);
if (FAILED(hr))
goto cleanup;
D3D11_VIDEO_PROCESSOR_STREAM stream = {
.Enable = TRUE,
.pInputSurface = in_view,
};
int frame = mp_refqueue_is_second_field(p->queue);
hr = ID3D11VideoContext_VideoProcessorBlt(p->video_ctx, p->video_proc,
out_view, frame, 1, &stream);
if (FAILED(hr)) {
MP_ERR(vf, "VideoProcessorBlt failed.\n");
goto cleanup;
}
res = 0;
cleanup:
if (in_view)
ID3D11VideoProcessorInputView_Release(in_view);
if (out_view)
ID3D11VideoProcessorOutputView_Release(out_view);
if (res >= 0) {
vf_add_output_frame(vf, out);
} else {
talloc_free(out);
}
mp_refqueue_next_field(p->queue);
return res;
}
static int filter_out(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
if (!mp_refqueue_has_output(p->queue))
return 0;
// no filtering
if (!mp_refqueue_should_deint(p->queue) && !p->require_filtering) {
struct mp_image *in = mp_image_new_ref(mp_refqueue_get(p->queue, 0));
if (!in)
return -1;
mp_image_set_params(in, &p->out_params);
vf_add_output_frame(vf, in);
mp_refqueue_next(p->queue);
return 0;
}
return render(vf);
}
static int reconfig(struct vf_instance *vf, struct mp_image_params *in,
struct mp_image_params *out)
{
struct vf_priv_s *p = vf->priv;
flush_frames(vf);
talloc_free(p->pool);
p->pool = NULL;
destroy_video_proc(vf);
*out = *in;
if (vf_next_query_format(vf, IMGFMT_D3D11VA) ||
vf_next_query_format(vf, IMGFMT_D3D11NV12))
{
out->imgfmt = vf_next_query_format(vf, IMGFMT_D3D11VA)
? IMGFMT_D3D11VA : IMGFMT_D3D11NV12;
out->hw_subfmt = IMGFMT_NV12;
p->out_format = DXGI_FORMAT_NV12;
p->out_shared = false;
p->out_rgb = false;
} else {
out->imgfmt = IMGFMT_D3D11RGB;
out->hw_subfmt = IMGFMT_RGB0;
p->out_format = DXGI_FORMAT_B8G8R8A8_UNORM;
p->out_shared = true;
p->out_rgb = true;
}
p->require_filtering = in->hw_subfmt != out->hw_subfmt;
p->params = *in;
p->out_params = *out;
p->pool = mp_image_pool_new(20);
mp_image_pool_set_allocator(p->pool, alloc_pool, vf);
mp_image_pool_set_lru(p->pool);
return 0;
}
static void uninit(struct vf_instance *vf)
{
struct vf_priv_s *p = vf->priv;
destroy_video_proc(vf);
flush_frames(vf);
mp_refqueue_free(p->queue);
talloc_free(p->pool);
if (p->video_ctx)
ID3D11VideoContext_Release(p->video_ctx);
if (p->video_dev)
ID3D11VideoDevice_Release(p->video_dev);
if (p->device_ctx)
ID3D11DeviceContext_Release(p->device_ctx);
if (p->vo_dev)
ID3D11Device_Release(p->vo_dev);
}
static int query_format(struct vf_instance *vf, unsigned int imgfmt)
{
if (imgfmt == IMGFMT_D3D11VA ||
imgfmt == IMGFMT_D3D11NV12 ||
imgfmt == IMGFMT_D3D11RGB)
{
return vf_next_query_format(vf, IMGFMT_D3D11VA) ||
vf_next_query_format(vf, IMGFMT_D3D11NV12) ||
vf_next_query_format(vf, IMGFMT_D3D11RGB);
}
return 0;
}
static bool test_conversion(int in, int out)
{
return (in == IMGFMT_D3D11VA ||
in == IMGFMT_D3D11NV12 ||
in == IMGFMT_D3D11RGB) &&
(out == IMGFMT_D3D11VA ||
out == IMGFMT_D3D11NV12 ||
out == IMGFMT_D3D11RGB);
}
static int control(struct vf_instance *vf, int request, void* data)
{
struct vf_priv_s *p = vf->priv;
switch (request){
case VFCTRL_GET_DEINTERLACE:
*(int*)data = !!p->deint_enabled;
return true;
case VFCTRL_SET_DEINTERLACE:
p->deint_enabled = !!*(int*)data;
return true;
case VFCTRL_SEEK_RESET:
flush_frames(vf);
return true;
default:
return CONTROL_UNKNOWN;
}
}
static int vf_open(vf_instance_t *vf)
{
struct vf_priv_s *p = vf->priv;
vf->reconfig = reconfig;
vf->filter_ext = filter_ext;
vf->filter_out = filter_out;
vf->query_format = query_format;
vf->uninit = uninit;
vf->control = control;
p->queue = mp_refqueue_alloc();
p->vo_dev = hwdec_devices_load(vf->hwdec_devs, HWDEC_D3D11VA);
if (!p->vo_dev)
return 0;
ID3D11Device_AddRef(p->vo_dev);
HRESULT hr;
hr = ID3D11Device_QueryInterface(p->vo_dev, &IID_ID3D11VideoDevice,
(void **)&p->video_dev);
if (FAILED(hr))
goto fail;
ID3D11Device_GetImmediateContext(p->vo_dev, &p->device_ctx);
if (!p->device_ctx)
goto fail;
hr = ID3D11DeviceContext_QueryInterface(p->device_ctx, &IID_ID3D11VideoContext,
(void **)&p->video_ctx);
if (FAILED(hr))
goto fail;
return 1;
fail:
uninit(vf);
return 0;
}
#define OPT_BASE_STRUCT struct vf_priv_s
static const m_option_t vf_opts_fields[] = {
OPT_FLAG("deint", deint_enabled, 0),
OPT_FLAG("interlaced-only", interlaced_only, 0),
OPT_CHOICE("mode", mode, 0,
({"blend", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BLEND},
{"bob", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_BOB},
{"adaptive", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_ADAPTIVE},
{"mocomp", D3D11_VIDEO_PROCESSOR_PROCESSOR_CAPS_DEINTERLACE_MOTION_COMPENSATION},
static int filter_ext(struct vf_instance *vf, struct mp_image *mpi)
{
struct vf_priv_s *p = vf->priv;
int ret = 0;
if (!p->out_node) {
talloc_free(mpi);
return -1;
}
MPSWAP(struct mp_image *, p->next_image, mpi);
if (!mpi)
return 0;
// Turn PTS into frame duration (the pts field is abused for storing it)
if (p->out_pts == MP_NOPTS_VALUE)
p->out_pts = mpi->pts;
mpi->pts = p->next_image ? p->next_image->pts - mpi->pts : 0;
// Try to get new frames until we get rid of the input mpi.
pthread_mutex_lock(&p->lock);
while (1) {
// Not sure what we do on errors, but at least don't deadlock.
if (p->failed) {
p->failed = false;
talloc_free(mpi);
ret = -1;
break;
}
if (mpi && p->num_buffered < MP_TALLOC_ELEMS(p->buffered)) {
p->buffered[p->num_buffered++] = talloc_steal(p->buffered, mpi);
mpi = NULL;
pthread_cond_broadcast(&p->wakeup);
}
while (p->requested[0] && p->requested[0] != &dummy_img) {
struct mp_image *out = p->requested[0];
if (out->pts != MP_NOPTS_VALUE) {
double duration = out->pts;
out->pts = p->out_pts;
p->out_pts += duration;
}
vf_add_output_frame(vf, out);
for (int n = 0; n < p->max_requests - 1; n++)
p->requested[n] = p->requested[n + 1];
p->requested[p->max_requests - 1] = NULL;
p->out_frameno++;
}
for (int n = 0; n < p->max_requests; n++) {
if (!p->requested[n]) {
// Note: this assumes getFrameAsync() will never call
// infiltGetFrame (if it does, we would deadlock)
p->requested[n] = (struct mp_image *)&dummy_img;
p->failed = false;
MP_DBG(vf, "requesting frame %d (%d)\n", p->out_frameno + n, n);
p->vsapi->getFrameAsync(p->out_frameno + n, p->out_node,
vs_frame_done, vf);
}
}
if (!mpi)
break;
pthread_cond_wait(&p->wakeup, &p->lock);
}
pthread_mutex_unlock(&p->lock);
return ret;
}
