falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
43714 Commits
32 Branches
824MB
Tree: 6c180b35c4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6c180b35c4'
${ noResults }
FFmpeg/libavfilter/avfiltergraph.c

1062 lines
37KB
Raw Blame History 

  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 <ctype.h>

  24. #include <string.h>

  25. 

  26. #include "libavutil/audioconvert.h"

  27. #include "libavutil/avassert.h"

  28. #include "libavutil/pixdesc.h"

  29. #include "libavcodec/avcodec.h" // avcodec_find_best_pix_fmt2()

  30. #include "avfilter.h"

  31. #include "avfiltergraph.h"

  32. #include "formats.h"

  33. #include "internal.h"

  34. 

  35. #include "libavutil/audioconvert.h"

  36. #include "libavutil/avassert.h"

  37. #include "libavutil/common.h"

  38. #include "libavutil/log.h"

  39. 

  40. static const AVClass filtergraph_class = {

  41.     .class_name = "AVFilterGraph",

  42.     .item_name  = av_default_item_name,

  43.     .version    = LIBAVUTIL_VERSION_INT,

  44.     .category   = AV_CLASS_CATEGORY_FILTER,

  45. };

  46. 

  47. AVFilterGraph *avfilter_graph_alloc(void)

  48. {

  49.     AVFilterGraph *ret = av_mallocz(sizeof(AVFilterGraph));

  50.     if (!ret)

  51.         return NULL;

  52.     ret->av_class = &filtergraph_class;

  53.     return ret;

  54. }

  55. 

  56. void avfilter_graph_free(AVFilterGraph **graph)

  57. {

  58.     if (!*graph)

  59.         return;

  60.     for (; (*graph)->filter_count > 0; (*graph)->filter_count--)

  61.         avfilter_free((*graph)->filters[(*graph)->filter_count - 1]);

  62.     av_freep(&(*graph)->sink_links);

  63.     av_freep(&(*graph)->scale_sws_opts);

  64.     av_freep(&(*graph)->filters);

  65.     av_freep(graph);

  66. }

  67. 

  68. int avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter)

  69. {

  70.     AVFilterContext **filters = av_realloc(graph->filters,

  71.                                            sizeof(AVFilterContext*) * (graph->filter_count+1));

  72.     if (!filters)

  73.         return AVERROR(ENOMEM);

  74. 

  75.     graph->filters = filters;

  76.     graph->filters[graph->filter_count++] = filter;

  77. 

  78.     return 0;

  79. }

  80. 

  81. int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt,

  82.                                  const char *name, const char *args, void *opaque,

  83.                                  AVFilterGraph *graph_ctx)

  84. {

  85.     int ret;

  86. 

  87.     if ((ret = avfilter_open(filt_ctx, filt, name)) < 0)

  88.         goto fail;

  89.     if ((ret = avfilter_init_filter(*filt_ctx, args, opaque)) < 0)

  90.         goto fail;

  91.     if ((ret = avfilter_graph_add_filter(graph_ctx, *filt_ctx)) < 0)

  92.         goto fail;

  93.     return 0;

  94. 

  95. fail:

  96.     if (*filt_ctx)

  97.         avfilter_free(*filt_ctx);

  98.     *filt_ctx = NULL;

  99.     return ret;

  100. }

  101. 

  102. void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)

  103. {

  104.     graph->disable_auto_convert = flags;

  105. }

  106. 

  107. /**

  108.  * Check for the validity of graph.

  109.  *

  110.  * A graph is considered valid if all its input and output pads are

  111.  * connected.

  112.  *

  113.  * @return 0 in case of success, a negative value otherwise

  114.  */

  115. static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)

  116. {

  117.     AVFilterContext *filt;

  118.     int i, j;

  119. 

  120.     for (i = 0; i < graph->filter_count; i++) {

  121.         filt = graph->filters[i];

  122. 

  123.         for (j = 0; j < filt->nb_inputs; j++) {

  124.             if (!filt->inputs[j] || !filt->inputs[j]->src) {

  125.                 av_log(log_ctx, AV_LOG_ERROR,

  126.                        "Input pad \"%s\" for the filter \"%s\" of type \"%s\" not connected to any source\n",

  127.                        filt->input_pads[j].name, filt->name, filt->filter->name);

  128.                 return AVERROR(EINVAL);

  129.             }

  130.         }

  131. 

  132.         for (j = 0; j < filt->nb_outputs; j++) {

  133.             if (!filt->outputs[j] || !filt->outputs[j]->dst) {

  134.                 av_log(log_ctx, AV_LOG_ERROR,

  135.                        "Output pad \"%s\" for the filter \"%s\" of type \"%s\" not connected to any destination\n",

  136.                        filt->output_pads[j].name, filt->name, filt->filter->name);

  137.                 return AVERROR(EINVAL);

  138.             }

  139.         }

  140.     }

  141. 

  142.     return 0;

  143. }

  144. 

  145. /**

  146.  * Configure all the links of graphctx.

  147.  *

  148.  * @return 0 in case of success, a negative value otherwise

  149.  */

  150. static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)

  151. {

  152.     AVFilterContext *filt;

  153.     int i, ret;

  154. 

  155.     for (i=0; i < graph->filter_count; i++) {

  156.         filt = graph->filters[i];

  157. 

  158.         if (!filt->nb_outputs) {

  159.             if ((ret = avfilter_config_links(filt)))

  160.                 return ret;

  161.         }

  162.     }

  163. 

  164.     return 0;

  165. }

  166. 

  167. AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name)

  168. {

  169.     int i;

  170. 

  171.     for (i = 0; i < graph->filter_count; i++)

  172.         if (graph->filters[i]->name && !strcmp(name, graph->filters[i]->name))

  173.             return graph->filters[i];

  174. 

  175.     return NULL;

  176. }

  177. 

  178. static int filter_query_formats(AVFilterContext *ctx)

  179. {

  180.     int ret;

  181.     AVFilterFormats *formats;

  182.     AVFilterChannelLayouts *chlayouts;

  183.     AVFilterFormats *samplerates;

  184.     enum AVMediaType type = ctx->inputs  && ctx->inputs [0] ? ctx->inputs [0]->type :

  185.                             ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :

  186.                             AVMEDIA_TYPE_VIDEO;

  187. 

  188.     if ((ret = ctx->filter->query_formats(ctx)) < 0)

  189.         return ret;

  190. 

  191.     formats = ff_all_formats(type);

  192.     if (!formats)

  193.         return AVERROR(ENOMEM);

  194.     ff_set_common_formats(ctx, formats);

  195.     if (type == AVMEDIA_TYPE_AUDIO) {

  196.         samplerates = ff_all_samplerates();

  197.         if (!samplerates)

  198.             return AVERROR(ENOMEM);

  199.         ff_set_common_samplerates(ctx, samplerates);

  200.         chlayouts = ff_all_channel_layouts();

  201.         if (!chlayouts)

  202.             return AVERROR(ENOMEM);

  203.         ff_set_common_channel_layouts(ctx, chlayouts);

  204.     }

  205.     return 0;

  206. }

  207. 

  208. static int insert_conv_filter(AVFilterGraph *graph, AVFilterLink *link,

  209.                               const char *filt_name, const char *filt_args)

  210. {

  211.     static int auto_count = 0, ret;

  212.     char inst_name[32];

  213.     AVFilterContext *filt_ctx;

  214. 

  215.     if (graph->disable_auto_convert) {

  216.         av_log(NULL, AV_LOG_ERROR,

  217.                "The filters '%s' and '%s' do not have a common format "

  218.                "and automatic conversion is disabled.\n",

  219.                link->src->name, link->dst->name);

  220.         return AVERROR(EINVAL);

  221.     }

  222. 

  223.     snprintf(inst_name, sizeof(inst_name), "auto-inserted %s %d",

  224.             filt_name, auto_count++);

  225. 

  226.     if ((ret = avfilter_graph_create_filter(&filt_ctx,

  227.                                             avfilter_get_by_name(filt_name),

  228.                                             inst_name, filt_args, NULL, graph)) < 0)

  229.         return ret;

  230.     if ((ret = avfilter_insert_filter(link, filt_ctx, 0, 0)) < 0)

  231.         return ret;

  232. 

  233.     filter_query_formats(filt_ctx);

  234. 

  235.     if ( ((link = filt_ctx-> inputs[0]) &&

  236.            !ff_merge_formats(link->in_formats, link->out_formats)) ||

  237.          ((link = filt_ctx->outputs[0]) &&

  238.            !ff_merge_formats(link->in_formats, link->out_formats))

  239.        ) {

  240.         av_log(NULL, AV_LOG_ERROR,

  241.                "Impossible to convert between the formats supported by the filter "

  242.                "'%s' and the filter '%s'\n", link->src->name, link->dst->name);

  243.         return AVERROR(EINVAL);

  244.     }

  245. 

  246.     if (link->type == AVMEDIA_TYPE_AUDIO &&

  247.          (((link = filt_ctx-> inputs[0]) &&

  248.            !ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts)) ||

  249.          ((link = filt_ctx->outputs[0]) &&

  250.            !ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts)))

  251.        ) {

  252.         av_log(NULL, AV_LOG_ERROR,

  253.                "Impossible to convert between the channel layouts formats supported by the filter "

  254.                "'%s' and the filter '%s'\n", link->src->name, link->dst->name);

  255.         return AVERROR(EINVAL);

  256.     }

  257. 

  258.     return 0;

  259. }

  260. 

  261. static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)

  262. {

  263.     int i, j, ret;

  264.     char filt_args[128];

  265.     AVFilterFormats *formats;

  266.     AVFilterChannelLayouts *chlayouts;

  267.     AVFilterFormats *samplerates;

  268.     int scaler_count = 0, resampler_count = 0;

  269. 

  270.     for (j = 0; j < 2; j++) {

  271.     /* ask all the sub-filters for their supported media formats */

  272.     for (i = 0; i < graph->filter_count; i++) {

  273.         /* Call query_formats on sources first.

  274.            This is a temporary workaround for amerge,

  275.            until format renegociation is implemented. */

  276.         if (!graph->filters[i]->nb_inputs == j)

  277.             continue;

  278.         if (graph->filters[i]->filter->query_formats)

  279.             ret = filter_query_formats(graph->filters[i]);

  280.         else

  281.             ret = ff_default_query_formats(graph->filters[i]);

  282.         if (ret < 0)

  283.             return ret;

  284.     }

  285.     }

  286. 

  287.     /* go through and merge as many format lists as possible */

  288.     for (i = 0; i < graph->filter_count; i++) {

  289.         AVFilterContext *filter = graph->filters[i];

  290. 

  291.         for (j = 0; j < filter->nb_inputs; j++) {

  292.             AVFilterLink *link = filter->inputs[j];

  293. #if 0

  294.             if (!link) continue;

  295. 

  296.             if (!link->in_formats || !link->out_formats)

  297.                 return AVERROR(EINVAL);

  298. 

  299.             if (link->type == AVMEDIA_TYPE_VIDEO &&

  300.                 !ff_merge_formats(link->in_formats, link->out_formats)) {

  301. 

  302.                 /* couldn't merge format lists, auto-insert scale filter */

  303.                 snprintf(filt_args, sizeof(filt_args), "0:0:%s",

  304.                          graph->scale_sws_opts);

  305.                 if (ret = insert_conv_filter(graph, link, "scale", filt_args))

  306.                     return ret;

  307.             }

  308.             else if (link->type == AVMEDIA_TYPE_AUDIO) {

  309.                 if (!link->in_channel_layouts || !link->out_channel_layouts)

  310.                     return AVERROR(EINVAL);

  311. 

  312.                 /* Merge all three list before checking: that way, in all

  313.                  * three categories, aconvert will use a common format

  314.                  * whenever possible. */

  315.                 formats     = ff_merge_formats(link->in_formats,   link->out_formats);

  316.                 chlayouts   = ff_merge_channel_layouts(link->in_channel_layouts  , link->out_channel_layouts);

  317.                 samplerates = ff_merge_samplerates    (link->in_samplerates, link->out_samplerates);

  318. 

  319.                 if (!formats || !chlayouts || !samplerates)

  320.                     if (ret = insert_conv_filter(graph, link, "aresample", NULL))

  321.                        return ret;

  322. #else

  323.             int convert_needed = 0;

  324. 

  325.             if (!link)

  326.                 continue;

  327. 

  328.             if (link->in_formats != link->out_formats &&

  329.                 !ff_merge_formats(link->in_formats,

  330.                                         link->out_formats))

  331.                 convert_needed = 1;

  332.             if (link->type == AVMEDIA_TYPE_AUDIO) {

  333.                 if (link->in_channel_layouts != link->out_channel_layouts &&

  334.                     !ff_merge_channel_layouts(link->in_channel_layouts,

  335.                                               link->out_channel_layouts))

  336.                     convert_needed = 1;

  337.                 if (link->in_samplerates != link->out_samplerates &&

  338.                     !ff_merge_samplerates(link->in_samplerates,

  339.                                           link->out_samplerates))

  340.                     convert_needed = 1;

  341.             }

  342. 

  343.             if (convert_needed) {

  344.                 AVFilterContext *convert;

  345.                 AVFilter *filter;

  346.                 AVFilterLink *inlink, *outlink;

  347.                 char scale_args[256];

  348.                 char inst_name[30];

  349. 

  350.                 /* couldn't merge format lists. auto-insert conversion filter */

  351.                 switch (link->type) {

  352.                 case AVMEDIA_TYPE_VIDEO:

  353.                     if (!(filter = avfilter_get_by_name("scale"))) {

  354.                         av_log(log_ctx, AV_LOG_ERROR, "'scale' filter "

  355.                                "not present, cannot convert pixel formats.\n");

  356.                         return AVERROR(EINVAL);

  357.                     }

  358. 

  359.                     snprintf(inst_name, sizeof(inst_name), "auto-inserted scaler %d",

  360.                              scaler_count++);

  361.                     snprintf(scale_args, sizeof(scale_args), "0:0:%s", graph->scale_sws_opts);

  362.                     if ((ret = avfilter_graph_create_filter(&convert, filter,

  363.                                                             inst_name, scale_args, NULL,

  364.                                                             graph)) < 0)

  365.                         return ret;

  366.                     break;

  367.                 case AVMEDIA_TYPE_AUDIO:

  368.                     if (!(filter = avfilter_get_by_name("aresample"))) {

  369.                         av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter "

  370.                                "not present, cannot convert audio formats.\n");

  371.                         return AVERROR(EINVAL);

  372.                     }

  373. 

  374.                     snprintf(inst_name, sizeof(inst_name), "auto-inserted resampler %d",

  375.                              resampler_count++);

  376.                     if ((ret = avfilter_graph_create_filter(&convert, filter,

  377.                                                             inst_name, NULL, NULL, graph)) < 0)

  378.                         return ret;

  379.                     break;

  380.                 default:

  381.                     return AVERROR(EINVAL);

  382.                 }

  383. 

  384.                 if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)

  385.                     return ret;

  386. 

  387.                 filter_query_formats(convert);

  388.                 inlink  = convert->inputs[0];

  389.                 outlink = convert->outputs[0];

  390.                 if (!ff_merge_formats( inlink->in_formats,  inlink->out_formats) ||

  391.                     !ff_merge_formats(outlink->in_formats, outlink->out_formats))

  392.                     ret |= AVERROR(ENOSYS);

  393.                 if (inlink->type == AVMEDIA_TYPE_AUDIO &&

  394.                     (!ff_merge_samplerates(inlink->in_samplerates,

  395.                                            inlink->out_samplerates) ||

  396.                      !ff_merge_channel_layouts(inlink->in_channel_layouts,

  397.                                                inlink->out_channel_layouts)))

  398.                     ret |= AVERROR(ENOSYS);

  399.                 if (outlink->type == AVMEDIA_TYPE_AUDIO &&

  400.                     (!ff_merge_samplerates(outlink->in_samplerates,

  401.                                            outlink->out_samplerates) ||

  402.                      !ff_merge_channel_layouts(outlink->in_channel_layouts,

  403.                                                outlink->out_channel_layouts)))

  404.                     ret |= AVERROR(ENOSYS);

  405. 

  406.                 if (ret < 0) {

  407.                     av_log(log_ctx, AV_LOG_ERROR,

  408.                            "Impossible to convert between the formats supported by the filter "

  409.                            "'%s' and the filter '%s'\n", link->src->name, link->dst->name);

  410.                     return ret;

  411.                 }

  412. #endif

  413.             }

  414.         }

  415.     }

  416. 

  417.     return 0;

  418. }

  419. 

  420. static int pick_format(AVFilterLink *link, AVFilterLink *ref)

  421. {

  422.     if (!link || !link->in_formats)

  423.         return 0;

  424. 

  425.     if (link->type == AVMEDIA_TYPE_VIDEO) {

  426.         if(ref && ref->type == AVMEDIA_TYPE_VIDEO){

  427.             int has_alpha= av_pix_fmt_descriptors[ref->format].nb_components % 2 == 0;

  428.             enum PixelFormat best= PIX_FMT_NONE;

  429.             int i;

  430.             for (i=0; i<link->in_formats->format_count; i++) {

  431.                 enum PixelFormat p = link->in_formats->formats[i];

  432.                 best= avcodec_find_best_pix_fmt2(best, p, ref->format, has_alpha, NULL);

  433.             }

  434.             av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",

  435.                    av_get_pix_fmt_name(best), link->in_formats->format_count,

  436.                    av_get_pix_fmt_name(ref->format), has_alpha);

  437.             link->in_formats->formats[0] = best;

  438.         }

  439.     }

  440. 

  441.     link->in_formats->format_count = 1;

  442.     link->format = link->in_formats->formats[0];

  443. 

  444.     if (link->type == AVMEDIA_TYPE_AUDIO) {

  445.         if (!link->in_samplerates->format_count) {

  446.             av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"

  447.                    " the link between filters %s and %s.\n", link->src->name,

  448.                    link->dst->name);

  449.             return AVERROR(EINVAL);

  450.         }

  451.         link->in_samplerates->format_count = 1;

  452.         link->sample_rate = link->in_samplerates->formats[0];

  453. 

  454.         if (!link->in_channel_layouts->nb_channel_layouts) {

  455.             av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"

  456.                    "the link between filters %s and %s.\n", link->src->name,

  457.                    link->dst->name);

  458.             return AVERROR(EINVAL);

  459.         }

  460.         link->in_channel_layouts->nb_channel_layouts = 1;

  461.         link->channel_layout = link->in_channel_layouts->channel_layouts[0];

  462.     }

  463. 

  464.     ff_formats_unref(&link->in_formats);

  465.     ff_formats_unref(&link->out_formats);

  466.     ff_formats_unref(&link->in_samplerates);

  467.     ff_formats_unref(&link->out_samplerates);

  468.     ff_channel_layouts_unref(&link->in_channel_layouts);

  469.     ff_channel_layouts_unref(&link->out_channel_layouts);

  470. 

  471.     return 0;

  472. }

  473. 

  474. #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \

  475. do {                                                                   \

  476.     for (i = 0; i < filter->nb_inputs; i++) {                          \

  477.         AVFilterLink *link = filter->inputs[i];                        \

  478.         fmt_type fmt;                                                  \

  479.                                                                        \

  480.         if (!link->out_ ## list || link->out_ ## list->nb != 1)        \

  481.             continue;                                                  \

  482.         fmt = link->out_ ## list->var[0];                              \

  483.                                                                        \

  484.         for (j = 0; j < filter->nb_outputs; j++) {                     \

  485.             AVFilterLink *out_link = filter->outputs[j];               \

  486.             list_type *fmts;                                           \

  487.                                                                        \

  488.             if (link->type != out_link->type ||                        \

  489.                 out_link->in_ ## list->nb == 1)                        \

  490.                 continue;                                              \

  491.             fmts = out_link->in_ ## list;                              \

  492.                                                                        \

  493.             if (!out_link->in_ ## list->nb) {                          \

  494.                 add_format(&out_link->in_ ##list, fmt);                \

  495.                 break;                                                 \

  496.             }                                                          \

  497.                                                                        \

  498.             for (k = 0; k < out_link->in_ ## list->nb; k++)            \

  499.                 if (fmts->var[k] == fmt) {                             \

  500.                     fmts->var[0]  = fmt;                               \

  501.                     fmts->nb = 1;                                      \

  502.                     ret = 1;                                           \

  503.                     break;                                             \

  504.                 }                                                      \

  505.         }                                                              \

  506.     }                                                                  \

  507. } while (0)

  508. 

  509. static int reduce_formats_on_filter(AVFilterContext *filter)

  510. {

  511.     int i, j, k, ret = 0;

  512. 

  513.     REDUCE_FORMATS(int,      AVFilterFormats,        formats,         formats,

  514.                    format_count, ff_add_format);

  515.     REDUCE_FORMATS(int,      AVFilterFormats,        samplerates,     formats,

  516.                    format_count, ff_add_format);

  517.     REDUCE_FORMATS(uint64_t, AVFilterChannelLayouts, channel_layouts,

  518.                    channel_layouts, nb_channel_layouts, ff_add_channel_layout);

  519. 

  520.     return ret;

  521. }

  522. 

  523. static void reduce_formats(AVFilterGraph *graph)

  524. {

  525.     int i, reduced;

  526. 

  527.     do {

  528.         reduced = 0;

  529. 

  530.         for (i = 0; i < graph->filter_count; i++)

  531.             reduced |= reduce_formats_on_filter(graph->filters[i]);

  532.     } while (reduced);

  533. }

  534. 

  535. static void swap_samplerates_on_filter(AVFilterContext *filter)

  536. {

  537.     AVFilterLink *link = NULL;

  538.     int sample_rate;

  539.     int i, j;

  540. 

  541.     for (i = 0; i < filter->nb_inputs; i++) {

  542.         link = filter->inputs[i];

  543. 

  544.         if (link->type == AVMEDIA_TYPE_AUDIO &&

  545.             link->out_samplerates->format_count == 1)

  546.             break;

  547.     }

  548.     if (i == filter->nb_inputs)

  549.         return;

  550. 

  551.     sample_rate = link->out_samplerates->formats[0];

  552. 

  553.     for (i = 0; i < filter->nb_outputs; i++) {

  554.         AVFilterLink *outlink = filter->outputs[i];

  555.         int best_idx, best_diff = INT_MAX;

  556. 

  557.         if (outlink->type != AVMEDIA_TYPE_AUDIO ||

  558.             outlink->in_samplerates->format_count < 2)

  559.             continue;

  560. 

  561.         for (j = 0; j < outlink->in_samplerates->format_count; j++) {

  562.             int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);

  563. 

  564.             if (diff < best_diff) {

  565.                 best_diff = diff;

  566.                 best_idx  = j;

  567.             }

  568.         }

  569.         FFSWAP(int, outlink->in_samplerates->formats[0],

  570.                outlink->in_samplerates->formats[best_idx]);

  571.     }

  572. }

  573. 

  574. static void swap_samplerates(AVFilterGraph *graph)

  575. {

  576.     int i;

  577. 

  578.     for (i = 0; i < graph->filter_count; i++)

  579.         swap_samplerates_on_filter(graph->filters[i]);

  580. }

  581. 

  582. #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)

  583. #define CH_FRONT_PAIR  (AV_CH_FRONT_LEFT           | AV_CH_FRONT_RIGHT)

  584. #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT          | AV_CH_STEREO_RIGHT)

  585. #define CH_WIDE_PAIR   (AV_CH_WIDE_LEFT            | AV_CH_WIDE_RIGHT)

  586. #define CH_SIDE_PAIR   (AV_CH_SIDE_LEFT            | AV_CH_SIDE_RIGHT)

  587. #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)

  588. #define CH_BACK_PAIR   (AV_CH_BACK_LEFT            | AV_CH_BACK_RIGHT)

  589. 

  590. /* allowable substitutions for channel pairs when comparing layouts,

  591.  * ordered by priority for both values */

  592. static const uint64_t ch_subst[][2] = {

  593.     { CH_FRONT_PAIR,      CH_CENTER_PAIR     },

  594.     { CH_FRONT_PAIR,      CH_WIDE_PAIR       },

  595.     { CH_FRONT_PAIR,      AV_CH_FRONT_CENTER },

  596.     { CH_CENTER_PAIR,     CH_FRONT_PAIR      },

  597.     { CH_CENTER_PAIR,     CH_WIDE_PAIR       },

  598.     { CH_CENTER_PAIR,     AV_CH_FRONT_CENTER },

  599.     { CH_WIDE_PAIR,       CH_FRONT_PAIR      },

  600.     { CH_WIDE_PAIR,       CH_CENTER_PAIR     },

  601.     { CH_WIDE_PAIR,       AV_CH_FRONT_CENTER },

  602.     { AV_CH_FRONT_CENTER, CH_FRONT_PAIR      },

  603.     { AV_CH_FRONT_CENTER, CH_CENTER_PAIR     },

  604.     { AV_CH_FRONT_CENTER, CH_WIDE_PAIR       },

  605.     { CH_SIDE_PAIR,       CH_DIRECT_PAIR     },

  606.     { CH_SIDE_PAIR,       CH_BACK_PAIR       },

  607.     { CH_SIDE_PAIR,       AV_CH_BACK_CENTER  },

  608.     { CH_BACK_PAIR,       CH_DIRECT_PAIR     },

  609.     { CH_BACK_PAIR,       CH_SIDE_PAIR       },

  610.     { CH_BACK_PAIR,       AV_CH_BACK_CENTER  },

  611.     { AV_CH_BACK_CENTER,  CH_BACK_PAIR       },

  612.     { AV_CH_BACK_CENTER,  CH_DIRECT_PAIR     },

  613.     { AV_CH_BACK_CENTER,  CH_SIDE_PAIR       },

  614. };

  615. 

  616. static void swap_channel_layouts_on_filter(AVFilterContext *filter)

  617. {

  618.     AVFilterLink *link = NULL;

  619.     int i, j, k;

  620. 

  621.     for (i = 0; i < filter->nb_inputs; i++) {

  622.         link = filter->inputs[i];

  623. 

  624.         if (link->type == AVMEDIA_TYPE_AUDIO &&

  625.             link->out_channel_layouts->nb_channel_layouts == 1)

  626.             break;

  627.     }

  628.     if (i == filter->nb_inputs)

  629.         return;

  630. 

  631.     for (i = 0; i < filter->nb_outputs; i++) {

  632.         AVFilterLink *outlink = filter->outputs[i];

  633.         int best_idx, best_score = INT_MIN, best_count_diff = INT_MAX;

  634. 

  635.         if (outlink->type != AVMEDIA_TYPE_AUDIO ||

  636.             outlink->in_channel_layouts->nb_channel_layouts < 2)

  637.             continue;

  638. 

  639.         for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) {

  640.             uint64_t  in_chlayout = link->out_channel_layouts->channel_layouts[0];

  641.             uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j];

  642.             int  in_channels      = av_get_channel_layout_nb_channels(in_chlayout);

  643.             int out_channels      = av_get_channel_layout_nb_channels(out_chlayout);

  644.             int count_diff        = out_channels - in_channels;

  645.             int matched_channels, extra_channels;

  646.             int score = 0;

  647. 

  648.             /* channel substitution */

  649.             for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {

  650.                 uint64_t cmp0 = ch_subst[k][0];

  651.                 uint64_t cmp1 = ch_subst[k][1];

  652.                 if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&

  653.                     (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {

  654.                     in_chlayout  &= ~cmp0;

  655.                     out_chlayout &= ~cmp1;

  656.                     /* add score for channel match, minus a deduction for

  657.                        having to do the substitution */

  658.                     score += 10 * av_get_channel_layout_nb_channels(cmp1) - 2;

  659.                 }

  660.             }

  661. 

  662.             /* no penalty for LFE channel mismatch */

  663.             if ( (in_chlayout & AV_CH_LOW_FREQUENCY) &&

  664.                 (out_chlayout & AV_CH_LOW_FREQUENCY))

  665.                 score += 10;

  666.             in_chlayout  &= ~AV_CH_LOW_FREQUENCY;

  667.             out_chlayout &= ~AV_CH_LOW_FREQUENCY;

  668. 

  669.             matched_channels = av_get_channel_layout_nb_channels(in_chlayout &

  670.                                                                  out_chlayout);

  671.             extra_channels   = av_get_channel_layout_nb_channels(out_chlayout &

  672.                                                                  (~in_chlayout));

  673.             score += 10 * matched_channels - 5 * extra_channels;

  674. 

  675.             if (score > best_score ||

  676.                 (count_diff < best_count_diff && score == best_score)) {

  677.                 best_score = score;

  678.                 best_idx   = j;

  679.                 best_count_diff = count_diff;

  680.             }

  681.         }

  682.         FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0],

  683.                outlink->in_channel_layouts->channel_layouts[best_idx]);

  684.     }

  685. 

  686. }

  687. 

  688. static void swap_channel_layouts(AVFilterGraph *graph)

  689. {

  690.     int i;

  691. 

  692.     for (i = 0; i < graph->filter_count; i++)

  693.         swap_channel_layouts_on_filter(graph->filters[i]);

  694. }

  695. 

  696. static void swap_sample_fmts_on_filter(AVFilterContext *filter)

  697. {

  698.     AVFilterLink *link = NULL;

  699.     int format, bps;

  700.     int i, j;

  701. 

  702.     for (i = 0; i < filter->nb_inputs; i++) {

  703.         link = filter->inputs[i];

  704. 

  705.         if (link->type == AVMEDIA_TYPE_AUDIO &&

  706.             link->out_formats->format_count == 1)

  707.             break;

  708.     }

  709.     if (i == filter->nb_inputs)

  710.         return;

  711. 

  712.     format = link->out_formats->formats[0];

  713.     bps    = av_get_bytes_per_sample(format);

  714. 

  715.     for (i = 0; i < filter->nb_outputs; i++) {

  716.         AVFilterLink *outlink = filter->outputs[i];

  717.         int best_idx = -1, best_score = INT_MIN;

  718. 

  719.         if (outlink->type != AVMEDIA_TYPE_AUDIO ||

  720.             outlink->in_formats->format_count < 2)

  721.             continue;

  722. 

  723.         for (j = 0; j < outlink->in_formats->format_count; j++) {

  724.             int out_format = outlink->in_formats->formats[j];

  725.             int out_bps    = av_get_bytes_per_sample(out_format);

  726.             int score;

  727. 

  728.             if (av_get_packed_sample_fmt(out_format) == format ||

  729.                 av_get_planar_sample_fmt(out_format) == format) {

  730.                 best_idx   = j;

  731.                 break;

  732.             }

  733. 

  734.             /* for s32 and float prefer double to prevent loss of information */

  735.             if (bps == 4 && out_bps == 8) {

  736.                 best_idx = j;

  737.                 break;

  738.             }

  739. 

  740.             /* prefer closest higher or equal bps */

  741.             score = -abs(out_bps - bps);

  742.             if (out_bps >= bps)

  743.                 score += INT_MAX/2;

  744. 

  745.             if (score > best_score) {

  746.                 best_score = score;

  747.                 best_idx   = j;

  748.             }

  749.         }

  750.         av_assert0(best_idx >= 0);

  751.         FFSWAP(int, outlink->in_formats->formats[0],

  752.                outlink->in_formats->formats[best_idx]);

  753.     }

  754. }

  755. 

  756. static void swap_sample_fmts(AVFilterGraph *graph)

  757. {

  758.     int i;

  759. 

  760.     for (i = 0; i < graph->filter_count; i++)

  761.         swap_sample_fmts_on_filter(graph->filters[i]);

  762. 

  763. }

  764. 

  765. static int pick_formats(AVFilterGraph *graph)

  766. {

  767.     int i, j, ret;

  768.     int change;

  769. 

  770.     do{

  771.         change = 0;

  772.         for (i = 0; i < graph->filter_count; i++) {

  773.             AVFilterContext *filter = graph->filters[i];

  774.             if (filter->nb_inputs){

  775.                 for (j = 0; j < filter->nb_inputs; j++){

  776.                     if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->format_count == 1) {

  777.                         pick_format(filter->inputs[j], NULL);

  778.                         change = 1;

  779.                     }

  780.                 }

  781.             }

  782.             if (filter->nb_outputs){

  783.                 for (j = 0; j < filter->nb_outputs; j++){

  784.                     if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->format_count == 1) {

  785.                         pick_format(filter->outputs[j], NULL);

  786.                         change = 1;

  787.                     }

  788.                 }

  789.             }

  790.             if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {

  791.                 for (j = 0; j < filter->nb_outputs; j++) {

  792.                     if(filter->outputs[j]->format<0) {

  793.                         pick_format(filter->outputs[j], filter->inputs[0]);

  794.                         change = 1;

  795.                     }

  796.                 }

  797.             }

  798.         }

  799.     }while(change);

  800. 

  801.     for (i = 0; i < graph->filter_count; i++) {

  802.         AVFilterContext *filter = graph->filters[i];

  803. 

  804.         for (j = 0; j < filter->nb_inputs; j++)

  805.             if ((ret = pick_format(filter->inputs[j], NULL)) < 0)

  806.                 return ret;

  807.         for (j = 0; j < filter->nb_outputs; j++)

  808.             if ((ret = pick_format(filter->outputs[j], NULL)) < 0)

  809.                 return ret;

  810.     }

  811.     return 0;

  812. }

  813. 

  814. /**

  815.  * Configure the formats of all the links in the graph.

  816.  */

  817. static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)

  818. {

  819.     int ret;

  820. 

  821.     /* find supported formats from sub-filters, and merge along links */

  822.     if ((ret = query_formats(graph, log_ctx)) < 0)

  823.         return ret;

  824. 

  825.     /* Once everything is merged, it's possible that we'll still have

  826.      * multiple valid media format choices. We try to minimize the amount

  827.      * of format conversion inside filters */

  828.     reduce_formats(graph);

  829. 

  830.     /* for audio filters, ensure the best format, sample rate and channel layout

  831.      * is selected */

  832.     swap_sample_fmts(graph);

  833.     swap_samplerates(graph);

  834.     swap_channel_layouts(graph);

  835. 

  836.     if ((ret = pick_formats(graph)) < 0)

  837.         return ret;

  838. 

  839.     return 0;

  840. }

  841. 

  842. static int ff_avfilter_graph_config_pointers(AVFilterGraph *graph,

  843.                                              AVClass *log_ctx)

  844. {

  845.     unsigned i, j;

  846.     int sink_links_count = 0, n = 0;

  847.     AVFilterContext *f;

  848.     AVFilterLink **sinks;

  849. 

  850.     for (i = 0; i < graph->filter_count; i++) {

  851.         f = graph->filters[i];

  852.         for (j = 0; j < f->nb_inputs; j++) {

  853.             f->inputs[j]->graph     = graph;

  854.             f->inputs[j]->age_index = -1;

  855.         }

  856.         for (j = 0; j < f->nb_outputs; j++) {

  857.             f->outputs[j]->graph    = graph;

  858.             f->outputs[j]->age_index= -1;

  859.         }

  860.         if (!f->nb_outputs) {

  861.             if (f->nb_inputs > INT_MAX - sink_links_count)

  862.                 return AVERROR(EINVAL);

  863.             sink_links_count += f->nb_inputs;

  864.         }

  865.     }

  866.     sinks = av_calloc(sink_links_count, sizeof(*sinks));

  867.     if (!sinks)

  868.         return AVERROR(ENOMEM);

  869.     for (i = 0; i < graph->filter_count; i++) {

  870.         f = graph->filters[i];

  871.         if (!f->nb_outputs) {

  872.             for (j = 0; j < f->nb_inputs; j++) {

  873.                 sinks[n] = f->inputs[j];

  874.                 f->inputs[j]->age_index = n++;

  875.             }

  876.         }

  877.     }

  878.     av_assert0(n == sink_links_count);

  879.     graph->sink_links       = sinks;

  880.     graph->sink_links_count = sink_links_count;

  881.     return 0;

  882. }

  883. 

  884. static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)

  885. {

  886.     AVFilterContext *f;

  887.     int i, j, ret;

  888.     int fifo_count = 0;

  889. 

  890.     for (i = 0; i < graph->filter_count; i++) {

  891.         f = graph->filters[i];

  892. 

  893.         for (j = 0; j < f->nb_inputs; j++) {

  894.             AVFilterLink *link = f->inputs[j];

  895.             AVFilterContext *fifo_ctx;

  896.             AVFilter *fifo;

  897.             char name[32];

  898. 

  899.             if (!link->dstpad->needs_fifo)

  900.                 continue;

  901. 

  902.             fifo = f->inputs[j]->type == AVMEDIA_TYPE_VIDEO ?

  903.                    avfilter_get_by_name("fifo") :

  904.                    avfilter_get_by_name("afifo");

  905. 

  906.             snprintf(name, sizeof(name), "auto-inserted fifo %d", fifo_count++);

  907. 

  908.             ret = avfilter_graph_create_filter(&fifo_ctx, fifo, name, NULL,

  909.                                                NULL, graph);

  910.             if (ret < 0)

  911.                 return ret;

  912. 

  913.             ret = avfilter_insert_filter(link, fifo_ctx, 0, 0);

  914.             if (ret < 0)

  915.                 return ret;

  916.         }

  917.     }

  918. 

  919.     return 0;

  920. }

  921. 

  922. int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)

  923. {

  924.     int ret;

  925. 

  926.     if ((ret = graph_check_validity(graphctx, log_ctx)))

  927.         return ret;

  928.     if ((ret = graph_insert_fifos(graphctx, log_ctx)) < 0)

  929.         return ret;

  930.     if ((ret = graph_config_formats(graphctx, log_ctx)))

  931.         return ret;

  932.     if ((ret = graph_config_links(graphctx, log_ctx)))

  933.         return ret;

  934.     if ((ret = ff_avfilter_graph_config_pointers(graphctx, log_ctx)))

  935.         return ret;

  936. 

  937.     return 0;

  938. }

  939. 

  940. int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)

  941. {

  942.     int i, r = AVERROR(ENOSYS);

  943. 

  944.     if(!graph)

  945.         return r;

  946. 

  947.     if((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {

  948.         r=avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);

  949.         if(r != AVERROR(ENOSYS))

  950.             return r;

  951.     }

  952. 

  953.     if(res_len && res)

  954.         res[0]= 0;

  955. 

  956.     for (i = 0; i < graph->filter_count; i++) {

  957.         AVFilterContext *filter = graph->filters[i];

  958.         if(!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)){

  959.             r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);

  960.             if(r != AVERROR(ENOSYS)) {

  961.                 if((flags & AVFILTER_CMD_FLAG_ONE) || r<0)

  962.                     return r;

  963.             }

  964.         }

  965.     }

  966. 

  967.     return r;

  968. }

  969. 

  970. int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)

  971. {

  972.     int i;

  973. 

  974.     if(!graph)

  975.         return 0;

  976. 

  977.     for (i = 0; i < graph->filter_count; i++) {

  978.         AVFilterContext *filter = graph->filters[i];

  979.         if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){

  980.             AVFilterCommand **que = &filter->command_queue, *next;

  981.             while(*que && (*que)->time <= ts)

  982.                 que = &(*que)->next;

  983.             next= *que;

  984.             *que= av_mallocz(sizeof(AVFilterCommand));

  985.             (*que)->command = av_strdup(command);

  986.             (*que)->arg     = av_strdup(arg);

  987.             (*que)->time    = ts;

  988.             (*que)->flags   = flags;

  989.             (*que)->next    = next;

  990.             if(flags & AVFILTER_CMD_FLAG_ONE)

  991.                 return 0;

  992.         }

  993.     }

  994. 

  995.     return 0;

  996. }

  997. 

  998. static void heap_bubble_up(AVFilterGraph *graph,

  999.                            AVFilterLink *link, int index)

  1000. {

  1001.     AVFilterLink **links = graph->sink_links;

  1002. 

  1003.     while (index) {

  1004.         int parent = (index - 1) >> 1;

  1005.         if (links[parent]->current_pts >= link->current_pts)

  1006.             break;

  1007.         links[index] = links[parent];

  1008.         links[index]->age_index = index;

  1009.         index = parent;

  1010.     }

  1011.     links[index] = link;

  1012.     link->age_index = index;

  1013. }

  1014. 

  1015. static void heap_bubble_down(AVFilterGraph *graph,

  1016.                              AVFilterLink *link, int index)

  1017. {

  1018.     AVFilterLink **links = graph->sink_links;

  1019. 

  1020.     while (1) {

  1021.         int child = 2 * index + 1;

  1022.         if (child >= graph->sink_links_count)

  1023.             break;

  1024.         if (child + 1 < graph->sink_links_count &&

  1025.             links[child + 1]->current_pts < links[child]->current_pts)

  1026.             child++;

  1027.         if (link->current_pts < links[child]->current_pts)

  1028.             break;

  1029.         links[index] = links[child];

  1030.         links[index]->age_index = index;

  1031.         index = child;

  1032.     }

  1033.     links[index] = link;

  1034.     link->age_index = index;

  1035. }

  1036. 

  1037. void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)

  1038. {

  1039.     heap_bubble_up  (graph, link, link->age_index);

  1040.     heap_bubble_down(graph, link, link->age_index);

  1041. }

  1042. 

  1043. 

  1044. int avfilter_graph_request_oldest(AVFilterGraph *graph)

  1045. {

  1046.     while (graph->sink_links_count) {

  1047.         AVFilterLink *oldest = graph->sink_links[0];

  1048.         int r = ff_request_frame(oldest);

  1049.         if (r != AVERROR_EOF)

  1050.             return r;

  1051.         av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",

  1052.                oldest->dst ? oldest->dst->name : "unknown",

  1053.                oldest->dstpad ? oldest->dstpad->name : "unknown");

  1054.         /* EOF: remove the link from the heap */

  1055.         if (oldest->age_index < --graph->sink_links_count)

  1056.             heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],

  1057.                              oldest->age_index);

  1058.         oldest->age_index = -1;

  1059.     }

  1060.     return AVERROR_EOF;

  1061. }