1 /*
2 * Copyright (c) 2012 Rudolf Polzer
3 * Copyright (c) 2013 Paul B Mahol
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /**
23 * @file telecine filter, heavily based from mpv-player:TOOLS/vf_dlopen/telecine.c by
24 * Rudolf Polzer.
25 */
26
27 #include "libavutil/avstring.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/pixdesc.h"
31 #include "avfilter.h"
32 #include "formats.h"
33 #include "internal.h"
34 #include "video.h"
35
36 typedef struct TelecineContext {
37 const AVClass *class;
38 int first_field;
39 char *pattern;
40 unsigned int pattern_pos;
41 int64_t start_time;
42
43 AVRational pts;
44 AVRational ts_unit;
45 int out_cnt;
46 int occupied;
47
48 int nb_planes;
49 int planeheight[4];
50 int stride[4];
51
52 AVFrame *frame[5];
53 AVFrame *temp;
54 } TelecineContext;
55
56 #define OFFSET(x) offsetof(TelecineContext, x)
57 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
58
59 static const AVOption telecine_options[] = {
60 {"first_field", "select first field", OFFSET(first_field), AV_OPT_TYPE_INT, {.i64=0}, 0, 1, FLAGS, "field"},
61 {"top", "select top field first", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "field"},
62 {"t", "select top field first", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, FLAGS, "field"},
63 {"bottom", "select bottom field first", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "field"},
64 {"b", "select bottom field first", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, FLAGS, "field"},
65 {"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},
66 {NULL}
67 };
68
69 AVFILTER_DEFINE_CLASS(telecine);
70
init(AVFilterContext * ctx)71 static av_cold int init(AVFilterContext *ctx)
72 {
73 TelecineContext *s = ctx->priv;
74 const char *p;
75 int max = 0;
76
77 if (!strlen(s->pattern)) {
78 av_log(ctx, AV_LOG_ERROR, "No pattern provided.\n");
79 return AVERROR_INVALIDDATA;
80 }
81
82 for (p = s->pattern; *p; p++) {
83 if (!av_isdigit(*p)) {
84 av_log(ctx, AV_LOG_ERROR, "Provided pattern includes non-numeric characters.\n");
85 return AVERROR_INVALIDDATA;
86 }
87
88 max = FFMAX(*p - '0', max);
89 s->pts.num += 2;
90 s->pts.den += *p - '0';
91 }
92
93 s->start_time = AV_NOPTS_VALUE;
94
95 s->out_cnt = (max + 1) / 2;
96 av_log(ctx, AV_LOG_INFO, "Telecine pattern %s yields up to %d frames per frame, pts advance factor: %d/%d\n",
97 s->pattern, s->out_cnt, s->pts.num, s->pts.den);
98
99 return 0;
100 }
101
query_formats(AVFilterContext * ctx)102 static int query_formats(AVFilterContext *ctx)
103 {
104 AVFilterFormats *formats = NULL;
105 int ret;
106
107 ret = ff_formats_pixdesc_filter(&formats, 0,
108 AV_PIX_FMT_FLAG_BITSTREAM |
109 AV_PIX_FMT_FLAG_PAL |
110 AV_PIX_FMT_FLAG_HWACCEL);
111 if (ret < 0)
112 return ret;
113 return ff_set_common_formats(ctx, formats);
114 }
115
config_input(AVFilterLink * inlink)116 static int config_input(AVFilterLink *inlink)
117 {
118 TelecineContext *s = inlink->dst->priv;
119 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
120 int i, ret;
121
122 s->temp = ff_get_video_buffer(inlink, inlink->w, inlink->h);
123 if (!s->temp)
124 return AVERROR(ENOMEM);
125 for (i = 0; i < s->out_cnt; i++) {
126 s->frame[i] = ff_get_video_buffer(inlink, inlink->w, inlink->h);
127 if (!s->frame[i])
128 return AVERROR(ENOMEM);
129 }
130
131 if ((ret = av_image_fill_linesizes(s->stride, inlink->format, inlink->w)) < 0)
132 return ret;
133
134 s->planeheight[1] = s->planeheight[2] = AV_CEIL_RSHIFT(inlink->h, desc->log2_chroma_h);
135 s->planeheight[0] = s->planeheight[3] = inlink->h;
136
137 s->nb_planes = av_pix_fmt_count_planes(inlink->format);
138
139 return 0;
140 }
141
config_output(AVFilterLink * outlink)142 static int config_output(AVFilterLink *outlink)
143 {
144 AVFilterContext *ctx = outlink->src;
145 TelecineContext *s = ctx->priv;
146 const AVFilterLink *inlink = ctx->inputs[0];
147 AVRational fps = inlink->frame_rate;
148
149 if (!fps.num || !fps.den) {
150 av_log(ctx, AV_LOG_ERROR, "The input needs a constant frame rate; "
151 "current rate of %d/%d is invalid\n", fps.num, fps.den);
152 return AVERROR(EINVAL);
153 }
154 fps = av_mul_q(fps, av_inv_q(s->pts));
155 av_log(ctx, AV_LOG_VERBOSE, "FPS: %d/%d -> %d/%d\n",
156 inlink->frame_rate.num, inlink->frame_rate.den, fps.num, fps.den);
157
158 outlink->frame_rate = fps;
159 outlink->time_base = av_mul_q(inlink->time_base, s->pts);
160 av_log(ctx, AV_LOG_VERBOSE, "TB: %d/%d -> %d/%d\n",
161 inlink->time_base.num, inlink->time_base.den, outlink->time_base.num, outlink->time_base.den);
162
163 s->ts_unit = av_inv_q(av_mul_q(fps, outlink->time_base));
164
165 return 0;
166 }
167
filter_frame(AVFilterLink * inlink,AVFrame * inpicref)168 static int filter_frame(AVFilterLink *inlink, AVFrame *inpicref)
169 {
170 AVFilterContext *ctx = inlink->dst;
171 AVFilterLink *outlink = ctx->outputs[0];
172 TelecineContext *s = ctx->priv;
173 int i, len, ret = 0, nout = 0;
174
175 if (s->start_time == AV_NOPTS_VALUE)
176 s->start_time = inpicref->pts;
177
178 len = s->pattern[s->pattern_pos] - '0';
179
180 s->pattern_pos++;
181 if (!s->pattern[s->pattern_pos])
182 s->pattern_pos = 0;
183
184 if (!len) { // do not output any field from this frame
185 av_frame_free(&inpicref);
186 return 0;
187 }
188
189 if (s->occupied) {
190 av_frame_make_writable(s->frame[nout]);
191 for (i = 0; i < s->nb_planes; i++) {
192 // fill in the EARLIER field from the buffered pic
193 av_image_copy_plane(s->frame[nout]->data[i] + s->frame[nout]->linesize[i] * s->first_field,
194 s->frame[nout]->linesize[i] * 2,
195 s->temp->data[i] + s->temp->linesize[i] * s->first_field,
196 s->temp->linesize[i] * 2,
197 s->stride[i],
198 (s->planeheight[i] - s->first_field + 1) / 2);
199 // fill in the LATER field from the new pic
200 av_image_copy_plane(s->frame[nout]->data[i] + s->frame[nout]->linesize[i] * !s->first_field,
201 s->frame[nout]->linesize[i] * 2,
202 inpicref->data[i] + inpicref->linesize[i] * !s->first_field,
203 inpicref->linesize[i] * 2,
204 s->stride[i],
205 (s->planeheight[i] - !s->first_field + 1) / 2);
206 }
207 s->frame[nout]->interlaced_frame = 1;
208 s->frame[nout]->top_field_first = !s->first_field;
209 nout++;
210 len--;
211 s->occupied = 0;
212 }
213
214 while (len >= 2) {
215 // output THIS image as-is
216 av_frame_make_writable(s->frame[nout]);
217 for (i = 0; i < s->nb_planes; i++)
218 av_image_copy_plane(s->frame[nout]->data[i], s->frame[nout]->linesize[i],
219 inpicref->data[i], inpicref->linesize[i],
220 s->stride[i],
221 s->planeheight[i]);
222 s->frame[nout]->interlaced_frame = inpicref->interlaced_frame;
223 s->frame[nout]->top_field_first = inpicref->top_field_first;
224 nout++;
225 len -= 2;
226 }
227
228 if (len >= 1) {
229 // copy THIS image to the buffer, we need it later
230 for (i = 0; i < s->nb_planes; i++)
231 av_image_copy_plane(s->temp->data[i], s->temp->linesize[i],
232 inpicref->data[i], inpicref->linesize[i],
233 s->stride[i],
234 s->planeheight[i]);
235 s->occupied = 1;
236 }
237
238 for (i = 0; i < nout; i++) {
239 AVFrame *frame = av_frame_clone(s->frame[i]);
240 int interlaced = frame ? frame->interlaced_frame : 0;
241 int tff = frame ? frame->top_field_first : 0;
242
243 if (!frame) {
244 av_frame_free(&inpicref);
245 return AVERROR(ENOMEM);
246 }
247
248 av_frame_copy_props(frame, inpicref);
249 frame->interlaced_frame = interlaced;
250 frame->top_field_first = tff;
251 frame->pts = ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time) +
252 av_rescale(outlink->frame_count_in, s->ts_unit.num,
253 s->ts_unit.den);
254 ret = ff_filter_frame(outlink, frame);
255 }
256 av_frame_free(&inpicref);
257
258 return ret;
259 }
260
uninit(AVFilterContext * ctx)261 static av_cold void uninit(AVFilterContext *ctx)
262 {
263 TelecineContext *s = ctx->priv;
264 int i;
265
266 av_frame_free(&s->temp);
267 for (i = 0; i < s->out_cnt; i++)
268 av_frame_free(&s->frame[i]);
269 }
270
271 static const AVFilterPad telecine_inputs[] = {
272 {
273 .name = "default",
274 .type = AVMEDIA_TYPE_VIDEO,
275 .filter_frame = filter_frame,
276 .config_props = config_input,
277 },
278 { NULL }
279 };
280
281 static const AVFilterPad telecine_outputs[] = {
282 {
283 .name = "default",
284 .type = AVMEDIA_TYPE_VIDEO,
285 .config_props = config_output,
286 },
287 { NULL }
288 };
289
290 AVFilter ff_vf_telecine = {
291 .name = "telecine",
292 .description = NULL_IF_CONFIG_SMALL("Apply a telecine pattern."),
293 .priv_size = sizeof(TelecineContext),
294 .priv_class = &telecine_class,
295 .init = init,
296 .uninit = uninit,
297 .query_formats = query_formats,
298 .inputs = telecine_inputs,
299 .outputs = telecine_outputs,
300 };
301