git.sesse.net Git - ffmpeg/blob - libavfilter/vf_mcdeint.c

   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     int mode;           ///< MCDeintMode
  73     int parity;         ///< MCDeintParity
  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 = INT_MAX;
 121     enc_ctx->max_b_frames = 0;
 122     enc_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
 123     enc_ctx->flags = AV_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     av_dict_set(&opts, "no_bitstream", "1", 0);
 130
 131     switch (mcdeint->mode) {
 132     case MODE_EXTRA_SLOW:
 133         enc_ctx->refs = 3;
 134     case MODE_SLOW:
 135         enc_ctx->me_method = ME_ITER;
 136     case MODE_MEDIUM:
 137         enc_ctx->flags |= AV_CODEC_FLAG_4MV;
 138         enc_ctx->dia_size = 2;
 139     case MODE_FAST:
 140         enc_ctx->flags |= AV_CODEC_FLAG_QPEL;
 141     }
 142
 143     ret = avcodec_open2(enc_ctx, enc, &opts);
 144     av_dict_free(&opts);
 145     if (ret < 0)
 146         return ret;
 147
 148     return 0;
 149 }
 150
 151 static av_cold void uninit(AVFilterContext *ctx)
 152 {
 153     MCDeintContext *mcdeint = ctx->priv;
 154
 155     if (mcdeint->enc_ctx) {
 156         avcodec_close(mcdeint->enc_ctx);
 157         av_freep(&mcdeint->enc_ctx);
 158     }
 159 }
 160
 161 static int query_formats(AVFilterContext *ctx)
 162 {
 163     static const enum AVPixelFormat pix_fmts[] = {
 164         AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
 165     };
 166     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
 167     if (!fmts_list)
 168         return AVERROR(ENOMEM);
 169     return ff_set_common_formats(ctx, fmts_list);
 170 }
 171
 172 static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
 173 {
 174     MCDeintContext *mcdeint = inlink->dst->priv;
 175     AVFilterLink *outlink = inlink->dst->outputs[0];
 176     AVFrame *outpic, *frame_dec;
 177     AVPacket pkt = {0};
 178     int x, y, i, ret, got_frame = 0;
 179
 180     outpic = ff_get_video_buffer(outlink, outlink->w, outlink->h);
 181     if (!outpic) {
 182         av_frame_free(&inpic);
 183         return AVERROR(ENOMEM);
 184     }
 185     av_frame_copy_props(outpic, inpic);
 186     inpic->quality = mcdeint->qp * FF_QP2LAMBDA;
 187
 188     av_init_packet(&pkt);
 189
 190     ret = avcodec_encode_video2(mcdeint->enc_ctx, &pkt, inpic, &got_frame);
 191     if (ret < 0)
 192         goto end;
 193
 194     frame_dec = mcdeint->enc_ctx->coded_frame;
 195
 196     for (i = 0; i < 3; i++) {
 197         int is_chroma = !!i;
 198         int w = FF_CEIL_RSHIFT(inlink->w, is_chroma);
 199         int h = FF_CEIL_RSHIFT(inlink->h, is_chroma);
 200         int fils = frame_dec->linesize[i];
 201         int srcs = inpic    ->linesize[i];
 202         int dsts = outpic   ->linesize[i];
 203
 204         for (y = 0; y < h; y++) {
 205             if ((y ^ mcdeint->parity) & 1) {
 206                 for (x = 0; x < w; x++) {
 207                     uint8_t *filp = &frame_dec->data[i][x + y*fils];
 208                     uint8_t *srcp = &inpic    ->data[i][x + y*srcs];
 209                     uint8_t *dstp = &outpic   ->data[i][x + y*dsts];
 210
 211                     if (y > 0 && y < h-1){
 212                         int is_edge = x < 3 || x > w-4;
 213                         int diff0 = filp[-fils] - srcp[-srcs];
 214                         int diff1 = filp[+fils] - srcp[+srcs];
 215                         int temp = filp[0];
 216
 217 #define DELTA(j) av_clip(j, -x, w-1-x)
 218
 219 #define GET_SCORE_EDGE(j)\
 220    FFABS(srcp[-srcs+DELTA(-1+(j))] - srcp[+srcs+DELTA(-1-(j))])+\
 221    FFABS(srcp[-srcs+DELTA(j)     ] - srcp[+srcs+DELTA(  -(j))])+\
 222    FFABS(srcp[-srcs+DELTA(1+(j)) ] - srcp[+srcs+DELTA( 1-(j))])
 223
 224 #define GET_SCORE(j)\
 225    FFABS(srcp[-srcs-1+(j)] - srcp[+srcs-1-(j)])+\
 226    FFABS(srcp[-srcs  +(j)] - srcp[+srcs  -(j)])+\
 227    FFABS(srcp[-srcs+1+(j)] - srcp[+srcs+1-(j)])
 228
 229 #define CHECK_EDGE(j)\
 230     {   int score = GET_SCORE_EDGE(j);\
 231         if (score < spatial_score){\
 232             spatial_score = score;\
 233             diff0 = filp[-fils+DELTA(j)]    - srcp[-srcs+DELTA(j)];\
 234             diff1 = filp[+fils+DELTA(-(j))] - srcp[+srcs+DELTA(-(j))];\
 235
 236 #define CHECK(j)\
 237     {   int score = GET_SCORE(j);\
 238         if (score < spatial_score){\
 239             spatial_score= score;\
 240             diff0 = filp[-fils+(j)] - srcp[-srcs+(j)];\
 241             diff1 = filp[+fils-(j)] - srcp[+srcs-(j)];\
 242
 243                         if (is_edge) {
 244                             int spatial_score = GET_SCORE_EDGE(0) - 1;
 245                             CHECK_EDGE(-1) CHECK_EDGE(-2) }} }}
 246                             CHECK_EDGE( 1) CHECK_EDGE( 2) }} }}
 247                         } else {
 248                             int spatial_score = GET_SCORE(0) - 1;
 249                             CHECK(-1) CHECK(-2) }} }}
 250                             CHECK( 1) CHECK( 2) }} }}
 251                         }
 252
 253
 254                         if (diff0 + diff1 > 0)
 255                             temp -= (diff0 + diff1 - FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
 256                         else
 257                             temp -= (diff0 + diff1 + FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
 258                         *filp = *dstp = temp > 255U ? ~(temp>>31) : temp;
 259                     } else {
 260                         *dstp = *filp;
 261                     }
 262                 }
 263             }
 264         }
 265
 266         for (y = 0; y < h; y++) {
 267             if (!((y ^ mcdeint->parity) & 1)) {
 268                 for (x = 0; x < w; x++) {
 269                     frame_dec->data[i][x + y*fils] =
 270                     outpic   ->data[i][x + y*dsts] = inpic->data[i][x + y*srcs];
 271                 }
 272             }
 273         }
 274     }
 275     mcdeint->parity ^= 1;
 276
 277 end:
 278     av_free_packet(&pkt);
 279     av_frame_free(&inpic);
 280     if (ret < 0) {
 281         av_frame_free(&outpic);
 282         return ret;
 283     }
 284     return ff_filter_frame(outlink, outpic);
 285 }
 286
 287 static const AVFilterPad mcdeint_inputs[] = {
 288     {
 289         .name         = "default",
 290         .type         = AVMEDIA_TYPE_VIDEO,
 291         .filter_frame = filter_frame,
 292         .config_props = config_props,
 293     },
 294     { NULL }
 295 };
 296
 297 static const AVFilterPad mcdeint_outputs[] = {
 298     {
 299         .name = "default",
 300         .type = AVMEDIA_TYPE_VIDEO,
 301     },
 302     { NULL }
 303 };
 304
 305 AVFilter ff_vf_mcdeint = {
 306     .name          = "mcdeint",
 307     .description   = NULL_IF_CONFIG_SMALL("Apply motion compensating deinterlacing."),
 308     .priv_size     = sizeof(MCDeintContext),
 309     .uninit        = uninit,
 310     .query_formats = query_formats,
 311     .inputs        = mcdeint_inputs,
 312     .outputs       = mcdeint_outputs,
 313     .priv_class    = &mcdeint_class,
 314 };