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: 2018-05-20 11:54:08 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        5667 : AVFilterGraph *avfilter_graph_alloc(void)
      84             : {
      85        5667 :     AVFilterGraph *ret = av_mallocz(sizeof(*ret));
      86        5667 :     if (!ret)
      87           0 :         return NULL;
      88             : 
      89        5667 :     ret->internal = av_mallocz(sizeof(*ret->internal));
      90        5667 :     if (!ret->internal) {
      91           0 :         av_freep(&ret);
      92           0 :         return NULL;
      93             :     }
      94             : 
      95        5667 :     ret->av_class = &filtergraph_class;
      96        5667 :     av_opt_set_defaults(ret);
      97        5667 :     ff_framequeue_global_init(&ret->internal->frame_queues);
      98             : 
      99        5667 :     return ret;
     100             : }
     101             : 
     102       28200 : void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
     103             : {
     104             :     int i, j;
     105       28200 :     for (i = 0; i < graph->nb_filters; i++) {
     106       28200 :         if (graph->filters[i] == filter) {
     107       28200 :             FFSWAP(AVFilterContext*, graph->filters[i],
     108             :                    graph->filters[graph->nb_filters - 1]);
     109       28200 :             graph->nb_filters--;
     110       28200 :             filter->graph = NULL;
     111       50898 :             for (j = 0; j<filter->nb_outputs; j++)
     112       22698 :                 if (filter->outputs[j])
     113       11265 :                     filter->outputs[j]->graph = NULL;
     114             : 
     115       28200 :             return;
     116             :         }
     117             :     }
     118             : }
     119             : 
     120       11141 : void avfilter_graph_free(AVFilterGraph **graph)
     121             : {
     122       11141 :     if (!*graph)
     123        5474 :         return;
     124             : 
     125       39468 :     while ((*graph)->nb_filters)
     126       28134 :         avfilter_free((*graph)->filters[0]);
     127             : 
     128        5667 :     ff_graph_thread_free(*graph);
     129             : 
     130        5667 :     av_freep(&(*graph)->sink_links);
     131             : 
     132        5667 :     av_freep(&(*graph)->scale_sws_opts);
     133        5667 :     av_freep(&(*graph)->aresample_swr_opts);
     134             : #if FF_API_LAVR_OPTS
     135        5667 :     av_freep(&(*graph)->resample_lavr_opts);
     136             : #endif
     137        5667 :     av_freep(&(*graph)->filters);
     138        5667 :     av_freep(&(*graph)->internal);
     139        5667 :     av_freep(graph);
     140             : }
     141             : 
     142       19074 : 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       19074 :     *filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name);
     149       19074 :     if (!*filt_ctx)
     150           0 :         return AVERROR(ENOMEM);
     151             : 
     152       19074 :     ret = avfilter_init_str(*filt_ctx, args);
     153       19074 :     if (ret < 0)
     154           0 :         goto fail;
     155             : 
     156       19074 :     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       28200 : AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
     171             :                                              const AVFilter *filter,
     172             :                                              const char *name)
     173             : {
     174             :     AVFilterContext **filters, *s;
     175             : 
     176       28200 :     if (graph->thread_type && !graph->internal->thread_execute) {
     177        5667 :         if (graph->execute) {
     178           0 :             graph->internal->thread_execute = graph->execute;
     179             :         } else {
     180        5667 :             int ret = ff_graph_thread_init(graph);
     181        5667 :             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       28200 :     s = ff_filter_alloc(filter, name);
     189       28200 :     if (!s)
     190           0 :         return NULL;
     191             : 
     192       28200 :     filters = av_realloc(graph->filters, sizeof(*filters) * (graph->nb_filters + 1));
     193       28200 :     if (!filters) {
     194           0 :         avfilter_free(s);
     195           0 :         return NULL;
     196             :     }
     197             : 
     198       28200 :     graph->filters = filters;
     199       28200 :     graph->filters[graph->nb_filters++] = s;
     200             : 
     201       28200 :     s->graph = graph;
     202             : 
     203       28200 :     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        5530 : static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)
     215             : {
     216             :     AVFilterContext *filt;
     217             :     int i, j;
     218             : 
     219       30598 :     for (i = 0; i < graph->nb_filters; i++) {
     220             :         const AVFilterPad *pad;
     221       25068 :         filt = graph->filters[i];
     222             : 
     223       44618 :         for (j = 0; j < filt->nb_inputs; j++) {
     224       19550 :             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       44618 :         for (j = 0; j < filt->nb_outputs; j++) {
     234       19550 :             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        5530 :     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        5530 : static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)
     253             : {
     254             :     AVFilterContext *filt;
     255             :     int i, ret;
     256             : 
     257       33507 :     for (i = 0; i < graph->nb_filters; i++) {
     258       27977 :         filt = graph->filters[i];
     259             : 
     260       27977 :         if (!filt->nb_outputs) {
     261        5535 :             if ((ret = avfilter_config_links(filt)))
     262           0 :                 return ret;
     263             :         }
     264             :     }
     265             : 
     266        5530 :     return 0;
     267             : }
     268             : 
     269        5530 : 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       33507 :     for (i = 0; i < graph->nb_filters; i++) {
     277       27977 :         f = graph->filters[i];
     278       50436 :         for (j = 0; j < f->nb_outputs; j++) {
     279       22459 :             l = f->outputs[j];
     280       22459 :             if (l->type == AVMEDIA_TYPE_VIDEO) {
     281       17622 :                 ret = av_image_check_size2(l->w, l->h, INT64_MAX, l->format, 0, f);
     282       17622 :                 if (ret < 0)
     283           0 :                     return ret;
     284             :             }
     285             :         }
     286             :     }
     287        5530 :     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       36247 : static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l)
     302             : {
     303       36247 :     if (!l)
     304       28839 :         return;
     305        7408 :     if (l->nb_channel_layouts) {
     306        1239 :         if (l->all_layouts || l->all_counts)
     307           0 :             av_log(log, AV_LOG_WARNING, "All layouts set on non-empty list\n");
     308        1239 :         l->all_layouts = l->all_counts = 0;
     309             :     } else {
     310        6169 :         if (l->all_counts && !l->all_layouts)
     311           0 :             av_log(log, AV_LOG_WARNING, "All counts without all layouts\n");
     312        6169 :         l->all_layouts = 1;
     313             :     }
     314             : }
     315             : 
     316       23662 : static int filter_query_formats(AVFilterContext *ctx)
     317             : {
     318             :     int ret, i;
     319             :     AVFilterFormats *formats;
     320             :     AVFilterChannelLayouts *chlayouts;
     321             :     AVFilterFormats *samplerates;
     322       29232 :     enum AVMediaType type = ctx->inputs  && ctx->inputs [0] ? ctx->inputs [0]->type :
     323        5570 :                             ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
     324             :                             AVMEDIA_TYPE_VIDEO;
     325             : 
     326       23662 :     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       41778 :     for (i = 0; i < ctx->nb_inputs; i++)
     334       18130 :         sanitize_channel_layouts(ctx, ctx->inputs[i]->out_channel_layouts);
     335       41765 :     for (i = 0; i < ctx->nb_outputs; i++)
     336       18117 :         sanitize_channel_layouts(ctx, ctx->outputs[i]->in_channel_layouts);
     337             : 
     338       23648 :     formats = ff_all_formats(type);
     339       23648 :     if ((ret = ff_set_common_formats(ctx, formats)) < 0)
     340           0 :         return ret;
     341       23648 :     if (type == AVMEDIA_TYPE_AUDIO) {
     342        4780 :         samplerates = ff_all_samplerates();
     343        4780 :         if ((ret = ff_set_common_samplerates(ctx, samplerates)) < 0)
     344           0 :             return ret;
     345        4780 :         chlayouts = ff_all_channel_layouts();
     346        4780 :         if ((ret = ff_set_common_channel_layouts(ctx, chlayouts)) < 0)
     347           0 :             return ret;
     348             :     }
     349       23648 :     return 0;
     350             : }
     351             : 
     352       25136 : static int formats_declared(AVFilterContext *f)
     353             : {
     354             :     int i;
     355             : 
     356       25171 :     for (i = 0; i < f->nb_inputs; i++) {
     357       19555 :         if (!f->inputs[i]->out_formats)
     358       19520 :             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        5650 :     for (i = 0; i < f->nb_outputs; i++) {
     365        5606 :         if (!f->outputs[i]->in_formats)
     366        5572 :             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       47720 : static AVFilterFormats *clone_filter_formats(AVFilterFormats *arg)
     376             : {
     377       47720 :     AVFilterFormats *a = av_memdup(arg, sizeof(*arg));
     378       47720 :     if (a) {
     379       47720 :         a->refcount = 0;
     380       47720 :         a->refs     = NULL;
     381       47720 :         a->formats  = av_memdup(a->formats, sizeof(*a->formats) * a->nb_formats);
     382       47720 :         if (!a->formats && arg->formats)
     383           0 :             av_freep(&a);
     384             :     }
     385       47720 :     return a;
     386             : }
     387             : 
     388       23860 : 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       23860 :     if (a_arg == b_arg)
     395           0 :         return 1;
     396       23860 :     a = clone_filter_formats(a_arg);
     397       23860 :     b = clone_filter_formats(b_arg);
     398             : 
     399       23860 :     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       23860 :     if (is_sample_rate) {
     412        4302 :         ret = ff_merge_samplerates(a, b);
     413             :     } else {
     414       19558 :         ret = ff_merge_formats(a, b, type);
     415             :     }
     416       23860 :     if (ret) {
     417       20956 :         av_freep(&ret->formats);
     418       20956 :         av_freep(&ret->refs);
     419       20956 :         av_freep(&ret);
     420       20956 :         return 1;
     421             :     } else {
     422        2904 :         av_freep(&a->formats);
     423        2904 :         av_freep(&b->formats);
     424        2904 :         av_freep(&a);
     425        2904 :         av_freep(&b);
     426        2904 :         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        5544 : static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
     441             : {
     442             :     int i, j, ret;
     443        5544 :     int scaler_count = 0, resampler_count = 0;
     444        5544 :     int count_queried = 0;        /* successful calls to query_formats() */
     445        5544 :     int count_merged = 0;         /* successful merge of formats lists */
     446        5544 :     int count_already_merged = 0; /* lists already merged */
     447        5544 :     int count_delayed = 0;        /* lists that need to be merged later */
     448             : 
     449       30680 :     for (i = 0; i < graph->nb_filters; i++) {
     450       25136 :         AVFilterContext *f = graph->filters[i];
     451       25136 :         if (formats_declared(f))
     452          44 :             continue;
     453       25092 :         if (f->filter->query_formats)
     454       20763 :             ret = filter_query_formats(f);
     455             :         else
     456        4329 :             ret = ff_default_query_formats(f);
     457       25092 :         if (ret < 0 && ret != AVERROR(EAGAIN))
     458           0 :             return ret;
     459             :         /* note: EAGAIN could indicate a partial success, not counted yet */
     460       25092 :         count_queried += ret >= 0;
     461             :     }
     462             : 
     463             :     /* go through and merge as many format lists as possible */
     464       33579 :     for (i = 0; i < graph->nb_filters; i++) {
     465       28035 :         AVFilterContext *filter = graph->filters[i];
     466             : 
     467       50542 :         for (j = 0; j < filter->nb_inputs; j++) {
     468       22507 :             AVFilterLink *link = filter->inputs[j];
     469       22507 :             int convert_needed = 0;
     470             : 
     471       22507 :             if (!link)
     472           0 :                 continue;
     473             : 
     474       22507 :             if (link->in_formats != link->out_formats
     475       19585 :                 && link->in_formats && link->out_formats)
     476       19558 :                 if (!can_merge_formats(link->in_formats, link->out_formats,
     477             :                                       link->type, 0))
     478        2887 :                     convert_needed = 1;
     479       22507 :             if (link->type == AVMEDIA_TYPE_AUDIO) {
     480        4841 :                 if (link->in_samplerates != link->out_samplerates
     481        4305 :                     && link->in_samplerates && link->out_samplerates)
     482        4302 :                     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       22507 :             if (link->type == AVMEDIA_TYPE_AUDIO) {
     499        4841 :                 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        4841 :                 MERGE_DISPATCH(samplerates,
     505             :                     if (!ff_merge_samplerates(link->in_samplerates,
     506             :                                               link->out_samplerates))
     507             :                         convert_needed = 1;
     508             :                 )
     509             :             }
     510       22507 :             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       22507 :             if (convert_needed) {
     518             :                 AVFilterContext *convert;
     519             :                 const AVFilter *filter;
     520             :                 AVFilterLink *inlink, *outlink;
     521             :                 char inst_name[30];
     522             : 
     523        2899 :                 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        2899 :                 switch (link->type) {
     533        2364 :                 case AVMEDIA_TYPE_VIDEO:
     534        2364 :                     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        2364 :                     snprintf(inst_name, sizeof(inst_name), "auto_scaler_%d",
     541             :                              scaler_count++);
     542             : 
     543        2364 :                     if ((ret = avfilter_graph_create_filter(&convert, filter,
     544        2364 :                                                             inst_name, graph->scale_sws_opts, NULL,
     545             :                                                             graph)) < 0)
     546           0 :                         return ret;
     547        2364 :                     break;
     548         535 :                 case AVMEDIA_TYPE_AUDIO:
     549         535 :                     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         535 :                     snprintf(inst_name, sizeof(inst_name), "auto_resampler_%d",
     556             :                              resampler_count++);
     557         535 :                     if ((ret = avfilter_graph_create_filter(&convert, filter,
     558         535 :                                                             inst_name, graph->aresample_swr_opts,
     559             :                                                             NULL, graph)) < 0)
     560           0 :                         return ret;
     561         535 :                     break;
     562           0 :                 default:
     563           0 :                     return AVERROR(EINVAL);
     564             :                 }
     565             : 
     566        2899 :                 if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
     567           0 :                     return ret;
     568             : 
     569        2899 :                 if ((ret = filter_query_formats(convert)) < 0)
     570           0 :                     return ret;
     571             : 
     572        2899 :                 inlink  = convert->inputs[0];
     573        2899 :                 outlink = convert->outputs[0];
     574        2899 :                 av_assert0( inlink-> in_formats->refcount > 0);
     575        2899 :                 av_assert0( inlink->out_formats->refcount > 0);
     576        2899 :                 av_assert0(outlink-> in_formats->refcount > 0);
     577        2899 :                 av_assert0(outlink->out_formats->refcount > 0);
     578        2899 :                 if (outlink->type == AVMEDIA_TYPE_AUDIO) {
     579         535 :                     av_assert0( inlink-> in_samplerates->refcount > 0);
     580         535 :                     av_assert0( inlink->out_samplerates->refcount > 0);
     581         535 :                     av_assert0(outlink-> in_samplerates->refcount > 0);
     582         535 :                     av_assert0(outlink->out_samplerates->refcount > 0);
     583         535 :                     av_assert0( inlink-> in_channel_layouts->refcount > 0);
     584         535 :                     av_assert0( inlink->out_channel_layouts->refcount > 0);
     585         535 :                     av_assert0(outlink-> in_channel_layouts->refcount > 0);
     586         535 :                     av_assert0(outlink->out_channel_layouts->refcount > 0);
     587             :                 }
     588        5798 :                 if (!ff_merge_formats( inlink->in_formats,  inlink->out_formats,  inlink->type) ||
     589        2899 :                     !ff_merge_formats(outlink->in_formats, outlink->out_formats, outlink->type))
     590           0 :                     ret = AVERROR(ENOSYS);
     591        3434 :                 if (inlink->type == AVMEDIA_TYPE_AUDIO &&
     592         535 :                     (!ff_merge_samplerates(inlink->in_samplerates,
     593         535 :                                            inlink->out_samplerates) ||
     594         535 :                      !ff_merge_channel_layouts(inlink->in_channel_layouts,
     595         535 :                                                inlink->out_channel_layouts)))
     596           0 :                     ret = AVERROR(ENOSYS);
     597        3434 :                 if (outlink->type == AVMEDIA_TYPE_AUDIO &&
     598         535 :                     (!ff_merge_samplerates(outlink->in_samplerates,
     599         535 :                                            outlink->out_samplerates) ||
     600         535 :                      !ff_merge_channel_layouts(outlink->in_channel_layouts,
     601         535 :                                                outlink->out_channel_layouts)))
     602           0 :                     ret = AVERROR(ENOSYS);
     603             : 
     604        2899 :                 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        5544 :     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        5544 :     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        5530 :     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       67350 : static int pick_format(AVFilterLink *link, AVFilterLink *ref)
     676             : {
     677       67350 :     if (!link || !link->in_formats)
     678       44891 :         return 0;
     679             : 
     680       22459 :     if (link->type == AVMEDIA_TYPE_VIDEO) {
     681       17622 :         if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
     682             :             //FIXME: This should check for AV_PIX_FMT_FLAG_ALPHA after PAL8 pixel format without alpha is implemented
     683          78 :             int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
     684          78 :             enum AVPixelFormat best= AV_PIX_FMT_NONE;
     685             :             int i;
     686         632 :             for (i=0; i<link->in_formats->nb_formats; i++) {
     687         554 :                 enum AVPixelFormat p = link->in_formats->formats[i];
     688         554 :                 best= av_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
     689             :             }
     690         156 :             av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
     691          78 :                    av_get_pix_fmt_name(best), link->in_formats->nb_formats,
     692          78 :                    av_get_pix_fmt_name(ref->format), has_alpha);
     693          78 :             link->in_formats->formats[0] = best;
     694             :         }
     695        4837 :     } else if (link->type == AVMEDIA_TYPE_AUDIO) {
     696        4837 :         if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
     697          21 :             enum AVSampleFormat best= AV_SAMPLE_FMT_NONE;
     698             :             int i;
     699         100 :             for (i=0; i<link->in_formats->nb_formats; i++) {
     700          79 :                 enum AVSampleFormat p = link->in_formats->formats[i];
     701          79 :                 best = find_best_sample_fmt_of_2(best, p, ref->format);
     702             :             }
     703          42 :             av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n",
     704          21 :                    av_get_sample_fmt_name(best), link->in_formats->nb_formats,
     705          21 :                    av_get_sample_fmt_name(ref->format));
     706          21 :             link->in_formats->formats[0] = best;
     707             :         }
     708             :     }
     709             : 
     710       22459 :     link->in_formats->nb_formats = 1;
     711       22459 :     link->format = link->in_formats->formats[0];
     712             : 
     713       22459 :     if (link->type == AVMEDIA_TYPE_AUDIO) {
     714        4837 :         if (!link->in_samplerates->nb_formats) {
     715           0 :             av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
     716           0 :                    " the link between filters %s and %s.\n", link->src->name,
     717           0 :                    link->dst->name);
     718           0 :             return AVERROR(EINVAL);
     719             :         }
     720        4837 :         link->in_samplerates->nb_formats = 1;
     721        4837 :         link->sample_rate = link->in_samplerates->formats[0];
     722             : 
     723        4837 :         if (link->in_channel_layouts->all_layouts) {
     724           0 :             av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
     725           0 :                    " the link between filters %s and %s.\n", link->src->name,
     726           0 :                    link->dst->name);
     727           0 :             if (!link->in_channel_layouts->all_counts)
     728           0 :                 av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not "
     729             :                        "supported, try specifying a channel layout using "
     730             :                        "'aformat=channel_layouts=something'.\n");
     731           0 :             return AVERROR(EINVAL);
     732             :         }
     733        4837 :         link->in_channel_layouts->nb_channel_layouts = 1;
     734        4837 :         link->channel_layout = link->in_channel_layouts->channel_layouts[0];
     735        4837 :         if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
     736          16 :             link->channel_layout = 0;
     737             :         else
     738        4821 :             link->channels = av_get_channel_layout_nb_channels(link->channel_layout);
     739             :     }
     740             : 
     741       22459 :     ff_formats_unref(&link->in_formats);
     742       22459 :     ff_formats_unref(&link->out_formats);
     743       22459 :     ff_formats_unref(&link->in_samplerates);
     744       22459 :     ff_formats_unref(&link->out_samplerates);
     745       22459 :     ff_channel_layouts_unref(&link->in_channel_layouts);
     746       22459 :     ff_channel_layouts_unref(&link->out_channel_layouts);
     747             : 
     748       22459 :     return 0;
     749             : }
     750             : 
     751             : #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format, unref_format) \
     752             : do {                                                                   \
     753             :     for (i = 0; i < filter->nb_inputs; i++) {                          \
     754             :         AVFilterLink *link = filter->inputs[i];                        \
     755             :         fmt_type fmt;                                                  \
     756             :                                                                        \
     757             :         if (!link->out_ ## list || link->out_ ## list->nb != 1)        \
     758             :             continue;                                                  \
     759             :         fmt = link->out_ ## list->var[0];                              \
     760             :                                                                        \
     761             :         for (j = 0; j < filter->nb_outputs; j++) {                     \
     762             :             AVFilterLink *out_link = filter->outputs[j];               \
     763             :             list_type *fmts;                                           \
     764             :                                                                        \
     765             :             if (link->type != out_link->type ||                        \
     766             :                 out_link->in_ ## list->nb == 1)                        \
     767             :                 continue;                                              \
     768             :             fmts = out_link->in_ ## list;                              \
     769             :                                                                        \
     770             :             if (!out_link->in_ ## list->nb) {                          \
     771             :                 if ((ret = add_format(&out_link->in_ ##list, fmt)) < 0)\
     772             :                     return ret;                                        \
     773             :                 ret = 1;                                               \
     774             :                 break;                                                 \
     775             :             }                                                          \
     776             :                                                                        \
     777             :             for (k = 0; k < out_link->in_ ## list->nb; k++)            \
     778             :                 if (fmts->var[k] == fmt) {                             \
     779             :                     fmts->var[0]  = fmt;                               \
     780             :                     fmts->nb = 1;                                      \
     781             :                     ret = 1;                                           \
     782             :                     break;                                             \
     783             :                 }                                                      \
     784             :         }                                                              \
     785             :     }                                                                  \
     786             : } while (0)
     787             : 
     788       30676 : static int reduce_formats_on_filter(AVFilterContext *filter)
     789             : {
     790       30676 :     int i, j, k, ret = 0;
     791             : 
     792       30676 :     REDUCE_FORMATS(int,      AVFilterFormats,        formats,         formats,
     793             :                    nb_formats, ff_add_format, ff_formats_unref);
     794       30676 :     REDUCE_FORMATS(int,      AVFilterFormats,        samplerates,     formats,
     795             :                    nb_formats, ff_add_format, ff_formats_unref);
     796             : 
     797             :     /* reduce channel layouts */
     798       55310 :     for (i = 0; i < filter->nb_inputs; i++) {
     799       24634 :         AVFilterLink *inlink = filter->inputs[i];
     800             :         uint64_t fmt;
     801             : 
     802       31477 :         if (!inlink->out_channel_layouts ||
     803        6843 :             inlink->out_channel_layouts->nb_channel_layouts != 1)
     804       18825 :             continue;
     805        5809 :         fmt = inlink->out_channel_layouts->channel_layouts[0];
     806             : 
     807        9427 :         for (j = 0; j < filter->nb_outputs; j++) {
     808        4741 :             AVFilterLink *outlink = filter->outputs[j];
     809             :             AVFilterChannelLayouts *fmts;
     810             : 
     811        4741 :             fmts = outlink->in_channel_layouts;
     812        4741 :             if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
     813        3597 :                 continue;
     814             : 
     815        2267 :             if (fmts->all_layouts &&
     816        1125 :                 (!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
     817             :                 /* Turn the infinite list into a singleton */
     818        1123 :                 fmts->all_layouts = fmts->all_counts  = 0;
     819        1123 :                 if (ff_add_channel_layout(&outlink->in_channel_layouts, fmt) < 0)
     820           0 :                     ret = 1;
     821        1123 :                 break;
     822             :             }
     823             : 
     824          71 :             for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) {
     825          69 :                 if (fmts->channel_layouts[k] == fmt) {
     826          19 :                     fmts->channel_layouts[0]  = fmt;
     827          19 :                     fmts->nb_channel_layouts = 1;
     828          19 :                     ret = 1;
     829          19 :                     break;
     830             :                 }
     831             :             }
     832             :         }
     833             :     }
     834             : 
     835       30676 :     return ret;
     836             : }
     837             : 
     838        6054 : static int reduce_formats(AVFilterGraph *graph)
     839             : {
     840             :     int i, reduced, ret;
     841             : 
     842             :     do {
     843        6054 :         reduced = 0;
     844             : 
     845       36730 :         for (i = 0; i < graph->nb_filters; i++) {
     846       30676 :             if ((ret = reduce_formats_on_filter(graph->filters[i])) < 0)
     847           0 :                 return ret;
     848       30676 :             reduced |= ret;
     849             :         }
     850        6054 :     } while (reduced);
     851             : 
     852        5530 :     return 0;
     853             : }
     854             : 
     855       27977 : static void swap_samplerates_on_filter(AVFilterContext *filter)
     856             : {
     857       27977 :     AVFilterLink *link = NULL;
     858             :     int sample_rate;
     859             :     int i, j;
     860             : 
     861       45597 :     for (i = 0; i < filter->nb_inputs; i++) {
     862       22448 :         link = filter->inputs[i];
     863             : 
     864       27276 :         if (link->type == AVMEDIA_TYPE_AUDIO &&
     865        4828 :             link->out_samplerates->nb_formats== 1)
     866        4828 :             break;
     867             :     }
     868       27977 :     if (i == filter->nb_inputs)
     869       23149 :         return;
     870             : 
     871        4828 :     sample_rate = link->out_samplerates->formats[0];
     872             : 
     873        8581 :     for (i = 0; i < filter->nb_outputs; i++) {
     874        3753 :         AVFilterLink *outlink = filter->outputs[i];
     875        3753 :         int best_idx, best_diff = INT_MAX;
     876             : 
     877        7505 :         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
     878        3752 :             outlink->in_samplerates->nb_formats < 2)
     879        3753 :             continue;
     880             : 
     881           0 :         for (j = 0; j < outlink->in_samplerates->nb_formats; j++) {
     882           0 :             int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
     883             : 
     884           0 :             av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
     885             : 
     886           0 :             if (diff < best_diff) {
     887           0 :                 best_diff = diff;
     888           0 :                 best_idx  = j;
     889             :             }
     890             :         }
     891           0 :         FFSWAP(int, outlink->in_samplerates->formats[0],
     892             :                outlink->in_samplerates->formats[best_idx]);
     893             :     }
     894             : }
     895             : 
     896        5530 : static void swap_samplerates(AVFilterGraph *graph)
     897             : {
     898             :     int i;
     899             : 
     900       33507 :     for (i = 0; i < graph->nb_filters; i++)
     901       27977 :         swap_samplerates_on_filter(graph->filters[i]);
     902        5530 : }
     903             : 
     904             : #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
     905             : #define CH_FRONT_PAIR  (AV_CH_FRONT_LEFT           | AV_CH_FRONT_RIGHT)
     906             : #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT          | AV_CH_STEREO_RIGHT)
     907             : #define CH_WIDE_PAIR   (AV_CH_WIDE_LEFT            | AV_CH_WIDE_RIGHT)
     908             : #define CH_SIDE_PAIR   (AV_CH_SIDE_LEFT            | AV_CH_SIDE_RIGHT)
     909             : #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
     910             : #define CH_BACK_PAIR   (AV_CH_BACK_LEFT            | AV_CH_BACK_RIGHT)
     911             : 
     912             : /* allowable substitutions for channel pairs when comparing layouts,
     913             :  * ordered by priority for both values */
     914             : static const uint64_t ch_subst[][2] = {
     915             :     { CH_FRONT_PAIR,      CH_CENTER_PAIR     },
     916             :     { CH_FRONT_PAIR,      CH_WIDE_PAIR       },
     917             :     { CH_FRONT_PAIR,      AV_CH_FRONT_CENTER },
     918             :     { CH_CENTER_PAIR,     CH_FRONT_PAIR      },
     919             :     { CH_CENTER_PAIR,     CH_WIDE_PAIR       },
     920             :     { CH_CENTER_PAIR,     AV_CH_FRONT_CENTER },
     921             :     { CH_WIDE_PAIR,       CH_FRONT_PAIR      },
     922             :     { CH_WIDE_PAIR,       CH_CENTER_PAIR     },
     923             :     { CH_WIDE_PAIR,       AV_CH_FRONT_CENTER },
     924             :     { AV_CH_FRONT_CENTER, CH_FRONT_PAIR      },
     925             :     { AV_CH_FRONT_CENTER, CH_CENTER_PAIR     },
     926             :     { AV_CH_FRONT_CENTER, CH_WIDE_PAIR       },
     927             :     { CH_SIDE_PAIR,       CH_DIRECT_PAIR     },
     928             :     { CH_SIDE_PAIR,       CH_BACK_PAIR       },
     929             :     { CH_SIDE_PAIR,       AV_CH_BACK_CENTER  },
     930             :     { CH_BACK_PAIR,       CH_DIRECT_PAIR     },
     931             :     { CH_BACK_PAIR,       CH_SIDE_PAIR       },
     932             :     { CH_BACK_PAIR,       AV_CH_BACK_CENTER  },
     933             :     { AV_CH_BACK_CENTER,  CH_BACK_PAIR       },
     934             :     { AV_CH_BACK_CENTER,  CH_DIRECT_PAIR     },
     935             :     { AV_CH_BACK_CENTER,  CH_SIDE_PAIR       },
     936             : };
     937             : 
     938       27977 : static void swap_channel_layouts_on_filter(AVFilterContext *filter)
     939             : {
     940       27977 :     AVFilterLink *link = NULL;
     941             :     int i, j, k;
     942             : 
     943       45599 :     for (i = 0; i < filter->nb_inputs; i++) {
     944       22448 :         link = filter->inputs[i];
     945             : 
     946       27276 :         if (link->type == AVMEDIA_TYPE_AUDIO &&
     947        4828 :             link->out_channel_layouts->nb_channel_layouts == 1)
     948        4826 :             break;
     949             :     }
     950       27977 :     if (i == filter->nb_inputs)
     951       23151 :         return;
     952             : 
     953        8578 :     for (i = 0; i < filter->nb_outputs; i++) {
     954        3752 :         AVFilterLink *outlink = filter->outputs[i];
     955        3752 :         int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
     956             : 
     957        7503 :         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
     958        3751 :             outlink->in_channel_layouts->nb_channel_layouts < 2)
     959        3751 :             continue;
     960             : 
     961          19 :         for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) {
     962          18 :             uint64_t  in_chlayout = link->out_channel_layouts->channel_layouts[0];
     963          18 :             uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j];
     964          18 :             int  in_channels      = av_get_channel_layout_nb_channels(in_chlayout);
     965          18 :             int out_channels      = av_get_channel_layout_nb_channels(out_chlayout);
     966          18 :             int count_diff        = out_channels - in_channels;
     967             :             int matched_channels, extra_channels;
     968          18 :             int score = 100000;
     969             : 
     970          18 :             if (FF_LAYOUT2COUNT(in_chlayout) || FF_LAYOUT2COUNT(out_chlayout)) {
     971             :                 /* Compute score in case the input or output layout encodes
     972             :                    a channel count; in this case the score is not altered by
     973             :                    the computation afterwards, as in_chlayout and
     974             :                    out_chlayout have both been set to 0 */
     975          18 :                 if (FF_LAYOUT2COUNT(in_chlayout))
     976          18 :                     in_channels = FF_LAYOUT2COUNT(in_chlayout);
     977          18 :                 if (FF_LAYOUT2COUNT(out_chlayout))
     978           0 :                     out_channels = FF_LAYOUT2COUNT(out_chlayout);
     979          36 :                 score -= 10000 + FFABS(out_channels - in_channels) +
     980          18 :                          (in_channels > out_channels ? 10000 : 0);
     981          18 :                 in_chlayout = out_chlayout = 0;
     982             :                 /* Let the remaining computation run, even if the score
     983             :                    value is not altered */
     984             :             }
     985             : 
     986             :             /* channel substitution */
     987         396 :             for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
     988         378 :                 uint64_t cmp0 = ch_subst[k][0];
     989         378 :                 uint64_t cmp1 = ch_subst[k][1];
     990         378 :                 if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&
     991           0 :                     (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {
     992           0 :                     in_chlayout  &= ~cmp0;
     993           0 :                     out_chlayout &= ~cmp1;
     994             :                     /* add score for channel match, minus a deduction for
     995             :                        having to do the substitution */
     996           0 :                     score += 10 * av_get_channel_layout_nb_channels(cmp1) - 2;
     997             :                 }
     998             :             }
     999             : 
    1000             :             /* no penalty for LFE channel mismatch */
    1001          18 :             if ( (in_chlayout & AV_CH_LOW_FREQUENCY) &&
    1002           0 :                 (out_chlayout & AV_CH_LOW_FREQUENCY))
    1003           0 :                 score += 10;
    1004          18 :             in_chlayout  &= ~AV_CH_LOW_FREQUENCY;
    1005          18 :             out_chlayout &= ~AV_CH_LOW_FREQUENCY;
    1006             : 
    1007          18 :             matched_channels = av_get_channel_layout_nb_channels(in_chlayout &
    1008             :                                                                  out_chlayout);
    1009          18 :             extra_channels   = av_get_channel_layout_nb_channels(out_chlayout &
    1010          18 :                                                                  (~in_chlayout));
    1011          18 :             score += 10 * matched_channels - 5 * extra_channels;
    1012             : 
    1013          18 :             if (score > best_score ||
    1014           0 :                 (count_diff < best_count_diff && score == best_score)) {
    1015           1 :                 best_score = score;
    1016           1 :                 best_idx   = j;
    1017           1 :                 best_count_diff = count_diff;
    1018             :             }
    1019             :         }
    1020           1 :         av_assert0(best_idx >= 0);
    1021           1 :         FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0],
    1022             :                outlink->in_channel_layouts->channel_layouts[best_idx]);
    1023             :     }
    1024             : 
    1025             : }
    1026             : 
    1027        5530 : static void swap_channel_layouts(AVFilterGraph *graph)
    1028             : {
    1029             :     int i;
    1030             : 
    1031       33507 :     for (i = 0; i < graph->nb_filters; i++)
    1032       27977 :         swap_channel_layouts_on_filter(graph->filters[i]);
    1033        5530 : }
    1034             : 
    1035       27977 : static void swap_sample_fmts_on_filter(AVFilterContext *filter)
    1036             : {
    1037       27977 :     AVFilterLink *link = NULL;
    1038             :     int format, bps;
    1039             :     int i, j;
    1040             : 
    1041       45638 :     for (i = 0; i < filter->nb_inputs; i++) {
    1042       22449 :         link = filter->inputs[i];
    1043             : 
    1044       27278 :         if (link->type == AVMEDIA_TYPE_AUDIO &&
    1045        4829 :             link->out_formats->nb_formats == 1)
    1046        4788 :             break;
    1047             :     }
    1048       27977 :     if (i == filter->nb_inputs)
    1049       23189 :         return;
    1050             : 
    1051        4788 :     format = link->out_formats->formats[0];
    1052        4788 :     bps    = av_get_bytes_per_sample(format);
    1053             : 
    1054        8515 :     for (i = 0; i < filter->nb_outputs; i++) {
    1055        3727 :         AVFilterLink *outlink = filter->outputs[i];
    1056        3727 :         int best_idx = -1, best_score = INT_MIN;
    1057             : 
    1058        7453 :         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
    1059        3726 :             outlink->in_formats->nb_formats < 2)
    1060        3705 :             continue;
    1061             : 
    1062          49 :         for (j = 0; j < outlink->in_formats->nb_formats; j++) {
    1063          49 :             int out_format = outlink->in_formats->formats[j];
    1064          49 :             int out_bps    = av_get_bytes_per_sample(out_format);
    1065             :             int score;
    1066             : 
    1067          80 :             if (av_get_packed_sample_fmt(out_format) == format ||
    1068          31 :                 av_get_planar_sample_fmt(out_format) == format) {
    1069          22 :                 best_idx   = j;
    1070          22 :                 break;
    1071             :             }
    1072             : 
    1073             :             /* for s32 and float prefer double to prevent loss of information */
    1074          27 :             if (bps == 4 && out_bps == 8) {
    1075           0 :                 best_idx = j;
    1076           0 :                 break;
    1077             :             }
    1078             : 
    1079             :             /* prefer closest higher or equal bps */
    1080          27 :             score = -abs(out_bps - bps);
    1081          27 :             if (out_bps >= bps)
    1082           0 :                 score += INT_MAX/2;
    1083             : 
    1084          27 :             if (score > best_score) {
    1085          23 :                 best_score = score;
    1086          23 :                 best_idx   = j;
    1087             :             }
    1088             :         }
    1089          22 :         av_assert0(best_idx >= 0);
    1090          22 :         FFSWAP(int, outlink->in_formats->formats[0],
    1091             :                outlink->in_formats->formats[best_idx]);
    1092             :     }
    1093             : }
    1094             : 
    1095        5530 : static void swap_sample_fmts(AVFilterGraph *graph)
    1096             : {
    1097             :     int i;
    1098             : 
    1099       33507 :     for (i = 0; i < graph->nb_filters; i++)
    1100       27977 :         swap_sample_fmts_on_filter(graph->filters[i]);
    1101             : 
    1102        5530 : }
    1103             : 
    1104       11120 : static int pick_formats(AVFilterGraph *graph)
    1105             : {
    1106             :     int i, j, ret;
    1107             :     int change;
    1108             : 
    1109             :     do{
    1110       11120 :         change = 0;
    1111       67402 :         for (i = 0; i < graph->nb_filters; i++) {
    1112       56282 :             AVFilterContext *filter = graph->filters[i];
    1113       56282 :             if (filter->nb_inputs){
    1114       90273 :                 for (j = 0; j < filter->nb_inputs; j++){
    1115       45191 :                     if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->nb_formats == 1) {
    1116       11030 :                         if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
    1117           0 :                             return ret;
    1118       11030 :                         change = 1;
    1119             :                     }
    1120             :                 }
    1121             :             }
    1122       56282 :             if (filter->nb_outputs){
    1123       90343 :                 for (j = 0; j < filter->nb_outputs; j++){
    1124       45191 :                     if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->nb_formats == 1) {
    1125       11303 :                         if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
    1126           0 :                             return ret;
    1127       11303 :                         change = 1;
    1128             :                     }
    1129             :                 }
    1130             :             }
    1131       56282 :             if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
    1132       67731 :                 for (j = 0; j < filter->nb_outputs; j++) {
    1133       33884 :                     if(filter->outputs[j]->format<0) {
    1134          99 :                         if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
    1135           0 :                             return ret;
    1136          99 :                         change = 1;
    1137             :                     }
    1138             :                 }
    1139             :             }
    1140             :         }
    1141       11120 :     }while(change);
    1142             : 
    1143       33507 :     for (i = 0; i < graph->nb_filters; i++) {
    1144       27977 :         AVFilterContext *filter = graph->filters[i];
    1145             : 
    1146       50436 :         for (j = 0; j < filter->nb_inputs; j++)
    1147       22459 :             if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
    1148           0 :                 return ret;
    1149       50436 :         for (j = 0; j < filter->nb_outputs; j++)
    1150       22459 :             if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
    1151           0 :                 return ret;
    1152             :     }
    1153        5530 :     return 0;
    1154             : }
    1155             : 
    1156             : /**
    1157             :  * Configure the formats of all the links in the graph.
    1158             :  */
    1159        5530 : static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
    1160             : {
    1161             :     int ret;
    1162             : 
    1163             :     /* find supported formats from sub-filters, and merge along links */
    1164       11074 :     while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
    1165          14 :         av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
    1166        5530 :     if (ret < 0)
    1167           0 :         return ret;
    1168             : 
    1169             :     /* Once everything is merged, it's possible that we'll still have
    1170             :      * multiple valid media format choices. We try to minimize the amount
    1171             :      * of format conversion inside filters */
    1172        5530 :     if ((ret = reduce_formats(graph)) < 0)
    1173           0 :         return ret;
    1174             : 
    1175             :     /* for audio filters, ensure the best format, sample rate and channel layout
    1176             :      * is selected */
    1177        5530 :     swap_sample_fmts(graph);
    1178        5530 :     swap_samplerates(graph);
    1179        5530 :     swap_channel_layouts(graph);
    1180             : 
    1181        5530 :     if ((ret = pick_formats(graph)) < 0)
    1182           0 :         return ret;
    1183             : 
    1184        5530 :     return 0;
    1185             : }
    1186             : 
    1187        5530 : static int graph_config_pointers(AVFilterGraph *graph,
    1188             :                                              AVClass *log_ctx)
    1189             : {
    1190             :     unsigned i, j;
    1191        5530 :     int sink_links_count = 0, n = 0;
    1192             :     AVFilterContext *f;
    1193             :     AVFilterLink **sinks;
    1194             : 
    1195       33507 :     for (i = 0; i < graph->nb_filters; i++) {
    1196       27977 :         f = graph->filters[i];
    1197       50436 :         for (j = 0; j < f->nb_inputs; j++) {
    1198       22459 :             f->inputs[j]->graph     = graph;
    1199       22459 :             f->inputs[j]->age_index = -1;
    1200             :         }
    1201       50436 :         for (j = 0; j < f->nb_outputs; j++) {
    1202       22459 :             f->outputs[j]->graph    = graph;
    1203       22459 :             f->outputs[j]->age_index= -1;
    1204             :         }
    1205       27977 :         if (!f->nb_outputs) {
    1206        5535 :             if (f->nb_inputs > INT_MAX - sink_links_count)
    1207           0 :                 return AVERROR(EINVAL);
    1208        5535 :             sink_links_count += f->nb_inputs;
    1209             :         }
    1210             :     }
    1211        5530 :     sinks = av_calloc(sink_links_count, sizeof(*sinks));
    1212        5530 :     if (!sinks)
    1213           0 :         return AVERROR(ENOMEM);
    1214       33507 :     for (i = 0; i < graph->nb_filters; i++) {
    1215       27977 :         f = graph->filters[i];
    1216       27977 :         if (!f->nb_outputs) {
    1217       11070 :             for (j = 0; j < f->nb_inputs; j++) {
    1218        5535 :                 sinks[n] = f->inputs[j];
    1219        5535 :                 f->inputs[j]->age_index = n++;
    1220             :             }
    1221             :         }
    1222             :     }
    1223        5530 :     av_assert0(n == sink_links_count);
    1224        5530 :     graph->sink_links       = sinks;
    1225        5530 :     graph->sink_links_count = sink_links_count;
    1226        5530 :     return 0;
    1227             : }
    1228             : 
    1229        5530 : static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)
    1230             : {
    1231             :     AVFilterContext *f;
    1232             :     int i, j, ret;
    1233        5530 :     int fifo_count = 0;
    1234             : 
    1235       30608 :     for (i = 0; i < graph->nb_filters; i++) {
    1236       25078 :         f = graph->filters[i];
    1237             : 
    1238       44638 :         for (j = 0; j < f->nb_inputs; j++) {
    1239       19560 :             AVFilterLink *link = f->inputs[j];
    1240             :             AVFilterContext *fifo_ctx;
    1241             :             const AVFilter *fifo;
    1242             :             char name[32];
    1243             : 
    1244       19560 :             if (!link->dstpad->needs_fifo)
    1245       19550 :                 continue;
    1246             : 
    1247          20 :             fifo = f->inputs[j]->type == AVMEDIA_TYPE_VIDEO ?
    1248          10 :                    avfilter_get_by_name("fifo") :
    1249             :                    avfilter_get_by_name("afifo");
    1250             : 
    1251          10 :             snprintf(name, sizeof(name), "auto_fifo_%d", fifo_count++);
    1252             : 
    1253          10 :             ret = avfilter_graph_create_filter(&fifo_ctx, fifo, name, NULL,
    1254             :                                                NULL, graph);
    1255          10 :             if (ret < 0)
    1256           0 :                 return ret;
    1257             : 
    1258          10 :             ret = avfilter_insert_filter(link, fifo_ctx, 0, 0);
    1259          10 :             if (ret < 0)
    1260           0 :                 return ret;
    1261             :         }
    1262             :     }
    1263             : 
    1264        5530 :     return 0;
    1265             : }
    1266             : 
    1267        5530 : int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
    1268             : {
    1269             :     int ret;
    1270             : 
    1271        5530 :     if ((ret = graph_check_validity(graphctx, log_ctx)))
    1272           0 :         return ret;
    1273        5530 :     if ((ret = graph_insert_fifos(graphctx, log_ctx)) < 0)
    1274           0 :         return ret;
    1275        5530 :     if ((ret = graph_config_formats(graphctx, log_ctx)))
    1276           0 :         return ret;
    1277        5530 :     if ((ret = graph_config_links(graphctx, log_ctx)))
    1278           0 :         return ret;
    1279        5530 :     if ((ret = graph_check_links(graphctx, log_ctx)))
    1280           0 :         return ret;
    1281        5530 :     if ((ret = graph_config_pointers(graphctx, log_ctx)))
    1282           0 :         return ret;
    1283             : 
    1284        5530 :     return 0;
    1285             : }
    1286             : 
    1287           0 : int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
    1288             : {
    1289           0 :     int i, r = AVERROR(ENOSYS);
    1290             : 
    1291           0 :     if (!graph)
    1292           0 :         return r;
    1293             : 
    1294           0 :     if ((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {
    1295           0 :         r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
    1296           0 :         if (r != AVERROR(ENOSYS))
    1297           0 :             return r;
    1298             :     }
    1299             : 
    1300           0 :     if (res_len && res)
    1301           0 :         res[0] = 0;
    1302             : 
    1303           0 :     for (i = 0; i < graph->nb_filters; i++) {
    1304           0 :         AVFilterContext *filter = graph->filters[i];
    1305           0 :         if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) {
    1306           0 :             r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
    1307           0 :             if (r != AVERROR(ENOSYS)) {
    1308           0 :                 if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
    1309           0 :                     return r;
    1310             :             }
    1311             :         }
    1312             :     }
    1313             : 
    1314           0 :     return r;
    1315             : }
    1316             : 
    1317           0 : int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
    1318             : {
    1319             :     int i;
    1320             : 
    1321           0 :     if(!graph)
    1322           0 :         return 0;
    1323             : 
    1324           0 :     for (i = 0; i < graph->nb_filters; i++) {
    1325           0 :         AVFilterContext *filter = graph->filters[i];
    1326           0 :         if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
    1327           0 :             AVFilterCommand **queue = &filter->command_queue, *next;
    1328           0 :             while (*queue && (*queue)->time <= ts)
    1329           0 :                 queue = &(*queue)->next;
    1330           0 :             next = *queue;
    1331           0 :             *queue = av_mallocz(sizeof(AVFilterCommand));
    1332           0 :             if (!*queue)
    1333           0 :                 return AVERROR(ENOMEM);
    1334             : 
    1335           0 :             (*queue)->command = av_strdup(command);
    1336           0 :             (*queue)->arg     = av_strdup(arg);
    1337           0 :             (*queue)->time    = ts;
    1338           0 :             (*queue)->flags   = flags;
    1339           0 :             (*queue)->next    = next;
    1340           0 :             if(flags & AVFILTER_CMD_FLAG_ONE)
    1341           0 :                 return 0;
    1342             :         }
    1343             :     }
    1344             : 
    1345           0 :     return 0;
    1346             : }
    1347             : 
    1348      401134 : static void heap_bubble_up(AVFilterGraph *graph,
    1349             :                            AVFilterLink *link, int index)
    1350             : {
    1351      401134 :     AVFilterLink **links = graph->sink_links;
    1352             : 
    1353      401134 :     av_assert0(index >= 0);
    1354             : 
    1355      802273 :     while (index) {
    1356           5 :         int parent = (index - 1) >> 1;
    1357           5 :         if (links[parent]->current_pts_us >= link->current_pts_us)
    1358           0 :             break;
    1359           5 :         links[index] = links[parent];
    1360           5 :         links[index]->age_index = index;
    1361           5 :         index = parent;
    1362             :     }
    1363      401134 :     links[index] = link;
    1364      401134 :     link->age_index = index;
    1365      401134 : }
    1366             : 
    1367      401135 : static void heap_bubble_down(AVFilterGraph *graph,
    1368             :                              AVFilterLink *link, int index)
    1369             : {
    1370      401135 :     AVFilterLink **links = graph->sink_links;
    1371             : 
    1372      401135 :     av_assert0(index >= 0);
    1373             : 
    1374         577 :     while (1) {
    1375      401712 :         int child = 2 * index + 1;
    1376      401712 :         if (child >= graph->sink_links_count)
    1377      400975 :             break;
    1378         752 :         if (child + 1 < graph->sink_links_count &&
    1379          15 :             links[child + 1]->current_pts_us < links[child]->current_pts_us)
    1380           4 :             child++;
    1381         737 :         if (link->current_pts_us < links[child]->current_pts_us)
    1382         160 :             break;
    1383         577 :         links[index] = links[child];
    1384         577 :         links[index]->age_index = index;
    1385         577 :         index = child;
    1386             :     }
    1387      401135 :     links[index] = link;
    1388      401135 :     link->age_index = index;
    1389      401135 : }
    1390             : 
    1391      401134 : void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
    1392             : {
    1393      401134 :     heap_bubble_up  (graph, link, link->age_index);
    1394      401134 :     heap_bubble_down(graph, link, link->age_index);
    1395      401134 : }
    1396             : 
    1397      366446 : int avfilter_graph_request_oldest(AVFilterGraph *graph)
    1398             : {
    1399      366446 :     AVFilterLink *oldest = graph->sink_links[0];
    1400             :     int64_t frame_count;
    1401             :     int r;
    1402             : 
    1403      736202 :     while (graph->sink_links_count) {
    1404      366448 :         oldest = graph->sink_links[0];
    1405      366448 :         if (oldest->dst->filter->activate) {
    1406             :             /* For now, buffersink is the only filter implementing activate. */
    1407      366443 :             r = av_buffersink_get_frame_flags(oldest->dst, NULL,
    1408             :                                               AV_BUFFERSINK_FLAG_PEEK);
    1409      366443 :             if (r != AVERROR_EOF)
    1410      363133 :                 return r;
    1411             :         } else {
    1412           5 :             r = ff_request_frame(oldest);
    1413             :         }
    1414        3315 :         if (r != AVERROR_EOF)
    1415           5 :             break;
    1416       13240 :         av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
    1417        6620 :                oldest->dst ? oldest->dst->name : "unknown",
    1418        6620 :                oldest->dstpad ? oldest->dstpad->name : "unknown");
    1419             :         /* EOF: remove the link from the heap */
    1420        3310 :         if (oldest->age_index < --graph->sink_links_count)
    1421           1 :             heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],
    1422             :                              oldest->age_index);
    1423        3310 :         oldest->age_index = -1;
    1424             :     }
    1425        3313 :     if (!graph->sink_links_count)
    1426        3308 :         return AVERROR_EOF;
    1427             :     av_assert1(!oldest->dst->filter->activate);
    1428             :     av_assert1(oldest->age_index >= 0);
    1429           5 :     frame_count = oldest->frame_count_out;
    1430          39 :     while (frame_count == oldest->frame_count_out) {
    1431          29 :         r = ff_filter_graph_run_once(graph);
    1432          29 :         if (r == AVERROR(EAGAIN) &&
    1433           0 :             !oldest->frame_wanted_out && !oldest->frame_blocked_in &&
    1434           0 :             !oldest->status_in)
    1435           0 :             ff_request_frame(oldest);
    1436          29 :         else if (r < 0)
    1437           0 :             return r;
    1438             :     }
    1439           5 :     return 0;
    1440             : }
    1441             : 
    1442     4165172 : int ff_filter_graph_run_once(AVFilterGraph *graph)
    1443             : {
    1444             :     AVFilterContext *filter;
    1445             :     unsigned i;
    1446             : 
    1447     4165172 :     av_assert0(graph->nb_filters);
    1448     4165172 :     filter = graph->filters[0];
    1449    20169369 :     for (i = 1; i < graph->nb_filters; i++)
    1450    16004197 :         if (graph->filters[i]->ready > filter->ready)
    1451     2642574 :             filter = graph->filters[i];
    1452     4165172 :     if (!filter->ready)
    1453      398920 :         return AVERROR(EAGAIN);
    1454     3766252 :     return ff_filter_activate(filter);
    1455             : }

Generated by: LCOV version 1.13