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 if ((ret
= filter_query_formats(convert
)) < 0)
565 inlink
= convert
->inputs
[0];
566 outlink
= convert
->outputs
[0];
567 av_assert0( inlink
-> in_formats
->refcount
> 0);
568 av_assert0( inlink
->out_formats
->refcount
> 0);
569 av_assert0(outlink
-> in_formats
->refcount
> 0);
570 av_assert0(outlink
->out_formats
->refcount
> 0);
571 if (outlink
->type
== AVMEDIA_TYPE_AUDIO
) {
572 av_assert0( inlink
-> in_samplerates
->refcount
> 0);
573 av_assert0( inlink
->out_samplerates
->refcount
> 0);
574 av_assert0(outlink
-> in_samplerates
->refcount
> 0);
575 av_assert0(outlink
->out_samplerates
->refcount
> 0);
576 av_assert0( inlink
-> in_channel_layouts
->refcount
> 0);
577 av_assert0( inlink
->out_channel_layouts
->refcount
> 0);
578 av_assert0(outlink
-> in_channel_layouts
->refcount
> 0);
579 av_assert0(outlink
->out_channel_layouts
->refcount
> 0);
581 if (!ff_merge_formats( inlink
->in_formats
, inlink
->out_formats
, inlink
->type
) ||
582 !ff_merge_formats(outlink
->in_formats
, outlink
->out_formats
, outlink
->type
))
583 ret
= AVERROR(ENOSYS
);
584 if (inlink
->type
== AVMEDIA_TYPE_AUDIO
&&
585 (!ff_merge_samplerates(inlink
->in_samplerates
,
586 inlink
->out_samplerates
) ||
587 !ff_merge_channel_layouts(inlink
->in_channel_layouts
,
588 inlink
->out_channel_layouts
)))
589 ret
= AVERROR(ENOSYS
);
590 if (outlink
->type
== AVMEDIA_TYPE_AUDIO
&&
591 (!ff_merge_samplerates(outlink
->in_samplerates
,
592 outlink
->out_samplerates
) ||
593 !ff_merge_channel_layouts(outlink
->in_channel_layouts
,
594 outlink
->out_channel_layouts
)))
595 ret
= AVERROR(ENOSYS
);
598 av_log(log_ctx
, AV_LOG_ERROR
,
599 "Impossible to convert between the formats supported by the filter "
600 "'%s' and the filter '%s'\n", link
->src
->name
, link
->dst
->name
);
607 av_log(graph
, AV_LOG_DEBUG
, "query_formats: "
608 "%d queried, %d merged, %d already done, %d delayed\n",
609 count_queried
, count_merged
, count_already_merged
, count_delayed
);
613 /* if count_queried > 0, one filter at least did set its formats,
614 that will give additional information to its neighbour;
615 if count_merged > 0, one pair of formats lists at least was merged,
616 that will give additional information to all connected filters;
617 in both cases, progress was made and a new round must be done */
618 if (count_queried
|| count_merged
)
619 return AVERROR(EAGAIN
);
620 av_bprint_init(&bp
, 0, AV_BPRINT_SIZE_AUTOMATIC
);
621 for (i
= 0; i
< graph
->nb_filters
; i
++)
622 if (!formats_declared(graph
->filters
[i
]))
623 av_bprintf(&bp
, "%s%s", bp
.len
? ", " : "",
624 graph
->filters
[i
]->name
);
625 av_log(graph
, AV_LOG_ERROR
,
626 "The following filters could not choose their formats: %s\n"
627 "Consider inserting the (a)format filter near their input or "
628 "output.\n", bp
.str
);
634 static int pick_format(AVFilterLink
*link
, AVFilterLink
*ref
)
636 if (!link
|| !link
->in_formats
)
639 if (link
->type
== AVMEDIA_TYPE_VIDEO
) {
640 if(ref
&& ref
->type
== AVMEDIA_TYPE_VIDEO
){
641 int has_alpha
= av_pix_fmt_desc_get(ref
->format
)->nb_components
% 2 == 0;
642 enum AVPixelFormat best
= AV_PIX_FMT_NONE
;
644 for (i
=0; i
<link
->in_formats
->nb_formats
; i
++) {
645 enum AVPixelFormat p
= link
->in_formats
->formats
[i
];
646 best
= av_find_best_pix_fmt_of_2(best
, p
, ref
->format
, has_alpha
, NULL
);
648 av_log(link
->src
,AV_LOG_DEBUG
, "picking %s out of %d ref:%s alpha:%d\n",
649 av_get_pix_fmt_name(best
), link
->in_formats
->nb_formats
,
650 av_get_pix_fmt_name(ref
->format
), has_alpha
);
651 link
->in_formats
->formats
[0] = best
;
655 link
->in_formats
->nb_formats
= 1;
656 link
->format
= link
->in_formats
->formats
[0];
658 if (link
->type
== AVMEDIA_TYPE_AUDIO
) {
659 if (!link
->in_samplerates
->nb_formats
) {
660 av_log(link
->src
, AV_LOG_ERROR
, "Cannot select sample rate for"
661 " the link between filters %s and %s.\n", link
->src
->name
,
663 return AVERROR(EINVAL
);
665 link
->in_samplerates
->nb_formats
= 1;
666 link
->sample_rate
= link
->in_samplerates
->formats
[0];
668 if (link
->in_channel_layouts
->all_layouts
) {
669 av_log(link
->src
, AV_LOG_ERROR
, "Cannot select channel layout for"
670 " the link between filters %s and %s.\n", link
->src
->name
,
672 if (!link
->in_channel_layouts
->all_counts
)
673 av_log(link
->src
, AV_LOG_ERROR
, "Unknown channel layouts not "
674 "supported, try specifying a channel layout using "
675 "'aformat=channel_layouts=something'.\n");
676 return AVERROR(EINVAL
);
678 link
->in_channel_layouts
->nb_channel_layouts
= 1;
679 link
->channel_layout
= link
->in_channel_layouts
->channel_layouts
[0];
680 if ((link
->channels
= FF_LAYOUT2COUNT(link
->channel_layout
)))
681 link
->channel_layout
= 0;
683 link
->channels
= av_get_channel_layout_nb_channels(link
->channel_layout
);
686 ff_formats_unref(&link
->in_formats
);
687 ff_formats_unref(&link
->out_formats
);
688 ff_formats_unref(&link
->in_samplerates
);
689 ff_formats_unref(&link
->out_samplerates
);
690 ff_channel_layouts_unref(&link
->in_channel_layouts
);
691 ff_channel_layouts_unref(&link
->out_channel_layouts
);
696 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
698 for (i = 0; i < filter->nb_inputs; i++) { \
699 AVFilterLink *link = filter->inputs[i]; \
702 if (!link->out_ ## list || link->out_ ## list->nb != 1) \
704 fmt = link->out_ ## list->var[0]; \
706 for (j = 0; j < filter->nb_outputs; j++) { \
707 AVFilterLink *out_link = filter->outputs[j]; \
710 if (link->type != out_link->type || \
711 out_link->in_ ## list->nb == 1) \
713 fmts = out_link->in_ ## list; \
715 if (!out_link->in_ ## list->nb) { \
716 add_format(&out_link->in_ ##list, fmt); \
721 for (k = 0; k < out_link->in_ ## list->nb; k++) \
722 if (fmts->var[k] == fmt) { \
723 fmts->var[0] = fmt; \
732 static int reduce_formats_on_filter(AVFilterContext
*filter
)
734 int i
, j
, k
, ret
= 0;
736 REDUCE_FORMATS(int, AVFilterFormats
, formats
, formats
,
737 nb_formats
, ff_add_format
);
738 REDUCE_FORMATS(int, AVFilterFormats
, samplerates
, formats
,
739 nb_formats
, ff_add_format
);
741 /* reduce channel layouts */
742 for (i
= 0; i
< filter
->nb_inputs
; i
++) {
743 AVFilterLink
*inlink
= filter
->inputs
[i
];
746 if (!inlink
->out_channel_layouts
||
747 inlink
->out_channel_layouts
->nb_channel_layouts
!= 1)
749 fmt
= inlink
->out_channel_layouts
->channel_layouts
[0];
751 for (j
= 0; j
< filter
->nb_outputs
; j
++) {
752 AVFilterLink
*outlink
= filter
->outputs
[j
];
753 AVFilterChannelLayouts
*fmts
;
755 fmts
= outlink
->in_channel_layouts
;
756 if (inlink
->type
!= outlink
->type
|| fmts
->nb_channel_layouts
== 1)
759 if (fmts
->all_layouts
&&
760 (!FF_LAYOUT2COUNT(fmt
) || fmts
->all_counts
)) {
761 /* Turn the infinite list into a singleton */
762 fmts
->all_layouts
= fmts
->all_counts
= 0;
763 ff_add_channel_layout(&outlink
->in_channel_layouts
, fmt
);
767 for (k
= 0; k
< outlink
->in_channel_layouts
->nb_channel_layouts
; k
++) {
768 if (fmts
->channel_layouts
[k
] == fmt
) {
769 fmts
->channel_layouts
[0] = fmt
;
770 fmts
->nb_channel_layouts
= 1;
781 static void reduce_formats(AVFilterGraph
*graph
)
788 for (i
= 0; i
< graph
->nb_filters
; i
++)
789 reduced
|= reduce_formats_on_filter(graph
->filters
[i
]);
793 static void swap_samplerates_on_filter(AVFilterContext
*filter
)
795 AVFilterLink
*link
= NULL
;
799 for (i
= 0; i
< filter
->nb_inputs
; i
++) {
800 link
= filter
->inputs
[i
];
802 if (link
->type
== AVMEDIA_TYPE_AUDIO
&&
803 link
->out_samplerates
->nb_formats
== 1)
806 if (i
== filter
->nb_inputs
)
809 sample_rate
= link
->out_samplerates
->formats
[0];
811 for (i
= 0; i
< filter
->nb_outputs
; i
++) {
812 AVFilterLink
*outlink
= filter
->outputs
[i
];
813 int best_idx
, best_diff
= INT_MAX
;
815 if (outlink
->type
!= AVMEDIA_TYPE_AUDIO
||
816 outlink
->in_samplerates
->nb_formats
< 2)
819 for (j
= 0; j
< outlink
->in_samplerates
->nb_formats
; j
++) {
820 int diff
= abs(sample_rate
- outlink
->in_samplerates
->formats
[j
]);
822 if (diff
< best_diff
) {
827 FFSWAP(int, outlink
->in_samplerates
->formats
[0],
828 outlink
->in_samplerates
->formats
[best_idx
]);
832 static void swap_samplerates(AVFilterGraph
*graph
)
836 for (i
= 0; i
< graph
->nb_filters
; i
++)
837 swap_samplerates_on_filter(graph
->filters
[i
]);
840 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
841 #define CH_FRONT_PAIR (AV_CH_FRONT_LEFT | AV_CH_FRONT_RIGHT)
842 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT | AV_CH_STEREO_RIGHT)
843 #define CH_WIDE_PAIR (AV_CH_WIDE_LEFT | AV_CH_WIDE_RIGHT)
844 #define CH_SIDE_PAIR (AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT)
845 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
846 #define CH_BACK_PAIR (AV_CH_BACK_LEFT | AV_CH_BACK_RIGHT)
848 /* allowable substitutions for channel pairs when comparing layouts,
849 * ordered by priority for both values */
850 static const uint64_t ch_subst
[][2] = {
851 { CH_FRONT_PAIR
, CH_CENTER_PAIR
},
852 { CH_FRONT_PAIR
, CH_WIDE_PAIR
},
853 { CH_FRONT_PAIR
, AV_CH_FRONT_CENTER
},
854 { CH_CENTER_PAIR
, CH_FRONT_PAIR
},
855 { CH_CENTER_PAIR
, CH_WIDE_PAIR
},
856 { CH_CENTER_PAIR
, AV_CH_FRONT_CENTER
},
857 { CH_WIDE_PAIR
, CH_FRONT_PAIR
},
858 { CH_WIDE_PAIR
, CH_CENTER_PAIR
},
859 { CH_WIDE_PAIR
, AV_CH_FRONT_CENTER
},
860 { AV_CH_FRONT_CENTER
, CH_FRONT_PAIR
},
861 { AV_CH_FRONT_CENTER
, CH_CENTER_PAIR
},
862 { AV_CH_FRONT_CENTER
, CH_WIDE_PAIR
},
863 { CH_SIDE_PAIR
, CH_DIRECT_PAIR
},
864 { CH_SIDE_PAIR
, CH_BACK_PAIR
},
865 { CH_SIDE_PAIR
, AV_CH_BACK_CENTER
},
866 { CH_BACK_PAIR
, CH_DIRECT_PAIR
},
867 { CH_BACK_PAIR
, CH_SIDE_PAIR
},
868 { CH_BACK_PAIR
, AV_CH_BACK_CENTER
},
869 { AV_CH_BACK_CENTER
, CH_BACK_PAIR
},
870 { AV_CH_BACK_CENTER
, CH_DIRECT_PAIR
},
871 { AV_CH_BACK_CENTER
, CH_SIDE_PAIR
},
874 static void swap_channel_layouts_on_filter(AVFilterContext
*filter
)
876 AVFilterLink
*link
= NULL
;
879 for (i
= 0; i
< filter
->nb_inputs
; i
++) {
880 link
= filter
->inputs
[i
];
882 if (link
->type
== AVMEDIA_TYPE_AUDIO
&&
883 link
->out_channel_layouts
->nb_channel_layouts
== 1)
886 if (i
== filter
->nb_inputs
)
889 for (i
= 0; i
< filter
->nb_outputs
; i
++) {
890 AVFilterLink
*outlink
= filter
->outputs
[i
];
891 int best_idx
= -1, best_score
= INT_MIN
, best_count_diff
= INT_MAX
;
893 if (outlink
->type
!= AVMEDIA_TYPE_AUDIO
||
894 outlink
->in_channel_layouts
->nb_channel_layouts
< 2)
897 for (j
= 0; j
< outlink
->in_channel_layouts
->nb_channel_layouts
; j
++) {
898 uint64_t in_chlayout
= link
->out_channel_layouts
->channel_layouts
[0];
899 uint64_t out_chlayout
= outlink
->in_channel_layouts
->channel_layouts
[j
];
900 int in_channels
= av_get_channel_layout_nb_channels(in_chlayout
);
901 int out_channels
= av_get_channel_layout_nb_channels(out_chlayout
);
902 int count_diff
= out_channels
- in_channels
;
903 int matched_channels
, extra_channels
;
906 if (FF_LAYOUT2COUNT(in_chlayout
) || FF_LAYOUT2COUNT(out_chlayout
)) {
907 /* Compute score in case the input or output layout encodes
908 a channel count; in this case the score is not altered by
909 the computation afterwards, as in_chlayout and
910 out_chlayout have both been set to 0 */
911 if (FF_LAYOUT2COUNT(in_chlayout
))
912 in_channels
= FF_LAYOUT2COUNT(in_chlayout
);
913 if (FF_LAYOUT2COUNT(out_chlayout
))
914 out_channels
= FF_LAYOUT2COUNT(out_chlayout
);
915 score
-= 10000 + FFABS(out_channels
- in_channels
) +
916 (in_channels
> out_channels
? 10000 : 0);
917 in_chlayout
= out_chlayout
= 0;
918 /* Let the remaining computation run, even if the score
919 value is not altered */
922 /* channel substitution */
923 for (k
= 0; k
< FF_ARRAY_ELEMS(ch_subst
); k
++) {
924 uint64_t cmp0
= ch_subst
[k
][0];
925 uint64_t cmp1
= ch_subst
[k
][1];
926 if (( in_chlayout
& cmp0
) && (!(out_chlayout
& cmp0
)) &&
927 (out_chlayout
& cmp1
) && (!( in_chlayout
& cmp1
))) {
928 in_chlayout
&= ~cmp0
;
929 out_chlayout
&= ~cmp1
;
930 /* add score for channel match, minus a deduction for
931 having to do the substitution */
932 score
+= 10 * av_get_channel_layout_nb_channels(cmp1
) - 2;
936 /* no penalty for LFE channel mismatch */
937 if ( (in_chlayout
& AV_CH_LOW_FREQUENCY
) &&
938 (out_chlayout
& AV_CH_LOW_FREQUENCY
))
940 in_chlayout
&= ~AV_CH_LOW_FREQUENCY
;
941 out_chlayout
&= ~AV_CH_LOW_FREQUENCY
;
943 matched_channels
= av_get_channel_layout_nb_channels(in_chlayout
&
945 extra_channels
= av_get_channel_layout_nb_channels(out_chlayout
&
947 score
+= 10 * matched_channels
- 5 * extra_channels
;
949 if (score
> best_score
||
950 (count_diff
< best_count_diff
&& score
== best_score
)) {
953 best_count_diff
= count_diff
;
956 av_assert0(best_idx
>= 0);
957 FFSWAP(uint64_t, outlink
->in_channel_layouts
->channel_layouts
[0],
958 outlink
->in_channel_layouts
->channel_layouts
[best_idx
]);
963 static void swap_channel_layouts(AVFilterGraph
*graph
)
967 for (i
= 0; i
< graph
->nb_filters
; i
++)
968 swap_channel_layouts_on_filter(graph
->filters
[i
]);
971 static void swap_sample_fmts_on_filter(AVFilterContext
*filter
)
973 AVFilterLink
*link
= NULL
;
977 for (i
= 0; i
< filter
->nb_inputs
; i
++) {
978 link
= filter
->inputs
[i
];
980 if (link
->type
== AVMEDIA_TYPE_AUDIO
&&
981 link
->out_formats
->nb_formats
== 1)
984 if (i
== filter
->nb_inputs
)
987 format
= link
->out_formats
->formats
[0];
988 bps
= av_get_bytes_per_sample(format
);
990 for (i
= 0; i
< filter
->nb_outputs
; i
++) {
991 AVFilterLink
*outlink
= filter
->outputs
[i
];
992 int best_idx
= -1, best_score
= INT_MIN
;
994 if (outlink
->type
!= AVMEDIA_TYPE_AUDIO
||
995 outlink
->in_formats
->nb_formats
< 2)
998 for (j
= 0; j
< outlink
->in_formats
->nb_formats
; j
++) {
999 int out_format
= outlink
->in_formats
->formats
[j
];
1000 int out_bps
= av_get_bytes_per_sample(out_format
);
1003 if (av_get_packed_sample_fmt(out_format
) == format
||
1004 av_get_planar_sample_fmt(out_format
) == format
) {
1009 /* for s32 and float prefer double to prevent loss of information */
1010 if (bps
== 4 && out_bps
== 8) {
1015 /* prefer closest higher or equal bps */
1016 score
= -abs(out_bps
- bps
);
1020 if (score
> best_score
) {
1025 av_assert0(best_idx
>= 0);
1026 FFSWAP(int, outlink
->in_formats
->formats
[0],
1027 outlink
->in_formats
->formats
[best_idx
]);
1031 static void swap_sample_fmts(AVFilterGraph
*graph
)
1035 for (i
= 0; i
< graph
->nb_filters
; i
++)
1036 swap_sample_fmts_on_filter(graph
->filters
[i
]);
1040 static int pick_formats(AVFilterGraph
*graph
)
1047 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1048 AVFilterContext
*filter
= graph
->filters
[i
];
1049 if (filter
->nb_inputs
){
1050 for (j
= 0; j
< filter
->nb_inputs
; j
++){
1051 if(filter
->inputs
[j
]->in_formats
&& filter
->inputs
[j
]->in_formats
->nb_formats
== 1) {
1052 if ((ret
= pick_format(filter
->inputs
[j
], NULL
)) < 0)
1058 if (filter
->nb_outputs
){
1059 for (j
= 0; j
< filter
->nb_outputs
; j
++){
1060 if(filter
->outputs
[j
]->in_formats
&& filter
->outputs
[j
]->in_formats
->nb_formats
== 1) {
1061 if ((ret
= pick_format(filter
->outputs
[j
], NULL
)) < 0)
1067 if (filter
->nb_inputs
&& filter
->nb_outputs
&& filter
->inputs
[0]->format
>=0) {
1068 for (j
= 0; j
< filter
->nb_outputs
; j
++) {
1069 if(filter
->outputs
[j
]->format
<0) {
1070 if ((ret
= pick_format(filter
->outputs
[j
], filter
->inputs
[0])) < 0)
1079 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1080 AVFilterContext
*filter
= graph
->filters
[i
];
1082 for (j
= 0; j
< filter
->nb_inputs
; j
++)
1083 if ((ret
= pick_format(filter
->inputs
[j
], NULL
)) < 0)
1085 for (j
= 0; j
< filter
->nb_outputs
; j
++)
1086 if ((ret
= pick_format(filter
->outputs
[j
], NULL
)) < 0)
1093 * Configure the formats of all the links in the graph.
1095 static int graph_config_formats(AVFilterGraph
*graph
, AVClass
*log_ctx
)
1099 /* find supported formats from sub-filters, and merge along links */
1100 while ((ret
= query_formats(graph
, log_ctx
)) == AVERROR(EAGAIN
))
1101 av_log(graph
, AV_LOG_DEBUG
, "query_formats not finished\n");
1105 /* Once everything is merged, it's possible that we'll still have
1106 * multiple valid media format choices. We try to minimize the amount
1107 * of format conversion inside filters */
1108 reduce_formats(graph
);
1110 /* for audio filters, ensure the best format, sample rate and channel layout
1112 swap_sample_fmts(graph
);
1113 swap_samplerates(graph
);
1114 swap_channel_layouts(graph
);
1116 if ((ret
= pick_formats(graph
)) < 0)
1122 static int ff_avfilter_graph_config_pointers(AVFilterGraph
*graph
,
1126 int sink_links_count
= 0, n
= 0;
1128 AVFilterLink
**sinks
;
1130 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1131 f
= graph
->filters
[i
];
1132 for (j
= 0; j
< f
->nb_inputs
; j
++) {
1133 f
->inputs
[j
]->graph
= graph
;
1134 f
->inputs
[j
]->age_index
= -1;
1136 for (j
= 0; j
< f
->nb_outputs
; j
++) {
1137 f
->outputs
[j
]->graph
= graph
;
1138 f
->outputs
[j
]->age_index
= -1;
1140 if (!f
->nb_outputs
) {
1141 if (f
->nb_inputs
> INT_MAX
- sink_links_count
)
1142 return AVERROR(EINVAL
);
1143 sink_links_count
+= f
->nb_inputs
;
1146 sinks
= av_calloc(sink_links_count
, sizeof(*sinks
));
1148 return AVERROR(ENOMEM
);
1149 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1150 f
= graph
->filters
[i
];
1151 if (!f
->nb_outputs
) {
1152 for (j
= 0; j
< f
->nb_inputs
; j
++) {
1153 sinks
[n
] = f
->inputs
[j
];
1154 f
->inputs
[j
]->age_index
= n
++;
1158 av_assert0(n
== sink_links_count
);
1159 graph
->sink_links
= sinks
;
1160 graph
->sink_links_count
= sink_links_count
;
1164 static int graph_insert_fifos(AVFilterGraph
*graph
, AVClass
*log_ctx
)
1170 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1171 f
= graph
->filters
[i
];
1173 for (j
= 0; j
< f
->nb_inputs
; j
++) {
1174 AVFilterLink
*link
= f
->inputs
[j
];
1175 AVFilterContext
*fifo_ctx
;
1179 if (!link
->dstpad
->needs_fifo
)
1182 fifo
= f
->inputs
[j
]->type
== AVMEDIA_TYPE_VIDEO
?
1183 avfilter_get_by_name("fifo") :
1184 avfilter_get_by_name("afifo");
1186 snprintf(name
, sizeof(name
), "auto-inserted fifo %d", fifo_count
++);
1188 ret
= avfilter_graph_create_filter(&fifo_ctx
, fifo
, name
, NULL
,
1193 ret
= avfilter_insert_filter(link
, fifo_ctx
, 0, 0);
1202 int avfilter_graph_config(AVFilterGraph
*graphctx
, void *log_ctx
)
1206 if ((ret
= graph_check_validity(graphctx
, log_ctx
)))
1208 if ((ret
= graph_insert_fifos(graphctx
, log_ctx
)) < 0)
1210 if ((ret
= graph_config_formats(graphctx
, log_ctx
)))
1212 if ((ret
= graph_config_links(graphctx
, log_ctx
)))
1214 if ((ret
= ff_avfilter_graph_config_pointers(graphctx
, log_ctx
)))
1220 int avfilter_graph_send_command(AVFilterGraph
*graph
, const char *target
, const char *cmd
, const char *arg
, char *res
, int res_len
, int flags
)
1222 int i
, r
= AVERROR(ENOSYS
);
1227 if ((flags
& AVFILTER_CMD_FLAG_ONE
) && !(flags
& AVFILTER_CMD_FLAG_FAST
)) {
1228 r
= avfilter_graph_send_command(graph
, target
, cmd
, arg
, res
, res_len
, flags
| AVFILTER_CMD_FLAG_FAST
);
1229 if (r
!= AVERROR(ENOSYS
))
1236 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1237 AVFilterContext
*filter
= graph
->filters
[i
];
1238 if (!strcmp(target
, "all") || (filter
->name
&& !strcmp(target
, filter
->name
)) || !strcmp(target
, filter
->filter
->name
)) {
1239 r
= avfilter_process_command(filter
, cmd
, arg
, res
, res_len
, flags
);
1240 if (r
!= AVERROR(ENOSYS
)) {
1241 if ((flags
& AVFILTER_CMD_FLAG_ONE
) || r
< 0)
1250 int avfilter_graph_queue_command(AVFilterGraph
*graph
, const char *target
, const char *command
, const char *arg
, int flags
, double ts
)
1257 for (i
= 0; i
< graph
->nb_filters
; i
++) {
1258 AVFilterContext
*filter
= graph
->filters
[i
];
1259 if(filter
&& (!strcmp(target
, "all") || !strcmp(target
, filter
->name
) || !strcmp(target
, filter
->filter
->name
))){
1260 AVFilterCommand
**queue
= &filter
->command_queue
, *next
;
1261 while (*queue
&& (*queue
)->time
<= ts
)
1262 queue
= &(*queue
)->next
;
1264 *queue
= av_mallocz(sizeof(AVFilterCommand
));
1265 (*queue
)->command
= av_strdup(command
);
1266 (*queue
)->arg
= av_strdup(arg
);
1267 (*queue
)->time
= ts
;
1268 (*queue
)->flags
= flags
;
1269 (*queue
)->next
= next
;
1270 if(flags
& AVFILTER_CMD_FLAG_ONE
)
1278 static void heap_bubble_up(AVFilterGraph
*graph
,
1279 AVFilterLink
*link
, int index
)
1281 AVFilterLink
**links
= graph
->sink_links
;
1284 int parent
= (index
- 1) >> 1;
1285 if (links
[parent
]->current_pts
>= link
->current_pts
)
1287 links
[index
] = links
[parent
];
1288 links
[index
]->age_index
= index
;
1291 links
[index
] = link
;
1292 link
->age_index
= index
;
1295 static void heap_bubble_down(AVFilterGraph
*graph
,
1296 AVFilterLink
*link
, int index
)
1298 AVFilterLink
**links
= graph
->sink_links
;
1301 int child
= 2 * index
+ 1;
1302 if (child
>= graph
->sink_links_count
)
1304 if (child
+ 1 < graph
->sink_links_count
&&
1305 links
[child
+ 1]->current_pts
< links
[child
]->current_pts
)
1307 if (link
->current_pts
< links
[child
]->current_pts
)
1309 links
[index
] = links
[child
];
1310 links
[index
]->age_index
= index
;
1313 links
[index
] = link
;
1314 link
->age_index
= index
;
1317 void ff_avfilter_graph_update_heap(AVFilterGraph
*graph
, AVFilterLink
*link
)
1319 heap_bubble_up (graph
, link
, link
->age_index
);
1320 heap_bubble_down(graph
, link
, link
->age_index
);
1324 int avfilter_graph_request_oldest(AVFilterGraph
*graph
)
1326 while (graph
->sink_links_count
) {
1327 AVFilterLink
*oldest
= graph
->sink_links
[0];
1328 int r
= ff_request_frame(oldest
);
1329 if (r
!= AVERROR_EOF
)
1331 av_log(oldest
->dst
, AV_LOG_DEBUG
, "EOF on sink link %s:%s.\n",
1332 oldest
->dst
? oldest
->dst
->name
: "unknown",
1333 oldest
->dstpad
? oldest
->dstpad
->name
: "unknown");
1334 /* EOF: remove the link from the heap */
1335 if (oldest
->age_index
< --graph
->sink_links_count
)
1336 heap_bubble_down(graph
, graph
->sink_links
[graph
->sink_links_count
],
1338 oldest
->age_index
= -1;