avcodec/g723_1dec: improve stereo support
[ffmpeg.git] / libavfilter / vf_yadif.c
1 /*
2  * Copyright (C) 2006-2011 Michael Niedermayer <michaelni@gmx.at>
3  *               2010      James Darnley <james.darnley@gmail.com>
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 #include "libavutil/avassert.h"
23 #include "libavutil/cpu.h"
24 #include "libavutil/common.h"
25 #include "libavutil/pixdesc.h"
26 #include "libavutil/imgutils.h"
27 #include "avfilter.h"
28 #include "formats.h"
29 #include "internal.h"
30 #include "video.h"
31 #include "yadif.h"
32
33 typedef struct ThreadData {
34     AVFrame *frame;
35     int plane;
36     int w, h;
37     int parity;
38     int tff;
39 } ThreadData;
40
41 #define CHECK(j)\
42     {   int score = FFABS(cur[mrefs - 1 + (j)] - cur[prefs - 1 - (j)])\
43                   + FFABS(cur[mrefs  +(j)] - cur[prefs  -(j)])\
44                   + FFABS(cur[mrefs + 1 + (j)] - cur[prefs + 1 - (j)]);\
45         if (score < spatial_score) {\
46             spatial_score= score;\
47             spatial_pred= (cur[mrefs  +(j)] + cur[prefs  -(j)])>>1;\
48
49 /* The is_not_edge argument here controls when the code will enter a branch
50  * which reads up to and including x-3 and x+3. */
51
52 #define FILTER(start, end, is_not_edge) \
53     for (x = start;  x < end; x++) { \
54         int c = cur[mrefs]; \
55         int d = (prev2[0] + next2[0])>>1; \
56         int e = cur[prefs]; \
57         int temporal_diff0 = FFABS(prev2[0] - next2[0]); \
58         int temporal_diff1 =(FFABS(prev[mrefs] - c) + FFABS(prev[prefs] - e) )>>1; \
59         int temporal_diff2 =(FFABS(next[mrefs] - c) + FFABS(next[prefs] - e) )>>1; \
60         int diff = FFMAX3(temporal_diff0 >> 1, temporal_diff1, temporal_diff2); \
61         int spatial_pred = (c+e) >> 1; \
62  \
63         if (is_not_edge) {\
64             int spatial_score = FFABS(cur[mrefs - 1] - cur[prefs - 1]) + FFABS(c-e) \
65                               + FFABS(cur[mrefs + 1] - cur[prefs + 1]) - 1; \
66             CHECK(-1) CHECK(-2) }} }} \
67             CHECK( 1) CHECK( 2) }} }} \
68         }\
69  \
70         if (!(mode&2)) { \
71             int b = (prev2[2 * mrefs] + next2[2 * mrefs])>>1; \
72             int f = (prev2[2 * prefs] + next2[2 * prefs])>>1; \
73             int max = FFMAX3(d - e, d - c, FFMIN(b - c, f - e)); \
74             int min = FFMIN3(d - e, d - c, FFMAX(b - c, f - e)); \
75  \
76             diff = FFMAX3(diff, min, -max); \
77         } \
78  \
79         if (spatial_pred > d + diff) \
80            spatial_pred = d + diff; \
81         else if (spatial_pred < d - diff) \
82            spatial_pred = d - diff; \
83  \
84         dst[0] = spatial_pred; \
85  \
86         dst++; \
87         cur++; \
88         prev++; \
89         next++; \
90         prev2++; \
91         next2++; \
92     }
93
94 static void filter_line_c(void *dst1,
95                           void *prev1, void *cur1, void *next1,
96                           int w, int prefs, int mrefs, int parity, int mode)
97 {
98     uint8_t *dst  = dst1;
99     uint8_t *prev = prev1;
100     uint8_t *cur  = cur1;
101     uint8_t *next = next1;
102     int x;
103     uint8_t *prev2 = parity ? prev : cur ;
104     uint8_t *next2 = parity ? cur  : next;
105
106     /* The function is called with the pointers already pointing to data[3] and
107      * with 6 subtracted from the width.  This allows the FILTER macro to be
108      * called so that it processes all the pixels normally.  A constant value of
109      * true for is_not_edge lets the compiler ignore the if statement. */
110     FILTER(0, w, 1)
111 }
112
113 #define MAX_ALIGN 8
114 static void filter_edges(void *dst1, void *prev1, void *cur1, void *next1,
115                          int w, int prefs, int mrefs, int parity, int mode)
116 {
117     uint8_t *dst  = dst1;
118     uint8_t *prev = prev1;
119     uint8_t *cur  = cur1;
120     uint8_t *next = next1;
121     int x;
122     uint8_t *prev2 = parity ? prev : cur ;
123     uint8_t *next2 = parity ? cur  : next;
124
125     const int edge = MAX_ALIGN - 1;
126
127     /* Only edge pixels need to be processed here.  A constant value of false
128      * for is_not_edge should let the compiler ignore the whole branch. */
129     FILTER(0, 3, 0)
130
131     dst  = (uint8_t*)dst1  + w - edge;
132     prev = (uint8_t*)prev1 + w - edge;
133     cur  = (uint8_t*)cur1  + w - edge;
134     next = (uint8_t*)next1 + w - edge;
135     prev2 = (uint8_t*)(parity ? prev : cur);
136     next2 = (uint8_t*)(parity ? cur  : next);
137
138     FILTER(w - edge, w - 3, 1)
139     FILTER(w - 3, w, 0)
140 }
141
142
143 static void filter_line_c_16bit(void *dst1,
144                                 void *prev1, void *cur1, void *next1,
145                                 int w, int prefs, int mrefs, int parity,
146                                 int mode)
147 {
148     uint16_t *dst  = dst1;
149     uint16_t *prev = prev1;
150     uint16_t *cur  = cur1;
151     uint16_t *next = next1;
152     int x;
153     uint16_t *prev2 = parity ? prev : cur ;
154     uint16_t *next2 = parity ? cur  : next;
155     mrefs /= 2;
156     prefs /= 2;
157
158     FILTER(0, w, 1)
159 }
160
161 static void filter_edges_16bit(void *dst1, void *prev1, void *cur1, void *next1,
162                                int w, int prefs, int mrefs, int parity, int mode)
163 {
164     uint16_t *dst  = dst1;
165     uint16_t *prev = prev1;
166     uint16_t *cur  = cur1;
167     uint16_t *next = next1;
168     int x;
169     uint16_t *prev2 = parity ? prev : cur ;
170     uint16_t *next2 = parity ? cur  : next;
171
172     const int edge = MAX_ALIGN / 2 - 1;
173
174     mrefs /= 2;
175     prefs /= 2;
176
177     FILTER(0, 3, 0)
178
179     dst   = (uint16_t*)dst1  + w - edge;
180     prev  = (uint16_t*)prev1 + w - edge;
181     cur   = (uint16_t*)cur1  + w - edge;
182     next  = (uint16_t*)next1 + w - edge;
183     prev2 = (uint16_t*)(parity ? prev : cur);
184     next2 = (uint16_t*)(parity ? cur  : next);
185
186     FILTER(w - edge, w - 3, 1)
187     FILTER(w - 3, w, 0)
188 }
189
190 static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
191 {
192     YADIFContext *s = ctx->priv;
193     ThreadData *td  = arg;
194     int refs = s->cur->linesize[td->plane];
195     int df = (s->csp->comp[td->plane].depth + 7) / 8;
196     int pix_3 = 3 * df;
197     int slice_start = (td->h *  jobnr   ) / nb_jobs;
198     int slice_end   = (td->h * (jobnr+1)) / nb_jobs;
199     int y;
200     int edge = 3 + MAX_ALIGN / df - 1;
201
202     /* filtering reads 3 pixels to the left/right; to avoid invalid reads,
203      * we need to call the c variant which avoids this for border pixels
204      */
205     for (y = slice_start; y < slice_end; y++) {
206         if ((y ^ td->parity) & 1) {
207             uint8_t *prev = &s->prev->data[td->plane][y * refs];
208             uint8_t *cur  = &s->cur ->data[td->plane][y * refs];
209             uint8_t *next = &s->next->data[td->plane][y * refs];
210             uint8_t *dst  = &td->frame->data[td->plane][y * td->frame->linesize[td->plane]];
211             int     mode  = y == 1 || y + 2 == td->h ? 2 : s->mode;
212             s->filter_line(dst + pix_3, prev + pix_3, cur + pix_3,
213                            next + pix_3, td->w - edge,
214                            y + 1 < td->h ? refs : -refs,
215                            y ? -refs : refs,
216                            td->parity ^ td->tff, mode);
217             s->filter_edges(dst, prev, cur, next, td->w,
218                             y + 1 < td->h ? refs : -refs,
219                             y ? -refs : refs,
220                             td->parity ^ td->tff, mode);
221         } else {
222             memcpy(&td->frame->data[td->plane][y * td->frame->linesize[td->plane]],
223                    &s->cur->data[td->plane][y * refs], td->w * df);
224         }
225     }
226     return 0;
227 }
228
229 static void filter(AVFilterContext *ctx, AVFrame *dstpic,
230                    int parity, int tff)
231 {
232     YADIFContext *yadif = ctx->priv;
233     ThreadData td = { .frame = dstpic, .parity = parity, .tff = tff };
234     int i;
235
236     for (i = 0; i < yadif->csp->nb_components; i++) {
237         int w = dstpic->width;
238         int h = dstpic->height;
239
240         if (i == 1 || i == 2) {
241             w = AV_CEIL_RSHIFT(w, yadif->csp->log2_chroma_w);
242             h = AV_CEIL_RSHIFT(h, yadif->csp->log2_chroma_h);
243         }
244
245
246         td.w       = w;
247         td.h       = h;
248         td.plane   = i;
249
250         ctx->internal->execute(ctx, filter_slice, &td, NULL, FFMIN(h, ff_filter_get_nb_threads(ctx)));
251     }
252
253     emms_c();
254 }
255
256 static av_cold void uninit(AVFilterContext *ctx)
257 {
258     YADIFContext *yadif = ctx->priv;
259
260     av_frame_free(&yadif->prev);
261     av_frame_free(&yadif->cur );
262     av_frame_free(&yadif->next);
263 }
264
265 static int query_formats(AVFilterContext *ctx)
266 {
267     static const enum AVPixelFormat pix_fmts[] = {
268         AV_PIX_FMT_YUV420P,
269         AV_PIX_FMT_YUV422P,
270         AV_PIX_FMT_YUV444P,
271         AV_PIX_FMT_YUV410P,
272         AV_PIX_FMT_YUV411P,
273         AV_PIX_FMT_GRAY8,
274         AV_PIX_FMT_YUVJ420P,
275         AV_PIX_FMT_YUVJ422P,
276         AV_PIX_FMT_YUVJ444P,
277         AV_PIX_FMT_GRAY16,
278         AV_PIX_FMT_YUV440P,
279         AV_PIX_FMT_YUVJ440P,
280         AV_PIX_FMT_YUV420P9,
281         AV_PIX_FMT_YUV422P9,
282         AV_PIX_FMT_YUV444P9,
283         AV_PIX_FMT_YUV420P10,
284         AV_PIX_FMT_YUV422P10,
285         AV_PIX_FMT_YUV444P10,
286         AV_PIX_FMT_YUV420P12,
287         AV_PIX_FMT_YUV422P12,
288         AV_PIX_FMT_YUV444P12,
289         AV_PIX_FMT_YUV420P14,
290         AV_PIX_FMT_YUV422P14,
291         AV_PIX_FMT_YUV444P14,
292         AV_PIX_FMT_YUV420P16,
293         AV_PIX_FMT_YUV422P16,
294         AV_PIX_FMT_YUV444P16,
295         AV_PIX_FMT_YUVA420P,
296         AV_PIX_FMT_YUVA422P,
297         AV_PIX_FMT_YUVA444P,
298         AV_PIX_FMT_GBRP,
299         AV_PIX_FMT_GBRP9,
300         AV_PIX_FMT_GBRP10,
301         AV_PIX_FMT_GBRP12,
302         AV_PIX_FMT_GBRP14,
303         AV_PIX_FMT_GBRP16,
304         AV_PIX_FMT_GBRAP,
305         AV_PIX_FMT_NONE
306     };
307
308     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
309     if (!fmts_list)
310         return AVERROR(ENOMEM);
311     return ff_set_common_formats(ctx, fmts_list);
312 }
313
314 static int config_props(AVFilterLink *link)
315 {
316     AVFilterContext *ctx = link->src;
317     YADIFContext *s = ctx->priv;
318
319     link->time_base.num = ctx->inputs[0]->time_base.num;
320     link->time_base.den = ctx->inputs[0]->time_base.den * 2;
321     link->w             = ctx->inputs[0]->w;
322     link->h             = ctx->inputs[0]->h;
323
324     if(s->mode & 1)
325         link->frame_rate = av_mul_q(ctx->inputs[0]->frame_rate,
326                                     (AVRational){2, 1});
327
328     if (link->w < 3 || link->h < 3) {
329         av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or lines is not supported\n");
330         return AVERROR(EINVAL);
331     }
332
333     s->csp = av_pix_fmt_desc_get(link->format);
334     s->filter = filter;
335     if (s->csp->comp[0].depth > 8) {
336         s->filter_line  = filter_line_c_16bit;
337         s->filter_edges = filter_edges_16bit;
338     } else {
339         s->filter_line  = filter_line_c;
340         s->filter_edges = filter_edges;
341     }
342
343     if (ARCH_X86)
344         ff_yadif_init_x86(s);
345
346     return 0;
347 }
348
349
350 static const AVClass yadif_class = {
351     .class_name = "yadif",
352     .item_name  = av_default_item_name,
353     .option     = ff_yadif_options,
354     .version    = LIBAVUTIL_VERSION_INT,
355     .category   = AV_CLASS_CATEGORY_FILTER,
356 };
357
358 static const AVFilterPad avfilter_vf_yadif_inputs[] = {
359     {
360         .name          = "default",
361         .type          = AVMEDIA_TYPE_VIDEO,
362         .filter_frame  = ff_yadif_filter_frame,
363     },
364     { NULL }
365 };
366
367 static const AVFilterPad avfilter_vf_yadif_outputs[] = {
368     {
369         .name          = "default",
370         .type          = AVMEDIA_TYPE_VIDEO,
371         .request_frame = ff_yadif_request_frame,
372         .config_props  = config_props,
373     },
374     { NULL }
375 };
376
377 AVFilter ff_vf_yadif = {
378     .name          = "yadif",
379     .description   = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
380     .priv_size     = sizeof(YADIFContext),
381     .priv_class    = &yadif_class,
382     .uninit        = uninit,
383     .query_formats = query_formats,
384     .inputs        = avfilter_vf_yadif_inputs,
385     .outputs       = avfilter_vf_yadif_outputs,
386     .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL | AVFILTER_FLAG_SLICE_THREADS,
387 };