3 * Copyright (c) 2008 Vitor Sessak
4 * Copyright (c) 2007 Bobby Bingham
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavutil/avassert.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/bprint.h"
30 #include "libavutil/channel_layout.h"
31 #include "libavutil/internal.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/pixdesc.h"
40 #define OFFSET(x) offsetof(AVFilterGraph, x)
41 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
42 static const AVOption filtergraph_options
[] = {
43 { "thread_type", "Allowed thread types", OFFSET(thread_type
), AV_OPT_TYPE_FLAGS
,
44 { .i64
= AVFILTER_THREAD_SLICE
}, 0, INT_MAX
, FLAGS
, "thread_type" },
45 { "slice", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= AVFILTER_THREAD_SLICE
}, .flags
= FLAGS
, .unit
= "thread_type" },
46 { "threads", "Maximum number of threads", OFFSET(nb_threads
),
47 AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, INT_MAX
, FLAGS
},
48 {"scale_sws_opts" , "default scale filter options" , OFFSET(scale_sws_opts
) ,
49 AV_OPT_TYPE_STRING
, {.str
= NULL
}, 0, 0, FLAGS
},
50 {"aresample_swr_opts" , "default aresample filter options" , OFFSET(aresample_swr_opts
) ,
51 AV_OPT_TYPE_STRING
, {.str
= NULL
}, 0, 0, FLAGS
},
55 static const AVClass filtergraph_class
= {
56 .class_name
= "AVFilterGraph",
57 .item_name
= av_default_item_name
,
58 .version
= LIBAVUTIL_VERSION_INT
,
59 .option
= filtergraph_options
,
60 .category
= AV_CLASS_CATEGORY_FILTER
,
64 void ff_graph_thread_free(AVFilterGraph
*graph
)
68 int ff_graph_thread_init(AVFilterGraph
*graph
)
70 graph
->thread_type
= 0;
71 graph
->nb_threads
= 1;
76 AVFilterGraph
*avfilter_graph_alloc(void)
78 AVFilterGraph
*ret
= av_mallocz(sizeof(*ret
));
82 ret
->internal
= av_mallocz(sizeof(*ret
->internal
));
88 ret
->av_class
= &filtergraph_class
;
89 av_opt_set_defaults(ret
);
94 void ff_filter_graph_remove_filter(AVFilterGraph
*graph
, AVFilterContext
*filter
)
97 for (i
= 0; i
< graph
->nb_filters
; i
++) {
98 if (graph
->filters
[i
] == filter
) {
99 FFSWAP(AVFilterContext
*, graph
->filters
[i
],
100 graph
->filters
[graph
->nb_filters
- 1]);
107 void avfilter_graph_free(AVFilterGraph
**graph
)
112 while ((*graph
)->nb_filters
)
113 avfilter_free((*graph
)->filters
[0]);
115 ff_graph_thread_free(*graph
);
117 av_freep(&(*graph
)->sink_links
);
119 av_freep(&(*graph
)->scale_sws_opts
);
120 av_freep(&(*graph
)->aresample_swr_opts
);
121 av_freep(&(*graph
)->resample_lavr_opts
);
122 av_freep(&(*graph
)->filters
);
123 av_freep(&(*graph
)->internal
);
127 #if FF_API_AVFILTER_OPEN
128 int avfilter_graph_add_filter(AVFilterGraph
*graph
, AVFilterContext
*filter
)
130 AVFilterContext
**filters
= av_realloc(graph
->filters
,
131 sizeof(*filters
) * (graph
->nb_filters
+ 1));
133 return AVERROR(ENOMEM
);
135 graph
->filters
= filters
;
136 graph
->filters
[graph
->nb_filters
++] = filter
;
139 FF_DISABLE_DEPRECATION_WARNINGS
140 graph
->filter_count_unused
= graph
->nb_filters
;
141 FF_ENABLE_DEPRECATION_WARNINGS
144 filter
->graph
= graph
;
150 int avfilter_graph_create_filter(AVFilterContext
**filt_ctx
, const AVFilter
*filt
,
151 const char *name
, const char *args
, void *opaque
,
152 AVFilterGraph
*graph_ctx
)
156 *filt_ctx
= avfilter_graph_alloc_filter(graph_ctx
, filt
, name
);
158 return AVERROR(ENOMEM
);
160 ret
= avfilter_init_str(*filt_ctx
, args
);
168 avfilter_free(*filt_ctx
);
173 void avfilter_graph_set_auto_convert(AVFilterGraph
*graph
, unsigned flags
)
175 graph
->disable_auto_convert
= flags
;
178 AVFilterContext
*avfilter_graph_alloc_filter(AVFilterGraph
*graph
,
179 const AVFilter
*filter
,
182 AVFilterContext
**filters
, *s
;
184 if (graph
->thread_type
&& !graph
->internal
->thread_execute
) {
185 if (graph
->execute
) {
186 graph
->internal
->thread_execute
= graph
->execute
;
188 int ret
= ff_graph_thread_init(graph
);
190 av_log(graph
, AV_LOG_ERROR
, "Error initializing threading.\n");
196 s
= ff_filter_alloc(filter
, name
);
200 filters
= av_realloc(graph
->filters
, sizeof(*filters
) * (graph
->nb_filters
+ 1));
206 graph
->filters
= filters
;
207 graph
->filters
[graph
->nb_filters
++] = s
;
210 FF_DISABLE_DEPRECATION_WARNINGS
211 graph
->filter_count_unused
= graph
->nb_filters
;
212 FF_ENABLE_DEPRECATION_WARNINGS
221 * Check for the validity of graph.
223 * A graph is considered valid if all its input and output pads are
226 * @return >= 0 in case of success, a negative value otherwise
228 static int graph_check_validity(AVFilterGraph
*graph
, AVClass
*log_ctx
)
230 AVFilterContext
*filt
;
233 for (i
= 0; i
< graph
->nb_filters
; i
++) {
234 const AVFilterPad
*pad
;
235 filt
= graph
->filters
[i
];
237 for (j
= 0; j
< filt
->nb_inputs
; j
++) {
238 if (!filt
->inputs
[j
] || !filt
->inputs
[j
]->src
) {
239 pad
= &filt
->input_pads
[j
];
240 av_log(log_ctx
, AV_LOG_ERROR
,
241 "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
242 pad
->name
, av_get_media_type_string(pad
->type
), filt
->name
, filt
->filter
->name
);
243 return AVERROR(EINVAL
);
247 for (j
= 0; j
< filt
->nb_outputs
; j
++) {
248 if (!filt
->outputs
[j
] || !filt
->outputs
[j
]->dst
) {
249 pad
= &filt
->output_pads
[j
];
250 av_log(log_ctx
, AV_LOG_ERROR
,
251 "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
252 pad
->name
, av_get_media_type_string(pad
->type
), filt
->name
, filt
->filter
->name
);
253 return AVERROR(EINVAL
);
262 * Configure all the links of graphctx.
264 * @return >= 0 in case of success, a negative value otherwise
266 static int graph_config_links(AVFilterGraph
*graph
, AVClass
*log_ctx
)
268 AVFilterContext
*filt
;
271 for (i
= 0; i
< graph
->nb_filters
; i
++) {
272 filt
= graph
->filters
[i
];
274 if (!filt
->nb_outputs
) {
275 if ((ret
= avfilter_config_links(filt
)))
283 AVFilterContext
*avfilter_graph_get_filter(AVFilterGraph
*graph
, const char *name
)
287 for (i
= 0; i
< graph
->nb_filters
; i
++)
288 if (graph
->filters
[i
]->name
&& !strcmp(name
, graph
->filters
[i
]->name
))
289 return graph
->filters
[i
];
294 static void sanitize_channel_layouts(void *log
, AVFilterChannelLayouts
*l
)
298 if (l
->nb_channel_layouts
) {
299 if (l
->all_layouts
|| l
->all_counts
)
300 av_log(log
, AV_LOG_WARNING
, "All layouts set on non-empty list\n");
301 l
->all_layouts
= l
->all_counts
= 0;
303 if (l
->all_counts
&& !l
->all_layouts
)
304 av_log(log
, AV_LOG_WARNING
, "All counts without all layouts\n");
309 static int filter_query_formats(AVFilterContext
*ctx
)
312 AVFilterFormats
*formats
;
313 AVFilterChannelLayouts
*chlayouts
;
314 AVFilterFormats
*samplerates
;
315 enum AVMediaType type
= ctx
->inputs
&& ctx
->inputs
[0] ? ctx
->inputs
[0]->type
:
316 ctx
->outputs
&& ctx
->outputs
[0] ? ctx
->outputs
[0]->type
:
319 if ((ret
= ctx
->filter
->query_formats(ctx
)) < 0) {
320 if (ret
!= AVERROR(EAGAIN
))
321 av_log(ctx
, AV_LOG_ERROR
, "Query format failed for '%s': %s\n",
322 ctx
->name
, av_err2str(ret
));
326 for (i
= 0; i
< ctx
->nb_inputs
; i
++)
327 sanitize_channel_layouts(ctx
, ctx
->inputs
[i
]->out_channel_layouts
);
328 for (i
= 0; i
< ctx
->nb_outputs
; i
++)
329 sanitize_channel_layouts(ctx
, ctx
->outputs
[i
]->in_channel_layouts
);
331 formats
= ff_all_formats(type
);
333 return AVERROR(ENOMEM
);
334 ff_set_common_formats(ctx
, formats
);
335 if (type
== AVMEDIA_TYPE_AUDIO
) {
336 samplerates
= ff_all_samplerates();
338 return AVERROR(ENOMEM
);
339 ff_set_common_samplerates(ctx
, samplerates
);
340 chlayouts
= ff_all_channel_layouts();
342 return AVERROR(ENOMEM
);
343 ff_set_common_channel_layouts(ctx
, chlayouts
);
348 static int formats_declared(AVFilterContext
*f
)
352 for (i
= 0; i
< f
->nb_inputs
; i
++) {
353 if (!f
->inputs
[i
]->out_formats
)
355 if (f
->inputs
[i
]->type
== AVMEDIA_TYPE_AUDIO
&&
356 !(f
->inputs
[i
]->out_samplerates
&&
357 f
->inputs
[i
]->out_channel_layouts
))
360 for (i
= 0; i
< f
->nb_outputs
; i
++) {
361 if (!f
->outputs
[i
]->in_formats
)
363 if (f
->outputs
[i
]->type
== AVMEDIA_TYPE_AUDIO
&&
364 !(f
->outputs
[i
]->in_samplerates
&&
365 f
->outputs
[i
]->in_channel_layouts
))
371 static AVFilterFormats
*clone_filter_formats(AVFilterFormats
*arg
)
373 AVFilterFormats
*a
= av_memdup(arg
, sizeof(*arg
));
377 a
->formats
= av_memdup(a
->formats
, sizeof(*a
->formats
) * a
->nb_formats
);
378 if (!a
->formats
&& arg
->formats
)
384 static int can_merge_formats(AVFilterFormats
*a_arg
,
385 AVFilterFormats
*b_arg
,
386 enum AVMediaType type
,
389 AVFilterFormats
*a
, *b
, *ret
;
392 a
= clone_filter_formats(a_arg
);
393 b
= clone_filter_formats(b_arg
);
397 av_freep(&a
->formats
);
399 av_freep(&b
->formats
);
407 if (is_sample_rate
) {
408 ret
= ff_merge_samplerates(a
, b
);
410 ret
= ff_merge_formats(a
, b
, type
);
413 av_freep(&ret
->formats
);
414 av_freep(&ret
->refs
);
418 av_freep(&a
->formats
);
419 av_freep(&b
->formats
);
427 * Perform one round of query_formats() and merging formats lists on the
429 * @return >=0 if all links formats lists could be queried and merged;
430 * AVERROR(EAGAIN) some progress was made in the queries or merging
431 * and a later call may succeed;
432 * AVERROR(EIO) (may be changed) plus a log message if no progress
433 * was made and the negotiation is stuck;
434 * a negative error code if some other error happened
436 static int query_formats(AVFilterGraph
*graph
, AVClass
*log_ctx
)
439 int scaler_count
= 0, resampler_count
= 0;
440 int count_queried
= 0; /* successful calls to query_formats() */
441 int count_merged
= 0; /* successful merge of formats lists */
442 int count_already_merged
= 0; /* lists already merged */
443 int count_delayed
= 0; /* lists that need to be merged later */
445 for (i
= 0; i
< graph
->nb_filters
; i
++) {
446 AVFilterContext
*f
= graph
->filters
[i
];
447 if (formats_declared(f
))
449 if (f
->filter
->query_formats
)
450 ret
= filter_query_formats(f
);
452 ret
= ff_default_query_formats(f
);
453 if (ret
< 0 && ret
!= AVERROR(EAGAIN
))
455 /* note: EAGAIN could indicate a partial success, not counted yet */
456 count_queried
+= ret
>= 0;
459 /* go through and merge as many format lists as possible */
460 for (i
= 0; i
< graph
->nb_filters
; i
++) {
461 AVFilterContext
*filter
= graph
->filters
[i
];
463 for (j
= 0; j
< filter
->nb_inputs
; j
++) {
464 AVFilterLink
*link
= filter
->inputs
[j
];
465 int convert_needed
= 0;
470 if (link
->in_formats
!= link
->out_formats
471 && link
->in_formats
&& link
->out_formats
)
472 if (!can_merge_formats(link
->in_formats
, link
->out_formats
,
475 if (link
->type
== AVMEDIA_TYPE_AUDIO
) {
476 if (link
->in_samplerates
!= link
->out_samplerates
477 && link
->in_samplerates
&& link
->out_samplerates
)
478 if (!can_merge_formats(link
->in_samplerates
,
479 link
->out_samplerates
,
484 #define MERGE_DISPATCH(field, statement) \
485 if (!(link->in_ ## field && link->out_ ## field)) { \
487 } else if (link->in_ ## field == link->out_ ## field) { \
488 count_already_merged++; \
489 } else if (!convert_needed) { \
494 if (link
->type
== AVMEDIA_TYPE_AUDIO
) {
495 MERGE_DISPATCH(channel_layouts
,
496 if (!ff_merge_channel_layouts(link
->in_channel_layouts
,
497 link
->out_channel_layouts
))
500 MERGE_DISPATCH(samplerates
,
501 if (!ff_merge_samplerates(link
->in_samplerates
,
502 link
->out_samplerates
))
506 MERGE_DISPATCH(formats
,
507 if (!ff_merge_formats(link
->in_formats
, link
->out_formats
,
511 #undef MERGE_DISPATCH
513 if (convert_needed
) {
514 AVFilterContext
*convert
;
516 AVFilterLink
*inlink
, *outlink
;
517 char scale_args
[256];
520 /* couldn't merge format lists. auto-insert conversion filter */
521 switch (link
->type
) {
522 case AVMEDIA_TYPE_VIDEO
:
523 if (!(filter
= avfilter_get_by_name("scale"))) {
524 av_log(log_ctx
, AV_LOG_ERROR
, "'scale' filter "
525 "not present, cannot convert pixel formats.\n");
526 return AVERROR(EINVAL
);
529 snprintf(inst_name
, sizeof(inst_name
), "auto-inserted scaler %d",
532 if ((ret
= avfilter_graph_create_filter(&convert
, filter
,
533 inst_name
, graph
->scale_sws_opts
, NULL
,
537 case AVMEDIA_TYPE_AUDIO
:
538 if (!(filter
= avfilter_get_by_name("aresample"))) {
539 av_log(log_ctx
, AV_LOG_ERROR
, "'aresample' filter "
540 "not present, cannot convert audio formats.\n");
541 return AVERROR(EINVAL
);
544 snprintf(inst_name
, sizeof(inst_name
), "auto-inserted resampler %d",
546 scale_args
[0] = '\0';
547 if (graph
->aresample_swr_opts
)
548 snprintf(scale_args
, sizeof(scale_args
), "%s",
549 graph
->aresample_swr_opts
);
550 if ((ret
= avfilter_graph_create_filter(&convert
, filter
,
551 inst_name
, graph
->aresample_swr_opts
,
556 return AVERROR(EINVAL
);
559 if ((ret
= avfilter_insert_filter(link
, convert
, 0, 0)) < 0)
562 filter_query_formats(convert
);
563 inlink
= convert
->inputs
[0];
564 outlink
= convert
->outputs
[0];
565 av_assert0( inlink
-> in_formats
->refcount
> 0);
566 av_assert0( inlink
->out_formats
->refcount
> 0);
567 av_assert0(outlink
-> in_formats
->refcount
> 0);
568 av_assert0(outlink
->out_formats
->refcount
> 0);
569 if (outlink
->type
== AVMEDIA_TYPE_AUDIO
) {
570 av_assert0( inlink
-> in_samplerates
->refcount
> 0);
571 av_assert0( inlink
->out_samplerates
->refcount
> 0);
572 av_assert0(outlink
-> in_samplerates
->refcount
> 0);
573 av_assert0(outlink
->out_samplerates
->refcount
> 0);
574 av_assert0( inlink
-> in_channel_layouts
->refcount
> 0);
575 av_assert0( inlink
->out_channel_layouts
->refcount
> 0);
576 av_assert0(outlink
-> in_channel_layouts
->refcount
> 0);
577 av_assert0(outlink
->out_channel_layouts
->refcount
> 0);
579 if (!ff_merge_formats( inlink
->in_formats
, inlink
->out_formats
, inlink
->type
) ||
580 !ff_merge_formats(outlink
->in_formats
, outlink
->out_formats
, outlink
->type
))
581 ret
= AVERROR(ENOSYS
);
582 if (inlink
->type
== AVMEDIA_TYPE_AUDIO
&&
583 (!ff_merge_samplerates(inlink
->in_samplerates
,
584 inlink
->out_samplerates
) ||
585 !ff_merge_channel_layouts(inlink
->in_channel_layouts
,
586 inlink
->out_channel_layouts
)))
587 ret
= AVERROR(ENOSYS
);
588 if (outlink
->type
== AVMEDIA_TYPE_AUDIO
&&
589 (!ff_merge_samplerates(outlink
->in_samplerates
,
590 outlink
->out_samplerates
) ||
591 !ff_merge_channel_layouts(outlink
->in_channel_layouts
,
592 outlink
->out_channel_layouts
)))
593 ret
= AVERROR(ENOSYS
);
596 av_log(log_ctx
, AV_LOG_ERROR
,
597 "Impossible to convert between the formats supported by the filter "
598 "'%s' and the filter '%s'\n", link
->src
->name
, link
->dst
->name
);
605 av_log(graph
, AV_LOG_DEBUG
, "query_formats: "
606 "%d queried, %d merged, %d already done, %d delayed\n",
607 count_queried
, count_merged
, count_already_merged
, count_delayed
);
611 /* if count_queried > 0, one filter at least did set its formats,
612 that will give additional information to its neighbour;
613 if count_merged > 0, one pair of formats lists at least was merged,
614 that will give additional information to all connected filters;
615 in both cases, progress was made and a new round must be done */
616 if (count_queried
|| count_merged
)
617 return AVERROR(EAGAIN
);
618 av_bprint_init(&bp
, 0, AV_BPRINT_SIZE_AUTOMATIC
);
619 for (i
= 0; i
< graph
->nb_filters
; i
++)
620 if (!formats_declared(graph
->filters
[i
]))
621 av_bprintf(&bp
, "%s%s", bp
.len
? ", " : "",
622 graph
->filters
[i
]->name
);
623 av_log(graph
, AV_LOG_ERROR
,
624 "The following filters could not choose their formats: %s\n"
625 "Consider inserting the (a)format filter near their input or "
626 "output.\n", bp
.str
);
632 static int pick_format(AVFilterLink
*link
, AVFilterLink
*ref
)
634 if (!link
|| !link
->in_formats
)
637 if (link
->type
== AVMEDIA_TYPE_VIDEO
) {
638 if(ref
&& ref
->type
== AVMEDIA_TYPE_VIDEO
){
639 int has_alpha
= av_pix_fmt_desc_get(ref
->format
)->nb_components
% 2 == 0;
640 enum AVPixelFormat best
= AV_PIX_FMT_NONE
;
642 for (i
=0; i
<link
->in_formats
->nb_formats
; i
++) {
643 enum AVPixelFormat p
= link
->in_formats
->formats
[i
];
644 best
= av_find_best_pix_fmt_of_2(best
, p
, ref
->format
, has_alpha
, NULL
);
646 av_log(link
->src
,AV_LOG_DEBUG
, "picking %s out of %d ref:%s alpha:%d\n",
647 av_get_pix_fmt_name(best
), link
->in_formats
->nb_formats
,
648 av_get_pix_fmt_name(ref
->format
), has_alpha
);
649 link
->in_formats
->formats
[0] = best
;
653 link
->in_formats
->nb_formats
= 1;
654 link
->format
= link
->in_formats
->formats
[0];
656 if (link
->type
== AVMEDIA_TYPE_AUDIO
) {
657 if (!link
->in_samplerates
->nb_formats
) {
658 av_log(link
->src
, AV_LOG_ERROR
, "Cannot select sample rate for"
659 " the link between filters %s and %s.\n", link
->src
->name
,
661 return AVERROR(EINVAL
);
663 link
->in_samplerates
->nb_formats
= 1;
664 link
->sample_rate
= link
->in_samplerates
->formats
[0];
666 if (link
->in_channel_layouts
->all_layouts
) {
667 av_log(link
->src
, AV_LOG_ERROR
, "Cannot select channel layout for"
668 " the link between filters %s and %s.\n", link
->src
->name
,
670 if (!link
->in_channel_layouts
->all_counts
)
671 av_log(link
->src
, AV_LOG_ERROR
, "Unknown channel layouts not "
672 "supported, try specifying a channel layout using "
673 "'aformat=channel_layouts=something'.\n");
674 return AVERROR(EINVAL
);
676 link
->in_channel_layouts
->nb_channel_layouts
= 1;
677 link
->channel_layout
= link
->in_channel_layouts
->channel_layouts
[0];
678 if ((link
->channels
= FF_LAYOUT2COUNT(link
->channel_layout
)))
679 link
->channel_layout
= 0;
681 link
->channels
= av_get_channel_layout_nb_channels(link
->channel_layout
);
684 ff_formats_unref(&link
->in_formats
);
685 ff_formats_unref(&link
->out_formats
);
686 ff_formats_unref(&link
->in_samplerates
);
687 ff_formats_unref(&link
->out_samplerates
);
688 ff_channel_layouts_unref(&link
->in_channel_layouts
);
689 ff_channel_layouts_unref(&link
->out_channel_layouts
);
694 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
696 for (i = 0; i < filter->nb_inputs; i++) { \
697 AVFilterLink *link = filter->inputs[i]; \
700 if (!link->out_ ## list || link->out_ ## list->nb != 1) \
702 fmt = link->out_ ## list->var[0]; \
704 for (j = 0; j < filter->nb_outputs; j++) { \
705 AVFilterLink *out_link = filter->outputs[j]; \
708 if (link->type != out_link->type || \
709 out_link->in_ ## list->nb == 1) \
711 fmts = out_link->in_ ## list; \
713 if (!out_link->in_ ## list->nb) { \
714 add_format(&out_link->in_ ##list, fmt); \
719 for (k = 0; k < out_link->in_ ## list->nb; k++) \
720 if (fmts->var[k] == fmt) { \
721 fmts->var[0] = fmt; \
730 static int reduce_formats_on_filter(AVFilterContext
*filter
)
732 int i
, j
, k
, ret
= 0;
734 REDUCE_FORMATS(int, AVFilterFormats
, formats
, formats
,
735 nb_formats
, ff_add_format
);
736 REDUCE_FORMATS(int, AVFilterFormats
, samplerates
, formats
,
737 nb_formats
, ff_add_format
);
739 /* reduce channel layouts */
740 for (i
= 0; i
< filter
->nb_inputs
; i
++) {
741 AVFilterLink
*inlink
= filter
->inputs
[i
];
744 if (!inlink
->out_channel_layouts
||
745 inlink
->out_channel_layouts
->nb_channel_layouts
!= 1)
747 fmt
= inlink
->out_channel_layouts
->channel_layouts
[0];
749 for (j
= 0; j
< filter
->nb_outputs
; j
++) {
750 AVFilterLink
*outlink
= filter
->outputs
[j
];
751 AVFilterChannelLayouts
*fmts
;
753 fmts
= outlink
->in_channel_layouts
;
754 if (inlink
->type
!= outlink
->type
|| fmts
->nb_channel_layouts
== 1)
757 if (fmts
->all_layouts
&&
758 (!FF_LAYOUT2COUNT(fmt
) || fmts
->all_counts
)) {
759 /* Turn the infinite list into a singleton */
760 fmts
->all_layouts
= fmts
->all_counts
= 0;
761 ff_add_channel_layout(&outlink
->in_channel_layouts
, fmt
);
765 for (k
= 0; k
< outlink
->in_channel_layouts
->nb_channel_layouts
; k
++) {
766 if (fmts
->channel_layouts
[k
] == fmt
) {
767 fmts
->channel_layouts
[0] = fmt
;
768 fmts
->nb_channel_layouts
= 1;
779 static void reduce_formats(AVFilterGraph
*graph
)
786 for (i
= 0; i
< graph
->nb_filters
; i
++)
787 reduced
|= reduce_formats_on_filter(graph
->filters
[i
]);
791 static void swap_samplerates_on_filter(AVFilterContext
*filter
)
793 AVFilterLink
*link
= NULL
;
797 for (i
= 0; i
< filter
->nb_inputs
; i
++) {
798 link
= filter
->inputs
[i
];
800 if (link
->type
== AVMEDIA_TYPE_AUDIO
&&
801 link
->out_samplerates
->nb_formats
== 1)
804 if (i
== filter
->nb_inputs
)
807 sample_rate
= link
->out_samplerates
->formats
[0];
809 for (i
= 0; i
< filter
->nb_outputs
; i
++) {
810 AVFilterLink
*outlink
= filter
->outputs
[i
];
811 int best_idx
, best_diff
= INT_MAX
;
813 if (outlink
->type
!= AVMEDIA_TYPE_AUDIO
||
814 outlink
->in_samplerates
->nb_formats
< 2)
817 for (j
= 0; j
< outlink
->in_samplerates
->nb_formats
; j
++) {
818 int diff
= abs(sample_rate
- outlink
->in_samplerates
->formats
[j
]);
820 if (diff
< best_diff
) {
825 FFSWAP(int, outlink
->in_samplerates
->formats
[0],
826 outlink
->in_samplerates
->formats
[best_idx
]);
830 static void swap_samplerates(AVFilterGraph
*graph
)
834 for (i
= 0; i
< graph
->nb_filters
; i
++)
835 swap_samplerates_on_filter(graph
->filters
[i
]);
838 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
839 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
840 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
841 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)
842 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
843 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
844 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
846 /* allowable substitutions for channel pairs when comparing layouts,
847 * ordered by priority for both values */
848 static const uint64_t ch_subst
[][2] = {
849 { CH_FRONT_PAIR
, CH_CENTER_PAIR
},
850 { CH_FRONT_PAIR
, CH_WIDE_PAIR
},
851 { CH_FRONT_PAIR
, AV_CH_FRONT_CENTER
},
852 { CH_CENTER_PAIR
, CH_FRONT_PAIR
},
853 { CH_CENTER_PAIR
, CH_WIDE_PAIR
},
854 { CH_CENTER_PAIR
, AV_CH_FRONT_CENTER
},
855 { CH_WIDE_PAIR
, CH_FRONT_PAIR
},
856 { CH_WIDE_PAIR
, CH_CENTER_PAIR
},
857 { CH_WIDE_PAIR
, AV_CH_FRONT_CENTER
},
858 { AV_CH_FRONT_CENTER
, CH_FRONT_PAIR
},
859 { AV_CH_FRONT_CENTER
, CH_CENTER_PAIR
},
860 { AV_CH_FRONT_CENTER
, CH_WIDE_PAIR
},
861 { CH_SIDE_PAIR
, CH_DIRECT_PAIR
},
862 { CH_SIDE_PAIR
, CH_BACK_PAIR
},
863 { CH_SIDE_PAIR
, AV_CH_BACK_CENTER
},
864 { CH_BACK_PAIR
, CH_DIRECT_PAIR
},
865 { CH_BACK_PAIR
, CH_SIDE_PAIR
},
866 { CH_BACK_PAIR
, AV_CH_BACK_CENTER
},
867 { AV_CH_BACK_CENTER
, CH_BACK_PAIR
},
868 { AV_CH_BACK_CENTER
, CH_DIRECT_PAIR
},
869 { AV_CH_BACK_CENTER
, CH_SIDE_PAIR
},
872 static void swap_channel_layouts_on_filter(AVFilterContext
*filter
)
874 AVFilterLink
*link
= NULL
;
877 for (i
= 0; i
< filter
->nb_inputs
; i
++) {
878 link
= filter
->inputs
[i
];
880 if (link
->type
== AVMEDIA_TYPE_AUDIO
&&
881 link
->out_channel_layouts
->nb_channel_layouts
== 1)
884 if (i
== filter
->nb_inputs
)
887 for (i
= 0; i
< filter
->nb_outputs
; i
++) {
888 AVFilterLink
*outlink
= filter
->outputs
[i
];
889 int best_idx
= -1, best_score
= INT_MIN
, best_count_diff
= INT_MAX
;
891 if (outlink
->type
!= AVMEDIA_TYPE_AUDIO
||
892 outlink
->in_channel_layouts
->nb_channel_layouts
< 2)
895 for (j
= 0; j
< outlink
->in_channel_layouts
->nb_channel_layouts
; j
++) {
896 uint64_t in_chlayout
= link
->out_channel_layouts
->channel_layouts
[0];
897 uint64_t out_chlayout
= outlink
->in_channel_layouts
->channel_layouts
[j
];
898 int in_channels
= av_get_channel_layout_nb_channels(in_chlayout
);
899 int out_channels
= av_get_channel_layout_nb_channels(out_chlayout
);
900 int count_diff
= out_channels
- in_channels
;
901 int matched_channels
, extra_channels
;
904 if (FF_LAYOUT2COUNT(in_chlayout
) || FF_LAYOUT2COUNT(out_chlayout
)) {
905 /* Compute score in case the input or output layout encodes
906 a channel count; in this case the score is not altered by
907 the computation afterwards, as in_chlayout and
908 out_chlayout have both been set to 0 */
909 if (FF_LAYOUT2COUNT(in_chlayout
))
910 in_channels
= FF_LAYOUT2COUNT(in_chlayout
);
911 if (FF_LAYOUT2COUNT(out_chlayout
))
912 out_channels
= FF_LAYOUT2COUNT(out_chlayout
);
913 score
-= 10000 + FFABS(out_channels
- in_channels
) +
914 (in_channels
> out_channels
? 10000 : 0);
915 in_chlayout
= out_chlayout
= 0;
916 /* Let the remaining computation run, even if the score
917 value is not altered */
920 /* channel substitution */
921 for (k
= 0; k
< FF_ARRAY_ELEMS(ch_subst
); k
++) {
922 uint64_t cmp0
= ch_subst
[k
][0];
923 uint64_t cmp1
= ch_subst
[k
][1];
924 if (( in_chlayout
& cmp0
) && (!(out_chlayout
& cmp0
)) &&
925 (out_chlayout
& cmp1
) && (!( in_chlayout
& cmp1
))) {
926 in_chlayout
&= ~cmp0
;
927 out_chlayout
&= ~cmp1
;
928 /* add score for channel match, minus a deduction for
929 having to do the substitution */
930 score
+= 10 * av_get_channel_layout_nb_channels(cmp1
) - 2;
934 /* no penalty for LFE channel mismatch */
935 if ( (in_chlayout
& AV_CH_LOW_FREQUENCY
) &&
936 (out_chlayout
& AV_CH_LOW_FREQUENCY
))
938 in_chlayout
&= ~AV_CH_LOW_FREQUENCY
;
939 out_chlayout
&= ~AV_CH_LOW_FREQUENCY
;
941 matched_channels
= av_get_channel_layout_nb_channels(in_chlayout
&
943 extra_channels
= av_get_channel_layout_nb_channels(out_chlayout
&
945 score
+= 10 * matched_channels
- 5 * extra_channels
;
947 if (score
> best_score
||
948 (count_diff
< best_count_diff
&& score
== best_score
)) {
951 best_count_diff
= count_diff
;
954 av_assert0(best_idx
>= 0);
955 FFSWAP(uint64_t, outlink
->in_channel_layouts
->channel_layouts
[0],
956 outlink
->in_channel_layouts
->channel_layouts
[best_idx
]);
961 static void swap_channel_layouts(AVFilterGraph
*graph
)
965 for (i
= 0; i
< graph
->nb_filters
; i
++)
966 swap_channel_layouts_on_filter(graph
->filters
[i
]);
969 static void swap_sample_fmts_on_filter(AVFilterContext
*filter
)
971 AVFilterLink
*link
= NULL
;
975 for (i
= 0; i
< filter
->nb_inputs
; i
++) {
976 link
= filter
->inputs
[i
];
978 if (link
->type
== AVMEDIA_TYPE_AUDIO
&&
979 link
->out_formats
->nb_formats
== 1)
982 if (i
== filter
->nb_inputs
)
985 format
= link
->out_formats
->formats
[0];
986 bps
= av_get_bytes_per_sample(format
);
988 for (i
= 0; i
< filter
->nb_outputs
; i
++) {
989 AVFilterLink
*outlink
= filter
->outputs
[i
];
990 int best_idx
= -1, best_score
= INT_MIN
;
992 if (outlink
->type
!= AVMEDIA_TYPE_AUDIO
||
993 outlink
->in_formats
->nb_formats
< 2)
996 for (j
= 0; j
< outlink
->in_formats
->nb_formats
; j
++) {
997 int out_format
= outlink
->in_formats
->formats
[j
];
998 int out_bps
= av_get_bytes_per_sample(out_format
);
1001 if (av_get_packed_sample_fmt(out_format
) == format
||
1002 av_get_planar_sample_fmt(out_format
) == format
) {
1007 /* for s32 and float prefer double to prevent loss of information */
1008 if (bps
== 4 && out_bps
== 8) {
1013 /* prefer closest higher or equal bps */
1014 score
= -abs(out_bps
- bps
);
1018 if (score
> best_score
) {
1023 av_assert0(best_idx
>= 0);
1024 FFSWAP(int, outlink
->in_formats
->formats
[0],
1025 outlink
->in_formats
->formats
[best_idx
]);
1029 static void swap_sample_fmts(AVFilterGraph
*graph
)
1033 for (i
= 0; i
< graph
->nb_filters
; i
++)
1034 swap_sample_fmts_on_filter(graph
->filters
[i
]);
1038 static int pick_formats(AVFilterGraph
*graph
)
1045 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1046 AVFilterContext
*filter
= graph
->filters
[i
];
1047 if (filter
->nb_inputs
){
1048 for (j
= 0; j
< filter
->nb_inputs
; j
++){
1049 if(filter
->inputs
[j
]->in_formats
&& filter
->inputs
[j
]->in_formats
->nb_formats
== 1) {
1050 if ((ret
= pick_format(filter
->inputs
[j
], NULL
)) < 0)
1056 if (filter
->nb_outputs
){
1057 for (j
= 0; j
< filter
->nb_outputs
; j
++){
1058 if(filter
->outputs
[j
]->in_formats
&& filter
->outputs
[j
]->in_formats
->nb_formats
== 1) {
1059 if ((ret
= pick_format(filter
->outputs
[j
], NULL
)) < 0)
1065 if (filter
->nb_inputs
&& filter
->nb_outputs
&& filter
->inputs
[0]->format
>=0) {
1066 for (j
= 0; j
< filter
->nb_outputs
; j
++) {
1067 if(filter
->outputs
[j
]->format
<0) {
1068 if ((ret
= pick_format(filter
->outputs
[j
], filter
->inputs
[0])) < 0)
1077 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1078 AVFilterContext
*filter
= graph
->filters
[i
];
1080 for (j
= 0; j
< filter
->nb_inputs
; j
++)
1081 if ((ret
= pick_format(filter
->inputs
[j
], NULL
)) < 0)
1083 for (j
= 0; j
< filter
->nb_outputs
; j
++)
1084 if ((ret
= pick_format(filter
->outputs
[j
], NULL
)) < 0)
1091 * Configure the formats of all the links in the graph.
1093 static int graph_config_formats(AVFilterGraph
*graph
, AVClass
*log_ctx
)
1097 /* find supported formats from sub-filters, and merge along links */
1098 while ((ret
= query_formats(graph
, log_ctx
)) == AVERROR(EAGAIN
))
1099 av_log(graph
, AV_LOG_DEBUG
, "query_formats not finished\n");
1103 /* Once everything is merged, it's possible that we'll still have
1104 * multiple valid media format choices. We try to minimize the amount
1105 * of format conversion inside filters */
1106 reduce_formats(graph
);
1108 /* for audio filters, ensure the best format, sample rate and channel layout
1110 swap_sample_fmts(graph
);
1111 swap_samplerates(graph
);
1112 swap_channel_layouts(graph
);
1114 if ((ret
= pick_formats(graph
)) < 0)
1120 static int ff_avfilter_graph_config_pointers(AVFilterGraph
*graph
,
1124 int sink_links_count
= 0, n
= 0;
1126 AVFilterLink
**sinks
;
1128 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1129 f
= graph
->filters
[i
];
1130 for (j
= 0; j
< f
->nb_inputs
; j
++) {
1131 f
->inputs
[j
]->graph
= graph
;
1132 f
->inputs
[j
]->age_index
= -1;
1134 for (j
= 0; j
< f
->nb_outputs
; j
++) {
1135 f
->outputs
[j
]->graph
= graph
;
1136 f
->outputs
[j
]->age_index
= -1;
1138 if (!f
->nb_outputs
) {
1139 if (f
->nb_inputs
> INT_MAX
- sink_links_count
)
1140 return AVERROR(EINVAL
);
1141 sink_links_count
+= f
->nb_inputs
;
1144 sinks
= av_calloc(sink_links_count
, sizeof(*sinks
));
1146 return AVERROR(ENOMEM
);
1147 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1148 f
= graph
->filters
[i
];
1149 if (!f
->nb_outputs
) {
1150 for (j
= 0; j
< f
->nb_inputs
; j
++) {
1151 sinks
[n
] = f
->inputs
[j
];
1152 f
->inputs
[j
]->age_index
= n
++;
1156 av_assert0(n
== sink_links_count
);
1157 graph
->sink_links
= sinks
;
1158 graph
->sink_links_count
= sink_links_count
;
1162 static int graph_insert_fifos(AVFilterGraph
*graph
, AVClass
*log_ctx
)
1168 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1169 f
= graph
->filters
[i
];
1171 for (j
= 0; j
< f
->nb_inputs
; j
++) {
1172 AVFilterLink
*link
= f
->inputs
[j
];
1173 AVFilterContext
*fifo_ctx
;
1177 if (!link
->dstpad
->needs_fifo
)
1180 fifo
= f
->inputs
[j
]->type
== AVMEDIA_TYPE_VIDEO
?
1181 avfilter_get_by_name("fifo") :
1182 avfilter_get_by_name("afifo");
1184 snprintf(name
, sizeof(name
), "auto-inserted fifo %d", fifo_count
++);
1186 ret
= avfilter_graph_create_filter(&fifo_ctx
, fifo
, name
, NULL
,
1191 ret
= avfilter_insert_filter(link
, fifo_ctx
, 0, 0);
1200 int avfilter_graph_config(AVFilterGraph
*graphctx
, void *log_ctx
)
1204 if ((ret
= graph_check_validity(graphctx
, log_ctx
)))
1206 if ((ret
= graph_insert_fifos(graphctx
, log_ctx
)) < 0)
1208 if ((ret
= graph_config_formats(graphctx
, log_ctx
)))
1210 if ((ret
= graph_config_links(graphctx
, log_ctx
)))
1212 if ((ret
= ff_avfilter_graph_config_pointers(graphctx
, log_ctx
)))
1218 int avfilter_graph_send_command(AVFilterGraph
*graph
, const char *target
, const char *cmd
, const char *arg
, char *res
, int res_len
, int flags
)
1220 int i
, r
= AVERROR(ENOSYS
);
1225 if ((flags
& AVFILTER_CMD_FLAG_ONE
) && !(flags
& AVFILTER_CMD_FLAG_FAST
)) {
1226 r
= avfilter_graph_send_command(graph
, target
, cmd
, arg
, res
, res_len
, flags
| AVFILTER_CMD_FLAG_FAST
);
1227 if (r
!= AVERROR(ENOSYS
))
1234 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1235 AVFilterContext
*filter
= graph
->filters
[i
];
1236 if (!strcmp(target
, "all") || (filter
->name
&& !strcmp(target
, filter
->name
)) || !strcmp(target
, filter
->filter
->name
)) {
1237 r
= avfilter_process_command(filter
, cmd
, arg
, res
, res_len
, flags
);
1238 if (r
!= AVERROR(ENOSYS
)) {
1239 if ((flags
& AVFILTER_CMD_FLAG_ONE
) || r
< 0)
1248 int avfilter_graph_queue_command(AVFilterGraph
*graph
, const char *target
, const char *command
, const char *arg
, int flags
, double ts
)
1255 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1256 AVFilterContext
*filter
= graph
->filters
[i
];
1257 if(filter
&& (!strcmp(target
, "all") || !strcmp(target
, filter
->name
) || !strcmp(target
, filter
->filter
->name
))){
1258 AVFilterCommand
**queue
= &filter
->command_queue
, *next
;
1259 while (*queue
&& (*queue
)->time
<= ts
)
1260 queue
= &(*queue
)->next
;
1262 *queue
= av_mallocz(sizeof(AVFilterCommand
));
1263 (*queue
)->command
= av_strdup(command
);
1264 (*queue
)->arg
= av_strdup(arg
);
1265 (*queue
)->time
= ts
;
1266 (*queue
)->flags
= flags
;
1267 (*queue
)->next
= next
;
1268 if(flags
& AVFILTER_CMD_FLAG_ONE
)
1276 static void heap_bubble_up(AVFilterGraph
*graph
,
1277 AVFilterLink
*link
, int index
)
1279 AVFilterLink
**links
= graph
->sink_links
;
1282 int parent
= (index
- 1) >> 1;
1283 if (links
[parent
]->current_pts
>= link
->current_pts
)
1285 links
[index
] = links
[parent
];
1286 links
[index
]->age_index
= index
;
1289 links
[index
] = link
;
1290 link
->age_index
= index
;
1293 static void heap_bubble_down(AVFilterGraph
*graph
,
1294 AVFilterLink
*link
, int index
)
1296 AVFilterLink
**links
= graph
->sink_links
;
1299 int child
= 2 * index
+ 1;
1300 if (child
>= graph
->sink_links_count
)
1302 if (child
+ 1 < graph
->sink_links_count
&&
1303 links
[child
+ 1]->current_pts
< links
[child
]->current_pts
)
1305 if (link
->current_pts
< links
[child
]->current_pts
)
1307 links
[index
] = links
[child
];
1308 links
[index
]->age_index
= index
;
1311 links
[index
] = link
;
1312 link
->age_index
= index
;
1315 void ff_avfilter_graph_update_heap(AVFilterGraph
*graph
, AVFilterLink
*link
)
1317 heap_bubble_up (graph
, link
, link
->age_index
);
1318 heap_bubble_down(graph
, link
, link
->age_index
);
1322 int avfilter_graph_request_oldest(AVFilterGraph
*graph
)
1324 while (graph
->sink_links_count
) {
1325 AVFilterLink
*oldest
= graph
->sink_links
[0];
1326 int r
= ff_request_frame(oldest
);
1327 if (r
!= AVERROR_EOF
)
1329 av_log(oldest
->dst
, AV_LOG_DEBUG
, "EOF on sink link %s:%s.\n",
1330 oldest
->dst
? oldest
->dst
->name
: "unknown",
1331 oldest
->dstpad
? oldest
->dstpad
->name
: "unknown");
1332 /* EOF: remove the link from the heap */
1333 if (oldest
->age_index
< --graph
->sink_links_count
)
1334 heap_bubble_down(graph
, graph
->sink_links
[graph
->sink_links_count
],
1336 oldest
->age_index
= -1;