[FFmpeg-devel] [PATCH v4 0/6] Add display_matrix option

[FFmpeg-devel] [PATCH v4 0/6] Add display_matrix option

[Thilo Borgmann]

Hi,

this is an updated and cleaned-up version of Jan's patchset discussed in [1], now v4...
I'd especially appreciate any comments on 5/6, ffmpeg_opt.c:119ff which is pretty ugly as-is.

Previous reviews were split between threads [2][3] and are merged into.
Now it comes with cover letter as the topic would have changed again, keep track of revision and notget reviews on the same stuff in seperate threads.

Should fix #8329 and #6370.

Thanks,
Thilo

[1] https://lists.ffmpeg.org/pipermail/ffmpeg-devel/2022-May/296553.html
[2] https://lists.ffmpeg.org/pipermail/ffmpeg-devel/2022-August/300076.html
[3] https://lists.ffmpeg.org/pipermail/ffmpeg-devel/2022-August/300122.html

Jan Ekström (3):
  fftools: Add support for dictionary options
  ffmpeg: Add display_matrix option
  ffmpeg: Deprecate display rotation override with a metadata key

Thilo Borgmann (3):
  lavu/opt: Allow options to be arguments of other options
  fftools/cmdutils: Print arguments of options
  lavu/display: Add horizontal and vertical scaling to the display
    matrix

 doc/APIchanges              |   7 ++
 doc/ffmpeg.texi             |  18 ++++
 fftools/cmdutils.c          |  22 +++++
 fftools/cmdutils.h          |   3 +
 fftools/ffmpeg.c            |   2 +
 fftools/ffmpeg.h            |   7 ++
 fftools/ffmpeg_filter.c     |  13 +++
 fftools/ffmpeg_opt.c        | 162 +++++++++++++++++++++++++++++++++++-
 libavutil/display.c         |  35 ++++++++
 libavutil/display.h         |  26 ++++++
 libavutil/opt.c             |  14 +++-
 libavutil/opt.h             |   8 ++
 libavutil/version.h         |   4 +-
 tests/fate/filter-video.mak |   2 +-
 14 files changed, 316 insertions(+), 7 deletions(-)

-- 
2.20.1 (Apple Git-117)

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 1/6] lavu/opt: Allow options to be arguments of other options

[Thilo Borgmann]

Adds AV_OPT_FLAG_ARGUMENT for options being used as arguments for other options.
Adds av_arg_show() to allow printing of such arguments in help output.
---
 doc/APIchanges      |  4 ++++
 libavutil/opt.c     | 14 +++++++++++++-
 libavutil/opt.h     |  8 ++++++++
 libavutil/version.h |  4 ++--
 4 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/doc/APIchanges b/doc/APIchanges
index 729f56be7b..e4b2fc8799 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -14,6 +14,10 @@ libavutil:     2021-04-27
 
 API changes, most recent first:
 
+2022-09-19 - xxxxxxxxxx - lavu 57.37.100 - opt.h
+  Add AV_OPT_FLAG_ARGUMENT.
+  Add av_arg_show() to print arguments to options.
+
 2022-09-03 - xxxxxxxxxx - lavu 57.36.100 - pixfmt.h
   Add AV_PIX_FMT_P012, AV_PIX_FMT_Y212, AV_PIX_FMT_XV30, AV_PIX_FMT_XV36
 
diff --git a/libavutil/opt.c b/libavutil/opt.c
index a3940f47fb..89ef111690 100644
--- a/libavutil/opt.c
+++ b/libavutil/opt.c
@@ -1256,7 +1256,7 @@ static void opt_list(void *obj, void *av_log_obj, const char *unit,
             av_log(av_log_obj, AV_LOG_INFO, "     %-15s ", opt->name);
         else
             av_log(av_log_obj, AV_LOG_INFO, "  %s%-17s ",
-                   (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? " " : "-",
+                   (opt->flags & (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_ARGUMENT)) ? " " : "-",
                    opt->name);
 
         switch (opt->type) {
@@ -1329,6 +1329,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
                 break;
         }
+        if (!(opt->flags & AV_OPT_FLAG_ARGUMENT)) {
         av_log(av_log_obj, AV_LOG_INFO, "%c%c%c%c%c%c%c%c%c%c%c",
                (opt->flags & AV_OPT_FLAG_ENCODING_PARAM)  ? 'E' : '.',
                (opt->flags & AV_OPT_FLAG_DECODING_PARAM)  ? 'D' : '.',
@@ -1341,6 +1342,7 @@ FF_ENABLE_DEPRECATION_WARNINGS
                (opt->flags & AV_OPT_FLAG_BSF_PARAM)       ? 'B' : '.',
                (opt->flags & AV_OPT_FLAG_RUNTIME_PARAM)   ? 'T' : '.',
                (opt->flags & AV_OPT_FLAG_DEPRECATED)      ? 'P' : '.');
+        }
 
         if (opt->help)
             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
@@ -1456,6 +1458,16 @@ int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
     return 0;
 }
 
+int av_arg_show(void *obj, void *av_log_obj)
+{
+    if (!obj)
+        return -1;
+
+    opt_list(obj, av_log_obj, NULL, AV_OPT_FLAG_ARGUMENT, 0, -1);
+
+    return 0;
+}
+
 void av_opt_set_defaults(void *s)
 {
     av_opt_set_defaults2(s, 0, 0);
diff --git a/libavutil/opt.h b/libavutil/opt.h
index 461b5d3b6b..dce3483237 100644
--- a/libavutil/opt.h
+++ b/libavutil/opt.h
@@ -297,6 +297,7 @@ typedef struct AVOption {
 #define AV_OPT_FLAG_FILTERING_PARAM (1<<16) ///< a generic parameter which can be set by the user for filtering
 #define AV_OPT_FLAG_DEPRECATED      (1<<17) ///< set if option is deprecated, users should refer to AVOption.help text for more information
 #define AV_OPT_FLAG_CHILD_CONSTS    (1<<18) ///< set if option constants can also reside in child objects
+#define AV_OPT_FLAG_ARGUMENT        (1<<19) ///< set if option is an argument to another option
 //FIXME think about enc-audio, ... style flags
 
     /**
@@ -386,6 +387,13 @@ typedef struct AVOptionRanges {
  */
 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags);
 
+/**
+ * Show the obj arguments.
+ *
+ * @param av_log_obj log context to use for showing the options
+ */
+int av_arg_show(void *obj, void *av_log_obj);
+
 /**
  * Set the values of all AVOption fields to their default values.
  *
diff --git a/libavutil/version.h b/libavutil/version.h
index 0585fa7b80..9c44cef6aa 100644
--- a/libavutil/version.h
+++ b/libavutil/version.h
@@ -79,8 +79,8 @@
  */
 
 #define LIBAVUTIL_VERSION_MAJOR  57
-#define LIBAVUTIL_VERSION_MINOR  36
-#define LIBAVUTIL_VERSION_MICRO 102
+#define LIBAVUTIL_VERSION_MINOR  37
+#define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
                                                LIBAVUTIL_VERSION_MINOR, \
-- 
2.20.1 (Apple Git-117)

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 2/6] fftools/cmdutils: Print arguments of options

[Thilo Borgmann]

---
 fftools/cmdutils.c | 5 +++++
 fftools/cmdutils.h | 1 +
 2 files changed, 6 insertions(+)

diff --git a/fftools/cmdutils.c b/fftools/cmdutils.c
index f911c52be2..b6dd73902b 100644
--- a/fftools/cmdutils.c
+++ b/fftools/cmdutils.c
@@ -162,6 +162,11 @@ void show_help_options(const OptionDef *options, const char *msg, int req_flags,
             av_strlcat(buf, po->argname, sizeof(buf));
         }
         printf("-%-17s  %s\n", buf, po->help);
+
+        if (po->args) {
+            const AVClass *p = po->args;
+            av_arg_show(&p, NULL);
+        }
     }
     printf("\n");
 }
diff --git a/fftools/cmdutils.h b/fftools/cmdutils.h
index 4496221983..2f469f8c25 100644
--- a/fftools/cmdutils.h
+++ b/fftools/cmdutils.h
@@ -175,6 +175,7 @@ typedef struct OptionDef {
     } u;
     const char *help;
     const char *argname;
+    const AVClass *args;
 } OptionDef;
 
 /**
-- 
2.20.1 (Apple Git-117)

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 3/6] fftools: Add support for dictionary options

[Thilo Borgmann]

From: Jan Ekström <jeebjp@gmail.com>

---
 fftools/cmdutils.c   | 17 +++++++++++++++++
 fftools/cmdutils.h   |  2 ++
 fftools/ffmpeg_opt.c | 29 ++++++++++++++++++++++++++---
 3 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/fftools/cmdutils.c b/fftools/cmdutils.c
index b6dd73902b..f918d83854 100644
--- a/fftools/cmdutils.c
+++ b/fftools/cmdutils.c
@@ -137,6 +137,21 @@ int64_t parse_time_or_die(const char *context, const char *timestr,
     return us;
 }
 
+static AVDictionary *parse_dict_or_die(const char *context,
+                                       const char *dict_str)
+{
+    AVDictionary *dict = NULL;
+    int ret = av_dict_parse_string(&dict, dict_str, "=", ":", 0);
+    if (ret < 0) {
+        av_log(NULL, AV_LOG_FATAL,
+               "Failed to create a dictionary from '%s': %s!\n",
+               dict_str, av_err2str(ret));
+        exit_program(1);
+    }
+
+    return dict;
+}
+
 void show_help_options(const OptionDef *options, const char *msg, int req_flags,
                        int rej_flags, int alt_flags)
 {
@@ -299,6 +314,8 @@ static int write_option(void *optctx, const OptionDef *po, const char *opt,
         *(float *)dst = parse_number_or_die(opt, arg, OPT_FLOAT, -INFINITY, INFINITY);
     } else if (po->flags & OPT_DOUBLE) {
         *(double *)dst = parse_number_or_die(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY);
+    } else if (po->flags & OPT_DICT) {
+        *(AVDictionary **)dst = parse_dict_or_die(opt, arg);
     } else if (po->u.func_arg) {
         int ret = po->u.func_arg(optctx, opt, arg);
         if (ret < 0) {
diff --git a/fftools/cmdutils.h b/fftools/cmdutils.h
index 2f469f8c25..c7a4628191 100644
--- a/fftools/cmdutils.h
+++ b/fftools/cmdutils.h
@@ -140,6 +140,7 @@ typedef struct SpecifierOpt {
         uint64_t ui64;
         float      f;
         double   dbl;
+        AVDictionary *dict;
     } u;
 } SpecifierOpt;
 
@@ -168,6 +169,7 @@ typedef struct OptionDef {
 #define OPT_DOUBLE 0x20000
 #define OPT_INPUT  0x40000
 #define OPT_OUTPUT 0x80000
+#define OPT_DICT  0x100000
      union {
         void *dst_ptr;
         int (*func_arg)(void *, const char *, const char *);
diff --git a/fftools/ffmpeg_opt.c b/fftools/ffmpeg_opt.c
index 5febe319e4..be1cd673f6 100644
--- a/fftools/ffmpeg_opt.c
+++ b/fftools/ffmpeg_opt.c
@@ -62,6 +62,21 @@
 #define SPECIFIER_OPT_FMT_ui64 "%"PRIu64
 #define SPECIFIER_OPT_FMT_f    "%f"
 #define SPECIFIER_OPT_FMT_dbl  "%lf"
+#define SPECIFIER_OPT_FMT_dict "%s"
+
+static char* specifier_opt_func_dict(char **valstr, AVDictionary *val) {
+    int ret;
+    ret = av_dict_get_string(val, valstr, '=', ':');
+    return (ret < 0) ? NULL : *valstr;
+}
+
+#define SPECIFIER_OPT_FUNC_str(val)  val
+#define SPECIFIER_OPT_FUNC_i(val)    val
+#define SPECIFIER_OPT_FUNC_i64(val)  val
+#define SPECIFIER_OPT_FUNC_ui64(val) val
+#define SPECIFIER_OPT_FUNC_f(val)    val
+#define SPECIFIER_OPT_FUNC_dbl(val)  val
+#define SPECIFIER_OPT_FUNC_dict(val) specifier_opt_func_dict(&valstr, val)
 
 static const char *const opt_name_codec_names[]               = {"c", "codec", "acodec", "vcodec", "scodec", "dcodec", NULL};
 static const char *const opt_name_audio_channels[]            = {"ac", NULL};
@@ -114,11 +129,13 @@ static const char *const opt_name_bits_per_raw_sample[]       = {"bits_per_raw_s
 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
 {\
     char namestr[128] = "";\
+    char *valstr = NULL;\
     const char *spec = so->specifier && so->specifier[0] ? so->specifier : "";\
     for (i = 0; opt_name_##name[i]; i++)\
         av_strlcatf(namestr, sizeof(namestr), "-%s%s", opt_name_##name[i], opt_name_##name[i+1] ? (opt_name_##name[i+2] ? ", " : " or ") : "");\
     av_log(NULL, AV_LOG_WARNING, "Multiple %s options specified for stream %d, only the last option '-%s%s%s "SPECIFIER_OPT_FMT_##type"' will be used.\n",\
-           namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, so->u.type);\
+           namestr, st->index, opt_name_##name[0], spec[0] ? ":" : "", spec, SPECIFIER_OPT_FUNC_##type(so->u.type));\
+    av_freep(&valstr);\
 }
 
 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
@@ -208,11 +225,17 @@ static void uninit_options(OptionsContext *o)
                 av_freep(&(*so)[i].specifier);
                 if (po->flags & OPT_STRING)
                     av_freep(&(*so)[i].u.str);
+                else if (po->flags & OPT_DICT)
+                    av_dict_free(&(*so)[i].u.dict);
             }
             av_freep(so);
             *count = 0;
-        } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
-            av_freep(dst);
+        } else if (po->flags & OPT_OFFSET) {
+            if (po->flags & OPT_STRING)
+                av_freep(dst);
+            else if (po->flags & OPT_DICT)
+                av_dict_free((AVDictionary **)dst);
+        }
         po++;
     }
 
-- 
2.20.1 (Apple Git-117)

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 4/6] lavu/display: Add horizontal and vertical scaling to the display matrix

[Thilo Borgmann]

---
 doc/APIchanges      |  3 +++
 libavutil/display.c | 35 +++++++++++++++++++++++++++++++++++
 libavutil/display.h | 26 ++++++++++++++++++++++++++
 libavutil/version.h |  2 +-
 4 files changed, 65 insertions(+), 1 deletion(-)

diff --git a/doc/APIchanges b/doc/APIchanges
index e4b2fc8799..9dc393d999 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -14,6 +14,9 @@ libavutil:     2021-04-27
 
 API changes, most recent first:
 
+2022-09-19 - xxxxxxxxxx - lavu 57.38.100 - display.h
+  Add av_display_matrix_scale(), av_display_{h,v}scale_get()
+
 2022-09-19 - xxxxxxxxxx - lavu 57.37.100 - opt.h
   Add AV_OPT_FLAG_ARGUMENT.
   Add av_arg_show() to print arguments to options.
diff --git a/libavutil/display.c b/libavutil/display.c
index d31061283c..434ed50104 100644
--- a/libavutil/display.c
+++ b/libavutil/display.c
@@ -48,6 +48,30 @@ double av_display_rotation_get(const int32_t matrix[9])
     return -rotation;
 }
 
+double av_display_hscale_get(const int32_t matrix[9])
+{
+    double scale;
+
+    scale = hypot(CONV_FP(matrix[0]), CONV_FP(matrix[1]));
+
+    if (scale == 0.0)
+        return NAN;
+
+    return scale;
+}
+
+double av_display_vscale_get(const int32_t matrix[9])
+{
+    double scale;
+
+    scale = hypot(CONV_FP(matrix[3]), CONV_FP(matrix[4]));
+
+    if (scale == 0.0)
+        return NAN;
+
+    return scale;
+}
+
 void av_display_rotation_set(int32_t matrix[9], double angle)
 {
     double radians = -angle * M_PI / 180.0f;
@@ -72,3 +96,14 @@ void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
         for (i = 0; i < 9; i++)
             matrix[i] *= flip[i % 3];
 }
+
+void av_display_matrix_scale(int32_t matrix[9], double hscale, double vscale)
+{
+    // hscale
+    matrix[0] = CONV_DB(CONV_FP(matrix[0]) * hscale);
+    matrix[1] = CONV_DB(CONV_FP(matrix[1]) * hscale);
+
+    // vscale
+    matrix[3] = CONV_DB(CONV_FP(matrix[3]) * vscale);
+    matrix[4] = CONV_DB(CONV_FP(matrix[4]) * vscale);
+}
diff --git a/libavutil/display.h b/libavutil/display.h
index 31d8bef361..ef507eb521 100644
--- a/libavutil/display.h
+++ b/libavutil/display.h
@@ -86,6 +86,24 @@
  */
 double av_display_rotation_get(const int32_t matrix[9]);
 
+/**
+ * Extract the horizontal scaling component of the transformation matrix.
+ *
+ * @param matrix the transformation matrix
+ * @return the horizontal scaling by which the transformation matrix scales the frame
+ *         in the horizontal direction.
+ */
+double av_display_hscale_get(const int32_t matrix[9]);
+
+/**
+ * Extract the vertical scaling component of the transformation matrix.
+ *
+ * @param matrix the transformation matrix
+ * @return the vertical scaling by which the transformation matrix scales the frame
+ *         in the vertical direction.
+ */
+double av_display_vscale_get(const int32_t matrix[9]);
+
 /**
  * Initialize a transformation matrix describing a pure clockwise
  * rotation by the specified angle (in degrees).
@@ -105,6 +123,14 @@ void av_display_rotation_set(int32_t matrix[9], double angle);
  */
 void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip);
 
+/**
+ * Scale the input matrix horizontally and/or vertically.
+ *
+ * @param matrix an allocated transformation matrix
+ * @param hscale scale factor by which the matrix should be scaled horizontally
+ * @param vscale scale factor by which the matrix should be scaled vertically
+ */
+void av_display_matrix_scale(int32_t matrix[9], double hscale, double vscale);
 /**
  * @}
  * @}
diff --git a/libavutil/version.h b/libavutil/version.h
index 9c44cef6aa..5aca550f45 100644
--- a/libavutil/version.h
+++ b/libavutil/version.h
@@ -79,7 +79,7 @@
  */
 
 #define LIBAVUTIL_VERSION_MAJOR  57
-#define LIBAVUTIL_VERSION_MINOR  37
+#define LIBAVUTIL_VERSION_MINOR  38
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
-- 
2.20.1 (Apple Git-117)

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 5/6] ffmpeg: Add display_matrix option

[Thilo Borgmann]

From: Jan Ekström <jeebjp@gmail.com>

This enables overriding the rotation as well as horizontal/vertical
flip state of a specific video stream on the input side.

Additionally, switch the singular test that was utilizing the rotation
metadata to instead override the input display rotation, thus leading
to the same result.
---
 doc/ffmpeg.texi             |  18 ++++++
 fftools/ffmpeg.h            |   2 +
 fftools/ffmpeg_filter.c     |  13 ++++
 fftools/ffmpeg_opt.c        | 123 ++++++++++++++++++++++++++++++++++++
 tests/fate/filter-video.mak |   2 +-
 5 files changed, 157 insertions(+), 1 deletion(-)

diff --git a/doc/ffmpeg.texi b/doc/ffmpeg.texi
index 42440d93b4..ee86faedc8 100644
--- a/doc/ffmpeg.texi
+++ b/doc/ffmpeg.texi
@@ -912,6 +912,24 @@ If used together with @option{-vcodec copy}, it will affect the aspect ratio
 stored at container level, but not the aspect ratio stored in encoded
 frames, if it exists.
 
+@item -display_matrix[:@var{stream_specifier}] @var{opt1=val1[,opt2=val2]...} (@emph{input,per-stream})
+Set the video display matrix according to given options.
+We support scaling, flipping and rotation. The order of application to an Image is scale, flip, rotate.
+
+@table @option
+@item rotation=@var{number}
+Set the rotation using a floating point number that describes a pure
+counter-clockwise rotation in degrees.
+The @code{-autorotate} logic will be affected.
+@item hflip=@var{[0,1]}
+@item vflip=@var{[0,1]}
+Set a horizontal or vertical flip.
+@item hscale=@var{number}
+Set a horizontal scaling by factor of the given floating-point value.
+@item vscale=@var{number}
+Set a vertical scaling by factor of the given floating-point value.
+@end table
+
 @item -vn (@emph{input/output})
 As an input option, blocks all video streams of a file from being filtered or
 being automatically selected or mapped for any output. See @code{-discard}
diff --git a/fftools/ffmpeg.h b/fftools/ffmpeg.h
index ede0b2bd96..524a1d415a 100644
--- a/fftools/ffmpeg.h
+++ b/fftools/ffmpeg.h
@@ -193,6 +193,8 @@ typedef struct OptionsContext {
     int        nb_force_fps;
     SpecifierOpt *frame_aspect_ratios;
     int        nb_frame_aspect_ratios;
+    SpecifierOpt *display_matrixes;
+    int        nb_display_matrixes;
     SpecifierOpt *rc_overrides;
     int        nb_rc_overrides;
     SpecifierOpt *intra_matrices;
diff --git a/fftools/ffmpeg_filter.c b/fftools/ffmpeg_filter.c
index 7a5308425d..8bcba0d3a2 100644
--- a/fftools/ffmpeg_filter.c
+++ b/fftools/ffmpeg_filter.c
@@ -779,9 +779,22 @@ static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
     if (ist->autorotate && !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL)) {
         int32_t *displaymatrix = ifilter->displaymatrix;
         double theta;
+        double hscale = 1.0f;
+        double vscale = 1.0f;
 
         if (!displaymatrix)
             displaymatrix = (int32_t *)av_stream_get_side_data(ist->st, AV_PKT_DATA_DISPLAYMATRIX, NULL);
+
+        if (displaymatrix) {
+            hscale = av_display_hscale_get(displaymatrix);
+            vscale = av_display_vscale_get(displaymatrix);
+            if (hscale != 1.0f || vscale != 1.0f) {
+                char scale_buf[128];
+                snprintf(scale_buf, sizeof(scale_buf), "%f*iw:%f*ih", hscale, vscale);
+                ret = insert_filter(&last_filter, &pad_idx, "scale", scale_buf);
+            }
+        }
+
         theta = get_rotation(displaymatrix);
 
         if (fabs(theta - 90) < 1.0) {
diff --git a/fftools/ffmpeg_opt.c b/fftools/ffmpeg_opt.c
index be1cd673f6..ba56267460 100644
--- a/fftools/ffmpeg_opt.c
+++ b/fftools/ffmpeg_opt.c
@@ -20,6 +20,7 @@
 
 #include "config.h"
 
+#include <float.h>
 #include <stdint.h>
 
 #if HAVE_SYS_RESOURCE_H
@@ -45,6 +46,7 @@
 #include "libavutil/avutil.h"
 #include "libavutil/bprint.h"
 #include "libavutil/channel_layout.h"
+#include "libavutil/display.h"
 #include "libavutil/getenv_utf8.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/fifo.h"
@@ -101,6 +103,7 @@ static const char *const opt_name_forced_key_frames[]         = {"forced_key_fra
 static const char *const opt_name_fps_mode[]                  = {"fps_mode", NULL};
 static const char *const opt_name_force_fps[]                 = {"force_fps", NULL};
 static const char *const opt_name_frame_aspect_ratios[]       = {"aspect", NULL};
+static const char *const opt_name_display_matrixes[]          = {"display_matrix", NULL};
 static const char *const opt_name_rc_overrides[]              = {"rc_override", NULL};
 static const char *const opt_name_intra_matrices[]            = {"intra_matrix", NULL};
 static const char *const opt_name_inter_matrices[]            = {"inter_matrix", NULL};
@@ -126,6 +129,38 @@ static const char *const opt_name_time_bases[]                = {"time_base", NU
 static const char *const opt_name_enc_time_bases[]            = {"enc_time_base", NULL};
 static const char *const opt_name_bits_per_raw_sample[]       = {"bits_per_raw_sample", NULL};
 
+// XXX this should probably go into a seperate file <name>_args.c and #included here
+    struct DisplayMatrix {
+        const AVClass *class;
+        double  rotation;
+        int     hflip;
+        int     vflip;
+        double  hscale;
+        double  vscale;
+    };
+#define OFFSET(x) offsetof(struct DisplayMatrix, x)
+    static const AVOption display_matrix_args[] = {
+        { "rotation", "set rotation", OFFSET(rotation), AV_OPT_TYPE_DOUBLE,
+            { .dbl = DBL_MAX }, -(DBL_MAX), DBL_MAX - 1.0f, AV_OPT_FLAG_ARGUMENT},
+        { "hflip",    "set hflip", OFFSET(hflip),    AV_OPT_TYPE_BOOL,
+            { .i64 = -1 }, 0, 1, AV_OPT_FLAG_ARGUMENT},
+        { "vflip",    "set vflip", OFFSET(vflip),    AV_OPT_TYPE_BOOL,
+            { .i64 = -1 }, 0, 1, AV_OPT_FLAG_ARGUMENT},
+        { "hscale", "set horizontal scale factor", OFFSET(hscale), AV_OPT_TYPE_DOUBLE,
+            { .dbl = DBL_MAX }, 0.0f, DBL_MAX - 1.0f, AV_OPT_FLAG_ARGUMENT},
+        { "vscale", "set vertical scale factor", OFFSET(vscale), AV_OPT_TYPE_DOUBLE,
+            { .dbl = DBL_MAX }, 0.0f, DBL_MAX - 1.0f, AV_OPT_FLAG_ARGUMENT},
+        { NULL },
+    };
+    static const AVClass class_display_matrix_args = {
+        .class_name = "display_matrix_args",
+        .item_name  = av_default_item_name,
+        .option     = display_matrix_args,
+        .version    = LIBAVUTIL_VERSION_INT,
+    };
+#undef OFFSET
+// XXX
+
 #define WARN_MULTIPLE_OPT_USAGE(name, type, so, st)\
 {\
     char namestr[128] = "";\
@@ -824,6 +859,85 @@ static int opt_recording_timestamp(void *optctx, const char *opt, const char *ar
     return 0;
 }
 
+static void add_display_matrix_to_stream(OptionsContext *o,
+                                         AVFormatContext *ctx, AVStream *st)
+{
+    int hflip_set = 0, vflip_set = 0, display_rotation_set = 0, hscale_set = 0, vscale_set = 0;
+    uint8_t *buf = NULL;
+
+    struct DisplayMatrix test_args = {
+        .class    = &class_display_matrix_args,
+        .rotation = DBL_MAX,
+        .hflip    = -1,
+        .vflip    = -1,
+        .hscale    = DBL_MAX,
+        .vscale    = DBL_MAX,
+    };
+
+    AVDictionary *global_args = NULL;
+    AVDictionary *local_args  = NULL;
+    AVDictionaryEntry *en = NULL;
+
+    MATCH_PER_STREAM_OPT(display_matrixes, dict, global_args, ctx, st);
+
+    if (!global_args)
+        return;
+
+    // make a copy of the dict so it doesn't get freed from underneath us
+    if (av_dict_copy(&local_args, global_args, 0) < 0) {
+        av_log(NULL, AV_LOG_FATAL,
+               "Failed to copy argument dict for display matrix!\n");
+        exit_program(1);
+    }
+
+    if (av_opt_set_dict2(&test_args, &local_args, 0) < 0) {
+        av_log(NULL, AV_LOG_FATAL,
+               "Failed to set options for a display matrix!\n");
+        exit_program(1);
+    }
+
+    while ((en = av_dict_get(local_args, "", en, AV_DICT_IGNORE_SUFFIX))) {
+        av_log(NULL, AV_LOG_FATAL,
+               "Unknown option=value pair for display matrix: "
+               "key: '%s', value: '%s'!\n",
+               en->key, en->value);
+    }
+
+    if (av_dict_count(local_args)) {
+        exit_program(1);
+    }
+
+    av_dict_free(&local_args);
+
+    display_rotation_set = test_args.rotation != DBL_MAX;
+    hflip_set            = test_args.hflip != -1;
+    vflip_set            = test_args.vflip != -1;
+    hscale_set           = test_args.hscale != DBL_MAX;
+    vscale_set           = test_args.vscale != DBL_MAX;
+
+    if (!display_rotation_set && !hflip_set && !vflip_set &&
+        !hscale_set && !vscale_set)
+        return;
+
+    if (!(buf = av_stream_new_side_data(st, AV_PKT_DATA_DISPLAYMATRIX,
+                                        sizeof(int32_t) * 9))) {
+        av_log(NULL, AV_LOG_FATAL, "Failed to generate a display matrix!\n");
+        exit_program(1);
+    }
+
+    av_display_rotation_set((int32_t *)buf,
+                            display_rotation_set ? -(test_args.rotation) :
+                                                   -0.0f);
+    av_display_matrix_flip((int32_t *)buf,
+                           hflip_set ? test_args.hflip : 0,
+                           vflip_set ? test_args.vflip : 0);
+
+    av_display_matrix_scale((int32_t *)buf,
+                            hscale_set ? test_args.hscale : 1.0f,
+                            vscale_set ? test_args.vscale : 1.0f);
+}
+
+
 static const AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
 {
     const AVCodecDescriptor *desc;
@@ -958,6 +1072,8 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
         }
 
         if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
+            add_display_matrix_to_stream(o, ic, st);
+
             MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
             MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
                                  hwaccel_output_format, ic, st);
@@ -1883,6 +1999,8 @@ static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, in
         ost->frame_aspect_ratio = q;
     }
 
+    add_display_matrix_to_stream(o, oc, st);
+
     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
 
@@ -4044,6 +4162,11 @@ const OptionDef options[] = {
     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
+    { "display_matrix", OPT_VIDEO | HAS_ARG | OPT_DICT | OPT_SPEC |
+                        OPT_INPUT,                                              { .off = OFFSET(display_matrixes) },
+        "define a display matrix with rotation, and/or horizontal/vertical "
+        "flip/scale for stream(s)",
+        "arguments", &class_display_matrix_args },
     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
         "set pixel format", "format" },
diff --git a/tests/fate/filter-video.mak b/tests/fate/filter-video.mak
index 372c70bba7..763390ea51 100644
--- a/tests/fate/filter-video.mak
+++ b/tests/fate/filter-video.mak
@@ -691,7 +691,7 @@ fate-filter-metadata-avf-aphase-meter-out-of-phase: SRC = $(TARGET_SAMPLES)/filt
 fate-filter-metadata-avf-aphase-meter-out-of-phase: CMD = run $(FILTER_METADATA_COMMAND) "amovie='$(SRC)',aphasemeter=video=0"
 
 FATE_FILTER_SAMPLES-$(call TRANSCODE, RAWVIDEO H264, MOV, ARESAMPLE_FILTER  AAC_FIXED_DECODER) += fate-filter-meta-4560-rotate0
-fate-filter-meta-4560-rotate0: CMD = transcode mov $(TARGET_SAMPLES)/filter/sample-in-issue-505.mov mov "-c copy -metadata:s:v:0 rotate=0" "-af aresample" "" "" "-flags +bitexact -c:a aac_fixed"
+fate-filter-meta-4560-rotate0: CMD = transcode "mov -display_matrix:v:0 rotation=0" $(TARGET_SAMPLES)/filter/sample-in-issue-505.mov mov "-c copy" "-af aresample" "" "" "-flags +bitexact -c:a aac_fixed"
 
 FATE_FILTER_CMP_METADATA-$(CONFIG_BLOCKDETECT_FILTER) += fate-filter-refcmp-blockdetect-yuv
 fate-filter-refcmp-blockdetect-yuv: CMD = cmp_metadata blockdetect yuv420p 0.015
-- 
2.20.1 (Apple Git-117)

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v4 6/6] ffmpeg: Deprecate display rotation override with a metadata key

[Thilo Borgmann]

From: Jan Ekström <jeebjp@gmail.com>

Now that we have proper options for defining display matrix
overrides, this should no longer be required.

fftools does not have its own versioning, so for now the define is
just set to 1 and disables the functionality if set to zero.
---
 fftools/ffmpeg.c     |  2 ++
 fftools/ffmpeg.h     |  5 +++++
 fftools/ffmpeg_opt.c | 10 ++++++++++
 3 files changed, 17 insertions(+)

diff --git a/fftools/ffmpeg.c b/fftools/ffmpeg.c
index 0e1477299d..65b0b83a18 100644
--- a/fftools/ffmpeg.c
+++ b/fftools/ffmpeg.c
@@ -2831,12 +2831,14 @@ static int init_output_stream_streamcopy(OutputStream *ost)
         }
     }
 
+#if FFMPEG_ROTATION_METADATA
     if (ost->rotate_overridden) {
         uint8_t *sd = av_stream_new_side_data(ost->st, AV_PKT_DATA_DISPLAYMATRIX,
                                               sizeof(int32_t) * 9);
         if (sd)
             av_display_rotation_set((int32_t *)sd, -ost->rotate_override_value);
     }
+#endif
 
     switch (par->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
diff --git a/fftools/ffmpeg.h b/fftools/ffmpeg.h
index 524a1d415a..c134b15726 100644
--- a/fftools/ffmpeg.h
+++ b/fftools/ffmpeg.h
@@ -53,6 +53,7 @@
 #define FFMPEG_OPT_PSNR 1
 #define FFMPEG_OPT_MAP_CHANNEL 1
 #define FFMPEG_OPT_MAP_SYNC 1
+#define FFMPEG_ROTATION_METADATA 1
 
 enum VideoSyncMethod {
     VSYNC_AUTO = -1,
@@ -532,11 +533,15 @@ typedef struct OutputStream {
     int is_cfr;
     int force_fps;
     int top_field_first;
+#if FFMPEG_ROTATION_METADATA
     int rotate_overridden;
+#endif
     int autoscale;
     int bitexact;
     int bits_per_raw_sample;
+#if FFMPEG_ROTATION_METADATA
     double rotate_override_value;
+#endif
 
     AVRational frame_aspect_ratio;
 
diff --git a/fftools/ffmpeg_opt.c b/fftools/ffmpeg_opt.c
index ba56267460..71e62d0aa7 100644
--- a/fftools/ffmpeg_opt.c
+++ b/fftools/ffmpeg_opt.c
@@ -2960,16 +2960,26 @@ static void of_add_metadata(AVFormatContext *oc, const OptionsContext *o)
             for (int j = 0; j < oc->nb_streams; j++) {
                 OutputStream *ost = output_streams[nb_output_streams - oc->nb_streams + j];
                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
+#if FFMPEG_ROTATION_METADATA
                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
                         char *tail;
                         double theta = av_strtod(val, &tail);
                         if (!*tail) {
                             ost->rotate_overridden = 1;
                             ost->rotate_override_value = theta;
+
+                        av_log(NULL, AV_LOG_WARNING,
+                               "Conversion of a 'rotate' metadata key to a "
+                               "proper display matrix rotation is deprecated. "
+                               "See -display_matrix for setting rotation "
+                               "instead.");
                         }
                     } else {
+#endif
                         av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
+#if FFMPEG_ROTATION_METADATA
                     }
+#endif
                 } else if (ret < 0)
                     exit_program(1);
             }
-- 
2.20.1 (Apple Git-117)

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 4/6] lavu/display: Add horizontal and vertical scaling to the display matrix

[Andreas Rheinhardt]

Thilo Borgmann:
> ---
>  doc/APIchanges      |  3 +++
>  libavutil/display.c | 35 +++++++++++++++++++++++++++++++++++
>  libavutil/display.h | 26 ++++++++++++++++++++++++++
>  libavutil/version.h |  2 +-
>  4 files changed, 65 insertions(+), 1 deletion(-)
> 
> diff --git a/doc/APIchanges b/doc/APIchanges
> index e4b2fc8799..9dc393d999 100644
> --- a/doc/APIchanges
> +++ b/doc/APIchanges
> @@ -14,6 +14,9 @@ libavutil:     2021-04-27
>  
>  API changes, most recent first:
>  
> +2022-09-19 - xxxxxxxxxx - lavu 57.38.100 - display.h
> +  Add av_display_matrix_scale(), av_display_{h,v}scale_get()
> +
>  2022-09-19 - xxxxxxxxxx - lavu 57.37.100 - opt.h
>    Add AV_OPT_FLAG_ARGUMENT.
>    Add av_arg_show() to print arguments to options.
> diff --git a/libavutil/display.c b/libavutil/display.c
> index d31061283c..434ed50104 100644
> --- a/libavutil/display.c
> +++ b/libavutil/display.c
> @@ -48,6 +48,30 @@ double av_display_rotation_get(const int32_t matrix[9])
>      return -rotation;
>  }
>  
> +double av_display_hscale_get(const int32_t matrix[9])
> +{
> +    double scale;
> +
> +    scale = hypot(CONV_FP(matrix[0]), CONV_FP(matrix[1]));
> +
> +    if (scale == 0.0)
> +        return NAN;
> +
> +    return scale;
> +}
> +
> +double av_display_vscale_get(const int32_t matrix[9])
> +{
> +    double scale;
> +
> +    scale = hypot(CONV_FP(matrix[3]), CONV_FP(matrix[4]));
> +
> +    if (scale == 0.0)
> +        return NAN;
> +
> +    return scale;
> +}

Did I not already tell you that an arbitrary displaymatrix doesn't have
well-defined horizontal and vertical scaling factors? Apart from that,
the formulae are wrong even for the case where it has one, because you
forgot the scaling given by what is called z in display.h.
(Apart from that, these functions do not return the horizontal/vertical
scaling factors; they return the length of the image of the
horizontal/vertical unit vector under the transformation, but these
vectors need not (and in general: will not) point into the
horizontal/vertical direction at all; the return value is therefore not
the "hor/ver scaling by which the transformation matrix scales the frame
in the hor/ver direction", although the documentation claims that. The
reason for this is of course that an arbitrary matrix doesn't have
well-defined scaling factors.)

> +
>  void av_display_rotation_set(int32_t matrix[9], double angle)
>  {
>      double radians = -angle * M_PI / 180.0f;
> @@ -72,3 +96,14 @@ void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
>          for (i = 0; i < 9; i++)
>              matrix[i] *= flip[i % 3];
>  }
> +
> +void av_display_matrix_scale(int32_t matrix[9], double hscale, double vscale)
> +{
> +    // hscale
> +    matrix[0] = CONV_DB(CONV_FP(matrix[0]) * hscale);
> +    matrix[1] = CONV_DB(CONV_FP(matrix[1]) * hscale);
> +
> +    // vscale
> +    matrix[3] = CONV_DB(CONV_FP(matrix[3]) * vscale);
> +    matrix[4] = CONV_DB(CONV_FP(matrix[4]) * vscale);
> +}
> diff --git a/libavutil/display.h b/libavutil/display.h
> index 31d8bef361..ef507eb521 100644
> --- a/libavutil/display.h
> +++ b/libavutil/display.h
> @@ -86,6 +86,24 @@
>   */
>  double av_display_rotation_get(const int32_t matrix[9]);
>  
> +/**
> + * Extract the horizontal scaling component of the transformation matrix.
> + *
> + * @param matrix the transformation matrix
> + * @return the horizontal scaling by which the transformation matrix scales the frame
> + *         in the horizontal direction.
> + */
> +double av_display_hscale_get(const int32_t matrix[9]);
> +
> +/**
> + * Extract the vertical scaling component of the transformation matrix.
> + *
> + * @param matrix the transformation matrix
> + * @return the vertical scaling by which the transformation matrix scales the frame
> + *         in the vertical direction.
> + */
> +double av_display_vscale_get(const int32_t matrix[9]);
> +
>  /**
>   * Initialize a transformation matrix describing a pure clockwise
>   * rotation by the specified angle (in degrees).
> @@ -105,6 +123,14 @@ void av_display_rotation_set(int32_t matrix[9], double angle);
>   */
>  void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip);
>  
> +/**
> + * Scale the input matrix horizontally and/or vertically.
> + *
> + * @param matrix an allocated transformation matrix
> + * @param hscale scale factor by which the matrix should be scaled horizontally
> + * @param vscale scale factor by which the matrix should be scaled vertically
> + */
> +void av_display_matrix_scale(int32_t matrix[9], double hscale, double vscale);
>  /**
>   * @}
>   * @}
> diff --git a/libavutil/version.h b/libavutil/version.h
> index 9c44cef6aa..5aca550f45 100644
> --- a/libavutil/version.h
> +++ b/libavutil/version.h
> @@ -79,7 +79,7 @@
>   */
>  
>  #define LIBAVUTIL_VERSION_MAJOR  57
> -#define LIBAVUTIL_VERSION_MINOR  37
> +#define LIBAVUTIL_VERSION_MINOR  38
>  #define LIBAVUTIL_VERSION_MICRO 100
>  
>  #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 0/6] Add display_matrix option

[Anton Khirnov]

I still see no convincing arguments in favor of adding all this
complexity just so that we can stuff multiple options into one and get a
WORSE user interface.

Just add multiple options.

-- 
Anton Khirnov
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 0/6] Add display_matrix option

[Nicolas George]

Anton Khirnov (12022-09-20):
> I still see no convincing arguments in favor of adding all this
> complexity just so that we can stuff multiple options into one and get a
> WORSE user interface.
> 
> Just add multiple options.

We agree, except on the last point.

All user-visible FFmpeg types should have a way for the user to input
them, self-contained and convenient with regard with the logic of the
type, and a function to print them in a way that can be parsed back.

Channels layouts do not have multiple options, they have
av_channel_layout_from_string(). Rationals are not entered with
-framerate_num 24000 -framerate_den 1001, they are entered as a ratio,
and so on. It should be systematic.

Regards,

-- 
  Nicolas George
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v4 0/6] Add display_matrix option

[Anton Khirnov]

Quoting Nicolas George (2022-09-20 11:05:59)
> Anton Khirnov (12022-09-20):
> > I still see no convincing arguments in favor of adding all this
> > complexity just so that we can stuff multiple options into one and get a
> > WORSE user interface.
> > 
> > Just add multiple options.
> 
> We agree, except on the last point.
> 
> All user-visible FFmpeg types should have a way for the user to input
> them, self-contained and convenient with regard with the logic of the
> type, and a function to print them in a way that can be parsed back.
> 
> Channels layouts do not have multiple options, they have
> av_channel_layout_from_string(). Rationals are not entered with
> -framerate_num 24000 -framerate_den 1001, they are entered as a ratio,
> and so on. It should be systematic.

I have no problem with adding a -display_matrix option that allows
expert users to specify all nine values of the display transformation
matrix directly. But this set is not adding such an option, it is only
handling rotation, flipping and scaling. Most users will think of these
as three different operations and so it will be simplest - both for us
and for our users - for them to be three separate options (with
documentation stating the order in which they are applied).

-- 
Anton Khirnov
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".