FFmpeg
formats.c
Go to the documentation of this file.
1 /*
2  * Filter layer - format negotiation
3  * Copyright (c) 2007 Bobby Bingham
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
24 #include "libavutil/common.h"
25 #include "libavutil/eval.h"
26 #include "libavutil/pixdesc.h"
27 #include "avfilter.h"
28 #include "internal.h"
29 #include "formats.h"
30 
31 #define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */
32 
33 /**
34  * Add all refs from a to ret and destroy a.
35  */
36 #define MERGE_REF(ret, a, fmts, type, fail_statement) \
37 do { \
38  type ***tmp; \
39  int i; \
40  \
41  if (!(tmp = av_realloc_array(ret->refs, ret->refcount + a->refcount, \
42  sizeof(*tmp)))) \
43  { fail_statement } \
44  ret->refs = tmp; \
45  \
46  for (i = 0; i < a->refcount; i ++) { \
47  ret->refs[ret->refcount] = a->refs[i]; \
48  *ret->refs[ret->refcount++] = ret; \
49  } \
50  \
51  av_freep(&a->refs); \
52  av_freep(&a->fmts); \
53  av_freep(&a); \
54 } while (0)
55 
56 /**
57  * Add all formats common to a and b to a, add b's refs to a and destroy b.
58  * If check is set, nothing is modified and it is only checked whether
59  * the formats are compatible.
60  * If empty_allowed is set and one of a,b->nb is zero, the lists are
61  * merged; otherwise, it is treated as error.
62  */
63 #define MERGE_FORMATS(a, b, fmts, nb, type, check, empty_allowed) \
64 do { \
65  int i, j, k = 0, skip = 0; \
66  \
67  if (empty_allowed) { \
68  if (!a->nb || !b->nb) { \
69  if (check) \
70  return 1; \
71  if (!a->nb) \
72  FFSWAP(type *, a, b); \
73  skip = 1; \
74  } \
75  } \
76  if (!skip) { \
77  for (i = 0; i < a->nb; i++) \
78  for (j = 0; j < b->nb; j++) \
79  if (a->fmts[i] == b->fmts[j]) { \
80  if (check) \
81  return 1; \
82  a->fmts[k++] = a->fmts[i]; \
83  break; \
84  } \
85  /* Check that there was at least one common format. \
86  * Notice that both a and b are unchanged if not. */ \
87  if (!k) \
88  return 0; \
89  av_assert2(!check); \
90  a->nb = k; \
91  } \
92  \
93  MERGE_REF(a, b, fmts, type, return AVERROR(ENOMEM);); \
94 } while (0)
95 
97  enum AVMediaType type, int check)
98 {
99  int i, j;
100  int alpha1=0, alpha2=0;
101  int chroma1=0, chroma2=0;
102 
103  av_assert2(check || (a->refcount && b->refcount));
104 
105  if (a == b)
106  return 1;
107 
108  /* Do not lose chroma or alpha in merging.
109  It happens if both lists have formats with chroma (resp. alpha), but
110  the only formats in common do not have it (e.g. YUV+gray vs.
111  RGB+gray): in that case, the merging would select the gray format,
112  possibly causing a lossy conversion elsewhere in the graph.
113  To avoid that, pretend that there are no common formats to force the
114  insertion of a conversion filter. */
115  if (type == AVMEDIA_TYPE_VIDEO)
116  for (i = 0; i < a->nb_formats; i++)
117  for (j = 0; j < b->nb_formats; j++) {
118  const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
119  const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
120  alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
121  chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
122  if (a->formats[i] == b->formats[j]) {
123  alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
124  chroma1|= adesc->nb_components > 1;
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  */
213 static int merge_channel_layouts(void *va, void *vb)
214 {
217  uint64_t *channel_layouts;
218  unsigned a_all = a->all_layouts + a->all_counts;
219  unsigned b_all = b->all_layouts + b->all_counts;
220  int ret_max, ret_nb = 0, i, j, round;
221 
222  av_assert2(a->refcount && b->refcount);
223 
224  if (a == b) return 1;
225 
226  /* Put the most generic set in a, to avoid doing everything twice */
227  if (a_all < b_all) {
229  FFSWAP(unsigned, a_all, b_all);
230  }
231  if (a_all) {
232  if (a_all == 1 && !b_all) {
233  /* keep only known layouts in b; works also for b_all = 1 */
234  for (i = j = 0; i < b->nb_channel_layouts; i++)
235  if (KNOWN(b->channel_layouts[i]))
236  b->channel_layouts[j++] = b->channel_layouts[i];
237  /* Not optimal: the unknown layouts of b may become known after
238  another merge. */
239  if (!j)
240  return 0;
241  b->nb_channel_layouts = j;
242  }
244  return 1;
245  }
246 
247  ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
248  if (!(channel_layouts = av_malloc_array(ret_max, sizeof(*channel_layouts))))
249  return AVERROR(ENOMEM);
250 
251  /* a[known] intersect b[known] */
252  for (i = 0; i < a->nb_channel_layouts; i++) {
253  if (!KNOWN(a->channel_layouts[i]))
254  continue;
255  for (j = 0; j < b->nb_channel_layouts; j++) {
256  if (a->channel_layouts[i] == b->channel_layouts[j]) {
257  channel_layouts[ret_nb++] = a->channel_layouts[i];
258  a->channel_layouts[i] = b->channel_layouts[j] = 0;
259  break;
260  }
261  }
262  }
263  /* 1st round: a[known] intersect b[generic]
264  2nd round: a[generic] intersect b[known] */
265  for (round = 0; round < 2; round++) {
266  for (i = 0; i < a->nb_channel_layouts; i++) {
267  uint64_t fmt = a->channel_layouts[i], bfmt;
268  if (!fmt || !KNOWN(fmt))
269  continue;
271  for (j = 0; j < b->nb_channel_layouts; j++)
272  if (b->channel_layouts[j] == bfmt)
273  channel_layouts[ret_nb++] = a->channel_layouts[i];
274  }
275  /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
277  }
278  /* a[generic] intersect b[generic] */
279  for (i = 0; i < a->nb_channel_layouts; i++) {
280  if (KNOWN(a->channel_layouts[i]))
281  continue;
282  for (j = 0; j < b->nb_channel_layouts; j++)
283  if (a->channel_layouts[i] == b->channel_layouts[j])
284  channel_layouts[ret_nb++] = a->channel_layouts[i];
285  }
286 
287  if (!ret_nb) {
289  return 0;
290  }
291 
292  if (a->refcount > b->refcount)
294 
296  { av_free(channel_layouts); return AVERROR(ENOMEM); });
297  av_freep(&b->channel_layouts);
298  b->channel_layouts = channel_layouts;
299  b->nb_channel_layouts = ret_nb;
300  return 1;
301 }
302 
303 static const AVFilterFormatsMerger mergers_video[] = {
304  {
305  .offset = offsetof(AVFilterFormatsConfig, formats),
306  .merge = merge_pix_fmts,
307  .can_merge = can_merge_pix_fmts,
308  },
309 };
310 
311 static const AVFilterFormatsMerger mergers_audio[] = {
312  {
313  .offset = offsetof(AVFilterFormatsConfig, channel_layouts),
314  .merge = merge_channel_layouts,
315  .can_merge = NULL,
316  },
317  {
318  .offset = offsetof(AVFilterFormatsConfig, samplerates),
319  .merge = merge_samplerates,
320  .can_merge = can_merge_samplerates,
321  },
322  {
323  .offset = offsetof(AVFilterFormatsConfig, formats),
324  .merge = merge_sample_fmts,
325  .can_merge = can_merge_sample_fmts,
326  },
327 };
328 
329 static const AVFilterNegotiation negotiate_video = {
331  .mergers = mergers_video,
332  .conversion_filter = "scale",
333  .conversion_opts_offset = offsetof(AVFilterGraph, scale_sws_opts),
334 };
335 
336 static const AVFilterNegotiation negotiate_audio = {
338  .mergers = mergers_audio,
339  .conversion_filter = "aresample",
340  .conversion_opts_offset = offsetof(AVFilterGraph, aresample_swr_opts),
341 };
342 
344 {
345  switch (link->type) {
346  case AVMEDIA_TYPE_VIDEO: return &negotiate_video;
347  case AVMEDIA_TYPE_AUDIO: return &negotiate_audio;
348  default: return NULL;
349  }
350 }
351 
352 int ff_fmt_is_in(int fmt, const int *fmts)
353 {
354  const int *p;
355 
356  for (p = fmts; *p != -1; p++) {
357  if (fmt == *p)
358  return 1;
359  }
360  return 0;
361 }
362 
363 #define MAKE_FORMAT_LIST(type, field, count_field) \
364  type *formats; \
365  int count = 0; \
366  if (fmts) \
367  for (count = 0; fmts[count] != -1; count++) \
368  ; \
369  formats = av_mallocz(sizeof(*formats)); \
370  if (!formats) \
371  return NULL; \
372  formats->count_field = count; \
373  if (count) { \
374  formats->field = av_malloc_array(count, sizeof(*formats->field)); \
375  if (!formats->field) { \
376  av_freep(&formats); \
377  return NULL; \
378  } \
379  }
380 
381 AVFilterFormats *ff_make_format_list(const int *fmts)
382 {
384  while (count--)
385  formats->formats[count] = fmts[count];
386 
387  return formats;
388 }
389 
390 AVFilterChannelLayouts *ff_make_format64_list(const int64_t *fmts)
391 {
393  channel_layouts, nb_channel_layouts);
394  if (count)
395  memcpy(formats->channel_layouts, fmts,
396  sizeof(*formats->channel_layouts) * count);
397 
398  return formats;
399 }
400 
401 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
402 do { \
403  type *fmts; \
404  \
405  if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
406  return AVERROR(ENOMEM); \
407  } \
408  \
409  fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
410  sizeof(*(*f)->list)); \
411  if (!fmts) { \
412  unref_fn(f); \
413  return AVERROR(ENOMEM); \
414  } \
415  \
416  (*f)->list = fmts; \
417  (*f)->list[(*f)->nb++] = fmt; \
418 } while (0)
419 
420 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
421 {
422  ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
423  return 0;
424 }
425 
426 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
427 {
428  av_assert1(!(*l && (*l)->all_layouts));
429  ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, uint64_t, channel_layouts, nb_channel_layouts);
430  return 0;
431 }
432 
434 {
436 
437  if (type == AVMEDIA_TYPE_VIDEO) {
438  const AVPixFmtDescriptor *desc = NULL;
439  while ((desc = av_pix_fmt_desc_next(desc))) {
441  return NULL;
442  }
443  } else if (type == AVMEDIA_TYPE_AUDIO) {
444  enum AVSampleFormat fmt = 0;
445  while (av_get_sample_fmt_name(fmt)) {
446  if (ff_add_format(&ret, fmt) < 0)
447  return NULL;
448  fmt++;
449  }
450  }
451 
452  return ret;
453 }
454 
455 int ff_formats_pixdesc_filter(AVFilterFormats **rfmts, unsigned want, unsigned rej)
456 {
457  unsigned nb_formats, fmt, flags;
459 
460  while (1) {
461  nb_formats = 0;
462  for (fmt = 0;; fmt++) {
464  if (!desc)
465  break;
466  flags = desc->flags;
467  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
468  !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
469  (desc->log2_chroma_w || desc->log2_chroma_h))
471  if ((flags & (want | rej)) != want)
472  continue;
473  if (formats)
474  formats->formats[nb_formats] = fmt;
475  nb_formats++;
476  }
477  if (formats) {
478  av_assert0(formats->nb_formats == nb_formats);
479  *rfmts = formats;
480  return 0;
481  }
482  formats = av_mallocz(sizeof(*formats));
483  if (!formats)
484  return AVERROR(ENOMEM);
485  formats->nb_formats = nb_formats;
486  if (nb_formats) {
487  formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
488  if (!formats->formats) {
489  av_freep(&formats);
490  return AVERROR(ENOMEM);
491  }
492  }
493  }
494 }
495 
497 {
499  int fmt;
500 
501  for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
502  if (av_sample_fmt_is_planar(fmt))
503  if (ff_add_format(&ret, fmt) < 0)
504  return NULL;
505 
506  return ret;
507 }
508 
510 {
511  AVFilterFormats *ret = av_mallocz(sizeof(*ret));
512  return ret;
513 }
514 
516 {
518  if (!ret)
519  return NULL;
520  ret->all_layouts = 1;
521  return ret;
522 }
523 
525 {
527  if (!ret)
528  return NULL;
529  ret->all_layouts = ret->all_counts = 1;
530  return ret;
531 }
532 
533 #define FORMATS_REF(f, ref, unref_fn) \
534  void *tmp; \
535  \
536  if (!f) \
537  return AVERROR(ENOMEM); \
538  \
539  tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1); \
540  if (!tmp) { \
541  unref_fn(&f); \
542  return AVERROR(ENOMEM); \
543  } \
544  f->refs = tmp; \
545  f->refs[f->refcount++] = ref; \
546  *ref = f; \
547  return 0
548 
550 {
552 }
553 
555 {
557 }
558 
559 #define FIND_REF_INDEX(ref, idx) \
560 do { \
561  int i; \
562  for (i = 0; i < (*ref)->refcount; i ++) \
563  if((*ref)->refs[i] == ref) { \
564  idx = i; \
565  break; \
566  } \
567 } while (0)
568 
569 #define FORMATS_UNREF(ref, list) \
570 do { \
571  int idx = -1; \
572  \
573  if (!*ref) \
574  return; \
575  \
576  FIND_REF_INDEX(ref, idx); \
577  \
578  if (idx >= 0) { \
579  memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
580  sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
581  --(*ref)->refcount; \
582  } \
583  if (!(*ref)->refcount) { \
584  av_free((*ref)->list); \
585  av_free((*ref)->refs); \
586  av_free(*ref); \
587  } \
588  *ref = NULL; \
589 } while (0)
590 
592 {
594 }
595 
597 {
599 }
600 
601 #define FORMATS_CHANGEREF(oldref, newref) \
602 do { \
603  int idx = -1; \
604  \
605  FIND_REF_INDEX(oldref, idx); \
606  \
607  if (idx >= 0) { \
608  (*oldref)->refs[idx] = newref; \
609  *newref = *oldref; \
610  *oldref = NULL; \
611  } \
612 } while (0)
613 
615  AVFilterChannelLayouts **newref)
616 {
617  FORMATS_CHANGEREF(oldref, newref);
618 }
619 
621 {
622  FORMATS_CHANGEREF(oldref, newref);
623 }
624 
625 #define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn) \
626  int i; \
627  \
628  if (!fmts) \
629  return AVERROR(ENOMEM); \
630  \
631  for (i = 0; i < ctx->nb_inputs; i++) { \
632  AVFilterLink *const link = ctx->inputs[i]; \
633  if (link && !link->outcfg.fmts && \
634  (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
635  int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts); \
636  if (ret < 0) { \
637  return ret; \
638  } \
639  } \
640  } \
641  for (i = 0; i < ctx->nb_outputs; i++) { \
642  AVFilterLink *const link = ctx->outputs[i]; \
643  if (link && !link->incfg.fmts && \
644  (media_type == AVMEDIA_TYPE_UNKNOWN || link->type == media_type)) { \
645  int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts); \
646  if (ret < 0) { \
647  return ret; \
648  } \
649  } \
650  } \
651  \
652  if (!fmts->refcount) \
653  unref_fn(&fmts); \
654  \
655  return 0;
656 
659 {
662 }
663 
665  const int64_t *fmts)
666 {
668 }
669 
671 {
673 }
674 
676  AVFilterFormats *samplerates)
677 {
680 }
681 
683  const int *samplerates)
684 {
685  return ff_set_common_samplerates(ctx, ff_make_format_list(samplerates));
686 }
687 
689 {
691 }
692 
693 /**
694  * A helper for query_formats() which sets all links to the same list of
695  * formats. If there are no links hooked to this filter, the list of formats is
696  * freed.
697  */
699 {
702 }
703 
705 {
707 }
708 
710 {
711  int ret;
712  enum AVMediaType type = ctx->nb_inputs ? ctx->inputs [0]->type :
713  ctx->nb_outputs ? ctx->outputs[0]->type :
715 
717  if (ret < 0)
718  return ret;
719  if (type == AVMEDIA_TYPE_AUDIO) {
721  if (ret < 0)
722  return ret;
724  if (ret < 0)
725  return ret;
726  }
727 
728  return 0;
729 }
730 
731 /* internal functions for parsing audio format arguments */
732 
733 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
734 {
735  char *tail;
736  int pix_fmt = av_get_pix_fmt(arg);
737  if (pix_fmt == AV_PIX_FMT_NONE) {
738  pix_fmt = strtol(arg, &tail, 0);
739  if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
740  av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
741  return AVERROR(EINVAL);
742  }
743  }
744  *ret = pix_fmt;
745  return 0;
746 }
747 
748 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
749 {
750  char *tail;
751  double srate = av_strtod(arg, &tail);
752  if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
753  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
754  return AVERROR(EINVAL);
755  }
756  *ret = srate;
757  return 0;
758 }
759 
760 int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
761  void *log_ctx)
762 {
763  int64_t chlayout;
764  int nb_channels;
765 
766  if (av_get_extended_channel_layout(arg, &chlayout, &nb_channels) < 0) {
767  av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
768  return AVERROR(EINVAL);
769  }
770  if (!chlayout && !nret) {
771  av_log(log_ctx, AV_LOG_ERROR, "Unknown channel layout '%s' is not supported.\n", arg);
772  return AVERROR(EINVAL);
773  }
774  *ret = chlayout;
775  if (nret)
776  *nret = nb_channels;
777 
778  return 0;
779 }
780 
781 static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
782 {
783  unsigned i, j;
784 
785  if (!fmts)
786  return 0;
787  if (!fmts->nb_formats) {
788  av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
789  return AVERROR(EINVAL);
790  }
791  for (i = 0; i < fmts->nb_formats; i++) {
792  for (j = i + 1; j < fmts->nb_formats; j++) {
793  if (fmts->formats[i] == fmts->formats[j]) {
794  av_log(log, AV_LOG_ERROR, "Duplicated %s\n", name);
795  return AVERROR(EINVAL);
796  }
797  }
798  }
799  return 0;
800 }
801 
802 int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
803 {
804  return check_list(log, "pixel format", fmts);
805 }
806 
807 int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
808 {
809  return check_list(log, "sample format", fmts);
810 }
811 
812 int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
813 {
814  if (!fmts || !fmts->nb_formats)
815  return 0;
816  return check_list(log, "sample rate", fmts);
817 }
818 
819 static int layouts_compatible(uint64_t a, uint64_t b)
820 {
821  return a == b ||
824 }
825 
827 {
828  unsigned i, j;
829 
830  if (!fmts)
831  return 0;
832  if (fmts->all_layouts < fmts->all_counts) {
833  av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
834  return AVERROR(EINVAL);
835  }
836  if (!fmts->all_layouts && !fmts->nb_channel_layouts) {
837  av_log(log, AV_LOG_ERROR, "Empty channel layout list\n");
838  return AVERROR(EINVAL);
839  }
840  for (i = 0; i < fmts->nb_channel_layouts; i++) {
841  for (j = i + 1; j < fmts->nb_channel_layouts; j++) {
842  if (layouts_compatible(fmts->channel_layouts[i], fmts->channel_layouts[j])) {
843  av_log(log, AV_LOG_ERROR, "Duplicated or redundant channel layout\n");
844  return AVERROR(EINVAL);
845  }
846  }
847  }
848  return 0;
849 }
formats
formats
Definition: signature.h:48
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:85
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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:95
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:380
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
merge_channel_layouts
static int merge_channel_layouts(void *va, void *vb)
See merge_pix_fmts().
Definition: formats.c:212
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:548
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
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:801
ff_formats_pixdesc_filter
int ff_formats_pixdesc_filter(AVFilterFormats **rfmts, unsigned want, unsigned rej)
Construct a formats list containing all pixel formats with certain properties.
Definition: formats.c:454
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:681
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:523
ff_make_format64_list
AVFilterChannelLayouts * ff_make_format64_list(const int64_t *fmts)
Definition: formats.c:389
pixdesc.h
b
#define b
Definition: input.c:40
mergers_video
static const AVFilterFormatsMerger mergers_video[]
Definition: formats.c:302
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:63
av_pix_fmt_desc_next
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2547
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:687
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
FORMATS_UNREF
#define FORMATS_UNREF(ref, list)
Definition: formats.c:568
ff_set_common_channel_layouts_from_list
int ff_set_common_channel_layouts_from_list(AVFilterContext *ctx, const int64_t *fmts)
Equivalent to ff_set_common_channel_layouts(ctx, ff_make_format64_list(fmts))
Definition: formats.c:663
FF_LAYOUT2COUNT
#define FF_LAYOUT2COUNT(l)
Decode a channel count encoded as a channel layout.
Definition: formats.h:108
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
formats.h
SET_COMMON_FORMATS
#define SET_COMMON_FORMATS(ctx, fmts, media_type, ref_fn, unref_fn)
Definition: formats.c:624
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
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:409
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:432
AVFilterNegotiation::nb_mergers
unsigned nb_mergers
Definition: formats.h:410
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:697
check
#define check(x, y, S, v)
Definition: motion_est_template.c:405
ff_add_channel_layout
int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
Definition: formats.c:425
AVFilterChannelLayouts::channel_layouts
uint64_t * channel_layouts
list of channel layouts
Definition: formats.h:86
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
ff_formats_ref
int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
Add *ref as a new reference to formats.
Definition: formats.c:553
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:703
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:112
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:48
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:41
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:49
f
#define f(width, name)
Definition: cbs_vp9.c:255
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:619
NULL
#define NULL
Definition: coverity.c:32
ff_filter_get_negotiation
const AVFilterNegotiation * ff_filter_get_negotiation(AVFilterLink *link)
Definition: formats.c:342
MAKE_FORMAT_LIST
#define MAKE_FORMAT_LIST(type, field, count_field)
Definition: formats.c:362
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:419
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:351
negotiate_audio
static const AVFilterNegotiation negotiate_audio
Definition: formats.c:335
AVFilterGraph
Definition: avfilter.h:805
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:669
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:595
AVFilterFormatsConfig
Lists of formats / etc.
Definition: avfilter.h:445
av_get_channel_layout_nb_channels
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
Definition: channel_layout.c:226
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:806
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:36
AVMediaType
AVMediaType
Definition: avutil.h:199
FF_PIX_FMT_FLAG_SW_FLAT_SUB
#define FF_PIX_FMT_FLAG_SW_FLAT_SUB
Definition: formats.h:236
ff_default_query_formats
int ff_default_query_formats(AVFilterContext *ctx)
Definition: formats.c:708
ff_parse_channel_layout
int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg, void *log_ctx)
Parse a channel layout or a corresponding integer representation.
Definition: formats.c:759
check_list
static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
Definition: formats.c:780
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
KNOWN
#define KNOWN(l)
Definition: formats.c:31
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:825
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
av_pix_fmt_desc_get_id
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2559
ff_all_channel_layouts
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:514
ADD_FORMAT
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb)
Definition: formats.c:400
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:590
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
int i
Definition: input.c:406
FORMATS_REF
#define FORMATS_REF(f, ref, unref_fn)
Definition: formats.c:532
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:811
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:106
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
common.h
FORMATS_CHANGEREF
#define FORMATS_CHANGEREF(oldref, newref)
Definition: formats.c:600
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
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:263
ff_planar_sample_fmts
AVFilterFormats * ff_planar_sample_fmts(void)
Construct a formats list containing all planar sample formats.
Definition: formats.c:495
mergers_audio
static const AVFilterFormatsMerger mergers_audio[]
Definition: formats.c:310
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:106
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:2472
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:508
channel_layout.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
avfilter.h
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
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
av_get_extended_channel_layout
int av_get_extended_channel_layout(const char *name, uint64_t *channel_layout, int *nb_channels)
Return a channel layout and the number of channels based on the specified name.
Definition: channel_layout.c:161
AVFilterContext
An instance of a filter.
Definition: avfilter.h:346
layouts_compatible
static int layouts_compatible(uint64_t a, uint64_t b)
Definition: formats.c:818
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
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
channel_layouts
static const uint16_t channel_layouts[7]
Definition: dca_lbr.c:114
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
negotiate_video
static const AVFilterNegotiation negotiate_video
Definition: formats.c:328
ff_parse_sample_rate
int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
Parse a sample rate.
Definition: formats.c:747
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:732
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
ff_set_common_samplerates
int ff_set_common_samplerates(AVFilterContext *ctx, AVFilterFormats *samplerates)
Definition: formats.c:674
ff_channel_layouts_changeref
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:613
merge_sample_fmts
static int merge_sample_fmts(void *a, void *b)
See merge_pix_fmts().
Definition: formats.c:178
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:656
nb_channels
int nb_channels
Definition: channel_layout.c:81