lavfi/tinterlace: remove unnecessary NULL check in start_frame()
[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 typedef struct {
33     int mode;                   ///< interlace mode selected
34     int frame;                  ///< number of the output frame
35     int vsub;                   ///< chroma vertical subsampling
36     AVFilterBufferRef *cur;
37     AVFilterBufferRef *next;
38     uint8_t *black_data[4];     ///< buffer used to fill padded lines
39     int black_linesize[4];
40 } TInterlaceContext;
41
42 #define FULL_SCALE_YUVJ_FORMATS \
43     PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUVJ440P
44
45 static enum PixelFormat full_scale_yuvj_pix_fmts[] = {
46     FULL_SCALE_YUVJ_FORMATS, PIX_FMT_NONE
47 };
48
49 static int query_formats(AVFilterContext *ctx)
50 {
51     static const enum PixelFormat pix_fmts[] = {
52         PIX_FMT_YUV420P,  PIX_FMT_YUV422P,  PIX_FMT_YUV444P,
53         PIX_FMT_YUV444P,  PIX_FMT_YUV410P,  PIX_FMT_YUVA420P,
54         PIX_FMT_GRAY8, FULL_SCALE_YUVJ_FORMATS,
55         PIX_FMT_NONE
56     };
57
58     avfilter_set_common_pixel_formats(ctx, avfilter_make_format_list(pix_fmts));
59     return 0;
60 }
61
62 static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
63 {
64     TInterlaceContext *tinterlace = ctx->priv;
65     int n;
66     tinterlace->mode = 0;
67
68     if (args) {
69         n = sscanf(args, "%d", &tinterlace->mode);
70
71         if (n != 1 || tinterlace->mode < 0 || tinterlace->mode > 5) {
72             av_log(ctx, AV_LOG_ERROR,
73                    "Invalid mode '%s', use an integer between 0 and 5\n", args);
74             return AVERROR(EINVAL);
75         }
76     }
77
78     return 0;
79 }
80
81 static av_cold void uninit(AVFilterContext *ctx)
82 {
83     TInterlaceContext *tinterlace = ctx->priv;
84
85     if (tinterlace->cur ) avfilter_unref_bufferp(&tinterlace->cur );
86     if (tinterlace->next) avfilter_unref_bufferp(&tinterlace->next);
87
88     av_freep(&tinterlace->black_data[0]);
89 }
90
91 static int config_out_props(AVFilterLink *outlink)
92 {
93     AVFilterContext *ctx = outlink->src;
94     AVFilterLink *inlink = outlink->src->inputs[0];
95     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[outlink->format];
96     TInterlaceContext *tinterlace = ctx->priv;
97
98     tinterlace->vsub = desc->log2_chroma_h;
99     outlink->w = inlink->w;
100     outlink->h = tinterlace->mode == 0 || tinterlace->mode == 3 ?
101         inlink->h*2 : inlink->h;
102
103     if (tinterlace->mode == 3) {
104         uint8_t black[4] = { 16, 128, 128, 16 };
105         int i, ret;
106         if (ff_fmt_is_in(outlink->format, full_scale_yuvj_pix_fmts))
107             black[0] = black[3] = 0;
108         ret = av_image_alloc(tinterlace->black_data, tinterlace->black_linesize,
109                              outlink->w, outlink->h, outlink->format, 1);
110         if (ret < 0)
111             return ret;
112
113         /* fill black picture with black */
114         for (i = 0; i < 4 && tinterlace->black_data[i]; i++) {
115             int h = i == 1 || i == 2 ? outlink->h >> desc->log2_chroma_h : outlink->h;
116             memset(tinterlace->black_data[i], black[i],
117                    tinterlace->black_linesize[i] * h);
118         }
119     }
120     av_log(ctx, AV_LOG_INFO, "mode:%d h:%d -> h:%d\n",
121            tinterlace->mode, inlink->h, outlink->h);
122
123     return 0;
124 }
125
126 #define FIELD_UPPER           0
127 #define FIELD_LOWER           1
128 #define FIELD_UPPER_AND_LOWER 2
129
130 /**
131  * Copy picture field from src to dst.
132  *
133  * @param src_field copy from upper, lower field or both
134  * @param interleave leave a padding line between each copied line
135  * @param dst_field copy to upper or lower field,
136  *        only meaningful when interleave is selected
137  */
138 static inline
139 void copy_picture_field(uint8_t *dst[4], int dst_linesize[4],
140                         uint8_t *src[4], int src_linesize[4],
141                         enum PixelFormat format, int w, int src_h,
142                         int src_field, int interleave, int dst_field)
143 {
144     const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[format];
145     int plane, vsub = desc->log2_chroma_h;
146     int k = src_field == FIELD_UPPER_AND_LOWER ? 1 : 2;
147
148     for (plane = 0; plane < desc->nb_components; plane++) {
149         int lines = plane == 1 || plane == 2 ? src_h >> vsub : src_h;
150         int linesize = av_image_get_linesize(format, w, plane);
151         uint8_t *dstp = dst[plane];
152         uint8_t *srcp = src[plane];
153         lines /= k;
154         if (src_field == FIELD_LOWER)
155             srcp += src_linesize[plane];
156         if (interleave && dst_field == FIELD_LOWER)
157             dstp += dst_linesize[plane];
158         av_image_copy_plane(dstp, dst_linesize[plane] * (interleave ? 2 : 1),
159                             srcp, src_linesize[plane]*k, linesize, lines);
160     }
161 }
162
163 static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
164 {
165     AVFilterContext *ctx = inlink->dst;
166     TInterlaceContext *tinterlace = ctx->priv;
167
168     avfilter_unref_buffer(tinterlace->cur);
169     tinterlace->cur  = tinterlace->next;
170     tinterlace->next = picref;
171 }
172
173 static void end_frame(AVFilterLink *inlink)
174 {
175     AVFilterContext *ctx = inlink->dst;
176     AVFilterLink *outlink = ctx->outputs[0];
177     TInterlaceContext *tinterlace = ctx->priv;
178     AVFilterBufferRef *cur  = tinterlace->cur;
179     AVFilterBufferRef *next = tinterlace->next;
180     AVFilterBufferRef *out  = NULL;
181     int field, tff;
182
183     /* we need at least two frames */
184     if (!tinterlace->cur)
185         return;
186
187     switch (tinterlace->mode) {
188     case 0: /* move the odd frame into the upper field of the new image, even into
189              * the lower field, generating a double-height video at half framerate */
190         out = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
191         avfilter_copy_buffer_ref_props(out, cur);
192         out->video->h = outlink->h;
193         out->video->interlaced = 1;
194         out->video->top_field_first = 1;
195
196         /* write odd frame lines into the upper field of the new frame */
197         copy_picture_field(out->data, out->linesize,
198                            cur->data, cur->linesize,
199                            inlink->format, inlink->w, inlink->h,
200                            FIELD_UPPER_AND_LOWER, 1, FIELD_UPPER);
201         /* write even frame lines into the lower field of the new frame */
202         copy_picture_field(out->data, out->linesize,
203                            next->data, next->linesize,
204                            inlink->format, inlink->w, inlink->h,
205                            FIELD_UPPER_AND_LOWER, 1, FIELD_LOWER);
206         avfilter_unref_bufferp(&tinterlace->next);
207         break;
208
209     case 1: /* only output even frames, odd  frames are dropped; height unchanged, half framerate */
210     case 2: /* only output odd  frames, even frames are dropped; height unchanged, half framerate */
211         out = avfilter_ref_buffer(tinterlace->mode == 2 ? cur : next, AV_PERM_READ);
212         avfilter_unref_bufferp(&tinterlace->next);
213         break;
214
215     case 3: /* expand each frame to double height, but pad alternate
216              * lines with black; framerate unchanged */
217         out = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
218         avfilter_copy_buffer_ref_props(out, cur);
219         out->video->h = outlink->h;
220
221         field = (1 + tinterlace->frame) & 1 ? FIELD_UPPER : FIELD_LOWER;
222         /* copy upper and lower fields */
223         copy_picture_field(out->data, out->linesize,
224                            cur->data, cur->linesize,
225                            inlink->format, inlink->w, inlink->h,
226                            FIELD_UPPER_AND_LOWER, 1, field);
227         /* pad with black the other field */
228         copy_picture_field(out->data, out->linesize,
229                            tinterlace->black_data, tinterlace->black_linesize,
230                            inlink->format, inlink->w, inlink->h,
231                            FIELD_UPPER_AND_LOWER, 1, !field);
232         break;
233
234         /* interleave upper/lower lines from odd frames with lower/upper lines from even frames,
235          * halving the frame rate and preserving image height */
236     case 4: /* top    field first */
237     case 5: /* bottom field first */
238         tff = tinterlace->mode == 4;
239         out = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
240         avfilter_copy_buffer_ref_props(out, cur);
241         out->video->interlaced = 1;
242         out->video->top_field_first = tff;
243
244         /* copy upper/lower field from cur */
245         copy_picture_field(out->data, out->linesize,
246                            cur->data, cur->linesize,
247                            inlink->format, inlink->w, inlink->h,
248                            tff ? FIELD_UPPER : FIELD_LOWER, 1, tff ? FIELD_UPPER : FIELD_LOWER);
249         /* copy lower/upper field from next */
250         copy_picture_field(out->data, out->linesize,
251                            next->data, next->linesize,
252                            inlink->format, inlink->w, inlink->h,
253                            tff ? FIELD_LOWER : FIELD_UPPER, 1, tff ? FIELD_LOWER : FIELD_UPPER);
254         avfilter_unref_bufferp(&tinterlace->next);
255         break;
256     }
257
258     avfilter_start_frame(outlink, out);
259     avfilter_draw_slice(outlink, 0, outlink->h, 1);
260     avfilter_end_frame(outlink);
261
262     tinterlace->frame++;
263 }
264
265 static int poll_frame(AVFilterLink *outlink)
266 {
267     TInterlaceContext *tinterlace = outlink->src->priv;
268     AVFilterLink *inlink = outlink->src->inputs[0];
269     int ret, val;
270
271     val = avfilter_poll_frame(inlink);
272
273     if (val == 1 && !tinterlace->next) {
274         if ((ret = avfilter_request_frame(inlink)) < 0)
275             return ret;
276         val = avfilter_poll_frame(inlink);
277     }
278     assert(tinterlace->next);
279
280     return val;
281 }
282
283 static int request_frame(AVFilterLink *outlink)
284 {
285     TInterlaceContext *tinterlace = outlink->src->priv;
286     AVFilterLink *inlink = outlink->src->inputs[0];
287
288     do {
289         int ret;
290
291         if ((ret = avfilter_request_frame(inlink)) < 0)
292             return ret;
293     } while (!tinterlace->cur);
294
295     return 0;
296 }
297
298 static void null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir) { }
299
300 AVFilter avfilter_vf_tinterlace = {
301     .name          = "tinterlace",
302     .description   = NULL_IF_CONFIG_SMALL("Perform temporal field interlacing."),
303     .priv_size     = sizeof(TInterlaceContext),
304     .init          = init,
305     .uninit        = uninit,
306     .query_formats = query_formats,
307
308     .inputs = (const AVFilterPad[]) {
309         { .name          = "default",
310           .type          = AVMEDIA_TYPE_VIDEO,
311           .start_frame   = start_frame,
312           .draw_slice    = null_draw_slice,
313           .end_frame     = end_frame, },
314         { .name = NULL}
315     },
316     .outputs = (const AVFilterPad[]) {
317         { .name          = "default",
318           .type          = AVMEDIA_TYPE_VIDEO,
319           .config_props  = config_out_props,
320           .poll_frame    = poll_frame,
321           .request_frame = request_frame },
322         { .name = NULL}
323     },
324 };