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		✗	int sum = AV_RN16A(&c[0][2 * x]) * matrix[0] +
326		✗	AV_RN16A(&c[1][2 * x]) * matrix[1] +
327		✗	AV_RN16A(&c[2][2 * x]) * matrix[2] +
328		✗	AV_RN16A(&c[3][2 * x]) * matrix[3] +
329		✗	AV_RN16A(&c[4][2 * x]) * matrix[4] +
330		✗	AV_RN16A(&c[5][2 * x]) * matrix[5] +
331		✗	AV_RN16A(&c[6][2 * x]) * matrix[6] +
332		✗	AV_RN16A(&c[7][2 * x]) * matrix[7] +
333		✗	AV_RN16A(&c[8][2 * x]) * matrix[8];
334		✗	sum = (int)(sum * rdiv + bias + 0.5f);
335		✗	dst[x] = av_clip(sum, 0, peak);
336			}
337		✗	}
338
339		✗	static void filter16_5x5(uint8_t *dstp, int width,
340			float rdiv, float bias, const int *const matrix,
341			const uint8_t *c[], int peak, int radius,
342			int dstride, int stride, int size)
343			{
344		✗	uint16_t *dst = (uint16_t *)dstp;
345			int x;
346
347		✗	for (x = 0; x < width; x++) {
348		✗	int i, sum = 0;
349
350		✗	for (i = 0; i < 25; i++)
351		✗	sum += AV_RN16A(&c[i][2 * x]) * matrix[i];
352
353		✗	sum = (int)(sum * rdiv + bias + 0.5f);
354		✗	dst[x] = av_clip(sum, 0, peak);
355			}
356		✗	}
357
358		✗	static void filter16_7x7(uint8_t *dstp, int width,
359			float rdiv, float bias, const int *const matrix,
360			const uint8_t *c[], int peak, int radius,
361			int dstride, int stride, int size)
362			{
363		✗	uint16_t *dst = (uint16_t *)dstp;
364			int x;
365
366		✗	for (x = 0; x < width; x++) {
367		✗	int i, sum = 0;
368
369		✗	for (i = 0; i < 49; i++)
370		✗	sum += AV_RN16A(&c[i][2 * x]) * matrix[i];
371
372		✗	sum = (int)(sum * rdiv + bias + 0.5f);
373		✗	dst[x] = av_clip(sum, 0, peak);
374			}
375		✗	}
376
377		✗	static void filter16_row(uint8_t *dstp, int width,
378			float rdiv, float bias, const int *const matrix,
379			const uint8_t *c[], int peak, int radius,
380			int dstride, int stride, int size)
381			{
382		✗	uint16_t *dst = (uint16_t *)dstp;
383			int x;
384
385		✗	for (x = 0; x < width; x++) {
386		✗	int i, sum = 0;
387
388		✗	for (i = 0; i < 2 * radius + 1; i++)
389		✗	sum += AV_RN16A(&c[i][2 * x]) * matrix[i];
390
391		✗	sum = (int)(sum * rdiv + bias + 0.5f);
392		✗	dst[x] = av_clip(sum, 0, peak);
393			}
394		✗	}
395
396		✗	static void filter16_column(uint8_t *dstp, int height,
397			float rdiv, float bias, const int *const matrix,
398			const uint8_t *c[], int peak, int radius,
399			int dstride, int stride, int size)
400			{
401			DECLARE_ALIGNED(64, int, sum)[16];
402		✗	uint16_t *dst = (uint16_t *)dstp;
403		✗	const int width = FFMIN(16, size);
404
405		✗	for (int y = 0; y < height; y++) {
406
407		✗	memset(sum, 0, sizeof(sum));
408		✗	for (int i = 0; i < 2 * radius + 1; i++) {
409		✗	for (int off16 = 0; off16 < width; off16++)
410		✗	sum[off16] += AV_RN16A(&c[i][0 + y * stride + off16 * 2]) * matrix[i];
411			}
412
413		✗	for (int off16 = 0; off16 < width; off16++) {
414		✗	sum[off16] = (int)(sum[off16] * rdiv + bias + 0.5f);
415		✗	dst[off16] = av_clip(sum[off16], 0, peak);
416			}
417		✗	dst += dstride / 2;
418			}
419		✗	}
420
421		✗	static void filter_7x7(uint8_t *dst, int width,
422			float rdiv, float bias, const int *const matrix,
423			const uint8_t *c[], int peak, int radius,
424			int dstride, int stride, int size)
425			{
426			int x;
427
428		✗	for (x = 0; x < width; x++) {
429		✗	int i, sum = 0;
430
431		✗	for (i = 0; i < 49; i++)
432		✗	sum += c[i][x] * matrix[i];
433
434		✗	sum = (int)(sum * rdiv + bias + 0.5f);
435		✗	dst[x] = av_clip_uint8(sum);
436			}
437		✗	}
438
439		✗	static void filter_5x5(uint8_t *dst, int width,
440			float rdiv, float bias, const int *const matrix,
441			const uint8_t *c[], int peak, int radius,
442			int dstride, int stride, int size)
443			{
444			int x;
445
446		✗	for (x = 0; x < width; x++) {
447		✗	int i, sum = 0;
448
449		✗	for (i = 0; i < 25; i++)
450		✗	sum += c[i][x] * matrix[i];
451
452		✗	sum = (int)(sum * rdiv + bias + 0.5f);
453		✗	dst[x] = av_clip_uint8(sum);
454			}
455		✗	}
456
457		✗	static void filter_3x3(uint8_t *dst, int width,
458			float rdiv, float bias, const int *const matrix,
459			const uint8_t *c[], int peak, int radius,
460			int dstride, int stride, int size)
461			{
462		✗	const uint8_t *c0 = c[0], *c1 = c[1], *c2 = c[2];
463		✗	const uint8_t *c3 = c[3], *c4 = c[4], *c5 = c[5];
464		✗	const uint8_t *c6 = c[6], *c7 = c[7], *c8 = c[8];
465			int x;
466
467		✗	for (x = 0; x < width; x++) {
468		✗	int sum = c0[x] * matrix[0] + c1[x] * matrix[1] + c2[x] * matrix[2] +
469		✗	c3[x] * matrix[3] + c4[x] * matrix[4] + c5[x] * matrix[5] +
470		✗	c6[x] * matrix[6] + c7[x] * matrix[7] + c8[x] * matrix[8];
471		✗	sum = (int)(sum * rdiv + bias + 0.5f);
472		✗	dst[x] = av_clip_uint8(sum);
473			}
474		✗	}
475
476		✗	static void filter_row(uint8_t *dst, int width,
477			float rdiv, float bias, const int *const matrix,
478			const uint8_t *c[], int peak, int radius,
479			int dstride, int stride, int size)
480			{
481			int x;
482
483		✗	for (x = 0; x < width; x++) {
484		✗	int i, sum = 0;
485
486		✗	for (i = 0; i < 2 * radius + 1; i++)
487		✗	sum += c[i][x] * matrix[i];
488
489		✗	sum = (int)(sum * rdiv + bias + 0.5f);
490		✗	dst[x] = av_clip_uint8(sum);
491			}
492		✗	}
493
494		✗	static void filter_column(uint8_t *dst, int height,
495			float rdiv, float bias, const int *const matrix,
496			const uint8_t *c[], int peak, int radius,
497			int dstride, int stride, int size)
498			{
499			DECLARE_ALIGNED(64, int, sum)[16];
500
501		✗	for (int y = 0; y < height; y++) {
502		✗	memset(sum, 0, sizeof(sum));
503
504		✗	for (int i = 0; i < 2 * radius + 1; i++) {
505		✗	for (int off16 = 0; off16 < 16; off16++)
506		✗	sum[off16] += c[i][0 + y * stride + off16] * matrix[i];
507			}
508
509		✗	for (int off16 = 0; off16 < 16; off16++) {
510		✗	sum[off16] = (int)(sum[off16] * rdiv + bias + 0.5f);
511		✗	dst[off16] = av_clip_uint8(sum[off16]);
512			}
513		✗	dst += dstride;
514			}
515		✗	}
516
517		✗	static void setup_5x5(int radius, const uint8_t *c[], const uint8_t *src, int stride,
518			int x, int w, int y, int h, int bpc)
519			{
520			int i;
521
522		✗	for (i = 0; i < 25; i++) {
523		✗	int xoff = avpriv_mirror(x + (i % 5) - 2, w - 1);
524		✗	int yoff = avpriv_mirror(y + (i / 5) - 2, h - 1);
525
526		✗	c[i] = src + xoff * bpc + yoff * stride;
527			}
528		✗	}
529
530		✗	static void setup_7x7(int radius, const uint8_t *c[], const uint8_t *src, int stride,
531			int x, int w, int y, int h, int bpc)
532			{
533			int i;
534
535		✗	for (i = 0; i < 49; i++) {
536		✗	int xoff = avpriv_mirror(x + (i % 7) - 3, w - 1);
537		✗	int yoff = avpriv_mirror(y + (i / 7) - 3, h - 1);
538
539		✗	c[i] = src + xoff * bpc + yoff * stride;
540			}
541		✗	}
542
543		✗	static void setup_row(int radius, const uint8_t *c[], const uint8_t *src, int stride,
544			int x, int w, int y, int h, int bpc)
545			{
546			int i;
547
548		✗	for (i = 0; i < radius * 2 + 1; i++) {
549		✗	int xoff = avpriv_mirror(x + i - radius, w - 1);
550
551		✗	c[i] = src + xoff * bpc + y * stride;
552			}
553		✗	}
554
555		✗	static void setup_column(int radius, const uint8_t *c[], const uint8_t *src, int stride,
556			int x, int w, int y, int h, int bpc)
557			{
558			int i;
559
560		✗	for (i = 0; i < radius * 2 + 1; i++) {
561		✗	int xoff = avpriv_mirror(x + i - radius, h - 1);
562
563		✗	c[i] = src + y * bpc + xoff * stride;
564			}
565		✗	}
566
567		✗	static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
568			{
569		✗	ConvolutionContext *s = ctx->priv;
570		✗	ThreadData *td = arg;
571		✗	AVFrame *in = td->in;
572		✗	AVFrame *out = td->out;
573			int plane;
574
575		✗	for (plane = 0; plane < s->nb_planes; plane++) {
576		✗	const int mode = s->mode[plane];
577		✗	const int bpc = s->bpc;
578		✗	const int radius = s->size[plane] / 2;
579		✗	const int height = s->planeheight[plane];
580		✗	const int width = s->planewidth[plane];
581		✗	const int stride = in->linesize[plane];
582		✗	const int dstride = out->linesize[plane];
583		✗	const int sizeh = mode == MATRIX_COLUMN ? width : height;
584		✗	const int sizew = mode == MATRIX_COLUMN ? height : width;
585		✗	const int slice_start = (sizeh * jobnr) / nb_jobs;
586		✗	const int slice_end = (sizeh * (jobnr+1)) / nb_jobs;
587		✗	const float rdiv = s->rdiv[plane];
588		✗	const float bias = s->bias[plane];
589		✗	const uint8_t *src = in->data[plane];
590		✗	const int dst_pos = slice_start * (mode == MATRIX_COLUMN ? bpc : dstride);
591		✗	uint8_t *dst = out->data[plane] + dst_pos;
592		✗	const int *matrix = s->matrix[plane];
593		✗	const int step = mode == MATRIX_COLUMN ? 16 : 1;
594			const uint8_t *c[49];
595			int y, x;
596
597		✗	if (s->copy[plane]) {
598		✗	if (mode == MATRIX_COLUMN)
599		✗	av_image_copy_plane(dst, dstride, src + slice_start * bpc, stride,
600		✗	(slice_end - slice_start) * bpc, height);
601			else
602		✗	av_image_copy_plane(dst, dstride, src + slice_start * stride, stride,
603			width * bpc, slice_end - slice_start);
604		✗	continue;
605			}
606		✗	for (y = slice_start; y < slice_end; y += step) {
607		✗	const int left = FFMIN(radius, sizew);
608		✗	const int right = FFMAX(left, sizew - radius);
609		✗	const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : left * bpc;
610		✗	const int yoff = mode == MATRIX_COLUMN ? left * dstride : 0;
611
612		✗	for (x = 0; x < left; x++) {
613		✗	const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : x * bpc;
614		✗	const int yoff = mode == MATRIX_COLUMN ? x * dstride : 0;
615
616		✗	s->setup[plane](radius, c, src, stride, x, width, y, height, bpc);
617		✗	s->filter[plane](dst + yoff + xoff, 1, rdiv,
618			bias, matrix, c, s->max, radius,
619			dstride, stride, slice_end - step);
620			}
621		✗	s->setup[plane](radius, c, src, stride, left, width, y, height, bpc);
622		✗	s->filter[plane](dst + yoff + xoff, right - left,
623			rdiv, bias, matrix, c, s->max, radius,
624			dstride, stride, slice_end - step);
625		✗	for (x = right; x < sizew; x++) {
626		✗	const int xoff = mode == MATRIX_COLUMN ? (y - slice_start) * bpc : x * bpc;
627		✗	const int yoff = mode == MATRIX_COLUMN ? x * dstride : 0;
628
629		✗	s->setup[plane](radius, c, src, stride, x, width, y, height, bpc);
630		✗	s->filter[plane](dst + yoff + xoff, 1, rdiv,
631			bias, matrix, c, s->max, radius,
632			dstride, stride, slice_end - step);
633			}
634		✗	if (mode != MATRIX_COLUMN)
635		✗	dst += dstride;
636			}
637			}
638
639		✗	return 0;
640			}
641
642		✗	static int param_init(AVFilterContext *ctx)
643			{
644		✗	ConvolutionContext *s = ctx->priv;
645		✗	AVFilterLink *inlink = ctx->inputs[0];
646		✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
647			int p, i;
648
649		✗	s->depth = desc->comp[0].depth;
650		✗	s->max = (1 << s->depth) - 1;
651
652		✗	s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
653		✗	s->planewidth[0] = s->planewidth[3] = inlink->w;
654		✗	s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
655		✗	s->planeheight[0] = s->planeheight[3] = inlink->h;
656
657		✗	s->nb_planes = av_pix_fmt_count_planes(inlink->format);
658		✗	s->nb_threads = ff_filter_get_nb_threads(ctx);
659		✗	s->bpc = (s->depth + 7) / 8;
660
661		✗	if (!strcmp(ctx->filter->name, "convolution")) {
662		✗	for (i = 0; i < 4; i++) {
663		✗	int *matrix = (int *)s->matrix[i];
664		✗	char *orig, *p, *arg, *saveptr = NULL;
665		✗	float sum = 1.f;
666
667		✗	p = orig = av_strdup(s->matrix_str[i]);
668		✗	if (p) {
669		✗	s->matrix_length[i] = 0;
670		✗	s->rdiv[i] = s->user_rdiv[i];
671		✗	sum = 0.f;
672
673		✗	while (s->matrix_length[i] < 49) {
674		✗	if (!(arg = av_strtok(p, " |", &saveptr)))
675		✗	break;
676
677		✗	p = NULL;
678		✗	sscanf(arg, "%d", &matrix[s->matrix_length[i]]);
679		✗	sum += matrix[s->matrix_length[i]];
680		✗	s->matrix_length[i]++;
681			}
682
683		✗	av_freep(&orig);
684		✗	if (!(s->matrix_length[i] & 1)) {
685		✗	av_log(ctx, AV_LOG_ERROR, "number of matrix elements must be odd\n");
686		✗	return AVERROR(EINVAL);
687			}
688			}
689
690		✗	if (s->mode[i] == MATRIX_ROW) {
691		✗	s->filter[i] = filter_row;
692		✗	s->setup[i] = setup_row;
693		✗	s->size[i] = s->matrix_length[i];
694		✗	} else if (s->mode[i] == MATRIX_COLUMN) {
695		✗	s->filter[i] = filter_column;
696		✗	s->setup[i] = setup_column;
697		✗	s->size[i] = s->matrix_length[i];
698		✗	} else if (s->matrix_length[i] == 9) {
699		✗	s->size[i] = 3;
700
701		✗	if (!memcmp(matrix, same3x3, sizeof(same3x3))) {
702		✗	s->copy[i] = 1;
703			} else {
704		✗	s->filter[i] = filter_3x3;
705		✗	s->copy[i] = 0;
706			}
707		✗	s->setup[i] = setup_3x3;
708		✗	} else if (s->matrix_length[i] == 25) {
709		✗	s->size[i] = 5;
710		✗	if (!memcmp(matrix, same5x5, sizeof(same5x5))) {
711		✗	s->copy[i] = 1;
712			} else {
713		✗	s->filter[i] = filter_5x5;
714		✗	s->copy[i] = 0;
715			}
716		✗	s->setup[i] = setup_5x5;
717		✗	} else if (s->matrix_length[i] == 49) {
718		✗	s->size[i] = 7;
719		✗	if (!memcmp(matrix, same7x7, sizeof(same7x7))) {
720		✗	s->copy[i] = 1;
721			} else {
722		✗	s->filter[i] = filter_7x7;
723		✗	s->copy[i] = 0;
724			}
725		✗	s->setup[i] = setup_7x7;
726			} else {
727		✗	return AVERROR(EINVAL);
728			}
729
730		✗	if (sum == 0)
731		✗	sum = 1;
732		✗	if (s->rdiv[i] == 0)
733		✗	s->rdiv[i] = 1. / sum;
734
735		✗	if (s->copy[i] && (s->rdiv[i] != 1. || s->bias[i] != 0.))
736		✗	s->copy[i] = 0;
737			}
738		✗	} else if (!strcmp(ctx->filter->name, "prewitt")) {
739		✗	for (i = 0; i < 4; i++) {
740		✗	s->filter[i] = filter_prewitt;
741		✗	s->copy[i] = !((1 << i) & s->planes);
742		✗	s->size[i] = 3;
743		✗	s->setup[i] = setup_3x3;
744		✗	s->rdiv[i] = s->scale;
745		✗	s->bias[i] = s->delta;
746			}
747		✗	} else if (!strcmp(ctx->filter->name, "roberts")) {
748		✗	for (i = 0; i < 4; i++) {
749		✗	s->filter[i] = filter_roberts;
750		✗	s->copy[i] = !((1 << i) & s->planes);
751		✗	s->size[i] = 3;
752		✗	s->setup[i] = setup_3x3;
753		✗	s->rdiv[i] = s->scale;
754		✗	s->bias[i] = s->delta;
755			}
756			#if CONFIG_SOBEL_FILTER
757		✗	} else if (!strcmp(ctx->filter->name, "sobel")) {
758		✗	ff_sobel_init(s, s->depth, s->nb_planes);
759			#endif
760		✗	} else if (!strcmp(ctx->filter->name, "kirsch")) {
761		✗	for (i = 0; i < 4; i++) {
762		✗	s->filter[i] = filter_kirsch;
763		✗	s->copy[i] = !((1 << i) & s->planes);
764		✗	s->size[i] = 3;
765		✗	s->setup[i] = setup_3x3;
766		✗	s->rdiv[i] = s->scale;
767		✗	s->bias[i] = s->delta;
768			}
769		✗	} else if (!strcmp(ctx->filter->name, "scharr")) {
770		✗	for (i = 0; i < 4; i++) {
771		✗	s->filter[i] = filter_scharr;
772		✗	s->copy[i] = !((1 << i) & s->planes);
773		✗	s->size[i] = 3;
774		✗	s->setup[i] = setup_3x3;
775		✗	s->rdiv[i] = s->scale;
776		✗	s->bias[i] = s->delta;
777			}
778			}
779
780		✗	if (!strcmp(ctx->filter->name, "convolution")) {
781		✗	if (s->depth > 8) {
782		✗	for (p = 0; p < s->nb_planes; p++) {
783		✗	if (s->mode[p] == MATRIX_ROW)
784		✗	s->filter[p] = filter16_row;
785		✗	else if (s->mode[p] == MATRIX_COLUMN)
786		✗	s->filter[p] = filter16_column;
787		✗	else if (s->size[p] == 3)
788		✗	s->filter[p] = filter16_3x3;
789		✗	else if (s->size[p] == 5)
790		✗	s->filter[p] = filter16_5x5;
791		✗	else if (s->size[p] == 7)
792		✗	s->filter[p] = filter16_7x7;
793			}
794			}
795			#if CONFIG_CONVOLUTION_FILTER && ARCH_X86_64 && HAVE_X86ASM
796		✗	ff_convolution_init_x86(s);
797			#endif
798		✗	} else if (!strcmp(ctx->filter->name, "prewitt")) {
799		✗	if (s->depth > 8)
800		✗	for (p = 0; p < s->nb_planes; p++)
801		✗	s->filter[p] = filter16_prewitt;
802		✗	} else if (!strcmp(ctx->filter->name, "roberts")) {
803		✗	if (s->depth > 8)
804		✗	for (p = 0; p < s->nb_planes; p++)
805		✗	s->filter[p] = filter16_roberts;
806		✗	} else if (!strcmp(ctx->filter->name, "kirsch")) {
807		✗	if (s->depth > 8)
808		✗	for (p = 0; p < s->nb_planes; p++)
809		✗	s->filter[p] = filter16_kirsch;
810		✗	} else if (!strcmp(ctx->filter->name, "scharr")) {
811		✗	if (s->depth > 8)
812		✗	for (p = 0; p < s->nb_planes; p++)
813		✗	s->filter[p] = filter16_scharr;
814			}
815
816		✗	return 0;
817			}
818
819		✗	static int config_input(AVFilterLink *inlink)
820			{
821		✗	AVFilterContext *ctx = inlink->dst;
822		✗	return param_init(ctx);
823			}
824
825		✗	static int filter_frame(AVFilterLink *inlink, AVFrame *in)
826			{
827		✗	AVFilterContext *ctx = inlink->dst;
828		✗	ConvolutionContext *s = ctx->priv;
829		✗	AVFilterLink *outlink = ctx->outputs[0];
830			AVFrame *out;
831			ThreadData td;
832
833		✗	out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
834		✗	if (!out) {
835		✗	av_frame_free(&in);
836		✗	return AVERROR(ENOMEM);
837			}
838		✗	av_frame_copy_props(out, in);
839
840		✗	td.in = in;
841		✗	td.out = out;
842		✗	ff_filter_execute(ctx, filter_slice, &td, NULL,
843		✗	FFMIN3(s->planeheight[1], s->planewidth[1], s->nb_threads));
844
845		✗	av_frame_free(&in);
846		✗	return ff_filter_frame(outlink, out);
847			}
848
849		✗	static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
850			char *res, int res_len, int flags)
851			{
852			int ret;
853
854		✗	ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
855		✗	if (ret < 0)
856		✗	return ret;
857
858		✗	return param_init(ctx);
859			}
860
861			static const AVFilterPad convolution_inputs[] = {
862			{
863			.name = "default",
864			.type = AVMEDIA_TYPE_VIDEO,
865			.config_props = config_input,
866			.filter_frame = filter_frame,
867			},
868			};
869
870			#if CONFIG_CONVOLUTION_FILTER
871
872			const FFFilter ff_vf_convolution = {
873			.p.name = "convolution",
874			.p.description = NULL_IF_CONFIG_SMALL("Apply convolution filter."),
875			.p.priv_class = &convolution_class,
876			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
877			.priv_size = sizeof(ConvolutionContext),
878			FILTER_INPUTS(convolution_inputs),
879			FILTER_OUTPUTS(ff_video_default_filterpad),
880			FILTER_PIXFMTS_ARRAY(pix_fmts),
881			.process_command = process_command,
882			};
883
884			#endif /* CONFIG_CONVOLUTION_FILTER */
885
886			static const AVOption common_options[] = {
887			{ "planes", "set planes to filter", OFFSET(planes), AV_OPT_TYPE_INT, {.i64=15}, 0, 15, FLAGS},
888			{ "scale", "set scale", OFFSET(scale), AV_OPT_TYPE_FLOAT, {.dbl=1.0}, 0.0, 65535, FLAGS},
889			{ "delta", "set delta", OFFSET(delta), AV_OPT_TYPE_FLOAT, {.dbl=0}, -65535, 65535, FLAGS},
890			{ NULL }
891			};
892
893			AVFILTER_DEFINE_CLASS_EXT(common, "kirsch/prewitt/roberts/scharr/sobel",
894			common_options);
895
896			#if CONFIG_PREWITT_FILTER
897
898			const FFFilter ff_vf_prewitt = {
899			.p.name = "prewitt",
900			.p.description = NULL_IF_CONFIG_SMALL("Apply prewitt operator."),
901			.p.priv_class = &common_class,
902			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
903			.priv_size = sizeof(ConvolutionContext),
904			FILTER_INPUTS(convolution_inputs),
905			FILTER_OUTPUTS(ff_video_default_filterpad),
906			FILTER_PIXFMTS_ARRAY(pix_fmts),
907			.process_command = process_command,
908			};
909
910			#endif /* CONFIG_PREWITT_FILTER */
911
912			#if CONFIG_SOBEL_FILTER
913
914			const FFFilter ff_vf_sobel = {
915			.p.name = "sobel",
916			.p.description = NULL_IF_CONFIG_SMALL("Apply sobel operator."),
917			.p.priv_class = &common_class,
918			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
919			.priv_size = sizeof(ConvolutionContext),
920			FILTER_INPUTS(convolution_inputs),
921			FILTER_OUTPUTS(ff_video_default_filterpad),
922			FILTER_PIXFMTS_ARRAY(pix_fmts),
923			.process_command = process_command,
924			};
925
926			#endif /* CONFIG_SOBEL_FILTER */
927
928			#if CONFIG_ROBERTS_FILTER
929
930			const FFFilter ff_vf_roberts = {
931			.p.name = "roberts",
932			.p.description = NULL_IF_CONFIG_SMALL("Apply roberts cross operator."),
933			.p.priv_class = &common_class,
934			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
935			.priv_size = sizeof(ConvolutionContext),
936			FILTER_INPUTS(convolution_inputs),
937			FILTER_OUTPUTS(ff_video_default_filterpad),
938			FILTER_PIXFMTS_ARRAY(pix_fmts),
939			.process_command = process_command,
940			};
941
942			#endif /* CONFIG_ROBERTS_FILTER */
943
944			#if CONFIG_KIRSCH_FILTER
945
946			const FFFilter ff_vf_kirsch = {
947			.p.name = "kirsch",
948			.p.description = NULL_IF_CONFIG_SMALL("Apply kirsch operator."),
949			.p.priv_class = &common_class,
950			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
951			.priv_size = sizeof(ConvolutionContext),
952			FILTER_INPUTS(convolution_inputs),
953			FILTER_OUTPUTS(ff_video_default_filterpad),
954			FILTER_PIXFMTS_ARRAY(pix_fmts),
955			.process_command = process_command,
956			};
957
958			#endif /* CONFIG_KIRSCH_FILTER */
959
960			#if CONFIG_SCHARR_FILTER
961
962			const FFFilter ff_vf_scharr = {
963			.p.name = "scharr",
964			.p.description = NULL_IF_CONFIG_SMALL("Apply scharr operator."),
965			.p.priv_class = &common_class,
966			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
967			.priv_size = sizeof(ConvolutionContext),
968			FILTER_INPUTS(convolution_inputs),
969			FILTER_OUTPUTS(ff_video_default_filterpad),
970			FILTER_PIXFMTS_ARRAY(pix_fmts),
971			.process_command = process_command,
972			};
973
974			#endif /* CONFIG_SCHARR_FILTER */
975