MrBesen
/
ffmpeg
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

lavfi: regroup formats lists in a single structure. 

It will allow to refernce it as a whole without clunky macros.

Most of the changes have been automatically made with sed:

sed -i '
  s/-> *in_formats/->incfg.formats/g;
  s/-> *out_formats/->outcfg.formats/g;
  s/-> *in_channel_layouts/->incfg.channel_layouts/g;
  s/-> *out_channel_layouts/->outcfg.channel_layouts/g;
  s/-> *in_samplerates/->incfg.samplerates/g;
  s/-> *out_samplerates/->outcfg.samplerates/g;
  ' src/libavfilter/*(.)
This commit is contained in:
Nicolas George 2020-08-24 12:16:34 +02:00
parent 6a2df7ca26
commit 2f76476549
70 changed files with 388 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libavfilter/aeval.c
View File

@ -362,7 +362,7 @@ static int aeval_query_formats(AVFilterContext *ctx)
// inlink supports any channel layout // inlink supports any channel layout
layouts = ff_all_channel_counts(); layouts = ff_all_channel_counts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
if (eval->same_chlayout) { if (eval->same_chlayout) {
@ -376,7 +376,7 @@ static int aeval_query_formats(AVFilterContext *ctx)
eval->out_channel_layout ? eval->out_channel_layout : eval->out_channel_layout ? eval->out_channel_layout :
FF_COUNT2LAYOUT(eval->nb_channels))) < 0) FF_COUNT2LAYOUT(eval->nb_channels))) < 0)
return ret; return ret;
if ((ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0)
return ret; return ret;
} }

8
libavfilter/af_afir.c
View File

@ -731,7 +731,7 @@ static int query_formats(AVFilterContext *ctx)
if (s->response) { if (s->response) {
AVFilterLink *videolink = ctx->outputs[1]; AVFilterLink *videolink = ctx->outputs[1];
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &videolink->incfg.formats)) < 0)
return ret; return ret;
} }
@ -746,16 +746,16 @@ static int query_formats(AVFilterContext *ctx)
} else { } else {
AVFilterChannelLayouts *mono = NULL; AVFilterChannelLayouts *mono = NULL;
if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->outcfg.channel_layouts)) < 0)
return ret; return ret;
if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
return ret; return ret;
ret = ff_add_channel_layout(&mono, AV_CH_LAYOUT_MONO); ret = ff_add_channel_layout(&mono, AV_CH_LAYOUT_MONO);
if (ret) if (ret)
return ret; return ret;
for (int i = 1; i < ctx->nb_inputs; i++) { for (int i = 1; i < ctx->nb_inputs; i++) {
if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[i]->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(mono, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
return ret; return ret;
} }
} }

10
libavfilter/af_agate.c
View File

@ -353,20 +353,20 @@ static int scquery_formats(AVFilterContext *ctx)
}; };
int ret, i; int ret, i;
if (!ctx->inputs[0]->in_channel_layouts || if (!ctx->inputs[0]->incfg.channel_layouts ||
!ctx->inputs[0]->in_channel_layouts->nb_channel_layouts) { !ctx->inputs[0]->incfg.channel_layouts->nb_channel_layouts) {
av_log(ctx, AV_LOG_WARNING, av_log(ctx, AV_LOG_WARNING,
"No channel layout for input 1\n"); "No channel layout for input 1\n");
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
} }
if ((ret = ff_add_channel_layout(&layouts, ctx->inputs[0]->in_channel_layouts->channel_layouts[0])) < 0 || if ((ret = ff_add_channel_layout(&layouts, ctx->inputs[0]->incfg.channel_layouts->channel_layouts[0])) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
return ret; return ret;
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
layouts = ff_all_channel_counts(); layouts = ff_all_channel_counts();
if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
return ret; return ret;
} }

2
libavfilter/af_aiir.c
View File

@ -95,7 +95,7 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *videolink = ctx->outputs[1]; AVFilterLink *videolink = ctx->outputs[1];
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &videolink->incfg.formats)) < 0)
return ret; return ret;
} }

12
libavfilter/af_amerge.c
View File

@ -81,14 +81,14 @@ static int query_formats(AVFilterContext *ctx)
int i, ret, overlap = 0, nb_ch = 0; int i, ret, overlap = 0, nb_ch = 0;
for (i = 0; i < s->nb_inputs; i++) { for (i = 0; i < s->nb_inputs; i++) {
if (!ctx->inputs[i]->in_channel_layouts || if (!ctx->inputs[i]->incfg.channel_layouts ||
!ctx->inputs[i]->in_channel_layouts->nb_channel_layouts) { !ctx->inputs[i]->incfg.channel_layouts->nb_channel_layouts) {
av_log(ctx, AV_LOG_WARNING, av_log(ctx, AV_LOG_WARNING,
"No channel layout for input %d\n", i + 1); "No channel layout for input %d\n", i + 1);
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
} }
inlayout[i] = ctx->inputs[i]->in_channel_layouts->channel_layouts[0]; inlayout[i] = ctx->inputs[i]->incfg.channel_layouts->channel_layouts[0];
if (ctx->inputs[i]->in_channel_layouts->nb_channel_layouts > 1) { if (ctx->inputs[i]->incfg.channel_layouts->nb_channel_layouts > 1) {
char buf[256]; char buf[256];
av_get_channel_layout_string(buf, sizeof(buf), 0, inlayout[i]); av_get_channel_layout_string(buf, sizeof(buf), 0, inlayout[i]);
av_log(ctx, AV_LOG_INFO, "Using \"%s\" for input %d\n", buf, i + 1); av_log(ctx, AV_LOG_INFO, "Using \"%s\" for input %d\n", buf, i + 1);
@ -136,13 +136,13 @@ static int query_formats(AVFilterContext *ctx)
layouts = NULL; layouts = NULL;
if ((ret = ff_add_channel_layout(&layouts, inlayout[i])) < 0) if ((ret = ff_add_channel_layout(&layouts, inlayout[i])) < 0)
return ret; return ret;
if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
return ret; return ret;
} }
layouts = NULL; layouts = NULL;
if ((ret = ff_add_channel_layout(&layouts, outlayout)) < 0) if ((ret = ff_add_channel_layout(&layouts, outlayout)) < 0)
return ret; return ret;
if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
return ret; return ret;
return ff_set_common_samplerates(ctx, ff_all_samplerates()); return ff_set_common_samplerates(ctx, ff_all_samplerates());

14
libavfilter/af_anequalizer.c
View File

@ -231,23 +231,23 @@ static int query_formats(AVFilterContext *ctx)
if (s->draw_curves) { if (s->draw_curves) {
AVFilterLink *videolink = ctx->outputs[1]; AVFilterLink *videolink = ctx->outputs[1];
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &videolink->incfg.formats)) < 0)
return ret; return ret;
} }
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0 || if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) (ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
layouts = ff_all_channel_counts(); layouts = ff_all_channel_counts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0 || if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 || if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0) (ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0)
return ret; return ret;
return 0; return 0;

12
libavfilter/af_aresample.c
View File

@ -95,15 +95,15 @@ static int query_formats(AVFilterContext *ctx)
av_opt_get_int(aresample->swr, "ocl", 0, &out_layout); av_opt_get_int(aresample->swr, "ocl", 0, &out_layout);
in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO); in_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
if ((ret = ff_formats_ref(in_formats, &inlink->out_formats)) < 0) if ((ret = ff_formats_ref(in_formats, &inlink->outcfg.formats)) < 0)
return ret; return ret;
in_samplerates = ff_all_samplerates(); in_samplerates = ff_all_samplerates();
if ((ret = ff_formats_ref(in_samplerates, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(in_samplerates, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
in_layouts = ff_all_channel_counts(); in_layouts = ff_all_channel_counts();
if ((ret = ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(in_layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
if(out_rate > 0) { if(out_rate > 0) {
@ -113,7 +113,7 @@ static int query_formats(AVFilterContext *ctx)
out_samplerates = ff_all_samplerates(); out_samplerates = ff_all_samplerates();
} }
if ((ret = ff_formats_ref(out_samplerates, &outlink->in_samplerates)) < 0) if ((ret = ff_formats_ref(out_samplerates, &outlink->incfg.samplerates)) < 0)
return ret; return ret;
if(out_format != AV_SAMPLE_FMT_NONE) { if(out_format != AV_SAMPLE_FMT_NONE) {
@ -121,7 +121,7 @@ static int query_formats(AVFilterContext *ctx)
out_formats = ff_make_format_list(formatlist); out_formats = ff_make_format_list(formatlist);
} else } else
out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO); out_formats = ff_all_formats(AVMEDIA_TYPE_AUDIO);
if ((ret = ff_formats_ref(out_formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(out_formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
if(out_layout) { if(out_layout) {
@ -130,7 +130,7 @@ static int query_formats(AVFilterContext *ctx)
} else } else
out_layouts = ff_all_channel_counts(); out_layouts = ff_all_channel_counts();
return ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts); return ff_channel_layouts_ref(out_layouts, &outlink->incfg.channel_layouts);
} }

2
libavfilter/af_asetrate.c
View File

@ -52,7 +52,7 @@ static av_cold int query_formats(AVFilterContext *ctx)
int sample_rates[] = { sr->sample_rate, -1 }; int sample_rates[] = { sr->sample_rate, -1 };
return ff_formats_ref(ff_make_format_list(sample_rates), return ff_formats_ref(ff_make_format_list(sample_rates),
&ctx->outputs[0]->in_samplerates); &ctx->outputs[0]->incfg.samplerates);
} }
static av_cold int config_props(AVFilterLink *outlink) static av_cold int config_props(AVFilterLink *outlink)

4
libavfilter/af_channelmap.c
View File

@ -287,11 +287,11 @@ static int channelmap_query_formats(AVFilterContext *ctx)
(ret = ff_set_common_samplerates (ctx , ff_all_samplerates() )) < 0 || (ret = ff_set_common_samplerates (ctx , ff_all_samplerates() )) < 0 ||
(ret = ff_add_channel_layout(&channel_layouts, s->output_layout)) < 0 || (ret = ff_add_channel_layout(&channel_layouts, s->output_layout)) < 0 ||
(ret = ff_channel_layouts_ref(channel_layouts, (ret = ff_channel_layouts_ref(channel_layouts,
&ctx->outputs[0]->in_channel_layouts)) < 0) &ctx->outputs[0]->incfg.channel_layouts)) < 0)
return ret; return ret;
return ff_channel_layouts_ref(ff_all_channel_counts(), return ff_channel_layouts_ref(ff_all_channel_counts(),
&ctx->inputs[0]->out_channel_layouts); &ctx->inputs[0]->outcfg.channel_layouts);
} }
static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf) static int channelmap_filter_frame(AVFilterLink *inlink, AVFrame *buf)

4
libavfilter/af_channelsplit.c
View File

@ -117,7 +117,7 @@ static int query_formats(AVFilterContext *ctx)
return ret; return ret;
if ((ret = ff_add_channel_layout(&in_layouts, s->channel_layout)) < 0 || 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) (ret = ff_channel_layouts_ref(in_layouts, &ctx->inputs[0]->outcfg.channel_layouts)) < 0)
return ret; return ret;
for (i = 0; i < ctx->nb_outputs; i++) { for (i = 0; i < ctx->nb_outputs; i++) {
@ -125,7 +125,7 @@ static int query_formats(AVFilterContext *ctx)
uint64_t channel = av_channel_layout_extract_channel(s->channel_layout, s->map[i]); uint64_t channel = av_channel_layout_extract_channel(s->channel_layout, s->map[i]);
if ((ret = ff_add_channel_layout(&out_layouts, channel)) < 0 || if ((ret = ff_add_channel_layout(&out_layouts, channel)) < 0 ||
(ret = ff_channel_layouts_ref(out_layouts, &ctx->outputs[i]->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref(out_layouts, &ctx->outputs[i]->incfg.channel_layouts)) < 0)
return ret; return ret;
} }

4
libavfilter/af_hdcd.c
View File

@ -1638,12 +1638,12 @@ static int query_formats(AVFilterContext *ctx)
return ret; return ret;
in_formats = ff_make_format_list(sample_fmts_in); in_formats = ff_make_format_list(sample_fmts_in);
ret = ff_formats_ref(in_formats, &inlink->out_formats); ret = ff_formats_ref(in_formats, &inlink->outcfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;
out_formats = ff_make_format_list(sample_fmts_out); out_formats = ff_make_format_list(sample_fmts_out);
ret = ff_formats_ref(out_formats, &outlink->in_formats); ret = ff_formats_ref(out_formats, &outlink->incfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;

8
libavfilter/af_headphone.c
View File

@ -698,14 +698,14 @@ static int query_formats(AVFilterContext *ctx)
if (!layouts) if (!layouts)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts); ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->outcfg.channel_layouts);
if (ret) if (ret)
return ret; return ret;
ret = ff_add_channel_layout(&stereo_layout, AV_CH_LAYOUT_STEREO); ret = ff_add_channel_layout(&stereo_layout, AV_CH_LAYOUT_STEREO);
if (ret) if (ret)
return ret; return ret;
ret = ff_channel_layouts_ref(stereo_layout, &ctx->outputs[0]->in_channel_layouts); ret = ff_channel_layouts_ref(stereo_layout, &ctx->outputs[0]->incfg.channel_layouts);
if (ret) if (ret)
return ret; return ret;
@ -713,12 +713,12 @@ static int query_formats(AVFilterContext *ctx)
hrir_layouts = ff_all_channel_counts(); hrir_layouts = ff_all_channel_counts();
if (!hrir_layouts) if (!hrir_layouts)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ret = ff_channel_layouts_ref(hrir_layouts, &ctx->inputs[1]->out_channel_layouts); ret = ff_channel_layouts_ref(hrir_layouts, &ctx->inputs[1]->outcfg.channel_layouts);
if (ret) if (ret)
return ret; return ret;
} else { } else {
for (i = 1; i < s->nb_inputs; i++) { for (i = 1; i < s->nb_inputs; i++) {
ret = ff_channel_layouts_ref(stereo_layout, &ctx->inputs[i]->out_channel_layouts); ret = ff_channel_layouts_ref(stereo_layout, &ctx->inputs[i]->outcfg.channel_layouts);
if (ret) if (ret)
return ret; return ret;
} }

4
libavfilter/af_join.c
View File

@ -227,12 +227,12 @@ static int join_query_formats(AVFilterContext *ctx)
int i, ret; int i, ret;
if ((ret = ff_add_channel_layout(&layouts, s->channel_layout)) < 0 || if ((ret = ff_add_channel_layout(&layouts, s->channel_layout)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
return ret; return ret;
for (i = 0; i < ctx->nb_inputs; i++) { for (i = 0; i < ctx->nb_inputs; i++) {
layouts = ff_all_channel_layouts(); layouts = ff_all_channel_layouts();
if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
return ret; return ret;
} }

6
libavfilter/af_ladspa.c
View File

@ -714,12 +714,12 @@ static int query_formats(AVFilterContext *ctx)
ret = ff_add_channel_layout(&layouts, inlayout); ret = ff_add_channel_layout(&layouts, inlayout);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts); ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (!s->nb_outputs) { if (!s->nb_outputs) {
ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
@ -732,7 +732,7 @@ static int query_formats(AVFilterContext *ctx)
ret = ff_add_channel_layout(&layouts, outlayout); ret = ff_add_channel_layout(&layouts, outlayout);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }

4
libavfilter/af_loudnorm.c
View File

@ -714,10 +714,10 @@ static int query_formats(AVFilterContext *ctx)
formats = ff_make_format_list(input_srate); formats = ff_make_format_list(input_srate);
if (!formats) if (!formats)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ret = ff_formats_ref(formats, &inlink->out_samplerates); ret = ff_formats_ref(formats, &inlink->outcfg.samplerates);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = ff_formats_ref(formats, &outlink->in_samplerates); ret = ff_formats_ref(formats, &outlink->incfg.samplerates);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }

6
libavfilter/af_lv2.c
View File

@ -524,12 +524,12 @@ static int query_formats(AVFilterContext *ctx)
ret = ff_add_channel_layout(&layouts, inlayout); ret = ff_add_channel_layout(&layouts, inlayout);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts); ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts);
if (ret < 0) if (ret < 0)
return ret; return ret;
if (!s->nb_outputs) { if (!s->nb_outputs) {
ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
@ -542,7 +542,7 @@ static int query_formats(AVFilterContext *ctx)
ret = ff_add_channel_layout(&layouts, outlayout); ret = ff_add_channel_layout(&layouts, outlayout);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }

4
libavfilter/af_pan.c
View File

@ -266,7 +266,7 @@ static int query_formats(AVFilterContext *ctx)
// inlink supports any channel layout // inlink supports any channel layout
layouts = ff_all_channel_counts(); layouts = ff_all_channel_counts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
// outlink supports only requested output channel layout // outlink supports only requested output channel layout
@ -275,7 +275,7 @@ static int query_formats(AVFilterContext *ctx)
pan->out_channel_layout ? pan->out_channel_layout : pan->out_channel_layout ? pan->out_channel_layout :
FF_COUNT2LAYOUT(pan->nb_output_channels))) < 0) FF_COUNT2LAYOUT(pan->nb_output_channels))) < 0)
return ret; return ret;
return ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts); return ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts);
} }
static int config_props(AVFilterLink *link) static int config_props(AVFilterLink *link)

12
libavfilter/af_resample.c
View File

@ -102,12 +102,12 @@ static int query_formats(AVFilterContext *ctx)
!(out_layouts = ff_all_channel_layouts ( ))) !(out_layouts = ff_all_channel_layouts ( )))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if ((ret = ff_formats_ref (in_formats, &inlink->out_formats )) < 0 || if ((ret = ff_formats_ref (in_formats, &inlink->outcfg.formats )) < 0 ||
(ret = ff_formats_ref (out_formats, &outlink->in_formats )) < 0 || (ret = ff_formats_ref (out_formats, &outlink->incfg.formats )) < 0 ||
(ret = ff_formats_ref (in_samplerates, &inlink->out_samplerates )) < 0 || (ret = ff_formats_ref (in_samplerates, &inlink->outcfg.samplerates )) < 0 ||
(ret = ff_formats_ref (out_samplerates, &outlink->in_samplerates )) < 0 || (ret = ff_formats_ref (out_samplerates, &outlink->incfg.samplerates )) < 0 ||
(ret = ff_channel_layouts_ref (in_layouts, &inlink->out_channel_layouts)) < 0 || (ret = ff_channel_layouts_ref (in_layouts, &inlink->outcfg.channel_layouts)) < 0 ||
(ret = ff_channel_layouts_ref (out_layouts, &outlink->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref (out_layouts, &outlink->incfg.channel_layouts)) < 0)
return ret; return ret;
return 0; return 0;

10
libavfilter/af_sidechaincompress.c
View File

@ -306,20 +306,20 @@ static int query_formats(AVFilterContext *ctx)
}; };
int ret, i; int ret, i;
if (!ctx->inputs[0]->in_channel_layouts || if (!ctx->inputs[0]->incfg.channel_layouts ||
!ctx->inputs[0]->in_channel_layouts->nb_channel_layouts) { !ctx->inputs[0]->incfg.channel_layouts->nb_channel_layouts) {
av_log(ctx, AV_LOG_WARNING, av_log(ctx, AV_LOG_WARNING,
"No channel layout for input 1\n"); "No channel layout for input 1\n");
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
} }
if ((ret = ff_add_channel_layout(&layouts, ctx->inputs[0]->in_channel_layouts->channel_layouts[0])) < 0 || if ((ret = ff_add_channel_layout(&layouts, ctx->inputs[0]->incfg.channel_layouts->channel_layouts[0])) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts)) < 0)
return ret; return ret;
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
layouts = ff_all_channel_counts(); layouts = ff_all_channel_counts();
if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &ctx->inputs[i]->outcfg.channel_layouts)) < 0)
return ret; return ret;
} }

4
libavfilter/af_sofalizer.c
View File

@ -652,7 +652,7 @@ static int query_formats(AVFilterContext *ctx)
if (!layouts) if (!layouts)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts); ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->outcfg.channel_layouts);
if (ret) if (ret)
return ret; return ret;
@ -661,7 +661,7 @@ static int query_formats(AVFilterContext *ctx)
if (ret) if (ret)
return ret; return ret;
ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts); ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts);
if (ret) if (ret)
return ret; return ret;

4
libavfilter/af_surround.c
View File

@ -175,7 +175,7 @@ static int query_formats(AVFilterContext *ctx)
if (ret) if (ret)
return ret; return ret;
ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts); ret = ff_channel_layouts_ref(layouts, &ctx->outputs[0]->incfg.channel_layouts);
if (ret) if (ret)
return ret; return ret;
@ -184,7 +184,7 @@ static int query_formats(AVFilterContext *ctx)
if (ret) if (ret)
return ret; return ret;
ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->out_channel_layouts); ret = ff_channel_layouts_ref(layouts, &ctx->inputs[0]->outcfg.channel_layouts);
if (ret) if (ret)
return ret; return ret;

8
libavfilter/avf_abitscope.c
View File

@ -69,21 +69,21 @@ static int query_formats(AVFilterContext *ctx)
int ret; int ret;
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0)
return ret; return ret;
layouts = ff_all_channel_counts(); layouts = ff_all_channel_counts();
if (!layouts) if (!layouts)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

8
libavfilter/avf_ahistogram.c
View File

@ -99,17 +99,17 @@ static int query_formats(AVFilterContext *ctx)
int ret = AVERROR(EINVAL); int ret = AVERROR(EINVAL);
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref (formats, &inlink->out_formats )) < 0 || if ((ret = ff_formats_ref (formats, &inlink->outcfg.formats )) < 0 ||
(layouts = ff_all_channel_counts()) == NULL || (layouts = ff_all_channel_counts()) == NULL ||
(ret = ff_channel_layouts_ref (layouts, &inlink->out_channel_layouts)) < 0) (ret = ff_channel_layouts_ref (layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

14
libavfilter/avf_aphasemeter.c
View File

@ -76,23 +76,23 @@ static int query_formats(AVFilterContext *ctx)
int ret; int ret;
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref (formats, &inlink->out_formats )) < 0 || if ((ret = ff_formats_ref (formats, &inlink->outcfg.formats )) < 0 ||
(ret = ff_formats_ref (formats, &outlink->in_formats )) < 0 || (ret = ff_formats_ref (formats, &outlink->incfg.formats )) < 0 ||
(ret = ff_add_channel_layout (&layout, AV_CH_LAYOUT_STEREO )) < 0 || (ret = ff_add_channel_layout (&layout, AV_CH_LAYOUT_STEREO )) < 0 ||
(ret = ff_channel_layouts_ref (layout , &inlink->out_channel_layouts)) < 0 || (ret = ff_channel_layouts_ref (layout , &inlink->outcfg.channel_layouts)) < 0 ||
(ret = ff_channel_layouts_ref (layout , &outlink->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref (layout , &outlink->incfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 || if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0) (ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0)
return ret; return ret;
if (s->do_video) { if (s->do_video) {
AVFilterLink *outlink = ctx->outputs[1]; AVFilterLink *outlink = ctx->outputs[1];
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
} }

8
libavfilter/avf_avectorscope.c
View File

@ -190,17 +190,17 @@ static int query_formats(AVFilterContext *ctx)
int ret; int ret;
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref (formats, &inlink->out_formats )) < 0 || if ((ret = ff_formats_ref (formats, &inlink->outcfg.formats )) < 0 ||
(ret = ff_add_channel_layout (&layout, AV_CH_LAYOUT_STEREO )) < 0 || (ret = ff_add_channel_layout (&layout, AV_CH_LAYOUT_STEREO )) < 0 ||
(ret = ff_channel_layouts_ref (layout , &inlink->out_channel_layouts)) < 0) (ret = ff_channel_layouts_ref (layout , &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

12
libavfilter/avf_concat.c
View File

@ -87,25 +87,25 @@ static int query_formats(AVFilterContext *ctx)
/* Set the output formats */ /* Set the output formats */
formats = ff_all_formats(type); formats = ff_all_formats(type);
if ((ret = ff_formats_ref(formats, &ctx->outputs[idx]->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &ctx->outputs[idx]->incfg.formats)) < 0)
return ret; return ret;
if (type == AVMEDIA_TYPE_AUDIO) { if (type == AVMEDIA_TYPE_AUDIO) {
rates = ff_all_samplerates(); rates = ff_all_samplerates();
if ((ret = ff_formats_ref(rates, &ctx->outputs[idx]->in_samplerates)) < 0) if ((ret = ff_formats_ref(rates, &ctx->outputs[idx]->incfg.samplerates)) < 0)
return ret; return ret;
layouts = ff_all_channel_layouts(); layouts = ff_all_channel_layouts();
if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[idx]->in_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &ctx->outputs[idx]->incfg.channel_layouts)) < 0)
return ret; return ret;
} }
/* Set the same formats for each corresponding input */ /* Set the same formats for each corresponding input */
for (seg = 0; seg < cat->nb_segments; seg++) { for (seg = 0; seg < cat->nb_segments; seg++) {
if ((ret = ff_formats_ref(formats, &ctx->inputs[idx]->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &ctx->inputs[idx]->outcfg.formats)) < 0)
return ret; return ret;
if (type == AVMEDIA_TYPE_AUDIO) { if (type == AVMEDIA_TYPE_AUDIO) {
if ((ret = ff_formats_ref(rates, &ctx->inputs[idx]->out_samplerates)) < 0 || if ((ret = ff_formats_ref(rates, &ctx->inputs[idx]->outcfg.samplerates)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &ctx->inputs[idx]->out_channel_layouts)) < 0) (ret = ff_channel_layouts_ref(layouts, &ctx->inputs[idx]->outcfg.channel_layouts)) < 0)
return ret; return ret;
} }
idx += ctx->nb_outputs; idx += ctx->nb_outputs;

8
libavfilter/avf_showcqt.c
View File

@ -1331,20 +1331,20 @@ static int query_formats(AVFilterContext *ctx)
/* set input audio formats */ /* set input audio formats */
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0)
return ret; return ret;
layouts = ff_make_format64_list(channel_layouts); layouts = ff_make_format64_list(channel_layouts);
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
/* set output video format */ /* set output video format */
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

8
libavfilter/avf_showfreqs.c
View File

@ -132,20 +132,20 @@ static int query_formats(AVFilterContext *ctx)
/* set input audio formats */ /* set input audio formats */
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0)
return ret; return ret;
layouts = ff_all_channel_layouts(); layouts = ff_all_channel_layouts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
/* set output video format */ /* set output video format */
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

8
libavfilter/avf_showspatial.c
View File

@ -114,17 +114,17 @@ static int query_formats(AVFilterContext *ctx)
int ret; int ret;
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref (formats, &inlink->out_formats )) < 0 || if ((ret = ff_formats_ref (formats, &inlink->outcfg.formats )) < 0 ||
(ret = ff_add_channel_layout (&layout, AV_CH_LAYOUT_STEREO )) < 0 || (ret = ff_add_channel_layout (&layout, AV_CH_LAYOUT_STEREO )) < 0 ||
(ret = ff_channel_layouts_ref (layout , &inlink->out_channel_layouts)) < 0) (ret = ff_channel_layouts_ref (layout , &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

8
libavfilter/avf_showspectrum.c
View File

@ -355,20 +355,20 @@ static int query_formats(AVFilterContext *ctx)
/* set input audio formats */ /* set input audio formats */
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0)
return ret; return ret;
layouts = ff_all_channel_layouts(); layouts = ff_all_channel_layouts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
/* set output video format */ /* set output video format */
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

8
libavfilter/avf_showvolume.c
View File

@ -125,19 +125,19 @@ static int query_formats(AVFilterContext *ctx)
int ret; int ret;
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0)
return ret; return ret;
layouts = ff_all_channel_counts(); layouts = ff_all_channel_counts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

8
libavfilter/avf_showwaves.c
View File

@ -161,20 +161,20 @@ static int query_formats(AVFilterContext *ctx)
/* set input audio formats */ /* set input audio formats */
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0)
return ret; return ret;
layouts = ff_all_channel_layouts(); layouts = ff_all_channel_layouts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0) if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_all_samplerates(); formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0)
return ret; return ret;
/* set output video format */ /* set output video format */
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

30
libavfilter/avfilter.c
View File

@ -261,15 +261,15 @@ int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
/* if any information on supported media formats already exists on the /* if any information on supported media formats already exists on the
* link, we need to preserve that */ * link, we need to preserve that */
if (link->out_formats) if (link->outcfg.formats)
ff_formats_changeref(&link->out_formats, ff_formats_changeref(&link->outcfg.formats,
&filt->outputs[filt_dstpad_idx]->out_formats); &filt->outputs[filt_dstpad_idx]->outcfg.formats);
if (link->out_samplerates) if (link->outcfg.samplerates)
ff_formats_changeref(&link->out_samplerates, ff_formats_changeref(&link->outcfg.samplerates,
&filt->outputs[filt_dstpad_idx]->out_samplerates); &filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
if (link->out_channel_layouts) if (link->outcfg.channel_layouts)
ff_channel_layouts_changeref(&link->out_channel_layouts, ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
&filt->outputs[filt_dstpad_idx]->out_channel_layouts); &filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
return 0; return 0;
} }
@ -746,12 +746,12 @@ static void free_link(AVFilterLink *link)
av_buffer_unref(&link->hw_frames_ctx); av_buffer_unref(&link->hw_frames_ctx);
ff_formats_unref(&link->in_formats); ff_formats_unref(&link->incfg.formats);
ff_formats_unref(&link->out_formats); ff_formats_unref(&link->outcfg.formats);
ff_formats_unref(&link->in_samplerates); ff_formats_unref(&link->incfg.samplerates);
ff_formats_unref(&link->out_samplerates); ff_formats_unref(&link->outcfg.samplerates);
ff_channel_layouts_unref(&link->in_channel_layouts); ff_channel_layouts_unref(&link->incfg.channel_layouts);
ff_channel_layouts_unref(&link->out_channel_layouts); ff_channel_layouts_unref(&link->outcfg.channel_layouts);
avfilter_link_free(&link); avfilter_link_free(&link);
} }

64
libavfilter/avfilter.h
View File

@ -68,6 +68,7 @@ typedef struct AVFilterContext AVFilterContext;
typedef struct AVFilterLink AVFilterLink; typedef struct AVFilterLink AVFilterLink;
typedef struct AVFilterPad AVFilterPad; typedef struct AVFilterPad AVFilterPad;
typedef struct AVFilterFormats AVFilterFormats; typedef struct AVFilterFormats AVFilterFormats;
typedef struct AVFilterChannelLayouts AVFilterChannelLayouts;
/** /**
* Get the number of elements in a NULL-terminated array of AVFilterPads (e.g. * Get the number of elements in a NULL-terminated array of AVFilterPads (e.g.
@ -264,13 +265,13 @@ typedef struct AVFilter {
* and outputs are fixed), shortly before the format negotiation. This * and outputs are fixed), shortly before the format negotiation. This
* callback may be called more than once. * callback may be called more than once.
* *
* This callback must set AVFilterLink.out_formats on every input link and * This callback must set AVFilterLink.outcfg.formats on every input link and
* AVFilterLink.in_formats on every output link to a list of pixel/sample * AVFilterLink.incfg.formats on every output link to a list of pixel/sample
* formats that the filter supports on that link. For audio links, this * formats that the filter supports on that link. For audio links, this
* filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" / * filter must also set @ref AVFilterLink.incfg.samplerates "in_samplerates" /
* @ref AVFilterLink.out_samplerates "out_samplerates" and * @ref AVFilterLink.outcfg.samplerates "out_samplerates" and
* @ref AVFilterLink.in_channel_layouts "in_channel_layouts" / * @ref AVFilterLink.incfg.channel_layouts "in_channel_layouts" /
* @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously. * @ref AVFilterLink.outcfg.channel_layouts "out_channel_layouts" analogously.
* *
* This callback may be NULL for filters with one input, in which case * This callback may be NULL for filters with one input, in which case
* libavfilter assumes that it supports all input formats and preserves * libavfilter assumes that it supports all input formats and preserves
@ -424,6 +425,35 @@ struct AVFilterContext {
int extra_hw_frames; int extra_hw_frames;
}; };
/**
* Lists of formats / etc. supported by an end of a link.
*
* This structure is directly part of AVFilterLink, in two copies:
* one for the source filter, one for the destination filter.
* These lists are used for negotiating the format to actually be used,
* which will be loaded into the format and channel_layout members of
* AVFilterLink, when chosen.
*/
typedef struct AVFilterFormatsConfig {
/**
* List of supported formats (pixel or sample).
*/
AVFilterFormats *formats;
/**
* Lists of supported sample rates, only for audio.
*/
AVFilterFormats *samplerates;
/**
* Lists of supported channel layouts, only for audio.
*/
AVFilterChannelLayouts *channel_layouts;
} AVFilterFormatsConfig;
/** /**
* A link between two filters. This contains pointers to the source and * A link between two filters. This contains pointers to the source and
* destination filters between which this link exists, and the indexes of * destination filters between which this link exists, and the indexes of
@ -471,24 +501,16 @@ struct AVFilterLink {
* New public fields should be added right above. * New public fields should be added right above.
***************************************************************** *****************************************************************
*/ */
/**
* Lists of formats and channel layouts supported by the input and output
* filters respectively. These lists are used for negotiating the format
* to actually be used, which will be loaded into the format and
* channel_layout members, above, when chosen.
*
*/
AVFilterFormats *in_formats;
AVFilterFormats *out_formats;
/** /**
* Lists of channel layouts and sample rates used for automatic * Lists of supported formats / etc. supported by the input filter.
* negotiation.
*/ */
AVFilterFormats *in_samplerates; AVFilterFormatsConfig incfg;
AVFilterFormats *out_samplerates;
struct AVFilterChannelLayouts *in_channel_layouts; /**
struct AVFilterChannelLayouts *out_channel_layouts; * Lists of supported formats / etc. supported by the output filter.
*/
AVFilterFormatsConfig outcfg;
/** stage of the initialization of the link properties (dimensions, etc) */ /** stage of the initialization of the link properties (dimensions, etc) */
enum { enum {

216
libavfilter/avfiltergraph.c
View File

@ -331,9 +331,9 @@ static int filter_query_formats(AVFilterContext *ctx)
} }
for (i = 0; i < ctx->nb_inputs; i++) for (i = 0; i < ctx->nb_inputs; i++)
sanitize_channel_layouts(ctx, ctx->inputs[i]->out_channel_layouts); sanitize_channel_layouts(ctx, ctx->inputs[i]->outcfg.channel_layouts);
for (i = 0; i < ctx->nb_outputs; i++) for (i = 0; i < ctx->nb_outputs; i++)
sanitize_channel_layouts(ctx, ctx->outputs[i]->in_channel_layouts); sanitize_channel_layouts(ctx, ctx->outputs[i]->incfg.channel_layouts);
formats = ff_all_formats(type); formats = ff_all_formats(type);
if ((ret = ff_set_common_formats(ctx, formats)) < 0) if ((ret = ff_set_common_formats(ctx, formats)) < 0)
@ -354,19 +354,19 @@ static int formats_declared(AVFilterContext *f)
int i; int i;
for (i = 0; i < f->nb_inputs; i++) { for (i = 0; i < f->nb_inputs; i++) {
if (!f->inputs[i]->out_formats) if (!f->inputs[i]->outcfg.formats)
return 0; return 0;
if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO && if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
!(f->inputs[i]->out_samplerates && !(f->inputs[i]->outcfg.samplerates &&
f->inputs[i]->out_channel_layouts)) f->inputs[i]->outcfg.channel_layouts))
return 0; return 0;
} }
for (i = 0; i < f->nb_outputs; i++) { for (i = 0; i < f->nb_outputs; i++) {
if (!f->outputs[i]->in_formats) if (!f->outputs[i]->incfg.formats)
return 0; return 0;
if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO && if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
!(f->outputs[i]->in_samplerates && !(f->outputs[i]->incfg.samplerates &&
f->outputs[i]->in_channel_layouts)) f->outputs[i]->incfg.channel_layouts))
return 0; return 0;
} }
return 1; return 1;
@ -416,24 +416,24 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
if (!link) if (!link)
continue; continue;
if (link->in_formats != link->out_formats if (link->incfg.formats != link->outcfg.formats
&& link->in_formats && link->out_formats) && link->incfg.formats && link->outcfg.formats)
if (!ff_can_merge_formats(link->in_formats, link->out_formats, if (!ff_can_merge_formats(link->incfg.formats, link->outcfg.formats,
link->type)) link->type))
convert_needed = 1; convert_needed = 1;
if (link->type == AVMEDIA_TYPE_AUDIO) { if (link->type == AVMEDIA_TYPE_AUDIO) {
if (link->in_samplerates != link->out_samplerates if (link->incfg.samplerates != link->outcfg.samplerates
&& link->in_samplerates && link->out_samplerates) && link->incfg.samplerates && link->outcfg.samplerates)
if (!ff_can_merge_samplerates(link->in_samplerates, if (!ff_can_merge_samplerates(link->incfg.samplerates,
link->out_samplerates)) link->outcfg.samplerates))
convert_needed = 1; convert_needed = 1;
} }
#define CHECKED_MERGE(field, ...) ((ret = ff_merge_ ## field(__VA_ARGS__)) <= 0) #define CHECKED_MERGE(field, ...) ((ret = ff_merge_ ## field(__VA_ARGS__)) <= 0)
#define MERGE_DISPATCH(field, ...) \ #define MERGE_DISPATCH(field, ...) \
if (!(link->in_ ## field && link->out_ ## field)) { \ if (!(link->incfg.field && link->outcfg.field)) { \
count_delayed++; \ count_delayed++; \
} else if (link->in_ ## field == link->out_ ## field) { \ } else if (link->incfg.field == link->outcfg.field) { \
count_already_merged++; \ count_already_merged++; \
} else if (!convert_needed) { \ } else if (!convert_needed) { \
count_merged++; \ count_merged++; \
@ -445,13 +445,13 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
} }
if (link->type == AVMEDIA_TYPE_AUDIO) { if (link->type == AVMEDIA_TYPE_AUDIO) {
MERGE_DISPATCH(channel_layouts, link->in_channel_layouts, MERGE_DISPATCH(channel_layouts, link->incfg.channel_layouts,
link->out_channel_layouts) link->outcfg.channel_layouts)
MERGE_DISPATCH(samplerates, link->in_samplerates, MERGE_DISPATCH(samplerates, link->incfg.samplerates,
link->out_samplerates) link->outcfg.samplerates)
} }
MERGE_DISPATCH(formats, link->in_formats, MERGE_DISPATCH(formats, link->incfg.formats,
link->out_formats, link->type) link->outcfg.formats, link->type)
#undef MERGE_DISPATCH #undef MERGE_DISPATCH
if (convert_needed) { if (convert_needed) {
@ -511,34 +511,34 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
inlink = convert->inputs[0]; inlink = convert->inputs[0];
outlink = convert->outputs[0]; outlink = convert->outputs[0];
av_assert0( inlink-> in_formats->refcount > 0); av_assert0( inlink->incfg.formats->refcount > 0);
av_assert0( inlink->out_formats->refcount > 0); av_assert0( inlink->outcfg.formats->refcount > 0);
av_assert0(outlink-> in_formats->refcount > 0); av_assert0(outlink->incfg.formats->refcount > 0);
av_assert0(outlink->out_formats->refcount > 0); av_assert0(outlink->outcfg.formats->refcount > 0);
if (outlink->type == AVMEDIA_TYPE_AUDIO) { if (outlink->type == AVMEDIA_TYPE_AUDIO) {
av_assert0( inlink-> in_samplerates->refcount > 0); av_assert0( inlink-> incfg.samplerates->refcount > 0);
av_assert0( inlink->out_samplerates->refcount > 0); av_assert0( inlink->outcfg.samplerates->refcount > 0);
av_assert0(outlink-> in_samplerates->refcount > 0); av_assert0(outlink-> incfg.samplerates->refcount > 0);
av_assert0(outlink->out_samplerates->refcount > 0); av_assert0(outlink->outcfg.samplerates->refcount > 0);
av_assert0( inlink-> in_channel_layouts->refcount > 0); av_assert0( inlink-> incfg.channel_layouts->refcount > 0);
av_assert0( inlink->out_channel_layouts->refcount > 0); av_assert0( inlink->outcfg.channel_layouts->refcount > 0);
av_assert0(outlink-> in_channel_layouts->refcount > 0); av_assert0(outlink-> incfg.channel_layouts->refcount > 0);
av_assert0(outlink->out_channel_layouts->refcount > 0); av_assert0(outlink->outcfg.channel_layouts->refcount > 0);
} }
if (CHECKED_MERGE(formats, inlink->in_formats, if (CHECKED_MERGE(formats, inlink->incfg.formats,
inlink->out_formats, inlink->type) || inlink->outcfg.formats, inlink->type) ||
CHECKED_MERGE(formats, outlink->in_formats, CHECKED_MERGE(formats, outlink->incfg.formats,
outlink->out_formats, outlink->type) || outlink->outcfg.formats, outlink->type) ||
inlink->type == AVMEDIA_TYPE_AUDIO && inlink->type == AVMEDIA_TYPE_AUDIO &&
(CHECKED_MERGE(samplerates, inlink->in_samplerates, (CHECKED_MERGE(samplerates, inlink->incfg.samplerates,
inlink->out_samplerates) || inlink->outcfg.samplerates) ||
CHECKED_MERGE(channel_layouts, inlink->in_channel_layouts, CHECKED_MERGE(channel_layouts, inlink->incfg.channel_layouts,
inlink->out_channel_layouts)) || inlink->outcfg.channel_layouts)) ||
outlink->type == AVMEDIA_TYPE_AUDIO && outlink->type == AVMEDIA_TYPE_AUDIO &&
(CHECKED_MERGE(samplerates, outlink->in_samplerates, (CHECKED_MERGE(samplerates, outlink->incfg.samplerates,
outlink->out_samplerates) || outlink->outcfg.samplerates) ||
CHECKED_MERGE(channel_layouts, outlink->in_channel_layouts, CHECKED_MERGE(channel_layouts, outlink->incfg.channel_layouts,
outlink->out_channel_layouts))) { outlink->outcfg.channel_layouts))) {
if (ret < 0) if (ret < 0)
return ret; return ret;
av_log(log_ctx, AV_LOG_ERROR, av_log(log_ctx, AV_LOG_ERROR,
@ -613,7 +613,7 @@ static enum AVSampleFormat find_best_sample_fmt_of_2(enum AVSampleFormat dst_fmt
static int pick_format(AVFilterLink *link, AVFilterLink *ref) static int pick_format(AVFilterLink *link, AVFilterLink *ref)
{ {
if (!link || !link->in_formats) if (!link || !link->incfg.formats)
return 0; return 0;
if (link->type == AVMEDIA_TYPE_VIDEO) { if (link->type == AVMEDIA_TYPE_VIDEO) {
@ -622,67 +622,67 @@ static int pick_format(AVFilterLink *link, AVFilterLink *ref)
int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0; int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
enum AVPixelFormat best= AV_PIX_FMT_NONE; enum AVPixelFormat best= AV_PIX_FMT_NONE;
int i; int i;
for (i=0; i<link->in_formats->nb_formats; i++) { for (i = 0; i < link->incfg.formats->nb_formats; i++) {
enum AVPixelFormat p = link->in_formats->formats[i]; enum AVPixelFormat p = link->incfg.formats->formats[i];
best= av_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL); best= av_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_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->nb_formats, av_get_pix_fmt_name(best), link->incfg.formats->nb_formats,
av_get_pix_fmt_name(ref->format), has_alpha); av_get_pix_fmt_name(ref->format), has_alpha);
link->in_formats->formats[0] = best; link->incfg.formats->formats[0] = best;
} }
} else if (link->type == AVMEDIA_TYPE_AUDIO) { } else if (link->type == AVMEDIA_TYPE_AUDIO) {
if(ref && ref->type == AVMEDIA_TYPE_AUDIO){ if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
enum AVSampleFormat best= AV_SAMPLE_FMT_NONE; enum AVSampleFormat best= AV_SAMPLE_FMT_NONE;
int i; int i;
for (i=0; i<link->in_formats->nb_formats; i++) { for (i = 0; i < link->incfg.formats->nb_formats; i++) {
enum AVSampleFormat p = link->in_formats->formats[i]; enum AVSampleFormat p = link->incfg.formats->formats[i];
best = find_best_sample_fmt_of_2(best, p, ref->format); best = find_best_sample_fmt_of_2(best, p, ref->format);
} }
av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n", av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s\n",
av_get_sample_fmt_name(best), link->in_formats->nb_formats, av_get_sample_fmt_name(best), link->incfg.formats->nb_formats,
av_get_sample_fmt_name(ref->format)); av_get_sample_fmt_name(ref->format));
link->in_formats->formats[0] = best; link->incfg.formats->formats[0] = best;
} }
} }
link->in_formats->nb_formats = 1; link->incfg.formats->nb_formats = 1;
link->format = link->in_formats->formats[0]; link->format = link->incfg.formats->formats[0];
if (link->type == AVMEDIA_TYPE_AUDIO) { if (link->type == AVMEDIA_TYPE_AUDIO) {
if (!link->in_samplerates->nb_formats) { if (!link->incfg.samplerates->nb_formats) {
av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for" av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
" the link between filters %s and %s.\n", link->src->name, " the link between filters %s and %s.\n", link->src->name,
link->dst->name); link->dst->name);
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
link->in_samplerates->nb_formats = 1; link->incfg.samplerates->nb_formats = 1;
link->sample_rate = link->in_samplerates->formats[0]; link->sample_rate = link->incfg.samplerates->formats[0];
if (link->in_channel_layouts->all_layouts) { if (link->incfg.channel_layouts->all_layouts) {
av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for" av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
" the link between filters %s and %s.\n", link->src->name, " the link between filters %s and %s.\n", link->src->name,
link->dst->name); link->dst->name);
if (!link->in_channel_layouts->all_counts) if (!link->incfg.channel_layouts->all_counts)
av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not " av_log(link->src, AV_LOG_ERROR, "Unknown channel layouts not "
"supported, try specifying a channel layout using " "supported, try specifying a channel layout using "
"'aformat=channel_layouts=something'.\n"); "'aformat=channel_layouts=something'.\n");
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
link->in_channel_layouts->nb_channel_layouts = 1; link->incfg.channel_layouts->nb_channel_layouts = 1;
link->channel_layout = link->in_channel_layouts->channel_layouts[0]; link->channel_layout = link->incfg.channel_layouts->channel_layouts[0];
if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout))) if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
link->channel_layout = 0; link->channel_layout = 0;
else else
link->channels = av_get_channel_layout_nb_channels(link->channel_layout); link->channels = av_get_channel_layout_nb_channels(link->channel_layout);
} }
ff_formats_unref(&link->in_formats); ff_formats_unref(&link->incfg.formats);
ff_formats_unref(&link->out_formats); ff_formats_unref(&link->outcfg.formats);
ff_formats_unref(&link->in_samplerates); ff_formats_unref(&link->incfg.samplerates);
ff_formats_unref(&link->out_samplerates); ff_formats_unref(&link->outcfg.samplerates);
ff_channel_layouts_unref(&link->in_channel_layouts); ff_channel_layouts_unref(&link->incfg.channel_layouts);
ff_channel_layouts_unref(&link->out_channel_layouts); ff_channel_layouts_unref(&link->outcfg.channel_layouts);
return 0; return 0;
} }
@ -693,27 +693,27 @@ do { \
AVFilterLink *link = filter->inputs[i]; \ AVFilterLink *link = filter->inputs[i]; \
fmt_type fmt; \ fmt_type fmt; \
\ \
if (!link->out_ ## list || link->out_ ## list->nb != 1) \ if (!link->outcfg.list || link->outcfg.list->nb != 1) \
continue; \ continue; \
fmt = link->out_ ## list->var[0]; \ fmt = link->outcfg.list->var[0]; \
\ \
for (j = 0; j < filter->nb_outputs; j++) { \ for (j = 0; j < filter->nb_outputs; j++) { \
AVFilterLink *out_link = filter->outputs[j]; \ AVFilterLink *out_link = filter->outputs[j]; \
list_type *fmts; \ list_type *fmts; \
\ \
if (link->type != out_link->type || \ if (link->type != out_link->type || \
out_link->in_ ## list->nb == 1) \ out_link->incfg.list->nb == 1) \
continue; \ continue; \
fmts = out_link->in_ ## list; \ fmts = out_link->incfg.list; \
\ \
if (!out_link->in_ ## list->nb) { \ if (!out_link->incfg.list->nb) { \
if ((ret = add_format(&out_link->in_ ##list, fmt)) < 0)\ if ((ret = add_format(&out_link->incfg.list, fmt)) < 0)\
return ret; \ return ret; \
ret = 1; \ ret = 1; \
break; \ break; \
} \ } \
\ \
for (k = 0; k < out_link->in_ ## list->nb; k++) \ for (k = 0; k < out_link->incfg.list->nb; k++) \
if (fmts->var[k] == fmt) { \ if (fmts->var[k] == fmt) { \
fmts->var[0] = fmt; \ fmts->var[0] = fmt; \
fmts->nb = 1; \ fmts->nb = 1; \
@ -738,16 +738,16 @@ static int reduce_formats_on_filter(AVFilterContext *filter)
AVFilterLink *inlink = filter->inputs[i]; AVFilterLink *inlink = filter->inputs[i];
uint64_t fmt; uint64_t fmt;
if (!inlink->out_channel_layouts || if (!inlink->outcfg.channel_layouts ||
inlink->out_channel_layouts->nb_channel_layouts != 1) inlink->outcfg.channel_layouts->nb_channel_layouts != 1)
continue; continue;
fmt = inlink->out_channel_layouts->channel_layouts[0]; fmt = inlink->outcfg.channel_layouts->channel_layouts[0];
for (j = 0; j < filter->nb_outputs; j++) { for (j = 0; j < filter->nb_outputs; j++) {
AVFilterLink *outlink = filter->outputs[j]; AVFilterLink *outlink = filter->outputs[j];
AVFilterChannelLayouts *fmts; AVFilterChannelLayouts *fmts;
fmts = outlink->in_channel_layouts; fmts = outlink->incfg.channel_layouts;
if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1) if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
continue; continue;
@ -755,12 +755,12 @@ static int reduce_formats_on_filter(AVFilterContext *filter)
(!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) { (!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
/* Turn the infinite list into a singleton */ /* Turn the infinite list into a singleton */
fmts->all_layouts = fmts->all_counts = 0; fmts->all_layouts = fmts->all_counts = 0;
if (ff_add_channel_layout(&outlink->in_channel_layouts, fmt) < 0) if (ff_add_channel_layout(&outlink->incfg.channel_layouts, fmt) < 0)
ret = 1; ret = 1;
break; break;
} }
for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) { for (k = 0; k < outlink->incfg.channel_layouts->nb_channel_layouts; k++) {
if (fmts->channel_layouts[k] == fmt) { if (fmts->channel_layouts[k] == fmt) {
fmts->channel_layouts[0] = fmt; fmts->channel_layouts[0] = fmt;
fmts->nb_channel_layouts = 1; fmts->nb_channel_layouts = 1;
@ -801,24 +801,24 @@ static void swap_samplerates_on_filter(AVFilterContext *filter)
link = filter->inputs[i]; link = filter->inputs[i];
if (link->type == AVMEDIA_TYPE_AUDIO && if (link->type == AVMEDIA_TYPE_AUDIO &&
link->out_samplerates->nb_formats== 1) link->outcfg.samplerates->nb_formats== 1)
break; break;
} }
if (i == filter->nb_inputs) if (i == filter->nb_inputs)
return; return;
sample_rate = link->out_samplerates->formats[0]; sample_rate = link->outcfg.samplerates->formats[0];
for (i = 0; i < filter->nb_outputs; i++) { for (i = 0; i < filter->nb_outputs; i++) {
AVFilterLink *outlink = filter->outputs[i]; AVFilterLink *outlink = filter->outputs[i];
int best_idx, best_diff = INT_MAX; int best_idx, best_diff = INT_MAX;
if (outlink->type != AVMEDIA_TYPE_AUDIO || if (outlink->type != AVMEDIA_TYPE_AUDIO ||
outlink->in_samplerates->nb_formats < 2) outlink->incfg.samplerates->nb_formats < 2)
continue; continue;
for (j = 0; j < outlink->in_samplerates->nb_formats; j++) { for (j = 0; j < outlink->incfg.samplerates->nb_formats; j++) {
int diff = abs(sample_rate - outlink->in_samplerates->formats[j]); int diff = abs(sample_rate - outlink->incfg.samplerates->formats[j]);
av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates av_assert0(diff < INT_MAX); // This would lead to the use of uninitialized best_diff but is only possible with invalid sample rates
@ -827,8 +827,8 @@ static void swap_samplerates_on_filter(AVFilterContext *filter)
best_idx = j; best_idx = j;
} }
} }
FFSWAP(int, outlink->in_samplerates->formats[0], FFSWAP(int, outlink->incfg.samplerates->formats[0],
outlink->in_samplerates->formats[best_idx]); outlink->incfg.samplerates->formats[best_idx]);
} }
} }
@ -883,7 +883,7 @@ static void swap_channel_layouts_on_filter(AVFilterContext *filter)
link = filter->inputs[i]; link = filter->inputs[i];
if (link->type == AVMEDIA_TYPE_AUDIO && if (link->type == AVMEDIA_TYPE_AUDIO &&
link->out_channel_layouts->nb_channel_layouts == 1) link->outcfg.channel_layouts->nb_channel_layouts == 1)
break; break;
} }
if (i == filter->nb_inputs) if (i == filter->nb_inputs)
@ -894,12 +894,12 @@ static void swap_channel_layouts_on_filter(AVFilterContext *filter)
int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX; int best_idx = -1, best_score = INT_MIN, best_count_diff = INT_MAX;
if (outlink->type != AVMEDIA_TYPE_AUDIO || if (outlink->type != AVMEDIA_TYPE_AUDIO ||
outlink->in_channel_layouts->nb_channel_layouts < 2) outlink->incfg.channel_layouts->nb_channel_layouts < 2)
continue; continue;
for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) { for (j = 0; j < outlink->incfg.channel_layouts->nb_channel_layouts; j++) {
uint64_t in_chlayout = link->out_channel_layouts->channel_layouts[0]; uint64_t in_chlayout = link->outcfg.channel_layouts->channel_layouts[0];
uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j]; uint64_t out_chlayout = outlink->incfg.channel_layouts->channel_layouts[j];
int in_channels = av_get_channel_layout_nb_channels(in_chlayout); int in_channels = av_get_channel_layout_nb_channels(in_chlayout);
int out_channels = av_get_channel_layout_nb_channels(out_chlayout); int out_channels = av_get_channel_layout_nb_channels(out_chlayout);
int count_diff = out_channels - in_channels; int count_diff = out_channels - in_channels;
@ -957,8 +957,8 @@ static void swap_channel_layouts_on_filter(AVFilterContext *filter)
} }
} }
av_assert0(best_idx >= 0); av_assert0(best_idx >= 0);
FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0], FFSWAP(uint64_t, outlink->incfg.channel_layouts->channel_layouts[0],
outlink->in_channel_layouts->channel_layouts[best_idx]); outlink->incfg.channel_layouts->channel_layouts[best_idx]);
} }
} }
@ -981,13 +981,13 @@ static void swap_sample_fmts_on_filter(AVFilterContext *filter)
link = filter->inputs[i]; link = filter->inputs[i];
if (link->type == AVMEDIA_TYPE_AUDIO && if (link->type == AVMEDIA_TYPE_AUDIO &&
link->out_formats->nb_formats == 1) link->outcfg.formats->nb_formats == 1)
break; break;
} }
if (i == filter->nb_inputs) if (i == filter->nb_inputs)
return; return;
format = link->out_formats->formats[0]; format = link->outcfg.formats->formats[0];
bps = av_get_bytes_per_sample(format); bps = av_get_bytes_per_sample(format);
for (i = 0; i < filter->nb_outputs; i++) { for (i = 0; i < filter->nb_outputs; i++) {
@ -995,11 +995,11 @@ static void swap_sample_fmts_on_filter(AVFilterContext *filter)
int best_idx = -1, best_score = INT_MIN; int best_idx = -1, best_score = INT_MIN;
if (outlink->type != AVMEDIA_TYPE_AUDIO || if (outlink->type != AVMEDIA_TYPE_AUDIO ||
outlink->in_formats->nb_formats < 2) outlink->incfg.formats->nb_formats < 2)
continue; continue;
for (j = 0; j < outlink->in_formats->nb_formats; j++) { for (j = 0; j < outlink->incfg.formats->nb_formats; j++) {
int out_format = outlink->in_formats->formats[j]; int out_format = outlink->incfg.formats->formats[j];
int out_bps = av_get_bytes_per_sample(out_format); int out_bps = av_get_bytes_per_sample(out_format);
int score; int score;
@ -1026,8 +1026,8 @@ static void swap_sample_fmts_on_filter(AVFilterContext *filter)
} }
} }
av_assert0(best_idx >= 0); av_assert0(best_idx >= 0);
FFSWAP(int, outlink->in_formats->formats[0], FFSWAP(int, outlink->incfg.formats->formats[0],
outlink->in_formats->formats[best_idx]); outlink->incfg.formats->formats[best_idx]);
} }
} }
@ -1051,7 +1051,7 @@ static int pick_formats(AVFilterGraph *graph)
AVFilterContext *filter = graph->filters[i]; AVFilterContext *filter = graph->filters[i];
if (filter->nb_inputs){ if (filter->nb_inputs){
for (j = 0; j < filter->nb_inputs; j++){ for (j = 0; j < filter->nb_inputs; j++){
if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->nb_formats == 1) { if (filter->inputs[j]->incfg.formats && filter->inputs[j]->incfg.formats->nb_formats == 1) {
if ((ret = pick_format(filter->inputs[j], NULL)) < 0) if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
return ret; return ret;
change = 1; change = 1;
@ -1060,7 +1060,7 @@ static int pick_formats(AVFilterGraph *graph)
} }
if (filter->nb_outputs){ if (filter->nb_outputs){
for (j = 0; j < filter->nb_outputs; j++){ for (j = 0; j < filter->nb_outputs; j++){
if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->nb_formats == 1) { if (filter->outputs[j]->incfg.formats && filter->outputs[j]->incfg.formats->nb_formats == 1) {
if ((ret = pick_format(filter->outputs[j], NULL)) < 0) if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
return ret; return ret;
change = 1; change = 1;
@ -1069,7 +1069,7 @@ static int pick_formats(AVFilterGraph *graph)
} }
if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) { if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
for (j = 0; j < filter->nb_outputs; j++) { for (j = 0; j < filter->nb_outputs; j++) {
if(filter->outputs[j]->format<0) { if (filter->outputs[j]->format<0) {
if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0) if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
return ret; return ret;
change = 1; change = 1;

2
libavfilter/f_drawgraph.c
View File

@ -134,7 +134,7 @@ static int query_formats(AVFilterContext *ctx)
int ret; int ret;
AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts); AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(fmts_list, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(fmts_list, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

14
libavfilter/f_ebur128.c
View File

@ -902,7 +902,7 @@ static int query_formats(AVFilterContext *ctx)
/* set optional output video format */ /* set optional output video format */
if (ebur128->do_video) { if (ebur128->do_video) {
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
outlink = ctx->outputs[1]; outlink = ctx->outputs[1];
} }
@ -911,18 +911,18 @@ static int query_formats(AVFilterContext *ctx)
* Note: ff_set_common_* functions are not used because they affect all the * Note: ff_set_common_* functions are not used because they affect all the
* links, and thus break the video format negotiation */ * links, and thus break the video format negotiation */
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0 || if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_formats)) < 0) (ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret; return ret;
layouts = ff_all_channel_layouts(); layouts = ff_all_channel_layouts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0 || if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0)
return ret; return ret;
formats = ff_make_format_list(input_srate); formats = ff_make_format_list(input_srate);
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 || if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0) (ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0)
return ret; return ret;
return 0; return 0;

2
libavfilter/f_graphmonitor.c
View File

@ -103,7 +103,7 @@ static int query_formats(AVFilterContext *ctx)
int ret; int ret;
AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts); AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(fmts_list, &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(fmts_list, &outlink->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

6
libavfilter/formats.c
View File

@ -569,14 +569,14 @@ void ff_formats_changeref(AVFilterFormats **oldref, AVFilterFormats **newref)
int ff_set_common_channel_layouts(AVFilterContext *ctx, int ff_set_common_channel_layouts(AVFilterContext *ctx,
AVFilterChannelLayouts *layouts) AVFilterChannelLayouts *layouts)
{ {
SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts, SET_COMMON_FORMATS(ctx, layouts, incfg.channel_layouts, outcfg.channel_layouts,
ff_channel_layouts_ref, ff_channel_layouts_unref); ff_channel_layouts_ref, ff_channel_layouts_unref);
} }
int ff_set_common_samplerates(AVFilterContext *ctx, int ff_set_common_samplerates(AVFilterContext *ctx,
AVFilterFormats *samplerates) AVFilterFormats *samplerates)
{ {
SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates, SET_COMMON_FORMATS(ctx, samplerates, incfg.samplerates, outcfg.samplerates,
ff_formats_ref, ff_formats_unref); ff_formats_ref, ff_formats_unref);
} }
@ -587,7 +587,7 @@ int ff_set_common_samplerates(AVFilterContext *ctx,
*/ */
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats) int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
{ {
SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats, SET_COMMON_FORMATS(ctx, formats, incfg.formats, outcfg.formats,
ff_formats_ref, ff_formats_unref); ff_formats_ref, ff_formats_unref);
} }

8
libavfilter/src_movie.c
View File

@ -362,19 +362,19 @@ static int movie_query_formats(AVFilterContext *ctx)
switch (c->codec_type) { switch (c->codec_type) {
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
list[0] = c->format; list[0] = c->format;
if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
return ret; return ret;
break; break;
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
list[0] = c->format; list[0] = c->format;
if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.formats)) < 0)
return ret; return ret;
list[0] = c->sample_rate; list[0] = c->sample_rate;
if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->in_samplerates)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(list), &outlink->incfg.samplerates)) < 0)
return ret; return ret;
list64[0] = c->channel_layout; list64[0] = c->channel_layout;
if ((ret = ff_channel_layouts_ref(ff_make_format64_list(list64), if ((ret = ff_channel_layouts_ref(ff_make_format64_list(list64),
&outlink->in_channel_layouts)) < 0) &outlink->incfg.channel_layouts)) < 0)
return ret; return ret;
break; break;
} }

6
libavfilter/tests/filtfmts.c
View File

@ -40,7 +40,7 @@ static void print_formats(AVFilterContext *filter_ctx)
for (i = 0; i < filter_ctx->nb_##inout##puts; i++) { \ for (i = 0; i < filter_ctx->nb_##inout##puts; i++) { \
if (filter_ctx->inout##puts[i]->type == AVMEDIA_TYPE_VIDEO) { \ if (filter_ctx->inout##puts[i]->type == AVMEDIA_TYPE_VIDEO) { \
AVFilterFormats *fmts = \ AVFilterFormats *fmts = \
filter_ctx->inout##puts[i]->outin##_formats; \ filter_ctx->inout##puts[i]->outin##cfg.formats; \
for (j = 0; j < fmts->nb_formats; j++) \ for (j = 0; j < fmts->nb_formats; j++) \
if(av_get_pix_fmt_name(fmts->formats[j])) \ if(av_get_pix_fmt_name(fmts->formats[j])) \
printf(#INOUT "PUT[%d] %s: fmt:%s\n", \ printf(#INOUT "PUT[%d] %s: fmt:%s\n", \
@ -50,13 +50,13 @@ static void print_formats(AVFilterContext *filter_ctx)
AVFilterFormats *fmts; \ AVFilterFormats *fmts; \
AVFilterChannelLayouts *layouts; \ AVFilterChannelLayouts *layouts; \
\ \
fmts = filter_ctx->inout##puts[i]->outin##_formats; \ fmts = filter_ctx->inout##puts[i]->outin##cfg.formats; \
for (j = 0; j < fmts->nb_formats; j++) \ for (j = 0; j < fmts->nb_formats; j++) \
printf(#INOUT "PUT[%d] %s: fmt:%s\n", \ printf(#INOUT "PUT[%d] %s: fmt:%s\n", \
i, avfilter_pad_get_name(filter_ctx->inout##put_pads, i), \ i, avfilter_pad_get_name(filter_ctx->inout##put_pads, i), \
av_get_sample_fmt_name(fmts->formats[j])); \ av_get_sample_fmt_name(fmts->formats[j])); \
\ \
layouts = filter_ctx->inout##puts[i]->outin##_channel_layouts; \ layouts = filter_ctx->inout##puts[i]->outin##cfg.channel_layouts; \
for (j = 0; j < layouts->nb_channel_layouts; j++) { \ for (j = 0; j < layouts->nb_channel_layouts; j++) { \
char buf[256]; \ char buf[256]; \
av_get_channel_layout_string(buf, sizeof(buf), -1, \ av_get_channel_layout_string(buf, sizeof(buf), -1, \

4
libavfilter/vaapi_vpp.c
View File

@ -32,10 +32,10 @@ int ff_vaapi_vpp_query_formats(AVFilterContext *avctx)
int err; int err;
if ((err = ff_formats_ref(ff_make_format_list(pix_fmts), if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
&avctx->inputs[0]->out_formats)) < 0) &avctx->inputs[0]->outcfg.formats)) < 0)
return err; return err;
if ((err = ff_formats_ref(ff_make_format_list(pix_fmts), if ((err = ff_formats_ref(ff_make_format_list(pix_fmts),
&avctx->outputs[0]->in_formats)) < 0) &avctx->outputs[0]->incfg.formats)) < 0)
return err; return err;
return 0; return 0;

10
libavfilter/vaf_spectrumsynth.c
View File

@ -115,28 +115,28 @@ static int query_formats(AVFilterContext *ctx)
int ret, sample_rates[] = { 48000, -1 }; int ret, sample_rates[] = { 48000, -1 };
formats = ff_make_format_list(sample_fmts); formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref (formats, &outlink->in_formats )) < 0 || if ((ret = ff_formats_ref (formats, &outlink->incfg.formats )) < 0 ||
(ret = ff_add_channel_layout (&layout, FF_COUNT2LAYOUT(s->channels))) < 0 || (ret = ff_add_channel_layout (&layout, FF_COUNT2LAYOUT(s->channels))) < 0 ||
(ret = ff_channel_layouts_ref (layout , &outlink->in_channel_layouts)) < 0) (ret = ff_channel_layouts_ref (layout , &outlink->incfg.channel_layouts)) < 0)
return ret; return ret;
sample_rates[0] = s->sample_rate; sample_rates[0] = s->sample_rate;
formats = ff_make_format_list(sample_rates); formats = ff_make_format_list(sample_rates);
if (!formats) if (!formats)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if ((ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0) if ((ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0)
return ret; return ret;
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if (!formats) if (!formats)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if ((ret = ff_formats_ref(formats, &magnitude->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &magnitude->outcfg.formats)) < 0)
return ret; return ret;
formats = ff_make_format_list(pix_fmts); formats = ff_make_format_list(pix_fmts);
if (!formats) if (!formats)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if ((ret = ff_formats_ref(formats, &phase->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &phase->outcfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

6
libavfilter/vf_alphamerge.c
View File

@ -103,12 +103,12 @@ static int query_formats(AVFilterContext *ctx)
AVFilterFormats *main_formats = ff_make_format_list(main_fmts); AVFilterFormats *main_formats = ff_make_format_list(main_fmts);
int ret; int ret;
if ((ret = ff_formats_ref(main_formats, &ctx->inputs[0]->out_formats)) < 0 || if ((ret = ff_formats_ref(main_formats, &ctx->inputs[0]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(main_formats, &ctx->outputs[0]->in_formats)) < 0) (ret = ff_formats_ref(main_formats, &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return ff_formats_ref(ff_make_format_list(alpha_fmts), return ff_formats_ref(ff_make_format_list(alpha_fmts),
&ctx->inputs[1]->out_formats); &ctx->inputs[1]->outcfg.formats);
} }
static int config_input_main(AVFilterLink *inlink) static int config_input_main(AVFilterLink *inlink)

4
libavfilter/vf_ciescope.c
View File

@ -139,10 +139,10 @@ static int query_formats(AVFilterContext *ctx)
{ {
int ret; int ret;
if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
return ret; return ret;
if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

4
libavfilter/vf_colorspace.c
View File

@ -896,7 +896,7 @@ static int query_formats(AVFilterContext *ctx)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if (s->user_format == AV_PIX_FMT_NONE) if (s->user_format == AV_PIX_FMT_NONE)
return ff_set_common_formats(ctx, formats); return ff_set_common_formats(ctx, formats);
res = ff_formats_ref(formats, &ctx->inputs[0]->out_formats); res = ff_formats_ref(formats, &ctx->inputs[0]->outcfg.formats);
if (res < 0) if (res < 0)
return res; return res;
formats = NULL; formats = NULL;
@ -904,7 +904,7 @@ static int query_formats(AVFilterContext *ctx)
if (res < 0) if (res < 0)
return res; return res;
return ff_formats_ref(formats, &ctx->outputs[0]->in_formats); return ff_formats_ref(formats, &ctx->outputs[0]->incfg.formats);
} }
static int config_props(AVFilterLink *outlink) static int config_props(AVFilterLink *outlink)

6
libavfilter/vf_coreimage.m
View File

@ -149,8 +149,8 @@ static int query_formats(AVFilterContext *fctx)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if ((ret = ff_formats_ref(inout_formats, &fctx->inputs[0]->out_formats)) < 0 || if ((ret = ff_formats_ref(inout_formats, &fctx->inputs[0]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(inout_formats, &fctx->outputs[0]->in_formats)) < 0) { (ret = ff_formats_ref(inout_formats, &fctx->outputs[0]->incfg.formats)) < 0) {
return ret; return ret;
} }
@ -171,7 +171,7 @@ static int query_formats_src(AVFilterContext *fctx)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if ((ret = ff_formats_ref(inout_formats, &fctx->outputs[0]->in_formats)) < 0) { if ((ret = ff_formats_ref(inout_formats, &fctx->outputs[0]->incfg.formats)) < 0) {
return ret; return ret;
} }

4
libavfilter/vf_elbg.c
View File

@ -100,8 +100,8 @@ static int query_formats(AVFilterContext *ctx)
AV_PIX_FMT_PAL8, AV_PIX_FMT_PAL8,
AV_PIX_FMT_NONE AV_PIX_FMT_NONE
}; };
if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts), &ctx->inputs[0]->out_formats)) < 0 || if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(ff_make_format_list(pal8_fmt), &ctx->outputs[0]->in_formats)) < 0) (ret = ff_formats_ref(ff_make_format_list(pal8_fmt), &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
} }
return 0; return 0;

12
libavfilter/vf_extractplanes.c
View File

@ -143,12 +143,12 @@ static int query_formats(AVFilterContext *ctx)
AVFilterFormats *avff; AVFilterFormats *avff;
int i, ret, depth = 0, be = 0; int i, ret, depth = 0, be = 0;
if (!ctx->inputs[0]->in_formats || if (!ctx->inputs[0]->incfg.formats ||
!ctx->inputs[0]->in_formats->nb_formats) { !ctx->inputs[0]->incfg.formats->nb_formats) {
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
} }
avff = ctx->inputs[0]->in_formats; avff = ctx->inputs[0]->incfg.formats;
desc = av_pix_fmt_desc_get(avff->formats[0]); desc = av_pix_fmt_desc_get(avff->formats[0]);
depth = desc->comp[0].depth; depth = desc->comp[0].depth;
be = desc->flags & AV_PIX_FMT_FLAG_BE; be = desc->flags & AV_PIX_FMT_FLAG_BE;
@ -157,8 +157,8 @@ static int query_formats(AVFilterContext *ctx)
} else { } else {
in_pixfmts = in_pixfmts_le; in_pixfmts = in_pixfmts_le;
} }
if (!ctx->inputs[0]->out_formats) if (!ctx->inputs[0]->outcfg.formats)
if ((ret = ff_formats_ref(ff_make_format_list(in_pixfmts), &ctx->inputs[0]->out_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(in_pixfmts), &ctx->inputs[0]->outcfg.formats)) < 0)
return ret; return ret;
for (i = 1; i < avff->nb_formats; i++) { for (i = 1; i < avff->nb_formats; i++) {
@ -193,7 +193,7 @@ static int query_formats(AVFilterContext *ctx)
out_pixfmts = out16le_pixfmts; out_pixfmts = out16le_pixfmts;
for (i = 0; i < ctx->nb_outputs; i++) for (i = 0; i < ctx->nb_outputs; i++)
if ((ret = ff_formats_ref(ff_make_format_list(out_pixfmts), &ctx->outputs[i]->in_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(out_pixfmts), &ctx->outputs[i]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;
} }

6
libavfilter/vf_fieldmatch.c
View File

@ -917,14 +917,14 @@ static int query_formats(AVFilterContext *ctx)
return ff_set_common_formats(ctx, fmts_list); return ff_set_common_formats(ctx, fmts_list);
} }
if ((ret = ff_formats_ref(fmts_list, &ctx->inputs[INPUT_MAIN]->out_formats)) < 0) if ((ret = ff_formats_ref(fmts_list, &ctx->inputs[INPUT_MAIN]->outcfg.formats)) < 0)
return ret; return ret;
fmts_list = ff_make_format_list(unproc_pix_fmts); fmts_list = ff_make_format_list(unproc_pix_fmts);
if (!fmts_list) if (!fmts_list)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
if ((ret = ff_formats_ref(fmts_list, &ctx->outputs[0]->in_formats)) < 0) if ((ret = ff_formats_ref(fmts_list, &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
if ((ret = ff_formats_ref(fmts_list, &ctx->inputs[INPUT_CLEANSRC]->out_formats)) < 0) if ((ret = ff_formats_ref(fmts_list, &ctx->inputs[INPUT_CLEANSRC]->outcfg.formats)) < 0)
return ret; return ret;
return 0; return 0;
} }

4
libavfilter/vf_fieldorder.c
View File

@ -58,8 +58,8 @@ static int query_formats(AVFilterContext *ctx)
(ret = ff_add_format(&formats, pix_fmt)) < 0) (ret = ff_add_format(&formats, pix_fmt)) < 0)
return ret; return ret;
} }
if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0 || if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0) (ret = ff_formats_ref(formats, &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
} }

12
libavfilter/vf_histogram.c
View File

@ -155,15 +155,15 @@ static int query_formats(AVFilterContext *ctx)
int rgb, i, bits; int rgb, i, bits;
int ret; int ret;
if (!ctx->inputs[0]->in_formats || if (!ctx->inputs[0]->incfg.formats ||
!ctx->inputs[0]->in_formats->nb_formats) { !ctx->inputs[0]->incfg.formats->nb_formats) {
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
} }
if (!ctx->inputs[0]->out_formats) if (!ctx->inputs[0]->outcfg.formats)
if ((ret = ff_formats_ref(ff_make_format_list(levels_in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(levels_in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
return ret; return ret;
avff = ctx->inputs[0]->in_formats; avff = ctx->inputs[0]->incfg.formats;
desc = av_pix_fmt_desc_get(avff->formats[0]); desc = av_pix_fmt_desc_get(avff->formats[0]);
rgb = desc->flags & AV_PIX_FMT_FLAG_RGB; rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
bits = desc->comp[0].depth; bits = desc->comp[0].depth;
@ -192,7 +192,7 @@ static int query_formats(AVFilterContext *ctx)
out_pix_fmts = levels_out_yuv12_pix_fmts; out_pix_fmts = levels_out_yuv12_pix_fmts;
else else
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

4
libavfilter/vf_hwdownload.c
View File

@ -41,9 +41,9 @@ static int hwdownload_query_formats(AVFilterContext *avctx)
int err; int err;
if ((err = ff_formats_pixdesc_filter(&fmts, AV_PIX_FMT_FLAG_HWACCEL, 0)) || if ((err = ff_formats_pixdesc_filter(&fmts, AV_PIX_FMT_FLAG_HWACCEL, 0)) ||
(err = ff_formats_ref(fmts, &avctx->inputs[0]->out_formats)) || (err = ff_formats_ref(fmts, &avctx->inputs[0]->outcfg.formats)) ||
(err = ff_formats_pixdesc_filter(&fmts, 0, AV_PIX_FMT_FLAG_HWACCEL)) || (err = ff_formats_pixdesc_filter(&fmts, 0, AV_PIX_FMT_FLAG_HWACCEL)) ||
(err = ff_formats_ref(fmts, &avctx->outputs[0]->in_formats))) (err = ff_formats_ref(fmts, &avctx->outputs[0]->incfg.formats)))
return err; return err;
return 0; return 0;

4
libavfilter/vf_hwmap.c
View File

@ -42,9 +42,9 @@ static int hwmap_query_formats(AVFilterContext *avctx)
int ret; int ret;
if ((ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO), if ((ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
&avctx->inputs[0]->out_formats)) < 0 || &avctx->inputs[0]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO), (ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),
&avctx->outputs[0]->in_formats)) < 0) &avctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

4
libavfilter/vf_hwupload.c
View File

@ -90,9 +90,9 @@ static int hwupload_query_formats(AVFilterContext *avctx)
} }
} }
if ((err = ff_formats_ref(input_formats, &avctx->inputs[0]->out_formats)) < 0 || if ((err = ff_formats_ref(input_formats, &avctx->inputs[0]->outcfg.formats)) < 0 ||
(err = ff_formats_ref(ff_make_format_list(output_pix_fmts), (err = ff_formats_ref(ff_make_format_list(output_pix_fmts),
&avctx->outputs[0]->in_formats)) < 0) &avctx->outputs[0]->incfg.formats)) < 0)
goto fail; goto fail;
av_hwframe_constraints_free(&constraints); av_hwframe_constraints_free(&constraints);

4
libavfilter/vf_hwupload_cuda.c
View File

@ -71,13 +71,13 @@ static int cudaupload_query_formats(AVFilterContext *ctx)
AVFilterFormats *in_fmts = ff_make_format_list(input_pix_fmts); AVFilterFormats *in_fmts = ff_make_format_list(input_pix_fmts);
AVFilterFormats *out_fmts; AVFilterFormats *out_fmts;
ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->out_formats); ret = ff_formats_ref(in_fmts, &ctx->inputs[0]->outcfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;
out_fmts = ff_make_format_list(output_pix_fmts); out_fmts = ff_make_format_list(output_pix_fmts);
ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->in_formats); ret = ff_formats_ref(out_fmts, &ctx->outputs[0]->incfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;

4
libavfilter/vf_lut2.c
View File

@ -177,7 +177,7 @@ static int query_formats(AVFilterContext *ctx)
if (s->tlut2 || !s->odepth) if (s->tlut2 || !s->odepth)
return ff_set_common_formats(ctx, ff_make_format_list(all_pix_fmts)); return ff_set_common_formats(ctx, ff_make_format_list(all_pix_fmts));
ret = ff_formats_ref(ff_make_format_list(all_pix_fmts), &ctx->inputs[0]->out_formats); ret = ff_formats_ref(ff_make_format_list(all_pix_fmts), &ctx->inputs[0]->outcfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -192,7 +192,7 @@ static int query_formats(AVFilterContext *ctx)
return AVERROR(EINVAL); return AVERROR(EINVAL);
} }
return ff_formats_ref(ff_make_format_list(pix_fmts), &ctx->outputs[0]->in_formats); return ff_formats_ref(ff_make_format_list(pix_fmts), &ctx->outputs[0]->incfg.formats);
} }
static int config_inputx(AVFilterLink *inlink) static int config_inputx(AVFilterLink *inlink)

4
libavfilter/vf_mergeplanes.c
View File

@ -122,12 +122,12 @@ static int query_formats(AVFilterContext *ctx)
} }
for (i = 0; i < s->nb_inputs; i++) for (i = 0; i < s->nb_inputs; i++)
if ((ret = ff_formats_ref(formats, &ctx->inputs[i]->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &ctx->inputs[i]->outcfg.formats)) < 0)
return ret; return ret;
formats = NULL; formats = NULL;
if ((ret = ff_add_format(&formats, s->out_fmt)) < 0 || if ((ret = ff_add_format(&formats, s->out_fmt)) < 0 ||
(ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0) (ret = ff_formats_ref(formats, &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

6
libavfilter/vf_overlay.c
View File

@ -261,12 +261,12 @@ static int query_formats(AVFilterContext *ctx)
} }
formats = ff_make_format_list(main_formats); formats = ff_make_format_list(main_formats);
if ((ret = ff_formats_ref(formats, &ctx->inputs[MAIN]->out_formats)) < 0 || if ((ret = ff_formats_ref(formats, &ctx->inputs[MAIN]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(formats, &ctx->outputs[MAIN]->in_formats)) < 0) (ret = ff_formats_ref(formats, &ctx->outputs[MAIN]->incfg.formats)) < 0)
return ret; return ret;
return ff_formats_ref(ff_make_format_list(overlay_formats), return ff_formats_ref(ff_make_format_list(overlay_formats),
&ctx->inputs[OVERLAY]->out_formats); &ctx->inputs[OVERLAY]->outcfg.formats);
} }
static int config_input_overlay(AVFilterLink *inlink) static int config_input_overlay(AVFilterLink *inlink)

4
libavfilter/vf_overlay_qsv.c
View File

@ -381,12 +381,12 @@ static int overlay_qsv_query_formats(AVFilterContext *ctx)
}; };
for (i = 0; i < ctx->nb_inputs; i++) { for (i = 0; i < ctx->nb_inputs; i++) {
ret = ff_formats_ref(ff_make_format_list(main_in_fmts), &ctx->inputs[i]->out_formats); ret = ff_formats_ref(ff_make_format_list(main_in_fmts), &ctx->inputs[i]->outcfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;
} }
ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats); ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;

4
libavfilter/vf_palettegen.c
View File

@ -99,9 +99,9 @@ static int query_formats(AVFilterContext *ctx)
static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE}; static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
int ret; int ret;
if ((ret = ff_formats_ref(ff_make_format_list(in_fmts) , &ctx->inputs[0]->out_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(in_fmts) , &ctx->inputs[0]->outcfg.formats)) < 0)
return ret; return ret;
if ((ret = ff_formats_ref(ff_make_format_list(out_fmts), &ctx->outputs[0]->in_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(out_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;
} }

6
libavfilter/vf_paletteuse.c
View File

@ -143,11 +143,11 @@ static int query_formats(AVFilterContext *ctx)
static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE}; static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE};
int ret; int ret;
if ((ret = ff_formats_ref(ff_make_format_list(in_fmts), if ((ret = ff_formats_ref(ff_make_format_list(in_fmts),
&ctx->inputs[0]->out_formats)) < 0 || &ctx->inputs[0]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(ff_make_format_list(inpal_fmts), (ret = ff_formats_ref(ff_make_format_list(inpal_fmts),
&ctx->inputs[1]->out_formats)) < 0 || &ctx->inputs[1]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(ff_make_format_list(out_fmts), (ret = ff_formats_ref(ff_make_format_list(out_fmts),
&ctx->outputs[0]->in_formats)) < 0) &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;
} }

8
libavfilter/vf_remap.c
View File

@ -116,14 +116,14 @@ static int query_formats(AVFilterContext *ctx)
int ret; int ret;
pix_formats = ff_make_format_list(s->format ? gray_pix_fmts : pix_fmts); pix_formats = ff_make_format_list(s->format ? gray_pix_fmts : pix_fmts);
if ((ret = ff_formats_ref(pix_formats, &ctx->inputs[0]->out_formats)) < 0 || if ((ret = ff_formats_ref(pix_formats, &ctx->inputs[0]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(pix_formats, &ctx->outputs[0]->in_formats)) < 0) (ret = ff_formats_ref(pix_formats, &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
map_formats = ff_make_format_list(map_fmts); map_formats = ff_make_format_list(map_fmts);
if ((ret = ff_formats_ref(map_formats, &ctx->inputs[1]->out_formats)) < 0) if ((ret = ff_formats_ref(map_formats, &ctx->inputs[1]->outcfg.formats)) < 0)
return ret; return ret;
return ff_formats_ref(map_formats, &ctx->inputs[2]->out_formats); return ff_formats_ref(map_formats, &ctx->inputs[2]->outcfg.formats);
} }
/** /**

4
libavfilter/vf_scale.c
View File

@ -358,7 +358,7 @@ static int query_formats(AVFilterContext *ctx)
return ret; return ret;
} }
} }
if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->out_formats)) < 0) if ((ret = ff_formats_ref(formats, &ctx->inputs[0]->outcfg.formats)) < 0)
return ret; return ret;
} }
if (ctx->outputs[0]) { if (ctx->outputs[0]) {
@ -372,7 +372,7 @@ static int query_formats(AVFilterContext *ctx)
return ret; return ret;
} }
} }
if ((ret = ff_formats_ref(formats, &ctx->outputs[0]->in_formats)) < 0) if ((ret = ff_formats_ref(formats, &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
} }

4
libavfilter/vf_showpalette.c
View File

@ -47,12 +47,12 @@ static int query_formats(AVFilterContext *ctx)
static const enum AVPixelFormat in_fmts[] = {AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE}; static const enum AVPixelFormat in_fmts[] = {AV_PIX_FMT_PAL8, AV_PIX_FMT_NONE};
static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE}; static const enum AVPixelFormat out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
int ret = ff_formats_ref(ff_make_format_list(in_fmts), int ret = ff_formats_ref(ff_make_format_list(in_fmts),
&ctx->inputs[0]->out_formats); &ctx->inputs[0]->outcfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;
return ff_formats_ref(ff_make_format_list(out_fmts), return ff_formats_ref(ff_make_format_list(out_fmts),
&ctx->outputs[0]->in_formats); &ctx->outputs[0]->incfg.formats);
} }
static int config_output(AVFilterLink *outlink) static int config_output(AVFilterLink *outlink)

12
libavfilter/vf_vectorscope.c
View File

@ -216,23 +216,23 @@ static int query_formats(AVFilterContext *ctx)
AVFilterFormats *avff; AVFilterFormats *avff;
int depth, rgb, i, ret; int depth, rgb, i, ret;
if (!ctx->inputs[0]->in_formats || if (!ctx->inputs[0]->incfg.formats ||
!ctx->inputs[0]->in_formats->nb_formats) { !ctx->inputs[0]->incfg.formats->nb_formats) {
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
} }
if (!ctx->inputs[0]->out_formats) { if (!ctx->inputs[0]->outcfg.formats) {
const enum AVPixelFormat *in_pix_fmts; const enum AVPixelFormat *in_pix_fmts;
if ((s->x == 1 && s->y == 2) || (s->x == 2 && s->y == 1)) if ((s->x == 1 && s->y == 2) || (s->x == 2 && s->y == 1))
in_pix_fmts = in2_pix_fmts; in_pix_fmts = in2_pix_fmts;
else else
in_pix_fmts = in1_pix_fmts; in_pix_fmts = in1_pix_fmts;
if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
return ret; return ret;
} }
avff = ctx->inputs[0]->in_formats; avff = ctx->inputs[0]->incfg.formats;
desc = av_pix_fmt_desc_get(avff->formats[0]); desc = av_pix_fmt_desc_get(avff->formats[0]);
rgb = desc->flags & AV_PIX_FMT_FLAG_RGB; rgb = desc->flags & AV_PIX_FMT_FLAG_RGB;
depth = desc->comp[0].depth; depth = desc->comp[0].depth;
@ -261,7 +261,7 @@ static int query_formats(AVFilterContext *ctx)
out_pix_fmts = out_yuv12_pix_fmts; out_pix_fmts = out_yuv12_pix_fmts;
else else
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

4
libavfilter/vf_vpp_qsv.c
View File

@ -505,11 +505,11 @@ static int query_formats(AVFilterContext *ctx)
}; };
ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), ret = ff_formats_ref(ff_make_format_list(in_pix_fmts),
&ctx->inputs[0]->out_formats); &ctx->inputs[0]->outcfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;
return ff_formats_ref(ff_make_format_list(out_pix_fmts), return ff_formats_ref(ff_make_format_list(out_pix_fmts),
&ctx->outputs[0]->in_formats); &ctx->outputs[0]->incfg.formats);
} }
static av_cold void vpp_uninit(AVFilterContext *ctx) static av_cold void vpp_uninit(AVFilterContext *ctx)

14
libavfilter/vf_waveform.c
View File

@ -319,8 +319,8 @@ static int query_formats(AVFilterContext *ctx)
AVFilterFormats *avff, *avff2; AVFilterFormats *avff, *avff2;
int depth, depth2, rgb, i, ret, ncomp, ncomp2; int depth, depth2, rgb, i, ret, ncomp, ncomp2;
if (!ctx->inputs[0]->in_formats || if (!ctx->inputs[0]->incfg.formats ||
!ctx->inputs[0]->in_formats->nb_formats) { !ctx->inputs[0]->incfg.formats->nb_formats) {
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
} }
@ -336,13 +336,13 @@ static int query_formats(AVFilterContext *ctx)
default: return AVERROR_BUG; default: return AVERROR_BUG;
} }
if (!ctx->inputs[0]->out_formats) { if (!ctx->inputs[0]->outcfg.formats) {
if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->out_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(in_pix_fmts), &ctx->inputs[0]->outcfg.formats)) < 0)
return ret; return ret;
} }
avff = ctx->inputs[0]->in_formats; avff = ctx->inputs[0]->incfg.formats;
avff2 = ctx->inputs[0]->out_formats; avff2 = ctx->inputs[0]->outcfg.formats;
desc = av_pix_fmt_desc_get(avff->formats[0]); desc = av_pix_fmt_desc_get(avff->formats[0]);
desc2 = av_pix_fmt_desc_get(avff2->formats[0]); desc2 = av_pix_fmt_desc_get(avff2->formats[0]);
ncomp = desc->nb_components; ncomp = desc->nb_components;
@ -385,7 +385,7 @@ static int query_formats(AVFilterContext *ctx)
out_pix_fmts = out_yuv12_lowpass_pix_fmts; out_pix_fmts = out_yuv12_lowpass_pix_fmts;
else else
return AVERROR(EAGAIN); return AVERROR(EAGAIN);
if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->in_formats)) < 0) if ((ret = ff_formats_ref(ff_make_format_list(out_pix_fmts), &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

4
libavfilter/vf_yadif_cuda.c
View File

@ -216,10 +216,10 @@ static int deint_cuda_query_formats(AVFilterContext *ctx)
int ret; int ret;
if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts), if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts),
&ctx->inputs[0]->out_formats)) < 0) &ctx->inputs[0]->outcfg.formats)) < 0)
return ret; return ret;
if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts), if ((ret = ff_formats_ref(ff_make_format_list(pix_fmts),
&ctx->outputs[0]->in_formats)) < 0) &ctx->outputs[0]->incfg.formats)) < 0)
return ret; return ret;
return 0; return 0;

4
libavfilter/vf_zscale.c
View File

@ -187,10 +187,10 @@ static int query_formats(AVFilterContext *ctx)
}; };
int ret; int ret;
ret = ff_formats_ref(ff_make_format_list(pixel_fmts), &ctx->inputs[0]->out_formats); ret = ff_formats_ref(ff_make_format_list(pixel_fmts), &ctx->inputs[0]->outcfg.formats);
if (ret < 0) if (ret < 0)
return ret; return ret;
return ff_formats_ref(ff_make_format_list(pixel_fmts), &ctx->outputs[0]->in_formats); return ff_formats_ref(ff_make_format_list(pixel_fmts), &ctx->outputs[0]->incfg.formats);
} }
static int config_props(AVFilterLink *outlink) static int config_props(AVFilterLink *outlink)