FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2020 Paul B Mahol
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			#include "libavutil/avassert.h"
22			#include "libavutil/common.h"
23			#include "libavutil/internal.h"
24			#include "libavutil/imgutils.h"
25			#include "libavutil/lfg.h"
26			#include "libavutil/mem.h"
27			#include "libavutil/opt.h"
28			#include "libavutil/pixdesc.h"
29			#include "libavutil/random_seed.h"
30
31			#include "avfilter.h"
32			#include "filters.h"
33			#include "video.h"
34
35			typedef struct ShufflePixelsContext {
36			const AVClass *class;
37
38			int block_w, block_h;
39			int mode;
40			int direction;
41			int64_t seed;
42
43			int depth;
44			int nb_planes;
45			int linesize[4];
46			int planewidth[4];
47			int planeheight[4];
48
49			int nb_blocks;
50
51			uint8_t *used;
52			int32_t *map;
53
54			AVLFG c;
55
56			int (*shuffle_pixels)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
57			} ShufflePixelsContext;
58
59			static const enum AVPixelFormat pix_fmts[] = {
60			AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
61			AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P,
62			AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRAP10,
63			AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRAP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
64			AV_PIX_FMT_GBRAP16, AV_PIX_FMT_GBRAP,
65			AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUVA444P10,
66			AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUVA444P16,
67			AV_PIX_FMT_NONE
68			};
69
70		✗	static void make_horizontal_map(AVFilterContext *ctx)
71			{
72		✗	ShufflePixelsContext *s = ctx->priv;
73		✗	const int nb_blocks = s->nb_blocks;
74		✗	AVLFG *c = &s->c;
75		✗	uint8_t *used = s->used;
76		✗	int32_t *map = s->map;
77
78		✗	for (int x = 0; x < s->planewidth[0];) {
79		✗	int rand = av_lfg_get(c) % nb_blocks;
80
81		✗	if (used[rand] == 0) {
82			int width;
83
84		✗	if (s->direction) {
85		✗	width = FFMIN(s->block_w, s->planewidth[0] - x);
86		✗	map[rand * s->block_w] = x;
87			} else {
88		✗	width = FFMIN(s->block_w, s->planewidth[0] - rand * s->block_w);
89		✗	map[x] = rand * s->block_w;
90			}
91		✗	used[rand] = 1;
92
93		✗	if (s->direction) {
94		✗	for (int i = 1; i < width; i++) {
95		✗	map[rand * s->block_w + i] = map[rand * s->block_w] + i;
96			}
97			} else {
98		✗	for (int i = 1; i < width; i++) {
99		✗	map[x + i] = map[x] + i;
100			}
101			}
102
103		✗	x += width;
104			}
105			}
106		✗	}
107
108		✗	static void make_vertical_map(AVFilterContext *ctx)
109			{
110		✗	ShufflePixelsContext *s = ctx->priv;
111		✗	const int nb_blocks = s->nb_blocks;
112		✗	AVLFG *c = &s->c;
113		✗	uint8_t *used = s->used;
114		✗	int32_t *map = s->map;
115
116		✗	for (int y = 0; y < s->planeheight[0];) {
117		✗	int rand = av_lfg_get(c) % nb_blocks;
118
119		✗	if (used[rand] == 0) {
120			int height;
121
122		✗	if (s->direction) {
123		✗	height = FFMIN(s->block_h, s->planeheight[0] - y);
124		✗	map[rand * s->block_h] = y;
125			} else {
126		✗	height = FFMIN(s->block_h, s->planeheight[0] - rand * s->block_h);
127		✗	map[y] = rand * s->block_h;
128			}
129		✗	used[rand] = 1;
130
131		✗	if (s->direction) {
132		✗	for (int i = 1; i < height; i++) {
133		✗	map[rand * s->block_h + i] = map[rand * s->block_h] + i;
134			}
135			} else {
136		✗	for (int i = 1; i < height; i++) {
137		✗	map[y + i] = map[y] + i;
138			}
139			}
140
141		✗	y += height;
142			}
143			}
144		✗	}
145
146		✗	static void make_block_map(AVFilterContext *ctx)
147			{
148		✗	ShufflePixelsContext *s = ctx->priv;
149		✗	const int nb_blocks = s->nb_blocks;
150		✗	int nb_blocks_w = s->planewidth[0] / s->block_w;
151		✗	AVLFG *c = &s->c;
152		✗	uint8_t *used = s->used;
153		✗	int32_t *map = s->map;
154
155		✗	for (int i = 0; i < nb_blocks;) {
156		✗	int rand = av_lfg_get(c) % nb_blocks;
157
158		✗	if (used[rand] == 0) {
159		✗	int yin = i / nb_blocks_w;
160		✗	int xin = i % nb_blocks_w;
161		✗	int in = yin * s->block_h * s->planewidth[0] + xin * s->block_w;
162		✗	int yout = rand / nb_blocks_w;
163		✗	int xout = rand % nb_blocks_w;
164		✗	int out = yout * s->block_h * s->planewidth[0] + xout * s->block_w;
165
166		✗	if (s->direction) {
167		✗	map[out] = in;
168			} else {
169		✗	map[in] = out;
170			}
171		✗	used[rand] = 1;
172
173		✗	if (s->direction) {
174		✗	for (int y = 0; y < s->block_h; y++) {
175		✗	for (int x = 0; x < s->block_w; x++) {
176		✗	map[out + y * s->planewidth[0] + x] = map[out] + x + y * s->planewidth[0];
177			}
178			}
179			} else {
180		✗	for (int y = 0; y < s->block_h; y++) {
181		✗	for (int x = 0; x < s->block_w; x++) {
182		✗	map[in + y * s->planewidth[0] + x] = map[in] + x + y * s->planewidth[0];
183			}
184			}
185			}
186
187		✗	i++;
188			}
189			}
190		✗	}
191
192			typedef struct ThreadData {
193			AVFrame *in, *out;
194			} ThreadData;
195
196
197			#define SHUFFLE_HORIZONTAL(name, type) \
198			static int shuffle_horizontal## name(AVFilterContext *ctx, void *arg, \
199			int jobnr, int nb_jobs) \
200			{ \
201			ShufflePixelsContext *s = ctx->priv; \
202			ThreadData *td = arg; \
203			AVFrame *in = td->in; \
204			AVFrame *out = td->out; \
205			\
206			for (int p = 0; p < s->nb_planes; p++) { \
207			const int slice_start = (s->planeheight[p] * jobnr) / nb_jobs; \
208			const int slice_end = (s->planeheight[p] * (jobnr+1)) / nb_jobs; \
209			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
210			const type *src = (const type *)(in->data[p] + \
211			slice_start * in->linesize[p]); \
212			const int32_t *map = s->map; \
213			\
214			for (int y = slice_start; y < slice_end; y++) { \
215			for (int x = 0; x < s->planewidth[p]; x++) { \
216			dst[x] = src[map[x]]; \
217			} \
218			\
219			dst += out->linesize[p] / sizeof(type); \
220			src += in->linesize[p] / sizeof(type); \
221			} \
222			} \
223			\
224			return 0; \
225			}
226
227		✗	SHUFFLE_HORIZONTAL(8, uint8_t)
228		✗	SHUFFLE_HORIZONTAL(16, uint16_t)
229
230			#define SHUFFLE_VERTICAL(name, type) \
231			static int shuffle_vertical## name(AVFilterContext *ctx, void *arg, \
232			int jobnr, int nb_jobs) \
233			{ \
234			ShufflePixelsContext *s = ctx->priv; \
235			ThreadData *td = arg; \
236			AVFrame *in = td->in; \
237			AVFrame *out = td->out; \
238			\
239			for (int p = 0; p < s->nb_planes; p++) { \
240			const int slice_start = (s->planeheight[p] * jobnr) / nb_jobs; \
241			const int slice_end = (s->planeheight[p] * (jobnr+1)) / nb_jobs; \
242			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
243			const int32_t *map = s->map; \
244			\
245			for (int y = slice_start; y < slice_end; y++) { \
246			const type *src = (const type *)(in->data[p] + \
247			map[y] * in->linesize[p]); \
248			\
249			memcpy(dst, src, s->linesize[p]); \
250			dst += out->linesize[p] / sizeof(type); \
251			} \
252			} \
253			\
254			return 0; \
255			}
256
257		✗	SHUFFLE_VERTICAL(8, uint8_t)
258		✗	SHUFFLE_VERTICAL(16, uint16_t)
259
260			#define SHUFFLE_BLOCK(name, type) \
261			static int shuffle_block## name(AVFilterContext *ctx, void *arg, \
262			int jobnr, int nb_jobs) \
263			{ \
264			ShufflePixelsContext *s = ctx->priv; \
265			ThreadData *td = arg; \
266			AVFrame *in = td->in; \
267			AVFrame *out = td->out; \
268			\
269			for (int p = 0; p < s->nb_planes; p++) { \
270			const int slice_start = (s->planeheight[p] * jobnr) / nb_jobs; \
271			const int slice_end = (s->planeheight[p] * (jobnr+1)) / nb_jobs; \
272			type *dst = (type *)(out->data[p] + slice_start * out->linesize[p]); \
273			const type *src = (const type *)in->data[p]; \
274			const int32_t *map = s->map + slice_start * s->planewidth[p]; \
275			\
276			for (int y = slice_start; y < slice_end; y++) { \
277			for (int x = 0; x < s->planewidth[p]; x++) { \
278			int ymap = map[x] / s->planewidth[p]; \
279			int xmap = map[x] % s->planewidth[p]; \
280			\
281			dst[x] = src[xmap + ymap * in->linesize[p] / sizeof(type)]; \
282			} \
283			\
284			dst += out->linesize[p] / sizeof(type); \
285			map += s->planewidth[p]; \
286			} \
287			} \
288			\
289			return 0; \
290			}
291
292		✗	SHUFFLE_BLOCK(8, uint8_t)
293		✗	SHUFFLE_BLOCK(16, uint16_t)
294
295		✗	static int config_output(AVFilterLink *outlink)
296			{
297		✗	AVFilterContext *ctx = outlink->src;
298		✗	ShufflePixelsContext *s = ctx->priv;
299		✗	AVFilterLink *inlink = ctx->inputs[0];
300			const AVPixFmtDescriptor *desc;
301			int ret;
302
303		✗	if (s->seed == -1)
304		✗	s->seed = av_get_random_seed();
305		✗	av_lfg_init(&s->c, s->seed);
306
307		✗	desc = av_pix_fmt_desc_get(outlink->format);
308		✗	if (!desc)
309		✗	return AVERROR_BUG;
310		✗	s->nb_planes = av_pix_fmt_count_planes(outlink->format);
311		✗	s->depth = desc->comp[0].depth;
312
313		✗	if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
314		✗	return ret;
315
316		✗	s->planewidth[1] = s->planewidth[2] = AV_CEIL_RSHIFT(inlink->w, desc->log2_chroma_w);
317		✗	s->planewidth[0] = s->planewidth[3] = inlink->w;
318
319		✗	s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
320		✗	s->planeheight[0] = s->planeheight[3] = inlink->h;
321
322		✗	s->map = av_calloc(inlink->w * inlink->h, sizeof(*s->map));
323		✗	if (!s->map)
324		✗	return AVERROR(ENOMEM);
325
326		✗	switch (s->mode) {
327		✗	case 0:
328		✗	s->shuffle_pixels = s->depth <= 8 ? shuffle_horizontal8 : shuffle_horizontal16;
329		✗	s->nb_blocks = (s->planewidth[0] + s->block_w - 1) / s->block_w;
330		✗	break;
331		✗	case 1:
332		✗	s->shuffle_pixels = s->depth <= 8 ? shuffle_vertical8 : shuffle_vertical16;
333		✗	s->nb_blocks = (s->planeheight[0] + s->block_h - 1) / s->block_h;
334		✗	break;
335		✗	case 2:
336		✗	s->shuffle_pixels = s->depth <= 8 ? shuffle_block8 : shuffle_block16;
337		✗	s->nb_blocks = (s->planeheight[0] / s->block_h) *
338		✗	(s->planewidth[0] / s->block_w);
339		✗	break;
340		✗	default:
341		✗	av_assert0(0);
342			}
343
344		✗	s->used = av_calloc(s->nb_blocks, sizeof(*s->used));
345		✗	if (!s->used)
346		✗	return AVERROR(ENOMEM);
347
348		✗	switch (s->mode) {
349		✗	case 0:
350		✗	make_horizontal_map(ctx);
351		✗	break;
352		✗	case 1:
353		✗	make_vertical_map(ctx);
354		✗	break;
355		✗	case 2:
356		✗	make_block_map(ctx);
357		✗	break;
358		✗	default:
359		✗	av_assert0(0);
360			}
361
362		✗	return 0;
363			}
364
365		✗	static int filter_frame(AVFilterLink *inlink, AVFrame *in)
366			{
367		✗	AVFilterContext *ctx = inlink->dst;
368		✗	ShufflePixelsContext *s = ctx->priv;
369		✗	AVFrame *out = ff_get_video_buffer(ctx->outputs[0], in->width, in->height);
370			ThreadData td;
371			int ret;
372
373		✗	if (!out) {
374		✗	ret = AVERROR(ENOMEM);
375		✗	goto fail;
376			}
377
378		✗	ret = av_frame_copy_props(out, in);
379		✗	if (ret < 0) {
380		✗	av_frame_free(&out);
381		✗	goto fail;
382			}
383
384		✗	td.out = out;
385		✗	td.in = in;
386		✗	ff_filter_execute(ctx, s->shuffle_pixels, &td, NULL,
387		✗	FFMIN(s->planeheight[1], ff_filter_get_nb_threads(ctx)));
388
389		✗	av_frame_free(&in);
390		✗	return ff_filter_frame(ctx->outputs[0], out);
391		✗	fail:
392		✗	av_frame_free(&in);
393		✗	return ret;
394			}
395
396		✗	static av_cold void uninit(AVFilterContext *ctx)
397			{
398		✗	ShufflePixelsContext *s = ctx->priv;
399
400		✗	av_freep(&s->map);
401		✗	av_freep(&s->used);
402		✗	}
403
404			#define OFFSET(x) offsetof(ShufflePixelsContext, x)
405			#define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
406			static const AVOption shufflepixels_options[] = {
407			{ "direction", "set shuffle direction", OFFSET(direction), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "dir" },
408			{ "d", "set shuffle direction", OFFSET(direction), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "dir" },
409			{ "forward", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "dir" },
410			{ "inverse", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "dir" },
411			{ "mode", "set shuffle mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, .unit = "mode" },
412			{ "m", "set shuffle mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=0}, 0, 2, FLAGS, .unit = "mode" },
413			{ "horizontal", 0, 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "mode" },
414			{ "vertical", 0, 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "mode" },
415			{ "block", 0, 0, AV_OPT_TYPE_CONST, {.i64=2}, 0, 0, FLAGS, .unit = "mode" },
416			{ "width", "set block width", OFFSET(block_w), AV_OPT_TYPE_INT, {.i64=10}, 1, 8000, FLAGS },
417			{ "w", "set block width", OFFSET(block_w), AV_OPT_TYPE_INT, {.i64=10}, 1, 8000, FLAGS },
418			{ "height", "set block height", OFFSET(block_h), AV_OPT_TYPE_INT, {.i64=10}, 1, 8000, FLAGS },
419			{ "h", "set block height", OFFSET(block_h), AV_OPT_TYPE_INT, {.i64=10}, 1, 8000, FLAGS },
420			{ "seed", "set random seed", OFFSET(seed), AV_OPT_TYPE_INT64, {.i64=-1}, -1, UINT_MAX, FLAGS },
421			{ "s", "set random seed", OFFSET(seed), AV_OPT_TYPE_INT64, {.i64=-1}, -1, UINT_MAX, FLAGS },
422			{ NULL },
423			};
424
425			AVFILTER_DEFINE_CLASS(shufflepixels);
426
427			static const AVFilterPad shufflepixels_inputs[] = {
428			{
429			.name = "default",
430			.type = AVMEDIA_TYPE_VIDEO,
431			.filter_frame = filter_frame,
432			},
433			};
434
435			static const AVFilterPad shufflepixels_outputs[] = {
436			{
437			.name = "default",
438			.type = AVMEDIA_TYPE_VIDEO,
439			.config_props = config_output,
440			},
441			};
442
443			const FFFilter ff_vf_shufflepixels = {
444			.p.name = "shufflepixels",
445			.p.description = NULL_IF_CONFIG_SMALL("Shuffle video pixels."),
446			.p.priv_class = &shufflepixels_class,
447			.p.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
448			.priv_size = sizeof(ShufflePixelsContext),
449			.uninit = uninit,
450			FILTER_INPUTS(shufflepixels_inputs),
451			FILTER_OUTPUTS(shufflepixels_outputs),
452			FILTER_PIXFMTS_ARRAY(pix_fmts),
453			};
454