avfilter: handle error in query_formats() in bunch of filters

Paul B Mahol committed 11 years ago

Commit a0854c01 parent 21e034a81 files · +401 −234Browse files

Unified · Split

81 files

libavfilter/aeval.c +20 −4
libavfilter/af_adelay.c +8 −5
libavfilter/af_aecho.c +8 −5
libavfilter/af_afade.c +8 −5
libavfilter/af_aformat.c +8 −5
libavfilter/af_amix.c +8 −4
libavfilter/af_aphaser.c +8 −5
libavfilter/af_asetrate.c +1 −2
libavfilter/af_astats.c +8 −5
libavfilter/af_atempo.c +8 −5
libavfilter/af_biquads.c +8 −5
libavfilter/af_bs2b.c +8 −5
libavfilter/af_compand.c +8 −5
libavfilter/af_dcshift.c +8 −5
libavfilter/af_flanger.c +8 −5
libavfilter/af_silencedetect.c +8 −5
libavfilter/af_silenceremove.c +8 −5
libavfilter/af_volume.c +8 −5
libavfilter/af_volumedetect.c +1 −3
libavfilter/asrc_sine.c +21 −4
libavfilter/vf_bbox.c +4 −2
libavfilter/vf_blackdetect.c +4 −2
libavfilter/vf_blackframe.c +4 −2
libavfilter/vf_blend.c +4 −2
libavfilter/vf_boxblur.c +1 −2
libavfilter/vf_colorchannelmixer.c +4 −2
libavfilter/vf_colorlevels.c +4 −2
libavfilter/vf_crop.c +1 −2
libavfilter/vf_cropdetect.c +4 −2
libavfilter/vf_detelecine.c +1 −2
libavfilter/vf_drawtext.c +1 −2
libavfilter/vf_fade.c +6 −3
libavfilter/vf_fftfilt.c +4 −3
libavfilter/vf_format.c +1 −2
libavfilter/vf_framepack.c +4 −2
libavfilter/vf_frei0r.c +1 −2
libavfilter/vf_fspp.c +5 −2
libavfilter/vf_geq.c +7 −3
libavfilter/vf_hflip.c +1 −2
libavfilter/vf_histogram.c +5 −3
libavfilter/vf_il.c +1 −2
libavfilter/vf_interlace.c +4 −2
libavfilter/vf_kerndeint.c +4 −3
libavfilter/vf_noise.c +1 −2
libavfilter/vf_pad.c +1 −2
libavfilter/vf_perspective.c +4 −2
libavfilter/vf_phase.c +4 −2
libavfilter/vf_pp.c +5 −2
libavfilter/vf_pp7.c +5 −2
libavfilter/vf_psnr.c +4 −2
libavfilter/vf_pullup.c +5 −2
libavfilter/vf_removelogo.c +4 −2
libavfilter/vf_repeatfields.c +4 −3
libavfilter/vf_rotate.c +4 −2
libavfilter/vf_sab.c +4 −3
libavfilter/vf_signalstats.c +4 −2
libavfilter/vf_smartblur.c +4 −3
libavfilter/vf_spp.c +5 −2
libavfilter/vf_stereo3d.c +5 −3
libavfilter/vf_subtitles.c +1 −2
libavfilter/vf_super2xsai.c +4 −2
libavfilter/vf_swapuv.c +1 −2
libavfilter/vf_telecine.c +1 −2
libavfilter/vf_thumbnail.c +4 −2
libavfilter/vf_tile.c +1 −2
libavfilter/vf_tinterlace.c +4 −2
libavfilter/vf_transpose.c +1 −2
libavfilter/vf_unsharp.c +4 −3
libavfilter/vf_uspp.c +5 −2
libavfilter/vf_vidstabdetect.c +4 −2
libavfilter/vf_vidstabtransform.c +4 −2
libavfilter/vf_vignette.c +4 −2
libavfilter/vf_w3fdif.c +4 −3
libavfilter/vf_xbr.c +4 −2
libavfilter/vf_yadif.c +4 −3
libavfilter/vf_zoompan.c +4 −3
libavfilter/vsrc_cellauto.c +4 −2
libavfilter/vsrc_life.c +5 −1
libavfilter/vsrc_mandelbrot.c +4 −2
libavfilter/vsrc_mptestsrc.c +4 −2
libavfilter/vsrc_testsrc.c +21 −10

@@ -247,12 +247,28 @@ static int query_formats(AVFilterContext *ctx) · 246 unmodified lines
247	247	static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE };
248	248	int64_t chlayouts[] = { eval->chlayout ? eval->chlayout : FF_COUNT2LAYOUT(eval->nb_channels) , -1 };
249	249	int sample_rates[] = { eval->sample_rate, -1 };
	250	+ AVFilterFormats *formats;
	251	+ AVFilterChannelLayouts *layouts;
	252	+ int ret;
	253	+
	254	+ formats = ff_make_format_list(sample_fmts);
	255	+ if (!formats)
	256	+ return AVERROR(ENOMEM);
	257	+ ret = ff_set_common_formats (ctx, formats);
	258	+ if (ret < 0)
	259	+ return ret;
250	260
251		− ff_set_common_formats (ctx, ff_make_format_list(sample_fmts));
252		− ff_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));
253		− ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates));
	261	+ layouts = avfilter_make_format64_list(chlayouts);
	262	+ if (!layouts)
	263	+ return AVERROR(ENOMEM);
	264	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	265	+ if (ret < 0)
	266	+ return ret;
254	267
255		− return 0;
	268	+ formats = ff_make_format_list(sample_rates);
	269	+ if (!formats)
	270	+ return AVERROR(ENOMEM);
	271	+ return ff_set_common_samplerates(ctx, formats);
256	272	}
257	273
258	274	static int request_frame(AVFilterLink *outlink)

libavfilter/af_adelay.c+8−5

@@ -64,23 +64,26 @@ static int query_formats(AVFilterContext *ctx) · 63 unmodified lines
64	64	AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP,
65	65	AV_SAMPLE_FMT_NONE
66	66	};
	67	+ int ret;
67	68
68	69	layouts = ff_all_channel_layouts();
69	70	if (!layouts)
70	71	return AVERROR(ENOMEM);
71		− ff_set_common_channel_layouts(ctx, layouts);
	72	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	73	+ if (ret < 0)
	74	+ return ret;
72	75
73	76	formats = ff_make_format_list(sample_fmts);
74	77	if (!formats)
75	78	return AVERROR(ENOMEM);
76		− ff_set_common_formats(ctx, formats);
	79	+ ret = ff_set_common_formats(ctx, formats);
	80	+ if (ret < 0)
	81	+ return ret;
77	82
78	83	formats = ff_all_samplerates();
79	84	if (!formats)
80	85	return AVERROR(ENOMEM);
81		− ff_set_common_samplerates(ctx, formats);
82		−
83		− return 0;
	86	+ return ff_set_common_samplerates(ctx, formats);
84	87	}
85	88
86	89	#define DELAY(name, type, fill) \

libavfilter/af_aecho.c+8−5

@@ -158,23 +158,26 @@ static int query_formats(AVFilterContext *ctx) · 157 unmodified lines
158	158	AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_DBLP,
159	159	AV_SAMPLE_FMT_NONE
160	160	};
	161	+ int ret;
161	162
162	163	layouts = ff_all_channel_layouts();
163	164	if (!layouts)
164	165	return AVERROR(ENOMEM);
165		− ff_set_common_channel_layouts(ctx, layouts);
	166	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	167	+ if (ret < 0)
	168	+ return ret;
166	169
167	170	formats = ff_make_format_list(sample_fmts);
168	171	if (!formats)
169	172	return AVERROR(ENOMEM);
170		− ff_set_common_formats(ctx, formats);
	173	+ ret = ff_set_common_formats(ctx, formats);
	174	+ if (ret < 0)
	175	+ return ret;
171	176
172	177	formats = ff_all_samplerates();
173	178	if (!formats)
174	179	return AVERROR(ENOMEM);
175		− ff_set_common_samplerates(ctx, formats);
176		−
177		− return 0;
	180	+ return ff_set_common_samplerates(ctx, formats);
178	181	}
179	182
180	183	#define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))

libavfilter/af_afade.c+8−5

@@ -98,23 +98,26 @@ static int query_formats(AVFilterContext *ctx) · 97 unmodified lines
98	98	AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP,
99	99	AV_SAMPLE_FMT_NONE
100	100	};
	101	+ int ret;
101	102
102	103	layouts = ff_all_channel_layouts();
103	104	if (!layouts)
104	105	return AVERROR(ENOMEM);
105		− ff_set_common_channel_layouts(ctx, layouts);
	106	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	107	+ if (ret < 0)
	108	+ return ret;
106	109
107	110	formats = ff_make_format_list(sample_fmts);
108	111	if (!formats)
109	112	return AVERROR(ENOMEM);
110		− ff_set_common_formats(ctx, formats);
	113	+ ret = ff_set_common_formats(ctx, formats);
	114	+ if (ret < 0)
	115	+ return ret;
111	116
112	117	formats = ff_all_samplerates();
113	118	if (!formats)
114	119	return AVERROR(ENOMEM);
115		− ff_set_common_samplerates(ctx, formats);
116		−
117		− return 0;
	120	+ return ff_set_common_samplerates(ctx, formats);
118	121	}
119	122
120	123	static double fade_gain(int curve, int64_t index, int range)

libavfilter/af_aformat.c+8−5

@@ -108,15 +108,18 @@ static av_cold int init(AVFilterContext *ctx) · 107 unmodified lines
108	108	static int query_formats(AVFilterContext *ctx)
109	109	{
110	110	AFormatContext *s = ctx->priv;
	111	+ int ret;
111	112
112		− ff_set_common_formats(ctx, s->formats ? s->formats :
	113	+ ret = ff_set_common_formats(ctx, s->formats ? s->formats :
113	114	ff_all_formats(AVMEDIA_TYPE_AUDIO));
114		− ff_set_common_samplerates(ctx, s->sample_rates ? s->sample_rates :
	115	+ if (ret < 0)
	116	+ return ret;
	117	+ ret = ff_set_common_samplerates(ctx, s->sample_rates ? s->sample_rates :
115	118	ff_all_samplerates());
116		− ff_set_common_channel_layouts(ctx, s->channel_layouts ? s->channel_layouts :
	119	+ if (ret < 0)
	120	+ return ret;
	121	+ return ff_set_common_channel_layouts(ctx, s->channel_layouts ? s->channel_layouts :
117	122	ff_all_channel_counts());
118		−
119		− return 0;
120	123	}
121	124
122	125	static const AVFilterPad avfilter_af_aformat_inputs[] = {

libavfilter/af_amix.c+8−4

@@ -534,6 +534,7 @@ static int query_formats(AVFilterContext *ctx) · 533 unmodified lines
534	534	{
535	535	AVFilterFormats *formats = NULL;
536	536	AVFilterChannelLayouts *layouts;
	537	+ int ret;
537	538
538	539	layouts = ff_all_channel_layouts();
539	540
@@ -542,10 +543,13 @@ static int query_formats(AVFilterContext *ctx) · 2 unmodified lines
542	543
543	544	ff_add_format(&formats, AV_SAMPLE_FMT_FLT);
544	545	ff_add_format(&formats, AV_SAMPLE_FMT_FLTP);
545		− ff_set_common_formats(ctx, formats);
546		− ff_set_common_channel_layouts(ctx, layouts);
547		− ff_set_common_samplerates(ctx, ff_all_samplerates());
548		− return 0;
	546	+ ret = ff_set_common_formats(ctx, formats);
	547	+ if (ret < 0)
	548	+ return ret;
	549	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	550	+ if (ret < 0)
	551	+ return ret;
	552	+ return ff_set_common_samplerates(ctx, ff_all_samplerates());
549	553	}
550	554
551	555	static const AVFilterPad avfilter_af_amix_outputs[] = {

libavfilter/af_aphaser.c+8−5

@@ -94,23 +94,26 @@ static int query_formats(AVFilterContext *ctx) · 93 unmodified lines
94	94	AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16P,
95	95	AV_SAMPLE_FMT_NONE
96	96	};
	97	+ int ret;
97	98
98	99	layouts = ff_all_channel_layouts();
99	100	if (!layouts)
100	101	return AVERROR(ENOMEM);
101		− ff_set_common_channel_layouts(ctx, layouts);
	102	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	103	+ if (ret < 0)
	104	+ return ret;
102	105
103	106	formats = ff_make_format_list(sample_fmts);
104	107	if (!formats)
105	108	return AVERROR(ENOMEM);
106		− ff_set_common_formats(ctx, formats);
	109	+ ret = ff_set_common_formats(ctx, formats);
	110	+ if (ret < 0)
	111	+ return ret;
107	112
108	113	formats = ff_all_samplerates();
109	114	if (!formats)
110	115	return AVERROR(ENOMEM);
111		− ff_set_common_samplerates(ctx, formats);
112		−
113		− return 0;
	116	+ return ff_set_common_samplerates(ctx, formats);
114	117	}
115	118
116	119	#define MOD(a, b) (((a) >= (b)) ? (a) - (b) : (a))

libavfilter/af_asetrate.c+1−2

@@ -51,9 +51,8 @@ static av_cold int query_formats(AVFilterContext *ctx) · 50 unmodified lines
51	51	ASetRateContext *sr = ctx->priv;
52	52	int sample_rates[] = { sr->sample_rate, -1 };
53	53
54		− ff_formats_ref(ff_make_format_list(sample_rates),
	54	+ return ff_formats_ref(ff_make_format_list(sample_rates),
55	55	&ctx->outputs[0]->in_samplerates);
56		− return 0;
57	56	}
58	57
59	58	static av_cold int config_props(AVFilterLink *outlink)

libavfilter/af_astats.c+8−5

@@ -64,23 +64,26 @@ static int query_formats(AVFilterContext *ctx) · 63 unmodified lines
64	64	AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBLP,
65	65	AV_SAMPLE_FMT_NONE
66	66	};
	67	+ int ret;
67	68
68	69	layouts = ff_all_channel_layouts();
69	70	if (!layouts)
70	71	return AVERROR(ENOMEM);
71		− ff_set_common_channel_layouts(ctx, layouts);
	72	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	73	+ if (ret < 0)
	74	+ return ret;
72	75
73	76	formats = ff_make_format_list(sample_fmts);
74	77	if (!formats)
75	78	return AVERROR(ENOMEM);
76		− ff_set_common_formats(ctx, formats);
	79	+ ret = ff_set_common_formats(ctx, formats);
	80	+ if (ret < 0)
	81	+ return ret;
77	82
78	83	formats = ff_all_samplerates();
79	84	if (!formats)
80	85	return AVERROR(ENOMEM);
81		− ff_set_common_samplerates(ctx, formats);
82		−
83		− return 0;
	86	+ return ff_set_common_samplerates(ctx, formats);
84	87	}
85	88
86	89	static int config_output(AVFilterLink *outlink)

libavfilter/af_atempo.c+8−5

@@ -1012,26 +1012,29 @@ static int query_formats(AVFilterContext *ctx) · 1011 unmodified lines
1012	1012	AV_SAMPLE_FMT_DBL,
1013	1013	AV_SAMPLE_FMT_NONE
1014	1014	};
	1015	+ int ret;
1015	1016
1016	1017	layouts = ff_all_channel_layouts();
1017	1018	if (!layouts) {
1018	1019	return AVERROR(ENOMEM);
1019	1020	}
1020		− ff_set_common_channel_layouts(ctx, layouts);
	1021	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	1022	+ if (ret < 0)
	1023	+ return ret;
1021	1024
1022	1025	formats = ff_make_format_list(sample_fmts);
1023	1026	if (!formats) {
1024	1027	return AVERROR(ENOMEM);
1025	1028	}
1026		− ff_set_common_formats(ctx, formats);
	1029	+ ret = ff_set_common_formats(ctx, formats);
	1030	+ if (ret < 0)
	1031	+ return ret;
1027	1032
1028	1033	formats = ff_all_samplerates();
1029	1034	if (!formats) {
1030	1035	return AVERROR(ENOMEM);
1031	1036	}
1032		− ff_set_common_samplerates(ctx, formats);
1033		−
1034		− return 0;
	1037	+ return ff_set_common_samplerates(ctx, formats);
1035	1038	}
1036	1039
1037	1040	static int config_props(AVFilterLink *inlink)

libavfilter/af_biquads.c+8−5

@@ -142,23 +142,26 @@ static int query_formats(AVFilterContext *ctx) · 141 unmodified lines
142	142	AV_SAMPLE_FMT_DBLP,
143	143	AV_SAMPLE_FMT_NONE
144	144	};
	145	+ int ret;
145	146
146	147	layouts = ff_all_channel_layouts();
147	148	if (!layouts)
148	149	return AVERROR(ENOMEM);
149		− ff_set_common_channel_layouts(ctx, layouts);
	150	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	151	+ if (ret < 0)
	152	+ return ret;
150	153
151	154	formats = ff_make_format_list(sample_fmts);
152	155	if (!formats)
153	156	return AVERROR(ENOMEM);
154		− ff_set_common_formats(ctx, formats);
	157	+ ret = ff_set_common_formats(ctx, formats);
	158	+ if (ret < 0)
	159	+ return ret;
155	160
156	161	formats = ff_all_samplerates();
157	162	if (!formats)
158	163	return AVERROR(ENOMEM);
159		− ff_set_common_samplerates(ctx, formats);
160		−
161		− return 0;
	164	+ return ff_set_common_samplerates(ctx, formats);
162	165	}
163	166
164	167	#define BIQUAD_FILTER(name, type, min, max, need_clipping) \

libavfilter/af_bs2b.c+8−5

@@ -106,22 +106,25 @@ static int query_formats(AVFilterContext *ctx) · 105 unmodified lines
106	106	AV_SAMPLE_FMT_DBL,
107	107	AV_SAMPLE_FMT_NONE,
108	108	};
	109	+ int ret;
109	110
110	111	if (ff_add_channel_layout(&layouts, AV_CH_LAYOUT_STEREO) != 0)
111	112	return AVERROR(ENOMEM);
112		− ff_set_common_channel_layouts(ctx, layouts);
	113	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	114	+ if (ret < 0)
	115	+ return ret;
113	116
114	117	formats = ff_make_format_list(sample_fmts);
115	118	if (!formats)
116	119	return AVERROR(ENOMEM);
117		− ff_set_common_formats(ctx, formats);
	120	+ ret = ff_set_common_formats(ctx, formats);
	121	+ if (ret < 0)
	122	+ return ret;
118	123
119	124	formats = ff_all_samplerates();
120	125	if (!formats)
121	126	return AVERROR(ENOMEM);
122		− ff_set_common_samplerates(ctx, formats);
123		−
124		− return 0;
	127	+ return ff_set_common_samplerates(ctx, formats);
125	128	}
126	129
127	130	static int filter_frame(AVFilterLink inlink, AVFrame frame)

libavfilter/af_compand.c+8−5

@@ -107,23 +107,26 @@ static int query_formats(AVFilterContext *ctx) · 106 unmodified lines
107	107	AV_SAMPLE_FMT_DBLP,
108	108	AV_SAMPLE_FMT_NONE
109	109	};
	110	+ int ret;
110	111
111	112	layouts = ff_all_channel_layouts();
112	113	if (!layouts)
113	114	return AVERROR(ENOMEM);
114		− ff_set_common_channel_layouts(ctx, layouts);
	115	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	116	+ if (ret < 0)
	117	+ return ret;
115	118
116	119	formats = ff_make_format_list(sample_fmts);
117	120	if (!formats)
118	121	return AVERROR(ENOMEM);
119		− ff_set_common_formats(ctx, formats);
	122	+ ret = ff_set_common_formats(ctx, formats);
	123	+ if (ret < 0)
	124	+ return ret;
120	125
121	126	formats = ff_all_samplerates();
122	127	if (!formats)
123	128	return AVERROR(ENOMEM);
124		− ff_set_common_samplerates(ctx, formats);
125		−
126		− return 0;
	129	+ return ff_set_common_samplerates(ctx, formats);
127	130	}
128	131
129	132	static void count_items(char item_str, int nb_items)

libavfilter/af_dcshift.c+8−5

@@ -59,23 +59,26 @@ static int query_formats(AVFilterContext *ctx) · 58 unmodified lines
59	59	static const enum AVSampleFormat sample_fmts[] = {
60	60	AV_SAMPLE_FMT_S32P, AV_SAMPLE_FMT_NONE
61	61	};
	62	+ int ret;
62	63
63	64	layouts = ff_all_channel_layouts();
64	65	if (!layouts)
65	66	return AVERROR(ENOMEM);
66		− ff_set_common_channel_layouts(ctx, layouts);
	67	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	68	+ if (ret < 0)
	69	+ return ret;
67	70
68	71	formats = ff_make_format_list(sample_fmts);
69	72	if (!formats)
70	73	return AVERROR(ENOMEM);
71		− ff_set_common_formats(ctx, formats);
	74	+ ret = ff_set_common_formats(ctx, formats);
	75	+ if (ret < 0)
	76	+ return ret;
72	77
73	78	formats = ff_all_samplerates();
74	79	if (!formats)
75	80	return AVERROR(ENOMEM);
76		− ff_set_common_samplerates(ctx, formats);
77		−
78		− return 0;
	81	+ return ff_set_common_samplerates(ctx, formats);
79	82	}
80	83
81	84	static int filter_frame(AVFilterLink inlink, AVFrame in)

libavfilter/af_flanger.c+8−5

@@ -95,23 +95,26 @@ static int query_formats(AVFilterContext *ctx) · 94 unmodified lines
95	95	static const enum AVSampleFormat sample_fmts[] = {
96	96	AV_SAMPLE_FMT_DBLP, AV_SAMPLE_FMT_NONE
97	97	};
	98	+ int ret;
98	99
99	100	layouts = ff_all_channel_layouts();
100	101	if (!layouts)
101	102	return AVERROR(ENOMEM);
102		− ff_set_common_channel_layouts(ctx, layouts);
	103	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	104	+ if (ret < 0)
	105	+ return ret;
103	106
104	107	formats = ff_make_format_list(sample_fmts);
105	108	if (!formats)
106	109	return AVERROR(ENOMEM);
107		− ff_set_common_formats(ctx, formats);
	110	+ ret = ff_set_common_formats(ctx, formats);
	111	+ if (ret < 0)
	112	+ return ret;
108	113
109	114	formats = ff_all_samplerates();
110	115	if (!formats)
111	116	return AVERROR(ENOMEM);
112		− ff_set_common_samplerates(ctx, formats);
113		−
114		− return 0;
	117	+ return ff_set_common_samplerates(ctx, formats);
115	118	}
116	119
117	120	static int config_input(AVFilterLink *inlink)

libavfilter/af_silencedetect.c+8−5

@@ -164,23 +164,26 @@ static int query_formats(AVFilterContext *ctx) · 163 unmodified lines
164	164	AV_SAMPLE_FMT_S16,
165	165	AV_SAMPLE_FMT_NONE
166	166	};
	167	+ int ret;
167	168
168	169	layouts = ff_all_channel_layouts();
169	170	if (!layouts)
170	171	return AVERROR(ENOMEM);
171		− ff_set_common_channel_layouts(ctx, layouts);
	172	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	173	+ if (ret < 0)
	174	+ return ret;
172	175
173	176	formats = ff_make_format_list(sample_fmts);
174	177	if (!formats)
175	178	return AVERROR(ENOMEM);
176		− ff_set_common_formats(ctx, formats);
	179	+ ret = ff_set_common_formats(ctx, formats);
	180	+ if (ret < 0)
	181	+ return ret;
177	182
178	183	formats = ff_all_samplerates();
179	184	if (!formats)
180	185	return AVERROR(ENOMEM);
181		− ff_set_common_samplerates(ctx, formats);
182		−
183		− return 0;
	186	+ return ff_set_common_samplerates(ctx, formats);
184	187	}
185	188
186	189	static const AVFilterPad silencedetect_inputs[] = {

libavfilter/af_silenceremove.c+8−5

@@ -418,23 +418,26 @@ static int query_formats(AVFilterContext *ctx) · 417 unmodified lines
418	418	static const enum AVSampleFormat sample_fmts[] = {
419	419	AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_NONE
420	420	};
	421	+ int ret;
421	422
422	423	layouts = ff_all_channel_layouts();
423	424	if (!layouts)
424	425	return AVERROR(ENOMEM);
425		− ff_set_common_channel_layouts(ctx, layouts);
	426	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	427	+ if (ret < 0)
	428	+ return ret;
426	429
427	430	formats = ff_make_format_list(sample_fmts);
428	431	if (!formats)
429	432	return AVERROR(ENOMEM);
430		− ff_set_common_formats(ctx, formats);
	433	+ ret = ff_set_common_formats(ctx, formats);
	434	+ if (ret < 0)
	435	+ return ret;
431	436
432	437	formats = ff_all_samplerates();
433	438	if (!formats)
434	439	return AVERROR(ENOMEM);
435		− ff_set_common_samplerates(ctx, formats);
436		−
437		− return 0;
	440	+ return ff_set_common_samplerates(ctx, formats);
438	441	}
439	442
440	443	static av_cold void uninit(AVFilterContext *ctx)

libavfilter/af_volume.c+8−5

@@ -153,23 +153,26 @@ static int query_formats(AVFilterContext *ctx) · 152 unmodified lines
153	153	AV_SAMPLE_FMT_NONE
154	154	}
155	155	};
	156	+ int ret;
156	157
157	158	layouts = ff_all_channel_counts();
158	159	if (!layouts)
159	160	return AVERROR(ENOMEM);
160		− ff_set_common_channel_layouts(ctx, layouts);
	161	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	162	+ if (ret < 0)
	163	+ return ret;
161	164
162	165	formats = ff_make_format_list(sample_fmts[vol->precision]);
163	166	if (!formats)
164	167	return AVERROR(ENOMEM);
165		− ff_set_common_formats(ctx, formats);
	168	+ ret = ff_set_common_formats(ctx, formats);
	169	+ if (ret < 0)
	170	+ return ret;
166	171
167	172	formats = ff_all_samplerates();
168	173	if (!formats)
169	174	return AVERROR(ENOMEM);
170		− ff_set_common_samplerates(ctx, formats);
171		−
172		− return 0;
	175	+ return ff_set_common_samplerates(ctx, formats);
173	176	}
174	177
175	178	static inline void scale_samples_u8(uint8_t dst, const uint8_t src,

libavfilter/af_volumedetect.c+1−3

@@ -44,9 +44,7 @@ static int query_formats(AVFilterContext *ctx) · 43 unmodified lines
44	44
45	45	if (!(formats = ff_make_format_list(sample_fmts)))
46	46	return AVERROR(ENOMEM);
47		− ff_set_common_formats(ctx, formats);
48		−
49		− return 0;
	47	+ return ff_set_common_formats(ctx, formats);
50	48	}
51	49
52	50	static int filter_frame(AVFilterLink inlink, AVFrame samples)

libavfilter/asrc_sine.c+21−4

@@ -153,11 +153,28 @@ static av_cold int query_formats(AVFilterContext *ctx) · 152 unmodified lines
153	153	int sample_rates[] = { sine->sample_rate, -1 };
154	154	static const enum AVSampleFormat sample_fmts[] = { AV_SAMPLE_FMT_S16,
155	155	AV_SAMPLE_FMT_NONE };
	156	+ AVFilterFormats *formats;
	157	+ AVFilterChannelLayouts *layouts;
	158	+ int ret;
156	159
157		− ff_set_common_formats (ctx, ff_make_format_list(sample_fmts));
158		− ff_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));
159		− ff_set_common_samplerates(ctx, ff_make_format_list(sample_rates));
160		− return 0;
	160	+ formats = ff_make_format_list(sample_fmts);
	161	+ if (!formats)
	162	+ return AVERROR(ENOMEM);
	163	+ ret = ff_set_common_formats (ctx, formats);
	164	+ if (ret < 0)
	165	+ return ret;
	166	+
	167	+ layouts = avfilter_make_format64_list(chlayouts);
	168	+ if (!layouts)
	169	+ return AVERROR(ENOMEM);
	170	+ ret = ff_set_common_channel_layouts(ctx, layouts);
	171	+ if (ret < 0)
	172	+ return ret;
	173	+
	174	+ formats = ff_make_format_list(sample_rates);
	175	+ if (!formats)
	176	+ return AVERROR(ENOMEM);
	177	+ return ff_set_common_samplerates(ctx, formats);
161	178	}
162	179
163	180	static av_cold int config_props(AVFilterLink *outlink)

libavfilter/vf_bbox.c+4−2

@@ -56,8 +56,10 @@ static int query_formats(AVFilterContext *ctx) · 55 unmodified lines
56	56	AV_PIX_FMT_NONE,
57	57	};
58	58
59		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
60		− return 0;
	59	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	60	+ if (!fmts_list)
	61	+ return AVERROR(ENOMEM);
	62	+ return ff_set_common_formats(ctx, fmts_list);
61	63	}
62	64
63	65	#define SET_META(key, value) \

libavfilter/vf_blackdetect.c+4−2

@@ -80,8 +80,10 @@ static int query_formats(AVFilterContext *ctx) · 79 unmodified lines
80	80	AV_PIX_FMT_NONE
81	81	};
82	82
83		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
84		− return 0;
	83	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	84	+ if (!fmts_list)
	85	+ return AVERROR(ENOMEM);
	86	+ return ff_set_common_formats(ctx, fmts_list);
85	87	}
86	88
87	89	static int config_input(AVFilterLink *inlink)

libavfilter/vf_blackframe.c+4−2

@@ -54,8 +54,10 @@ static int query_formats(AVFilterContext *ctx) · 53 unmodified lines
54	54	AV_PIX_FMT_NONE
55	55	};
56	56
57		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
58		− return 0;
	57	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	58	+ if (!fmts_list)
	59	+ return AVERROR(ENOMEM);
	60	+ return ff_set_common_formats(ctx, fmts_list);
59	61	}
60	62
61	63	#define SET_META(key, format, value) \

libavfilter/vf_blend.c+4−2

@@ -369,8 +369,10 @@ static int query_formats(AVFilterContext *ctx) · 368 unmodified lines
369	369	AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
370	370	};
371	371
372		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
373		− return 0;
	372	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	373	+ if (!fmts_list)
	374	+ return AVERROR(ENOMEM);
	375	+ return ff_set_common_formats(ctx, fmts_list);
374	376	}
375	377
376	378	static av_cold void uninit(AVFilterContext *ctx)

libavfilter/vf_boxblur.c+1−2

@@ -128,8 +128,7 @@ static int query_formats(AVFilterContext *ctx) · 127 unmodified lines
128	128	ff_add_format(&formats, fmt);
129	129	}
130	130
131		− ff_set_common_formats(ctx, formats);
132		− return 0;
	131	+ return ff_set_common_formats(ctx, formats);
133	132	}
134	133
135	134	static int config_input(AVFilterLink *inlink)

libavfilter/vf_colorchannelmixer.c+4−2

@@ -81,8 +81,10 @@ static int query_formats(AVFilterContext *ctx) · 80 unmodified lines
81	81	AV_PIX_FMT_NONE
82	82	};
83	83
84		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
85		− return 0;
	84	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	85	+ if (!fmts_list)
	86	+ return AVERROR(ENOMEM);
	87	+ return ff_set_common_formats(ctx, fmts_list);
86	88	}
87	89
88	90	static int config_output(AVFilterLink *outlink)

libavfilter/vf_colorlevels.c+4−2

@@ -84,8 +84,10 @@ static int query_formats(AVFilterContext *ctx) · 83 unmodified lines
84	84	AV_PIX_FMT_NONE
85	85	};
86	86
87		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
88		− return 0;
	87	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	88	+ if (!fmts_list)
	89	+ return AVERROR(ENOMEM);
	90	+ return ff_set_common_formats(ctx, fmts_list);
89	91	}
90	92
91	93	static int config_input(AVFilterLink *inlink)

libavfilter/vf_crop.c+1−2

@@ -102,8 +102,7 @@ static int query_formats(AVFilterContext *ctx) · 101 unmodified lines
102	102	ff_add_format(&formats, fmt);
103	103	}
104	104
105		− ff_set_common_formats(ctx, formats);
106		− return 0;
	105	+ return ff_set_common_formats(ctx, formats);
107	106	}
108	107
109	108	static av_cold void uninit(AVFilterContext *ctx)

libavfilter/vf_cropdetect.c+4−2

@@ -62,8 +62,10 @@ static int query_formats(AVFilterContext *ctx) · 61 unmodified lines
62	62	AV_PIX_FMT_NONE
63	63	};
64	64
65		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
66		− return 0;
	65	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	66	+ if (!fmts_list)
	67	+ return AVERROR(ENOMEM);
	68	+ return ff_set_common_formats(ctx, fmts_list);
67	69	}
68	70
69	71	static int checkline(void ctx, const unsigned char src, int stride, int len, int bpp)

libavfilter/vf_detelecine.c+1−2

@@ -126,8 +126,7 @@ static int query_formats(AVFilterContext *ctx) · 125 unmodified lines
126	126	ff_add_format(&pix_fmts, fmt);
127	127	}
128	128
129		− ff_set_common_formats(ctx, pix_fmts);
130		− return 0;
	129	+ return ff_set_common_formats(ctx, pix_fmts);
131	130	}
132	131
133	132	static int config_input(AVFilterLink *inlink)

libavfilter/vf_drawtext.c+1−2

@@ -682,8 +682,7 @@ static av_cold int init(AVFilterContext *ctx) · 681 unmodified lines
682	682
683	683	static int query_formats(AVFilterContext *ctx)
684	684	{
685		− ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
686		− return 0;
	685	+ return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
687	686	}
688	687
689	688	static int glyph_enu_free(void opaque, void elem)

libavfilter/vf_fade.c+6−3

@@ -115,12 +115,15 @@ static int query_formats(AVFilterContext *ctx) · 114 unmodified lines
115	115	AV_PIX_FMT_RGBA, AV_PIX_FMT_BGRA,
116	116	AV_PIX_FMT_NONE
117	117	};
	118	+ AVFilterFormats *fmts_list;
118	119
119	120	if (s->black_fade)
120		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
	121	+ fmts_list = ff_make_format_list(pix_fmts);
121	122	else
122		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts_rgb));
123		− return 0;
	123	+ fmts_list = ff_make_format_list(pix_fmts_rgb);
	124	+ if (!fmts_list)
	125	+ return AVERROR(ENOMEM);
	126	+ return ff_set_common_formats(ctx, fmts_list);
124	127	}
125	128
126	129	const static enum AVPixelFormat studio_level_pix_fmts[] = {

libavfilter/vf_fftfilt.c+4−3

@@ -307,9 +307,10 @@ static int query_formats(AVFilterContext *ctx) · 306 unmodified lines
307	307	AV_PIX_FMT_NONE
308	308	};
309	309
310		− ff_set_common_formats(ctx, ff_make_format_list(pixel_fmts_fftfilt));
311		−
312		− return 0;
	310	+ AVFilterFormats *fmts_list = ff_make_format_list(pixel_fmts_fftfilt);
	311	+ if (!fmts_list)
	312	+ return AVERROR(ENOMEM);
	313	+ return ff_set_common_formats(ctx, fmts_list);
313	314	}
314	315
315	316	static const AVFilterPad fftfilt_inputs[] = {

libavfilter/vf_format.c+1−2

@@ -134,8 +134,7 @@ static int query_formats(AVFilterContext *ctx) · 133 unmodified lines
134	134	if (!formats)
135	135	return AVERROR(ENOMEM);
136	136
137		− ff_set_common_formats(ctx, formats);
138		− return 0;
	137	+ return ff_set_common_formats(ctx, formats);
139	138	}
140	139
141	140

libavfilter/vf_framepack.c+4−2

@@ -61,8 +61,10 @@ static const enum AVPixelFormat formats_supported[] = { · 60 unmodified lines
61	61	static int query_formats(AVFilterContext *ctx)
62	62	{
63	63	// this will ensure that formats are the same on all pads
64		− ff_set_common_formats(ctx, ff_make_format_list(formats_supported));
65		− return 0;
	64	+ AVFilterFormats *fmts_list = ff_make_format_list(formats_supported);
	65	+ if (!fmts_list)
	66	+ return AVERROR(ENOMEM);
	67	+ return ff_set_common_formats(ctx, fmts_list);
66	68	}
67	69
68	70	static av_cold void framepack_uninit(AVFilterContext *ctx)

libavfilter/vf_frei0r.c+1−2

@@ -385,8 +385,7 @@ static int query_formats(AVFilterContext *ctx) · 384 unmodified lines
385	385	if (!formats)
386	386	return AVERROR(ENOMEM);
387	387
388		− ff_set_common_formats(ctx, formats);
389		− return 0;
	388	+ return ff_set_common_formats(ctx, formats);
390	389	}
391	390
392	391	static int filter_frame(AVFilterLink inlink, AVFrame in)

libavfilter/vf_fspp.c+5−2

@@ -501,8 +501,11 @@ static int query_formats(AVFilterContext *ctx) · 500 unmodified lines
501	501	AV_PIX_FMT_GBRP, AV_PIX_FMT_GRAY8,
502	502	AV_PIX_FMT_NONE
503	503	};
504		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
505		− return 0;
	504	+
	505	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	506	+ if (!fmts_list)
	507	+ return AVERROR(ENOMEM);
	508	+ return ff_set_common_formats(ctx, fmts_list);
506	509	}
507	510
508	511	static int config_input(AVFilterLink *inlink)

libavfilter/vf_geq.c+7−3

@@ -176,11 +176,15 @@ static int geq_query_formats(AVFilterContext *ctx) · 175 unmodified lines
176	176	AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
177	177	AV_PIX_FMT_NONE
178	178	};
	179	+ AVFilterFormats *fmts_list;
	180	+
179	181	if (geq->is_rgb) {
180		− ff_set_common_formats(ctx, ff_make_format_list(rgb_pix_fmts));
	182	+ fmts_list = ff_make_format_list(rgb_pix_fmts);
181	183	} else
182		− ff_set_common_formats(ctx, ff_make_format_list(yuv_pix_fmts));
183		− return 0;
	184	+ fmts_list = ff_make_format_list(yuv_pix_fmts);
	185	+ if (!fmts_list)
	186	+ return AVERROR(ENOMEM);
	187	+ return ff_set_common_formats(ctx, fmts_list);
184	188	}
185	189
186	190	static int geq_config_props(AVFilterLink *inlink)

libavfilter/vf_hflip.c+1−2

@@ -55,8 +55,7 @@ static int query_formats(AVFilterContext *ctx) · 54 unmodified lines
55	55	ff_add_format(&pix_fmts, fmt);
56	56	}
57	57
58		− ff_set_common_formats(ctx, pix_fmts);
59		− return 0;
	58	+ return ff_set_common_formats(ctx, pix_fmts);
60	59	}
61	60
62	61	static int config_props(AVFilterLink *inlink)

libavfilter/vf_histogram.c+5−3

@@ -105,6 +105,7 @@ static int query_formats(AVFilterContext *ctx) · 104 unmodified lines
105	105	{
106	106	HistogramContext *h = ctx->priv;
107	107	const enum AVPixelFormat *pix_fmts;
	108	+ AVFilterFormats *fmts_list;
108	109
109	110	switch (h->mode) {
110	111	case MODE_WAVEFORM:
@@ -121,9 +122,10 @@ static int query_formats(AVFilterContext *ctx) · 10 unmodified lines
121	122	av_assert0(0);
122	123	}
123	124
124		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
125		−
126		− return 0;
	125	+ fmts_list = ff_make_format_list(pix_fmts);
	126	+ if (!fmts_list)
	127	+ return AVERROR(ENOMEM);
	128	+ return ff_set_common_formats(ctx, fmts_list);
127	129	}
128	130
129	131	static const uint8_t black_yuva_color[4] = { 0, 127, 127, 255 };

libavfilter/vf_il.c+1−2

@@ -92,8 +92,7 @@ static int query_formats(AVFilterContext *ctx) · 91 unmodified lines
92	92	ff_add_format(&formats, fmt);
93	93	}
94	94
95		− ff_set_common_formats(ctx, formats);
96		− return 0;
	95	+ return ff_set_common_formats(ctx, formats);
97	96	}
98	97
99	98	static int config_input(AVFilterLink *inlink)

libavfilter/vf_interlace.c+4−2

@@ -76,8 +76,10 @@ static const enum AVPixelFormat formats_supported[] = { · 75 unmodified lines
76	76
77	77	static int query_formats(AVFilterContext *ctx)
78	78	{
79		− ff_set_common_formats(ctx, ff_make_format_list(formats_supported));
80		− return 0;
	79	+ AVFilterFormats *fmts_list = ff_make_format_list(formats_supported);
	80	+ if (!fmts_list)
	81	+ return AVERROR(ENOMEM);
	82	+ return ff_set_common_formats(ctx, fmts_list);
81	83	}
82	84
83	85	static av_cold void uninit(AVFilterContext *ctx)

libavfilter/vf_kerndeint.c+4−3

@@ -78,9 +78,10 @@ static int query_formats(AVFilterContext *ctx) · 77 unmodified lines
78	78	AV_PIX_FMT_NONE
79	79	};
80	80
81		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
82		−
83		− return 0;
	81	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	82	+ if (!fmts_list)
	83	+ return AVERROR(ENOMEM);
	84	+ return ff_set_common_formats(ctx, fmts_list);
84	85	}
85	86
86	87	static int config_props(AVFilterLink *inlink)

libavfilter/vf_noise.c+1−2

@@ -141,8 +141,7 @@ static int query_formats(AVFilterContext *ctx) · 140 unmodified lines
141	141	ff_add_format(&formats, fmt);
142	142	}
143	143
144		− ff_set_common_formats(ctx, formats);
145		− return 0;
	144	+ return ff_set_common_formats(ctx, formats);
146	145	}
147	146
148	147	static int config_input(AVFilterLink *inlink)

libavfilter/vf_pad.c+1−2

@@ -73,8 +73,7 @@ enum var_name { · 72 unmodified lines
73	73
74	74	static int query_formats(AVFilterContext *ctx)
75	75	{
76		− ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
77		− return 0;
	76	+ return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
78	77	}
79	78
80	79	typedef struct PadContext {

libavfilter/vf_perspective.c+4−2

@@ -93,8 +93,10 @@ static int query_formats(AVFilterContext *ctx) · 92 unmodified lines
93	93	AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
94	94	};
95	95
96		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
97		− return 0;
	96	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	97	+ if (!fmts_list)
	98	+ return AVERROR(ENOMEM);
	99	+ return ff_set_common_formats(ctx, fmts_list);
98	100	}
99	101
100	102	static inline double get_coeff(double d)

libavfilter/vf_phase.c+4−2

@@ -77,8 +77,10 @@ static int query_formats(AVFilterContext *ctx) · 76 unmodified lines
77	77	AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
78	78	};
79	79
80		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
81		− return 0;
	80	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	81	+ if (!fmts_list)
	82	+ return AVERROR(ENOMEM);
	83	+ return ff_set_common_formats(ctx, fmts_list);
82	84	}
83	85
84	86	static int config_input(AVFilterLink *inlink)

libavfilter/vf_pp.c+5−2

@@ -85,8 +85,11 @@ static int pp_query_formats(AVFilterContext *ctx) · 84 unmodified lines
85	85	AV_PIX_FMT_GRAY8,
86	86	AV_PIX_FMT_NONE
87	87	};
88		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
89		− return 0;
	88	+
	89	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	90	+ if (!fmts_list)
	91	+ return AVERROR(ENOMEM);
	92	+ return ff_set_common_formats(ctx, fmts_list);
90	93	}
91	94
92	95	static int pp_config_props(AVFilterLink *inlink)

libavfilter/vf_pp7.c+5−2

@@ -274,8 +274,11 @@ static int query_formats(AVFilterContext *ctx) · 273 unmodified lines
274	274	AV_PIX_FMT_GBRP,
275	275	AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
276	276	};
277		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
278		− return 0;
	277	+
	278	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	279	+ if (!fmts_list)
	280	+ return AVERROR(ENOMEM);
	281	+ return ff_set_common_formats(ctx, fmts_list);
279	282	}
280	283
281	284	static int config_input(AVFilterLink *inlink)

libavfilter/vf_psnr.c+4−2

@@ -232,8 +232,10 @@ static int query_formats(AVFilterContext *ctx) · 231 unmodified lines
232	232	AV_PIX_FMT_NONE
233	233	};
234	234
235		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
236		− return 0;
	235	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	236	+ if (!fmts_list)
	237	+ return AVERROR(ENOMEM);
	238	+ return ff_set_common_formats(ctx, fmts_list);
237	239	}
238	240
239	241	static int config_input_ref(AVFilterLink *inlink)

libavfilter/vf_pullup.c+5−2

@@ -63,8 +63,11 @@ static int query_formats(AVFilterContext *ctx) · 62 unmodified lines
63	63	AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_GRAY8,
64	64	AV_PIX_FMT_NONE
65	65	};
66		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
67		− return 0;
	66	+
	67	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	68	+ if (!fmts_list)
	69	+ return AVERROR(ENOMEM);
	70	+ return ff_set_common_formats(ctx, fmts_list);
68	71	}
69	72
70	73	#define ABS(a) (((a) ^ ((a) >> 31)) - ((a) >> 31))

libavfilter/vf_removelogo.c+4−2

@@ -206,8 +206,10 @@ static void convert_mask_to_strength_mask(uint8_t *data, int linesize, · 205 unmodified lines
206	206	static int query_formats(AVFilterContext *ctx)
207	207	{
208	208	static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
209		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
210		− return 0;
	209	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	210	+ if (!fmts_list)
	211	+ return AVERROR(ENOMEM);
	212	+ return ff_set_common_formats(ctx, fmts_list);
211	213	}
212	214
213	215	static int load_mask(uint8_t *mask, int w, int *h,

libavfilter/vf_repeatfields.c+4−3

@@ -50,9 +50,10 @@ static int query_formats(AVFilterContext *ctx) · 49 unmodified lines
50	50	AV_PIX_FMT_NONE
51	51	};
52	52
53		− ff_set_common_formats(ctx, ff_make_format_list(pixel_fmts_eq));
54		−
55		− return 0;
	53	+ AVFilterFormats *fmts_list = ff_make_format_list(pixel_fmts_eq);
	54	+ if (!fmts_list)
	55	+ return AVERROR(ENOMEM);
	56	+ return ff_set_common_formats(ctx, fmts_list);
56	57	}
57	58
58	59	static int config_input(AVFilterLink *inlink)

libavfilter/vf_rotate.c+4−2

@@ -145,8 +145,10 @@ static int query_formats(AVFilterContext *ctx) · 144 unmodified lines
145	145	AV_PIX_FMT_NONE
146	146	};
147	147
148		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
149		− return 0;
	148	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	149	+ if (!fmts_list)
	150	+ return AVERROR(ENOMEM);
	151	+ return ff_set_common_formats(ctx, fmts_list);
150	152	}
151	153
152	154	static double get_rotated_w(void *opaque, double angle)

libavfilter/vf_sab.c+4−3

@@ -65,9 +65,10 @@ static int query_formats(AVFilterContext *ctx) · 64 unmodified lines
65	65	AV_PIX_FMT_YUV411P,
66	66	AV_PIX_FMT_NONE
67	67	};
68		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
69		−
70		− return 0;
	68	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	69	+ if (!fmts_list)
	70	+ return AVERROR(ENOMEM);
	71	+ return ff_set_common_formats(ctx, fmts_list);
71	72	}
72	73
73	74	#define RADIUS_MIN 0.1

libavfilter/vf_signalstats.c+4−2

@@ -118,8 +118,10 @@ static int query_formats(AVFilterContext *ctx) · 117 unmodified lines
118	118	AV_PIX_FMT_NONE
119	119	};
120	120
121		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
122		− return 0;
	121	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	122	+ if (!fmts_list)
	123	+ return AVERROR(ENOMEM);
	124	+ return ff_set_common_formats(ctx, fmts_list);
123	125	}
124	126
125	127	static AVFrame *alloc_frame(enum AVPixelFormat pixfmt, int w, int h)

libavfilter/vf_smartblur.c+4−3

@@ -124,9 +124,10 @@ static int query_formats(AVFilterContext *ctx) · 123 unmodified lines
124	124	AV_PIX_FMT_NONE
125	125	};
126	126
127		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
128		−
129		− return 0;
	127	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	128	+ if (!fmts_list)
	129	+ return AVERROR(ENOMEM);
	130	+ return ff_set_common_formats(ctx, fmts_list);
130	131	}
131	132
132	133	static int alloc_sws_context(FilterParam *f, int width, int height, unsigned int flags)

libavfilter/vf_spp.c+5−2

@@ -319,8 +319,11 @@ static int query_formats(AVFilterContext *ctx) · 318 unmodified lines
319	319	AV_PIX_FMT_GBRP10,
320	320	AV_PIX_FMT_NONE
321	321	};
322		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
323		− return 0;
	322	+
	323	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	324	+ if (!fmts_list)
	325	+ return AVERROR(ENOMEM);
	326	+ return ff_set_common_formats(ctx, fmts_list);
324	327	}
325	328
326	329	static int config_input(AVFilterLink *inlink)

libavfilter/vf_stereo3d.c+5−3

@@ -256,6 +256,7 @@ static int query_formats(AVFilterContext *ctx) · 255 unmodified lines
256	256	{
257	257	Stereo3DContext *s = ctx->priv;
258	258	const enum AVPixelFormat *pix_fmts;
	259	+ AVFilterFormats *fmts_list;
259	260
260	261	switch (s->out.format) {
261	262	case ANAGLYPH_GM_COLOR:
@@ -278,9 +279,10 @@ static int query_formats(AVFilterContext *ctx) · 16 unmodified lines
278	279	pix_fmts = other_pix_fmts;
279	280	}
280	281
281		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
282		−
283		− return 0;
	282	+ fmts_list = ff_make_format_list(pix_fmts);
	283	+ if (!fmts_list)
	284	+ return AVERROR(ENOMEM);
	285	+ return ff_set_common_formats(ctx, fmts_list);
284	286	}
285	287
286	288	static int config_output(AVFilterLink *outlink)

libavfilter/vf_subtitles.c+1−2

@@ -129,8 +129,7 @@ static av_cold void uninit(AVFilterContext *ctx) · 128 unmodified lines
129	129
130	130	static int query_formats(AVFilterContext *ctx)
131	131	{
132		− ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
133		− return 0;
	132	+ return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
134	133	}
135	134
136	135	static int config_input(AVFilterLink *inlink)

libavfilter/vf_super2xsai.c+4−2

@@ -241,8 +241,10 @@ static int query_formats(AVFilterContext *ctx) · 240 unmodified lines
241	241	AV_PIX_FMT_NONE
242	242	};
243	243
244		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
245		− return 0;
	244	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	245	+ if (!fmts_list)
	246	+ return AVERROR(ENOMEM);
	247	+ return ff_set_common_formats(ctx, fmts_list);
246	248	}
247	249
248	250	static int config_input(AVFilterLink *inlink)

libavfilter/vf_swapuv.c+1−2

@@ -79,8 +79,7 @@ static int query_formats(AVFilterContext *ctx) · 78 unmodified lines
79	79	ff_add_format(&formats, fmt);
80	80	}
81	81
82		− ff_set_common_formats(ctx, formats);
83		− return 0;
	82	+ return ff_set_common_formats(ctx, formats);
84	83	}
85	84
86	85	static const AVFilterPad swapuv_inputs[] = {

libavfilter/vf_telecine.c+1−2

@@ -112,8 +112,7 @@ static int query_formats(AVFilterContext *ctx) · 111 unmodified lines
112	112	ff_add_format(&pix_fmts, fmt);
113	113	}
114	114
115		− ff_set_common_formats(ctx, pix_fmts);
116		− return 0;
	115	+ return ff_set_common_formats(ctx, pix_fmts);
117	116	}
118	117
119	118	static int config_input(AVFilterLink *inlink)

libavfilter/vf_thumbnail.c+4−2

@@ -203,8 +203,10 @@ static int query_formats(AVFilterContext *ctx) · 202 unmodified lines
203	203	AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
204	204	AV_PIX_FMT_NONE
205	205	};
206		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
207		− return 0;
	206	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	207	+ if (!fmts_list)
	208	+ return AVERROR(ENOMEM);
	209	+ return ff_set_common_formats(ctx, fmts_list);
208	210	}
209	211
210	212	static const AVFilterPad thumbnail_inputs[] = {

libavfilter/vf_tile.c+1−2

@@ -87,8 +87,7 @@ static av_cold int init(AVFilterContext *ctx) · 86 unmodified lines
87	87
88	88	static int query_formats(AVFilterContext *ctx)
89	89	{
90		− ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
91		− return 0;
	90	+ return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
92	91	}
93	92
94	93	static int config_props(AVFilterLink *outlink)

libavfilter/vf_tinterlace.c+4−2

@@ -81,8 +81,10 @@ static int query_formats(AVFilterContext *ctx) · 80 unmodified lines
81	81	AV_PIX_FMT_NONE
82	82	};
83	83
84		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
85		− return 0;
	84	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	85	+ if (!fmts_list)
	86	+ return AVERROR(ENOMEM);
	87	+ return ff_set_common_formats(ctx, fmts_list);
86	88	}
87	89
88	90	static void lowpass_line_c(uint8_t dstp, ptrdiff_t width, const uint8_t srcp,

libavfilter/vf_transpose.c+1−2

@@ -75,8 +75,7 @@ static int query_formats(AVFilterContext *ctx) · 74 unmodified lines
75	75	}
76	76
77	77
78		− ff_set_common_formats(ctx, pix_fmts);
79		− return 0;
	78	+ return ff_set_common_formats(ctx, pix_fmts);
80	79	}
81	80
82	81	static int config_props_output(AVFilterLink *outlink)

libavfilter/vf_unsharp.c+4−3

@@ -163,9 +163,10 @@ static int query_formats(AVFilterContext *ctx) · 162 unmodified lines
163	163	AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P, AV_PIX_FMT_NONE
164	164	};
165	165
166		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
167		−
168		− return 0;
	166	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	167	+ if (!fmts_list)
	168	+ return AVERROR(ENOMEM);
	169	+ return ff_set_common_formats(ctx, fmts_list);
169	170	}
170	171
171	172	static int init_filter_param(AVFilterContext ctx, UnsharpFilterParam fp, const char *effect_type, int width)

libavfilter/vf_uspp.c+5−2

@@ -293,8 +293,11 @@ static int query_formats(AVFilterContext *ctx) · 292 unmodified lines
293	293	AV_PIX_FMT_GRAY8,
294	294	AV_PIX_FMT_NONE
295	295	};
296		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
297		− return 0;
	296	+
	297	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	298	+ if (!fmts_list)
	299	+ return AVERROR(ENOMEM);
	300	+ return ff_set_common_formats(ctx, fmts_list);
298	301	}
299	302
300	303	static int config_input(AVFilterLink *inlink)

libavfilter/vf_vidstabdetect.c+4−2

@@ -93,8 +93,10 @@ static int query_formats(AVFilterContext *ctx) · 92 unmodified lines
93	93	AV_PIX_FMT_NONE
94	94	};
95	95
96		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
97		− return 0;
	96	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	97	+ if (!fmts_list)
	98	+ return AVERROR(ENOMEM);
	99	+ return ff_set_common_formats(ctx, fmts_list);
98	100	}
99	101
100	102	static int config_input(AVFilterLink *inlink)

libavfilter/vf_vidstabtransform.c+4−2

@@ -132,8 +132,10 @@ static int query_formats(AVFilterContext *ctx) · 131 unmodified lines
132	132	AV_PIX_FMT_NONE
133	133	};
134	134
135		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
136		− return 0;
	135	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	136	+ if (!fmts_list)
	137	+ return AVERROR(ENOMEM);
	138	+ return ff_set_common_formats(ctx, fmts_list);
137	139	}
138	140
139	141

libavfilter/vf_vignette.c+4−2

@@ -136,8 +136,10 @@ static int query_formats(AVFilterContext *ctx) · 135 unmodified lines
136	136	AV_PIX_FMT_GRAY8,
137	137	AV_PIX_FMT_NONE
138	138	};
139		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
140		− return 0;
	139	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	140	+ if (!fmts_list)
	141	+ return AVERROR(ENOMEM);
	142	+ return ff_set_common_formats(ctx, fmts_list);
141	143	}
142	144
143	145	static double get_natural_factor(const VignetteContext *s, int x, int y)

libavfilter/vf_w3fdif.c+4−3

@@ -74,9 +74,10 @@ static int query_formats(AVFilterContext *ctx) · 73 unmodified lines
74	74	AV_PIX_FMT_NONE
75	75	};
76	76
77		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
78		−
79		− return 0;
	77	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	78	+ if (!fmts_list)
	79	+ return AVERROR(ENOMEM);
	80	+ return ff_set_common_formats(ctx, fmts_list);
80	81	}
81	82
82	83	static int config_input(AVFilterLink *inlink)

libavfilter/vf_xbr.c+4−2

@@ -342,8 +342,10 @@ static int query_formats(AVFilterContext *ctx) · 341 unmodified lines
342	342	AV_PIX_FMT_0RGB32, AV_PIX_FMT_NONE,
343	343	};
344	344
345		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
346		− return 0;
	345	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	346	+ if (!fmts_list)
	347	+ return AVERROR(ENOMEM);
	348	+ return ff_set_common_formats(ctx, fmts_list);
347	349	}
348	350
349	351	static int filter_frame(AVFilterLink inlink, AVFrame in)

libavfilter/vf_yadif.c+4−3

@@ -461,9 +461,10 @@ static int query_formats(AVFilterContext *ctx) · 460 unmodified lines
461	461	AV_PIX_FMT_NONE
462	462	};
463	463
464		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
465		−
466		− return 0;
	464	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	465	+ if (!fmts_list)
	466	+ return AVERROR(ENOMEM);
	467	+ return ff_set_common_formats(ctx, fmts_list);
467	468	}
468	469
469	470	static int config_props(AVFilterLink *link)

libavfilter/vf_zoompan.c+4−3

@@ -264,9 +264,10 @@ static int query_formats(AVFilterContext *ctx) · 263 unmodified lines
264	264	AV_PIX_FMT_NONE
265	265	};
266	266
267		−
268		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
269		− return 0;
	267	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	268	+ if (!fmts_list)
	269	+ return AVERROR(ENOMEM);
	270	+ return ff_set_common_formats(ctx, fmts_list);
270	271	}
271	272
272	273	static av_cold void uninit(AVFilterContext *ctx)

libavfilter/vsrc_cellauto.c+4−2

@@ -310,8 +310,10 @@ static int request_frame(AVFilterLink *outlink) · 309 unmodified lines
310	310	static int query_formats(AVFilterContext *ctx)
311	311	{
312	312	static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE };
313		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
314		− return 0;
	313	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	314	+ if (!fmts_list)
	315	+ return AVERROR(ENOMEM);
	316	+ return ff_set_common_formats(ctx, fmts_list);
315	317	}
316	318
317	319	static const AVFilterPad cellauto_outputs[] = {

libavfilter/vsrc_life.c+5−1

@@ -423,7 +423,11 @@ static int query_formats(AVFilterContext *ctx) · 422 unmodified lines
423	423	pix_fmts[0] = AV_PIX_FMT_MONOBLACK;
424	424	life->draw = fill_picture_monoblack;
425	425	}
426		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
	426	+
	427	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	428	+ if (!fmts_list)
	429	+ return AVERROR(ENOMEM);
	430	+ ff_set_common_formats(ctx, fmts_list);
427	431	return 0;
428	432	}
429	433

libavfilter/vsrc_mandelbrot.c+4−2

@@ -153,8 +153,10 @@ static int query_formats(AVFilterContext *ctx) · 152 unmodified lines
153	153	AV_PIX_FMT_NONE
154	154	};
155	155
156		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
157		− return 0;
	156	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	157	+ if (!fmts_list)
	158	+ return AVERROR(ENOMEM);
	159	+ return ff_set_common_formats(ctx, fmts_list);
158	160	}
159	161
160	162	static int config_props(AVFilterLink *inlink)

libavfilter/vsrc_mptestsrc.c+4−2

@@ -291,8 +291,10 @@ static int query_formats(AVFilterContext *ctx) · 290 unmodified lines
291	291	AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
292	292	};
293	293
294		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
295		− return 0;
	294	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	295	+ if (!fmts_list)
	296	+ return AVERROR(ENOMEM);
	297	+ return ff_set_common_formats(ctx, fmts_list);
296	298	}
297	299
298	300	static int request_frame(AVFilterLink *outlink)

libavfilter/vsrc_testsrc.c+21−10

@@ -202,8 +202,7 @@ static av_cold int color_init(AVFilterContext *ctx) · 201 unmodified lines
202	202
203	203	static int color_query_formats(AVFilterContext *ctx)
204	204	{
205		− ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
206		− return 0;
	205	+ return ff_set_common_formats(ctx, ff_draw_supported_pixel_formats(0));
207	206	}
208	207
209	208	static int color_config_props(AVFilterLink *inlink)
@@ -366,8 +365,11 @@ static int haldclutsrc_query_formats(AVFilterContext *ctx) · 156 unmodified lines
366	365	AV_PIX_FMT_RGBA64, AV_PIX_FMT_BGRA64,
367	366	AV_PIX_FMT_NONE,
368	367	};
369		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
370		− return 0;
	368	+
	369	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	370	+ if (!fmts_list)
	371	+ return AVERROR(ENOMEM);
	372	+ return ff_set_common_formats(ctx, fmts_list);
371	373	}
372	374
373	375	static int haldclutsrc_config_props(AVFilterLink *outlink)
@@ -646,8 +648,11 @@ static int test_query_formats(AVFilterContext *ctx) · 272 unmodified lines
646	648	static const enum AVPixelFormat pix_fmts[] = {
647	649	AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE
648	650	};
649		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
650		− return 0;
	651	+
	652	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	653	+ if (!fmts_list)
	654	+ return AVERROR(ENOMEM);
	655	+ return ff_set_common_formats(ctx, fmts_list);
651	656	}
652	657
653	658	static const AVFilterPad avfilter_vsrc_testsrc_outputs[] = {
@@ -754,8 +759,11 @@ static int rgbtest_query_formats(AVFilterContext *ctx) · 100 unmodified lines
754	759	AV_PIX_FMT_RGB555, AV_PIX_FMT_BGR555,
755	760	AV_PIX_FMT_NONE
756	761	};
757		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
758		− return 0;
	762	+
	763	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	764	+ if (!fmts_list)
	765	+ return AVERROR(ENOMEM);
	766	+ return ff_set_common_formats(ctx, fmts_list);
759	767	}
760	768
761	769	static int rgbtest_config_props(AVFilterLink *outlink)
@@ -883,8 +891,11 @@ static int smptebars_query_formats(AVFilterContext *ctx) · 121 unmodified lines
883	891	AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
884	892	AV_PIX_FMT_NONE,
885	893	};
886		− ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
887		− return 0;
	894	+
	895	+ AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
	896	+ if (!fmts_list)
	897	+ return AVERROR(ENOMEM);
	898	+ return ff_set_common_formats(ctx, fmts_list);
888	899	}
889	900
890	901	static const AVFilterPad smptebars_outputs[] = {

avfilter: handle error in query_formats() in bunch of filters

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code