FFmpeg: libavfilter/formats.c Source File

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"
23 #include "libavutil/bprint.h"
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/common.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/pixdesc.h"
28 #include "avfilter.h"
29 #include "filters.h"
30 #include "formats.h"
31 
32 /**
33  * Add all refs from a to ret and destroy a.
34  */
35  #define MERGE_REF(ret, a, fmts, type, fail_statement) \
36 do { \
37  type ***tmp; \
38  int i; \
39  \
40  if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
41  sizeof(*tmp)))) \
42  { fail_statement } \
43  ret->refs = tmp; \
44  \
45  for (i = 0; i < a->refcount; i ++) { \
46  ret->refs[ret->refcount] = a->refs[i]; \
47  *ret->refs[ret->refcount++] = ret; \
48  } \
49  \
50  av_freep(&a->refs); \
51  av_freep(&a->fmts); \
52  av_freep(&a); \
53 } while (0)
54 
55 /**
56  * Add all formats common to a and b to a, add b's refs to a and destroy b.
57  * If check is set, nothing is modified and it is only checked whether
58  * the formats are compatible.
59  * If empty_allowed is set and one of a,b->nb is zero, the lists are
60  * merged; otherwise, 0 (for nonmergeability) is returned.
61  */
62  #define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed) \
63 do { \
64  int i, j, k = 0, skip = 0; \
65  \
66  if (empty_allowed) { \
67  if (!a->nb || !b->nb) { \
68  if (check) \
69  return 1; \
70  if (!a->nb) \
71  FFSWAP(type *, a, b); \
72  skip = 1; \
73  } \
74  } \
75  if (!skip) { \
76  for (i = 0; i < a->nb; i++) \
77  for (j = 0; j < b->nb; j++) \
78  if (a->fmts[i] == b->fmts[j]) { \
79  if (check) \
80  return 1; \
81  a->fmts[k++] = a->fmts[i]; \
82  break; \
83  } \
84 /* Check that there was at least one common format. \
85  * Notice that both a and b are unchanged if not. */ \
86  if (!k) \
87  return 0; \
88  av_assert2(!check); \
89  a->nb = k; \
90  } \
91  \
92  MERGE_REF(a, b, fmts, type, return AVERROR(ENOMEM);); \
93 } while (0)
94  
95 static int merge_formats_internal(AVFilterFormats *a, AVFilterFormats *b,
96  enum AVMediaType type, int check)
97 {
98  int i, j;
99  int alpha1=0, alpha2=0;
100  int chroma1=0, chroma2=0;
101 
102  av_assert2(check || (a->refcount && b->refcount));
103 
104  if (a == b)
105  return 1;
106 
107  /* Do not lose chroma or alpha in merging.
108  It happens if both lists have formats with chroma (resp. alpha), but
109  the only formats in common do not have it (e.g. YUV+gray vs.
110  RGB+gray): in that case, the merging would select the gray format,
111  possibly causing a lossy conversion elsewhere in the graph.
112  To avoid that, pretend that there are no common formats to force the
113  insertion of a conversion filter. */
114  if (type == AVMEDIA_TYPE_VIDEO)
115  for (i = 0; i < a->nb_formats; i++) {
116  const AVPixFmtDescriptor *const adesc = av_pix_fmt_desc_get(a->formats[i]);
117  for (j = 0; j < b->nb_formats; j++) {
118  const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
119  alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
120  chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
121  if (a->formats[i] == b->formats[j]) {
122  alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
123  chroma1|= adesc->nb_components > 1;
124  }
125  }
126  }
127 
128  // If chroma or alpha can be lost through merging then do not merge
129  if (alpha2 > alpha1 || chroma2 > chroma1)
130  return 0;
131 
132  MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
133 
134  return 1;
135 }
136 
137 
138 /**
139  * Check the formats lists for compatibility for merging without actually
140  * merging.
141  *
142  * @return 1 if they are compatible, 0 if not.
143   */
144 static int can_merge_pix_fmts(const void *a, const void *b)
145 {
146  return merge_formats_internal((AVFilterFormats *)a,
147  (AVFilterFormats *)b, AVMEDIA_TYPE_VIDEO, 1);
148 }
149 
150 /**
151  * Merge the formats lists if they are compatible and update all the
152  * references of a and b to point to the combined list and free the old
153  * lists as needed. The combined list usually contains the intersection of
154  * the lists of a and b.
155  *
156  * Both a and b must have owners (i.e. refcount > 0) for these functions.
157  *
158  * @return 1 if merging succeeded, 0 if a and b are incompatible
159  * and negative AVERROR code on failure.
160  * a and b are unmodified if 0 is returned.
161   */
162 static int merge_pix_fmts(void *a, void *b)
163 {
164  return merge_formats_internal(a, b, AVMEDIA_TYPE_VIDEO, 0);
165 }
166 
167 /**
168  * See can_merge_pix_fmts().
169   */
170 static int can_merge_sample_fmts(const void *a, const void *b)
171 {
172  return merge_formats_internal((AVFilterFormats *)a,
173  (AVFilterFormats *)b, AVMEDIA_TYPE_AUDIO, 1);
174 }
175 
176 /**
177  * See merge_pix_fmts().
178   */
179 static int merge_sample_fmts(void *a, void *b)
180 {
181  return merge_formats_internal(a, b, AVMEDIA_TYPE_AUDIO, 0);
182 }
183  
184 static int merge_samplerates_internal(AVFilterFormats *a,
185  AVFilterFormats *b, int check)
186 {
187  av_assert2(check || (a->refcount && b->refcount));
188  if (a == b) return 1;
189 
190  MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 1);
191  return 1;
192 }
193 
194 /**
195  * See can_merge_pix_fmts().
196   */
197 static int can_merge_samplerates(const void *a, const void *b)
198 {
199  return merge_samplerates_internal((AVFilterFormats *)a, (AVFilterFormats *)b, 1);
200 }
201 
202 /**
203  * See merge_pix_fmts().
204   */
205 static int merge_samplerates(void *a, void *b)
206 {
207  return merge_samplerates_internal(a, b, 0);
208 }
209 
210 /**
211  * See merge_pix_fmts().
212   */
213 static int merge_channel_layouts_internal(AVFilterChannelLayouts *a,
214  AVFilterChannelLayouts *b, int check)
215 {
216  AVChannelLayout *channel_layouts = NULL;
217  unsigned a_all = a->all_layouts + a->all_counts;
218  unsigned b_all = b->all_layouts + b->all_counts;
219  int ret_max, ret_nb = 0, i, j, round;
220 
221  av_assert2(a->refcount && b->refcount);
222 
223  if (a == b) return 1;
224 
225  /* Put the most generic set in a, to avoid doing everything twice */
226  if (a_all < b_all) {
227  FFSWAP(AVFilterChannelLayouts *, a, b);
228  FFSWAP(unsigned, a_all, b_all);
229  }
230  if (a_all) {
231  if (a_all == 1 && !b_all) {
232  /* keep only known layouts in b; works also for b_all = 1 */
233  for (i = j = 0; i < b->nb_channel_layouts; i++)
234  if (KNOWN(&b->channel_layouts[i]) && i != j++) {
235  if (check)
236  return 1;
237  av_channel_layout_copy(&b->channel_layouts[j], &b->channel_layouts[i]);
238  }
239  /* Not optimal: the unknown layouts of b may become known after
240  another merge. */
241  if (!j)
242  return 0;
243  b->nb_channel_layouts = j;
244  }
245  MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, return AVERROR(ENOMEM););
246  return 1;
247  }
248 
249  ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
250  if (!check && !(channel_layouts = av_calloc(ret_max, sizeof(*channel_layouts))))
251  return AVERROR(ENOMEM);
252 
253  /* a[known] intersect b[known] */
254  for (i = 0; i < a->nb_channel_layouts; i++) {
255  if (!KNOWN(&a->channel_layouts[i]))
256  continue;
257  for (j = 0; j < b->nb_channel_layouts; j++) {
258  if (!av_channel_layout_compare(&a->channel_layouts[i], &b->channel_layouts[j])) {
259  if (check)
260  return 1;
261  av_channel_layout_copy(&channel_layouts[ret_nb++], &a->channel_layouts[i]);
262  av_channel_layout_uninit(&a->channel_layouts[i]);
263  av_channel_layout_uninit(&b->channel_layouts[j]);
264  break;
265  }
266  }
267  }
268  /* 1st round: a[known] intersect b[generic]
269  2nd round: a[generic] intersect b[known] */
270  for (round = 0; round < 2; round++) {
271  for (i = 0; i < a->nb_channel_layouts; i++) {
272  AVChannelLayout *fmt = &a->channel_layouts[i], bfmt = { 0 };
273  if (!av_channel_layout_check(fmt) || !KNOWN(fmt))
274  continue;
275  bfmt = FF_COUNT2LAYOUT(fmt->nb_channels);
276  for (j = 0; j < b->nb_channel_layouts; j++)
277  if (!av_channel_layout_compare(&b->channel_layouts[j], &bfmt)) {
278  if (check)
279  return 1;
280  av_channel_layout_copy(&channel_layouts[ret_nb++], fmt);
281  }
282  }
283  /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
284  FFSWAP(AVFilterChannelLayouts *, a, b);
285  }
286  /* a[generic] intersect b[generic] */
287  for (i = 0; i < a->nb_channel_layouts; i++) {
288  if (KNOWN(&a->channel_layouts[i]))
289  continue;
290  for (j = 0; j < b->nb_channel_layouts; j++)
291  if (!av_channel_layout_compare(&a->channel_layouts[i], &b->channel_layouts[j])) {
292  if (check)
293  return 1;
294  av_channel_layout_copy(&channel_layouts[ret_nb++], &a->channel_layouts[i]);
295  }
296  }
297 
298  if (!ret_nb) {
299  av_free(channel_layouts);
300  return 0;
301  }
302 
303  if (a->refcount > b->refcount)
304  FFSWAP(AVFilterChannelLayouts *, a, b);
305 
306  MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts,
307  { av_free(channel_layouts); return AVERROR(ENOMEM); });
308  av_freep(&b->channel_layouts);
309  b->channel_layouts = channel_layouts;
310  b->nb_channel_layouts = ret_nb;
311  return 1;
312 }
313  
314 static int can_merge_channel_layouts(const void *a, const void *b)
315 {
316  return merge_channel_layouts_internal((AVFilterChannelLayouts *)a,
317  (AVFilterChannelLayouts *)b, 1);
318 }
319  
320 static int merge_channel_layouts(void *a, void *b)
321 {
322  return merge_channel_layouts_internal(a, b, 0);
323 }
324  
325 static int merge_generic_internal(AVFilterFormats *a,
326  AVFilterFormats *b, int check)
327 {
328  av_assert2(check || (a->refcount && b->refcount));
329 
330  if (a == b)
331  return 1;
332 
333  MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
334 
335  return 1;
336 }
337  
338 static int can_merge_generic(const void *a, const void *b)
339 {
340  return merge_generic_internal((AVFilterFormats *)a,
341  (AVFilterFormats *)b, 1);
342 }
343  
344 static int merge_generic(void *a, void *b)
345 {
346  return merge_generic_internal(a, b, 0);
347 }
348  
349 #define PRINT_NAME(type, type_name) \
350 static void print_##type_name(AVBPrint *bp, const void *fmtsp) \
351 { \
352  const AVFilterFormats *fmts = fmtsp; \
353  for (int i = 0; i < fmts->nb_formats; i++) { \
354  const char *name = av_##type_name(fmts->formats[i]); \
355  av_bprint_chars(bp, ' ', i ? 1 : 0); \
356  av_bprint_append_data(bp, name, name ? strlen(name) : 0); \
357  } \
358 }
359 
360 PRINT_NAME(enum AVSampleFormat, get_sample_fmt_name)
361 PRINT_NAME(enum AVPixelFormat, get_pix_fmt_name)
362 PRINT_NAME(enum AVColorSpace, color_space_name)
363 PRINT_NAME(enum AVColorRange, color_range_name)
364 PRINT_NAME(enum AVAlphaMode, alpha_mode_name)
365  
366 static void print_channel_layout_desc(AVBPrint *bp, const void *layoutsp)
367 {
368  const AVFilterChannelLayouts *layouts = layoutsp;
369  for (int i = 0; i < layouts->nb_channel_layouts; i++) {
370  av_bprint_chars(bp, ' ', i ? 1 : 0);
371  av_channel_layout_describe_bprint(&layouts->channel_layouts[i], bp);
372  }
373 }
374  
375 static void print_sample_rate(AVBPrint *bp, const void *ratesp)
376 {
377  const AVFilterFormats *rates = ratesp;
378  for (int i = 0; i < rates->nb_formats; i++)
379  av_bprintf(bp, "%s%d", i ? " " : "", rates->formats[i]);
380 }
381  
382 #define CONVERSION_FILTER_SWSCALE \
383  .conversion_filter = "scale", \
384  .conversion_opts_offset = offsetof(AVFilterGraph, scale_sws_opts),
385  
386 #define CONVERSION_FILTER_ARESAMPLE \
387  .conversion_filter = "aresample", \
388  .conversion_opts_offset = offsetof(AVFilterGraph, aresample_swr_opts),
389  
390 static const AVFilterFormatsMerger mergers_video[] = {
391  {
392  .name = "Pixel formats",
393  .offset = offsetof(AVFilterFormatsConfig, formats),
394  .merge = merge_pix_fmts,
395  .can_merge = can_merge_pix_fmts,
396  .print_list = print_get_pix_fmt_name,
397  CONVERSION_FILTER_SWSCALE
398  },
399  {
400  .name = "Color spaces",
401  .offset = offsetof(AVFilterFormatsConfig, color_spaces),
402  .merge = merge_generic,
403  .can_merge = can_merge_generic,
404  .print_list = print_color_space_name,
405  CONVERSION_FILTER_SWSCALE
406  },
407  {
408  .name = "Color ranges",
409  .offset = offsetof(AVFilterFormatsConfig, color_ranges),
410  .merge = merge_generic,
411  .can_merge = can_merge_generic,
412  .print_list = print_color_range_name,
413  CONVERSION_FILTER_SWSCALE
414  },
415  {
416  .name = "Alpha modes",
417  .offset = offsetof(AVFilterFormatsConfig, alpha_modes),
418  .merge = merge_generic,
419  .can_merge = can_merge_generic,
420  .print_list = print_alpha_mode_name,
421  .conversion_filter = "premultiply_dynamic",
422  },
423 };
424  
425 static const AVFilterFormatsMerger mergers_audio[] = {
426  {
427  .name = "Channel layouts",
428  .offset = offsetof(AVFilterFormatsConfig, channel_layouts),
429  .merge = merge_channel_layouts,
430  .can_merge = can_merge_channel_layouts,
431  .print_list = print_channel_layout_desc,
432  CONVERSION_FILTER_ARESAMPLE
433  },
434  {
435  .name = "Sample rates",
436  .offset = offsetof(AVFilterFormatsConfig, samplerates),
437  .merge = merge_samplerates,
438  .can_merge = can_merge_samplerates,
439  .print_list = print_sample_rate,
440  CONVERSION_FILTER_ARESAMPLE
441  },
442  {
443  .name = "Sample formats",
444  .offset = offsetof(AVFilterFormatsConfig, formats),
445  .merge = merge_sample_fmts,
446  .can_merge = can_merge_sample_fmts,
447  .print_list = print_get_sample_fmt_name,
448  CONVERSION_FILTER_ARESAMPLE
449  },
450 };
451  
452 static const AVFilterNegotiation negotiate_video = {
453  .nb_mergers = FF_ARRAY_ELEMS(mergers_video),
454  .mergers = mergers_video,
455 };
456  
457 static const AVFilterNegotiation negotiate_audio = {
458  .nb_mergers = FF_ARRAY_ELEMS(mergers_audio),
459  .mergers = mergers_audio,
460 };
461  
462 const AVFilterNegotiation *ff_filter_get_negotiation(const AVFilterLink *link)
463 {
464  switch (link->type) {
465  case AVMEDIA_TYPE_VIDEO: return &negotiate_video;
466  case AVMEDIA_TYPE_AUDIO: return &negotiate_audio;
467  default: return NULL;
468  }
469 }
470  
471 int ff_fmt_is_in(int fmt, const int *fmts)
472 {
473  const int *p;
474 
475  for (p = fmts; *p != -1; p++) {
476  if (fmt == *p)
477  return 1;
478  }
479  return 0;
480 }
481  
482 #define MAKE_FORMAT_LIST(type, field, count_field) \
483  type *formats; \
484  int count = 0; \
485  if (fmts) \
486  for (count = 0; fmts[count] != -1; count++) \
487  ; \
488  formats = av_mallocz(sizeof(*formats)); \
489  if (!formats) \
490  return NULL; \
491  formats->count_field = count; \
492  if (count) { \
493  formats->field = av_malloc_array(count, sizeof(*formats->field)); \
494  if (!formats->field) { \
495  av_freep(&formats); \
496  return NULL; \
497  } \
498  }
499  
500 AVFilterFormats *ff_make_format_list(const int *fmts)
501 {
502  MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);
503  while (count--)
504  formats->formats[count] = fmts[count];
505 
506  return formats;
507 }
508  
509 AVFilterChannelLayouts *ff_make_channel_layout_list(const AVChannelLayout *fmts)
510 {
511  AVFilterChannelLayouts *ch_layouts;
512  int count = 0;
513  if (fmts)
514  for (count = 0; fmts[count].nb_channels; count++)
515  ;
516  ch_layouts = av_mallocz(sizeof(*ch_layouts));
517  if (!ch_layouts)
518  return NULL;
519  ch_layouts->nb_channel_layouts = count;
520  if (count) {
521  ch_layouts->channel_layouts =
522  av_calloc(count, sizeof(*ch_layouts->channel_layouts));
523  if (!ch_layouts->channel_layouts) {
524  av_freep(&ch_layouts);
525  return NULL;
526  }
527  for (int i = 0; i < count; i++) {
528  int ret = av_channel_layout_copy(&ch_layouts->channel_layouts[i], &fmts[i]);
529  if (ret < 0)
530  goto fail;
531  }
532  }
533 
534  return ch_layouts;
535 
536 fail:
537  for (int i = 0; i < count; i++)
538  av_channel_layout_uninit(&ch_layouts->channel_layouts[i]);
539  av_free(ch_layouts->channel_layouts);
540  av_freep(&ch_layouts);
541 
542  return NULL;
543 }
544  
545 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
546 do { \
547  type *fmts; \
548  \
549  if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
550  return AVERROR(ENOMEM); \
551  } \
552  \
553  fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
554  sizeof(*(*f)->list)); \
555  if (!fmts) { \
556  unref_fn(f); \
557  return AVERROR(ENOMEM); \
558  } \
559  \
560  (*f)->list = fmts; \
561  ASSIGN_FMT(f, fmt, list, nb); \
562 } while (0)
563 
564 #define ASSIGN_FMT(f, fmt, list, nb) \
565 do { \
566  (*f)->list[(*f)->nb++] = fmt; \
567 } while (0)
568  
569 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
570 {
571  ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
572  return 0;
573 }
574 
575  #undef ASSIGN_FMT
576 #define ASSIGN_FMT(f, fmt, list, nb) \
577 do { \
578  int ret; \
579  memset((*f)->list + (*f)->nb, 0, sizeof(*(*f)->list)); \
580  ret = av_channel_layout_copy(&(*f)->list[(*f)->nb], fmt); \
581  if (ret < 0) \
582  return ret; \
583  (*f)->nb++; \
584 } while (0)
585  
586 int ff_add_channel_layout(AVFilterChannelLayouts **l,
587  const AVChannelLayout *channel_layout)
588 {
589  av_assert1(!(*l && (*l)->all_layouts));
590  ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, AVChannelLayout, channel_layouts, nb_channel_layouts);
591  return 0;
592 }
593  
594 AVFilterFormats *ff_make_formats_list_singleton(int fmt)
595 {
596  int fmts[2] = { fmt, -1 };
597  return ff_make_format_list(fmts);
598 }
599  
600 AVFilterFormats *ff_all_formats(enum AVMediaType type)
601 {
602  AVFilterFormats *ret = NULL;
603 
604  if (type == AVMEDIA_TYPE_VIDEO) {
605  return ff_formats_pixdesc_filter(0, 0);
606  } else if (type == AVMEDIA_TYPE_AUDIO) {
607  enum AVSampleFormat fmt = 0;
608  while (av_get_sample_fmt_name(fmt)) {
609  if (ff_add_format(&ret, fmt) < 0)
610  return NULL;
611  fmt++;
612  }
613  }
614 
615  return ret;
616 }
617  
618 AVFilterFormats *ff_formats_pixdesc_filter(unsigned want, unsigned rej)
619 {
620  unsigned nb_formats, fmt, flags;
621  AVFilterFormats *formats = NULL;
622 
623  while (1) {
624  nb_formats = 0;
625  for (fmt = 0;; fmt++) {
626  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
627  if (!desc)
628  break;
629  flags = desc->flags;
630  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
631  !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
632  (desc->log2_chroma_w || desc->log2_chroma_h))
633  flags |= FF_PIX_FMT_FLAG_SW_FLAT_SUB;
634  if ((flags & (want | rej)) != want)
635  continue;
636  if (formats)
637  formats->formats[nb_formats] = fmt;
638  nb_formats++;
639  }
640  if (formats) {
641  av_assert0(formats->nb_formats == nb_formats);
642  return formats;
643  }
644  formats = av_mallocz(sizeof(*formats));
645  if (!formats)
646  return NULL;
647  formats->nb_formats = nb_formats;
648  if (nb_formats) {
649  formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
650  if (!formats->formats) {
651  av_freep(&formats);
652  return NULL;
653  }
654  }
655  }
656 }
657  
658 AVFilterFormats *ff_planar_sample_fmts(void)
659 {
660  AVFilterFormats *ret = NULL;
661  int fmt;
662 
663  for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
664  if (av_sample_fmt_is_planar(fmt))
665  if (ff_add_format(&ret, fmt) < 0)
666  return NULL;
667 
668  return ret;
669 }
670  
671 AVFilterFormats *ff_all_samplerates(void)
672 {
673  AVFilterFormats *ret = av_mallocz(sizeof(*ret));
674  return ret;
675 }
676  
677 AVFilterChannelLayouts *ff_all_channel_layouts(void)
678 {
679  AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
680  if (!ret)
681  return NULL;
682  ret->all_layouts = 1;
683  return ret;
684 }
685  
686 AVFilterChannelLayouts *ff_all_channel_counts(void)
687 {
688  AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
689  if (!ret)
690  return NULL;
691  ret->all_layouts = ret->all_counts = 1;
692  return ret;
693 }
694  
695 AVFilterFormats *ff_all_color_spaces(void)
696 {
697  AVFilterFormats *ret = NULL;
698  if (ff_add_format(&ret, AVCOL_SPC_UNSPECIFIED) < 0)
699  return NULL;
700  for (int csp = 0; csp < AVCOL_SPC_NB; csp++) {
701  if (csp == AVCOL_SPC_RESERVED ||
702  csp == AVCOL_SPC_UNSPECIFIED)
703  continue;
704  if (ff_add_format(&ret, csp) < 0)
705  return NULL;
706  }
707 
708  return ret;
709 }
710  
711 AVFilterFormats *ff_all_color_ranges(void)
712 {
713  AVFilterFormats *ret = NULL;
714  for (int range = 0; range < AVCOL_RANGE_NB; range++) {
715  if (ff_add_format(&ret, range) < 0)
716  return NULL;
717  }
718 
719  return ret;
720 }
721  
722 AVFilterFormats *ff_all_alpha_modes(void)
723 {
724  AVFilterFormats *ret = NULL;
725  for (int range = 0; range < AVALPHA_MODE_NB; range++) {
726  if (ff_add_format(&ret, range) < 0)
727  return NULL;
728  }
729 
730  return ret;
731 }
732  
733 #define FORMATS_REF(f, ref, unref_fn) \
734  void *tmp; \
735  \
736  if (!f) \
737  return AVERROR(ENOMEM); \
738  \
739  tmp = av_realloc_array(f->refs, f->refcount + 1, sizeof(*f->refs)); \
740  if (!tmp) { \
741  unref_fn(&f); \
742  return AVERROR(ENOMEM); \
743  } \
744  f->refs = tmp; \
745  f->refs[f->refcount++] = ref; \
746  *ref = f; \
747  return 0
748  
749 int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
750 {
751  FORMATS_REF(f, ref, ff_channel_layouts_unref);
752 }
753  
754 int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
755 {
756  FORMATS_REF(f, ref, ff_formats_unref);
757 }
758  
759 #define FIND_REF_INDEX(ref, idx) \
760 do { \
761  int i; \
762  for (i = 0; i < (*ref)->refcount; i ++) \
763  if((*ref)->refs[i] == ref) { \
764  idx = i; \
765  break; \
766  } \
767 } while (0)
768  
769 #define FORMATS_UNREF(ref, list) \
770 do { \
771  int idx = -1; \
772  \
773  if (!*ref) \
774  return; \
775  \
776  FIND_REF_INDEX(ref, idx); \
777  \
778  if (idx >= 0) { \
779  memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
780  sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
781  --(*ref)->refcount; \
782  } \
783  if (!(*ref)->refcount) { \
784  FREE_LIST(ref, list); \
785  av_free((*ref)->list); \
786  av_free((*ref)->refs); \
787  av_free(*ref); \
788  } \
789  *ref = NULL; \
790 } while (0)
791 
792  #define FREE_LIST(ref, list) do { } while(0)
793 void ff_formats_unref(AVFilterFormats **ref)
794 {
795  FORMATS_UNREF(ref, formats);
796 }
797 
798  #undef FREE_LIST
799 #define FREE_LIST(ref, list) \
800  do { \
801  for (int i = 0; i < (*ref)->nb_channel_layouts; i++) \
802  av_channel_layout_uninit(&(*ref)->list[i]); \
803  } while(0)
804  
805 void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
806 {
807  FORMATS_UNREF(ref, channel_layouts);
808 }
809  
810 #define FORMATS_CHANGEREF(oldref, newref) \
811 do { \
812  int idx = -1; \
813  \
814  FIND_REF_INDEX(oldref, idx); \
815  \
816  if (idx >= 0) { \
817  (*oldref)->refs[idx] = newref; \
818  *newref = *oldref; \
819  *oldref = NULL; \
820  } \
821 } while (0)
822  
823 void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
824  AVFilterChannelLayouts **newref)
825 {
826  FORMATS_CHANGEREF(oldref, newref);
827 }
828  
829 void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
830 {
831  FORMATS_CHANGEREF(oldref, newref);
832 }
833  
834 #define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn) \
835  int i; \
836  \
837  if (!fmts) \
838  return AVERROR(ENOMEM); \
839  \
840  for (i = 0; i < ctx->nb_inputs; i++) { \
841  AVFilterLink *const link = ctx->inputs[i]; \
842  if (link && !link->outcfg.fmts && \
843  (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
844  int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts); \
845  if (ret < 0) { \
846  return ret; \
847  } \
848  } \
849  } \
850  for (i = 0; i < ctx->nb_outputs; i++) { \
851  AVFilterLink *const link = ctx->outputs[i]; \
852  if (link && !link->incfg.fmts && \
853  (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
854  int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts); \
855  if (ret < 0) { \
856  return ret; \
857  } \
858  } \
859  } \
860  \
861  if (!fmts->refcount) \
862  unref_fn(&fmts); \
863  \
864  return 0;
865  
866 int ff_set_common_channel_layouts(AVFilterContext *ctx,
867  AVFilterChannelLayouts *channel_layouts)
868 {
869  SET_COMMON_FORMATS(ctx, channel_layouts, AVMEDIA_TYPE_AUDIO,
870  ff_channel_layouts_ref, ff_channel_layouts_unref);
871 }
872  
873 int ff_set_common_channel_layouts_from_list(AVFilterContext *ctx,
874  const AVChannelLayout *fmts)
875 {
876  return ff_set_common_channel_layouts(ctx, ff_make_channel_layout_list(fmts));
877 }
878  
879 int ff_set_common_all_channel_counts(AVFilterContext *ctx)
880 {
881  return ff_set_common_channel_layouts(ctx, ff_all_channel_counts());
882 }
883  
884 int ff_set_common_samplerates(AVFilterContext *ctx,
885  AVFilterFormats *samplerates)
886 {
887  SET_COMMON_FORMATS(ctx, samplerates, AVMEDIA_TYPE_AUDIO,
888  ff_formats_ref, ff_formats_unref);
889 }
890  
891 int ff_set_common_samplerates_from_list(AVFilterContext *ctx,
892  const int *samplerates)
893 {
894  return ff_set_common_samplerates(ctx, ff_make_format_list(samplerates));
895 }
896  
897 int ff_set_common_all_samplerates(AVFilterContext *ctx)
898 {
899  return ff_set_common_samplerates(ctx, ff_all_samplerates());
900 }
901  
902 int ff_set_common_color_spaces(AVFilterContext *ctx,
903  AVFilterFormats *color_spaces)
904 {
905  SET_COMMON_FORMATS(ctx, color_spaces, AVMEDIA_TYPE_VIDEO,
906  ff_formats_ref, ff_formats_unref);
907 }
908  
909 int ff_set_common_color_spaces_from_list(AVFilterContext *ctx,
910  const int *color_spaces)
911 {
912  return ff_set_common_color_spaces(ctx, ff_make_format_list(color_spaces));
913 }
914  
915 int ff_set_common_all_color_spaces(AVFilterContext *ctx)
916 {
917  return ff_set_common_color_spaces(ctx, ff_all_color_spaces());
918 }
919  
920 int ff_set_common_color_ranges(AVFilterContext *ctx,
921  AVFilterFormats *color_ranges)
922 {
923  SET_COMMON_FORMATS(ctx, color_ranges, AVMEDIA_TYPE_VIDEO,
924  ff_formats_ref, ff_formats_unref);
925 }
926  
927 int ff_set_common_color_ranges_from_list(AVFilterContext *ctx,
928  const int *color_ranges)
929 {
930  return ff_set_common_color_ranges(ctx, ff_make_format_list(color_ranges));
931 }
932  
933 int ff_set_common_all_color_ranges(AVFilterContext *ctx)
934 {
935  return ff_set_common_color_ranges(ctx, ff_all_color_ranges());
936 }
937  
938 int ff_set_common_alpha_modes(AVFilterContext *ctx,
939  AVFilterFormats *alpha_modes)
940 {
941  SET_COMMON_FORMATS(ctx, alpha_modes, AVMEDIA_TYPE_VIDEO,
942  ff_formats_ref, ff_formats_unref);
943 }
944  
945 int ff_set_common_alpha_modes_from_list(AVFilterContext *ctx,
946  const int *alpha_modes)
947 {
948  return ff_set_common_alpha_modes(ctx, ff_make_format_list(alpha_modes));
949 }
950  
951 int ff_set_common_all_alpha_modes(AVFilterContext *ctx)
952 {
953  return ff_set_common_alpha_modes(ctx, ff_all_alpha_modes());
954 }
955 
956 /**
957  * A helper for query_formats() which sets all links to the same list of
958  * formats. If there are no links hooked to this filter, the list of formats is
959  * freed.
960   */
961 int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
962 {
963  SET_COMMON_FORMATS(ctx, formats, AVMEDIA_TYPE_UNKNOWN,
964  ff_formats_ref, ff_formats_unref);
965 }
966  
967 int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
968 {
969  return ff_set_common_formats(ctx, ff_make_format_list(fmts));
970 }
971  
972 #define SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, fmts, media_type, \
973  ref_fn, unref_fn) \
974  if (!fmts) \
975  return AVERROR(ENOMEM); \
976  \
977  for (unsigned i = 0; i < ctx->nb_inputs; i++) { \
978  const AVFilterLink *const link = ctx->inputs[i]; \
979  if (!cfg_in[i]->fmts && \
980  (media_type == AVMEDIA_TYPE_UNKNOWN || \
981  link->type == media_type)) { \
982  int ret = ref_fn(fmts, &cfg_in[i]->fmts); \
983  if (ret < 0) { \
984  return ret; \
985  } \
986  } \
987  } \
988  for (unsigned i = 0; i < ctx->nb_outputs; i++) { \
989  const AVFilterLink *const link = ctx->outputs[i]; \
990  if (!cfg_out[i]->fmts && \
991  (media_type == AVMEDIA_TYPE_UNKNOWN || \
992  link->type == media_type)) { \
993  int ret = ref_fn(fmts, &cfg_out[i]->fmts); \
994  if (ret < 0) { \
995  return ret; \
996  } \
997  } \
998  } \
999  \
1000  if (!fmts->refcount) \
1001  unref_fn(&fmts); \
1002  \
1003  return 0;
1004  
1005 int ff_set_common_channel_layouts2(const AVFilterContext *ctx,
1006  AVFilterFormatsConfig **cfg_in,
1007  AVFilterFormatsConfig **cfg_out,
1008  AVFilterChannelLayouts *channel_layouts)
1009 {
1010  SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, channel_layouts, AVMEDIA_TYPE_AUDIO,
1011  ff_channel_layouts_ref, ff_channel_layouts_unref);
1012 }
1013  
1014 int ff_set_common_channel_layouts_from_list2(const AVFilterContext *ctx,
1015  AVFilterFormatsConfig **cfg_in,
1016  AVFilterFormatsConfig **cfg_out,
1017  const AVChannelLayout *fmts)
1018 {
1019  return ff_set_common_channel_layouts2(ctx, cfg_in, cfg_out, ff_make_channel_layout_list(fmts));
1020 }
1021  
1022 int ff_set_common_all_channel_counts2(const AVFilterContext *ctx,
1023  AVFilterFormatsConfig **cfg_in,
1024  AVFilterFormatsConfig **cfg_out)
1025 {
1026  return ff_set_common_channel_layouts2(ctx, cfg_in, cfg_out, ff_all_channel_counts());
1027 }
1028  
1029 int ff_set_common_samplerates2(const AVFilterContext *ctx,
1030  AVFilterFormatsConfig **cfg_in,
1031  AVFilterFormatsConfig **cfg_out,
1032  AVFilterFormats *samplerates)
1033 {
1034  SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, samplerates, AVMEDIA_TYPE_AUDIO,
1035  ff_formats_ref, ff_formats_unref);
1036 }
1037  
1038 int ff_set_common_samplerates_from_list2(const AVFilterContext *ctx,
1039  AVFilterFormatsConfig **cfg_in,
1040  AVFilterFormatsConfig **cfg_out,
1041  const int *samplerates)
1042 {
1043  return ff_set_common_samplerates2(ctx, cfg_in, cfg_out, ff_make_format_list(samplerates));
1044 }
1045  
1046 int ff_set_common_all_samplerates2(const AVFilterContext *ctx,
1047  AVFilterFormatsConfig **cfg_in,
1048  AVFilterFormatsConfig **cfg_out)
1049 {
1050  return ff_set_common_samplerates2(ctx, cfg_in, cfg_out, ff_all_samplerates());
1051 }
1052  
1053 int ff_set_common_color_spaces2(const AVFilterContext *ctx,
1054  AVFilterFormatsConfig **cfg_in,
1055  AVFilterFormatsConfig **cfg_out,
1056  AVFilterFormats *color_spaces)
1057 {
1058  SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, color_spaces, AVMEDIA_TYPE_VIDEO,
1059  ff_formats_ref, ff_formats_unref);
1060 }
1061  
1062 int ff_set_common_color_spaces_from_list2(const AVFilterContext *ctx,
1063  AVFilterFormatsConfig **cfg_in,
1064  AVFilterFormatsConfig **cfg_out,
1065  const int *color_spaces)
1066 {
1067  return ff_set_common_color_spaces2(ctx, cfg_in, cfg_out, ff_make_format_list(color_spaces));
1068 }
1069  
1070 int ff_set_common_all_color_spaces2(const AVFilterContext *ctx,
1071  AVFilterFormatsConfig **cfg_in,
1072  AVFilterFormatsConfig **cfg_out)
1073 {
1074  return ff_set_common_color_spaces2(ctx, cfg_in, cfg_out, ff_all_color_spaces());
1075 }
1076  
1077 int ff_set_common_color_ranges2(const AVFilterContext *ctx,
1078  AVFilterFormatsConfig **cfg_in,
1079  AVFilterFormatsConfig **cfg_out,
1080  AVFilterFormats *color_ranges)
1081 {
1082  SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, color_ranges, AVMEDIA_TYPE_VIDEO,
1083  ff_formats_ref, ff_formats_unref);
1084 }
1085  
1086 int ff_set_common_color_ranges_from_list2(const AVFilterContext *ctx,
1087  AVFilterFormatsConfig **cfg_in,
1088  AVFilterFormatsConfig **cfg_out,
1089  const int *color_ranges)
1090 {
1091  return ff_set_common_color_ranges2(ctx, cfg_in, cfg_out, ff_make_format_list(color_ranges));
1092 }
1093  
1094 int ff_set_common_all_color_ranges2(const AVFilterContext *ctx,
1095  AVFilterFormatsConfig **cfg_in,
1096  AVFilterFormatsConfig **cfg_out)
1097 {
1098  return ff_set_common_color_ranges2(ctx, cfg_in, cfg_out, ff_all_color_ranges());
1099 }
1100  
1101 int ff_set_common_alpha_modes2(const AVFilterContext *ctx,
1102  AVFilterFormatsConfig **cfg_in,
1103  AVFilterFormatsConfig **cfg_out,
1104  AVFilterFormats *alpha_modes)
1105 {
1106  SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, alpha_modes, AVMEDIA_TYPE_VIDEO,
1107  ff_formats_ref, ff_formats_unref);
1108 }
1109  
1110 int ff_set_common_alpha_modes_from_list2(const AVFilterContext *ctx,
1111  AVFilterFormatsConfig **cfg_in,
1112  AVFilterFormatsConfig **cfg_out,
1113  const int *alpha_modes)
1114 {
1115  return ff_set_common_alpha_modes2(ctx, cfg_in, cfg_out, ff_make_format_list(alpha_modes));
1116 }
1117  
1118 int ff_set_common_all_alpha_modes2(const AVFilterContext *ctx,
1119  AVFilterFormatsConfig **cfg_in,
1120  AVFilterFormatsConfig **cfg_out)
1121 {
1122  return ff_set_common_alpha_modes2(ctx, cfg_in, cfg_out, ff_all_alpha_modes());
1123 }
1124  
1125 int ff_set_common_formats2(const AVFilterContext *ctx,
1126  AVFilterFormatsConfig **cfg_in,
1127  AVFilterFormatsConfig **cfg_out,
1128  AVFilterFormats *formats)
1129 {
1130  SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, formats, AVMEDIA_TYPE_UNKNOWN,
1131  ff_formats_ref, ff_formats_unref);
1132 }
1133  
1134 int ff_set_common_formats_from_list2(const AVFilterContext *ctx,
1135  AVFilterFormatsConfig **cfg_in,
1136  AVFilterFormatsConfig **cfg_out,
1137  const int *fmts)
1138 {
1139  return ff_set_common_formats2(ctx, cfg_in, cfg_out, ff_make_format_list(fmts));
1140 }
1141 
1142  
1143 int ff_default_query_formats(AVFilterContext *ctx)
1144 {
1145  const FFFilter *const f = fffilter(ctx->filter);
1146  AVFilterFormats *formats;
1147  enum AVMediaType type;
1148  int ret;
1149 
1150  switch (f->formats_state) {
1151  case FF_FILTER_FORMATS_PIXFMT_LIST:
1152  type = AVMEDIA_TYPE_VIDEO;
1153  formats = ff_make_format_list(f->formats.pixels_list);
1154  break;
1155  case FF_FILTER_FORMATS_SAMPLEFMTS_LIST:
1156  type = AVMEDIA_TYPE_AUDIO;
1157  formats = ff_make_format_list(f->formats.samples_list);
1158  break;
1159  case FF_FILTER_FORMATS_SINGLE_PIXFMT:
1160  type = AVMEDIA_TYPE_VIDEO;
1161  formats = ff_make_formats_list_singleton(f->formats.pix_fmt);
1162  break;
1163  case FF_FILTER_FORMATS_SINGLE_SAMPLEFMT:
1164  type = AVMEDIA_TYPE_AUDIO;
1165  formats = ff_make_formats_list_singleton(f->formats.sample_fmt);
1166  break;
1167  default:
1168  av_assert2(!"Unreachable");
1169  /* Intended fallthrough */
1170  case FF_FILTER_FORMATS_PASSTHROUGH:
1171  case FF_FILTER_FORMATS_QUERY_FUNC:
1172  case FF_FILTER_FORMATS_QUERY_FUNC2:
1173  type = AVMEDIA_TYPE_UNKNOWN;
1174  formats = ff_all_formats(ctx->nb_inputs ? ctx->inputs [0]->type :
1175  ctx->nb_outputs ? ctx->outputs[0]->type :
1176  AVMEDIA_TYPE_VIDEO);
1177  break;
1178  }
1179 
1180  ret = ff_set_common_formats(ctx, formats);
1181  if (ret < 0)
1182  return ret;
1183  if (type != AVMEDIA_TYPE_AUDIO) {
1184  ret = ff_set_common_all_color_spaces(ctx);
1185  if (ret < 0)
1186  return ret;
1187  ret = ff_set_common_all_color_ranges(ctx);
1188  if (ret < 0)
1189  return ret;
1190  ret = ff_set_common_all_alpha_modes(ctx);
1191  if (ret < 0)
1192  return ret;
1193  }
1194  if (type != AVMEDIA_TYPE_VIDEO) {
1195  ret = ff_set_common_all_channel_counts(ctx);
1196  if (ret < 0)
1197  return ret;
1198  ret = ff_set_common_all_samplerates(ctx);
1199  if (ret < 0)
1200  return ret;
1201  }
1202 
1203  return 0;
1204 }
1205  
1206 static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
1207 {
1208  unsigned i, j;
1209 
1210  if (!fmts)
1211  return 0;
1212  if (!fmts->nb_formats) {
1213  av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
1214  return AVERROR(EINVAL);
1215  }
1216  for (i = 0; i < fmts->nb_formats; i++) {
1217  for (j = i + 1; j < fmts->nb_formats; j++) {
1218  if (fmts->formats[i] == fmts->formats[j]) {
1219  av_log(log, AV_LOG_ERROR, "Duplicated %s\n", name);
1220  return AVERROR(EINVAL);
1221  }
1222  }
1223  }
1224  return 0;
1225 }
1226  
1227 int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
1228 {
1229  return check_list(log, "pixel format", fmts);
1230 }
1231  
1232 int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
1233 {
1234  return check_list(log, "sample format", fmts);
1235 }
1236  
1237 int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
1238 {
1239  if (!fmts || !fmts->nb_formats)
1240  return 0;
1241  return check_list(log, "sample rate", fmts);
1242 }
1243  
1244 int ff_formats_check_color_spaces(void *log, const AVFilterFormats *fmts)
1245 {
1246  for (int i = 0; fmts && i < fmts->nb_formats; i++) {
1247  if (fmts->formats[i] == AVCOL_SPC_RESERVED) {
1248  av_log(log, AV_LOG_ERROR, "Invalid color space\n");
1249  return AVERROR(EINVAL);
1250  }
1251  }
1252  return check_list(log, "color space", fmts);
1253 }
1254  
1255 int ff_formats_check_color_ranges(void *log, const AVFilterFormats *fmts)
1256 {
1257  return check_list(log, "color range", fmts);
1258 }
1259  
1260 int ff_formats_check_alpha_modes(void *log, const AVFilterFormats *fmts)
1261 {
1262  return check_list(log, "alpha mode", fmts);
1263 }
1264  
1265 static int layouts_compatible(const AVChannelLayout *a, const AVChannelLayout *b)
1266 {
1267  return !av_channel_layout_compare(a, b) ||
1268  (KNOWN(a) && !KNOWN(b) && a->nb_channels == b->nb_channels) ||
1269  (KNOWN(b) && !KNOWN(a) && b->nb_channels == a->nb_channels);
1270 }
1271  
1272 int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
1273 {
1274  unsigned i, j;
1275 
1276  if (!fmts)
1277  return 0;
1278  if (fmts->all_layouts < fmts->all_counts) {
1279  av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
1280  return AVERROR(EINVAL);
1281  }
1282  if (!fmts->all_layouts && !fmts->nb_channel_layouts) {
1283  av_log(log, AV_LOG_ERROR, "Empty channel layout list\n");
1284  return AVERROR(EINVAL);
1285  }
1286  for (i = 0; i < fmts->nb_channel_layouts; i++) {
1287  for (j = i + 1; j < fmts->nb_channel_layouts; j++) {
1288  if (layouts_compatible(&fmts->channel_layouts[i], &fmts->channel_layouts[j])) {
1289  av_log(log, AV_LOG_ERROR, "Duplicated or redundant channel layout\n");
1290  return AVERROR(EINVAL);
1291  }
1292  }
1293  }
1294  return 0;
1295 }
can_merge_generic
static int can_merge_generic(const void *a, const void *b)
Definition: formats.c:337
flags
const SwsFlags flags[]
Definition: swscale.c:61
merge_generic_internal
static int merge_generic_internal(AVFilterFormats *a, AVFilterFormats *b, int check)
Definition: formats.c:324
formats
formats
Definition: signature.h:47
ff_set_common_all_alpha_modes2
int ff_set_common_all_alpha_modes2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: formats.c:1117
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AVFilterFormatsConfig::samplerates
AVFilterFormats * samplerates
Lists of supported sample rates, only for audio.
Definition: avfilter.h:131
name
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 just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
CONVERSION_FILTER_SWSCALE
#define CONVERSION_FILTER_SWSCALE
Definition: formats.c:381
AVERROR
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
FF_FILTER_FORMATS_QUERY_FUNC
@ FF_FILTER_FORMATS_QUERY_FUNC
formats.query active.
Definition: filters.h:229
can_merge_sample_fmts
static int can_merge_sample_fmts(const void *a, const void *b)
See can_merge_pix_fmts().
Definition: formats.c:169
merge_formats_internal
static int merge_formats_internal(AVFilterFormats *a, AVFilterFormats *b, enum AVMediaType type, int check)
Definition: formats.c:94
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:499
ff_set_common_channel_layouts2
int ff_set_common_channel_layouts2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterChannelLayouts *channel_layouts)
Helpers for query_formats2() which set all free audio links to the same list of channel layouts/sampl...
Definition: formats.c:1004
can_merge_pix_fmts
static int can_merge_pix_fmts(const void *a, const void *b)
Check the formats lists for compatibility for merging without actually merging.
Definition: formats.c:143
ff_set_common_color_ranges2
int ff_set_common_color_ranges2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *color_ranges)
Definition: formats.c:1076
ff_set_common_alpha_modes
int ff_set_common_alpha_modes(AVFilterContext *ctx, AVFilterFormats *alpha_modes)
Definition: formats.c:937
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:748
layouts
enum MovChannelLayoutTag * layouts
Definition: mov_chan.c:335
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
ff_set_common_all_channel_counts2
int ff_set_common_all_channel_counts2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: formats.c:1021
ff_formats_check_pixel_formats
int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid pixel formats list.
Definition: formats.c:1226
ff_set_common_formats2
int ff_set_common_formats2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *formats)
Definition: formats.c:1124
int64_t
long long int64_t
Definition: coverity.c:34
ff_set_common_samplerates_from_list
int ff_set_common_samplerates_from_list(AVFilterContext *ctx, const int *samplerates)
Equivalent to ff_set_common_samplerates(ctx, ff_make_format_list(samplerates))
Definition: formats.c:890
PRINT_NAME
#define PRINT_NAME(type, type_name)
Definition: formats.c:348
merge_generic
static int merge_generic(void *a, void *b)
Definition: formats.c:343
normalize.log
log
Definition: normalize.py:21
ff_all_channel_counts
AVFilterChannelLayouts * ff_all_channel_counts(void)
Construct an AVFilterChannelLayouts coding for any channel layout, with known or unknown disposition.
Definition: formats.c:685
can_merge_channel_layouts
static int can_merge_channel_layouts(const void *a, const void *b)
Definition: formats.c:313
ff_set_common_all_color_spaces
int ff_set_common_all_color_spaces(AVFilterContext *ctx)
Equivalent to ff_set_common_color_spaces(ctx, ff_all_color_spaces())
Definition: formats.c:914
pixdesc.h
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:720
b
#define b
Definition: input.c:42
mergers_video
static const AVFilterFormatsMerger mergers_video[]
Definition: formats.c:389
MERGE_FORMATS
#define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed)
Add all formats common to a and b to a, add b's refs to a and destroy b.
Definition: formats.c:62
ff_set_common_channel_layouts_from_list2
int ff_set_common_channel_layouts_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const AVChannelLayout *fmts)
Definition: formats.c:1013
FF_FILTER_FORMATS_SINGLE_PIXFMT
@ FF_FILTER_FORMATS_SINGLE_PIXFMT
formats.pix_fmt active
Definition: filters.h:233
ff_set_common_all_samplerates
int ff_set_common_all_samplerates(AVFilterContext *ctx)
Equivalent to ff_set_common_samplerates(ctx, ff_all_samplerates())
Definition: formats.c:896
AVFilterFormats::formats
int * formats
list of media formats
Definition: formats.h:66
merge_samplerates_internal
static int merge_samplerates_internal(AVFilterFormats *a, AVFilterFormats *b, int check)
Definition: formats.c:183
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
ff_make_formats_list_singleton
AVFilterFormats * ff_make_formats_list_singleton(int fmt)
Equivalent to ff_make_format_list({const int[]}{ fmt, -1 })
Definition: formats.c:593
ff_set_common_color_ranges_from_list2
int ff_set_common_color_ranges_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *color_ranges)
Definition: formats.c:1085
FORMATS_UNREF
#define FORMATS_UNREF(ref, list)
Definition: formats.c:768
av_channel_layout_describe_bprint
int av_channel_layout_describe_bprint(const AVChannelLayout *channel_layout, AVBPrint *bp)
bprint variant of av_channel_layout_describe().
Definition: channel_layout.c:599
CONVERSION_FILTER_ARESAMPLE
#define CONVERSION_FILTER_ARESAMPLE
Definition: formats.c:385
fffilter
static const FFFilter * fffilter(const AVFilter *f)
Definition: filters.h:463
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
layouts_compatible
static int layouts_compatible(const AVChannelLayout *a, const AVChannelLayout *b)
Definition: formats.c:1264
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:704
SET_COMMON_FORMATS
#define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn)
Definition: formats.c:833
fail
#define fail()
Definition: checkasm.h:207
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
AVCOL_RANGE_NB
@ AVCOL_RANGE_NB
Not part of ABI.
Definition: pixfmt.h:778
type
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 just let it vf type
Definition: writing_filters.txt:86
ff_set_common_color_spaces_from_list
int ff_set_common_color_spaces_from_list(AVFilterContext *ctx, const int *color_spaces)
Equivalent to ff_set_common_color_spaces(ctx, ff_make_format_list(color_spaces))
Definition: formats.c:908
AVFilterNegotiation
Callbacks and properties to describe the steps of a format negotiation.
Definition: formats.h:613
ff_all_formats
AVFilterFormats * ff_all_formats(enum AVMediaType type)
Return a list of all formats supported by FFmpeg for the given media type.
Definition: formats.c:599
AVFilterNegotiation::nb_mergers
unsigned nb_mergers
Definition: formats.h:614
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
ff_set_common_formats
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:960
ff_set_common_color_spaces2
int ff_set_common_color_spaces2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *color_spaces)
Definition: formats.c:1052
FFFilter
Definition: filters.h:266
check
#define check(x, y, S, v)
Definition: motion_est_template.c:405
SET_COMMON_FORMATS2
#define SET_COMMON_FORMATS2(ctx, cfg_in, cfg_out, fmts, media_type, ref_fn, unref_fn)
Definition: formats.c:971
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:753
ff_set_common_formats_from_list
int ff_set_common_formats_from_list(AVFilterContext *ctx, const int *fmts)
Equivalent to ff_set_common_formats(ctx, ff_make_format_list(fmts))
Definition: formats.c:966
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
av_sample_fmt_is_planar
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:114
filters.h
ff_set_common_alpha_modes2
int ff_set_common_alpha_modes2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *alpha_modes)
Definition: formats.c:1100
ff_set_common_samplerates_from_list2
int ff_set_common_samplerates_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *samplerates)
Definition: formats.c:1037
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AVFilterFormatsConfig::color_spaces
AVFilterFormats * color_spaces
Lists of supported YUV color metadata, only for YUV video.
Definition: avfilter.h:141
ff_set_common_channel_layouts_from_list
int ff_set_common_channel_layouts_from_list(AVFilterContext *ctx, const AVChannelLayout *fmts)
Equivalent to ff_set_common_channel_layouts(ctx, ff_make_channel_layout_list(fmts))
Definition: formats.c:872
ff_set_common_samplerates2
int ff_set_common_samplerates2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, AVFilterFormats *samplerates)
Definition: formats.c:1028
av_get_sample_fmt_name
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:51
link
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
Definition: filter_design.txt:23
ff_formats_changeref
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Definition: formats.c:828
ff_set_common_color_spaces_from_list2
int ff_set_common_color_spaces_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *color_spaces)
Definition: formats.c:1061
NULL
#define NULL
Definition: coverity.c:32
MAKE_FORMAT_LIST
#define MAKE_FORMAT_LIST(type, field, count_field)
Definition: formats.c:481
merge_pix_fmts
static int merge_pix_fmts(void *a, void *b)
Merge the formats lists if they are compatible and update all the references of a and b to point to t...
Definition: formats.c:161
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
ff_formats_check_alpha_modes
int ff_formats_check_alpha_modes(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid formats list for alpha modes.
Definition: formats.c:1259
print_sample_rate
static void print_sample_rate(AVBPrint *bp, const void *ratesp)
Definition: formats.c:374
ff_add_format
int ff_add_format(AVFilterFormats **avff, int64_t fmt)
Add fmt to the list of media formats contained in *avff.
Definition: formats.c:568
AVFilterFormats::nb_formats
unsigned nb_formats
number of formats
Definition: formats.h:65
ff_fmt_is_in
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:470
negotiate_audio
static const AVFilterNegotiation negotiate_audio
Definition: formats.c:456
ff_filter_get_negotiation
const AVFilterNegotiation * ff_filter_get_negotiation(const AVFilterLink *link)
Definition: formats.c:461
merge_samplerates
static int merge_samplerates(void *a, void *b)
See merge_pix_fmts().
Definition: formats.c:204
ff_set_common_all_channel_counts
int ff_set_common_all_channel_counts(AVFilterContext *ctx)
Equivalent to ff_set_common_channel_layouts(ctx, ff_all_channel_counts())
Definition: formats.c:878
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition: formats.c:585
ff_all_color_spaces
AVFilterFormats * ff_all_color_spaces(void)
Construct an AVFilterFormats representing all possible color spaces.
Definition: formats.c:694
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
ff_channel_layouts_unref
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:804
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:121
FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
@ FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
formats.sample_fmt active.
Definition: filters.h:234
ff_formats_check_sample_formats
int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid sample formats list.
Definition: formats.c:1231
AVAlphaMode
AVAlphaMode
Correlation between the alpha channel and color values.
Definition: pixfmt.h:810
MERGE_REF
#define MERGE_REF(ret, a, fmts, type, fail_statement)
Add all refs from a to ret and destroy a.
Definition: formats.c:35
f
f
Definition: af_crystalizer.c:122
ff_formats_check_color_spaces
int ff_formats_check_color_spaces(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid formats list for YUV colorspace metadata.
Definition: formats.c:1243
AVMediaType
AVMediaType
Definition: avutil.h:198
FF_PIX_FMT_FLAG_SW_FLAT_SUB
#define FF_PIX_FMT_FLAG_SW_FLAT_SUB
Definition: formats.h:419
ff_default_query_formats
int ff_default_query_formats(AVFilterContext *ctx)
Sets all remaining unset filter lists for all inputs/outputs to their corresponding ff_all_*() lists.
Definition: formats.c:1142
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
merge_channel_layouts_internal
static int merge_channel_layouts_internal(AVFilterChannelLayouts *a, AVFilterChannelLayouts *b, int check)
See merge_pix_fmts().
Definition: formats.c:212
check_list
static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
Definition: formats.c:1205
ff_set_common_color_ranges_from_list
int ff_set_common_color_ranges_from_list(AVFilterContext *ctx, const int *color_ranges)
Equivalent to ff_set_common_color_ranges(ctx, ff_make_format_list(color_ranges))
Definition: formats.c:926
AVFilterChannelLayouts::channel_layouts
AVChannelLayout * channel_layouts
list of channel layouts
Definition: formats.h:86
AVFilterChannelLayouts::all_layouts
char all_layouts
accept any known channel layout
Definition: formats.h:88
AVFilterChannelLayouts::all_counts
char all_counts
accept any channel layout or count
Definition: formats.h:89
AVALPHA_MODE_NB
@ AVALPHA_MODE_NB
Not part of ABI.
Definition: pixfmt.h:814
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:199
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2594
ff_formats_check_channel_layouts
int ff_formats_check_channel_layouts(void *log, const AVFilterChannelLayouts *fmts)
Check that fmts is a valid channel layouts list.
Definition: formats.c:1271
a
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:41
ff_all_color_ranges
AVFilterFormats * ff_all_color_ranges(void)
Construct an AVFilterFormats representing all possible color ranges.
Definition: formats.c:710
AVFilterFormatsConfig::color_ranges
AVFilterFormats * color_ranges
AVColorRange.
Definition: avfilter.h:142
ff_all_channel_layouts
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:676
ADD_FORMAT
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb)
Definition: formats.c:544
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:809
ff_formats_unref
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:792
ff_set_common_color_ranges
int ff_set_common_color_ranges(AVFilterContext *ctx, AVFilterFormats *color_ranges)
Definition: formats.c:919
ff_set_common_alpha_modes_from_list2
int ff_set_common_alpha_modes_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *alpha_modes)
Definition: formats.c:1109
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
FF_FILTER_FORMATS_PASSTHROUGH
@ FF_FILTER_FORMATS_PASSTHROUGH
The default value meaning that this filter supports all formats and (for audio) sample rates and chan...
Definition: filters.h:228
ff_formats_pixdesc_filter
AVFilterFormats * ff_formats_pixdesc_filter(unsigned want, unsigned rej)
Construct a formats list containing all pixel formats with certain properties.
Definition: formats.c:617
bprint.h
FORMATS_REF
#define FORMATS_REF(f, ref, unref_fn)
Definition: formats.c:732
ff_formats_check_sample_rates
int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
Check that fmts is a valid sample rates list.
Definition: formats.c:1236
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
round
static av_always_inline av_const double round(double x)
Definition: libm.h:446
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
AVColorSpace
AVColorSpace
YUV colorspace type.
Definition: pixfmt.h:700
common.h
FORMATS_CHANGEREF
#define FORMATS_CHANGEREF(oldref, newref)
Definition: formats.c:809
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
ff_set_common_all_alpha_modes
int ff_set_common_all_alpha_modes(AVFilterContext *ctx)
Equivalent to ff_set_common_alpha_modes(ctx, ff_all_alpha_modes())
Definition: formats.c:950
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
ff_set_common_all_color_ranges
int ff_set_common_all_color_ranges(AVFilterContext *ctx)
Equivalent to ff_set_common_color_ranges(ctx, ff_all_color_ranges())
Definition: formats.c:932
ch_layouts
static const AVChannelLayout ch_layouts[]
Definition: adpcmenc.c:956
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
ff_planar_sample_fmts
AVFilterFormats * ff_planar_sample_fmts(void)
Construct a formats list containing all planar sample formats.
Definition: formats.c:657
mergers_audio
static const AVFilterFormatsMerger mergers_audio[]
Definition: formats.c:424
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:703
merge_channel_layouts
static int merge_channel_layouts(void *a, void *b)
Definition: formats.c:319
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
ff_formats_check_color_ranges
int ff_formats_check_color_ranges(void *log, const AVFilterFormats *fmts)
Definition: formats.c:1254
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
ff_set_common_color_spaces
int ff_set_common_color_spaces(AVFilterContext *ctx, AVFilterFormats *color_spaces)
Definition: formats.c:901
av_channel_layout_check
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
Definition: channel_layout.c:783
FF_COUNT2LAYOUT
#define FF_COUNT2LAYOUT(c)
Encode a channel count as a channel layout.
Definition: formats.h:102
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:122
ff_set_common_all_color_ranges2
int ff_set_common_all_color_ranges2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: formats.c:1093
FF_FILTER_FORMATS_QUERY_FUNC2
@ FF_FILTER_FORMATS_QUERY_FUNC2
formats.query_func2 active.
Definition: filters.h:230
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:670
ff_set_common_formats_from_list2
int ff_set_common_formats_from_list2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out, const int *fmts)
Definition: formats.c:1133
channel_layout.h
ff_set_common_alpha_modes_from_list
int ff_set_common_alpha_modes_from_list(AVFilterContext *ctx, const int *alpha_modes)
Equivalent to ff_set_common_alpha_modes(ctx, ff_make_format_list(alpha_modes))
Definition: formats.c:944
rates
static const int rates[]
Definition: swresample.c:103
avfilter.h
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:442
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
KNOWN
#define KNOWN(l)
Definition: formats.h:111
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
can_merge_samplerates
static int can_merge_samplerates(const void *a, const void *b)
See can_merge_pix_fmts().
Definition: formats.c:196
ff_all_alpha_modes
AVFilterFormats * ff_all_alpha_modes(void)
Construct an AVFilterFormats representing all possible alpha modes.
Definition: formats.c:721
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
AVFilterContext
An instance of a filter.
Definition: avfilter.h:274
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:449
desc
const char * desc
Definition: libsvtav1.c:78
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AVFilterChannelLayouts::nb_channel_layouts
int nb_channel_layouts
number of channel layouts
Definition: formats.h:87
mem.h
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
ff_set_common_all_samplerates2
int ff_set_common_all_samplerates2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: formats.c:1045
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:112
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
negotiate_video
static const AVFilterNegotiation negotiate_video
Definition: formats.c:451
ff_make_channel_layout_list
AVFilterChannelLayouts * ff_make_channel_layout_list(const AVChannelLayout *fmts)
Definition: formats.c:508
FF_FILTER_FORMATS_SAMPLEFMTS_LIST
@ FF_FILTER_FORMATS_SAMPLEFMTS_LIST
formats.samples_list active.
Definition: filters.h:232
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_set_common_all_color_spaces2
int ff_set_common_all_color_spaces2(const AVFilterContext *ctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)
Definition: formats.c:1069
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:883
print_channel_layout_desc
static void print_channel_layout_desc(AVBPrint *bp, const void *layoutsp)
Definition: formats.c:365
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:130
ff_channel_layouts_changeref
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:822
merge_sample_fmts
static int merge_sample_fmts(void *a, void *b)
See merge_pix_fmts().
Definition: formats.c:178
AVColorRange
AVColorRange
Visual content value range.
Definition: pixfmt.h:742
AVFilterFormatsConfig::alpha_modes
AVFilterFormats * alpha_modes
List of supported alpha modes, only for video with an alpha channel.
Definition: avfilter.h:147
FF_FILTER_FORMATS_PIXFMT_LIST
@ FF_FILTER_FORMATS_PIXFMT_LIST
formats.pixels_list active.
Definition: filters.h:231
ff_set_common_channel_layouts
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *channel_layouts)
Helpers for query_formats() which set all free audio links to the same list of channel layouts/sample...
Definition: formats.c:865
Generated on Tue Nov 18 2025 19:23:05 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /