vdpau: split off decoder parts, use "new" libavcodec vdpau hwaccel API

Move the decoder parts from vo_vdpau.c to a new file vdpau_old.c. This
file is named so because because it's written against the "old"
libavcodec vdpau pseudo-decoder (e.g. "h264_vdpau").

Add support for the "new" libavcodec vdpau support. This was recently
added and replaces the "old" vdpau parts. (In fact, Libav is about to
deprecate and remove the "old" API without deprecation grace period,
so we have to support it now. Moreover, there will probably be no Libav
release which supports both, so the transition is even less smooth than
we could hope, and we have to support both the old and new API.)

Whether the old or new API is used is checked by a configure test: if
the new API is found, it is used, otherwise the old API is assumed.

Some details might be handled differently. Especially display preemption
is a bit problematic with the "new" libavcodec vdpau support: it wants
to keep a pointer to a specific vdpau API function (which can be driver
specific, because preemption might switch drivers). Also, surface IDs
are now directly stored in AVFrames (and mp_images), so they can't be
forced to VDP_INVALID_HANDLE on preemption. (This changes even with
older libavcodec versions, because mp_image always uses the newer
representation to make vo_vdpau.c simpler.)

Decoder initialization in the new code tries to deal with codec
profiles, while the old code always uses the highest profile per codec.

Surface allocation changes. Since the decoder won't call config() in
vo_vdpau.c on video size change anymore, we allow allocating surfaces
of arbitrary size instead of locking it to what the VO was configured.
The non-hwdec code also has slightly different allocation behavior now.

Enabling the old vdpau special decoders via e.g. --vd=lavc:h264_vdpau
doesn't work anymore (a warning suggesting the --hwdec option is
printed instead).

1 files changed, 140 insertions, 232 deletions

diff --git a/video/out/vo_vdpau.c b/video/out/vo_vdpau.c
index 6f1483cdd9..414071b5a0 100644
--- a/video/out/vo_vdpau.c
+++ b/video/out/vo_vdpau.c
@@ -22,10 +22,7 @@
  */
 
 /*
- * Actual decoding and presentation are implemented here.
- * All necessary frame information is collected through
- * the "vdpau_render_state" structure after parsing all headers
- * etc. in libavcodec for different codecs.
+ * Actual decoding is done in video/decode/vdpau.c
  */
 
 #include <stdio.h>
@@ -36,9 +33,10 @@
 #include <assert.h>
 
 #include <libavutil/common.h>
-#include <libavcodec/vdpau.h>
 
 #include "config.h"
+#include "video/vdpau.h"
+#include "video/decode/dec_video.h"
 #include "core/mp_msg.h"
 #include "core/options.h"
 #include "talloc.h"
@@ -56,21 +54,6 @@
                            ? ((x)+(a)+(m) < (m) ? (x)+(a)+(m) : (x)+(a)) \
                            : ((x)+(a) < (m) ? (x)+(a) : (x)+(a)-(m)))
 
-#define CHECK_ST_ERROR(message) \
-    do { \
-        if (vdp_st != VDP_STATUS_OK) { \
-            mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] %s: %s\n", \
-                   message, vdp->get_error_string(vdp_st)); \
-            return -1; \
-        } \
-    } while (0)
-
-#define CHECK_ST_WARNING(message) \
-    do { \
-        if (vdp_st != VDP_STATUS_OK) \
-            mp_msg(MSGT_VO, MSGL_WARN, "[   vdpau] %s: %s\n", \
-                   message, vdp->get_error_string(vdp_st)); \
-    } while (0)
 
 /* number of video and output surfaces */
 #define MAX_OUTPUT_SURFACES                15
@@ -84,21 +67,15 @@
  * Global variable declaration - VDPAU specific
  */
 
-struct vdp_functions {
-#define VDP_FUNCTION(vdp_type, _, mp_name) vdp_type *mp_name;
-#include "vdpau_template.c"
-#undef VDP_FUNCTION
-};
-
 struct vdpctx {
-    struct vdp_functions *vdp;
-
+    struct mp_vdpau_ctx                mpvdp;
+    struct vdp_functions              *vdp;
     VdpDevice                          vdp_device;
+
     bool                               is_preempted;
     bool                               preemption_acked;
     bool                               preemption_user_notified;
     double                             last_preemption_retry_fail;
-    VdpGetProcAddress                 *vdp_get_proc_address;
 
     VdpPresentationQueueTarget         flip_target;
     VdpPresentationQueue               flip_queue;
@@ -131,15 +108,18 @@ struct vdpctx {
     int                                top_field_first;
     bool                               flip;
 
-    VdpDecoder                         decoder;
-    int                                decoder_max_refs;
-
     VdpRect                            src_rect_vid;
     VdpRect                            out_rect_vid;
     struct mp_osd_res                  osd_rect;
 
-    struct vdpau_render_state          surface_render[MAX_VIDEO_SURFACES];
-    bool                               surface_in_use[MAX_VIDEO_SURFACES];
+    // Surface pool
+    struct surface_entry {
+        VdpVideoSurface surface;
+        int fmt, w, h;
+        VdpChromaType chroma;
+        bool in_use;
+    } video_surfaces[MAX_VIDEO_SURFACES];
+
     int                                surface_num; // indexes output_surfaces
     int                                query_surface_num;
     VdpTime                            recent_vsync_time;
@@ -334,7 +314,7 @@ static void add_new_video_surface(struct vo *vo, VdpVideoSurface surface,
     for (int i = NUM_BUFFERED_VIDEO - 1; i > 0; i--)
         bv[i] = bv[i - 1];
     bv[0] = (struct buffered_video_surface){
-        .mpi = reserved_mpi ? mp_image_new_ref(reserved_mpi) : NULL,
+        .mpi = reserved_mpi,
         .surface = surface,
         .pts = pts,
     };
@@ -419,21 +399,19 @@ static void preemption_callback(VdpDevice device, void *context)
 {
     struct vdpctx *vc = context;
     vc->is_preempted = true;
+    vc->mpvdp.is_preempted = true;
     vc->preemption_acked = false;
 }
 
-/* Initialize vdp_get_proc_address, called from preinit() */
 static int win_x11_init_vdpau_procs(struct vo *vo)
 {
     struct vo_x11_state *x11 = vo->x11;
     struct vdpctx *vc = vo->priv;
-    if (vc->vdp)  // reinitialization after preemption
-        memset(vc->vdp, 0, sizeof(*vc->vdp));
-    else
-        vc->vdp = talloc_zero(vc, struct vdp_functions);
     struct vdp_functions *vdp = vc->vdp;
     VdpStatus vdp_st;
 
+    *vdp = (struct vdp_functions){0};
+
     struct vdp_function {
         const int id;
         int offset;
@@ -448,8 +426,10 @@ static int win_x11_init_vdpau_procs(struct vo *vo)
         {0, -1}
     };
 
+    VdpGetProcAddress *get_proc_address;
     vdp_st = vdp_device_create_x11(x11->display, x11->screen, &vc->vdp_device,
-                                   &vc->vdp_get_proc_address);
+                                   &get_proc_address);
+    vc->mpvdp.vdp_device = vc->vdp_device;
     if (vdp_st != VDP_STATUS_OK) {
         if (vc->is_preempted)
             mp_msg(MSGT_VO, MSGL_DBG2, "[vdpau] Error calling "
@@ -462,7 +442,7 @@ static int win_x11_init_vdpau_procs(struct vo *vo)
 
     vdp->get_error_string = NULL;
     for (dsc = vdp_func; dsc->offset >= 0; dsc++) {
-        vdp_st = vc->vdp_get_proc_address(vc->vdp_device, dsc->id,
+        vdp_st = get_proc_address(vc->vdp_device, dsc->id,
                                       (void **)((char *)vdp + dsc->offset));
         if (vdp_st != VDP_STATUS_OK) {
             mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Error when calling "
@@ -671,24 +651,10 @@ static void free_video_specific(struct vo *vo)
 {
     struct vdpctx *vc = vo->priv;
     struct vdp_functions *vdp = vc->vdp;
-    int i;
     VdpStatus vdp_st;
 
-    if (vc->decoder != VDP_INVALID_HANDLE)
-        vdp->decoder_destroy(vc->decoder);
-    vc->decoder = VDP_INVALID_HANDLE;
-    vc->decoder_max_refs = -1;
-
     forget_frames(vo);
 
-    for (i = 0; i < MAX_VIDEO_SURFACES; i++) {
-        if (vc->surface_render[i].surface != VDP_INVALID_HANDLE) {
-            vdp_st = vdp->video_surface_destroy(vc->surface_render[i].surface);
-            CHECK_ST_WARNING("Error when calling vdp_video_surface_destroy");
-        }
-        vc->surface_render[i].surface = VDP_INVALID_HANDLE;
-    }
-
     if (vc->video_mixer != VDP_INVALID_HANDLE) {
         vdp_st = vdp->video_mixer_destroy(vc->video_mixer);
         CHECK_ST_WARNING("Error when calling vdp_video_mixer_destroy");
@@ -702,73 +668,13 @@ static void free_video_specific(struct vo *vo)
     vc->screenshot_surface = VDP_INVALID_HANDLE;
 }
 
-static int create_vdp_decoder(struct vo *vo, int max_refs)
-{
-    struct vdpctx *vc = vo->priv;
-    struct vdp_functions *vdp = vc->vdp;
-    VdpStatus vdp_st;
-    VdpDecoderProfile vdp_decoder_profile;
-    if (vc->decoder != VDP_INVALID_HANDLE)
-        vdp->decoder_destroy(vc->decoder);
-    switch (vc->image_format) {
-    case IMGFMT_VDPAU_MPEG1:
-        vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG1;
-        break;
-    case IMGFMT_VDPAU_MPEG2:
-        vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG2_MAIN;
-        break;
-    case IMGFMT_VDPAU_H264:
-        vdp_decoder_profile = VDP_DECODER_PROFILE_H264_HIGH;
-        mp_msg(MSGT_VO, MSGL_V, "[vdpau] Creating H264 hardware decoder "
-               "for %d reference frames.\n", max_refs);
-        break;
-    case IMGFMT_VDPAU_WMV3:
-        vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_MAIN;
-        break;
-    case IMGFMT_VDPAU_VC1:
-        vdp_decoder_profile = VDP_DECODER_PROFILE_VC1_ADVANCED;
-        break;
-    case IMGFMT_VDPAU_MPEG4:
-        vdp_decoder_profile = VDP_DECODER_PROFILE_MPEG4_PART2_ASP;
-        break;
-    default:
-        mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] Unknown image format!\n");
-        goto fail;
-    }
-    vdp_st = vdp->decoder_create(vc->vdp_device, vdp_decoder_profile,
-                                 vc->vid_width, vc->vid_height, max_refs,
-                                 &vc->decoder);
-    CHECK_ST_WARNING("Failed creating VDPAU decoder");
-    if (vdp_st != VDP_STATUS_OK) {
-    fail:
-        vc->decoder = VDP_INVALID_HANDLE;
-        vc->decoder_max_refs = 0;
-        return 0;
-    }
-    vc->decoder_max_refs = max_refs;
-    return 1;
-}
-
 static int initialize_vdpau_objects(struct vo *vo)
 {
     struct vdpctx *vc = vo->priv;
 
-    vc->vdp_chroma_type = VDP_CHROMA_TYPE_420;
-    switch (vc->image_format) {
-    case IMGFMT_420P:
-        vc->vdp_pixel_format = VDP_YCBCR_FORMAT_YV12;
-        break;
-    case IMGFMT_NV12:
-        vc->vdp_pixel_format = VDP_YCBCR_FORMAT_NV12;
-        break;
-    case IMGFMT_YUYV:
-        vc->vdp_pixel_format = VDP_YCBCR_FORMAT_YUYV;
-        vc->vdp_chroma_type  = VDP_CHROMA_TYPE_422;
-        break;
-    case IMGFMT_UYVY:
-        vc->vdp_pixel_format = VDP_YCBCR_FORMAT_UYVY;
-        vc->vdp_chroma_type  = VDP_CHROMA_TYPE_422;
-    }
+    mp_vdpau_get_format(vc->image_format, &vc->vdp_chroma_type,
+                        &vc->vdp_pixel_format);
+
     if (win_x11_init_vdpau_flip_queue(vo) < 0)
         return -1;
 
@@ -784,9 +690,8 @@ static void mark_vdpau_objects_uninitialized(struct vo *vo)
 {
     struct vdpctx *vc = vo->priv;
 
-    vc->decoder = VDP_INVALID_HANDLE;
     for (int i = 0; i < MAX_VIDEO_SURFACES; i++)
-        vc->surface_render[i].surface = VDP_INVALID_HANDLE;
+        vc->video_surfaces[i].surface = VDP_INVALID_HANDLE;
     forget_frames(vo);
     vc->video_mixer = VDP_INVALID_HANDLE;
     vc->flip_queue = VDP_INVALID_HANDLE;
@@ -795,6 +700,7 @@ static void mark_vdpau_objects_uninitialized(struct vo *vo)
         vc->output_surfaces[i] = VDP_INVALID_HANDLE;
     vc->screenshot_surface = VDP_INVALID_HANDLE;
     vc->vdp_device = VDP_INVALID_HANDLE;
+    vc->mpvdp.vdp_device = vc->vdp_device;
     for (int i = 0; i < MAX_OSD_PARTS; i++) {
         struct osd_bitmap_surface *sfc = &vc->osd_surfaces[i];
         talloc_free(sfc->packer);
@@ -831,11 +737,24 @@ static int handle_preemption(struct vo *vo)
     }
     vc->last_preemption_retry_fail = 0;
     vc->is_preempted = false;
+    vc->mpvdp.is_preempted = false;
+    vc->mpvdp.preemption_counter++;
     vc->preemption_user_notified = false;
     mp_tmsg(MSGT_VO, MSGL_INFO, "[vdpau] Recovered from display preemption.\n");
     return 1;
 }
 
+static bool status_ok(struct vo *vo)
+{
+    return vo->config_ok && handle_preemption(vo) >= 0;
+}
+
+static bool ctx_status_ok(struct mp_vdpau_ctx *ctx)
+{
+    struct vo *vo = ctx->priv;
+    return handle_preemption(vo) >= 0;
+}
+
 /*
  * connect to X server, create and map window, initialize all
  * VDPAU objects, create different surfaces etc.
@@ -855,8 +774,6 @@ static int config(struct vo *vo, uint32_t width, uint32_t height,
     vc->vid_height   = height;
 
     free_video_specific(vo);
-    if (IMGFMT_IS_VDPAU(vc->image_format) && !create_vdp_decoder(vo, 2))
-        return -1;
 
     vo_x11_config_vo_window(vo, NULL, vo->dx, vo->dy, d_width, d_height,
                             flags, "vdpau");
@@ -1191,51 +1108,82 @@ static void flip_page_timed(struct vo *vo, int64_t pts_us, int duration)
     vc->surface_num = WRAP_ADD(vc->surface_num, 1, vc->num_output_surfaces);
 }
 
-static int decoder_render(struct vo *vo, void *state_ptr)
+static void release_decoder_surface(void *ptr)
 {
-    struct vdpctx *vc = vo->priv;
-    struct vdp_functions *vdp = vc->vdp;
-    VdpStatus vdp_st;
-    struct vdpau_render_state *rndr = (struct vdpau_render_state *)state_ptr;
-
-    if (handle_preemption(vo) < 0)
-        return VO_TRUE;
-
-    int max_refs = vc->image_format == IMGFMT_VDPAU_H264 ?
-        rndr->info.h264.num_ref_frames : 2;
-    if (!IMGFMT_IS_VDPAU(vc->image_format))
-        return VO_FALSE;
-    if ((vc->decoder == VDP_INVALID_HANDLE || vc->decoder_max_refs < max_refs)
-        && !create_vdp_decoder(vo, max_refs))
-        return VO_FALSE;
-
-    vdp_st = vdp->decoder_render(vc->decoder, rndr->surface,
-                                 (void *)&rndr->info,
-                                 rndr->bitstream_buffers_used,
-                                 rndr->bitstream_buffers);
-    CHECK_ST_WARNING("Failed VDPAU decoder rendering");
-    return VO_TRUE;
+    bool *in_use_ptr = ptr;
+    *in_use_ptr = false;
 }
 
+static struct mp_image *create_ref(struct surface_entry *e)
+{
+    assert(!e->in_use);
+    e->in_use = true;
+    struct mp_image *res =
+        mp_image_new_custom_ref(&(struct mp_image){0}, &e->in_use,
+                                release_decoder_surface);
+    mp_image_setfmt(res, e->fmt);
+    mp_image_set_size(res, e->w, e->h);
+    res->planes[0] = (void *)"dummy"; // must be non-NULL, otherwise arbitrary
+    res->planes[3] = (void *)(intptr_t)e->surface;
+    return res;
+}
 
-static struct vdpau_render_state *get_surface(struct vo *vo, int number)
+static struct mp_image *get_video_surface(struct mp_vdpau_ctx *ctx, int fmt,
+                                          VdpChromaType chroma, int w, int h)
 {
+    struct vo *vo = ctx->priv;
     struct vdpctx *vc = vo->priv;
     struct vdp_functions *vdp = vc->vdp;
+    VdpStatus vdp_st;
 
-    if (number >= MAX_VIDEO_SURFACES)
-        return NULL;
-    if (vc->surface_render[number].surface == VDP_INVALID_HANDLE
-        && !vc->is_preempted) {
-        VdpStatus vdp_st;
-        vdp_st = vdp->video_surface_create(vc->vdp_device, vc->vdp_chroma_type,
-                                           vc->vid_width, vc->vid_height,
-                                           &vc->surface_render[number].surface);
-        CHECK_ST_WARNING("Error when calling vdp_video_surface_create");
+    assert(IMGFMT_IS_VDPAU(fmt));
+
+    // Destroy all unused surfaces that don't have matching parameters
+    for (int n = 0; n < MAX_VIDEO_SURFACES; n++) {
+        struct surface_entry *e = &vc->video_surfaces[n];
+        if (!e->in_use && e->surface != VDP_INVALID_HANDLE) {
+            if (e->fmt != fmt || e->chroma != chroma || e->w != w || e->h != h) {
+                vdp_st = vdp->video_surface_destroy(e->surface);
+                CHECK_ST_WARNING("Error when calling vdp_video_surface_destroy");
+                e->surface = VDP_INVALID_HANDLE;
+            }
+        }
     }
-    mp_msg(MSGT_VO, MSGL_DBG3, "vdpau vid create: %u\n",
-           vc->surface_render[number].surface);
-    return &vc->surface_render[number];
+
+    // Try to find an existing unused surface
+    for (int n = 0; n < MAX_VIDEO_SURFACES; n++) {
+        struct surface_entry *e = &vc->video_surfaces[n];
+        if (!e->in_use && e->surface != VDP_INVALID_HANDLE) {
+            assert(e->w == w && e->h == h);
+            assert(e->fmt == fmt && e->chroma == chroma);
+            return create_ref(e);
+        }
+    }
+
+    // Allocate new surface
+    for (int n = 0; n < MAX_VIDEO_SURFACES; n++) {
+        struct surface_entry *e = &vc->video_surfaces[n];
+        if (!e->in_use) {
+            assert(e->surface == VDP_INVALID_HANDLE);
+            e->fmt = fmt;
+            e->chroma = chroma;
+            e->w = w;
+            e->h = h;
+            if (vc->is_preempted) {
+                mp_msg(MSGT_VO, MSGL_WARN, "[vdpau] Preempted, no surface.\n");
+            } else {
+                vdp_st = vdp->video_surface_create(vc->vdp_device, chroma,
+                                                   w, h, &e->surface);
+                CHECK_ST_WARNING("Error when calling vdp_video_surface_create");
+            }
+            return create_ref(e);
+        }
+    }
+
+    mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] no surfaces available in "
+           "get_video_surface\n");
+    // TODO: this probably breaks things forever, provide a dummy buffer?
+    return NULL;
 }
 
 static void draw_image(struct vo *vo, mp_image_t *mpi)
@@ -1243,13 +1191,17 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     struct vdpctx *vc = vo->priv;
     struct vdp_functions *vdp = vc->vdp;
     struct mp_image *reserved_mpi = NULL;
-    struct vdpau_render_state *rndr;
+    VdpVideoSurface surface = VDP_INVALID_HANDLE;
 
     if (IMGFMT_IS_VDPAU(vc->image_format)) {
-        rndr = (struct vdpau_render_state *)mpi->planes[0];
-        reserved_mpi = mpi;
+        surface = (VdpVideoSurface)(intptr_t)mpi->planes[3];
+        reserved_mpi = mp_image_new_ref(mpi);
     } else {
-        rndr = get_surface(vo, vc->deint_counter);
+        reserved_mpi = get_video_surface(&vc->mpvdp, IMGFMT_VDPAU,
+                                         vc->vdp_chroma_type, mpi->w, mpi->h);
+        if (!reserved_mpi)
+            return;
+        surface = (VdpVideoSurface)(intptr_t)reserved_mpi->planes[3];
         vc->deint_counter = WRAP_ADD(vc->deint_counter, 1, NUM_BUFFERED_VIDEO);
         if (handle_preemption(vo) >= 0) {
             VdpStatus vdp_st;
@@ -1257,7 +1209,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
                                        mpi->planes[1]};
             if (vc->image_format == IMGFMT_NV12)
                 destdata[1] = destdata[2];
-            vdp_st = vdp->video_surface_put_bits_y_cb_cr(rndr->surface,
+            vdp_st = vdp->video_surface_put_bits_y_cb_cr(surface,
                     vc->vdp_pixel_format, destdata, mpi->stride);
             CHECK_ST_WARNING("Error when calling "
                              "vdp_video_surface_put_bits_y_cb_cr");
@@ -1268,7 +1220,7 @@ static void draw_image(struct vo *vo, mp_image_t *mpi)
     else
         vc->top_field_first = 1;
 
-    add_new_video_surface(vo, rndr->surface, reserved_mpi, mpi->pts);
+    add_new_video_surface(vo, surface, reserved_mpi, mpi->pts);
 
     return;
 }
@@ -1331,58 +1283,12 @@ static struct mp_image *get_window_screenshot(struct vo *vo)
     return image;
 }
 
-static void release_decoder_surface(void *ptr)
-{
-    bool *in_use_ptr = ptr;
-    *in_use_ptr = false;
-}
-
-static struct mp_image *get_decoder_surface(struct vo *vo)
-{
-    struct vdpctx *vc = vo->priv;
-
-    if (!IMGFMT_IS_VDPAU(vc->image_format))
-        return NULL;
-
-    for (int n = 0; n < MAX_VIDEO_SURFACES; n++) {
-        if (!vc->surface_in_use[n]) {
-            vc->surface_in_use[n] = true;
-            struct mp_image *res =
-                mp_image_new_custom_ref(&(struct mp_image){0},
-                                        &vc->surface_in_use[n],
-                                        release_decoder_surface);
-            mp_image_setfmt(res, vc->image_format);
-            mp_image_set_size(res, vc->vid_width, vc->vid_height);
-            struct vdpau_render_state *rndr = get_surface(vo, n);
-            res->planes[0] = (void *)rndr;
-            return res;
-        }
-    }
-
-    mp_msg(MSGT_VO, MSGL_ERR, "[vdpau] no surfaces available in "
-           "get_decoder_surface\n");
-    // TODO: this probably breaks things forever, provide a dummy buffer?
-    return NULL;
-}
 
 static int query_format(struct vo *vo, uint32_t format)
 {
-    int default_flags = VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW
-        | VFCAP_FLIP;
-    switch (format) {
-    case IMGFMT_420P:
-    case IMGFMT_NV12:
-    case IMGFMT_YUYV:
-    case IMGFMT_UYVY:
-    case IMGFMT_VDPAU_MPEG1:
-    case IMGFMT_VDPAU_MPEG2:
-    case IMGFMT_VDPAU_H264:
-    case IMGFMT_VDPAU_WMV3:
-    case IMGFMT_VDPAU_VC1:
-    case IMGFMT_VDPAU_MPEG4:
-        return default_flags;
-    }
-    return 0;
+    if (!mp_vdpau_get_format(format, NULL, NULL))
+        return 0;
+    return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW | VFCAP_FLIP;
 }
 
 static void destroy_vdpau_objects(struct vo *vo)
@@ -1394,6 +1300,15 @@ static void destroy_vdpau_objects(struct vo *vo)
 
     free_video_specific(vo);
 
+    for (int i = 0; i < MAX_VIDEO_SURFACES; i++) {
+        // can't hold references past VO lifetime
+        assert(!vc->video_surfaces[i].in_use);
+        if (vc->video_surfaces[i].surface != VDP_INVALID_HANDLE) {
+            vdp_st = vdp->video_surface_destroy(vc->video_surfaces[i].surface);
+            CHECK_ST_WARNING("Error when calling vdp_video_surface_destroy");
+        }
+    }
+
     if (vc->flip_queue != VDP_INVALID_HANDLE) {
         vdp_st = vdp->presentation_queue_destroy(vc->flip_queue);
         CHECK_ST_WARNING("Error when calling vdp_presentation_queue_destroy");
@@ -1426,22 +1341,22 @@ static void destroy_vdpau_objects(struct vo *vo)
 
 static void uninit(struct vo *vo)
 {
-    struct vdpctx *vc = vo->priv;
-
     /* Destroy all vdpau objects */
     destroy_vdpau_objects(vo);
 
     vo_x11_uninit(vo);
-
-    // Free bitstream buffers allocated by FFmpeg
-    for (int i = 0; i < MAX_VIDEO_SURFACES; i++)
-        av_freep(&vc->surface_render[i].bitstream_buffers);
 }
 
 static int preinit(struct vo *vo)
 {
     struct vdpctx *vc = vo->priv;
 
+    vc->vdp = talloc_zero(vc, struct vdp_functions);
+    vc->mpvdp.priv = vo;
+    vc->mpvdp.vdp = vc->vdp;
+    vc->mpvdp.status_ok = ctx_status_ok;
+    vc->mpvdp.get_video_surface = get_video_surface;
+
     // Mark everything as invalid first so uninit() can tell what has been
     // allocated
     mark_vdpau_objects_uninitialized(vo);
@@ -1459,7 +1374,7 @@ static int preinit(struct vo *vo)
     // After this calling uninit() should work to free resources
 
     if (win_x11_init_vdpau_procs(vo) < 0) {
-        if (vc->vdp && vc->vdp->device_destroy)
+        if (vc->vdp->device_destroy)
             vc->vdp->device_destroy(vc->vdp_device);
         vo_x11_uninit(vo);
         return -1;
@@ -1475,13 +1390,6 @@ static int get_equalizer(struct vo *vo, const char *name, int *value)
            VO_TRUE : VO_NOTIMPL;
 }
 
-static bool status_ok(struct vo *vo)
-{
-    if (!vo->config_ok || handle_preemption(vo) < 0)
-        return false;
-    return true;
-}
-
 static int set_equalizer(struct vo *vo, const char *name, int value)
 {
     struct vdpctx *vc = vo->priv;
@@ -1534,11 +1442,11 @@ static int control(struct vo *vo, uint32_t request, void *data)
         if (vc->dropped_frame)
             vo->want_redraw = true;
         return true;
-    case VOCTRL_HWDEC_ALLOC_SURFACE:
-        *(struct mp_image **)data = get_decoder_surface(vo);
+    case VOCTRL_GET_HWDEC_INFO: {
+        struct mp_hwdec_info *arg = data;
+        arg->vdpau_ctx = &vc->mpvdp;
         return true;
-    case VOCTRL_HWDEC_DECODER_RENDER:
-        return decoder_render(vo, data);
+    }
     case VOCTRL_GET_PANSCAN:
         return VO_TRUE;
     case VOCTRL_SET_PANSCAN: