FFmpeg: libavfilter/vf_mcdeint.c Source File

FFmpeg
vf_mcdeint.c
Go to the documentation of this file.
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 = 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 |= CODEC_FLAG_4MV;
138  enc_ctx->dia_size = 2;
139  case MODE_FAST:
140  enc_ctx->flags |= 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 };
NULL
#define NULL
Definition: coverity.c:32
mcdeint_inputs
static const AVFilterPad mcdeint_inputs[]
Definition: vf_mcdeint.c:287
av_free_packet
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:280
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
MODE_SLOW
Definition: vf_mcdeint.c:60
avcodec_find_encoder
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:2932
h
h
Definition: vp9dsp_template.c:2093
AVOption
AVOption.
Definition: opt.h:255
outputs
static const AVFilterPad outputs[]
Definition: af_ashowinfo.c:248
avfilter.h
Main libavfilter public API header.
temp
else temp
Definition: vf_mcdeint.c:257
AVCodecContext::coded_frame
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2745
AV_OPT_TYPE_INT
Definition: opt.h:223
AVCodecContext::max_b_frames
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:1503
FF_CMP_SSE
#define FF_CMP_SSE
Definition: avcodec.h:1650
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1444
ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:109
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVCodec
AVCodec.
Definition: avcodec.h:3181
CODEC_FLAG_QPEL
#define CODEC_FLAG_QPEL
Use qpel MC.
Definition: avcodec.h:715
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1369
ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283
OFFSET
#define OFFSET(x)
Definition: vf_mcdeint.c:78
MCDeintMode
MCDeintMode
Definition: vf_mcdeint.c:57
srcp
BYTE int const BYTE * srcp
Definition: avisynth_c.h:676
AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:67
MCDeintContext::enc_ctx
AVCodecContext * enc_ctx
Definition: vf_mcdeint.c:75
uint8_t
uint8_t
Definition: audio_convert.c:194
av_cold
#define av_cold
Definition: attributes.h:74
mode
mode
Definition: f_perms.c:27
opt.h
AVOptions.
GET_SCORE_EDGE
#define GET_SCORE_EDGE(j)
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:67
PARITY_BFF
bottom field first
Definition: vf_mcdeint.c:67
inpic
av_frame_free & inpic
Definition: vf_mcdeint.c:279
AVCodecContext::me_cmp
int me_cmp
motion estimation comparison function
Definition: avcodec.h:1630
avcodec_encode_video2
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: utils.c:2101
else
else
Definition: vf_mcdeint.c:259
mcdeint_outputs
static const AVFilterPad mcdeint_outputs[]
Definition: vf_mcdeint.c:297
AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(mcdeint)
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
CONST
#define CONST(name, help, val, unit)
Definition: vf_mcdeint.c:80
AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:61
U
#define U(x)
Definition: vp56_arith.h:37
avcodec_close
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:2843
AVDictionary
Definition: dict.c:29
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
ff_set_common_formats
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:542
FLAGS
#define FLAGS
Definition: vf_mcdeint.c:79
spatial_score
else int spatial_score
Definition: vf_mcdeint.c:248
ff_filter_frame
return ff_filter_frame(outlink, outpic)
config_props
static int config_props(AVFilterLink *inlink)
Definition: vf_mcdeint.c:99
dstp
BYTE * dstp
Definition: avisynth_c.h:676
AVERROR
#define AVERROR(e)
Definition: error.h:43
AVCodecContext::me_sub_cmp
int me_sub_cmp
subpixel motion estimation comparison function
Definition: avcodec.h:1636
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:148
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:654
MODE_NB
Definition: vf_mcdeint.c:62
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:199
AVCodecContext::flags
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1335
CODEC_FLAG_QSCALE
#define CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:712
MCDeintContext::mode
int mode
MCDeintMode.
Definition: vf_mcdeint.c:72
avcodec.h
Libavcodec external API header.
CODEC_FLAG_LOW_DELAY
#define CODEC_FLAG_LOW_DELAY
Force low delay.
Definition: avcodec.h:757
uninit
static av_cold void uninit(AVFilterContext *ctx)
Definition: vf_mcdeint.c:151
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:1901
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2548
y
float y
Definition: avf_showspectrum.c:96
ME_ITER
iterative search
Definition: avcodec.h:654
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:147
ret
ret
Definition: avfilter.c:974
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1414
FF_CEIL_RSHIFT
#define FF_CEIL_RSHIFT(a, b)
Definition: common.h:57
mcdeint_options
static const AVOption mcdeint_options[]
Definition: vf_mcdeint.c:82
FFABS
#define FFABS(a)
Definition: common.h:61
parity
mcdeint parity
Definition: vf_mcdeint.c:275
AVFrame::quality
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:283
MODE_MEDIUM
Definition: vf_mcdeint.c:59
AVCodecContext::height
int height
Definition: avcodec.h:1414
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:199
CHECK
#define CHECK(j)
AVCodecContext
main external API structure.
Definition: avcodec.h:1241
AV_CODEC_ID_SNOW
Definition: avcodec.h:319
query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_mcdeint.c:161
av_dict_set
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:69
PARITY_TFF
top field first
Definition: vf_mcdeint.c:66
CHECK_EDGE
#define CHECK_EDGE(j)
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
GET_SCORE
#define GET_SCORE(j)
AVFilter
Filter definition.
Definition: avfilter.h:470
inputs
static const AVFilterPad inputs[]
Definition: af_ashowinfo.c:239
AVRational
rational number numerator/denominator
Definition: rational.h:43
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:474
avcodec_open2
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:1330
AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:648
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1321
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
AVCodecContext::gop_size
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:1435
FF_CMP_SAD
#define FF_CMP_SAD
Definition: avcodec.h:1649
AVCodecContext::mb_cmp
int mb_cmp
macroblock comparison function (not supported yet)
Definition: avcodec.h:1642
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
filp
* filp
Definition: vf_mcdeint.c:258
if
if(ret< 0)
Definition: vf_mcdeint.c:280
MCDeintContext::parity
int parity
MCDeintParity.
Definition: vf_mcdeint.c:73
av_init_packet
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:49
AVCodecContext::dia_size
int dia_size
ME diamond size & shape.
Definition: avcodec.h:1671
MCDeintParity
MCDeintParity
Definition: vf_mcdeint.c:65
AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:220
filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *inpic)
Definition: vf_mcdeint.c:172
AVFilterContext
An instance of a filter.
Definition: avfilter.h:633
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVMEDIA_TYPE_VIDEO
Definition: avutil.h:194
AVCodecContext::me_method
int me_method
Motion estimation algorithm used for video coding.
Definition: avcodec.h:1453
internal.h
internal API functions
CODEC_FLAG_4MV
#define CODEC_FLAG_4MV
4 MV per MB allowed / advanced prediction for H.263.
Definition: avcodec.h:713
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:61
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1139
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
Definition: avcodec.h:2543
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:548
MODE_FAST
Definition: vf_mcdeint.c:58
ff_vf_mcdeint
AVFilter ff_vf_mcdeint
Definition: vf_mcdeint.c:305
MODE_EXTRA_SLOW
Definition: vf_mcdeint.c:61
Generated on Wed Jun 10 2015 01:56:55 for FFmpeg by   doxygen 1.8.6

AltStyle によって変換されたページ (->オリジナル) /