FFmpeg
formats.c
Go to the documentation of this file.
1 /*
2  * Filter layer - format negotiation
3  * Copyright (c) 2007 Bobby Bingham
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
24 #include "libavutil/common.h"
25 #include "libavutil/eval.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/parseutils.h"
28 #include "avfilter.h"
29 #include "internal.h"
30 #include "formats.h"
31 
32 #define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */
33 
34 /**
35  * Add all refs from a to ret and destroy a.
36  */
37 #define MERGE_REF(ret, a, fmts, type, fail) \
38 do { \
39  type ***tmp; \
40  int i; \
41  \
42  if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
43  sizeof(*tmp)))) \
44  goto fail; \
45  ret->refs = tmp; \
46  \
47  for (i = 0; i < a->refcount; i ++) { \
48  ret->refs[ret->refcount] = a->refs[i]; \
49  *ret->refs[ret->refcount++] = ret; \
50  } \
51  \
52  av_freep(&a->refs); \
53  av_freep(&a->fmts); \
54  av_freep(&a); \
55 } while (0)
56 
57 /**
58  * Add all formats common for a and b to ret, copy the refs and destroy
59  * a and b.
60  */
61 #define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail) \
62 do { \
63  int i, j, k = 0, count = FFMIN(a->nb, b->nb); \
64  \
65  if (!(ret = av_mallocz(sizeof(*ret)))) \
66  goto fail; \
67  \
68  if (count) { \
69  if (!(ret->fmts = av_malloc_array(count, sizeof(*ret->fmts)))) \
70  goto fail; \
71  for (i = 0; i < a->nb; i++) \
72  for (j = 0; j < b->nb; j++) \
73  if (a->fmts[i] == b->fmts[j]) { \
74  if(k >= FFMIN(a->nb, b->nb)){ \
75  av_log(NULL, AV_LOG_ERROR, "Duplicate formats in %s detected\n", __FUNCTION__); \
76  av_free(ret->fmts); \
77  av_free(ret); \
78  return NULL; \
79  } \
80  ret->fmts[k++] = a->fmts[i]; \
81  } \
82  } \
83  ret->nb = k; \
84  /* check that there was at least one common format */ \
85  if (!ret->nb) \
86  goto fail; \
87  \
88  MERGE_REF(ret, a, fmts, type, fail); \
89  MERGE_REF(ret, b, fmts, type, fail); \
90 } while (0)
91 
93  enum AVMediaType type)
94 {
96  int i, j;
97  int alpha1=0, alpha2=0;
98  int chroma1=0, chroma2=0;
99 
100  if (a == b)
101  return a;
102 
103  /* Do not lose chroma or alpha in merging.
104  It happens if both lists have formats with chroma (resp. alpha), but
105  the only formats in common do not have it (e.g. YUV+gray vs.
106  RGB+gray): in that case, the merging would select the gray format,
107  possibly causing a lossy conversion elsewhere in the graph.
108  To avoid that, pretend that there are no common formats to force the
109  insertion of a conversion filter. */
110  if (type == AVMEDIA_TYPE_VIDEO)
111  for (i = 0; i < a->nb_formats; i++)
112  for (j = 0; j < b->nb_formats; j++) {
113  const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
114  const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
115  alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
116  chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
117  if (a->formats[i] == b->formats[j]) {
118  alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
119  chroma1|= adesc->nb_components > 1;
120  }
121  }
122 
123  // If chroma or alpha can be lost through merging then do not merge
124  if (alpha2 > alpha1 || chroma2 > chroma1)
125  return NULL;
126 
127  MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
128 
129  return ret;
130 fail:
131  if (ret) {
132  av_freep(&ret->refs);
133  av_freep(&ret->formats);
134  }
135  av_freep(&ret);
136  return NULL;
137 }
138 
141 {
143 
144  if (a == b) return a;
145 
146  if (a->nb_formats && b->nb_formats) {
147  MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
148  } else if (a->nb_formats) {
150  ret = a;
151  } else {
153  ret = b;
154  }
155 
156  return ret;
157 fail:
158  if (ret) {
159  av_freep(&ret->refs);
160  av_freep(&ret->formats);
161  }
162  av_freep(&ret);
163  return NULL;
164 }
165 
168 {
170  unsigned a_all = a->all_layouts + a->all_counts;
171  unsigned b_all = b->all_layouts + b->all_counts;
172  int ret_max, ret_nb = 0, i, j, round;
173 
174  if (a == b) return a;
175 
176  /* Put the most generic set in a, to avoid doing everything twice */
177  if (a_all < b_all) {
179  FFSWAP(unsigned, a_all, b_all);
180  }
181  if (a_all) {
182  if (a_all == 1 && !b_all) {
183  /* keep only known layouts in b; works also for b_all = 1 */
184  for (i = j = 0; i < b->nb_channel_layouts; i++)
185  if (KNOWN(b->channel_layouts[i]))
186  b->channel_layouts[j++] = b->channel_layouts[i];
187  /* Not optimal: the unknown layouts of b may become known after
188  another merge. */
189  if (!j)
190  return NULL;
191  b->nb_channel_layouts = j;
192  }
194  return b;
195  }
196 
197  ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
198  if (!(ret = av_mallocz(sizeof(*ret))) ||
199  !(ret->channel_layouts = av_malloc_array(ret_max,
200  sizeof(*ret->channel_layouts))))
201  goto fail;
202 
203  /* a[known] intersect b[known] */
204  for (i = 0; i < a->nb_channel_layouts; i++) {
205  if (!KNOWN(a->channel_layouts[i]))
206  continue;
207  for (j = 0; j < b->nb_channel_layouts; j++) {
208  if (a->channel_layouts[i] == b->channel_layouts[j]) {
209  ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
210  a->channel_layouts[i] = b->channel_layouts[j] = 0;
211  }
212  }
213  }
214  /* 1st round: a[known] intersect b[generic]
215  2nd round: a[generic] intersect b[known] */
216  for (round = 0; round < 2; round++) {
217  for (i = 0; i < a->nb_channel_layouts; i++) {
218  uint64_t fmt = a->channel_layouts[i], bfmt;
219  if (!fmt || !KNOWN(fmt))
220  continue;
222  for (j = 0; j < b->nb_channel_layouts; j++)
223  if (b->channel_layouts[j] == bfmt)
224  ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
225  }
226  /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
228  }
229  /* a[generic] intersect b[generic] */
230  for (i = 0; i < a->nb_channel_layouts; i++) {
231  if (KNOWN(a->channel_layouts[i]))
232  continue;
233  for (j = 0; j < b->nb_channel_layouts; j++)
234  if (a->channel_layouts[i] == b->channel_layouts[j])
235  ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
236  }
237 
238  ret->nb_channel_layouts = ret_nb;
239  if (!ret->nb_channel_layouts)
240  goto fail;
243  return ret;
244 
245 fail:
246  if (ret) {
247  av_freep(&ret->refs);
248  av_freep(&ret->channel_layouts);
249  }
250  av_freep(&ret);
251  return NULL;
252 }
253 
254 int ff_fmt_is_in(int fmt, const int *fmts)
255 {
256  const int *p;
257 
258  for (p = fmts; *p != -1; p++) {
259  if (fmt == *p)
260  return 1;
261  }
262  return 0;
263 }
264 
265 #define MAKE_FORMAT_LIST(type, field, count_field) \
266  type *formats; \
267  int count = 0; \
268  if (fmts) \
269  for (count = 0; fmts[count] != -1; count++) \
270  ; \
271  formats = av_mallocz(sizeof(*formats)); \
272  if (!formats) \
273  return NULL; \
274  formats->count_field = count; \
275  if (count) { \
276  formats->field = av_malloc_array(count, sizeof(*formats->field)); \
277  if (!formats->field) { \
278  av_freep(&formats); \
279  return NULL; \
280  } \
281  }
282 
284 {
286  while (count--)
287  formats->formats[count] = fmts[count];
288 
289  return formats;
290 }
291 
293 {
295  channel_layouts, nb_channel_layouts);
296  if (count)
297  memcpy(formats->channel_layouts, fmts,
298  sizeof(*formats->channel_layouts) * count);
299 
300  return formats;
301 }
302 
304 {
306  channel_layouts, nb_channel_layouts);
307  if (count)
308  memcpy(formats->channel_layouts, fmts,
309  sizeof(*formats->channel_layouts) * count);
310 
311  return formats;
312 }
313 
314 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
315 do { \
316  type *fmts; \
317  void *oldf = *f; \
318  \
319  if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
320  return AVERROR(ENOMEM); \
321  } \
322  \
323  fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
324  sizeof(*(*f)->list)); \
325  if (!fmts) { \
326  unref_fn(f); \
327  if (!oldf) \
328  av_freep(f); \
329  return AVERROR(ENOMEM); \
330  } \
331  \
332  (*f)->list = fmts; \
333  (*f)->list[(*f)->nb++] = fmt; \
334 } while (0)
335 
336 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
337 {
338  ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
339  return 0;
340 }
341 
342 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
343 {
344  av_assert1(!(*l && (*l)->all_layouts));
345  ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, uint64_t, channel_layouts, nb_channel_layouts);
346  return 0;
347 }
348 
350 {
352 
353  if (type == AVMEDIA_TYPE_VIDEO) {
354  const AVPixFmtDescriptor *desc = NULL;
355  while ((desc = av_pix_fmt_desc_next(desc))) {
356  if (ff_add_format(&ret, av_pix_fmt_desc_get_id(desc)) < 0)
357  return NULL;
358  }
359  } else if (type == AVMEDIA_TYPE_AUDIO) {
360  enum AVSampleFormat fmt = 0;
361  while (av_get_sample_fmt_name(fmt)) {
362  if (ff_add_format(&ret, fmt) < 0)
363  return NULL;
364  fmt++;
365  }
366  }
367 
368  return ret;
369 }
370 
371 int ff_formats_pixdesc_filter(AVFilterFormats **rfmts, unsigned want, unsigned rej)
372 {
373  unsigned nb_formats, fmt, flags;
375 
376  while (1) {
377  nb_formats = 0;
378  for (fmt = 0;; fmt++) {
380  if (!desc)
381  break;
382  flags = desc->flags;
383  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
384  !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
385  (desc->log2_chroma_w || desc->log2_chroma_h))
387  if ((flags & (want | rej)) != want)
388  continue;
389  if (formats)
390  formats->formats[nb_formats] = fmt;
391  nb_formats++;
392  }
393  if (formats) {
394  av_assert0(formats->nb_formats == nb_formats);
395  *rfmts = formats;
396  return 0;
397  }
398  formats = av_mallocz(sizeof(*formats));
399  if (!formats)
400  return AVERROR(ENOMEM);
401  formats->nb_formats = nb_formats;
402  if (nb_formats) {
403  formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
404  if (!formats->formats) {
405  av_freep(&formats);
406  return AVERROR(ENOMEM);
407  }
408  }
409  }
410 }
411 
413 {
415  int fmt;
416 
417  for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
418  if (av_sample_fmt_is_planar(fmt))
419  if (ff_add_format(&ret, fmt) < 0)
420  return NULL;
421 
422  return ret;
423 }
424 
426 {
427  AVFilterFormats *ret = av_mallocz(sizeof(*ret));
428  return ret;
429 }
430 
432 {
433  AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
434  if (!ret)
435  return NULL;
436  ret->all_layouts = 1;
437  return ret;
438 }
439 
441 {
442  AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
443  if (!ret)
444  return NULL;
445  ret->all_layouts = ret->all_counts = 1;
446  return ret;
447 }
448 
449 #define FORMATS_REF(f, ref, unref_fn) \
450  void *tmp; \
451  \
452  if (!f || !ref) \
453  return AVERROR(ENOMEM); \
454  \
455  tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1); \
456  if (!tmp) { \
457  unref_fn(&f); \
458  return AVERROR(ENOMEM); \
459  } \
460  f->refs = tmp; \
461  f->refs[f->refcount++] = ref; \
462  *ref = f; \
463  return 0
464 
466 {
468 }
469 
471 {
472  FORMATS_REF(f, ref, ff_formats_unref);
473 }
474 
475 #define FIND_REF_INDEX(ref, idx) \
476 do { \
477  int i; \
478  for (i = 0; i < (*ref)->refcount; i ++) \
479  if((*ref)->refs[i] == ref) { \
480  idx = i; \
481  break; \
482  } \
483 } while (0)
484 
485 #define FORMATS_UNREF(ref, list) \
486 do { \
487  int idx = -1; \
488  \
489  if (!ref || !*ref || !(*ref)->refs) \
490  return; \
491  \
492  FIND_REF_INDEX(ref, idx); \
493  \
494  if (idx >= 0) \
495  memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
496  sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
497  \
498  if(!--(*ref)->refcount) { \
499  av_free((*ref)->list); \
500  av_free((*ref)->refs); \
501  av_free(*ref); \
502  } \
503  *ref = NULL; \
504 } while (0)
505 
507 {
508  FORMATS_UNREF(ref, formats);
509 }
510 
512 {
514 }
515 
516 #define FORMATS_CHANGEREF(oldref, newref) \
517 do { \
518  int idx = -1; \
519  \
520  FIND_REF_INDEX(oldref, idx); \
521  \
522  if (idx >= 0) { \
523  (*oldref)->refs[idx] = newref; \
524  *newref = *oldref; \
525  *oldref = NULL; \
526  } \
527 } while (0)
528 
530  AVFilterChannelLayouts **newref)
531 {
532  FORMATS_CHANGEREF(oldref, newref);
533 }
534 
536 {
537  FORMATS_CHANGEREF(oldref, newref);
538 }
539 
540 #define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref_fn, unref_fn, list) \
541  int count = 0, i; \
542  \
543  if (!fmts) \
544  return AVERROR(ENOMEM); \
545  \
546  for (i = 0; i < ctx->nb_inputs; i++) { \
547  if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
548  int ret = ref_fn(fmts, &ctx->inputs[i]->out_fmts); \
549  if (ret < 0) { \
550  unref_fn(&fmts); \
551  if (fmts) \
552  av_freep(&fmts->list); \
553  av_freep(&fmts); \
554  return ret; \
555  } \
556  count++; \
557  } \
558  } \
559  for (i = 0; i < ctx->nb_outputs; i++) { \
560  if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
561  int ret = ref_fn(fmts, &ctx->outputs[i]->in_fmts); \
562  if (ret < 0) { \
563  unref_fn(&fmts); \
564  if (fmts) \
565  av_freep(&fmts->list); \
566  av_freep(&fmts); \
567  return ret; \
568  } \
569  count++; \
570  } \
571  } \
572  \
573  if (!count) { \
574  av_freep(&fmts->list); \
575  av_freep(&fmts->refs); \
576  av_freep(&fmts); \
577  } \
578  \
579  return 0;
580 
583 {
584  SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
586 }
587 
589  AVFilterFormats *samplerates)
590 {
591  SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
593 }
594 
595 /**
596  * A helper for query_formats() which sets all links to the same list of
597  * formats. If there are no links hooked to this filter, the list of formats is
598  * freed.
599  */
601 {
602  SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
603  ff_formats_ref, ff_formats_unref, formats);
604 }
605 
608 {
609  int ret;
610  enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
611  ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
613 
614  ret = ff_set_common_formats(ctx, ff_all_formats(type));
615  if (ret < 0)
616  return ret;
617  if (type == AVMEDIA_TYPE_AUDIO) {
619  if (ret < 0)
620  return ret;
622  if (ret < 0)
623  return ret;
624  }
625 
626  return 0;
627 }
628 
630 {
632 }
633 
635 {
637 }
638 
639 /* internal functions for parsing audio format arguments */
640 
641 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
642 {
643  char *tail;
644  int pix_fmt = av_get_pix_fmt(arg);
645  if (pix_fmt == AV_PIX_FMT_NONE) {
646  pix_fmt = strtol(arg, &tail, 0);
647  if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
648  av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
649  return AVERROR(EINVAL);
650  }
651  }
652  *ret = pix_fmt;
653  return 0;
654 }
655 
656 int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
657 {
658  char *tail;
659  int sfmt = av_get_sample_fmt(arg);
660  if (sfmt == AV_SAMPLE_FMT_NONE) {
661  sfmt = strtol(arg, &tail, 0);
662  if (*tail || av_get_bytes_per_sample(sfmt)<=0) {
663  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
664  return AVERROR(EINVAL);
665  }
666  }
667  *ret = sfmt;
668  return 0;
669 }
670 
671 int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
672 {
673  AVRational r;
674  if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0 ||r.den<=0) {
675  av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
676  return AVERROR(EINVAL);
677  }
678  *ret = r;
679  return 0;
680 }
681 
682 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
683 {
684  char *tail;
685  double srate = av_strtod(arg, &tail);
686  if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
687  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
688  return AVERROR(EINVAL);
689  }
690  *ret = srate;
691  return 0;
692 }
693 
694 int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
695  void *log_ctx)
696 {
697  int64_t chlayout;
698  int nb_channels;
699 
700  if (av_get_extended_channel_layout(arg, &chlayout, &nb_channels) < 0) {
701  av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
702  return AVERROR(EINVAL);
703  }
704  if (!chlayout && !nret) {
705  av_log(log_ctx, AV_LOG_ERROR, "Unknown channel layout '%s' is not supported.\n", arg);
706  return AVERROR(EINVAL);
707  }
708  *ret = chlayout;
709  if (nret)
710  *nret = nb_channels;
711 
712  return 0;
713 }
int av_parse_ratio(AVRational *q, const char *str, int max, int log_offset, void *log_ctx)
Parse str and store the parsed ratio in q.
Definition: parseutils.c:45
#define NULL
Definition: coverity.c:32
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates...
Definition: formats.c:581
static enum AVPixelFormat pix_fmt
#define FORMATS_UNREF(ref, list)
Definition: formats.c:485
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
Parse a pixel format.
Definition: formats.c:641
const char * desc
Definition: libsvtav1.c:79
Main libavfilter public API header.
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:529
int num
Numerator.
Definition: rational.h:59
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
GLint GLenum type
Definition: opengl_enc.c:104
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:92
struct AVFilterChannelLayouts *** refs
references to this list
Definition: formats.h:92
int ff_query_formats_all_layouts(AVFilterContext *ctx)
Set the formats list to all known channel layouts.
Definition: formats.c:634
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:346
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:465
int ff_formats_pixdesc_filter(AVFilterFormats **rfmts, unsigned want, unsigned rej)
Construct a formats list containing all pixel formats with certain properties.
Definition: formats.c:371
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:177
#define f(width, name)
Definition: cbs_vp9.c:255
struct AVFilterFormats *** refs
references to this list
Definition: formats.h:69
static int default_query_formats_common(AVFilterContext *ctx, AVFilterChannelLayouts *(layouts)(void))
Definition: formats.c:606
int ff_fmt_is_in(int fmt, const int *fmts)
Tell if an integer is contained in the provided -1-terminated list of integers.
Definition: formats.c:254
#define av_log(a,...)
AVFilterFormats * ff_all_formats(enum AVMediaType type)
Return a list of all formats supported by FFmpeg for the given media type.
Definition: formats.c:349
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Before After |formats |<------—.
Definition: formats.c:535
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:600
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:101
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:342
const char * r
Definition: vf_curves.c:114
int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg, void *log_ctx)
Parse a channel layout or a corresponding integer representation.
Definition: formats.c:694
uint64_t * channel_layouts
list of channel layouts
Definition: formats.h:86
const char * arg
Definition: jacosubdec.c:66
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
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
static av_always_inline av_const double round(double x)
Definition: libm.h:444
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:49
GLsizei count
Definition: opengl_enc.c:108
int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
Parse a sample format name or a corresponding integer representation.
Definition: formats.c:656
#define fail()
Definition: checkasm.h:123
char all_counts
accept any channel layout or count
Definition: formats.h:89
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2592
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define b
Definition: input.c:41
audio channel layout utility functions
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define MAKE_FORMAT_LIST(type, field, count_field)
Definition: formats.c:265
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:470
AVFormatContext * ctx
Definition: movenc.c:48
int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
Parse a time base.
Definition: formats.c:671
unsigned nb_formats
number of formats
Definition: formats.h:65
AVFilterFormats * ff_planar_sample_fmts(void)
Construct a formats list containing all planar sample formats.
Definition: formats.c:412
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (...
Definition: formats.c:431
A list of supported channel layouts.
Definition: formats.h:85
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:106
int ff_default_query_formats(AVFilterContext *ctx)
Definition: formats.c:629
#define FF_PIX_FMT_FLAG_SW_FLAT_SUB
Definition: formats.h:232
#define FORMATS_REF(f, ref, unref_fn)
Definition: formats.c:449
AVFilterChannelLayouts * avfilter_make_format64_list(const int64_t *fmts)
Definition: formats.c:303
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
char all_layouts
accept any known channel layout
Definition: formats.h:88
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
#define FORMATS_CHANGEREF(oldref, newref)
Definition: formats.c:516
AVFilterChannelLayouts * ff_merge_channel_layouts(AVFilterChannelLayouts *a, AVFilterChannelLayouts *b)
Return a channel layouts/samplerates list which contains the intersection of the layouts/samplerates ...
Definition: formats.c:166
AVFilterFormats * ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b, enum AVMediaType type)
Return a format list which contains the intersection of the formats of a and b.
Definition: formats.c:92
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:511
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:113
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb)
Definition: formats.c:314
Rational number (pair of numerator and denominator).
Definition: rational.h:58
enum AVSampleFormat av_get_sample_fmt(const char *name)
Return a sample format corresponding to name, or AV_SAMPLE_FMT_NONE on error.
Definition: samplefmt.c:56
AVMediaType
Definition: avutil.h:199
void ff_formats_unref(AVFilterFormats **ref)
If *ref is non-NULL, remove *ref as a reference to the format list it currently points to...
Definition: formats.c:506
misc parsing utilities
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
#define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref_fn, unref_fn, list)
Definition: formats.c:540
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:425
#define flags(name, subs,...)
Definition: cbs_av1.c:560
#define KNOWN(l)
Definition: formats.c:32
AVFilterChannelLayouts * ff_make_formatu64_list(const uint64_t *fmts)
Definition: formats.c:292
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
common internal and external API header
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
int nb_channel_layouts
number of channel layouts
Definition: formats.h:87
int den
Denominator.
Definition: rational.h:60
int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
Parse a sample rate.
Definition: formats.c:682
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
#define av_freep(p)
#define FF_COUNT2LAYOUT(c)
Encode a channel count as a channel layout.
Definition: formats.h:102
#define av_malloc_array(a, b)
formats
Definition: signature.h:48
#define FFSWAP(type, a, b)
Definition: common.h:99
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2501
int nb_channels
AVFilterFormats * ff_merge_samplerates(AVFilterFormats *a, AVFilterFormats *b)
Definition: formats.c:139
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
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:440
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
int av_get_extended_channel_layout(const char *name, uint64_t *channel_layout, int *nb_channels)
Return a channel layout and the number of channels based on the specified name.
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:588
int i
Definition: input.c:407
simple arithmetic expression evaluator
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2580
int * formats
list of media formats
Definition: formats.h:66
#define MERGE_REF(ret, a, fmts, type, fail)
Add all refs from a to ret and destroy a.
Definition: formats.c:37
#define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail)
Add all formats common for a and b to ret, copy the refs and destroy a and b.
Definition: formats.c:61