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