FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 avfilter_merge_formats() detected\n"); \
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 {
95  AVFilterFormats *ret = NULL;
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 {
142  AVFilterFormats *ret = NULL;
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  }
193  MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
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;
241  MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);
242  MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, 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 
303 #define ADD_FORMAT(f, fmt, type, list, nb) \
304 do { \
305  type *fmts; \
306  void *oldf = *f; \
307  \
308  if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) \
309  return AVERROR(ENOMEM); \
310  \
311  fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
312  sizeof(*(*f)->list)); \
313  if (!fmts) { \
314  if (!oldf) \
315  av_freep(f); \
316  return AVERROR(ENOMEM); \
317  } \
318  \
319  (*f)->list = fmts; \
320  (*f)->list[(*f)->nb++] = fmt; \
321 } while (0)
322 
323 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
324 {
325  ADD_FORMAT(avff, fmt, int, formats, nb_formats);
326  return 0;
327 }
328 
329 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
330 {
331  av_assert1(!(*l && (*l)->all_layouts));
332  ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
333  return 0;
334 }
335 
337 {
338  AVFilterFormats *ret = NULL;
339 
340  if (type == AVMEDIA_TYPE_VIDEO) {
341  const AVPixFmtDescriptor *desc = NULL;
342  while ((desc = av_pix_fmt_desc_next(desc))) {
343  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
345  }
346  } else if (type == AVMEDIA_TYPE_AUDIO) {
347  enum AVSampleFormat fmt = 0;
348  while (av_get_sample_fmt_name(fmt)) {
349  ff_add_format(&ret, fmt);
350  fmt++;
351  }
352  }
353 
354  return ret;
355 }
356 
357 const int64_t avfilter_all_channel_layouts[] = {
358 #include "all_channel_layouts.inc"
359  -1
360 };
361 
362 // AVFilterFormats *avfilter_make_all_channel_layouts(void)
363 // {
364 // return avfilter_make_format64_list(avfilter_all_channel_layouts);
365 // }
366 
368 {
369  AVFilterFormats *ret = NULL;
370  int fmt;
371 
372  for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
373  if (av_sample_fmt_is_planar(fmt))
374  ff_add_format(&ret, fmt);
375 
376  return ret;
377 }
378 
380 {
381  AVFilterFormats *ret = av_mallocz(sizeof(*ret));
382  return ret;
383 }
384 
386 {
387  AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
388  if (!ret)
389  return NULL;
390  ret->all_layouts = 1;
391  return ret;
392 }
393 
395 {
396  AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
397  if (!ret)
398  return NULL;
399  ret->all_layouts = ret->all_counts = 1;
400  return ret;
401 }
402 
403 #define FORMATS_REF(f, ref) \
404  void *tmp; \
405  \
406  if (!ref) \
407  return AVERROR_BUG; \
408  \
409  tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1); \
410  if (!tmp) \
411  return AVERROR(ENOMEM); \
412  f->refs = tmp; \
413  f->refs[f->refcount++] = ref; \
414  *ref = f; \
415  return 0
416 
418 {
419  FORMATS_REF(f, ref);
420 }
421 
423 {
424  FORMATS_REF(f, ref);
425 }
426 
427 #define FIND_REF_INDEX(ref, idx) \
428 do { \
429  int i; \
430  for (i = 0; i < (*ref)->refcount; i ++) \
431  if((*ref)->refs[i] == ref) { \
432  idx = i; \
433  break; \
434  } \
435 } while (0)
436 
437 #define FORMATS_UNREF(ref, list) \
438 do { \
439  int idx = -1; \
440  \
441  if (!*ref) \
442  return; \
443  \
444  FIND_REF_INDEX(ref, idx); \
445  \
446  if (idx >= 0) \
447  memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
448  sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
449  \
450  if(!--(*ref)->refcount) { \
451  av_free((*ref)->list); \
452  av_free((*ref)->refs); \
453  av_free(*ref); \
454  } \
455  *ref = NULL; \
456 } while (0)
457 
459 {
460  FORMATS_UNREF(ref, formats);
461 }
462 
464 {
465  FORMATS_UNREF(ref, channel_layouts);
466 }
467 
468 #define FORMATS_CHANGEREF(oldref, newref) \
469 do { \
470  int idx = -1; \
471  \
472  FIND_REF_INDEX(oldref, idx); \
473  \
474  if (idx >= 0) { \
475  (*oldref)->refs[idx] = newref; \
476  *newref = *oldref; \
477  *oldref = NULL; \
478  } \
479 } while (0)
480 
482  AVFilterChannelLayouts **newref)
483 {
484  FORMATS_CHANGEREF(oldref, newref);
485 }
486 
488 {
489  FORMATS_CHANGEREF(oldref, newref);
490 }
491 
492 #define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \
493  int count = 0, i; \
494  \
495  if (!fmts) \
496  return AVERROR_BUG; \
497  \
498  for (i = 0; i < ctx->nb_inputs; i++) { \
499  if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
500  int ret = ref(fmts, &ctx->inputs[i]->out_fmts); \
501  if (ret < 0) \
502  return ret; \
503  count++; \
504  } \
505  } \
506  for (i = 0; i < ctx->nb_outputs; i++) { \
507  if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
508  int ret = ref(fmts, &ctx->outputs[i]->in_fmts); \
509  if (ret < 0) \
510  return ret; \
511  count++; \
512  } \
513  } \
514  \
515  if (!count) { \
516  av_freep(&fmts->list); \
517  av_freep(&fmts->refs); \
518  av_freep(&fmts); \
519  } \
520  \
521  return 0;
522 
525 {
526  SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
527  ff_channel_layouts_ref, channel_layouts);
528 }
529 
531  AVFilterFormats *samplerates)
532 {
533  SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
535 }
536 
537 /**
538  * A helper for query_formats() which sets all links to the same list of
539  * formats. If there are no links hooked to this filter, the list of formats is
540  * freed.
541  */
543 {
544  SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
545  ff_formats_ref, formats);
546 }
547 
550 {
551  int ret;
552  enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
553  ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
555 
556  ret = ff_set_common_formats(ctx, ff_all_formats(type));
557  if (ret < 0)
558  return ret;
559  if (type == AVMEDIA_TYPE_AUDIO) {
561  if (ret < 0)
562  return ret;
564  if (ret < 0)
565  return ret;
566  }
567 
568  return 0;
569 }
570 
572 {
574 }
575 
577 {
579 }
580 
581 /* internal functions for parsing audio format arguments */
582 
583 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
584 {
585  char *tail;
586  int pix_fmt = av_get_pix_fmt(arg);
587  if (pix_fmt == AV_PIX_FMT_NONE) {
588  pix_fmt = strtol(arg, &tail, 0);
589  if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
590  av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
591  return AVERROR(EINVAL);
592  }
593  }
594  *ret = pix_fmt;
595  return 0;
596 }
597 
598 int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
599 {
600  char *tail;
601  int sfmt = av_get_sample_fmt(arg);
602  if (sfmt == AV_SAMPLE_FMT_NONE) {
603  sfmt = strtol(arg, &tail, 0);
604  if (*tail || av_get_bytes_per_sample(sfmt)<=0) {
605  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
606  return AVERROR(EINVAL);
607  }
608  }
609  *ret = sfmt;
610  return 0;
611 }
612 
613 int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
614 {
615  AVRational r;
616  if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0 ||r.den<=0) {
617  av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
618  return AVERROR(EINVAL);
619  }
620  *ret = r;
621  return 0;
622 }
623 
624 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
625 {
626  char *tail;
627  double srate = av_strtod(arg, &tail);
628  if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
629  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
630  return AVERROR(EINVAL);
631  }
632  *ret = srate;
633  return 0;
634 }
635 
636 int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
637  void *log_ctx)
638 {
639  char *tail;
640  int64_t chlayout;
641 
642  chlayout = av_get_channel_layout(arg);
643  if (chlayout == 0) {
644  chlayout = strtol(arg, &tail, 10);
645  if (!(*tail == '\0' || *tail == 'c' && *(tail + 1) == '\0') || chlayout <= 0 || chlayout > 63) {
646  av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
647  return AVERROR(EINVAL);
648  }
649  if (nret) {
650  *nret = chlayout;
651  *ret = 0;
652  return 0;
653  }
654  }
655  *ret = chlayout;
656  if (nret)
657  *nret = av_get_channel_layout_nb_channels(chlayout);
658  return 0;
659 }
660 
661 #ifdef TEST
662 
663 #undef printf
664 
665 int main(void)
666 {
667  const int64_t *cl;
668  char buf[512];
669  int i;
670  const char *teststrings[] ={
671  "blah",
672  "1",
673  "2",
674  "-1",
675  "60",
676  "65",
677  "1c",
678  "2c",
679  "-1c",
680  "60c",
681  "65c",
682  "5.1",
683  "stereo",
684  "1+1+1+1",
685  "1c+1c+1c+1c",
686  "2c+1c",
687  "0x3",
688  };
689 
690  for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
691  av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
692  printf("%s\n", buf);
693  }
694 
695  for ( i = 0; i<FF_ARRAY_ELEMS(teststrings); i++) {
696  int64_t layout = -1;
697  int count = -1;
698  int ret;
699  ret = ff_parse_channel_layout(&layout, &count, teststrings[i], NULL);
700 
701  printf ("%d = ff_parse_channel_layout(%016"PRIX64", %2d, %s);\n", ret ? -1 : 0, layout, count, teststrings[i]);
702  }
703 
704  return 0;
705 }
706 
707 #endif
708 
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:44
#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:523
static enum AVPixelFormat pix_fmt
#define FORMATS_UNREF(ref, list)
Definition: formats.c:437
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2129
const char * fmt
Definition: avisynth_c.h:632
int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
Parse a pixel format.
Definition: formats.c:583
Main libavfilter public API header.
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:481
const int64_t avfilter_all_channel_layouts[]
Definition: formats.c:357
int num
numerator
Definition: rational.h:44
const char * b
Definition: vf_curves.c:109
static enum AVSampleFormat formats[]
struct AVFilterChannelLayouts *** refs
references to this list
Definition: formats.h:92
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.
uint64_t av_get_channel_layout(const char *name)
Return a channel layout id that matches name, or 0 if no match is found.
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:641
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:417
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:156
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:548
int ff_fmt_is_in(int fmt, const int *fmts)
Tell is a format is contained in the provided list terminated by -1.
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:336
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:110
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Before After |formats |<------—.
Definition: formats.c:487
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:542
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:329
#define AVERROR(e)
Definition: error.h:43
const char * r
Definition: vf_curves.c:107
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:636
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:123
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:323
static av_always_inline av_const double round(double x)
Definition: libm.h:162
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:47
GLsizei count
Definition: opengl_enc.c:109
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:598
#define fail()
Definition: checkasm.h:57
char all_counts
accept any channel layout or count
Definition: formats.h:89
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2148
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
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:422
#define ADD_FORMAT(f, fmt, type, list, nb)
Definition: formats.c:303
int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
Parse a time base.
Definition: formats.c:613
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:367
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:385
#define FF_ARRAY_ELEMS(a)
A list of supported channel layouts.
Definition: formats.h:85
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:93
int ff_default_query_formats(AVFilterContext *ctx)
Definition: formats.c:571
#define FORMATS_REF(f, ref)
Definition: formats.c:403
AVFilterChannelLayouts * avfilter_make_format64_list(const int64_t *fmts)
Definition: formats.c:292
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:59
char all_layouts
accept any known channel layout
Definition: formats.h:88
uint8_t flags
Definition: pixdesc.h:90
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
#define FORMATS_CHANGEREF(oldref, newref)
Definition: formats.c:468
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:463
void * buf
Definition: avisynth_c.h:553
GLint GLenum type
Definition: opengl_enc.c:105
int ff_query_formats_all(AVFilterContext *ctx)
Set the formats list to all existing formats.
Definition: formats.c:576
rational number numerator/denominator
Definition: rational.h:43
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:54
AVMediaType
Definition: avutil.h:191
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:458
misc parsing utilities
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:648
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:434
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:379
#define KNOWN(l)
Definition: formats.c:32
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:104
common internal and external API header
int nb_channel_layouts
number of channel layouts
Definition: formats.h:87
int den
denominator
Definition: rational.h:45
int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
Parse a sample rate.
Definition: formats.c:624
A list of supported formats for one end of a filter link.
Definition: formats.h:64
uint64_t layout
An instance of a filter.
Definition: avfilter.h:633
#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)
#define FFSWAP(type, a, b)
Definition: common.h:84
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2062
#define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list)
Definition: formats.c:492
int main(int argc, char **argv)
Definition: main.c:22
AVFilterFormats * ff_merge_samplerates(AVFilterFormats *a, AVFilterFormats *b)
Definition: formats.c:139
internal API functions
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition...
Definition: formats.c:394
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:252
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:530
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:2136
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