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 <stdio.h>
27 #include <string.h>
28 
29 #include "avfilter.h"
30 #include "formats.h"
31 #include "internal.h"
32 #include "scale.h"
33 #include "video.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/internal.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/opt.h"
38 #include "libavutil/parseutils.h"
39 #include "libavutil/pixdesc.h"
40 #include "libavutil/imgutils.h"
41 #include "libavutil/avassert.h"
42 #include "libswscale/swscale.h"
43 
44 enum EvalMode {
48 };
49 
50 typedef struct ScaleContext {
51  const AVClass *class;
52  struct SwsContext *sws; ///< software scaler context
53  struct SwsContext *isws[2]; ///< software scaler context for interlaced material
55 
56  /**
57  * New dimensions. Special values are:
58  * 0 = original width/height
59  * -1 = keep original aspect
60  * -N = try to keep aspect but make sure it is divisible by N
61  */
62  int w, h;
63  char *size_str;
64  unsigned int flags; ///sws flags
65  double param[2]; // sws params
66 
67  int hsub, vsub; ///< chroma subsampling
68  int slice_y; ///< top of current output slice
69  int input_is_pal; ///< set to 1 if the input format is paletted
70  int output_is_pal; ///< set to 1 if the output format is paletted
72 
73  char *w_expr; ///< width expression string
74  char *h_expr; ///< height expression string
75  char *flags_str;
76 
79 
80  int in_range;
81  int out_range;
82 
87 
89 
90  int nb_slices;
91 
92  int eval_mode; ///< expression evaluation mode
93 
94 } ScaleContext;
95 
97 
99 {
100  ScaleContext *scale = ctx->priv;
101  int ret;
102 
103  if (scale->size_str && (scale->w_expr || scale->h_expr)) {
104  av_log(ctx, AV_LOG_ERROR,
105  "Size and width/height expressions cannot be set at the same time.\n");
106  return AVERROR(EINVAL);
107  }
108 
109  if (scale->w_expr && !scale->h_expr)
110  FFSWAP(char *, scale->w_expr, scale->size_str);
111 
112  if (scale->size_str) {
113  char buf[32];
114  if ((ret = av_parse_video_size(&scale->w, &scale->h, scale->size_str)) < 0) {
115  av_log(ctx, AV_LOG_ERROR,
116  "Invalid size '%s'\n", scale->size_str);
117  return ret;
118  }
119  snprintf(buf, sizeof(buf)-1, "%d", scale->w);
120  av_opt_set(scale, "w", buf, 0);
121  snprintf(buf, sizeof(buf)-1, "%d", scale->h);
122  av_opt_set(scale, "h", buf, 0);
123  }
124  if (!scale->w_expr)
125  av_opt_set(scale, "w", "iw", 0);
126  if (!scale->h_expr)
127  av_opt_set(scale, "h", "ih", 0);
128 
129  av_log(ctx, AV_LOG_VERBOSE, "w:%s h:%s flags:'%s' interl:%d\n",
130  scale->w_expr, scale->h_expr, (char *)av_x_if_null(scale->flags_str, ""), scale->interlaced);
131 
132  scale->flags = 0;
133 
134  if (scale->flags_str) {
135  const AVClass *class = sws_get_class();
136  const AVOption *o = av_opt_find(&class, "sws_flags", NULL, 0,
138  int ret = av_opt_eval_flags(&class, o, scale->flags_str, &scale->flags);
139  if (ret < 0)
140  return ret;
141  }
142  scale->opts = *opts;
143  *opts = NULL;
144 
145  return 0;
146 }
147 
149 {
150  ScaleContext *scale = ctx->priv;
151  sws_freeContext(scale->sws);
152  sws_freeContext(scale->isws[0]);
153  sws_freeContext(scale->isws[1]);
154  scale->sws = NULL;
155  av_dict_free(&scale->opts);
156 }
157 
159 {
161  enum AVPixelFormat pix_fmt;
162  int ret;
163 
164  if (ctx->inputs[0]) {
165  const AVPixFmtDescriptor *desc = NULL;
166  formats = NULL;
167  while ((desc = av_pix_fmt_desc_next(desc))) {
168  pix_fmt = av_pix_fmt_desc_get_id(desc);
169  if ((sws_isSupportedInput(pix_fmt) ||
171  && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
172  return ret;
173  }
174  }
175  if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0)
176  return ret;
177  }
178  if (ctx->outputs[0]) {
179  const AVPixFmtDescriptor *desc = NULL;
180  formats = NULL;
181  while ((desc = av_pix_fmt_desc_next(desc))) {
182  pix_fmt = av_pix_fmt_desc_get_id(desc);
183  if ((sws_isSupportedOutput(pix_fmt) || pix_fmt == AV_PIX_FMT_PAL8 ||
185  && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
186  return ret;
187  }
188  }
189  if ((ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0)
190  return ret;
191  }
192 
193  return 0;
194 }
195 
196 static const int *parse_yuv_type(const char *s, enum AVColorSpace colorspace)
197 {
198  if (!s)
199  s = "bt601";
200 
201  if (s && strstr(s, "bt709")) {
202  colorspace = AVCOL_SPC_BT709;
203  } else if (s && strstr(s, "fcc")) {
204  colorspace = AVCOL_SPC_FCC;
205  } else if (s && strstr(s, "smpte240m")) {
206  colorspace = AVCOL_SPC_SMPTE240M;
207  } else if (s && (strstr(s, "bt601") || strstr(s, "bt470") || strstr(s, "smpte170m"))) {
208  colorspace = AVCOL_SPC_BT470BG;
209  } else if (s && strstr(s, "bt2020")) {
210  colorspace = AVCOL_SPC_BT2020_NCL;
211  }
212 
213  if (colorspace < 1 || colorspace > 10 || colorspace == 8) {
214  colorspace = AVCOL_SPC_BT470BG;
215  }
216 
217  return sws_getCoefficients(colorspace);
218 }
219 
220 static int config_props(AVFilterLink *outlink)
221 {
222  AVFilterContext *ctx = outlink->src;
223  AVFilterLink *inlink0 = outlink->src->inputs[0];
224  AVFilterLink *inlink = ctx->filter == &ff_vf_scale2ref ?
225  outlink->src->inputs[1] :
226  outlink->src->inputs[0];
227  enum AVPixelFormat outfmt = outlink->format;
229  ScaleContext *scale = ctx->priv;
230  int w, h;
231  int ret;
232 
233  if ((ret = ff_scale_eval_dimensions(ctx,
234  scale->w_expr, scale->h_expr,
235  inlink, outlink,
236  &w, &h)) < 0)
237  goto fail;
238 
239  /* Note that force_original_aspect_ratio may overwrite the previous set
240  * dimensions so that it is not divisible by the set factors anymore. */
241  if (scale->force_original_aspect_ratio) {
242  int tmp_w = av_rescale(h, inlink->w, inlink->h);
243  int tmp_h = av_rescale(w, inlink->h, inlink->w);
244 
245  if (scale->force_original_aspect_ratio == 1) {
246  w = FFMIN(tmp_w, w);
247  h = FFMIN(tmp_h, h);
248  } else {
249  w = FFMAX(tmp_w, w);
250  h = FFMAX(tmp_h, h);
251  }
252  }
253 
254  if (w > INT_MAX || h > INT_MAX ||
255  (h * inlink->w) > INT_MAX ||
256  (w * inlink->h) > INT_MAX)
257  av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
258 
259  outlink->w = w;
260  outlink->h = h;
261 
262  /* TODO: make algorithm configurable */
263 
264  scale->input_is_pal = desc->flags & AV_PIX_FMT_FLAG_PAL;
265  if (outfmt == AV_PIX_FMT_PAL8) outfmt = AV_PIX_FMT_BGR8;
268 
269  if (scale->sws)
270  sws_freeContext(scale->sws);
271  if (scale->isws[0])
272  sws_freeContext(scale->isws[0]);
273  if (scale->isws[1])
274  sws_freeContext(scale->isws[1]);
275  scale->isws[0] = scale->isws[1] = scale->sws = NULL;
276  if (inlink0->w == outlink->w &&
277  inlink0->h == outlink->h &&
278  !scale->out_color_matrix &&
279  scale->in_range == scale->out_range &&
280  inlink0->format == outlink->format)
281  ;
282  else {
283  struct SwsContext **swscs[3] = {&scale->sws, &scale->isws[0], &scale->isws[1]};
284  int i;
285 
286  for (i = 0; i < 3; i++) {
287  int in_v_chr_pos = scale->in_v_chr_pos, out_v_chr_pos = scale->out_v_chr_pos;
288  struct SwsContext **s = swscs[i];
289  *s = sws_alloc_context();
290  if (!*s)
291  return AVERROR(ENOMEM);
292 
293  av_opt_set_int(*s, "srcw", inlink0 ->w, 0);
294  av_opt_set_int(*s, "srch", inlink0 ->h >> !!i, 0);
295  av_opt_set_int(*s, "src_format", inlink0->format, 0);
296  av_opt_set_int(*s, "dstw", outlink->w, 0);
297  av_opt_set_int(*s, "dsth", outlink->h >> !!i, 0);
298  av_opt_set_int(*s, "dst_format", outfmt, 0);
299  av_opt_set_int(*s, "sws_flags", scale->flags, 0);
300  av_opt_set_int(*s, "param0", scale->param[0], 0);
301  av_opt_set_int(*s, "param1", scale->param[1], 0);
302  if (scale->in_range != AVCOL_RANGE_UNSPECIFIED)
303  av_opt_set_int(*s, "src_range",
304  scale->in_range == AVCOL_RANGE_JPEG, 0);
305  if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
306  av_opt_set_int(*s, "dst_range",
307  scale->out_range == AVCOL_RANGE_JPEG, 0);
308 
309  if (scale->opts) {
310  AVDictionaryEntry *e = NULL;
311  while ((e = av_dict_get(scale->opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
312  if ((ret = av_opt_set(*s, e->key, e->value, 0)) < 0)
313  return ret;
314  }
315  }
316  /* Override YUV420P default settings to have the correct (MPEG-2) chroma positions
317  * MPEG-2 chroma positions are used by convention
318  * XXX: support other 4:2:0 pixel formats */
319  if (inlink0->format == AV_PIX_FMT_YUV420P && scale->in_v_chr_pos == -513) {
320  in_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
321  }
322 
323  if (outlink->format == AV_PIX_FMT_YUV420P && scale->out_v_chr_pos == -513) {
324  out_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
325  }
326 
327  av_opt_set_int(*s, "src_h_chr_pos", scale->in_h_chr_pos, 0);
328  av_opt_set_int(*s, "src_v_chr_pos", in_v_chr_pos, 0);
329  av_opt_set_int(*s, "dst_h_chr_pos", scale->out_h_chr_pos, 0);
330  av_opt_set_int(*s, "dst_v_chr_pos", out_v_chr_pos, 0);
331 
332  if ((ret = sws_init_context(*s, NULL, NULL)) < 0)
333  return ret;
334  if (!scale->interlaced)
335  break;
336  }
337  }
338 
339  if (inlink0->sample_aspect_ratio.num){
340  outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h * inlink0->w, outlink->w * inlink0->h}, inlink0->sample_aspect_ratio);
341  } else
342  outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
343 
344  av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d fmt:%s sar:%d/%d -> w:%d h:%d fmt:%s sar:%d/%d flags:0x%0x\n",
345  inlink ->w, inlink ->h, av_get_pix_fmt_name( inlink->format),
347  outlink->w, outlink->h, av_get_pix_fmt_name(outlink->format),
348  outlink->sample_aspect_ratio.num, outlink->sample_aspect_ratio.den,
349  scale->flags);
350  return 0;
351 
352 fail:
353  return ret;
354 }
355 
356 static int config_props_ref(AVFilterLink *outlink)
357 {
358  AVFilterLink *inlink = outlink->src->inputs[1];
359 
360  outlink->w = inlink->w;
361  outlink->h = inlink->h;
362  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
363  outlink->time_base = inlink->time_base;
364  outlink->frame_rate = inlink->frame_rate;
365 
366  return 0;
367 }
368 
369 static int request_frame(AVFilterLink *outlink)
370 {
371  return ff_request_frame(outlink->src->inputs[0]);
372 }
373 
374 static int request_frame_ref(AVFilterLink *outlink)
375 {
376  return ff_request_frame(outlink->src->inputs[1]);
377 }
378 
379 static int scale_slice(AVFilterLink *link, AVFrame *out_buf, AVFrame *cur_pic, struct SwsContext *sws, int y, int h, int mul, int field)
380 {
381  ScaleContext *scale = link->dst->priv;
382  const uint8_t *in[4];
383  uint8_t *out[4];
384  int in_stride[4],out_stride[4];
385  int i;
386 
387  for(i=0; i<4; i++){
388  int vsub= ((i+1)&2) ? scale->vsub : 0;
389  in_stride[i] = cur_pic->linesize[i] * mul;
390  out_stride[i] = out_buf->linesize[i] * mul;
391  in[i] = cur_pic->data[i] + ((y>>vsub)+field) * cur_pic->linesize[i];
392  out[i] = out_buf->data[i] + field * out_buf->linesize[i];
393  }
394  if(scale->input_is_pal)
395  in[1] = cur_pic->data[1];
396  if(scale->output_is_pal)
397  out[1] = out_buf->data[1];
398 
399  return sws_scale(sws, in, in_stride, y/mul, h,
400  out,out_stride);
401 }
402 
404 {
405  ScaleContext *scale = link->dst->priv;
406  AVFilterLink *outlink = link->dst->outputs[0];
407  AVFrame *out;
409  char buf[32];
410  int in_range;
411 
412  if (in->colorspace == AVCOL_SPC_YCGCO)
413  av_log(link->dst, AV_LOG_WARNING, "Detected unsupported YCgCo colorspace.\n");
414 
415  if( in->width != link->w
416  || in->height != link->h
417  || in->format != link->format
419  int ret;
420 
421  if (scale->eval_mode == EVAL_MODE_INIT) {
422  snprintf(buf, sizeof(buf)-1, "%d", outlink->w);
423  av_opt_set(scale, "w", buf, 0);
424  snprintf(buf, sizeof(buf)-1, "%d", outlink->h);
425  av_opt_set(scale, "h", buf, 0);
426  }
427 
428  link->dst->inputs[0]->format = in->format;
429  link->dst->inputs[0]->w = in->width;
430  link->dst->inputs[0]->h = in->height;
431 
434 
435 
436  if ((ret = config_props(outlink)) < 0)
437  return ret;
438  }
439 
440  if (!scale->sws)
441  return ff_filter_frame(outlink, in);
442 
443  scale->hsub = desc->log2_chroma_w;
444  scale->vsub = desc->log2_chroma_h;
445 
446  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
447  if (!out) {
448  av_frame_free(&in);
449  return AVERROR(ENOMEM);
450  }
451 
452  av_frame_copy_props(out, in);
453  out->width = outlink->w;
454  out->height = outlink->h;
455 
456  if(scale->output_is_pal)
457  avpriv_set_systematic_pal2((uint32_t*)out->data[1], outlink->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : outlink->format);
458 
459  in_range = in->color_range;
460 
461  if ( scale->in_color_matrix
462  || scale->out_color_matrix
463  || scale-> in_range != AVCOL_RANGE_UNSPECIFIED
464  || in_range != AVCOL_RANGE_UNSPECIFIED
465  || scale->out_range != AVCOL_RANGE_UNSPECIFIED) {
466  int in_full, out_full, brightness, contrast, saturation;
467  const int *inv_table, *table;
468 
469  sws_getColorspaceDetails(scale->sws, (int **)&inv_table, &in_full,
470  (int **)&table, &out_full,
471  &brightness, &contrast, &saturation);
472 
473  if (scale->in_color_matrix)
474  inv_table = parse_yuv_type(scale->in_color_matrix, in->colorspace);
475  if (scale->out_color_matrix)
477  else if (scale->in_color_matrix)
478  table = inv_table;
479 
480  if (scale-> in_range != AVCOL_RANGE_UNSPECIFIED)
481  in_full = (scale-> in_range == AVCOL_RANGE_JPEG);
482  else if (in_range != AVCOL_RANGE_UNSPECIFIED)
483  in_full = (in_range == AVCOL_RANGE_JPEG);
484  if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
485  out_full = (scale->out_range == AVCOL_RANGE_JPEG);
486 
487  sws_setColorspaceDetails(scale->sws, inv_table, in_full,
488  table, out_full,
489  brightness, contrast, saturation);
490  if (scale->isws[0])
491  sws_setColorspaceDetails(scale->isws[0], inv_table, in_full,
492  table, out_full,
493  brightness, contrast, saturation);
494  if (scale->isws[1])
495  sws_setColorspaceDetails(scale->isws[1], inv_table, in_full,
496  table, out_full,
497  brightness, contrast, saturation);
498 
499  out->color_range = out_full ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
500  }
501 
503  (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
504  (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
505  INT_MAX);
506 
507  if(scale->interlaced>0 || (scale->interlaced<0 && in->interlaced_frame)){
508  scale_slice(link, out, in, scale->isws[0], 0, (link->h+1)/2, 2, 0);
509  scale_slice(link, out, in, scale->isws[1], 0, link->h /2, 2, 1);
510  }else if (scale->nb_slices) {
511  int i, slice_h, slice_start, slice_end = 0;
512  const int nb_slices = FFMIN(scale->nb_slices, link->h);
513  for (i = 0; i < nb_slices; i++) {
514  slice_start = slice_end;
515  slice_end = (link->h * (i+1)) / nb_slices;
516  slice_h = slice_end - slice_start;
517  scale_slice(link, out, in, scale->sws, slice_start, slice_h, 1, 0);
518  }
519  }else{
520  scale_slice(link, out, in, scale->sws, 0, link->h, 1, 0);
521  }
522 
523  av_frame_free(&in);
524  return ff_filter_frame(outlink, out);
525 }
526 
528 {
529  AVFilterLink *outlink = link->dst->outputs[1];
530 
531  return ff_filter_frame(outlink, in);
532 }
533 
534 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
535  char *res, int res_len, int flags)
536 {
537  ScaleContext *scale = ctx->priv;
538  int ret;
539 
540  if ( !strcmp(cmd, "width") || !strcmp(cmd, "w")
541  || !strcmp(cmd, "height") || !strcmp(cmd, "h")) {
542 
543  int old_w = scale->w;
544  int old_h = scale->h;
545  AVFilterLink *outlink = ctx->outputs[0];
546 
547  av_opt_set(scale, cmd, args, 0);
548  if ((ret = config_props(outlink)) < 0) {
549  scale->w = old_w;
550  scale->h = old_h;
551  }
552  } else
553  ret = AVERROR(ENOSYS);
554 
555  return ret;
556 }
557 
558 static const AVClass *child_class_next(const AVClass *prev)
559 {
560  return prev ? NULL : sws_get_class();
561 }
562 
563 #define OFFSET(x) offsetof(ScaleContext, x)
564 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
565 
566 static const AVOption scale_options[] = {
567  { "w", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
568  { "width", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
569  { "h", "Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
570  { "height","Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
571  { "flags", "Flags to pass to libswscale", OFFSET(flags_str), AV_OPT_TYPE_STRING, { .str = "bilinear" }, .flags = FLAGS },
572  { "interl", "set interlacing", OFFSET(interlaced), AV_OPT_TYPE_BOOL, {.i64 = 0 }, -1, 1, FLAGS },
573  { "size", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },
574  { "s", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },
575  { "in_color_matrix", "set input YCbCr type", OFFSET(in_color_matrix), AV_OPT_TYPE_STRING, { .str = "auto" }, .flags = FLAGS },
576  { "out_color_matrix", "set output YCbCr type", OFFSET(out_color_matrix), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
577  { "in_range", "set input color range", OFFSET( in_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },
578  { "out_range", "set output color range", OFFSET(out_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },
579  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },
580  { "unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },
581  { "full", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
582  { "limited",NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
583  { "jpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
584  { "mpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
585  { "tv", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
586  { "pc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
587  { "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 },
588  { "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 },
589  { "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 },
590  { "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 },
591  { "force_original_aspect_ratio", "decrease or increase w/h if necessary to keep the original AR", OFFSET(force_original_aspect_ratio), AV_OPT_TYPE_INT, { .i64 = 0}, 0, 2, FLAGS, "force_oar" },
592  { "disable", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },
593  { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },
594  { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },
595  { "param0", "Scaler param 0", OFFSET(param[0]), AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT }, INT_MIN, INT_MAX, FLAGS },
596  { "param1", "Scaler param 1", OFFSET(param[1]), AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT }, INT_MIN, INT_MAX, FLAGS },
597  { "nb_slices", "set the number of slices (debug purpose only)", OFFSET(nb_slices), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
598  { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
599  { "init", "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT}, .flags = FLAGS, .unit = "eval" },
600  { "frame", "eval expressions during initialization and per-frame", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
601  { NULL }
602 };
603 
604 static const AVClass scale_class = {
605  .class_name = "scale",
606  .item_name = av_default_item_name,
607  .option = scale_options,
608  .version = LIBAVUTIL_VERSION_INT,
609  .category = AV_CLASS_CATEGORY_FILTER,
610  .child_class_next = child_class_next,
611 };
612 
614  {
615  .name = "default",
616  .type = AVMEDIA_TYPE_VIDEO,
617  .filter_frame = filter_frame,
618  },
619  { NULL }
620 };
621 
623  {
624  .name = "default",
625  .type = AVMEDIA_TYPE_VIDEO,
626  .config_props = config_props,
627  },
628  { NULL }
629 };
630 
632  .name = "scale",
633  .description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format."),
634  .init_dict = init_dict,
635  .uninit = uninit,
636  .query_formats = query_formats,
637  .priv_size = sizeof(ScaleContext),
638  .priv_class = &scale_class,
639  .inputs = avfilter_vf_scale_inputs,
640  .outputs = avfilter_vf_scale_outputs,
642 };
643 
644 static const AVClass scale2ref_class = {
645  .class_name = "scale2ref",
646  .item_name = av_default_item_name,
647  .option = scale_options,
648  .version = LIBAVUTIL_VERSION_INT,
649  .category = AV_CLASS_CATEGORY_FILTER,
650  .child_class_next = child_class_next,
651 };
652 
654  {
655  .name = "default",
656  .type = AVMEDIA_TYPE_VIDEO,
657  .filter_frame = filter_frame,
658  },
659  {
660  .name = "ref",
661  .type = AVMEDIA_TYPE_VIDEO,
662  .filter_frame = filter_frame_ref,
663  },
664  { NULL }
665 };
666 
668  {
669  .name = "default",
670  .type = AVMEDIA_TYPE_VIDEO,
671  .config_props = config_props,
672  .request_frame= request_frame,
673  },
674  {
675  .name = "ref",
676  .type = AVMEDIA_TYPE_VIDEO,
677  .config_props = config_props_ref,
678  .request_frame= request_frame_ref,
679  },
680  { NULL }
681 };
682 
683 AVFilter ff_vf_scale2ref = {
684  .name = "scale2ref",
685  .description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format to the given reference."),
686  .init_dict = init_dict,
687  .uninit = uninit,
688  .query_formats = query_formats,
689  .priv_size = sizeof(ScaleContext),
690  .priv_class = &scale2ref_class,
691  .inputs = avfilter_vf_scale2ref_inputs,
692  .outputs = avfilter_vf_scale2ref_outputs,
694 };
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:498
#define NULL
Definition: coverity.c:32
static av_cold int init_dict(AVFilterContext *ctx, AVDictionary **opts)
Definition: vf_scale.c:98
static enum AVPixelFormat pix_fmt
int ff_scale_eval_dimensions(void *log_ctx, const char *w_expr, const char *h_expr, AVFilterLink *inlink, AVFilterLink *outlink, int *ret_w, int *ret_h)
Definition: scale.c:106
#define FLAGS
Definition: vf_scale.c:564
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
int in_h_chr_pos
Definition: vf_scale.c:85
AVOption.
Definition: opt.h:246
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:148
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Main libavfilter public API header.
const char * desc
Definition: nvenc.c:68
int sws_getColorspaceDetails(struct SwsContext *c, int **inv_table, int *srcRange, int **table, int *dstRange, int *brightness, int *contrast, int *saturation)
Definition: utils.c:993
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:502
static int scale_slice(AVFilterLink *link, AVFrame *out_buf, AVFrame *cur_pic, struct SwsContext *sws, int y, int h, int mul, int field)
Definition: vf_scale.c:379
int num
Numerator.
Definition: rational.h:59
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
int in_v_chr_pos
Definition: vf_scale.c:86
int out_h_chr_pos
Definition: vf_scale.c:83
int eval_mode
expression evaluation mode
Definition: vf_scale.c:92
int sws_isSupportedEndiannessConversion(enum AVPixelFormat pix_fmt)
Definition: utils.c:283
int force_original_aspect_ratio
Definition: vf_scale.c:88
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
const AVClass * sws_get_class(void)
Get the AVClass for swsContext.
Definition: options.c:95
int vsub
chroma subsampling
Definition: vf_scale.c:67
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
int output_is_pal
set to 1 if the output format is paletted
Definition: vf_scale.c:70
functionally identical to above
Definition: pixfmt.h:504
const char * name
Pad name.
Definition: internal.h:60
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:72
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
char * w_expr
width expression string
Definition: vf_scale.c:73
static int query_formats(AVFilterContext *ctx)
Definition: vf_scale.c:158
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1080
uint8_t
#define av_cold
Definition: attributes.h:82
av_warn_unused_result int sws_init_context(struct SwsContext *sws_context, SwsFilter *srcFilter, SwsFilter *dstFilter)
Initialize the swscaler context sws_context.
Definition: utils.c:1165
char * h_expr
height expression string
Definition: vf_scale.c:74
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
AVOptions.
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:496
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:152
Used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16.
Definition: pixfmt.h:505
AVFilter ff_vf_scale2ref
Definition: vf_scale.c:96
static const int * parse_yuv_type(const char *s, enum AVColorSpace colorspace)
Definition: vf_scale.c:196
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
static const AVClass scale_class
Definition: vf_scale.c:604
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:415
external API header
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
#define av_log(a,...)
static const uint16_t table[]
Definition: prosumer.c:206
A filter pad used for either input or output.
Definition: internal.h:54
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
Definition: avutil.h:308
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
int width
Definition: frame.h:326
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
static const AVClass scale2ref_class
Definition: vf_scale.c:644
static const AVOption scale_options[]
Definition: vf_scale.c:566
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define sws_isSupportedOutput(x)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:512
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:568
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:523
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
Add fmt to the list of media formats contained in *avff.
Definition: formats.c:337
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:120
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_scale.c:534
int w
New dimensions.
Definition: vf_scale.c:62
static int config_props(AVFilterLink *outlink)
Definition: vf_scale.c:220
const AVOption * av_opt_find(void *obj, const char *name, const char *unit, int opt_flags, int search_flags)
Look for an option in an object.
Definition: opt.c:1608
common internal API header
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
char * out_color_matrix
Definition: vf_scale.c:78
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2541
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_scale.c:148
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
static const AVFilterPad avfilter_vf_scale_outputs[]
Definition: vf_scale.c:622
#define FFMIN(a, b)
Definition: common.h:96
double param[2]
sws flags
Definition: vf_scale.c:65
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:440
static int request_frame(AVFilterLink *outlink)
Definition: vf_scale.c:369
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:507
static const AVClass * child_class_next(const AVClass *prev)
Definition: vf_scale.c:558
AVFormatContext * ctx
Definition: movenc.c:48
void sws_freeContext(struct SwsContext *swsContext)
Free the swscaler context swsContext.
Definition: utils.c:2311
#define s(width, name)
Definition: cbs_vp9.c:257
int interlaced
Definition: vf_scale.c:71
const int * sws_getCoefficients(int colorspace)
Return a pointer to yuv<->rgb coefficients for the given colorspace suitable for sws_setColorspaceDet...
Definition: yuv2rgb.c:63
#define sws_isSupportedInput(x)
int sws_setColorspaceDetails(struct SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation)
Definition: utils.c:858
char * flags_str
Definition: vf_scale.c:75
FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:501
EvalMode
Definition: af_volume.h:39
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:522
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:341
static int config_props_ref(AVFilterLink *outlink)
Definition: vf_scale.c:356
static int filter_frame_ref(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:527
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
#define OFFSET(x)
Definition: vf_scale.c:563
AVFilter ff_vf_scale
Definition: vf_scale.c:631
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
struct SwsContext * sws
software scaler context
Definition: vf_scale.c:52
static int request_frame_ref(AVFilterLink *outlink)
Definition: vf_scale.c:374
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
static const AVFilterPad avfilter_vf_scale_inputs[]
Definition: vf_scale.c:613
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:356
static const AVFilterPad avfilter_vf_scale2ref_outputs[]
Definition: vf_scale.c:667
AVDictionary * opts
Definition: vf_scale.c:54
int attribute_align_arg sws_scale(struct SwsContext *c, const uint8_t *const srcSlice[], const int srcStride[], int srcSliceY, int srcSliceH, uint8_t *const dst[], const int dstStride[])
swscale wrapper, so we don&#39;t need to export the SwsContext.
Definition: swscale.c:759
void * buf
Definition: avisynth_c.h:766
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
Describe the class of an AVClass context structure.
Definition: log.h:67
Filter definition.
Definition: avfilter.h:144
Rational number (pair of numerator and denominator).
Definition: rational.h:58
const char * name
Filter name.
Definition: avfilter.h:148
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
#define snprintf
Definition: snprintf.h:34
int input_is_pal
set to 1 if the input format is paletted
Definition: vf_scale.c:69
unsigned int flags
Definition: vf_scale.c:64
misc parsing utilities
struct SwsContext * sws_alloc_context(void)
Allocate an empty SwsContext.
Definition: utils.c:1079
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
int out_v_chr_pos
Definition: vf_scale.c:84
struct SwsContext * isws[2]
software scaler context for interlaced material
Definition: vf_scale.c:53
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:403
int in_range
Definition: vf_scale.c:80
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
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:521
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
int out_range
Definition: vf_scale.c:81
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poi...
Definition: opt.h:565
char * size_str
Definition: vf_scale.c:63
char * key
Definition: dict.h:86
int den
Denominator.
Definition: rational.h:60
#define SWS_PARAM_DEFAULT
Definition: swscale.h:73
int slice_y
top of current output slice
Definition: vf_scale.c:68
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2029
#define FF_PSEUDOPAL
Definition: internal.h:367
char * value
Definition: dict.h:87
char * in_color_matrix
Definition: vf_scale.c:77
int nb_slices
Definition: vf_scale.c:90
A list of supported formats for one end of a filter link.
Definition: formats.h:64
An instance of a filter.
Definition: avfilter.h:338
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
int height
Definition: frame.h:326
FILE * out
Definition: movenc.c:54
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
int ff_request_frame(AVFilterLink *link)
Request an input frame from the filter at the other end of the link.
Definition: avfilter.c:407
formats
Definition: signature.h:48
#define FFSWAP(type, a, b)
Definition: common.h:99
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:2438
internal API functions
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
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:449
const AVFilter * filter
the AVFilter of which this is an instance
Definition: avfilter.h:341
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
static const AVFilterPad avfilter_vf_scale2ref_inputs[]
Definition: vf_scale.c:653
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2529