diff mbox

[FFmpeg-devel] avfilter/scale.c: factorize ff_scale_eval_dimensions

Message ID 43a9c592-bd5d-2474-b3ea-21f3bb041ed3@gyani.pro
State New
Headers show

Commit Message

Gyan Dec. 4, 2019, 8:44 a.m. UTC
Will help reduce code duplication when adding animation support to vf_scale.
See Michael's last comment in https://patchwork.ffmpeg.org/patch/16272/

Gyan
From 138a8dba766674a1b017614c58fa99aeca98e9e5 Mon Sep 17 00:00:00 2001
From: Gyan Doshi <ffmpeg@gyani.pro>
Date: Mon, 2 Dec 2019 21:11:21 +0530
Subject: [PATCH] avfilter/scale.c: factorize ff_scale_eval_dimensions

Adjustment of evaluated values shifted to ff_adjust_scale_dimensions
Shifted code for force_original_aspect_ratio and force_divisble_by from
vf_scale so it is now available for scale_cuda, scale_npp and
scale_vaapi as well.
---
 doc/filters.texi             | 40 ++++++++++++++++++++++++
 libavfilter/scale.c          | 59 +++++++++++++++++++++++++++++-------
 libavfilter/scale.h          |  4 +++
 libavfilter/vf_scale.c       | 28 ++---------------
 libavfilter/vf_scale_cuda.c  | 11 +++++++
 libavfilter/vf_scale_npp.c   | 11 +++++++
 libavfilter/vf_scale_vaapi.c | 11 +++++++
 7 files changed, 128 insertions(+), 36 deletions(-)

Comments

Gyan Dec. 6, 2019, 4:52 p.m. UTC | #1
On 04-12-2019 02:14 pm, Gyan wrote:
> Will help reduce code duplication when adding animation support to 
> vf_scale.
> See Michael's last comment in https://patchwork.ffmpeg.org/patch/16272/

Ping.

Gyan
Michael Niedermayer Dec. 6, 2019, 7:06 p.m. UTC | #2
On Wed, Dec 04, 2019 at 02:14:35PM +0530, Gyan wrote:
> Will help reduce code duplication when adding animation support to vf_scale.
> See Michael's last comment in https://patchwork.ffmpeg.org/patch/16272/
> 
> Gyan

>  doc/filters.texi             |   40 +++++++++++++++++++++++++++++
>  libavfilter/scale.c          |   59 ++++++++++++++++++++++++++++++++++---------
>  libavfilter/scale.h          |    4 ++
>  libavfilter/vf_scale.c       |   28 ++------------------
>  libavfilter/vf_scale_cuda.c  |   11 ++++++++
>  libavfilter/vf_scale_npp.c   |   11 ++++++++
>  libavfilter/vf_scale_vaapi.c |   11 ++++++++
>  7 files changed, 128 insertions(+), 36 deletions(-)
> 380bf799c14d6286cc625afe019aa553614a7d53  0001-avfilter-scale.c-factorize-ff_scale_eval_dimensions.patch
> From 138a8dba766674a1b017614c58fa99aeca98e9e5 Mon Sep 17 00:00:00 2001
> From: Gyan Doshi <ffmpeg@gyani.pro>
> Date: Mon, 2 Dec 2019 21:11:21 +0530
> Subject: [PATCH] avfilter/scale.c: factorize ff_scale_eval_dimensions
> 
> Adjustment of evaluated values shifted to ff_adjust_scale_dimensions
> Shifted code for force_original_aspect_ratio and force_divisble_by from
> vf_scale so it is now available for scale_cuda, scale_npp and
> scale_vaapi as well.
> ---
>  doc/filters.texi             | 40 ++++++++++++++++++++++++
>  libavfilter/scale.c          | 59 +++++++++++++++++++++++++++++-------
>  libavfilter/scale.h          |  4 +++
>  libavfilter/vf_scale.c       | 28 ++---------------
>  libavfilter/vf_scale_cuda.c  | 11 +++++++
>  libavfilter/vf_scale_npp.c   | 11 +++++++
>  libavfilter/vf_scale_vaapi.c | 11 +++++++
>  7 files changed, 128 insertions(+), 36 deletions(-)
> 
> diff --git a/doc/filters.texi b/doc/filters.texi
> index 5fdec6f015..9129f7e3a5 100644
> --- a/doc/filters.texi
> +++ b/doc/filters.texi
> @@ -16210,6 +16210,46 @@ Supersampling
>  @item lanczos
>  @end table
>  
> +@item force_original_aspect_ratio
> +Enable decreasing or increasing output video width or height if necessary to
> +keep the original aspect ratio. Possible values:
> +
> +@table @samp
> +@item disable
> +Scale the video as specified and disable this feature.
> +
> +@item decrease
> +The output video dimensions will automatically be decreased if needed.
> +
> +@item increase
> +The output video dimensions will automatically be increased if needed.
> +
> +@end table
> +
> +One useful instance of this option is that when you know a specific device's
> +maximum allowed resolution, you can use this to limit the output video to
> +that, while retaining the aspect ratio. For example, device A allows
> +1280x720 playback, and your video is 1920x800. Using this option (set it to
> +decrease) and specifying 1280x720 to the command line makes the output
> +1280x533.
> +
> +Please note that this is a different thing than specifying -1 for @option{w}
> +or @option{h}, you still need to specify the output resolution for this option
> +to work.
> +
> +@item force_divisible_by
> +Ensures that both the output dimensions, width and height, are divisible by the
> +given integer when used together with @option{force_original_aspect_ratio}. This
> +works similar to using @code{-n} in the @option{w} and @option{h} options.
> +
> +This option respects the value set for @option{force_original_aspect_ratio},
> +increasing or decreasing the resolution accordingly. The video's aspect ratio
> +may be slightly modified.
> +
> +This option can be handy if you need to have a video fit within or exceed
> +a defined resolution using @option{force_original_aspect_ratio} but also have
> +encoder restrictions on width or height divisibility.
> +
>  @end table
>  
>  @section scale2ref
> diff --git a/libavfilter/scale.c b/libavfilter/scale.c
> index eaee95fac6..5e9f97230c 100644
> --- a/libavfilter/scale.c
> +++ b/libavfilter/scale.c
> @@ -111,8 +111,6 @@ int ff_scale_eval_dimensions(void *log_ctx,
>      const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
>      const AVPixFmtDescriptor *out_desc = av_pix_fmt_desc_get(outlink->format);
>      const char *expr;
> -    int w, h;
> -    int factor_w, factor_h;
>      int eval_w, eval_h;
>      int ret;
>      const char scale2ref = outlink->src->nb_inputs == 2 && outlink->src->inputs[1] == inlink;
> @@ -172,8 +170,28 @@ int ff_scale_eval_dimensions(void *log_ctx,
>          goto fail;
>      eval_w = (int) res == 0 ? inlink->w : (int) res;
>  
> -    w = eval_w;
> -    h = eval_h;
> +    *ret_w = eval_w;
> +    *ret_h = eval_h;
> +
> +    return 0;
> +
> +fail:
> +    av_log(log_ctx, AV_LOG_ERROR,
> +           "Error when evaluating the expression '%s'.\n"
> +           "Maybe the expression for out_w:'%s' or for out_h:'%s' is self-referencing.\n",
> +           expr, w_expr, h_expr);
> +    return ret;
> +}
> +
> +int ff_scale_adjust_dimensions(AVFilterLink *inlink,
> +    int *ret_w, int *ret_h,
> +    int force_original_aspect_ratio, int force_divisible_by)
> +{
> +    int w, h;
> +    int factor_w, factor_h;
> +
> +    w = *ret_w;
> +    h = *ret_h;
>  
>      /* Check if it is requested that the result has to be divisible by a some
>       * factor (w or h = -n with n being the factor). */
> @@ -199,15 +217,34 @@ int ff_scale_eval_dimensions(void *log_ctx,
>      if (h < 0)
>          h = av_rescale(w, inlink->h, inlink->w * factor_h) * factor_h;
>  
> +    /* Note that force_original_aspect_ratio may overwrite the previous set
> +     * dimensions so that it is not divisible by the set factors anymore
> +     * unless force_divisible_by is defined as well */
> +    if (force_original_aspect_ratio) {
> +        int tmp_w = av_rescale(h, inlink->w, inlink->h);
> +        int tmp_h = av_rescale(w, inlink->h, inlink->w);
> +
> +        if (force_original_aspect_ratio == 1) {
> +             w = FFMIN(tmp_w, w);
> +             h = FFMIN(tmp_h, h);
> +             if (force_divisible_by > 1) {
> +                 // round down
> +                 w = w / force_divisible_by * force_divisible_by;
> +                 h = h / force_divisible_by * force_divisible_by;
> +             }
> +        } else {
> +             w = FFMAX(tmp_w, w);
> +             h = FFMAX(tmp_h, h);
> +             if (force_divisible_by > 1) {
> +                 // round up
> +                 w = (w + force_divisible_by - 1) / force_divisible_by * force_divisible_by;
> +                 h = (h + force_divisible_by - 1) / force_divisible_by * force_divisible_by;
> +             }
> +        }
> +    }
> +
>      *ret_w = w;
>      *ret_h = h;
>  
>      return 0;
> -
> -fail:
> -    av_log(log_ctx, AV_LOG_ERROR,
> -           "Error when evaluating the expression '%s'.\n"
> -           "Maybe the expression for out_w:'%s' or for out_h:'%s' is self-referencing.\n",
> -           expr, w_expr, h_expr);
> -    return ret;
>  }

> diff --git a/libavfilter/scale.h b/libavfilter/scale.h
> index dfe67d0be0..fa480d727a 100644
> --- a/libavfilter/scale.h
> +++ b/libavfilter/scale.h
> @@ -25,4 +25,8 @@ int ff_scale_eval_dimensions(void *ctx,
>      const char *w_expr, const char *h_expr,
>      AVFilterLink *inlink, AVFilterLink *outlink,
>      int *ret_w, int *ret_h);
> +
> +int ff_scale_adjust_dimensions(AVFilterLink *inlink,
> +    int *ret_w, int *ret_h,
> +    int force_original_aspect_ratio, int force_divisible_by);
>  #endif

This should be documented so developers know what it is, how to use it
and what changes can be done to it without breaking code using it.

That would make it easier to future contributors to work on this
function and the code calling this function

thx

[...]
diff mbox

Patch

diff --git a/doc/filters.texi b/doc/filters.texi
index 5fdec6f015..9129f7e3a5 100644
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -16210,6 +16210,46 @@  Supersampling
 @item lanczos
 @end table
 
+@item force_original_aspect_ratio
+Enable decreasing or increasing output video width or height if necessary to
+keep the original aspect ratio. Possible values:
+
+@table @samp
+@item disable
+Scale the video as specified and disable this feature.
+
+@item decrease
+The output video dimensions will automatically be decreased if needed.
+
+@item increase
+The output video dimensions will automatically be increased if needed.
+
+@end table
+
+One useful instance of this option is that when you know a specific device's
+maximum allowed resolution, you can use this to limit the output video to
+that, while retaining the aspect ratio. For example, device A allows
+1280x720 playback, and your video is 1920x800. Using this option (set it to
+decrease) and specifying 1280x720 to the command line makes the output
+1280x533.
+
+Please note that this is a different thing than specifying -1 for @option{w}
+or @option{h}, you still need to specify the output resolution for this option
+to work.
+
+@item force_divisible_by
+Ensures that both the output dimensions, width and height, are divisible by the
+given integer when used together with @option{force_original_aspect_ratio}. This
+works similar to using @code{-n} in the @option{w} and @option{h} options.
+
+This option respects the value set for @option{force_original_aspect_ratio},
+increasing or decreasing the resolution accordingly. The video's aspect ratio
+may be slightly modified.
+
+This option can be handy if you need to have a video fit within or exceed
+a defined resolution using @option{force_original_aspect_ratio} but also have
+encoder restrictions on width or height divisibility.
+
 @end table
 
 @section scale2ref
diff --git a/libavfilter/scale.c b/libavfilter/scale.c
index eaee95fac6..5e9f97230c 100644
--- a/libavfilter/scale.c
+++ b/libavfilter/scale.c
@@ -111,8 +111,6 @@  int ff_scale_eval_dimensions(void *log_ctx,
     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
     const AVPixFmtDescriptor *out_desc = av_pix_fmt_desc_get(outlink->format);
     const char *expr;
-    int w, h;
-    int factor_w, factor_h;
     int eval_w, eval_h;
     int ret;
     const char scale2ref = outlink->src->nb_inputs == 2 && outlink->src->inputs[1] == inlink;
@@ -172,8 +170,28 @@  int ff_scale_eval_dimensions(void *log_ctx,
         goto fail;
     eval_w = (int) res == 0 ? inlink->w : (int) res;
 
-    w = eval_w;
-    h = eval_h;
+    *ret_w = eval_w;
+    *ret_h = eval_h;
+
+    return 0;
+
+fail:
+    av_log(log_ctx, AV_LOG_ERROR,
+           "Error when evaluating the expression '%s'.\n"
+           "Maybe the expression for out_w:'%s' or for out_h:'%s' is self-referencing.\n",
+           expr, w_expr, h_expr);
+    return ret;
+}
+
+int ff_scale_adjust_dimensions(AVFilterLink *inlink,
+    int *ret_w, int *ret_h,
+    int force_original_aspect_ratio, int force_divisible_by)
+{
+    int w, h;
+    int factor_w, factor_h;
+
+    w = *ret_w;
+    h = *ret_h;
 
     /* Check if it is requested that the result has to be divisible by a some
      * factor (w or h = -n with n being the factor). */
@@ -199,15 +217,34 @@  int ff_scale_eval_dimensions(void *log_ctx,
     if (h < 0)
         h = av_rescale(w, inlink->h, inlink->w * factor_h) * factor_h;
 
+    /* Note that force_original_aspect_ratio may overwrite the previous set
+     * dimensions so that it is not divisible by the set factors anymore
+     * unless force_divisible_by is defined as well */
+    if (force_original_aspect_ratio) {
+        int tmp_w = av_rescale(h, inlink->w, inlink->h);
+        int tmp_h = av_rescale(w, inlink->h, inlink->w);
+
+        if (force_original_aspect_ratio == 1) {
+             w = FFMIN(tmp_w, w);
+             h = FFMIN(tmp_h, h);
+             if (force_divisible_by > 1) {
+                 // round down
+                 w = w / force_divisible_by * force_divisible_by;
+                 h = h / force_divisible_by * force_divisible_by;
+             }
+        } else {
+             w = FFMAX(tmp_w, w);
+             h = FFMAX(tmp_h, h);
+             if (force_divisible_by > 1) {
+                 // round up
+                 w = (w + force_divisible_by - 1) / force_divisible_by * force_divisible_by;
+                 h = (h + force_divisible_by - 1) / force_divisible_by * force_divisible_by;
+             }
+        }
+    }
+
     *ret_w = w;
     *ret_h = h;
 
     return 0;
-
-fail:
-    av_log(log_ctx, AV_LOG_ERROR,
-           "Error when evaluating the expression '%s'.\n"
-           "Maybe the expression for out_w:'%s' or for out_h:'%s' is self-referencing.\n",
-           expr, w_expr, h_expr);
-    return ret;
 }
diff --git a/libavfilter/scale.h b/libavfilter/scale.h
index dfe67d0be0..fa480d727a 100644
--- a/libavfilter/scale.h
+++ b/libavfilter/scale.h
@@ -25,4 +25,8 @@  int ff_scale_eval_dimensions(void *ctx,
     const char *w_expr, const char *h_expr,
     AVFilterLink *inlink, AVFilterLink *outlink,
     int *ret_w, int *ret_h);
+
+int ff_scale_adjust_dimensions(AVFilterLink *inlink,
+    int *ret_w, int *ret_h,
+    int force_original_aspect_ratio, int force_divisible_by);
 #endif
diff --git a/libavfilter/vf_scale.c b/libavfilter/vf_scale.c
index 41ddec7661..b7f541be1f 100644
--- a/libavfilter/vf_scale.c
+++ b/libavfilter/vf_scale.c
@@ -237,31 +237,9 @@  static int config_props(AVFilterLink *outlink)
                                         &w, &h)) < 0)
         goto fail;
 
-    /* Note that force_original_aspect_ratio may overwrite the previous set
-     * dimensions so that it is not divisible by the set factors anymore
-     * unless force_divisible_by is defined as well */
-    if (scale->force_original_aspect_ratio) {
-        int tmp_w = av_rescale(h, inlink->w, inlink->h);
-        int tmp_h = av_rescale(w, inlink->h, inlink->w);
-
-        if (scale->force_original_aspect_ratio == 1) {
-             w = FFMIN(tmp_w, w);
-             h = FFMIN(tmp_h, h);
-             if (scale->force_divisible_by > 1) {
-                 // round down
-                 w = w / scale->force_divisible_by * scale->force_divisible_by;
-                 h = h / scale->force_divisible_by * scale->force_divisible_by;
-             }
-        } else {
-             w = FFMAX(tmp_w, w);
-             h = FFMAX(tmp_h, h);
-             if (scale->force_divisible_by > 1) {
-                 // round up
-                 w = (w + scale->force_divisible_by - 1) / scale->force_divisible_by * scale->force_divisible_by;
-                 h = (h + scale->force_divisible_by - 1) / scale->force_divisible_by * scale->force_divisible_by;
-             }
-        }
-    }
+    ff_scale_adjust_dimensions(inlink, &w, &h,
+                               scale->force_original_aspect_ratio,
+                               scale->force_divisible_by);
 
     if (w > INT_MAX || h > INT_MAX ||
         (h * inlink->w) > INT_MAX  ||
diff --git a/libavfilter/vf_scale_cuda.c b/libavfilter/vf_scale_cuda.c
index 0a73ea1422..cca68dd835 100644
--- a/libavfilter/vf_scale_cuda.c
+++ b/libavfilter/vf_scale_cuda.c
@@ -82,6 +82,9 @@  typedef struct CUDAScaleContext {
     char *w_expr;               ///< width  expression string
     char *h_expr;               ///< height expression string
 
+    int force_original_aspect_ratio;
+    int force_divisible_by;
+
     CUcontext   cu_ctx;
     CUmodule    cu_module;
     CUfunction  cu_func_uchar;
@@ -305,6 +308,9 @@  static av_cold int cudascale_config_props(AVFilterLink *outlink)
                                         &w, &h)) < 0)
         goto fail;
 
+    ff_scale_adjust_dimensions(inlink, &w, &h,
+                               s->force_original_aspect_ratio, s->force_divisible_by);
+
     if (((int64_t)h * inlink->w) > INT_MAX  ||
         ((int64_t)w * inlink->h) > INT_MAX)
         av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
@@ -536,6 +542,11 @@  fail:
 static const AVOption options[] = {
     { "w",      "Output video width",  OFFSET(w_expr),     AV_OPT_TYPE_STRING, { .str = "iw"   }, .flags = FLAGS },
     { "h",      "Output video height", OFFSET(h_expr),     AV_OPT_TYPE_STRING, { .str = "ih"   }, .flags = FLAGS },
+    { "force_original_aspect_ratio", "decrease or increase w/h if necessary to keep the original AR", OFFSET(force_original_aspect_ratio), AV_OPT_TYPE_INT, { .i64 = 0}, 0, 2, FLAGS, "force_oar" },
+    { "disable",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },
+    { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },
+    { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },
+    { "force_divisible_by", "enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used", OFFSET(force_divisible_by), AV_OPT_TYPE_INT, { .i64 = 1}, 1, 256, FLAGS },
     { NULL },
 };
 
diff --git a/libavfilter/vf_scale_npp.c b/libavfilter/vf_scale_npp.c
index a3e085764a..09c3d51727 100644
--- a/libavfilter/vf_scale_npp.c
+++ b/libavfilter/vf_scale_npp.c
@@ -98,6 +98,9 @@  typedef struct NPPScaleContext {
     char *h_expr;               ///< height expression string
     char *format_str;
 
+    int force_original_aspect_ratio;
+    int force_divisible_by;
+
     int interp_algo;
 } NPPScaleContext;
 
@@ -347,6 +350,9 @@  static int nppscale_config_props(AVFilterLink *outlink)
                                         &w, &h)) < 0)
         goto fail;
 
+    ff_scale_adjust_dimensions(inlink, &w, &h,
+                               s->force_original_aspect_ratio, s->force_divisible_by);
+
     if (((int64_t)h * inlink->w) > INT_MAX  ||
         ((int64_t)w * inlink->h) > INT_MAX)
         av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
@@ -552,6 +558,11 @@  static const AVOption options[] = {
         { "cubic2p_b05c03",     "2-parameter cubic (B=1/2, C=3/10)", 0, AV_OPT_TYPE_CONST, { .i64 = NPPI_INTER_CUBIC2P_B05C03     }, 0, 0, FLAGS, "interp_algo" },
         { "super",              "supersampling",                     0, AV_OPT_TYPE_CONST, { .i64 = NPPI_INTER_SUPER              }, 0, 0, FLAGS, "interp_algo" },
         { "lanczos",            "Lanczos",                           0, AV_OPT_TYPE_CONST, { .i64 = NPPI_INTER_LANCZOS            }, 0, 0, FLAGS, "interp_algo" },
+    { "force_original_aspect_ratio", "decrease or increase w/h if necessary to keep the original AR", OFFSET(force_original_aspect_ratio), AV_OPT_TYPE_INT, { .i64 = 0}, 0, 2, FLAGS, "force_oar" },
+    { "disable",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },
+    { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },
+    { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },
+    { "force_divisible_by", "enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used", OFFSET(force_divisible_by), AV_OPT_TYPE_INT, { .i64 = 1}, 1, 256, FLAGS },
     { NULL },
 };
 
diff --git a/libavfilter/vf_scale_vaapi.c b/libavfilter/vf_scale_vaapi.c
index c32395ac09..88642cbe73 100644
--- a/libavfilter/vf_scale_vaapi.c
+++ b/libavfilter/vf_scale_vaapi.c
@@ -40,6 +40,9 @@  typedef struct ScaleVAAPIContext {
     char *w_expr;      // width expression string
     char *h_expr;      // height expression string
 
+    int force_original_aspect_ratio;
+    int force_divisible_by;
+
     char *colour_primaries_string;
     char *colour_transfer_string;
     char *colour_matrix_string;
@@ -81,6 +84,9 @@  static int scale_vaapi_config_output(AVFilterLink *outlink)
                                         &vpp_ctx->output_width, &vpp_ctx->output_height)) < 0)
         return err;
 
+    ff_scale_adjust_dimensions(inlink, &vpp_ctx->output_width, &vpp_ctx->output_height,
+                               ctx->force_original_aspect_ratio, ctx->force_divisible_by);
+
     err = ff_vaapi_vpp_config_output(outlink);
     if (err < 0)
         return err;
@@ -247,6 +253,11 @@  static const AVOption scale_vaapi_options[] = {
     { "out_chroma_location", "Output chroma sample location",
       OFFSET(chroma_location_string),  AV_OPT_TYPE_STRING,
       { .str = NULL }, .flags = FLAGS },
+    { "force_original_aspect_ratio", "decrease or increase w/h if necessary to keep the original AR", OFFSET(force_original_aspect_ratio), AV_OPT_TYPE_INT, { .i64 = 0}, 0, 2, FLAGS, "force_oar" },
+    { "disable",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },
+    { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },
+    { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },
+    { "force_divisible_by", "enforce that the output resolution is divisible by a defined integer when force_original_aspect_ratio is used", OFFSET(force_divisible_by), AV_OPT_TYPE_INT, { .i64 = 1}, 1, 256, FLAGS },
 
     { NULL },
 };