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