FFmpeg
vf_mcdeint.c
Go to the documentation of this file.
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 
60  MODE_FAST = 0,
65 };
66 
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;
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 
102 {
103  AVFilterContext *ctx = inlink->dst;
104  MCDeintContext *mcdeint = ctx->priv;
105  AVCodec *enc;
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;
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  av_dict_set(&opts, "motion_est", "iter", 0);
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 
154 {
155  MCDeintContext *mcdeint = ctx->priv;
156 
157  avcodec_free_context(&mcdeint->enc_ctx);
158 }
159 
161 {
162  static const enum AVPixelFormat pix_fmts[] = {
164  };
165  AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);
166  if (!fmts_list)
167  return AVERROR(ENOMEM);
168  return ff_set_common_formats(ctx, fmts_list);
169 }
170 
172 {
173  MCDeintContext *mcdeint = inlink->dst->priv;
174  AVFilterLink *outlink = inlink->dst->outputs[0];
175  AVFrame *outpic, *frame_dec;
176  AVPacket pkt = {0};
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 
189  ret = avcodec_encode_video2(mcdeint->enc_ctx, &pkt, inpic, &got_frame);
190  if (ret < 0)
191  goto end;
192 
193  frame_dec = mcdeint->enc_ctx->coded_frame;
194 
195  for (i = 0; i < 3; i++) {
196  int is_chroma = !!i;
197  int w = AV_CEIL_RSHIFT(inlink->w, is_chroma);
198  int h = AV_CEIL_RSHIFT(inlink->h, is_chroma);
199  int fils = frame_dec->linesize[i];
200  int srcs = inpic ->linesize[i];
201  int dsts = outpic ->linesize[i];
202 
203  for (y = 0; y < h; y++) {
204  if ((y ^ mcdeint->parity) & 1) {
205  for (x = 0; x < w; x++) {
206  uint8_t *filp = &frame_dec->data[i][x + y*fils];
207  uint8_t *srcp = &inpic ->data[i][x + y*srcs];
208  uint8_t *dstp = &outpic ->data[i][x + y*dsts];
209 
210  if (y > 0 && y < h-1){
211  int is_edge = x < 3 || x > w-4;
212  int diff0 = filp[-fils] - srcp[-srcs];
213  int diff1 = filp[+fils] - srcp[+srcs];
214  int temp = filp[0];
215 
216 #define DELTA(j) av_clip(j, -x, w-1-x)
217 
218 #define GET_SCORE_EDGE(j)\
219  FFABS(srcp[-srcs+DELTA(-1+(j))] - srcp[+srcs+DELTA(-1-(j))])+\
220  FFABS(srcp[-srcs+DELTA(j) ] - srcp[+srcs+DELTA( -(j))])+\
221  FFABS(srcp[-srcs+DELTA(1+(j)) ] - srcp[+srcs+DELTA( 1-(j))])
222 
223 #define GET_SCORE(j)\
224  FFABS(srcp[-srcs-1+(j)] - srcp[+srcs-1-(j)])+\
225  FFABS(srcp[-srcs +(j)] - srcp[+srcs -(j)])+\
226  FFABS(srcp[-srcs+1+(j)] - srcp[+srcs+1-(j)])
227 
228 #define CHECK_EDGE(j)\
229  { int score = GET_SCORE_EDGE(j);\
230  if (score < spatial_score){\
231  spatial_score = score;\
232  diff0 = filp[-fils+DELTA(j)] - srcp[-srcs+DELTA(j)];\
233  diff1 = filp[+fils+DELTA(-(j))] - srcp[+srcs+DELTA(-(j))];\
234 
235 #define CHECK(j)\
236  { int score = GET_SCORE(j);\
237  if (score < spatial_score){\
238  spatial_score= score;\
239  diff0 = filp[-fils+(j)] - srcp[-srcs+(j)];\
240  diff1 = filp[+fils-(j)] - srcp[+srcs-(j)];\
241 
242  if (is_edge) {
243  int spatial_score = GET_SCORE_EDGE(0) - 1;
244  CHECK_EDGE(-1) CHECK_EDGE(-2) }} }}
245  CHECK_EDGE( 1) CHECK_EDGE( 2) }} }}
246  } else {
247  int spatial_score = GET_SCORE(0) - 1;
248  CHECK(-1) CHECK(-2) }} }}
249  CHECK( 1) CHECK( 2) }} }}
250  }
251 
252 
253  if (diff0 + diff1 > 0)
254  temp -= (diff0 + diff1 - FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
255  else
256  temp -= (diff0 + diff1 + FFABS(FFABS(diff0) - FFABS(diff1)) / 2) / 2;
257  *filp = *dstp = temp > 255U ? ~(temp>>31) : temp;
258  } else {
259  *dstp = *filp;
260  }
261  }
262  }
263  }
264 
265  for (y = 0; y < h; y++) {
266  if (!((y ^ mcdeint->parity) & 1)) {
267  for (x = 0; x < w; x++) {
268  frame_dec->data[i][x + y*fils] =
269  outpic ->data[i][x + y*dsts] = inpic->data[i][x + y*srcs];
270  }
271  }
272  }
273  }
274  mcdeint->parity ^= 1;
275 
276 end:
279  if (ret < 0) {
280  av_frame_free(&outpic);
281  return ret;
282  }
283  return ff_filter_frame(outlink, outpic);
284 }
285 
286 static const AVFilterPad mcdeint_inputs[] = {
287  {
288  .name = "default",
289  .type = AVMEDIA_TYPE_VIDEO,
290  .filter_frame = filter_frame,
291  .config_props = config_props,
292  },
293  { NULL }
294 };
295 
296 static const AVFilterPad mcdeint_outputs[] = {
297  {
298  .name = "default",
299  .type = AVMEDIA_TYPE_VIDEO,
300  },
301  { NULL }
302 };
303 
305  .name = "mcdeint",
306  .description = NULL_IF_CONFIG_SMALL("Apply motion compensating deinterlacing."),
307  .priv_size = sizeof(MCDeintContext),
308  .uninit = uninit,
310  .inputs = mcdeint_inputs,
311  .outputs = mcdeint_outputs,
312  .priv_class = &mcdeint_class,
313 };
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2633
#define NULL
Definition: coverity.c:32
static const AVFilterPad mcdeint_inputs[]
Definition: vf_mcdeint.c:286
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: allcodecs.c:885
AVOption.
Definition: opt.h:246
Main libavfilter public API header.
else temp
Definition: vf_mcdeint.c:256
int max_b_frames
maximum number of B-frames between non-B-frames Note: The output will be delayed by max_b_frames+1 re...
Definition: avcodec.h:1825
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:99
static AVPacket pkt
AVCodec.
Definition: avcodec.h:3481
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1688
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
#define OFFSET(x)
Definition: vf_mcdeint.c:80
MCDeintMode
Definition: vf_mcdeint.c:59
BYTE int const BYTE * srcp
Definition: avisynth_c.h:908
const char * name
Pad name.
Definition: internal.h:60
AVCodecContext * enc_ctx
Definition: vf_mcdeint.c:77
uint8_t
#define av_cold
Definition: attributes.h:82
AVOptions.
#define GET_SCORE_EDGE(j)
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
bottom field first
Definition: vf_mcdeint.c:69
av_frame_free & inpic
Definition: vf_mcdeint.c:278
#define AV_CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:900
int me_cmp
motion estimation comparison function
Definition: avcodec.h:1951
static const AVFilterPad mcdeint_outputs[]
Definition: vf_mcdeint.c:296
AVFILTER_DEFINE_CLASS(mcdeint)
#define FF_CMP_SSE
Definition: avcodec.h:1971
#define av_log(a,...)
#define CONST(name, help, val, unit)
Definition: vf_mcdeint.c:82
A filter pad used for either input or output.
Definition: internal.h:54
#define U(x)
Definition: vp56_arith.h:37
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568
#define FLAGS
Definition: vf_mcdeint.c:81
#define AV_CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: avcodec.h:854
return ff_filter_frame(outlink, outpic)
static int config_props(AVFilterLink *inlink)
Definition: vf_mcdeint.c:101
BYTE * dstp
Definition: avisynth_c.h:908
int me_sub_cmp
subpixel motion estimation comparison function
Definition: avcodec.h:1957
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
void * priv
private data for use by the filter
Definition: avfilter.h:353
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
int mode
MCDeintMode.
Definition: vf_mcdeint.c:74
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_mcdeint.c:153
int refs
number of reference frames
Definition: avcodec.h:2153
AVDictionary * opts
Definition: movenc.c:50
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:850
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:156
int width
picture width / height.
Definition: avcodec.h:1738
uint8_t w
Definition: llviddspenc.c:38
static const AVOption mcdeint_options[]
Definition: vf_mcdeint.c:84
AVFormatContext * ctx
Definition: movenc.c:48
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:418
#define FF_CMP_SAD
Definition: avcodec.h:1970
static const AVFilterPad outputs[]
Definition: af_acontrast.c:203
Libavcodec external API header.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
Definition: options.c:171
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
#define CHECK(j)
main external API structure.
Definition: avcodec.h:1565
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
static int query_formats(AVFilterContext *ctx)
Definition: vf_mcdeint.c:160
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
top field first
Definition: vf_mcdeint.c:68
#define CHECK_EDGE(j)
Describe the class of an AVClass context structure.
Definition: log.h:67
#define GET_SCORE(j)
Filter definition.
Definition: avfilter.h:144
Rational number (pair of numerator and denominator).
Definition: rational.h:58
attribute_deprecated int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: encode.c:258
const char * name
Filter name.
Definition: avfilter.h:148
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:542
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:350
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1631
#define AV_CODEC_FLAG_QPEL
Use qpel MC.
Definition: avcodec.h:862
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1760
int mb_cmp
macroblock comparison function (not supported yet)
Definition: avcodec.h:1963
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
* filp
Definition: vf_mcdeint.c:257
int parity
MCDeintParity.
Definition: vf_mcdeint.c:75
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2815
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
int dia_size
ME diamond size & shape.
Definition: avcodec.h:1993
MCDeintParity
Definition: vf_mcdeint.c:67
A list of supported formats for one end of a filter link.
Definition: formats.h:64
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
Definition: vf_mcdeint.c:171
An instance of a filter.
Definition: avfilter.h:338
internal API functions
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
mode
Use these values in ebur128_init (or&#39;ed).
Definition: ebur128.h:83
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2628
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AVFilter ff_vf_mcdeint
Definition: vf_mcdeint.c:304