summaryrefslogtreecommitdiff
path: root/libavfilter/vf_mcdeint.c (plain)
blob: d4f718cc95a3c08578b8fa39142cd488c0da1f92
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
59enum MCDeintMode {
60 MODE_FAST = 0,
61 MODE_MEDIUM,
62 MODE_SLOW,
63 MODE_EXTRA_SLOW,
64 MODE_NB,
65};
66
67enum MCDeintParity {
68 PARITY_TFF = 0, ///< top field first
69 PARITY_BFF = 1, ///< bottom field first
70};
71
72typedef struct {
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
84static 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
99AVFILTER_DEFINE_CLASS(mcdeint);
100
101static 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
153static 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
163static 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
174static 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
279end:
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
289static 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
299static const AVFilterPad mcdeint_outputs[] = {
300 {
301 .name = "default",
302 .type = AVMEDIA_TYPE_VIDEO,
303 },
304 { NULL }
305};
306
307AVFilter 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};
317
generated by cgit at 2024-05-17 05:00:45 (GMT)