git.sesse.net Git - ffmpeg/blob - libavfilter/avfiltergraph.c

   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 <string.h>
  24
  25 #include "libavutil/avassert.h"
  26 #include "libavutil/avstring.h"
  27 #include "libavutil/bprint.h"
  28 #include "libavutil/channel_layout.h"
  29 #include "libavutil/opt.h"
  30 #include "libavutil/pixdesc.h"
  31 #include "libavcodec/avcodec.h" // avcodec_find_best_pix_fmt_of_2()
  32 #include "avfilter.h"
  33 #include "formats.h"
  34 #include "internal.h"
  35
  36 #define OFFSET(x) offsetof(AVFilterGraph,x)
  37
  38 static const AVOption options[]={
  39 {"scale_sws_opts"       , "default scale filter options"        , OFFSET(scale_sws_opts)        ,  AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, 0 },
  40 {"aresample_swr_opts"   , "default aresample filter options"    , OFFSET(aresample_swr_opts)    ,  AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, 0 },
  41 {0}
  42 };
  43
  44
  45 static const AVClass filtergraph_class = {
  46     .class_name = "AVFilterGraph",
  47     .item_name  = av_default_item_name,
  48     .option     = options,
  49     .version    = LIBAVUTIL_VERSION_INT,
  50     .category   = AV_CLASS_CATEGORY_FILTER,
  51 };
  52
  53 AVFilterGraph *avfilter_graph_alloc(void)
  54 {
  55     AVFilterGraph *ret = av_mallocz(sizeof(*ret));
  56     if (!ret)
  57         return NULL;
  58     ret->av_class = &filtergraph_class;
  59     return ret;
  60 }
  61
  62 void ff_filter_graph_remove_filter(AVFilterGraph *graph, AVFilterContext *filter)
  63 {
  64     int i;
  65     for (i = 0; i < graph->nb_filters; i++) {
  66         if (graph->filters[i] == filter) {
  67             FFSWAP(AVFilterContext*, graph->filters[i],
  68                    graph->filters[graph->nb_filters - 1]);
  69             graph->nb_filters--;
  70             return;
  71         }
  72     }
  73 }
  74
  75 void avfilter_graph_free(AVFilterGraph **graph)
  76 {
  77     if (!*graph)
  78         return;
  79
  80     while ((*graph)->nb_filters)
  81         avfilter_free((*graph)->filters[0]);
  82
  83     av_freep(&(*graph)->sink_links);
  84     av_freep(&(*graph)->scale_sws_opts);
  85     av_freep(&(*graph)->aresample_swr_opts);
  86     av_freep(&(*graph)->resample_lavr_opts);
  87     av_freep(&(*graph)->filters);
  88     av_freep(graph);
  89 }
  90
  91 #if FF_API_AVFILTER_OPEN
  92 int avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter)
  93 {
  94     AVFilterContext **filters = av_realloc(graph->filters,
  95                                            sizeof(*filters) * (graph->nb_filters + 1));
  96     if (!filters)
  97         return AVERROR(ENOMEM);
  98
  99     graph->filters = filters;
 100     graph->filters[graph->nb_filters++] = filter;
 101
 102 #if FF_API_FOO_COUNT
 103     graph->filter_count_unused = graph->nb_filters;
 104 #endif
 105
 106     filter->graph = graph;
 107
 108     return 0;
 109 }
 110 #endif
 111
 112 int avfilter_graph_create_filter(AVFilterContext **filt_ctx, AVFilter *filt,
 113                                  const char *name, const char *args, void *opaque,
 114                                  AVFilterGraph *graph_ctx)
 115 {
 116     int ret;
 117
 118     *filt_ctx = avfilter_graph_alloc_filter(graph_ctx, filt, name);
 119     if (!*filt_ctx)
 120         return AVERROR(ENOMEM);
 121
 122     ret = avfilter_init_str(*filt_ctx, args);
 123     if (ret < 0)
 124         goto fail;
 125
 126     return 0;
 127
 128 fail:
 129     if (*filt_ctx)
 130         avfilter_free(*filt_ctx);
 131     *filt_ctx = NULL;
 132     return ret;
 133 }
 134
 135 void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
 136 {
 137     graph->disable_auto_convert = flags;
 138 }
 139
 140 AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
 141                                              const AVFilter *filter,
 142                                              const char *name)
 143 {
 144     AVFilterContext **filters, *s;
 145
 146     s = ff_filter_alloc(filter, name);
 147     if (!s)
 148         return NULL;
 149
 150     filters = av_realloc(graph->filters, sizeof(*filters) * (graph->nb_filters + 1));
 151     if (!filters) {
 152         avfilter_free(s);
 153         return NULL;
 154     }
 155
 156     graph->filters = filters;
 157     graph->filters[graph->nb_filters++] = s;
 158
 159 #if FF_API_FOO_COUNT
 160     graph->filter_count_unused = graph->nb_filters;
 161 #endif
 162
 163     s->graph = graph;
 164
 165     return s;
 166 }
 167
 168 /**
 169  * Check for the validity of graph.
 170  *
 171  * A graph is considered valid if all its input and output pads are
 172  * connected.
 173  *
 174  * @return 0 in case of success, a negative value otherwise
 175  */
 176 static int graph_check_validity(AVFilterGraph *graph, AVClass *log_ctx)
 177 {
 178     AVFilterContext *filt;
 179     int i, j;
 180
 181     for (i = 0; i < graph->nb_filters; i++) {
 182         const AVFilterPad *pad;
 183         filt = graph->filters[i];
 184
 185         for (j = 0; j < filt->nb_inputs; j++) {
 186             if (!filt->inputs[j] || !filt->inputs[j]->src) {
 187                 pad = &filt->input_pads[j];
 188                 av_log(log_ctx, AV_LOG_ERROR,
 189                        "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
 190                        pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
 191                 return AVERROR(EINVAL);
 192             }
 193         }
 194
 195         for (j = 0; j < filt->nb_outputs; j++) {
 196             if (!filt->outputs[j] || !filt->outputs[j]->dst) {
 197                 pad = &filt->output_pads[j];
 198                 av_log(log_ctx, AV_LOG_ERROR,
 199                        "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
 200                        pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
 201                 return AVERROR(EINVAL);
 202             }
 203         }
 204     }
 205
 206     return 0;
 207 }
 208
 209 /**
 210  * Configure all the links of graphctx.
 211  *
 212  * @return 0 in case of success, a negative value otherwise
 213  */
 214 static int graph_config_links(AVFilterGraph *graph, AVClass *log_ctx)
 215 {
 216     AVFilterContext *filt;
 217     int i, ret;
 218
 219     for (i = 0; i < graph->nb_filters; i++) {
 220         filt = graph->filters[i];
 221
 222         if (!filt->nb_outputs) {
 223             if ((ret = avfilter_config_links(filt)))
 224                 return ret;
 225         }
 226     }
 227
 228     return 0;
 229 }
 230
 231 AVFilterContext *avfilter_graph_get_filter(AVFilterGraph *graph, char *name)
 232 {
 233     int i;
 234
 235     for (i = 0; i < graph->nb_filters; i++)
 236         if (graph->filters[i]->name && !strcmp(name, graph->filters[i]->name))
 237             return graph->filters[i];
 238
 239     return NULL;
 240 }
 241
 242 static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l)
 243 {
 244     if (!l)
 245         return;
 246     if (l->nb_channel_layouts) {
 247         if (l->all_layouts || l->all_counts)
 248             av_log(log, AV_LOG_WARNING, "All layouts set on non-empty list\n");
 249         l->all_layouts = l->all_counts = 0;
 250     } else {
 251         if (l->all_counts && !l->all_layouts)
 252             av_log(log, AV_LOG_WARNING, "All counts without all layouts\n");
 253         l->all_layouts = 1;
 254     }
 255 }
 256
 257 static int filter_query_formats(AVFilterContext *ctx)
 258 {
 259     int ret, i;
 260     AVFilterFormats *formats;
 261     AVFilterChannelLayouts *chlayouts;
 262     AVFilterFormats *samplerates;
 263     enum AVMediaType type = ctx->inputs  && ctx->inputs [0] ? ctx->inputs [0]->type :
 264                             ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
 265                             AVMEDIA_TYPE_VIDEO;
 266
 267     if ((ret = ctx->filter->query_formats(ctx)) < 0) {
 268         if (ret != AVERROR(EAGAIN))
 269             av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
 270                    ctx->name, av_err2str(ret));
 271         return ret;
 272     }
 273
 274     for (i = 0; i < ctx->nb_inputs; i++)
 275         sanitize_channel_layouts(ctx, ctx->inputs[i]->out_channel_layouts);
 276     for (i = 0; i < ctx->nb_outputs; i++)
 277         sanitize_channel_layouts(ctx, ctx->outputs[i]->in_channel_layouts);
 278
 279     formats = ff_all_formats(type);
 280     if (!formats)
 281         return AVERROR(ENOMEM);
 282     ff_set_common_formats(ctx, formats);
 283     if (type == AVMEDIA_TYPE_AUDIO) {
 284         samplerates = ff_all_samplerates();
 285         if (!samplerates)
 286             return AVERROR(ENOMEM);
 287         ff_set_common_samplerates(ctx, samplerates);
 288         chlayouts = ff_all_channel_layouts();
 289         if (!chlayouts)
 290             return AVERROR(ENOMEM);
 291         ff_set_common_channel_layouts(ctx, chlayouts);
 292     }
 293     return 0;
 294 }
 295
 296 static int formats_declared(AVFilterContext *f)
 297 {
 298     int i;
 299
 300     for (i = 0; i < f->nb_inputs; i++) {
 301         if (!f->inputs[i]->out_formats)
 302             return 0;
 303         if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
 304             !(f->inputs[i]->out_samplerates &&
 305               f->inputs[i]->out_channel_layouts))
 306             return 0;
 307     }
 308     for (i = 0; i < f->nb_outputs; i++) {
 309         if (!f->outputs[i]->in_formats)
 310             return 0;
 311         if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
 312             !(f->outputs[i]->in_samplerates &&
 313               f->outputs[i]->in_channel_layouts))
 314             return 0;
 315     }
 316     return 1;
 317 }
 318
 319 static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
 320 {
 321     int i, j, ret;
 322     int scaler_count = 0, resampler_count = 0;
 323     int count_queried = 0, count_merged = 0, count_already_merged = 0,
 324         count_delayed = 0;
 325
 326     for (i = 0; i < graph->nb_filters; i++) {
 327         AVFilterContext *f = graph->filters[i];
 328         if (formats_declared(f))
 329             continue;
 330         if (f->filter->query_formats)
 331             ret = filter_query_formats(f);
 332         else
 333             ret = ff_default_query_formats(f);
 334         if (ret < 0 && ret != AVERROR(EAGAIN))
 335             return ret;
 336         count_queried++;
 337     }
 338
 339     /* go through and merge as many format lists as possible */
 340     for (i = 0; i < graph->nb_filters; i++) {
 341         AVFilterContext *filter = graph->filters[i];
 342
 343         for (j = 0; j < filter->nb_inputs; j++) {
 344             AVFilterLink *link = filter->inputs[j];
 345             int convert_needed = 0;
 346
 347             if (!link)
 348                 continue;
 349
 350 #define MERGE_DISPATCH(field, statement)                                     \
 351             if (!(link->in_ ## field && link->out_ ## field)) {              \
 352                 count_delayed++;                                             \
 353             } else if (link->in_ ## field == link->out_ ## field) {          \
 354                 count_already_merged++;                                      \
 355             } else {                                                         \
 356                 count_merged++;                                              \
 357                 statement                                                    \
 358             }
 359             MERGE_DISPATCH(formats,
 360                 if (!ff_merge_formats(link->in_formats, link->out_formats,
 361                                       link->type))
 362                     convert_needed = 1;
 363             )
 364             if (link->type == AVMEDIA_TYPE_AUDIO) {
 365                 MERGE_DISPATCH(channel_layouts,
 366                     if (!ff_merge_channel_layouts(link->in_channel_layouts,
 367                                                   link->out_channel_layouts))
 368                         convert_needed = 1;
 369                 )
 370                 MERGE_DISPATCH(samplerates,
 371                     if (!ff_merge_samplerates(link->in_samplerates,
 372                                               link->out_samplerates))
 373                         convert_needed = 1;
 374                 )
 375             }
 376 #undef MERGE_DISPATCH
 377
 378             if (convert_needed) {
 379                 AVFilterContext *convert;
 380                 AVFilter *filter;
 381                 AVFilterLink *inlink, *outlink;
 382                 char scale_args[256];
 383                 char inst_name[30];
 384
 385                 /* couldn't merge format lists. auto-insert conversion filter */
 386                 switch (link->type) {
 387                 case AVMEDIA_TYPE_VIDEO:
 388                     if (!(filter = avfilter_get_by_name("scale"))) {
 389                         av_log(log_ctx, AV_LOG_ERROR, "'scale' filter "
 390                                "not present, cannot convert pixel formats.\n");
 391                         return AVERROR(EINVAL);
 392                     }
 393
 394                     snprintf(inst_name, sizeof(inst_name), "auto-inserted scaler %d",
 395                              scaler_count++);
 396                     av_strlcpy(scale_args, "0:0", sizeof(scale_args));
 397                     if (graph->scale_sws_opts) {
 398                         av_strlcat(scale_args, ":", sizeof(scale_args));
 399                         av_strlcat(scale_args, graph->scale_sws_opts, sizeof(scale_args));
 400                     }
 401                     if ((ret = avfilter_graph_create_filter(&convert, filter,
 402                                                             inst_name, scale_args, NULL,
 403                                                             graph)) < 0)
 404                         return ret;
 405                     break;
 406                 case AVMEDIA_TYPE_AUDIO:
 407                     if (!(filter = avfilter_get_by_name("aresample"))) {
 408                         av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter "
 409                                "not present, cannot convert audio formats.\n");
 410                         return AVERROR(EINVAL);
 411                     }
 412
 413                     snprintf(inst_name, sizeof(inst_name), "auto-inserted resampler %d",
 414                              resampler_count++);
 415                     scale_args[0] = '\0';
 416                     if (graph->aresample_swr_opts)
 417                         snprintf(scale_args, sizeof(scale_args), "%s",
 418                                  graph->aresample_swr_opts);
 419                     if ((ret = avfilter_graph_create_filter(&convert, filter,
 420                                                             inst_name, graph->aresample_swr_opts,
 421                                                             NULL, graph)) < 0)
 422                         return ret;
 423                     break;
 424                 default:
 425                     return AVERROR(EINVAL);
 426                 }
 427
 428                 if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
 429                     return ret;
 430
 431                 filter_query_formats(convert);
 432                 inlink  = convert->inputs[0];
 433                 outlink = convert->outputs[0];
 434                 if (!ff_merge_formats( inlink->in_formats,  inlink->out_formats,  inlink->type) ||
 435                     !ff_merge_formats(outlink->in_formats, outlink->out_formats, outlink->type))
 436                     ret |= AVERROR(ENOSYS);
 437                 if (inlink->type == AVMEDIA_TYPE_AUDIO &&
 438                     (!ff_merge_samplerates(inlink->in_samplerates,
 439                                            inlink->out_samplerates) ||
 440                      !ff_merge_channel_layouts(inlink->in_channel_layouts,
 441                                                inlink->out_channel_layouts)))
 442                     ret |= AVERROR(ENOSYS);
 443                 if (outlink->type == AVMEDIA_TYPE_AUDIO &&
 444                     (!ff_merge_samplerates(outlink->in_samplerates,
 445                                            outlink->out_samplerates) ||
 446                      !ff_merge_channel_layouts(outlink->in_channel_layouts,
 447                                                outlink->out_channel_layouts)))
 448                     ret |= AVERROR(ENOSYS);
 449
 450                 if (ret < 0) {
 451                     av_log(log_ctx, AV_LOG_ERROR,
 452                            "Impossible to convert between the formats supported by the filter "
 453                            "'%s' and the filter '%s'\n", link->src->name, link->dst->name);
 454                     return ret;
 455                 }
 456             }
 457         }
 458     }
 459
 460     av_log(graph, AV_LOG_DEBUG, "query_formats: "
 461            "%d queried, %d merged, %d already done, %d delayed\n",
 462            count_queried, count_merged, count_already_merged, count_delayed);
 463     if (count_delayed) {
 464         AVBPrint bp;
 465
 466         if (count_queried || count_merged)
 467             return AVERROR(EAGAIN);
 468         av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
 469         for (i = 0; i < graph->nb_filters; i++)
 470             if (!formats_declared(graph->filters[i]))
 471                 av_bprintf(&bp, "%s%s", bp.len ? ", " : "",
 472                           graph->filters[i]->name);
 473         av_log(graph, AV_LOG_ERROR,
 474                "The following filters could not choose their formats: %s\n"
 475                "Consider inserting the (a)format filter near their input or "
 476                "output.\n", bp.str);
 477         return AVERROR(EIO);
 478     }
 479     return 0;
 480 }
 481
 482 static int pick_format(AVFilterLink *link, AVFilterLink *ref)
 483 {
 484     if (!link || !link->in_formats)
 485         return 0;
 486
 487     if (link->type == AVMEDIA_TYPE_VIDEO) {
 488         if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
 489             int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
 490             enum AVPixelFormat best= AV_PIX_FMT_NONE;
 491             int i;
 492             for (i=0; i<link->in_formats->format_count; i++) {
 493                 enum AVPixelFormat p = link->in_formats->formats[i];
 494                 best= avcodec_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
 495             }
 496             av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
 497                    av_get_pix_fmt_name(best), link->in_formats->format_count,
 498                    av_get_pix_fmt_name(ref->format), has_alpha);
 499             link->in_formats->formats[0] = best;
 500         }
 501     }
 502
 503     link->in_formats->format_count = 1;
 504     link->format = link->in_formats->formats[0];
 505
 506     if (link->type == AVMEDIA_TYPE_AUDIO) {
 507         if (!link->in_samplerates->format_count) {
 508             av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
 509                    " the link between filters %s and %s.\n", link->src->name,
 510                    link->dst->name);
 511             return AVERROR(EINVAL);
 512         }
 513         link->in_samplerates->format_count = 1;
 514         link->sample_rate = link->in_samplerates->formats[0];
 515
 516         if (link->in_channel_layouts->all_layouts) {
 517             av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
 518                    " the link between filters %s and %s.\n", link->src->name,
 519                    link->dst->name);
 520             return AVERROR(EINVAL);
 521         }
 522         link->in_channel_layouts->nb_channel_layouts = 1;
 523         link->channel_layout = link->in_channel_layouts->channel_layouts[0];
 524         if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
 525             link->channel_layout = 0;
 526         else
 527             link->channels = av_get_channel_layout_nb_channels(link->channel_layout);
 528     }
 529
 530     ff_formats_unref(&link->in_formats);
 531     ff_formats_unref(&link->out_formats);
 532     ff_formats_unref(&link->in_samplerates);
 533     ff_formats_unref(&link->out_samplerates);
 534     ff_channel_layouts_unref(&link->in_channel_layouts);
 535     ff_channel_layouts_unref(&link->out_channel_layouts);
 536
 537     return 0;
 538 }
 539
 540 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
 541 do {                                                                   \
 542     for (i = 0; i < filter->nb_inputs; i++) {                          \
 543         AVFilterLink *link = filter->inputs[i];                        \
 544         fmt_type fmt;                                                  \
 545                                                                        \
 546         if (!link->out_ ## list || link->out_ ## list->nb != 1)        \
 547             continue;                                                  \
 548         fmt = link->out_ ## list->var[0];                              \
 549                                                                        \
 550         for (j = 0; j < filter->nb_outputs; j++) {                     \
 551             AVFilterLink *out_link = filter->outputs[j];               \
 552             list_type *fmts;                                           \
 553                                                                        \
 554             if (link->type != out_link->type ||                        \
 555                 out_link->in_ ## list->nb == 1)                        \
 556                 continue;                                              \
 557             fmts = out_link->in_ ## list;                              \
 558                                                                        \
 559             if (!out_link->in_ ## list->nb) {                          \
 560                 add_format(&out_link->in_ ##list, fmt);                \
 561                 break;                                                 \
 562             }                                                          \
 563                                                                        \
 564             for (k = 0; k < out_link->in_ ## list->nb; k++)            \
 565                 if (fmts->var[k] == fmt) {                             \
 566                     fmts->var[0]  = fmt;                               \
 567                     fmts->nb = 1;                                      \
 568                     ret = 1;                                           \
 569                     break;                                             \
 570                 }                                                      \
 571         }                                                              \
 572     }                                                                  \
 573 } while (0)
 574
 575 static int reduce_formats_on_filter(AVFilterContext *filter)
 576 {
 577     int i, j, k, ret = 0;
 578
 579     REDUCE_FORMATS(int,      AVFilterFormats,        formats,         formats,
 580                    format_count, ff_add_format);
 581     REDUCE_FORMATS(int,      AVFilterFormats,        samplerates,     formats,
 582                    format_count, ff_add_format);
 583
 584     /* reduce channel layouts */
 585     for (i = 0; i < filter->nb_inputs; i++) {
 586         AVFilterLink *inlink = filter->inputs[i];
 587         uint64_t fmt;
 588
 589         if (!inlink->out_channel_layouts ||
 590             inlink->out_channel_layouts->nb_channel_layouts != 1)
 591             continue;
 592         fmt = inlink->out_channel_layouts->channel_layouts[0];
 593
 594         for (j = 0; j < filter->nb_outputs; j++) {
 595             AVFilterLink *outlink = filter->outputs[j];
 596             AVFilterChannelLayouts *fmts;
 597
 598             fmts = outlink->in_channel_layouts;
 599             if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
 600                 continue;
 601
 602             if (fmts->all_layouts) {
 603                 /* Turn the infinite list into a singleton */
 604                 fmts->all_layouts = fmts->all_counts  = 0;
 605                 ff_add_channel_layout(&outlink->in_channel_layouts, fmt);
 606                 break;
 607             }
 608
 609             for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) {
 610                 if (fmts->channel_layouts[k] == fmt) {
 611                     fmts->channel_layouts[0]  = fmt;
 612                     fmts->nb_channel_layouts = 1;
 613                     ret = 1;
 614                     break;
 615                 }
 616             }
 617         }
 618     }
 619
 620     return ret;
 621 }
 622
 623 static void reduce_formats(AVFilterGraph *graph)
 624 {
 625     int i, reduced;
 626
 627     do {
 628         reduced = 0;
 629
 630         for (i = 0; i < graph->nb_filters; i++)
 631             reduced |= reduce_formats_on_filter(graph->filters[i]);
 632     } while (reduced);
 633 }
 634
 635 static void swap_samplerates_on_filter(AVFilterContext *filter)
 636 {
 637     AVFilterLink *link = NULL;
 638     int sample_rate;
 639     int i, j;
 640
 641     for (i = 0; i < filter->nb_inputs; i++) {
 642         link = filter->inputs[i];
 643
 644         if (link->type == AVMEDIA_TYPE_AUDIO &&
 645             link->out_samplerates->format_count == 1)
 646             break;
 647     }
 648     if (i == filter->nb_inputs)
 649         return;
 650
 651     sample_rate = link->out_samplerates->formats[0];
 652
 653     for (i = 0; i < filter->nb_outputs; i++) {
 654         AVFilterLink *outlink = filter->outputs[i];
 655         int best_idx, best_diff = INT_MAX;
 656
 657         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
 658             outlink->in_samplerates->format_count < 2)
 659             continue;
 660
 661         for (j = 0; j < outlink->in_samplerates->format_count; j++) {
 662             int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
 663
 664             if (diff < best_diff) {
 665                 best_diff = diff;
 666                 best_idx  = j;
 667             }
 668         }
 669         FFSWAP(int, outlink->in_samplerates->formats[0],
 670                outlink->in_samplerates->formats[best_idx]);
 671     }
 672 }
 673
 674 static void swap_samplerates(AVFilterGraph *graph)
 675 {
 676     int i;
 677
 678     for (i = 0; i < graph->nb_filters; i++)
 679         swap_samplerates_on_filter(graph->filters[i]);
 680 }
 681
 682 #define CH_CENTER_PAIR (AV_CH_FRONT_LEFT_OF_CENTER | AV_CH_FRONT_RIGHT_OF_CENTER)
 683 #define CH_FRONT_PAIR  (AV_CH_FRONT_LEFT           | AV_CH_FRONT_RIGHT)
 684 #define CH_STEREO_PAIR (AV_CH_STEREO_LEFT          | AV_CH_STEREO_RIGHT)
 685 #define CH_WIDE_PAIR   (AV_CH_WIDE_LEFT            | AV_CH_WIDE_RIGHT)
 686 #define CH_SIDE_PAIR   (AV_CH_SIDE_LEFT            | AV_CH_SIDE_RIGHT)
 687 #define CH_DIRECT_PAIR (AV_CH_SURROUND_DIRECT_LEFT | AV_CH_SURROUND_DIRECT_RIGHT)
 688 #define CH_BACK_PAIR   (AV_CH_BACK_LEFT            | AV_CH_BACK_RIGHT)
 689
 690 /* allowable substitutions for channel pairs when comparing layouts,
 691  * ordered by priority for both values */
 692 static const uint64_t ch_subst[][2] = {
 693     { CH_FRONT_PAIR,      CH_CENTER_PAIR     },
 694     { CH_FRONT_PAIR,      CH_WIDE_PAIR       },
 695     { CH_FRONT_PAIR,      AV_CH_FRONT_CENTER },
 696     { CH_CENTER_PAIR,     CH_FRONT_PAIR      },
 697     { CH_CENTER_PAIR,     CH_WIDE_PAIR       },
 698     { CH_CENTER_PAIR,     AV_CH_FRONT_CENTER },
 699     { CH_WIDE_PAIR,       CH_FRONT_PAIR      },
 700     { CH_WIDE_PAIR,       CH_CENTER_PAIR     },
 701     { CH_WIDE_PAIR,       AV_CH_FRONT_CENTER },
 702     { AV_CH_FRONT_CENTER, CH_FRONT_PAIR      },
 703     { AV_CH_FRONT_CENTER, CH_CENTER_PAIR     },
 704     { AV_CH_FRONT_CENTER, CH_WIDE_PAIR       },
 705     { CH_SIDE_PAIR,       CH_DIRECT_PAIR     },
 706     { CH_SIDE_PAIR,       CH_BACK_PAIR       },
 707     { CH_SIDE_PAIR,       AV_CH_BACK_CENTER  },
 708     { CH_BACK_PAIR,       CH_DIRECT_PAIR     },
 709     { CH_BACK_PAIR,       CH_SIDE_PAIR       },
 710     { CH_BACK_PAIR,       AV_CH_BACK_CENTER  },
 711     { AV_CH_BACK_CENTER,  CH_BACK_PAIR       },
 712     { AV_CH_BACK_CENTER,  CH_DIRECT_PAIR     },
 713     { AV_CH_BACK_CENTER,  CH_SIDE_PAIR       },
 714 };
 715
 716 static void swap_channel_layouts_on_filter(AVFilterContext *filter)
 717 {
 718     AVFilterLink *link = NULL;
 719     int i, j, k;
 720
 721     for (i = 0; i < filter->nb_inputs; i++) {
 722         link = filter->inputs[i];
 723
 724         if (link->type == AVMEDIA_TYPE_AUDIO &&
 725             link->out_channel_layouts->nb_channel_layouts == 1)
 726             break;
 727     }
 728     if (i == filter->nb_inputs)
 729         return;
 730
 731     for (i = 0; i < filter->nb_outputs; i++) {
 732         AVFilterLink *outlink = filter->outputs[i];
 733         int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
 734
 735         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
 736             outlink->in_channel_layouts->nb_channel_layouts < 2)
 737             continue;
 738
 739         for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) {
 740             uint64_t  in_chlayout = link->out_channel_layouts->channel_layouts[0];
 741             uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j];
 742             int  in_channels      = av_get_channel_layout_nb_channels(in_chlayout);
 743             int out_channels      = av_get_channel_layout_nb_channels(out_chlayout);
 744             int count_diff        = out_channels - in_channels;
 745             int matched_channels, extra_channels;
 746             int score = 100000;
 747
 748             if (FF_LAYOUT2COUNT(in_chlayout) || FF_LAYOUT2COUNT(out_chlayout)) {
 749                 /* Compute score in case the input or output layout encodes
 750                    a channel count; in this case the score is not altered by
 751                    the computation afterwards, as in_chlayout and
 752                    out_chlayout have both been set to 0 */
 753                 if (FF_LAYOUT2COUNT(in_chlayout))
 754                     in_channels = FF_LAYOUT2COUNT(in_chlayout);
 755                 if (FF_LAYOUT2COUNT(out_chlayout))
 756                     out_channels = FF_LAYOUT2COUNT(out_chlayout);
 757                 score -= 10000 + FFABS(out_channels - in_channels) +
 758                          (in_channels > out_channels ? 10000 : 0);
 759                 in_chlayout = out_chlayout = 0;
 760                 /* Let the remaining computation run, even if the score
 761                    value is not altered */
 762             }
 763
 764             /* channel substitution */
 765             for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
 766                 uint64_t cmp0 = ch_subst[k][0];
 767                 uint64_t cmp1 = ch_subst[k][1];
 768                 if (( in_chlayout & cmp0) && (!(out_chlayout & cmp0)) &&
 769                     (out_chlayout & cmp1) && (!( in_chlayout & cmp1))) {
 770                     in_chlayout  &= ~cmp0;
 771                     out_chlayout &= ~cmp1;
 772                     /* add score for channel match, minus a deduction for
 773                        having to do the substitution */
 774                     score += 10 * av_get_channel_layout_nb_channels(cmp1) - 2;
 775                 }
 776             }
 777
 778             /* no penalty for LFE channel mismatch */
 779             if ( (in_chlayout & AV_CH_LOW_FREQUENCY) &&
 780                 (out_chlayout & AV_CH_LOW_FREQUENCY))
 781                 score += 10;
 782             in_chlayout  &= ~AV_CH_LOW_FREQUENCY;
 783             out_chlayout &= ~AV_CH_LOW_FREQUENCY;
 784
 785             matched_channels = av_get_channel_layout_nb_channels(in_chlayout &
 786                                                                  out_chlayout);
 787             extra_channels   = av_get_channel_layout_nb_channels(out_chlayout &
 788                                                                  (~in_chlayout));
 789             score += 10 * matched_channels - 5 * extra_channels;
 790
 791             if (score > best_score ||
 792                 (count_diff < best_count_diff && score == best_score)) {
 793                 best_score = score;
 794                 best_idx   = j;
 795                 best_count_diff = count_diff;
 796             }
 797         }
 798         av_assert0(best_idx >= 0);
 799         FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0],
 800                outlink->in_channel_layouts->channel_layouts[best_idx]);
 801     }
 802
 803 }
 804
 805 static void swap_channel_layouts(AVFilterGraph *graph)
 806 {
 807     int i;
 808
 809     for (i = 0; i < graph->nb_filters; i++)
 810         swap_channel_layouts_on_filter(graph->filters[i]);
 811 }
 812
 813 static void swap_sample_fmts_on_filter(AVFilterContext *filter)
 814 {
 815     AVFilterLink *link = NULL;
 816     int format, bps;
 817     int i, j;
 818
 819     for (i = 0; i < filter->nb_inputs; i++) {
 820         link = filter->inputs[i];
 821
 822         if (link->type == AVMEDIA_TYPE_AUDIO &&
 823             link->out_formats->format_count == 1)
 824             break;
 825     }
 826     if (i == filter->nb_inputs)
 827         return;
 828
 829     format = link->out_formats->formats[0];
 830     bps    = av_get_bytes_per_sample(format);
 831
 832     for (i = 0; i < filter->nb_outputs; i++) {
 833         AVFilterLink *outlink = filter->outputs[i];
 834         int best_idx = -1, best_score = INT_MIN;
 835
 836         if (outlink->type != AVMEDIA_TYPE_AUDIO ||
 837             outlink->in_formats->format_count < 2)
 838             continue;
 839
 840         for (j = 0; j < outlink->in_formats->format_count; j++) {
 841             int out_format = outlink->in_formats->formats[j];
 842             int out_bps    = av_get_bytes_per_sample(out_format);
 843             int score;
 844
 845             if (av_get_packed_sample_fmt(out_format) == format ||
 846                 av_get_planar_sample_fmt(out_format) == format) {
 847                 best_idx   = j;
 848                 break;
 849             }
 850
 851             /* for s32 and float prefer double to prevent loss of information */
 852             if (bps == 4 && out_bps == 8) {
 853                 best_idx = j;
 854                 break;
 855             }
 856
 857             /* prefer closest higher or equal bps */
 858             score = -abs(out_bps - bps);
 859             if (out_bps >= bps)
 860                 score += INT_MAX/2;
 861
 862             if (score > best_score) {
 863                 best_score = score;
 864                 best_idx   = j;
 865             }
 866         }
 867         av_assert0(best_idx >= 0);
 868         FFSWAP(int, outlink->in_formats->formats[0],
 869                outlink->in_formats->formats[best_idx]);
 870     }
 871 }
 872
 873 static void swap_sample_fmts(AVFilterGraph *graph)
 874 {
 875     int i;
 876
 877     for (i = 0; i < graph->nb_filters; i++)
 878         swap_sample_fmts_on_filter(graph->filters[i]);
 879
 880 }
 881
 882 static int pick_formats(AVFilterGraph *graph)
 883 {
 884     int i, j, ret;
 885     int change;
 886
 887     do{
 888         change = 0;
 889         for (i = 0; i < graph->nb_filters; i++) {
 890             AVFilterContext *filter = graph->filters[i];
 891             if (filter->nb_inputs){
 892                 for (j = 0; j < filter->nb_inputs; j++){
 893                     if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->format_count == 1) {
 894                         if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
 895                             return ret;
 896                         change = 1;
 897                     }
 898                 }
 899             }
 900             if (filter->nb_outputs){
 901                 for (j = 0; j < filter->nb_outputs; j++){
 902                     if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->format_count == 1) {
 903                         if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
 904                             return ret;
 905                         change = 1;
 906                     }
 907                 }
 908             }
 909             if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
 910                 for (j = 0; j < filter->nb_outputs; j++) {
 911                     if(filter->outputs[j]->format<0) {
 912                         if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
 913                             return ret;
 914                         change = 1;
 915                     }
 916                 }
 917             }
 918         }
 919     }while(change);
 920
 921     for (i = 0; i < graph->nb_filters; i++) {
 922         AVFilterContext *filter = graph->filters[i];
 923
 924         for (j = 0; j < filter->nb_inputs; j++)
 925             if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
 926                 return ret;
 927         for (j = 0; j < filter->nb_outputs; j++)
 928             if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
 929                 return ret;
 930     }
 931     return 0;
 932 }
 933
 934 /**
 935  * Configure the formats of all the links in the graph.
 936  */
 937 static int graph_config_formats(AVFilterGraph *graph, AVClass *log_ctx)
 938 {
 939     int ret;
 940
 941     /* find supported formats from sub-filters, and merge along links */
 942     while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
 943         av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
 944     if (ret < 0)
 945         return ret;
 946
 947     /* Once everything is merged, it's possible that we'll still have
 948      * multiple valid media format choices. We try to minimize the amount
 949      * of format conversion inside filters */
 950     reduce_formats(graph);
 951
 952     /* for audio filters, ensure the best format, sample rate and channel layout
 953      * is selected */
 954     swap_sample_fmts(graph);
 955     swap_samplerates(graph);
 956     swap_channel_layouts(graph);
 957
 958     if ((ret = pick_formats(graph)) < 0)
 959         return ret;
 960
 961     return 0;
 962 }
 963
 964 static int ff_avfilter_graph_config_pointers(AVFilterGraph *graph,
 965                                              AVClass *log_ctx)
 966 {
 967     unsigned i, j;
 968     int sink_links_count = 0, n = 0;
 969     AVFilterContext *f;
 970     AVFilterLink **sinks;
 971
 972     for (i = 0; i < graph->nb_filters; i++) {
 973         f = graph->filters[i];
 974         for (j = 0; j < f->nb_inputs; j++) {
 975             f->inputs[j]->graph     = graph;
 976             f->inputs[j]->age_index = -1;
 977         }
 978         for (j = 0; j < f->nb_outputs; j++) {
 979             f->outputs[j]->graph    = graph;
 980             f->outputs[j]->age_index= -1;
 981         }
 982         if (!f->nb_outputs) {
 983             if (f->nb_inputs > INT_MAX - sink_links_count)
 984                 return AVERROR(EINVAL);
 985             sink_links_count += f->nb_inputs;
 986         }
 987     }
 988     sinks = av_calloc(sink_links_count, sizeof(*sinks));
 989     if (!sinks)
 990         return AVERROR(ENOMEM);
 991     for (i = 0; i < graph->nb_filters; i++) {
 992         f = graph->filters[i];
 993         if (!f->nb_outputs) {
 994             for (j = 0; j < f->nb_inputs; j++) {
 995                 sinks[n] = f->inputs[j];
 996                 f->inputs[j]->age_index = n++;
 997             }
 998         }
 999     }
1000     av_assert0(n == sink_links_count);
1001     graph->sink_links       = sinks;
1002     graph->sink_links_count = sink_links_count;
1003     return 0;
1004 }
1005
1006 static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)
1007 {
1008     AVFilterContext *f;
1009     int i, j, ret;
1010     int fifo_count = 0;
1011
1012     for (i = 0; i < graph->nb_filters; i++) {
1013         f = graph->filters[i];
1014
1015         for (j = 0; j < f->nb_inputs; j++) {
1016             AVFilterLink *link = f->inputs[j];
1017             AVFilterContext *fifo_ctx;
1018             AVFilter *fifo;
1019             char name[32];
1020
1021             if (!link->dstpad->needs_fifo)
1022                 continue;
1023
1024             fifo = f->inputs[j]->type == AVMEDIA_TYPE_VIDEO ?
1025                    avfilter_get_by_name("fifo") :
1026                    avfilter_get_by_name("afifo");
1027
1028             snprintf(name, sizeof(name), "auto-inserted fifo %d", fifo_count++);
1029
1030             ret = avfilter_graph_create_filter(&fifo_ctx, fifo, name, NULL,
1031                                                NULL, graph);
1032             if (ret < 0)
1033                 return ret;
1034
1035             ret = avfilter_insert_filter(link, fifo_ctx, 0, 0);
1036             if (ret < 0)
1037                 return ret;
1038         }
1039     }
1040
1041     return 0;
1042 }
1043
1044 int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
1045 {
1046     int ret;
1047
1048     if ((ret = graph_check_validity(graphctx, log_ctx)))
1049         return ret;
1050     if ((ret = graph_insert_fifos(graphctx, log_ctx)) < 0)
1051         return ret;
1052     if ((ret = graph_config_formats(graphctx, log_ctx)))
1053         return ret;
1054     if ((ret = graph_config_links(graphctx, log_ctx)))
1055         return ret;
1056     if ((ret = ff_avfilter_graph_config_pointers(graphctx, log_ctx)))
1057         return ret;
1058
1059     return 0;
1060 }
1061
1062 int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
1063 {
1064     int i, r = AVERROR(ENOSYS);
1065
1066     if(!graph)
1067         return r;
1068
1069     if((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {
1070         r=avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
1071         if(r != AVERROR(ENOSYS))
1072             return r;
1073     }
1074
1075     if(res_len && res)
1076         res[0]= 0;
1077
1078     for (i = 0; i < graph->nb_filters; i++) {
1079         AVFilterContext *filter = graph->filters[i];
1080         if(!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)){
1081             r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
1082             if(r != AVERROR(ENOSYS)) {
1083                 if((flags & AVFILTER_CMD_FLAG_ONE) || r<0)
1084                     return r;
1085             }
1086         }
1087     }
1088
1089     return r;
1090 }
1091
1092 int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
1093 {
1094     int i;
1095
1096     if(!graph)
1097         return 0;
1098
1099     for (i = 0; i < graph->nb_filters; i++) {
1100         AVFilterContext *filter = graph->filters[i];
1101         if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
1102             AVFilterCommand **queue = &filter->command_queue, *next;
1103             while (*queue && (*queue)->time <= ts)
1104                 queue = &(*queue)->next;
1105             next = *queue;
1106             *queue = av_mallocz(sizeof(AVFilterCommand));
1107             (*queue)->command = av_strdup(command);
1108             (*queue)->arg     = av_strdup(arg);
1109             (*queue)->time    = ts;
1110             (*queue)->flags   = flags;
1111             (*queue)->next    = next;
1112             if(flags & AVFILTER_CMD_FLAG_ONE)
1113                 return 0;
1114         }
1115     }
1116
1117     return 0;
1118 }
1119
1120 static void heap_bubble_up(AVFilterGraph *graph,
1121                            AVFilterLink *link, int index)
1122 {
1123     AVFilterLink **links = graph->sink_links;
1124
1125     while (index) {
1126         int parent = (index - 1) >> 1;
1127         if (links[parent]->current_pts >= link->current_pts)
1128             break;
1129         links[index] = links[parent];
1130         links[index]->age_index = index;
1131         index = parent;
1132     }
1133     links[index] = link;
1134     link->age_index = index;
1135 }
1136
1137 static void heap_bubble_down(AVFilterGraph *graph,
1138                              AVFilterLink *link, int index)
1139 {
1140     AVFilterLink **links = graph->sink_links;
1141
1142     while (1) {
1143         int child = 2 * index + 1;
1144         if (child >= graph->sink_links_count)
1145             break;
1146         if (child + 1 < graph->sink_links_count &&
1147             links[child + 1]->current_pts < links[child]->current_pts)
1148             child++;
1149         if (link->current_pts < links[child]->current_pts)
1150             break;
1151         links[index] = links[child];
1152         links[index]->age_index = index;
1153         index = child;
1154     }
1155     links[index] = link;
1156     link->age_index = index;
1157 }
1158
1159 void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
1160 {
1161     heap_bubble_up  (graph, link, link->age_index);
1162     heap_bubble_down(graph, link, link->age_index);
1163 }
1164
1165
1166 int avfilter_graph_request_oldest(AVFilterGraph *graph)
1167 {
1168     while (graph->sink_links_count) {
1169         AVFilterLink *oldest = graph->sink_links[0];
1170         int r = ff_request_frame(oldest);
1171         if (r != AVERROR_EOF)
1172             return r;
1173         av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
1174                oldest->dst ? oldest->dst->name : "unknown",
1175                oldest->dstpad ? oldest->dstpad->name : "unknown");
1176         /* EOF: remove the link from the heap */
1177         if (oldest->age_index < --graph->sink_links_count)
1178             heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],
1179                              oldest->age_index);
1180         oldest->age_index = -1;
1181     }
1182     return AVERROR_EOF;
1183 }