FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2013 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/eval.h"
22			#include "libavutil/opt.h"
23			#include "libavutil/pixdesc.h"
24			#include "avfilter.h"
25			#include "filters.h"
26			#include "internal.h"
27			#include "video.h"
28			#include "libswscale/swscale.h"
29
30			static const char *const var_names[] = {
31			"in_w", "iw",
32			"in_h", "ih",
33			"out_w", "ow",
34			"out_h", "oh",
35			"in",
36			"on",
37			"duration",
38			"pduration",
39			"in_time", "it",
40			"out_time", "time", "ot",
41			"frame",
42			"zoom",
43			"pzoom",
44			"x", "px",
45			"y", "py",
46			"a",
47			"sar",
48			"dar",
49			"hsub",
50			"vsub",
51			NULL
52			};
53
54			enum var_name {
55			VAR_IN_W, VAR_IW,
56			VAR_IN_H, VAR_IH,
57			VAR_OUT_W, VAR_OW,
58			VAR_OUT_H, VAR_OH,
59			VAR_IN,
60			VAR_ON,
61			VAR_DURATION,
62			VAR_PDURATION,
63			VAR_IN_TIME, VAR_IT,
64			VAR_TIME, VAR_OUT_TIME, VAR_OT,
65			VAR_FRAME,
66			VAR_ZOOM,
67			VAR_PZOOM,
68			VAR_X, VAR_PX,
69			VAR_Y, VAR_PY,
70			VAR_A,
71			VAR_SAR,
72			VAR_DAR,
73			VAR_HSUB,
74			VAR_VSUB,
75			VARS_NB
76			};
77
78			typedef struct ZPcontext {
79			const AVClass *class;
80			char *zoom_expr_str;
81			char *x_expr_str;
82			char *y_expr_str;
83			char *duration_expr_str;
84
85			AVExpr *zoom_expr, *x_expr, *y_expr;
86
87			int w, h;
88			double x, y;
89			double prev_zoom;
90			int prev_nb_frames;
91			struct SwsContext *sws;
92			int64_t frame_count;
93			const AVPixFmtDescriptor *desc;
94			AVFrame *in;
95			double var_values[VARS_NB];
96			int nb_frames;
97			int current_frame;
98			int finished;
99			AVRational framerate;
100			} ZPContext;
101
102			#define OFFSET(x) offsetof(ZPContext, x)
103			#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
104			static const AVOption zoompan_options[] = {
105			{ "zoom", "set the zoom expression", OFFSET(zoom_expr_str), AV_OPT_TYPE_STRING, {.str = "1" }, .flags = FLAGS },
106			{ "z", "set the zoom expression", OFFSET(zoom_expr_str), AV_OPT_TYPE_STRING, {.str = "1" }, .flags = FLAGS },
107			{ "x", "set the x expression", OFFSET(x_expr_str), AV_OPT_TYPE_STRING, {.str="0"}, .flags = FLAGS },
108			{ "y", "set the y expression", OFFSET(y_expr_str), AV_OPT_TYPE_STRING, {.str="0"}, .flags = FLAGS },
109			{ "d", "set the duration expression", OFFSET(duration_expr_str), AV_OPT_TYPE_STRING, {.str="90"}, .flags = FLAGS },
110			{ "s", "set the output image size", OFFSET(w), AV_OPT_TYPE_IMAGE_SIZE, {.str="hd720"}, .flags = FLAGS },
111			{ "fps", "set the output framerate", OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, { .str = "25" }, 0, INT_MAX, .flags = FLAGS },
112			{ NULL }
113			};
114
115			AVFILTER_DEFINE_CLASS(zoompan);
116
117		✗	static av_cold int init(AVFilterContext *ctx)
118			{
119		✗	ZPContext *s = ctx->priv;
120
121		✗	s->prev_zoom = 1;
122		✗	return 0;
123			}
124
125		✗	static int config_output(AVFilterLink *outlink)
126			{
127		✗	AVFilterContext *ctx = outlink->src;
128		✗	ZPContext *s = ctx->priv;
129			int ret;
130
131		✗	outlink->w = s->w;
132		✗	outlink->h = s->h;
133		✗	outlink->time_base = av_inv_q(s->framerate);
134		✗	outlink->frame_rate = s->framerate;
135		✗	s->desc = av_pix_fmt_desc_get(outlink->format);
136		✗	s->finished = 1;
137
138		✗	ret = av_expr_parse(&s->zoom_expr, s->zoom_expr_str, var_names, NULL, NULL, NULL, NULL, 0, ctx);
139		✗	if (ret < 0)
140		✗	return ret;
141
142		✗	ret = av_expr_parse(&s->x_expr, s->x_expr_str, var_names, NULL, NULL, NULL, NULL, 0, ctx);
143		✗	if (ret < 0)
144		✗	return ret;
145
146		✗	ret = av_expr_parse(&s->y_expr, s->y_expr_str, var_names, NULL, NULL, NULL, NULL, 0, ctx);
147		✗	if (ret < 0)
148		✗	return ret;
149
150		✗	return 0;
151			}
152
153		✗	static int output_single_frame(AVFilterContext *ctx, AVFrame *in, double *var_values, int i,
154			double *zoom, double *dx, double *dy)
155			{
156		✗	ZPContext *s = ctx->priv;
157		✗	AVFilterLink *outlink = ctx->outputs[0];
158		✗	AVFilterLink *inlink = ctx->inputs[0];
159		✗	int64_t pts = s->frame_count;
160		✗	int k, x, y, w, h, ret = 0;
161			uint8_t *input[4];
162			int px[4], py[4];
163			AVFrame *out;
164
165		✗	var_values[VAR_PX] = s->x;
166		✗	var_values[VAR_PY] = s->y;
167		✗	var_values[VAR_PZOOM] = s->prev_zoom;
168		✗	var_values[VAR_PDURATION] = s->prev_nb_frames;
169		✗	var_values[VAR_IN_TIME] = var_values[VAR_IT] = in->pts == AV_NOPTS_VALUE ?
170		✗	NAN : in->pts * av_q2d(inlink->time_base);
171		✗	var_values[VAR_OUT_TIME] = pts * av_q2d(outlink->time_base);
172		✗	var_values[VAR_TIME] = var_values[VAR_OT] = var_values[VAR_OUT_TIME];
173		✗	var_values[VAR_FRAME] = i;
174		✗	var_values[VAR_ON] = outlink->frame_count_in;
175
176		✗	*zoom = av_expr_eval(s->zoom_expr, var_values, NULL);
177
178		✗	*zoom = av_clipd(*zoom, 1, 10);
179		✗	var_values[VAR_ZOOM] = *zoom;
180		✗	w = in->width * (1.0 / *zoom);
181		✗	h = in->height * (1.0 / *zoom);
182
183		✗	*dx = av_expr_eval(s->x_expr, var_values, NULL);
184
185		✗	x = *dx = av_clipd(*dx, 0, FFMAX(in->width - w, 0));
186		✗	var_values[VAR_X] = *dx;
187		✗	x &= ~((1 << s->desc->log2_chroma_w) - 1);
188
189		✗	*dy = av_expr_eval(s->y_expr, var_values, NULL);
190
191		✗	y = *dy = av_clipd(*dy, 0, FFMAX(in->height - h, 0));
192		✗	var_values[VAR_Y] = *dy;
193		✗	y &= ~((1 << s->desc->log2_chroma_h) - 1);
194
195		✗	out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
196		✗	if (!out) {
197		✗	ret = AVERROR(ENOMEM);
198		✗	return ret;
199			}
200
201		✗	px[1] = px[2] = AV_CEIL_RSHIFT(x, s->desc->log2_chroma_w);
202		✗	px[0] = px[3] = x;
203
204		✗	py[1] = py[2] = AV_CEIL_RSHIFT(y, s->desc->log2_chroma_h);
205		✗	py[0] = py[3] = y;
206
207		✗	s->sws = sws_alloc_context();
208		✗	if (!s->sws) {
209		✗	ret = AVERROR(ENOMEM);
210		✗	goto error;
211			}
212
213		✗	for (k = 0; in->data[k]; k++)
214		✗	input[k] = in->data[k] + py[k] * in->linesize[k] + px[k];
215
216		✗	av_opt_set_int(s->sws, "srcw", w, 0);
217		✗	av_opt_set_int(s->sws, "srch", h, 0);
218		✗	av_opt_set_int(s->sws, "src_format", in->format, 0);
219		✗	av_opt_set_int(s->sws, "dstw", outlink->w, 0);
220		✗	av_opt_set_int(s->sws, "dsth", outlink->h, 0);
221		✗	av_opt_set_int(s->sws, "dst_format", outlink->format, 0);
222		✗	av_opt_set_int(s->sws, "sws_flags", SWS_BICUBIC, 0);
223
224		✗	if ((ret = sws_init_context(s->sws, NULL, NULL)) < 0)
225		✗	goto error;
226
227		✗	sws_scale(s->sws, (const uint8_t *const *)&input, in->linesize, 0, h, out->data, out->linesize);
228
229		✗	out->pts = pts;
230		✗	s->frame_count++;
231
232		✗	ret = ff_filter_frame(outlink, out);
233		✗	sws_freeContext(s->sws);
234		✗	s->sws = NULL;
235		✗	s->current_frame++;
236
237		✗	if (s->current_frame >= s->nb_frames) {
238		✗	if (*dx != -1)
239		✗	s->x = *dx;
240		✗	if (*dy != -1)
241		✗	s->y = *dy;
242		✗	if (*zoom != -1)
243		✗	s->prev_zoom = *zoom;
244		✗	s->prev_nb_frames = s->nb_frames;
245		✗	s->nb_frames = 0;
246		✗	s->current_frame = 0;
247		✗	av_frame_free(&s->in);
248		✗	s->finished = 1;
249			}
250		✗	return ret;
251		✗	error:
252		✗	sws_freeContext(s->sws);
253		✗	s->sws = NULL;
254		✗	av_frame_free(&out);
255		✗	return ret;
256			}
257
258		✗	static int activate(AVFilterContext *ctx)
259			{
260		✗	ZPContext *s = ctx->priv;
261		✗	AVFilterLink *inlink = ctx->inputs[0];
262		✗	AVFilterLink *outlink = ctx->outputs[0];
263		✗	int status, ret = 0;
264			int64_t pts;
265
266		✗	FF_FILTER_FORWARD_STATUS_BACK(outlink, inlink);
267
268		✗	if (s->in && ff_outlink_frame_wanted(outlink)) {
269		✗	double zoom = -1, dx = -1, dy = -1;
270
271		✗	ret = output_single_frame(ctx, s->in, s->var_values, s->current_frame,
272			&zoom, &dx, &dy);
273		✗	if (ret < 0)
274		✗	return ret;
275			}
276
277		✗	if (!s->in && (ret = ff_inlink_consume_frame(inlink, &s->in)) > 0) {
278		✗	double zoom = -1, dx = -1, dy = -1, nb_frames;
279
280		✗	s->finished = 0;
281		✗	s->var_values[VAR_IN_W] = s->var_values[VAR_IW] = s->in->width;
282		✗	s->var_values[VAR_IN_H] = s->var_values[VAR_IH] = s->in->height;
283		✗	s->var_values[VAR_OUT_W] = s->var_values[VAR_OW] = s->w;
284		✗	s->var_values[VAR_OUT_H] = s->var_values[VAR_OH] = s->h;
285		✗	s->var_values[VAR_IN] = inlink->frame_count_out - 1;
286		✗	s->var_values[VAR_ON] = outlink->frame_count_in;
287		✗	s->var_values[VAR_PX] = s->x;
288		✗	s->var_values[VAR_PY] = s->y;
289		✗	s->var_values[VAR_X] = 0;
290		✗	s->var_values[VAR_Y] = 0;
291		✗	s->var_values[VAR_PZOOM] = s->prev_zoom;
292		✗	s->var_values[VAR_ZOOM] = 1;
293		✗	s->var_values[VAR_PDURATION] = s->prev_nb_frames;
294		✗	s->var_values[VAR_A] = (double) s->in->width / s->in->height;
295		✗	s->var_values[VAR_SAR] = inlink->sample_aspect_ratio.num ?
296		✗	(double) inlink->sample_aspect_ratio.num / inlink->sample_aspect_ratio.den : 1;
297		✗	s->var_values[VAR_DAR] = s->var_values[VAR_A] * s->var_values[VAR_SAR];
298		✗	s->var_values[VAR_HSUB] = 1 << s->desc->log2_chroma_w;
299		✗	s->var_values[VAR_VSUB] = 1 << s->desc->log2_chroma_h;
300
301		✗	if ((ret = av_expr_parse_and_eval(&nb_frames, s->duration_expr_str,
302		✗	var_names, s->var_values,
303			NULL, NULL, NULL, NULL, NULL, 0, ctx)) < 0) {
304		✗	av_frame_free(&s->in);
305		✗	return ret;
306			}
307
308		✗	s->var_values[VAR_DURATION] = s->nb_frames = nb_frames;
309
310		✗	ret = output_single_frame(ctx, s->in, s->var_values, s->current_frame,
311			&zoom, &dx, &dy);
312		✗	if (ret < 0)
313		✗	return ret;
314			}
315		✗	if (ret < 0) {
316		✗	return ret;
317		✗	} else if (s->finished && ff_inlink_acknowledge_status(inlink, &status, &pts)) {
318		✗	ff_outlink_set_status(outlink, status, pts);
319		✗	return 0;
320			} else {
321		✗	if (ff_outlink_frame_wanted(outlink) && s->finished)
322		✗	ff_inlink_request_frame(inlink);
323		✗	return 0;
324			}
325			}
326
327			static const enum AVPixelFormat pix_fmts[] = {
328			AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P,
329			AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P,
330			AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P,
331			AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUVA422P,
332			AV_PIX_FMT_YUVA420P,
333			AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ440P,
334			AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
335			AV_PIX_FMT_YUVJ411P,
336			AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
337			AV_PIX_FMT_GRAY8,
338			AV_PIX_FMT_NONE
339			};
340
341		✗	static av_cold void uninit(AVFilterContext *ctx)
342			{
343		✗	ZPContext *s = ctx->priv;
344
345		✗	sws_freeContext(s->sws);
346		✗	s->sws = NULL;
347		✗	av_expr_free(s->x_expr);
348		✗	av_expr_free(s->y_expr);
349		✗	av_expr_free(s->zoom_expr);
350		✗	av_frame_free(&s->in);
351		✗	}
352
353			static const AVFilterPad outputs[] = {
354			{
355			.name = "default",
356			.type = AVMEDIA_TYPE_VIDEO,
357			.config_props = config_output,
358			},
359			};
360
361			const AVFilter ff_vf_zoompan = {
362			.name = "zoompan",
363			.description = NULL_IF_CONFIG_SMALL("Apply Zoom & Pan effect."),
364			.priv_size = sizeof(ZPContext),
365			.priv_class = &zoompan_class,
366			.init = init,
367			.uninit = uninit,
368			.activate = activate,
369			FILTER_INPUTS(ff_video_default_filterpad),
370			FILTER_OUTPUTS(outputs),
371			FILTER_PIXFMTS_ARRAY(pix_fmts),
372			};
373