FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavfilter/vf_detelecine.c
Date: 2022-12-09 07:38:14
Exec Total Coverage
Lines: 0 171 0.0%
Functions: 0 6 0.0%
Branches: 0 84 0.0%

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, "field"},
62 {"top", "select top field first", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "field"},
63 {"t", "select top field first", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "field"},
64 {"bottom", "select bottom field first", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "field"},
65 {"b", "select bottom field first", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "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