[MPlayer-dev-eng] [PATCH]Implement advanced deinterlacing for vdpau with SW decoders, try 4

[Carl Eugen Hoyos]

Hi!

Attached is a possibly more future-proof way of implementing advanced 
deinterlacing for vo vdpau (currently only non-hardware-accelerated 
codecs).

Please comment, Carl Eugen
-------------- next part --------------
Index: libvo/vo_vdpau.c
===================================================================
--- libvo/vo_vdpau.c	(revision 28934)
+++ libvo/vo_vdpau.c	(working copy)
@@ -147,11 +147,13 @@
 /* output_surfaces[NUM_OUTPUT_SURFACES] is misused for OSD. */
 #define osd_surface output_surfaces[NUM_OUTPUT_SURFACES]
 static VdpOutputSurface                   output_surfaces[NUM_OUTPUT_SURFACES + 1];
+static VdpVideoSurface                    deint_surfaces[3];
 static int                                output_surface_width, output_surface_height;
 
 static VdpVideoMixer                      video_mixer;
 static int                                deint;
 static int                                deint_type;
+static int                                deint_counter;
 static int                                pullup;
 static float                              denoise;
 static float                              sharpen;
@@ -212,11 +214,9 @@
     VdpTime dummy;
     VdpStatus vdp_st;
     int i;
-    if (vid_surface_num < 0)
+    if (vid_surface_num < 0 || deint_surfaces[2] == VDP_INVALID_HANDLE)
         return;
 
-    // we would need to provide 2 past and 1 future frames to allow advanced
-    // deinterlacing, which is not really possible currently.
     for (i = 0; i <= !!(deint > 1); i++) {
         int field = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME;
         VdpOutputSurface output_surface;
@@ -236,9 +236,10 @@
         CHECK_ST_WARNING("Error when calling vdp_presentation_queue_block_until_surface_idle")
 
         vdp_st = vdp_video_mixer_render(video_mixer, VDP_INVALID_HANDLE, 0,
-                                        field, 0, NULL,
-                                        surface_render[vid_surface_num].surface,
-                                        0, NULL, &src_rect_vid,
+                                        field, 2, deint_surfaces,
+                                        deint_surfaces[2],
+                                        1, &surface_render[vid_surface_num].surface,
+                                        &src_rect_vid,
                                         output_surface,
                                         NULL, &out_rect_vid, 0, NULL);
         CHECK_ST_WARNING("Error when calling vdp_video_mixer_render")
@@ -407,7 +408,6 @@
         &vid_height,
         &vdp_chroma_type
     };
-    if (deint == 3)
         features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL;
     if (deint == 4)
         features[feature_count++] = VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL;
@@ -425,6 +425,8 @@
     CHECK_ST_ERROR("Error when calling vdp_video_mixer_create")
 
     for (i = 0; i < feature_count; i++) feature_enables[i] = VDP_TRUE;
+    if (deint < 3)
+        feature_enables[0] = VDP_FALSE;
     if (feature_count)
         vdp_video_mixer_set_feature_enables(video_mixer, feature_count, features, feature_enables);
     if (denoise)
@@ -837,10 +839,15 @@
     if (IMGFMT_IS_VDPAU(image_format)) {
         struct vdpau_render_state *rndr = mpi->priv;
         vid_surface_num = rndr - surface_render;
+        deint = FFMIN(deint, 2);
     } else if (!(mpi->flags & MP_IMGFLAG_DRAW_CALLBACK)) {
         VdpStatus vdp_st;
         void *destdata[3] = {mpi->planes[0], mpi->planes[2], mpi->planes[1]};
-        struct vdpau_render_state *rndr = get_surface(0);
+        struct vdpau_render_state *rndr = get_surface(deint_counter);
+        deint_counter = (deint_counter + 1) & 3;
+        deint_surfaces[1] = deint_surfaces[0];
+        if (vid_surface_num >= 0)
+            deint_surfaces[0] = surface_render[vid_surface_num].surface;
         vid_surface_num = rndr - surface_render;
         vdp_st = vdp_video_surface_put_bits_y_cb_cr(rndr->surface,
                                                     VDP_YCBCR_FORMAT_YV12,
@@ -848,9 +855,12 @@
                                                     mpi->stride); // pitch
         CHECK_ST_ERROR("Error when calling vdp_video_surface_put_bits_y_cb_cr")
     }
+    if (deint < 3)
+        deint_surfaces[2] = surface_render[vid_surface_num].surface;
     top_field_first = !!(mpi->fields & MP_IMGFIELD_TOP_FIRST);
 
     video_to_output_surface();
+    deint_surfaces[2] = surface_render[vid_surface_num].surface;
     return VO_TRUE;
 }
 
@@ -984,6 +994,7 @@
 
     deint = 0;
     deint_type = 3;
+    deint_counter = 0;
     pullup = 0;
     denoise = 0;
     sharpen = 0;
@@ -1015,6 +1026,8 @@
     video_mixer = VDP_INVALID_HANDLE;
     for (i = 0; i <= NUM_OUTPUT_SURFACES; i++)
         output_surfaces[i] = VDP_INVALID_HANDLE;
+    for (i = 0; i <= 2; i++)
+        deint_surfaces[i] = VDP_INVALID_HANDLE;
     vdp_flip_queue = VDP_INVALID_HANDLE;
     output_surface_width = output_surface_height = -1;
 
@@ -1087,6 +1100,18 @@
             deint = *(int*)data;
             if (deint)
                 deint = deint_type;
+            if (deint_type > 2) {
+                VdpStatus vdp_st;
+                VdpVideoMixerFeature features[1] =
+                    {deint_type == 3 ?
+                     VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL :
+                     VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL};
+                VdpBool feature_enables[1] = {deint ? VDP_TRUE : VDP_FALSE};
+                vdp_st = vdp_video_mixer_set_feature_enables(video_mixer, 1,
+                                                             features,
+                                                             feature_enables);
+                CHECK_ST_WARNING("Error changing deinterlacing settings")
+            }
             return VO_TRUE;
         case VOCTRL_PAUSE:
             return (int_pause = 1);