lavfi/vf_libvmaf: convert to framesync2.
[ffmpeg.git] / libavfilter / vf_mcdeint.c
1 /*
2  * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (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
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with FFmpeg; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19  */
20
21 /**
22  * @file
23  * Motion Compensation Deinterlacer
24  * Ported from MPlayer libmpcodecs/vf_mcdeint.c.
25  *
26  * Known Issues:
27  *
28  * The motion estimation is somewhat at the mercy of the input, if the
29  * input frames are created purely based on spatial interpolation then
30  * for example a thin black line or another random and not
31  * interpolateable pattern will cause problems.
32  * Note: completely ignoring the "unavailable" lines during motion
33  * estimation did not look any better, so the most obvious solution
34  * would be to improve tfields or penalize problematic motion vectors.
35  *
36  * If non iterative ME is used then snow currently ignores the OBMC
37  * window and as a result sometimes creates artifacts.
38  *
39  * Only past frames are used, we should ideally use future frames too,
40  * something like filtering the whole movie in forward and then
41  * backward direction seems like an interesting idea but the current
42  * filter framework is FAR from supporting such things.
43  *
44  * Combining the motion compensated image with the input image also is
45  * not as trivial as it seems, simple blindly taking even lines from
46  * one and odd ones from the other does not work at all as ME/MC
47  * sometimes has nothing in the previous frames which matches the
48  * current. The current algorithm has been found by trial and error
49  * and almost certainly can be improved...
50  */
51
52 #include "libavutil/opt.h"
53 #include "libavutil/pixdesc.h"
54 #include "libavcodec/avcodec.h"
55 #include "avfilter.h"
56 #include "formats.h"
57 #include "internal.h"
58
59 enum MCDeintMode {
60     MODE_FAST = 0,
61     MODE_MEDIUM,
62     MODE_SLOW,
63     MODE_EXTRA_SLOW,
64     MODE_NB,
65 };
66
67 enum MCDeintParity {
68     PARITY_TFF  =  0, ///< top field first
69     PARITY_BFF  =  1, ///< bottom field first
70 };
71
72 typedef struct MCDeintContext {
73     const AVClass *class;
74     int mode;           ///< MCDeintMode
75     int parity;         ///< MCDeintParity
76     int qp;
77     AVCodecContext *enc_ctx;
78 } MCDeintContext;
79
80 #define OFFSET(x) offsetof(MCDeintContext, x)
81 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
82 #define CONST(name, help, val, unit) { name, help, 0, AV_OPT_TYPE_CONST, {.i64=val}, INT_MIN, INT_MAX, FLAGS, unit }
83
84 static const AVOption mcdeint_options[] = {
85     { "mode", "set mode", OFFSET(mode), AV_OPT_TYPE_INT, {.i64=MODE_FAST}, 0, MODE_NB-1, FLAGS, .unit="mode" },
86     CONST("fast",       NULL, MODE_FAST,       "mode"),
87     CONST("medium",     NULL, MODE_MEDIUM,     "mode"),
88     CONST("slow",       NULL, MODE_SLOW,       "mode"),
89     CONST("extra_slow", NULL, MODE_EXTRA_SLOW, "mode"),
90
91     { "parity", "set the assumed picture field parity", OFFSET(parity), AV_OPT_TYPE_INT, {.i64=PARITY_BFF}, -1, 1, FLAGS, "parity" },
92     CONST("tff", "assume top field first",    PARITY_TFF, "parity"),
93     CONST("bff", "assume bottom field first", PARITY_BFF, "parity"),
94
95     { "qp", "set qp", OFFSET(qp), AV_OPT_TYPE_INT, {.i64=1}, INT_MIN, INT_MAX, FLAGS },
96     { NULL }
97 };
98
99 AVFILTER_DEFINE_CLASS(mcdeint);
100
101 static int config_props(AVFilterLink *inlink)
102 {
103     AVFilterContext *ctx = inlink->dst;
104     MCDeintContext *mcdeint = ctx->priv;
105     AVCodec *enc;
106     AVCodecContext *enc_ctx;
107     AVDictionary *opts = NULL;
108     int ret;
109
110     if (!(enc = avcodec_find_encoder(AV_CODEC_ID_SNOW))) {
111         av_log(ctx, AV_LOG_ERROR, "Snow encoder is not enabled in libavcodec\n");
112         return AVERROR(EINVAL);
113     }
114
115     mcdeint->enc_ctx = avcodec_alloc_context3(enc);
116     if (!mcdeint->enc_ctx)
117         return AVERROR(ENOMEM);
118     enc_ctx = mcdeint->enc_ctx;
119     enc_ctx->width  = inlink->w;
120     enc_ctx->height = inlink->h;
121     enc_ctx->time_base = (AVRational){1,25};  // meaningless
122     enc_ctx->gop_size = INT_MAX;
123     enc_ctx->max_b_frames = 0;
124     enc_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
125     enc_ctx->flags = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_LOW_DELAY;
126     enc_ctx->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
127     enc_ctx->global_quality = 1;
128     enc_ctx->me_cmp = enc_ctx->me_sub_cmp = FF_CMP_SAD;
129     enc_ctx->mb_cmp = FF_CMP_SSE;
130     av_dict_set(&opts, "memc_only", "1", 0);
131     av_dict_set(&opts, "no_bitstream", "1", 0);
132
133     switch (mcdeint->mode) {
134     case MODE_EXTRA_SLOW:
135         enc_ctx->refs = 3;
136     case MODE_SLOW:
137         enc_ctx->me_method = ME_ITER;
138     case MODE_MEDIUM:
139         enc_ctx->flags |= AV_CODEC_FLAG_4MV;
140         enc_ctx->dia_size = 2;
141     case MODE_FAST:
142         enc_ctx->flags |= AV_CODEC_FLAG_QPEL;
143     }
144
145     ret = avcodec_open2(enc_ctx, enc, &opts);
146     av_dict_free(&opts);
147     if (ret < 0)
148         return ret;
149
150     return 0;
151 }
152
153 static av_cold void uninit(AVFilterContext *ctx)
154 {
155     MCDeintContext *mcdeint = ctx->priv;
156
157     if (mcdeint->enc_ctx) {
158         avcodec_close(mcdeint->enc_ctx);
159         av_freep(&mcdeint->enc_ctx);
160     }
161 }
162
163 static int query_formats(AVFilterContext *ctx)
164 {
165     static const enum AVPixelFormat pix_fmts[] = {
166         AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
167     };
168     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
169     if (!fmts_list)
170         return AVERROR(ENOMEM);
171     return ff_set_common_formats(ctx, fmts_list);
172 }
173
174 static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
175 {
176     MCDeintContext *mcdeint = inlink->dst->priv;
177     AVFilterLink *outlink = inlink->dst->outputs[0];
178     AVFrame *outpic, *frame_dec;
179     AVPacket pkt = {0};
180     int x, y, i, ret, got_frame = 0;
181
182     outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);
183     if (!outpic) {
184         av_frame_free(&inpic);
185         return AVERROR(ENOMEM);
186     }
187     av_frame_copy_props(outpic, inpic);
188     inpic->quality = mcdeint->qp * FF_QP2LAMBDA;
189
190     av_init_packet(&pkt);
191
192     ret = avcodec_encode_video2(mcdeint->enc_ctx, &pkt, inpic, &got_frame);
193     if (ret < 0)
194         goto end;
195
196     frame_dec = mcdeint->enc_ctx->coded_frame;
197
198     for (i = 0; i < 3; i++) {
199         int is_chroma = !!i;
200         int w = AV_CEIL_RSHIFT(inlink->w, is_chroma);
201         int h = AV_CEIL_RSHIFT(inlink->h, is_chroma);
202         int fils = frame_dec->linesize[i];
203         int srcs = inpic    ->linesize[i];
204         int dsts = outpic   ->linesize[i];
205
206         for (y = 0; y < h; y++) {
207             if ((y ^ mcdeint->parity) & 1) {
208                 for (x = 0; x < w; x++) {
209                     uint8_t *filp = &frame_dec->data[i][x + y*fils];
210                     uint8_t *srcp = &inpic    ->data[i][x + y*srcs];
211                     uint8_t *dstp = &outpic   ->data[i][x + y*dsts];
212
213                     if (y > 0 && y < h-1){
214                         int is_edge = x < 3 || x > w-4;
215                         int diff0 = filp[-fils] - srcp[-srcs];
216                         int diff1 = filp[+fils] - srcp[+srcs];
217                         int temp = filp[0];
218
219 #define DELTA(j) av_clip(j, -x, w-1-x)
220
221 #define GET_SCORE_EDGE(j)\
222    FFABS(srcp[-srcs+DELTA(-1+(j))] - srcp[+srcs+DELTA(-1-(j))])+\
223    FFABS(srcp[-srcs+DELTA(j)     ] - srcp[+srcs+DELTA(  -(j))])+\
224    FFABS(srcp[-srcs+DELTA(1+(j)) ] - srcp[+srcs+DELTA( 1-(j))])
225
226 #define GET_SCORE(j)\
227    FFABS(srcp[-srcs-1+(j)] - srcp[+srcs-1-(j)])+\
228    FFABS(srcp[-srcs  +(j)] - srcp[+srcs  -(j)])+\
229    FFABS(srcp[-srcs+1+(j)] - srcp[+srcs+1-(j)])
230
231 #define CHECK_EDGE(j)\
232     {   int score = GET_SCORE_EDGE(j);\
233         if (score < spatial_score){\
234             spatial_score = score;\
235             diff0 = filp[-fils+DELTA(j)]    - srcp[-srcs+DELTA(j)];\
236             diff1 = filp[+fils+DELTA(-(j))] - srcp[+srcs+DELTA(-(j))];\
237
238 #define CHECK(j)\
239     {   int score = GET_SCORE(j);\
240         if (score < spatial_score){\
241             spatial_score= score;\
242             diff0 = filp[-fils+(j)] - srcp[-srcs+(j)];\
243             diff1 = filp[+fils-(j)] - srcp[+srcs-(j)];\
244
245                         if (is_edge) {
246                             int spatial_score = GET_SCORE_EDGE(0) - 1;
247                             CHECK_EDGE(-1) CHECK_EDGE(-2) }} }}
248                             CHECK_EDGE( 1) CHECK_EDGE( 2) }} }}
249                         } else {
250                             int spatial_score = GET_SCORE(0) - 1;
251                             CHECK(-1) CHECK(-2) }} }}
252                             CHECK( 1) CHECK( 2) }} }}
253                         }
254
255
256                         if (diff0 + diff1 > 0)
257                             temp -= (diff0 + diff1 - FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
258                         else
259                             temp -= (diff0 + diff1 + FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
260                         *filp = *dstp = temp > 255U ? ~(temp>>31) : temp;
261                     } else {
262                         *dstp = *filp;
263                     }
264                 }
265             }
266         }
267
268         for (y = 0; y < h; y++) {
269             if (!((y ^ mcdeint->parity) & 1)) {
270                 for (x = 0; x < w; x++) {
271                     frame_dec->data[i][x + y*fils] =
272                     outpic   ->data[i][x + y*dsts] = inpic->data[i][x + y*srcs];
273                 }
274             }
275         }
276     }
277     mcdeint->parity ^= 1;
278
279 end:
280     av_packet_unref(&pkt);
281     av_frame_free(&inpic);
282     if (ret < 0) {
283         av_frame_free(&outpic);
284         return ret;
285     }
286     return ff_filter_frame(outlink, outpic);
287 }
288
289 static const AVFilterPad mcdeint_inputs[] = {
290     {
291         .name         = "default",
292         .type         = AVMEDIA_TYPE_VIDEO,
293         .filter_frame = filter_frame,
294         .config_props = config_props,
295     },
296     { NULL }
297 };
298
299 static const AVFilterPad mcdeint_outputs[] = {
300     {
301         .name = "default",
302         .type = AVMEDIA_TYPE_VIDEO,
303     },
304     { NULL }
305 };
306
307 AVFilter ff_vf_mcdeint = {
308     .name          = "mcdeint",
309     .description   = NULL_IF_CONFIG_SMALL("Apply motion compensating deinterlacing."),
310     .priv_size     = sizeof(MCDeintContext),
311     .uninit        = uninit,
312     .query_formats = query_formats,
313     .inputs        = mcdeint_inputs,
314     .outputs       = mcdeint_outputs,
315     .priv_class    = &mcdeint_class,
316 };