3 * Copyright (c) 2001 Fabrice Bellard.
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28 /* needed for mkstemp() */
29 #define _XOPEN_SOURCE 600
31 #include "libavutil/integer.h"
32 #include "libavutil/crc.h"
36 #include "imgconvert.h"
37 #include "audioconvert.h"
42 #if !defined(HAVE_MKSTEMP)
46 const uint8_t ff_reverse
[256]={
47 0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
48 0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
49 0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
50 0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
51 0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
52 0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
53 0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
54 0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
55 0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
56 0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
57 0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
58 0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
59 0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
60 0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
61 0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
62 0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
65 static int volatile entangled_thread_counter
=0;
67 void *av_fast_realloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
72 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
74 ptr
= av_realloc(ptr
, *size
);
75 if(!ptr
) //we could set this to the unmodified min_size but this is safer if the user lost the ptr and uses NULL now
81 /* encoder management */
82 static AVCodec
*first_avcodec
= NULL
;
84 AVCodec
*av_codec_next(AVCodec
*c
){
86 else return first_avcodec
;
89 void register_avcodec(AVCodec
*format
)
93 while (*p
!= NULL
) p
= &(*p
)->next
;
98 void avcodec_set_dimensions(AVCodecContext
*s
, int width
, int height
){
99 s
->coded_width
= width
;
100 s
->coded_height
= height
;
101 s
->width
= -((-width
)>>s
->lowres
);
102 s
->height
= -((-height
)>>s
->lowres
);
105 typedef struct InternalBuffer
{
111 enum PixelFormat pix_fmt
;
114 #define INTERNAL_BUFFER_SIZE 32
116 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
118 void avcodec_align_dimensions(AVCodecContext
*s
, int *width
, int *height
){
123 case PIX_FMT_YUV420P
:
124 case PIX_FMT_YUYV422
:
125 case PIX_FMT_UYVY422
:
126 case PIX_FMT_YUV422P
:
127 case PIX_FMT_YUV444P
:
129 case PIX_FMT_GRAY16BE
:
130 case PIX_FMT_GRAY16LE
:
131 case PIX_FMT_YUVJ420P
:
132 case PIX_FMT_YUVJ422P
:
133 case PIX_FMT_YUVJ444P
:
134 case PIX_FMT_YUVA420P
:
135 w_align
= 16; //FIXME check for non mpeg style codecs and use less alignment
138 case PIX_FMT_YUV411P
:
139 case PIX_FMT_UYYVYY411
:
143 case PIX_FMT_YUV410P
:
144 if(s
->codec_id
== CODEC_ID_SVQ1
){
149 if(s
->codec_id
== CODEC_ID_RPZA
){
154 if(s
->codec_id
== CODEC_ID_SMC
){
160 if((s
->codec_id
== CODEC_ID_MSZH
) || (s
->codec_id
== CODEC_ID_ZLIB
)){
171 *width
= ALIGN(*width
, w_align
);
172 *height
= ALIGN(*height
, h_align
);
173 if(s
->codec_id
== CODEC_ID_H264
)
174 *height
+=2; // some of the optimized chroma MC reads one line too much
177 int avcodec_check_dimensions(void *av_log_ctx
, unsigned int w
, unsigned int h
){
178 if((int)w
>0 && (int)h
>0 && (w
+128)*(uint64_t)(h
+128) < INT_MAX
/4)
181 av_log(av_log_ctx
, AV_LOG_ERROR
, "picture size invalid (%ux%u)\n", w
, h
);
185 int avcodec_default_get_buffer(AVCodecContext
*s
, AVFrame
*pic
){
192 if(pic
->data
[0]!=NULL
) {
193 av_log(s
, AV_LOG_ERROR
, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
196 if(s
->internal_buffer_count
>= INTERNAL_BUFFER_SIZE
) {
197 av_log(s
, AV_LOG_ERROR
, "internal_buffer_count overflow (missing release_buffer?)\n");
201 if(avcodec_check_dimensions(s
,w
,h
))
204 if(s
->internal_buffer
==NULL
){
205 s
->internal_buffer
= av_mallocz((INTERNAL_BUFFER_SIZE
+1)*sizeof(InternalBuffer
));
208 s
->internal_buffer
= av_fast_realloc(
210 &s
->internal_buffer_size
,
211 sizeof(InternalBuffer
)*FFMAX(99, s
->internal_buffer_count
+1)/*FIXME*/
215 buf
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
216 picture_number
= &(((InternalBuffer
*)s
->internal_buffer
)[INTERNAL_BUFFER_SIZE
]).last_pic_num
; //FIXME ugly hack
219 if(buf
->base
[0] && (buf
->width
!= w
|| buf
->height
!= h
|| buf
->pix_fmt
!= s
->pix_fmt
)){
221 av_freep(&buf
->base
[i
]);
227 pic
->age
= *picture_number
- buf
->last_pic_num
;
228 buf
->last_pic_num
= *picture_number
;
230 int h_chroma_shift
, v_chroma_shift
;
236 avcodec_get_chroma_sub_sample(s
->pix_fmt
, &h_chroma_shift
, &v_chroma_shift
);
238 avcodec_align_dimensions(s
, &w
, &h
);
240 if(!(s
->flags
&CODEC_FLAG_EMU_EDGE
)){
245 ff_fill_linesize(&picture
, s
->pix_fmt
, w
);
248 //STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
249 //we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
250 //picture size unneccessarily in some cases. The solution here is not
251 //pretty and better ideas are welcome!
253 if(s
->codec_id
== CODEC_ID_SVQ1
)
257 stride_align
[i
] = STRIDE_ALIGN
;
258 picture
.linesize
[i
] = ALIGN(picture
.linesize
[i
], stride_align
[i
]);
261 tmpsize
= ff_fill_pointer(&picture
, NULL
, s
->pix_fmt
, h
);
263 for (i
=0; i
<3 && picture
.data
[i
+1]; i
++)
264 size
[i
] = picture
.data
[i
+1] - picture
.data
[i
];
265 size
[i
] = tmpsize
- (picture
.data
[i
] - picture
.data
[0]);
267 buf
->last_pic_num
= -256*256*256*64;
268 memset(buf
->base
, 0, sizeof(buf
->base
));
269 memset(buf
->data
, 0, sizeof(buf
->data
));
271 for(i
=0; i
<4 && size
[i
]; i
++){
272 const int h_shift
= i
==0 ? 0 : h_chroma_shift
;
273 const int v_shift
= i
==0 ? 0 : v_chroma_shift
;
275 buf
->linesize
[i
]= picture
.linesize
[i
];
277 buf
->base
[i
]= av_malloc(size
[i
]+16); //FIXME 16
278 if(buf
->base
[i
]==NULL
) return -1;
279 memset(buf
->base
[i
], 128, size
[i
]);
281 // no edge if EDEG EMU or not planar YUV, we check for PAL8 redundantly to protect against a exploitable bug regression ...
282 if((s
->flags
&CODEC_FLAG_EMU_EDGE
) || (s
->pix_fmt
== PIX_FMT_PAL8
) || !size
[2])
283 buf
->data
[i
] = buf
->base
[i
];
285 buf
->data
[i
] = buf
->base
[i
] + ALIGN((buf
->linesize
[i
]*EDGE_WIDTH
>>v_shift
) + (EDGE_WIDTH
>>h_shift
), stride_align
[i
]);
287 buf
->width
= s
->width
;
288 buf
->height
= s
->height
;
289 buf
->pix_fmt
= s
->pix_fmt
;
290 pic
->age
= 256*256*256*64;
292 pic
->type
= FF_BUFFER_TYPE_INTERNAL
;
295 pic
->base
[i
]= buf
->base
[i
];
296 pic
->data
[i
]= buf
->data
[i
];
297 pic
->linesize
[i
]= buf
->linesize
[i
];
299 s
->internal_buffer_count
++;
301 pic
->reordered_opaque
= s
->reordered_opaque
;
303 if(s
->debug
&FF_DEBUG_BUFFERS
)
304 av_log(s
, AV_LOG_DEBUG
, "default_get_buffer called on pic %p, %d buffers used\n", pic
, s
->internal_buffer_count
);
309 void avcodec_default_release_buffer(AVCodecContext
*s
, AVFrame
*pic
){
311 InternalBuffer
*buf
, *last
;
313 assert(pic
->type
==FF_BUFFER_TYPE_INTERNAL
);
314 assert(s
->internal_buffer_count
);
316 buf
= NULL
; /* avoids warning */
317 for(i
=0; i
<s
->internal_buffer_count
; i
++){ //just 3-5 checks so is not worth to optimize
318 buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
319 if(buf
->data
[0] == pic
->data
[0])
322 assert(i
< s
->internal_buffer_count
);
323 s
->internal_buffer_count
--;
324 last
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
326 FFSWAP(InternalBuffer
, *buf
, *last
);
330 // pic->base[i]=NULL;
332 //printf("R%X\n", pic->opaque);
334 if(s
->debug
&FF_DEBUG_BUFFERS
)
335 av_log(s
, AV_LOG_DEBUG
, "default_release_buffer called on pic %p, %d buffers used\n", pic
, s
->internal_buffer_count
);
338 int avcodec_default_reget_buffer(AVCodecContext
*s
, AVFrame
*pic
){
342 /* If no picture return a new buffer */
343 if(pic
->data
[0] == NULL
) {
344 /* We will copy from buffer, so must be readable */
345 pic
->buffer_hints
|= FF_BUFFER_HINTS_READABLE
;
346 return s
->get_buffer(s
, pic
);
349 /* If internal buffer type return the same buffer */
350 if(pic
->type
== FF_BUFFER_TYPE_INTERNAL
)
354 * Not internal type and reget_buffer not overridden, emulate cr buffer
357 for(i
= 0; i
< 4; i
++)
358 pic
->data
[i
] = pic
->base
[i
] = NULL
;
360 /* Allocate new frame */
361 if (s
->get_buffer(s
, pic
))
363 /* Copy image data from old buffer to new buffer */
364 av_picture_copy((AVPicture
*)pic
, (AVPicture
*)&temp_pic
, s
->pix_fmt
, s
->width
,
366 s
->release_buffer(s
, &temp_pic
); // Release old frame
370 int avcodec_default_execute(AVCodecContext
*c
, int (*func
)(AVCodecContext
*c2
, void *arg2
),void **arg
, int *ret
, int count
){
373 for(i
=0; i
<count
; i
++){
374 int r
= func(c
, arg
[i
]);
380 enum PixelFormat
avcodec_default_get_format(struct AVCodecContext
*s
, const enum PixelFormat
* fmt
){
384 static const char* context_to_name(void* ptr
) {
385 AVCodecContext
*avc
= ptr
;
387 if(avc
&& avc
->codec
&& avc
->codec
->name
)
388 return avc
->codec
->name
;
393 #define OFFSET(x) offsetof(AVCodecContext,x)
394 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
395 //these names are too long to be readable
396 #define V AV_OPT_FLAG_VIDEO_PARAM
397 #define A AV_OPT_FLAG_AUDIO_PARAM
398 #define S AV_OPT_FLAG_SUBTITLE_PARAM
399 #define E AV_OPT_FLAG_ENCODING_PARAM
400 #define D AV_OPT_FLAG_DECODING_PARAM
402 #define AV_CODEC_DEFAULT_BITRATE 200*1000
404 static const AVOption options
[]={
405 {"b", "set bitrate (in bits/s)", OFFSET(bit_rate
), FF_OPT_TYPE_INT
, AV_CODEC_DEFAULT_BITRATE
, INT_MIN
, INT_MAX
, V
|E
},
406 {"ab", "set bitrate (in bits/s)", OFFSET(bit_rate
), FF_OPT_TYPE_INT
, 64*1000, INT_MIN
, INT_MAX
, A
|E
},
407 {"bt", "set video bitrate tolerance (in bits/s)", OFFSET(bit_rate_tolerance
), FF_OPT_TYPE_INT
, AV_CODEC_DEFAULT_BITRATE
*20, 1, INT_MAX
, V
|E
},
408 {"flags", NULL
, OFFSET(flags
), FF_OPT_TYPE_FLAGS
, DEFAULT
, 0, UINT_MAX
, V
|A
|E
|D
, "flags"},
409 {"mv4", "use four motion vector by macroblock (mpeg4)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_4MV
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
410 {"obmc", "use overlapped block motion compensation (h263+)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_OBMC
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
411 {"qpel", "use 1/4 pel motion compensation", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_QPEL
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
412 {"loop", "use loop filter", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_LOOP_FILTER
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
413 {"qscale", "use fixed qscale", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_QSCALE
, INT_MIN
, INT_MAX
, 0, "flags"},
414 {"gmc", "use gmc", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_GMC
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
415 {"mv0", "always try a mb with mv=<0,0>", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_MV0
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
416 {"part", "use data partitioning", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_PART
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
417 {"input_preserved", NULL
, 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_INPUT_PRESERVED
, INT_MIN
, INT_MAX
, 0, "flags"},
418 {"pass1", "use internal 2pass ratecontrol in first pass mode", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_PASS1
, INT_MIN
, INT_MAX
, 0, "flags"},
419 {"pass2", "use internal 2pass ratecontrol in second pass mode", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_PASS2
, INT_MIN
, INT_MAX
, 0, "flags"},
420 {"extern_huff", "use external huffman table (for mjpeg)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_EXTERN_HUFF
, INT_MIN
, INT_MAX
, 0, "flags"},
421 {"gray", "only decode/encode grayscale", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_GRAY
, INT_MIN
, INT_MAX
, V
|E
|D
, "flags"},
422 {"emu_edge", "don't draw edges", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_EMU_EDGE
, INT_MIN
, INT_MAX
, 0, "flags"},
423 {"psnr", "error[?] variables will be set during encoding", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_PSNR
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
424 {"truncated", NULL
, 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_TRUNCATED
, INT_MIN
, INT_MAX
, 0, "flags"},
425 {"naq", "normalize adaptive quantization", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_NORMALIZE_AQP
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
426 {"ildct", "use interlaced dct", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_INTERLACED_DCT
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
427 {"low_delay", "force low delay", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_LOW_DELAY
, INT_MIN
, INT_MAX
, V
|D
|E
, "flags"},
428 {"alt", "enable alternate scantable (mpeg2/mpeg4)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_ALT_SCAN
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
429 {"global_header", "place global headers in extradata instead of every keyframe", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_GLOBAL_HEADER
, INT_MIN
, INT_MAX
, V
|A
|E
, "flags"},
430 {"bitexact", "use only bitexact stuff (except (i)dct)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_BITEXACT
, INT_MIN
, INT_MAX
, A
|V
|S
|D
|E
, "flags"},
431 {"aic", "h263 advanced intra coding / mpeg4 ac prediction", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_AC_PRED
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
432 {"umv", "use unlimited motion vectors", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_H263P_UMV
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
433 {"cbp", "use rate distortion optimization for cbp", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_CBP_RD
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
434 {"qprd", "use rate distortion optimization for qp selection", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_QP_RD
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
435 {"aiv", "h263 alternative inter vlc", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_H263P_AIV
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
436 {"slice", NULL
, 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_H263P_SLICE_STRUCT
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
437 {"ilme", "interlaced motion estimation", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_INTERLACED_ME
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
438 {"scan_offset", "will reserve space for svcd scan offset user data", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_SVCD_SCAN_OFFSET
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
439 {"cgop", "closed gop", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_CLOSED_GOP
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
440 {"fast", "allow non spec compliant speedup tricks", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_FAST
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
441 {"sgop", "strictly enforce gop size", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_STRICT_GOP
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
442 {"noout", "skip bitstream encoding", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_NO_OUTPUT
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
443 {"local_header", "place global headers at every keyframe instead of in extradata", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_LOCAL_HEADER
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
444 {"sub_id", NULL
, OFFSET(sub_id
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
445 {"me_method", "set motion estimation method", OFFSET(me_method
), FF_OPT_TYPE_INT
, ME_EPZS
, INT_MIN
, INT_MAX
, V
|E
, "me_method"},
446 {"zero", "zero motion estimation (fastest)", 0, FF_OPT_TYPE_CONST
, ME_ZERO
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
447 {"full", "full motion estimation (slowest)", 0, FF_OPT_TYPE_CONST
, ME_FULL
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
448 {"epzs", "EPZS motion estimation (default)", 0, FF_OPT_TYPE_CONST
, ME_EPZS
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
449 {"esa", "esa motion estimation (alias for full)", 0, FF_OPT_TYPE_CONST
, ME_FULL
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
450 {"tesa", "tesa motion estimation", 0, FF_OPT_TYPE_CONST
, ME_TESA
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
451 {"dia", "dia motion estimation (alias for epzs)", 0, FF_OPT_TYPE_CONST
, ME_EPZS
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
452 {"log", "log motion estimation", 0, FF_OPT_TYPE_CONST
, ME_LOG
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
453 {"phods", "phods motion estimation", 0, FF_OPT_TYPE_CONST
, ME_PHODS
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
454 {"x1", "X1 motion estimation", 0, FF_OPT_TYPE_CONST
, ME_X1
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
455 {"hex", "hex motion estimation", 0, FF_OPT_TYPE_CONST
, ME_HEX
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
456 {"umh", "umh motion estimation", 0, FF_OPT_TYPE_CONST
, ME_UMH
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
457 {"iter", "iter motion estimation", 0, FF_OPT_TYPE_CONST
, ME_ITER
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
458 {"extradata_size", NULL
, OFFSET(extradata_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
459 {"time_base", NULL
, OFFSET(time_base
), FF_OPT_TYPE_RATIONAL
, DEFAULT
, INT_MIN
, INT_MAX
},
460 {"g", "set the group of picture size", OFFSET(gop_size
), FF_OPT_TYPE_INT
, 12, INT_MIN
, INT_MAX
, V
|E
},
461 {"rate_emu", "frame rate emulation", OFFSET(rate_emu
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
462 {"ar", "set audio sampling rate (in Hz)", OFFSET(sample_rate
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
463 {"ac", "set number of audio channels", OFFSET(channels
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
464 {"cutoff", "set cutoff bandwidth", OFFSET(cutoff
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, A
|E
},
465 {"frame_size", NULL
, OFFSET(frame_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, A
|E
},
466 {"frame_number", NULL
, OFFSET(frame_number
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
467 {"real_pict_num", NULL
, OFFSET(real_pict_num
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
468 {"delay", NULL
, OFFSET(delay
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
469 {"qcomp", "video quantizer scale compression (VBR)", OFFSET(qcompress
), FF_OPT_TYPE_FLOAT
, 0.5, -FLT_MAX
, FLT_MAX
, V
|E
},
470 {"qblur", "video quantizer scale blur (VBR)", OFFSET(qblur
), FF_OPT_TYPE_FLOAT
, 0.5, 0, FLT_MAX
, V
|E
},
471 {"qmin", "min video quantizer scale (VBR)", OFFSET(qmin
), FF_OPT_TYPE_INT
, 2, 1, 51, V
|E
},
472 {"qmax", "max video quantizer scale (VBR)", OFFSET(qmax
), FF_OPT_TYPE_INT
, 31, 1, 51, V
|E
},
473 {"qdiff", "max difference between the quantizer scale (VBR)", OFFSET(max_qdiff
), FF_OPT_TYPE_INT
, 3, INT_MIN
, INT_MAX
, V
|E
},
474 {"bf", "use 'frames' B frames", OFFSET(max_b_frames
), FF_OPT_TYPE_INT
, DEFAULT
, 0, FF_MAX_B_FRAMES
, V
|E
},
475 {"b_qfactor", "qp factor between p and b frames", OFFSET(b_quant_factor
), FF_OPT_TYPE_FLOAT
, 1.25, -FLT_MAX
, FLT_MAX
, V
|E
},
476 {"rc_strategy", "ratecontrol method", OFFSET(rc_strategy
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
477 {"b_strategy", "strategy to choose between I/P/B-frames", OFFSET(b_frame_strategy
), FF_OPT_TYPE_INT
, 0, INT_MIN
, INT_MAX
, V
|E
},
478 {"hurry_up", NULL
, OFFSET(hurry_up
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|D
},
479 {"ps", "rtp payload size in bits", OFFSET(rtp_payload_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
480 {"mv_bits", NULL
, OFFSET(mv_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
481 {"header_bits", NULL
, OFFSET(header_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
482 {"i_tex_bits", NULL
, OFFSET(i_tex_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
483 {"p_tex_bits", NULL
, OFFSET(p_tex_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
484 {"i_count", NULL
, OFFSET(i_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
485 {"p_count", NULL
, OFFSET(p_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
486 {"skip_count", NULL
, OFFSET(skip_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
487 {"misc_bits", NULL
, OFFSET(misc_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
488 {"frame_bits", NULL
, OFFSET(frame_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
489 {"codec_tag", NULL
, OFFSET(codec_tag
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
490 {"bug", "workaround not auto detected encoder bugs", OFFSET(workaround_bugs
), FF_OPT_TYPE_FLAGS
, FF_BUG_AUTODETECT
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
491 {"autodetect", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_AUTODETECT
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
492 {"old_msmpeg4", "some old lavc generated msmpeg4v3 files (no autodetection)", 0, FF_OPT_TYPE_CONST
, FF_BUG_OLD_MSMPEG4
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
493 {"xvid_ilace", "Xvid interlacing bug (autodetected if fourcc==XVIX)", 0, FF_OPT_TYPE_CONST
, FF_BUG_XVID_ILACE
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
494 {"ump4", "(autodetected if fourcc==UMP4)", 0, FF_OPT_TYPE_CONST
, FF_BUG_UMP4
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
495 {"no_padding", "padding bug (autodetected)", 0, FF_OPT_TYPE_CONST
, FF_BUG_NO_PADDING
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
496 {"amv", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_AMV
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
497 {"ac_vlc", "illegal vlc bug (autodetected per fourcc)", 0, FF_OPT_TYPE_CONST
, FF_BUG_AC_VLC
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
498 {"qpel_chroma", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_QPEL_CHROMA
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
499 {"std_qpel", "old standard qpel (autodetected per fourcc/version)", 0, FF_OPT_TYPE_CONST
, FF_BUG_STD_QPEL
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
500 {"qpel_chroma2", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_QPEL_CHROMA2
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
501 {"direct_blocksize", "direct-qpel-blocksize bug (autodetected per fourcc/version)", 0, FF_OPT_TYPE_CONST
, FF_BUG_DIRECT_BLOCKSIZE
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
502 {"edge", "edge padding bug (autodetected per fourcc/version)", 0, FF_OPT_TYPE_CONST
, FF_BUG_EDGE
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
503 {"hpel_chroma", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_HPEL_CHROMA
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
504 {"dc_clip", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_DC_CLIP
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
505 {"ms", "workaround various bugs in microsofts broken decoders", 0, FF_OPT_TYPE_CONST
, FF_BUG_MS
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
506 {"lelim", "single coefficient elimination threshold for luminance (negative values also consider dc coefficient)", OFFSET(luma_elim_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
507 {"celim", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)", OFFSET(chroma_elim_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
508 {"strict", "how strictly to follow the standards", OFFSET(strict_std_compliance
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, A
|V
|D
|E
, "strict"},
509 {"very", "strictly conform to a older more strict version of the spec or reference software", 0, FF_OPT_TYPE_CONST
, FF_COMPLIANCE_VERY_STRICT
, INT_MIN
, INT_MAX
, V
|D
|E
, "strict"},
510 {"strict", "strictly conform to all the things in the spec no matter what consequences", 0, FF_OPT_TYPE_CONST
, FF_COMPLIANCE_STRICT
, INT_MIN
, INT_MAX
, V
|D
|E
, "strict"},
511 {"normal", NULL
, 0, FF_OPT_TYPE_CONST
, FF_COMPLIANCE_NORMAL
, INT_MIN
, INT_MAX
, V
|D
|E
, "strict"},
512 {"inofficial", "allow inofficial extensions", 0, FF_OPT_TYPE_CONST
, FF_COMPLIANCE_INOFFICIAL
, INT_MIN
, INT_MAX
, V
|D
|E
, "strict"},
513 {"experimental", "allow non standardized experimental things", 0, FF_OPT_TYPE_CONST
, FF_COMPLIANCE_EXPERIMENTAL
, INT_MIN
, INT_MAX
, V
|D
|E
, "strict"},
514 {"b_qoffset", "qp offset between P and B frames", OFFSET(b_quant_offset
), FF_OPT_TYPE_FLOAT
, 1.25, -FLT_MAX
, FLT_MAX
, V
|E
},
515 {"er", "set error detection aggressivity", OFFSET(error_recognition
), FF_OPT_TYPE_INT
, FF_ER_CAREFUL
, INT_MIN
, INT_MAX
, A
|V
|D
, "er"},
516 {"careful", NULL
, 0, FF_OPT_TYPE_CONST
, FF_ER_CAREFUL
, INT_MIN
, INT_MAX
, V
|D
, "er"},
517 {"compliant", NULL
, 0, FF_OPT_TYPE_CONST
, FF_ER_COMPLIANT
, INT_MIN
, INT_MAX
, V
|D
, "er"},
518 {"aggressive", NULL
, 0, FF_OPT_TYPE_CONST
, FF_ER_AGGRESSIVE
, INT_MIN
, INT_MAX
, V
|D
, "er"},
519 {"very_aggressive", NULL
, 0, FF_OPT_TYPE_CONST
, FF_ER_VERY_AGGRESSIVE
, INT_MIN
, INT_MAX
, V
|D
, "er"},
520 {"has_b_frames", NULL
, OFFSET(has_b_frames
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
521 {"block_align", NULL
, OFFSET(block_align
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
522 {"parse_only", NULL
, OFFSET(parse_only
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
523 {"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
524 {"stats_out", NULL
, OFFSET(stats_out
), FF_OPT_TYPE_STRING
, DEFAULT
, CHAR_MIN
, CHAR_MAX
},
525 {"stats_in", NULL
, OFFSET(stats_in
), FF_OPT_TYPE_STRING
, DEFAULT
, CHAR_MIN
, CHAR_MAX
},
526 {"qsquish", "how to keep quantizer between qmin and qmax (0 = clip, 1 = use differentiable function)", OFFSET(rc_qsquish
), FF_OPT_TYPE_FLOAT
, DEFAULT
, 0, 99, V
|E
},
527 {"rc_qmod_amp", "experimental quantizer modulation", OFFSET(rc_qmod_amp
), FF_OPT_TYPE_FLOAT
, DEFAULT
, -FLT_MAX
, FLT_MAX
, V
|E
},
528 {"rc_qmod_freq", "experimental quantizer modulation", OFFSET(rc_qmod_freq
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
529 {"rc_override_count", NULL
, OFFSET(rc_override_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
530 {"rc_eq", "set rate control equation", OFFSET(rc_eq
), FF_OPT_TYPE_STRING
, DEFAULT
, CHAR_MIN
, CHAR_MAX
, V
|E
},
531 {"maxrate", "set max video bitrate tolerance (in bits/s)", OFFSET(rc_max_rate
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
532 {"minrate", "set min video bitrate tolerance (in bits/s)", OFFSET(rc_min_rate
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
533 {"bufsize", "set ratecontrol buffer size (in bits)", OFFSET(rc_buffer_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, A
|V
|E
},
534 {"rc_buf_aggressivity", "currently useless", OFFSET(rc_buffer_aggressivity
), FF_OPT_TYPE_FLOAT
, 1.0, -FLT_MAX
, FLT_MAX
, V
|E
},
535 {"i_qfactor", "qp factor between P and I frames", OFFSET(i_quant_factor
), FF_OPT_TYPE_FLOAT
, -0.8, -FLT_MAX
, FLT_MAX
, V
|E
},
536 {"i_qoffset", "qp offset between P and I frames", OFFSET(i_quant_offset
), FF_OPT_TYPE_FLOAT
, 0.0, -FLT_MAX
, FLT_MAX
, V
|E
},
537 {"rc_init_cplx", "initial complexity for 1-pass encoding", OFFSET(rc_initial_cplx
), FF_OPT_TYPE_FLOAT
, DEFAULT
, -FLT_MAX
, FLT_MAX
, V
|E
},
538 {"dct", "DCT algorithm", OFFSET(dct_algo
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, V
|E
, "dct"},
539 {"auto", "autoselect a good one (default)", 0, FF_OPT_TYPE_CONST
, FF_DCT_AUTO
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
540 {"fastint", "fast integer", 0, FF_OPT_TYPE_CONST
, FF_DCT_FASTINT
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
541 {"int", "accurate integer", 0, FF_OPT_TYPE_CONST
, FF_DCT_INT
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
542 {"mmx", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DCT_MMX
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
543 {"mlib", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DCT_MLIB
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
544 {"altivec", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DCT_ALTIVEC
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
545 {"faan", "floating point AAN DCT", 0, FF_OPT_TYPE_CONST
, FF_DCT_FAAN
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
546 {"lumi_mask", "compresses bright areas stronger than medium ones", OFFSET(lumi_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
547 {"tcplx_mask", "temporal complexity masking", OFFSET(temporal_cplx_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
548 {"scplx_mask", "spatial complexity masking", OFFSET(spatial_cplx_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
549 {"p_mask", "inter masking", OFFSET(p_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
550 {"dark_mask", "compresses dark areas stronger than medium ones", OFFSET(dark_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
551 {"idct", "select IDCT implementation", OFFSET(idct_algo
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, V
|E
|D
, "idct"},
552 {"auto", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_AUTO
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
553 {"int", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_INT
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
554 {"simple", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLE
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
555 {"simplemmx", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLEMMX
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
556 {"libmpeg2mmx", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_LIBMPEG2MMX
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
557 {"ps2", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_PS2
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
558 {"mlib", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_MLIB
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
559 {"arm", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_ARM
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
560 {"altivec", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_ALTIVEC
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
561 {"sh4", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SH4
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
562 {"simplearm", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLEARM
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
563 {"simplearmv5te", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLEARMV5TE
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
564 {"simplearmv6", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLEARMV6
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
565 {"h264", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_H264
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
566 {"vp3", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_VP3
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
567 {"ipp", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_IPP
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
568 {"xvidmmx", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_XVIDMMX
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
569 {"faani", "floating point AAN IDCT", 0, FF_OPT_TYPE_CONST
, FF_IDCT_FAAN
, INT_MIN
, INT_MAX
, V
|D
|E
, "idct"},
570 {"slice_count", NULL
, OFFSET(slice_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
571 {"ec", "set error concealment strategy", OFFSET(error_concealment
), FF_OPT_TYPE_FLAGS
, 3, INT_MIN
, INT_MAX
, V
|D
, "ec"},
572 {"guess_mvs", "iterative motion vector (MV) search (slow)", 0, FF_OPT_TYPE_CONST
, FF_EC_GUESS_MVS
, INT_MIN
, INT_MAX
, V
|D
, "ec"},
573 {"deblock", "use strong deblock filter for damaged MBs", 0, FF_OPT_TYPE_CONST
, FF_EC_DEBLOCK
, INT_MIN
, INT_MAX
, V
|D
, "ec"},
574 {"bits_per_coded_sample", NULL
, OFFSET(bits_per_coded_sample
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
575 {"pred", "prediction method", OFFSET(prediction_method
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "pred"},
576 {"left", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PRED_LEFT
, INT_MIN
, INT_MAX
, V
|E
, "pred"},
577 {"plane", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PRED_PLANE
, INT_MIN
, INT_MAX
, V
|E
, "pred"},
578 {"median", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PRED_MEDIAN
, INT_MIN
, INT_MAX
, V
|E
, "pred"},
579 {"aspect", "sample aspect ratio", OFFSET(sample_aspect_ratio
), FF_OPT_TYPE_RATIONAL
, DEFAULT
, 0, 10, V
|E
},
580 {"debug", "print specific debug info", OFFSET(debug
), FF_OPT_TYPE_FLAGS
, DEFAULT
, 0, INT_MAX
, V
|A
|S
|E
|D
, "debug"},
581 {"pict", "picture info", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_PICT_INFO
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
582 {"rc", "rate control", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_RC
, INT_MIN
, INT_MAX
, V
|E
, "debug"},
583 {"bitstream", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_BITSTREAM
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
584 {"mb_type", "macroblock (MB) type", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_MB_TYPE
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
585 {"qp", "per-block quantization parameter (QP)", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_QP
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
586 {"mv", "motion vector", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_MV
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
587 {"dct_coeff", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_DCT_COEFF
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
588 {"skip", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_SKIP
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
589 {"startcode", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_STARTCODE
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
590 {"pts", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_PTS
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
591 {"er", "error recognition", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_ER
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
592 {"mmco", "memory management control operations (H.264)", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_MMCO
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
593 {"bugs", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_BUGS
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
594 {"vis_qp", "visualize quantization parameter (QP), lower QP are tinted greener", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_VIS_QP
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
595 {"vis_mb_type", "visualize block types", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_VIS_MB_TYPE
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
596 {"buffers", "picture buffer allocations", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_BUFFERS
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
597 {"vismv", "visualize motion vectors (MVs)", OFFSET(debug_mv
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, V
|D
, "debug_mv"},
598 {"pf", "forward predicted MVs of P-frames", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_VIS_MV_P_FOR
, INT_MIN
, INT_MAX
, V
|D
, "debug_mv"},
599 {"bf", "forward predicted MVs of B-frames", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_VIS_MV_B_FOR
, INT_MIN
, INT_MAX
, V
|D
, "debug_mv"},
600 {"bb", "backward predicted MVs of B-frames", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_VIS_MV_B_BACK
, INT_MIN
, INT_MAX
, V
|D
, "debug_mv"},
601 {"mb_qmin", "obsolete, use qmin", OFFSET(mb_qmin
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
602 {"mb_qmax", "obsolete, use qmax", OFFSET(mb_qmax
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
603 {"cmp", "full pel me compare function", OFFSET(me_cmp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
604 {"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
605 {"mbcmp", "macroblock compare function", OFFSET(mb_cmp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
606 {"ildctcmp", "interlaced dct compare function", OFFSET(ildct_cmp
), FF_OPT_TYPE_INT
, FF_CMP_VSAD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
607 {"dia_size", "diamond type & size for motion estimation", OFFSET(dia_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
608 {"last_pred", "amount of motion predictors from the previous frame", OFFSET(last_predictor_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
609 {"preme", "pre motion estimation", OFFSET(pre_me
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
610 {"precmp", "pre motion estimation compare function", OFFSET(me_pre_cmp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
611 {"sad", "sum of absolute differences, fast (default)", 0, FF_OPT_TYPE_CONST
, FF_CMP_SAD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
612 {"sse", "sum of squared errors", 0, FF_OPT_TYPE_CONST
, FF_CMP_SSE
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
613 {"satd", "sum of absolute Hadamard transformed differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_SATD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
614 {"dct", "sum of absolute DCT transformed differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_DCT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
615 {"psnr", "sum of squared quantization errors (avoid, low quality)", 0, FF_OPT_TYPE_CONST
, FF_CMP_PSNR
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
616 {"bit", "number of bits needed for the block", 0, FF_OPT_TYPE_CONST
, FF_CMP_BIT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
617 {"rd", "rate distortion optimal, slow", 0, FF_OPT_TYPE_CONST
, FF_CMP_RD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
618 {"zero", "0", 0, FF_OPT_TYPE_CONST
, FF_CMP_ZERO
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
619 {"vsad", "sum of absolute vertical differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_VSAD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
620 {"vsse","sum of squared vertical differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_VSSE
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
621 {"nsse", "noise preserving sum of squared differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_NSSE
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
622 #ifdef CONFIG_SNOW_ENCODER
623 {"w53", "5/3 wavelet, only used in snow", 0, FF_OPT_TYPE_CONST
, FF_CMP_W53
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
624 {"w97", "9/7 wavelet, only used in snow", 0, FF_OPT_TYPE_CONST
, FF_CMP_W97
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
626 {"dctmax", NULL
, 0, FF_OPT_TYPE_CONST
, FF_CMP_DCTMAX
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
627 {"chroma", NULL
, 0, FF_OPT_TYPE_CONST
, FF_CMP_CHROMA
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
628 {"pre_dia_size", "diamond type & size for motion estimation pre-pass", OFFSET(pre_dia_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
629 {"subq", "sub pel motion estimation quality", OFFSET(me_subpel_quality
), FF_OPT_TYPE_INT
, 8, INT_MIN
, INT_MAX
, V
|E
},
630 {"dtg_active_format", NULL
, OFFSET(dtg_active_format
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
631 {"me_range", "limit motion vectors range (1023 for DivX player)", OFFSET(me_range
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
632 {"ibias", "intra quant bias", OFFSET(intra_quant_bias
), FF_OPT_TYPE_INT
, FF_DEFAULT_QUANT_BIAS
, INT_MIN
, INT_MAX
, V
|E
},
633 {"pbias", "inter quant bias", OFFSET(inter_quant_bias
), FF_OPT_TYPE_INT
, FF_DEFAULT_QUANT_BIAS
, INT_MIN
, INT_MAX
, V
|E
},
634 {"color_table_id", NULL
, OFFSET(color_table_id
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
635 {"internal_buffer_count", NULL
, OFFSET(internal_buffer_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
636 {"global_quality", NULL
, OFFSET(global_quality
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
637 {"coder", NULL
, OFFSET(coder_type
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
638 {"vlc", "variable length coder / huffman coder", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_VLC
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
639 {"ac", "arithmetic coder", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_AC
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
640 {"raw", "raw (no encoding)", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_RAW
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
641 {"rle", "run-length coder", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_RLE
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
642 {"deflate", "deflate-based coder", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_DEFLATE
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
643 {"context", "context model", OFFSET(context_model
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
644 {"slice_flags", NULL
, OFFSET(slice_flags
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
645 {"xvmc_acceleration", NULL
, OFFSET(xvmc_acceleration
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
646 {"mbd", "macroblock decision algorithm (high quality mode)", OFFSET(mb_decision
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "mbd"},
647 {"simple", "use mbcmp (default)", 0, FF_OPT_TYPE_CONST
, FF_MB_DECISION_SIMPLE
, INT_MIN
, INT_MAX
, V
|E
, "mbd"},
648 {"bits", "use fewest bits", 0, FF_OPT_TYPE_CONST
, FF_MB_DECISION_BITS
, INT_MIN
, INT_MAX
, V
|E
, "mbd"},
649 {"rd", "use best rate distortion", 0, FF_OPT_TYPE_CONST
, FF_MB_DECISION_RD
, INT_MIN
, INT_MAX
, V
|E
, "mbd"},
650 {"stream_codec_tag", NULL
, OFFSET(stream_codec_tag
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
651 {"sc_threshold", "scene change threshold", OFFSET(scenechange_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
652 {"lmin", "min lagrange factor (VBR)", OFFSET(lmin
), FF_OPT_TYPE_INT
, 2*FF_QP2LAMBDA
, 0, INT_MAX
, V
|E
},
653 {"lmax", "max lagrange factor (VBR)", OFFSET(lmax
), FF_OPT_TYPE_INT
, 31*FF_QP2LAMBDA
, 0, INT_MAX
, V
|E
},
654 {"nr", "noise reduction", OFFSET(noise_reduction
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
655 {"rc_init_occupancy", "number of bits which should be loaded into the rc buffer before decoding starts", OFFSET(rc_initial_buffer_occupancy
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
656 {"inter_threshold", NULL
, OFFSET(inter_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
657 {"flags2", NULL
, OFFSET(flags2
), FF_OPT_TYPE_FLAGS
, CODEC_FLAG2_FASTPSKIP
|CODEC_FLAG2_BIT_RESERVOIR
, 0, UINT_MAX
, V
|A
|E
|D
, "flags2"},
658 {"error", NULL
, OFFSET(error_rate
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
659 {"antialias", "MP3 antialias algorithm", OFFSET(antialias_algo
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
660 {"auto", NULL
, 0, FF_OPT_TYPE_CONST
, FF_AA_AUTO
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
661 {"fastint", NULL
, 0, FF_OPT_TYPE_CONST
, FF_AA_FASTINT
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
662 {"int", NULL
, 0, FF_OPT_TYPE_CONST
, FF_AA_INT
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
663 {"float", NULL
, 0, FF_OPT_TYPE_CONST
, FF_AA_FLOAT
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
664 {"qns", "quantizer noise shaping", OFFSET(quantizer_noise_shaping
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
665 {"threads", NULL
, OFFSET(thread_count
), FF_OPT_TYPE_INT
, 1, INT_MIN
, INT_MAX
, V
|E
|D
},
666 {"me_threshold", "motion estimaton threshold", OFFSET(me_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
667 {"mb_threshold", "macroblock threshold", OFFSET(mb_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
668 {"dc", "intra_dc_precision", OFFSET(intra_dc_precision
), FF_OPT_TYPE_INT
, 0, INT_MIN
, INT_MAX
, V
|E
},
669 {"nssew", "nsse weight", OFFSET(nsse_weight
), FF_OPT_TYPE_INT
, 8, INT_MIN
, INT_MAX
, V
|E
},
670 {"skip_top", "number of macroblock rows at the top which are skipped", OFFSET(skip_top
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|D
},
671 {"skip_bottom", "number of macroblock rows at the bottom which are skipped", OFFSET(skip_bottom
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|D
},
672 {"profile", NULL
, OFFSET(profile
), FF_OPT_TYPE_INT
, FF_PROFILE_UNKNOWN
, INT_MIN
, INT_MAX
, V
|A
|E
, "profile"},
673 {"unknown", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_UNKNOWN
, INT_MIN
, INT_MAX
, V
|A
|E
, "profile"},
674 {"aac_main", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_AAC_MAIN
, INT_MIN
, INT_MAX
, A
|E
, "profile"},
675 {"aac_low", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_AAC_LOW
, INT_MIN
, INT_MAX
, A
|E
, "profile"},
676 {"aac_ssr", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_AAC_SSR
, INT_MIN
, INT_MAX
, A
|E
, "profile"},
677 {"aac_ltp", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_AAC_LTP
, INT_MIN
, INT_MAX
, A
|E
, "profile"},
678 {"level", NULL
, OFFSET(level
), FF_OPT_TYPE_INT
, FF_LEVEL_UNKNOWN
, INT_MIN
, INT_MAX
, V
|A
|E
, "level"},
679 {"unknown", NULL
, 0, FF_OPT_TYPE_CONST
, FF_LEVEL_UNKNOWN
, INT_MIN
, INT_MAX
, V
|A
|E
, "level"},
680 {"lowres", "decode at 1= 1/2, 2=1/4, 3=1/8 resolutions", OFFSET(lowres
), FF_OPT_TYPE_INT
, 0, 0, INT_MAX
, V
|D
},
681 {"skip_threshold", "frame skip threshold", OFFSET(frame_skip_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
682 {"skip_factor", "frame skip factor", OFFSET(frame_skip_factor
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
683 {"skip_exp", "frame skip exponent", OFFSET(frame_skip_exp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
684 {"skipcmp", "frame skip compare function", OFFSET(frame_skip_cmp
), FF_OPT_TYPE_INT
, FF_CMP_DCTMAX
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
685 {"border_mask", "increases the quantizer for macroblocks close to borders", OFFSET(border_masking
), FF_OPT_TYPE_FLOAT
, DEFAULT
, -FLT_MAX
, FLT_MAX
, V
|E
},
686 {"mblmin", "min macroblock lagrange factor (VBR)", OFFSET(mb_lmin
), FF_OPT_TYPE_INT
, FF_QP2LAMBDA
* 2, 1, FF_LAMBDA_MAX
, V
|E
},
687 {"mblmax", "max macroblock lagrange factor (VBR)", OFFSET(mb_lmax
), FF_OPT_TYPE_INT
, FF_QP2LAMBDA
* 31, 1, FF_LAMBDA_MAX
, V
|E
},
688 {"mepc", "motion estimation bitrate penalty compensation (1.0 = 256)", OFFSET(me_penalty_compensation
), FF_OPT_TYPE_INT
, 256, INT_MIN
, INT_MAX
, V
|E
},
689 {"skip_loop_filter", NULL
, OFFSET(skip_loop_filter
), FF_OPT_TYPE_INT
, AVDISCARD_DEFAULT
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
690 {"skip_idct" , NULL
, OFFSET(skip_idct
) , FF_OPT_TYPE_INT
, AVDISCARD_DEFAULT
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
691 {"skip_frame" , NULL
, OFFSET(skip_frame
) , FF_OPT_TYPE_INT
, AVDISCARD_DEFAULT
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
692 {"none" , NULL
, 0, FF_OPT_TYPE_CONST
, AVDISCARD_NONE
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
693 {"default" , NULL
, 0, FF_OPT_TYPE_CONST
, AVDISCARD_DEFAULT
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
694 {"noref" , NULL
, 0, FF_OPT_TYPE_CONST
, AVDISCARD_NONREF
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
695 {"bidir" , NULL
, 0, FF_OPT_TYPE_CONST
, AVDISCARD_BIDIR
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
696 {"nokey" , NULL
, 0, FF_OPT_TYPE_CONST
, AVDISCARD_NONKEY
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
697 {"all" , NULL
, 0, FF_OPT_TYPE_CONST
, AVDISCARD_ALL
, INT_MIN
, INT_MAX
, V
|D
, "avdiscard"},
698 {"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine
), FF_OPT_TYPE_INT
, DEFAULT
, 0, 4, V
|E
},
699 {"brd_scale", "downscales frames for dynamic B-frame decision", OFFSET(brd_scale
), FF_OPT_TYPE_INT
, DEFAULT
, 0, 10, V
|E
},
700 {"crf", "enables constant quality mode, and selects the quality (x264)", OFFSET(crf
), FF_OPT_TYPE_FLOAT
, DEFAULT
, 0, 51, V
|E
},
701 {"cqp", "constant quantization parameter rate control method", OFFSET(cqp
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, V
|E
},
702 {"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min
), FF_OPT_TYPE_INT
, 25, INT_MIN
, INT_MAX
, V
|E
},
703 {"refs", "reference frames to consider for motion compensation (Snow)", OFFSET(refs
), FF_OPT_TYPE_INT
, 1, INT_MIN
, INT_MAX
, V
|E
},
704 {"chromaoffset", "chroma qp offset from luma", OFFSET(chromaoffset
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
705 {"bframebias", "influences how often B-frames are used", OFFSET(bframebias
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
706 {"trellis", "rate-distortion optimal quantization", OFFSET(trellis
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|A
|E
},
707 {"directpred", "direct mv prediction mode - 0 (none), 1 (spatial), 2 (temporal), 3 (auto)", OFFSET(directpred
), FF_OPT_TYPE_INT
, 2, INT_MIN
, INT_MAX
, V
|E
},
708 {"bpyramid", "allows B-frames to be used as references for predicting", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_BPYRAMID
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
709 {"wpred", "weighted biprediction for b-frames (H.264)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_WPRED
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
710 {"mixed_refs", "one reference per partition, as opposed to one reference per macroblock", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_MIXED_REFS
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
711 {"dct8x8", "high profile 8x8 transform (H.264)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_8X8DCT
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
712 {"fastpskip", "fast pskip (H.264)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_FASTPSKIP
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
713 {"aud", "access unit delimiters (H.264)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_AUD
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
714 {"skiprd", "RD optimal MB level residual skipping", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_SKIP_RD
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
715 {"complexityblur", "reduce fluctuations in qp (before curve compression)", OFFSET(complexityblur
), FF_OPT_TYPE_FLOAT
, 20.0, FLT_MIN
, FLT_MAX
, V
|E
},
716 {"deblockalpha", "in-loop deblocking filter alphac0 parameter", OFFSET(deblockalpha
), FF_OPT_TYPE_INT
, DEFAULT
, -6, 6, V
|E
},
717 {"deblockbeta", "in-loop deblocking filter beta parameter", OFFSET(deblockbeta
), FF_OPT_TYPE_INT
, DEFAULT
, -6, 6, V
|E
},
718 {"partitions", "macroblock subpartition sizes to consider", OFFSET(partitions
), FF_OPT_TYPE_FLAGS
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
719 {"parti4x4", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_I4X4
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
720 {"parti8x8", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_I8X8
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
721 {"partp4x4", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_P4X4
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
722 {"partp8x8", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_P8X8
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
723 {"partb8x8", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_B8X8
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
724 {"sc_factor", "multiplied by qscale for each frame and added to scene_change_score", OFFSET(scenechange_factor
), FF_OPT_TYPE_INT
, 6, 0, INT_MAX
, V
|E
},
725 {"mv0_threshold", NULL
, OFFSET(mv0_threshold
), FF_OPT_TYPE_INT
, 256, 0, INT_MAX
, V
|E
},
726 {"ivlc", "intra vlc table", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_INTRA_VLC
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
727 {"b_sensitivity", "adjusts sensitivity of b_frame_strategy 1", OFFSET(b_sensitivity
), FF_OPT_TYPE_INT
, 40, 1, INT_MAX
, V
|E
},
728 {"compression_level", NULL
, OFFSET(compression_level
), FF_OPT_TYPE_INT
, FF_COMPRESSION_DEFAULT
, INT_MIN
, INT_MAX
, V
|A
|E
},
729 {"use_lpc", "sets whether to use LPC mode (FLAC)", OFFSET(use_lpc
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
730 {"lpc_coeff_precision", "LPC coefficient precision (FLAC)", OFFSET(lpc_coeff_precision
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, A
|E
},
731 {"min_prediction_order", NULL
, OFFSET(min_prediction_order
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
732 {"max_prediction_order", NULL
, OFFSET(max_prediction_order
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
733 {"prediction_order_method", "search method for selecting prediction order", OFFSET(prediction_order_method
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
734 {"min_partition_order", NULL
, OFFSET(min_partition_order
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
735 {"max_partition_order", NULL
, OFFSET(max_partition_order
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
736 {"timecode_frame_start", "GOP timecode frame start number, in non drop frame format", OFFSET(timecode_frame_start
), FF_OPT_TYPE_INT
, 0, 0, INT_MAX
, V
|E
},
737 {"drop_frame_timecode", NULL
, 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_DROP_FRAME_TIMECODE
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
738 {"non_linear_q", "use non linear quantizer", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_NON_LINEAR_QUANT
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
739 {"request_channels", "set desired number of audio channels", OFFSET(request_channels
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, A
|D
},
740 {"drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale
), FF_OPT_TYPE_FLOAT
, 1.0, 0.0, 1.0, A
|D
},
741 {"reservoir", "use bit reservoir", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_BIT_RESERVOIR
, INT_MIN
, INT_MAX
, A
|E
, "flags2"},
742 {"bits_per_raw_sample", NULL
, OFFSET(bits_per_raw_sample
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
753 static const AVClass av_codec_context_class
= { "AVCodecContext", context_to_name
, options
};
755 void avcodec_get_context_defaults2(AVCodecContext
*s
, enum CodecType codec_type
){
757 memset(s
, 0, sizeof(AVCodecContext
));
759 s
->av_class
= &av_codec_context_class
;
761 s
->codec_type
= codec_type
;
762 if(codec_type
== CODEC_TYPE_AUDIO
)
763 flags
= AV_OPT_FLAG_AUDIO_PARAM
;
764 else if(codec_type
== CODEC_TYPE_VIDEO
)
765 flags
= AV_OPT_FLAG_VIDEO_PARAM
;
766 else if(codec_type
== CODEC_TYPE_SUBTITLE
)
767 flags
= AV_OPT_FLAG_SUBTITLE_PARAM
;
768 av_opt_set_defaults2(s
, flags
, flags
);
770 s
->time_base
= (AVRational
){0,1};
771 s
->get_buffer
= avcodec_default_get_buffer
;
772 s
->release_buffer
= avcodec_default_release_buffer
;
773 s
->get_format
= avcodec_default_get_format
;
774 s
->execute
= avcodec_default_execute
;
775 s
->sample_aspect_ratio
= (AVRational
){0,1};
776 s
->pix_fmt
= PIX_FMT_NONE
;
777 s
->sample_fmt
= SAMPLE_FMT_S16
; // FIXME: set to NONE
780 s
->reget_buffer
= avcodec_default_reget_buffer
;
783 AVCodecContext
*avcodec_alloc_context2(enum CodecType codec_type
){
784 AVCodecContext
*avctx
= av_malloc(sizeof(AVCodecContext
));
786 if(avctx
==NULL
) return NULL
;
788 avcodec_get_context_defaults2(avctx
, codec_type
);
793 void avcodec_get_context_defaults(AVCodecContext
*s
){
794 avcodec_get_context_defaults2(s
, CODEC_TYPE_UNKNOWN
);
797 AVCodecContext
*avcodec_alloc_context(void){
798 return avcodec_alloc_context2(CODEC_TYPE_UNKNOWN
);
801 void avcodec_get_frame_defaults(AVFrame
*pic
){
802 memset(pic
, 0, sizeof(AVFrame
));
804 pic
->pts
= AV_NOPTS_VALUE
;
808 AVFrame
*avcodec_alloc_frame(void){
809 AVFrame
*pic
= av_malloc(sizeof(AVFrame
));
811 if(pic
==NULL
) return NULL
;
813 avcodec_get_frame_defaults(pic
);
818 int attribute_align_arg
avcodec_open(AVCodecContext
*avctx
, AVCodec
*codec
)
822 entangled_thread_counter
++;
823 if(entangled_thread_counter
!= 1){
824 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
828 if(avctx
->codec
|| !codec
)
831 if (codec
->priv_data_size
> 0) {
832 avctx
->priv_data
= av_mallocz(codec
->priv_data_size
);
833 if (!avctx
->priv_data
) {
834 ret
= AVERROR(ENOMEM
);
838 avctx
->priv_data
= NULL
;
841 if(avctx
->coded_width
&& avctx
->coded_height
)
842 avcodec_set_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
);
843 else if(avctx
->width
&& avctx
->height
)
844 avcodec_set_dimensions(avctx
, avctx
->width
, avctx
->height
);
846 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
)){
847 av_freep(&avctx
->priv_data
);
848 ret
= AVERROR(EINVAL
);
852 avctx
->codec
= codec
;
853 avctx
->codec_id
= codec
->id
;
854 avctx
->frame_number
= 0;
855 if(avctx
->codec
->init
){
856 ret
= avctx
->codec
->init(avctx
);
858 av_freep(&avctx
->priv_data
);
865 entangled_thread_counter
--;
869 int attribute_align_arg
avcodec_encode_audio(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
870 const short *samples
)
872 if(buf_size
< FF_MIN_BUFFER_SIZE
&& 0){
873 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
876 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || samples
){
877 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, (void *)samples
);
878 avctx
->frame_number
++;
884 int attribute_align_arg
avcodec_encode_video(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
887 if(buf_size
< FF_MIN_BUFFER_SIZE
){
888 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
891 if(avcodec_check_dimensions(avctx
,avctx
->width
,avctx
->height
))
893 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || pict
){
894 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, (void *)pict
);
895 avctx
->frame_number
++;
896 emms_c(); //needed to avoid an emms_c() call before every return;
903 int avcodec_encode_subtitle(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
904 const AVSubtitle
*sub
)
907 ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, (void *)sub
);
908 avctx
->frame_number
++;
912 int attribute_align_arg
avcodec_decode_video(AVCodecContext
*avctx
, AVFrame
*picture
,
913 int *got_picture_ptr
,
914 const uint8_t *buf
, int buf_size
)
919 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
))
921 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || buf_size
){
922 ret
= avctx
->codec
->decode(avctx
, picture
, got_picture_ptr
,
925 emms_c(); //needed to avoid an emms_c() call before every return;
927 if (*got_picture_ptr
)
928 avctx
->frame_number
++;
935 int attribute_align_arg
avcodec_decode_audio2(AVCodecContext
*avctx
, int16_t *samples
,
937 const uint8_t *buf
, int buf_size
)
941 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || buf_size
){
942 //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
943 if(*frame_size_ptr
< AVCODEC_MAX_AUDIO_FRAME_SIZE
){
944 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
947 if(*frame_size_ptr
< FF_MIN_BUFFER_SIZE
||
948 *frame_size_ptr
< avctx
->channels
* avctx
->frame_size
* sizeof(int16_t)){
949 av_log(avctx
, AV_LOG_ERROR
, "buffer %d too small\n", *frame_size_ptr
);
953 ret
= avctx
->codec
->decode(avctx
, samples
, frame_size_ptr
,
955 avctx
->frame_number
++;
963 int avcodec_decode_subtitle(AVCodecContext
*avctx
, AVSubtitle
*sub
,
965 const uint8_t *buf
, int buf_size
)
970 ret
= avctx
->codec
->decode(avctx
, sub
, got_sub_ptr
,
973 avctx
->frame_number
++;
977 int avcodec_close(AVCodecContext
*avctx
)
979 entangled_thread_counter
++;
980 if(entangled_thread_counter
!= 1){
981 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
982 entangled_thread_counter
--;
986 if (ENABLE_THREADS
&& avctx
->thread_opaque
)
987 avcodec_thread_free(avctx
);
988 if (avctx
->codec
->close
)
989 avctx
->codec
->close(avctx
);
990 avcodec_default_free_buffers(avctx
);
991 av_freep(&avctx
->priv_data
);
993 entangled_thread_counter
--;
997 AVCodec
*avcodec_find_encoder(enum CodecID id
)
1002 if (p
->encode
!= NULL
&& p
->id
== id
)
1009 AVCodec
*avcodec_find_encoder_by_name(const char *name
)
1016 if (p
->encode
!= NULL
&& strcmp(name
,p
->name
) == 0)
1023 AVCodec
*avcodec_find_decoder(enum CodecID id
)
1028 if (p
->decode
!= NULL
&& p
->id
== id
)
1035 AVCodec
*avcodec_find_decoder_by_name(const char *name
)
1042 if (p
->decode
!= NULL
&& strcmp(name
,p
->name
) == 0)
1049 void avcodec_string(char *buf
, int buf_size
, AVCodecContext
*enc
, int encode
)
1051 const char *codec_name
;
1054 char channels_str
[100];
1056 AVRational display_aspect_ratio
;
1059 p
= avcodec_find_encoder(enc
->codec_id
);
1061 p
= avcodec_find_decoder(enc
->codec_id
);
1064 codec_name
= p
->name
;
1065 if (!encode
&& enc
->codec_id
== CODEC_ID_MP3
) {
1066 if (enc
->sub_id
== 2)
1068 else if (enc
->sub_id
== 1)
1071 } else if (enc
->codec_id
== CODEC_ID_MPEG2TS
) {
1072 /* fake mpeg2 transport stream codec (currently not
1074 codec_name
= "mpeg2ts";
1075 } else if (enc
->codec_name
[0] != '\0') {
1076 codec_name
= enc
->codec_name
;
1078 /* output avi tags */
1079 if( isprint(enc
->codec_tag
&0xFF) && isprint((enc
->codec_tag
>>8)&0xFF)
1080 && isprint((enc
->codec_tag
>>16)&0xFF) && isprint((enc
->codec_tag
>>24)&0xFF)){
1081 snprintf(buf1
, sizeof(buf1
), "%c%c%c%c / 0x%04X",
1082 enc
->codec_tag
& 0xff,
1083 (enc
->codec_tag
>> 8) & 0xff,
1084 (enc
->codec_tag
>> 16) & 0xff,
1085 (enc
->codec_tag
>> 24) & 0xff,
1088 snprintf(buf1
, sizeof(buf1
), "0x%04x", enc
->codec_tag
);
1093 switch(enc
->codec_type
) {
1094 case CODEC_TYPE_VIDEO
:
1095 snprintf(buf
, buf_size
,
1097 codec_name
, enc
->mb_decision
? " (hq)" : "");
1098 if (enc
->pix_fmt
!= PIX_FMT_NONE
) {
1099 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1101 avcodec_get_pix_fmt_name(enc
->pix_fmt
));
1104 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1106 enc
->width
, enc
->height
);
1107 if (enc
->sample_aspect_ratio
.num
) {
1108 av_reduce(&display_aspect_ratio
.num
, &display_aspect_ratio
.den
,
1109 enc
->width
*enc
->sample_aspect_ratio
.num
,
1110 enc
->height
*enc
->sample_aspect_ratio
.den
,
1112 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1113 " [PAR %d:%d DAR %d:%d]",
1114 enc
->sample_aspect_ratio
.num
, enc
->sample_aspect_ratio
.den
,
1115 display_aspect_ratio
.num
, display_aspect_ratio
.den
);
1117 if(av_log_get_level() >= AV_LOG_DEBUG
){
1118 int g
= ff_gcd(enc
->time_base
.num
, enc
->time_base
.den
);
1119 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1121 enc
->time_base
.num
/g
, enc
->time_base
.den
/g
);
1125 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1126 ", q=%d-%d", enc
->qmin
, enc
->qmax
);
1128 bitrate
= enc
->bit_rate
;
1130 case CODEC_TYPE_AUDIO
:
1131 snprintf(buf
, buf_size
,
1134 switch (enc
->channels
) {
1136 strcpy(channels_str
, "mono");
1139 strcpy(channels_str
, "stereo");
1142 strcpy(channels_str
, "5:1");
1145 snprintf(channels_str
, sizeof(channels_str
), "%d channels", enc
->channels
);
1148 if (enc
->sample_rate
) {
1149 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1154 if (enc
->sample_fmt
!= SAMPLE_FMT_NONE
) {
1155 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1156 ", %s", avcodec_get_sample_fmt_name(enc
->sample_fmt
));
1159 /* for PCM codecs, compute bitrate directly */
1160 switch(enc
->codec_id
) {
1161 case CODEC_ID_PCM_F64BE
:
1162 case CODEC_ID_PCM_F64LE
:
1163 bitrate
= enc
->sample_rate
* enc
->channels
* 64;
1165 case CODEC_ID_PCM_S32LE
:
1166 case CODEC_ID_PCM_S32BE
:
1167 case CODEC_ID_PCM_U32LE
:
1168 case CODEC_ID_PCM_U32BE
:
1169 case CODEC_ID_PCM_F32BE
:
1170 case CODEC_ID_PCM_F32LE
:
1171 bitrate
= enc
->sample_rate
* enc
->channels
* 32;
1173 case CODEC_ID_PCM_S24LE
:
1174 case CODEC_ID_PCM_S24BE
:
1175 case CODEC_ID_PCM_U24LE
:
1176 case CODEC_ID_PCM_U24BE
:
1177 case CODEC_ID_PCM_S24DAUD
:
1178 bitrate
= enc
->sample_rate
* enc
->channels
* 24;
1180 case CODEC_ID_PCM_S16LE
:
1181 case CODEC_ID_PCM_S16BE
:
1182 case CODEC_ID_PCM_S16LE_PLANAR
:
1183 case CODEC_ID_PCM_U16LE
:
1184 case CODEC_ID_PCM_U16BE
:
1185 bitrate
= enc
->sample_rate
* enc
->channels
* 16;
1187 case CODEC_ID_PCM_S8
:
1188 case CODEC_ID_PCM_U8
:
1189 case CODEC_ID_PCM_ALAW
:
1190 case CODEC_ID_PCM_MULAW
:
1191 case CODEC_ID_PCM_ZORK
:
1192 bitrate
= enc
->sample_rate
* enc
->channels
* 8;
1195 bitrate
= enc
->bit_rate
;
1199 case CODEC_TYPE_DATA
:
1200 snprintf(buf
, buf_size
, "Data: %s", codec_name
);
1201 bitrate
= enc
->bit_rate
;
1203 case CODEC_TYPE_SUBTITLE
:
1204 snprintf(buf
, buf_size
, "Subtitle: %s", codec_name
);
1205 bitrate
= enc
->bit_rate
;
1207 case CODEC_TYPE_ATTACHMENT
:
1208 snprintf(buf
, buf_size
, "Attachment: %s", codec_name
);
1209 bitrate
= enc
->bit_rate
;
1212 snprintf(buf
, buf_size
, "Invalid Codec type %d", enc
->codec_type
);
1216 if (enc
->flags
& CODEC_FLAG_PASS1
)
1217 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1219 if (enc
->flags
& CODEC_FLAG_PASS2
)
1220 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1224 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1225 ", %d kb/s", bitrate
/ 1000);
1229 unsigned avcodec_version( void )
1231 return LIBAVCODEC_VERSION_INT
;
1234 void avcodec_init(void)
1236 static int initialized
= 0;
1238 if (initialized
!= 0)
1242 dsputil_static_init();
1245 void avcodec_flush_buffers(AVCodecContext
*avctx
)
1247 if(avctx
->codec
->flush
)
1248 avctx
->codec
->flush(avctx
);
1251 void avcodec_default_free_buffers(AVCodecContext
*s
){
1254 if(s
->internal_buffer
==NULL
) return;
1256 for(i
=0; i
<INTERNAL_BUFFER_SIZE
; i
++){
1257 InternalBuffer
*buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
1259 av_freep(&buf
->base
[j
]);
1263 av_freep(&s
->internal_buffer
);
1265 s
->internal_buffer_count
=0;
1268 char av_get_pict_type_char(int pict_type
){
1270 case FF_I_TYPE
: return 'I';
1271 case FF_P_TYPE
: return 'P';
1272 case FF_B_TYPE
: return 'B';
1273 case FF_S_TYPE
: return 'S';
1274 case FF_SI_TYPE
:return 'i';
1275 case FF_SP_TYPE
:return 'p';
1276 case FF_BI_TYPE
:return 'b';
1277 default: return '?';
1281 int av_get_bits_per_sample(enum CodecID codec_id
){
1283 case CODEC_ID_ADPCM_SBPRO_2
:
1285 case CODEC_ID_ADPCM_SBPRO_3
:
1287 case CODEC_ID_ADPCM_SBPRO_4
:
1288 case CODEC_ID_ADPCM_CT
:
1290 case CODEC_ID_PCM_ALAW
:
1291 case CODEC_ID_PCM_MULAW
:
1292 case CODEC_ID_PCM_S8
:
1293 case CODEC_ID_PCM_U8
:
1294 case CODEC_ID_PCM_ZORK
:
1296 case CODEC_ID_PCM_S16BE
:
1297 case CODEC_ID_PCM_S16LE
:
1298 case CODEC_ID_PCM_S16LE_PLANAR
:
1299 case CODEC_ID_PCM_U16BE
:
1300 case CODEC_ID_PCM_U16LE
:
1302 case CODEC_ID_PCM_S24DAUD
:
1303 case CODEC_ID_PCM_S24BE
:
1304 case CODEC_ID_PCM_S24LE
:
1305 case CODEC_ID_PCM_U24BE
:
1306 case CODEC_ID_PCM_U24LE
:
1308 case CODEC_ID_PCM_S32BE
:
1309 case CODEC_ID_PCM_S32LE
:
1310 case CODEC_ID_PCM_U32BE
:
1311 case CODEC_ID_PCM_U32LE
:
1312 case CODEC_ID_PCM_F32BE
:
1313 case CODEC_ID_PCM_F32LE
:
1315 case CODEC_ID_PCM_F64BE
:
1316 case CODEC_ID_PCM_F64LE
:
1323 int av_get_bits_per_sample_format(enum SampleFormat sample_fmt
) {
1324 switch (sample_fmt
) {
1327 case SAMPLE_FMT_S16
:
1329 case SAMPLE_FMT_S32
:
1330 case SAMPLE_FMT_FLT
:
1332 case SAMPLE_FMT_DBL
:
1339 #if !defined(HAVE_THREADS)
1340 int avcodec_thread_init(AVCodecContext
*s
, int thread_count
){
1345 unsigned int av_xiphlacing(unsigned char *s
, unsigned int v
)
1359 /* Wrapper to work around the lack of mkstemp() on mingw/cygin.
1360 * Also, tries to create file in /tmp first, if possible.
1361 * *prefix can be a character constant; *filename will be allocated internally.
1362 * Returns file descriptor of opened file (or -1 on error)
1363 * and opened file name in **filename. */
1364 int av_tempfile(char *prefix
, char **filename
) {
1366 #if !defined(HAVE_MKSTEMP)
1367 *filename
= tempnam(".", prefix
);
1369 size_t len
= strlen(prefix
) + 12; /* room for "/tmp/" and "XXXXXX\0" */
1370 *filename
= av_malloc(len
);
1372 /* -----common section-----*/
1373 if (*filename
== NULL
) {
1374 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot allocate file name\n");
1377 #if !defined(HAVE_MKSTEMP)
1378 fd
= open(*filename
, O_RDWR
| O_BINARY
| O_CREAT
, 0444);
1380 snprintf(*filename
, len
, "/tmp/%sXXXXXX", prefix
);
1381 fd
= mkstemp(*filename
);
1383 snprintf(*filename
, len
, "./%sXXXXXX", prefix
);
1384 fd
= mkstemp(*filename
);
1387 /* -----common section-----*/
1389 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot open temporary file %s\n", *filename
);
1392 return fd
; /* success */
1398 } VideoFrameSizeAbbr
;
1402 int rate_num
, rate_den
;
1403 } VideoFrameRateAbbr
;
1405 static const VideoFrameSizeAbbr video_frame_size_abbrs
[] = {
1406 { "ntsc", 720, 480 },
1407 { "pal", 720, 576 },
1408 { "qntsc", 352, 240 }, /* VCD compliant NTSC */
1409 { "qpal", 352, 288 }, /* VCD compliant PAL */
1410 { "sntsc", 640, 480 }, /* square pixel NTSC */
1411 { "spal", 768, 576 }, /* square pixel PAL */
1412 { "film", 352, 240 },
1413 { "ntsc-film", 352, 240 },
1414 { "sqcif", 128, 96 },
1415 { "qcif", 176, 144 },
1416 { "cif", 352, 288 },
1417 { "4cif", 704, 576 },
1418 { "qqvga", 160, 120 },
1419 { "qvga", 320, 240 },
1420 { "vga", 640, 480 },
1421 { "svga", 800, 600 },
1422 { "xga", 1024, 768 },
1423 { "uxga", 1600,1200 },
1424 { "qxga", 2048,1536 },
1425 { "sxga", 1280,1024 },
1426 { "qsxga", 2560,2048 },
1427 { "hsxga", 5120,4096 },
1428 { "wvga", 852, 480 },
1429 { "wxga", 1366, 768 },
1430 { "wsxga", 1600,1024 },
1431 { "wuxga", 1920,1200 },
1432 { "woxga", 2560,1600 },
1433 { "wqsxga", 3200,2048 },
1434 { "wquxga", 3840,2400 },
1435 { "whsxga", 6400,4096 },
1436 { "whuxga", 7680,4800 },
1437 { "cga", 320, 200 },
1438 { "ega", 640, 350 },
1439 { "hd480", 852, 480 },
1440 { "hd720", 1280, 720 },
1441 { "hd1080", 1920,1080 },
1444 static const VideoFrameRateAbbr video_frame_rate_abbrs
[]= {
1445 { "ntsc", 30000, 1001 },
1447 { "qntsc", 30000, 1001 }, /* VCD compliant NTSC */
1448 { "qpal", 25, 1 }, /* VCD compliant PAL */
1449 { "sntsc", 30000, 1001 }, /* square pixel NTSC */
1450 { "spal", 25, 1 }, /* square pixel PAL */
1452 { "ntsc-film", 24000, 1001 },
1455 int av_parse_video_frame_size(int *width_ptr
, int *height_ptr
, const char *str
)
1458 int n
= FF_ARRAY_ELEMS(video_frame_size_abbrs
);
1460 int frame_width
= 0, frame_height
= 0;
1463 if (!strcmp(video_frame_size_abbrs
[i
].abbr
, str
)) {
1464 frame_width
= video_frame_size_abbrs
[i
].width
;
1465 frame_height
= video_frame_size_abbrs
[i
].height
;
1471 frame_width
= strtol(p
, (char **)&p
, 10);
1474 frame_height
= strtol(p
, (char **)&p
, 10);
1476 if (frame_width
<= 0 || frame_height
<= 0)
1478 *width_ptr
= frame_width
;
1479 *height_ptr
= frame_height
;
1483 int av_parse_video_frame_rate(AVRational
*frame_rate
, const char *arg
)
1486 int n
= FF_ARRAY_ELEMS(video_frame_rate_abbrs
);
1489 /* First, we check our abbreviation table */
1490 for (i
= 0; i
< n
; ++i
)
1491 if (!strcmp(video_frame_rate_abbrs
[i
].abbr
, arg
)) {
1492 frame_rate
->num
= video_frame_rate_abbrs
[i
].rate_num
;
1493 frame_rate
->den
= video_frame_rate_abbrs
[i
].rate_den
;
1497 /* Then, we try to parse it as fraction */
1498 cp
= strchr(arg
, '/');
1500 cp
= strchr(arg
, ':');
1503 frame_rate
->num
= strtol(arg
, &cpp
, 10);
1504 if (cpp
!= arg
|| cpp
== cp
)
1505 frame_rate
->den
= strtol(cp
+1, &cpp
, 10);
1507 frame_rate
->num
= 0;
1510 /* Finally we give up and parse it as double */
1511 AVRational time_base
= av_d2q(strtod(arg
, 0), 1001000);
1512 frame_rate
->den
= time_base
.den
;
1513 frame_rate
->num
= time_base
.num
;
1515 if (!frame_rate
->num
|| !frame_rate
->den
)
1521 void av_log_missing_feature(void *avc
, const char *feature
, int want_sample
)
1523 av_log(avc
, AV_LOG_WARNING
, "%s not implemented. Update your FFmpeg "
1524 "version to the newest one from SVN. If the problem still "
1525 "occurs, it means that your file has a feature which has not "
1526 "been implemented.", feature
);
1528 av_log(avc
, AV_LOG_WARNING
, " If you want to help, upload a sample "
1529 "of this file to ftp://upload.mplayerhq.hu/MPlayer/incoming/ "
1530 "and contact the FFmpeg-devel mailing list.");
1531 av_log(avc
, AV_LOG_WARNING
, "\n");