Merge remote-tracking branch 'qatar/master'
[ffmpeg.git] / libavfilter / vf_tinterlace.c
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
3  * Copyright (c) 2010 Baptiste Coudurier
4  * Copyright (c) 2003 Michael Zucchi <notzed@ximian.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License along
19  * with FFmpeg if not, write to the Free Software Foundation, Inc.,
20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21  */
22
23 /**
24  * @file
25  * temporal field interlace filter, ported from MPlayer/libmpcodecs
26  */
27
28 #include "libavutil/imgutils.h"
29 #include "avfilter.h"
30 #include "internal.h"
31
32 enum TInterlaceMode {
33     MODE_MERGE = 0,
34     MODE_DROP_EVEN,
35     MODE_DROP_ODD,
36     MODE_PAD,
37     MODE_INTERLEAVE_TOP,
38     MODE_INTERLEAVE_BOTTOM,
39     MODE_INTERLACEX2,
40 };
41
42 static const char *tinterlace_mode_str[] = {
43     "merge",
44     "drop_even",
45     "drop_odd",
46     "pad",
47     "interleave_top",
48     "interleave_bottom",
49     "interlacex2",
50     NULL
51 };
52
53 typedef struct {
54     enum TInterlaceMode mode;   ///< interlace mode selected
55     int frame;                  ///< number of the output frame
56     int vsub;                   ///< chroma vertical subsampling
57     AVFilterBufferRef *cur;
58     AVFilterBufferRef *next;
59     uint8_t *black_data[4];     ///< buffer used to fill padded lines
60     int black_linesize[4];
61 } TInterlaceContext;
62
63 #define FULL_SCALE_YUVJ_FORMATS \
64     PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUVJ440P
65
66 static enum PixelFormat full_scale_yuvj_pix_fmts[] = {
67     FULL_SCALE_YUVJ_FORMATS, PIX_FMT_NONE
68 };
69
70 static int query_formats(AVFilterContext *ctx)
71 {
72     static const enum PixelFormat pix_fmts[] = {
73         PIX_FMT_YUV420P,  PIX_FMT_YUV422P,  PIX_FMT_YUV444P,
74         PIX_FMT_YUV444P,  PIX_FMT_YUV410P,  PIX_FMT_YUVA420P,
75         PIX_FMT_GRAY8, FULL_SCALE_YUVJ_FORMATS,
76         PIX_FMT_NONE
77     };
78
79     avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
80     return 0;
81 }
82
83 static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
84 {
85     TInterlaceContext *tinterlace = ctx->priv;
86     int i;
87     char c;
88
89     tinterlace->mode = MODE_MERGE;
90
91     if (args) {
92         if (sscanf(args, "%d%c", (int *)&tinterlace->mode, &c) == 1) {
93             if (tinterlace->mode > 6) {
94                 av_log(ctx, AV_LOG_ERROR,
95                        "Invalid mode '%s', use an integer between 0 and 6\n", args);
96                 return AVERROR(EINVAL);
97             }
98
99             av_log(ctx, AV_LOG_WARNING,
100                    "Using numeric constant is deprecated, use symbolic values\n");
101         } else {
102             for (i = 0; tinterlace_mode_str[i]; i++) {
103                 if (!strcmp(tinterlace_mode_str[i], args)) {
104                     tinterlace->mode = i;
105                     break;
106                 }
107             }
108             if (!tinterlace_mode_str[i]) {
109                 av_log(ctx, AV_LOG_ERROR, "Invalid argument '%s'\n", args);
110                 return AVERROR(EINVAL);
111             }
112         }
113     }
114
115     return 0;
116 }
117
118 static av_cold void uninit(AVFilterContext *ctx)
119 {
120     TInterlaceContext *tinterlace = ctx->priv;
121
122     if (tinterlace->cur ) avfilter_unref_bufferp(&tinterlace->cur );
123     if (tinterlace->next) avfilter_unref_bufferp(&tinterlace->next);
124
125     av_freep(&tinterlace->black_data[0]);
126 }
127
128 static int config_out_props(AVFilterLink *outlink)
129 {
130     AVFilterContext *ctx = outlink->src;
131     AVFilterLink *inlink = outlink->src->inputs[0];
132     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[outlink->format];
133     TInterlaceContext *tinterlace = ctx->priv;
134
135     tinterlace->vsub = desc->log2_chroma_h;
136     outlink->w = inlink->w;
137     outlink->h = tinterlace->mode == MODE_MERGE || tinterlace->mode == MODE_PAD ?
138         inlink->h*2 : inlink->h;
139
140     if (tinterlace->mode == MODE_PAD) {
141         uint8_t black[4] = { 16, 128, 128, 16 };
142         int i, ret;
143         if (ff_fmt_is_in(outlink->format, full_scale_yuvj_pix_fmts))
144             black[0] = black[3] = 0;
145         ret = av_image_alloc(tinterlace->black_data, tinterlace->black_linesize,
146                              outlink->w, outlink->h, outlink->format, 1);
147         if (ret < 0)
148             return ret;
149
150         /* fill black picture with black */
151         for (i = 0; i < 4 && tinterlace->black_data[i]; i++) {
152             int h = i == 1 || i == 2 ? outlink->h >> desc->log2_chroma_h : outlink->h;
153             memset(tinterlace->black_data[i], black[i],
154                    tinterlace->black_linesize[i] * h);
155         }
156     }
157     av_log(ctx, AV_LOG_INFO, "mode:%s h:%d -> h:%d\n",
158            tinterlace_mode_str[tinterlace->mode], inlink->h, outlink->h);
159
160     return 0;
161 }
162
163 #define FIELD_UPPER           0
164 #define FIELD_LOWER           1
165 #define FIELD_UPPER_AND_LOWER 2
166
167 /**
168  * Copy picture field from src to dst.
169  *
170  * @param src_field copy from upper, lower field or both
171  * @param interleave leave a padding line between each copied line
172  * @param dst_field copy to upper or lower field,
173  *        only meaningful when interleave is selected
174  */
175 static inline
176 void copy_picture_field(uint8_t *dst[4], int dst_linesize[4],
177                         uint8_t *src[4], int src_linesize[4],
178                         enum PixelFormat format, int w, int src_h,
179                         int src_field, int interleave, int dst_field)
180 {
181     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[format];
182     int plane, vsub = desc->log2_chroma_h;
183     int k = src_field == FIELD_UPPER_AND_LOWER ? 1 : 2;
184
185     for (plane = 0; plane < desc->nb_components; plane++) {
186         int lines = plane == 1 || plane == 2 ? src_h >> vsub : src_h;
187         int linesize = av_image_get_linesize(format, w, plane);
188         uint8_t *dstp = dst[plane];
189         uint8_t *srcp = src[plane];
190         lines /= k;
191         if (src_field == FIELD_LOWER)
192             srcp += src_linesize[plane];
193         if (interleave && dst_field == FIELD_LOWER)
194             dstp += dst_linesize[plane];
195         av_image_copy_plane(dstp, dst_linesize[plane] * (interleave ? 2 : 1),
196                             srcp, src_linesize[plane]*k, linesize, lines);
197     }
198 }
199
200 static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
201 {
202     AVFilterContext *ctx = inlink->dst;
203     TInterlaceContext *tinterlace = ctx->priv;
204
205     avfilter_unref_buffer(tinterlace->cur);
206     tinterlace->cur  = tinterlace->next;
207     tinterlace->next = picref;
208 }
209
210 static void end_frame(AVFilterLink *inlink)
211 {
212     AVFilterContext *ctx = inlink->dst;
213     AVFilterLink *outlink = ctx->outputs[0];
214     TInterlaceContext *tinterlace = ctx->priv;
215     AVFilterBufferRef *cur  = tinterlace->cur;
216     AVFilterBufferRef *next = tinterlace->next;
217     AVFilterBufferRef *out  = NULL;
218     int field, tff;
219
220     /* we need at least two frames */
221     if (!tinterlace->cur)
222         return;
223
224     switch (tinterlace->mode) {
225     case MODE_MERGE: /* move the odd frame into the upper field of the new image, even into
226              * the lower field, generating a double-height video at half framerate */
227         out = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
228         avfilter_copy_buffer_ref_props(out, cur);
229         out->video->h = outlink->h;
230         out->video->interlaced = 1;
231         out->video->top_field_first = 1;
232
233         /* write odd frame lines into the upper field of the new frame */
234         copy_picture_field(out->data, out->linesize,
235                            cur->data, cur->linesize,
236                            inlink->format, inlink->w, inlink->h,
237                            FIELD_UPPER_AND_LOWER, 1, FIELD_UPPER);
238         /* write even frame lines into the lower field of the new frame */
239         copy_picture_field(out->data, out->linesize,
240                            next->data, next->linesize,
241                            inlink->format, inlink->w, inlink->h,
242                            FIELD_UPPER_AND_LOWER, 1, FIELD_LOWER);
243         avfilter_unref_bufferp(&tinterlace->next);
244         break;
245
246     case MODE_DROP_ODD:  /* only output even frames, odd  frames are dropped; height unchanged, half framerate */
247     case MODE_DROP_EVEN: /* only output odd  frames, even frames are dropped; height unchanged, half framerate */
248         out = avfilter_ref_buffer(tinterlace->mode == MODE_DROP_EVEN ? cur : next, AV_PERM_READ);
249         avfilter_unref_bufferp(&tinterlace->next);
250         break;
251
252     case MODE_PAD: /* expand each frame to double height, but pad alternate
253                     * lines with black; framerate unchanged */
254         out = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
255         avfilter_copy_buffer_ref_props(out, cur);
256         out->video->h = outlink->h;
257
258         field = (1 + tinterlace->frame) & 1 ? FIELD_UPPER : FIELD_LOWER;
259         /* copy upper and lower fields */
260         copy_picture_field(out->data, out->linesize,
261                            cur->data, cur->linesize,
262                            inlink->format, inlink->w, inlink->h,
263                            FIELD_UPPER_AND_LOWER, 1, field);
264         /* pad with black the other field */
265         copy_picture_field(out->data, out->linesize,
266                            tinterlace->black_data, tinterlace->black_linesize,
267                            inlink->format, inlink->w, inlink->h,
268                            FIELD_UPPER_AND_LOWER, 1, !field);
269         break;
270
271         /* interleave upper/lower lines from odd frames with lower/upper lines from even frames,
272          * halving the frame rate and preserving image height */
273     case MODE_INTERLEAVE_TOP:    /* top    field first */
274     case MODE_INTERLEAVE_BOTTOM: /* bottom field first */
275         tff = tinterlace->mode == MODE_INTERLEAVE_TOP;
276         out = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
277         avfilter_copy_buffer_ref_props(out, cur);
278         out->video->interlaced = 1;
279         out->video->top_field_first = tff;
280
281         /* copy upper/lower field from cur */
282         copy_picture_field(out->data, out->linesize,
283                            cur->data, cur->linesize,
284                            inlink->format, inlink->w, inlink->h,
285                            tff ? FIELD_UPPER : FIELD_LOWER, 1, tff ? FIELD_UPPER : FIELD_LOWER);
286         /* copy lower/upper field from next */
287         copy_picture_field(out->data, out->linesize,
288                            next->data, next->linesize,
289                            inlink->format, inlink->w, inlink->h,
290                            tff ? FIELD_LOWER : FIELD_UPPER, 1, tff ? FIELD_LOWER : FIELD_UPPER);
291         avfilter_unref_bufferp(&tinterlace->next);
292         break;
293     case MODE_INTERLACEX2: /* re-interlace preserving image height, double frame rate */
294         /* output current frame first */
295         out = avfilter_ref_buffer(cur, AV_PERM_READ);
296         out->video->interlaced = 1;
297
298         avfilter_start_frame(outlink, out);
299         avfilter_draw_slice(outlink, 0, outlink->h, 1);
300         avfilter_end_frame(outlink);
301
302         /* output mix of current and next frame */
303         tff = next->video->top_field_first;
304         out = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
305         avfilter_copy_buffer_ref_props(out, next);
306         out->video->interlaced = 1;
307
308         /* write current frame second field lines into the second field of the new frame */
309         copy_picture_field(out->data, out->linesize,
310                            cur->data, cur->linesize,
311                            inlink->format, inlink->w, inlink->h,
312                            tff ? FIELD_LOWER : FIELD_UPPER, 1, tff ? FIELD_LOWER : FIELD_UPPER);
313         /* write next frame first field lines into the first field of the new frame */
314         copy_picture_field(out->data, out->linesize,
315                            next->data, next->linesize,
316                            inlink->format, inlink->w, inlink->h,
317                            tff ? FIELD_UPPER : FIELD_LOWER, 1, tff ? FIELD_UPPER : FIELD_LOWER);
318         break;
319     }
320
321     avfilter_start_frame(outlink, out);
322     avfilter_draw_slice(outlink, 0, outlink->h, 1);
323     avfilter_end_frame(outlink);
324
325     tinterlace->frame++;
326 }
327
328 static int poll_frame(AVFilterLink *outlink)
329 {
330     TInterlaceContext *tinterlace = outlink->src->priv;
331     AVFilterLink *inlink = outlink->src->inputs[0];
332     int ret, val;
333
334     val = avfilter_poll_frame(inlink);
335
336     if (val == 1 && !tinterlace->next) {
337         if ((ret = avfilter_request_frame(inlink)) < 0)
338             return ret;
339         val = avfilter_poll_frame(inlink);
340     }
341     assert(tinterlace->next);
342
343     return val;
344 }
345
346 static int request_frame(AVFilterLink *outlink)
347 {
348     TInterlaceContext *tinterlace = outlink->src->priv;
349     AVFilterLink *inlink = outlink->src->inputs[0];
350
351     do {
352         int ret;
353
354         if ((ret = avfilter_request_frame(inlink)) < 0)
355             return ret;
356     } while (!tinterlace->cur);
357
358     return 0;
359 }
360
361 static void null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir) { }
362
363 AVFilter avfilter_vf_tinterlace = {
364     .name          = "tinterlace",
365     .description   = NULL_IF_CONFIG_SMALL("Perform temporal field interlacing."),
366     .priv_size     = sizeof(TInterlaceContext),
367     .init          = init,
368     .uninit        = uninit,
369     .query_formats = query_formats,
370
371     .inputs = (const AVFilterPad[]) {
372         { .name          = "default",
373           .type          = AVMEDIA_TYPE_VIDEO,
374           .start_frame   = start_frame,
375           .draw_slice    = null_draw_slice,
376           .end_frame     = end_frame, },
377         { .name = NULL}
378     },
379     .outputs = (const AVFilterPad[]) {
380         { .name          = "default",
381           .type          = AVMEDIA_TYPE_VIDEO,
382           .config_props  = config_out_props,
383           .poll_frame    = poll_frame,
384           .request_frame = request_frame },
385         { .name = NULL}
386     },
387 };