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 #include "libavutil/integer.h"
29 #include "libavutil/crc.h"
33 #include "imgconvert.h"
37 #if !defined(HAVE_MKSTEMP)
41 const uint8_t ff_reverse
[256]={
42 0x00,0x80,0x40,0xC0,0x20,0xA0,0x60,0xE0,0x10,0x90,0x50,0xD0,0x30,0xB0,0x70,0xF0,
43 0x08,0x88,0x48,0xC8,0x28,0xA8,0x68,0xE8,0x18,0x98,0x58,0xD8,0x38,0xB8,0x78,0xF8,
44 0x04,0x84,0x44,0xC4,0x24,0xA4,0x64,0xE4,0x14,0x94,0x54,0xD4,0x34,0xB4,0x74,0xF4,
45 0x0C,0x8C,0x4C,0xCC,0x2C,0xAC,0x6C,0xEC,0x1C,0x9C,0x5C,0xDC,0x3C,0xBC,0x7C,0xFC,
46 0x02,0x82,0x42,0xC2,0x22,0xA2,0x62,0xE2,0x12,0x92,0x52,0xD2,0x32,0xB2,0x72,0xF2,
47 0x0A,0x8A,0x4A,0xCA,0x2A,0xAA,0x6A,0xEA,0x1A,0x9A,0x5A,0xDA,0x3A,0xBA,0x7A,0xFA,
48 0x06,0x86,0x46,0xC6,0x26,0xA6,0x66,0xE6,0x16,0x96,0x56,0xD6,0x36,0xB6,0x76,0xF6,
49 0x0E,0x8E,0x4E,0xCE,0x2E,0xAE,0x6E,0xEE,0x1E,0x9E,0x5E,0xDE,0x3E,0xBE,0x7E,0xFE,
50 0x01,0x81,0x41,0xC1,0x21,0xA1,0x61,0xE1,0x11,0x91,0x51,0xD1,0x31,0xB1,0x71,0xF1,
51 0x09,0x89,0x49,0xC9,0x29,0xA9,0x69,0xE9,0x19,0x99,0x59,0xD9,0x39,0xB9,0x79,0xF9,
52 0x05,0x85,0x45,0xC5,0x25,0xA5,0x65,0xE5,0x15,0x95,0x55,0xD5,0x35,0xB5,0x75,0xF5,
53 0x0D,0x8D,0x4D,0xCD,0x2D,0xAD,0x6D,0xED,0x1D,0x9D,0x5D,0xDD,0x3D,0xBD,0x7D,0xFD,
54 0x03,0x83,0x43,0xC3,0x23,0xA3,0x63,0xE3,0x13,0x93,0x53,0xD3,0x33,0xB3,0x73,0xF3,
55 0x0B,0x8B,0x4B,0xCB,0x2B,0xAB,0x6B,0xEB,0x1B,0x9B,0x5B,0xDB,0x3B,0xBB,0x7B,0xFB,
56 0x07,0x87,0x47,0xC7,0x27,0xA7,0x67,0xE7,0x17,0x97,0x57,0xD7,0x37,0xB7,0x77,0xF7,
57 0x0F,0x8F,0x4F,0xCF,0x2F,0xAF,0x6F,0xEF,0x1F,0x9F,0x5F,0xDF,0x3F,0xBF,0x7F,0xFF,
60 static int volatile entangled_thread_counter
=0;
62 void *av_fast_realloc(void *ptr
, unsigned int *size
, unsigned int min_size
)
67 *size
= FFMAX(17*min_size
/16 + 32, min_size
);
69 ptr
= av_realloc(ptr
, *size
);
70 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
76 /* encoder management */
77 AVCodec
*first_avcodec
= NULL
;
79 AVCodec
*av_codec_next(AVCodec
*c
){
81 else return first_avcodec
;
84 void register_avcodec(AVCodec
*format
)
88 while (*p
!= NULL
) p
= &(*p
)->next
;
93 void avcodec_set_dimensions(AVCodecContext
*s
, int width
, int height
){
94 s
->coded_width
= width
;
95 s
->coded_height
= height
;
96 s
->width
= -((-width
)>>s
->lowres
);
97 s
->height
= -((-height
)>>s
->lowres
);
100 typedef struct InternalBuffer
{
106 enum PixelFormat pix_fmt
;
109 #define INTERNAL_BUFFER_SIZE 32
111 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
113 void avcodec_align_dimensions(AVCodecContext
*s
, int *width
, int *height
){
118 case PIX_FMT_YUV420P
:
119 case PIX_FMT_YUYV422
:
120 case PIX_FMT_UYVY422
:
121 case PIX_FMT_YUV422P
:
122 case PIX_FMT_YUV444P
:
124 case PIX_FMT_GRAY16BE
:
125 case PIX_FMT_GRAY16LE
:
126 case PIX_FMT_YUVJ420P
:
127 case PIX_FMT_YUVJ422P
:
128 case PIX_FMT_YUVJ444P
:
129 case PIX_FMT_YUVA420P
:
130 w_align
= 16; //FIXME check for non mpeg style codecs and use less alignment
133 case PIX_FMT_YUV411P
:
134 case PIX_FMT_UYYVYY411
:
138 case PIX_FMT_YUV410P
:
139 if(s
->codec_id
== CODEC_ID_SVQ1
){
144 if(s
->codec_id
== CODEC_ID_RPZA
){
149 if(s
->codec_id
== CODEC_ID_SMC
){
155 if((s
->codec_id
== CODEC_ID_MSZH
) || (s
->codec_id
== CODEC_ID_ZLIB
)){
166 *width
= ALIGN(*width
, w_align
);
167 *height
= ALIGN(*height
, h_align
);
170 int avcodec_check_dimensions(void *av_log_ctx
, unsigned int w
, unsigned int h
){
171 if((int)w
>0 && (int)h
>0 && (w
+128)*(uint64_t)(h
+128) < INT_MAX
/4)
174 av_log(av_log_ctx
, AV_LOG_ERROR
, "picture size invalid (%ux%u)\n", w
, h
);
178 int avcodec_default_get_buffer(AVCodecContext
*s
, AVFrame
*pic
){
185 if(pic
->data
[0]!=NULL
) {
186 av_log(s
, AV_LOG_ERROR
, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
189 if(s
->internal_buffer_count
>= INTERNAL_BUFFER_SIZE
) {
190 av_log(s
, AV_LOG_ERROR
, "internal_buffer_count overflow (missing release_buffer?)\n");
194 if(avcodec_check_dimensions(s
,w
,h
))
197 if(s
->internal_buffer
==NULL
){
198 s
->internal_buffer
= av_mallocz(INTERNAL_BUFFER_SIZE
*sizeof(InternalBuffer
));
201 s
->internal_buffer
= av_fast_realloc(
203 &s
->internal_buffer_size
,
204 sizeof(InternalBuffer
)*FFMAX(99, s
->internal_buffer_count
+1)/*FIXME*/
208 buf
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
209 picture_number
= &(((InternalBuffer
*)s
->internal_buffer
)[INTERNAL_BUFFER_SIZE
-1]).last_pic_num
; //FIXME ugly hack
212 if(buf
->base
[0] && (buf
->width
!= w
|| buf
->height
!= h
|| buf
->pix_fmt
!= s
->pix_fmt
)){
214 av_freep(&buf
->base
[i
]);
220 pic
->age
= *picture_number
- buf
->last_pic_num
;
221 buf
->last_pic_num
= *picture_number
;
223 int h_chroma_shift
, v_chroma_shift
;
228 avcodec_get_chroma_sub_sample(s
->pix_fmt
, &h_chroma_shift
, &v_chroma_shift
);
230 avcodec_align_dimensions(s
, &w
, &h
);
232 if(!(s
->flags
&CODEC_FLAG_EMU_EDGE
)){
236 avcodec_align_dimensions(s
, &w
, &h
);
238 ff_fill_linesize(&picture
, s
->pix_fmt
, w
);
241 picture
.linesize
[i
] = ALIGN(picture
.linesize
[i
], STRIDE_ALIGN
);
243 tmpsize
= ff_fill_pointer(&picture
, NULL
, s
->pix_fmt
, h
);
245 for (i
=0; i
<3 && picture
.data
[i
+1]; i
++)
246 size
[i
] = picture
.data
[i
+1] - picture
.data
[i
];
247 size
[i
] = tmpsize
- (picture
.data
[i
] - picture
.data
[0]);
249 buf
->last_pic_num
= -256*256*256*64;
250 memset(buf
->base
, 0, sizeof(buf
->base
));
251 memset(buf
->data
, 0, sizeof(buf
->data
));
253 for(i
=0; i
<4 && size
[i
]; i
++){
254 const int h_shift
= i
==0 ? 0 : h_chroma_shift
;
255 const int v_shift
= i
==0 ? 0 : v_chroma_shift
;
257 buf
->linesize
[i
]= picture
.linesize
[i
];
259 buf
->base
[i
]= av_malloc(size
[i
]+16); //FIXME 16
260 if(buf
->base
[i
]==NULL
) return -1;
261 memset(buf
->base
[i
], 128, size
[i
]);
263 // no edge if EDEG EMU or not planar YUV, we check for PAL8 redundantly to protect against a exploitable bug regression ...
264 if((s
->flags
&CODEC_FLAG_EMU_EDGE
) || (s
->pix_fmt
== PIX_FMT_PAL8
) || !size
[2])
265 buf
->data
[i
] = buf
->base
[i
];
267 buf
->data
[i
] = buf
->base
[i
] + ALIGN((buf
->linesize
[i
]*EDGE_WIDTH
>>v_shift
) + (EDGE_WIDTH
>>h_shift
), STRIDE_ALIGN
);
269 buf
->width
= s
->width
;
270 buf
->height
= s
->height
;
271 buf
->pix_fmt
= s
->pix_fmt
;
272 pic
->age
= 256*256*256*64;
274 pic
->type
= FF_BUFFER_TYPE_INTERNAL
;
277 pic
->base
[i
]= buf
->base
[i
];
278 pic
->data
[i
]= buf
->data
[i
];
279 pic
->linesize
[i
]= buf
->linesize
[i
];
281 s
->internal_buffer_count
++;
286 void avcodec_default_release_buffer(AVCodecContext
*s
, AVFrame
*pic
){
288 InternalBuffer
*buf
, *last
;
290 assert(pic
->type
==FF_BUFFER_TYPE_INTERNAL
);
291 assert(s
->internal_buffer_count
);
293 buf
= NULL
; /* avoids warning */
294 for(i
=0; i
<s
->internal_buffer_count
; i
++){ //just 3-5 checks so is not worth to optimize
295 buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
296 if(buf
->data
[0] == pic
->data
[0])
299 assert(i
< s
->internal_buffer_count
);
300 s
->internal_buffer_count
--;
301 last
= &((InternalBuffer
*)s
->internal_buffer
)[s
->internal_buffer_count
];
303 FFSWAP(InternalBuffer
, *buf
, *last
);
307 // pic->base[i]=NULL;
309 //printf("R%X\n", pic->opaque);
312 int avcodec_default_reget_buffer(AVCodecContext
*s
, AVFrame
*pic
){
316 /* If no picture return a new buffer */
317 if(pic
->data
[0] == NULL
) {
318 /* We will copy from buffer, so must be readable */
319 pic
->buffer_hints
|= FF_BUFFER_HINTS_READABLE
;
320 return s
->get_buffer(s
, pic
);
323 /* If internal buffer type return the same buffer */
324 if(pic
->type
== FF_BUFFER_TYPE_INTERNAL
)
328 * Not internal type and reget_buffer not overridden, emulate cr buffer
331 for(i
= 0; i
< 4; i
++)
332 pic
->data
[i
] = pic
->base
[i
] = NULL
;
334 /* Allocate new frame */
335 if (s
->get_buffer(s
, pic
))
337 /* Copy image data from old buffer to new buffer */
338 av_picture_copy((AVPicture
*)pic
, (AVPicture
*)&temp_pic
, s
->pix_fmt
, s
->width
,
340 s
->release_buffer(s
, &temp_pic
); // Release old frame
344 int avcodec_default_execute(AVCodecContext
*c
, int (*func
)(AVCodecContext
*c2
, void *arg2
),void **arg
, int *ret
, int count
){
347 for(i
=0; i
<count
; i
++){
348 int r
= func(c
, arg
[i
]);
354 enum PixelFormat
avcodec_default_get_format(struct AVCodecContext
*s
, const enum PixelFormat
* fmt
){
358 static const char* context_to_name(void* ptr
) {
359 AVCodecContext
*avc
= ptr
;
361 if(avc
&& avc
->codec
&& avc
->codec
->name
)
362 return avc
->codec
->name
;
367 #define OFFSET(x) offsetof(AVCodecContext,x)
368 #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
369 //these names are too long to be readable
370 #define V AV_OPT_FLAG_VIDEO_PARAM
371 #define A AV_OPT_FLAG_AUDIO_PARAM
372 #define S AV_OPT_FLAG_SUBTITLE_PARAM
373 #define E AV_OPT_FLAG_ENCODING_PARAM
374 #define D AV_OPT_FLAG_DECODING_PARAM
376 #define AV_CODEC_DEFAULT_BITRATE 200*1000
378 static const AVOption options
[]={
379 {"b", "set bitrate (in bits/s)", OFFSET(bit_rate
), FF_OPT_TYPE_INT
, AV_CODEC_DEFAULT_BITRATE
, INT_MIN
, INT_MAX
, V
|E
},
380 {"ab", "set bitrate (in bits/s)", OFFSET(bit_rate
), FF_OPT_TYPE_INT
, 64*1000, INT_MIN
, INT_MAX
, A
|E
},
381 {"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
},
382 {"flags", NULL
, OFFSET(flags
), FF_OPT_TYPE_FLAGS
, DEFAULT
, 0, UINT_MAX
, V
|A
|E
|D
, "flags"},
383 {"mv4", "use four motion vector by macroblock (mpeg4)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_4MV
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
384 {"obmc", "use overlapped block motion compensation (h263+)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_OBMC
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
385 {"qpel", "use 1/4 pel motion compensation", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_QPEL
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
386 {"loop", "use loop filter", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_LOOP_FILTER
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
387 {"qscale", "use fixed qscale", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_QSCALE
, INT_MIN
, INT_MAX
, 0, "flags"},
388 {"gmc", "use gmc", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_GMC
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
389 {"mv0", "always try a mb with mv=<0,0>", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_MV0
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
390 {"part", "use data partitioning", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_PART
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
391 {"input_preserved", NULL
, 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_INPUT_PRESERVED
, INT_MIN
, INT_MAX
, 0, "flags"},
392 {"pass1", "use internal 2pass ratecontrol in first pass mode", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_PASS1
, INT_MIN
, INT_MAX
, 0, "flags"},
393 {"pass2", "use internal 2pass ratecontrol in second pass mode", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_PASS2
, INT_MIN
, INT_MAX
, 0, "flags"},
394 {"extern_huff", "use external huffman table (for mjpeg)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_EXTERN_HUFF
, INT_MIN
, INT_MAX
, 0, "flags"},
395 {"gray", "only decode/encode grayscale", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_GRAY
, INT_MIN
, INT_MAX
, V
|E
|D
, "flags"},
396 {"emu_edge", "don't draw edges", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_EMU_EDGE
, INT_MIN
, INT_MAX
, 0, "flags"},
397 {"psnr", "error[?] variables will be set during encoding", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_PSNR
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
398 {"truncated", NULL
, 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_TRUNCATED
, INT_MIN
, INT_MAX
, 0, "flags"},
399 {"naq", "normalize adaptive quantization", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_NORMALIZE_AQP
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
400 {"ildct", "use interlaced dct", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_INTERLACED_DCT
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
401 {"low_delay", "force low delay", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_LOW_DELAY
, INT_MIN
, INT_MAX
, V
|D
|E
, "flags"},
402 {"alt", "enable alternate scantable (mpeg2/mpeg4)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_ALT_SCAN
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
403 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
404 {"trell", "use trellis quantization", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_TRELLIS_QUANT
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
406 {"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"},
407 {"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"},
408 {"aic", "h263 advanced intra coding / mpeg4 ac prediction", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_AC_PRED
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
409 {"umv", "use unlimited motion vectors", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_H263P_UMV
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
410 {"cbp", "use rate distortion optimization for cbp", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_CBP_RD
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
411 {"qprd", "use rate distortion optimization for qp selection", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_QP_RD
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
412 {"aiv", "h263 alternative inter vlc", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_H263P_AIV
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
413 {"slice", NULL
, 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_H263P_SLICE_STRUCT
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
414 {"ilme", "interlaced motion estimation", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_INTERLACED_ME
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
415 {"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"},
416 {"cgop", "closed gop", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG_CLOSED_GOP
, INT_MIN
, INT_MAX
, V
|E
, "flags"},
417 {"fast", "allow non spec compliant speedup tricks", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_FAST
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
418 {"sgop", "strictly enforce gop size", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_STRICT_GOP
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
419 {"noout", "skip bitstream encoding", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_NO_OUTPUT
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
420 {"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"},
421 {"sub_id", NULL
, OFFSET(sub_id
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
422 {"me_method", "set motion estimation method", OFFSET(me_method
), FF_OPT_TYPE_INT
, ME_EPZS
, INT_MIN
, INT_MAX
, V
|E
, "me_method"},
423 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
424 {"me", "set motion estimation method (deprecated, use me_method instead)", OFFSET(me_method
), FF_OPT_TYPE_INT
, ME_EPZS
, INT_MIN
, INT_MAX
, V
|E
, "me_method"},
426 {"zero", "zero motion estimation (fastest)", 0, FF_OPT_TYPE_CONST
, ME_ZERO
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
427 {"full", "full motion estimation (slowest)", 0, FF_OPT_TYPE_CONST
, ME_FULL
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
428 {"epzs", "EPZS motion estimation (default)", 0, FF_OPT_TYPE_CONST
, ME_EPZS
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
429 {"esa", "esa motion estimation (alias for full)", 0, FF_OPT_TYPE_CONST
, ME_FULL
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
430 {"tesa", "tesa motion estimation", 0, FF_OPT_TYPE_CONST
, ME_TESA
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
431 {"dia", "dia motion estimation (alias for epzs)", 0, FF_OPT_TYPE_CONST
, ME_EPZS
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
432 {"log", "log motion estimation", 0, FF_OPT_TYPE_CONST
, ME_LOG
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
433 {"phods", "phods motion estimation", 0, FF_OPT_TYPE_CONST
, ME_PHODS
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
434 {"x1", "X1 motion estimation", 0, FF_OPT_TYPE_CONST
, ME_X1
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
435 {"hex", "hex motion estimation", 0, FF_OPT_TYPE_CONST
, ME_HEX
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
436 {"umh", "umh motion estimation", 0, FF_OPT_TYPE_CONST
, ME_UMH
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
437 {"iter", "iter motion estimation", 0, FF_OPT_TYPE_CONST
, ME_ITER
, INT_MIN
, INT_MAX
, V
|E
, "me_method" },
438 {"extradata_size", NULL
, OFFSET(extradata_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
439 {"time_base", NULL
, OFFSET(time_base
), FF_OPT_TYPE_RATIONAL
, DEFAULT
, INT_MIN
, INT_MAX
},
440 {"g", "set the group of picture size", OFFSET(gop_size
), FF_OPT_TYPE_INT
, 12, INT_MIN
, INT_MAX
, V
|E
},
441 {"rate_emu", "frame rate emulation", OFFSET(rate_emu
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
442 {"ar", "set audio sampling rate (in Hz)", OFFSET(sample_rate
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
443 {"ac", "set number of audio channels", OFFSET(channels
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
444 {"cutoff", "set cutoff bandwidth", OFFSET(cutoff
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, A
|E
},
445 {"frame_size", NULL
, OFFSET(frame_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, A
|E
},
446 {"frame_number", NULL
, OFFSET(frame_number
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
447 {"real_pict_num", NULL
, OFFSET(real_pict_num
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
448 {"delay", NULL
, OFFSET(delay
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
449 {"qcomp", "video quantizer scale compression (VBR)", OFFSET(qcompress
), FF_OPT_TYPE_FLOAT
, 0.5, FLT_MIN
, FLT_MAX
, V
|E
},
450 {"qblur", "video quantizer scale blur (VBR)", OFFSET(qblur
), FF_OPT_TYPE_FLOAT
, 0.5, FLT_MIN
, FLT_MAX
, V
|E
},
451 {"qmin", "min video quantizer scale (VBR)", OFFSET(qmin
), FF_OPT_TYPE_INT
, 2, 1, 51, V
|E
},
452 {"qmax", "max video quantizer scale (VBR)", OFFSET(qmax
), FF_OPT_TYPE_INT
, 31, 1, 51, V
|E
},
453 {"qdiff", "max difference between the quantizer scale (VBR)", OFFSET(max_qdiff
), FF_OPT_TYPE_INT
, 3, INT_MIN
, INT_MAX
, V
|E
},
454 {"bf", "use 'frames' B frames", OFFSET(max_b_frames
), FF_OPT_TYPE_INT
, DEFAULT
, 0, FF_MAX_B_FRAMES
, V
|E
},
455 {"b_qfactor", "qp factor between p and b frames", OFFSET(b_quant_factor
), FF_OPT_TYPE_FLOAT
, 1.25, FLT_MIN
, FLT_MAX
, V
|E
},
456 {"rc_strategy", "ratecontrol method", OFFSET(rc_strategy
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
457 {"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
},
458 {"hurry_up", NULL
, OFFSET(hurry_up
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|D
},
459 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
460 {"rtp_mode", NULL
, OFFSET(rtp_mode
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
462 {"ps", "rtp payload size in bits", OFFSET(rtp_payload_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
463 {"mv_bits", NULL
, OFFSET(mv_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
464 {"header_bits", NULL
, OFFSET(header_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
465 {"i_tex_bits", NULL
, OFFSET(i_tex_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
466 {"p_tex_bits", NULL
, OFFSET(p_tex_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
467 {"i_count", NULL
, OFFSET(i_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
468 {"p_count", NULL
, OFFSET(p_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
469 {"skip_count", NULL
, OFFSET(skip_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
470 {"misc_bits", NULL
, OFFSET(misc_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
471 {"frame_bits", NULL
, OFFSET(frame_bits
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
472 {"codec_tag", NULL
, OFFSET(codec_tag
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
473 {"bug", "workaround not auto detected encoder bugs", OFFSET(workaround_bugs
), FF_OPT_TYPE_FLAGS
, FF_BUG_AUTODETECT
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
474 {"autodetect", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_AUTODETECT
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
475 {"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"},
476 {"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"},
477 {"ump4", "(autodetected if fourcc==UMP4)", 0, FF_OPT_TYPE_CONST
, FF_BUG_UMP4
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
478 {"no_padding", "padding bug (autodetected)", 0, FF_OPT_TYPE_CONST
, FF_BUG_NO_PADDING
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
479 {"amv", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_AMV
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
480 {"ac_vlc", "illegal vlc bug (autodetected per fourcc)", 0, FF_OPT_TYPE_CONST
, FF_BUG_AC_VLC
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
481 {"qpel_chroma", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_QPEL_CHROMA
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
482 {"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"},
483 {"qpel_chroma2", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_QPEL_CHROMA2
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
484 {"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"},
485 {"edge", "edge padding bug (autodetected per fourcc/version)", 0, FF_OPT_TYPE_CONST
, FF_BUG_EDGE
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
486 {"hpel_chroma", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_HPEL_CHROMA
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
487 {"dc_clip", NULL
, 0, FF_OPT_TYPE_CONST
, FF_BUG_DC_CLIP
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
488 {"ms", "workaround various bugs in microsofts broken decoders", 0, FF_OPT_TYPE_CONST
, FF_BUG_MS
, INT_MIN
, INT_MAX
, V
|D
, "bug"},
489 {"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
},
490 {"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
},
491 {"strict", "how strictly to follow the standards", OFFSET(strict_std_compliance
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, A
|V
|D
, "strict"},
492 {"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
|E
, "strict"},
493 {"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
|E
, "strict"},
494 {"normal", NULL
, 0, FF_OPT_TYPE_CONST
, FF_COMPLIANCE_NORMAL
, INT_MIN
, INT_MAX
, V
|E
, "strict"},
495 {"inofficial", "allow inofficial extensions", 0, FF_OPT_TYPE_CONST
, FF_COMPLIANCE_INOFFICIAL
, INT_MIN
, INT_MAX
, V
|E
, "strict"},
496 {"experimental", "allow non standardized experimental things", 0, FF_OPT_TYPE_CONST
, FF_COMPLIANCE_EXPERIMENTAL
, INT_MIN
, INT_MAX
, V
|E
, "strict"},
497 {"b_qoffset", "qp offset between P and B frames", OFFSET(b_quant_offset
), FF_OPT_TYPE_FLOAT
, 1.25, FLT_MIN
, FLT_MAX
, V
|E
},
498 {"er", "set error resilience strategy", OFFSET(error_resilience
), FF_OPT_TYPE_INT
, FF_ER_CAREFUL
, INT_MIN
, INT_MAX
, A
|V
|D
, "er"},
499 {"careful", NULL
, 0, FF_OPT_TYPE_CONST
, FF_ER_CAREFUL
, INT_MIN
, INT_MAX
, V
|D
, "er"},
500 {"compliant", NULL
, 0, FF_OPT_TYPE_CONST
, FF_ER_COMPLIANT
, INT_MIN
, INT_MAX
, V
|D
, "er"},
501 {"aggressive", NULL
, 0, FF_OPT_TYPE_CONST
, FF_ER_AGGRESSIVE
, INT_MIN
, INT_MAX
, V
|D
, "er"},
502 {"very_aggressive", NULL
, 0, FF_OPT_TYPE_CONST
, FF_ER_VERY_AGGRESSIVE
, INT_MIN
, INT_MAX
, V
|D
, "er"},
503 {"has_b_frames", NULL
, OFFSET(has_b_frames
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
504 {"block_align", NULL
, OFFSET(block_align
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
505 {"parse_only", NULL
, OFFSET(parse_only
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
506 {"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
507 {"stats_out", NULL
, OFFSET(stats_out
), FF_OPT_TYPE_STRING
, DEFAULT
, CHAR_MIN
, CHAR_MAX
},
508 {"stats_in", NULL
, OFFSET(stats_in
), FF_OPT_TYPE_STRING
, DEFAULT
, CHAR_MIN
, CHAR_MAX
},
509 {"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
},
510 {"rc_qmod_amp", "experimental quantizer modulation", OFFSET(rc_qmod_amp
), FF_OPT_TYPE_FLOAT
, DEFAULT
, -FLT_MAX
, FLT_MAX
, V
|E
},
511 {"rc_qmod_freq", "experimental quantizer modulation", OFFSET(rc_qmod_freq
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
512 {"rc_override_count", NULL
, OFFSET(rc_override_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
513 {"rc_eq", "set rate control equation", OFFSET(rc_eq
), FF_OPT_TYPE_STRING
, DEFAULT
, CHAR_MIN
, CHAR_MAX
, V
|E
},
514 {"maxrate", "set max video bitrate tolerance (in bits/s)", OFFSET(rc_max_rate
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
515 {"minrate", "set min video bitrate tolerance (in bits/s)", OFFSET(rc_min_rate
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
516 {"bufsize", "set ratecontrol buffer size (in bits)", OFFSET(rc_buffer_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, A
|V
|E
},
517 {"rc_buf_aggressivity", "currently useless", OFFSET(rc_buffer_aggressivity
), FF_OPT_TYPE_FLOAT
, 1.0, FLT_MIN
, FLT_MAX
, V
|E
},
518 {"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
},
519 {"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
},
520 {"rc_init_cplx", "initial complexity for 1-pass encoding", OFFSET(rc_initial_cplx
), FF_OPT_TYPE_FLOAT
, DEFAULT
, -FLT_MAX
, FLT_MAX
, V
|E
},
521 {"dct", "DCT algorithm", OFFSET(dct_algo
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, V
|E
, "dct"},
522 {"auto", "autoselect a good one (default)", 0, FF_OPT_TYPE_CONST
, FF_DCT_AUTO
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
523 {"fastint", "fast integer", 0, FF_OPT_TYPE_CONST
, FF_DCT_FASTINT
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
524 {"int", "accurate integer", 0, FF_OPT_TYPE_CONST
, FF_DCT_INT
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
525 {"mmx", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DCT_MMX
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
526 {"mlib", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DCT_MLIB
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
527 {"altivec", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DCT_ALTIVEC
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
528 {"faan", "floating point AAN DCT", 0, FF_OPT_TYPE_CONST
, FF_DCT_FAAN
, INT_MIN
, INT_MAX
, V
|E
, "dct"},
529 {"lumi_mask", "compresses bright areas stronger than medium ones", OFFSET(lumi_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
530 {"tcplx_mask", "temporal complexity masking", OFFSET(temporal_cplx_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
531 {"scplx_mask", "spatial complexity masking", OFFSET(spatial_cplx_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
532 {"p_mask", "inter masking", OFFSET(p_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
533 {"dark_mask", "compresses dark areas stronger than medium ones", OFFSET(dark_masking
), FF_OPT_TYPE_FLOAT
, 0, -FLT_MAX
, FLT_MAX
, V
|E
},
534 {"unused", NULL
, OFFSET(unused
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
535 {"idct", "select IDCT implementation", OFFSET(idct_algo
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, V
|E
|D
, "idct"},
536 {"auto", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_AUTO
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
537 {"int", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_INT
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
538 {"simple", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLE
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
539 {"simplemmx", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLEMMX
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
540 {"libmpeg2mmx", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_LIBMPEG2MMX
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
541 {"ps2", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_PS2
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
542 {"mlib", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_MLIB
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
543 {"arm", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_ARM
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
544 {"altivec", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_ALTIVEC
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
545 {"sh4", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SH4
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
546 {"simplearm", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLEARM
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
547 {"simplearmv5te", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLEARMV5TE
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
548 {"simplearmv6", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_SIMPLEARMV6
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
549 {"h264", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_H264
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
550 {"vp3", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_VP3
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
551 {"ipp", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_IPP
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
552 {"xvidmmx", NULL
, 0, FF_OPT_TYPE_CONST
, FF_IDCT_XVIDMMX
, INT_MIN
, INT_MAX
, V
|E
|D
, "idct"},
553 {"faani", "floating point AAN IDCT", 0, FF_OPT_TYPE_CONST
, FF_IDCT_FAAN
, INT_MIN
, INT_MAX
, V
|D
|E
, "idct"},
554 {"slice_count", NULL
, OFFSET(slice_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
555 {"ec", "set error concealment strategy", OFFSET(error_concealment
), FF_OPT_TYPE_FLAGS
, 3, INT_MIN
, INT_MAX
, V
|D
, "ec"},
556 {"guess_mvs", "iterative motion vector (MV) search (slow)", 0, FF_OPT_TYPE_CONST
, FF_EC_GUESS_MVS
, INT_MIN
, INT_MAX
, V
|D
, "ec"},
557 {"deblock", "use strong deblock filter for damaged MBs", 0, FF_OPT_TYPE_CONST
, FF_EC_DEBLOCK
, INT_MIN
, INT_MAX
, V
|D
, "ec"},
558 {"bits_per_sample", NULL
, OFFSET(bits_per_sample
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
559 {"pred", "prediction method", OFFSET(prediction_method
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "pred"},
560 {"left", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PRED_LEFT
, INT_MIN
, INT_MAX
, V
|E
, "pred"},
561 {"plane", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PRED_PLANE
, INT_MIN
, INT_MAX
, V
|E
, "pred"},
562 {"median", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PRED_MEDIAN
, INT_MIN
, INT_MAX
, V
|E
, "pred"},
563 {"aspect", "sample aspect ratio", OFFSET(sample_aspect_ratio
), FF_OPT_TYPE_RATIONAL
, DEFAULT
, 0, 10, V
|E
},
564 {"debug", "print specific debug info", OFFSET(debug
), FF_OPT_TYPE_FLAGS
, DEFAULT
, 0, INT_MAX
, V
|A
|S
|E
|D
, "debug"},
565 {"pict", "picture info", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_PICT_INFO
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
566 {"rc", "rate control", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_RC
, INT_MIN
, INT_MAX
, V
|E
, "debug"},
567 {"bitstream", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_BITSTREAM
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
568 {"mb_type", "macroblock (MB) type", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_MB_TYPE
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
569 {"qp", "per-block quantization parameter (QP)", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_QP
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
570 {"mv", "motion vector", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_MV
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
571 {"dct_coeff", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_DCT_COEFF
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
572 {"skip", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_SKIP
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
573 {"startcode", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_STARTCODE
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
574 {"pts", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_PTS
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
575 {"er", "error resilience", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_ER
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
576 {"mmco", "memory management control operations (H.264)", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_MMCO
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
577 {"bugs", NULL
, 0, FF_OPT_TYPE_CONST
, FF_DEBUG_BUGS
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
578 {"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"},
579 {"vis_mb_type", "visualize block types", 0, FF_OPT_TYPE_CONST
, FF_DEBUG_VIS_MB_TYPE
, INT_MIN
, INT_MAX
, V
|D
, "debug"},
580 {"vismv", "visualize motion vectors (MVs)", OFFSET(debug_mv
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, V
|D
, "debug_mv"},
581 {"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"},
582 {"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"},
583 {"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"},
584 {"mb_qmin", "obsolete, use qmin", OFFSET(mb_qmin
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
585 {"mb_qmax", "obsolete, use qmax", OFFSET(mb_qmax
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
586 {"cmp", "full pel me compare function", OFFSET(me_cmp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
587 {"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
588 {"mbcmp", "macroblock compare function", OFFSET(mb_cmp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
589 {"ildctcmp", "interlaced dct compare function", OFFSET(ildct_cmp
), FF_OPT_TYPE_INT
, FF_CMP_VSAD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
590 {"dia_size", "diamond type & size for motion estimation", OFFSET(dia_size
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
591 {"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
},
592 {"preme", "pre motion estimation", OFFSET(pre_me
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
593 {"precmp", "pre motion estimation compare function", OFFSET(me_pre_cmp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
594 {"sad", "sum of absolute differences, fast (default)", 0, FF_OPT_TYPE_CONST
, FF_CMP_SAD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
595 {"sse", "sum of squared errors", 0, FF_OPT_TYPE_CONST
, FF_CMP_SSE
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
596 {"satd", "sum of absolute Hadamard transformed differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_SATD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
597 {"dct", "sum of absolute DCT transformed differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_DCT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
598 {"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"},
599 {"bit", "number of bits needed for the block", 0, FF_OPT_TYPE_CONST
, FF_CMP_BIT
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
600 {"rd", "rate distortion optimal, slow", 0, FF_OPT_TYPE_CONST
, FF_CMP_RD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
601 {"zero", "0", 0, FF_OPT_TYPE_CONST
, FF_CMP_ZERO
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
602 {"vsad", "sum of absolute vertical differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_VSAD
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
603 {"vsse","sum of squared vertical differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_VSSE
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
604 {"nsse", "noise preserving sum of squared differences", 0, FF_OPT_TYPE_CONST
, FF_CMP_NSSE
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
605 #ifdef CONFIG_SNOW_ENCODER
606 {"w53", "5/3 wavelet, only used in snow", 0, FF_OPT_TYPE_CONST
, FF_CMP_W53
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
607 {"w97", "9/7 wavelet, only used in snow", 0, FF_OPT_TYPE_CONST
, FF_CMP_W97
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
609 {"dctmax", NULL
, 0, FF_OPT_TYPE_CONST
, FF_CMP_DCTMAX
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
610 {"chroma", NULL
, 0, FF_OPT_TYPE_CONST
, FF_CMP_CHROMA
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
611 {"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
},
612 {"subq", "sub pel motion estimation quality", OFFSET(me_subpel_quality
), FF_OPT_TYPE_INT
, 8, INT_MIN
, INT_MAX
, V
|E
},
613 {"dtg_active_format", NULL
, OFFSET(dtg_active_format
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
614 {"me_range", "limit motion vectors range (1023 for DivX player)", OFFSET(me_range
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
615 {"ibias", "intra quant bias", OFFSET(intra_quant_bias
), FF_OPT_TYPE_INT
, FF_DEFAULT_QUANT_BIAS
, INT_MIN
, INT_MAX
, V
|E
},
616 {"pbias", "inter quant bias", OFFSET(inter_quant_bias
), FF_OPT_TYPE_INT
, FF_DEFAULT_QUANT_BIAS
, INT_MIN
, INT_MAX
, V
|E
},
617 {"color_table_id", NULL
, OFFSET(color_table_id
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
618 {"internal_buffer_count", NULL
, OFFSET(internal_buffer_count
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
619 {"global_quality", NULL
, OFFSET(global_quality
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
620 {"coder", NULL
, OFFSET(coder_type
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
621 {"vlc", "variable length coder / huffman coder", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_VLC
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
622 {"ac", "arithmetic coder", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_AC
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
623 {"raw", "raw (no encoding)", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_RAW
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
624 {"rle", "run-length coder", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_RLE
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
625 {"deflate", "deflate-based coder", 0, FF_OPT_TYPE_CONST
, FF_CODER_TYPE_DEFLATE
, INT_MIN
, INT_MAX
, V
|E
, "coder"},
626 {"context", "context model", OFFSET(context_model
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
627 {"slice_flags", NULL
, OFFSET(slice_flags
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
628 {"xvmc_acceleration", NULL
, OFFSET(xvmc_acceleration
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
629 {"mbd", "macroblock decision algorithm (high quality mode)", OFFSET(mb_decision
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "mbd"},
630 {"simple", "use mbcmp (default)", 0, FF_OPT_TYPE_CONST
, FF_MB_DECISION_SIMPLE
, INT_MIN
, INT_MAX
, V
|E
, "mbd"},
631 {"bits", "use fewest bits", 0, FF_OPT_TYPE_CONST
, FF_MB_DECISION_BITS
, INT_MIN
, INT_MAX
, V
|E
, "mbd"},
632 {"rd", "use best rate distortion", 0, FF_OPT_TYPE_CONST
, FF_MB_DECISION_RD
, INT_MIN
, INT_MAX
, V
|E
, "mbd"},
633 {"stream_codec_tag", NULL
, OFFSET(stream_codec_tag
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
634 {"sc_threshold", "scene change threshold", OFFSET(scenechange_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
635 {"lmin", "min lagrange factor (VBR)", OFFSET(lmin
), FF_OPT_TYPE_INT
, 2*FF_QP2LAMBDA
, 0, INT_MAX
, V
|E
},
636 {"lmax", "max lagrange factor (VBR)", OFFSET(lmax
), FF_OPT_TYPE_INT
, 31*FF_QP2LAMBDA
, 0, INT_MAX
, V
|E
},
637 {"nr", "noise reduction", OFFSET(noise_reduction
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
638 {"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
},
639 {"inter_threshold", NULL
, OFFSET(inter_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
640 {"flags2", NULL
, OFFSET(flags2
), FF_OPT_TYPE_FLAGS
, CODEC_FLAG2_FASTPSKIP
|CODEC_FLAG2_BIT_RESERVOIR
, 0, UINT_MAX
, V
|A
|E
|D
, "flags2"},
641 {"error", NULL
, OFFSET(error_rate
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
642 {"antialias", "MP3 antialias algorithm", OFFSET(antialias_algo
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
643 {"auto", NULL
, 0, FF_OPT_TYPE_CONST
, FF_AA_AUTO
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
644 {"fastint", NULL
, 0, FF_OPT_TYPE_CONST
, FF_AA_FASTINT
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
645 {"int", NULL
, 0, FF_OPT_TYPE_CONST
, FF_AA_INT
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
646 {"float", NULL
, 0, FF_OPT_TYPE_CONST
, FF_AA_FLOAT
, INT_MIN
, INT_MAX
, V
|D
, "aa"},
647 {"qns", "quantizer noise shaping", OFFSET(quantizer_noise_shaping
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
648 {"threads", NULL
, OFFSET(thread_count
), FF_OPT_TYPE_INT
, 1, INT_MIN
, INT_MAX
, V
|E
|D
},
649 {"me_threshold", "motion estimaton threshold", OFFSET(me_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
},
650 {"mb_threshold", "macroblock threshold", OFFSET(mb_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
651 {"dc", "intra_dc_precision", OFFSET(intra_dc_precision
), FF_OPT_TYPE_INT
, 0, INT_MIN
, INT_MAX
, V
|E
},
652 {"nssew", "nsse weight", OFFSET(nsse_weight
), FF_OPT_TYPE_INT
, 8, INT_MIN
, INT_MAX
, V
|E
},
653 {"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
},
654 {"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
},
655 {"profile", NULL
, OFFSET(profile
), FF_OPT_TYPE_INT
, FF_PROFILE_UNKNOWN
, INT_MIN
, INT_MAX
, V
|A
|E
, "profile"},
656 {"unknown", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_UNKNOWN
, INT_MIN
, INT_MAX
, V
|A
|E
, "profile"},
657 {"aac_main", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_AAC_MAIN
, INT_MIN
, INT_MAX
, A
|E
, "profile"},
658 {"aac_low", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_AAC_LOW
, INT_MIN
, INT_MAX
, A
|E
, "profile"},
659 {"aac_ssr", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_AAC_SSR
, INT_MIN
, INT_MAX
, A
|E
, "profile"},
660 {"aac_ltp", NULL
, 0, FF_OPT_TYPE_CONST
, FF_PROFILE_AAC_LTP
, INT_MIN
, INT_MAX
, A
|E
, "profile"},
661 {"level", NULL
, OFFSET(level
), FF_OPT_TYPE_INT
, FF_LEVEL_UNKNOWN
, INT_MIN
, INT_MAX
, V
|A
|E
, "level"},
662 {"unknown", NULL
, 0, FF_OPT_TYPE_CONST
, FF_LEVEL_UNKNOWN
, INT_MIN
, INT_MAX
, V
|A
|E
, "level"},
663 {"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
},
664 {"skip_threshold", "frame skip threshold", OFFSET(frame_skip_threshold
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
665 {"skip_factor", "frame skip factor", OFFSET(frame_skip_factor
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
666 {"skip_exp", "frame skip exponent", OFFSET(frame_skip_exp
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
667 {"skipcmp", "frame skip compare function", OFFSET(frame_skip_cmp
), FF_OPT_TYPE_INT
, FF_CMP_DCTMAX
, INT_MIN
, INT_MAX
, V
|E
, "cmp_func"},
668 {"border_mask", "increases the quantizer for macroblocks close to borders", OFFSET(border_masking
), FF_OPT_TYPE_FLOAT
, DEFAULT
, -FLT_MAX
, FLT_MAX
, V
|E
},
669 {"mblmin", "min macroblock lagrange factor (VBR)", OFFSET(mb_lmin
), FF_OPT_TYPE_INT
, FF_QP2LAMBDA
* 2, 1, FF_LAMBDA_MAX
, V
|E
},
670 {"mblmax", "max macroblock lagrange factor (VBR)", OFFSET(mb_lmax
), FF_OPT_TYPE_INT
, FF_QP2LAMBDA
* 31, 1, FF_LAMBDA_MAX
, V
|E
},
671 {"mepc", "motion estimation bitrate penalty compensation (1.0 = 256)", OFFSET(me_penalty_compensation
), FF_OPT_TYPE_INT
, 256, INT_MIN
, INT_MAX
, V
|E
},
672 {"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine
), FF_OPT_TYPE_INT
, DEFAULT
, 0, 4, V
|E
},
673 {"brd_scale", "downscales frames for dynamic B-frame decision", OFFSET(brd_scale
), FF_OPT_TYPE_INT
, DEFAULT
, 0, 10, V
|E
},
674 {"crf", "enables constant quality mode, and selects the quality (x264)", OFFSET(crf
), FF_OPT_TYPE_FLOAT
, DEFAULT
, 0, 51, V
|E
},
675 {"cqp", "constant quantization parameter rate control method", OFFSET(cqp
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, V
|E
},
676 {"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min
), FF_OPT_TYPE_INT
, 25, INT_MIN
, INT_MAX
, V
|E
},
677 {"refs", "reference frames to consider for motion compensation (Snow)", OFFSET(refs
), FF_OPT_TYPE_INT
, 1, INT_MIN
, INT_MAX
, V
|E
},
678 {"chromaoffset", "chroma qp offset from luma", OFFSET(chromaoffset
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
679 {"bframebias", "influences how often B-frames are used", OFFSET(bframebias
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
},
680 {"trellis", "rate-distortion optimal quantization", OFFSET(trellis
), FF_OPT_TYPE_INT
, DEFAULT
, INT_MIN
, INT_MAX
, V
|A
|E
},
681 {"directpred", "direct mv prediction mode - 0 (none), 1 (spatial), 2 (temporal)", OFFSET(directpred
), FF_OPT_TYPE_INT
, 2, INT_MIN
, INT_MAX
, V
|E
},
682 {"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"},
683 {"wpred", "weighted biprediction for b-frames (H.264)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_WPRED
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
684 {"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"},
685 {"dct8x8", "high profile 8x8 transform (H.264)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_8X8DCT
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
686 {"fastpskip", "fast pskip (H.264)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_FASTPSKIP
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
687 {"aud", "access unit delimiters (H.264)", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_AUD
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
688 {"brdo", "b-frame rate-distortion optimization", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_BRDO
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
689 {"skiprd", "RD optimal MB level residual skipping", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_SKIP_RD
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
690 {"complexityblur", "reduce fluctuations in qp (before curve compression)", OFFSET(complexityblur
), FF_OPT_TYPE_FLOAT
, 20.0, FLT_MIN
, FLT_MAX
, V
|E
},
691 {"deblockalpha", "in-loop deblocking filter alphac0 parameter", OFFSET(deblockalpha
), FF_OPT_TYPE_INT
, DEFAULT
, -6, 6, V
|E
},
692 {"deblockbeta", "in-loop deblocking filter beta parameter", OFFSET(deblockbeta
), FF_OPT_TYPE_INT
, DEFAULT
, -6, 6, V
|E
},
693 {"partitions", "macroblock subpartition sizes to consider", OFFSET(partitions
), FF_OPT_TYPE_FLAGS
, DEFAULT
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
694 {"parti4x4", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_I4X4
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
695 {"parti8x8", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_I8X8
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
696 {"partp4x4", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_P4X4
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
697 {"partp8x8", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_P8X8
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
698 {"partb8x8", NULL
, 0, FF_OPT_TYPE_CONST
, X264_PART_B8X8
, INT_MIN
, INT_MAX
, V
|E
, "partitions"},
699 {"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
},
700 {"mv0_threshold", NULL
, OFFSET(mv0_threshold
), FF_OPT_TYPE_INT
, 256, 0, INT_MAX
, V
|E
},
701 {"ivlc", "intra vlc table", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_INTRA_VLC
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
702 {"b_sensitivity", "adjusts sensitivity of b_frame_strategy 1", OFFSET(b_sensitivity
), FF_OPT_TYPE_INT
, 40, 1, INT_MAX
, V
|E
},
703 {"compression_level", NULL
, OFFSET(compression_level
), FF_OPT_TYPE_INT
, FF_COMPRESSION_DEFAULT
, INT_MIN
, INT_MAX
, V
|A
|E
},
704 {"use_lpc", "sets whether to use LPC mode (FLAC)", OFFSET(use_lpc
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
705 {"lpc_coeff_precision", "LPC coefficient precision (FLAC)", OFFSET(lpc_coeff_precision
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, A
|E
},
706 {"min_prediction_order", NULL
, OFFSET(min_prediction_order
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
707 {"max_prediction_order", NULL
, OFFSET(max_prediction_order
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
708 {"prediction_order_method", "search method for selecting prediction order", OFFSET(prediction_order_method
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
709 {"min_partition_order", NULL
, OFFSET(min_partition_order
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
710 {"max_partition_order", NULL
, OFFSET(max_partition_order
), FF_OPT_TYPE_INT
, -1, INT_MIN
, INT_MAX
, A
|E
},
711 {"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
},
712 {"drop_frame_timecode", NULL
, 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_DROP_FRAME_TIMECODE
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
713 {"non_linear_q", "use non linear quantizer", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_NON_LINEAR_QUANT
, INT_MIN
, INT_MAX
, V
|E
, "flags2"},
714 {"request_channels", "set desired number of audio channels", OFFSET(request_channels
), FF_OPT_TYPE_INT
, DEFAULT
, 0, INT_MAX
, A
|D
},
715 {"drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale
), FF_OPT_TYPE_FLOAT
, 1.0, 0.0, 1.0, A
|D
},
716 {"reservoir", "use bit reservoir", 0, FF_OPT_TYPE_CONST
, CODEC_FLAG2_BIT_RESERVOIR
, INT_MIN
, INT_MAX
, A
|E
, "flags2"},
727 static const AVClass av_codec_context_class
= { "AVCodecContext", context_to_name
, options
};
729 void avcodec_get_context_defaults2(AVCodecContext
*s
, enum CodecType codec_type
){
731 memset(s
, 0, sizeof(AVCodecContext
));
733 s
->av_class
= &av_codec_context_class
;
735 s
->codec_type
= codec_type
;
736 if(codec_type
== CODEC_TYPE_AUDIO
)
737 flags
= AV_OPT_FLAG_AUDIO_PARAM
;
738 else if(codec_type
== CODEC_TYPE_VIDEO
)
739 flags
= AV_OPT_FLAG_VIDEO_PARAM
;
740 else if(codec_type
== CODEC_TYPE_SUBTITLE
)
741 flags
= AV_OPT_FLAG_SUBTITLE_PARAM
;
742 av_opt_set_defaults2(s
, flags
, flags
);
744 s
->rc_eq
= "tex^qComp";
745 s
->time_base
= (AVRational
){0,1};
746 s
->get_buffer
= avcodec_default_get_buffer
;
747 s
->release_buffer
= avcodec_default_release_buffer
;
748 s
->get_format
= avcodec_default_get_format
;
749 s
->execute
= avcodec_default_execute
;
750 s
->sample_aspect_ratio
= (AVRational
){0,1};
751 s
->pix_fmt
= PIX_FMT_NONE
;
752 s
->sample_fmt
= SAMPLE_FMT_S16
; // FIXME: set to NONE
755 s
->reget_buffer
= avcodec_default_reget_buffer
;
758 AVCodecContext
*avcodec_alloc_context2(enum CodecType codec_type
){
759 AVCodecContext
*avctx
= av_malloc(sizeof(AVCodecContext
));
761 if(avctx
==NULL
) return NULL
;
763 avcodec_get_context_defaults2(avctx
, codec_type
);
768 void avcodec_get_context_defaults(AVCodecContext
*s
){
769 avcodec_get_context_defaults2(s
, CODEC_TYPE_UNKNOWN
);
772 AVCodecContext
*avcodec_alloc_context(void){
773 return avcodec_alloc_context2(CODEC_TYPE_UNKNOWN
);
776 void avcodec_get_frame_defaults(AVFrame
*pic
){
777 memset(pic
, 0, sizeof(AVFrame
));
779 pic
->pts
= AV_NOPTS_VALUE
;
783 AVFrame
*avcodec_alloc_frame(void){
784 AVFrame
*pic
= av_malloc(sizeof(AVFrame
));
786 if(pic
==NULL
) return NULL
;
788 avcodec_get_frame_defaults(pic
);
793 int attribute_align_arg
avcodec_open(AVCodecContext
*avctx
, AVCodec
*codec
)
797 entangled_thread_counter
++;
798 if(entangled_thread_counter
!= 1){
799 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
803 if(avctx
->codec
|| !codec
)
806 if (codec
->priv_data_size
> 0) {
807 avctx
->priv_data
= av_mallocz(codec
->priv_data_size
);
808 if (!avctx
->priv_data
) {
809 ret
= AVERROR(ENOMEM
);
813 avctx
->priv_data
= NULL
;
816 if(avctx
->coded_width
&& avctx
->coded_height
)
817 avcodec_set_dimensions(avctx
, avctx
->coded_width
, avctx
->coded_height
);
818 else if(avctx
->width
&& avctx
->height
)
819 avcodec_set_dimensions(avctx
, avctx
->width
, avctx
->height
);
821 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
)){
822 av_freep(&avctx
->priv_data
);
823 ret
= AVERROR(EINVAL
);
827 avctx
->codec
= codec
;
828 avctx
->codec_id
= codec
->id
;
829 avctx
->frame_number
= 0;
830 if(avctx
->codec
->init
){
831 ret
= avctx
->codec
->init(avctx
);
833 av_freep(&avctx
->priv_data
);
840 entangled_thread_counter
--;
844 int attribute_align_arg
avcodec_encode_audio(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
845 const short *samples
)
847 if(buf_size
< FF_MIN_BUFFER_SIZE
&& 0){
848 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
851 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || samples
){
852 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, (void *)samples
);
853 avctx
->frame_number
++;
859 int attribute_align_arg
avcodec_encode_video(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
862 if(buf_size
< FF_MIN_BUFFER_SIZE
){
863 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than minimum size\n");
866 if(avcodec_check_dimensions(avctx
,avctx
->width
,avctx
->height
))
868 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || pict
){
869 int ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, (void *)pict
);
870 avctx
->frame_number
++;
871 emms_c(); //needed to avoid an emms_c() call before every return;
878 int avcodec_encode_subtitle(AVCodecContext
*avctx
, uint8_t *buf
, int buf_size
,
879 const AVSubtitle
*sub
)
882 ret
= avctx
->codec
->encode(avctx
, buf
, buf_size
, (void *)sub
);
883 avctx
->frame_number
++;
887 int attribute_align_arg
avcodec_decode_video(AVCodecContext
*avctx
, AVFrame
*picture
,
888 int *got_picture_ptr
,
889 const uint8_t *buf
, int buf_size
)
894 if((avctx
->coded_width
||avctx
->coded_height
) && avcodec_check_dimensions(avctx
,avctx
->coded_width
,avctx
->coded_height
))
896 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || buf_size
){
897 ret
= avctx
->codec
->decode(avctx
, picture
, got_picture_ptr
,
900 emms_c(); //needed to avoid an emms_c() call before every return;
902 if (*got_picture_ptr
)
903 avctx
->frame_number
++;
910 int attribute_align_arg
avcodec_decode_audio2(AVCodecContext
*avctx
, int16_t *samples
,
912 const uint8_t *buf
, int buf_size
)
916 if((avctx
->codec
->capabilities
& CODEC_CAP_DELAY
) || buf_size
){
917 //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
918 if(*frame_size_ptr
< AVCODEC_MAX_AUDIO_FRAME_SIZE
){
919 av_log(avctx
, AV_LOG_ERROR
, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
922 if(*frame_size_ptr
< FF_MIN_BUFFER_SIZE
||
923 *frame_size_ptr
< avctx
->channels
* avctx
->frame_size
* sizeof(int16_t)){
924 av_log(avctx
, AV_LOG_ERROR
, "buffer %d too small\n", *frame_size_ptr
);
928 ret
= avctx
->codec
->decode(avctx
, samples
, frame_size_ptr
,
930 avctx
->frame_number
++;
938 #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
939 int avcodec_decode_audio(AVCodecContext
*avctx
, int16_t *samples
,
941 const uint8_t *buf
, int buf_size
){
942 *frame_size_ptr
= AVCODEC_MAX_AUDIO_FRAME_SIZE
;
943 return avcodec_decode_audio2(avctx
, samples
, frame_size_ptr
, buf
, buf_size
);
947 int avcodec_decode_subtitle(AVCodecContext
*avctx
, AVSubtitle
*sub
,
949 const uint8_t *buf
, int buf_size
)
954 ret
= avctx
->codec
->decode(avctx
, sub
, got_sub_ptr
,
957 avctx
->frame_number
++;
961 int avcodec_close(AVCodecContext
*avctx
)
963 entangled_thread_counter
++;
964 if(entangled_thread_counter
!= 1){
965 av_log(avctx
, AV_LOG_ERROR
, "insufficient thread locking around avcodec_open/close()\n");
966 entangled_thread_counter
--;
970 if (ENABLE_THREADS
&& avctx
->thread_opaque
)
971 avcodec_thread_free(avctx
);
972 if (avctx
->codec
->close
)
973 avctx
->codec
->close(avctx
);
974 avcodec_default_free_buffers(avctx
);
975 av_freep(&avctx
->priv_data
);
977 entangled_thread_counter
--;
981 AVCodec
*avcodec_find_encoder(enum CodecID id
)
986 if (p
->encode
!= NULL
&& p
->id
== id
)
993 AVCodec
*avcodec_find_encoder_by_name(const char *name
)
998 if (p
->encode
!= NULL
&& strcmp(name
,p
->name
) == 0)
1005 AVCodec
*avcodec_find_decoder(enum CodecID id
)
1010 if (p
->decode
!= NULL
&& p
->id
== id
)
1017 AVCodec
*avcodec_find_decoder_by_name(const char *name
)
1022 if (p
->decode
!= NULL
&& strcmp(name
,p
->name
) == 0)
1029 void avcodec_string(char *buf
, int buf_size
, AVCodecContext
*enc
, int encode
)
1031 const char *codec_name
;
1034 char channels_str
[100];
1036 AVRational display_aspect_ratio
;
1039 p
= avcodec_find_encoder(enc
->codec_id
);
1041 p
= avcodec_find_decoder(enc
->codec_id
);
1044 codec_name
= p
->name
;
1045 if (!encode
&& enc
->codec_id
== CODEC_ID_MP3
) {
1046 if (enc
->sub_id
== 2)
1048 else if (enc
->sub_id
== 1)
1051 } else if (enc
->codec_id
== CODEC_ID_MPEG2TS
) {
1052 /* fake mpeg2 transport stream codec (currently not
1054 codec_name
= "mpeg2ts";
1055 } else if (enc
->codec_name
[0] != '\0') {
1056 codec_name
= enc
->codec_name
;
1058 /* output avi tags */
1059 if( isprint(enc
->codec_tag
&0xFF) && isprint((enc
->codec_tag
>>8)&0xFF)
1060 && isprint((enc
->codec_tag
>>16)&0xFF) && isprint((enc
->codec_tag
>>24)&0xFF)){
1061 snprintf(buf1
, sizeof(buf1
), "%c%c%c%c / 0x%04X",
1062 enc
->codec_tag
& 0xff,
1063 (enc
->codec_tag
>> 8) & 0xff,
1064 (enc
->codec_tag
>> 16) & 0xff,
1065 (enc
->codec_tag
>> 24) & 0xff,
1068 snprintf(buf1
, sizeof(buf1
), "0x%04x", enc
->codec_tag
);
1073 switch(enc
->codec_type
) {
1074 case CODEC_TYPE_VIDEO
:
1075 snprintf(buf
, buf_size
,
1077 codec_name
, enc
->mb_decision
? " (hq)" : "");
1078 if (enc
->pix_fmt
!= PIX_FMT_NONE
) {
1079 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1081 avcodec_get_pix_fmt_name(enc
->pix_fmt
));
1084 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1086 enc
->width
, enc
->height
);
1087 if (enc
->sample_aspect_ratio
.num
) {
1088 av_reduce(&display_aspect_ratio
.num
, &display_aspect_ratio
.den
,
1089 enc
->width
*enc
->sample_aspect_ratio
.num
,
1090 enc
->height
*enc
->sample_aspect_ratio
.den
,
1092 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1093 " [PAR %d:%d DAR %d:%d]",
1094 enc
->sample_aspect_ratio
.num
, enc
->sample_aspect_ratio
.den
,
1095 display_aspect_ratio
.num
, display_aspect_ratio
.den
);
1097 if(av_log_get_level() >= AV_LOG_DEBUG
){
1098 int g
= ff_gcd(enc
->time_base
.num
, enc
->time_base
.den
);
1099 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1101 enc
->time_base
.num
/g
, enc
->time_base
.den
/g
);
1105 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1106 ", q=%d-%d", enc
->qmin
, enc
->qmax
);
1108 bitrate
= enc
->bit_rate
;
1110 case CODEC_TYPE_AUDIO
:
1111 snprintf(buf
, buf_size
,
1114 switch (enc
->channels
) {
1116 strcpy(channels_str
, "mono");
1119 strcpy(channels_str
, "stereo");
1122 strcpy(channels_str
, "5:1");
1125 snprintf(channels_str
, sizeof(channels_str
), "%d channels", enc
->channels
);
1128 if (enc
->sample_rate
) {
1129 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1135 /* for PCM codecs, compute bitrate directly */
1136 switch(enc
->codec_id
) {
1137 case CODEC_ID_PCM_S32LE
:
1138 case CODEC_ID_PCM_S32BE
:
1139 case CODEC_ID_PCM_U32LE
:
1140 case CODEC_ID_PCM_U32BE
:
1141 bitrate
= enc
->sample_rate
* enc
->channels
* 32;
1143 case CODEC_ID_PCM_S24LE
:
1144 case CODEC_ID_PCM_S24BE
:
1145 case CODEC_ID_PCM_U24LE
:
1146 case CODEC_ID_PCM_U24BE
:
1147 case CODEC_ID_PCM_S24DAUD
:
1148 bitrate
= enc
->sample_rate
* enc
->channels
* 24;
1150 case CODEC_ID_PCM_S16LE
:
1151 case CODEC_ID_PCM_S16BE
:
1152 case CODEC_ID_PCM_S16LE_PLANAR
:
1153 case CODEC_ID_PCM_U16LE
:
1154 case CODEC_ID_PCM_U16BE
:
1155 bitrate
= enc
->sample_rate
* enc
->channels
* 16;
1157 case CODEC_ID_PCM_S8
:
1158 case CODEC_ID_PCM_U8
:
1159 case CODEC_ID_PCM_ALAW
:
1160 case CODEC_ID_PCM_MULAW
:
1161 bitrate
= enc
->sample_rate
* enc
->channels
* 8;
1164 bitrate
= enc
->bit_rate
;
1168 case CODEC_TYPE_DATA
:
1169 snprintf(buf
, buf_size
, "Data: %s", codec_name
);
1170 bitrate
= enc
->bit_rate
;
1172 case CODEC_TYPE_SUBTITLE
:
1173 snprintf(buf
, buf_size
, "Subtitle: %s", codec_name
);
1174 bitrate
= enc
->bit_rate
;
1176 case CODEC_TYPE_ATTACHMENT
:
1177 snprintf(buf
, buf_size
, "Attachment: %s", codec_name
);
1178 bitrate
= enc
->bit_rate
;
1181 snprintf(buf
, buf_size
, "Invalid Codec type %d", enc
->codec_type
);
1185 if (enc
->flags
& CODEC_FLAG_PASS1
)
1186 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1188 if (enc
->flags
& CODEC_FLAG_PASS2
)
1189 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1193 snprintf(buf
+ strlen(buf
), buf_size
- strlen(buf
),
1194 ", %d kb/s", bitrate
/ 1000);
1198 unsigned avcodec_version( void )
1200 return LIBAVCODEC_VERSION_INT
;
1203 unsigned avcodec_build( void )
1205 return LIBAVCODEC_BUILD
;
1208 void avcodec_init(void)
1210 static int initialized
= 0;
1212 if (initialized
!= 0)
1216 dsputil_static_init();
1219 void avcodec_flush_buffers(AVCodecContext
*avctx
)
1221 if(avctx
->codec
->flush
)
1222 avctx
->codec
->flush(avctx
);
1225 void avcodec_default_free_buffers(AVCodecContext
*s
){
1228 if(s
->internal_buffer
==NULL
) return;
1230 for(i
=0; i
<INTERNAL_BUFFER_SIZE
; i
++){
1231 InternalBuffer
*buf
= &((InternalBuffer
*)s
->internal_buffer
)[i
];
1233 av_freep(&buf
->base
[j
]);
1237 av_freep(&s
->internal_buffer
);
1239 s
->internal_buffer_count
=0;
1242 char av_get_pict_type_char(int pict_type
){
1244 case FF_I_TYPE
: return 'I';
1245 case FF_P_TYPE
: return 'P';
1246 case FF_B_TYPE
: return 'B';
1247 case FF_S_TYPE
: return 'S';
1248 case FF_SI_TYPE
:return 'i';
1249 case FF_SP_TYPE
:return 'p';
1250 case FF_BI_TYPE
:return 'b';
1251 default: return '?';
1255 int av_get_bits_per_sample(enum CodecID codec_id
){
1257 case CODEC_ID_ADPCM_SBPRO_2
:
1259 case CODEC_ID_ADPCM_SBPRO_3
:
1261 case CODEC_ID_ADPCM_SBPRO_4
:
1262 case CODEC_ID_ADPCM_CT
:
1264 case CODEC_ID_PCM_ALAW
:
1265 case CODEC_ID_PCM_MULAW
:
1266 case CODEC_ID_PCM_S8
:
1267 case CODEC_ID_PCM_U8
:
1269 case CODEC_ID_PCM_S16BE
:
1270 case CODEC_ID_PCM_S16LE
:
1271 case CODEC_ID_PCM_S16LE_PLANAR
:
1272 case CODEC_ID_PCM_U16BE
:
1273 case CODEC_ID_PCM_U16LE
:
1275 case CODEC_ID_PCM_S24DAUD
:
1276 case CODEC_ID_PCM_S24BE
:
1277 case CODEC_ID_PCM_S24LE
:
1278 case CODEC_ID_PCM_U24BE
:
1279 case CODEC_ID_PCM_U24LE
:
1281 case CODEC_ID_PCM_S32BE
:
1282 case CODEC_ID_PCM_S32LE
:
1283 case CODEC_ID_PCM_U32BE
:
1284 case CODEC_ID_PCM_U32LE
:
1291 int av_get_bits_per_sample_format(enum SampleFormat sample_fmt
) {
1292 switch (sample_fmt
) {
1295 case SAMPLE_FMT_S16
:
1297 case SAMPLE_FMT_S24
:
1299 case SAMPLE_FMT_S32
:
1300 case SAMPLE_FMT_FLT
:
1307 #if !defined(HAVE_THREADS)
1308 int avcodec_thread_init(AVCodecContext
*s
, int thread_count
){
1313 unsigned int av_xiphlacing(unsigned char *s
, unsigned int v
)
1327 /* Wrapper to work around the lack of mkstemp() on mingw/cygin.
1328 * Also, tries to create file in /tmp first, if possible.
1329 * *prefix can be a character constant; *filename will be allocated internally.
1330 * Returns file descriptor of opened file (or -1 on error)
1331 * and opened file name in **filename. */
1332 int av_tempfile(char *prefix
, char **filename
) {
1334 #if !defined(HAVE_MKSTEMP)
1335 *filename
= tempnam(".", prefix
);
1337 size_t len
= strlen(prefix
) + 12; /* room for "/tmp/" and "XXXXXX\0" */
1338 *filename
= av_malloc(len
);
1340 /* -----common section-----*/
1341 if (*filename
== NULL
) {
1342 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot allocate file name\n");
1345 #if !defined(HAVE_MKSTEMP)
1346 fd
= open(*filename
, O_RDWR
| O_BINARY
| O_CREAT
, 0444);
1348 snprintf(*filename
, len
, "/tmp/%sXXXXXX", prefix
);
1349 fd
= mkstemp(*filename
);
1351 snprintf(*filename
, len
, "./%sXXXXXX", prefix
);
1352 fd
= mkstemp(*filename
);
1355 /* -----common section-----*/
1357 av_log(NULL
, AV_LOG_ERROR
, "ff_tempfile: Cannot open temporary file %s\n", *filename
);
1360 return fd
; /* success */
1366 } VideoFrameSizeAbbr
;
1370 int rate_num
, rate_den
;
1371 } VideoFrameRateAbbr
;
1373 static const VideoFrameSizeAbbr video_frame_size_abbrs
[] = {
1374 { "ntsc", 720, 480 },
1375 { "pal", 720, 576 },
1376 { "qntsc", 352, 240 }, /* VCD compliant NTSC */
1377 { "qpal", 352, 288 }, /* VCD compliant PAL */
1378 { "sntsc", 640, 480 }, /* square pixel NTSC */
1379 { "spal", 768, 576 }, /* square pixel PAL */
1380 { "film", 352, 240 },
1381 { "ntsc-film", 352, 240 },
1382 { "sqcif", 128, 96 },
1383 { "qcif", 176, 144 },
1384 { "cif", 352, 288 },
1385 { "4cif", 704, 576 },
1386 { "qqvga", 160, 120 },
1387 { "qvga", 320, 240 },
1388 { "vga", 640, 480 },
1389 { "svga", 800, 600 },
1390 { "xga", 1024, 768 },
1391 { "uxga", 1600,1200 },
1392 { "qxga", 2048,1536 },
1393 { "sxga", 1280,1024 },
1394 { "qsxga", 2560,2048 },
1395 { "hsxga", 5120,4096 },
1396 { "wvga", 852, 480 },
1397 { "wxga", 1366, 768 },
1398 { "wsxga", 1600,1024 },
1399 { "wuxga", 1920,1200 },
1400 { "woxga", 2560,1600 },
1401 { "wqsxga", 3200,2048 },
1402 { "wquxga", 3840,2400 },
1403 { "whsxga", 6400,4096 },
1404 { "whuxga", 7680,4800 },
1405 { "cga", 320, 200 },
1406 { "ega", 640, 350 },
1407 { "hd480", 852, 480 },
1408 { "hd720", 1280, 720 },
1409 { "hd1080", 1920,1080 },
1412 static const VideoFrameRateAbbr video_frame_rate_abbrs
[]= {
1413 { "ntsc", 30000, 1001 },
1415 { "qntsc", 30000, 1001 }, /* VCD compliant NTSC */
1416 { "qpal", 25, 1 }, /* VCD compliant PAL */
1417 { "sntsc", 30000, 1001 }, /* square pixel NTSC */
1418 { "spal", 25, 1 }, /* square pixel PAL */
1420 { "ntsc-film", 24000, 1001 },
1423 int av_parse_video_frame_size(int *width_ptr
, int *height_ptr
, const char *str
)
1426 int n
= sizeof(video_frame_size_abbrs
) / sizeof(VideoFrameSizeAbbr
);
1428 int frame_width
= 0, frame_height
= 0;
1431 if (!strcmp(video_frame_size_abbrs
[i
].abbr
, str
)) {
1432 frame_width
= video_frame_size_abbrs
[i
].width
;
1433 frame_height
= video_frame_size_abbrs
[i
].height
;
1439 frame_width
= strtol(p
, (char **)&p
, 10);
1442 frame_height
= strtol(p
, (char **)&p
, 10);
1444 if (frame_width
<= 0 || frame_height
<= 0)
1446 *width_ptr
= frame_width
;
1447 *height_ptr
= frame_height
;
1451 int av_parse_video_frame_rate(AVRational
*frame_rate
, const char *arg
)
1454 int n
= sizeof(video_frame_rate_abbrs
) / sizeof(VideoFrameRateAbbr
);
1457 /* First, we check our abbreviation table */
1458 for (i
= 0; i
< n
; ++i
)
1459 if (!strcmp(video_frame_rate_abbrs
[i
].abbr
, arg
)) {
1460 frame_rate
->num
= video_frame_rate_abbrs
[i
].rate_num
;
1461 frame_rate
->den
= video_frame_rate_abbrs
[i
].rate_den
;
1465 /* Then, we try to parse it as fraction */
1466 cp
= strchr(arg
, '/');
1468 cp
= strchr(arg
, ':');
1471 frame_rate
->num
= strtol(arg
, &cpp
, 10);
1472 if (cpp
!= arg
|| cpp
== cp
)
1473 frame_rate
->den
= strtol(cp
+1, &cpp
, 10);
1475 frame_rate
->num
= 0;
1478 /* Finally we give up and parse it as double */
1479 AVRational time_base
= av_d2q(strtod(arg
, 0), DEFAULT_FRAME_RATE_BASE
);
1480 frame_rate
->den
= time_base
.den
;
1481 frame_rate
->num
= time_base
.num
;
1483 if (!frame_rate
->num
|| !frame_rate
->den
)