falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
96379 Commits
32 Branches
293MB
Tree: ce2cfa67aa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ce2cfa67aa'
${ noResults }
FFmpeg/libavfilter/vf_scale.c

977 lines
36KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2007 Bobby Bingham

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2.1 of the License, or (at your option) any later version.

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with FFmpeg; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. /**

  22.  * @file

  23.  * scale video filter

  24.  */

  25. 

  26. #include <stdio.h>

  27. #include <string.h>

  28. 

  29. #include "avfilter.h"

  30. #include "formats.h"

  31. #include "internal.h"

  32. #include "scale_eval.h"

  33. #include "video.h"

  34. #include "libavutil/avstring.h"

  35. #include "libavutil/eval.h"

  36. #include "libavutil/internal.h"

  37. #include "libavutil/mathematics.h"

  38. #include "libavutil/opt.h"

  39. #include "libavutil/parseutils.h"

  40. #include "libavutil/pixdesc.h"

  41. #include "libavutil/imgutils.h"

  42. #include "libavutil/avassert.h"

  43. #include "libswscale/swscale.h"

  44. 

  45. static const char *const var_names[] = {

  46.     "in_w",   "iw",

  47.     "in_h",   "ih",

  48.     "out_w",  "ow",

  49.     "out_h",  "oh",

  50.     "a",

  51.     "sar",

  52.     "dar",

  53.     "hsub",

  54.     "vsub",

  55.     "ohsub",

  56.     "ovsub",

  57.     "main_w",

  58.     "main_h",

  59.     "main_a",

  60.     "main_sar",

  61.     "main_dar", "mdar",

  62.     "main_hsub",

  63.     "main_vsub",

  64.     NULL

  65. };

  66. 

  67. enum var_name {

  68.     VAR_IN_W,   VAR_IW,

  69.     VAR_IN_H,   VAR_IH,

  70.     VAR_OUT_W,  VAR_OW,

  71.     VAR_OUT_H,  VAR_OH,

  72.     VAR_A,

  73.     VAR_SAR,

  74.     VAR_DAR,

  75.     VAR_HSUB,

  76.     VAR_VSUB,

  77.     VAR_OHSUB,

  78.     VAR_OVSUB,

  79.     VAR_S2R_MAIN_W,

  80.     VAR_S2R_MAIN_H,

  81.     VAR_S2R_MAIN_A,

  82.     VAR_S2R_MAIN_SAR,

  83.     VAR_S2R_MAIN_DAR, VAR_S2R_MDAR,

  84.     VAR_S2R_MAIN_HSUB,

  85.     VAR_S2R_MAIN_VSUB,

  86.     VARS_NB

  87. };

  88. 

  89. enum EvalMode {

  90.     EVAL_MODE_INIT,

  91.     EVAL_MODE_FRAME,

  92.     EVAL_MODE_NB

  93. };

  94. 

  95. typedef struct ScaleContext {

  96.     const AVClass *class;

  97.     struct SwsContext *sws;     ///< software scaler context

  98.     struct SwsContext *isws[2]; ///< software scaler context for interlaced material

  99.     AVDictionary *opts;

  100. 

  101.     /**

  102.      * New dimensions. Special values are:

  103.      *   0 = original width/height

  104.      *  -1 = keep original aspect

  105.      *  -N = try to keep aspect but make sure it is divisible by N

  106.      */

  107.     int w, h;

  108.     char *size_str;

  109.     unsigned int flags;         ///sws flags

  110.     double param[2];            // sws params

  111. 

  112.     int hsub, vsub;             ///< chroma subsampling

  113.     int slice_y;                ///< top of current output slice

  114.     int input_is_pal;           ///< set to 1 if the input format is paletted

  115.     int output_is_pal;          ///< set to 1 if the output format is paletted

  116.     int interlaced;

  117. 

  118.     char *w_expr;               ///< width  expression string

  119.     char *h_expr;               ///< height expression string

  120.     AVExpr *w_pexpr;

  121.     AVExpr *h_pexpr;

  122.     double var_values[VARS_NB];

  123. 

  124.     char *flags_str;

  125. 

  126.     char *in_color_matrix;

  127.     char *out_color_matrix;

  128. 

  129.     int in_range;

  130.     int out_range;

  131. 

  132.     int out_h_chr_pos;

  133.     int out_v_chr_pos;

  134.     int in_h_chr_pos;

  135.     int in_v_chr_pos;

  136. 

  137.     int force_original_aspect_ratio;

  138.     int force_divisible_by;

  139. 

  140.     int nb_slices;

  141. 

  142.     int eval_mode;              ///< expression evaluation mode

  143. 

  144. } ScaleContext;

  145. 

  146. AVFilter ff_vf_scale2ref;

  147. 

  148. static int config_props(AVFilterLink *outlink);

  149. 

  150. static int check_exprs(AVFilterContext *ctx)

  151. {

  152.     ScaleContext *scale = ctx->priv;

  153.     unsigned vars_w[VARS_NB] = { 0 }, vars_h[VARS_NB] = { 0 };

  154. 

  155.     if (!scale->w_pexpr && !scale->h_pexpr)

  156.         return AVERROR(EINVAL);

  157. 

  158.     if (scale->w_pexpr)

  159.         av_expr_count_vars(scale->w_pexpr, vars_w, VARS_NB);

  160.     if (scale->h_pexpr)

  161.         av_expr_count_vars(scale->h_pexpr, vars_h, VARS_NB);

  162. 

  163.     if (vars_w[VAR_OUT_W] || vars_w[VAR_OW]) {

  164.         av_log(ctx, AV_LOG_ERROR, "Width expression cannot be self-referencing: '%s'.\n", scale->w_expr);

  165.         return AVERROR(EINVAL);

  166.     }

  167. 

  168.     if (vars_h[VAR_OUT_H] || vars_h[VAR_OH]) {

  169.         av_log(ctx, AV_LOG_ERROR, "Height expression cannot be self-referencing: '%s'.\n", scale->h_expr);

  170.         return AVERROR(EINVAL);

  171.     }

  172. 

  173.     if ((vars_w[VAR_OUT_H] || vars_w[VAR_OH]) &&

  174.         (vars_h[VAR_OUT_W] || vars_h[VAR_OW])) {

  175.         av_log(ctx, AV_LOG_ERROR, "Circular expressions invalid for width '%s' and height '%s'.\n", scale->w_expr, scale->h_expr);

  176.         return AVERROR(EINVAL);

  177.     }

  178. 

  179.     if (ctx->filter != &ff_vf_scale2ref &&

  180.         (vars_w[VAR_S2R_MAIN_W]    || vars_h[VAR_S2R_MAIN_W]    ||

  181.          vars_w[VAR_S2R_MAIN_H]    || vars_h[VAR_S2R_MAIN_H]    ||

  182.          vars_w[VAR_S2R_MAIN_A]    || vars_h[VAR_S2R_MAIN_A]    ||

  183.          vars_w[VAR_S2R_MAIN_SAR]  || vars_h[VAR_S2R_MAIN_SAR]  ||

  184.          vars_w[VAR_S2R_MAIN_DAR]  || vars_h[VAR_S2R_MAIN_DAR]  ||

  185.          vars_w[VAR_S2R_MDAR]      || vars_h[VAR_S2R_MDAR]      ||

  186.          vars_w[VAR_S2R_MAIN_HSUB] || vars_h[VAR_S2R_MAIN_HSUB] ||

  187.          vars_w[VAR_S2R_MAIN_VSUB] || vars_h[VAR_S2R_MAIN_VSUB]) ) {

  188.         av_log(ctx, AV_LOG_ERROR, "Expressions with scale2ref variables are not valid in scale filter.\n");

  189.         return AVERROR(EINVAL);

  190.     }

  191. 

  192.     return 0;

  193. }

  194. 

  195. static int scale_parse_expr(AVFilterContext *ctx, char *str_expr, AVExpr **pexpr_ptr, const char *var, const char *args)

  196. {

  197.     ScaleContext *scale = ctx->priv;

  198.     int ret, is_inited = 0;

  199.     char *old_str_expr = NULL;

  200.     AVExpr *old_pexpr = NULL;

  201. 

  202.     if (str_expr) {

  203.         old_str_expr = av_strdup(str_expr);

  204.         if (!old_str_expr)

  205.             return AVERROR(ENOMEM);

  206.         av_opt_set(scale, var, args, 0);

  207.     }

  208. 

  209.     if (*pexpr_ptr) {

  210.         old_pexpr = *pexpr_ptr;

  211.         *pexpr_ptr = NULL;

  212.         is_inited = 1;

  213.     }

  214. 

  215.     ret = av_expr_parse(pexpr_ptr, args, var_names,

  216.                         NULL, NULL, NULL, NULL, 0, ctx);

  217.     if (ret < 0) {

  218.         av_log(ctx, AV_LOG_ERROR, "Cannot parse expression for %s: '%s'\n", var, args);

  219.         goto revert;

  220.     }

  221. 

  222.     ret = check_exprs(ctx);

  223.     if (ret < 0)

  224.         goto revert;

  225. 

  226.     if (is_inited && (ret = config_props(ctx->outputs[0])) < 0)

  227.         goto revert;

  228. 

  229.     av_expr_free(old_pexpr);

  230.     old_pexpr = NULL;

  231.     av_freep(&old_str_expr);

  232. 

  233.     return 0;

  234. 

  235. revert:

  236.     av_expr_free(*pexpr_ptr);

  237.     *pexpr_ptr = NULL;

  238.     if (old_str_expr) {

  239.         av_opt_set(scale, var, old_str_expr, 0);

  240.         av_free(old_str_expr);

  241.     }

  242.     if (old_pexpr)

  243.         *pexpr_ptr = old_pexpr;

  244. 

  245.     return ret;

  246. }

  247. 

  248. static av_cold int init_dict(AVFilterContext *ctx, AVDictionary **opts)

  249. {

  250.     ScaleContext *scale = ctx->priv;

  251.     int ret;

  252. 

  253.     if (scale->size_str && (scale->w_expr || scale->h_expr)) {

  254.         av_log(ctx, AV_LOG_ERROR,

  255.                "Size and width/height expressions cannot be set at the same time.\n");

  256.             return AVERROR(EINVAL);

  257.     }

  258. 

  259.     if (scale->w_expr && !scale->h_expr)

  260.         FFSWAP(char *, scale->w_expr, scale->size_str);

  261. 

  262.     if (scale->size_str) {

  263.         char buf[32];

  264.         if ((ret = av_parse_video_size(&scale->w, &scale->h, scale->size_str)) < 0) {

  265.             av_log(ctx, AV_LOG_ERROR,

  266.                    "Invalid size '%s'\n", scale->size_str);

  267.             return ret;

  268.         }

  269.         snprintf(buf, sizeof(buf)-1, "%d", scale->w);

  270.         av_opt_set(scale, "w", buf, 0);

  271.         snprintf(buf, sizeof(buf)-1, "%d", scale->h);

  272.         av_opt_set(scale, "h", buf, 0);

  273.     }

  274.     if (!scale->w_expr)

  275.         av_opt_set(scale, "w", "iw", 0);

  276.     if (!scale->h_expr)

  277.         av_opt_set(scale, "h", "ih", 0);

  278. 

  279.     ret = scale_parse_expr(ctx, NULL, &scale->w_pexpr, "width", scale->w_expr);

  280.     if (ret < 0)

  281.         return ret;

  282. 

  283.     ret = scale_parse_expr(ctx, NULL, &scale->h_pexpr, "height", scale->h_expr);

  284.     if (ret < 0)

  285.         return ret;

  286. 

  287.     av_log(ctx, AV_LOG_VERBOSE, "w:%s h:%s flags:'%s' interl:%d\n",

  288.            scale->w_expr, scale->h_expr, (char *)av_x_if_null(scale->flags_str, ""), scale->interlaced);

  289. 

  290.     scale->flags = 0;

  291. 

  292.     if (scale->flags_str) {

  293.         const AVClass *class = sws_get_class();

  294.         const AVOption    *o = av_opt_find(&class, "sws_flags", NULL, 0,

  295.                                            AV_OPT_SEARCH_FAKE_OBJ);

  296.         int ret = av_opt_eval_flags(&class, o, scale->flags_str, &scale->flags);

  297.         if (ret < 0)

  298.             return ret;

  299.     }

  300.     scale->opts = *opts;

  301.     *opts = NULL;

  302. 

  303.     return 0;

  304. }

  305. 

  306. static av_cold void uninit(AVFilterContext *ctx)

  307. {

  308.     ScaleContext *scale = ctx->priv;

  309.     av_expr_free(scale->w_pexpr);

  310.     av_expr_free(scale->h_pexpr);

  311.     scale->w_pexpr = scale->h_pexpr = NULL;

  312.     sws_freeContext(scale->sws);

  313.     sws_freeContext(scale->isws[0]);

  314.     sws_freeContext(scale->isws[1]);

  315.     scale->sws = NULL;

  316.     av_dict_free(&scale->opts);

  317. }

  318. 

  319. static int query_formats(AVFilterContext *ctx)

  320. {

  321.     AVFilterFormats *formats;

  322.     enum AVPixelFormat pix_fmt;

  323.     int ret;

  324. 

  325.     if (ctx->inputs[0]) {

  326.         const AVPixFmtDescriptor *desc = NULL;

  327.         formats = NULL;

  328.         while ((desc = av_pix_fmt_desc_next(desc))) {

  329.             pix_fmt = av_pix_fmt_desc_get_id(desc);

  330.             if ((sws_isSupportedInput(pix_fmt) ||

  331.                  sws_isSupportedEndiannessConversion(pix_fmt))

  332.                 && (ret = ff_add_format(&formats, pix_fmt)) < 0) {

  333.                 return ret;

  334.             }

  335.         }

  336.         if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0)

  337.             return ret;

  338.     }

  339.     if (ctx->outputs[0]) {

  340.         const AVPixFmtDescriptor *desc = NULL;

  341.         formats = NULL;

  342.         while ((desc = av_pix_fmt_desc_next(desc))) {

  343.             pix_fmt = av_pix_fmt_desc_get_id(desc);

  344.             if ((sws_isSupportedOutput(pix_fmt) || pix_fmt == AV_PIX_FMT_PAL8 ||

  345.                  sws_isSupportedEndiannessConversion(pix_fmt))

  346.                 && (ret = ff_add_format(&formats, pix_fmt)) < 0) {

  347.                 return ret;

  348.             }

  349.         }

  350.         if ((ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0)

  351.             return ret;

  352.     }

  353. 

  354.     return 0;

  355. }

  356. 

  357. static const int *parse_yuv_type(const char *s, enum AVColorSpace colorspace)

  358. {

  359.     if (!s)

  360.         s = "bt601";

  361. 

  362.     if (s && strstr(s, "bt709")) {

  363.         colorspace = AVCOL_SPC_BT709;

  364.     } else if (s && strstr(s, "fcc")) {

  365.         colorspace = AVCOL_SPC_FCC;

  366.     } else if (s && strstr(s, "smpte240m")) {

  367.         colorspace = AVCOL_SPC_SMPTE240M;

  368.     } else if (s && (strstr(s, "bt601") || strstr(s, "bt470") || strstr(s, "smpte170m"))) {

  369.         colorspace = AVCOL_SPC_BT470BG;

  370.     } else if (s && strstr(s, "bt2020")) {

  371.         colorspace = AVCOL_SPC_BT2020_NCL;

  372.     }

  373. 

  374.     if (colorspace < 1 || colorspace > 10 || colorspace == 8) {

  375.         colorspace = AVCOL_SPC_BT470BG;

  376.     }

  377. 

  378.     return sws_getCoefficients(colorspace);

  379. }

  380. 

  381. static int scale_eval_dimensions(AVFilterContext *ctx)

  382. {

  383.     ScaleContext *scale = ctx->priv;

  384.     const char scale2ref = ctx->filter == &ff_vf_scale2ref;

  385.     const AVFilterLink *inlink = scale2ref ? ctx->inputs[1] : ctx->inputs[0];

  386.     const AVFilterLink *outlink = ctx->outputs[0];

  387.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

  388.     const AVPixFmtDescriptor *out_desc = av_pix_fmt_desc_get(outlink->format);

  389.     char *expr;

  390.     int eval_w, eval_h;

  391.     int ret;

  392.     double res;

  393.     const AVPixFmtDescriptor *main_desc;

  394.     const AVFilterLink *main_link;

  395. 

  396.     if (scale2ref) {

  397.         main_link = ctx->inputs[0];

  398.         main_desc = av_pix_fmt_desc_get(main_link->format);

  399.     }

  400. 

  401.     scale->var_values[VAR_IN_W]  = scale->var_values[VAR_IW] = inlink->w;

  402.     scale->var_values[VAR_IN_H]  = scale->var_values[VAR_IH] = inlink->h;

  403.     scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = NAN;

  404.     scale->var_values[VAR_OUT_H] = scale->var_values[VAR_OH] = NAN;

  405.     scale->var_values[VAR_A]     = (double) inlink->w / inlink->h;

  406.     scale->var_values[VAR_SAR]   = inlink->sample_aspect_ratio.num ?

  407.         (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;

  408.     scale->var_values[VAR_DAR]   = scale->var_values[VAR_A] * scale->var_values[VAR_SAR];

  409.     scale->var_values[VAR_HSUB]  = 1 << desc->log2_chroma_w;

  410.     scale->var_values[VAR_VSUB]  = 1 << desc->log2_chroma_h;

  411.     scale->var_values[VAR_OHSUB] = 1 << out_desc->log2_chroma_w;

  412.     scale->var_values[VAR_OVSUB] = 1 << out_desc->log2_chroma_h;

  413. 

  414.     if (scale2ref) {

  415.         scale->var_values[VAR_S2R_MAIN_W] = main_link->w;

  416.         scale->var_values[VAR_S2R_MAIN_H] = main_link->h;

  417.         scale->var_values[VAR_S2R_MAIN_A] = (double) main_link->w / main_link->h;

  418.         scale->var_values[VAR_S2R_MAIN_SAR] = main_link->sample_aspect_ratio.num ?

  419.             (double) main_link->sample_aspect_ratio.num / main_link->sample_aspect_ratio.den : 1;

  420.         scale->var_values[VAR_S2R_MAIN_DAR] = scale->var_values[VAR_S2R_MDAR] =

  421.             scale->var_values[VAR_S2R_MAIN_A] * scale->var_values[VAR_S2R_MAIN_SAR];

  422.         scale->var_values[VAR_S2R_MAIN_HSUB] = 1 << main_desc->log2_chroma_w;

  423.         scale->var_values[VAR_S2R_MAIN_VSUB] = 1 << main_desc->log2_chroma_h;

  424.     }

  425. 

  426.     res = av_expr_eval(scale->w_pexpr, scale->var_values, NULL);

  427.     eval_w = scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = (int) res == 0 ? inlink->w : (int) res;

  428. 

  429.     res = av_expr_eval(scale->h_pexpr, scale->var_values, NULL);

  430.     if (isnan(res)) {

  431.         expr = scale->h_expr;

  432.         ret = AVERROR(EINVAL);

  433.         goto fail;

  434.     }

  435.     eval_h = scale->var_values[VAR_OUT_H] = scale->var_values[VAR_OH] = (int) res == 0 ? inlink->h : (int) res;

  436. 

  437.     res = av_expr_eval(scale->w_pexpr, scale->var_values, NULL);

  438.     if (isnan(res)) {

  439.         expr = scale->w_expr;

  440.         ret = AVERROR(EINVAL);

  441.         goto fail;

  442.     }

  443.     eval_w = scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = (int) res == 0 ? inlink->w : (int) res;

  444. 

  445.     scale->w = eval_w;

  446.     scale->h = eval_h;

  447. 

  448.     return 0;

  449. 

  450. fail:

  451.     av_log(ctx, AV_LOG_ERROR,

  452.            "Error when evaluating the expression '%s'.\n", expr);

  453.     return ret;

  454. }

  455. 

  456. static int config_props(AVFilterLink *outlink)

  457. {

  458.     AVFilterContext *ctx = outlink->src;

  459.     AVFilterLink *inlink0 = outlink->src->inputs[0];

  460.     AVFilterLink *inlink  = ctx->filter == &ff_vf_scale2ref ?

  461.                             outlink->src->inputs[1] :

  462.                             outlink->src->inputs[0];

  463.     enum AVPixelFormat outfmt = outlink->format;

  464.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);

  465.     ScaleContext *scale = ctx->priv;

  466.     int ret;

  467. 

  468.     if ((ret = scale_eval_dimensions(ctx)) < 0)

  469.         goto fail;

  470. 

  471.     ff_scale_adjust_dimensions(inlink, &scale->w, &scale->h,

  472.                                scale->force_original_aspect_ratio,

  473.                                scale->force_divisible_by);

  474. 

  475.     if (scale->w > INT_MAX ||

  476.         scale->h > INT_MAX ||

  477.         (scale->h * inlink->w) > INT_MAX ||

  478.         (scale->w * inlink->h) > INT_MAX)

  479.         av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");

  480. 

  481.     outlink->w = scale->w;

  482.     outlink->h = scale->h;

  483. 

  484.     /* TODO: make algorithm configurable */

  485. 

  486.     scale->input_is_pal = desc->flags & AV_PIX_FMT_FLAG_PAL;

  487.     if (outfmt == AV_PIX_FMT_PAL8) outfmt = AV_PIX_FMT_BGR8;

  488.     scale->output_is_pal = av_pix_fmt_desc_get(outfmt)->flags & AV_PIX_FMT_FLAG_PAL ||

  489.                            av_pix_fmt_desc_get(outfmt)->flags & FF_PSEUDOPAL;

  490. 

  491.     if (scale->sws)

  492.         sws_freeContext(scale->sws);

  493.     if (scale->isws[0])

  494.         sws_freeContext(scale->isws[0]);

  495.     if (scale->isws[1])

  496.         sws_freeContext(scale->isws[1]);

  497.     scale->isws[0] = scale->isws[1] = scale->sws = NULL;

  498.     if (inlink0->w == outlink->w &&

  499.         inlink0->h == outlink->h &&

  500.         !scale->out_color_matrix &&

  501.         scale->in_range == scale->out_range &&

  502.         inlink0->format == outlink->format)

  503.         ;

  504.     else {

  505.         struct SwsContext **swscs[3] = {&scale->sws, &scale->isws[0], &scale->isws[1]};

  506.         int i;

  507. 

  508.         for (i = 0; i < 3; i++) {

  509.             int in_v_chr_pos = scale->in_v_chr_pos, out_v_chr_pos = scale->out_v_chr_pos;

  510.             struct SwsContext **s = swscs[i];

  511.             *s = sws_alloc_context();

  512.             if (!*s)

  513.                 return AVERROR(ENOMEM);

  514. 

  515.             av_opt_set_int(*s, "srcw", inlink0 ->w, 0);

  516.             av_opt_set_int(*s, "srch", inlink0 ->h >> !!i, 0);

  517.             av_opt_set_int(*s, "src_format", inlink0->format, 0);

  518.             av_opt_set_int(*s, "dstw", outlink->w, 0);

  519.             av_opt_set_int(*s, "dsth", outlink->h >> !!i, 0);

  520.             av_opt_set_int(*s, "dst_format", outfmt, 0);

  521.             av_opt_set_int(*s, "sws_flags", scale->flags, 0);

  522.             av_opt_set_int(*s, "param0", scale->param[0], 0);

  523.             av_opt_set_int(*s, "param1", scale->param[1], 0);

  524.             if (scale->in_range != AVCOL_RANGE_UNSPECIFIED)

  525.                 av_opt_set_int(*s, "src_range",

  526.                                scale->in_range == AVCOL_RANGE_JPEG, 0);

  527.             if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)

  528.                 av_opt_set_int(*s, "dst_range",

  529.                                scale->out_range == AVCOL_RANGE_JPEG, 0);

  530. 

  531.             if (scale->opts) {

  532.                 AVDictionaryEntry *e = NULL;

  533.                 while ((e = av_dict_get(scale->opts, "", e, AV_DICT_IGNORE_SUFFIX))) {

  534.                     if ((ret = av_opt_set(*s, e->key, e->value, 0)) < 0)

  535.                         return ret;

  536.                 }

  537.             }

  538.             /* Override YUV420P default settings to have the correct (MPEG-2) chroma positions

  539.              * MPEG-2 chroma positions are used by convention

  540.              * XXX: support other 4:2:0 pixel formats */

  541.             if (inlink0->format == AV_PIX_FMT_YUV420P && scale->in_v_chr_pos == -513) {

  542.                 in_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;

  543.             }

  544. 

  545.             if (outlink->format == AV_PIX_FMT_YUV420P && scale->out_v_chr_pos == -513) {

  546.                 out_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;

  547.             }

  548. 

  549.             av_opt_set_int(*s, "src_h_chr_pos", scale->in_h_chr_pos, 0);

  550.             av_opt_set_int(*s, "src_v_chr_pos", in_v_chr_pos, 0);

  551.             av_opt_set_int(*s, "dst_h_chr_pos", scale->out_h_chr_pos, 0);

  552.             av_opt_set_int(*s, "dst_v_chr_pos", out_v_chr_pos, 0);

  553. 

  554.             if ((ret = sws_init_context(*s, NULL, NULL)) < 0)

  555.                 return ret;

  556.             if (!scale->interlaced)

  557.                 break;

  558.         }

  559.     }

  560. 

  561.     if (inlink0->sample_aspect_ratio.num){

  562.         outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h * inlink0->w, outlink->w * inlink0->h}, inlink0->sample_aspect_ratio);

  563.     } else

  564.         outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;

  565. 

  566.     av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d fmt:%s sar:%d/%d -> w:%d h:%d fmt:%s sar:%d/%d flags:0x%0x\n",

  567.            inlink ->w, inlink ->h, av_get_pix_fmt_name( inlink->format),

  568.            inlink->sample_aspect_ratio.num, inlink->sample_aspect_ratio.den,

  569.            outlink->w, outlink->h, av_get_pix_fmt_name(outlink->format),

  570.            outlink->sample_aspect_ratio.num, outlink->sample_aspect_ratio.den,

  571.            scale->flags);

  572.     return 0;

  573. 

  574. fail:

  575.     return ret;

  576. }

  577. 

  578. static int config_props_ref(AVFilterLink *outlink)

  579. {

  580.     AVFilterLink *inlink = outlink->src->inputs[1];

  581. 

  582.     outlink->w = inlink->w;

  583.     outlink->h = inlink->h;

  584.     outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;

  585.     outlink->time_base = inlink->time_base;

  586.     outlink->frame_rate = inlink->frame_rate;

  587. 

  588.     return 0;

  589. }

  590. 

  591. static int request_frame(AVFilterLink *outlink)

  592. {

  593.     return ff_request_frame(outlink->src->inputs[0]);

  594. }

  595. 

  596. static int request_frame_ref(AVFilterLink *outlink)

  597. {

  598.     return ff_request_frame(outlink->src->inputs[1]);

  599. }

  600. 

  601. static int scale_slice(AVFilterLink *link, AVFrame *out_buf, AVFrame *cur_pic, struct SwsContext *sws, int y, int h, int mul, int field)

  602. {

  603.     ScaleContext *scale = link->dst->priv;

  604.     const uint8_t *in[4];

  605.     uint8_t *out[4];

  606.     int in_stride[4],out_stride[4];

  607.     int i;

  608. 

  609.     for (i=0; i<4; i++) {

  610.         int vsub= ((i+1)&2) ? scale->vsub : 0;

  611.          in_stride[i] = cur_pic->linesize[i] * mul;

  612.         out_stride[i] = out_buf->linesize[i] * mul;

  613.          in[i] = cur_pic->data[i] + ((y>>vsub)+field) * cur_pic->linesize[i];

  614.         out[i] = out_buf->data[i] +            field  * out_buf->linesize[i];

  615.     }

  616.     if (scale->input_is_pal)

  617.          in[1] = cur_pic->data[1];

  618.     if (scale->output_is_pal)

  619.         out[1] = out_buf->data[1];

  620. 

  621.     return sws_scale(sws, in, in_stride, y/mul, h,

  622.                          out,out_stride);

  623. }

  624. 

  625. static int scale_frame(AVFilterLink *link, AVFrame *in, AVFrame **frame_out)

  626. {

  627.     AVFilterContext *ctx = link->dst;

  628.     ScaleContext *scale = ctx->priv;

  629.     AVFilterLink *outlink = ctx->outputs[0];

  630.     AVFrame *out;

  631.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);

  632.     char buf[32];

  633.     int in_range;

  634.     int frame_changed;

  635. 

  636.     *frame_out = NULL;

  637.     if (in->colorspace == AVCOL_SPC_YCGCO)

  638.         av_log(link->dst, AV_LOG_WARNING, "Detected unsupported YCgCo colorspace.\n");

  639. 

  640.     frame_changed = in->width  != link->w ||

  641.                     in->height != link->h ||

  642.                     in->format != link->format ||

  643.                     in->sample_aspect_ratio.den != link->sample_aspect_ratio.den ||

  644.                     in->sample_aspect_ratio.num != link->sample_aspect_ratio.num;

  645. 

  646.     if (frame_changed ||

  647.         (scale->eval_mode == EVAL_MODE_FRAME &&

  648.          ctx->filter == &ff_vf_scale2ref) ) {

  649.         int ret;

  650. 

  651.         if (scale->eval_mode == EVAL_MODE_INIT) {

  652.             snprintf(buf, sizeof(buf)-1, "%d", outlink->w);

  653.             av_opt_set(scale, "w", buf, 0);

  654.             snprintf(buf, sizeof(buf)-1, "%d", outlink->h);

  655.             av_opt_set(scale, "h", buf, 0);

  656. 

  657.             ret = scale_parse_expr(ctx, NULL, &scale->w_pexpr, "width", scale->w_expr);

  658.             if (ret < 0)

  659.                 return ret;

  660. 

  661.             ret = scale_parse_expr(ctx, NULL, &scale->h_pexpr, "height", scale->h_expr);

  662.             if (ret < 0)

  663.                 return ret;

  664.         }

  665. 

  666.         link->dst->inputs[0]->format = in->format;

  667.         link->dst->inputs[0]->w      = in->width;

  668.         link->dst->inputs[0]->h      = in->height;

  669. 

  670.         link->dst->inputs[0]->sample_aspect_ratio.den = in->sample_aspect_ratio.den;

  671.         link->dst->inputs[0]->sample_aspect_ratio.num = in->sample_aspect_ratio.num;

  672. 

  673.         if ((ret = config_props(outlink)) < 0)

  674.             return ret;

  675.     }

  676. 

  677.     if (!scale->sws) {

  678.         *frame_out = in;

  679.         return 0;

  680.     }

  681. 

  682.     scale->hsub = desc->log2_chroma_w;

  683.     scale->vsub = desc->log2_chroma_h;

  684. 

  685.     out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

  686.     if (!out) {

  687.         av_frame_free(&in);

  688.         return AVERROR(ENOMEM);

  689.     }

  690.     *frame_out = out;

  691. 

  692.     av_frame_copy_props(out, in);

  693.     out->width  = outlink->w;

  694.     out->height = outlink->h;

  695. 

  696.     if (scale->output_is_pal)

  697.         avpriv_set_systematic_pal2((uint32_t*)out->data[1], outlink->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : outlink->format);

  698. 

  699.     in_range = in->color_range;

  700. 

  701.     if (   scale->in_color_matrix

  702.         || scale->out_color_matrix

  703.         || scale-> in_range != AVCOL_RANGE_UNSPECIFIED

  704.         || in_range != AVCOL_RANGE_UNSPECIFIED

  705.         || scale->out_range != AVCOL_RANGE_UNSPECIFIED) {

  706.         int in_full, out_full, brightness, contrast, saturation;

  707.         const int *inv_table, *table;

  708. 

  709.         sws_getColorspaceDetails(scale->sws, (int **)&inv_table, &in_full,

  710.                                  (int **)&table, &out_full,

  711.                                  &brightness, &contrast, &saturation);

  712. 

  713.         if (scale->in_color_matrix)

  714.             inv_table = parse_yuv_type(scale->in_color_matrix, in->colorspace);

  715.         if (scale->out_color_matrix)

  716.             table     = parse_yuv_type(scale->out_color_matrix, AVCOL_SPC_UNSPECIFIED);

  717.         else if (scale->in_color_matrix)

  718.             table = inv_table;

  719. 

  720.         if (scale-> in_range != AVCOL_RANGE_UNSPECIFIED)

  721.             in_full  = (scale-> in_range == AVCOL_RANGE_JPEG);

  722.         else if (in_range != AVCOL_RANGE_UNSPECIFIED)

  723.             in_full  = (in_range == AVCOL_RANGE_JPEG);

  724.         if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)

  725.             out_full = (scale->out_range == AVCOL_RANGE_JPEG);

  726. 

  727.         sws_setColorspaceDetails(scale->sws, inv_table, in_full,

  728.                                  table, out_full,

  729.                                  brightness, contrast, saturation);

  730.         if (scale->isws[0])

  731.             sws_setColorspaceDetails(scale->isws[0], inv_table, in_full,

  732.                                      table, out_full,

  733.                                      brightness, contrast, saturation);

  734.         if (scale->isws[1])

  735.             sws_setColorspaceDetails(scale->isws[1], inv_table, in_full,

  736.                                      table, out_full,

  737.                                      brightness, contrast, saturation);

  738. 

  739.         out->color_range = out_full ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;

  740.     }

  741. 

  742.     av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,

  743.               (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,

  744.               (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,

  745.               INT_MAX);

  746. 

  747.     if (scale->interlaced>0 || (scale->interlaced<0 && in->interlaced_frame)) {

  748.         scale_slice(link, out, in, scale->isws[0], 0, (link->h+1)/2, 2, 0);

  749.         scale_slice(link, out, in, scale->isws[1], 0,  link->h   /2, 2, 1);

  750.     } else if (scale->nb_slices) {

  751.         int i, slice_h, slice_start, slice_end = 0;

  752.         const int nb_slices = FFMIN(scale->nb_slices, link->h);

  753.         for (i = 0; i < nb_slices; i++) {

  754.             slice_start = slice_end;

  755.             slice_end   = (link->h * (i+1)) / nb_slices;

  756.             slice_h     = slice_end - slice_start;

  757.             scale_slice(link, out, in, scale->sws, slice_start, slice_h, 1, 0);

  758.         }

  759.     } else {

  760.         scale_slice(link, out, in, scale->sws, 0, link->h, 1, 0);

  761.     }

  762. 

  763.     av_frame_free(&in);

  764.     return 0;

  765. }

  766. 

  767. static int filter_frame(AVFilterLink *link, AVFrame *in)

  768. {

  769.     AVFilterContext *ctx = link->dst;

  770.     AVFilterLink *outlink = ctx->outputs[0];

  771.     AVFrame *out;

  772.     int ret;

  773. 

  774.     ret = scale_frame(link, in, &out);

  775.     if (out)

  776.         return ff_filter_frame(outlink, out);

  777. 

  778.     return ret;

  779. }

  780. 

  781. static int filter_frame_ref(AVFilterLink *link, AVFrame *in)

  782. {

  783.     AVFilterLink *outlink = link->dst->outputs[1];

  784.     int frame_changed;

  785. 

  786.     frame_changed = in->width  != link->w ||

  787.                     in->height != link->h ||

  788.                     in->format != link->format ||

  789.                     in->sample_aspect_ratio.den != link->sample_aspect_ratio.den ||

  790.                     in->sample_aspect_ratio.num != link->sample_aspect_ratio.num;

  791. 

  792.     if (frame_changed) {

  793.         link->format = in->format;

  794.         link->w = in->width;

  795.         link->h = in->height;

  796.         link->sample_aspect_ratio.num = in->sample_aspect_ratio.num;

  797.         link->sample_aspect_ratio.den = in->sample_aspect_ratio.den;

  798. 

  799.         config_props_ref(outlink);

  800.     }

  801. 

  802.     return ff_filter_frame(outlink, in);

  803. }

  804. 

  805. static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,

  806.                            char *res, int res_len, int flags)

  807. {

  808.     ScaleContext *scale = ctx->priv;

  809.     char *str_expr;

  810.     AVExpr **pexpr_ptr;

  811.     int ret, w, h;

  812. 

  813.     w = !strcmp(cmd, "width")  || !strcmp(cmd, "w");

  814.     h = !strcmp(cmd, "height")  || !strcmp(cmd, "h");

  815. 

  816.     if (w || h) {

  817.         str_expr = w ? scale->w_expr : scale->h_expr;

  818.         pexpr_ptr = w ? &scale->w_pexpr : &scale->h_pexpr;

  819. 

  820.         ret = scale_parse_expr(ctx, str_expr, pexpr_ptr, cmd, args);

  821.     } else

  822.         ret = AVERROR(ENOSYS);

  823. 

  824.     if (ret < 0)

  825.         av_log(ctx, AV_LOG_ERROR, "Failed to process command. Continuing with existing parameters.\n");

  826. 

  827.     return ret;

  828. }

  829. 

  830. static const AVClass *child_class_next(const AVClass *prev)

  831. {

  832.     return prev ? NULL : sws_get_class();

  833. }

  834. 

  835. #define OFFSET(x) offsetof(ScaleContext, x)

  836. #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM

  837. #define TFLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM

  838. 

  839. static const AVOption scale_options[] = {

  840.     { "w",     "Output video width",          OFFSET(w_expr),    AV_OPT_TYPE_STRING,        .flags = TFLAGS },

  841.     { "width", "Output video width",          OFFSET(w_expr),    AV_OPT_TYPE_STRING,        .flags = TFLAGS },

  842.     { "h",     "Output video height",         OFFSET(h_expr),    AV_OPT_TYPE_STRING,        .flags = TFLAGS },

  843.     { "height","Output video height",         OFFSET(h_expr),    AV_OPT_TYPE_STRING,        .flags = TFLAGS },

  844.     { "flags", "Flags to pass to libswscale", OFFSET(flags_str), AV_OPT_TYPE_STRING, { .str = "bilinear" }, .flags = FLAGS },

  845.     { "interl", "set interlacing", OFFSET(interlaced), AV_OPT_TYPE_BOOL, {.i64 = 0 }, -1, 1, FLAGS },

  846.     { "size",   "set video size",          OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },

  847.     { "s",      "set video size",          OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },

  848.     {  "in_color_matrix", "set input YCbCr type",   OFFSET(in_color_matrix),  AV_OPT_TYPE_STRING, { .str = "auto" }, .flags = FLAGS, "color" },

  849.     { "out_color_matrix", "set output YCbCr type",  OFFSET(out_color_matrix), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS,  "color"},

  850.         { "auto",        NULL, 0, AV_OPT_TYPE_CONST, { .str = "auto" },      0, 0, FLAGS, "color" },

  851.         { "bt601",       NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt601" },     0, 0, FLAGS, "color" },

  852.         { "bt470",       NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt470" },     0, 0, FLAGS, "color" },

  853.         { "smpte170m",   NULL, 0, AV_OPT_TYPE_CONST, { .str = "smpte170m" }, 0, 0, FLAGS, "color" },

  854.         { "bt709",       NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt709" },     0, 0, FLAGS, "color" },

  855.         { "fcc",         NULL, 0, AV_OPT_TYPE_CONST, { .str = "fcc" },       0, 0, FLAGS, "color" },

  856.         { "smpte240m",   NULL, 0, AV_OPT_TYPE_CONST, { .str = "smpte240m" }, 0, 0, FLAGS, "color" },

  857.         { "bt2020",      NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt2020" },    0, 0, FLAGS, "color" },

  858.     {  "in_range", "set input color range",  OFFSET( in_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },

  859.     { "out_range", "set output color range", OFFSET(out_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },

  860.     { "auto",   NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },

  861.     { "unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },

  862.     { "full",   NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },

  863.     { "limited",NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },

  864.     { "jpeg",   NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },

  865.     { "mpeg",   NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },

  866.     { "tv",     NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },

  867.     { "pc",     NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },

  868.     { "in_v_chr_pos",   "input vertical chroma position in luma grid/256"  ,   OFFSET(in_v_chr_pos),  AV_OPT_TYPE_INT, { .i64 = -513}, -513, 512, FLAGS },

  869.     { "in_h_chr_pos",   "input horizontal chroma position in luma grid/256",   OFFSET(in_h_chr_pos),  AV_OPT_TYPE_INT, { .i64 = -513}, -513, 512, FLAGS },

  870.     { "out_v_chr_pos",   "output vertical chroma position in luma grid/256"  , OFFSET(out_v_chr_pos), AV_OPT_TYPE_INT, { .i64 = -513}, -513, 512, FLAGS },

  871.     { "out_h_chr_pos",   "output horizontal chroma position in luma grid/256", OFFSET(out_h_chr_pos), AV_OPT_TYPE_INT, { .i64 = -513}, -513, 512, FLAGS },

  872.     { "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" },

  873.     { "disable",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },

  874.     { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },

  875.     { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },

  876.     { "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 },

  877.     { "param0", "Scaler param 0",             OFFSET(param[0]),  AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT  }, INT_MIN, INT_MAX, FLAGS },

  878.     { "param1", "Scaler param 1",             OFFSET(param[1]),  AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT  }, INT_MIN, INT_MAX, FLAGS },

  879.     { "nb_slices", "set the number of slices (debug purpose only)", OFFSET(nb_slices), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },

  880.     { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },

  881.          { "init",  "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT},  .flags = FLAGS, .unit = "eval" },

  882.          { "frame", "eval expressions during initialization and per-frame", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },

  883.     { NULL }

  884. };

  885. 

  886. static const AVClass scale_class = {

  887.     .class_name       = "scale",

  888.     .item_name        = av_default_item_name,

  889.     .option           = scale_options,

  890.     .version          = LIBAVUTIL_VERSION_INT,

  891.     .category         = AV_CLASS_CATEGORY_FILTER,

  892.     .child_class_next = child_class_next,

  893. };

  894. 

  895. static const AVFilterPad avfilter_vf_scale_inputs[] = {

  896.     {

  897.         .name         = "default",

  898.         .type         = AVMEDIA_TYPE_VIDEO,

  899.         .filter_frame = filter_frame,

  900.     },

  901.     { NULL }

  902. };

  903. 

  904. static const AVFilterPad avfilter_vf_scale_outputs[] = {

  905.     {

  906.         .name         = "default",

  907.         .type         = AVMEDIA_TYPE_VIDEO,

  908.         .config_props = config_props,

  909.     },

  910.     { NULL }

  911. };

  912. 

  913. AVFilter ff_vf_scale = {

  914.     .name            = "scale",

  915.     .description     = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format."),

  916.     .init_dict       = init_dict,

  917.     .uninit          = uninit,

  918.     .query_formats   = query_formats,

  919.     .priv_size       = sizeof(ScaleContext),

  920.     .priv_class      = &scale_class,

  921.     .inputs          = avfilter_vf_scale_inputs,

  922.     .outputs         = avfilter_vf_scale_outputs,

  923.     .process_command = process_command,

  924. };

  925. 

  926. static const AVClass scale2ref_class = {

  927.     .class_name       = "scale2ref",

  928.     .item_name        = av_default_item_name,

  929.     .option           = scale_options,

  930.     .version          = LIBAVUTIL_VERSION_INT,

  931.     .category         = AV_CLASS_CATEGORY_FILTER,

  932.     .child_class_next = child_class_next,

  933. };

  934. 

  935. static const AVFilterPad avfilter_vf_scale2ref_inputs[] = {

  936.     {

  937.         .name         = "default",

  938.         .type         = AVMEDIA_TYPE_VIDEO,

  939.         .filter_frame = filter_frame,

  940.     },

  941.     {

  942.         .name         = "ref",

  943.         .type         = AVMEDIA_TYPE_VIDEO,

  944.         .filter_frame = filter_frame_ref,

  945.     },

  946.     { NULL }

  947. };

  948. 

  949. static const AVFilterPad avfilter_vf_scale2ref_outputs[] = {

  950.     {

  951.         .name         = "default",

  952.         .type         = AVMEDIA_TYPE_VIDEO,

  953.         .config_props = config_props,

  954.         .request_frame= request_frame,

  955.     },

  956.     {

  957.         .name         = "ref",

  958.         .type         = AVMEDIA_TYPE_VIDEO,

  959.         .config_props = config_props_ref,

  960.         .request_frame= request_frame_ref,

  961.     },

  962.     { NULL }

  963. };

  964. 

  965. AVFilter ff_vf_scale2ref = {

  966.     .name            = "scale2ref",

  967.     .description     = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format to the given reference."),

  968.     .init_dict       = init_dict,

  969.     .uninit          = uninit,

  970.     .query_formats   = query_formats,

  971.     .priv_size       = sizeof(ScaleContext),

  972.     .priv_class      = &scale2ref_class,

  973.     .inputs          = avfilter_vf_scale2ref_inputs,

  974.     .outputs         = avfilter_vf_scale2ref_outputs,

  975.     .process_command = process_command,

  976. };