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 
90 
91  int nb_slices;
92 
93  int eval_mode; ///< expression evaluation mode
94 
95 } ScaleContext;
96 
98 
100 {
101  ScaleContext *scale = ctx->priv;
102  int ret;
103 
104  if (scale->size_str && (scale->w_expr || scale->h_expr)) {
105  av_log(ctx, AV_LOG_ERROR,
106  "Size and width/height expressions cannot be set at the same time.\n");
107  return AVERROR(EINVAL);
108  }
109 
110  if (scale->w_expr && !scale->h_expr)
111  FFSWAP(char *, scale->w_expr, scale->size_str);
112 
113  if (scale->size_str) {
114  char buf[32];
115  if ((ret = av_parse_video_size(&scale->w, &scale->h, scale->size_str)) < 0) {
116  av_log(ctx, AV_LOG_ERROR,
117  "Invalid size '%s'\n", scale->size_str);
118  return ret;
119  }
120  snprintf(buf, sizeof(buf)-1, "%d", scale->w);
121  av_opt_set(scale, "w", buf, 0);
122  snprintf(buf, sizeof(buf)-1, "%d", scale->h);
123  av_opt_set(scale, "h", buf, 0);
124  }
125  if (!scale->w_expr)
126  av_opt_set(scale, "w", "iw", 0);
127  if (!scale->h_expr)
128  av_opt_set(scale, "h", "ih", 0);
129 
130  av_log(ctx, AV_LOG_VERBOSE, "w:%s h:%s flags:'%s' interl:%d\n",
131  scale->w_expr, scale->h_expr, (char *)av_x_if_null(scale->flags_str, ""), scale->interlaced);
132 
133  scale->flags = 0;
134 
135  if (scale->flags_str) {
136  const AVClass *class = sws_get_class();
137  const AVOption *o = av_opt_find(&class, "sws_flags", NULL, 0,
139  int ret = av_opt_eval_flags(&class, o, scale->flags_str, &scale->flags);
140  if (ret < 0)
141  return ret;
142  }
143  scale->opts = *opts;
144  *opts = NULL;
145 
146  return 0;
147 }
148 
150 {
151  ScaleContext *scale = ctx->priv;
152  sws_freeContext(scale->sws);
153  sws_freeContext(scale->isws[0]);
154  sws_freeContext(scale->isws[1]);
155  scale->sws = NULL;
156  av_dict_free(&scale->opts);
157 }
158 
160 {
162  enum AVPixelFormat pix_fmt;
163  int ret;
164 
165  if (ctx->inputs[0]) {
166  const AVPixFmtDescriptor *desc = NULL;
167  formats = NULL;
168  while ((desc = av_pix_fmt_desc_next(desc))) {
169  pix_fmt = av_pix_fmt_desc_get_id(desc);
170  if ((sws_isSupportedInput(pix_fmt) ||
172  && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
173  return ret;
174  }
175  }
176  if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0)
177  return ret;
178  }
179  if (ctx->outputs[0]) {
180  const AVPixFmtDescriptor *desc = NULL;
181  formats = NULL;
182  while ((desc = av_pix_fmt_desc_next(desc))) {
183  pix_fmt = av_pix_fmt_desc_get_id(desc);
184  if ((sws_isSupportedOutput(pix_fmt) || pix_fmt == AV_PIX_FMT_PAL8 ||
186  && (ret = ff_add_format(&formats, pix_fmt)) < 0) {
187  return ret;
188  }
189  }
190  if ((ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0)
191  return ret;
192  }
193 
194  return 0;
195 }
196 
197 static const int *parse_yuv_type(const char *s, enum AVColorSpace colorspace)
198 {
199  if (!s)
200  s = "bt601";
201 
202  if (s && strstr(s, "bt709")) {
203  colorspace = AVCOL_SPC_BT709;
204  } else if (s && strstr(s, "fcc")) {
205  colorspace = AVCOL_SPC_FCC;
206  } else if (s && strstr(s, "smpte240m")) {
207  colorspace = AVCOL_SPC_SMPTE240M;
208  } else if (s && (strstr(s, "bt601") || strstr(s, "bt470") || strstr(s, "smpte170m"))) {
209  colorspace = AVCOL_SPC_BT470BG;
210  } else if (s && strstr(s, "bt2020")) {
211  colorspace = AVCOL_SPC_BT2020_NCL;
212  }
213 
214  if (colorspace < 1 || colorspace > 10 || colorspace == 8) {
215  colorspace = AVCOL_SPC_BT470BG;
216  }
217 
218  return sws_getCoefficients(colorspace);
219 }
220 
221 static int config_props(AVFilterLink *outlink)
222 {
223  AVFilterContext *ctx = outlink->src;
224  AVFilterLink *inlink0 = outlink->src->inputs[0];
225  AVFilterLink *inlink = ctx->filter == &ff_vf_scale2ref ?
226  outlink->src->inputs[1] :
227  outlink->src->inputs[0];
228  enum AVPixelFormat outfmt = outlink->format;
230  ScaleContext *scale = ctx->priv;
231  int w, h;
232  int ret;
233 
234  if ((ret = ff_scale_eval_dimensions(ctx,
235  scale->w_expr, scale->h_expr,
236  inlink, outlink,
237  &w, &h)) < 0)
238  goto fail;
239 
240  /* Note that force_original_aspect_ratio may overwrite the previous set
241  * dimensions so that it is not divisible by the set factors anymore
242  * unless force_divisible_by is defined as well */
243  if (scale->force_original_aspect_ratio) {
244  int tmp_w = av_rescale(h, inlink->w, inlink->h);
245  int tmp_h = av_rescale(w, inlink->h, inlink->w);
246 
247  if (scale->force_original_aspect_ratio == 1) {
248  w = FFMIN(tmp_w, w);
249  h = FFMIN(tmp_h, h);
250  if (scale->force_divisible_by > 1) {
251  // round down
252  w = w / scale->force_divisible_by * scale->force_divisible_by;
253  h = h / scale->force_divisible_by * scale->force_divisible_by;
254  }
255  } else {
256  w = FFMAX(tmp_w, w);
257  h = FFMAX(tmp_h, h);
258  if (scale->force_divisible_by > 1) {
259  // round up
260  w = (w + scale->force_divisible_by - 1) / scale->force_divisible_by * scale->force_divisible_by;
261  h = (h + scale->force_divisible_by - 1) / scale->force_divisible_by * scale->force_divisible_by;
262  }
263  }
264  }
265 
266  if (w > INT_MAX || h > INT_MAX ||
267  (h * inlink->w) > INT_MAX ||
268  (w * inlink->h) > INT_MAX)
269  av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
270 
271  outlink->w = w;
272  outlink->h = h;
273 
274  /* TODO: make algorithm configurable */
275 
276  scale->input_is_pal = desc->flags & AV_PIX_FMT_FLAG_PAL;
277  if (outfmt == AV_PIX_FMT_PAL8) outfmt = AV_PIX_FMT_BGR8;
280 
281  if (scale->sws)
282  sws_freeContext(scale->sws);
283  if (scale->isws[0])
284  sws_freeContext(scale->isws[0]);
285  if (scale->isws[1])
286  sws_freeContext(scale->isws[1]);
287  scale->isws[0] = scale->isws[1] = scale->sws = NULL;
288  if (inlink0->w == outlink->w &&
289  inlink0->h == outlink->h &&
290  !scale->out_color_matrix &&
291  scale->in_range == scale->out_range &&
292  inlink0->format == outlink->format)
293  ;
294  else {
295  struct SwsContext **swscs[3] = {&scale->sws, &scale->isws[0], &scale->isws[1]};
296  int i;
297 
298  for (i = 0; i < 3; i++) {
299  int in_v_chr_pos = scale->in_v_chr_pos, out_v_chr_pos = scale->out_v_chr_pos;
300  struct SwsContext **s = swscs[i];
301  *s = sws_alloc_context();
302  if (!*s)
303  return AVERROR(ENOMEM);
304 
305  av_opt_set_int(*s, "srcw", inlink0 ->w, 0);
306  av_opt_set_int(*s, "srch", inlink0 ->h >> !!i, 0);
307  av_opt_set_int(*s, "src_format", inlink0->format, 0);
308  av_opt_set_int(*s, "dstw", outlink->w, 0);
309  av_opt_set_int(*s, "dsth", outlink->h >> !!i, 0);
310  av_opt_set_int(*s, "dst_format", outfmt, 0);
311  av_opt_set_int(*s, "sws_flags", scale->flags, 0);
312  av_opt_set_int(*s, "param0", scale->param[0], 0);
313  av_opt_set_int(*s, "param1", scale->param[1], 0);
314  if (scale->in_range != AVCOL_RANGE_UNSPECIFIED)
315  av_opt_set_int(*s, "src_range",
316  scale->in_range == AVCOL_RANGE_JPEG, 0);
317  if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
318  av_opt_set_int(*s, "dst_range",
319  scale->out_range == AVCOL_RANGE_JPEG, 0);
320 
321  if (scale->opts) {
322  AVDictionaryEntry *e = NULL;
323  while ((e = av_dict_get(scale->opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
324  if ((ret = av_opt_set(*s, e->key, e->value, 0)) < 0)
325  return ret;
326  }
327  }
328  /* Override YUV420P default settings to have the correct (MPEG-2) chroma positions
329  * MPEG-2 chroma positions are used by convention
330  * XXX: support other 4:2:0 pixel formats */
331  if (inlink0->format == AV_PIX_FMT_YUV420P && scale->in_v_chr_pos == -513) {
332  in_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
333  }
334 
335  if (outlink->format == AV_PIX_FMT_YUV420P && scale->out_v_chr_pos == -513) {
336  out_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
337  }
338 
339  av_opt_set_int(*s, "src_h_chr_pos", scale->in_h_chr_pos, 0);
340  av_opt_set_int(*s, "src_v_chr_pos", in_v_chr_pos, 0);
341  av_opt_set_int(*s, "dst_h_chr_pos", scale->out_h_chr_pos, 0);
342  av_opt_set_int(*s, "dst_v_chr_pos", out_v_chr_pos, 0);
343 
344  if ((ret = sws_init_context(*s, NULL, NULL)) < 0)
345  return ret;
346  if (!scale->interlaced)
347  break;
348  }
349  }
350 
351  if (inlink0->sample_aspect_ratio.num){
352  outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h * inlink0->w, outlink->w * inlink0->h}, inlink0->sample_aspect_ratio);
353  } else
354  outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
355 
356  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",
357  inlink ->w, inlink ->h, av_get_pix_fmt_name( inlink->format),
359  outlink->w, outlink->h, av_get_pix_fmt_name(outlink->format),
360  outlink->sample_aspect_ratio.num, outlink->sample_aspect_ratio.den,
361  scale->flags);
362  return 0;
363 
364 fail:
365  return ret;
366 }
367 
368 static int config_props_ref(AVFilterLink *outlink)
369 {
370  AVFilterLink *inlink = outlink->src->inputs[1];
371 
372  outlink->w = inlink->w;
373  outlink->h = inlink->h;
374  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
375  outlink->time_base = inlink->time_base;
376  outlink->frame_rate = inlink->frame_rate;
377 
378  return 0;
379 }
380 
381 static int request_frame(AVFilterLink *outlink)
382 {
383  return ff_request_frame(outlink->src->inputs[0]);
384 }
385 
386 static int request_frame_ref(AVFilterLink *outlink)
387 {
388  return ff_request_frame(outlink->src->inputs[1]);
389 }
390 
391 static int scale_slice(AVFilterLink *link, AVFrame *out_buf, AVFrame *cur_pic, struct SwsContext *sws, int y, int h, int mul, int field)
392 {
393  ScaleContext *scale = link->dst->priv;
394  const uint8_t *in[4];
395  uint8_t *out[4];
396  int in_stride[4],out_stride[4];
397  int i;
398 
399  for (i=0; i<4; i++) {
400  int vsub= ((i+1)&2) ? scale->vsub : 0;
401  in_stride[i] = cur_pic->linesize[i] * mul;
402  out_stride[i] = out_buf->linesize[i] * mul;
403  in[i] = cur_pic->data[i] + ((y>>vsub)+field) * cur_pic->linesize[i];
404  out[i] = out_buf->data[i] + field * out_buf->linesize[i];
405  }
406  if (scale->input_is_pal)
407  in[1] = cur_pic->data[1];
408  if (scale->output_is_pal)
409  out[1] = out_buf->data[1];
410 
411  return sws_scale(sws, in, in_stride, y/mul, h,
412  out,out_stride);
413 }
414 
415 static int scale_frame(AVFilterLink *link, AVFrame *in, AVFrame **frame_out)
416 {
417  ScaleContext *scale = link->dst->priv;
418  AVFilterLink *outlink = link->dst->outputs[0];
419  AVFrame *out;
421  char buf[32];
422  int in_range;
423 
424  *frame_out = NULL;
425  if (in->colorspace == AVCOL_SPC_YCGCO)
426  av_log(link->dst, AV_LOG_WARNING, "Detected unsupported YCgCo colorspace.\n");
427 
428  if ( in->width != link->w
429  || in->height != link->h
430  || in->format != link->format
432  int ret;
433 
434  if (scale->eval_mode == EVAL_MODE_INIT) {
435  snprintf(buf, sizeof(buf)-1, "%d", outlink->w);
436  av_opt_set(scale, "w", buf, 0);
437  snprintf(buf, sizeof(buf)-1, "%d", outlink->h);
438  av_opt_set(scale, "h", buf, 0);
439  }
440 
441  link->dst->inputs[0]->format = in->format;
442  link->dst->inputs[0]->w = in->width;
443  link->dst->inputs[0]->h = in->height;
444 
447 
448  if ((ret = config_props(outlink)) < 0)
449  return ret;
450  }
451 
452  if (!scale->sws) {
453  *frame_out = in;
454  return 0;
455  }
456 
457  scale->hsub = desc->log2_chroma_w;
458  scale->vsub = desc->log2_chroma_h;
459 
460  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
461  if (!out) {
462  av_frame_free(&in);
463  return AVERROR(ENOMEM);
464  }
465  *frame_out = out;
466 
467  av_frame_copy_props(out, in);
468  out->width = outlink->w;
469  out->height = outlink->h;
470 
471  if (scale->output_is_pal)
472  avpriv_set_systematic_pal2((uint32_t*)out->data[1], outlink->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : outlink->format);
473 
474  in_range = in->color_range;
475 
476  if ( scale->in_color_matrix
477  || scale->out_color_matrix
478  || scale-> in_range != AVCOL_RANGE_UNSPECIFIED
479  || in_range != AVCOL_RANGE_UNSPECIFIED
480  || scale->out_range != AVCOL_RANGE_UNSPECIFIED) {
481  int in_full, out_full, brightness, contrast, saturation;
482  const int *inv_table, *table;
483 
484  sws_getColorspaceDetails(scale->sws, (int **)&inv_table, &in_full,
485  (int **)&table, &out_full,
486  &brightness, &contrast, &saturation);
487 
488  if (scale->in_color_matrix)
489  inv_table = parse_yuv_type(scale->in_color_matrix, in->colorspace);
490  if (scale->out_color_matrix)
492  else if (scale->in_color_matrix)
493  table = inv_table;
494 
495  if (scale-> in_range != AVCOL_RANGE_UNSPECIFIED)
496  in_full = (scale-> in_range == AVCOL_RANGE_JPEG);
497  else if (in_range != AVCOL_RANGE_UNSPECIFIED)
498  in_full = (in_range == AVCOL_RANGE_JPEG);
499  if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
500  out_full = (scale->out_range == AVCOL_RANGE_JPEG);
501 
502  sws_setColorspaceDetails(scale->sws, inv_table, in_full,
503  table, out_full,
504  brightness, contrast, saturation);
505  if (scale->isws[0])
506  sws_setColorspaceDetails(scale->isws[0], inv_table, in_full,
507  table, out_full,
508  brightness, contrast, saturation);
509  if (scale->isws[1])
510  sws_setColorspaceDetails(scale->isws[1], inv_table, in_full,
511  table, out_full,
512  brightness, contrast, saturation);
513 
514  out->color_range = out_full ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
515  }
516 
518  (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
519  (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
520  INT_MAX);
521 
522  if (scale->interlaced>0 || (scale->interlaced<0 && in->interlaced_frame)) {
523  scale_slice(link, out, in, scale->isws[0], 0, (link->h+1)/2, 2, 0);
524  scale_slice(link, out, in, scale->isws[1], 0, link->h /2, 2, 1);
525  } else if (scale->nb_slices) {
526  int i, slice_h, slice_start, slice_end = 0;
527  const int nb_slices = FFMIN(scale->nb_slices, link->h);
528  for (i = 0; i < nb_slices; i++) {
529  slice_start = slice_end;
530  slice_end = (link->h * (i+1)) / nb_slices;
531  slice_h = slice_end - slice_start;
532  scale_slice(link, out, in, scale->sws, slice_start, slice_h, 1, 0);
533  }
534  } else {
535  scale_slice(link, out, in, scale->sws, 0, link->h, 1, 0);
536  }
537 
538  av_frame_free(&in);
539  return 0;
540 }
541 
543 {
544  AVFilterContext *ctx = link->dst;
545  AVFilterLink *outlink = ctx->outputs[0];
546  AVFrame *out;
547  int ret;
548 
549  ret = scale_frame(link, in, &out);
550  if (out)
551  return ff_filter_frame(outlink, out);
552 
553  return ret;
554 }
555 
557 {
558  AVFilterLink *outlink = link->dst->outputs[1];
559 
560  return ff_filter_frame(outlink, in);
561 }
562 
563 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
564  char *res, int res_len, int flags)
565 {
566  ScaleContext *scale = ctx->priv;
567  int ret;
568 
569  if ( !strcmp(cmd, "width") || !strcmp(cmd, "w")
570  || !strcmp(cmd, "height") || !strcmp(cmd, "h")) {
571 
572  int old_w = scale->w;
573  int old_h = scale->h;
574  AVFilterLink *outlink = ctx->outputs[0];
575 
576  av_opt_set(scale, cmd, args, 0);
577  if ((ret = config_props(outlink)) < 0) {
578  scale->w = old_w;
579  scale->h = old_h;
580  }
581  } else
582  ret = AVERROR(ENOSYS);
583 
584  return ret;
585 }
586 
587 static const AVClass *child_class_next(const AVClass *prev)
588 {
589  return prev ? NULL : sws_get_class();
590 }
591 
592 #define OFFSET(x) offsetof(ScaleContext, x)
593 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
594 
595 static const AVOption scale_options[] = {
596  { "w", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
597  { "width", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
598  { "h", "Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
599  { "height","Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
600  { "flags", "Flags to pass to libswscale", OFFSET(flags_str), AV_OPT_TYPE_STRING, { .str = "bilinear" }, .flags = FLAGS },
601  { "interl", "set interlacing", OFFSET(interlaced), AV_OPT_TYPE_BOOL, {.i64 = 0 }, -1, 1, FLAGS },
602  { "size", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },
603  { "s", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },
604  { "in_color_matrix", "set input YCbCr type", OFFSET(in_color_matrix), AV_OPT_TYPE_STRING, { .str = "auto" }, .flags = FLAGS, "color" },
605  { "out_color_matrix", "set output YCbCr type", OFFSET(out_color_matrix), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS, "color"},
606  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .str = "auto" }, 0, 0, FLAGS, "color" },
607  { "bt601", NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt601" }, 0, 0, FLAGS, "color" },
608  { "bt470", NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt470" }, 0, 0, FLAGS, "color" },
609  { "smpte170m", NULL, 0, AV_OPT_TYPE_CONST, { .str = "smpte170m" }, 0, 0, FLAGS, "color" },
610  { "bt709", NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt709" }, 0, 0, FLAGS, "color" },
611  { "fcc", NULL, 0, AV_OPT_TYPE_CONST, { .str = "fcc" }, 0, 0, FLAGS, "color" },
612  { "smpte240m", NULL, 0, AV_OPT_TYPE_CONST, { .str = "smpte240m" }, 0, 0, FLAGS, "color" },
613  { "bt2020", NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt2020" }, 0, 0, FLAGS, "color" },
614  { "in_range", "set input color range", OFFSET( in_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },
615  { "out_range", "set output color range", OFFSET(out_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },
616  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },
617  { "unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },
618  { "full", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
619  { "limited",NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
620  { "jpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
621  { "mpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
622  { "tv", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
623  { "pc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
624  { "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 },
625  { "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 },
626  { "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 },
627  { "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 },
628  { "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" },
629  { "disable", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },
630  { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },
631  { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },
632  { "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 },
633  { "param0", "Scaler param 0", OFFSET(param[0]), AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT }, INT_MIN, INT_MAX, FLAGS },
634  { "param1", "Scaler param 1", OFFSET(param[1]), AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT }, INT_MIN, INT_MAX, FLAGS },
635  { "nb_slices", "set the number of slices (debug purpose only)", OFFSET(nb_slices), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
636  { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
637  { "init", "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT}, .flags = FLAGS, .unit = "eval" },
638  { "frame", "eval expressions during initialization and per-frame", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
639  { NULL }
640 };
641 
642 static const AVClass scale_class = {
643  .class_name = "scale",
644  .item_name = av_default_item_name,
645  .option = scale_options,
646  .version = LIBAVUTIL_VERSION_INT,
647  .category = AV_CLASS_CATEGORY_FILTER,
648  .child_class_next = child_class_next,
649 };
650 
652  {
653  .name = "default",
654  .type = AVMEDIA_TYPE_VIDEO,
655  .filter_frame = filter_frame,
656  },
657  { NULL }
658 };
659 
661  {
662  .name = "default",
663  .type = AVMEDIA_TYPE_VIDEO,
664  .config_props = config_props,
665  },
666  { NULL }
667 };
668 
670  .name = "scale",
671  .description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format."),
672  .init_dict = init_dict,
673  .uninit = uninit,
674  .query_formats = query_formats,
675  .priv_size = sizeof(ScaleContext),
676  .priv_class = &scale_class,
677  .inputs = avfilter_vf_scale_inputs,
678  .outputs = avfilter_vf_scale_outputs,
680 };
681 
682 static const AVClass scale2ref_class = {
683  .class_name = "scale2ref",
684  .item_name = av_default_item_name,
685  .option = scale_options,
686  .version = LIBAVUTIL_VERSION_INT,
687  .category = AV_CLASS_CATEGORY_FILTER,
688  .child_class_next = child_class_next,
689 };
690 
692  {
693  .name = "default",
694  .type = AVMEDIA_TYPE_VIDEO,
695  .filter_frame = filter_frame,
696  },
697  {
698  .name = "ref",
699  .type = AVMEDIA_TYPE_VIDEO,
700  .filter_frame = filter_frame_ref,
701  },
702  { NULL }
703 };
704 
706  {
707  .name = "default",
708  .type = AVMEDIA_TYPE_VIDEO,
709  .config_props = config_props,
710  .request_frame= request_frame,
711  },
712  {
713  .name = "ref",
714  .type = AVMEDIA_TYPE_VIDEO,
715  .config_props = config_props_ref,
716  .request_frame= request_frame_ref,
717  },
718  { NULL }
719 };
720 
721 AVFilter ff_vf_scale2ref = {
722  .name = "scale2ref",
723  .description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format to the given reference."),
724  .init_dict = init_dict,
725  .uninit = uninit,
726  .query_formats = query_formats,
727  .priv_size = sizeof(ScaleContext),
728  .priv_class = &scale2ref_class,
729  .inputs = avfilter_vf_scale2ref_inputs,
730  .outputs = avfilter_vf_scale2ref_outputs,
732 };
#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:499
#define NULL
Definition: coverity.c:32
static av_cold int init_dict(AVFilterContext *ctx, AVDictionary **opts)
Definition: vf_scale.c:99
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:593
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:295
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:503
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:391
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:93
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:505
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:159
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1093
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:497
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:506
AVFilter ff_vf_scale2ref
Definition: vf_scale.c:97
static const int * parse_yuv_type(const char *s, enum AVColorSpace colorspace)
Definition: vf_scale.c:197
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:642
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
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
static int scale_frame(AVFilterLink *link, AVFrame *in, AVFrame **frame_out)
Definition: vf_scale.c:415
#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:259
int width
Definition: frame.h:353
#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:682
static const AVOption scale_options[]
Definition: vf_scale.c:595
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:539
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:550
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:336
#define FFMAX(a, b)
Definition: common.h:94
#define fail()
Definition: checkasm.h:122
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Definition: vf_scale.c:563
int w
New dimensions.
Definition: vf_scale.c:62
static int config_props(AVFilterLink *outlink)
Definition: vf_scale.c:221
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:1631
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:149
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:660
#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:439
static int request_frame(AVFilterLink *outlink)
Definition: vf_scale.c:381
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:508
static const AVClass * child_class_next(const AVClass *prev)
Definition: vf_scale.c:587
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:502
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:523
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
static int config_props_ref(AVFilterLink *outlink)
Definition: vf_scale.c:368
static int filter_frame_ref(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:556
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
#define OFFSET(x)
Definition: vf_scale.c:592
AVFilter ff_vf_scale
Definition: vf_scale.c:669
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
struct SwsContext * sws
software scaler context
Definition: vf_scale.c:52
static int request_frame_ref(AVFilterLink *outlink)
Definition: vf_scale.c:386
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:651
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:383
static const AVFilterPad avfilter_vf_scale2ref_outputs[]
Definition: vf_scale.c:705
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:753
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:309
static int filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:542
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:522
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:566
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:2036
#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:91
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:353
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
int force_divisible_by
Definition: vf_scale.c:89
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:691
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2529