FFmpeg
formats.c
Go to the documentation of this file.
1 /*
2  * Filter layer - format negotiation
3  * Copyright (c) 2007 Bobby Bingham
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
24 #include "libavutil/common.h"
25 #include "libavutil/eval.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/pixdesc.h"
28 #include "avfilter.h"
29 #include "internal.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 
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 {
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 {
165 }
166 
167 /**
168  * See can_merge_pix_fmts().
169  */
170 static int can_merge_sample_fmts(const void *a, const void *b)
171 {
174 }
175 
176 /**
177  * See merge_pix_fmts().
178  */
179 static int merge_sample_fmts(void *a, void *b)
180 {
182 }
183 
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 {
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  */
215 {
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) {
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  }
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 */
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) {
300  return 0;
301  }
302 
303  if (a->refcount > b->refcount)
305 
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 {
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 
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 {
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 static const AVFilterFormatsMerger mergers_video[] = {
350  {
351  .offset = offsetof(AVFilterFormatsConfig, formats),
352  .merge = merge_pix_fmts,
353  .can_merge = can_merge_pix_fmts,
354  },
355  {
356  .offset = offsetof(AVFilterFormatsConfig, color_spaces),
357  .merge = merge_generic,
358  .can_merge = can_merge_generic,
359  },
360  {
361  .offset = offsetof(AVFilterFormatsConfig, color_ranges),
362  .merge = merge_generic,
363  .can_merge = can_merge_generic,
364  },
365 };
366 
367 static const AVFilterFormatsMerger mergers_audio[] = {
368  {
369  .offset = offsetof(AVFilterFormatsConfig, channel_layouts),
370  .merge = merge_channel_layouts,
371  .can_merge = can_merge_channel_layouts,
372  },
373  {
374  .offset = offsetof(AVFilterFormatsConfig, samplerates),
375  .merge = merge_samplerates,
376  .can_merge = can_merge_samplerates,
377  },
378  {
379  .offset = offsetof(AVFilterFormatsConfig, formats),
380  .merge = merge_sample_fmts,
381  .can_merge = can_merge_sample_fmts,
382  },
383 };
384 
385 static const AVFilterNegotiation negotiate_video = {
387  .mergers = mergers_video,
388  .conversion_filter = "scale",
389  .conversion_opts_offset = offsetof(AVFilterGraph, scale_sws_opts),
390 };
391 
392 static const AVFilterNegotiation negotiate_audio = {
394  .mergers = mergers_audio,
395  .conversion_filter = "aresample",
396  .conversion_opts_offset = offsetof(AVFilterGraph, aresample_swr_opts),
397 };
398 
400 {
401  switch (link->type) {
402  case AVMEDIA_TYPE_VIDEO: return &negotiate_video;
403  case AVMEDIA_TYPE_AUDIO: return &negotiate_audio;
404  default: return NULL;
405  }
406 }
407 
408 int ff_fmt_is_in(int fmt, const int *fmts)
409 {
410  const int *p;
411 
412  for (p = fmts; *p != -1; p++) {
413  if (fmt == *p)
414  return 1;
415  }
416  return 0;
417 }
418 
419 #define MAKE_FORMAT_LIST(type, field, count_field) \
420  type *formats; \
421  int count = 0; \
422  if (fmts) \
423  for (count = 0; fmts[count] != -1; count++) \
424  ; \
425  formats = av_mallocz(sizeof(*formats)); \
426  if (!formats) \
427  return NULL; \
428  formats->count_field = count; \
429  if (count) { \
430  formats->field = av_malloc_array(count, sizeof(*formats->field)); \
431  if (!formats->field) { \
432  av_freep(&formats); \
433  return NULL; \
434  } \
435  }
436 
437 AVFilterFormats *ff_make_format_list(const int *fmts)
438 {
440  while (count--)
441  formats->formats[count] = fmts[count];
442 
443  return formats;
444 }
445 
447 {
449  int count = 0;
450  if (fmts)
451  for (count = 0; fmts[count].nb_channels; count++)
452  ;
453  ch_layouts = av_mallocz(sizeof(*ch_layouts));
454  if (!ch_layouts)
455  return NULL;
456  ch_layouts->nb_channel_layouts = count;
457  if (count) {
458  ch_layouts->channel_layouts =
459  av_calloc(count, sizeof(*ch_layouts->channel_layouts));
460  if (!ch_layouts->channel_layouts) {
462  return NULL;
463  }
464  for (int i = 0; i < count; i++) {
465  int ret = av_channel_layout_copy(&ch_layouts->channel_layouts[i], &fmts[i]);
466  if (ret < 0)
467  goto fail;
468  }
469  }
470 
471  return ch_layouts;
472 
473 fail:
474  for (int i = 0; i < count; i++)
475  av_channel_layout_uninit(&ch_layouts->channel_layouts[i]);
476  av_free(ch_layouts->channel_layouts);
478 
479  return NULL;
480 }
481 
482 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
483 do { \
484  type *fmts; \
485  \
486  if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
487  return AVERROR(ENOMEM); \
488  } \
489  \
490  fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
491  sizeof(*(*f)->list)); \
492  if (!fmts) { \
493  unref_fn(f); \
494  return AVERROR(ENOMEM); \
495  } \
496  \
497  (*f)->list = fmts; \
498  ASSIGN_FMT(f, fmt, list, nb); \
499 } while (0)
500 
501 #define ASSIGN_FMT(f, fmt, list, nb) \
502 do { \
503  (*f)->list[(*f)->nb++] = fmt; \
504 } while (0)
505 
506 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
507 {
508  ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
509  return 0;
510 }
511 
512 #undef ASSIGN_FMT
513 #define ASSIGN_FMT(f, fmt, list, nb) \
514 do { \
515  int ret; \
516  memset((*f)->list + (*f)->nb, 0, sizeof(*(*f)->list)); \
517  ret = av_channel_layout_copy(&(*f)->list[(*f)->nb], fmt); \
518  if (ret < 0) \
519  return ret; \
520  (*f)->nb++; \
521 } while (0)
522 
524  const AVChannelLayout *channel_layout)
525 {
526  av_assert1(!(*l && (*l)->all_layouts));
527  ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, AVChannelLayout, channel_layouts, nb_channel_layouts);
528  return 0;
529 }
530 
532 {
533  int fmts[2] = { fmt, -1 };
534  return ff_make_format_list(fmts);
535 }
536 
538 {
540 
541  if (type == AVMEDIA_TYPE_VIDEO) {
542  return ff_formats_pixdesc_filter(0, 0);
543  } else if (type == AVMEDIA_TYPE_AUDIO) {
544  enum AVSampleFormat fmt = 0;
545  while (av_get_sample_fmt_name(fmt)) {
546  if (ff_add_format(&ret, fmt) < 0)
547  return NULL;
548  fmt++;
549  }
550  }
551 
552  return ret;
553 }
554 
555 AVFilterFormats *ff_formats_pixdesc_filter(unsigned want, unsigned rej)
556 {
557  unsigned nb_formats, fmt, flags;
559 
560  while (1) {
561  nb_formats = 0;
562  for (fmt = 0;; fmt++) {
564  if (!desc)
565  break;
566  flags = desc->flags;
567  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
568  !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
569  (desc->log2_chroma_w || desc->log2_chroma_h))
571  if ((flags & (want | rej)) != want)
572  continue;
573  if (formats)
574  formats->formats[nb_formats] = fmt;
575  nb_formats++;
576  }
577  if (formats) {
578  av_assert0(formats->nb_formats == nb_formats);
579  return formats;
580  }
581  formats = av_mallocz(sizeof(*formats));
582  if (!formats)
583  return NULL;
584  formats->nb_formats = nb_formats;
585  if (nb_formats) {
586  formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
587  if (!formats->formats) {
588  av_freep(&formats);
589  return NULL;
590  }
591  }
592  }
593 }
594 
596 {
598  int fmt;
599 
600  for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
601  if (av_sample_fmt_is_planar(fmt))
602  if (ff_add_format(&ret, fmt) < 0)
603  return NULL;
604 
605  return ret;
606 }
607 
609 {
610  AVFilterFormats *ret = av_mallocz(sizeof(*ret));
611  return ret;
612 }
613 
615 {
617  if (!ret)
618  return NULL;
619  ret->all_layouts = 1;
620  return ret;
621 }
622 
624 {
626  if (!ret)
627  return NULL;
628  ret->all_layouts = ret->all_counts = 1;
629  return ret;
630 }
631 
633 {
636  return NULL;
637  for (int csp = 0; csp < AVCOL_SPC_NB; csp++) {
638  if (csp == AVCOL_SPC_RESERVED ||
639  csp == AVCOL_SPC_UNSPECIFIED)
640  continue;
641  if (ff_add_format(&ret, csp) < 0)
642  return NULL;
643  }
644 
645  return ret;
646 }
647 
649 {
651  for (int range = 0; range < AVCOL_RANGE_NB; range++) {
652  if (ff_add_format(&ret, range) < 0)
653  return NULL;
654  }
655 
656  return ret;
657 }
658 
659 #define FORMATS_REF(f, ref, unref_fn) \
660  void *tmp; \
661  \
662  if (!f) \
663  return AVERROR(ENOMEM); \
664  \
665  tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1); \
666  if (!tmp) { \
667  unref_fn(&f); \
668  return AVERROR(ENOMEM); \
669  } \
670  f->refs = tmp; \
671  f->refs[f->refcount++] = ref; \
672  *ref = f; \
673  return 0
674 
676 {
678 }
679 
681 {
683 }
684 
685 #define FIND_REF_INDEX(ref, idx) \
686 do { \
687  int i; \
688  for (i = 0; i < (*ref)->refcount; i ++) \
689  if((*ref)->refs[i] == ref) { \
690  idx = i; \
691  break; \
692  } \
693 } while (0)
694 
695 #define FORMATS_UNREF(ref, list) \
696 do { \
697  int idx = -1; \
698  \
699  if (!*ref) \
700  return; \
701  \
702  FIND_REF_INDEX(ref, idx); \
703  \
704  if (idx >= 0) { \
705  memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
706  sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
707  --(*ref)->refcount; \
708  } \
709  if (!(*ref)->refcount) { \
710  FREE_LIST(ref, list); \
711  av_free((*ref)->list); \
712  av_free((*ref)->refs); \
713  av_free(*ref); \
714  } \
715  *ref = NULL; \
716 } while (0)
717 
718 #define FREE_LIST(ref, list) do { } while(0)
720 {
722 }
723 
724 #undef FREE_LIST
725 #define FREE_LIST(ref, list) \
726  do { \
727  for (int i = 0; i < (*ref)->nb_channel_layouts; i++) \
728  av_channel_layout_uninit(&(*ref)->list[i]); \
729  } while(0)
730 
732 {
734 }
735 
736 #define FORMATS_CHANGEREF(oldref, newref) \
737 do { \
738  int idx = -1; \
739  \
740  FIND_REF_INDEX(oldref, idx); \
741  \
742  if (idx >= 0) { \
743  (*oldref)->refs[idx] = newref; \
744  *newref = *oldref; \
745  *oldref = NULL; \
746  } \
747 } while (0)
748 
750  AVFilterChannelLayouts **newref)
751 {
752  FORMATS_CHANGEREF(oldref, newref);
753 }
754 
756 {
757  FORMATS_CHANGEREF(oldref, newref);
758 }
759 
760 #define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn) \
761  int i; \
762  \
763  if (!fmts) \
764  return AVERROR(ENOMEM); \
765  \
766  for (i = 0; i < ctx->nb_inputs; i++) { \
767  AVFilterLink *const link = ctx->inputs[i]; \
768  if (link && !link->outcfg.fmts && \
769  (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
770  int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts); \
771  if (ret < 0) { \
772  return ret; \
773  } \
774  } \
775  } \
776  for (i = 0; i < ctx->nb_outputs; i++) { \
777  AVFilterLink *const link = ctx->outputs[i]; \
778  if (link && !link->incfg.fmts && \
779  (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
780  int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts); \
781  if (ret < 0) { \
782  return ret; \
783  } \
784  } \
785  } \
786  \
787  if (!fmts->refcount) \
788  unref_fn(&fmts); \
789  \
790  return 0;
791 
794 {
797 }
798 
800  const AVChannelLayout *fmts)
801 {
803 }
804 
806 {
808 }
809 
811  AVFilterFormats *samplerates)
812 {
815 }
816 
818  const int *samplerates)
819 {
820  return ff_set_common_samplerates(ctx, ff_make_format_list(samplerates));
821 }
822 
824 {
826 }
827 
829  AVFilterFormats *color_spaces)
830 {
833 }
834 
836  const int *color_ranges)
837 {
838  return ff_set_common_color_spaces(ctx, ff_make_format_list(color_ranges));
839 }
840 
842 {
844 }
845 
847  AVFilterFormats *color_ranges)
848 {
851 }
852 
854  const int *color_ranges)
855 {
856  return ff_set_common_color_ranges(ctx, ff_make_format_list(color_ranges));
857 }
858 
860 {
862 }
863 
864 /**
865  * A helper for query_formats() which sets all links to the same list of
866  * formats. If there are no links hooked to this filter, the list of formats is
867  * freed.
868  */
870 {
873 }
874 
876 {
878 }
879 
881 {
882  const AVFilter *const f = ctx->filter;
884  enum AVMediaType type;
885  int ret;
886 
887  switch (f->formats_state) {
890  formats = ff_make_format_list(f->formats.pixels_list);
891  break;
894  formats = ff_make_format_list(f->formats.samples_list);
895  break;
898  formats = ff_make_formats_list_singleton(f->formats.pix_fmt);
899  break;
902  formats = ff_make_formats_list_singleton(f->formats.sample_fmt);
903  break;
904  default:
905  av_assert2(!"Unreachable");
906  /* Intended fallthrough */
910  formats = ff_all_formats(ctx->nb_inputs ? ctx->inputs [0]->type :
911  ctx->nb_outputs ? ctx->outputs[0]->type :
913  break;
914  }
915 
917  if (ret < 0)
918  return ret;
919  if (type != AVMEDIA_TYPE_AUDIO) {
921  if (ret < 0)
922  return ret;
924  if (ret < 0)
925  return ret;
926  }
927  if (type != AVMEDIA_TYPE_VIDEO) {
929  if (ret < 0)
930  return ret;
932  if (ret < 0)
933  return ret;
934  }
935 
936  return 0;
937 }
938 
939 /* internal functions for parsing audio format arguments */
940 
941 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
942 {
943  char *tail;
944  int pix_fmt = av_get_pix_fmt(arg);
945  if (pix_fmt == AV_PIX_FMT_NONE) {
946  pix_fmt = strtol(arg, &tail, 0);
947  if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
948  av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
949  return AVERROR(EINVAL);
950  }
951  }
952  *ret = pix_fmt;
953  return 0;
954 }
955 
956 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
957 {
958  char *tail;
959  double srate = av_strtod(arg, &tail);
960  if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
961  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
962  return AVERROR(EINVAL);
963  }
964  *ret = srate;
965  return 0;
966 }
967 
968 int ff_parse_channel_layout(AVChannelLayout *ret, int *nret, const char *arg,
969  void *log_ctx)
970 {
971  AVChannelLayout chlayout = { 0 };
972  int res;
973 
974  res = av_channel_layout_from_string(&chlayout, arg);
975  if (res < 0) {
976  av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
977  return AVERROR(EINVAL);
978  }
979 
980  if (chlayout.order == AV_CHANNEL_ORDER_UNSPEC && !nret) {
981  av_log(log_ctx, AV_LOG_ERROR, "Unknown channel layout '%s' is not supported.\n", arg);
982  return AVERROR(EINVAL);
983  }
984  *ret = chlayout;
985  if (nret)
986  *nret = chlayout.nb_channels;
987 
988  return 0;
989 }
990 
991 static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
992 {
993  unsigned i, j;
994 
995  if (!fmts)
996  return 0;
997  if (!fmts->nb_formats) {
998  av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
999  return AVERROR(EINVAL);
1000  }
1001  for (i = 0; i < fmts->nb_formats; i++) {
1002  for (j = i + 1; j < fmts->nb_formats; j++) {
1003  if (fmts->formats[i] == fmts->formats[j]) {
1004  av_log(log, AV_LOG_ERROR, "Duplicated %s\n", name);
1005  return AVERROR(EINVAL);
1006  }
1007  }
1008  }
1009  return 0;
1010 }
1012 int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
1013 {
1014  return check_list(log, "pixel format", fmts);
1015 }
1017 int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
1018 {
1019  return check_list(log, "sample format", fmts);
1020 }
1022 int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
1023 {
1024  if (!fmts || !fmts->nb_formats)
1025  return 0;
1026  return check_list(log, "sample rate", fmts);
1027 }
1029 int ff_formats_check_color_spaces(void *log, const AVFilterFormats *fmts)
1030 {
1031  for (int i = 0; fmts && i < fmts->nb_formats; i++) {
1032  if (fmts->formats[i] == AVCOL_SPC_RESERVED) {
1033  av_log(log, AV_LOG_ERROR, "Invalid color range\n");
1034  return AVERROR(EINVAL);
1035  }
1036  }
1037  return check_list(log, "color space", fmts);
1038 }
1040 int ff_formats_check_color_ranges(void *log, const AVFilterFormats *fmts)
1041 {
1042  return check_list(log, "color range", fmts);
1043 }
1045 static int layouts_compatible(const AVChannelLayout *a, const AVChannelLayout *b)
1046 {
1047  return !av_channel_layout_compare(a, b) ||
1048  (KNOWN(a) && !KNOWN(b) && a->nb_channels == b->nb_channels) ||
1049  (KNOWN(b) && !KNOWN(a) && b->nb_channels == a->nb_channels);
1050 }
1053 {
1054  unsigned i, j;
1055 
1056  if (!fmts)
1057  return 0;
1058  if (fmts->all_layouts < fmts->all_counts) {
1059  av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
1060  return AVERROR(EINVAL);
1061  }
1062  if (!fmts->all_layouts && !fmts->nb_channel_layouts) {
1063  av_log(log, AV_LOG_ERROR, "Empty channel layout list\n");
1064  return AVERROR(EINVAL);
1065  }
1066  for (i = 0; i < fmts->nb_channel_layouts; i++) {
1067  for (j = i + 1; j < fmts->nb_channel_layouts; j++) {
1068  if (layouts_compatible(&fmts->channel_layouts[i], &fmts->channel_layouts[j])) {
1069  av_log(log, AV_LOG_ERROR, "Duplicated or redundant channel layout\n");
1070  return AVERROR(EINVAL);
1071  }
1072  }
1073  }
1074  return 0;
1075 }
can_merge_generic
static int can_merge_generic(const void *a, const void *b)
Definition: formats.c:337
merge_generic_internal
static int merge_generic_internal(AVFilterFormats *a, AVFilterFormats *b, int check)
Definition: formats.c:324
formats
formats
Definition: signature.h:48
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
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
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
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:436
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_spaces_from_list
int ff_set_common_color_spaces_from_list(AVFilterContext *ctx, const int *color_ranges)
Equivalent to ff_set_common_color_spaces(ctx, ff_make_format_list(color_spaces))
Definition: formats.c:834
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:674
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
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:1011
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:816
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:622
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:840
pixdesc.h
AVCOL_SPC_NB
@ AVCOL_SPC_NB
Not part of ABI.
Definition: pixfmt.h:629
b
#define b
Definition: input.c:41
mergers_video
static const AVFilterFormatsMerger mergers_video[]
Definition: formats.c:348
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_all_samplerates
int ff_set_common_all_samplerates(AVFilterContext *ctx)
Equivalent to ff_set_common_samplerates(ctx, ff_all_samplerates())
Definition: formats.c:822
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:308
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:313
FF_FILTER_FORMATS_SAMPLEFMTS_LIST
@ FF_FILTER_FORMATS_SAMPLEFMTS_LIST
formats.samples_list active.
Definition: internal.h:154
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:530
FORMATS_UNREF
#define FORMATS_UNREF(ref, list)
Definition: formats.c:694
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:1044
AVCOL_SPC_RESERVED
@ AVCOL_SPC_RESERVED
reserved for future use by ITU-T and ISO/IEC just like 15-255 are
Definition: pixfmt.h:613
SET_COMMON_FORMATS
#define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn)
Definition: formats.c:759
fail
#define fail()
Definition: checkasm.h:183
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:687
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
AVFilterNegotiation
Callbacks and properties to describe the steps of a format negotiation.
Definition: formats.h:476
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:536
AVFilterNegotiation::nb_mergers
unsigned nb_mergers
Definition: formats.h:477
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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:868
FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
@ FF_FILTER_FORMATS_SINGLE_SAMPLEFMT
formats.sample_fmt active.
Definition: internal.h:156
check
#define check(x, y, S, v)
Definition: motion_est_template.c:405
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demux_decode.c:41
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:679
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:874
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
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
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
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:798
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
arg
const char * arg
Definition: jacosubdec.c:67
ff_formats_changeref
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Definition: formats.c:754
NULL
#define NULL
Definition: coverity.c:32
ff_filter_get_negotiation
const AVFilterNegotiation * ff_filter_get_negotiation(AVFilterLink *link)
Definition: formats.c:398
MAKE_FORMAT_LIST
#define MAKE_FORMAT_LIST(type, field, count_field)
Definition: formats.c:418
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_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:505
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:407
negotiate_audio
static const AVFilterNegotiation negotiate_audio
Definition: formats.c:391
AVFilterGraph
Definition: avfilter.h:813
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:804
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, const AVChannelLayout *channel_layout)
Definition: formats.c:522
ff_all_color_spaces
AVFilterFormats * ff_all_color_spaces(void)
Construct an AVFilterFormats representing all possible color spaces.
Definition: formats.c:631
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:730
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:505
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:1016
eval.h
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:121
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:1028
AVMediaType
AVMediaType
Definition: avutil.h:199
FF_PIX_FMT_FLAG_SW_FLAT_SUB
#define FF_PIX_FMT_FLAG_SW_FLAT_SUB
Definition: formats.h:295
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:879
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:303
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:990
ff_parse_channel_layout
int ff_parse_channel_layout(AVChannelLayout *ret, int *nret, const char *arg, void *log_ctx)
Parse a channel layout or a corresponding integer representation.
Definition: formats.c:967
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:852
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
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2464
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:1051
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:647
ff_all_channel_layouts
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:613
ADD_FORMAT
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb)
Definition: formats.c:481
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:800
internal.h
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:718
ff_set_common_color_ranges
int ff_set_common_color_ranges(AVFilterContext *ctx, AVFilterFormats *color_ranges)
Definition: formats.c:845
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:67
av_channel_layout_from_string
int av_channel_layout_from_string(AVChannelLayout *channel_layout, const char *str)
Initialize a channel layout from a given string description.
Definition: channel_layout.c:303
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:554
FORMATS_REF
#define FORMATS_REF(f, ref, unref_fn)
Definition: formats.c:658
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:1021
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:444
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
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: internal.h:151
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
common.h
FORMATS_CHANGEREF
#define FORMATS_CHANGEREF(oldref, newref)
Definition: formats.c:735
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
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:858
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:594
mergers_audio
static const AVFilterFormatsMerger mergers_audio[]
Definition: formats.c:366
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:612
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:1039
AVFilter
Filter definition.
Definition: avfilter.h:166
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
av_strtod
double av_strtod(const char *numstr, char **tail)
Parse the string in numstr and return its value as a double.
Definition: eval.c:107
ff_set_common_color_spaces
int ff_set_common_color_spaces(AVFilterContext *ctx, AVFilterFormats *color_spaces)
Definition: formats.c:827
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:774
FF_COUNT2LAYOUT
#define FF_COUNT2LAYOUT(c)
Encode a channel count as a channel layout.
Definition: formats.h:102
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2897
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:607
channel_layout.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
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:433
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
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
AVFilterContext
An instance of a filter.
Definition: avfilter.h:407
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:440
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVFilterChannelLayouts::nb_channel_layouts
int nb_channel_layouts
number of channel layouts
Definition: formats.h:87
mem.h
FF_FILTER_FORMATS_PIXFMT_LIST
@ FF_FILTER_FORMATS_PIXFMT_LIST
formats.pixels_list active.
Definition: internal.h:153
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:33
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:112
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
negotiate_video
static const AVFilterNegotiation negotiate_video
Definition: formats.c:384
ff_make_channel_layout_list
AVFilterChannelLayouts * ff_make_channel_layout_list(const AVChannelLayout *fmts)
Definition: formats.c:445
FF_FILTER_FORMATS_QUERY_FUNC
@ FF_FILTER_FORMATS_QUERY_FUNC
formats.query active.
Definition: internal.h:152
ff_parse_sample_rate
int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
Parse a sample rate.
Definition: formats.c:955
ff_parse_pixel_format
int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
Parse a pixel format.
Definition: formats.c:940
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:809
ff_channel_layouts_changeref
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:748
merge_sample_fmts
static int merge_sample_fmts(void *a, void *b)
See merge_pix_fmts().
Definition: formats.c:178
FF_FILTER_FORMATS_SINGLE_PIXFMT
@ FF_FILTER_FORMATS_SINGLE_PIXFMT
formats.pix_fmt active
Definition: internal.h:155
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:791