LCOV - code coverage report
Current view: top level - src/libavfilter - avfiltergraph.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 552 745 74.1 %
Date: 2017-04-23 07:57:23 Functions: 35 39 89.7 %

          Line data    Source code
       1             : /*
       2             :  * filter graphs
       3             :  * Copyright (c) 2008 Vitor Sessak
       4             :  * Copyright (c) 2007 Bobby Bingham
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       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.
      12             :  *
      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.
      17             :  *
      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
      21             :  */
      22             : 
      23             : #include "config.h"
      24             : 
      25             : #include <string.h>
      26             : 
      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"
      34             : 
      35             : #define FF_INTERNAL_FIELDS 1
      36             : #include "framequeue.h"
      37             : 
      38             : #include "avfilter.h"
      39             : #include "buffersink.h"
      40             : #include "formats.h"
      41             : #include "internal.h"
      42             : #include "thread.h"
      43             : 
      44             : #define OFFSET(x) offsetof(AVFilterGraph, x)
      45             : #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
      46             : static const AVOption filtergraph_options[] = {
      47             :     { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
      48             :         { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
      49             :         { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
      50             :     { "threads",     "Maximum number of threads", OFFSET(nb_threads),
      51             :         AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, INT_MAX, FLAGS },
      52             :     {"scale_sws_opts"       , "default scale filter options"        , OFFSET(scale_sws_opts)        ,
      53             :         AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
      54             :     {"aresample_swr_opts"   , "default aresample filter options"    , OFFSET(aresample_swr_opts)    ,
      55             :         AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
      56             :     { NULL },
      57             : };
      58             : 
      59             : static const AVClass filtergraph_class = {
      60             :     .class_name = "AVFilterGraph",
      61             :     .item_name  = av_default_item_name,
      62             :     .version    = LIBAVUTIL_VERSION_INT,
      63             :     .option     = filtergraph_options,
      64             :     .category   = AV_CLASS_CATEGORY_FILTER,
      65             : };
      66             : 
      67             : #if !HAVE_THREADS
      68             : void ff_graph_thread_free(AVFilterGraph *graph)
      69             : {
      70             : }
      71             : 
      72             : int ff_graph_thread_init(AVFilterGraph *graph)
      73             : {
      74             :     graph->thread_type = 0;
      75             :     graph->nb_threads  = 1;
      76             :     return 0;
      77             : }
      78             : #endif
      79             : 
      80        5238 : AVFilterGraph *avfilter_graph_alloc(void)
      81             : {
      82        5238 :     AVFilterGraph *ret = av_mallocz(sizeof(*ret));
      83        5238 :     if (!ret)
      84           0 :         return NULL;
      85             : 
      86        5238 :     ret->internal = av_mallocz(sizeof(*ret->internal));
      87        5238 :     if (!ret->internal) {
      88           0 :         av_freep(&ret);
      89           0 :         return NULL;
      90             :     }
      91             : 
      92        5238 :     ret->av_class = &filtergraph_class;
      93        5238 :     av_opt_set_defaults(ret);
      94        5238 :     ff_framequeue_global_init(&ret->internal->frame_queues);
      95             : 
      96        5238 :     return ret;
      97             : }
      98             : 
      99       25877 : void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
     100             : {
     101             :     int i, j;
     102       25877 :     for (i = 0; i < graph->nb_filters; i++) {
     103       25877 :         if (graph->filters[i] == filter) {
     104       25877 :             FFSWAP(AVFilterContext*, graph->filters[i],
     105             :                    graph->filters[graph->nb_filters - 1]);
     106       25877 :             graph->nb_filters--;
     107       25877 :             filter->graph = NULL;
     108       46637 :             for (j = 0; j<filter->nb_outputs; j++)
     109       20760 :                 if (filter->outputs[j])
     110       10341 :                     filter->outputs[j]->graph = NULL;
     111             : 
     112       25877 :             return;
     113             :         }
     114             :     }
     115             : }
     116             : 
     117       10320 : void avfilter_graph_free(AVFilterGraph **graph)
     118             : {
     119       10320 :     if (!*graph)
     120        5082 :         return;
     121             : 
     122       36296 :     while ((*graph)->nb_filters)
     123       25820 :         avfilter_free((*graph)->filters[0]);
     124             : 
     125        5238 :     ff_graph_thread_free(*graph);
     126             : 
     127        5238 :     av_freep(&(*graph)->sink_links);
     128             : 
     129        5238 :     av_freep(&(*graph)->scale_sws_opts);
     130        5238 :     av_freep(&(*graph)->aresample_swr_opts);
     131             : #if FF_API_LAVR_OPTS
     132        5238 :     av_freep(&(*graph)->resample_lavr_opts);
     133             : #endif
     134        5238 :     av_freep(&(*graph)->filters);
     135        5238 :     av_freep(&(*graph)->internal);
     136        5238 :     av_freep(graph);
     137             : }
     138             : 
     139             : #if FF_API_AVFILTER_OPEN
     140           0 : int avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter)
     141             : {
     142           0 :     AVFilterContext **filters = av_realloc(graph->filters,
     143           0 :                                            sizeof(*filters) * (graph->nb_filters + 1));
     144           0 :     if (!filters)
     145           0 :         return AVERROR(ENOMEM);
     146             : 
     147           0 :     graph->filters = filters;
     148           0 :     graph->filters[graph->nb_filters++] = filter;
     149             : 
     150           0 :     filter->graph = graph;
     151             : 
     152           0 :     return 0;
     153             : }
     154             : #endif
     155             : 
     156       17556 : int avfilter_graph_create_filter(AVFilterContext **filt_ctx, const AVFilter *filt,
     157             :                                  const char *name, const char *args, void *opaque,
     158             :                                  AVFilterGraph *graph_ctx)
     159             : {
     160             :     int ret;
     161             : 
     162       17556 :     *filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name);
     163       17556 :     if (!*filt_ctx)
     164           0 :         return AVERROR(ENOMEM);
     165             : 
     166       17556 :     ret = avfilter_init_str(*filt_ctx, args);
     167       17556 :     if (ret < 0)
     168           0 :         goto fail;
     169             : 
     170       17556 :     return 0;
     171             : 
     172             : fail:
     173           0 :     if (*filt_ctx)
     174           0 :         avfilter_free(*filt_ctx);
     175           0 :     *filt_ctx = NULL;
     176           0 :     return ret;
     177             : }
     178             : 
     179          14 : void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
     180             : {
     181          14 :     graph->disable_auto_convert = flags;
     182          14 : }
     183             : 
     184       25877 : AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
     185             :                                              const AVFilter *filter,
     186             :                                              const char *name)
     187             : {
     188             :     AVFilterContext **filters, *s;
     189             : 
     190       25877 :     if (graph->thread_type && !graph->internal->thread_execute) {
     191        5238 :         if (graph->execute) {
     192           0 :             graph->internal->thread_execute = graph->execute;
     193             :         } else {
     194        5238 :             int ret = ff_graph_thread_init(graph);
     195        5238 :             if (ret < 0) {
     196           0 :                 av_log(graph, AV_LOG_ERROR, "Error initializing threading.\n");
     197           0 :                 return NULL;
     198             :             }
     199             :         }
     200             :     }
     201             : 
     202       25877 :     s = ff_filter_alloc(filter, name);
     203       25877 :     if (!s)
     204           0 :         return NULL;
     205             : 
     206       25877 :     filters = av_realloc(graph->filters, sizeof(*filters) * (graph->nb_filters + 1));
     207       25877 :     if (!filters) {
     208           0 :         avfilter_free(s);
     209           0 :         return NULL;
     210             :     }
     211             : 
     212       25877 :     graph->filters = filters;
     213       25877 :     graph->filters[graph->nb_filters++] = s;
     214             : 
     215       25877 :     s->graph = graph;
     216             : 
     217       25877 :     return s;
     218             : }
     219             : 
     220             : /**
     221             :  * Check for the validity of graph.
     222             :  *
     223             :  * A graph is considered valid if all its input and output pads are
     224             :  * connected.
     225             :  *
     226             :  * @return >= 0 in case of success, a negative value otherwise
     227             :  */
     228        5137 : static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)
     229             : {
     230             :     AVFilterContext *filt;
     231             :     int i, j;
     232             : 
     233       28236 :     for (i = 0; i < graph->nb_filters; i++) {
     234             :         const AVFilterPad *pad;
     235       23099 :         filt = graph->filters[i];
     236             : 
     237       41069 :         for (j = 0; j < filt->nb_inputs; j++) {
     238       17970 :             if (!filt->inputs[j] || !filt->inputs[j]->src) {
     239           0 :                 pad = &filt->input_pads[j];
     240           0 :                 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           0 :                        pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
     243           0 :                 return AVERROR(EINVAL);
     244             :             }
     245             :         }
     246             : 
     247       41069 :         for (j = 0; j < filt->nb_outputs; j++) {
     248       17970 :             if (!filt->outputs[j] || !filt->outputs[j]->dst) {
     249           0 :                 pad = &filt->output_pads[j];
     250           0 :                 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           0 :                        pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
     253           0 :                 return AVERROR(EINVAL);
     254             :             }
     255             :         }
     256             :     }
     257             : 
     258        5137 :     return 0;
     259             : }
     260             : 
     261             : /**
     262             :  * Configure all the links of graphctx.
     263             :  *
     264             :  * @return >= 0 in case of success, a negative value otherwise
     265             :  */
     266        5137 : static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)
     267             : {
     268             :     AVFilterContext *filt;
     269             :     int i, ret;
     270             : 
     271       30866 :     for (i = 0; i < graph->nb_filters; i++) {
     272       25729 :         filt = graph->filters[i];
     273             : 
     274       25729 :         if (!filt->nb_outputs) {
     275        5141 :             if ((ret = avfilter_config_links(filt)))
     276           0 :                 return ret;
     277             :         }
     278             :     }
     279             : 
     280        5137 :     return 0;
     281             : }
     282             : 
     283           0 : AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, const char *name)
     284             : {
     285             :     int i;
     286             : 
     287           0 :     for (i = 0; i < graph->nb_filters; i++)
     288           0 :         if (graph->filters[i]->name && !strcmp(name, graph->filters[i]->name))
     289           0 :             return graph->filters[i];
     290             : 
     291           0 :     return NULL;
     292             : }
     293             : 
     294       32840 : static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l)
     295             : {
     296       32840 :     if (!l)
     297       25520 :         return;
     298        7320 :     if (l->nb_channel_layouts) {
     299        1213 :         if (l->all_layouts || l->all_counts)
     300           0 :             av_log(log, AV_LOG_WARNING, "All layouts set on non-empty list\n");
     301        1213 :         l->all_layouts = l->all_counts = 0;
     302             :     } else {
     303        6107 :         if (l->all_counts && !l->all_layouts)
     304           0 :             av_log(log, AV_LOG_WARNING, "All counts without all layouts\n");
     305        6107 :         l->all_layouts = 1;
     306             :     }
     307             : }
     308             : 
     309       21568 : static int filter_query_formats(AVFilterContext *ctx)
     310             : {
     311             :     int ret, i;
     312             :     AVFilterFormats *formats;
     313             :     AVFilterChannelLayouts *chlayouts;
     314             :     AVFilterFormats *samplerates;
     315       26734 :     enum AVMediaType type = ctx->inputs  && ctx->inputs [0] ? ctx->inputs [0]->type :
     316        5166 :                             ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
     317             :                             AVMEDIA_TYPE_VIDEO;
     318             : 
     319       21568 :     if ((ret = ctx->filter->query_formats(ctx)) < 0) {
     320          14 :         if (ret != AVERROR(EAGAIN))
     321           0 :             av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
     322           0 :                    ctx->name, av_err2str(ret));
     323          14 :         return ret;
     324             :     }
     325             : 
     326       37979 :     for (i = 0; i < ctx->nb_inputs; i++)
     327       16425 :         sanitize_channel_layouts(ctx, ctx->inputs[i]->out_channel_layouts);
     328       37969 :     for (i = 0; i < ctx->nb_outputs; i++)
     329       16415 :         sanitize_channel_layouts(ctx, ctx->outputs[i]->in_channel_layouts);
     330             : 
     331       21554 :     formats = ff_all_formats(type);
     332       21554 :     if ((ret = ff_set_common_formats(ctx, formats)) < 0)
     333           0 :         return ret;
     334       21554 :     if (type == AVMEDIA_TYPE_AUDIO) {
     335        4720 :         samplerates = ff_all_samplerates();
     336        4720 :         if ((ret = ff_set_common_samplerates(ctx, samplerates)) < 0)
     337           0 :             return ret;
     338        4720 :         chlayouts = ff_all_channel_layouts();
     339        4720 :         if ((ret = ff_set_common_channel_layouts(ctx, chlayouts)) < 0)
     340           0 :             return ret;
     341             :     }
     342       21554 :     return 0;
     343             : }
     344             : 
     345       23169 : static int formats_declared(AVFilterContext *f)
     346             : {
     347             :     int i;
     348             : 
     349       23204 :     for (i = 0; i < f->nb_inputs; i++) {
     350       17992 :         if (!f->inputs[i]->out_formats)
     351       17957 :             return 0;
     352          37 :         if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
     353           4 :             !(f->inputs[i]->out_samplerates &&
     354           2 :               f->inputs[i]->out_channel_layouts))
     355           0 :             return 0;
     356             :     }
     357        5246 :     for (i = 0; i < f->nb_outputs; i++) {
     358        5202 :         if (!f->outputs[i]->in_formats)
     359        5168 :             return 0;
     360          37 :         if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
     361           6 :             !(f->outputs[i]->in_samplerates &&
     362           3 :               f->outputs[i]->in_channel_layouts))
     363           0 :             return 0;
     364             :     }
     365          44 :     return 1;
     366             : }
     367             : 
     368       44458 : static AVFilterFormats *clone_filter_formats(AVFilterFormats *arg)
     369             : {
     370       44458 :     AVFilterFormats *a = av_memdup(arg, sizeof(*arg));
     371       44458 :     if (a) {
     372       44458 :         a->refcount = 0;
     373       44458 :         a->refs     = NULL;
     374       44458 :         a->formats  = av_memdup(a->formats, sizeof(*a->formats) * a->nb_formats);
     375       44458 :         if (!a->formats && arg->formats)
     376           0 :             av_freep(&a);
     377             :     }
     378       44458 :     return a;
     379             : }
     380             : 
     381       22229 : static int can_merge_formats(AVFilterFormats *a_arg,
     382             :                              AVFilterFormats *b_arg,
     383             :                              enum AVMediaType type,
     384             :                              int is_sample_rate)
     385             : {
     386             :     AVFilterFormats *a, *b, *ret;
     387       22229 :     if (a_arg == b_arg)
     388           0 :         return 1;
     389       22229 :     a = clone_filter_formats(a_arg);
     390       22229 :     b = clone_filter_formats(b_arg);
     391             : 
     392       22229 :     if (!a || !b) {
     393           0 :         if (a)
     394           0 :             av_freep(&a->formats);
     395           0 :         if (b)
     396           0 :             av_freep(&b->formats);
     397             : 
     398           0 :         av_freep(&a);
     399           0 :         av_freep(&b);
     400             : 
     401           0 :         return 0;
     402             :     }
     403             : 
     404       22229 :     if (is_sample_rate) {
     405        4247 :         ret = ff_merge_samplerates(a, b);
     406             :     } else {
     407       17982 :         ret = ff_merge_formats(a, b, type);
     408             :     }
     409       22229 :     if (ret) {
     410       19606 :         av_freep(&ret->formats);
     411       19606 :         av_freep(&ret->refs);
     412       19606 :         av_freep(&ret);
     413       19606 :         return 1;
     414             :     } else {
     415        2623 :         av_freep(&a->formats);
     416        2623 :         av_freep(&b->formats);
     417        2623 :         av_freep(&a);
     418        2623 :         av_freep(&b);
     419        2623 :         return 0;
     420             :     }
     421             : }
     422             : 
     423             : /**
     424             :  * Perform one round of query_formats() and merging formats lists on the
     425             :  * filter graph.
     426             :  * @return  >=0 if all links formats lists could be queried and merged;
     427             :  *          AVERROR(EAGAIN) some progress was made in the queries or merging
     428             :  *          and a later call may succeed;
     429             :  *          AVERROR(EIO) (may be changed) plus a log message if no progress
     430             :  *          was made and the negotiation is stuck;
     431             :  *          a negative error code if some other error happened
     432             :  */
     433        5151 : static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
     434             : {
     435             :     int i, j, ret;
     436        5151 :     int scaler_count = 0, resampler_count = 0;
     437        5151 :     int count_queried = 0;        /* successful calls to query_formats() */
     438        5151 :     int count_merged = 0;         /* successful merge of formats lists */
     439        5151 :     int count_already_merged = 0; /* lists already merged */
     440        5151 :     int count_delayed = 0;        /* lists that need to be merged later */
     441             : 
     442       28320 :     for (i = 0; i < graph->nb_filters; i++) {
     443       23169 :         AVFilterContext *f = graph->filters[i];
     444       23169 :         if (formats_declared(f))
     445          44 :             continue;
     446       23125 :         if (f->filter->query_formats)
     447       18950 :             ret = filter_query_formats(f);
     448             :         else
     449        4175 :             ret = ff_default_query_formats(f);
     450       23125 :         if (ret < 0 && ret != AVERROR(EAGAIN))
     451           0 :             return ret;
     452             :         /* note: EAGAIN could indicate a partial success, not counted yet */
     453       23125 :         count_queried += ret >= 0;
     454             :     }
     455             : 
     456             :     /* go through and merge as many format lists as possible */
     457       30938 :     for (i = 0; i < graph->nb_filters; i++) {
     458       25787 :         AVFilterContext *filter = graph->filters[i];
     459             : 
     460       46435 :         for (j = 0; j < filter->nb_inputs; j++) {
     461       20648 :             AVFilterLink *link = filter->inputs[j];
     462       20648 :             int convert_needed = 0;
     463             : 
     464       20648 :             if (!link)
     465           0 :                 continue;
     466             : 
     467       20648 :             if (link->in_formats != link->out_formats
     468       18009 :                 && link->in_formats && link->out_formats)
     469       17982 :                 if (!can_merge_formats(link->in_formats, link->out_formats,
     470             :                                       link->type, 0))
     471        2606 :                     convert_needed = 1;
     472       20648 :             if (link->type == AVMEDIA_TYPE_AUDIO) {
     473        4782 :                 if (link->in_samplerates != link->out_samplerates
     474        4250 :                     && link->in_samplerates && link->out_samplerates)
     475        4247 :                     if (!can_merge_formats(link->in_samplerates,
     476             :                                            link->out_samplerates,
     477             :                                            0, 1))
     478          17 :                         convert_needed = 1;
     479             :             }
     480             : 
     481             : #define MERGE_DISPATCH(field, statement)                                     \
     482             :             if (!(link->in_ ## field && link->out_ ## field)) {              \
     483             :                 count_delayed++;                                             \
     484             :             } else if (link->in_ ## field == link->out_ ## field) {          \
     485             :                 count_already_merged++;                                      \
     486             :             } else if (!convert_needed) {                                    \
     487             :                 count_merged++;                                              \
     488             :                 statement                                                    \
     489             :             }
     490             : 
     491       20648 :             if (link->type == AVMEDIA_TYPE_AUDIO) {
     492        4782 :                 MERGE_DISPATCH(channel_layouts,
     493             :                     if (!ff_merge_channel_layouts(link->in_channel_layouts,
     494             :                                                   link->out_channel_layouts))
     495             :                         convert_needed = 1;
     496             :                 )
     497        4782 :                 MERGE_DISPATCH(samplerates,
     498             :                     if (!ff_merge_samplerates(link->in_samplerates,
     499             :                                               link->out_samplerates))
     500             :                         convert_needed = 1;
     501             :                 )
     502             :             }
     503       20648 :             MERGE_DISPATCH(formats,
     504             :                 if (!ff_merge_formats(link->in_formats, link->out_formats,
     505             :                                       link->type))
     506             :                     convert_needed = 1;
     507             :             )
     508             : #undef MERGE_DISPATCH
     509             : 
     510       20648 :             if (convert_needed) {
     511             :                 AVFilterContext *convert;
     512             :                 AVFilter *filter;
     513             :                 AVFilterLink *inlink, *outlink;
     514             :                 char scale_args[256];
     515             :                 char inst_name[30];
     516             : 
     517        2618 :                 if (graph->disable_auto_convert) {
     518           0 :                     av_log(log_ctx, AV_LOG_ERROR,
     519             :                            "The filters '%s' and '%s' do not have a common format "
     520             :                            "and automatic conversion is disabled.\n",
     521           0 :                            link->src->name, link->dst->name);
     522           0 :                     return AVERROR(EINVAL);
     523             :                 }
     524             : 
     525             :                 /* couldn't merge format lists. auto-insert conversion filter */
     526        2618 :                 switch (link->type) {
     527             :                 case AVMEDIA_TYPE_VIDEO:
     528        2087 :                     if (!(filter = avfilter_get_by_name("scale"))) {
     529           0 :                         av_log(log_ctx, AV_LOG_ERROR, "'scale' filter "
     530             :                                "not present, cannot convert pixel formats.\n");
     531           0 :                         return AVERROR(EINVAL);
     532             :                     }
     533             : 
     534        2087 :                     snprintf(inst_name, sizeof(inst_name), "auto_scaler_%d",
     535             :                              scaler_count++);
     536             : 
     537        2087 :                     if ((ret = avfilter_graph_create_filter(&convert, filter,
     538        2087 :                                                             inst_name, graph->scale_sws_opts, NULL,
     539             :                                                             graph)) < 0)
     540           0 :                         return ret;
     541        2087 :                     break;
     542             :                 case AVMEDIA_TYPE_AUDIO:
     543         531 :                     if (!(filter = avfilter_get_by_name("aresample"))) {
     544           0 :                         av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter "
     545             :                                "not present, cannot convert audio formats.\n");
     546           0 :                         return AVERROR(EINVAL);
     547             :                     }
     548             : 
     549         531 :                     snprintf(inst_name, sizeof(inst_name), "auto_resampler_%d",
     550             :                              resampler_count++);
     551         531 :                     scale_args[0] = '\0';
     552         531 :                     if (graph->aresample_swr_opts)
     553         503 :                         snprintf(scale_args, sizeof(scale_args), "%s",
     554             :                                  graph->aresample_swr_opts);
     555         531 :                     if ((ret = avfilter_graph_create_filter(&convert, filter,
     556         531 :                                                             inst_name, graph->aresample_swr_opts,
     557             :                                                             NULL, graph)) < 0)
     558           0 :                         return ret;
     559         531 :                     break;
     560             :                 default:
     561           0 :                     return AVERROR(EINVAL);
     562             :                 }
     563             : 
     564        2618 :                 if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
     565           0 :                     return ret;
     566             : 
     567        2618 :                 if ((ret = filter_query_formats(convert)) < 0)
     568           0 :                     return ret;
     569             : 
     570        2618 :                 inlink  = convert->inputs[0];
     571        2618 :                 outlink = convert->outputs[0];
     572        2618 :                 av_assert0( inlink-> in_formats->refcount > 0);
     573        2618 :                 av_assert0( inlink->out_formats->refcount > 0);
     574        2618 :                 av_assert0(outlink-> in_formats->refcount > 0);
     575        2618 :                 av_assert0(outlink->out_formats->refcount > 0);
     576        2618 :                 if (outlink->type == AVMEDIA_TYPE_AUDIO) {
     577         531 :                     av_assert0( inlink-> in_samplerates->refcount > 0);
     578         531 :                     av_assert0( inlink->out_samplerates->refcount > 0);
     579         531 :                     av_assert0(outlink-> in_samplerates->refcount > 0);
     580         531 :                     av_assert0(outlink->out_samplerates->refcount > 0);
     581         531 :                     av_assert0( inlink-> in_channel_layouts->refcount > 0);
     582         531 :                     av_assert0( inlink->out_channel_layouts->refcount > 0);
     583         531 :                     av_assert0(outlink-> in_channel_layouts->refcount > 0);
     584         531 :                     av_assert0(outlink->out_channel_layouts->refcount > 0);
     585             :                 }
     586        5236 :                 if (!ff_merge_formats( inlink->in_formats,  inlink->out_formats,  inlink->type) ||
     587        2618 :                     !ff_merge_formats(outlink->in_formats, outlink->out_formats, outlink->type))
     588           0 :                     ret = AVERROR(ENOSYS);
     589        3149 :                 if (inlink->type == AVMEDIA_TYPE_AUDIO &&
     590         531 :                     (!ff_merge_samplerates(inlink->in_samplerates,
     591         531 :                                            inlink->out_samplerates) ||
     592         531 :                      !ff_merge_channel_layouts(inlink->in_channel_layouts,
     593         531 :                                                inlink->out_channel_layouts)))
     594           0 :                     ret = AVERROR(ENOSYS);
     595        3149 :                 if (outlink->type == AVMEDIA_TYPE_AUDIO &&
     596         531 :                     (!ff_merge_samplerates(outlink->in_samplerates,
     597         531 :                                            outlink->out_samplerates) ||
     598         531 :                      !ff_merge_channel_layouts(outlink->in_channel_layouts,
     599         531 :                                                outlink->out_channel_layouts)))
     600           0 :                     ret = AVERROR(ENOSYS);
     601             : 
     602        2618 :                 if (ret < 0) {
     603           0 :                     av_log(log_ctx, AV_LOG_ERROR,
     604             :                            "Impossible to convert between the formats supported by the filter "
     605           0 :                            "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
     606           0 :                     return ret;
     607             :                 }
     608             :             }
     609             :         }
     610             :     }
     611             : 
     612        5151 :     av_log(graph, AV_LOG_DEBUG, "query_formats: "
     613             :            "%d queried, %d merged, %d already done, %d delayed\n",
     614             :            count_queried, count_merged, count_already_merged, count_delayed);
     615        5151 :     if (count_delayed) {
     616             :         AVBPrint bp;
     617             : 
     618             :         /* if count_queried > 0, one filter at least did set its formats,
     619             :            that will give additional information to its neighbour;
     620             :            if count_merged > 0, one pair of formats lists at least was merged,
     621             :            that will give additional information to all connected filters;
     622             :            in both cases, progress was made and a new round must be done */
     623          14 :         if (count_queried || count_merged)
     624          14 :             return AVERROR(EAGAIN);
     625           0 :         av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
     626           0 :         for (i = 0; i < graph->nb_filters; i++)
     627           0 :             if (!formats_declared(graph->filters[i]))
     628           0 :                 av_bprintf(&bp, "%s%s", bp.len ? ", " : "",
     629           0 :                           graph->filters[i]->name);
     630           0 :         av_log(graph, AV_LOG_ERROR,
     631             :                "The following filters could not choose their formats: %s\n"
     632             :                "Consider inserting the (a)format filter near their input or "
     633             :                "output.\n", bp.str);
     634           0 :         return AVERROR(EIO);
     635             :     }
     636        5137 :     return 0;
     637             : }
     638             : 
     639         158 : static int get_fmt_score(enum AVSampleFormat dst_fmt, enum AVSampleFormat src_fmt)
     640             : {
     641         158 :     int score = 0;
     642             : 
     643         158 :     if (av_sample_fmt_is_planar(dst_fmt) != av_sample_fmt_is_planar(src_fmt))
     644         141 :         score ++;
     645             : 
     646         158 :     if (av_get_bytes_per_sample(dst_fmt) < av_get_bytes_per_sample(src_fmt)) {
     647          48 :         score += 100 * (av_get_bytes_per_sample(src_fmt) - av_get_bytes_per_sample(dst_fmt));
     648             :     }else
     649         110 :         score += 10  * (av_get_bytes_per_sample(dst_fmt) - av_get_bytes_per_sample(src_fmt));
     650             : 
     651         183 :     if (av_get_packed_sample_fmt(dst_fmt) == AV_SAMPLE_FMT_S32 &&
     652          25 :         av_get_packed_sample_fmt(src_fmt) == AV_SAMPLE_FMT_FLT)
     653           0 :         score += 20;
     654             : 
     655         170 :     if (av_get_packed_sample_fmt(dst_fmt) == AV_SAMPLE_FMT_FLT &&
     656          12 :         av_get_packed_sample_fmt(src_fmt) == AV_SAMPLE_FMT_S32)
     657           0 :         score += 2;
     658             : 
     659         158 :     return score;
     660             : }
     661             : 
     662          79 : static enum AVSampleFormat find_best_sample_fmt_of_2(enum AVSampleFormat dst_fmt1, enum AVSampleFormat dst_fmt2,
     663             :                                                      enum AVSampleFormat src_fmt)
     664             : {
     665             :     int score1, score2;
     666             : 
     667          79 :     score1 = get_fmt_score(dst_fmt1, src_fmt);
     668          79 :     score2 = get_fmt_score(dst_fmt2, src_fmt);
     669             : 
     670          79 :     return score1 < score2 ? dst_fmt1 : dst_fmt2;
     671             : }
     672             : 
     673       61792 : static int pick_format(AVFilterLink *link, AVFilterLink *ref)
     674             : {
     675       61792 :     if (!link || !link->in_formats)
     676       41192 :         return 0;
     677             : 
     678       20600 :     if (link->type == AVMEDIA_TYPE_VIDEO) {
     679       15822 :         if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
     680          71 :             int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
     681          71 :             enum AVPixelFormat best= AV_PIX_FMT_NONE;
     682             :             int i;
     683         492 :             for (i=0; i<link->in_formats->nb_formats; i++) {
     684         421 :                 enum AVPixelFormat p = link->in_formats->formats[i];
     685         421 :                 best= av_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
     686             :             }
     687         142 :             av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
     688          71 :                    av_get_pix_fmt_name(best), link->in_formats->nb_formats,
     689          71 :                    av_get_pix_fmt_name(ref->format), has_alpha);
     690          71 :             link->in_formats->formats[0] = best;
     691             :         }
     692        4778 :     } else if (link->type == AVMEDIA_TYPE_AUDIO) {
     693        4778 :         if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
     694          21 :             enum AVSampleFormat best= AV_SAMPLE_FMT_NONE;
     695             :             int i;
     696         100 :             for (i=0; i<link->in_formats->nb_formats; i++) {
     697          79 :                 enum AVSampleFormat p = link->in_formats->formats[i];
     698          79 :                 best = find_best_sample_fmt_of_2(best, p, ref->format);
     699             :             }
     700          42 :             av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n",
     701          21 :                    av_get_sample_fmt_name(best), link->in_formats->nb_formats,
     702          21 :                    av_get_sample_fmt_name(ref->format));
     703          21 :             link->in_formats->formats[0] = best;
     704             :         }
     705             :     }
     706             : 
     707       20600 :     link->in_formats->nb_formats = 1;
     708       20600 :     link->format = link->in_formats->formats[0];
     709             : 
     710       20600 :     if (link->type == AVMEDIA_TYPE_AUDIO) {
     711        4778 :         if (!link->in_samplerates->nb_formats) {
     712           0 :             av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
     713           0 :                    " the link between filters %s and %s.\n", link->src->name,
     714           0 :                    link->dst->name);
     715           0 :             return AVERROR(EINVAL);
     716             :         }
     717        4778 :         link->in_samplerates->nb_formats = 1;
     718        4778 :         link->sample_rate = link->in_samplerates->formats[0];
     719             : 
     720        4778 :         if (link->in_channel_layouts->all_layouts) {
     721           0 :             av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
     722           0 :                    " the link between filters %s and %s.\n", link->src->name,
     723           0 :                    link->dst->name);
     724           0 :             if (!link->in_channel_layouts->all_counts)
     725           0 :                 av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not "
     726             :                        "supported, try specifying a channel layout using "
     727             :                        "'aformat=channel_layouts=something'.\n");
     728           0 :             return AVERROR(EINVAL);
     729             :         }
     730        4778 :         link->in_channel_layouts->nb_channel_layouts = 1;
     731        4778 :         link->channel_layout = link->in_channel_layouts->channel_layouts[0];
     732        4778 :         if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
     733          10 :             link->channel_layout = 0;
     734             :         else
     735        4768 :             link->channels = av_get_channel_layout_nb_channels(link->channel_layout);
     736             :     }
     737             : 
     738       20600 :     ff_formats_unref(&link->in_formats);
     739       20600 :     ff_formats_unref(&link->out_formats);
     740       20600 :     ff_formats_unref(&link->in_samplerates);
     741       20600 :     ff_formats_unref(&link->out_samplerates);
     742       20600 :     ff_channel_layouts_unref(&link->in_channel_layouts);
     743       20600 :     ff_channel_layouts_unref(&link->out_channel_layouts);
     744             : 
     745       20600 :     return 0;
     746             : }
     747             : 
     748             : #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format, unref_format) \
     749             : do {                                                                   \
     750             :     for (i = 0; i < filter->nb_inputs; i++) {                          \
     751             :         AVFilterLink *link = filter->inputs[i];                        \
     752             :         fmt_type fmt;                                                  \
     753             :                                                                        \
     754             :         if (!link->out_ ## list || link->out_ ## list->nb != 1)        \
     755             :             continue;                                                  \
     756             :         fmt = link->out_ ## list->var[0];                              \
     757             :                                                                        \
     758             :         for (j = 0; j < filter->nb_outputs; j++) {                     \
     759             :             AVFilterLink *out_link = filter->outputs[j];               \
     760             :             list_type *fmts;                                           \
     761             :                                                                        \
     762             :             if (link->type != out_link->type ||                        \
     763             :                 out_link->in_ ## list->nb == 1)                        \
     764             :                 continue;                                              \
     765             :             fmts = out_link->in_ ## list;                              \
     766             :                                                                        \
     767             :             if (!out_link->in_ ## list->nb) {                          \
     768             :                 if ((ret = add_format(&out_link->in_ ##list, fmt)) < 0)\
     769             :                     return ret;                                        \
     770             :                 ret = 1;                                               \
     771             :                 break;                                                 \
     772             :             }                                                          \
     773             :                                                                        \
     774             :             for (k = 0; k < out_link->in_ ## list->nb; k++)            \
     775             :                 if (fmts->var[k] == fmt) {                             \
     776             :                     fmts->var[0]  = fmt;                               \
     777             :                     fmts->nb = 1;                                      \
     778             :                     ret = 1;                                           \
     779             :                     break;                                             \
     780             :                 }                                                      \
     781             :         }                                                              \
     782             :     }                                                                  \
     783             : } while (0)
     784             : 
     785       28415 : static int reduce_formats_on_filter(AVFilterContext *filter)
     786             : {
     787       28415 :     int i, j, k, ret = 0;
     788             : 
     789       28415 :     REDUCE_FORMATS(int,      AVFilterFormats,        formats,         formats,
     790             :                    nb_formats, ff_add_format, ff_formats_unref);
     791       28415 :     REDUCE_FORMATS(int,      AVFilterFormats,        samplerates,     formats,
     792             :                    nb_formats, ff_add_format, ff_formats_unref);
     793             : 
     794             :     /* reduce channel layouts */
     795       51181 :     for (i = 0; i < filter->nb_inputs; i++) {
     796       22766 :         AVFilterLink *inlink = filter->inputs[i];
     797             :         uint64_t fmt;
     798             : 
     799       29545 :         if (!inlink->out_channel_layouts ||
     800        6779 :             inlink->out_channel_layouts->nb_channel_layouts != 1)
     801       17015 :             continue;
     802        5751 :         fmt = inlink->out_channel_layouts->channel_layouts[0];
     803             : 
     804        9329 :         for (j = 0; j < filter->nb_outputs; j++) {
     805        4698 :             AVFilterLink *outlink = filter->outputs[j];
     806             :             AVFilterChannelLayouts *fmts;
     807             : 
     808        4698 :             fmts = outlink->in_channel_layouts;
     809        4698 :             if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
     810        3558 :                 continue;
     811             : 
     812        2260 :             if (fmts->all_layouts &&
     813        1122 :                 (!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
     814             :                 /* Turn the infinite list into a singleton */
     815        1120 :                 fmts->all_layouts = fmts->all_counts  = 0;
     816        1120 :                 if (ff_add_channel_layout(&outlink->in_channel_layouts, fmt) < 0)
     817           0 :                     ret = 1;
     818        1120 :                 break;
     819             :             }
     820             : 
     821          70 :             for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) {
     822          68 :                 if (fmts->channel_layouts[k] == fmt) {
     823          18 :                     fmts->channel_layouts[0]  = fmt;
     824          18 :                     fmts->nb_channel_layouts = 1;
     825          18 :                     ret = 1;
     826          18 :                     break;
     827             :                 }
     828             :             }
     829             :         }
     830             :     }
     831             : 
     832       28415 :     return ret;
     833             : }
     834             : 
     835        5657 : static int reduce_formats(AVFilterGraph *graph)
     836             : {
     837             :     int i, reduced, ret;
     838             : 
     839             :     do {
     840        5657 :         reduced = 0;
     841             : 
     842       34072 :         for (i = 0; i < graph->nb_filters; i++) {
     843       28415 :             if ((ret = reduce_formats_on_filter(graph->filters[i])) < 0)
     844           0 :                 return ret;
     845       28415 :             reduced |= ret;
     846             :         }
     847        5657 :     } while (reduced);
     848             : 
     849        5137 :     return 0;
     850             : }
     851             : 
     852       25729 : static void swap_samplerates_on_filter(AVFilterContext *filter)
     853             : {
     854       25729 :     AVFilterLink *link = NULL;
     855             :     int sample_rate;
     856             :     int i, j;
     857             : 
     858       41549 :     for (i = 0; i < filter->nb_inputs; i++) {
     859       20589 :         link = filter->inputs[i];
     860             : 
     861       25358 :         if (link->type == AVMEDIA_TYPE_AUDIO &&
     862        4769 :             link->out_samplerates->nb_formats== 1)
     863        4769 :             break;
     864             :     }
     865       25729 :     if (i == filter->nb_inputs)
     866       20960 :         return;
     867             : 
     868        4769 :     sample_rate = link->out_samplerates->formats[0];
     869             : 
     870        8479 :     for (i = 0; i < filter->nb_outputs; i++) {
     871        3710 :         AVFilterLink *outlink = filter->outputs[i];
     872        3710 :         int best_idx, best_diff = INT_MAX;
     873             : 
     874        7419 :         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
     875        3709 :             outlink->in_samplerates->nb_formats < 2)
     876        3710 :             continue;
     877             : 
     878           0 :         for (j = 0; j < outlink->in_samplerates->nb_formats; j++) {
     879           0 :             int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
     880             : 
     881           0 :             av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
     882             : 
     883           0 :             if (diff < best_diff) {
     884           0 :                 best_diff = diff;
     885           0 :                 best_idx  = j;
     886             :             }
     887             :         }
     888           0 :         FFSWAP(int, outlink->in_samplerates->formats[0],
     889             :                outlink->in_samplerates->formats[best_idx]);
     890             :     }
     891             : }
     892             : 
     893        5137 : static void swap_samplerates(AVFilterGraph *graph)
     894             : {
     895             :     int i;
     896             : 
     897       30866 :     for (i = 0; i < graph->nb_filters; i++)
     898       25729 :         swap_samplerates_on_filter(graph->filters[i]);
     899        5137 : }
     900             : 
     901             : #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
     902             : #define CH_FRONT_PAIR  (AV_CH_FRONT_LEFT           | AV_CH_FRONT_RIGHT)
     903             : #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT          | AV_CH_STEREO_RIGHT)
     904             : #define CH_WIDE_PAIR   (AV_CH_WIDE_LEFT            | AV_CH_WIDE_RIGHT)
     905             : #define CH_SIDE_PAIR   (AV_CH_SIDE_LEFT            | AV_CH_SIDE_RIGHT)
     906             : #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
     907             : #define CH_BACK_PAIR   (AV_CH_BACK_LEFT            | AV_CH_BACK_RIGHT)
     908             : 
     909             : /* allowable substitutions for channel pairs when comparing layouts,
     910             :  * ordered by priority for both values */
     911             : static const uint64_t ch_subst[][2] = {
     912             :     { CH_FRONT_PAIR,      CH_CENTER_PAIR     },
     913             :     { CH_FRONT_PAIR,      CH_WIDE_PAIR       },
     914             :     { CH_FRONT_PAIR,      AV_CH_FRONT_CENTER },
     915             :     { CH_CENTER_PAIR,     CH_FRONT_PAIR      },
     916             :     { CH_CENTER_PAIR,     CH_WIDE_PAIR       },
     917             :     { CH_CENTER_PAIR,     AV_CH_FRONT_CENTER },
     918             :     { CH_WIDE_PAIR,       CH_FRONT_PAIR      },
     919             :     { CH_WIDE_PAIR,       CH_CENTER_PAIR     },
     920             :     { CH_WIDE_PAIR,       AV_CH_FRONT_CENTER },
     921             :     { AV_CH_FRONT_CENTER, CH_FRONT_PAIR      },
     922             :     { AV_CH_FRONT_CENTER, CH_CENTER_PAIR     },
     923             :     { AV_CH_FRONT_CENTER, CH_WIDE_PAIR       },
     924             :     { CH_SIDE_PAIR,       CH_DIRECT_PAIR     },
     925             :     { CH_SIDE_PAIR,       CH_BACK_PAIR       },
     926             :     { CH_SIDE_PAIR,       AV_CH_BACK_CENTER  },
     927             :     { CH_BACK_PAIR,       CH_DIRECT_PAIR     },
     928             :     { CH_BACK_PAIR,       CH_SIDE_PAIR       },
     929             :     { CH_BACK_PAIR,       AV_CH_BACK_CENTER  },
     930             :     { AV_CH_BACK_CENTER,  CH_BACK_PAIR       },
     931             :     { AV_CH_BACK_CENTER,  CH_DIRECT_PAIR     },
     932             :     { AV_CH_BACK_CENTER,  CH_SIDE_PAIR       },
     933             : };
     934             : 
     935       25729 : static void swap_channel_layouts_on_filter(AVFilterContext *filter)
     936             : {
     937       25729 :     AVFilterLink *link = NULL;
     938             :     int i, j, k;
     939             : 
     940       41551 :     for (i = 0; i < filter->nb_inputs; i++) {
     941       20589 :         link = filter->inputs[i];
     942             : 
     943       25358 :         if (link->type == AVMEDIA_TYPE_AUDIO &&
     944        4769 :             link->out_channel_layouts->nb_channel_layouts == 1)
     945        4767 :             break;
     946             :     }
     947       25729 :     if (i == filter->nb_inputs)
     948       20962 :         return;
     949             : 
     950        8476 :     for (i = 0; i < filter->nb_outputs; i++) {
     951        3709 :         AVFilterLink *outlink = filter->outputs[i];
     952        3709 :         int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
     953             : 
     954        7417 :         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
     955        3708 :             outlink->in_channel_layouts->nb_channel_layouts < 2)
     956        3708 :             continue;
     957             : 
     958          19 :         for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) {
     959          18 :             uint64_t  in_chlayout = link->out_channel_layouts->channel_layouts[0];
     960          18 :             uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j];
     961          18 :             int  in_channels      = av_get_channel_layout_nb_channels(in_chlayout);
     962          18 :             int out_channels      = av_get_channel_layout_nb_channels(out_chlayout);
     963          18 :             int count_diff        = out_channels - in_channels;
     964             :             int matched_channels, extra_channels;
     965          18 :             int score = 100000;
     966             : 
     967          18 :             if (FF_LAYOUT2COUNT(in_chlayout) || FF_LAYOUT2COUNT(out_chlayout)) {
     968             :                 /* Compute score in case the input or output layout encodes
     969             :                    a channel count; in this case the score is not altered by
     970             :                    the computation afterwards, as in_chlayout and
     971             :                    out_chlayout have both been set to 0 */
     972          18 :                 if (FF_LAYOUT2COUNT(in_chlayout))
     973          18 :                     in_channels = FF_LAYOUT2COUNT(in_chlayout);
     974          18 :                 if (FF_LAYOUT2COUNT(out_chlayout))
     975           0 :                     out_channels = FF_LAYOUT2COUNT(out_chlayout);
     976          36 :                 score -= 10000 + FFABS(out_channels - in_channels) +
     977          18 :                          (in_channels > out_channels ? 10000 : 0);
     978          18 :                 in_chlayout = out_chlayout = 0;
     979             :                 /* Let the remaining computation run, even if the score
     980             :                    value is not altered */
     981             :             }
     982             : 
     983             :             /* channel substitution */
     984         396 :             for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
     985         378 :                 uint64_t cmp0 = ch_subst[k][0];
     986         378 :                 uint64_t cmp1 = ch_subst[k][1];
     987         378 :                 if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&
     988           0 :                     (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {
     989           0 :                     in_chlayout  &= ~cmp0;
     990           0 :                     out_chlayout &= ~cmp1;
     991             :                     /* add score for channel match, minus a deduction for
     992             :                        having to do the substitution */
     993           0 :                     score += 10 * av_get_channel_layout_nb_channels(cmp1) - 2;
     994             :                 }
     995             :             }
     996             : 
     997             :             /* no penalty for LFE channel mismatch */
     998          18 :             if ( (in_chlayout & AV_CH_LOW_FREQUENCY) &&
     999           0 :                 (out_chlayout & AV_CH_LOW_FREQUENCY))
    1000           0 :                 score += 10;
    1001          18 :             in_chlayout  &= ~AV_CH_LOW_FREQUENCY;
    1002          18 :             out_chlayout &= ~AV_CH_LOW_FREQUENCY;
    1003             : 
    1004          18 :             matched_channels = av_get_channel_layout_nb_channels(in_chlayout &
    1005             :                                                                  out_chlayout);
    1006          18 :             extra_channels   = av_get_channel_layout_nb_channels(out_chlayout &
    1007          18 :                                                                  (~in_chlayout));
    1008          18 :             score += 10 * matched_channels - 5 * extra_channels;
    1009             : 
    1010          18 :             if (score > best_score ||
    1011           0 :                 (count_diff < best_count_diff && score == best_score)) {
    1012           1 :                 best_score = score;
    1013           1 :                 best_idx   = j;
    1014           1 :                 best_count_diff = count_diff;
    1015             :             }
    1016             :         }
    1017           1 :         av_assert0(best_idx >= 0);
    1018           1 :         FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0],
    1019             :                outlink->in_channel_layouts->channel_layouts[best_idx]);
    1020             :     }
    1021             : 
    1022             : }
    1023             : 
    1024        5137 : static void swap_channel_layouts(AVFilterGraph *graph)
    1025             : {
    1026             :     int i;
    1027             : 
    1028       30866 :     for (i = 0; i < graph->nb_filters; i++)
    1029       25729 :         swap_channel_layouts_on_filter(graph->filters[i]);
    1030        5137 : }
    1031             : 
    1032       25729 : static void swap_sample_fmts_on_filter(AVFilterContext *filter)
    1033             : {
    1034       25729 :     AVFilterLink *link = NULL;
    1035             :     int format, bps;
    1036             :     int i, j;
    1037             : 
    1038       41592 :     for (i = 0; i < filter->nb_inputs; i++) {
    1039       20590 :         link = filter->inputs[i];
    1040             : 
    1041       25360 :         if (link->type == AVMEDIA_TYPE_AUDIO &&
    1042        4770 :             link->out_formats->nb_formats == 1)
    1043        4727 :             break;
    1044             :     }
    1045       25729 :     if (i == filter->nb_inputs)
    1046       21002 :         return;
    1047             : 
    1048        4727 :     format = link->out_formats->formats[0];
    1049        4727 :     bps    = av_get_bytes_per_sample(format);
    1050             : 
    1051        8409 :     for (i = 0; i < filter->nb_outputs; i++) {
    1052        3682 :         AVFilterLink *outlink = filter->outputs[i];
    1053        3682 :         int best_idx = -1, best_score = INT_MIN;
    1054             : 
    1055        7363 :         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
    1056        3681 :             outlink->in_formats->nb_formats < 2)
    1057        3660 :             continue;
    1058             : 
    1059          49 :         for (j = 0; j < outlink->in_formats->nb_formats; j++) {
    1060          49 :             int out_format = outlink->in_formats->formats[j];
    1061          49 :             int out_bps    = av_get_bytes_per_sample(out_format);
    1062             :             int score;
    1063             : 
    1064          80 :             if (av_get_packed_sample_fmt(out_format) == format ||
    1065          31 :                 av_get_planar_sample_fmt(out_format) == format) {
    1066          22 :                 best_idx   = j;
    1067          22 :                 break;
    1068             :             }
    1069             : 
    1070             :             /* for s32 and float prefer double to prevent loss of information */
    1071          27 :             if (bps == 4 && out_bps == 8) {
    1072           0 :                 best_idx = j;
    1073           0 :                 break;
    1074             :             }
    1075             : 
    1076             :             /* prefer closest higher or equal bps */
    1077          27 :             score = -abs(out_bps - bps);
    1078          27 :             if (out_bps >= bps)
    1079           0 :                 score += INT_MAX/2;
    1080             : 
    1081          27 :             if (score > best_score) {
    1082          23 :                 best_score = score;
    1083          23 :                 best_idx   = j;
    1084             :             }
    1085             :         }
    1086          22 :         av_assert0(best_idx >= 0);
    1087          22 :         FFSWAP(int, outlink->in_formats->formats[0],
    1088             :                outlink->in_formats->formats[best_idx]);
    1089             :     }
    1090             : }
    1091             : 
    1092        5137 : static void swap_sample_fmts(AVFilterGraph *graph)
    1093             : {
    1094             :     int i;
    1095             : 
    1096       30866 :     for (i = 0; i < graph->nb_filters; i++)
    1097       25729 :         swap_sample_fmts_on_filter(graph->filters[i]);
    1098             : 
    1099        5137 : }
    1100             : 
    1101       10340 : static int pick_formats(AVFilterGraph *graph)
    1102             : {
    1103             :     int i, j, ret;
    1104             :     int change;
    1105             : 
    1106             :     do{
    1107       10340 :         change = 0;
    1108       62136 :         for (i = 0; i < graph->nb_filters; i++) {
    1109       51796 :             AVFilterContext *filter = graph->filters[i];
    1110       51796 :             if (filter->nb_inputs){
    1111       82872 :                 for (j = 0; j < filter->nb_inputs; j++){
    1112       41475 :                     if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->nb_formats == 1) {
    1113       10169 :                         if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
    1114           0 :                             return ret;
    1115       10169 :                         change = 1;
    1116             :                     }
    1117             :                 }
    1118             :             }
    1119       51796 :             if (filter->nb_outputs){
    1120       82923 :                 for (j = 0; j < filter->nb_outputs; j++){
    1121       41475 :                     if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->nb_formats == 1) {
    1122       10331 :                         if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
    1123           0 :                             return ret;
    1124       10331 :                         change = 1;
    1125             :                     }
    1126             :                 }
    1127             :             }
    1128       51796 :             if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
    1129       61943 :                 for (j = 0; j < filter->nb_outputs; j++) {
    1130       30984 :                     if(filter->outputs[j]->format<0) {
    1131          92 :                         if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
    1132           0 :                             return ret;
    1133          92 :                         change = 1;
    1134             :                     }
    1135             :                 }
    1136             :             }
    1137             :         }
    1138       10340 :     }while(change);
    1139             : 
    1140       30866 :     for (i = 0; i < graph->nb_filters; i++) {
    1141       25729 :         AVFilterContext *filter = graph->filters[i];
    1142             : 
    1143       46329 :         for (j = 0; j < filter->nb_inputs; j++)
    1144       20600 :             if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
    1145           0 :                 return ret;
    1146       46329 :         for (j = 0; j < filter->nb_outputs; j++)
    1147       20600 :             if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
    1148           0 :                 return ret;
    1149             :     }
    1150        5137 :     return 0;
    1151             : }
    1152             : 
    1153             : /**
    1154             :  * Configure the formats of all the links in the graph.
    1155             :  */
    1156        5137 : static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
    1157             : {
    1158             :     int ret;
    1159             : 
    1160             :     /* find supported formats from sub-filters, and merge along links */
    1161       10288 :     while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
    1162          14 :         av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
    1163        5137 :     if (ret < 0)
    1164           0 :         return ret;
    1165             : 
    1166             :     /* Once everything is merged, it's possible that we'll still have
    1167             :      * multiple valid media format choices. We try to minimize the amount
    1168             :      * of format conversion inside filters */
    1169        5137 :     if ((ret = reduce_formats(graph)) < 0)
    1170           0 :         return ret;
    1171             : 
    1172             :     /* for audio filters, ensure the best format, sample rate and channel layout
    1173             :      * is selected */
    1174        5137 :     swap_sample_fmts(graph);
    1175        5137 :     swap_samplerates(graph);
    1176        5137 :     swap_channel_layouts(graph);
    1177             : 
    1178        5137 :     if ((ret = pick_formats(graph)) < 0)
    1179           0 :         return ret;
    1180             : 
    1181        5137 :     return 0;
    1182             : }
    1183             : 
    1184        5137 : static int graph_config_pointers(AVFilterGraph *graph,
    1185             :                                              AVClass *log_ctx)
    1186             : {
    1187             :     unsigned i, j;
    1188        5137 :     int sink_links_count = 0, n = 0;
    1189             :     AVFilterContext *f;
    1190             :     AVFilterLink **sinks;
    1191             : 
    1192       30866 :     for (i = 0; i < graph->nb_filters; i++) {
    1193       25729 :         f = graph->filters[i];
    1194       46329 :         for (j = 0; j < f->nb_inputs; j++) {
    1195       20600 :             f->inputs[j]->graph     = graph;
    1196       20600 :             f->inputs[j]->age_index = -1;
    1197             :         }
    1198       46329 :         for (j = 0; j < f->nb_outputs; j++) {
    1199       20600 :             f->outputs[j]->graph    = graph;
    1200       20600 :             f->outputs[j]->age_index= -1;
    1201             :         }
    1202       25729 :         if (!f->nb_outputs) {
    1203        5141 :             if (f->nb_inputs > INT_MAX - sink_links_count)
    1204           0 :                 return AVERROR(EINVAL);
    1205        5141 :             sink_links_count += f->nb_inputs;
    1206             :         }
    1207             :     }
    1208        5137 :     sinks = av_calloc(sink_links_count, sizeof(*sinks));
    1209        5137 :     if (!sinks)
    1210           0 :         return AVERROR(ENOMEM);
    1211       30866 :     for (i = 0; i < graph->nb_filters; i++) {
    1212       25729 :         f = graph->filters[i];
    1213       25729 :         if (!f->nb_outputs) {
    1214       10282 :             for (j = 0; j < f->nb_inputs; j++) {
    1215        5141 :                 sinks[n] = f->inputs[j];
    1216        5141 :                 f->inputs[j]->age_index = n++;
    1217             :             }
    1218             :         }
    1219             :     }
    1220        5137 :     av_assert0(n == sink_links_count);
    1221        5137 :     graph->sink_links       = sinks;
    1222        5137 :     graph->sink_links_count = sink_links_count;
    1223        5137 :     return 0;
    1224             : }
    1225             : 
    1226        5137 : static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)
    1227             : {
    1228             :     AVFilterContext *f;
    1229             :     int i, j, ret;
    1230        5137 :     int fifo_count = 0;
    1231             : 
    1232       28248 :     for (i = 0; i < graph->nb_filters; i++) {
    1233       23111 :         f = graph->filters[i];
    1234             : 
    1235       41093 :         for (j = 0; j < f->nb_inputs; j++) {
    1236       17982 :             AVFilterLink *link = f->inputs[j];
    1237             :             AVFilterContext *fifo_ctx;
    1238             :             AVFilter *fifo;
    1239             :             char name[32];
    1240             : 
    1241       17982 :             if (!link->dstpad->needs_fifo)
    1242       17970 :                 continue;
    1243             : 
    1244          24 :             fifo = f->inputs[j]->type == AVMEDIA_TYPE_VIDEO ?
    1245          12 :                    avfilter_get_by_name("fifo") :
    1246             :                    avfilter_get_by_name("afifo");
    1247             : 
    1248          12 :             snprintf(name, sizeof(name), "auto_fifo_%d", fifo_count++);
    1249             : 
    1250          12 :             ret = avfilter_graph_create_filter(&fifo_ctx, fifo, name, NULL,
    1251             :                                                NULL, graph);
    1252          12 :             if (ret < 0)
    1253           0 :                 return ret;
    1254             : 
    1255          12 :             ret = avfilter_insert_filter(link, fifo_ctx, 0, 0);
    1256          12 :             if (ret < 0)
    1257           0 :                 return ret;
    1258             :         }
    1259             :     }
    1260             : 
    1261        5137 :     return 0;
    1262             : }
    1263             : 
    1264        5137 : int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
    1265             : {
    1266             :     int ret;
    1267             : 
    1268        5137 :     if ((ret = graph_check_validity(graphctx, log_ctx)))
    1269           0 :         return ret;
    1270        5137 :     if ((ret = graph_insert_fifos(graphctx, log_ctx)) < 0)
    1271           0 :         return ret;
    1272        5137 :     if ((ret = graph_config_formats(graphctx, log_ctx)))
    1273           0 :         return ret;
    1274        5137 :     if ((ret = graph_config_links(graphctx, log_ctx)))
    1275           0 :         return ret;
    1276        5137 :     if ((ret = graph_config_pointers(graphctx, log_ctx)))
    1277           0 :         return ret;
    1278             : 
    1279        5137 :     return 0;
    1280             : }
    1281             : 
    1282           0 : int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
    1283             : {
    1284           0 :     int i, r = AVERROR(ENOSYS);
    1285             : 
    1286           0 :     if (!graph)
    1287           0 :         return r;
    1288             : 
    1289           0 :     if ((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {
    1290           0 :         r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
    1291           0 :         if (r != AVERROR(ENOSYS))
    1292           0 :             return r;
    1293             :     }
    1294             : 
    1295           0 :     if (res_len && res)
    1296           0 :         res[0] = 0;
    1297             : 
    1298           0 :     for (i = 0; i < graph->nb_filters; i++) {
    1299           0 :         AVFilterContext *filter = graph->filters[i];
    1300           0 :         if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) {
    1301           0 :             r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
    1302           0 :             if (r != AVERROR(ENOSYS)) {
    1303           0 :                 if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
    1304           0 :                     return r;
    1305             :             }
    1306             :         }
    1307             :     }
    1308             : 
    1309           0 :     return r;
    1310             : }
    1311             : 
    1312           0 : int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
    1313             : {
    1314             :     int i;
    1315             : 
    1316           0 :     if(!graph)
    1317           0 :         return 0;
    1318             : 
    1319           0 :     for (i = 0; i < graph->nb_filters; i++) {
    1320           0 :         AVFilterContext *filter = graph->filters[i];
    1321           0 :         if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
    1322           0 :             AVFilterCommand **queue = &filter->command_queue, *next;
    1323           0 :             while (*queue && (*queue)->time <= ts)
    1324           0 :                 queue = &(*queue)->next;
    1325           0 :             next = *queue;
    1326           0 :             *queue = av_mallocz(sizeof(AVFilterCommand));
    1327           0 :             if (!*queue)
    1328           0 :                 return AVERROR(ENOMEM);
    1329             : 
    1330           0 :             (*queue)->command = av_strdup(command);
    1331           0 :             (*queue)->arg     = av_strdup(arg);
    1332           0 :             (*queue)->time    = ts;
    1333           0 :             (*queue)->flags   = flags;
    1334           0 :             (*queue)->next    = next;
    1335           0 :             if(flags & AVFILTER_CMD_FLAG_ONE)
    1336           0 :                 return 0;
    1337             :         }
    1338             :     }
    1339             : 
    1340           0 :     return 0;
    1341             : }
    1342             : 
    1343      387668 : static void heap_bubble_up(AVFilterGraph *graph,
    1344             :                            AVFilterLink *link, int index)
    1345             : {
    1346      387668 :     AVFilterLink **links = graph->sink_links;
    1347             : 
    1348      387668 :     av_assert0(index >= 0);
    1349             : 
    1350      775349 :     while (index) {
    1351          13 :         int parent = (index - 1) >> 1;
    1352          13 :         if (links[parent]->current_pts_us >= link->current_pts_us)
    1353           0 :             break;
    1354          13 :         links[index] = links[parent];
    1355          13 :         links[index]->age_index = index;
    1356          13 :         index = parent;
    1357             :     }
    1358      387668 :     links[index] = link;
    1359      387668 :     link->age_index = index;
    1360      387668 : }
    1361             : 
    1362      387668 : static void heap_bubble_down(AVFilterGraph *graph,
    1363             :                              AVFilterLink *link, int index)
    1364             : {
    1365      387668 :     AVFilterLink **links = graph->sink_links;
    1366             : 
    1367      387668 :     av_assert0(index >= 0);
    1368             : 
    1369         574 :     while (1) {
    1370      388242 :         int child = 2 * index + 1;
    1371      388242 :         if (child >= graph->sink_links_count)
    1372      387510 :             break;
    1373         746 :         if (child + 1 < graph->sink_links_count &&
    1374          14 :             links[child + 1]->current_pts_us < links[child]->current_pts_us)
    1375           4 :             child++;
    1376         732 :         if (link->current_pts_us < links[child]->current_pts_us)
    1377         158 :             break;
    1378         574 :         links[index] = links[child];
    1379         574 :         links[index]->age_index = index;
    1380         574 :         index = child;
    1381             :     }
    1382      387668 :     links[index] = link;
    1383      387668 :     link->age_index = index;
    1384      387668 : }
    1385             : 
    1386      387668 : void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
    1387             : {
    1388      387668 :     heap_bubble_up  (graph, link, link->age_index);
    1389      387668 :     heap_bubble_down(graph, link, link->age_index);
    1390      387668 : }
    1391             : 
    1392      362571 : int avfilter_graph_request_oldest(AVFilterGraph *graph)
    1393             : {
    1394      362571 :     AVFilterLink *oldest = graph->sink_links[0];
    1395             :     int64_t frame_count;
    1396             :     int r;
    1397             : 
    1398      725142 :     while (graph->sink_links_count) {
    1399      362571 :         oldest = graph->sink_links[0];
    1400      362571 :         if (oldest->dst->filter->activate) {
    1401             :             /* For now, buffersink is the only filter implementing activate. */
    1402      362571 :             return av_buffersink_get_frame_flags(oldest->dst, NULL,
    1403             :                                                  AV_BUFFERSINK_FLAG_PEEK);
    1404             :         }
    1405           0 :         r = ff_request_frame(oldest);
    1406           0 :         if (r != AVERROR_EOF)
    1407           0 :             break;
    1408           0 :         av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
    1409           0 :                oldest->dst ? oldest->dst->name : "unknown",
    1410           0 :                oldest->dstpad ? oldest->dstpad->name : "unknown");
    1411             :         /* EOF: remove the link from the heap */
    1412           0 :         if (oldest->age_index < --graph->sink_links_count)
    1413           0 :             heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],
    1414             :                              oldest->age_index);
    1415           0 :         oldest->age_index = -1;
    1416             :     }
    1417           0 :     if (!graph->sink_links_count)
    1418           0 :         return AVERROR_EOF;
    1419             :     av_assert1(!oldest->dst->filter->activate);
    1420             :     av_assert1(oldest->age_index >= 0);
    1421           0 :     frame_count = oldest->frame_count_out;
    1422           0 :     while (frame_count == oldest->frame_count_out) {
    1423           0 :         r = ff_filter_graph_run_once(graph);
    1424           0 :         if (r == AVERROR(EAGAIN) &&
    1425           0 :             !oldest->frame_wanted_out && !oldest->frame_blocked_in &&
    1426           0 :             !oldest->status_in)
    1427           0 :             ff_request_frame(oldest);
    1428           0 :         else if (r < 0)
    1429           0 :             return r;
    1430             :     }
    1431           0 :     return 0;
    1432             : }
    1433             : 
    1434     4105204 : int ff_filter_graph_run_once(AVFilterGraph *graph)
    1435             : {
    1436             :     AVFilterContext *filter;
    1437             :     unsigned i;
    1438             : 
    1439     4105204 :     av_assert0(graph->nb_filters);
    1440     4105204 :     filter = graph->filters[0];
    1441    19877531 :     for (i = 1; i < graph->nb_filters; i++)
    1442    15772327 :         if (graph->filters[i]->ready > filter->ready)
    1443     2594890 :             filter = graph->filters[i];
    1444     4105204 :     if (!filter->ready)
    1445      394708 :         return AVERROR(EAGAIN);
    1446     3710496 :     return ff_filter_activate(filter);
    1447             : }

Generated by: LCOV version 1.13