static int query_formats(AVFilterContext *ctx) { ChannelSplitContext *s = ctx->priv; AVFilterChannelLayouts *in_layouts = NULL; int i, ret; if ((ret = ff_set_common_formats(ctx, ff_planar_sample_fmts())) < 0 || (ret = ff_set_common_samplerates(ctx, ff_all_samplerates())) < 0) return ret; if ((ret = ff_add_channel_layout(&in_layouts, s->channel_layout)) < 0 || (ret = ff_channel_layouts_ref(in_layouts, &ctx->inputs[0]->out_channel_layouts)) < 0) return ret; for (i = 0; i < ctx->nb_outputs; i++) { AVFilterChannelLayouts *out_layouts = NULL; uint64_t channel = av_channel_layout_extract_channel(s->channel_layout, i); if ((ret = ff_add_channel_layout(&out_layouts, channel)) < 0 || (ret = ff_channel_layouts_ref(out_layouts, &ctx->outputs[i]->in_channel_layouts)) < 0) return ret; } return 0; }
static int query_formats(AVFilterContext *ctx) { LADSPAContext *s = ctx->priv; AVFilterFormats *formats; AVFilterChannelLayouts *layouts; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE }; formats = ff_make_format_list(sample_fmts); if (!formats) return AVERROR(ENOMEM); ff_set_common_formats(ctx, formats); if (s->nb_inputs) { formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); ff_set_common_samplerates(ctx, formats); } else { int sample_rates[] = { s->sample_rate, -1 }; ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates)); } if (s->nb_inputs == 1 && s->nb_outputs == 1) { // We will instantiate multiple LADSPA_Handle, one over each channel layouts = ff_all_channel_layouts(); if (!layouts) return AVERROR(ENOMEM); ff_set_common_channel_layouts(ctx, layouts); } else { AVFilterLink *outlink = ctx->outputs[0]; if (s->nb_inputs >= 1) { AVFilterLink *inlink = ctx->inputs[0]; int64_t inlayout = FF_COUNT2LAYOUT(s->nb_inputs); layouts = NULL; ff_add_channel_layout(&layouts, inlayout); ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts); if (!s->nb_outputs) ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); } if (s->nb_outputs >= 1) { int64_t outlayout = FF_COUNT2LAYOUT(s->nb_outputs); layouts = NULL; ff_add_channel_layout(&layouts, outlayout); ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); } } return 0; }
static int query_formats(AVFilterContext *ctx) { BufferSourceContext *c = ctx->priv; AVFilterChannelLayouts *channel_layouts = NULL; AVFilterFormats *formats = NULL; AVFilterFormats *samplerates = NULL; switch (ctx->outputs[0]->type) { case AVMEDIA_TYPE_VIDEO: ff_add_format(&formats, c->pix_fmt); ff_set_common_formats(ctx, formats); break; case AVMEDIA_TYPE_AUDIO: ff_add_format(&formats, c->sample_fmt); ff_set_common_formats(ctx, formats); ff_add_format(&samplerates, c->sample_rate); ff_set_common_samplerates(ctx, samplerates); ff_add_channel_layout(&channel_layouts, c->channel_layout); ff_set_common_channel_layouts(ctx, channel_layouts); break; default: return AVERROR(EINVAL); } return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layouts = NULL; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE, }; if (ff_add_channel_layout(&layouts, AV_CH_LAYOUT_STEREO) != 0) return AVERROR(ENOMEM); ff_set_common_channel_layouts(ctx, layouts); formats = ff_make_format_list(sample_fmts); if (!formats) return AVERROR(ENOMEM); ff_set_common_formats(ctx, formats); formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); ff_set_common_samplerates(ctx, formats); return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layout = NULL; AVFilterLink *inlink = ctx->inputs[0]; AVFilterLink *outlink = ctx->outputs[0]; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_NONE }; static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGBA, AV_PIX_FMT_NONE }; formats = ff_make_format_list(sample_fmts); if (!formats) return AVERROR(ENOMEM); ff_formats_ref(formats, &inlink->out_formats); ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO); ff_channel_layouts_ref(layout, &inlink->out_channel_layouts); formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); ff_formats_ref(formats, &inlink->out_samplerates); formats = ff_make_format_list(pix_fmts); if (!formats) return AVERROR(ENOMEM); ff_formats_ref(formats, &outlink->in_formats); return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats = NULL; AConvertContext *aconvert = ctx->priv; AVFilterLink *inlink = ctx->inputs[0]; AVFilterLink *outlink = ctx->outputs[0]; AVFilterChannelLayouts *layouts; ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_AUDIO), &inlink->out_formats); if (aconvert->out_sample_fmt != AV_SAMPLE_FMT_NONE) { formats = NULL; ff_add_format(&formats, aconvert->out_sample_fmt); ff_formats_ref(formats, &outlink->in_formats); } else ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_AUDIO), &outlink->in_formats); ff_channel_layouts_ref(ff_all_channel_layouts(), &inlink->out_channel_layouts); if (aconvert->out_chlayout != 0) { layouts = NULL; ff_add_channel_layout(&layouts, aconvert->out_chlayout); ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); } else ff_channel_layouts_ref(ff_all_channel_layouts(), &outlink->in_channel_layouts); return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats; AVFilterChannelLayouts *layouts = NULL; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE }; int ret, i; if (!ctx->inputs[0]->in_channel_layouts || !ctx->inputs[0]->in_channel_layouts->nb_channel_layouts) { av_log(ctx, AV_LOG_WARNING, "No channel layout for input 1\n"); return AVERROR(EAGAIN); } if ((ret = ff_add_channel_layout(&layouts, ctx->inputs[0]->in_channel_layouts->channel_layouts[0])) < 0 || (ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) return ret; for (i = 0; i < 2; i++) { layouts = ff_all_channel_counts(); if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0) return ret; } formats = ff_make_format_list(sample_fmts); if ((ret = ff_set_common_formats(ctx, formats)) < 0) return ret; formats = ff_all_samplerates(); return ff_set_common_samplerates(ctx, formats); }
static int query_formats(AVFilterContext *ctx) { AudioFIRContext *s = ctx->priv; AVFilterFormats *formats; AVFilterChannelLayouts *layouts; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE }; static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_RGB0, AV_PIX_FMT_NONE }; int ret; if (s->response) { AVFilterLink *videolink = ctx->outputs[1]; formats = ff_make_format_list(pix_fmts); if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0) return ret; } layouts = ff_all_channel_counts(); if (!layouts) return AVERROR(ENOMEM); if (s->ir_format) { ret = ff_set_common_channel_layouts(ctx, layouts); if (ret < 0) return ret; } else { AVFilterChannelLayouts *mono = NULL; ret = ff_add_channel_layout(&mono, AV_CH_LAYOUT_MONO); if (ret) return ret; if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts)) < 0) return ret; if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) return ret; if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[1]->out_channel_layouts)) < 0) return ret; } formats = ff_make_format_list(sample_fmts); if ((ret = ff_set_common_formats(ctx, formats)) < 0) return ret; formats = ff_all_samplerates(); return ff_set_common_samplerates(ctx, formats); }
static int query_formats(AVFilterContext *ctx) { AudioSurroundContext *s = ctx->priv; AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layouts = NULL; int ret; ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLTP); if (ret) return ret; ret = ff_set_common_formats(ctx, formats); if (ret) return ret; layouts = NULL; ret = ff_add_channel_layout(&layouts, s->out_channel_layout); if (ret) return ret; ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts); if (ret) return ret; layouts = NULL; ret = ff_add_channel_layout(&layouts, s->in_channel_layout); if (ret) return ret; ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts); if (ret) return ret; formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); return ff_set_common_samplerates(ctx, formats); }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layout = NULL; int ret; if ((ret = ff_add_format (&formats, AV_SAMPLE_FMT_FLT )) < 0 || (ret = ff_set_common_formats (ctx , formats )) < 0 || (ret = ff_add_channel_layout (&layout , AV_CH_LAYOUT_STEREO)) < 0 || (ret = ff_set_common_channel_layouts (ctx , layout )) < 0) return ret; formats = ff_all_samplerates(); return ff_set_common_samplerates(ctx, formats); }
static int query_formats(AVFilterContext *ctx) { static const int sample_rates[] = { 44100, -1 }; AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layout = NULL; ff_add_format(&formats, AV_SAMPLE_FMT_S16); ff_set_common_formats(ctx, formats); ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO); ff_set_common_channel_layouts(ctx, layout); ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates)); return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layout = NULL; ff_add_format(&formats, AV_SAMPLE_FMT_FLT); ff_set_common_formats(ctx, formats); ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO); ff_set_common_channel_layouts(ctx, layout); formats = ff_all_samplerates(); if (!formats) return AVERROR(ENOMEM); return ff_set_common_samplerates(ctx, formats); }
static int reduce_formats_on_filter(AVFilterContext *filter) { int i, j, k, ret = 0; REDUCE_FORMATS(int, AVFilterFormats, formats, formats, format_count, ff_add_format); REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats, format_count, ff_add_format); /* reduce channel layouts */ for (i = 0; i < filter->nb_inputs; i++) { AVFilterLink *inlink = filter->inputs[i]; uint64_t fmt; if (!inlink->out_channel_layouts || inlink->out_channel_layouts->nb_channel_layouts != 1) continue; fmt = inlink->out_channel_layouts->channel_layouts[0]; for (j = 0; j < filter->nb_outputs; j++) { AVFilterLink *outlink = filter->outputs[j]; AVFilterChannelLayouts *fmts; fmts = outlink->in_channel_layouts; if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1) continue; if (fmts->all_layouts) { /* Turn the infinite list into a singleton */ fmts->all_layouts = fmts->all_counts = 0; ff_add_channel_layout(&outlink->in_channel_layouts, fmt); break; } for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) { if (fmts->channel_layouts[k] == fmt) { fmts->channel_layouts[0] = fmt; fmts->nb_channel_layouts = 1; ret = 1; break; } } } } return ret; }
static int query_formats(AVFilterContext *ctx) { ASRContext *s = ctx->priv; int sample_rates[] = { s->rate, -1 }; int ret; AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layout = NULL; if ((ret = ff_add_format (&formats, AV_SAMPLE_FMT_S16 )) < 0 || (ret = ff_set_common_formats (ctx , formats )) < 0 || (ret = ff_add_channel_layout (&layout , AV_CH_LAYOUT_MONO )) < 0 || (ret = ff_set_common_channel_layouts (ctx , layout )) < 0 || (ret = ff_set_common_samplerates (ctx , ff_make_format_list(sample_rates) )) < 0) return ret; return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layout = NULL; int i; ff_add_format(&formats, AV_SAMPLE_FMT_FLT); ff_set_common_formats(ctx, formats); ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO); ff_set_common_channel_layouts(ctx, layout); formats = NULL; for (i = 0; i < FF_ARRAY_ELEMS(freqinfos); i++) ff_add_format(&formats, freqinfos[i].sample_rate); ff_set_common_samplerates(ctx, formats); return 0; }
static int query_formats(AVFilterContext *ctx) { SpectrumSynthContext *s = ctx->priv; AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layout = NULL; AVFilterLink *magnitude = ctx->inputs[0]; AVFilterLink *phase = ctx->inputs[1]; AVFilterLink *outlink = ctx->outputs[0]; static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE }; static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_NONE }; int ret, sample_rates[] = { 48000, -1 }; formats = ff_make_format_list(sample_fmts); if ((ret = ff_formats_ref (formats, &outlink->in_formats )) < 0 || (ret = ff_add_channel_layout (&layout, FF_COUNT2LAYOUT(s->channels))) < 0 || (ret = ff_channel_layouts_ref (layout , &outlink->in_channel_layouts)) < 0) return ret; sample_rates[0] = s->sample_rate; formats = ff_make_format_list(sample_rates); if (!formats) return AVERROR(ENOMEM); if ((ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0) return ret; formats = ff_make_format_list(pix_fmts); if (!formats) return AVERROR(ENOMEM); if ((ret = ff_formats_ref(formats, &magnitude->out_formats)) < 0) return ret; formats = ff_make_format_list(pix_fmts); if (!formats) return AVERROR(ENOMEM); if ((ret = ff_formats_ref(formats, &phase->out_formats)) < 0) return ret; return 0; }
static int query_formats(AVFilterContext *ctx) { SoxContext *sox = ctx->priv; AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layouts = NULL; ff_add_format(&formats, AV_SAMPLE_FMT_S32); ff_set_common_formats(ctx, formats); if (sox->effect->handler.flags & SOX_EFF_CHAN) { layouts = NULL; ff_add_channel_layout(&layouts, av_get_default_channel_layout(sox->effect->out_signal.channels)); ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts); ff_channel_layouts_ref(ff_all_channel_layouts(), &ctx->inputs[0]->out_channel_layouts); } else { ff_set_common_channel_layouts(ctx, ff_all_channel_layouts()); } return 0; }
static int query_formats(AVFilterContext *ctx) { AVFilterFormats *formats = NULL; AVFilterChannelLayouts *layouts = NULL; int ret; ret = ff_add_channel_layout(&layouts, AV_CH_LAYOUT_STEREO); if (ret < 0) return ret; ret = ff_set_common_channel_layouts(ctx, layouts); if (ret < 0) return ret; #if 0 ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLT); if (ret < 0) return ret; #endif ret = ff_add_format(&formats, AV_SAMPLE_FMT_FLTP); if (ret < 0) return ret; ret = ff_set_common_formats(ctx, formats); if (ret < 0) return ret; return ff_set_common_samplerates(ctx, ff_all_samplerates()); }
static int query_formats(AVFilterGraph *graph, AVClass *log_ctx) { int i, j, ret; #if 0 char filt_args[128]; AVFilterFormats *formats; AVFilterChannelLayouts *chlayouts; AVFilterFormats *samplerates; #endif int scaler_count = 0, resampler_count = 0; for (j = 0; j < 2; j++) { /* ask all the sub-filters for their supported media formats */ for (i = 0; i < graph->filter_count; i++) { /* Call query_formats on sources first. This is a temporary workaround for amerge, until format renegociation is implemented. */ if (!graph->filters[i]->nb_inputs == j) continue; if (graph->filters[i]->filter->query_formats) ret = filter_query_formats(graph->filters[i]); else ret = ff_default_query_formats(graph->filters[i]); if (ret < 0) return ret; } } /* go through and merge as many format lists as possible */ for (i = 0; i < graph->filter_count; i++) { AVFilterContext *filter = graph->filters[i]; for (j = 0; j < filter->nb_inputs; j++) { AVFilterLink *link = filter->inputs[j]; #if 0 if (!link) continue; if (!link->in_formats || !link->out_formats) return AVERROR(EINVAL); if (link->type == AVMEDIA_TYPE_VIDEO && !ff_merge_formats(link->in_formats, link->out_formats)) { /* couldn't merge format lists, auto-insert scale filter */ snprintf(filt_args, sizeof(filt_args), "0:0:%s", graph->scale_sws_opts); if (ret = insert_conv_filter(graph, link, "scale", filt_args)) return ret; } else if (link->type == AVMEDIA_TYPE_AUDIO) { if (!link->in_channel_layouts || !link->out_channel_layouts) return AVERROR(EINVAL); /* Merge all three list before checking: that way, in all * three categories, aconvert will use a common format * whenever possible. */ formats = ff_merge_formats(link->in_formats, link->out_formats); chlayouts = ff_merge_channel_layouts(link->in_channel_layouts , link->out_channel_layouts); samplerates = ff_merge_samplerates (link->in_samplerates, link->out_samplerates); if (!formats || !chlayouts || !samplerates) if (ret = insert_conv_filter(graph, link, "aresample", NULL)) return ret; #else int convert_needed = 0; if (!link) continue; if (link->in_formats != link->out_formats && !ff_merge_formats(link->in_formats, link->out_formats)) convert_needed = 1; if (link->type == AVMEDIA_TYPE_AUDIO) { if (link->in_channel_layouts != link->out_channel_layouts && !ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts)) convert_needed = 1; if (link->in_samplerates != link->out_samplerates && !ff_merge_samplerates(link->in_samplerates, link->out_samplerates)) convert_needed = 1; } if (convert_needed) { AVFilterContext *convert; AVFilter *filter; AVFilterLink *inlink, *outlink; char scale_args[256]; char inst_name[30]; /* couldn't merge format lists. auto-insert conversion filter */ switch (link->type) { case AVMEDIA_TYPE_VIDEO: if (!(filter = avfilter_get_by_name("scale"))) { av_log(log_ctx, AV_LOG_ERROR, "'scale' filter " "not present, cannot convert pixel formats.\n"); return AVERROR(EINVAL); } snprintf(inst_name, sizeof(inst_name), "auto-inserted scaler %d", scaler_count++); if (graph->scale_sws_opts) snprintf(scale_args, sizeof(scale_args), "0:0:%s", graph->scale_sws_opts); else snprintf(scale_args, sizeof(scale_args), "0:0"); if ((ret = avfilter_graph_create_filter(&convert, filter, inst_name, scale_args, NULL, graph)) < 0) return ret; break; case AVMEDIA_TYPE_AUDIO: if (!(filter = avfilter_get_by_name("aresample"))) { av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter " "not present, cannot convert audio formats.\n"); return AVERROR(EINVAL); } snprintf(inst_name, sizeof(inst_name), "auto-inserted resampler %d", resampler_count++); if ((ret = avfilter_graph_create_filter(&convert, filter, inst_name, graph->aresample_swr_opts, NULL, graph)) < 0) return ret; break; default: return AVERROR(EINVAL); } if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0) return ret; filter_query_formats(convert); inlink = convert->inputs[0]; outlink = convert->outputs[0]; if (!ff_merge_formats( inlink->in_formats, inlink->out_formats) || !ff_merge_formats(outlink->in_formats, outlink->out_formats)) ret |= AVERROR(ENOSYS); if (inlink->type == AVMEDIA_TYPE_AUDIO && (!ff_merge_samplerates(inlink->in_samplerates, inlink->out_samplerates) || !ff_merge_channel_layouts(inlink->in_channel_layouts, inlink->out_channel_layouts))) ret |= AVERROR(ENOSYS); if (outlink->type == AVMEDIA_TYPE_AUDIO && (!ff_merge_samplerates(outlink->in_samplerates, outlink->out_samplerates) || !ff_merge_channel_layouts(outlink->in_channel_layouts, outlink->out_channel_layouts))) ret |= AVERROR(ENOSYS); if (ret < 0) { av_log(log_ctx, AV_LOG_ERROR, "Impossible to convert between the formats supported by the filter " "'%s' and the filter '%s'\n", link->src->name, link->dst->name); return ret; } #endif } } } return 0; } static int pick_format(AVFilterLink *link, AVFilterLink *ref) { if (!link || !link->in_formats) return 0; if (link->type == AVMEDIA_TYPE_VIDEO) { if(ref && ref->type == AVMEDIA_TYPE_VIDEO){ int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0; enum AVPixelFormat best= AV_PIX_FMT_NONE; int i; for (i=0; i<link->in_formats->format_count; i++) { enum AVPixelFormat p = link->in_formats->formats[i]; best= avcodec_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL); } av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n", av_get_pix_fmt_name(best), link->in_formats->format_count, av_get_pix_fmt_name(ref->format), has_alpha); link->in_formats->formats[0] = best; } } link->in_formats->format_count = 1; link->format = link->in_formats->formats[0]; if (link->type == AVMEDIA_TYPE_AUDIO) { if (!link->in_samplerates->format_count) { av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for" " the link between filters %s and %s.\n", link->src->name, link->dst->name); return AVERROR(EINVAL); } link->in_samplerates->format_count = 1; link->sample_rate = link->in_samplerates->formats[0]; if (link->in_channel_layouts->all_layouts) { av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for" "the link between filters %s and %s.\n", link->src->name, link->dst->name); return AVERROR(EINVAL); } link->in_channel_layouts->nb_channel_layouts = 1; link->channel_layout = link->in_channel_layouts->channel_layouts[0]; if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout))) link->channel_layout = 0; else link->channels = av_get_channel_layout_nb_channels(link->channel_layout); } ff_formats_unref(&link->in_formats); ff_formats_unref(&link->out_formats); ff_formats_unref(&link->in_samplerates); ff_formats_unref(&link->out_samplerates); ff_channel_layouts_unref(&link->in_channel_layouts); ff_channel_layouts_unref(&link->out_channel_layouts); return 0; } #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \ do { \ for (i = 0; i < filter->nb_inputs; i++) { \ AVFilterLink *link = filter->inputs[i]; \ fmt_type fmt; \ \ if (!link->out_ ## list || link->out_ ## list->nb != 1) \ continue; \ fmt = link->out_ ## list->var[0]; \ \ for (j = 0; j < filter->nb_outputs; j++) { \ AVFilterLink *out_link = filter->outputs[j]; \ list_type *fmts; \ \ if (link->type != out_link->type || \ out_link->in_ ## list->nb == 1) \ continue; \ fmts = out_link->in_ ## list; \ \ if (!out_link->in_ ## list->nb) { \ add_format(&out_link->in_ ##list, fmt); \ break; \ } \ \ for (k = 0; k < out_link->in_ ## list->nb; k++) \ if (fmts->var[k] == fmt) { \ fmts->var[0] = fmt; \ fmts->nb = 1; \ ret = 1; \ break; \ } \ } \ } \ } while (0) static int reduce_formats_on_filter(AVFilterContext *filter) { int i, j, k, ret = 0; REDUCE_FORMATS(int, AVFilterFormats, formats, formats, format_count, ff_add_format); REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats, format_count, ff_add_format); /* reduce channel layouts */ for (i = 0; i < filter->nb_inputs; i++) { AVFilterLink *inlink = filter->inputs[i]; uint64_t fmt; if (!inlink->out_channel_layouts || inlink->out_channel_layouts->nb_channel_layouts != 1) continue; fmt = inlink->out_channel_layouts->channel_layouts[0]; for (j = 0; j < filter->nb_outputs; j++) { AVFilterLink *outlink = filter->outputs[j]; AVFilterChannelLayouts *fmts; fmts = outlink->in_channel_layouts; if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1) continue; if (fmts->all_layouts) { /* Turn the infinite list into a singleton */ fmts->all_layouts = fmts->all_counts = 0; ff_add_channel_layout(&outlink->in_channel_layouts, fmt); break; } for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) { if (fmts->channel_layouts[k] == fmt) { fmts->channel_layouts[0] = fmt; fmts->nb_channel_layouts = 1; ret = 1; break; } } } } return ret; }