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 "filters.h"
32 #include "formats.h"
33 #include "framesync.h"
34 #include "libavutil/pixfmt.h"
35 #include "scale_eval.h"
36 #include "video.h"
37 #include "libavutil/eval.h"
38 #include "libavutil/imgutils_internal.h"
39 #include "libavutil/internal.h"
40 #include "libavutil/mem.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/parseutils.h"
43 #include "libavutil/pixdesc.h"
44 #include "libswscale/swscale.h"
45 
46 static const char *const var_names[] = {
47  "in_w", "iw",
48  "in_h", "ih",
49  "out_w", "ow",
50  "out_h", "oh",
51  "a",
52  "sar",
53  "dar",
54  "hsub",
55  "vsub",
56  "ohsub",
57  "ovsub",
58  "n",
59  "t",
60  "ref_w", "rw",
61  "ref_h", "rh",
62  "ref_a",
63  "ref_sar",
64  "ref_dar", "rdar",
65  "ref_hsub",
66  "ref_vsub",
67  "ref_n",
68  "ref_t",
69  "ref_pos",
70  /* Legacy variables for scale2ref */
71  "main_w",
72  "main_h",
73  "main_a",
74  "main_sar",
75  "main_dar", "mdar",
76  "main_hsub",
77  "main_vsub",
78  "main_n",
79  "main_t",
80  "main_pos",
81  NULL
82 };
83 
84 enum var_name {
85  VAR_IN_W, VAR_IW,
86  VAR_IN_H, VAR_IH,
87  VAR_OUT_W, VAR_OW,
88  VAR_OUT_H, VAR_OH,
89  VAR_A,
90  VAR_SAR,
91  VAR_DAR,
92  VAR_HSUB,
93  VAR_VSUB,
94  VAR_OHSUB,
95  VAR_OVSUB,
96  VAR_N,
97  VAR_T,
98  VAR_REF_W, VAR_RW,
99  VAR_REF_H, VAR_RH,
100  VAR_REF_A,
101  VAR_REF_SAR,
102  VAR_REF_DAR, VAR_RDAR,
103  VAR_REF_HSUB,
104  VAR_REF_VSUB,
105  VAR_REF_N,
106  VAR_REF_T,
107  VAR_REF_POS,
108  VAR_S2R_MAIN_W,
109  VAR_S2R_MAIN_H,
110  VAR_S2R_MAIN_A,
111  VAR_S2R_MAIN_SAR,
112  VAR_S2R_MAIN_DAR, VAR_S2R_MDAR,
113  VAR_S2R_MAIN_HSUB,
114  VAR_S2R_MAIN_VSUB,
115  VAR_S2R_MAIN_N,
116  VAR_S2R_MAIN_T,
117  VAR_S2R_MAIN_POS,
118  VARS_NB
119 };
120 
121 enum EvalMode {
122  EVAL_MODE_INIT,
123  EVAL_MODE_FRAME,
124  EVAL_MODE_NB
125 };
126 
127 typedef struct ScaleContext {
128  const AVClass *class;
129  SwsContext *sws;
130  FFFrameSync fs;
131 
132  /**
133  * New dimensions. Special values are:
134  * 0 = original width/height
135  * -1 = keep original aspect
136  * -N = try to keep aspect but make sure it is divisible by N
137  */
138  int w, h;
139  char *size_str;
140  double param[2]; // sws params
141 
142  int hsub, vsub; ///< chroma subsampling
143  int slice_y; ///< top of current output slice
144  int interlaced;
145  int uses_ref;
146 
147  char *w_expr; ///< width expression string
148  char *h_expr; ///< height expression string
149  AVExpr *w_pexpr;
150  AVExpr *h_pexpr;
151  double var_values[VARS_NB];
152 
153  char *flags_str;
154 
155  int in_color_matrix;
156  int out_color_matrix;
157  int in_primaries;
158  int out_primaries;
159  int in_transfer;
160  int out_transfer;
161  int in_range;
162  int out_range;
163 
164  int in_chroma_loc;
165  int out_chroma_loc;
166  int out_h_chr_pos;
167  int out_v_chr_pos;
168  int in_h_chr_pos;
169  int in_v_chr_pos;
170 
171  int force_original_aspect_ratio;
172  int force_divisible_by;
173  int reset_sar;
174 
175  int eval_mode; ///< expression evaluation mode
176 
177 } ScaleContext;
178 
179 const FFFilter ff_vf_scale2ref;
180 #define IS_SCALE2REF(ctx) ((ctx)->filter == &ff_vf_scale2ref.p)
181 
182 static int config_props(AVFilterLink *outlink);
183 
184 static int check_exprs(AVFilterContext *ctx)
185 {
186  ScaleContext *scale = ctx->priv;
187  unsigned vars_w[VARS_NB] = { 0 }, vars_h[VARS_NB] = { 0 };
188 
189  if (!scale->w_pexpr && !scale->h_pexpr)
190  return AVERROR(EINVAL);
191 
192  if (scale->w_pexpr)
193  av_expr_count_vars(scale->w_pexpr, vars_w, VARS_NB);
194  if (scale->h_pexpr)
195  av_expr_count_vars(scale->h_pexpr, vars_h, VARS_NB);
196 
197  if (vars_w[VAR_OUT_W] || vars_w[VAR_OW]) {
198  av_log(ctx, AV_LOG_ERROR, "Width expression cannot be self-referencing: '%s'.\n", scale->w_expr);
199  return AVERROR(EINVAL);
200  }
201 
202  if (vars_h[VAR_OUT_H] || vars_h[VAR_OH]) {
203  av_log(ctx, AV_LOG_ERROR, "Height expression cannot be self-referencing: '%s'.\n", scale->h_expr);
204  return AVERROR(EINVAL);
205  }
206 
207  if ((vars_w[VAR_OUT_H] || vars_w[VAR_OH]) &&
208  (vars_h[VAR_OUT_W] || vars_h[VAR_OW])) {
209  av_log(ctx, AV_LOG_WARNING, "Circular references detected for width '%s' and height '%s' - possibly invalid.\n", scale->w_expr, scale->h_expr);
210  }
211 
212  if (vars_w[VAR_REF_W] || vars_h[VAR_REF_W] ||
213  vars_w[VAR_RW] || vars_h[VAR_RW] ||
214  vars_w[VAR_REF_H] || vars_h[VAR_REF_H] ||
215  vars_w[VAR_RH] || vars_h[VAR_RH] ||
216  vars_w[VAR_REF_A] || vars_h[VAR_REF_A] ||
217  vars_w[VAR_REF_SAR] || vars_h[VAR_REF_SAR] ||
218  vars_w[VAR_REF_DAR] || vars_h[VAR_REF_DAR] ||
219  vars_w[VAR_RDAR] || vars_h[VAR_RDAR] ||
220  vars_w[VAR_REF_HSUB] || vars_h[VAR_REF_HSUB] ||
221  vars_w[VAR_REF_VSUB] || vars_h[VAR_REF_VSUB] ||
222  vars_w[VAR_REF_N] || vars_h[VAR_REF_N] ||
223  vars_w[VAR_REF_T] || vars_h[VAR_REF_T] ||
224  vars_w[VAR_REF_POS] || vars_h[VAR_REF_POS]) {
225  scale->uses_ref = 1;
226  }
227 
228  if (!IS_SCALE2REF(ctx) &&
229  (vars_w[VAR_S2R_MAIN_W] || vars_h[VAR_S2R_MAIN_W] ||
230  vars_w[VAR_S2R_MAIN_H] || vars_h[VAR_S2R_MAIN_H] ||
231  vars_w[VAR_S2R_MAIN_A] || vars_h[VAR_S2R_MAIN_A] ||
232  vars_w[VAR_S2R_MAIN_SAR] || vars_h[VAR_S2R_MAIN_SAR] ||
233  vars_w[VAR_S2R_MAIN_DAR] || vars_h[VAR_S2R_MAIN_DAR] ||
234  vars_w[VAR_S2R_MDAR] || vars_h[VAR_S2R_MDAR] ||
235  vars_w[VAR_S2R_MAIN_HSUB] || vars_h[VAR_S2R_MAIN_HSUB] ||
236  vars_w[VAR_S2R_MAIN_VSUB] || vars_h[VAR_S2R_MAIN_VSUB] ||
237  vars_w[VAR_S2R_MAIN_N] || vars_h[VAR_S2R_MAIN_N] ||
238  vars_w[VAR_S2R_MAIN_T] || vars_h[VAR_S2R_MAIN_T] ||
239  vars_w[VAR_S2R_MAIN_POS] || vars_h[VAR_S2R_MAIN_POS]) ) {
240  av_log(ctx, AV_LOG_ERROR, "Expressions with scale2ref variables are not valid in scale filter.\n");
241  return AVERROR(EINVAL);
242  }
243 
244  if (scale->eval_mode == EVAL_MODE_INIT &&
245  (vars_w[VAR_N] || vars_h[VAR_N] ||
246  vars_w[VAR_T] || vars_h[VAR_T] ||
247  vars_w[VAR_S2R_MAIN_N] || vars_h[VAR_S2R_MAIN_N] ||
248  vars_w[VAR_S2R_MAIN_T] || vars_h[VAR_S2R_MAIN_T] ||
249  vars_w[VAR_S2R_MAIN_POS] || vars_h[VAR_S2R_MAIN_POS]) ) {
250  av_log(ctx, AV_LOG_ERROR, "Expressions with frame variables 'n', 't', 'pos' are not valid in init eval_mode.\n");
251  return AVERROR(EINVAL);
252  }
253 
254  return 0;
255 }
256 
257 static int scale_parse_expr(AVFilterContext *ctx, char *str_expr, AVExpr **pexpr_ptr, const char *var, const char *args)
258 {
259  ScaleContext *scale = ctx->priv;
260  int ret, is_inited = 0;
261  char *old_str_expr = NULL;
262  AVExpr *old_pexpr = NULL;
263 
264  if (str_expr) {
265  old_str_expr = av_strdup(str_expr);
266  if (!old_str_expr)
267  return AVERROR(ENOMEM);
268  av_opt_set(scale, var, args, 0);
269  }
270 
271  if (*pexpr_ptr) {
272  old_pexpr = *pexpr_ptr;
273  *pexpr_ptr = NULL;
274  is_inited = 1;
275  }
276 
277  ret = av_expr_parse(pexpr_ptr, args, var_names,
278  NULL, NULL, NULL, NULL, 0, ctx);
279  if (ret < 0) {
280  av_log(ctx, AV_LOG_ERROR, "Cannot parse expression for %s: '%s'\n", var, args);
281  goto revert;
282  }
283 
284  ret = check_exprs(ctx);
285  if (ret < 0)
286  goto revert;
287 
288  if (is_inited && (ret = config_props(ctx->outputs[0])) < 0)
289  goto revert;
290 
291  av_expr_free(old_pexpr);
292  old_pexpr = NULL;
293  av_freep(&old_str_expr);
294 
295  return 0;
296 
297 revert:
298  av_expr_free(*pexpr_ptr);
299  *pexpr_ptr = NULL;
300  if (old_str_expr) {
301  av_opt_set(scale, var, old_str_expr, 0);
302  av_free(old_str_expr);
303  }
304  if (old_pexpr)
305  *pexpr_ptr = old_pexpr;
306 
307  return ret;
308 }
309 
310 static av_cold int preinit(AVFilterContext *ctx)
311 {
312  ScaleContext *scale = ctx->priv;
313 
314  scale->sws = sws_alloc_context();
315  if (!scale->sws)
316  return AVERROR(ENOMEM);
317 
318  // set threads=0, so we can later check whether the user modified it
319  scale->sws->threads = 0;
320 
321  ff_framesync_preinit(&scale->fs);
322 
323  return 0;
324 }
325 
326 static int do_scale(FFFrameSync *fs);
327 
328 static av_cold int init(AVFilterContext *ctx)
329 {
330  ScaleContext *scale = ctx->priv;
331  int ret;
332 
333  if (IS_SCALE2REF(ctx))
334  av_log(ctx, AV_LOG_WARNING, "scale2ref is deprecated, use scale=rw:rh instead\n");
335 
336  if (scale->size_str && (scale->w_expr || scale->h_expr)) {
337  av_log(ctx, AV_LOG_ERROR,
338  "Size and width/height expressions cannot be set at the same time.\n");
339  return AVERROR(EINVAL);
340  }
341 
342  if (scale->w_expr && !scale->h_expr)
343  FFSWAP(char *, scale->w_expr, scale->size_str);
344 
345  if (scale->size_str) {
346  char buf[32];
347  if ((ret = av_parse_video_size(&scale->w, &scale->h, scale->size_str)) < 0) {
348  av_log(ctx, AV_LOG_ERROR,
349  "Invalid size '%s'\n", scale->size_str);
350  return ret;
351  }
352  snprintf(buf, sizeof(buf)-1, "%d", scale->w);
353  av_opt_set(scale, "w", buf, 0);
354  snprintf(buf, sizeof(buf)-1, "%d", scale->h);
355  av_opt_set(scale, "h", buf, 0);
356  }
357  if (!scale->w_expr)
358  av_opt_set(scale, "w", "iw", 0);
359  if (!scale->h_expr)
360  av_opt_set(scale, "h", "ih", 0);
361 
362  ret = scale_parse_expr(ctx, NULL, &scale->w_pexpr, "width", scale->w_expr);
363  if (ret < 0)
364  return ret;
365 
366  ret = scale_parse_expr(ctx, NULL, &scale->h_pexpr, "height", scale->h_expr);
367  if (ret < 0)
368  return ret;
369 
370  if (scale->in_primaries != -1 && !sws_test_primaries(scale->in_primaries, 0)) {
371  av_log(ctx, AV_LOG_ERROR, "Unsupported input primaries '%s'\n",
372  av_color_primaries_name(scale->in_primaries));
373  return AVERROR(EINVAL);
374  }
375 
376  if (scale->out_primaries != -1 && !sws_test_primaries(scale->out_primaries, 1)) {
377  av_log(ctx, AV_LOG_ERROR, "Unsupported output primaries '%s'\n",
378  av_color_primaries_name(scale->out_primaries));
379  return AVERROR(EINVAL);
380  }
381 
382  if (scale->in_transfer != -1 && !sws_test_transfer(scale->in_transfer, 0)) {
383  av_log(ctx, AV_LOG_ERROR, "Unsupported input transfer '%s'\n",
384  av_color_transfer_name(scale->in_transfer));
385  return AVERROR(EINVAL);
386  }
387 
388  if (scale->out_transfer != -1 && !sws_test_transfer(scale->out_transfer, 1)) {
389  av_log(ctx, AV_LOG_ERROR, "Unsupported output transfer '%s'\n",
390  av_color_transfer_name(scale->out_transfer));
391  return AVERROR(EINVAL);
392  }
393 
394  if (scale->in_color_matrix != -1 && !sws_test_colorspace(scale->in_color_matrix, 0)) {
395  av_log(ctx, AV_LOG_ERROR, "Unsupported input color matrix '%s'\n",
396  av_color_space_name(scale->in_color_matrix));
397  return AVERROR(EINVAL);
398  }
399 
400  if (scale->out_color_matrix != -1 && !sws_test_colorspace(scale->out_color_matrix, 1)) {
401  av_log(ctx, AV_LOG_ERROR, "Unsupported output color matrix '%s'\n",
402  av_color_space_name(scale->out_color_matrix));
403  return AVERROR(EINVAL);
404  }
405 
406  av_log(ctx, AV_LOG_VERBOSE, "w:%s h:%s flags:'%s' interl:%d\n",
407  scale->w_expr, scale->h_expr, (char *)av_x_if_null(scale->flags_str, ""), scale->interlaced);
408 
409  if (scale->flags_str && *scale->flags_str) {
410  ret = av_opt_set(scale->sws, "sws_flags", scale->flags_str, 0);
411  if (ret < 0)
412  return ret;
413  }
414 
415  for (int i = 0; i < FF_ARRAY_ELEMS(scale->param); i++)
416  if (scale->param[i] != DBL_MAX)
417  scale->sws->scaler_params[i] = scale->param[i];
418 
419  scale->sws->src_h_chr_pos = scale->in_h_chr_pos;
420  scale->sws->src_v_chr_pos = scale->in_v_chr_pos;
421  scale->sws->dst_h_chr_pos = scale->out_h_chr_pos;
422  scale->sws->dst_v_chr_pos = scale->out_v_chr_pos;
423 
424  // use generic thread-count if the user did not set it explicitly
425  if (!scale->sws->threads)
426  scale->sws->threads = ff_filter_get_nb_threads(ctx);
427 
428  if (!IS_SCALE2REF(ctx) && scale->uses_ref) {
429  AVFilterPad pad = {
430  .name = "ref",
431  .type = AVMEDIA_TYPE_VIDEO,
432  };
433  ret = ff_append_inpad(ctx, &pad);
434  if (ret < 0)
435  return ret;
436  }
437 
438  return 0;
439 }
440 
441 static av_cold void uninit(AVFilterContext *ctx)
442 {
443  ScaleContext *scale = ctx->priv;
444  av_expr_free(scale->w_pexpr);
445  av_expr_free(scale->h_pexpr);
446  scale->w_pexpr = scale->h_pexpr = NULL;
447  ff_framesync_uninit(&scale->fs);
448  sws_free_context(&scale->sws);
449 }
450 
451 static int query_formats(const AVFilterContext *ctx,
452  AVFilterFormatsConfig **cfg_in,
453  AVFilterFormatsConfig **cfg_out)
454 {
455  const ScaleContext *scale = ctx->priv;
456  AVFilterFormats *formats;
457  const AVPixFmtDescriptor *desc;
458  enum AVPixelFormat pix_fmt;
459  int ret;
460 
461  desc = NULL;
462  formats = NULL;
463  while ((desc = av_pix_fmt_desc_next(desc))) {
464  pix_fmt = av_pix_fmt_desc_get_id(desc);
465  if (sws_test_format(pix_fmt, 0)) {
466  if ((ret = ff_add_format(&formats, pix_fmt)) < 0)
467  return ret;
468  }
469  }
470  if ((ret = ff_formats_ref(formats, &cfg_in[0]->formats)) < 0)
471  return ret;
472 
473  desc = NULL;
474  formats = NULL;
475  while ((desc = av_pix_fmt_desc_next(desc))) {
476  pix_fmt = av_pix_fmt_desc_get_id(desc);
477  if (sws_test_format(pix_fmt, 1) || pix_fmt == AV_PIX_FMT_PAL8) {
478  if ((ret = ff_add_format(&formats, pix_fmt)) < 0)
479  return ret;
480  }
481  }
482  if ((ret = ff_formats_ref(formats, &cfg_out[0]->formats)) < 0)
483  return ret;
484 
485  /* accept all supported inputs, even if user overrides their properties */
486  formats = ff_all_color_spaces();
487  for (int i = 0; i < formats->nb_formats; i++) {
488  if (!sws_test_colorspace(formats->formats[i], 0)) {
489  for (int j = i--; j + 1 < formats->nb_formats; j++)
490  formats->formats[j] = formats->formats[j + 1];
491  formats->nb_formats--;
492  }
493  }
494  if ((ret = ff_formats_ref(formats, &cfg_in[0]->color_spaces)) < 0)
495  return ret;
496 
497  if ((ret = ff_formats_ref(ff_all_color_ranges(),
498  &cfg_in[0]->color_ranges)) < 0)
499  return ret;
500 
501  /* propagate output properties if overridden */
502  if (scale->out_color_matrix != AVCOL_SPC_UNSPECIFIED) {
503  formats = ff_make_formats_list_singleton(scale->out_color_matrix);
504  } else {
505  formats = ff_all_color_spaces();
506  for (int i = 0; i < formats->nb_formats; i++) {
507  if (!sws_test_colorspace(formats->formats[i], 1)) {
508  for (int j = i--; j + 1 < formats->nb_formats; j++)
509  formats->formats[j] = formats->formats[j + 1];
510  formats->nb_formats--;
511  }
512  }
513  }
514  if ((ret = ff_formats_ref(formats, &cfg_out[0]->color_spaces)) < 0)
515  return ret;
516 
517  formats = scale->out_range != AVCOL_RANGE_UNSPECIFIED
518  ? ff_make_formats_list_singleton(scale->out_range)
519  : ff_all_color_ranges();
520  if ((ret = ff_formats_ref(formats, &cfg_out[0]->color_ranges)) < 0)
521  return ret;
522 
523  if (scale->sws->alpha_blend) {
524  if ((ret = ff_formats_ref(ff_make_formats_list_singleton(AVALPHA_MODE_STRAIGHT),
525  &cfg_in[0]->alpha_modes)) < 0)
526  return ret;
527  }
528 
529  return 0;
530 }
531 
532 static int scale_eval_dimensions(AVFilterContext *ctx)
533 {
534  ScaleContext *scale = ctx->priv;
535  const char scale2ref = IS_SCALE2REF(ctx);
536  const AVFilterLink *inlink = scale2ref ? ctx->inputs[1] : ctx->inputs[0];
537  const AVFilterLink *outlink = ctx->outputs[0];
538  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
539  const AVPixFmtDescriptor *out_desc = av_pix_fmt_desc_get(outlink->format);
540  char *expr;
541  int eval_w, eval_h;
542  int ret;
543  double res;
544  const AVPixFmtDescriptor *main_desc;
545  const AVFilterLink *main_link;
546 
547  if (scale2ref) {
548  main_link = ctx->inputs[0];
549  main_desc = av_pix_fmt_desc_get(main_link->format);
550  }
551 
552  scale->var_values[VAR_IN_W] = scale->var_values[VAR_IW] = inlink->w;
553  scale->var_values[VAR_IN_H] = scale->var_values[VAR_IH] = inlink->h;
554  scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = NAN;
555  scale->var_values[VAR_OUT_H] = scale->var_values[VAR_OH] = NAN;
556  scale->var_values[VAR_A] = (double) inlink->w / inlink->h;
557  scale->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ?
558  (double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
559  scale->var_values[VAR_DAR] = scale->var_values[VAR_A] * scale->var_values[VAR_SAR];
560  scale->var_values[VAR_HSUB] = 1 << desc->log2_chroma_w;
561  scale->var_values[VAR_VSUB] = 1 << desc->log2_chroma_h;
562  scale->var_values[VAR_OHSUB] = 1 << out_desc->log2_chroma_w;
563  scale->var_values[VAR_OVSUB] = 1 << out_desc->log2_chroma_h;
564 
565  if (scale2ref) {
566  scale->var_values[VAR_S2R_MAIN_W] = main_link->w;
567  scale->var_values[VAR_S2R_MAIN_H] = main_link->h;
568  scale->var_values[VAR_S2R_MAIN_A] = (double) main_link->w / main_link->h;
569  scale->var_values[VAR_S2R_MAIN_SAR] = main_link->sample_aspect_ratio.num ?
570  (double) main_link->sample_aspect_ratio.num / main_link->sample_aspect_ratio.den : 1;
571  scale->var_values[VAR_S2R_MAIN_DAR] = scale->var_values[VAR_S2R_MDAR] =
572  scale->var_values[VAR_S2R_MAIN_A] * scale->var_values[VAR_S2R_MAIN_SAR];
573  scale->var_values[VAR_S2R_MAIN_HSUB] = 1 << main_desc->log2_chroma_w;
574  scale->var_values[VAR_S2R_MAIN_VSUB] = 1 << main_desc->log2_chroma_h;
575  }
576 
577  if (scale->uses_ref) {
578  const AVFilterLink *reflink = ctx->inputs[1];
579  const AVPixFmtDescriptor *ref_desc = av_pix_fmt_desc_get(reflink->format);
580  scale->var_values[VAR_REF_W] = scale->var_values[VAR_RW] = reflink->w;
581  scale->var_values[VAR_REF_H] = scale->var_values[VAR_RH] = reflink->h;
582  scale->var_values[VAR_REF_A] = (double) reflink->w / reflink->h;
583  scale->var_values[VAR_REF_SAR] = reflink->sample_aspect_ratio.num ?
584  (double) reflink->sample_aspect_ratio.num / reflink->sample_aspect_ratio.den : 1;
585  scale->var_values[VAR_REF_DAR] = scale->var_values[VAR_RDAR] =
586  scale->var_values[VAR_REF_A] * scale->var_values[VAR_REF_SAR];
587  scale->var_values[VAR_REF_HSUB] = 1 << ref_desc->log2_chroma_w;
588  scale->var_values[VAR_REF_VSUB] = 1 << ref_desc->log2_chroma_h;
589  }
590 
591  res = av_expr_eval(scale->w_pexpr, scale->var_values, NULL);
592  eval_w = scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = (int) res == 0 ? inlink->w : (int) res;
593 
594  res = av_expr_eval(scale->h_pexpr, scale->var_values, NULL);
595  if (isnan(res)) {
596  expr = scale->h_expr;
597  ret = AVERROR(EINVAL);
598  goto fail;
599  }
600  eval_h = scale->var_values[VAR_OUT_H] = scale->var_values[VAR_OH] = (int) res == 0 ? inlink->h : (int) res;
601 
602  res = av_expr_eval(scale->w_pexpr, scale->var_values, NULL);
603  if (isnan(res)) {
604  expr = scale->w_expr;
605  ret = AVERROR(EINVAL);
606  goto fail;
607  }
608  eval_w = scale->var_values[VAR_OUT_W] = scale->var_values[VAR_OW] = (int) res == 0 ? inlink->w : (int) res;
609 
610  scale->w = eval_w;
611  scale->h = eval_h;
612 
613  return 0;
614 
615 fail:
616  av_log(ctx, AV_LOG_ERROR,
617  "Error when evaluating the expression '%s'.\n", expr);
618  return ret;
619 }
620 
621 static int config_props(AVFilterLink *outlink)
622 {
623  AVFilterContext *ctx = outlink->src;
624  AVFilterLink *inlink0 = outlink->src->inputs[0];
625  AVFilterLink *inlink = IS_SCALE2REF(ctx) ?
626  outlink->src->inputs[1] :
627  outlink->src->inputs[0];
628  ScaleContext *scale = ctx->priv;
629  uint8_t *flags_val = NULL;
630  double w_adj = 1.0;
631  int ret;
632 
633  if ((ret = scale_eval_dimensions(ctx)) < 0)
634  goto fail;
635 
636  outlink->w = scale->w;
637  outlink->h = scale->h;
638 
639  if (scale->reset_sar)
640  w_adj = IS_SCALE2REF(ctx) ? scale->var_values[VAR_S2R_MAIN_SAR] :
641  scale->var_values[VAR_SAR];
642 
643  ret = ff_scale_adjust_dimensions(inlink, &outlink->w, &outlink->h,
644  scale->force_original_aspect_ratio,
645  scale->force_divisible_by, w_adj);
646 
647  if (ret < 0)
648  goto fail;
649 
650  if (outlink->w > INT_MAX ||
651  outlink->h > INT_MAX ||
652  (outlink->h * inlink->w) > INT_MAX ||
653  (outlink->w * inlink->h) > INT_MAX)
654  av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
655 
656  /* TODO: make algorithm configurable */
657 
658  if (scale->reset_sar)
659  outlink->sample_aspect_ratio = (AVRational){1, 1};
660  else if (inlink0->sample_aspect_ratio.num){
661  outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h * inlink0->w, outlink->w * inlink0->h}, inlink0->sample_aspect_ratio);
662  } else
663  outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
664 
665  av_opt_get(scale->sws, "sws_flags", 0, &flags_val);
666  av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d fmt:%s csp:%s range:%s sar:%d/%d -> w:%d h:%d fmt:%s csp:%s range:%s sar:%d/%d flags:%s\n",
667  inlink ->w, inlink ->h, av_get_pix_fmt_name( inlink->format),
668  av_color_space_name(inlink->colorspace), av_color_range_name(inlink->color_range),
669  inlink->sample_aspect_ratio.num, inlink->sample_aspect_ratio.den,
670  outlink->w, outlink->h, av_get_pix_fmt_name(outlink->format),
671  av_color_space_name(outlink->colorspace), av_color_range_name(outlink->color_range),
672  outlink->sample_aspect_ratio.num, outlink->sample_aspect_ratio.den,
673  flags_val);
674  av_freep(&flags_val);
675 
676  if (inlink->w != outlink->w || inlink->h != outlink->h) {
677  av_frame_side_data_remove_by_props(&outlink->side_data, &outlink->nb_side_data,
678  AV_SIDE_DATA_PROP_SIZE_DEPENDENT);
679  }
680 
681  if (scale->in_primaries != scale->out_primaries || scale->in_transfer != scale->out_transfer) {
682  av_frame_side_data_remove_by_props(&outlink->side_data, &outlink->nb_side_data,
683  AV_SIDE_DATA_PROP_COLOR_DEPENDENT);
684  }
685 
686  if (!IS_SCALE2REF(ctx)) {
687  ff_framesync_uninit(&scale->fs);
688  ret = ff_framesync_init(&scale->fs, ctx, ctx->nb_inputs);
689  if (ret < 0)
690  return ret;
691  scale->fs.on_event = do_scale;
692  scale->fs.in[0].time_base = ctx->inputs[0]->time_base;
693  scale->fs.in[0].sync = 1;
694  scale->fs.in[0].before = EXT_STOP;
695  scale->fs.in[0].after = EXT_STOP;
696  if (scale->uses_ref) {
697  av_assert0(ctx->nb_inputs == 2);
698  scale->fs.in[1].time_base = ctx->inputs[1]->time_base;
699  scale->fs.in[1].sync = 0;
700  scale->fs.in[1].before = EXT_NULL;
701  scale->fs.in[1].after = EXT_INFINITY;
702  }
703 
704  ret = ff_framesync_configure(&scale->fs);
705  if (ret < 0)
706  return ret;
707  }
708 
709  return 0;
710 
711 fail:
712  return ret;
713 }
714 
715 static int config_props_ref(AVFilterLink *outlink)
716 {
717  AVFilterLink *inlink = outlink->src->inputs[1];
718  FilterLink *il = ff_filter_link(inlink);
719  FilterLink *ol = ff_filter_link(outlink);
720 
721  outlink->w = inlink->w;
722  outlink->h = inlink->h;
723  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
724  outlink->time_base = inlink->time_base;
725  ol->frame_rate = il->frame_rate;
726  outlink->colorspace = inlink->colorspace;
727  outlink->color_range = inlink->color_range;
728 
729  return 0;
730 }
731 
732 static int request_frame(AVFilterLink *outlink)
733 {
734  return ff_request_frame(outlink->src->inputs[0]);
735 }
736 
737 static int request_frame_ref(AVFilterLink *outlink)
738 {
739  return ff_request_frame(outlink->src->inputs[1]);
740 }
741 
742 /* Takes over ownership of *frame_in, passes ownership of *frame_out to caller */
743 static int scale_frame(AVFilterLink *link, AVFrame **frame_in,
744  AVFrame **frame_out)
745 {
746  FilterLink *inl = ff_filter_link(link);
747  AVFilterContext *ctx = link->dst;
748  ScaleContext *scale = ctx->priv;
749  AVFilterLink *outlink = ctx->outputs[0];
750  AVFrame *out, *in = *frame_in;
751  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(link->format);
752  char buf[32];
753  int ret, flags_orig, frame_changed;
754 
755  *frame_in = NULL;
756 
757  frame_changed = in->width != link->w ||
758  in->height != link->h ||
759  in->format != link->format ||
760  in->sample_aspect_ratio.den != link->sample_aspect_ratio.den ||
761  in->sample_aspect_ratio.num != link->sample_aspect_ratio.num ||
762  in->colorspace != link->colorspace ||
763  in->color_range != link->color_range;
764 
765  if (scale->eval_mode == EVAL_MODE_FRAME || frame_changed) {
766  unsigned vars_w[VARS_NB] = { 0 }, vars_h[VARS_NB] = { 0 };
767 
768  av_expr_count_vars(scale->w_pexpr, vars_w, VARS_NB);
769  av_expr_count_vars(scale->h_pexpr, vars_h, VARS_NB);
770 
771  if (scale->eval_mode == EVAL_MODE_FRAME &&
772  !frame_changed &&
773  !IS_SCALE2REF(ctx) &&
774  !(vars_w[VAR_N] || vars_w[VAR_T]) &&
775  !(vars_h[VAR_N] || vars_h[VAR_T]) &&
776  scale->w && scale->h)
777  goto scale;
778 
779  if (scale->eval_mode == EVAL_MODE_INIT) {
780  snprintf(buf, sizeof(buf) - 1, "%d", scale->w);
781  av_opt_set(scale, "w", buf, 0);
782  snprintf(buf, sizeof(buf) - 1, "%d", scale->h);
783  av_opt_set(scale, "h", buf, 0);
784 
785  ret = scale_parse_expr(ctx, NULL, &scale->w_pexpr, "width", scale->w_expr);
786  if (ret < 0)
787  goto err;
788 
789  ret = scale_parse_expr(ctx, NULL, &scale->h_pexpr, "height", scale->h_expr);
790  if (ret < 0)
791  goto err;
792  }
793 
794  if (IS_SCALE2REF(ctx)) {
795  scale->var_values[VAR_S2R_MAIN_N] = inl->frame_count_out;
796  scale->var_values[VAR_S2R_MAIN_T] = TS2T(in->pts, link->time_base);
797  } else {
798  scale->var_values[VAR_N] = inl->frame_count_out;
799  scale->var_values[VAR_T] = TS2T(in->pts, link->time_base);
800  }
801 
802  link->dst->inputs[0]->format = in->format;
803  link->dst->inputs[0]->w = in->width;
804  link->dst->inputs[0]->h = in->height;
805  link->dst->inputs[0]->colorspace = in->colorspace;
806  link->dst->inputs[0]->color_range = in->color_range;
807 
808  link->dst->inputs[0]->sample_aspect_ratio.den = in->sample_aspect_ratio.den;
809  link->dst->inputs[0]->sample_aspect_ratio.num = in->sample_aspect_ratio.num;
810 
811  if ((ret = config_props(outlink)) < 0)
812  goto err;
813  }
814 
815 scale:
816  scale->hsub = desc->log2_chroma_w;
817  scale->vsub = desc->log2_chroma_h;
818 
819  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
820  if (!out) {
821  ret = AVERROR(ENOMEM);
822  goto err;
823  }
824 
825  if (scale->in_color_matrix != -1)
826  in->colorspace = scale->in_color_matrix;
827  if (scale->in_primaries != -1)
828  in->color_primaries = scale->in_primaries;
829  if (scale->in_transfer != -1)
830  in->color_trc = scale->in_transfer;
831  if (scale->in_range != AVCOL_RANGE_UNSPECIFIED)
832  in->color_range = scale->in_range;
833  in->chroma_location = scale->in_chroma_loc;
834 
835  flags_orig = in->flags;
836  if (scale->interlaced > 0)
837  in->flags |= AV_FRAME_FLAG_INTERLACED;
838  else if (!scale->interlaced)
839  in->flags &= ~AV_FRAME_FLAG_INTERLACED;
840 
841  av_frame_copy_props(out, in);
842  out->width = outlink->w;
843  out->height = outlink->h;
844  out->color_range = outlink->color_range;
845  out->colorspace = outlink->colorspace;
846  out->alpha_mode = outlink->alpha_mode;
847  if (scale->out_chroma_loc != AVCHROMA_LOC_UNSPECIFIED)
848  out->chroma_location = scale->out_chroma_loc;
849  if (scale->out_primaries != -1)
850  out->color_primaries = scale->out_primaries;
851  if (scale->out_transfer != -1)
852  out->color_trc = scale->out_transfer;
853 
854  if (out->width != in->width || out->height != in->height) {
855  av_frame_side_data_remove_by_props(&out->side_data, &out->nb_side_data,
856  AV_SIDE_DATA_PROP_SIZE_DEPENDENT);
857  }
858 
859  if (in->color_primaries != out->color_primaries || in->color_trc != out->color_trc) {
860  av_frame_side_data_remove_by_props(&out->side_data, &out->nb_side_data,
861  AV_SIDE_DATA_PROP_COLOR_DEPENDENT);
862  }
863 
864  if (scale->reset_sar) {
865  out->sample_aspect_ratio = outlink->sample_aspect_ratio;
866  } else {
867  av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,
868  (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
869  (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
870  INT_MAX);
871  }
872 
873  if (sws_is_noop(out, in)) {
874  av_frame_free(&out);
875  in->flags = flags_orig;
876  *frame_out = in;
877  return 0;
878  }
879 
880  if (out->format == AV_PIX_FMT_PAL8) {
881  out->format = AV_PIX_FMT_BGR8;
882  avpriv_set_systematic_pal2((uint32_t*) out->data[1], out->format);
883  }
884 
885  ret = sws_scale_frame(scale->sws, out, in);
886  av_frame_free(&in);
887  out->flags = flags_orig;
888  out->format = outlink->format; /* undo PAL8 handling */
889  if (ret < 0)
890  av_frame_free(&out);
891  *frame_out = out;
892  return ret;
893 
894 err:
895  av_frame_free(&in);
896  return ret;
897 }
898 
899 static int do_scale(FFFrameSync *fs)
900 {
901  AVFilterContext *ctx = fs->parent;
902  ScaleContext *scale = ctx->priv;
903  AVFilterLink *outlink = ctx->outputs[0];
904  AVFrame *out, *in = NULL, *ref = NULL;
905  int ret = 0, frame_changed;
906 
907  ret = ff_framesync_get_frame(fs, 0, &in, 1);
908  if (ret < 0)
909  goto err;
910 
911  if (scale->uses_ref) {
912  ret = ff_framesync_get_frame(fs, 1, &ref, 0);
913  if (ret < 0)
914  goto err;
915  }
916 
917  if (ref) {
918  AVFilterLink *reflink = ctx->inputs[1];
919  FilterLink *rl = ff_filter_link(reflink);
920 
921  frame_changed = ref->width != reflink->w ||
922  ref->height != reflink->h ||
923  ref->format != reflink->format ||
924  ref->sample_aspect_ratio.den != reflink->sample_aspect_ratio.den ||
925  ref->sample_aspect_ratio.num != reflink->sample_aspect_ratio.num ||
926  ref->colorspace != reflink->colorspace ||
927  ref->color_range != reflink->color_range;
928 
929  if (frame_changed) {
930  reflink->format = ref->format;
931  reflink->w = ref->width;
932  reflink->h = ref->height;
933  reflink->sample_aspect_ratio.num = ref->sample_aspect_ratio.num;
934  reflink->sample_aspect_ratio.den = ref->sample_aspect_ratio.den;
935  reflink->colorspace = ref->colorspace;
936  reflink->color_range = ref->color_range;
937 
938  ret = config_props(outlink);
939  if (ret < 0)
940  goto err;
941  }
942 
943  if (scale->eval_mode == EVAL_MODE_FRAME) {
944  scale->var_values[VAR_REF_N] = rl->frame_count_out;
945  scale->var_values[VAR_REF_T] = TS2T(ref->pts, reflink->time_base);
946  }
947  }
948 
949  ret = scale_frame(ctx->inputs[0], &in, &out);
950  if (ret < 0)
951  goto err;
952 
953  av_assert0(out);
954  out->pts = av_rescale_q(fs->pts, fs->time_base, outlink->time_base);
955  return ff_filter_frame(outlink, out);
956 
957 err:
958  av_frame_free(&in);
959  return ret;
960 }
961 
962 static int filter_frame(AVFilterLink *link, AVFrame *in)
963 {
964  AVFilterContext *ctx = link->dst;
965  AVFilterLink *outlink = ctx->outputs[0];
966  AVFrame *out;
967  int ret;
968 
969  ret = scale_frame(link, &in, &out);
970  if (out)
971  return ff_filter_frame(outlink, out);
972 
973  return ret;
974 }
975 
976 static int filter_frame_ref(AVFilterLink *link, AVFrame *in)
977 {
978  FilterLink *l = ff_filter_link(link);
979  ScaleContext *scale = link->dst->priv;
980  AVFilterLink *outlink = link->dst->outputs[1];
981  int frame_changed;
982 
983  frame_changed = in->width != link->w ||
984  in->height != link->h ||
985  in->format != link->format ||
986  in->sample_aspect_ratio.den != link->sample_aspect_ratio.den ||
987  in->sample_aspect_ratio.num != link->sample_aspect_ratio.num ||
988  in->colorspace != link->colorspace ||
989  in->color_range != link->color_range;
990 
991  if (frame_changed) {
992  link->format = in->format;
993  link->w = in->width;
994  link->h = in->height;
995  link->sample_aspect_ratio.num = in->sample_aspect_ratio.num;
996  link->sample_aspect_ratio.den = in->sample_aspect_ratio.den;
997  link->colorspace = in->colorspace;
998  link->color_range = in->color_range;
999 
1000  config_props_ref(outlink);
1001  }
1002 
1003  if (scale->eval_mode == EVAL_MODE_FRAME) {
1004  scale->var_values[VAR_N] = l->frame_count_out;
1005  scale->var_values[VAR_T] = TS2T(in->pts, link->time_base);
1006  }
1007 
1008  return ff_filter_frame(outlink, in);
1009 }
1010 
1011 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
1012  char *res, int res_len, int flags)
1013 {
1014  ScaleContext *scale = ctx->priv;
1015  char *str_expr;
1016  AVExpr **pexpr_ptr;
1017  int ret, w, h;
1018 
1019  w = !strcmp(cmd, "width") || !strcmp(cmd, "w");
1020  h = !strcmp(cmd, "height") || !strcmp(cmd, "h");
1021 
1022  if (w || h) {
1023  str_expr = w ? scale->w_expr : scale->h_expr;
1024  pexpr_ptr = w ? &scale->w_pexpr : &scale->h_pexpr;
1025 
1026  ret = scale_parse_expr(ctx, str_expr, pexpr_ptr, cmd, args);
1027  } else
1028  ret = AVERROR(ENOSYS);
1029 
1030  if (ret < 0)
1031  av_log(ctx, AV_LOG_ERROR, "Failed to process command. Continuing with existing parameters.\n");
1032 
1033  return ret;
1034 }
1035 
1036 static int activate(AVFilterContext *ctx)
1037 {
1038  ScaleContext *scale = ctx->priv;
1039  return ff_framesync_activate(&scale->fs);
1040 }
1041 
1042 static const AVClass *child_class_iterate(void **iter)
1043 {
1044  switch ((uintptr_t) *iter) {
1045  case 0:
1046  *iter = (void*)(uintptr_t) 1;
1047  return sws_get_class();
1048  case 1:
1049  *iter = (void*)(uintptr_t) 2;
1050  return &ff_framesync_class;
1051  }
1052 
1053  return NULL;
1054 }
1055 
1056 static void *child_next(void *obj, void *prev)
1057 {
1058  ScaleContext *s = obj;
1059  if (!prev)
1060  return s->sws;
1061  if (prev == s->sws)
1062  return &s->fs;
1063  return NULL;
1064 }
1065 
1066 #define OFFSET(x) offsetof(ScaleContext, x)
1067 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
1068 #define TFLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
1069 
1070 static const AVOption scale_options[] = {
1071  { "w", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = TFLAGS },
1072  { "width", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = TFLAGS },
1073  { "h", "Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = TFLAGS },
1074  { "height","Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = TFLAGS },
1075  { "flags", "Flags to pass to libswscale", OFFSET(flags_str), AV_OPT_TYPE_STRING, { .str = "" }, .flags = FLAGS },
1076  { "interl", "set interlacing", OFFSET(interlaced), AV_OPT_TYPE_BOOL, {.i64 = 0 }, -1, 1, FLAGS },
1077  { "size", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, .flags = FLAGS },
1078  { "s", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, .flags = FLAGS },
1079  { "in_color_matrix", "set input YCbCr type", OFFSET(in_color_matrix), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, AVCOL_SPC_NB-1, .flags = FLAGS, .unit = "color" },
1080  { "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, .unit = "color"},
1081  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, .unit = "color" },
1082  { "bt601", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT470BG}, 0, 0, FLAGS, .unit = "color" },
1083  { "bt470", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT470BG}, 0, 0, FLAGS, .unit = "color" },
1084  { "smpte170m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT470BG}, 0, 0, FLAGS, .unit = "color" },
1085  { "bt470bg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT470BG}, 0, 0, FLAGS, .unit = "color" },
1086  { "bt709", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT709}, 0, 0, FLAGS, .unit = "color" },
1087  { "fcc", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_FCC}, 0, 0, FLAGS, .unit = "color" },
1088  { "smpte240m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_SMPTE240M}, 0, 0, FLAGS, .unit = "color" },
1089  { "bt2020", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT2020_NCL}, 0, 0, FLAGS, .unit = "color" },
1090  { "bt2020nc", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_SPC_BT2020_NCL}, 0, 0, FLAGS, .unit = "color" },
1091  { "in_range", "set input color range", OFFSET( in_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, .unit = "range" },
1092  { "out_range", "set output color range", OFFSET(out_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, .unit = "range" },
1093  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, .unit = "range" },
1094  { "unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, .unit = "range" },
1095  { "full", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_JPEG}, 0, 0, FLAGS, .unit = "range" },
1096  { "limited", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_MPEG}, 0, 0, FLAGS, .unit = "range" },
1097  { "jpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_JPEG}, 0, 0, FLAGS, .unit = "range" },
1098  { "mpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_MPEG}, 0, 0, FLAGS, .unit = "range" },
1099  { "tv", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_MPEG}, 0, 0, FLAGS, .unit = "range" },
1100  { "pc", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_RANGE_JPEG}, 0, 0, FLAGS, .unit = "range" },
1101  { "in_chroma_loc", "set input chroma sample location", OFFSET(in_chroma_loc), AV_OPT_TYPE_INT, { .i64 = AVCHROMA_LOC_UNSPECIFIED }, 0, AVCHROMA_LOC_NB-1, .flags = FLAGS, .unit = "chroma_loc" },
1102  { "out_chroma_loc", "set output chroma sample location", OFFSET(out_chroma_loc), AV_OPT_TYPE_INT, { .i64 = AVCHROMA_LOC_UNSPECIFIED }, 0, AVCHROMA_LOC_NB-1, .flags = FLAGS, .unit = "chroma_loc" },
1103  {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCHROMA_LOC_UNSPECIFIED}, 0, 0, FLAGS, .unit = "chroma_loc"},
1104  {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCHROMA_LOC_UNSPECIFIED}, 0, 0, FLAGS, .unit = "chroma_loc"},
1105  {"left", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCHROMA_LOC_LEFT}, 0, 0, FLAGS, .unit = "chroma_loc"},
1106  {"center", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCHROMA_LOC_CENTER}, 0, 0, FLAGS, .unit = "chroma_loc"},
1107  {"topleft", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCHROMA_LOC_TOPLEFT}, 0, 0, FLAGS, .unit = "chroma_loc"},
1108  {"top", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCHROMA_LOC_TOP}, 0, 0, FLAGS, .unit = "chroma_loc"},
1109  {"bottomleft", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCHROMA_LOC_BOTTOMLEFT}, 0, 0, FLAGS, .unit = "chroma_loc"},
1110  {"bottom", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCHROMA_LOC_BOTTOM}, 0, 0, FLAGS, .unit = "chroma_loc"},
1111  { "in_primaries", "set input primaries", OFFSET(in_primaries), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, AVCOL_PRI_NB-1, .flags = FLAGS, .unit = "primaries" },
1112  { "out_primaries", "set output primaries", OFFSET(out_primaries), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, AVCOL_PRI_NB-1, .flags = FLAGS, .unit = "primaries"},
1113  {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, .unit = "primaries"},
1114  {"bt709", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_BT709}, 0, 0, FLAGS, .unit = "primaries"},
1115  {"bt470m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_BT470M}, 0, 0, FLAGS, .unit = "primaries"},
1116  {"bt470bg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_BT470BG}, 0, 0, FLAGS, .unit = "primaries"},
1117  {"smpte170m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE170M}, 0, 0, FLAGS, .unit = "primaries"},
1118  {"smpte240m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE240M}, 0, 0, FLAGS, .unit = "primaries"},
1119  {"film", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_FILM}, 0, 0, FLAGS, .unit = "primaries"},
1120  {"bt2020", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_BT2020}, 0, 0, FLAGS, .unit = "primaries"},
1121  {"smpte428", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE428}, 0, 0, FLAGS, .unit = "primaries"},
1122  {"smpte431", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE431}, 0, 0, FLAGS, .unit = "primaries"},
1123  {"smpte432", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_SMPTE432}, 0, 0, FLAGS, .unit = "primaries"},
1124  {"jedec-p22", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_JEDEC_P22}, 0, 0, FLAGS, .unit = "primaries"},
1125  {"ebu3213", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_PRI_EBU3213}, 0, 0, FLAGS, .unit = "primaries"},
1126  { "in_transfer", "set output color transfer", OFFSET(in_transfer), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, AVCOL_TRC_NB-1, .flags = FLAGS, .unit = "transfer"},
1127  {"out_transfer", "set output color transfer", OFFSET(out_transfer), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, AVCOL_TRC_NB-1, .flags = FLAGS, .unit = "transfer"},
1128  {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64=-1}, 0, 0, FLAGS, .unit = "transfer"},
1129  {"bt709", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_BT709}, 0, 0, FLAGS, .unit = "transfer"},
1130  {"bt470m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_GAMMA22}, 0, 0, FLAGS, .unit = "transfer"},
1131  {"gamma22", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_GAMMA22}, 0, 0, FLAGS, .unit = "transfer"},
1132  {"bt470bg", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_GAMMA28}, 0, 0, FLAGS, .unit = "transfer"},
1133  {"gamma28", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_GAMMA28}, 0, 0, FLAGS, .unit = "transfer"},
1134  {"smpte170m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_SMPTE170M}, 0, 0, FLAGS, .unit = "transfer"},
1135  {"smpte240m", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_SMPTE240M}, 0, 0, FLAGS, .unit = "transfer"},
1136  {"linear", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_LINEAR}, 0, 0, FLAGS, .unit = "transfer"},
1137  {"iec61966-2-1", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_IEC61966_2_1}, 0, 0, FLAGS, .unit = "transfer"},
1138  {"srgb", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_IEC61966_2_1}, 0, 0, FLAGS, .unit = "transfer"},
1139  {"iec61966-2-4", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_IEC61966_2_4}, 0, 0, FLAGS, .unit = "transfer"},
1140  {"xvycc", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_IEC61966_2_4}, 0, 0, FLAGS, .unit = "transfer"},
1141  {"bt1361e", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_BT1361_ECG}, 0, 0, FLAGS, .unit = "transfer"},
1142  {"bt2020-10", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_BT2020_10}, 0, 0, FLAGS, .unit = "transfer"},
1143  {"bt2020-12", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_BT2020_12}, 0, 0, FLAGS, .unit = "transfer"},
1144  {"smpte2084", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_SMPTE2084}, 0, 0, FLAGS, .unit = "transfer"},
1145  {"smpte428", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_SMPTE428}, 0, 0, FLAGS, .unit = "transfer"},
1146  {"arib-std-b67", NULL, 0, AV_OPT_TYPE_CONST, {.i64=AVCOL_TRC_ARIB_STD_B67}, 0, 0, FLAGS, .unit = "transfer"},
1147  { "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 },
1148  { "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 },
1149  { "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 },
1150  { "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 },
1151  { "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, .unit = "force_oar" },
1152  { "disable", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, .unit = "force_oar" },
1153  { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, .unit = "force_oar" },
1154  { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, .unit = "force_oar" },
1155  { "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 },
1156  { "reset_sar", "reset SAR to 1 and scale to square pixels if scaling proportionally", OFFSET(reset_sar), AV_OPT_TYPE_BOOL, { .i64 = 0}, 0, 1, FLAGS },
1157  { "param0", "Scaler param 0", OFFSET(param[0]), AV_OPT_TYPE_DOUBLE, { .dbl = DBL_MAX }, -DBL_MAX, DBL_MAX, FLAGS },
1158  { "param1", "Scaler param 1", OFFSET(param[1]), AV_OPT_TYPE_DOUBLE, { .dbl = DBL_MAX }, -DBL_MAX, DBL_MAX, FLAGS },
1159  { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, .unit = "eval" },
1160  { "init", "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT}, .flags = FLAGS, .unit = "eval" },
1161  { "frame", "eval expressions during initialization and per-frame", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
1162  { NULL }
1163 };
1164 
1165 static const AVClass scale_class = {
1166  .class_name = "scale",
1167  .item_name = av_default_item_name,
1168  .option = scale_options,
1169  .version = LIBAVUTIL_VERSION_INT,
1170  .category = AV_CLASS_CATEGORY_FILTER,
1171  .child_class_iterate = child_class_iterate,
1172  .child_next = child_next,
1173 };
1174 
1175 static const AVFilterPad avfilter_vf_scale_inputs[] = {
1176  {
1177  .name = "default",
1178  .type = AVMEDIA_TYPE_VIDEO,
1179  },
1180 };
1181 
1182 static const AVFilterPad avfilter_vf_scale_outputs[] = {
1183  {
1184  .name = "default",
1185  .type = AVMEDIA_TYPE_VIDEO,
1186  .config_props = config_props,
1187  },
1188 };
1189 
1190 const FFFilter ff_vf_scale = {
1191  .p.name = "scale",
1192  .p.description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format."),
1193  .p.priv_class = &scale_class,
1194  .p.flags = AVFILTER_FLAG_DYNAMIC_INPUTS,
1195  .preinit = preinit,
1196  .init = init,
1197  .uninit = uninit,
1198  .priv_size = sizeof(ScaleContext),
1199  FILTER_INPUTS(avfilter_vf_scale_inputs),
1200  FILTER_OUTPUTS(avfilter_vf_scale_outputs),
1201  FILTER_QUERY_FUNC2(query_formats),
1202  .activate = activate,
1203  .process_command = process_command,
1204 };
1205 
1206 static const AVClass *scale2ref_child_class_iterate(void **iter)
1207 {
1208  const AVClass *c = *iter ? NULL : sws_get_class();
1209  *iter = (void*)(uintptr_t)c;
1210  return c;
1211 }
1212 
1213 static void *scale2ref_child_next(void *obj, void *prev)
1214 {
1215  ScaleContext *s = obj;
1216  if (!prev)
1217  return s->sws;
1218  return NULL;
1219 }
1220 
1221 static const AVClass scale2ref_class = {
1222  .class_name = "scale(2ref)",
1223  .item_name = av_default_item_name,
1224  .option = scale_options,
1225  .version = LIBAVUTIL_VERSION_INT,
1226  .category = AV_CLASS_CATEGORY_FILTER,
1227  .child_class_iterate = scale2ref_child_class_iterate,
1228  .child_next = scale2ref_child_next,
1229 };
1230 
1231 static const AVFilterPad avfilter_vf_scale2ref_inputs[] = {
1232  {
1233  .name = "default",
1234  .type = AVMEDIA_TYPE_VIDEO,
1235  .filter_frame = filter_frame,
1236  },
1237  {
1238  .name = "ref",
1239  .type = AVMEDIA_TYPE_VIDEO,
1240  .filter_frame = filter_frame_ref,
1241  },
1242 };
1243 
1244 static const AVFilterPad avfilter_vf_scale2ref_outputs[] = {
1245  {
1246  .name = "default",
1247  .type = AVMEDIA_TYPE_VIDEO,
1248  .config_props = config_props,
1249  .request_frame= request_frame,
1250  },
1251  {
1252  .name = "ref",
1253  .type = AVMEDIA_TYPE_VIDEO,
1254  .config_props = config_props_ref,
1255  .request_frame= request_frame_ref,
1256  },
1257 };
1258 
1259 const FFFilter ff_vf_scale2ref = {
1260  .p.name = "scale2ref",
1261  .p.description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format to the given reference."),
1262  .p.priv_class = &scale2ref_class,
1263  .preinit = preinit,
1264  .init = init,
1265  .uninit = uninit,
1266  .priv_size = sizeof(ScaleContext),
1267  FILTER_INPUTS(avfilter_vf_scale2ref_inputs),
1268  FILTER_OUTPUTS(avfilter_vf_scale2ref_outputs),
1269  FILTER_QUERY_FUNC2(query_formats),
1270  .process_command = process_command,
1271 };
filter_frame_ref
static int filter_frame_ref(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:976
ScaleContext::param
double param[2]
Definition: vf_scale.c:140
VAR_S2R_MAIN_SAR
@ VAR_S2R_MAIN_SAR
Definition: vf_scale.c:111
flags
const SwsFlags flags[]
Definition: swscale.c:61
formats
formats
Definition: signature.h:47
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:117
ScaleContext::fs
FFFrameSync fs
Definition: vf_scale.c:130
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:682
VAR_S2R_MAIN_A
@ VAR_S2R_MAIN_A
Definition: vf_scale.c:110
VAR_HSUB
@ VAR_HSUB
Definition: vf_scale.c:92
config_props_ref
static int config_props_ref(AVFilterLink *outlink)
Definition: vf_scale.c:715
ff_framesync_configure
int ff_framesync_configure(FFFrameSync *fs)
Configure a frame sync structure.
Definition: framesync.c:137
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:678
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
TFLAGS
#define TFLAGS
Definition: vf_scale.c:1068
AVCOL_PRI_EBU3213
@ AVCOL_PRI_EBU3213
EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors.
Definition: pixfmt.h:652
check_exprs
static int check_exprs(AVFilterContext *ctx)
Definition: vf_scale.c:184
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
AVALPHA_MODE_STRAIGHT
@ AVALPHA_MODE_STRAIGHT
Alpha channel is independent of color values.
Definition: pixfmt.h:803
var_name
var_name
Definition: noise.c:47
ScaleContext::in_primaries
int in_primaries
Definition: vf_scale.c:157
VAR_REF_POS
@ VAR_REF_POS
Definition: vf_scale.c:107
ff_framesync_uninit
void ff_framesync_uninit(FFFrameSync *fs)
Free all memory currently allocated.
Definition: framesync.c:301
out
FILE * out
Definition: movenc.c:55
ScaleContext
Definition: vf_scale.c:127
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1067
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3447
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:670
AVCHROMA_LOC_BOTTOM
@ AVCHROMA_LOC_BOTTOM
Definition: pixfmt.h:793
ScaleContext::force_divisible_by
int force_divisible_by
Definition: vf_scale.c:172
VAR_REF_N
@ VAR_REF_N
Definition: vf_scale.c:105
ff_framesync_get_frame
int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe, unsigned get)
Get the current frame in an input.
Definition: framesync.c:269
avfilter_vf_scale2ref_outputs
static const AVFilterPad avfilter_vf_scale2ref_outputs[]
Definition: vf_scale.c:1244
FLAGS
#define FLAGS
Definition: vf_scale.c:1067
int64_t
long long int64_t
Definition: coverity.c:34
ScaleContext::flags_str
char * flags_str
Definition: vf_scale.c:153
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
AVFrame::color_primaries
enum AVColorPrimaries color_primaries
Definition: frame.h:680
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:64
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:689
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:263
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
AVCOL_TRC_NB
@ AVCOL_TRC_NB
Not part of ABI.
Definition: pixfmt.h:683
pixdesc.h
AVFrame::pts
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:529
AVFrame::width
int width
Definition: frame.h:499
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:767
VAR_A
@ VAR_A
Definition: vf_scale.c:89
request_frame_ref
static int request_frame_ref(AVFilterLink *outlink)
Definition: vf_scale.c:737
sws_test_primaries
int sws_test_primaries(enum AVColorPrimaries prim, int output)
Test if a given set of color primaries is supported.
Definition: format.c:547
AVOption
AVOption.
Definition: opt.h:429
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:710
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:257
scale2ref_class
static const AVClass scale2ref_class
Definition: vf_scale.c:1221
request_frame
static int request_frame(AVFilterLink *outlink)
Definition: vf_scale.c:732
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:3454
VAR_REF_T
@ VAR_REF_T
Definition: vf_scale.c:106
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:483
VAR_S2R_MAIN_HSUB
@ VAR_S2R_MAIN_HSUB
Definition: vf_scale.c:113
ScaleContext::var_values
double var_values[VARS_NB]
Definition: vf_scale.c:151
ScaleContext::out_range
int out_range
Definition: vf_scale.c:162
AVCOL_PRI_JEDEC_P22
@ AVCOL_PRI_JEDEC_P22
Definition: pixfmt.h:653
VAR_S2R_MDAR
@ VAR_S2R_MDAR
Definition: vf_scale.c:112
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
float.h
AVCOL_TRC_BT2020_12
@ AVCOL_TRC_BT2020_12
ITU-R BT2020 for 12-bit system.
Definition: pixfmt.h:677
EVAL_MODE_FRAME
@ EVAL_MODE_FRAME
Definition: vf_scale.c:123
VAR_S2R_MAIN_H
@ VAR_S2R_MAIN_H
Definition: vf_scale.c:109
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:671
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:220
FFFrameSync
Frame sync structure.
Definition: framesync.h:168
EXT_INFINITY
@ EXT_INFINITY
Extend the frame to infinity.
Definition: framesync.h:75
ScaleContext::in_h_chr_pos
int in_h_chr_pos
Definition: vf_scale.c:168
VAR_OUT_H
@ VAR_OUT_H
Definition: vf_scale.c:88
video.h
ff_make_formats_list_singleton
AVFilterFormats * ff_make_formats_list_singleton(int fmt)
Equivalent to ff_make_format_list({const int[]}{ fmt, -1 })
Definition: formats.c:545
ScaleContext::out_chroma_loc
int out_chroma_loc
Definition: vf_scale.c:165
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:710
VAR_S2R_MAIN_POS
@ VAR_S2R_MAIN_POS
Definition: vf_scale.c:117
AVFrame::chroma_location
enum AVChromaLocation chroma_location
Definition: frame.h:691
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:696
EXT_STOP
@ EXT_STOP
Completely stop all streams with this one.
Definition: framesync.h:65
ff_append_inpad
int ff_append_inpad(AVFilterContext *f, AVFilterPad *p)
Append a new input/output pad to the filter's list of such pads.
Definition: avfilter.c:127
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:675
av_color_space_name
const char * av_color_space_name(enum AVColorSpace space)
Definition: pixdesc.c:3823
VAR_DAR
@ VAR_DAR
Definition: vf_scale.c:91
avfilter_vf_scale_inputs
static const AVFilterPad avfilter_vf_scale_inputs[]
Definition: vf_scale.c:1175
fail
#define fail()
Definition: checkasm.h:200
VARS_NB
@ VARS_NB
Definition: vf_scale.c:118
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:667
VAR_REF_A
@ VAR_REF_A
Definition: vf_scale.c:100
ScaleContext::eval_mode
int eval_mode
expression evaluation mode
Definition: vf_scale.c:175
EXT_NULL
@ EXT_NULL
Ignore this stream and continue processing the other ones.
Definition: framesync.h:70
VAR_IN_H
@ VAR_IN_H
Definition: vf_scale.c:86
EVAL_MODE_NB
@ EVAL_MODE_NB
Definition: vf_scale.c:124
ScaleContext::in_chroma_loc
int in_chroma_loc
Definition: vf_scale.c:164
sws_get_class
const AVClass * sws_get_class(void)
Get the AVClass for SwsContext.
Definition: options.c:107
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:835
VAR_REF_W
@ VAR_REF_W
Definition: vf_scale.c:98
AVFILTER_FLAG_DYNAMIC_INPUTS
#define AVFILTER_FLAG_DYNAMIC_INPUTS
The number of the filter inputs is not determined just by AVFilter.inputs.
Definition: avfilter.h:156
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:358
AVRational::num
int num
Numerator.
Definition: rational.h:59
OFFSET
#define OFFSET(x)
Definition: vf_scale.c:1066
AV_SIDE_DATA_PROP_SIZE_DEPENDENT
@ AV_SIDE_DATA_PROP_SIZE_DEPENDENT
Side data depends on the video dimensions.
Definition: frame.h:309
AVCOL_TRC_GAMMA22
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:666
preinit
static av_cold int preinit(AVFilterContext *ctx)
Definition: vf_scale.c:310
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:39
activate
static int activate(AVFilterContext *ctx)
Definition: vf_scale.c:1036
AV_PIX_FMT_BGR8
@ AV_PIX_FMT_BGR8
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:90
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
VAR_REF_H
@ VAR_REF_H
Definition: vf_scale.c:99
scale2ref_child_next
static void * scale2ref_child_next(void *obj, void *prev)
Definition: vf_scale.c:1213
FFFilter
Definition: filters.h:266
ScaleContext::reset_sar
int reset_sar
Definition: vf_scale.c:173
s
#define s(width, name)
Definition: cbs_vp9.c:198
VAR_OH
@ VAR_OH
Definition: vf_scale.c:88
AVCHROMA_LOC_TOP
@ AVCHROMA_LOC_TOP
Definition: pixfmt.h:791
AVCOL_PRI_NB
@ AVCOL_PRI_NB
Not part of ABI.
Definition: pixfmt.h:654
ScaleContext::out_primaries
int out_primaries
Definition: vf_scale.c:158
VAR_S2R_MAIN_W
@ VAR_S2R_MAIN_W
Definition: vf_scale.c:108
AVCOL_TRC_BT1361_ECG
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:674
ScaleContext::slice_y
int slice_y
top of current output slice
Definition: vf_scale.c:143
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Underlying C type is double.
Definition: opt.h:267
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:782
query_formats
static int query_formats(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: vf_scale.c:451
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:705
init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_scale.c:328
VAR_OVSUB
@ VAR_OVSUB
Definition: vf_scale.c:95
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
filters.h
ScaleContext::uses_ref
int uses_ref
Definition: vf_scale.c:145
sws_test_colorspace
int sws_test_colorspace(enum AVColorSpace csp, int output)
Test if a given color space is supported.
Definition: format.c:530
ctx
AVFormatContext * ctx
Definition: movenc.c:49
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:1011
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
AVCOL_PRI_SMPTE428
@ AVCOL_PRI_SMPTE428
SMPTE ST 428-1 (CIE 1931 XYZ)
Definition: pixfmt.h:648
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
AVExpr
Definition: eval.c:158
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
AVCOL_PRI_SMPTE240M
@ AVCOL_PRI_SMPTE240M
identical to above, also called "SMPTE C" even though it uses D65
Definition: pixfmt.h:645
ScaleContext::w_pexpr
AVExpr * w_pexpr
Definition: vf_scale.c:149
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:264
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
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
AVCOL_PRI_BT470BG
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:643
AVCOL_PRI_SMPTE170M
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:644
ScaleContext::out_h_chr_pos
int out_h_chr_pos
Definition: vf_scale.c:166
av_color_range_name
const char * av_color_range_name(enum AVColorRange range)
Definition: pixdesc.c:3763
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
VAR_REF_DAR
@ VAR_REF_DAR
Definition: vf_scale.c:102
ff_framesync_class
const AVClass ff_framesync_class
Definition: framesync.c:54
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
ScaleContext::out_v_chr_pos
int out_v_chr_pos
Definition: vf_scale.c:167
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:599
VAR_T
@ VAR_T
Definition: vf_scale.c:97
fs
#define fs(width, name, subs,...)
Definition: cbs_vp9.c:200
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:788
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:790
sws_is_noop
int sws_is_noop(const AVFrame *dst, const AVFrame *src)
Check if a given conversion is a noop.
Definition: format.c:594
AVCOL_TRC_IEC61966_2_4
@ AVCOL_TRC_IEC61966_2_4
IEC 61966-2-4.
Definition: pixfmt.h:673
isnan
#define isnan(x)
Definition: libm.h:342
scale2ref_child_class_iterate
static const AVClass * scale2ref_child_class_iterate(void **iter)
Definition: vf_scale.c:1206
ScaleContext::in_range
int in_range
Definition: vf_scale.c:161
AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:282
VAR_IN_W
@ VAR_IN_W
Definition: vf_scale.c:85
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:638
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:241
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:520
parseutils.h
sws_test_format
int sws_test_format(enum AVPixelFormat format, int output)
Test if a given pixel format is supported.
Definition: format.c:525
ScaleContext::h_pexpr
AVExpr * h_pexpr
Definition: vf_scale.c:150
av_color_primaries_name
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
Definition: pixdesc.c:3781
double
double
Definition: af_crystalizer.c:132
AVCOL_TRC_BT2020_10
@ AVCOL_TRC_BT2020_10
ITU-R BT2020 for 10-bit system.
Definition: pixfmt.h:676
ScaleContext::out_transfer
int out_transfer
Definition: vf_scale.c:160
ff_all_color_spaces
AVFilterFormats * ff_all_color_spaces(void)
Construct an AVFilterFormats representing all possible color spaces.
Definition: formats.c:646
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:733
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
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:121
ScaleContext::out_color_matrix
int out_color_matrix
Definition: vf_scale.c:156
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:198
AV_CLASS_CATEGORY_FILTER
@ AV_CLASS_CATEGORY_FILTER
Definition: log.h:36
AVCOL_PRI_BT2020
@ AVCOL_PRI_BT2020
ITU-R BT2020.
Definition: pixfmt.h:647
VAR_IW
@ VAR_IW
Definition: vf_scale.c:85
ScaleContext::in_transfer
int in_transfer
Definition: vf_scale.c:159
ScaleContext::sws
SwsContext * sws
Definition: vf_scale.c:129
AVCOL_TRC_SMPTE2084
@ AVCOL_TRC_SMPTE2084
SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.
Definition: pixfmt.h:678
AVCOL_PRI_SMPTE431
@ AVCOL_PRI_SMPTE431
SMPTE ST 431-2 (2011) / DCI P3.
Definition: pixfmt.h:650
eval.h
VAR_IH
@ VAR_IH
Definition: vf_scale.c:86
VAR_REF_SAR
@ VAR_REF_SAR
Definition: vf_scale.c:101
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:94
AVCOL_TRC_SMPTE240M
@ AVCOL_TRC_SMPTE240M
Definition: pixfmt.h:669
AVCOL_PRI_FILM
@ AVCOL_PRI_FILM
colour filters using Illuminant C
Definition: pixfmt.h:646
sws_alloc_context
SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext and set its fields to default values.
Definition: utils.c:1018
AVClass::child_next
void *(* child_next)(void *obj, void *prev)
Return next AVOptions-enabled child or NULL.
Definition: log.h:150
child_class_iterate
static const AVClass * child_class_iterate(void **iter)
Definition: vf_scale.c:1042
ScaleContext::w
int w
New dimensions.
Definition: vf_scale.c:138
AVFrame::time_base
AVRational time_base
Time base for the timestamps in this frame.
Definition: frame.h:544
scale_frame
static int scale_frame(AVFilterLink *link, AVFrame **frame_in, AVFrame **frame_out)
Definition: vf_scale.c:743
VAR_RH
@ VAR_RH
Definition: vf_scale.c:99
TS2T
#define TS2T(ts, tb)
Definition: filters.h:482
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:787
IS_SCALE2REF
#define IS_SCALE2REF(ctx)
Definition: vf_scale.c:180
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:514
scale_eval.h
VAR_RW
@ VAR_RW
Definition: vf_scale.c:98
ScaleContext::hsub
int hsub
Definition: vf_scale.c:142
VAR_OUT_W
@ VAR_OUT_W
Definition: vf_scale.c:87
imgutils_internal.h
sws_test_transfer
int sws_test_transfer(enum AVColorTransferCharacteristic trc, int output)
Test if a given color transfer function is supported.
Definition: format.c:553
ff_all_color_ranges
AVFilterFormats * ff_all_color_ranges(void)
Construct an AVFilterFormats representing all possible color ranges.
Definition: formats.c:662
av_pix_fmt_desc_get_id
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:3466
filter_frame
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:962
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
av_frame_side_data_remove_by_props
void av_frame_side_data_remove_by_props(AVFrameSideData ***sd, int *nb_sd, int props)
Remove and free all side data instances that match any of the given side data properties.
Definition: side_data.c:117
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:663
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:698
ScaleContext::vsub
int vsub
chroma subsampling
Definition: vf_scale.c:142
config_props
static int config_props(AVFilterLink *outlink)
Definition: vf_scale.c:621
interlaced
uint8_t interlaced
Definition: mxfenc.c:2315
VAR_SAR
@ VAR_SAR
Definition: vf_scale.c:90
VAR_RDAR
@ VAR_RDAR
Definition: vf_scale.c:102
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:701
VAR_S2R_MAIN_N
@ VAR_S2R_MAIN_N
Definition: vf_scale.c:115
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:845
EvalMode
EvalMode
Definition: af_volume.h:39
FILTER_QUERY_FUNC2
#define FILTER_QUERY_FUNC2(func)
Definition: filters.h:240
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:45
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:693
ScaleContext::h_expr
char * h_expr
height expression string
Definition: vf_scale.c:148
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:650
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:750
AV_SIDE_DATA_PROP_COLOR_DEPENDENT
@ AV_SIDE_DATA_PROP_COLOR_DEPENDENT
Side data depends on the video color space.
Definition: frame.h:316
avfilter_vf_scale_outputs
static const AVFilterPad avfilter_vf_scale_outputs[]
Definition: vf_scale.c:1182
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:84
AVCOL_PRI_BT470M
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:641
ret
ret
Definition: filter_design.txt:187
pixfmt.h
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:81
ScaleContext::in_color_matrix
int in_color_matrix
Definition: vf_scale.c:155
VAR_REF_HSUB
@ VAR_REF_HSUB
Definition: vf_scale.c:103
child_next
static void * child_next(void *obj, void *prev)
Definition: vf_scale.c:1056
ff_framesync_init
int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in)
Initialize a frame sync structure.
Definition: framesync.c:86
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:524
VAR_S2R_MAIN_T
@ VAR_S2R_MAIN_T
Definition: vf_scale.c:116
scale_eval_dimensions
static int scale_eval_dimensions(AVFilterContext *ctx)
Definition: vf_scale.c:532
var_names
static const char *const var_names[]
Definition: vf_scale.c:46
AVFrame::height
int height
Definition: frame.h:499
VAR_S2R_MAIN_DAR
@ VAR_S2R_MAIN_DAR
Definition: vf_scale.c:112
scale_options
static const AVOption scale_options[]
Definition: vf_scale.c:1070
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:682
framesync.h
do_scale
static int do_scale(FFFrameSync *fs)
Definition: vf_scale.c:899
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:789
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:695
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avfilter.h
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_scale.c:441
ScaleContext::force_original_aspect_ratio
int force_original_aspect_ratio
Definition: vf_scale.c:171
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
AVCOL_TRC_SMPTE170M
@ AVCOL_TRC_SMPTE170M
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:668
avfilter_vf_scale2ref_inputs
static const AVFilterPad avfilter_vf_scale2ref_inputs[]
Definition: vf_scale.c:1231
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:274
VAR_OW
@ VAR_OW
Definition: vf_scale.c:87
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
desc
const char * desc
Definition: libsvtav1.c:79
VAR_VSUB
@ VAR_VSUB
Definition: vf_scale.c:93
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
FFFilter::p
AVFilter p
The public AVFilter.
Definition: filters.h:270
mem.h
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVCOL_PRI_SMPTE432
@ AVCOL_PRI_SMPTE432
SMPTE ST 432-1 (2010) / P3 D65 / Display P3.
Definition: pixfmt.h:651
ScaleContext::interlaced
int interlaced
Definition: vf_scale.c:144
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
VAR_N
@ VAR_N
Definition: vf_scale.c:96
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
ff_vf_scale2ref
const FFFilter ff_vf_scale2ref
Definition: vf_scale.c:179
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
scale_class
static const AVClass scale_class
Definition: vf_scale.c:1165
ScaleContext::w_expr
char * w_expr
width expression string
Definition: vf_scale.c:147
ff_vf_scale
const FFFilter ff_vf_scale
Definition: vf_scale.c:1190
sws_free_context
void sws_free_context(SwsContext **ctx)
Free the context and everything associated with it, and write NULL to the provided pointer.
Definition: utils.c:2326
EVAL_MODE_INIT
@ EVAL_MODE_INIT
Definition: vf_scale.c:122
AVCHROMA_LOC_NB
@ AVCHROMA_LOC_NB
Not part of ABI.
Definition: pixfmt.h:794
av_opt_get
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
Definition: opt.c:1215
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVCOL_TRC_SMPTE428
@ AVCOL_TRC_SMPTE428
SMPTE ST 428-1.
Definition: pixfmt.h:680
VAR_REF_VSUB
@ VAR_REF_VSUB
Definition: vf_scale.c:104
h
h
Definition: vp9dsp_template.c:2070
sws_scale_frame
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image dimensions or settings change in any way sws_scale_frame() is itself just a light-weight wrapper that runs ff_sws_graph_create() whenever the format changes
ff_framesync_activate
int ff_framesync_activate(FFFrameSync *fs)
Examine the frames in the filter's input and try to produce output.
Definition: framesync.c:352
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Underlying C type is a uint8_t* that is either NULL or points to a C string allocated with the av_mal...
Definition: opt.h:276
VAR_OHSUB
@ VAR_OHSUB
Definition: vf_scale.c:94
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:692
SwsContext
Main external API structure.
Definition: swscale.h:189
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
ScaleContext::size_str
char * size_str
Definition: vf_scale.c:139
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3802
VAR_S2R_MAIN_VSUB
@ VAR_S2R_MAIN_VSUB
Definition: vf_scale.c:114
AVCHROMA_LOC_BOTTOMLEFT
@ AVCHROMA_LOC_BOTTOMLEFT
Definition: pixfmt.h:792
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, double w_adj)
Transform evaluated width and height obtained from ff_scale_eval_dimensions into actual target width ...
Definition: scale_eval.c:113
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
ff_framesync_preinit
void ff_framesync_preinit(FFFrameSync *fs)
Pre-initialize a frame sync structure.
Definition: framesync.c:78
swscale.h
ScaleContext::h
int h
Definition: vf_scale.c:138
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:311
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:3367
ScaleContext::in_v_chr_pos
int in_v_chr_pos
Definition: vf_scale.c:169
Generated on Thu Sep 4 2025 19:23:22 for FFmpeg by   doxygen 1.8.17