vo_gpu_next: use shader deinterlacer instead of software bwdif

Author: llyyr

DOCS/interface-changes/add-deinterlace-algorithm.txt

@@ -0,0 +1 @@
+add `--deinterlace-algorithm` option

DOCS/man/options.rst

@@ -1808,9 +1808,11 @@ Video
 ``--deinterlace=<yes|no|auto>``
     Enable or disable deinterlacing (default: no).
     Interlaced video shows ugly comb-like artifacts, which are visible on
-    fast movement. Enabling this typically inserts the bwdif video filter in
-    order to deinterlace the video, or lets the video output apply deinterlacing
-    if supported.
+    fast movement. Enabling this inserts the hardware deinterlacing filter if
+    ``--hwdec`` is used, otherwise the video output applies deinterlacing. If
+    neither is possible, a software bwdif filter is used instead. The
+    ``--deinterlace-algorithm`` option can be used to select the deinterlacing
+    algorithm used by the video output (``gpu-next`` only).
 
     When using ``auto``, mpv will insert a deinterlacing filter if ffmpeg
     detects that the video frame is interlaced. Be aware that there can be false
@@ -6248,6 +6250,12 @@ them.
     Among these kernels, ``burkes`` achieves a good balance between performance
     and quality, and probably is the one you want to try first.
 
+``--deinterlace-algorithm=<weave|bob|yadif|bwdif>``
+    Sets the deinterlacing algorithm to use when the VO is doing deinterlacing.
+    Currently only ``gpu-next`` supports this.
+
+    Default: ``bwdif``.
+
 ``--gpu-debug``
     Enables GPU debugging. What this means depends on the API type. For OpenGL,
     it calls ``glGetError()``, and requests a debug context. For Vulkan, it

filters/f_auto_filters.c

@@ -95,6 +95,7 @@ static void deint_process(struct mp_filter *f)
         field_parity = "auto";
     }
 
+    struct mp_stream_info *info = mp_filter_find_stream_info(f);
     bool has_filter = true;
     if (img->imgfmt == IMGFMT_VDPAU) {
         char *args[] = {"deint", "yes",
@@ -126,6 +127,11 @@ static void deint_process(struct mp_filter *f)
                         "parity", field_parity, NULL};
         p->sub.filter =
             mp_create_user_filter(f, MP_OUTPUT_CHAIN_VIDEO, "vavpp", args);
+    } else if (info && info->deinterlace && !IMGFMT_IS_HWACCEL(img->imgfmt)) {
+        char *args[] = {"interlaced-only", opts->deinterlace == 1 ? "no" : "yes",
+                        "parity", field_parity, NULL};
+        p->sub.filter = mp_create_user_filter(f, MP_OUTPUT_CHAIN_VIDEO,
+                                              "fieldrate", args);
     } else {
         has_filter = false;
     }

video/out/vo_gpu_next.c

@@ -149,6 +149,7 @@ struct priv {
     pl_options pars;
     struct m_config_cache *opts_cache;
     struct m_config_cache *next_opts_cache;
+    struct m_config_cache *filter_opts_cache;
     struct gl_next_opts *next_opts;
     struct cache shader_cache, icc_cache;
     struct mp_csp_equalizer_state *video_eq;
@@ -182,6 +183,7 @@ struct gl_next_opts {
     float background_blur_radius;
     float corner_rounding;
     bool inter_preserve;
+    int deint_algo;
     struct user_lut lut;
     struct user_lut image_lut;
     struct user_lut target_lut;
@@ -215,6 +217,11 @@ const struct m_sub_options gl_next_conf = {
         {"background-blur-radius", OPT_FLOAT(background_blur_radius)},
         {"corner-rounding", OPT_FLOAT(corner_rounding), M_RANGE(0, 1)},
         {"interpolation-preserve", OPT_BOOL(inter_preserve)},
+        {"deinterlace-algorithm", OPT_CHOICE(deint_algo,
+             {"weave", PL_DEINTERLACE_WEAVE},
+             {"bob", PL_DEINTERLACE_BOB},
+             {"yadif", PL_DEINTERLACE_YADIF},
+             {"bwdif", PL_DEINTERLACE_BWDIF})},
         {"lut", OPT_STRING(lut.opt), .flags = M_OPT_FILE},
         {"lut-type", OPT_CHOICE_C(lut.type, lut_types)},
         {"image-lut", OPT_STRING(image_lut.opt), .flags = M_OPT_FILE},
@@ -230,6 +237,7 @@ const struct m_sub_options gl_next_conf = {
     .defaults = &(struct gl_next_opts) {
         .border_background = BACKGROUND_COLOR,
         .background_blur_radius = 16.0f,
+        .deint_algo = PL_DEINTERLACE_BWDIF,
         .inter_preserve = true,
         .image_subs_hdr_peak = 1000,
         .target_hint = -1,
@@ -1036,6 +1044,7 @@ static void update_options(struct vo *vo)
     pl_options pars = p->pars;
     bool changed = m_config_cache_update(p->opts_cache);
     changed = m_config_cache_update(p->next_opts_cache) || changed;
+    changed = m_config_cache_update(p->filter_opts_cache) || changed;
     if (changed)
         update_render_options(vo);
 
@@ -1290,13 +1299,50 @@ static bool draw_frame(struct vo *vo, struct vo_frame *frame)
         mpi->priv = fp;
         fp->vo = vo;
 
+        bool is_deinterlacing = params.deinterlace_params &&
+                                mpi->fields & MP_IMGFIELD_INTERLACED;
+
+        // vf_fieldrate emits a frame for each field only to make mpv render
+        // at the second field PTS. But don't actually push it to pl_queue,
+        // because it already derives it internally from first_field.
+        bool second_tick = is_deinterlacing && (mpi->fields & MP_IMGFIELD_TICK_SECOND);
+        if (second_tick && p->last_id) {
+            talloc_free(mpi);
+            p->last_id = id;
+            continue;
+        }
+        int first_field = !is_deinterlacing ? PL_FIELD_NONE :
+            (mpi->fields & MP_IMGFIELD_TOP_FIRST) ? PL_FIELD_TOP : PL_FIELD_BOTTOM;
+
+        if (!p->last_id && !second_tick && mpi->deint_prev) {
+            struct mp_image *prev = mp_image_new_ref(mpi->deint_prev);
+            mp_image_unrefp(&prev->deint_prev);
+            struct frame_priv *prev_fp = talloc_zero(prev, struct frame_priv);
+            prev->priv = prev_fp;
+            prev_fp->vo = vo;
+            mp_assert(prev->fields & MP_IMGFIELD_TICK_SECOND);
+            pl_queue_push(p->queue, &(struct pl_source_frame) {
+                .pts = prev->pts - prev->pkt_duration / 2,
+                .duration = prev->pkt_duration,
+                .frame_data = prev,
+                .map = map_frame,
+                .unmap = unmap_frame,
+                .discard = discard_frame,
+                .first_field = (prev->fields & MP_IMGFIELD_TOP_FIRST) ?
+                               PL_FIELD_TOP : PL_FIELD_BOTTOM,
+            });
+        }
+        mp_image_unrefp(&mpi->deint_prev);
+
         pl_queue_push(p->queue, &(struct pl_source_frame) {
-            .pts = mpi->pts,
-            .duration = can_interpolate ? frame->approx_duration : 0,
+            .pts = second_tick ? mpi->pts - mpi->pkt_duration / 2 : mpi->pts,
+            .duration = can_interpolate ? frame->approx_duration :
+                            is_deinterlacing ? mpi->pkt_duration : 0,
             .frame_data = mpi,
             .map = map_frame,
             .unmap = unmap_frame,
             .discard = discard_frame,
+            .first_field = first_field,
         });
 
         p->last_id = id;
@@ -2388,6 +2434,7 @@ static int preinit(struct vo *vo)
 {
     struct priv *p = vo->priv;
     p->opts_cache = m_config_cache_alloc(p, vo->global, &gl_video_conf);
+    p->filter_opts_cache = m_config_cache_alloc(p, vo->global, &filter_conf);
     p->next_opts_cache = m_config_cache_alloc(p, vo->global, &gl_next_conf);
     p->next_opts = p->next_opts_cache->opts;
     p->video_eq = mp_csp_equalizer_create(p, vo->global);
@@ -2715,6 +2762,7 @@ static void update_render_options(struct vo *vo)
     struct priv *p = vo->priv;
     pl_options pars = p->pars;
     const struct gl_video_opts *opts = p->opts_cache->opts;
+    const struct filter_opts *fopts = p->filter_opts_cache->opts;
     pars->params.background_color[0] = opts->background_color.r / 255.0;
     pars->params.background_color[1] = opts->background_color.g / 255.0;
     pars->params.background_color[2] = opts->background_color.b / 255.0;
@@ -2748,6 +2796,9 @@ static void update_render_options(struct vo *vo)
     pars->params.plane_upscaler = map_scaler(p, SCALER_CSCALE);
     pars->params.frame_mixer = opts->interpolation ? map_scaler(p, SCALER_TSCALE) : NULL;
 
+    pars->params.deinterlace_params = fopts->deinterlace != 0 ? &pars->deinterlace_params : NULL;
+    pars->deinterlace_params.algo = p->next_opts->deint_algo;
+
     // Request as many frames as required from the decoder, depending on the
     // speed VPS/FPS ratio libplacebo may need more frames. Request frames up to
     // ratio of 1/2, but only if anti aliasing is enabled.
@@ -2756,6 +2807,9 @@ static void update_render_options(struct vo *vo)
         req_frames += ceilf(pars->params.frame_mixer->kernel->radius) *
                       (pars->params.skip_anti_aliasing ? 1 : 2);
     }
+
+    if (pars->params.deinterlace_params)
+        req_frames++;
     vo_set_queue_params(vo, 0, MPMIN(VO_MAX_REQ_FRAMES, req_frames));
 
     pars->params.deband_params = opts->deband ? &pars->deband_params : NULL;
@@ -2865,6 +2919,7 @@ const struct vo_driver video_out_gpu_next = {
     .caps = VO_CAP_ROTATE90 |
             VO_CAP_FILM_GRAIN |
             VO_CAP_VFLIP |
+            VO_CAP_DEINTERLACE |
             0x0,
     .preinit = preinit,
     .query_format = query_format,