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_array(ret->refs, 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_array(count, sizeof(*ret->fmts)))) \
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->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;
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, nb_formats, 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->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);
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 /* Not optimal: the unknown layouts of b may become known after
191 b->nb_channel_layouts = j;
193 MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
197 ret_max = a->nb_channel_layouts + b->nb_channel_layouts;
198 if (!(ret = av_mallocz(sizeof(*ret))) ||
199 !(ret->channel_layouts = av_malloc_array(ret_max,
200 sizeof(*ret->channel_layouts))))
203 /* a[known] intersect b[known] */
204 for (i = 0; i < a->nb_channel_layouts; i++) {
205 if (!KNOWN(a->channel_layouts[i]))
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;
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))
221 bfmt = FF_COUNT2LAYOUT(av_get_channel_layout_nb_channels(fmt));
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];
226 /* 1st round: swap to prepare 2nd round; 2nd round: put it back */
227 FFSWAP(AVFilterChannelLayouts *, a, b);
229 /* a[generic] intersect b[generic] */
230 for (i = 0; i < a->nb_channel_layouts; i++) {
231 if (KNOWN(a->channel_layouts[i]))
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];
238 ret->nb_channel_layouts = ret_nb;
239 if (!ret->nb_channel_layouts)
241 MERGE_REF(ret, a, channel_layouts, AVFilterChannelLayouts, fail);
242 MERGE_REF(ret, b, channel_layouts, AVFilterChannelLayouts, fail);
247 av_freep(&ret->refs);
248 av_freep(&ret->channel_layouts);
254 int ff_fmt_is_in(int fmt, const int *fmts)
258 for (p = fmts; *p != -1; p++) {
265 #define COPY_INT_LIST(list_copy, list, type) { \
268 for (count = 0; list[count] != -1; count++) \
270 list_copy = av_calloc(count+1, sizeof(type)); \
272 memcpy(list_copy, list, sizeof(type) * count); \
273 list_copy[count] = -1; \
277 #define MAKE_FORMAT_LIST(type, field, count_field) \
281 for (count = 0; fmts[count] != -1; count++) \
283 formats = av_mallocz(sizeof(*formats)); \
286 formats->count_field = count; \
288 formats->field = av_malloc_array(count, sizeof(*formats->field)); \
289 if (!formats->field) { \
290 av_freep(&formats); \
295 AVFilterFormats *ff_make_format_list(const int *fmts)
297 MAKE_FORMAT_LIST(AVFilterFormats, formats, nb_formats);
299 formats->formats[count] = fmts[count];
304 AVFilterChannelLayouts *avfilter_make_format64_list(const int64_t *fmts)
306 MAKE_FORMAT_LIST(AVFilterChannelLayouts,
307 channel_layouts, nb_channel_layouts);
309 memcpy(formats->channel_layouts, fmts,
310 sizeof(*formats->channel_layouts) * count);
315 #define ADD_FORMAT(f, fmt, type, list, nb) \
320 if (!(*f) && !(*f = av_mallocz(sizeof(**f)))) \
321 return AVERROR(ENOMEM); \
323 fmts = av_realloc((*f)->list, \
324 sizeof(*(*f)->list) * ((*f)->nb + 1));\
328 return AVERROR(ENOMEM); \
332 (*f)->list[(*f)->nb++] = fmt; \
335 int ff_add_format(AVFilterFormats **avff, int64_t fmt)
337 ADD_FORMAT(avff, fmt, int, formats, nb_formats);
341 int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
343 av_assert1(!(*l && (*l)->all_layouts));
344 ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
348 AVFilterFormats *ff_all_formats(enum AVMediaType type)
350 AVFilterFormats *ret = NULL;
352 if (type == AVMEDIA_TYPE_VIDEO) {
353 const AVPixFmtDescriptor *desc = NULL;
354 while ((desc = av_pix_fmt_desc_next(desc))) {
355 if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
356 ff_add_format(&ret, av_pix_fmt_desc_get_id(desc));
358 } else if (type == AVMEDIA_TYPE_AUDIO) {
359 enum AVSampleFormat fmt = 0;
360 while (av_get_sample_fmt_name(fmt)) {
361 ff_add_format(&ret, fmt);
369 const int64_t avfilter_all_channel_layouts[] = {
370 #include "all_channel_layouts.inc"
374 // AVFilterFormats *avfilter_make_all_channel_layouts(void)
376 // return avfilter_make_format64_list(avfilter_all_channel_layouts);
379 AVFilterFormats *ff_planar_sample_fmts(void)
381 AVFilterFormats *ret = NULL;
384 for (fmt = 0; av_get_bytes_per_sample(fmt)>0; fmt++)
385 if (av_sample_fmt_is_planar(fmt))
386 ff_add_format(&ret, fmt);
391 AVFilterFormats *ff_all_samplerates(void)
393 AVFilterFormats *ret = av_mallocz(sizeof(*ret));
397 AVFilterChannelLayouts *ff_all_channel_layouts(void)
399 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
402 ret->all_layouts = 1;
406 AVFilterChannelLayouts *ff_all_channel_counts(void)
408 AVFilterChannelLayouts *ret = av_mallocz(sizeof(*ret));
411 ret->all_layouts = ret->all_counts = 1;
415 #define FORMATS_REF(f, ref) \
418 f->refs = av_realloc(f->refs, sizeof(*f->refs) * ++f->refcount); \
421 f->refs[f->refcount-1] = ref; \
424 void ff_channel_layouts_ref(AVFilterChannelLayouts *f, AVFilterChannelLayouts **ref)
429 void ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)
434 #define FIND_REF_INDEX(ref, idx) \
437 for (i = 0; i < (*ref)->refcount; i ++) \
438 if((*ref)->refs[i] == ref) { \
444 #define FORMATS_UNREF(ref, list) \
451 FIND_REF_INDEX(ref, idx); \
454 memmove((*ref)->refs + idx, (*ref)->refs + idx + 1, \
455 sizeof(*(*ref)->refs) * ((*ref)->refcount - idx - 1)); \
457 if(!--(*ref)->refcount) { \
458 av_free((*ref)->list); \
459 av_free((*ref)->refs); \
465 void ff_formats_unref(AVFilterFormats **ref)
467 FORMATS_UNREF(ref, formats);
470 void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
472 FORMATS_UNREF(ref, channel_layouts);
475 #define FORMATS_CHANGEREF(oldref, newref) \
479 FIND_REF_INDEX(oldref, idx); \
482 (*oldref)->refs[idx] = newref; \
488 void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
489 AVFilterChannelLayouts **newref)
491 FORMATS_CHANGEREF(oldref, newref);
494 void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
496 FORMATS_CHANGEREF(oldref, newref);
499 #define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \
503 for (i = 0; i < ctx->nb_inputs; i++) { \
504 if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) { \
505 ref(fmts, &ctx->inputs[i]->out_fmts); \
509 for (i = 0; i < ctx->nb_outputs; i++) { \
510 if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) { \
511 ref(fmts, &ctx->outputs[i]->in_fmts); \
517 av_freep(&fmts->list); \
518 av_freep(&fmts->refs); \
523 void ff_set_common_channel_layouts(AVFilterContext *ctx,
524 AVFilterChannelLayouts *layouts)
526 SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
527 ff_channel_layouts_ref, channel_layouts);
530 void ff_set_common_samplerates(AVFilterContext *ctx,
531 AVFilterFormats *samplerates)
533 SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
534 ff_formats_ref, formats);
538 * A helper for query_formats() which sets all links to the same list of
539 * formats. If there are no links hooked to this filter, the list of formats is
542 void ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
544 SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
545 ff_formats_ref, formats);
548 static int default_query_formats_common(AVFilterContext *ctx,
549 AVFilterChannelLayouts *(layouts)(void))
551 enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
552 ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
555 ff_set_common_formats(ctx, ff_all_formats(type));
556 if (type == AVMEDIA_TYPE_AUDIO) {
557 ff_set_common_channel_layouts(ctx, layouts());
558 ff_set_common_samplerates(ctx, ff_all_samplerates());
564 int ff_default_query_formats(AVFilterContext *ctx)
566 return default_query_formats_common(ctx, ff_all_channel_layouts);
569 int ff_query_formats_all(AVFilterContext *ctx)
571 return default_query_formats_common(ctx, ff_all_channel_counts);
574 /* internal functions for parsing audio format arguments */
576 int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx)
579 int pix_fmt = av_get_pix_fmt(arg);
580 if (pix_fmt == AV_PIX_FMT_NONE) {
581 pix_fmt = strtol(arg, &tail, 0);
582 if (*tail || !av_pix_fmt_desc_get(pix_fmt)) {
583 av_log(log_ctx, AV_LOG_ERROR, "Invalid pixel format '%s'\n", arg);
584 return AVERROR(EINVAL);
591 int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx)
594 int sfmt = av_get_sample_fmt(arg);
595 if (sfmt == AV_SAMPLE_FMT_NONE) {
596 sfmt = strtol(arg, &tail, 0);
597 if (*tail || av_get_bytes_per_sample(sfmt)<=0) {
598 av_log(log_ctx, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
599 return AVERROR(EINVAL);
606 int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx)
609 if(av_parse_ratio(&r, arg, INT_MAX, 0, log_ctx) < 0 ||r.num<=0 ||r.den<=0) {
610 av_log(log_ctx, AV_LOG_ERROR, "Invalid time base '%s'\n", arg);
611 return AVERROR(EINVAL);
617 int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx)
620 double srate = av_strtod(arg, &tail);
621 if (*tail || srate < 1 || (int)srate != srate || srate > INT_MAX) {
622 av_log(log_ctx, AV_LOG_ERROR, "Invalid sample rate '%s'\n", arg);
623 return AVERROR(EINVAL);
629 int ff_parse_channel_layout(int64_t *ret, int *nret, const char *arg,
633 int64_t chlayout, count;
636 count = strtol(arg, &tail, 10);
637 if (*tail == 'c' && !tail[1] && count > 0 && count < 63) {
643 chlayout = av_get_channel_layout(arg);
645 chlayout = strtol(arg, &tail, 10);
646 if (*tail || chlayout == 0) {
647 av_log(log_ctx, AV_LOG_ERROR, "Invalid channel layout '%s'\n", arg);
648 return AVERROR(EINVAL);
653 *nret = av_get_channel_layout_nb_channels(chlayout);
666 for (cl = avfilter_all_channel_layouts; *cl != -1; cl++) {
667 av_get_channel_layout_string(buf, sizeof(buf), -1, *cl);