2 * Filter layer - format negotiation
3 * Copyright (c) 2007 Bobby Bingham
5 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/avassert.h"
23 #include "libavutil/channel_layout.h"
24 #include "libavutil/common.h"
25 #include "libavutil/eval.h"
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/parseutils.h"
32 #define KNOWN(l) (!FF_LAYOUT2COUNT(l)) /* for readability */
35 * Add all refs from a to ret and destroy a.
37 #define MERGE_REF(ret, a, fmts, type, fail) \
42 if (!(tmp = av_realloc(ret->refs, \
43 sizeof(*tmp) * (ret->refcount + a->refcount)))) \
47 for (i = 0; i < a->refcount; i ++) { \
48 ret->refs[ret->refcount] = a->refs[i]; \
49 *ret->refs[ret->refcount++] = ret; \
58 * Add all formats common for a and b to ret, copy the refs and destroy
61 #define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail) \
63 int i, j, k = 0, count = FFMIN(a->nb, b->nb); \
65 if (!(ret = av_mallocz(sizeof(*ret)))) \
69 if (!(ret->fmts = av_malloc(sizeof(*ret->fmts) * count))) \
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"); \
80 ret->fmts[k++] = a->fmts[i]; \
84 /* check that there was at least one common format */ \
88 MERGE_REF(ret, a, fmts, type, fail); \
89 MERGE_REF(ret, b, fmts, type, fail); \
92 AVFilterFormats *ff_merge_formats(AVFilterFormats *a, AVFilterFormats *b,
93 enum AVMediaType type)
95 AVFilterFormats *ret = NULL;
97 int alpha1=0, alpha2=0;
98 int chroma1=0, chroma2=0;
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->format_count; i++)
112 for (j = 0; j < b->format_count; 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 & PIX_FMT_ALPHA;
116 chroma2|= adesc->nb_components > 1 && bdesc->nb_components > 1;
117 if (a->formats[i] == b->formats[j]) {
118 alpha1 |= adesc->flags & PIX_FMT_ALPHA;
119 chroma1|= adesc->nb_components > 1;
123 // If chroma or alpha can be lost through merging then do not merge
124 if (alpha2 > alpha1 || chroma2 > chroma1)
127 MERGE_FORMATS(ret, a, b, formats, format_count, AVFilterFormats, fail);
132 av_freep(&ret->refs);
133 av_freep(&ret->formats);
139 AVFilterFormats *ff_merge_samplerates(AVFilterFormats *a,
142 AVFilterFormats *ret = NULL;
144 if (a == b) return a;
146 if (a->format_count && b->format_count) {
147 MERGE_FORMATS(ret, a, b, formats, format_count, AVFilterFormats, fail);
148 } else if (a->format_count) {
149 MERGE_REF(a, b, formats, AVFilterFormats, fail);
152 MERGE_REF(b, a, formats, AVFilterFormats, fail);
159 av_freep(&ret->refs);
160 av_freep(&ret->formats);
166 AVFilterChannelLayouts *ff_merge_channel_layouts(AVFilterChannelLayouts *a,
167 AVFilterChannelLayouts *b)
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;
174 if (a == b) return a;
176 /* Put the most generic set in a, to avoid doing everything twice */
178 FFSWAP(AVFilterChannelLayouts *, a, b);
179 FFSWAP(unsigned, a_all, b_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 b->nb_channel_layouts = j;
189 MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
193 ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
194 if (!(ret = av_mallocz(sizeof(*ret))) ||
195 !(ret->channel_layouts = av_malloc(sizeof(*ret->channel_layouts) *
199 /* a[known] intersect b[known] */
200 for (i = 0; i < a->nb_channel_layouts; i++) {
201 if (!KNOWN(a->channel_layouts[i]))
203 for (j = 0; j < b->nb_channel_layouts; j++) {
204 if (a->channel_layouts[i] == b->channel_layouts[j]) {
205 ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
206 a->channel_layouts[i] = b->channel_layouts[j] = 0;
210 /* 1st round: a[known] intersect b[generic]
211 2nd round: a[generic] intersect b[known] */
212 for (round = 0; round < 2; round++) {
213 for (i = 0; i < a->nb_channel_layouts; i++) {
214 uint64_t fmt = a->channel_layouts[i], bfmt;
215 if (!fmt || !KNOWN(fmt))
217 bfmt = FF_COUNT2LAYOUT(av_get_channel_layout_nb_channels(fmt));
218 for (j = 0; j < b->nb_channel_layouts; j++)
219 if (b->channel_layouts[j] == bfmt)
220 ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
222 /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
223 FFSWAP(AVFilterChannelLayouts *, a, b);
225 /* a[generic] intersect b[generic] */
226 for (i = 0; i < a->nb_channel_layouts; i++) {
227 if (KNOWN(a->channel_layouts[i]))
229 for (j = 0; j < b->nb_channel_layouts; j++)
230 if (a->channel_layouts[i] == b->channel_layouts[j])
231 ret->channel_layouts[ret_nb++] = a->channel_layouts[i];
234 ret->nb_channel_layouts = ret_nb;
235 if (!ret->nb_channel_layouts)
237 MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);
238 MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, fail);
243 av_freep(&ret->refs);
244 av_freep(&ret->channel_layouts);
250 int ff_fmt_is_in(int fmt, const int *fmts)
254 for (p = fmts; *p != -1; p++) {
261 #define COPY_INT_LIST(list_copy, list, type) { \
264 for (count = 0; list[count] != -1; count++) \
266 list_copy = av_calloc(count+1, sizeof(type)); \
268 memcpy(list_copy, list, sizeof(type) * count); \
269 list_copy[count] = -1; \
273 int *ff_copy_int_list(const int * const list)
276 COPY_INT_LIST(ret, list, int);
280 int64_t *ff_copy_int64_list(const int64_t * const list)
283 COPY_INT_LIST(ret, list, int64_t);
287 #define MAKE_FORMAT_LIST(type, field, count_field) \
291 for (count = 0; fmts[count] != -1; count++) \
293 formats = av_mallocz(sizeof(*formats)); \
294 if (!formats) return NULL; \
295 formats->count_field = count; \
297 formats->field = av_malloc(sizeof(*formats->field)*count); \
298 if (!formats->field) { \
304 AVFilterFormats *ff_make_format_list(const int *fmts)
306 MAKE_FORMAT_LIST(AVFilterFormats, formats, format_count);
308 formats->formats[count] = fmts[count];
313 AVFilterChannelLayouts *avfilter_make_format64_list(const int64_t *fmts)
315 MAKE_FORMAT_LIST(AVFilterChannelLayouts,
316 channel_layouts, nb_channel_layouts);
318 memcpy(formats->channel_layouts, fmts,
319 sizeof(*formats->channel_layouts) * count);
324 #define ADD_FORMAT(f, fmt, type, list, nb) \
328 if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) \
329 return AVERROR(ENOMEM); \
331 fmts = av_realloc((*f)->list, \
332 sizeof(*(*f)->list) * ((*f)->nb + 1));\
334 return AVERROR(ENOMEM); \
337 (*f)->list[(*f)->nb++] = fmt; \
340 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
342 ADD_FORMAT(avff, fmt, int, formats, format_count);
346 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
348 av_assert1(!(*l && (*l)->all_layouts));
349 ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
353 AVFilterFormats *ff_all_formats(enum AVMediaType type)
355 AVFilterFormats *ret = NULL;
357 int num_formats = type == AVMEDIA_TYPE_VIDEO ? AV_PIX_FMT_NB :
358 type == AVMEDIA_TYPE_AUDIO ? AV_SAMPLE_FMT_NB : 0;
360 for (fmt = 0; fmt < num_formats; fmt++) {
361 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(fmt);
362 if ((type != AVMEDIA_TYPE_VIDEO) ||
363 (type == AVMEDIA_TYPE_VIDEO && !(desc->flags & PIX_FMT_HWACCEL)))
364 ff_add_format(&ret, fmt);
370 const int64_t avfilter_all_channel_layouts[] = {
371 #include "all_channel_layouts.inc"
375 // AVFilterFormats *avfilter_make_all_channel_layouts(void)
377 // return avfilter_make_format64_list(avfilter_all_channel_layouts);
380 AVFilterFormats *ff_planar_sample_fmts(void)
382 AVFilterFormats *ret = NULL;
385 for (fmt = 0; fmt < AV_SAMPLE_FMT_NB; fmt++)
386 if (av_sample_fmt_is_planar(fmt))
387 ff_add_format(&ret, fmt);
392 AVFilterFormats *ff_all_samplerates(void)
394 AVFilterFormats *ret = av_mallocz(sizeof(*ret));
398 AVFilterChannelLayouts *ff_all_channel_layouts(void)
400 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
403 ret->all_layouts = 1;
407 AVFilterChannelLayouts *ff_all_channel_counts(void)
409 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
412 ret->all_layouts = ret->all_counts = 1;
416 #define FORMATS_REF(f, ref) \
419 f->refs = av_realloc(f->refs, sizeof(*f->refs) * ++f->refcount); \
420 f->refs[f->refcount-1] = ref; \
423 void ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
428 void ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
433 #define FIND_REF_INDEX(ref, idx) \
436 for (i = 0; i < (*ref)->refcount; i ++) \
437 if((*ref)->refs[i] == ref) { \
443 #define FORMATS_UNREF(ref, list) \
450 FIND_REF_INDEX(ref, idx); \
453 memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
454 sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
456 if(!--(*ref)->refcount) { \
457 av_free((*ref)->list); \
458 av_free((*ref)->refs); \
464 void ff_formats_unref(AVFilterFormats **ref)
466 FORMATS_UNREF(ref, formats);
469 void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
471 FORMATS_UNREF(ref, channel_layouts);
474 #define FORMATS_CHANGEREF(oldref, newref) \
478 FIND_REF_INDEX(oldref, idx); \
481 (*oldref)->refs[idx] = newref; \
487 void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
488 AVFilterChannelLayouts **newref)
490 FORMATS_CHANGEREF(oldref, newref);
493 void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
495 FORMATS_CHANGEREF(oldref, newref);
498 #define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \
502 for (i = 0; i < ctx->nb_inputs; i++) { \
503 if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
504 ref(fmts, &ctx->inputs[i]->out_fmts); \
508 for (i = 0; i < ctx->nb_outputs; i++) { \
509 if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
510 ref(fmts, &ctx->outputs[i]->in_fmts); \
516 av_freep(&fmts->list); \
517 av_freep(&fmts->refs); \
522 void ff_set_common_channel_layouts(AVFilterContext *ctx,
523 AVFilterChannelLayouts *layouts)
525 SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
526 ff_channel_layouts_ref, channel_layouts);
529 void ff_set_common_samplerates(AVFilterContext *ctx,
530 AVFilterFormats *samplerates)
532 SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
533 ff_formats_ref, formats);
537 * A helper for query_formats() which sets all links to the same list of
538 * formats. If there are no links hooked to this filter, the list of formats is
541 void ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
543 SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
544 ff_formats_ref, formats);
547 static int default_query_formats_common(AVFilterContext *ctx,
548 AVFilterChannelLayouts *(layouts)(void))
550 enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
551 ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
554 ff_set_common_formats(ctx, ff_all_formats(type));
555 if (type == AVMEDIA_TYPE_AUDIO) {
556 ff_set_common_channel_layouts(ctx, layouts());
557 ff_set_common_samplerates(ctx, ff_all_samplerates());
563 int ff_default_query_formats(AVFilterContext *ctx)
565 return default_query_formats_common(ctx, ff_all_channel_layouts);
568 int ff_query_formats_all(AVFilterContext *ctx)
570 return default_query_formats_common(ctx, ff_all_channel_counts);
573 /* internal functions for parsing audio format arguments */
575 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
578 int pix_fmt = av_get_pix_fmt(arg);
579 if (pix_fmt == AV_PIX_FMT_NONE) {
580 pix_fmt = strtol(arg, &tail, 0);
581 if (*tail || (unsigned)pix_fmt >= AV_PIX_FMT_NB) {
582 av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
583 return AVERROR(EINVAL);
590 int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
593 int sfmt = av_get_sample_fmt(arg);
594 if (sfmt == AV_SAMPLE_FMT_NONE) {
595 sfmt = strtol(arg, &tail, 0);
596 if (*tail || (unsigned)sfmt >= AV_SAMPLE_FMT_NB) {
597 av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
598 return AVERROR(EINVAL);
605 int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
608 if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0 ||r.den<=0) {
609 av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
610 return AVERROR(EINVAL);
616 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
619 double srate = av_strtod(arg, &tail);
620 if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
621 av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
622 return AVERROR(EINVAL);
628 int ff_parse_channel_layout(int64_t *ret, const char *arg, void *log_ctx)
631 int64_t chlayout = av_get_channel_layout(arg);
633 chlayout = strtol(arg, &tail, 10);
634 if (*tail || chlayout == 0) {
635 av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
636 return AVERROR(EINVAL);
652 for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
653 av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);