FFmpeg
vf_scale.c
Go to the documentation of this file.
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 <float.h>
27 #include <stdio.h>
28 #include <string.h>
29 
30 #include "avfilter.h"
31 #include "formats.h"
32 #include "internal.h"
33 #include "scale_eval.h"
34 #include "video.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/eval.h"
37 #include "libavutil/internal.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/imgutils.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  "n",
58  "t",
59 #if FF_API_FRAME_PKT
60  "pos",
61 #endif
62  "main_w",
63  "main_h",
64  "main_a",
65  "main_sar",
66  "main_dar", "mdar",
67  "main_hsub",
68  "main_vsub",
69  "main_n",
70  "main_t",
71  "main_pos",
72  NULL
73 };
74 
75 enum var_name {
76  VAR_IN_W, VAR_IW,
77  VAR_IN_H, VAR_IH,
78  VAR_OUT_W, VAR_OW,
79  VAR_OUT_H, VAR_OH,
80  VAR_A,
81  VAR_SAR,
82  VAR_DAR,
83  VAR_HSUB,
84  VAR_VSUB,
85  VAR_OHSUB,
86  VAR_OVSUB,
87  VAR_N,
88  VAR_T,
89 #if FF_API_FRAME_PKT
90  VAR_POS,
91 #endif
92  VAR_S2R_MAIN_W,
93  VAR_S2R_MAIN_H,
94  VAR_S2R_MAIN_A,
95  VAR_S2R_MAIN_SAR,
96  VAR_S2R_MAIN_DAR, VAR_S2R_MDAR,
97  VAR_S2R_MAIN_HSUB,
98  VAR_S2R_MAIN_VSUB,
99  VAR_S2R_MAIN_N,
100  VAR_S2R_MAIN_T,
101  VAR_S2R_MAIN_POS,
102  VARS_NB
103 };
104 
105 enum EvalMode {
106  EVAL_MODE_INIT,
107  EVAL_MODE_FRAME,
108  EVAL_MODE_NB
109 };
110 
111 typedef struct ScaleContext {
112  const AVClass *class;
113  struct SwsContext *sws; ///< software scaler context
114  struct SwsContext *isws[2]; ///< software scaler context for interlaced material
115  // context used for forwarding options to sws
116  struct SwsContext *sws_opts;
117 
118  /**
119  * New dimensions. Special values are:
120  * 0 = original width/height
121  * -1 = keep original aspect
122  * -N = try to keep aspect but make sure it is divisible by N
123  */
124  int w, h;
125  char *size_str;
126  double param[2]; // sws params
127 
128  int hsub, vsub; ///< chroma subsampling
129  int slice_y; ///< top of current output slice
130  int input_is_pal; ///< set to 1 if the input format is paletted
131  int output_is_pal; ///< set to 1 if the output format is paletted
132  int interlaced;
133 
134  char *w_expr; ///< width expression string
135  char *h_expr; ///< height expression string
136  AVExpr *w_pexpr;
137  AVExpr *h_pexpr;
138  double var_values[VARS_NB];
139 
140  char *flags_str;
141 
142  int in_color_matrix;
143  int out_color_matrix;
144 
145  int in_range;
146  int in_frame_range;
147  int out_range;
148 
149  int out_h_chr_pos;
150  int out_v_chr_pos;
151  int in_h_chr_pos;
152  int in_v_chr_pos;
153 
154  int force_original_aspect_ratio;
155  int force_divisible_by;
156 
157  int eval_mode; ///< expression evaluation mode
158 
159 } ScaleContext;
160 
161 const AVFilter ff_vf_scale2ref;
162 
163 static int config_props(AVFilterLink *outlink);
164 
165 static int check_exprs(AVFilterContext *ctx)
166 {
167  ScaleContext *scale = ctx->priv;
168  unsigned vars_w[VARS_NB] = { 0 }, vars_h[VARS_NB] = { 0 };
169 
170  if (!scale->w_pexpr && !scale->h_pexpr)
171  return AVERROR(EINVAL);
172 
173  if (scale->w_pexpr)
174  av_expr_count_vars(scale->w_pexpr, vars_w, VARS_NB);
175  if (scale->h_pexpr)
176  av_expr_count_vars(scale->h_pexpr, vars_h, VARS_NB);
177 
178  if (vars_w[VAR_OUT_W] || vars_w[VAR_OW]) {
179  av_log(ctx, AV_LOG_ERROR, "Width expression cannot be self-referencing: '%s'.\n", scale->w_expr);
180  return AVERROR(EINVAL);
181  }
182 
183  if (vars_h[VAR_OUT_H] || vars_h[VAR_OH]) {
184  av_log(ctx, AV_LOG_ERROR, "Height expression cannot be self-referencing: '%s'.\n", scale->h_expr);
185  return AVERROR(EINVAL);
186  }
187 
188  if ((vars_w[VAR_OUT_H] || vars_w[VAR_OH]) &&
189  (vars_h[VAR_OUT_W] || vars_h[VAR_OW])) {
190  av_log(ctx, AV_LOG_WARNING, "Circular references detected for width '%s' and height '%s' - possibly invalid.\n", scale->w_expr, scale->h_expr);
191  }
192 
193  if (ctx->filter != &ff_vf_scale2ref &&
194  (vars_w[VAR_S2R_MAIN_W] || vars_h[VAR_S2R_MAIN_W] ||
195  vars_w[VAR_S2R_MAIN_H] || vars_h[VAR_S2R_MAIN_H] ||
196  vars_w[VAR_S2R_MAIN_A] || vars_h[VAR_S2R_MAIN_A] ||
197  vars_w[VAR_S2R_MAIN_SAR] || vars_h[VAR_S2R_MAIN_SAR] ||
198  vars_w[VAR_S2R_MAIN_DAR] || vars_h[VAR_S2R_MAIN_DAR] ||
199  vars_w[VAR_S2R_MDAR] || vars_h[VAR_S2R_MDAR] ||
200  vars_w[VAR_S2R_MAIN_HSUB] || vars_h[VAR_S2R_MAIN_HSUB] ||
201  vars_w[VAR_S2R_MAIN_VSUB] || vars_h[VAR_S2R_MAIN_VSUB] ||
202  vars_w[VAR_S2R_MAIN_N] || vars_h[VAR_S2R_MAIN_N] ||
203  vars_w[VAR_S2R_MAIN_T] || vars_h[VAR_S2R_MAIN_T] ||
204  vars_w[VAR_S2R_MAIN_POS] || vars_h[VAR_S2R_MAIN_POS]) ) {
205  av_log(ctx, AV_LOG_ERROR, "Expressions with scale2ref variables are not valid in scale filter.\n");
206  return AVERROR(EINVAL);
207  }
208 
209  if (scale->eval_mode == EVAL_MODE_INIT &&
210  (vars_w[VAR_N] || vars_h[VAR_N] ||
211  vars_w[VAR_T] || vars_h[VAR_T] ||
212 #if FF_API_FRAME_PKT
213  vars_w[VAR_POS] || vars_h[VAR_POS] ||
214 #endif
215  vars_w[VAR_S2R_MAIN_N] || vars_h[VAR_S2R_MAIN_N] ||
216  vars_w[VAR_S2R_MAIN_T] || vars_h[VAR_S2R_MAIN_T] ||
217  vars_w[VAR_S2R_MAIN_POS] || vars_h[VAR_S2R_MAIN_POS]) ) {
218  av_log(ctx, AV_LOG_ERROR, "Expressions with frame variables 'n', 't', 'pos' are not valid in init eval_mode.\n");
219  return AVERROR(EINVAL);
220  }
221 
222  return 0;
223 }
224 
225 static int scale_parse_expr(AVFilterContext *ctx, char *str_expr, AVExpr **pexpr_ptr, const char *var, const char *args)
226 {
227  ScaleContext *scale = ctx->priv;
228  int ret, is_inited = 0;
229  char *old_str_expr = NULL;
230  AVExpr *old_pexpr = NULL;
231 
232  if (str_expr) {
233  old_str_expr = av_strdup(str_expr);
234  if (!old_str_expr)
235  return AVERROR(ENOMEM);
236  av_opt_set(scale, var, args, 0);
237  }
238 
239  if (*pexpr_ptr) {
240  old_pexpr = *pexpr_ptr;
241  *pexpr_ptr = NULL;
242  is_inited = 1;
243  }
244 
245  ret = av_expr_parse(pexpr_ptr, args, var_names,
246  NULL, NULL, NULL, NULL, 0, ctx);
247  if (ret < 0) {
248  av_log(ctx, AV_LOG_ERROR, "Cannot parse expression for %s: '%s'\n", var, args);
249  goto revert;
250  }
251 
252  ret = check_exprs(ctx);
253  if (ret < 0)
254  goto revert;
255 
256  if (is_inited && (ret = config_props(ctx->outputs[0])) < 0)
257  goto revert;
258 
259  av_expr_free(old_pexpr);
260  old_pexpr = NULL;
261  av_freep(&old_str_expr);
262 
263  return 0;
264 
265 revert:
266  av_expr_free(*pexpr_ptr);
267  *pexpr_ptr = NULL;
268  if (old_str_expr) {
269  av_opt_set(scale, var, old_str_expr, 0);
270  av_free(old_str_expr);
271  }
272  if (old_pexpr)
273  *pexpr_ptr = old_pexpr;
274 
275  return ret;
276 }
277 
278 static av_cold int preinit(AVFilterContext *ctx)
279 {
280  ScaleContext *scale = ctx->priv;
281  int ret;
282 
283  scale->sws_opts = sws_alloc_context();
284  if (!scale->sws_opts)
285  return AVERROR(ENOMEM);
286 
287  // set threads=0, so we can later check whether the user modified it
288  ret = av_opt_set_int(scale->sws_opts, "threads", 0, 0);
289  if (ret < 0)
290  return ret;
291 
292  return 0;
293 }
294 
295 static av_cold int init(AVFilterContext *ctx)
296 {
297  ScaleContext *scale = ctx->priv;
298  int64_t threads;
299  int ret;
300 
301  if (scale->size_str && (scale->w_expr || scale->h_expr)) {
302  av_log(ctx, AV_LOG_ERROR,
303  "Size and width/height expressions cannot be set at the same time.\n");
304  return AVERROR(EINVAL);
305  }
306 
307  if (scale->w_expr && !scale->h_expr)
308  FFSWAP(char *, scale->w_expr, scale->size_str);
309 
310  if (scale->size_str) {
311  char buf[32];
312  if ((ret = av_parse_video_size(&scale->w, &scale->h, scale->size_str)) < 0) {
313  av_log(ctx, AV_LOG_ERROR,
314  "Invalid size '%s'\n", scale->size_str);
315  return ret;
316  }
317  snprintf(buf, sizeof(buf)-1, "%d", scale->w);
318  av_opt_set(scale, "w", buf, 0);
319  snprintf(buf, sizeof(buf)-1, "%d", scale->h);
320  av_opt_set(scale, "h", buf, 0);
321  }
322  if (!scale->w_expr)
323  av_opt_set(scale, "w", "iw", 0);
324  if (!scale->h_expr)
325  av_opt_set(scale, "h", "ih", 0);
326 
327  ret = scale_parse_expr(ctx, NULL, &scale->w_pexpr, "width", scale->w_expr);
328  if (ret < 0)
329  return ret;
330 
331  ret = scale_parse_expr(ctx, NULL, &scale->h_pexpr, "height", scale->h_expr);
332  if (ret < 0)
333  return ret;
334 
335  av_log(ctx, AV_LOG_VERBOSE, "w:%s h:%s flags:'%s' interl:%d\n",
336  scale->w_expr, scale->h_expr, (char *)av_x_if_null(scale->flags_str, ""), scale->interlaced);
337 
338  if (scale->flags_str && *scale->flags_str) {
339  ret = av_opt_set(scale->sws_opts, "sws_flags", scale->flags_str, 0);
340  if (ret < 0)
341  return ret;
342  }
343 
344  for (int i = 0; i < FF_ARRAY_ELEMS(scale->param); i++)
345  if (scale->param[i] != DBL_MAX) {
346  ret = av_opt_set_double(scale->sws_opts, i ? "param1" : "param0",
347  scale->param[i], 0);
348  if (ret < 0)
349  return ret;
350  }
351 
352  // use generic thread-count if the user did not set it explicitly
353  ret = av_opt_get_int(scale->sws_opts, "threads", 0, &threads);
354  if (ret < 0)
355  return ret;
356  if (!threads)
357  av_opt_set_int(scale->sws_opts, "threads", ff_filter_get_nb_threads(ctx), 0);
358 
359  scale->in_frame_range = AVCOL_RANGE_UNSPECIFIED;
360 
361  return 0;
362 }
363 
364 static av_cold void uninit(AVFilterContext *ctx)
365 {
366  ScaleContext *scale = ctx->priv;
367  av_expr_free(scale->w_pexpr);
368  av_expr_free(scale->h_pexpr);
369  scale->w_pexpr = scale->h_pexpr = NULL;
370  sws_freeContext(scale->sws_opts);
371  sws_freeContext(scale->sws);
372  sws_freeContext(scale->isws[0]);
373  sws_freeContext(scale->isws[1]);
374  scale->sws = NULL;
375 }
376 
377 static int query_formats(AVFilterContext *ctx)
378 {
379  AVFilterFormats *formats;
380  const AVPixFmtDescriptor *desc;
381  enum AVPixelFormat pix_fmt;
382  int ret;
383 
384  desc = NULL;
385  formats = NULL;
386  while ((desc = av_pix_fmt_desc_next(desc))) {
387  pix_fmt = av_pix_fmt_desc_get_id(desc);
388  if ((sws_isSupportedInput(pix_fmt) ||
389  sws_isSupportedEndiannessConversion(pix_fmt))
390  && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
391  return ret;
392  }
393  }
394  if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->outcfg.formats)) < 0)
395  return ret;
396 
397  desc = NULL;
398  formats = NULL;
399  while ((desc = av_pix_fmt_desc_next(desc))) {
400  pix_fmt = av_pix_fmt_desc_get_id(desc);
401  if ((sws_isSupportedOutput(pix_fmt) || pix_fmt == AV_PIX_FMT_PAL8 ||
402  sws_isSupportedEndiannessConversion(pix_fmt))
403  && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
404  return ret;
405  }
406  }
407  if ((ret = ff_formats_ref(formats, &ctx->outputs[0]->incfg.formats)) < 0)
408  return ret;
409 
410  return 0;
411 }
412 
413 static int scale_eval_dimensions(AVFilterContext *ctx)
414 {
415  ScaleContext *scale = ctx->priv;
416  const char scale2ref = ctx->filter == &ff_vf_scale2ref;
417  const AVFilterLink *inlink = scale2ref ? ctx->inputs[1] : ctx->inputs[0];
418  const AVFilterLink *outlink = ctx->outputs[0];
419  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
420  const AVPixFmtDescriptor *out_desc = av_pix_fmt_desc_get(outlink->format);
421  char *expr;
422  int eval_w, eval_h;
423  int ret;
424  double res;
425  const AVPixFmtDescriptor *main_desc;
426  const AVFilterLink *main_link;
427 
428  if (scale2ref) {
429  main_link = ctx->inputs[0];
430  main_desc = av_pix_fmt_desc_get(main_link->format);
431  }
432 
433  scale->var_values[VAR_IN_W] = scale->var_values[VAR_IW] = inlink->w;
434  scale->var_values[VAR_IN_H] = scale->var_values[VAR_IH] = inlink->h;
435  scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = NAN;
436  scale->var_values[VAR_OUT_H] = scale->var_values[VAR_OH] = NAN;
437  scale->var_values[VAR_A] = (double) inlink->w / inlink->h;
438  scale->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ?
439  (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
440  scale->var_values[VAR_DAR] = scale->var_values[VAR_A] * scale->var_values[VAR_SAR];
441  scale->var_values[VAR_HSUB] = 1 << desc->log2_chroma_w;
442  scale->var_values[VAR_VSUB] = 1 << desc->log2_chroma_h;
443  scale->var_values[VAR_OHSUB] = 1 << out_desc->log2_chroma_w;
444  scale->var_values[VAR_OVSUB] = 1 << out_desc->log2_chroma_h;
445 
446  if (scale2ref) {
447  scale->var_values[VAR_S2R_MAIN_W] = main_link->w;
448  scale->var_values[VAR_S2R_MAIN_H] = main_link->h;
449  scale->var_values[VAR_S2R_MAIN_A] = (double) main_link->w / main_link->h;
450  scale->var_values[VAR_S2R_MAIN_SAR] = main_link->sample_aspect_ratio.num ?
451  (double) main_link->sample_aspect_ratio.num / main_link->sample_aspect_ratio.den : 1;
452  scale->var_values[VAR_S2R_MAIN_DAR] = scale->var_values[VAR_S2R_MDAR] =
453  scale->var_values[VAR_S2R_MAIN_A] * scale->var_values[VAR_S2R_MAIN_SAR];
454  scale->var_values[VAR_S2R_MAIN_HSUB] = 1 << main_desc->log2_chroma_w;
455  scale->var_values[VAR_S2R_MAIN_VSUB] = 1 << main_desc->log2_chroma_h;
456  }
457 
458  res = av_expr_eval(scale->w_pexpr, scale->var_values, NULL);
459  eval_w = scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = (int) res == 0 ? inlink->w : (int) res;
460 
461  res = av_expr_eval(scale->h_pexpr, scale->var_values, NULL);
462  if (isnan(res)) {
463  expr = scale->h_expr;
464  ret = AVERROR(EINVAL);
465  goto fail;
466  }
467  eval_h = scale->var_values[VAR_OUT_H] = scale->var_values[VAR_OH] = (int) res == 0 ? inlink->h : (int) res;
468 
469  res = av_expr_eval(scale->w_pexpr, scale->var_values, NULL);
470  if (isnan(res)) {
471  expr = scale->w_expr;
472  ret = AVERROR(EINVAL);
473  goto fail;
474  }
475  eval_w = scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = (int) res == 0 ? inlink->w : (int) res;
476 
477  scale->w = eval_w;
478  scale->h = eval_h;
479 
480  return 0;
481 
482 fail:
483  av_log(ctx, AV_LOG_ERROR,
484  "Error when evaluating the expression '%s'.\n", expr);
485  return ret;
486 }
487 
488 static int config_props(AVFilterLink *outlink)
489 {
490  AVFilterContext *ctx = outlink->src;
491  AVFilterLink *inlink0 = outlink->src->inputs[0];
492  AVFilterLink *inlink = ctx->filter == &ff_vf_scale2ref ?
493  outlink->src->inputs[1] :
494  outlink->src->inputs[0];
495  enum AVPixelFormat outfmt = outlink->format;
496  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
497  const AVPixFmtDescriptor *outdesc = av_pix_fmt_desc_get(outfmt);
498  ScaleContext *scale = ctx->priv;
499  uint8_t *flags_val = NULL;
500  int ret;
501 
502  if ((ret = scale_eval_dimensions(ctx)) < 0)
503  goto fail;
504 
505  outlink->w = scale->w;
506  outlink->h = scale->h;
507 
508  ff_scale_adjust_dimensions(inlink, &outlink->w, &outlink->h,
509  scale->force_original_aspect_ratio,
510  scale->force_divisible_by);
511 
512  if (outlink->w > INT_MAX ||
513  outlink->h > INT_MAX ||
514  (outlink->h * inlink->w) > INT_MAX ||
515  (outlink->w * inlink->h) > INT_MAX)
516  av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
517 
518  /* TODO: make algorithm configurable */
519 
520  scale->input_is_pal = desc->flags & AV_PIX_FMT_FLAG_PAL;
521  if (outfmt == AV_PIX_FMT_PAL8) outfmt = AV_PIX_FMT_BGR8;
522  scale->output_is_pal = av_pix_fmt_desc_get(outfmt)->flags & AV_PIX_FMT_FLAG_PAL;
523 
524  if (scale->sws)
525  sws_freeContext(scale->sws);
526  if (scale->isws[0])
527  sws_freeContext(scale->isws[0]);
528  if (scale->isws[1])
529  sws_freeContext(scale->isws[1]);
530  scale->isws[0] = scale->isws[1] = scale->sws = NULL;
531  if (inlink0->w == outlink->w &&
532  inlink0->h == outlink->h &&
533  scale->out_color_matrix == AVCOL_SPC_UNSPECIFIED &&
534  scale->in_range == scale->out_range &&
535  inlink0->format == outlink->format)
536  ;
537  else {
538  struct SwsContext **swscs[3] = {&scale->sws, &scale->isws[0], &scale->isws[1]};
539  int i;
540 
541  for (i = 0; i < 3; i++) {
542  int in_v_chr_pos = scale->in_v_chr_pos, out_v_chr_pos = scale->out_v_chr_pos;
543  struct SwsContext *const s = sws_alloc_context();
544  if (!s)
545  return AVERROR(ENOMEM);
546  *swscs[i] = s;
547 
548  ret = av_opt_copy(s, scale->sws_opts);
549  if (ret < 0)
550  return ret;
551 
552  av_opt_set_int(s, "srcw", inlink0 ->w, 0);
553  av_opt_set_int(s, "srch", inlink0 ->h >> !!i, 0);
554  av_opt_set_int(s, "src_format", inlink0->format, 0);
555  av_opt_set_int(s, "dstw", outlink->w, 0);
556  av_opt_set_int(s, "dsth", outlink->h >> !!i, 0);
557  av_opt_set_int(s, "dst_format", outfmt, 0);
558  if (scale->in_range != AVCOL_RANGE_UNSPECIFIED)
559  av_opt_set_int(s, "src_range",
560  scale->in_range == AVCOL_RANGE_JPEG, 0);
561  else if (scale->in_frame_range != AVCOL_RANGE_UNSPECIFIED)
562  av_opt_set_int(s, "src_range",
563  scale->in_frame_range == AVCOL_RANGE_JPEG, 0);
564  if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
565  av_opt_set_int(s, "dst_range",
566  scale->out_range == AVCOL_RANGE_JPEG, 0);
567 
568  /* Override chroma location default settings to have the correct
569  * chroma positions. MPEG chroma positions are used by convention.
570  * Note that this works for both MPEG-1/JPEG and MPEG-2/4 chroma
571  * locations, since they share a vertical alignment */
572  if (desc->log2_chroma_h == 1 && scale->in_v_chr_pos == -513) {
573  in_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
574  }
575 
576  if (outdesc->log2_chroma_h == 1 && scale->out_v_chr_pos == -513) {
577  out_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
578  }
579 
580  av_opt_set_int(s, "src_h_chr_pos", scale->in_h_chr_pos, 0);
581  av_opt_set_int(s, "src_v_chr_pos", in_v_chr_pos, 0);
582  av_opt_set_int(s, "dst_h_chr_pos", scale->out_h_chr_pos, 0);
583  av_opt_set_int(s, "dst_v_chr_pos", out_v_chr_pos, 0);
584 
585  if ((ret = sws_init_context(s, NULL, NULL)) < 0)
586  return ret;
587  if (!scale->interlaced)
588  break;
589  }
590  }
591 
592  if (inlink0->sample_aspect_ratio.num){
593  outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h * inlink0->w, outlink->w * inlink0->h}, inlink0->sample_aspect_ratio);
594  } else
595  outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
596 
597  if (scale->sws)
598  av_opt_get(scale->sws, "sws_flags", 0, &flags_val);
599 
600  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:%s\n",
601  inlink ->w, inlink ->h, av_get_pix_fmt_name( inlink->format),
602  inlink->sample_aspect_ratio.num, inlink->sample_aspect_ratio.den,
603  outlink->w, outlink->h, av_get_pix_fmt_name(outlink->format),
604  outlink->sample_aspect_ratio.num, outlink->sample_aspect_ratio.den,
605  flags_val);
606  av_freep(&flags_val);
607 
608  return 0;
609 
610 fail:
611  return ret;
612 }
613 
614 static int config_props_ref(AVFilterLink *outlink)
615 {
616  AVFilterLink *inlink = outlink->src->inputs[1];
617 
618  outlink->w = inlink->w;
619  outlink->h = inlink->h;
620  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
621  outlink->time_base = inlink->time_base;
622  outlink->frame_rate = inlink->frame_rate;
623 
624  return 0;
625 }
626 
627 static int request_frame(AVFilterLink *outlink)
628 {
629  return ff_request_frame(outlink->src->inputs[0]);
630 }
631 
632 static int request_frame_ref(AVFilterLink *outlink)
633 {
634  return ff_request_frame(outlink->src->inputs[1]);
635 }
636 
637 static void frame_offset(AVFrame *frame, int dir, int is_pal)
638 {
639  for (int i = 0; i < 4 && frame->data[i]; i++) {
640  if (i == 1 && is_pal)
641  break;
642  frame->data[i] += frame->linesize[i] * dir;
643  }
644 }
645 
646 static int scale_field(ScaleContext *scale, AVFrame *dst, AVFrame *src,
647  int field)
648 {
649  int orig_h_src = src->height;
650  int orig_h_dst = dst->height;
651  int ret;
652 
653  // offset the data pointers for the bottom field
654  if (field) {
655  frame_offset(src, 1, scale->input_is_pal);
656  frame_offset(dst, 1, scale->output_is_pal);
657  }
658 
659  // take every second line
660  for (int i = 0; i < 4; i++) {
661  src->linesize[i] *= 2;
662  dst->linesize[i] *= 2;
663  }
664  src->height /= 2;
665  dst->height /= 2;
666 
667  ret = sws_scale_frame(scale->isws[field], dst, src);
668  if (ret < 0)
669  return ret;
670 
671  // undo the changes we made above
672  for (int i = 0; i < 4; i++) {
673  src->linesize[i] /= 2;
674  dst->linesize[i] /= 2;
675  }
676  src->height = orig_h_src;
677  dst->height = orig_h_dst;
678 
679  if (field) {
680  frame_offset(src, -1, scale->input_is_pal);
681  frame_offset(dst, -1, scale->output_is_pal);
682  }
683 
684  return 0;
685 }
686 
687 static int scale_frame(AVFilterLink *link, AVFrame *in, AVFrame **frame_out)
688 {
689  AVFilterContext *ctx = link->dst;
690  ScaleContext *scale = ctx->priv;
691  AVFilterLink *outlink = ctx->outputs[0];
692  AVFrame *out;
693  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);
694  char buf[32];
695  int ret;
696  int in_range;
697  int frame_changed;
698 
699  *frame_out = NULL;
700  if (in->colorspace == AVCOL_SPC_YCGCO)
701  av_log(link->dst, AV_LOG_WARNING, "Detected unsupported YCgCo colorspace.\n");
702 
703  frame_changed = in->width != link->w ||
704  in->height != link->h ||
705  in->format != link->format ||
706  in->sample_aspect_ratio.den != link->sample_aspect_ratio.den ||
707  in->sample_aspect_ratio.num != link->sample_aspect_ratio.num;
708 
709  if (in->color_range != AVCOL_RANGE_UNSPECIFIED &&
710  scale->in_range == AVCOL_RANGE_UNSPECIFIED &&
711  in->color_range != scale->in_frame_range) {
712  scale->in_frame_range = in->color_range;
713  frame_changed = 1;
714  }
715 
716  if (scale->eval_mode == EVAL_MODE_FRAME || frame_changed) {
717  unsigned vars_w[VARS_NB] = { 0 }, vars_h[VARS_NB] = { 0 };
718 
719  av_expr_count_vars(scale->w_pexpr, vars_w, VARS_NB);
720  av_expr_count_vars(scale->h_pexpr, vars_h, VARS_NB);
721 
722  if (scale->eval_mode == EVAL_MODE_FRAME &&
723  !frame_changed &&
724  ctx->filter != &ff_vf_scale2ref &&
725  !(vars_w[VAR_N] || vars_w[VAR_T]
726 #if FF_API_FRAME_PKT
727  || vars_w[VAR_POS]
728 #endif
729  ) &&
730  !(vars_h[VAR_N] || vars_h[VAR_T]
731 #if FF_API_FRAME_PKT
732  || vars_h[VAR_POS]
733 #endif
734  ) &&
735  scale->w && scale->h)
736  goto scale;
737 
738  if (scale->eval_mode == EVAL_MODE_INIT) {
739  snprintf(buf, sizeof(buf) - 1, "%d", scale->w);
740  av_opt_set(scale, "w", buf, 0);
741  snprintf(buf, sizeof(buf) - 1, "%d", scale->h);
742  av_opt_set(scale, "h", buf, 0);
743 
744  ret = scale_parse_expr(ctx, NULL, &scale->w_pexpr, "width", scale->w_expr);
745  if (ret < 0)
746  return ret;
747 
748  ret = scale_parse_expr(ctx, NULL, &scale->h_pexpr, "height", scale->h_expr);
749  if (ret < 0)
750  return ret;
751  }
752 
753  if (ctx->filter == &ff_vf_scale2ref) {
754  scale->var_values[VAR_S2R_MAIN_N] = link->frame_count_out;
755  scale->var_values[VAR_S2R_MAIN_T] = TS2T(in->pts, link->time_base);
756 #if FF_API_FRAME_PKT
757 FF_DISABLE_DEPRECATION_WARNINGS
758  scale->var_values[VAR_S2R_MAIN_POS] = in->pkt_pos == -1 ? NAN : in->pkt_pos;
759 FF_ENABLE_DEPRECATION_WARNINGS
760 #endif
761  } else {
762  scale->var_values[VAR_N] = link->frame_count_out;
763  scale->var_values[VAR_T] = TS2T(in->pts, link->time_base);
764 #if FF_API_FRAME_PKT
765 FF_DISABLE_DEPRECATION_WARNINGS
766  scale->var_values[VAR_POS] = in->pkt_pos == -1 ? NAN : in->pkt_pos;
767 FF_ENABLE_DEPRECATION_WARNINGS
768 #endif
769  }
770 
771  link->dst->inputs[0]->format = in->format;
772  link->dst->inputs[0]->w = in->width;
773  link->dst->inputs[0]->h = in->height;
774 
775  link->dst->inputs[0]->sample_aspect_ratio.den = in->sample_aspect_ratio.den;
776  link->dst->inputs[0]->sample_aspect_ratio.num = in->sample_aspect_ratio.num;
777 
778  if ((ret = config_props(outlink)) < 0)
779  return ret;
780  }
781 
782 scale:
783  if (!scale->sws) {
784  *frame_out = in;
785  return 0;
786  }
787 
788  scale->hsub = desc->log2_chroma_w;
789  scale->vsub = desc->log2_chroma_h;
790 
791  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
792  if (!out) {
793  av_frame_free(&in);
794  return AVERROR(ENOMEM);
795  }
796  *frame_out = out;
797 
798  av_frame_copy_props(out, in);
799  out->width = outlink->w;
800  out->height = outlink->h;
801 
802  if (scale->output_is_pal)
803  avpriv_set_systematic_pal2((uint32_t*)out->data[1], outlink->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : outlink->format);
804 
805  in_range = in->color_range;
806 
807  if ( scale->in_color_matrix != AVCOL_SPC_UNSPECIFIED
808  || scale->out_color_matrix != AVCOL_SPC_UNSPECIFIED
809  || scale-> in_range != AVCOL_RANGE_UNSPECIFIED
810  || in_range != AVCOL_RANGE_UNSPECIFIED
811  || scale->out_range != AVCOL_RANGE_UNSPECIFIED) {
812  int in_full, out_full, brightness, contrast, saturation;
813  const int *inv_table, *table;
814 
815  sws_getColorspaceDetails(scale->sws, (int **)&inv_table, &in_full,
816  (int **)&table, &out_full,
817  &brightness, &contrast, &saturation);
818 
819  if (scale->in_color_matrix == -1 /* auto */)
820  inv_table = sws_getCoefficients(in->colorspace);
821  else if (scale->in_color_matrix != AVCOL_SPC_UNSPECIFIED)
822  inv_table = sws_getCoefficients(scale->in_color_matrix);
823  if (scale->out_color_matrix != AVCOL_SPC_UNSPECIFIED)
824  table = sws_getCoefficients(scale->out_color_matrix);
825  else if (scale->in_color_matrix != AVCOL_SPC_UNSPECIFIED)
826  table = inv_table;
827 
828  if (scale-> in_range != AVCOL_RANGE_UNSPECIFIED)
829  in_full = (scale-> in_range == AVCOL_RANGE_JPEG);
830  else if (in_range != AVCOL_RANGE_UNSPECIFIED)
831  in_full = (in_range == AVCOL_RANGE_JPEG);
832  if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
833  out_full = (scale->out_range == AVCOL_RANGE_JPEG);
834 
835  sws_setColorspaceDetails(scale->sws, inv_table, in_full,
836  table, out_full,
837  brightness, contrast, saturation);
838  if (scale->isws[0])
839  sws_setColorspaceDetails(scale->isws[0], inv_table, in_full,
840  table, out_full,
841  brightness, contrast, saturation);
842  if (scale->isws[1])
843  sws_setColorspaceDetails(scale->isws[1], inv_table, in_full,
844  table, out_full,
845  brightness, contrast, saturation);
846 
847  out->color_range = out_full ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
848  if (scale->out_color_matrix != AVCOL_SPC_UNSPECIFIED)
849  out->colorspace = scale->out_color_matrix;
850  }
851 
852  // Sanity checks:
853  // 1. If the output is RGB, set the matrix coefficients to RGB.
854  // 2. If the output is not RGB and we've got the RGB/XYZ (identity)
855  // matrix configured, unset the matrix.
856  // In theory these should be in swscale itself as the AVFrame
857  // based API gets in, so that not every swscale API user has
858  // to go through duplicating such sanity checks.
859  if (av_pix_fmt_desc_get(out->format)->flags & AV_PIX_FMT_FLAG_RGB)
860  out->colorspace = AVCOL_SPC_RGB;
861  else if (out->colorspace == AVCOL_SPC_RGB)
862  out->colorspace = AVCOL_SPC_UNSPECIFIED;
863 
864  av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,
865  (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
866  (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
867  INT_MAX);
868 
869  if (scale->interlaced>0 || (scale->interlaced<0 &&
870  (in->flags & AV_FRAME_FLAG_INTERLACED))) {
871  ret = scale_field(scale, out, in, 0);
872  if (ret >= 0)
873  ret = scale_field(scale, out, in, 1);
874  } else {
875  ret = sws_scale_frame(scale->sws, out, in);
876  }
877 
878  av_frame_free(&in);
879  if (ret < 0)
880  av_frame_free(frame_out);
881  return ret;
882 }
883 
884 static int filter_frame(AVFilterLink *link, AVFrame *in)
885 {
886  AVFilterContext *ctx = link->dst;
887  AVFilterLink *outlink = ctx->outputs[0];
888  AVFrame *out;
889  int ret;
890 
891  ret = scale_frame(link, in, &out);
892  if (out)
893  return ff_filter_frame(outlink, out);
894 
895  return ret;
896 }
897 
898 static int filter_frame_ref(AVFilterLink *link, AVFrame *in)
899 {
900  ScaleContext *scale = link->dst->priv;
901  AVFilterLink *outlink = link->dst->outputs[1];
902  int frame_changed;
903 
904  frame_changed = in->width != link->w ||
905  in->height != link->h ||
906  in->format != link->format ||
907  in->sample_aspect_ratio.den != link->sample_aspect_ratio.den ||
908  in->sample_aspect_ratio.num != link->sample_aspect_ratio.num;
909 
910  if (frame_changed) {
911  link->format = in->format;
912  link->w = in->width;
913  link->h = in->height;
914  link->sample_aspect_ratio.num = in->sample_aspect_ratio.num;
915  link->sample_aspect_ratio.den = in->sample_aspect_ratio.den;
916 
917  config_props_ref(outlink);
918  }
919 
920  if (scale->eval_mode == EVAL_MODE_FRAME) {
921  scale->var_values[VAR_N] = link->frame_count_out;
922  scale->var_values[VAR_T] = TS2T(in->pts, link->time_base);
923 #if FF_API_FRAME_PKT
924 FF_DISABLE_DEPRECATION_WARNINGS
925  scale->var_values[VAR_POS] = in->pkt_pos == -1 ? NAN : in->pkt_pos;
926 FF_ENABLE_DEPRECATION_WARNINGS
927 #endif
928  }
929 
930  return ff_filter_frame(outlink, in);
931 }
932 
933 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
934  char *res, int res_len, int flags)
935 {
936  ScaleContext *scale = ctx->priv;
937  char *str_expr;
938  AVExpr **pexpr_ptr;
939  int ret, w, h;
940 
941  w = !strcmp(cmd, "width") || !strcmp(cmd, "w");
942  h = !strcmp(cmd, "height") || !strcmp(cmd, "h");
943 
944  if (w || h) {
945  str_expr = w ? scale->w_expr : scale->h_expr;
946  pexpr_ptr = w ? &scale->w_pexpr : &scale->h_pexpr;
947 
948  ret = scale_parse_expr(ctx, str_expr, pexpr_ptr, cmd, args);
949  } else
950  ret = AVERROR(ENOSYS);
951 
952  if (ret < 0)
953  av_log(ctx, AV_LOG_ERROR, "Failed to process command. Continuing with existing parameters.\n");
954 
955  return ret;
956 }
957 
958 static const AVClass *child_class_iterate(void **iter)
959 {
960  const AVClass *c = *iter ? NULL : sws_get_class();
961  *iter = (void*)(uintptr_t)c;
962  return c;
963 }
964 
965 static void *child_next(void *obj, void *prev)
966 {
967  ScaleContext *s = obj;
968  if (!prev)
969  return s->sws_opts;
970  return NULL;
971 }
972 
973 #define OFFSET(x) offsetof(ScaleContext, x)
974 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
975 #define TFLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
976 
977 static const AVOption scale_options[] = {
978  { "w", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = TFLAGS },
979  { "width", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = TFLAGS },
980  { "h", "Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = TFLAGS },
981  { "height","Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = TFLAGS },
982  { "flags", "Flags to pass to libswscale", OFFSET(flags_str), AV_OPT_TYPE_STRING, { .str = "" }, .flags = FLAGS },
983  { "interl", "set interlacing", OFFSET(interlaced), AV_OPT_TYPE_BOOL, {.i64 = 0 }, -1, 1, FLAGS },
984  { "size", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },
985  { "s", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },
986  { "in_color_matrix", "set input YCbCr type", OFFSET(in_color_matrix), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, AVCOL_SPC_NB-1, .flags = FLAGS, "color" },
987  { "out_color_matrix", "set output YCbCr type", OFFSET(out_color_matrix), AV_OPT_TYPE_INT, { .i64 = AVCOL_SPC_UNSPECIFIED }, 0, AVCOL_SPC_NB-1, .flags = FLAGS, "color"},
988  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, 0, 0, FLAGS, "color" },
989  { "bt601", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_BT470BG }, 0, 0, FLAGS, "color" },
990  { "bt470", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_BT470BG }, 0, 0, FLAGS, "color" },
991  { "smpte170m", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_BT470BG }, 0, 0, FLAGS, "color" },
992  { "bt709", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_BT709 }, 0, 0, FLAGS, "color" },
993  { "fcc", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_FCC }, 0, 0, FLAGS, "color" },
994  { "smpte240m", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_SMPTE240M }, 0, 0, FLAGS, "color" },
995  { "bt2020", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVCOL_SPC_BT2020_NCL }, 0, 0, FLAGS, "color" },
996  { "in_range", "set input color range", OFFSET( in_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },
997  { "out_range", "set output color range", OFFSET(out_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },
998  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },
999  { "unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },
1000  { "full", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
1001  { "limited",NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
1002  { "jpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
1003  { "mpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
1004  { "tv", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
1005  { "pc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
1006  { "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 },
1007  { "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 },
1008  { "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 },
1009  { "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 },
1010  { "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" },
1011  { "disable", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },
1012  { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },
1013  { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },
1014  { "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 },
1015  { "param0", "Scaler param 0", OFFSET(param[0]), AV_OPT_TYPE_DOUBLE, { .dbl = DBL_MAX }, -DBL_MAX, DBL_MAX, FLAGS },
1016  { "param1", "Scaler param 1", OFFSET(param[1]), AV_OPT_TYPE_DOUBLE, { .dbl = DBL_MAX }, -DBL_MAX, DBL_MAX, FLAGS },
1017  { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
1018  { "init", "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT}, .flags = FLAGS, .unit = "eval" },
1019  { "frame", "eval expressions during initialization and per-frame", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
1020  { NULL }
1021 };
1022 
1023 static const AVClass scale_class = {
1024  .class_name = "scale(2ref)",
1025  .item_name = av_default_item_name,
1026  .option = scale_options,
1027  .version = LIBAVUTIL_VERSION_INT,
1028  .category = AV_CLASS_CATEGORY_FILTER,
1029  .child_class_iterate = child_class_iterate,
1030  .child_next = child_next,
1031 };
1032 
1033 static const AVFilterPad avfilter_vf_scale_inputs[] = {
1034  {
1035  .name = "default",
1036  .type = AVMEDIA_TYPE_VIDEO,
1037  .filter_frame = filter_frame,
1038  },
1039 };
1040 
1041 static const AVFilterPad avfilter_vf_scale_outputs[] = {
1042  {
1043  .name = "default",
1044  .type = AVMEDIA_TYPE_VIDEO,
1045  .config_props = config_props,
1046  },
1047 };
1048 
1049 const AVFilter ff_vf_scale = {
1050  .name = "scale",
1051  .description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format."),
1052  .preinit = preinit,
1053  .init = init,
1054  .uninit = uninit,
1055  .priv_size = sizeof(ScaleContext),
1056  .priv_class = &scale_class,
1057  FILTER_INPUTS(avfilter_vf_scale_inputs),
1058  FILTER_OUTPUTS(avfilter_vf_scale_outputs),
1059  FILTER_QUERY_FUNC(query_formats),
1060  .process_command = process_command,
1061 };
1062 
1063 static const AVFilterPad avfilter_vf_scale2ref_inputs[] = {
1064  {
1065  .name = "default",
1066  .type = AVMEDIA_TYPE_VIDEO,
1067  .filter_frame = filter_frame,
1068  },
1069  {
1070  .name = "ref",
1071  .type = AVMEDIA_TYPE_VIDEO,
1072  .filter_frame = filter_frame_ref,
1073  },
1074 };
1075 
1076 static const AVFilterPad avfilter_vf_scale2ref_outputs[] = {
1077  {
1078  .name = "default",
1079  .type = AVMEDIA_TYPE_VIDEO,
1080  .config_props = config_props,
1081  .request_frame= request_frame,
1082  },
1083  {
1084  .name = "ref",
1085  .type = AVMEDIA_TYPE_VIDEO,
1086  .config_props = config_props_ref,
1087  .request_frame= request_frame_ref,
1088  },
1089 };
1090 
1091 const AVFilter ff_vf_scale2ref = {
1092  .name = "scale2ref",
1093  .description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format to the given reference."),
1094  .preinit = preinit,
1095  .init = init,
1096  .uninit = uninit,
1097  .priv_size = sizeof(ScaleContext),
1098  .priv_class = &scale_class,
1099  FILTER_INPUTS(avfilter_vf_scale2ref_inputs),
1100  FILTER_OUTPUTS(avfilter_vf_scale2ref_outputs),
1101  FILTER_QUERY_FUNC(query_formats),
1102  .process_command = process_command,
1103 };
filter_frame_ref
static int filter_frame_ref(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:898
ScaleContext::param
double param[2]
Definition: vf_scale.c:126
VAR_S2R_MAIN_SAR
@ VAR_S2R_MAIN_SAR
Definition: vf_scale.c:95
formats
formats
Definition: signature.h:48
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:108
VAR_S2R_MAIN_A
@ VAR_S2R_MAIN_A
Definition: vf_scale.c:94
VAR_HSUB
@ VAR_HSUB
Definition: vf_scale.c:83
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
config_props_ref
static int config_props_ref(AVFilterLink *outlink)
Definition: vf_scale.c:614
SwsContext::saturation
int saturation
Definition: swscale_internal.h:454
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:656
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
TFLAGS
#define TFLAGS
Definition: vf_scale.c:975
ScaleContext::sws_opts
struct SwsContext * sws_opts
Definition: vf_scale.c:116
check_exprs
static int check_exprs(AVFilterContext *ctx)
Definition: vf_scale.c:165
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
ScaleContext::input_is_pal
int input_is_pal
set to 1 if the input format is paletted
Definition: vf_scale.c:130
out
FILE * out
Definition: movenc.c:54
sws_isSupportedOutput
#define sws_isSupportedOutput(x)
ScaleContext
Definition: vf_scale.c:111
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:978
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2964
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_scale.c:377
ScaleContext::force_divisible_by
int force_divisible_by
Definition: vf_scale.c:155
avfilter_vf_scale2ref_outputs
static const AVFilterPad avfilter_vf_scale2ref_outputs[]
Definition: vf_scale.c:1076
FLAGS
#define FLAGS
Definition: vf_scale.c:974
ScaleContext::flags_str
char * flags_str
Definition: vf_scale.c:140
inlink
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:667
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:452
AVFrame::width
int width
Definition: frame.h:412
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:673
VAR_A
@ VAR_A
Definition: vf_scale.c:80
request_frame_ref
static int request_frame_ref(AVFilterLink *outlink)
Definition: vf_scale.c:632
av_opt_set_double
int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
Definition: opt.c:629
AVOption
AVOption.
Definition: opt.h:251
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:616
scale_parse_expr
static int scale_parse_expr(AVFilterContext *ctx, char *str_expr, AVExpr **pexpr_ptr, const char *var, const char *args)
Definition: vf_scale.c:225
FILTER_QUERY_FUNC
#define FILTER_QUERY_FUNC(func)
Definition: internal.h:169
table
static const uint16_t table[]
Definition: prosumer.c:205
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: vf_scale.c:627
av_pix_fmt_desc_next
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2971
ff_request_frame
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:431
VAR_S2R_MAIN_HSUB
@ VAR_S2R_MAIN_HSUB
Definition: vf_scale.c:97
ScaleContext::var_values
double var_values[VARS_NB]
Definition: vf_scale.c:138
ScaleContext::out_range
int out_range
Definition: vf_scale.c:147
VAR_S2R_MDAR
@ VAR_S2R_MDAR
Definition: vf_scale.c:96
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:600
float.h
EVAL_MODE_FRAME
@ EVAL_MODE_FRAME
Definition: vf_scale.c:107
VAR_S2R_MAIN_H
@ VAR_S2R_MAIN_H
Definition: vf_scale.c:93
mathematics.h
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:170
ScaleContext::in_h_chr_pos
int in_h_chr_pos
Definition: vf_scale.c:151
VAR_OUT_H
@ VAR_OUT_H
Definition: vf_scale.c:79
video.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
av_expr_parse
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:685
VAR_S2R_MAIN_POS
@ VAR_S2R_MAIN_POS
Definition: vf_scale.c:101
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:605
VAR_DAR
@ VAR_DAR
Definition: vf_scale.c:82
avfilter_vf_scale_inputs
static const AVFilterPad avfilter_vf_scale_inputs[]
Definition: vf_scale.c:1033
fail
#define fail()
Definition: checkasm.h:142
VARS_NB
@ VARS_NB
Definition: vf_scale.c:102
frame_offset
static void frame_offset(AVFrame *frame, int dir, int is_pal)
Definition: vf_scale.c:637
ScaleContext::isws
struct SwsContext * isws[2]
software scaler context for interlaced material
Definition: vf_scale.c:114
ScaleContext::eval_mode
int eval_mode
expression evaluation mode
Definition: vf_scale.c:157
VAR_IN_H
@ VAR_IN_H
Definition: vf_scale.c:77
EVAL_MODE_NB
@ EVAL_MODE_NB
Definition: vf_scale.c:108
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
sws_get_class
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:97
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:487
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
av_expr_free
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:336
AVRational::num
int num
Numerator.
Definition: rational.h:59
OFFSET
#define OFFSET(x)
Definition: vf_scale.c:973
preinit
static av_cold int preinit(AVFilterContext *ctx)
Definition: vf_scale.c:278
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:47
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
TS2T
#define TS2T(ts, tb)
Definition: internal.h:255
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ScaleContext::sws
struct SwsContext * sws
software scaler context
Definition: vf_scale.c:113
s
#define s(width, name)
Definition: cbs_vp9.c:198
VAR_OH
@ VAR_OH
Definition: vf_scale.c:79
VAR_S2R_MAIN_W
@ VAR_S2R_MAIN_W
Definition: vf_scale.c:92
SwsContext::brightness
int brightness
Definition: swscale_internal.h:454
scale_frame
static int scale_frame(AVFilterLink *link, AVFrame *in, AVFrame **frame_out)
Definition: vf_scale.c:687
ScaleContext::slice_y
int slice_y
top of current output slice
Definition: vf_scale.c:129
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:227
av_expr_count_vars
int av_expr_count_vars(AVExpr *e, unsigned *counter, int size)
Track the presence of variables and their number of occurrences in a parsed expression.
Definition: eval.c:756
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:617
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_scale.c:295
VAR_OVSUB
@ VAR_OVSUB
Definition: vf_scale.c:86
var_name
var_name
Definition: noise_bsf.c:46
ctx
AVFormatContext * ctx
Definition: movenc.c:48
process_command
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_scale.c:933
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:766
AVExpr
Definition: eval.c:157
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
SwsContext::contrast
int contrast
Definition: swscale_internal.h:454
ScaleContext::w_pexpr
AVExpr * w_pexpr
Definition: vf_scale.c:136
avpriv_set_systematic_pal2
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:178
NAN
#define NAN
Definition: mathematics.h:115
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: internal.h:192
link
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
Definition: filter_design.txt:23
frame
static AVFrame * frame
Definition: demux_decode.c:54
ScaleContext::out_h_chr_pos
int out_h_chr_pos
Definition: vf_scale.c:149
scale_field
static int scale_field(ScaleContext *scale, AVFrame *dst, AVFrame *src, int field)
Definition: vf_scale.c:646
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
ScaleContext::out_v_chr_pos
int out_v_chr_pos
Definition: vf_scale.c:150
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:736
VAR_T
@ VAR_T
Definition: vf_scale.c:88
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
isnan
#define isnan(x)
Definition: libm.h:340
ScaleContext::in_range
int in_range
Definition: vf_scale.c:145
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:405
VAR_IN_W
@ VAR_IN_W
Definition: vf_scale.c:76
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
ff_add_format
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
Add fmt to the list of media formats contained in *avff.
Definition: formats.c:470
parseutils.h
sws_alloc_context
struct SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1180
VAR_POS
@ VAR_POS
Definition: noise_bsf.c:55
ScaleContext::h_pexpr
AVExpr * h_pexpr
Definition: vf_scale.c:137
double
double
Definition: af_crystalizer.c:131
AVCOL_SPC_YCGCO
@ AVCOL_SPC_YCGCO
used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
Definition: pixfmt.h:608
ScaleContext::in_frame_range
int in_frame_range
Definition: vf_scale.c:146
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:978
sws_setColorspaceDetails
int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation)
Definition: utils.c:1001
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
ff_vf_scale2ref
const AVFilter ff_vf_scale2ref
Definition: vf_scale.c:161
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:639
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ScaleContext::out_color_matrix
int out_color_matrix
Definition: vf_scale.c:143
av_opt_set_int
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:624
AV_CLASS_CATEGORY_FILTER
@ AV_CLASS_CATEGORY_FILTER
Definition: log.h:36
VAR_IW
@ VAR_IW
Definition: vf_scale.c:76
eval.h
VAR_IH
@ VAR_IH
Definition: vf_scale.c:77
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
AVClass::child_next
void *(* child_next)(void *obj, void *prev)
Return next AVOptions-enabled child or NULL.
Definition: log.h:131
child_class_iterate
static const AVClass * child_class_iterate(void **iter)
Definition: vf_scale.c:958
ScaleContext::w
int w
New dimensions.
Definition: vf_scale.c:124
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:467
AVFrame::pkt_pos
attribute_deprecated int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:687
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
scale_eval.h
FF_API_FRAME_PKT
#define FF_API_FRAME_PKT
Definition: version.h:117
ScaleContext::hsub
int hsub
Definition: vf_scale.c:128
VAR_OUT_W
@ VAR_OUT_W
Definition: vf_scale.c:78
av_pix_fmt_desc_get_id
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2983
filter_frame
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:884
av_parse_video_size
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
Definition: parseutils.c:150
sws_isSupportedInput
#define sws_isSupportedInput(x)
internal.h
AVCOL_SPC_SMPTE240M
@ AVCOL_SPC_SMPTE240M
derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
Definition: pixfmt.h:607
ScaleContext::vsub
int vsub
chroma subsampling
Definition: vf_scale.c:128
sws_scale_frame
int sws_scale_frame(struct SwsContext *c, AVFrame *dst, const AVFrame *src)
Scale source data from src and write the output to dst.
Definition: swscale.c:1183
config_props
static int config_props(AVFilterLink *outlink)
Definition: vf_scale.c:488
interlaced
uint8_t interlaced
Definition: mxfenc.c:2152
ScaleContext::output_is_pal
int output_is_pal
set to 1 if the output format is paletted
Definition: vf_scale.c:131
VAR_SAR
@ VAR_SAR
Definition: vf_scale.c:81
sws_isSupportedEndiannessConversion
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
Definition: utils.c:341
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:610
VAR_S2R_MAIN_N
@ VAR_S2R_MAIN_N
Definition: vf_scale.c:99
internal.h
ff_filter_get_nb_threads
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
Definition: avfilter.c:786
EvalMode
EvalMode
Definition: af_volume.h:39
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:53
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:602
ScaleContext::h_expr
char * h_expr
height expression string
Definition: vf_scale.c:135
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:636
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:656
avfilter_vf_scale_outputs
static const AVFilterPad avfilter_vf_scale_outputs[]
Definition: vf_scale.c:1041
AVFilter
Filter definition.
Definition: avfilter.h:166
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
ScaleContext::in_color_matrix
int in_color_matrix
Definition: vf_scale.c:142
child_next
static void * child_next(void *obj, void *prev)
Definition: vf_scale.c:965
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:447
sws_getColorspaceDetails
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation)
Definition: utils.c:1156
ff_scale_adjust_dimensions
int ff_scale_adjust_dimensions(AVFilterLink *inlink, int *ret_w, int *ret_h, int force_original_aspect_ratio, int force_divisible_by)
Transform evaluated width and height obtained from ff_scale_eval_dimensions into actual target width ...
Definition: scale_eval.c:113
sws_init_context
av_warn_unused_result int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
Definition: utils.c:2031
VAR_S2R_MAIN_T
@ VAR_S2R_MAIN_T
Definition: vf_scale.c:100
scale_eval_dimensions
static int scale_eval_dimensions(AVFilterContext *ctx)
Definition: vf_scale.c:413
var_names
static const char *const var_names[]
Definition: vf_scale.c:45
AVFrame::height
int height
Definition: frame.h:412
VAR_S2R_MAIN_DAR
@ VAR_S2R_MAIN_DAR
Definition: vf_scale.c:96
scale_options
static const AVOption scale_options[]
Definition: vf_scale.c:977
sws_freeContext
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2420
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVCOL_SPC_FCC
@ AVCOL_SPC_FCC
FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:604
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
avfilter.h
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_scale.c:364
ScaleContext::force_original_aspect_ratio
int force_original_aspect_ratio
Definition: vf_scale.c:154
avfilter_vf_scale2ref_inputs
static const AVFilterPad avfilter_vf_scale2ref_inputs[]
Definition: vf_scale.c:1063
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVFilterContext
An instance of a filter.
Definition: avfilter.h:397
VAR_OW
@ VAR_OW
Definition: vf_scale.c:78
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
desc
const char * desc
Definition: libsvtav1.c:83
VAR_VSUB
@ VAR_VSUB
Definition: vf_scale.c:84
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
sws_getCoefficients
const int * sws_getCoefficients(int colorspace)
Return a pointer to yuv<->rgb coefficients for the given colorspace suitable for sws_setColorspaceDet...
Definition: yuv2rgb.c:62
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
ScaleContext::interlaced
int interlaced
Definition: vf_scale.c:132
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1885
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
VAR_N
@ VAR_N
Definition: vf_scale.c:87
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: internal.h:193
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
scale_class
static const AVClass scale_class
Definition: vf_scale.c:1023
ScaleContext::w_expr
char * w_expr
width expression string
Definition: vf_scale.c:134
EVAL_MODE_INIT
@ EVAL_MODE_INIT
Definition: vf_scale.c:106
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:837
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2038
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
VAR_OHSUB
@ VAR_OHSUB
Definition: vf_scale.c:85
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:601
int
int
Definition: ffmpeg_filter.c:372
SwsContext
Definition: swscale_internal.h:299
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
ff_vf_scale
const AVFilter ff_vf_scale
Definition: vf_scale.c:1049
snprintf
#define snprintf
Definition: snprintf.h:34
ScaleContext::size_str
char * size_str
Definition: vf_scale.c:125
VAR_S2R_MAIN_VSUB
@ VAR_S2R_MAIN_VSUB
Definition: vf_scale.c:98
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
swscale.h
ScaleContext::h
int h
Definition: vf_scale.c:124
av_x_if_null
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:312
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2884
ScaleContext::in_v_chr_pos
int in_v_chr_pos
Definition: vf_scale.c:152
SwsContext::param
double param[2]
Input parameters for scaling algorithms that need them.
Definition: swscale_internal.h:342
Generated on Sun Dec 10 2023 19:22:11 for FFmpeg by   doxygen 1.8.17