f_autoconvert: only copy through system memory when unmappable

Author: flowreen

filters/f_autoconvert.c

@@ -233,17 +233,28 @@ static bool build_image_converter(struct mp_autoconvert *c, struct mp_log *log,
     } else if (dst_all_hw && num_fmts > 0) {
         bool upload_created = false;
         int sw_fmt = imgfmt_is_sw ? img->imgfmt : img->params.hw_subfmt;
-        // None of the targets accept the source's hardware format, so this is
-        // a transfer between two different devices, which cannot be done
-        // directly. Route the frame through system memory instead, which also
-        // lets the scaler fix up the sw format if the devices disagree.
-        bool download_first = !imgfmt_is_sw;
-
         for (int i = 0; i < num_fmts; i++) {
             // We can probably use this! Very lazy and very approximate.
             struct mp_hwupload upload = mp_hwupload_create(conv, fmts[i],
                                                            sw_fmt, false);
             if (upload.successful_init) {
+                // None of the targets accept the source's hardware format. If
+                // the two can share frames the uploader maps them directly.
+                // Otherwise this is a transfer between separate devices, which
+                // libavutil cannot do, so route it through system memory. That
+                // is also what makes a sw format conversion possible below.
+                bool download_first = !imgfmt_is_sw &&
+                    !mp_hwupload_can_map(fmts[i], img->imgfmt);
+
+                if (download_first) {
+                    mp_warn(log, "Transferring %s to %s through system memory. "
+                            "These are separate devices and cannot share "
+                            "frames, so every frame is copied twice. Use a "
+                            "decoder that outputs %s to avoid this.\n",
+                            mp_imgfmt_to_name(img->imgfmt),
+                            mp_imgfmt_to_name(fmts[i]),
+                            mp_imgfmt_to_name(fmts[i]));
+                }
                 mp_info(log, "HW-uploading to %s\n", mp_imgfmt_to_name(fmts[i]));
                 filters[2] = upload.f;
                 hwupload_fmt = upload.selected_sw_imgfmt;

filters/f_hwtransfer.c

@@ -68,6 +68,18 @@ static const struct hwmap_pairs hwmap_pairs[] = {
     {0}
 };
 
+bool mp_hwupload_can_map(int dst_hw_imgfmt, int src_imgfmt)
+{
+    for (int n = 0; hwmap_pairs[n].first_fmt; n++) {
+        if ((hwmap_pairs[n].first_fmt  == dst_hw_imgfmt &&
+             hwmap_pairs[n].second_fmt == src_imgfmt) ||
+            (hwmap_pairs[n].second_fmt == dst_hw_imgfmt &&
+             hwmap_pairs[n].first_fmt  == src_imgfmt))
+            return true;
+    }
+    return false;
+}
+
 /**
  * @brief Find the closest supported format when hw uploading
  *

filters/f_hwtransfer.h

@@ -18,6 +18,10 @@ struct mp_hwupload {
 struct mp_hwupload mp_hwupload_create(struct mp_filter *parent, int hw_imgfmt,
                                        int sw_imgfmt, bool src_is_same_hw);
 
+// Whether uploading to dst_hw_imgfmt from the hardware format src_imgfmt maps
+// the frame instead of copying it.
+bool mp_hwupload_can_map(int dst_hw_imgfmt, int src_imgfmt);
+
 // A filter which downloads sw frames from hw. Ignores sw frames.
 struct mp_hwdownload {
     struct mp_filter *f;