FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* This file is part of FFmpeg.
3			*
4			* FFmpeg is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU Lesser General Public
6			* License as published by the Free Software Foundation; either
7			* version 2.1 of the License, or (at your option) any later version.
8			*
9			* FFmpeg is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Lesser General Public License for more details.
13			*
14			* You should have received a copy of the GNU Lesser General Public
15			* License along with FFmpeg; if not, write to the Free Software
16			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17			*/
18
19			/**
20			* @file
21			* feedback video filter
22			*/
23
24			#include "libavutil/fifo.h"
25			#include "libavutil/imgutils.h"
26			#include "libavutil/opt.h"
27			#include "libavutil/internal.h"
28			#include "avfilter.h"
29			#include "filters.h"
30			#include "formats.h"
31			#include "video.h"
32
33			typedef struct FeedbackContext {
34			const AVClass *class;
35
36			int x, y;
37			int w, h;
38
39			int max_step[4];
40			int hsub, vsub;
41
42			AVFrame *feed;
43
44			AVFifo *fifo;
45			} FeedbackContext;
46
47		✗	static void adjust_pos(AVFilterContext *ctx, FeedbackContext *s)
48			{
49		✗	if (s->x + s->w > ctx->inputs[0]->w)
50		✗	s->x = ctx->inputs[0]->w - s->w;
51		✗	if (s->y + s->h > ctx->inputs[0]->h)
52		✗	s->y = ctx->inputs[0]->h - s->h;
53		✗	}
54
55		✗	static void adjust_parameters(AVFilterContext *ctx, FeedbackContext *s)
56			{
57		✗	if (s->x >= ctx->inputs[0]->w)
58		✗	s->x = 0;
59		✗	if (s->y >= ctx->inputs[0]->h)
60		✗	s->y = 0;
61
62		✗	if (s->w <= 0)
63		✗	s->w = ctx->inputs[0]->w - s->x;
64		✗	if (s->h <= 0)
65		✗	s->h = ctx->inputs[0]->h - s->y;
66
67		✗	if (s->w > ctx->inputs[0]->w)
68		✗	s->w = ctx->inputs[0]->w;
69		✗	if (s->h > ctx->inputs[0]->h)
70		✗	s->h = ctx->inputs[0]->h;
71
72		✗	adjust_pos(ctx, s);
73		✗	}
74
75		✗	static int config_input(AVFilterLink *inlink)
76			{
77		✗	AVFilterContext *ctx = inlink->dst;
78		✗	const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(inlink->format);
79		✗	FeedbackContext *s = ctx->priv;
80
81		✗	s->hsub = pix_desc->log2_chroma_w;
82		✗	s->vsub = pix_desc->log2_chroma_h;
83
84		✗	av_image_fill_max_pixsteps(s->max_step, NULL, pix_desc);
85
86		✗	adjust_parameters(ctx, s);
87
88		✗	ctx->inputs[1]->w = s->w;
89		✗	ctx->inputs[1]->h = s->h;
90
91		✗	return 0;
92			}
93
94		✗	static int config_output(AVFilterLink *outlink)
95			{
96		✗	AVFilterContext *ctx = outlink->src;
97		✗	FeedbackContext *s = ctx->priv;
98
99		✗	adjust_parameters(ctx, s);
100
101		✗	ctx->outputs[0]->w = ctx->inputs[0]->w;
102		✗	ctx->outputs[0]->h = ctx->inputs[0]->h;
103		✗	ctx->outputs[1]->w = s->w;
104		✗	ctx->outputs[1]->h = s->h;
105
106		✗	return 0;
107			}
108
109		✗	static int query_formats(AVFilterContext *ctx)
110			{
111		✗	return ff_set_common_formats(ctx, ff_formats_pixdesc_filter(0, AV_PIX_FMT_FLAG_BITSTREAM |
112			AV_PIX_FMT_FLAG_HWACCEL |
113			AV_PIX_FMT_FLAG_PAL));
114			}
115
116		✗	static int activate(AVFilterContext *ctx)
117			{
118		✗	FeedbackContext *s = ctx->priv;
119			int status, ret;
120			int64_t pts;
121
122		✗	adjust_pos(ctx, s);
123
124		✗	for (int i = 0; i < ctx->nb_outputs; i++)
125		✗	FF_FILTER_FORWARD_STATUS_BACK_ALL(ctx->outputs[i], ctx);
126
127		✗	if (!s->feed) {
128		✗	ret = ff_inlink_consume_frame(ctx->inputs[1], &s->feed);
129		✗	if (ret < 0)
130		✗	return ret;
131			}
132
133		✗	if (s->feed && av_fifo_can_read(s->fifo)) {
134		✗	AVFrame *src = s->feed;
135		✗	AVFrame *dst = NULL;
136
137		✗	av_fifo_read(s->fifo, &dst, 1);
138		✗	if (!dst)
139		✗	return AVERROR_BUG;
140
141		✗	if (!av_frame_is_writable(dst)) {
142		✗	AVFrame *tmp = ff_get_video_buffer(ctx->outputs[0], ctx->outputs[0]->w, ctx->outputs[0]->h);
143
144		✗	if (!tmp) {
145		✗	av_frame_free(&dst);
146		✗	return AVERROR(ENOMEM);
147			}
148
149		✗	ret = av_frame_copy(tmp, dst);
150		✗	if (ret < 0) {
151		✗	av_frame_free(&dst);
152		✗	av_frame_free(&tmp);
153		✗	return ret;
154			}
155
156		✗	av_frame_copy_props(tmp, dst);
157		✗	av_frame_free(&dst);
158		✗	dst = tmp;
159			}
160
161		✗	for (int y = 0; y < src->height; y++) {
162		✗	memmove(dst->data[0] + (s->y + y) * dst->linesize[0] + s->x * s->max_step[0],
163		✗	src->data[0] + y * src->linesize[0], src->width * s->max_step[0]);
164			}
165
166		✗	for (int i = 1; i < 3; i++) {
167		✗	if (dst->data[i]) {
168		✗	for (int y = 0; y < src->height; y++) {
169		✗	memmove(dst->data[i] + ((s->y + y) >> s->vsub) * dst->linesize[i] + (s->x >> s->hsub) * s->max_step[i],
170		✗	src->data[i] + (y >> s->vsub) * src->linesize[i], (src->width >> s->hsub) * s->max_step[i]);
171			}
172			}
173			}
174
175		✗	if (dst->data[3]) {
176		✗	for (int y = 0; y < src->height; y++) {
177		✗	memmove(dst->data[3] + (s->y + y) * dst->linesize[3] + s->x * s->max_step[3],
178		✗	src->data[3] + y * src->linesize[3], src->width * s->max_step[3]);
179			}
180			}
181
182		✗	ret = ff_filter_frame(ctx->outputs[0], dst);
183		✗	av_frame_free(&s->feed);
184		✗	return ret;
185			}
186
187		✗	if (!s->feed || ctx->is_disabled) {
188		✗	AVFrame *in = NULL;
189
190		✗	ret = ff_inlink_consume_frame(ctx->inputs[0], &in);
191		✗	if (ret < 0)
192		✗	return ret;
193
194		✗	if (ret > 0 && ctx->is_disabled)
195		✗	return ff_filter_frame(ctx->outputs[0], in);
196
197		✗	if (ret > 0) {
198			AVFrame *frame;
199
200		✗	ret = av_fifo_write(s->fifo, &in, 1);
201		✗	if (ret < 0) {
202		✗	av_frame_free(&in);
203		✗	return ret;
204			}
205
206		✗	frame = av_frame_clone(in);
207		✗	if (!frame)
208		✗	return AVERROR(ENOMEM);
209
210		✗	frame->width = s->w;
211		✗	frame->height = s->h;
212
213		✗	frame->data[0] += s->y * frame->linesize[0];
214		✗	frame->data[0] += s->x * s->max_step[0];
215
216		✗	for (int i = 1; i < 3; i ++) {
217		✗	if (frame->data[i]) {
218		✗	frame->data[i] += (s->y >> s->vsub) * frame->linesize[i];
219		✗	frame->data[i] += (s->x >> s->hsub) * s->max_step[i];
220			}
221			}
222
223		✗	if (frame->data[3]) {
224		✗	frame->data[3] += s->y * frame->linesize[3];
225		✗	frame->data[3] += s->x * s->max_step[3];
226			}
227
228		✗	return ff_filter_frame(ctx->outputs[1], frame);
229			}
230			}
231
232		✗	if (ff_inlink_acknowledge_status(ctx->inputs[0], &status, &pts)) {
233		✗	ff_outlink_set_status(ctx->outputs[0], status, pts);
234		✗	ff_outlink_set_status(ctx->outputs[1], status, pts);
235		✗	return 0;
236			}
237
238		✗	if (ff_inlink_acknowledge_status(ctx->inputs[1], &status, &pts)) {
239		✗	ff_outlink_set_status(ctx->outputs[0], status, pts);
240		✗	ff_outlink_set_status(ctx->outputs[1], status, pts);
241		✗	return 0;
242			}
243
244		✗	if (!s->feed || ctx->is_disabled) {
245		✗	if (ff_outlink_frame_wanted(ctx->outputs[0])) {
246		✗	ff_inlink_request_frame(ctx->inputs[0]);
247		✗	if (!ctx->is_disabled)
248		✗	ff_inlink_request_frame(ctx->inputs[1]);
249		✗	return 0;
250			}
251			}
252
253		✗	return FFERROR_NOT_READY;
254			}
255
256		✗	static av_cold int init(AVFilterContext *ctx)
257			{
258		✗	FeedbackContext *s = ctx->priv;
259
260		✗	s->fifo = av_fifo_alloc2(8, sizeof(AVFrame *), AV_FIFO_FLAG_AUTO_GROW);
261		✗	if (!s->fifo)
262		✗	return AVERROR(ENOMEM);
263
264		✗	return 0;
265			}
266
267		✗	static av_cold void uninit(AVFilterContext *ctx)
268			{
269		✗	FeedbackContext *s = ctx->priv;
270		✗	if (s->fifo) {
271		✗	size_t size = av_fifo_can_read(s->fifo);
272
273		✗	for (size_t n = 0; n < size; n++) {
274		✗	AVFrame *frame = NULL;
275
276		✗	av_fifo_read(s->fifo, &frame, 1);
277
278		✗	av_frame_free(&frame);
279			}
280
281		✗	av_fifo_freep2(&s->fifo);
282			}
283		✗	}
284
285			static const AVFilterPad inputs[] = {
286			{
287			.name = "default",
288			.type = AVMEDIA_TYPE_VIDEO,
289			.config_props = config_input,
290			},
291			{
292			.name = "feedin",
293			.type = AVMEDIA_TYPE_VIDEO,
294			.config_props = config_input,
295			},
296			};
297
298			static const AVFilterPad outputs[] = {
299			{
300			.name = "default",
301			.type = AVMEDIA_TYPE_VIDEO,
302			.config_props = config_output,
303			},
304			{
305			.name = "feedout",
306			.type = AVMEDIA_TYPE_VIDEO,
307			.config_props = config_output,
308			},
309			};
310
311			#define OFFSET(x) offsetof(FeedbackContext, x)
312			#define FLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM)
313			#define TFLAGS (AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_RUNTIME_PARAM)
314
315			static const AVOption feedback_options[] = {
316			{ "x", "set top left crop position", OFFSET(x), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, TFLAGS },
317			{ "y", "set top left crop position", OFFSET(y), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, TFLAGS },
318			{ "w", "set crop size", OFFSET(w), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
319			{ "h", "set crop size", OFFSET(h), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
320			{ NULL }
321			};
322
323			AVFILTER_DEFINE_CLASS(feedback);
324
325			const AVFilter ff_vf_feedback = {
326			.name = "feedback",
327			.description = NULL_IF_CONFIG_SMALL("Apply feedback video filter."),
328			.priv_class = &feedback_class,
329			.priv_size = sizeof(FeedbackContext),
330			.activate = activate,
331			.init = init,
332			.uninit = uninit,
333			FILTER_INPUTS(inputs),
334			FILTER_OUTPUTS(outputs),
335			FILTER_QUERY_FUNC(query_formats),
336			.flags = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL,
337			.process_command = ff_filter_process_command,
338			};
339