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_eval.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  ff_scale_adjust_dimensions(inlink, &w, &h,
242  scale->force_divisible_by);
243 
244  if (w > INT_MAX || h > INT_MAX ||
245  (h * inlink->w) > INT_MAX ||
246  (w * inlink->h) > INT_MAX)
247  av_log(ctx, AV_LOG_ERROR, "Rescaled value for width or height is too big.\n");
248 
249  outlink->w = w;
250  outlink->h = h;
251 
252  /* TODO: make algorithm configurable */
253 
254  scale->input_is_pal = desc->flags & AV_PIX_FMT_FLAG_PAL;
255  if (outfmt == AV_PIX_FMT_PAL8) outfmt = AV_PIX_FMT_BGR8;
258 
259  if (scale->sws)
260  sws_freeContext(scale->sws);
261  if (scale->isws[0])
262  sws_freeContext(scale->isws[0]);
263  if (scale->isws[1])
264  sws_freeContext(scale->isws[1]);
265  scale->isws[0] = scale->isws[1] = scale->sws = NULL;
266  if (inlink0->w == outlink->w &&
267  inlink0->h == outlink->h &&
268  !scale->out_color_matrix &&
269  scale->in_range == scale->out_range &&
270  inlink0->format == outlink->format)
271  ;
272  else {
273  struct SwsContext **swscs[3] = {&scale->sws, &scale->isws[0], &scale->isws[1]};
274  int i;
275 
276  for (i = 0; i < 3; i++) {
277  int in_v_chr_pos = scale->in_v_chr_pos, out_v_chr_pos = scale->out_v_chr_pos;
278  struct SwsContext **s = swscs[i];
279  *s = sws_alloc_context();
280  if (!*s)
281  return AVERROR(ENOMEM);
282 
283  av_opt_set_int(*s, "srcw", inlink0 ->w, 0);
284  av_opt_set_int(*s, "srch", inlink0 ->h >> !!i, 0);
285  av_opt_set_int(*s, "src_format", inlink0->format, 0);
286  av_opt_set_int(*s, "dstw", outlink->w, 0);
287  av_opt_set_int(*s, "dsth", outlink->h >> !!i, 0);
288  av_opt_set_int(*s, "dst_format", outfmt, 0);
289  av_opt_set_int(*s, "sws_flags", scale->flags, 0);
290  av_opt_set_int(*s, "param0", scale->param[0], 0);
291  av_opt_set_int(*s, "param1", scale->param[1], 0);
292  if (scale->in_range != AVCOL_RANGE_UNSPECIFIED)
293  av_opt_set_int(*s, "src_range",
294  scale->in_range == AVCOL_RANGE_JPEG, 0);
295  if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
296  av_opt_set_int(*s, "dst_range",
297  scale->out_range == AVCOL_RANGE_JPEG, 0);
298 
299  if (scale->opts) {
300  AVDictionaryEntry *e = NULL;
301  while ((e = av_dict_get(scale->opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
302  if ((ret = av_opt_set(*s, e->key, e->value, 0)) < 0)
303  return ret;
304  }
305  }
306  /* Override YUV420P default settings to have the correct (MPEG-2) chroma positions
307  * MPEG-2 chroma positions are used by convention
308  * XXX: support other 4:2:0 pixel formats */
309  if (inlink0->format == AV_PIX_FMT_YUV420P && scale->in_v_chr_pos == -513) {
310  in_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
311  }
312 
313  if (outlink->format == AV_PIX_FMT_YUV420P && scale->out_v_chr_pos == -513) {
314  out_v_chr_pos = (i == 0) ? 128 : (i == 1) ? 64 : 192;
315  }
316 
317  av_opt_set_int(*s, "src_h_chr_pos", scale->in_h_chr_pos, 0);
318  av_opt_set_int(*s, "src_v_chr_pos", in_v_chr_pos, 0);
319  av_opt_set_int(*s, "dst_h_chr_pos", scale->out_h_chr_pos, 0);
320  av_opt_set_int(*s, "dst_v_chr_pos", out_v_chr_pos, 0);
321 
322  if ((ret = sws_init_context(*s, NULL, NULL)) < 0)
323  return ret;
324  if (!scale->interlaced)
325  break;
326  }
327  }
328 
329  if (inlink0->sample_aspect_ratio.num){
330  outlink->sample_aspect_ratio = av_mul_q((AVRational){outlink->h * inlink0->w, outlink->w * inlink0->h}, inlink0->sample_aspect_ratio);
331  } else
332  outlink->sample_aspect_ratio = inlink0->sample_aspect_ratio;
333 
334  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",
335  inlink ->w, inlink ->h, av_get_pix_fmt_name( inlink->format),
337  outlink->w, outlink->h, av_get_pix_fmt_name(outlink->format),
338  outlink->sample_aspect_ratio.num, outlink->sample_aspect_ratio.den,
339  scale->flags);
340  return 0;
341 
342 fail:
343  return ret;
344 }
345 
346 static int config_props_ref(AVFilterLink *outlink)
347 {
348  AVFilterLink *inlink = outlink->src->inputs[1];
349 
350  outlink->w = inlink->w;
351  outlink->h = inlink->h;
352  outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;
353  outlink->time_base = inlink->time_base;
354  outlink->frame_rate = inlink->frame_rate;
355 
356  return 0;
357 }
358 
359 static int request_frame(AVFilterLink *outlink)
360 {
361  return ff_request_frame(outlink->src->inputs[0]);
362 }
363 
364 static int request_frame_ref(AVFilterLink *outlink)
365 {
366  return ff_request_frame(outlink->src->inputs[1]);
367 }
368 
369 static int scale_slice(AVFilterLink *link, AVFrame *out_buf, AVFrame *cur_pic, struct SwsContext *sws, int y, int h, int mul, int field)
370 {
371  ScaleContext *scale = link->dst->priv;
372  const uint8_t *in[4];
373  uint8_t *out[4];
374  int in_stride[4],out_stride[4];
375  int i;
376 
377  for (i=0; i<4; i++) {
378  int vsub= ((i+1)&2) ? scale->vsub : 0;
379  in_stride[i] = cur_pic->linesize[i] * mul;
380  out_stride[i] = out_buf->linesize[i] * mul;
381  in[i] = cur_pic->data[i] + ((y>>vsub)+field) * cur_pic->linesize[i];
382  out[i] = out_buf->data[i] + field * out_buf->linesize[i];
383  }
384  if (scale->input_is_pal)
385  in[1] = cur_pic->data[1];
386  if (scale->output_is_pal)
387  out[1] = out_buf->data[1];
388 
389  return sws_scale(sws, in, in_stride, y/mul, h,
390  out,out_stride);
391 }
392 
393 static int scale_frame(AVFilterLink *link, AVFrame *in, AVFrame **frame_out)
394 {
395  ScaleContext *scale = link->dst->priv;
396  AVFilterLink *outlink = link->dst->outputs[0];
397  AVFrame *out;
399  char buf[32];
400  int in_range;
401 
402  *frame_out = NULL;
403  if (in->colorspace == AVCOL_SPC_YCGCO)
404  av_log(link->dst, AV_LOG_WARNING, "Detected unsupported YCgCo colorspace.\n");
405 
406  if ( in->width != link->w
407  || in->height != link->h
408  || in->format != link->format
410  int ret;
411 
412  if (scale->eval_mode == EVAL_MODE_INIT) {
413  snprintf(buf, sizeof(buf)-1, "%d", outlink->w);
414  av_opt_set(scale, "w", buf, 0);
415  snprintf(buf, sizeof(buf)-1, "%d", outlink->h);
416  av_opt_set(scale, "h", buf, 0);
417  }
418 
419  link->dst->inputs[0]->format = in->format;
420  link->dst->inputs[0]->w = in->width;
421  link->dst->inputs[0]->h = in->height;
422 
425 
426  if ((ret = config_props(outlink)) < 0)
427  return ret;
428  }
429 
430  if (!scale->sws) {
431  *frame_out = in;
432  return 0;
433  }
434 
435  scale->hsub = desc->log2_chroma_w;
436  scale->vsub = desc->log2_chroma_h;
437 
438  out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
439  if (!out) {
440  av_frame_free(&in);
441  return AVERROR(ENOMEM);
442  }
443  *frame_out = out;
444 
445  av_frame_copy_props(out, in);
446  out->width = outlink->w;
447  out->height = outlink->h;
448 
449  if (scale->output_is_pal)
450  avpriv_set_systematic_pal2((uint32_t*)out->data[1], outlink->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : outlink->format);
451 
452  in_range = in->color_range;
453 
454  if ( scale->in_color_matrix
455  || scale->out_color_matrix
456  || scale-> in_range != AVCOL_RANGE_UNSPECIFIED
457  || in_range != AVCOL_RANGE_UNSPECIFIED
458  || scale->out_range != AVCOL_RANGE_UNSPECIFIED) {
459  int in_full, out_full, brightness, contrast, saturation;
460  const int *inv_table, *table;
461 
462  sws_getColorspaceDetails(scale->sws, (int **)&inv_table, &in_full,
463  (int **)&table, &out_full,
464  &brightness, &contrast, &saturation);
465 
466  if (scale->in_color_matrix)
467  inv_table = parse_yuv_type(scale->in_color_matrix, in->colorspace);
468  if (scale->out_color_matrix)
470  else if (scale->in_color_matrix)
471  table = inv_table;
472 
473  if (scale-> in_range != AVCOL_RANGE_UNSPECIFIED)
474  in_full = (scale-> in_range == AVCOL_RANGE_JPEG);
475  else if (in_range != AVCOL_RANGE_UNSPECIFIED)
476  in_full = (in_range == AVCOL_RANGE_JPEG);
477  if (scale->out_range != AVCOL_RANGE_UNSPECIFIED)
478  out_full = (scale->out_range == AVCOL_RANGE_JPEG);
479 
480  sws_setColorspaceDetails(scale->sws, inv_table, in_full,
481  table, out_full,
482  brightness, contrast, saturation);
483  if (scale->isws[0])
484  sws_setColorspaceDetails(scale->isws[0], inv_table, in_full,
485  table, out_full,
486  brightness, contrast, saturation);
487  if (scale->isws[1])
488  sws_setColorspaceDetails(scale->isws[1], inv_table, in_full,
489  table, out_full,
490  brightness, contrast, saturation);
491 
492  out->color_range = out_full ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
493  }
494 
496  (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,
497  (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,
498  INT_MAX);
499 
500  if (scale->interlaced>0 || (scale->interlaced<0 && in->interlaced_frame)) {
501  scale_slice(link, out, in, scale->isws[0], 0, (link->h+1)/2, 2, 0);
502  scale_slice(link, out, in, scale->isws[1], 0, link->h /2, 2, 1);
503  } else if (scale->nb_slices) {
504  int i, slice_h, slice_start, slice_end = 0;
505  const int nb_slices = FFMIN(scale->nb_slices, link->h);
506  for (i = 0; i < nb_slices; i++) {
507  slice_start = slice_end;
508  slice_end = (link->h * (i+1)) / nb_slices;
509  slice_h = slice_end - slice_start;
510  scale_slice(link, out, in, scale->sws, slice_start, slice_h, 1, 0);
511  }
512  } else {
513  scale_slice(link, out, in, scale->sws, 0, link->h, 1, 0);
514  }
515 
516  av_frame_free(&in);
517  return 0;
518 }
519 
521 {
522  AVFilterContext *ctx = link->dst;
523  AVFilterLink *outlink = ctx->outputs[0];
524  AVFrame *out;
525  int ret;
526 
527  ret = scale_frame(link, in, &out);
528  if (out)
529  return ff_filter_frame(outlink, out);
530 
531  return ret;
532 }
533 
535 {
536  AVFilterLink *outlink = link->dst->outputs[1];
537 
538  return ff_filter_frame(outlink, in);
539 }
540 
541 static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
542  char *res, int res_len, int flags)
543 {
544  ScaleContext *scale = ctx->priv;
545  int ret;
546 
547  if ( !strcmp(cmd, "width") || !strcmp(cmd, "w")
548  || !strcmp(cmd, "height") || !strcmp(cmd, "h")) {
549 
550  int old_w = scale->w;
551  int old_h = scale->h;
552  AVFilterLink *outlink = ctx->outputs[0];
553 
554  av_opt_set(scale, cmd, args, 0);
555  if ((ret = config_props(outlink)) < 0) {
556  scale->w = old_w;
557  scale->h = old_h;
558  }
559  } else
560  ret = AVERROR(ENOSYS);
561 
562  return ret;
563 }
564 
565 static const AVClass *child_class_next(const AVClass *prev)
566 {
567  return prev ? NULL : sws_get_class();
568 }
569 
570 #define OFFSET(x) offsetof(ScaleContext, x)
571 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
572 
573 static const AVOption scale_options[] = {
574  { "w", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
575  { "width", "Output video width", OFFSET(w_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
576  { "h", "Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
577  { "height","Output video height", OFFSET(h_expr), AV_OPT_TYPE_STRING, .flags = FLAGS },
578  { "flags", "Flags to pass to libswscale", OFFSET(flags_str), AV_OPT_TYPE_STRING, { .str = "bilinear" }, .flags = FLAGS },
579  { "interl", "set interlacing", OFFSET(interlaced), AV_OPT_TYPE_BOOL, {.i64 = 0 }, -1, 1, FLAGS },
580  { "size", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },
581  { "s", "set video size", OFFSET(size_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, FLAGS },
582  { "in_color_matrix", "set input YCbCr type", OFFSET(in_color_matrix), AV_OPT_TYPE_STRING, { .str = "auto" }, .flags = FLAGS, "color" },
583  { "out_color_matrix", "set output YCbCr type", OFFSET(out_color_matrix), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS, "color"},
584  { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .str = "auto" }, 0, 0, FLAGS, "color" },
585  { "bt601", NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt601" }, 0, 0, FLAGS, "color" },
586  { "bt470", NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt470" }, 0, 0, FLAGS, "color" },
587  { "smpte170m", NULL, 0, AV_OPT_TYPE_CONST, { .str = "smpte170m" }, 0, 0, FLAGS, "color" },
588  { "bt709", NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt709" }, 0, 0, FLAGS, "color" },
589  { "fcc", NULL, 0, AV_OPT_TYPE_CONST, { .str = "fcc" }, 0, 0, FLAGS, "color" },
590  { "smpte240m", NULL, 0, AV_OPT_TYPE_CONST, { .str = "smpte240m" }, 0, 0, FLAGS, "color" },
591  { "bt2020", NULL, 0, AV_OPT_TYPE_CONST, { .str = "bt2020" }, 0, 0, FLAGS, "color" },
592  { "in_range", "set input color range", OFFSET( in_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },
593  { "out_range", "set output color range", OFFSET(out_range), AV_OPT_TYPE_INT, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 2, FLAGS, "range" },
594  { "auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },
595  { "unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_UNSPECIFIED }, 0, 0, FLAGS, "range" },
596  { "full", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
597  { "limited",NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
598  { "jpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
599  { "mpeg", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
600  { "tv", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_MPEG}, 0, 0, FLAGS, "range" },
601  { "pc", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVCOL_RANGE_JPEG}, 0, 0, FLAGS, "range" },
602  { "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 },
603  { "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 },
604  { "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 },
605  { "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 },
606  { "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" },
607  { "disable", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0 }, 0, 0, FLAGS, "force_oar" },
608  { "decrease", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1 }, 0, 0, FLAGS, "force_oar" },
609  { "increase", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2 }, 0, 0, FLAGS, "force_oar" },
610  { "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 },
611  { "param0", "Scaler param 0", OFFSET(param[0]), AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT }, INT_MIN, INT_MAX, FLAGS },
612  { "param1", "Scaler param 1", OFFSET(param[1]), AV_OPT_TYPE_DOUBLE, { .dbl = SWS_PARAM_DEFAULT }, INT_MIN, INT_MAX, FLAGS },
613  { "nb_slices", "set the number of slices (debug purpose only)", OFFSET(nb_slices), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
614  { "eval", "specify when to evaluate expressions", OFFSET(eval_mode), AV_OPT_TYPE_INT, {.i64 = EVAL_MODE_INIT}, 0, EVAL_MODE_NB-1, FLAGS, "eval" },
615  { "init", "eval expressions once during initialization", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_INIT}, .flags = FLAGS, .unit = "eval" },
616  { "frame", "eval expressions during initialization and per-frame", 0, AV_OPT_TYPE_CONST, {.i64=EVAL_MODE_FRAME}, .flags = FLAGS, .unit = "eval" },
617  { NULL }
618 };
619 
620 static const AVClass scale_class = {
621  .class_name = "scale",
622  .item_name = av_default_item_name,
623  .option = scale_options,
624  .version = LIBAVUTIL_VERSION_INT,
625  .category = AV_CLASS_CATEGORY_FILTER,
626  .child_class_next = child_class_next,
627 };
628 
630  {
631  .name = "default",
632  .type = AVMEDIA_TYPE_VIDEO,
633  .filter_frame = filter_frame,
634  },
635  { NULL }
636 };
637 
639  {
640  .name = "default",
641  .type = AVMEDIA_TYPE_VIDEO,
642  .config_props = config_props,
643  },
644  { NULL }
645 };
646 
648  .name = "scale",
649  .description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format."),
650  .init_dict = init_dict,
651  .uninit = uninit,
652  .query_formats = query_formats,
653  .priv_size = sizeof(ScaleContext),
654  .priv_class = &scale_class,
655  .inputs = avfilter_vf_scale_inputs,
656  .outputs = avfilter_vf_scale_outputs,
658 };
659 
660 static const AVClass scale2ref_class = {
661  .class_name = "scale2ref",
662  .item_name = av_default_item_name,
663  .option = scale_options,
664  .version = LIBAVUTIL_VERSION_INT,
665  .category = AV_CLASS_CATEGORY_FILTER,
666  .child_class_next = child_class_next,
667 };
668 
670  {
671  .name = "default",
672  .type = AVMEDIA_TYPE_VIDEO,
673  .filter_frame = filter_frame,
674  },
675  {
676  .name = "ref",
677  .type = AVMEDIA_TYPE_VIDEO,
678  .filter_frame = filter_frame_ref,
679  },
680  { NULL }
681 };
682 
684  {
685  .name = "default",
686  .type = AVMEDIA_TYPE_VIDEO,
687  .config_props = config_props,
688  .request_frame= request_frame,
689  },
690  {
691  .name = "ref",
692  .type = AVMEDIA_TYPE_VIDEO,
693  .config_props = config_props_ref,
694  .request_frame= request_frame_ref,
695  },
696  { NULL }
697 };
698 
699 AVFilter ff_vf_scale2ref = {
700  .name = "scale2ref",
701  .description = NULL_IF_CONFIG_SMALL("Scale the input video size and/or convert the image format to the given reference."),
702  .init_dict = init_dict,
703  .uninit = uninit,
704  .query_formats = query_formats,
705  .priv_size = sizeof(ScaleContext),
706  .priv_class = &scale2ref_class,
707  .inputs = avfilter_vf_scale2ref_inputs,
708  .outputs = avfilter_vf_scale2ref_outputs,
710 };
#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
#define FLAGS
Definition: vf_scale.c:571
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:369
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:620
#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:393
#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:660
static const AVOption scale_options[]
Definition: vf_scale.c:573
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)
Parse and evaluate string expressions for width and height.
Definition: scale_eval.c:106
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 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:541
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
static const AVFilterPad avfilter_vf_scale_outputs[]
Definition: vf_scale.c:638
#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:359
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:508
static const AVClass * child_class_next(const AVClass *prev)
Definition: vf_scale.c:565
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:346
static int filter_frame_ref(AVFilterLink *link, AVFrame *in)
Definition: vf_scale.c:534
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
Definition: pixfmt.h:83
#define OFFSET(x)
Definition: vf_scale.c:570
AVFilter ff_vf_scale
Definition: vf_scale.c:647
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:364
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:629
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:683
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 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:186
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:520
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:669
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2529