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 57enum MCDeintMode { 58 MODE_FAST = 0, 59 MODE_MEDIUM, 60 MODE_SLOW, 61 MODE_EXTRA_SLOW, 62 MODE_NB, 63}; 64 65enum MCDeintParity { 66 PARITY_TFF = 0, ///< top field first 67 PARITY_BFF = 1, ///< bottom field first 68}; 69 70typedef 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 82static 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 97AVFILTER_DEFINE_CLASS(mcdeint); 98 99static 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 150static 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 160static 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 171static 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 278end: 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 288static 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 298static const AVFilterPad mcdeint_outputs[] = { 299 { 300 .name = "default", 301 .type = AVMEDIA_TYPE_VIDEO, 302 }, 303 { NULL } 304}; 305 306AVFilter 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}; 316