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  if (a == b)
104  return 1;
105 
106  /* Do not lose chroma or alpha in merging.
107  It happens if both lists have formats with chroma (resp. alpha), but
108  the only formats in common do not have it (e.g. YUV+gray vs.
109  RGB+gray): in that case, the merging would select the gray format,
110  possibly causing a lossy conversion elsewhere in the graph.
111  To avoid that, pretend that there are no common formats to force the
112  insertion of a conversion filter. */
113  if (type == AVMEDIA_TYPE_VIDEO)
114  for (i = 0; i < a->nb_formats; i++)
115  for (j = 0; j < b->nb_formats; j++) {
116  const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
117  const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
118  alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
119  chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
120  if (a->formats[i] == b->formats[j]) {
121  alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
122  chroma1|= adesc->nb_components > 1;
123  }
124  }
125 
126  // If chroma or alpha can be lost through merging then do not merge
127  if (alpha2 > alpha1 || chroma2 > chroma1)
128  return 0;
129 
130  MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 0);
131 
132  return 1;
133 }
134 
136  enum AVMediaType type)
137 {
139  (AVFilterFormats *)b, type, 1);
140 }
141 
143  enum AVMediaType type)
144 {
145  av_assert2(a->refcount && b->refcount);
146  return merge_formats_internal(a, b, type, 0);
147 }
148 
150  AVFilterFormats *b, int check)
151 {
152  if (a == b) return 1;
153 
154  MERGE_FORMATS(a, b, formats, nb_formats, AVFilterFormats, check, 1);
155  return 1;
156 }
157 
159 {
161 }
162 
164 {
165  av_assert2(a->refcount && b->refcount);
166  return merge_samplerates_internal(a, b, 0);
167 }
168 
171 {
172  uint64_t *channel_layouts;
173  unsigned a_all = a->all_layouts + a->all_counts;
174  unsigned b_all = b->all_layouts + b->all_counts;
175  int ret_max, ret_nb = 0, i, j, round;
176 
177  av_assert2(a->refcount && b->refcount);
178 
179  if (a == b) return 1;
180 
181  /* Put the most generic set in a, to avoid doing everything twice */
182  if (a_all < b_all) {
184  FFSWAP(unsigned, a_all, b_all);
185  }
186  if (a_all) {
187  if (a_all == 1 && !b_all) {
188  /* keep only known layouts in b; works also for b_all = 1 */
189  for (i = j = 0; i < b->nb_channel_layouts; i++)
190  if (KNOWN(b->channel_layouts[i]))
191  b->channel_layouts[j++] = b->channel_layouts[i];
192  /* Not optimal: the unknown layouts of b may become known after
193  another merge. */
194  if (!j)
195  return 0;
196  b->nb_channel_layouts = j;
197  }
199  return 1;
200  }
201 
202  ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
203  if (!(channel_layouts = av_malloc_array(ret_max, sizeof(*channel_layouts))))
204  return AVERROR(ENOMEM);
205 
206  /* a[known] intersect b[known] */
207  for (i = 0; i < a->nb_channel_layouts; i++) {
208  if (!KNOWN(a->channel_layouts[i]))
209  continue;
210  for (j = 0; j < b->nb_channel_layouts; j++) {
211  if (a->channel_layouts[i] == b->channel_layouts[j]) {
212  channel_layouts[ret_nb++] = a->channel_layouts[i];
213  a->channel_layouts[i] = b->channel_layouts[j] = 0;
214  break;
215  }
216  }
217  }
218  /* 1st round: a[known] intersect b[generic]
219  2nd round: a[generic] intersect b[known] */
220  for (round = 0; round < 2; round++) {
221  for (i = 0; i < a->nb_channel_layouts; i++) {
222  uint64_t fmt = a->channel_layouts[i], bfmt;
223  if (!fmt || !KNOWN(fmt))
224  continue;
226  for (j = 0; j < b->nb_channel_layouts; j++)
227  if (b->channel_layouts[j] == bfmt)
228  channel_layouts[ret_nb++] = a->channel_layouts[i];
229  }
230  /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
232  }
233  /* a[generic] intersect b[generic] */
234  for (i = 0; i < a->nb_channel_layouts; i++) {
235  if (KNOWN(a->channel_layouts[i]))
236  continue;
237  for (j = 0; j < b->nb_channel_layouts; j++)
238  if (a->channel_layouts[i] == b->channel_layouts[j])
239  channel_layouts[ret_nb++] = a->channel_layouts[i];
240  }
241 
242  if (!ret_nb) {
244  return 0;
245  }
246 
247  if (a->refcount > b->refcount)
249 
251  { av_free(channel_layouts); return AVERROR(ENOMEM); });
252  av_freep(&b->channel_layouts);
253  b->channel_layouts = channel_layouts;
254  b->nb_channel_layouts = ret_nb;
255  return 1;
256 }
257 
258 int ff_fmt_is_in(int fmt, const int *fmts)
259 {
260  const int *p;
261 
262  for (p = fmts; *p != -1; p++) {
263  if (fmt == *p)
264  return 1;
265  }
266  return 0;
267 }
268 
269 #define MAKE_FORMAT_LIST(type, field, count_field) \
270  type *formats; \
271  int count = 0; \
272  if (fmts) \
273  for (count = 0; fmts[count] != -1; count++) \
274  ; \
275  formats = av_mallocz(sizeof(*formats)); \
276  if (!formats) \
277  return NULL; \
278  formats->count_field = count; \
279  if (count) { \
280  formats->field = av_malloc_array(count, sizeof(*formats->field)); \
281  if (!formats->field) { \
282  av_freep(&formats); \
283  return NULL; \
284  } \
285  }
286 
287 AVFilterFormats *ff_make_format_list(const int *fmts)
288 {
290  while (count--)
291  formats->formats[count] = fmts[count];
292 
293  return formats;
294 }
295 
296 AVFilterChannelLayouts *ff_make_format64_list(const int64_t *fmts)
297 {
299  channel_layouts, nb_channel_layouts);
300  if (count)
301  memcpy(formats->channel_layouts, fmts,
302  sizeof(*formats->channel_layouts) * count);
303 
304  return formats;
305 }
306 
307 #define ADD_FORMAT(f, fmt, unref_fn, type, list, nb) \
308 do { \
309  type *fmts; \
310  \
311  if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) { \
312  return AVERROR(ENOMEM); \
313  } \
314  \
315  fmts = av_realloc_array((*f)->list, (*f)->nb + 1, \
316  sizeof(*(*f)->list)); \
317  if (!fmts) { \
318  unref_fn(f); \
319  return AVERROR(ENOMEM); \
320  } \
321  \
322  (*f)->list = fmts; \
323  (*f)->list[(*f)->nb++] = fmt; \
324 } while (0)
325 
326 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
327 {
328  ADD_FORMAT(avff, fmt, ff_formats_unref, int, formats, nb_formats);
329  return 0;
330 }
331 
332 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
333 {
334  av_assert1(!(*l && (*l)->all_layouts));
335  ADD_FORMAT(l, channel_layout, ff_channel_layouts_unref, uint64_t, channel_layouts, nb_channel_layouts);
336  return 0;
337 }
338 
340 {
342 
343  if (type == AVMEDIA_TYPE_VIDEO) {
344  const AVPixFmtDescriptor *desc = NULL;
345  while ((desc = av_pix_fmt_desc_next(desc))) {
347  return NULL;
348  }
349  } else if (type == AVMEDIA_TYPE_AUDIO) {
350  enum AVSampleFormat fmt = 0;
351  while (av_get_sample_fmt_name(fmt)) {
352  if (ff_add_format(&ret, fmt) < 0)
353  return NULL;
354  fmt++;
355  }
356  }
357 
358  return ret;
359 }
360 
361 int ff_formats_pixdesc_filter(AVFilterFormats **rfmts, unsigned want, unsigned rej)
362 {
363  unsigned nb_formats, fmt, flags;
365 
366  while (1) {
367  nb_formats = 0;
368  for (fmt = 0;; fmt++) {
370  if (!desc)
371  break;
372  flags = desc->flags;
373  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&
374  !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
375  (desc->log2_chroma_w || desc->log2_chroma_h))
377  if ((flags & (want | rej)) != want)
378  continue;
379  if (formats)
380  formats->formats[nb_formats] = fmt;
381  nb_formats++;
382  }
383  if (formats) {
384  av_assert0(formats->nb_formats == nb_formats);
385  *rfmts = formats;
386  return 0;
387  }
388  formats = av_mallocz(sizeof(*formats));
389  if (!formats)
390  return AVERROR(ENOMEM);
391  formats->nb_formats = nb_formats;
392  if (nb_formats) {
393  formats->formats = av_malloc_array(nb_formats, sizeof(*formats->formats));
394  if (!formats->formats) {
395  av_freep(&formats);
396  return AVERROR(ENOMEM);
397  }
398  }
399  }
400 }
401 
403 {
405  int fmt;
406 
407  for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
408  if (av_sample_fmt_is_planar(fmt))
409  if (ff_add_format(&ret, fmt) < 0)
410  return NULL;
411 
412  return ret;
413 }
414 
416 {
417  AVFilterFormats *ret = av_mallocz(sizeof(*ret));
418  return ret;
419 }
420 
422 {
424  if (!ret)
425  return NULL;
426  ret->all_layouts = 1;
427  return ret;
428 }
429 
431 {
433  if (!ret)
434  return NULL;
435  ret->all_layouts = ret->all_counts = 1;
436  return ret;
437 }
438 
439 #define FORMATS_REF(f, ref, unref_fn) \
440  void *tmp; \
441  \
442  if (!f) \
443  return AVERROR(ENOMEM); \
444  \
445  tmp = av_realloc_array(f->refs, sizeof(*f->refs), f->refcount + 1); \
446  if (!tmp) { \
447  unref_fn(&f); \
448  return AVERROR(ENOMEM); \
449  } \
450  f->refs = tmp; \
451  f->refs[f->refcount++] = ref; \
452  *ref = f; \
453  return 0
454 
456 {
458 }
459 
461 {
463 }
464 
465 #define FIND_REF_INDEX(ref, idx) \
466 do { \
467  int i; \
468  for (i = 0; i < (*ref)->refcount; i ++) \
469  if((*ref)->refs[i] == ref) { \
470  idx = i; \
471  break; \
472  } \
473 } while (0)
474 
475 #define FORMATS_UNREF(ref, list) \
476 do { \
477  int idx = -1; \
478  \
479  if (!*ref) \
480  return; \
481  \
482  FIND_REF_INDEX(ref, idx); \
483  \
484  if (idx >= 0) { \
485  memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
486  sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
487  --(*ref)->refcount; \
488  } \
489  if (!(*ref)->refcount) { \
490  av_free((*ref)->list); \
491  av_free((*ref)->refs); \
492  av_free(*ref); \
493  } \
494  *ref = NULL; \
495 } while (0)
496 
498 {
500 }
501 
503 {
505 }
506 
507 #define FORMATS_CHANGEREF(oldref, newref) \
508 do { \
509  int idx = -1; \
510  \
511  FIND_REF_INDEX(oldref, idx); \
512  \
513  if (idx >= 0) { \
514  (*oldref)->refs[idx] = newref; \
515  *newref = *oldref; \
516  *oldref = NULL; \
517  } \
518 } while (0)
519 
521  AVFilterChannelLayouts **newref)
522 {
523  FORMATS_CHANGEREF(oldref, newref);
524 }
525 
527 {
528  FORMATS_CHANGEREF(oldref, newref);
529 }
530 
531 #define SET_COMMON_FORMATS(ctx, fmts, ref_fn, unref_fn) \
532  int count = 0, i; \
533  \
534  if (!fmts) \
535  return AVERROR(ENOMEM); \
536  \
537  for (i = 0; i < ctx->nb_inputs; i++) { \
538  if (ctx->inputs[i] && !ctx->inputs[i]->outcfg.fmts) { \
539  int ret = ref_fn(fmts, &ctx->inputs[i]->outcfg.fmts); \
540  if (ret < 0) { \
541  return ret; \
542  } \
543  count++; \
544  } \
545  } \
546  for (i = 0; i < ctx->nb_outputs; i++) { \
547  if (ctx->outputs[i] && !ctx->outputs[i]->incfg.fmts) { \
548  int ret = ref_fn(fmts, &ctx->outputs[i]->incfg.fmts); \
549  if (ret < 0) { \
550  return ret; \
551  } \
552  count++; \
553  } \
554  } \
555  \
556  if (!count) { \
557  unref_fn(&fmts); \
558  } \
559  \
560  return 0;
561 
564 {
567 }
568 
570  AVFilterFormats *samplerates)
571 {
572  SET_COMMON_FORMATS(ctx, samplerates,
574 }
575 
576 /**
577  * A helper for query_formats() which sets all links to the same list of
578  * formats. If there are no links hooked to this filter, the list of formats is
579  * freed.
580  */
582 {
585 }
586 
588 {
589  int ret;
590  enum AVMediaType type = ctx->nb_inputs ? ctx->inputs [0]->type :
591  ctx->nb_outputs ? ctx->outputs[0]->type :
593 
595  if (ret < 0)
596  return ret;
597  if (type == AVMEDIA_TYPE_AUDIO) {
599  if (ret < 0)
600  return ret;
602  if (ret < 0)
603  return ret;
604  }
605 
606  return 0;
607 }
608 
609 /* internal functions for parsing audio format arguments */
610 
611 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
612 {
613  char *tail;
614  int pix_fmt = av_get_pix_fmt(arg);
615  if (pix_fmt == AV_PIX_FMT_NONE) {
616  pix_fmt = strtol(arg, &tail, 0);
617  if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
618  av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
619  return AVERROR(EINVAL);
620  }
621  }
622  *ret = pix_fmt;
623  return 0;
624 }
625 
626 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
627 {
628  char *tail;
629  double srate = av_strtod(arg, &tail);
630  if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
631  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
632  return AVERROR(EINVAL);
633  }
634  *ret = srate;
635  return 0;
636 }
637 
638 int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
639  void *log_ctx)
640 {
641  int64_t chlayout;
642  int nb_channels;
643 
644  if (av_get_extended_channel_layout(arg, &chlayout, &nb_channels) < 0) {
645  av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
646  return AVERROR(EINVAL);
647  }
648  if (!chlayout && !nret) {
649  av_log(log_ctx, AV_LOG_ERROR, "Unknown channel layout '%s' is not supported.\n", arg);
650  return AVERROR(EINVAL);
651  }
652  *ret = chlayout;
653  if (nret)
654  *nret = nb_channels;
655 
656  return 0;
657 }
658 
659 static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
660 {
661  unsigned i, j;
662 
663  if (!fmts)
664  return 0;
665  if (!fmts->nb_formats) {
666  av_log(log, AV_LOG_ERROR, "Empty %s list\n", name);
667  return AVERROR(EINVAL);
668  }
669  for (i = 0; i < fmts->nb_formats; i++) {
670  for (j = i + 1; j < fmts->nb_formats; j++) {
671  if (fmts->formats[i] == fmts->formats[j]) {
672  av_log(log, AV_LOG_ERROR, "Duplicated %s\n", name);
673  return AVERROR(EINVAL);
674  }
675  }
676  }
677  return 0;
678 }
679 
680 int ff_formats_check_pixel_formats(void *log, const AVFilterFormats *fmts)
681 {
682  return check_list(log, "pixel format", fmts);
683 }
684 
685 int ff_formats_check_sample_formats(void *log, const AVFilterFormats *fmts)
686 {
687  return check_list(log, "sample format", fmts);
688 }
689 
690 int ff_formats_check_sample_rates(void *log, const AVFilterFormats *fmts)
691 {
692  if (!fmts || !fmts->nb_formats)
693  return 0;
694  return check_list(log, "sample rate", fmts);
695 }
696 
697 static int layouts_compatible(uint64_t a, uint64_t b)
698 {
699  return a == b ||
702 }
703 
705 {
706  unsigned i, j;
707 
708  if (!fmts)
709  return 0;
710  if (fmts->all_layouts < fmts->all_counts) {
711  av_log(log, AV_LOG_ERROR, "Inconsistent generic list\n");
712  return AVERROR(EINVAL);
713  }
714  if (!fmts->all_layouts && !fmts->nb_channel_layouts) {
715  av_log(log, AV_LOG_ERROR, "Empty channel layout list\n");
716  return AVERROR(EINVAL);
717  }
718  for (i = 0; i < fmts->nb_channel_layouts; i++) {
719  for (j = i + 1; j < fmts->nb_channel_layouts; j++) {
720  if (layouts_compatible(fmts->channel_layouts[i], fmts->channel_layouts[j])) {
721  av_log(log, AV_LOG_ERROR, "Duplicated or redundant channel layout\n");
722  return AVERROR(EINVAL);
723  }
724  }
725  }
726  return 0;
727 }
formats
formats
Definition: signature.h:48
AVFilterChannelLayouts
A list of supported channel layouts.
Definition: formats.h:86
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
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:286
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:108
ff_channel_layouts_ref
int ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
Add *ref as a new reference to f.
Definition: formats.c:454
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2541
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:679
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:360
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:429
ff_make_format64_list
AVFilterChannelLayouts * ff_make_format64_list(const int64_t *fmts)
Definition: formats.c:295
pixdesc.h
b
#define b
Definition: input.c:41
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:2548
AVFilterFormats::formats
int * formats
list of media formats
Definition: formats.h:67
merge_samplerates_internal
static int merge_samplerates_internal(AVFilterFormats *a, AVFilterFormats *b, int check)
Definition: formats.c:148
FORMATS_UNREF
#define FORMATS_UNREF(ref, list)
Definition: formats.c:474
FF_LAYOUT2COUNT
#define FF_LAYOUT2COUNT(l)
Decode a channel count encoded as a channel layout.
Definition: formats.h:109
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:65
formats.h
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:129
ff_can_merge_samplerates
int ff_can_merge_samplerates(const AVFilterFormats *a, const AVFilterFormats *b)
Definition: formats.c:157
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_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:338
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
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:580
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:331
AVFilterChannelLayouts::channel_layouts
uint64_t * channel_layouts
list of channel layouts
Definition: formats.h:87
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:459
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:148
ctx
AVFormatContext * ctx
Definition: movenc.c:48
pix_fmt
static enum AVPixelFormat pix_fmt
Definition: demuxing_decoding.c:40
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
ff_can_merge_formats
int ff_can_merge_formats(const AVFilterFormats *a, const AVFilterFormats *b, enum AVMediaType type)
Check the formats/samplerates lists for compatibility for merging without actually merging.
Definition: formats.c:134
f
#define f(width, name)
Definition: cbs_vp9.c:255
arg
const char * arg
Definition: jacosubdec.c:67
ff_formats_changeref
void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
Definition: formats.c:525
NULL
#define NULL
Definition: coverity.c:32
ff_merge_samplerates
int ff_merge_samplerates(AVFilterFormats *a, AVFilterFormats *b)
Definition: formats.c:162
MAKE_FORMAT_LIST
#define MAKE_FORMAT_LIST(type, field, count_field)
Definition: formats.c:268
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:72
SET_COMMON_FORMATS
#define SET_COMMON_FORMATS(ctx, fmts, ref_fn, unref_fn)
Definition: formats.c:530
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:325
AVFilterFormats::nb_formats
unsigned nb_formats
number of formats
Definition: formats.h:66
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:257
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:95
ff_channel_layouts_unref
void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
Remove a reference to a channel layouts list.
Definition: formats.c:501
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:684
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:586
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:637
check_list
static int check_list(void *log, const char *name, const AVFilterFormats *fmts)
Definition: formats.c:658
AVFilterChannelLayouts::all_layouts
char all_layouts
accept any known channel layout
Definition: formats.h:89
AVFilterChannelLayouts::all_counts
char all_counts
accept any channel layout or count
Definition: formats.h:90
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:703
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:2560
ff_all_channel_layouts
AVFilterChannelLayouts * ff_all_channel_layouts(void)
Construct an empty AVFilterChannelLayouts/AVFilterFormats struct – representing any channel layout (w...
Definition: formats.c:420
ADD_FORMAT
#define ADD_FORMAT(f, fmt, unref_fn, type, list, nb)
Definition: formats.c:306
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:496
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:407
FORMATS_REF
#define FORMATS_REF(f, ref, unref_fn)
Definition: formats.c:438
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:689
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:506
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:243
ff_planar_sample_fmts
AVFilterFormats * ff_planar_sample_fmts(void)
Construct a formats list containing all planar sample formats.
Definition: formats.c:401
ret
ret
Definition: filter_design.txt:187
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:103
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2473
ff_all_samplerates
AVFilterFormats * ff_all_samplerates(void)
Definition: formats.c:414
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:133
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:333
layouts_compatible
static int layouts_compatible(uint64_t a, uint64_t b)
Definition: formats.c:696
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:88
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:70
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
ff_parse_sample_rate
int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
Parse a sample rate.
Definition: formats.c:625
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:610
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
ff_merge_channel_layouts
int ff_merge_channel_layouts(AVFilterChannelLayouts *a, AVFilterChannelLayouts *b)
Merge the formats/channel layouts/samplerates lists if they are compatible and update all the referen...
Definition: formats.c:168
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:568
ff_channel_layouts_changeref
void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref, AVFilterChannelLayouts **newref)
Definition: formats.c:519
ff_merge_formats
int ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b, enum AVMediaType type)
Definition: formats.c:141
ff_set_common_channel_layouts
int ff_set_common_channel_layouts(AVFilterContext *ctx, AVFilterChannelLayouts *channel_layouts)
A helper for query_formats() which sets all links to the same list of channel layouts/sample rates.
Definition: formats.c:561
nb_channels
int nb_channels
Definition: channel_layout.c:81