FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
formats.c
Go to the documentation of this file.
1 /*
2  * Filter layer - format negotiation
3  * Copyright (c) 2007 Bobby Bingham
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
24 #include "libavutil/common.h"
25 #include "libavutil/eval.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/parseutils.h"
28 #include "avfilter.h"
29 #include "internal.h"
30 #include "formats.h"
31 
32 #define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */
33 
34 /**
35  * Add all refs from a to ret and destroy a.
36  */
37 #define MERGE_REF(ret, a, fmts, type, fail) \
38 do { \
39  type ***tmp; \
40  int i; \
41  \
42  if (!(tmp = av_realloc(ret->refs, \
43  sizeof(*tmp) * (ret->refcount + a->refcount)))) \
44  goto fail; \
45  ret->refs = tmp; \
46  \
47  for (i = 0; i < a->refcount; i ++) { \
48  ret->refs[ret->refcount] = a->refs[i]; \
49  *ret->refs[ret->refcount++] = ret; \
50  } \
51  \
52  av_freep(&a->refs); \
53  av_freep(&a->fmts); \
54  av_freep(&a); \
55 } while (0)
56 
57 /**
58  * Add all formats common for a and b to ret, copy the refs and destroy
59  * a and b.
60  */
61 #define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail) \
62 do { \
63  int i, j, k = 0, count = FFMIN(a->nb, b->nb); \
64  \
65  if (!(ret = av_mallocz(sizeof(*ret)))) \
66  goto fail; \
67  \
68  if (count) { \
69  if (!(ret->fmts = av_malloc(sizeof(*ret->fmts) * count))) \
70  goto fail; \
71  for (i = 0; i < a->nb; i++) \
72  for (j = 0; j < b->nb; j++) \
73  if (a->fmts[i] == b->fmts[j]) { \
74  if(k >= FFMIN(a->nb, b->nb)){ \
75  av_log(NULL, AV_LOG_ERROR, "Duplicate formats in avfilter_merge_formats() detected\n"); \
76  av_free(ret->fmts); \
77  av_free(ret); \
78  return NULL; \
79  } \
80  ret->fmts[k++] = a->fmts[i]; \
81  } \
82  } \
83  ret->nb = k; \
84  /* check that there was at least one common format */ \
85  if (!ret->nb) \
86  goto fail; \
87  \
88  MERGE_REF(ret, a, fmts, type, fail); \
89  MERGE_REF(ret, b, fmts, type, fail); \
90 } while (0)
91 
93  enum AVMediaType type)
94 {
95  AVFilterFormats *ret = NULL;
96  int i, j;
97  int alpha1=0, alpha2=0;
98  int chroma1=0, chroma2=0;
99 
100  if (a == b)
101  return a;
102 
103  /* Do not lose chroma or alpha in merging.
104  It happens if both lists have formats with chroma (resp. alpha), but
105  the only formats in common do not have it (e.g. YUV+gray vs.
106  RGB+gray): in that case, the merging would select the gray format,
107  possibly causing a lossy conversion elsewhere in the graph.
108  To avoid that, pretend that there are no common formats to force the
109  insertion of a conversion filter. */
110  if (type == AVMEDIA_TYPE_VIDEO)
111  for (i = 0; i < a->nb_formats; i++)
112  for (j = 0; j < b->nb_formats; j++) {
113  const AVPixFmtDescriptor *adesc = av_pix_fmt_desc_get(a->formats[i]);
114  const AVPixFmtDescriptor *bdesc = av_pix_fmt_desc_get(b->formats[j]);
115  alpha2 |= adesc->flags & bdesc->flags & AV_PIX_FMT_FLAG_ALPHA;
116  chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
117  if (a->formats[i] == b->formats[j]) {
118  alpha1 |= adesc->flags & AV_PIX_FMT_FLAG_ALPHA;
119  chroma1|= adesc->nb_components > 1;
120  }
121  }
122 
123  // If chroma or alpha can be lost through merging then do not merge
124  if (alpha2 > alpha1 || chroma2 > chroma1)
125  return NULL;
126 
127  MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
128 
129  return ret;
130 fail:
131  if (ret) {
132  av_freep(&ret->refs);
133  av_freep(&ret->formats);
134  }
135  av_freep(&ret);
136  return NULL;
137 }
138 
141 {
142  AVFilterFormats *ret = NULL;
143 
144  if (a == b) return a;
145 
146  if (a->nb_formats && b->nb_formats) {
147  MERGE_FORMATS(ret, a, b, formats, nb_formats, AVFilterFormats, fail);
148  } else if (a->nb_formats) {
149  MERGE_REF(a, b, formats, AVFilterFormats, fail);
150  ret = a;
151  } else {
152  MERGE_REF(b, a, formats, AVFilterFormats, fail);
153  ret = b;
154  }
155 
156  return ret;
157 fail:
158  if (ret) {
159  av_freep(&ret->refs);
160  av_freep(&ret->formats);
161  }
162  av_freep(&ret);
163  return NULL;
164 }
165 
168 {
169  AVFilterChannelLayouts *ret = NULL;
170  unsigned a_all = a->all_layouts + a->all_counts;
171  unsigned b_all = b->all_layouts + b->all_counts;
172  int ret_max, ret_nb = 0, i, j, round;
173 
174  if (a == b) return a;
175 
176  /* Put the most generic set in a, to avoid doing everything twice */
177  if (a_all < b_all) {
179  FFSWAP(unsigned, a_all, b_all);
180  }
181  if (a_all) {
182  if (a_all == 1 && !b_all) {
183  /* keep only known layouts in b; works also for b_all = 1 */
184  for (i = j = 0; i < b->nb_channel_layouts; i++)
185  if (KNOWN(b->channel_layouts[i]))
186  b->channel_layouts[j++] = b->channel_layouts[i];
187  /* Not optimal: the unknown layouts of b may become known after
188  another merge. */
189  if (!j)
190  return NULL;
191  b->nb_channel_layouts = j;
192  }
193  MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
194  return b;
195  }
196 
197  ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
198  if (!(ret = av_mallocz(sizeof(*ret))) ||
199  !(ret->channel_layouts = av_malloc(sizeof(*ret->channel_layouts) *
200  ret_max)))
201  goto fail;
202 
203  /* a[known] intersect b[known] */
204  for (i = 0; i < a->nb_channel_layouts; i++) {
205  if (!KNOWN(a->channel_layouts[i]))
206  continue;
207  for (j = 0; j < b->nb_channel_layouts; j++) {
208  if (a->channel_layouts[i] == b->channel_layouts[j]) {
209  ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
210  a->channel_layouts[i] = b->channel_layouts[j] = 0;
211  }
212  }
213  }
214  /* 1st round: a[known] intersect b[generic]
215  2nd round: a[generic] intersect b[known] */
216  for (round = 0; round < 2; round++) {
217  for (i = 0; i < a->nb_channel_layouts; i++) {
218  uint64_t fmt = a->channel_layouts[i], bfmt;
219  if (!fmt || !KNOWN(fmt))
220  continue;
222  for (j = 0; j < b->nb_channel_layouts; j++)
223  if (b->channel_layouts[j] == bfmt)
224  ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
225  }
226  /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
228  }
229  /* a[generic] intersect b[generic] */
230  for (i = 0; i < a->nb_channel_layouts; i++) {
231  if (KNOWN(a->channel_layouts[i]))
232  continue;
233  for (j = 0; j < b->nb_channel_layouts; j++)
234  if (a->channel_layouts[i] == b->channel_layouts[j])
235  ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
236  }
237 
238  ret->nb_channel_layouts = ret_nb;
239  if (!ret->nb_channel_layouts)
240  goto fail;
241  MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);
242  MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, fail);
243  return ret;
244 
245 fail:
246  if (ret) {
247  av_freep(&ret->refs);
248  av_freep(&ret->channel_layouts);
249  }
250  av_freep(&ret);
251  return NULL;
252 }
253 
254 int ff_fmt_is_in(int fmt, const int *fmts)
255 {
256  const int *p;
257 
258  for (p = fmts; *p != -1; p++) {
259  if (fmt == *p)
260  return 1;
261  }
262  return 0;
263 }
264 
265 #define COPY_INT_LIST(list_copy, list, type) { \
266  int count = 0; \
267  if (list) \
268  for (count = 0; list[count] != -1; count++) \
269  ; \
270  list_copy = av_calloc(count+1, sizeof(type)); \
271  if (list_copy) { \
272  memcpy(list_copy, list, sizeof(type) * count); \
273  list_copy[count] = -1; \
274  } \
275 }
276 
277 int *ff_copy_int_list(const int * const list)
278 {
279  int *ret = NULL;
280  COPY_INT_LIST(ret, list, int);
281  return ret;
282 }
283 
284 int64_t *ff_copy_int64_list(const int64_t * const list)
285 {
286  int64_t *ret = NULL;
287  COPY_INT_LIST(ret, list, int64_t);
288  return ret;
289 }
290 
291 #define MAKE_FORMAT_LIST(type, field, count_field) \
292  type *formats; \
293  int count = 0; \
294  if (fmts) \
295  for (count = 0; fmts[count] != -1; count++) \
296  ; \
297  formats = av_mallocz(sizeof(*formats)); \
298  if (!formats) return NULL; \
299  formats->count_field = count; \
300  if (count) { \
301  formats->field = av_malloc(sizeof(*formats->field)*count); \
302  if (!formats->field) { \
303  av_free(formats); \
304  return NULL; \
305  } \
306  }
307 
309 {
311  while (count--)
312  formats->formats[count] = fmts[count];
313 
314  return formats;
315 }
316 
318 {
320  channel_layouts, nb_channel_layouts);
321  if (count)
322  memcpy(formats->channel_layouts, fmts,
323  sizeof(*formats->channel_layouts) * count);
324 
325  return formats;
326 }
327 
328 #define ADD_FORMAT(f, fmt, type, list, nb) \
329 do { \
330  type *fmts; \
331  \
332  if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) \
333  return AVERROR(ENOMEM); \
334  \
335  fmts = av_realloc((*f)->list, \
336  sizeof(*(*f)->list) * ((*f)->nb + 1));\
337  if (!fmts) \
338  return AVERROR(ENOMEM); \
339  \
340  (*f)->list = fmts; \
341  (*f)->list[(*f)->nb++] = fmt; \
342 } while (0)
343 
344 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
345 {
346  ADD_FORMAT(avff, fmt, int, formats, nb_formats);
347  return 0;
348 }
349 
350 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
351 {
352  av_assert1(!(*l && (*l)->all_layouts));
353  ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
354  return 0;
355 }
356 
358 {
359  AVFilterFormats *ret = NULL;
360  int fmt;
361  int num_formats = type == AVMEDIA_TYPE_VIDEO ? AV_PIX_FMT_NB :
362  type == AVMEDIA_TYPE_AUDIO ? AV_SAMPLE_FMT_NB : 0;
363 
364  for (fmt = 0; fmt < num_formats; fmt++) {
365  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
366  if ((type != AVMEDIA_TYPE_VIDEO) ||
367  (type == AVMEDIA_TYPE_VIDEO && !(desc->flags & AV_PIX_FMT_FLAG_HWACCEL)))
368  ff_add_format(&ret, fmt);
369  }
370 
371  return ret;
372 }
373 
374 const int64_t avfilter_all_channel_layouts[] = {
375 #include "all_channel_layouts.inc"
376  -1
377 };
378 
379 // AVFilterFormats *avfilter_make_all_channel_layouts(void)
380 // {
381 // return avfilter_make_format64_list(avfilter_all_channel_layouts);
382 // }
383 
385 {
386  AVFilterFormats *ret = NULL;
387  int fmt;
388 
389  for (fmt = 0; fmt < AV_SAMPLE_FMT_NB; fmt++)
390  if (av_sample_fmt_is_planar(fmt))
391  ff_add_format(&ret, fmt);
392 
393  return ret;
394 }
395 
397 {
398  AVFilterFormats *ret = av_mallocz(sizeof(*ret));
399  return ret;
400 }
401 
403 {
404  AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
405  if (!ret)
406  return NULL;
407  ret->all_layouts = 1;
408  return ret;
409 }
410 
412 {
413  AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
414  if (!ret)
415  return NULL;
416  ret->all_layouts = ret->all_counts = 1;
417  return ret;
418 }
419 
420 #define FORMATS_REF(f, ref) \
421 do { \
422  *ref = f; \
423  f->refs = av_realloc(f->refs, sizeof(*f->refs) * ++f->refcount); \
424  f->refs[f->refcount-1] = ref; \
425 } while (0)
426 
428 {
429  FORMATS_REF(f, ref);
430 }
431 
433 {
434  FORMATS_REF(f, ref);
435 }
436 
437 #define FIND_REF_INDEX(ref, idx) \
438 do { \
439  int i; \
440  for (i = 0; i < (*ref)->refcount; i ++) \
441  if((*ref)->refs[i] == ref) { \
442  idx = i; \
443  break; \
444  } \
445 } while (0)
446 
447 #define FORMATS_UNREF(ref, list) \
448 do { \
449  int idx = -1; \
450  \
451  if (!*ref) \
452  return; \
453  \
454  FIND_REF_INDEX(ref, idx); \
455  \
456  if (idx >= 0) \
457  memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
458  sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
459  \
460  if(!--(*ref)->refcount) { \
461  av_free((*ref)->list); \
462  av_free((*ref)->refs); \
463  av_free(*ref); \
464  } \
465  *ref = NULL; \
466 } while (0)
467 
469 {
470  FORMATS_UNREF(ref, formats);
471 }
472 
474 {
475  FORMATS_UNREF(ref, channel_layouts);
476 }
477 
478 #define FORMATS_CHANGEREF(oldref, newref) \
479 do { \
480  int idx = -1; \
481  \
482  FIND_REF_INDEX(oldref, idx); \
483  \
484  if (idx >= 0) { \
485  (*oldref)->refs[idx] = newref; \
486  *newref = *oldref; \
487  *oldref = NULL; \
488  } \
489 } while (0)
490 
492  AVFilterChannelLayouts **newref)
493 {
494  FORMATS_CHANGEREF(oldref, newref);
495 }
496 
498 {
499  FORMATS_CHANGEREF(oldref, newref);
500 }
501 
502 #define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \
503 { \
504  int count = 0, i; \
505  \
506  for (i = 0; i < ctx->nb_inputs; i++) { \
507  if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
508  ref(fmts, &ctx->inputs[i]->out_fmts); \
509  count++; \
510  } \
511  } \
512  for (i = 0; i < ctx->nb_outputs; i++) { \
513  if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
514  ref(fmts, &ctx->outputs[i]->in_fmts); \
515  count++; \
516  } \
517  } \
518  \
519  if (!count) { \
520  av_freep(&fmts->list); \
521  av_freep(&fmts->refs); \
522  av_freep(&fmts); \
523  } \
524 }
525 
528 {
529  SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
530  ff_channel_layouts_ref, channel_layouts);
531 }
532 
534  AVFilterFormats *samplerates)
535 {
536  SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
538 }
539 
540 /**
541  * A helper for query_formats() which sets all links to the same list of
542  * formats. If there are no links hooked to this filter, the list of formats is
543  * freed.
544  */
546 {
547  SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
548  ff_formats_ref, formats);
549 }
550 
553 {
554  enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
555  ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
557 
559  if (type == AVMEDIA_TYPE_AUDIO) {
562  }
563 
564  return 0;
565 }
566 
568 {
570 }
571 
573 {
575 }
576 
577 /* internal functions for parsing audio format arguments */
578 
579 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
580 {
581  char *tail;
582  int pix_fmt = av_get_pix_fmt(arg);
583  if (pix_fmt == AV_PIX_FMT_NONE) {
584  pix_fmt = strtol(arg, &tail, 0);
585  if (*tail || (unsigned)pix_fmt >= AV_PIX_FMT_NB) {
586  av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
587  return AVERROR(EINVAL);
588  }
589  }
590  *ret = pix_fmt;
591  return 0;
592 }
593 
594 int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
595 {
596  char *tail;
597  int sfmt = av_get_sample_fmt(arg);
598  if (sfmt == AV_SAMPLE_FMT_NONE) {
599  sfmt = strtol(arg, &tail, 0);
600  if (*tail || (unsigned)sfmt >= AV_SAMPLE_FMT_NB) {
601  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
602  return AVERROR(EINVAL);
603  }
604  }
605  *ret = sfmt;
606  return 0;
607 }
608 
609 int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
610 {
611  AVRational r;
612  if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0 ||r.den<=0) {
613  av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
614  return AVERROR(EINVAL);
615  }
616  *ret = r;
617  return 0;
618 }
619 
620 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
621 {
622  char *tail;
623  double srate = av_strtod(arg, &tail);
624  if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
625  av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
626  return AVERROR(EINVAL);
627  }
628  *ret = srate;
629  return 0;
630 }
631 
632 int ff_parse_channel_layout(int64_t *ret, const char *arg, void *log_ctx)
633 {
634  char *tail;
635  int64_t chlayout = av_get_channel_layout(arg);
636  if (chlayout == 0) {
637  chlayout = strtol(arg, &tail, 10);
638  if (*tail || chlayout == 0) {
639  av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
640  return AVERROR(EINVAL);
641  }
642  }
643  *ret = chlayout;
644  return 0;
645 }
646 
647 #ifdef TEST
648 
649 #undef printf
650 
651 int main(void)
652 {
653  const int64_t *cl;
654  char buf[512];
655 
656  for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
657  av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);
658  printf("%s\n", buf);
659  }
660 
661  return 0;
662 }
663 
664 #endif
665