LCOV - code coverage report
Current view: top level - libavfilter - avfiltergraph.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 580 751 77.2 %
Date: 2017-12-12 03:56:30 Functions: 36 39 92.3 %

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

Generated by: LCOV version 1.13