virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-01-08 13:22:53 +02:00
Code Issues Releases Activity

lavfi: regroup formats lists in a single structure.

Browse Source 
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
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;
if (eval->same_chlayout) {
@ -376,7 +376,7 @@ static int aeval_query_formats(AVFilterContext *ctx)
eval->out_channel_layout ? eval->out_channel_layout :
FF_COUNT2LAYOUT(eval->nb_channels))) < 0)
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;
}

8
libavfilter/af_afir.c
View File

@ -731,7 +731,7 @@ static int query_formats(AVFilterContext *ctx)
if (s->response) {
AVFilterLink *videolink = ctx->outputs[1];
formats = ff_make_format_list(pix_fmts);
if ((ret = ff_formats_ref(formats, &videolink->in_formats)) < 0)
if ((ret = ff_formats_ref(formats, &videolink->incfg.formats)) < 0)
return ret;
}
@ -746,16 +746,16 @@ static int query_formats(AVFilterContext *ctx)
} else {
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;
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;
ret = ff_add_channel_layout(&mono, AV_CH_LAYOUT_MONO);
if (ret)
return ret;
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;
}
}

10
libavfilter/af_agate.c
View File

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

2
libavfilter/af_aiir.c
View File

@ -95,7 +95,7 @@ static int query_formats(AVFilterContext *ctx)
AVFilterLink *videolink = ctx->outputs[1];
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;
}

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;
for (i = 0; i < s->nb_inputs; i++) {
if (!ctx->inputs[i]->in_channel_layouts ||
!ctx->inputs[i]->in_channel_layouts->nb_channel_layouts) {
if (!ctx->inputs[i]->incfg.channel_layouts ||
!ctx->inputs[i]->incfg.channel_layouts->nb_channel_layouts) {
av_log(ctx, AV_LOG_WARNING,
"No channel layout for input %d\n", i + 1);
return AVERROR(EAGAIN);
}
inlayout[i] = ctx->inputs[i]->in_channel_layouts->channel_layouts[0];
if (ctx->inputs[i]->in_channel_layouts->nb_channel_layouts > 1) {
inlayout[i] = ctx->inputs[i]->incfg.channel_layouts->channel_layouts[0];
if (ctx->inputs[i]->incfg.channel_layouts->nb_channel_layouts > 1) {
char buf[256];
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);
@ -136,13 +136,13 @@ static int query_formats(AVFilterContext *ctx)
layouts = NULL;
if ((ret = ff_add_channel_layout(&layouts, inlayout[i])) < 0)
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;
}
layouts = NULL;
if ((ret = ff_add_channel_layout(&layouts, outlayout)) < 0)
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 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) {
AVFilterLink *videolink = ctx->outputs[1];
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;
}
formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret;
layouts = ff_all_channel_counts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0)
if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0)
return ret;
formats = ff_all_samplerates();
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0)
if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0)
return ret;
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);
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;
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;
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;
if(out_rate > 0) {
@ -113,7 +113,7 @@ static int query_formats(AVFilterContext *ctx)
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;
if(out_format != AV_SAMPLE_FMT_NONE) {
@ -121,7 +121,7 @@ static int query_formats(AVFilterContext *ctx)
out_formats = ff_make_format_list(formatlist);
} else
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;
if(out_layout) {
@ -130,7 +130,7 @@ static int query_formats(AVFilterContext *ctx)
} else
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 };
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)

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_add_channel_layout(&channel_layouts, s->output_layout)) < 0 ||
(ret = ff_channel_layouts_ref(channel_layouts,
&ctx->outputs[0]->in_channel_layouts)) < 0)
&ctx->outputs[0]->incfg.channel_layouts)) < 0)
return ret;
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)

4
libavfilter/af_channelsplit.c
View File

@ -117,7 +117,7 @@ static int query_formats(AVFilterContext *ctx)
return ret;
if ((ret = ff_add_channel_layout(&in_layouts, s->channel_layout)) < 0 ||
(ret = ff_channel_layouts_ref(in_layouts, &ctx->inputs[0]->out_channel_layouts)) < 0)
(ret = ff_channel_layouts_ref(in_layouts, &ctx->inputs[0]->outcfg.channel_layouts)) < 0)
return ret;
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]);
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;
}

4
libavfilter/af_hdcd.c
View File

@ -1638,12 +1638,12 @@ static int query_formats(AVFilterContext *ctx)
return ret;
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)
return ret;
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)
return ret;

8
libavfilter/af_headphone.c
View File

@ -698,14 +698,14 @@ static int query_formats(AVFilterContext *ctx)
if (!layouts)
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)
return ret;
ret = ff_add_channel_layout(&stereo_layout, AV_CH_LAYOUT_STEREO);
if (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)
return ret;
@ -713,12 +713,12 @@ static int query_formats(AVFilterContext *ctx)
hrir_layouts = ff_all_channel_counts();
if (!hrir_layouts)
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)
return ret;
} else {
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)
return ret;
}

4
libavfilter/af_join.c
View File

@ -227,12 +227,12 @@ static int join_query_formats(AVFilterContext *ctx)
int i, ret;
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;
for (i = 0; i < ctx->nb_inputs; i++) {
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;
}

6
libavfilter/af_ladspa.c
View File

@ -714,12 +714,12 @@ static int query_formats(AVFilterContext *ctx)
ret = ff_add_channel_layout(&layouts, inlayout);
if (ret < 0)
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)
return ret;
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)
return ret;
}
@ -732,7 +732,7 @@ static int query_formats(AVFilterContext *ctx)
ret = ff_add_channel_layout(&layouts, outlayout);
if (ret < 0)
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)
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);
if (!formats)
return AVERROR(ENOMEM);
ret = ff_formats_ref(formats, &inlink->out_samplerates);
ret = ff_formats_ref(formats, &inlink->outcfg.samplerates);
if (ret < 0)
return ret;
ret = ff_formats_ref(formats, &outlink->in_samplerates);
ret = ff_formats_ref(formats, &outlink->incfg.samplerates);
if (ret < 0)
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);
if (ret < 0)
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)
return ret;
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)
return ret;
}
@ -542,7 +542,7 @@ static int query_formats(AVFilterContext *ctx)
ret = ff_add_channel_layout(&layouts, outlayout);
if (ret < 0)
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)
return ret;
}

4
libavfilter/af_pan.c
View File

@ -266,7 +266,7 @@ static int query_formats(AVFilterContext *ctx)
// inlink supports any channel layout
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;
// 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 :
FF_COUNT2LAYOUT(pan->nb_output_channels))) < 0)
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)

12
libavfilter/af_resample.c
View File

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

10
libavfilter/af_sidechaincompress.c
View File

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

4
libavfilter/af_sofalizer.c
View File

@ -652,7 +652,7 @@ static int query_formats(AVFilterContext *ctx)
if (!layouts)
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)
return ret;
@ -661,7 +661,7 @@ static int query_formats(AVFilterContext *ctx)
if (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)
return ret;

4
libavfilter/af_surround.c
View File

@ -175,7 +175,7 @@ static int query_formats(AVFilterContext *ctx)
if (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)
return ret;
@ -184,7 +184,7 @@ static int query_formats(AVFilterContext *ctx)
if (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)
return ret;

8
libavfilter/avf_abitscope.c
View File

@ -69,21 +69,21 @@ static int query_formats(AVFilterContext *ctx)
int ret;
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;
layouts = ff_all_channel_counts();
if (!layouts)
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;
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;
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 0;

8
libavfilter/avf_ahistogram.c
View File

@ -99,17 +99,17 @@ static int query_formats(AVFilterContext *ctx)
int ret = AVERROR(EINVAL);
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 ||
(ret = ff_channel_layouts_ref (layouts, &inlink->out_channel_layouts)) < 0)
(ret = ff_channel_layouts_ref (layouts, &inlink->outcfg.channel_layouts)) < 0)
return ret;
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;
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 0;

14
libavfilter/avf_aphasemeter.c
View File

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

8
libavfilter/avf_avectorscope.c
View File

@ -190,17 +190,17 @@ static int query_formats(AVFilterContext *ctx)
int ret;
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_channel_layouts_ref (layout , &inlink->out_channel_layouts)) < 0)
(ret = ff_channel_layouts_ref (layout , &inlink->outcfg.channel_layouts)) < 0)
return ret;
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;
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 0;

12
libavfilter/avf_concat.c
View File

@ -87,25 +87,25 @@ static int query_formats(AVFilterContext *ctx)
/* Set the output formats */
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;
if (type == AVMEDIA_TYPE_AUDIO) {
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;
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;
}
/* Set the same formats for each corresponding input */
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;
if (type == AVMEDIA_TYPE_AUDIO) {
if ((ret = ff_formats_ref(rates, &ctx->inputs[idx]->out_samplerates)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &ctx->inputs[idx]->out_channel_layouts)) < 0)
if ((ret = ff_formats_ref(rates, &ctx->inputs[idx]->outcfg.samplerates)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &ctx->inputs[idx]->outcfg.channel_layouts)) < 0)
return ret;
}
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 */
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;
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;
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;
/* set output video format */
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 0;

8
libavfilter/avf_showfreqs.c
View File

@ -132,20 +132,20 @@ static int query_formats(AVFilterContext *ctx)
/* set input audio formats */
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;
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;
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;
/* set output video format */
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 0;

8
libavfilter/avf_showspatial.c
View File

@ -114,17 +114,17 @@ static int query_formats(AVFilterContext *ctx)
int ret;
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_channel_layouts_ref (layout , &inlink->out_channel_layouts)) < 0)
(ret = ff_channel_layouts_ref (layout , &inlink->outcfg.channel_layouts)) < 0)
return ret;
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;
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 0;

8
libavfilter/avf_showspectrum.c
View File

@ -355,20 +355,20 @@ static int query_formats(AVFilterContext *ctx)
/* set input audio formats */
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;
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;
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;
/* set output video format */
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 0;

8
libavfilter/avf_showvolume.c
View File

@ -125,19 +125,19 @@ static int query_formats(AVFilterContext *ctx)
int ret;
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;
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;
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;
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 0;

8
libavfilter/avf_showwaves.c
View File

@ -161,20 +161,20 @@ static int query_formats(AVFilterContext *ctx)
/* set input audio formats */
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;
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;
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;
/* set output video format */
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 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
* link, we need to preserve that */
if (link->out_formats)
ff_formats_changeref(&link->out_formats,
&filt->outputs[filt_dstpad_idx]->out_formats);
if (link->out_samplerates)
ff_formats_changeref(&link->out_samplerates,
&filt->outputs[filt_dstpad_idx]->out_samplerates);
if (link->out_channel_layouts)
ff_channel_layouts_changeref(&link->out_channel_layouts,
&filt->outputs[filt_dstpad_idx]->out_channel_layouts);
if (link->outcfg.formats)
ff_formats_changeref(&link->outcfg.formats,
&filt->outputs[filt_dstpad_idx]->outcfg.formats);
if (link->outcfg.samplerates)
ff_formats_changeref(&link->outcfg.samplerates,
&filt->outputs[filt_dstpad_idx]->outcfg.samplerates);
if (link->outcfg.channel_layouts)
ff_channel_layouts_changeref(&link->outcfg.channel_layouts,
&filt->outputs[filt_dstpad_idx]->outcfg.channel_layouts);
return 0;
}
@ -746,12 +746,12 @@ static void free_link(AVFilterLink *link)
av_buffer_unref(&link->hw_frames_ctx);
ff_formats_unref(&link->in_formats);
ff_formats_unref(&link->out_formats);
ff_formats_unref(&link->in_samplerates);
ff_formats_unref(&link->out_samplerates);
ff_channel_layouts_unref(&link->in_channel_layouts);
ff_channel_layouts_unref(&link->out_channel_layouts);
ff_formats_unref(&link->incfg.formats);
ff_formats_unref(&link->outcfg.formats);
ff_formats_unref(&link->incfg.samplerates);
ff_formats_unref(&link->outcfg.samplerates);
ff_channel_layouts_unref(&link->incfg.channel_layouts);
ff_channel_layouts_unref(&link->outcfg.channel_layouts);
avfilter_link_free(&link);
}

64
libavfilter/avfilter.h
View File

@ -68,6 +68,7 @@ typedef struct AVFilterContext AVFilterContext;
typedef struct AVFilterLink AVFilterLink;
typedef struct AVFilterPad AVFilterPad;
typedef struct AVFilterFormats AVFilterFormats;
typedef struct AVFilterChannelLayouts AVFilterChannelLayouts;
/**
* 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
* callback may be called more than once.
*
* This callback must set AVFilterLink.out_formats on every input link and
* AVFilterLink.in_formats on every output link to a list of pixel/sample
* This callback must set AVFilterLink.outcfg.formats on every input link and
* 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
* filter must also set @ref AVFilterLink.in_samplerates "in_samplerates" /
* @ref AVFilterLink.out_samplerates "out_samplerates" and
* @ref AVFilterLink.in_channel_layouts "in_channel_layouts" /
* @ref AVFilterLink.out_channel_layouts "out_channel_layouts" analogously.
* filter must also set @ref AVFilterLink.incfg.samplerates "in_samplerates" /
* @ref AVFilterLink.outcfg.samplerates "out_samplerates" and
* @ref AVFilterLink.incfg.channel_layouts "in_channel_layouts" /
* @ref AVFilterLink.outcfg.channel_layouts "out_channel_layouts" analogously.
*
* This callback may be NULL for filters with one input, in which case
* libavfilter assumes that it supports all input formats and preserves
@ -424,6 +425,35 @@ struct AVFilterContext {
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
* 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.
*****************************************************************
*/
/**
* 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
* negotiation.
* Lists of supported formats / etc. supported by the input filter.
*/
AVFilterFormats *in_samplerates;
AVFilterFormats *out_samplerates;
struct AVFilterChannelLayouts *in_channel_layouts;
struct AVFilterChannelLayouts *out_channel_layouts;
AVFilterFormatsConfig incfg;
/**
* Lists of supported formats / etc. supported by the output filter.
*/
AVFilterFormatsConfig outcfg;
/** stage of the initialization of the link properties (dimensions, etc) */
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++)
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++)
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);
if ((ret = ff_set_common_formats(ctx, formats)) < 0)
@ -354,19 +354,19 @@ static int formats_declared(AVFilterContext *f)
int i;
for (i = 0; i < f->nb_inputs; i++) {
if (!f->inputs[i]->out_formats)
if (!f->inputs[i]->outcfg.formats)
return 0;
if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
!(f->inputs[i]->out_samplerates &&
f->inputs[i]->out_channel_layouts))
!(f->inputs[i]->outcfg.samplerates &&
f->inputs[i]->outcfg.channel_layouts))
return 0;
}
for (i = 0; i < f->nb_outputs; i++) {
if (!f->outputs[i]->in_formats)
if (!f->outputs[i]->incfg.formats)
return 0;
if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
!(f->outputs[i]->in_samplerates &&
f->outputs[i]->in_channel_layouts))
!(f->outputs[i]->incfg.samplerates &&
f->outputs[i]->incfg.channel_layouts))
return 0;
}
return 1;
@ -416,24 +416,24 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
if (!link)
continue;
if (link->in_formats != link->out_formats
&& link->in_formats && link->out_formats)
if (!ff_can_merge_formats(link->in_formats, link->out_formats,
if (link->incfg.formats != link->outcfg.formats
&& link->incfg.formats && link->outcfg.formats)
if (!ff_can_merge_formats(link->incfg.formats, link->outcfg.formats,
link->type))
convert_needed = 1;
if (link->type == AVMEDIA_TYPE_AUDIO) {
if (link->in_samplerates != link->out_samplerates
&& link->in_samplerates && link->out_samplerates)
if (!ff_can_merge_samplerates(link->in_samplerates,
link->out_samplerates))
if (link->incfg.samplerates != link->outcfg.samplerates
&& link->incfg.samplerates && link->outcfg.samplerates)
if (!ff_can_merge_samplerates(link->incfg.samplerates,
link->outcfg.samplerates))
convert_needed = 1;
}
#define CHECKED_MERGE(field, ...) ((ret = ff_merge_ ## field(__VA_ARGS__)) <= 0)
#define MERGE_DISPATCH(field, ...) \
if (!(link->in_ ## field && link->out_ ## field)) { \
if (!(link->incfg.field && link->outcfg.field)) { \
count_delayed++; \
} else if (link->in_ ## field == link->out_ ## field) { \
} else if (link->incfg.field == link->outcfg.field) { \
count_already_merged++; \
} else if (!convert_needed) { \
count_merged++; \
@ -445,13 +445,13 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
}
if (link->type == AVMEDIA_TYPE_AUDIO) {
MERGE_DISPATCH(channel_layouts, link->in_channel_layouts,
link->out_channel_layouts)
MERGE_DISPATCH(samplerates, link->in_samplerates,
link->out_samplerates)
MERGE_DISPATCH(channel_layouts, link->incfg.channel_layouts,
link->outcfg.channel_layouts)
MERGE_DISPATCH(samplerates, link->incfg.samplerates,
link->outcfg.samplerates)
}
MERGE_DISPATCH(formats, link->in_formats,
link->out_formats, link->type)
MERGE_DISPATCH(formats, link->incfg.formats,
link->outcfg.formats, link->type)
#undef MERGE_DISPATCH
if (convert_needed) {
@ -511,34 +511,34 @@ static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
inlink = convert->inputs[0];
outlink = convert->outputs[0];
av_assert0( inlink-> in_formats->refcount > 0);
av_assert0( inlink->out_formats->refcount > 0);
av_assert0(outlink-> in_formats->refcount > 0);
av_assert0(outlink->out_formats->refcount > 0);
av_assert0( inlink->incfg.formats->refcount > 0);
av_assert0( inlink->outcfg.formats->refcount > 0);
av_assert0(outlink->incfg.formats->refcount > 0);
av_assert0(outlink->outcfg.formats->refcount > 0);
if (outlink->type == AVMEDIA_TYPE_AUDIO) {
av_assert0( inlink-> in_samplerates->refcount > 0);
av_assert0( inlink->out_samplerates->refcount > 0);
av_assert0(outlink-> in_samplerates->refcount > 0);
av_assert0(outlink->out_samplerates->refcount > 0);
av_assert0( inlink-> in_channel_layouts->refcount > 0);
av_assert0( inlink->out_channel_layouts->refcount > 0);
av_assert0(outlink-> in_channel_layouts->refcount > 0);
av_assert0(outlink->out_channel_layouts->refcount > 0);
av_assert0( inlink-> incfg.samplerates->refcount > 0);
av_assert0( inlink->outcfg.samplerates->refcount > 0);
av_assert0(outlink-> incfg.samplerates->refcount > 0);
av_assert0(outlink->outcfg.samplerates->refcount > 0);
av_assert0( inlink-> incfg.channel_layouts->refcount > 0);
av_assert0( inlink->outcfg.channel_layouts->refcount > 0);
av_assert0(outlink-> incfg.channel_layouts->refcount > 0);
av_assert0(outlink->outcfg.channel_layouts->refcount > 0);
}
if (CHECKED_MERGE(formats, inlink->in_formats,
inlink->out_formats, inlink->type) ||
CHECKED_MERGE(formats, outlink->in_formats,
outlink->out_formats, outlink->type) ||
if (CHECKED_MERGE(formats, inlink->incfg.formats,
inlink->outcfg.formats, inlink->type) ||
CHECKED_MERGE(formats, outlink->incfg.formats,
outlink->outcfg.formats, outlink->type) ||
inlink->type == AVMEDIA_TYPE_AUDIO &&
(CHECKED_MERGE(samplerates, inlink->in_samplerates,
inlink->out_samplerates) ||
CHECKED_MERGE(channel_layouts, inlink->in_channel_layouts,
inlink->out_channel_layouts)) ||
(CHECKED_MERGE(samplerates, inlink->incfg.samplerates,
inlink->outcfg.samplerates) ||
CHECKED_MERGE(channel_layouts, inlink->incfg.channel_layouts,
inlink->outcfg.channel_layouts)) ||
outlink->type == AVMEDIA_TYPE_AUDIO &&
(CHECKED_MERGE(samplerates, outlink->in_samplerates,
outlink->out_samplerates) ||
CHECKED_MERGE(channel_layouts, outlink->in_channel_layouts,
outlink->out_channel_layouts))) {
(CHECKED_MERGE(samplerates, outlink->incfg.samplerates,
outlink->outcfg.samplerates) ||
CHECKED_MERGE(channel_layouts, outlink->incfg.channel_layouts,
outlink->outcfg.channel_layouts))) {
if (ret < 0)
return ret;
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)
{
if (!link || !link->in_formats)
if (!link || !link->incfg.formats)
return 0;
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;
enum AVPixelFormat best= AV_PIX_FMT_NONE;
int i;
for (i=0; i<link->in_formats->nb_formats; i++) {
enum AVPixelFormat p = link->in_formats->formats[i];
for (i = 0; i < link->incfg.formats->nb_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);
}
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);
link->in_formats->formats[0] = best;
link->incfg.formats->formats[0] = best;
}
} else if (link->type == AVMEDIA_TYPE_AUDIO) {
if(ref && ref->type == AVMEDIA_TYPE_AUDIO){
enum AVSampleFormat best= AV_SAMPLE_FMT_NONE;
int i;
for (i=0; i<link->in_formats->nb_formats; i++) {
enum AVSampleFormat p = link->in_formats->formats[i];
for (i = 0; i < link->incfg.formats->nb_formats; i++) {
enum AVSampleFormat p = link->incfg.formats->formats[i];
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_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));
link->in_formats->formats[0] = best;
link->incfg.formats->formats[0] = best;
}
}
link->in_formats->nb_formats = 1;
link->format = link->in_formats->formats[0];
link->incfg.formats->nb_formats = 1;
link->format = link->incfg.formats->formats[0];
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"
" the link between filters %s and %s.\n", link->src->name,
link->dst->name);
return AVERROR(EINVAL);
}
link->in_samplerates->nb_formats = 1;
link->sample_rate = link->in_samplerates->formats[0];
link->incfg.samplerates->nb_formats = 1;
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"
" the link between filters %s and %s.\n", link->src->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 "
"supported, try specifying a channel layout using "
"'aformat=channel_layouts=something'.\n");
return AVERROR(EINVAL);
}
link->in_channel_layouts->nb_channel_layouts = 1;
link->channel_layout = link->in_channel_layouts->channel_layouts[0];
link->incfg.channel_layouts->nb_channel_layouts = 1;
link->channel_layout = link->incfg.channel_layouts->channel_layouts[0];
if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
link->channel_layout = 0;
else
link->channels = av_get_channel_layout_nb_channels(link->channel_layout);
}
ff_formats_unref(&link->in_formats);
ff_formats_unref(&link->out_formats);
ff_formats_unref(&link->in_samplerates);
ff_formats_unref(&link->out_samplerates);
ff_channel_layouts_unref(&link->in_channel_layouts);
ff_channel_layouts_unref(&link->out_channel_layouts);
ff_formats_unref(&link->incfg.formats);
ff_formats_unref(&link->outcfg.formats);
ff_formats_unref(&link->incfg.samplerates);
ff_formats_unref(&link->outcfg.samplerates);
ff_channel_layouts_unref(&link->incfg.channel_layouts);
ff_channel_layouts_unref(&link->outcfg.channel_layouts);
return 0;
}
@ -693,27 +693,27 @@ do { \
AVFilterLink *link = filter->inputs[i]; \
fmt_type fmt; \
\
if (!link->out_ ## list || link->out_ ## list->nb != 1) \
if (!link->outcfg.list || link->outcfg.list->nb != 1) \
continue; \
fmt = link->out_ ## list->var[0]; \
fmt = link->outcfg.list->var[0]; \
\
for (j = 0; j < filter->nb_outputs; j++) { \
AVFilterLink *out_link = filter->outputs[j]; \
list_type *fmts; \
\
if (link->type != out_link->type || \
out_link->in_ ## list->nb == 1) \
out_link->incfg.list->nb == 1) \
continue; \
fmts = out_link->in_ ## list; \
fmts = out_link->incfg.list; \
\
if (!out_link->in_ ## list->nb) { \
if ((ret = add_format(&out_link->in_ ##list, fmt)) < 0)\
if (!out_link->incfg.list->nb) { \
if ((ret = add_format(&out_link->incfg.list, fmt)) < 0)\
return ret; \
ret = 1; \
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) { \
fmts->var[0] = fmt; \
fmts->nb = 1; \
@ -738,16 +738,16 @@ static int reduce_formats_on_filter(AVFilterContext *filter)
AVFilterLink *inlink = filter->inputs[i];
uint64_t fmt;
if (!inlink->out_channel_layouts ||
inlink->out_channel_layouts->nb_channel_layouts != 1)
if (!inlink->outcfg.channel_layouts ||
inlink->outcfg.channel_layouts->nb_channel_layouts != 1)
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++) {
AVFilterLink *outlink = filter->outputs[j];
AVFilterChannelLayouts *fmts;
fmts = outlink->in_channel_layouts;
fmts = outlink->incfg.channel_layouts;
if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
continue;
@ -755,12 +755,12 @@ static int reduce_formats_on_filter(AVFilterContext *filter)
(!FF_LAYOUT2COUNT(fmt) || fmts->all_counts)) {
/* Turn the infinite list into a singleton */
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;
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) {
fmts->channel_layouts[0] = fmt;
fmts->nb_channel_layouts = 1;
@ -801,24 +801,24 @@ static void swap_samplerates_on_filter(AVFilterContext *filter)
link = filter->inputs[i];
if (link->type == AVMEDIA_TYPE_AUDIO &&
link->out_samplerates->nb_formats== 1)
link->outcfg.samplerates->nb_formats== 1)
break;
}
if (i == filter->nb_inputs)
return;
sample_rate = link->out_samplerates->formats[0];
sample_rate = link->outcfg.samplerates->formats[0];
for (i = 0; i < filter->nb_outputs; i++) {
AVFilterLink *outlink = filter->outputs[i];
int best_idx, best_diff = INT_MAX;
if (outlink->type != AVMEDIA_TYPE_AUDIO ||
outlink->in_samplerates->nb_formats < 2)
outlink->incfg.samplerates->nb_formats < 2)
continue;
for (j = 0; j < outlink->in_samplerates->nb_formats; j++) {
int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
for (j = 0; j < outlink->incfg.samplerates->nb_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
@ -827,8 +827,8 @@ static void swap_samplerates_on_filter(AVFilterContext *filter)
best_idx = j;
}
}
FFSWAP(int, outlink->in_samplerates->formats[0],
outlink->in_samplerates->formats[best_idx]);
FFSWAP(int, outlink->incfg.samplerates->formats[0],
outlink->incfg.samplerates->formats[best_idx]);
}
}
@ -883,7 +883,7 @@ static void swap_channel_layouts_on_filter(AVFilterContext *filter)
link = filter->inputs[i];
if (link->type == AVMEDIA_TYPE_AUDIO &&
link->out_channel_layouts->nb_channel_layouts == 1)
link->outcfg.channel_layouts->nb_channel_layouts == 1)
break;
}
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;
if (outlink->type != AVMEDIA_TYPE_AUDIO ||
outlink->in_channel_layouts->nb_channel_layouts < 2)
outlink->incfg.channel_layouts->nb_channel_layouts < 2)
continue;
for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) {
uint64_t in_chlayout = link->out_channel_layouts->channel_layouts[0];
uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j];
for (j = 0; j < outlink->incfg.channel_layouts->nb_channel_layouts; j++) {
uint64_t in_chlayout = link->outcfg.channel_layouts->channel_layouts[0];
uint64_t out_chlayout = outlink->incfg.channel_layouts->channel_layouts[j];
int in_channels = av_get_channel_layout_nb_channels(in_chlayout);
int out_channels = av_get_channel_layout_nb_channels(out_chlayout);
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);
FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0],
outlink->in_channel_layouts->channel_layouts[best_idx]);
FFSWAP(uint64_t, outlink->incfg.channel_layouts->channel_layouts[0],
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];
if (link->type == AVMEDIA_TYPE_AUDIO &&
link->out_formats->nb_formats == 1)
link->outcfg.formats->nb_formats == 1)
break;
}
if (i == filter->nb_inputs)
return;
format = link->out_formats->formats[0];
format = link->outcfg.formats->formats[0];
bps = av_get_bytes_per_sample(format);
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;
if (outlink->type != AVMEDIA_TYPE_AUDIO ||
outlink->in_formats->nb_formats < 2)
outlink->incfg.formats->nb_formats < 2)
continue;
for (j = 0; j < outlink->in_formats->nb_formats; j++) {
int out_format = outlink->in_formats->formats[j];
for (j = 0; j < outlink->incfg.formats->nb_formats; j++) {
int out_format = outlink->incfg.formats->formats[j];
int out_bps = av_get_bytes_per_sample(out_format);
int score;
@ -1026,8 +1026,8 @@ static void swap_sample_fmts_on_filter(AVFilterContext *filter)
}
}
av_assert0(best_idx >= 0);
FFSWAP(int, outlink->in_formats->formats[0],
outlink->in_formats->formats[best_idx]);
FFSWAP(int, outlink->incfg.formats->formats[0],
outlink->incfg.formats->formats[best_idx]);
}
}
@ -1051,7 +1051,7 @@ static int pick_formats(AVFilterGraph *graph)
AVFilterContext *filter = graph->filters[i];
if (filter->nb_inputs){
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)
return ret;
change = 1;
@ -1060,7 +1060,7 @@ static int pick_formats(AVFilterGraph *graph)
}
if (filter->nb_outputs){
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)
return ret;
change = 1;
@ -1069,7 +1069,7 @@ static int pick_formats(AVFilterGraph *graph)
}
if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
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)
return ret;
change = 1;

2
libavfilter/f_drawgraph.c
View File

@ -134,7 +134,7 @@ static int query_formats(AVFilterContext *ctx)
int ret;
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 0;

14
libavfilter/f_ebur128.c
View File

@ -902,7 +902,7 @@ static int query_formats(AVFilterContext *ctx)
/* set optional output video format */
if (ebur128->do_video) {
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;
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
* links, and thus break the video format negotiation */
formats = ff_make_format_list(sample_fmts);
if ((ret = ff_formats_ref(formats, &inlink->out_formats)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_formats)) < 0)
if ((ret = ff_formats_ref(formats, &inlink->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->incfg.formats)) < 0)
return ret;
layouts = ff_all_channel_layouts();
if ((ret = ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts)) < 0)
if ((ret = ff_channel_layouts_ref(layouts, &inlink->outcfg.channel_layouts)) < 0 ||
(ret = ff_channel_layouts_ref(layouts, &outlink->incfg.channel_layouts)) < 0)
return ret;
formats = ff_make_format_list(input_srate);
if ((ret = ff_formats_ref(formats, &inlink->out_samplerates)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->in_samplerates)) < 0)
if ((ret = ff_formats_ref(formats, &inlink->outcfg.samplerates)) < 0 ||
(ret = ff_formats_ref(formats, &outlink->incfg.samplerates)) < 0)
return ret;
return 0;

2
libavfilter/f_graphmonitor.c
View File

@ -103,7 +103,7 @@ static int query_formats(AVFilterContext *ctx)
int ret;
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 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,
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);
}
int ff_set_common_samplerates(AVFilterContext *ctx,
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);
}
@ -587,7 +587,7 @@ int ff_set_common_samplerates(AVFilterContext *ctx,
*/
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);
}

8
libavfilter/src_movie.c
View File

@ -362,19 +362,19 @@ static int movie_query_formats(AVFilterContext *ctx)
switch (c->codec_type) {
case AVMEDIA_TYPE_VIDEO:
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;
break;
case AVMEDIA_TYPE_AUDIO:
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;
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;
list64[0] = c->channel_layout;
if ((ret = ff_channel_layouts_ref(ff_make_format64_list(list64),
&outlink->in_channel_layouts)) < 0)
&outlink->incfg.channel_layouts)) < 0)
return ret;
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++) { \
if (filter_ctx->inout##puts[i]->type == AVMEDIA_TYPE_VIDEO) { \
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++) \
if(av_get_pix_fmt_name(fmts->formats[j])) \
printf(#INOUT "PUT[%d] %s: fmt:%s\n", \
@ -50,13 +50,13 @@ static void print_formats(AVFilterContext *filter_ctx)
AVFilterFormats *fmts; \
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++) \
printf(#INOUT "PUT[%d] %s: fmt:%s\n", \
i, avfilter_pad_get_name(filter_ctx->inout##put_pads, i), \
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++) { \
char buf[256]; \
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;
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;
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 0;

10
libavfilter/vaf_spectrumsynth.c
View File

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

4
libavfilter/vf_ciescope.c
View File

@ -139,10 +139,10 @@ static int query_formats(AVFilterContext *ctx)
{
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;
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 0;

4
libavfilter/vf_colorspace.c
View File

@ -896,7 +896,7 @@ static int query_formats(AVFilterContext *ctx)
return AVERROR(ENOMEM);
if (s->user_format == AV_PIX_FMT_NONE)
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)
return res;
formats = NULL;
@ -904,7 +904,7 @@ static int query_formats(AVFilterContext *ctx)
if (res < 0)
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)

6
libavfilter/vf_coreimage.m
View File

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

4
libavfilter/vf_elbg.c
View File

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

12
libavfilter/vf_extractplanes.c
View File

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

12
libavfilter/vf_histogram.c
View File

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

4
libavfilter/vf_hwdownload.c
View File

@ -41,9 +41,9 @@ static int hwdownload_query_formats(AVFilterContext *avctx)
int err;
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_ref(fmts, &avctx->outputs[0]->in_formats)))
(err = ff_formats_ref(fmts, &avctx->outputs[0]->incfg.formats)))
return err;
return 0;

4
libavfilter/vf_hwmap.c
View File

@ -42,9 +42,9 @@ static int hwmap_query_formats(AVFilterContext *avctx)
int ret;
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),
&avctx->outputs[0]->in_formats)) < 0)
&avctx->outputs[0]->incfg.formats)) < 0)
return ret;
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),
&avctx->outputs[0]->in_formats)) < 0)
&avctx->outputs[0]->incfg.formats)) < 0)
goto fail;
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 *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)
return ret;
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)
return ret;

4
libavfilter/vf_lut2.c
View File

@ -177,7 +177,7 @@ static int query_formats(AVFilterContext *ctx)
if (s->tlut2 || !s->odepth)
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)
return ret;
@ -192,7 +192,7 @@ static int query_formats(AVFilterContext *ctx)
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)

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++)
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;
formats = NULL;
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 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);
if ((ret = ff_formats_ref(formats, &ctx->inputs[MAIN]->out_formats)) < 0 ||
(ret = ff_formats_ref(formats, &ctx->outputs[MAIN]->in_formats)) < 0)
if ((ret = ff_formats_ref(formats, &ctx->inputs[MAIN]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(formats, &ctx->outputs[MAIN]->incfg.formats)) < 0)
return ret;
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)

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++) {
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)
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)
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};
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;
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 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};
int ret;
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),
&ctx->inputs[1]->out_formats)) < 0 ||
&ctx->inputs[1]->outcfg.formats)) < 0 ||
(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 0;
}

8
libavfilter/vf_remap.c
View File

@ -116,14 +116,14 @@ static int query_formats(AVFilterContext *ctx)
int ret;
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 ||
(ret = ff_formats_ref(pix_formats, &ctx->outputs[0]->in_formats)) < 0)
if ((ret = ff_formats_ref(pix_formats, &ctx->inputs[0]->outcfg.formats)) < 0 ||
(ret = ff_formats_ref(pix_formats, &ctx->outputs[0]->incfg.formats)) < 0)
return ret;
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 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;
}
}
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;
}
if (ctx->outputs[0]) {
@ -372,7 +372,7 @@ static int query_formats(AVFilterContext *ctx)
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;
}

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 out_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};
int ret = ff_formats_ref(ff_make_format_list(in_fmts),
&ctx->inputs[0]->out_formats);
&ctx->inputs[0]->outcfg.formats);
if (ret < 0)
return ret;
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)

12
libavfilter/vf_vectorscope.c
View File

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

14
libavfilter/vf_waveform.c
View File

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

4
libavfilter/vf_yadif_cuda.c
View File

@ -216,10 +216,10 @@ static int deint_cuda_query_formats(AVFilterContext *ctx)
int ret;
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;
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 0;

4
libavfilter/vf_zscale.c
View File

@ -187,10 +187,10 @@ static int query_formats(AVFilterContext *ctx)
};
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)
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)