FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2015 Himangi Saraogi <himangi774@gmail.com>
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			/**
22			* @file detelecine filter.
23			*/
24
25
26			#include "libavutil/avstring.h"
27			#include "libavutil/imgutils.h"
28			#include "libavutil/opt.h"
29			#include "libavutil/pixdesc.h"
30			#include "avfilter.h"
31			#include "formats.h"
32			#include "internal.h"
33			#include "video.h"
34
35			typedef struct DetelecineContext {
36			const AVClass *class;
37			int first_field;
38			char *pattern;
39			int start_frame;
40			int init_len;
41			unsigned int pattern_pos;
42			unsigned int nskip_fields;
43			int64_t start_time;
44
45			AVRational pts;
46			AVRational ts_unit;
47			int occupied;
48
49			int nb_planes;
50			int planeheight[4];
51			int stride[4];
52
53			AVFrame *frame[2];
54			AVFrame *temp;
55			} DetelecineContext;
56
57			#define OFFSET(x) offsetof(DetelecineContext, x)
58			#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
59
60			static const AVOption detelecine_options[] = {
61			{"first_field", "select first field", OFFSET(first_field), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, .unit = "field"},
62			{"top", "select top field first", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "field"},
63			{"t", "select top field first", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, .unit = "field"},
64			{"bottom", "select bottom field first", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "field"},
65			{"b", "select bottom field first", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, .unit = "field"},
66			{"pattern", "pattern that describe for how many fields a frame is to be displayed", OFFSET(pattern), AV_OPT_TYPE_STRING, {.str="23"}, 0, 0, FLAGS},
67			{"start_frame", "position of first frame with respect to the pattern if stream is cut", OFFSET(start_frame), AV_OPT_TYPE_INT, {.i64=0}, 0, 13, FLAGS},
68			{NULL}
69			};
70
71			AVFILTER_DEFINE_CLASS(detelecine);
72
73		✗	static av_cold int init(AVFilterContext *ctx)
74			{
75		✗	DetelecineContext *s = ctx->priv;
76			const char *p;
77		✗	int max = 0;
78		✗	int sum = 0;
79
80		✗	if (!strlen(s->pattern)) {
81		✗	av_log(ctx, AV_LOG_ERROR, "No pattern provided.\n");
82		✗	return AVERROR_INVALIDDATA;
83			}
84
85		✗	for (p = s->pattern; *p; p++) {
86		✗	if (!av_isdigit(*p)) {
87		✗	av_log(ctx, AV_LOG_ERROR, "Provided pattern includes non-numeric characters.\n");
88		✗	return AVERROR_INVALIDDATA;
89			}
90
91		✗	sum += *p - '0';
92		✗	max = FFMAX(*p - '0', max);
93		✗	s->pts.num += *p - '0';
94		✗	s->pts.den += 2;
95			}
96
97		✗	if (s->start_frame >= sum) {
98		✗	av_log(ctx, AV_LOG_ERROR, "Provided start_frame is too big.\n");
99		✗	return AVERROR_INVALIDDATA;
100			}
101
102		✗	s->nskip_fields = 0;
103		✗	s->pattern_pos = 0;
104		✗	s->start_time = AV_NOPTS_VALUE;
105		✗	s->init_len = 0;
106
107		✗	if (s->start_frame != 0) {
108		✗	int nfields = 0;
109		✗	for (p = s->pattern; *p; p++) {
110		✗	nfields += *p - '0';
111		✗	s->pattern_pos++;
112		✗	if (nfields >= 2*s->start_frame) {
113		✗	s->init_len = nfields - 2*s->start_frame;
114		✗	break;
115			}
116			}
117			}
118
119		✗	av_log(ctx, AV_LOG_INFO, "Detelecine pattern %s removes up to %d frames per frame, pts advance factor: %d/%d\n",
120		✗	s->pattern, (max + 1) / 2, s->pts.num, s->pts.den);
121
122		✗	return 0;
123			}
124
125		✗	static int query_formats(AVFilterContext *ctx)
126			{
127		✗	int reject_flags = AV_PIX_FMT_FLAG_BITSTREAM |
128			AV_PIX_FMT_FLAG_PAL |
129			AV_PIX_FMT_FLAG_HWACCEL;
130
131		✗	return ff_set_common_formats(ctx, ff_formats_pixdesc_filter(0, reject_flags));
132			}
133
134		✗	static int config_input(AVFilterLink *inlink)
135			{
136		✗	DetelecineContext *s = inlink->dst->priv;
137		✗	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
138			int ret;
139
140		✗	s->temp = ff_get_video_buffer(inlink, inlink->w, inlink->h);
141		✗	if (!s->temp)
142		✗	return AVERROR(ENOMEM);
143
144		✗	s->frame[0] = ff_get_video_buffer(inlink, inlink->w, inlink->h);
145		✗	if (!s->frame[0])
146		✗	return AVERROR(ENOMEM);
147
148		✗	s->frame[1] = ff_get_video_buffer(inlink, inlink->w, inlink->h);
149		✗	if (!s->frame[1])
150		✗	return AVERROR(ENOMEM);
151
152		✗	if ((ret = av_image_fill_linesizes(s->stride, inlink->format, inlink->w)) < 0)
153		✗	return ret;
154
155		✗	s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
156		✗	s->planeheight[0] = s->planeheight[3] = inlink->h;
157
158		✗	s->nb_planes = av_pix_fmt_count_planes(inlink->format);
159
160		✗	return 0;
161			}
162
163		✗	static int config_output(AVFilterLink *outlink)
164			{
165		✗	AVFilterContext *ctx = outlink->src;
166		✗	DetelecineContext *s = ctx->priv;
167		✗	const AVFilterLink *inlink = ctx->inputs[0];
168		✗	AVRational fps = inlink->frame_rate;
169
170		✗	if (!fps.num || !fps.den) {
171		✗	av_log(ctx, AV_LOG_ERROR, "The input needs a constant frame rate; "
172			"current rate of %d/%d is invalid\n", fps.num, fps.den);
173		✗	return AVERROR(EINVAL);
174			}
175		✗	fps = av_mul_q(fps, av_inv_q(s->pts));
176		✗	av_log(ctx, AV_LOG_VERBOSE, "FPS: %d/%d -> %d/%d\n",
177		✗	inlink->frame_rate.num, inlink->frame_rate.den, fps.num, fps.den);
178
179		✗	outlink->frame_rate = fps;
180		✗	outlink->time_base = av_mul_q(inlink->time_base, s->pts);
181		✗	av_log(ctx, AV_LOG_VERBOSE, "TB: %d/%d -> %d/%d\n",
182		✗	inlink->time_base.num, inlink->time_base.den, outlink->time_base.num, outlink->time_base.den);
183
184		✗	s->ts_unit = av_inv_q(av_mul_q(fps, outlink->time_base));
185
186		✗	return 0;
187			}
188
189		✗	static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
190			{
191		✗	AVFilterContext *ctx = inlink->dst;
192		✗	AVFilterLink *outlink = ctx->outputs[0];
193		✗	DetelecineContext *s = ctx->priv;
194		✗	int i, len = 0, ret = 0, out = 0;
195
196		✗	if (s->start_time == AV_NOPTS_VALUE)
197		✗	s->start_time = inpicref->pts;
198
199		✗	if (s->nskip_fields >= 2) {
200		✗	s->nskip_fields -= 2;
201		✗	av_frame_free(&inpicref);
202		✗	return 0;
203		✗	} else if (s->nskip_fields >= 1) {
204		✗	for (i = 0; i < s->nb_planes; i++) {
205		✗	av_image_copy_plane(s->temp->data[i], s->temp->linesize[i],
206		✗	inpicref->data[i], inpicref->linesize[i],
207			s->stride[i],
208			s->planeheight[i]);
209			}
210		✗	s->occupied = 1;
211		✗	s->nskip_fields--;
212		✗	av_frame_free(&inpicref);
213		✗	return 0;
214			}
215
216		✗	if (s->nskip_fields == 0) {
217		✗	len = s->init_len;
218		✗	s->init_len = 0;
219		✗	while(!len && s->pattern[s->pattern_pos]) {
220		✗	len = s->pattern[s->pattern_pos] - '0';
221		✗	s->pattern_pos++;
222			}
223
224		✗	if (!s->pattern[s->pattern_pos])
225		✗	s->pattern_pos = 0;
226
227		✗	if(!len) { // do not output any field as the entire pattern is zero
228		✗	av_frame_free(&inpicref);
229		✗	return 0;
230			}
231
232		✗	if (len == 1 && s->occupied) {
233		✗	s->occupied = 0;
234			// output THIS image as-is
235		✗	for (i = 0; i < s->nb_planes; i++)
236		✗	av_image_copy_plane(s->frame[out]->data[i], s->frame[out]->linesize[i],
237		✗	s->temp->data[i], s->temp->linesize[i],
238			s->stride[i],
239			s->planeheight[i]);
240		✗	len = 0;
241		✗	while(!len && s->pattern[s->pattern_pos]) {
242		✗	len = s->pattern[s->pattern_pos] - '0';
243		✗	s->pattern_pos++;
244			}
245
246		✗	if (!s->pattern[s->pattern_pos])
247		✗	s->pattern_pos = 0;
248
249		✗	s->occupied = 0;
250		✗	++out;
251			}
252
253		✗	if (s->occupied) {
254		✗	for (i = 0; i < s->nb_planes; i++) {
255			// fill in the EARLIER field from the new pic
256		✗	av_image_copy_plane(s->frame[out]->data[i] + s->frame[out]->linesize[i] * s->first_field,
257		✗	s->frame[out]->linesize[i] * 2,
258		✗	inpicref->data[i] + inpicref->linesize[i] * s->first_field,
259		✗	inpicref->linesize[i] * 2,
260			s->stride[i],
261		✗	(s->planeheight[i] - s->first_field + 1) / 2);
262			// fill in the LATER field from the buffered pic
263		✗	av_image_copy_plane(s->frame[out]->data[i] + s->frame[out]->linesize[i] * !s->first_field,
264		✗	s->frame[out]->linesize[i] * 2,
265		✗	s->temp->data[i] + s->temp->linesize[i] * !s->first_field,
266		✗	s->temp->linesize[i] * 2,
267			s->stride[i],
268		✗	(s->planeheight[i] - !s->first_field + 1) / 2);
269			}
270
271		✗	s->occupied = 0;
272		✗	if (len <= 2) {
273		✗	for (i = 0; i < s->nb_planes; i++) {
274		✗	av_image_copy_plane(s->temp->data[i], s->temp->linesize[i],
275		✗	inpicref->data[i], inpicref->linesize[i],
276			s->stride[i],
277			s->planeheight[i]);
278			}
279		✗	s->occupied = 1;
280			}
281		✗	++out;
282		✗	len = (len >= 3) ? len - 3 : 0;
283			} else {
284		✗	if (len >= 2) {
285			// output THIS image as-is
286		✗	for (i = 0; i < s->nb_planes; i++)
287		✗	av_image_copy_plane(s->frame[out]->data[i], s->frame[out]->linesize[i],
288		✗	inpicref->data[i], inpicref->linesize[i],
289			s->stride[i],
290			s->planeheight[i]);
291		✗	len -= 2;
292		✗	++out;
293		✗	} else if (len == 1) {
294			// output THIS image as-is
295		✗	for (i = 0; i < s->nb_planes; i++)
296		✗	av_image_copy_plane(s->frame[out]->data[i], s->frame[out]->linesize[i],
297		✗	inpicref->data[i], inpicref->linesize[i],
298			s->stride[i],
299			s->planeheight[i]);
300
301		✗	for (i = 0; i < s->nb_planes; i++) {
302		✗	av_image_copy_plane(s->temp->data[i], s->temp->linesize[i],
303		✗	inpicref->data[i], inpicref->linesize[i],
304			s->stride[i],
305			s->planeheight[i]);
306			}
307		✗	s->occupied = 1;
308
309		✗	len--;
310		✗	++out;
311			}
312			}
313
314		✗	if (len == 1 && s->occupied)
315			{
316		✗	len--;
317		✗	s->occupied = 0;
318			}
319			}
320		✗	s->nskip_fields = len;
321
322		✗	for (i = 0; i < out; ++i) {
323		✗	AVFrame *frame = av_frame_clone(s->frame[i]);
324
325		✗	if (!frame) {
326		✗	av_frame_free(&inpicref);
327		✗	return AVERROR(ENOMEM);
328			}
329
330		✗	av_frame_copy_props(frame, inpicref);
331		✗	frame->pts = ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time) +
332		✗	av_rescale(outlink->frame_count_in, s->ts_unit.num,
333		✗	s->ts_unit.den);
334		✗	ret = ff_filter_frame(outlink, frame);
335			}
336
337		✗	av_frame_free(&inpicref);
338
339		✗	return ret;
340			}
341
342		✗	static av_cold void uninit(AVFilterContext *ctx)
343			{
344		✗	DetelecineContext *s = ctx->priv;
345
346		✗	av_frame_free(&s->temp);
347		✗	av_frame_free(&s->frame[0]);
348		✗	av_frame_free(&s->frame[1]);
349		✗	}
350
351			static const AVFilterPad detelecine_inputs[] = {
352			{
353			.name = "default",
354			.type = AVMEDIA_TYPE_VIDEO,
355			.filter_frame = filter_frame,
356			.config_props = config_input,
357			},
358			};
359
360			static const AVFilterPad detelecine_outputs[] = {
361			{
362			.name = "default",
363			.type = AVMEDIA_TYPE_VIDEO,
364			.config_props = config_output,
365			},
366			};
367
368			const AVFilter ff_vf_detelecine = {
369			.name = "detelecine",
370			.description = NULL_IF_CONFIG_SMALL("Apply an inverse telecine pattern."),
371			.priv_size = sizeof(DetelecineContext),
372			.priv_class = &detelecine_class,
373			.init = init,
374			.uninit = uninit,
375			FILTER_INPUTS(detelecine_inputs),
376			FILTER_OUTPUTS(detelecine_outputs),
377			FILTER_QUERY_FUNC(query_formats),
378			};
379