filters: automatically flip video if displaymatrix indicates so

Currently we check AV_FRAME_DATA_DISPLAYMATRIX for its rotation factor
but not for its flip factor, which could happen with some input files.
This commit adds and autovflip filter, which is applied before the
autorotate filter to flip vertically before rotating. It also changes
the displaymatrix reading code to output to mp_image->params.vflip so
it can be autoinserted as necessary.

Signed-off-by: Leo Izen <[email protected]>

Author: Traneptora

filters/f_auto_filters.c

@@ -332,6 +332,127 @@ struct mp_filter *mp_autorotate_create(struct mp_filter *parent)
     return f;
 }
 
+struct vflip_priv {
+    struct mp_subfilter sub;
+    int prev_vflip;
+    int prev_imgfmt;
+    int target_vflip;
+};
+
+static void vflip_process(struct mp_filter *f)
+{
+    struct vflip_priv *p = f->priv;
+
+    if (!mp_subfilter_read(&p->sub))
+        return;
+
+    struct mp_frame frame = p->sub.frame;
+
+    if (mp_frame_is_signaling(frame)) {
+        mp_subfilter_continue(&p->sub);
+        return;
+    }
+
+    if (frame.type != MP_FRAME_VIDEO) {
+        MP_ERR(f, "video input required!\n");
+        return;
+    }
+
+    struct mp_image *img = frame.data;
+
+    if (img->params.vflip == p->prev_vflip &&
+        img->imgfmt == p->prev_imgfmt)
+    {
+        img->params.vflip = p->target_vflip;
+        mp_subfilter_continue(&p->sub);
+        return;
+    }
+
+    if (!mp_subfilter_drain_destroy(&p->sub))
+        return;
+
+    mp_assert(!p->sub.filter);
+
+    int vflip = p->prev_vflip = img->params.vflip;
+    p->target_vflip = vflip;
+    p->prev_imgfmt = img->imgfmt;
+
+    struct mp_stream_info *info = mp_filter_find_stream_info(f);
+    if (!vflip || (info && info->vflip)) {
+        mp_subfilter_continue(&p->sub);
+        return;
+    }
+
+    if (!mp_sws_supports_input(img->imgfmt)) {
+        MP_ERR(f, "Video vflip with this format not supported\n");
+        mp_subfilter_continue(&p->sub);
+        return;
+    }
+
+    char *args[] = {NULL};
+
+    p->sub.filter = mp_create_user_filter(f, MP_OUTPUT_CHAIN_VIDEO, "vflip", args);
+
+    if (p->sub.filter) {
+        MP_INFO(f, "Inserting vflip filter.\n");
+        p->target_vflip = 0;
+    } else {
+        MP_ERR(f, "could not create vflip filter\n");
+    }
+
+    mp_subfilter_continue(&p->sub);
+}
+
+static void vflip_reset(struct mp_filter *f)
+{
+    struct vflip_priv *p = f->priv;
+
+    mp_subfilter_reset(&p->sub);
+}
+
+static void vflip_destroy(struct mp_filter *f)
+{
+    struct vflip_priv *p = f->priv;
+
+    mp_subfilter_reset(&p->sub);
+    TA_FREEP(&p->sub.filter);
+}
+
+static bool vflip_command(struct mp_filter *f, struct mp_filter_command *cmd)
+{
+    struct vflip_priv *p = f->priv;
+
+    if (cmd->type == MP_FILTER_COMMAND_IS_ACTIVE) {
+        cmd->is_active = !!p->sub.filter;
+        return true;
+    }
+    return false;
+}
+
+static const struct mp_filter_info vflip_filter = {
+    .name = "autovflip",
+    .priv_size = sizeof(struct vflip_priv),
+    .command = vflip_command,
+    .process = vflip_process,
+    .reset = vflip_reset,
+    .destroy = vflip_destroy,
+};
+
+struct mp_filter *mp_autovflip_create(struct mp_filter *parent)
+{
+    struct mp_filter *f = mp_filter_create(parent, &vflip_filter);
+    if (!f)
+        return NULL;
+
+    struct vflip_priv *p = f->priv;
+    p->prev_vflip = -1;
+
+    p->sub.in = mp_filter_add_pin(f, MP_PIN_IN, "in");
+    p->sub.out = mp_filter_add_pin(f, MP_PIN_OUT, "out");
+
+    return f;
+}
+
 struct aspeed_priv {
     struct mp_subfilter sub;
     double cur_speed, cur_speed_drop;

filters/f_auto_filters.h

@@ -6,6 +6,9 @@
 // hardware decode mode and the deinterlace user option.
 struct mp_filter *mp_deint_create(struct mp_filter *parent);
 
+// Flip according to mp_image.vflip
+struct mp_filter *mp_autovflip_create(struct mp_filter *parent);
+
 // Rotate according to mp_image.rotate and VO capabilities.
 struct mp_filter *mp_autorotate_create(struct mp_filter *parent);
 

filters/f_output_chain.c

@@ -376,6 +376,7 @@ void mp_output_chain_set_vo(struct mp_output_chain *c, struct vo *vo)
 
     p->stream_info.hwdec_devs = vo ? vo->hwdec_devs : NULL;
     p->stream_info.osd = vo ? vo->osd : NULL;
+    p->stream_info.vflip = vo ? vo->driver->caps & VO_CAP_VFLIP : false;
     p->stream_info.rotate90 = vo ? vo->driver->caps & VO_CAP_ROTATE90 : false;
     p->stream_info.dr_vo = vo;
     p->vo = vo;
@@ -652,6 +653,13 @@ static void create_video_things(struct chain *p)
         abort();
     MP_TARRAY_APPEND(p, p->pre_filters, p->num_pre_filters, f);
 
+    f = create_wrapper_filter(p);
+    f->name = "autovflip";
+    f->f = mp_autovflip_create(f->wrapper);
+    if (!f->f)
+        abort();
+    MP_TARRAY_APPEND(p, p->post_filters, p->num_post_filters, f);
+
     f = create_wrapper_filter(p);
     f->name = "autorotate";
     f->f = mp_autorotate_create(f->wrapper);

filters/filter.h

@@ -405,6 +405,7 @@ struct mp_stream_info {
 
     struct mp_hwdec_devices *hwdec_devs;
     struct osd_state *osd;
+    bool vflip;
     bool rotate90;
     struct vo *dr_vo; // for calling vo_get_image()
 };

video/mp_image.c

@@ -525,6 +525,7 @@ void mp_image_copy_attributes(struct mp_image *dst, struct mp_image *src)
     dst->pts = src->pts;
     dst->dts = src->dts;
     dst->pkt_duration = src->pkt_duration;
+    dst->params.vflip = src->params.vflip;
     dst->params.rotate = src->params.rotate;
     dst->params.stereo3d = src->params.stereo3d;
     dst->params.p_w = src->params.p_w;
@@ -851,6 +852,7 @@ bool mp_image_params_equal(const struct mp_image_params *p1,
            pl_color_repr_equal(&p1->repr, &p2->repr) &&
            p1->light == p2->light &&
            p1->chroma_location == p2->chroma_location &&
+           p1->vflip == p2->vflip &&
            p1->rotate == p2->rotate &&
            p1->stereo3d == p2->stereo3d &&
            mp_rect_equals(&p1->crop, &p2->crop);
@@ -1104,9 +1106,15 @@ struct mp_image *mp_image_from_av_frame(struct AVFrame *src)
 
     sd = av_frame_get_side_data(src, AV_FRAME_DATA_DISPLAYMATRIX);
     if (sd) {
-        double r = av_display_rotation_get((int32_t *)(sd->data));
-        if (!isnan(r))
+        int32_t *matrix = (int32_t *) sd->data;
+        // determinant
+        int vflip = ((int64_t)matrix[0] * (int64_t)matrix[4]
+                    - (int64_t)matrix[1] * (int64_t)matrix[3]) < 0;
+        double r = av_display_rotation_get(matrix);
+        if (!isnan(r)) {
             dst->params.rotate = (((int)(-r) % 360) + 360) % 360;
+            dst->params.vflip = vflip;
+        }
     }
 
     sd = av_frame_get_side_data(src, AV_FRAME_DATA_ICC_PROFILE);

video/mp_image.h

@@ -57,6 +57,8 @@ struct mp_image_params {
 
     enum mp_csp_light light;
     enum pl_chroma_location chroma_location;
+    // The image should be flipped vertically before rotating
+    bool vflip;
     // The image should be rotated clockwise (0-359 degrees).
     int rotate;
     enum mp_stereo3d_mode stereo3d; // image is encoded with this mode

video/out/gpu/libmpv_gpu.c

@@ -89,7 +89,7 @@ static int init(struct render_backend *ctx, mpv_render_param *params)
 
     ctx->hwdec_devs = hwdec_devices_create();
     gl_video_init_hwdecs(p->renderer, p->context->ra_ctx, ctx->hwdec_devs, true);
-    ctx->driver_caps = VO_CAP_ROTATE90;
+    ctx->driver_caps = VO_CAP_ROTATE90 | VO_CAP_VFLIP;
     return 0;
 }
 

video/out/gpu/video.c

@@ -3737,6 +3737,7 @@ static bool pass_upload_image(struct gl_video *p, struct mp_image *mpi, uint64_t
                     .w = mp_image_plane_w(&layout, n),
                     .h = mp_image_plane_h(&layout, n),
                     .tex = tex[n],
+                    .flipped = layout.params.vflip,
                 };
             }
         } else {
@@ -3750,6 +3751,10 @@ static bool pass_upload_image(struct gl_video *p, struct mp_image *mpi, uint64_t
     mp_assert(mpi->num_planes == p->plane_count);
 
     timer_pool_start(p->upload_timer);
+
+    if (mpi->params.vflip)
+        mp_image_vflip(mpi);
+
     for (int n = 0; n < p->plane_count; n++) {
         struct texplane *plane = &vimg->planes[n];
         if (!plane->tex) {

video/out/vo.c

@@ -579,6 +579,9 @@ static void check_vo_caps(struct vo *vo)
                    "video output does not support this.\n", rot);
         }
     }
+    if (vo->params->vflip && !(vo->driver->caps & VO_CAP_VFLIP))
+        MP_WARN(vo, "Video is flagged as vertically flipped, but the "
+                    "video output does not support this.\n");
 }
 
 static void run_reconfig(void *p)

video/out/vo.h

@@ -206,6 +206,8 @@ enum {
     VO_CAP_UNTIMED      = 1 << 4,
     // VO is responsible for freeing frames.
     VO_CAP_FRAMEOWNER   = 1 << 5,
+    // VO does handle mp_image_params.vflip
+    VO_CAP_VFLIP        = 1 << 6,
 };
 
 enum {