FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2012-2013 Oka Motofumi (chikuzen.mo at gmail dot com)
3			* Copyright (c) 2015 Paul B Mahol
4			*
5			* This file is part of FFmpeg.
6			*
7			* FFmpeg is free software; you can redistribute it and/or
8			* modify it under the terms of the GNU Lesser General Public
9			* License as published by the Free Software Foundation; either
10			* version 2.1 of the License, or (at your option) any later version.
11			*
12			* FFmpeg is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15			* Lesser General Public License for more details.
16			*
17			* You should have received a copy of the GNU Lesser General Public
18			* License along with FFmpeg; if not, write to the Free Software
19			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20			*/
21
22			#include "config_components.h"
23
24			#include "libavutil/avstring.h"
25			#include "libavutil/imgutils.h"
26			#include "libavutil/intreadwrite.h"
27			#include "libavutil/mem.h"
28			#include "libavutil/mem_internal.h"
29			#include "libavutil/opt.h"
30			#include "libavutil/pixdesc.h"
31			#include "avfilter.h"
32			#include "convolution.h"
33			#include "filters.h"
34			#include "video.h"
35
36			#define OFFSET(x) offsetof(ConvolutionContext, x)
37			#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
38
39			static const AVOption convolution_options[] = {
40			{ "0m", "set matrix for 1st plane", OFFSET(matrix_str[0]), AV_OPT_TYPE_STRING, {.str="0 0 0 0 1 0 0 0 0"}, 0, 0, FLAGS },
41			{ "1m", "set matrix for 2nd plane", OFFSET(matrix_str[1]), AV_OPT_TYPE_STRING, {.str="0 0 0 0 1 0 0 0 0"}, 0, 0, FLAGS },
42			{ "2m", "set matrix for 3rd plane", OFFSET(matrix_str[2]), AV_OPT_TYPE_STRING, {.str="0 0 0 0 1 0 0 0 0"}, 0, 0, FLAGS },
43			{ "3m", "set matrix for 4th plane", OFFSET(matrix_str[3]), AV_OPT_TYPE_STRING, {.str="0 0 0 0 1 0 0 0 0"}, 0, 0, FLAGS },
44			{ "0rdiv", "set rdiv for 1st plane", OFFSET(user_rdiv[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
45			{ "1rdiv", "set rdiv for 2nd plane", OFFSET(user_rdiv[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
46			{ "2rdiv", "set rdiv for 3rd plane", OFFSET(user_rdiv[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
47			{ "3rdiv", "set rdiv for 4th plane", OFFSET(user_rdiv[3]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
48			{ "0bias", "set bias for 1st plane", OFFSET(bias[0]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
49			{ "1bias", "set bias for 2nd plane", OFFSET(bias[1]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
50			{ "2bias", "set bias for 3rd plane", OFFSET(bias[2]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
51			{ "3bias", "set bias for 4th plane", OFFSET(bias[3]), AV_OPT_TYPE_FLOAT, {.dbl=0.0}, 0.0, INT_MAX, FLAGS},
52			{ "0mode", "set matrix mode for 1st plane", OFFSET(mode[0]), AV_OPT_TYPE_INT, {.i64=MATRIX_SQUARE}, 0, MATRIX_NBMODES-1, FLAGS, .unit = "mode" },
53			{ "1mode", "set matrix mode for 2nd plane", OFFSET(mode[1]), AV_OPT_TYPE_INT, {.i64=MATRIX_SQUARE}, 0, MATRIX_NBMODES-1, FLAGS, .unit = "mode" },
54			{ "2mode", "set matrix mode for 3rd plane", OFFSET(mode[2]), AV_OPT_TYPE_INT, {.i64=MATRIX_SQUARE}, 0, MATRIX_NBMODES-1, FLAGS, .unit = "mode" },
55			{ "3mode", "set matrix mode for 4th plane", OFFSET(mode[3]), AV_OPT_TYPE_INT, {.i64=MATRIX_SQUARE}, 0, MATRIX_NBMODES-1, FLAGS, .unit = "mode" },
56			{ "square", "square matrix", 0, AV_OPT_TYPE_CONST, {.i64=MATRIX_SQUARE}, 0, 0, FLAGS, .unit = "mode" },
57			{ "row", "single row matrix", 0, AV_OPT_TYPE_CONST, {.i64=MATRIX_ROW} , 0, 0, FLAGS, .unit = "mode" },
58			{ "column", "single column matrix", 0, AV_OPT_TYPE_CONST, {.i64=MATRIX_COLUMN}, 0, 0, FLAGS, .unit = "mode" },
59			{ NULL }
60			};
61
62			AVFILTER_DEFINE_CLASS(convolution);
63
64			static const int same3x3[9] = {0, 0, 0,
65			0, 1, 0,
66			0, 0, 0};
67
68			static const int same5x5[25] = {0, 0, 0, 0, 0,
69			0, 0, 0, 0, 0,
70			0, 0, 1, 0, 0,
71			0, 0, 0, 0, 0,
72			0, 0, 0, 0, 0};
73
74			static const int same7x7[49] = {0, 0, 0, 0, 0, 0, 0,
75			0, 0, 0, 0, 0, 0, 0,
76			0, 0, 0, 0, 0, 0, 0,
77			0, 0, 0, 1, 0, 0, 0,
78			0, 0, 0, 0, 0, 0, 0,
79			0, 0, 0, 0, 0, 0, 0,
80			0, 0, 0, 0, 0, 0, 0};
81
82			static const enum AVPixelFormat pix_fmts[] = {
83			AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV440P,
84			AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
85			AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUV420P,
86			AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
87			AV_PIX_FMT_YUVJ411P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
88			AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
89			AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
90			AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV440P12,
91			AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
92			AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
93			AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
94			AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
95			AV_PIX_FMT_YUVA422P12, AV_PIX_FMT_YUVA444P12,
96			AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
97			AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
98			AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
99			AV_PIX_FMT_GBRAP, AV_PIX_FMT_GBRAP10, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRAP16,
100			AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
101			AV_PIX_FMT_NONE
102			};
103
104			typedef struct ThreadData {
105			AVFrame *in, *out;
106			} ThreadData;
107
108		✗	static void filter16_prewitt(uint8_t *dstp, int width,
109			float scale, float delta, const int *const matrix,
110			const uint8_t *c[], int peak, int radius,
111			int dstride, int stride, int size)
112			{
113		✗	uint16_t *dst = (uint16_t *)dstp;
114			int x;
115
116		✗	for (x = 0; x < width; x++) {
117		✗	float suma = AV_RN16A(&c[0][2 * x]) * -1 + AV_RN16A(&c[1][2 * x]) * -1 + AV_RN16A(&c[2][2 * x]) * -1 +
118		✗	AV_RN16A(&c[6][2 * x]) * 1 + AV_RN16A(&c[7][2 * x]) * 1 + AV_RN16A(&c[8][2 * x]) * 1;
119		✗	float sumb = AV_RN16A(&c[0][2 * x]) * -1 + AV_RN16A(&c[2][2 * x]) * 1 + AV_RN16A(&c[3][2 * x]) * -1 +
120		✗	AV_RN16A(&c[5][2 * x]) * 1 + AV_RN16A(&c[6][2 * x]) * -1 + AV_RN16A(&c[8][2 * x]) * 1;
121
122		✗	dst[x] = av_clip(sqrtf(suma*suma + sumb*sumb) * scale + delta, 0, peak);
123			}
124		✗	}
125
126		✗	static void filter16_roberts(uint8_t *dstp, int width,
127			float scale, float delta, const int *const matrix,
128			const uint8_t *c[], int peak, int radius,
129			int dstride, int stride, int size)
130			{
131		✗	uint16_t *dst = (uint16_t *)dstp;
132			int x;
133
134		✗	for (x = 0; x < width; x++) {
135		✗	float suma = AV_RN16A(&c[0][2 * x]) * 1 + AV_RN16A(&c[1][2 * x]) * -1;
136		✗	float sumb = AV_RN16A(&c[4][2 * x]) * 1 + AV_RN16A(&c[3][2 * x]) * -1;
137
138		✗	dst[x] = av_clip(sqrtf(suma*suma + sumb*sumb) * scale + delta, 0, peak);
139			}
140		✗	}
141
142		✗	static void filter16_scharr(uint8_t *dstp, int width,
143			float scale, float delta, const int *const matrix,
144			const uint8_t *c[], int peak, int radius,
145			int dstride, int stride, int size)
146			{
147		✗	uint16_t *dst = (uint16_t *)dstp;
148			int x;
149
150		✗	for (x = 0; x < width; x++) {
151		✗	float suma = AV_RN16A(&c[0][2 * x]) * -47 + AV_RN16A(&c[1][2 * x]) * -162 + AV_RN16A(&c[2][2 * x]) * -47 +
152		✗	AV_RN16A(&c[6][2 * x]) * 47 + AV_RN16A(&c[7][2 * x]) * 162 + AV_RN16A(&c[8][2 * x]) * 47;
153		✗	float sumb = AV_RN16A(&c[0][2 * x]) * -47 + AV_RN16A(&c[2][2 * x]) * 47 + AV_RN16A(&c[3][2 * x]) * -162 +
154		✗	AV_RN16A(&c[5][2 * x]) * 162 + AV_RN16A(&c[6][2 * x]) * -47 + AV_RN16A(&c[8][2 * x]) * 47;
155
156		✗	suma /= 256.f;
157		✗	sumb /= 256.f;
158		✗	dst[x] = av_clip(sqrtf(suma*suma + sumb*sumb) * scale + delta, 0, peak);
159			}
160		✗	}
161
162		✗	static void filter16_kirsch(uint8_t *dstp, int width,
163			float scale, float delta, const int *const matrix,
164			const uint8_t *c[], int peak, int radius,
165			int dstride, int stride, int size)
166			{
167		✗	uint16_t *dst = (uint16_t *)dstp;
168		✗	const uint16_t *c0 = (const uint16_t *)c[0], *c1 = (const uint16_t *)c[1], *c2 = (const uint16_t *)c[2];
169		✗	const uint16_t *c3 = (const uint16_t *)c[3], *c5 = (const uint16_t *)c[5];
170		✗	const uint16_t *c6 = (const uint16_t *)c[6], *c7 = (const uint16_t *)c[7], *c8 = (const uint16_t *)c[8];
171			int x;
172
173		✗	for (x = 0; x < width; x++) {
174		✗	int sum0 = c0[x] * 5 + c1[x] * 5 + c2[x] * 5 +
175		✗	c3[x] * -3 + c5[x] * -3 +
176		✗	c6[x] * -3 + c7[x] * -3 + c8[x] * -3;
177		✗	int sum1 = c0[x] * -3 + c1[x] * 5 + c2[x] * 5 +
178		✗	c3[x] * 5 + c5[x] * -3 +
179		✗	c6[x] * -3 + c7[x] * -3 + c8[x] * -3;
180		✗	int sum2 = c0[x] * -3 + c1[x] * -3 + c2[x] * 5 +
181		✗	c3[x] * 5 + c5[x] * 5 +
182		✗	c6[x] * -3 + c7[x] * -3 + c8[x] * -3;
183		✗	int sum3 = c0[x] * -3 + c1[x] * -3 + c2[x] * -3 +
184		✗	c3[x] * 5 + c5[x] * 5 +
185		✗	c6[x] * 5 + c7[x] * -3 + c8[x] * -3;
186		✗	int sum4 = c0[x] * -3 + c1[x] * -3 + c2[x] * -3 +
187		✗	c3[x] * -3 + c5[x] * 5 +
188		✗	c6[x] * 5 + c7[x] * 5 + c8[x] * -3;
189		✗	int sum5 = c0[x] * -3 + c1[x] * -3 + c2[x] * -3 +
190		✗	c3[x] * -3 + c5[x] * -3 +
191		✗	c6[x] * 5 + c7[x] * 5 + c8[x] * 5;
192		✗	int sum6 = c0[x] * 5 + c1[x] * -3 + c2[x] * -3 +
193		✗	c3[x] * -3 + c5[x] * -3 +
194		✗	c6[x] * -3 + c7[x] * 5 + c8[x] * 5;
195		✗	int sum7 = c0[x] * 5 + c1[x] * 5 + c2[x] * -3 +
196		✗	c3[x] * -3 + c5[x] * -3 +
197		✗	c6[x] * -3 + c7[x] * -3 + c8[x] * 5;
198
199		✗	sum0 = FFMAX(sum0, sum1);
200		✗	sum2 = FFMAX(sum2, sum3);
201		✗	sum4 = FFMAX(sum4, sum5);
202		✗	sum6 = FFMAX(sum6, sum7);
203		✗	sum0 = FFMAX(sum0, sum2);
204		✗	sum4 = FFMAX(sum4, sum6);
205		✗	sum0 = FFMAX(sum0, sum4);
206
207		✗	dst[x] = av_clip(FFABS(sum0) * scale + delta, 0, peak);
208			}
209		✗	}
210
211		✗	static void filter_prewitt(uint8_t *dst, int width,
212			float scale, float delta, const int *const matrix,
213			const uint8_t *c[], int peak, int radius,
214			int dstride, int stride, int size)
215			{
216		✗	const uint8_t *c0 = c[0], *c1 = c[1], *c2 = c[2];
217		✗	const uint8_t *c3 = c[3], *c5 = c[5];
218		✗	const uint8_t *c6 = c[6], *c7 = c[7], *c8 = c[8];
219			int x;
220
221		✗	for (x = 0; x < width; x++) {
222		✗	float suma = c0[x] * -1 + c1[x] * -1 + c2[x] * -1 +
223		✗	c6[x] * 1 + c7[x] * 1 + c8[x] * 1;
224		✗	float sumb = c0[x] * -1 + c2[x] * 1 + c3[x] * -1 +
225		✗	c5[x] * 1 + c6[x] * -1 + c8[x] * 1;
226
227		✗	dst[x] = av_clip_uint8(sqrtf(suma*suma + sumb*sumb) * scale + delta);
228			}
229		✗	}
230
231		✗	static void filter_roberts(uint8_t *dst, int width,
232			float scale, float delta, const int *const matrix,
233			const uint8_t *c[], int peak, int radius,
234			int dstride, int stride, int size)
235			{
236			int x;
237
238		✗	for (x = 0; x < width; x++) {
239		✗	float suma = c[0][x] * 1 + c[1][x] * -1;
240		✗	float sumb = c[4][x] * 1 + c[3][x] * -1;
241
242		✗	dst[x] = av_clip_uint8(sqrtf(suma*suma + sumb*sumb) * scale + delta);
243			}
244		✗	}
245
246		✗	static void filter_scharr(uint8_t *dst, int width,
247			float scale, float delta, const int *const matrix,
248			const uint8_t *c[], int peak, int radius,
249			int dstride, int stride, int size)
250			{
251		✗	const uint8_t *c0 = c[0], *c1 = c[1], *c2 = c[2];
252		✗	const uint8_t *c3 = c[3], *c5 = c[5];
253		✗	const uint8_t *c6 = c[6], *c7 = c[7], *c8 = c[8];
254			int x;
255
256		✗	for (x = 0; x < width; x++) {
257		✗	float suma = c0[x] * -47 + c1[x] * -162 + c2[x] * -47 +
258		✗	c6[x] * 47 + c7[x] * 162 + c8[x] * 47;
259		✗	float sumb = c0[x] * -47 + c2[x] * 47 + c3[x] * -162 +
260		✗	c5[x] * 162 + c6[x] * -47 + c8[x] * 47;
261
262		✗	suma /= 256.f;
263		✗	sumb /= 256.f;
264		✗	dst[x] = av_clip_uint8(sqrtf(suma*suma + sumb*sumb) * scale + delta);
265			}
266		✗	}
267
268		✗	static void filter_kirsch(uint8_t *dst, int width,
269			float scale, float delta, const int *const matrix,
270			const uint8_t *c[], int peak, int radius,
271			int dstride, int stride, int size)
272			{
273		✗	const uint8_t *c0 = c[0], *c1 = c[1], *c2 = c[2];
274		✗	const uint8_t *c3 = c[3], *c5 = c[5];
275		✗	const uint8_t *c6 = c[6], *c7 = c[7], *c8 = c[8];
276			int x;
277
278		✗	for (x = 0; x < width; x++) {
279		✗	int sum0 = c0[x] * 5 + c1[x] * 5 + c2[x] * 5 +
280		✗	c3[x] * -3 + c5[x] * -3 +
281		✗	c6[x] * -3 + c7[x] * -3 + c8[x] * -3;
282		✗	int sum1 = c0[x] * -3 + c1[x] * 5 + c2[x] * 5 +
283		✗	c3[x] * 5 + c5[x] * -3 +
284		✗	c6[x] * -3 + c7[x] * -3 + c8[x] * -3;
285		✗	int sum2 = c0[x] * -3 + c1[x] * -3 + c2[x] * 5 +
286		✗	c3[x] * 5 + c5[x] * 5 +
287		✗	c6[x] * -3 + c7[x] * -3 + c8[x] * -3;
288		✗	int sum3 = c0[x] * -3 + c1[x] * -3 + c2[x] * -3 +
289		✗	c3[x] * 5 + c5[x] * 5 +
290		✗	c6[x] * 5 + c7[x] * -3 + c8[x] * -3;
291		✗	int sum4 = c0[x] * -3 + c1[x] * -3 + c2[x] * -3 +
292		✗	c3[x] * -3 + c5[x] * 5 +
293		✗	c6[x] * 5 + c7[x] * 5 + c8[x] * -3;
294		✗	int sum5 = c0[x] * -3 + c1[x] * -3 + c2[x] * -3 +
295		✗	c3[x] * -3 + c5[x] * -3 +
296		✗	c6[x] * 5 + c7[x] * 5 + c8[x] * 5;
297		✗	int sum6 = c0[x] * 5 + c1[x] * -3 + c2[x] * -3 +
298		✗	c3[x] * -3 + c5[x] * -3 +
299		✗	c6[x] * -3 + c7[x] * 5 + c8[x] * 5;
300		✗	int sum7 = c0[x] * 5 + c1[x] * 5 + c2[x] * -3 +
301		✗	c3[x] * -3 + c5[x] * -3 +
302		✗	c6[x] * -3 + c7[x] * -3 + c8[x] * 5;
303
304		✗	sum0 = FFMAX(sum0, sum1);
305		✗	sum2 = FFMAX(sum2, sum3);
306		✗	sum4 = FFMAX(sum4, sum5);
307		✗	sum6 = FFMAX(sum6, sum7);
308		✗	sum0 = FFMAX(sum0, sum2);
309		✗	sum4 = FFMAX(sum4, sum6);
310		✗	sum0 = FFMAX(sum0, sum4);
311
312		✗	dst[x] = av_clip_uint8(FFABS(sum0) * scale + delta);
313			}
314		✗	}
315
316		✗	static void filter16_3x3(uint8_t *dstp, int width,
317			float rdiv, float bias, const int *const matrix,
318			const uint8_t *c[], int peak, int radius,
319			int dstride, int stride, int size)
320			{
321		✗	uint16_t *dst = (uint16_t *)dstp;
322			int x;
323
324		✗	for (x = 0; x < width; x++) {
325		✗	unsigned sum = (unsigned)AV_RN16A(&c[0][2 * x]) * matrix[0] +
326		✗	(unsigned)AV_RN16A(&c[1][2 * x]) * matrix[1] +
327		✗	(unsigned)AV_RN16A(&c[2][2 * x]) * matrix[2] +
328		✗	(unsigned)AV_RN16A(&c[3][2 * x]) * matrix[3] +
329		✗	(unsigned)AV_RN16A(&c[4][2 * x]) * matrix[4] +
330		✗	(unsigned)AV_RN16A(&c[5][2 * x]) * matrix[5] +
331		✗	(unsigned)AV_RN16A(&c[6][2 * x]) * matrix[6] +
332		✗	(unsigned)AV_RN16A(&c[7][2 * x]) * matrix[7] +
333		✗	(unsigned)AV_RN16A(&c[8][2 * x]) * matrix[8];
334		✗	dst[x] = av_clip((int)sum * rdiv + bias + 0.5f, 0, peak);
335			}
336		✗	}
337
338		✗	static void filter16_5x5(uint8_t *dstp, int width,
339			float rdiv, float bias, const int *const matrix,
340			const uint8_t *c[], int peak, int radius,
341			int dstride, int stride, int size)
342			{
343		✗	uint16_t *dst = (uint16_t *)dstp;
344			int x;
345
346		✗	for (x = 0; x < width; x++) {
347			int i;
348		✗	unsigned sum = 0;
349
350		✗	for (i = 0; i < 25; i++)
351		✗	sum += (unsigned)AV_RN16A(&c[i][2 * x]) * matrix[i];
352
353		✗	dst[x] = av_clip((int)sum * rdiv + bias + 0.5f, 0, peak);
354			}
355		✗	}
356
357		✗	static void filter16_7x7(uint8_t *dstp, int width,
358			float rdiv, float bias, const int *const matrix,
359			const uint8_t *c[], int peak, int radius,
360			int dstride, int stride, int size)
361			{
362		✗	uint16_t *dst = (uint16_t *)dstp;
363			int x;
364
365		✗	for (x = 0; x < width; x++) {
366			int i;
367		✗	unsigned sum = 0;
368
369		✗	for (i = 0; i < 49; i++)
370		✗	sum += (unsigned)AV_RN16A(&c[i][2 * x]) * matrix[i];
371
372		✗	dst[x] = av_clip((int)sum * rdiv + bias + 0.5f, 0, peak);
373			}
374		✗	}
375
376		✗	static void filter16_row(uint8_t *dstp, int width,
377			float rdiv, float bias, const int *const matrix,
378			const uint8_t *c[], int peak, int radius,
379			int dstride, int stride, int size)
380			{
381		✗	uint16_t *dst = (uint16_t *)dstp;
382			int x;
383
384		✗	for (x = 0; x < width; x++) {
385			int i;
386		✗	unsigned sum = 0;
387
388		✗	for (i = 0; i < 2 * radius + 1; i++)
389		✗	sum += (unsigned)AV_RN16A(&c[i][2 * x]) * matrix[i];
390
391		✗	dst[x] = av_clip((int)sum * rdiv + bias + 0.5f, 0, peak);
392			}
393		✗	}
394
395		✗	static void filter16_column(uint8_t *dstp, int height,
396			float rdiv, float bias, const int *const matrix,
397			const uint8_t *c[], int peak, int radius,
398			int dstride, int stride, int size)
399			{
400			DECLARE_ALIGNED(64, unsigned, sum)[16];
401		✗	uint16_t *dst = (uint16_t *)dstp;
402		✗	const int width = FFMIN(16, size);
403
404		✗	for (int y = 0; y < height; y++) {
405
406		✗	memset(sum, 0, sizeof(sum));
407		✗	for (int i = 0; i < 2 * radius + 1; i++) {
408		✗	for (int off16 = 0; off16 < width; off16++)
409		✗	sum[off16] += (unsigned)AV_RN16A(&c[i][0 + y * stride + off16 * 2]) * matrix[i];
410			}
411
412		✗	for (int off16 = 0; off16 < width; off16++) {
413		✗	dst[off16] = av_clip((int)sum[off16] * rdiv + bias + 0.5f, 0, peak);
414			}
415		✗	dst += dstride / 2;
416			}
417		✗	}
418
419		✗	static void filter_7x7(uint8_t *dst, int width,
420			float rdiv, float bias, const int *const matrix,
421			const uint8_t *c[], int peak, int radius,
422			int dstride, int stride, int size)
423			{
424			int x;
425
426		✗	for (x = 0; x < width; x++) {
427			int i;
428		✗	unsigned sum = 0;
429
430		✗	for (i = 0; i < 49; i++)
431		✗	sum += (unsigned)c[i][x] * matrix[i];
432
433		✗	dst[x] = av_clip_uint8((int)sum * rdiv + bias + 0.5f);
434			}
435		✗	}
436
437		✗	static void filter_5x5(uint8_t *dst, int width,
438			float rdiv, float bias, const int *const matrix,
439			const uint8_t *c[], int peak, int radius,
440			int dstride, int stride, int size)
441			{
442			int x;
443
444		✗	for (x = 0; x < width; x++) {
445			int i;
446		✗	unsigned sum = 0;
447
448		✗	for (i = 0; i < 25; i++)
449		✗	sum += (unsigned)c[i][x] * matrix[i];
450
451		✗	dst[x] = av_clip_uint8((int)sum * rdiv + bias + 0.5f);
452			}
453		✗	}
454
455		✗	static void filter_3x3(uint8_t *dst, int width,
456			float rdiv, float bias, const int *const matrix,
457			const uint8_t *c[], int peak, int radius,
458			int dstride, int stride, int size)
459			{
460		✗	const uint8_t *c0 = c[0], *c1 = c[1], *c2 = c[2];
461		✗	const uint8_t *c3 = c[3], *c4 = c[4], *c5 = c[5];
462		✗	const uint8_t *c6 = c[6], *c7 = c[7], *c8 = c[8];
463			int x;
464
465		✗	for (x = 0; x < width; x++) {
466		✗	unsigned sum = (unsigned)c0[x] * matrix[0] + (unsigned)c1[x] * matrix[1] + (unsigned)c2[x] * matrix[2] +
467		✗	(unsigned)c3[x] * matrix[3] + (unsigned)c4[x] * matrix[4] + (unsigned)c5[x] * matrix[5] +
468		✗	(unsigned)c6[x] * matrix[6] + (unsigned)c7[x] * matrix[7] + (unsigned)c8[x] * matrix[8];
469		✗	dst[x] = av_clip_uint8((int)sum * rdiv + bias + 0.5f);
470			}
471		✗	}
472
473		✗	static void filter_row(uint8_t *dst, int width,
474			float rdiv, float bias, const int *const matrix,
475			const uint8_t *c[], int peak, int radius,
476			int dstride, int stride, int size)
477			{
478			int x;
479
480		✗	for (x = 0; x < width; x++) {
481			int i;
482		✗	unsigned sum = 0;
483
484		✗	for (i = 0; i < 2 * radius + 1; i++)
485		✗	sum += (unsigned)c[i][x] * matrix[i];
486
487		✗	dst[x] = av_clip_uint8((int)sum * rdiv + bias + 0.5f);
488			}
489		✗	}
490
491		✗	static void filter_column(uint8_t *dst, int height,
492			float rdiv, float bias, const int *const matrix,
493			const uint8_t *c[], int peak, int radius,
494			int dstride, int stride, int size)
495			{
496			DECLARE_ALIGNED(64, unsigned, sum)[16];
497
498		✗	for (int y = 0; y < height; y++) {
499		✗	memset(sum, 0, sizeof(sum));
500
501		✗	for (int i = 0; i < 2 * radius + 1; i++) {
502		✗	for (int off16 = 0; off16 < 16; off16++)
503		✗	sum[off16] += (unsigned)c[i][0 + y * stride + off16] * matrix[i];
504			}
505
506		✗	for (int off16 = 0; off16 < 16; off16++) {
507		✗	dst[off16] = av_clip_uint8((int)sum[off16] * rdiv + bias + 0.5f);
508			}
509		✗	dst += dstride;
510			}
511		✗	}
512
513		✗	static void setup_5x5(int radius, const uint8_t *c[], const uint8_t *src, int stride,
514			int x, int w, int y, int h, int bpc)
515			{
516			int i;
517
518		✗	for (i = 0; i < 25; i++) {
519		✗	int xoff = avpriv_mirror(x + (i % 5) - 2, w - 1);
520		✗	int yoff = avpriv_mirror(y + (i / 5) - 2, h - 1);
521
522		✗	c[i] = src + xoff * bpc + yoff * stride;
523			}
524		✗	}
525
526		✗	static void setup_7x7(int radius, const uint8_t *c[], const uint8_t *src, int stride,
527			int x, int w, int y, int h, int bpc)
528			{
529			int i;
530
531		✗	for (i = 0; i < 49; i++) {
532		✗	int xoff = avpriv_mirror(x + (i % 7) - 3, w - 1);
533		✗	int yoff = avpriv_mirror(y + (i / 7) - 3, h - 1);
534
535		✗	c[i] = src + xoff * bpc + yoff * stride;
536			}
537		✗	}
538
539		✗	static void setup_row(int radius, const uint8_t *c[], const uint8_t *src, int stride,
540			int x, int w, int y, int h, int bpc)
541			{
542			int i;
543
544		✗	for (i = 0; i < radius * 2 + 1; i++) {
545		✗	int xoff = avpriv_mirror(x + i - radius, w - 1);
546
547		✗	c[i] = src + xoff * bpc + y * stride;
548			}
549		✗	}
550
551		✗	static void setup_column(int radius, const uint8_t *c[], const uint8_t *src, int stride,
552			int x, int w, int y, int h, int bpc)
553			{
554			int i;
555
556		✗	for (i = 0; i < radius * 2 + 1; i++) {
557		✗	int xoff = avpriv_mirror(x + i - radius, h - 1);
558
559		✗	c[i] = src + y * bpc + xoff * stride;
560			}
561		✗	}
562
563		✗	static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
564			{
565		✗	ConvolutionContext *s = ctx->priv;
566		✗	ThreadData *td = arg;
567		✗	AVFrame *in = td->in;
568		✗	AVFrame *out = td->out;
569			int plane;
570
571		✗	for (plane = 0; plane < s->nb_planes; plane++) {
572		✗	const int mode = s->mode[plane];
573		✗	const int bpc = s->bpc;
574		✗	const int radius = s->size[plane] / 2;
575		✗	const int height = s->planeheight[plane];
576		✗	const int width = s->planewidth[plane];
577		✗	const int stride = in->linesize[plane];
578		✗	const int dstride = out->linesize[plane];
579		✗	const int sizeh = mode == MATRIX_COLUMN ? width : height;
580		✗	const int sizew = mode == MATRIX_COLUMN ? height : width;
581		✗	const int slice_start = ff_slice_pos(sizeh, jobnr, nb_jobs);
582		✗	const int slice_end = ff_slice_pos(sizeh, jobnr + 1, nb_jobs);
583		✗	const float rdiv = s->rdiv[plane];
584		✗	const float bias = s->bias[plane];
585		✗	const uint8_t *src = in->data[plane];
586		✗	const int dst_pos = slice_start * (mode == MATRIX_COLUMN ? bpc : dstride);
587		✗	uint8_t *dst = out->data[plane] + dst_pos;
588		✗	const int *matrix = s->matrix[plane];
589		✗	const int step = mode == MATRIX_COLUMN ? 16 : 1;
590			const uint8_t *c[49];
591			int y, x;
592
593		✗	if (s->copy[plane]) {
594		✗	if (mode == MATRIX_COLUMN)
595		✗	av_image_copy_plane(dst, dstride, src + slice_start * bpc, stride,
596		✗	(slice_end - slice_start) * bpc, height);
597			else
598		✗	av_image_copy_plane(dst, dstride, src + slice_start * stride, stride,
599			width * bpc, slice_end - slice_start);
600		✗	continue;
601			}
602		✗	for (y = slice_start; y < slice_end; y += step) {
603		✗	const int left = FFMIN(radius, sizew);
604		✗	const int right = FFMAX(left, sizew - radius);
605		✗	const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : left * bpc;
606		✗	const int yoff = mode == MATRIX_COLUMN ? left * dstride : 0;
607
608		✗	for (x = 0; x < left; x++) {
609		✗	const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : x * bpc;
610		✗	const int yoff = mode == MATRIX_COLUMN ? x * dstride : 0;
611
612		✗	s->setup[plane](radius, c, src, stride, x, width, y, height, bpc);
613		✗	s->filter[plane](dst + yoff + xoff, 1, rdiv,
614			bias, matrix, c, s->max, radius,
615			dstride, stride, slice_end - step);
616			}
617		✗	s->setup[plane](radius, c, src, stride, left, width, y, height, bpc);
618		✗	s->filter[plane](dst + yoff + xoff, right - left,
619			rdiv, bias, matrix, c, s->max, radius,
620			dstride, stride, slice_end - step);
621		✗	for (x = right; x < sizew; x++) {
622		✗	const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : x * bpc;
623		✗	const int yoff = mode == MATRIX_COLUMN ? x * dstride : 0;
624
625		✗	s->setup[plane](radius, c, src, stride, x, width, y, height, bpc);
626		✗	s->filter[plane](dst + yoff + xoff, 1, rdiv,
627			bias, matrix, c, s->max, radius,
628			dstride, stride, slice_end - step);
629			}
630		✗	if (mode != MATRIX_COLUMN)
631		✗	dst += dstride;
632			}
633			}
634
635		✗	return 0;
636			}
637
638		✗	static int param_init(AVFilterContext *ctx)
639			{
640		✗	ConvolutionContext *s = ctx->priv;
641		✗	AVFilterLink *inlink = ctx->inputs[0];
642		✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
643			int p, i;
644
645		✗	s->depth = desc->comp[0].depth;
646		✗	s->max = (1 << s->depth) - 1;
647
648		✗	s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
649		✗	s->planewidth[0] = s->planewidth[3] = inlink->w;
650		✗	s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
651		✗	s->planeheight[0] = s->planeheight[3] = inlink->h;
652
653		✗	s->nb_planes = av_pix_fmt_count_planes(inlink->format);
654		✗	s->nb_threads = ff_filter_get_nb_threads(ctx);
655		✗	s->bpc = (s->depth + 7) / 8;
656
657		✗	if (!strcmp(ctx->filter->name, "convolution")) {
658		✗	for (i = 0; i < 4; i++) {
659		✗	int *matrix = (int *)s->matrix[i];
660		✗	char *orig, *p, *arg, *saveptr = NULL;
661		✗	float sum = 1.f;
662
663		✗	p = orig = av_strdup(s->matrix_str[i]);
664		✗	if (p) {
665		✗	s->matrix_length[i] = 0;
666		✗	s->rdiv[i] = s->user_rdiv[i];
667		✗	sum = 0.f;
668
669		✗	while (s->matrix_length[i] < 49) {
670		✗	if (!(arg = av_strtok(p, " |", &saveptr)))
671		✗	break;
672
673		✗	p = NULL;
674		✗	sscanf(arg, "%d", &matrix[s->matrix_length[i]]);
675		✗	sum += matrix[s->matrix_length[i]];
676		✗	s->matrix_length[i]++;
677			}
678
679		✗	av_freep(&orig);
680		✗	if (!(s->matrix_length[i] & 1)) {
681		✗	av_log(ctx, AV_LOG_ERROR, "number of matrix elements must be odd\n");
682		✗	return AVERROR(EINVAL);
683			}
684			}
685
686		✗	if (s->mode[i] == MATRIX_ROW) {
687		✗	s->filter[i] = filter_row;
688		✗	s->setup[i] = setup_row;
689		✗	s->size[i] = s->matrix_length[i];
690		✗	} else if (s->mode[i] == MATRIX_COLUMN) {
691		✗	s->filter[i] = filter_column;
692		✗	s->setup[i] = setup_column;
693		✗	s->size[i] = s->matrix_length[i];
694		✗	} else if (s->matrix_length[i] == 9) {
695		✗	s->size[i] = 3;
696
697		✗	if (!memcmp(matrix, same3x3, sizeof(same3x3))) {
698		✗	s->copy[i] = 1;
699			} else {
700		✗	s->filter[i] = filter_3x3;
701		✗	s->copy[i] = 0;
702			}
703		✗	s->setup[i] = setup_3x3;
704		✗	} else if (s->matrix_length[i] == 25) {
705		✗	s->size[i] = 5;
706		✗	if (!memcmp(matrix, same5x5, sizeof(same5x5))) {
707		✗	s->copy[i] = 1;
708			} else {
709		✗	s->filter[i] = filter_5x5;
710		✗	s->copy[i] = 0;
711			}
712		✗	s->setup[i] = setup_5x5;
713		✗	} else if (s->matrix_length[i] == 49) {
714		✗	s->size[i] = 7;
715		✗	if (!memcmp(matrix, same7x7, sizeof(same7x7))) {
716		✗	s->copy[i] = 1;
717			} else {
718		✗	s->filter[i] = filter_7x7;
719		✗	s->copy[i] = 0;
720			}
721		✗	s->setup[i] = setup_7x7;
722			} else {
723		✗	return AVERROR(EINVAL);
724			}
725
726		✗	if (sum == 0)
727		✗	sum = 1;
728		✗	if (s->rdiv[i] == 0)
729		✗	s->rdiv[i] = 1. / sum;
730
731		✗	if (s->copy[i] && (s->rdiv[i] != 1. || s->bias[i] != 0.))
732		✗	s->copy[i] = 0;
733			}
734		✗	} else if (!strcmp(ctx->filter->name, "prewitt")) {
735		✗	for (i = 0; i < 4; i++) {
736		✗	s->filter[i] = filter_prewitt;
737		✗	s->copy[i] = !((1 << i) & s->planes);
738		✗	s->size[i] = 3;
739		✗	s->setup[i] = setup_3x3;
740		✗	s->rdiv[i] = s->scale;
741		✗	s->bias[i] = s->delta;
742			}
743		✗	} else if (!strcmp(ctx->filter->name, "roberts")) {
744		✗	for (i = 0; i < 4; i++) {
745		✗	s->filter[i] = filter_roberts;
746		✗	s->copy[i] = !((1 << i) & s->planes);
747		✗	s->size[i] = 3;
748		✗	s->setup[i] = setup_3x3;
749		✗	s->rdiv[i] = s->scale;
750		✗	s->bias[i] = s->delta;
751			}
752			#if CONFIG_SOBEL_FILTER
753		✗	} else if (!strcmp(ctx->filter->name, "sobel")) {
754		✗	ff_sobel_init(s, s->depth, s->nb_planes);
755			#endif
756		✗	} else if (!strcmp(ctx->filter->name, "kirsch")) {
757		✗	for (i = 0; i < 4; i++) {
758		✗	s->filter[i] = filter_kirsch;
759		✗	s->copy[i] = !((1 << i) & s->planes);
760		✗	s->size[i] = 3;
761		✗	s->setup[i] = setup_3x3;
762		✗	s->rdiv[i] = s->scale;
763		✗	s->bias[i] = s->delta;
764			}
765		✗	} else if (!strcmp(ctx->filter->name, "scharr")) {
766		✗	for (i = 0; i < 4; i++) {
767		✗	s->filter[i] = filter_scharr;
768		✗	s->copy[i] = !((1 << i) & s->planes);
769		✗	s->size[i] = 3;
770		✗	s->setup[i] = setup_3x3;
771		✗	s->rdiv[i] = s->scale;
772		✗	s->bias[i] = s->delta;
773			}
774			}
775
776		✗	if (!strcmp(ctx->filter->name, "convolution")) {
777		✗	if (s->depth > 8) {
778		✗	for (p = 0; p < s->nb_planes; p++) {
779		✗	if (s->mode[p] == MATRIX_ROW)
780		✗	s->filter[p] = filter16_row;
781		✗	else if (s->mode[p] == MATRIX_COLUMN)
782		✗	s->filter[p] = filter16_column;
783		✗	else if (s->size[p] == 3)
784		✗	s->filter[p] = filter16_3x3;
785		✗	else if (s->size[p] == 5)
786		✗	s->filter[p] = filter16_5x5;
787		✗	else if (s->size[p] == 7)
788		✗	s->filter[p] = filter16_7x7;
789			}
790			}
791			#if CONFIG_CONVOLUTION_FILTER && ARCH_X86_64 && HAVE_X86ASM
792		✗	ff_convolution_init_x86(s);
793			#endif
794		✗	} else if (!strcmp(ctx->filter->name, "prewitt")) {
795		✗	if (s->depth > 8)
796		✗	for (p = 0; p < s->nb_planes; p++)
797		✗	s->filter[p] = filter16_prewitt;
798		✗	} else if (!strcmp(ctx->filter->name, "roberts")) {
799		✗	if (s->depth > 8)
800		✗	for (p = 0; p < s->nb_planes; p++)
801		✗	s->filter[p] = filter16_roberts;
802		✗	} else if (!strcmp(ctx->filter->name, "kirsch")) {
803		✗	if (s->depth > 8)
804		✗	for (p = 0; p < s->nb_planes; p++)
805		✗	s->filter[p] = filter16_kirsch;
806		✗	} else if (!strcmp(ctx->filter->name, "scharr")) {
807		✗	if (s->depth > 8)
808		✗	for (p = 0; p < s->nb_planes; p++)
809		✗	s->filter[p] = filter16_scharr;
810			}
811
812		✗	return 0;
813			}
814
815		✗	static int config_input(AVFilterLink *inlink)
816			{
817		✗	AVFilterContext *ctx = inlink->dst;
818		✗	return param_init(ctx);
819			}
820
821		✗	static int filter_frame(AVFilterLink *inlink, AVFrame *in)
822			{
823		✗	AVFilterContext *ctx = inlink->dst;
824		✗	ConvolutionContext *s = ctx->priv;
825		✗	AVFilterLink *outlink = ctx->outputs[0];
826			AVFrame *out;
827			ThreadData td;
828
829		✗	out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
830		✗	if (!out) {
831		✗	av_frame_free(&in);
832		✗	return AVERROR(ENOMEM);
833			}
834		✗	av_frame_copy_props(out, in);
835
836		✗	td.in = in;
837		✗	td.out = out;
838		✗	ff_filter_execute(ctx, filter_slice, &td, NULL,
839		✗	FFMIN3(s->planeheight[1], s->planewidth[1], s->nb_threads));
840
841		✗	av_frame_free(&in);
842		✗	return ff_filter_frame(outlink, out);
843			}
844
845		✗	static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
846			char *res, int res_len, int flags)
847			{
848			int ret;
849
850		✗	ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
851		✗	if (ret < 0)
852		✗	return ret;
853
854		✗	return param_init(ctx);
855			}
856
857			static const AVFilterPad convolution_inputs[] = {
858			{
859			.name = "default",
860			.type = AVMEDIA_TYPE_VIDEO,
861			.config_props = config_input,
862			.filter_frame = filter_frame,
863			},
864			};
865
866			#if CONFIG_CONVOLUTION_FILTER
867
868			const FFFilter ff_vf_convolution = {
869			.p.name = "convolution",
870			.p.description = NULL_IF_CONFIG_SMALL("Apply convolution filter."),
871			.p.priv_class = &convolution_class,
872			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
873			.priv_size = sizeof(ConvolutionContext),
874			FILTER_INPUTS(convolution_inputs),
875			FILTER_OUTPUTS(ff_video_default_filterpad),
876			FILTER_PIXFMTS_ARRAY(pix_fmts),
877			.process_command = process_command,
878			};
879
880			#endif /* CONFIG_CONVOLUTION_FILTER */
881
882			static const AVOption common_options[] = {
883			{ "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=15}, 0, 15, FLAGS},
884			{ "scale", "set scale", OFFSET(scale), AV_OPT_TYPE_FLOAT, {.dbl=1.0}, 0.0, 65535, FLAGS},
885			{ "delta", "set delta", OFFSET(delta), AV_OPT_TYPE_FLOAT, {.dbl=0}, -65535, 65535, FLAGS},
886			{ NULL }
887			};
888
889			AVFILTER_DEFINE_CLASS_EXT(common, "kirsch/prewitt/roberts/scharr/sobel",
890			common_options);
891
892			#if CONFIG_PREWITT_FILTER
893
894			const FFFilter ff_vf_prewitt = {
895			.p.name = "prewitt",
896			.p.description = NULL_IF_CONFIG_SMALL("Apply prewitt operator."),
897			.p.priv_class = &common_class,
898			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
899			.priv_size = sizeof(ConvolutionContext),
900			FILTER_INPUTS(convolution_inputs),
901			FILTER_OUTPUTS(ff_video_default_filterpad),
902			FILTER_PIXFMTS_ARRAY(pix_fmts),
903			.process_command = process_command,
904			};
905
906			#endif /* CONFIG_PREWITT_FILTER */
907
908			#if CONFIG_SOBEL_FILTER
909
910			const FFFilter ff_vf_sobel = {
911			.p.name = "sobel",
912			.p.description = NULL_IF_CONFIG_SMALL("Apply sobel operator."),
913			.p.priv_class = &common_class,
914			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
915			.priv_size = sizeof(ConvolutionContext),
916			FILTER_INPUTS(convolution_inputs),
917			FILTER_OUTPUTS(ff_video_default_filterpad),
918			FILTER_PIXFMTS_ARRAY(pix_fmts),
919			.process_command = process_command,
920			};
921
922			#endif /* CONFIG_SOBEL_FILTER */
923
924			#if CONFIG_ROBERTS_FILTER
925
926			const FFFilter ff_vf_roberts = {
927			.p.name = "roberts",
928			.p.description = NULL_IF_CONFIG_SMALL("Apply roberts cross operator."),
929			.p.priv_class = &common_class,
930			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
931			.priv_size = sizeof(ConvolutionContext),
932			FILTER_INPUTS(convolution_inputs),
933			FILTER_OUTPUTS(ff_video_default_filterpad),
934			FILTER_PIXFMTS_ARRAY(pix_fmts),
935			.process_command = process_command,
936			};
937
938			#endif /* CONFIG_ROBERTS_FILTER */
939
940			#if CONFIG_KIRSCH_FILTER
941
942			const FFFilter ff_vf_kirsch = {
943			.p.name = "kirsch",
944			.p.description = NULL_IF_CONFIG_SMALL("Apply kirsch operator."),
945			.p.priv_class = &common_class,
946			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
947			.priv_size = sizeof(ConvolutionContext),
948			FILTER_INPUTS(convolution_inputs),
949			FILTER_OUTPUTS(ff_video_default_filterpad),
950			FILTER_PIXFMTS_ARRAY(pix_fmts),
951			.process_command = process_command,
952			};
953
954			#endif /* CONFIG_KIRSCH_FILTER */
955
956			#if CONFIG_SCHARR_FILTER
957
958			const FFFilter ff_vf_scharr = {
959			.p.name = "scharr",
960			.p.description = NULL_IF_CONFIG_SMALL("Apply scharr operator."),
961			.p.priv_class = &common_class,
962			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
963			.priv_size = sizeof(ConvolutionContext),
964			FILTER_INPUTS(convolution_inputs),
965			FILTER_OUTPUTS(ff_video_default_filterpad),
966			FILTER_PIXFMTS_ARRAY(pix_fmts),
967			.process_command = process_command,
968			};
969
970			#endif /* CONFIG_SCHARR_FILTER */
971