2001-07-22 16:18:56 +02:00
/*
* utils for libavcodec
2002-05-26 00:45:33 +02:00
* Copyright ( c ) 2001 Fabrice Bellard .
2004-01-10 17:04:55 +01:00
* Copyright ( c ) 2002 - 2004 Michael Niedermayer < michaelni @ gmx . at >
2001-07-22 16:18:56 +02:00
*
2006-10-07 17:30:46 +02:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2002-05-26 00:45:33 +02:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 17:30:46 +02:00
* version 2.1 of the License , or ( at your option ) any later version .
2001-07-22 16:18:56 +02:00
*
2006-10-07 17:30:46 +02:00
* FFmpeg is distributed in the hope that it will be useful ,
2001-07-22 16:18:56 +02:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
2002-05-26 00:45:33 +02:00
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
2001-07-22 16:18:56 +02:00
*
2002-05-26 00:45:33 +02:00
* You should have received a copy of the GNU Lesser General Public
2006-10-07 17:30:46 +02:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 23:43:26 +01:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2001-07-22 16:18:56 +02:00
*/
2005-12-17 19:14:38 +01:00
2003-03-06 12:32:04 +01:00
/**
* @ file utils . c
* utils .
*/
2005-12-17 19:14:38 +01:00
2008-08-15 00:01:59 +02:00
/* needed for mkstemp() */
# define _XOPEN_SOURCE 500
2008-05-09 13:56:36 +02:00
# include "libavutil/integer.h"
# include "libavutil/crc.h"
2001-07-22 16:18:56 +02:00
# include "avcodec.h"
2002-05-19 00:59:50 +02:00
# include "dsputil.h"
2005-09-12 20:24:48 +02:00
# include "opt.h"
2008-02-15 21:23:49 +01:00
# include "imgconvert.h"
2008-07-31 14:56:56 +02:00
# include "audioconvert.h"
2008-08-15 00:01:59 +02:00
# include <stdlib.h>
2003-11-03 14:26:22 +01:00
# include <stdarg.h>
2004-05-04 04:58:30 +02:00
# include <limits.h>
2005-09-06 14:51:56 +02:00
# include <float.h>
2007-07-11 15:57:22 +02:00
# if !defined(HAVE_MKSTEMP)
2006-03-30 06:33:05 +02:00
# include <fcntl.h>
# endif
2001-07-22 16:18:56 +02:00
2005-05-07 21:24:07 +02:00
const uint8_t ff_reverse [ 256 ] = {
0x00 , 0x80 , 0x40 , 0xC0 , 0x20 , 0xA0 , 0x60 , 0xE0 , 0x10 , 0x90 , 0x50 , 0xD0 , 0x30 , 0xB0 , 0x70 , 0xF0 ,
0x08 , 0x88 , 0x48 , 0xC8 , 0x28 , 0xA8 , 0x68 , 0xE8 , 0x18 , 0x98 , 0x58 , 0xD8 , 0x38 , 0xB8 , 0x78 , 0xF8 ,
0x04 , 0x84 , 0x44 , 0xC4 , 0x24 , 0xA4 , 0x64 , 0xE4 , 0x14 , 0x94 , 0x54 , 0xD4 , 0x34 , 0xB4 , 0x74 , 0xF4 ,
0x0C , 0x8C , 0x4C , 0xCC , 0x2C , 0xAC , 0x6C , 0xEC , 0x1C , 0x9C , 0x5C , 0xDC , 0x3C , 0xBC , 0x7C , 0xFC ,
0x02 , 0x82 , 0x42 , 0xC2 , 0x22 , 0xA2 , 0x62 , 0xE2 , 0x12 , 0x92 , 0x52 , 0xD2 , 0x32 , 0xB2 , 0x72 , 0xF2 ,
0x0A , 0x8A , 0x4A , 0xCA , 0x2A , 0xAA , 0x6A , 0xEA , 0x1A , 0x9A , 0x5A , 0xDA , 0x3A , 0xBA , 0x7A , 0xFA ,
0x06 , 0x86 , 0x46 , 0xC6 , 0x26 , 0xA6 , 0x66 , 0xE6 , 0x16 , 0x96 , 0x56 , 0xD6 , 0x36 , 0xB6 , 0x76 , 0xF6 ,
0x0E , 0x8E , 0x4E , 0xCE , 0x2E , 0xAE , 0x6E , 0xEE , 0x1E , 0x9E , 0x5E , 0xDE , 0x3E , 0xBE , 0x7E , 0xFE ,
0x01 , 0x81 , 0x41 , 0xC1 , 0x21 , 0xA1 , 0x61 , 0xE1 , 0x11 , 0x91 , 0x51 , 0xD1 , 0x31 , 0xB1 , 0x71 , 0xF1 ,
0x09 , 0x89 , 0x49 , 0xC9 , 0x29 , 0xA9 , 0x69 , 0xE9 , 0x19 , 0x99 , 0x59 , 0xD9 , 0x39 , 0xB9 , 0x79 , 0xF9 ,
0x05 , 0x85 , 0x45 , 0xC5 , 0x25 , 0xA5 , 0x65 , 0xE5 , 0x15 , 0x95 , 0x55 , 0xD5 , 0x35 , 0xB5 , 0x75 , 0xF5 ,
0x0D , 0x8D , 0x4D , 0xCD , 0x2D , 0xAD , 0x6D , 0xED , 0x1D , 0x9D , 0x5D , 0xDD , 0x3D , 0xBD , 0x7D , 0xFD ,
0x03 , 0x83 , 0x43 , 0xC3 , 0x23 , 0xA3 , 0x63 , 0xE3 , 0x13 , 0x93 , 0x53 , 0xD3 , 0x33 , 0xB3 , 0x73 , 0xF3 ,
0x0B , 0x8B , 0x4B , 0xCB , 0x2B , 0xAB , 0x6B , 0xEB , 0x1B , 0x9B , 0x5B , 0xDB , 0x3B , 0xBB , 0x7B , 0xFB ,
0x07 , 0x87 , 0x47 , 0xC7 , 0x27 , 0xA7 , 0x67 , 0xE7 , 0x17 , 0x97 , 0x57 , 0xD7 , 0x37 , 0xB7 , 0x77 , 0xF7 ,
0x0F , 0x8F , 0x4F , 0xCF , 0x2F , 0xAF , 0x6F , 0xEF , 0x1F , 0x9F , 0x5F , 0xDF , 0x3F , 0xBF , 0x7F , 0xFF ,
} ;
2005-07-25 16:35:01 +02:00
static int volatile entangled_thread_counter = 0 ;
2003-02-10 10:35:32 +01:00
void * av_fast_realloc ( void * ptr , unsigned int * size , unsigned int min_size )
2003-01-24 00:03:09 +01:00
{
2005-12-17 19:14:38 +01:00
if ( min_size < * size )
2003-01-24 00:03:09 +01:00
return ptr ;
2005-12-17 19:14:38 +01:00
2005-01-12 01:16:25 +01:00
* size = FFMAX ( 17 * min_size / 16 + 32 , min_size ) ;
2003-01-24 00:03:09 +01:00
2008-03-25 11:15:17 +01:00
ptr = av_realloc ( ptr , * size ) ;
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
* size = 0 ;
return ptr ;
2003-01-24 00:03:09 +01:00
}
2001-07-22 16:18:56 +02:00
/* encoder management */
2004-08-13 17:30:42 +02:00
AVCodec * first_avcodec = NULL ;
2001-07-22 16:18:56 +02:00
2007-12-12 19:40:11 +01:00
AVCodec * av_codec_next ( AVCodec * c ) {
if ( c ) return c - > next ;
else return first_avcodec ;
}
2001-07-22 16:18:56 +02:00
void register_avcodec ( AVCodec * format )
{
AVCodec * * p ;
p = & first_avcodec ;
while ( * p ! = NULL ) p = & ( * p ) - > next ;
* p = format ;
format - > next = NULL ;
}
2004-09-27 13:50:56 +02:00
void avcodec_set_dimensions ( AVCodecContext * s , int width , int height ) {
s - > coded_width = width ;
s - > coded_height = height ;
s - > width = - ( ( - width ) > > s - > lowres ) ;
s - > height = - ( ( - height ) > > s - > lowres ) ;
}
2003-04-25 02:29:48 +02:00
typedef struct InternalBuffer {
2002-12-04 11:04:03 +01:00
int last_pic_num ;
2003-04-25 02:29:48 +02:00
uint8_t * base [ 4 ] ;
2002-12-04 11:04:03 +01:00
uint8_t * data [ 4 ] ;
2003-10-30 22:05:00 +01:00
int linesize [ 4 ] ;
2007-08-10 21:28:28 +02:00
int width , height ;
enum PixelFormat pix_fmt ;
2003-04-25 02:29:48 +02:00
} InternalBuffer ;
# define INTERNAL_BUFFER_SIZE 32
2002-12-04 11:04:03 +01:00
2003-10-15 23:59:08 +02:00
# define ALIGN(x, a) (((x)+(a)-1)&~((a)-1))
void avcodec_align_dimensions ( AVCodecContext * s , int * width , int * height ) {
2005-12-17 19:14:38 +01:00
int w_align = 1 ;
int h_align = 1 ;
2003-10-15 23:59:08 +02:00
switch ( s - > pix_fmt ) {
case PIX_FMT_YUV420P :
2007-02-07 02:48:09 +01:00
case PIX_FMT_YUYV422 :
2004-07-25 12:01:36 +02:00
case PIX_FMT_UYVY422 :
2003-10-15 23:59:08 +02:00
case PIX_FMT_YUV422P :
case PIX_FMT_YUV444P :
case PIX_FMT_GRAY8 :
2006-10-24 06:57:43 +02:00
case PIX_FMT_GRAY16BE :
case PIX_FMT_GRAY16LE :
2003-10-15 23:59:08 +02:00
case PIX_FMT_YUVJ420P :
case PIX_FMT_YUVJ422P :
case PIX_FMT_YUVJ444P :
2007-09-24 15:21:41 +02:00
case PIX_FMT_YUVA420P :
2003-10-15 23:59:08 +02:00
w_align = 16 ; //FIXME check for non mpeg style codecs and use less alignment
h_align = 16 ;
break ;
case PIX_FMT_YUV411P :
2007-02-07 02:48:09 +01:00
case PIX_FMT_UYYVYY411 :
2003-10-15 23:59:08 +02:00
w_align = 32 ;
h_align = 8 ;
break ;
case PIX_FMT_YUV410P :
if ( s - > codec_id = = CODEC_ID_SVQ1 ) {
w_align = 64 ;
h_align = 64 ;
}
2004-06-27 13:07:05 +02:00
case PIX_FMT_RGB555 :
if ( s - > codec_id = = CODEC_ID_RPZA ) {
w_align = 4 ;
h_align = 4 ;
}
case PIX_FMT_PAL8 :
if ( s - > codec_id = = CODEC_ID_SMC ) {
w_align = 4 ;
h_align = 4 ;
}
2003-10-15 23:59:08 +02:00
break ;
2005-01-10 00:39:32 +01:00
case PIX_FMT_BGR24 :
if ( ( s - > codec_id = = CODEC_ID_MSZH ) | | ( s - > codec_id = = CODEC_ID_ZLIB ) ) {
w_align = 4 ;
h_align = 4 ;
}
break ;
2003-10-15 23:59:08 +02:00
default :
w_align = 1 ;
h_align = 1 ;
break ;
}
* width = ALIGN ( * width , w_align ) ;
* height = ALIGN ( * height , h_align ) ;
}
2005-01-12 01:16:25 +01:00
int avcodec_check_dimensions ( void * av_log_ctx , unsigned int w , unsigned int h ) {
if ( ( int ) w > 0 & & ( int ) h > 0 & & ( w + 128 ) * ( uint64_t ) ( h + 128 ) < INT_MAX / 4 )
return 0 ;
2005-12-17 19:14:38 +01:00
2005-01-12 01:16:25 +01:00
av_log ( av_log_ctx , AV_LOG_ERROR , " picture size invalid (%ux%u) \n " , w , h ) ;
return - 1 ;
}
2002-12-09 13:03:43 +01:00
int avcodec_default_get_buffer ( AVCodecContext * s , AVFrame * pic ) {
2002-12-04 11:04:03 +01:00
int i ;
2003-10-15 23:59:08 +02:00
int w = s - > width ;
int h = s - > height ;
2003-04-25 02:29:48 +02:00
InternalBuffer * buf ;
2003-10-30 22:05:00 +01:00
int * picture_number ;
2005-01-12 01:16:25 +01:00
2007-02-01 10:45:05 +01:00
if ( pic - > data [ 0 ] ! = NULL ) {
av_log ( s , AV_LOG_ERROR , " pic->data[0]!=NULL in avcodec_default_get_buffer \n " ) ;
return - 1 ;
}
if ( s - > internal_buffer_count > = INTERNAL_BUFFER_SIZE ) {
av_log ( s , AV_LOG_ERROR , " internal_buffer_count overflow (missing release_buffer?) \n " ) ;
return - 1 ;
}
2002-12-04 11:04:03 +01:00
2005-01-12 01:16:25 +01:00
if ( avcodec_check_dimensions ( s , w , h ) )
return - 1 ;
2003-04-25 02:29:48 +02:00
if ( s - > internal_buffer = = NULL ) {
2008-07-19 02:32:15 +02:00
s - > internal_buffer = av_mallocz ( ( INTERNAL_BUFFER_SIZE + 1 ) * sizeof ( InternalBuffer ) ) ;
2003-04-25 02:29:48 +02:00
}
#if 0
s - > internal_buffer = av_fast_realloc (
2005-12-17 19:14:38 +01:00
s - > internal_buffer ,
& s - > internal_buffer_size ,
2003-04-25 02:29:48 +02:00
sizeof ( InternalBuffer ) * FFMAX ( 99 , s - > internal_buffer_count + 1 ) /*FIXME*/
) ;
# endif
2005-12-17 19:14:38 +01:00
2003-04-25 02:29:48 +02:00
buf = & ( ( InternalBuffer * ) s - > internal_buffer ) [ s - > internal_buffer_count ] ;
2008-07-19 02:32:15 +02:00
picture_number = & ( ( ( InternalBuffer * ) s - > internal_buffer ) [ INTERNAL_BUFFER_SIZE ] ) . last_pic_num ; //FIXME ugly hack
2003-10-30 22:05:00 +01:00
( * picture_number ) + + ;
2005-12-17 19:14:38 +01:00
2007-08-10 21:28:28 +02:00
if ( buf - > base [ 0 ] & & ( buf - > width ! = w | | buf - > height ! = h | | buf - > pix_fmt ! = s - > pix_fmt ) ) {
for ( i = 0 ; i < 4 ; i + + ) {
av_freep ( & buf - > base [ i ] ) ;
buf - > data [ i ] = NULL ;
}
}
2003-04-25 02:29:48 +02:00
if ( buf - > base [ 0 ] ) {
2003-10-30 22:05:00 +01:00
pic - > age = * picture_number - buf - > last_pic_num ;
buf - > last_pic_num = * picture_number ;
2002-12-04 11:04:03 +01:00
} else {
2003-10-15 23:59:08 +02:00
int h_chroma_shift , v_chroma_shift ;
2008-02-15 21:23:49 +01:00
int size [ 4 ] = { 0 } ;
int tmpsize ;
2005-12-02 01:12:37 +01:00
AVPicture picture ;
2002-12-04 11:04:03 +01:00
avcodec_get_chroma_sub_sample ( s - > pix_fmt , & h_chroma_shift , & v_chroma_shift ) ;
2003-10-15 23:59:08 +02:00
avcodec_align_dimensions ( s , & w , & h ) ;
2005-12-17 19:14:38 +01:00
2002-12-04 11:04:03 +01:00
if ( ! ( s - > flags & CODEC_FLAG_EMU_EDGE ) ) {
w + = EDGE_WIDTH * 2 ;
h + = EDGE_WIDTH * 2 ;
}
2007-05-12 02:31:48 +02:00
avcodec_align_dimensions ( s , & w , & h ) ;
2008-02-15 21:23:49 +01:00
ff_fill_linesize ( & picture , s - > pix_fmt , w ) ;
2008-02-22 20:27:22 +01:00
for ( i = 0 ; i < 4 ; i + + )
2008-02-15 21:23:49 +01:00
picture . linesize [ i ] = ALIGN ( picture . linesize [ i ] , STRIDE_ALIGN ) ;
tmpsize = ff_fill_pointer ( & picture , NULL , s - > pix_fmt , h ) ;
for ( i = 0 ; i < 3 & & picture . data [ i + 1 ] ; i + + )
size [ i ] = picture . data [ i + 1 ] - picture . data [ i ] ;
2008-02-24 08:47:02 +01:00
size [ i ] = tmpsize - ( picture . data [ i ] - picture . data [ 0 ] ) ;
2005-12-02 01:12:37 +01:00
2003-04-25 02:29:48 +02:00
buf - > last_pic_num = - 256 * 256 * 256 * 64 ;
2005-12-02 01:12:37 +01:00
memset ( buf - > base , 0 , sizeof ( buf - > base ) ) ;
memset ( buf - > data , 0 , sizeof ( buf - > data ) ) ;
2002-12-04 11:04:03 +01:00
2007-09-24 15:21:41 +02:00
for ( i = 0 ; i < 4 & & size [ i ] ; i + + ) {
2003-04-02 12:18:29 +02:00
const int h_shift = i = = 0 ? 0 : h_chroma_shift ;
const int v_shift = i = = 0 ? 0 : v_chroma_shift ;
2002-12-04 11:04:03 +01:00
2005-12-02 01:12:37 +01:00
buf - > linesize [ i ] = picture . linesize [ i ] ;
2002-12-04 11:04:03 +01:00
2005-12-02 01:12:37 +01:00
buf - > base [ i ] = av_malloc ( size [ i ] + 16 ) ; //FIXME 16
2003-04-25 02:29:48 +02:00
if ( buf - > base [ i ] = = NULL ) return - 1 ;
2005-12-02 01:12:37 +01:00
memset ( buf - > base [ i ] , 128 , size [ i ] ) ;
// no edge if EDEG EMU or not planar YUV, we check for PAL8 redundantly to protect against a exploitable bug regression ...
2005-12-17 19:14:38 +01:00
if ( ( s - > flags & CODEC_FLAG_EMU_EDGE ) | | ( s - > pix_fmt = = PIX_FMT_PAL8 ) | | ! size [ 2 ] )
2003-04-25 02:29:48 +02:00
buf - > data [ i ] = buf - > base [ i ] ;
2002-12-04 11:04:03 +01:00
else
2004-10-26 14:47:56 +02:00
buf - > data [ i ] = buf - > base [ i ] + ALIGN ( ( buf - > linesize [ i ] * EDGE_WIDTH > > v_shift ) + ( EDGE_WIDTH > > h_shift ) , STRIDE_ALIGN ) ;
2002-12-04 11:04:03 +01:00
}
2007-08-10 21:28:28 +02:00
buf - > width = s - > width ;
buf - > height = s - > height ;
buf - > pix_fmt = s - > pix_fmt ;
2002-12-04 11:04:03 +01:00
pic - > age = 256 * 256 * 256 * 64 ;
}
2003-10-30 22:05:00 +01:00
pic - > type = FF_BUFFER_TYPE_INTERNAL ;
2002-12-04 11:04:03 +01:00
2003-04-25 02:29:48 +02:00
for ( i = 0 ; i < 4 ; i + + ) {
pic - > base [ i ] = buf - > base [ i ] ;
pic - > data [ i ] = buf - > data [ i ] ;
2003-10-30 22:05:00 +01:00
pic - > linesize [ i ] = buf - > linesize [ i ] ;
2003-04-25 02:29:48 +02:00
}
s - > internal_buffer_count + + ;
2008-08-21 01:11:26 +02:00
pic - > reordered_opaque = s - > reordered_opaque ;
2008-07-26 03:57:10 +02:00
if ( s - > debug & FF_DEBUG_BUFFERS )
av_log ( s , AV_LOG_DEBUG , " default_get_buffer called on pic %p, %d buffers used \n " , pic , s - > internal_buffer_count ) ;
2002-12-04 11:04:03 +01:00
return 0 ;
}
2002-12-09 13:03:43 +01:00
void avcodec_default_release_buffer ( AVCodecContext * s , AVFrame * pic ) {
2002-12-04 11:04:03 +01:00
int i ;
2007-02-22 00:46:25 +01:00
InternalBuffer * buf , * last ;
2003-04-25 02:29:48 +02:00
2002-12-09 01:29:17 +01:00
assert ( pic - > type = = FF_BUFFER_TYPE_INTERNAL ) ;
2003-08-05 12:19:43 +02:00
assert ( s - > internal_buffer_count ) ;
2003-04-25 02:29:48 +02:00
2003-09-10 00:59:16 +02:00
buf = NULL ; /* avoids warning */
2003-04-25 02:29:48 +02:00
for ( i = 0 ; i < s - > internal_buffer_count ; i + + ) { //just 3-5 checks so is not worth to optimize
buf = & ( ( InternalBuffer * ) s - > internal_buffer ) [ i ] ;
if ( buf - > data [ 0 ] = = pic - > data [ 0 ] )
break ;
}
assert ( i < s - > internal_buffer_count ) ;
s - > internal_buffer_count - - ;
last = & ( ( InternalBuffer * ) s - > internal_buffer ) [ s - > internal_buffer_count ] ;
2007-02-22 00:46:25 +01:00
FFSWAP ( InternalBuffer , * buf , * last ) ;
2003-04-25 02:29:48 +02:00
2007-09-24 15:21:41 +02:00
for ( i = 0 ; i < 4 ; i + + ) {
2002-12-04 11:04:03 +01:00
pic - > data [ i ] = NULL ;
2003-04-25 02:29:48 +02:00
// pic->base[i]=NULL;
}
2002-12-04 11:04:03 +01:00
//printf("R%X\n", pic->opaque);
2008-07-26 03:57:10 +02:00
if ( s - > debug & FF_DEBUG_BUFFERS )
av_log ( s , AV_LOG_DEBUG , " default_release_buffer called on pic %p, %d buffers used \n " , pic , s - > internal_buffer_count ) ;
2002-12-04 11:04:03 +01:00
}
2003-11-26 21:57:15 +01:00
int avcodec_default_reget_buffer ( AVCodecContext * s , AVFrame * pic ) {
AVFrame temp_pic ;
int i ;
/* If no picture return a new buffer */
if ( pic - > data [ 0 ] = = NULL ) {
/* We will copy from buffer, so must be readable */
pic - > buffer_hints | = FF_BUFFER_HINTS_READABLE ;
return s - > get_buffer ( s , pic ) ;
}
/* If internal buffer type return the same buffer */
if ( pic - > type = = FF_BUFFER_TYPE_INTERNAL )
return 0 ;
/*
* Not internal type and reget_buffer not overridden , emulate cr buffer
*/
temp_pic = * pic ;
for ( i = 0 ; i < 4 ; i + + )
pic - > data [ i ] = pic - > base [ i ] = NULL ;
pic - > opaque = NULL ;
/* Allocate new frame */
if ( s - > get_buffer ( s , pic ) )
return - 1 ;
/* Copy image data from old buffer to new buffer */
2007-03-04 12:53:11 +01:00
av_picture_copy ( ( AVPicture * ) pic , ( AVPicture * ) & temp_pic , s - > pix_fmt , s - > width ,
2003-11-26 21:57:15 +01:00
s - > height ) ;
s - > release_buffer ( s , & temp_pic ) ; // Release old frame
return 0 ;
}
2004-02-13 18:54:10 +01:00
int avcodec_default_execute ( AVCodecContext * c , int ( * func ) ( AVCodecContext * c2 , void * arg2 ) , void * * arg , int * ret , int count ) {
int i ;
for ( i = 0 ; i < count ; i + + ) {
int r = func ( c , arg [ i ] ) ;
if ( ret ) ret [ i ] = r ;
}
return 0 ;
}
2004-03-04 15:58:48 +01:00
enum PixelFormat avcodec_default_get_format ( struct AVCodecContext * s , const enum PixelFormat * fmt ) {
2003-01-12 01:48:29 +01:00
return fmt [ 0 ] ;
}
2004-03-03 18:53:55 +01:00
static const char * context_to_name ( void * ptr ) {
AVCodecContext * avc = ptr ;
if ( avc & & avc - > codec & & avc - > codec - > name )
2005-12-17 19:14:38 +01:00
return avc - > codec - > name ;
2004-03-03 18:53:55 +01:00
else
return " NULL " ;
}
2006-09-14 15:51:54 +02:00
# define OFFSET(x) offsetof(AVCodecContext,x)
2007-06-12 11:29:25 +02:00
# 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
2005-09-11 13:10:25 +02:00
//these names are too long to be readable
# define V AV_OPT_FLAG_VIDEO_PARAM
# define A AV_OPT_FLAG_AUDIO_PARAM
# define S AV_OPT_FLAG_SUBTITLE_PARAM
2005-12-17 19:14:38 +01:00
# define E AV_OPT_FLAG_ENCODING_PARAM
2005-09-11 13:10:25 +02:00
# define D AV_OPT_FLAG_DECODING_PARAM
2005-09-06 14:51:56 +02:00
2006-09-14 16:02:32 +02:00
# define AV_CODEC_DEFAULT_BITRATE 200*1000
2006-09-10 23:51:08 +02:00
2006-07-06 15:53:07 +02:00
static const AVOption options [ ] = {
2007-03-07 10:51:45 +01:00
{ " b " , " set bitrate (in bits/s) " , OFFSET ( bit_rate ) , FF_OPT_TYPE_INT , AV_CODEC_DEFAULT_BITRATE , INT_MIN , INT_MAX , V | E } ,
{ " ab " , " set bitrate (in bits/s) " , OFFSET ( bit_rate ) , FF_OPT_TYPE_INT , 64 * 1000 , INT_MIN , INT_MAX , A | E } ,
2006-12-22 11:10:13 +01:00
{ " 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 } ,
2008-03-29 23:27:25 +01:00
{ " flags " , NULL , OFFSET ( flags ) , FF_OPT_TYPE_FLAGS , DEFAULT , 0 , UINT_MAX , V | A | E | D , " flags " } ,
2005-09-12 21:16:07 +02:00
{ " mv4 " , " use four motion vector by macroblock (mpeg4) " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_4MV , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " obmc " , " use overlapped block motion compensation (h263+) " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_OBMC , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " qpel " , " use 1/4 pel motion compensation " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_QPEL , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " loop " , " use loop filter " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_LOOP_FILTER , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " qscale " , " use fixed qscale " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_QSCALE , INT_MIN , INT_MAX , 0 , " flags " } ,
{ " gmc " , " use gmc " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_GMC , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " mv0 " , " always try a mb with mv=<0,0> " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_MV0 , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " part " , " use data partitioning " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_PART , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " input_preserved " , NULL , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_INPUT_PRESERVED , INT_MIN , INT_MAX , 0 , " flags " } ,
{ " pass1 " , " use internal 2pass ratecontrol in first pass mode " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_PASS1 , INT_MIN , INT_MAX , 0 , " flags " } ,
{ " pass2 " , " use internal 2pass ratecontrol in second pass mode " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_PASS2 , INT_MIN , INT_MAX , 0 , " flags " } ,
{ " extern_huff " , " use external huffman table (for mjpeg) " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_EXTERN_HUFF , INT_MIN , INT_MAX , 0 , " flags " } ,
{ " gray " , " only decode/encode grayscale " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_GRAY , INT_MIN , INT_MAX , V | E | D , " flags " } ,
{ " emu_edge " , " don't draw edges " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_EMU_EDGE , INT_MIN , INT_MAX , 0 , " flags " } ,
{ " psnr " , " error[?] variables will be set during encoding " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_PSNR , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " truncated " , NULL , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_TRUNCATED , INT_MIN , INT_MAX , 0 , " flags " } ,
{ " naq " , " normalize adaptive quantization " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_NORMALIZE_AQP , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " ildct " , " use interlaced dct " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_INTERLACED_DCT , INT_MIN , INT_MAX , V | E , " flags " } ,
2006-11-13 12:30:26 +01:00
{ " low_delay " , " force low delay " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_LOW_DELAY , INT_MIN , INT_MAX , V | D | E , " flags " } ,
2005-09-12 21:16:07 +02:00
{ " alt " , " enable alternate scantable (mpeg2/mpeg4) " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_ALT_SCAN , INT_MIN , INT_MAX , V | E , " flags " } ,
2008-06-09 02:43:07 +02:00
# if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
2005-09-12 21:16:07 +02:00
{ " trell " , " use trellis quantization " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_TRELLIS_QUANT , INT_MIN , INT_MAX , V | E , " flags " } ,
2008-06-09 02:43:07 +02:00
# endif
2008-06-09 03:21:57 +02:00
{ " 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 " } ,
2005-09-12 21:16:07 +02:00
{ " 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 " } ,
{ " aic " , " h263 advanced intra coding / mpeg4 ac prediction " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_AC_PRED , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " umv " , " use unlimited motion vectors " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_H263P_UMV , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " cbp " , " use rate distortion optimization for cbp " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_CBP_RD , INT_MIN , INT_MAX , V | E , " flags " } ,
2005-09-20 23:43:45 +02:00
{ " qprd " , " use rate distortion optimization for qp selection " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_QP_RD , INT_MIN , INT_MAX , V | E , " flags " } ,
2005-09-12 21:16:07 +02:00
{ " aiv " , " h263 alternative inter vlc " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_H263P_AIV , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " slice " , NULL , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_H263P_SLICE_STRUCT , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " ilme " , " interlaced motion estimation " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_INTERLACED_ME , INT_MIN , INT_MAX , V | E , " flags " } ,
{ " 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 " } ,
2005-09-20 23:43:45 +02:00
{ " cgop " , " closed gop " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG_CLOSED_GOP , INT_MIN , INT_MAX , V | E , " flags " } ,
2005-09-12 21:16:07 +02:00
{ " fast " , " allow non spec compliant speedup tricks " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_FAST , INT_MIN , INT_MAX , V | E , " flags2 " } ,
{ " sgop " , " strictly enforce gop size " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_STRICT_GOP , INT_MIN , INT_MAX , V | E , " flags2 " } ,
{ " noout " , " skip bitstream encoding " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_NO_OUTPUT , INT_MIN , INT_MAX , V | E , " flags2 " } ,
{ " 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 " } ,
2005-09-06 14:51:56 +02:00
{ " sub_id " , NULL , OFFSET ( sub_id ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-09-13 11:03:13 +02:00
{ " me_method " , " set motion estimation method " , OFFSET ( me_method ) , FF_OPT_TYPE_INT , ME_EPZS , INT_MIN , INT_MAX , V | E , " me_method " } ,
2007-07-06 13:47:02 +02:00
# if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
{ " 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 " } ,
# endif
{ " zero " , " zero motion estimation (fastest) " , 0 , FF_OPT_TYPE_CONST , ME_ZERO , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " full " , " full motion estimation (slowest) " , 0 , FF_OPT_TYPE_CONST , ME_FULL , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " epzs " , " EPZS motion estimation (default) " , 0 , FF_OPT_TYPE_CONST , ME_EPZS , INT_MIN , INT_MAX , V | E , " me_method " } ,
2008-06-05 03:57:35 +02:00
{ " esa " , " esa motion estimation (alias for full) " , 0 , FF_OPT_TYPE_CONST , ME_FULL , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " tesa " , " tesa motion estimation " , 0 , FF_OPT_TYPE_CONST , ME_TESA , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " dia " , " dia motion estimation (alias for epzs) " , 0 , FF_OPT_TYPE_CONST , ME_EPZS , INT_MIN , INT_MAX , V | E , " me_method " } ,
2007-07-06 13:47:02 +02:00
{ " log " , " log motion estimation " , 0 , FF_OPT_TYPE_CONST , ME_LOG , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " phods " , " phods motion estimation " , 0 , FF_OPT_TYPE_CONST , ME_PHODS , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " x1 " , " X1 motion estimation " , 0 , FF_OPT_TYPE_CONST , ME_X1 , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " hex " , " hex motion estimation " , 0 , FF_OPT_TYPE_CONST , ME_HEX , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " umh " , " umh motion estimation " , 0 , FF_OPT_TYPE_CONST , ME_UMH , INT_MIN , INT_MAX , V | E , " me_method " } ,
{ " iter " , " iter motion estimation " , 0 , FF_OPT_TYPE_CONST , ME_ITER , INT_MIN , INT_MAX , V | E , " me_method " } ,
2005-09-06 14:51:56 +02:00
{ " extradata_size " , NULL , OFFSET ( extradata_size ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " time_base " , NULL , OFFSET ( time_base ) , FF_OPT_TYPE_RATIONAL , DEFAULT , INT_MIN , INT_MAX } ,
2006-09-15 12:57:20 +02:00
{ " g " , " set the group of picture size " , OFFSET ( gop_size ) , FF_OPT_TYPE_INT , 12 , INT_MIN , INT_MAX , V | E } ,
2006-12-06 09:24:29 +01:00
{ " rate_emu " , " frame rate emulation " , OFFSET ( rate_emu ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-09-15 12:57:20 +02:00
{ " ar " , " set audio sampling rate (in Hz) " , OFFSET ( sample_rate ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-10-09 13:36:42 +02:00
{ " ac " , " set number of audio channels " , OFFSET ( channels ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-01-10 21:07:29 +01:00
{ " cutoff " , " set cutoff bandwidth " , OFFSET ( cutoff ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , A | E } ,
2006-07-08 18:39:58 +02:00
{ " frame_size " , NULL , OFFSET ( frame_size ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , A | E } ,
2005-09-06 14:51:56 +02:00
{ " frame_number " , NULL , OFFSET ( frame_number ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " real_pict_num " , NULL , OFFSET ( real_pict_num ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " delay " , NULL , OFFSET ( delay ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2008-07-17 19:42:44 +02:00
{ " qcomp " , " video quantizer scale compression (VBR) " , OFFSET ( qcompress ) , FF_OPT_TYPE_FLOAT , 0.5 , - FLT_MAX , FLT_MAX , V | E } ,
{ " qblur " , " video quantizer scale blur (VBR) " , OFFSET ( qblur ) , FF_OPT_TYPE_FLOAT , 0.5 , 0 , FLT_MAX , V | E } ,
2006-10-02 12:23:59 +02:00
{ " qmin " , " min video quantizer scale (VBR) " , OFFSET ( qmin ) , FF_OPT_TYPE_INT , 2 , 1 , 51 , V | E } ,
{ " qmax " , " max video quantizer scale (VBR) " , OFFSET ( qmax ) , FF_OPT_TYPE_INT , 31 , 1 , 51 , V | E } ,
{ " qdiff " , " max difference between the quantizer scale (VBR) " , OFFSET ( max_qdiff ) , FF_OPT_TYPE_INT , 3 , INT_MIN , INT_MAX , V | E } ,
2006-09-20 10:34:13 +02:00
{ " bf " , " use 'frames' B frames " , OFFSET ( max_b_frames ) , FF_OPT_TYPE_INT , DEFAULT , 0 , FF_MAX_B_FRAMES , V | E } ,
2008-07-17 19:42:44 +02:00
{ " 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 } ,
2006-12-02 19:58:20 +01:00
{ " rc_strategy " , " ratecontrol method " , OFFSET ( rc_strategy ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " 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 } ,
2005-09-11 13:10:25 +02:00
{ " hurry_up " , NULL , OFFSET ( hurry_up ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | D } ,
2007-02-28 18:56:45 +01:00
# if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
2005-09-06 14:51:56 +02:00
{ " rtp_mode " , NULL , OFFSET ( rtp_mode ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2007-02-28 18:56:45 +01:00
# endif
2007-03-01 17:36:38 +01:00
{ " ps " , " rtp payload size in bits " , OFFSET ( rtp_payload_size ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2005-09-06 14:51:56 +02:00
{ " mv_bits " , NULL , OFFSET ( mv_bits ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " header_bits " , NULL , OFFSET ( header_bits ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " i_tex_bits " , NULL , OFFSET ( i_tex_bits ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " p_tex_bits " , NULL , OFFSET ( p_tex_bits ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " i_count " , NULL , OFFSET ( i_count ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " p_count " , NULL , OFFSET ( p_count ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " skip_count " , NULL , OFFSET ( skip_count ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " misc_bits " , NULL , OFFSET ( misc_bits ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " frame_bits " , NULL , OFFSET ( frame_bits ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " codec_tag " , NULL , OFFSET ( codec_tag ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-09-15 12:57:20 +02:00
{ " bug " , " workaround not auto detected encoder bugs " , OFFSET ( workaround_bugs ) , FF_OPT_TYPE_FLAGS , FF_BUG_AUTODETECT , INT_MIN , INT_MAX , V | D , " bug " } ,
2005-09-12 21:16:07 +02:00
{ " autodetect " , NULL , 0 , FF_OPT_TYPE_CONST , FF_BUG_AUTODETECT , INT_MIN , INT_MAX , V | D , " bug " } ,
2006-12-02 19:58:20 +01:00
{ " 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 " } ,
{ " 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 " } ,
{ " ump4 " , " (autodetected if fourcc==UMP4) " , 0 , FF_OPT_TYPE_CONST , FF_BUG_UMP4 , INT_MIN , INT_MAX , V | D , " bug " } ,
{ " no_padding " , " padding bug (autodetected) " , 0 , FF_OPT_TYPE_CONST , FF_BUG_NO_PADDING , INT_MIN , INT_MAX , V | D , " bug " } ,
2005-09-12 21:16:07 +02:00
{ " amv " , NULL , 0 , FF_OPT_TYPE_CONST , FF_BUG_AMV , INT_MIN , INT_MAX , V | D , " bug " } ,
2006-12-02 19:58:20 +01:00
{ " ac_vlc " , " illegal vlc bug (autodetected per fourcc) " , 0 , FF_OPT_TYPE_CONST , FF_BUG_AC_VLC , INT_MIN , INT_MAX , V | D , " bug " } ,
2005-09-12 21:16:07 +02:00
{ " qpel_chroma " , NULL , 0 , FF_OPT_TYPE_CONST , FF_BUG_QPEL_CHROMA , INT_MIN , INT_MAX , V | D , " bug " } ,
2006-12-02 19:58:20 +01:00
{ " 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 " } ,
2005-09-12 21:16:07 +02:00
{ " qpel_chroma2 " , NULL , 0 , FF_OPT_TYPE_CONST , FF_BUG_QPEL_CHROMA2 , INT_MIN , INT_MAX , V | D , " bug " } ,
2006-12-02 19:58:20 +01:00
{ " 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 " } ,
{ " edge " , " edge padding bug (autodetected per fourcc/version) " , 0 , FF_OPT_TYPE_CONST , FF_BUG_EDGE , INT_MIN , INT_MAX , V | D , " bug " } ,
2005-09-12 21:16:07 +02:00
{ " hpel_chroma " , NULL , 0 , FF_OPT_TYPE_CONST , FF_BUG_HPEL_CHROMA , INT_MIN , INT_MAX , V | D , " bug " } ,
{ " dc_clip " , NULL , 0 , FF_OPT_TYPE_CONST , FF_BUG_DC_CLIP , INT_MIN , INT_MAX , V | D , " bug " } ,
2006-12-06 09:24:29 +01:00
{ " ms " , " workaround various bugs in microsofts broken decoders " , 0 , FF_OPT_TYPE_CONST , FF_BUG_MS , INT_MIN , INT_MAX , V | D , " bug " } ,
2005-09-12 21:16:07 +02:00
{ " 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 } ,
{ " 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 } ,
2008-07-19 17:57:06 +02:00
{ " 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 " } ,
{ " 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 " } ,
{ " 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 " } ,
{ " normal " , NULL , 0 , FF_OPT_TYPE_CONST , FF_COMPLIANCE_NORMAL , INT_MIN , INT_MAX , V | D | E , " strict " } ,
{ " inofficial " , " allow inofficial extensions " , 0 , FF_OPT_TYPE_CONST , FF_COMPLIANCE_INOFFICIAL , INT_MIN , INT_MAX , V | D | E , " strict " } ,
{ " experimental " , " allow non standardized experimental things " , 0 , FF_OPT_TYPE_CONST , FF_COMPLIANCE_EXPERIMENTAL , INT_MIN , INT_MAX , V | D | E , " strict " } ,
2008-07-17 19:42:44 +02:00
{ " 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 } ,
2007-01-15 00:19:22 +01:00
{ " er " , " set error resilience strategy " , OFFSET ( error_resilience ) , FF_OPT_TYPE_INT , FF_ER_CAREFUL , INT_MIN , INT_MAX , A | V | D , " er " } ,
2005-09-12 21:16:07 +02:00
{ " careful " , NULL , 0 , FF_OPT_TYPE_CONST , FF_ER_CAREFUL , INT_MIN , INT_MAX , V | D , " er " } ,
{ " compliant " , NULL , 0 , FF_OPT_TYPE_CONST , FF_ER_COMPLIANT , INT_MIN , INT_MAX , V | D , " er " } ,
{ " aggressive " , NULL , 0 , FF_OPT_TYPE_CONST , FF_ER_AGGRESSIVE , INT_MIN , INT_MAX , V | D , " er " } ,
{ " very_aggressive " , NULL , 0 , FF_OPT_TYPE_CONST , FF_ER_VERY_AGGRESSIVE , INT_MIN , INT_MAX , V | D , " er " } ,
2005-09-06 14:51:56 +02:00
{ " has_b_frames " , NULL , OFFSET ( has_b_frames ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " block_align " , NULL , OFFSET ( block_align ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " parse_only " , NULL , OFFSET ( parse_only ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-12-02 19:58:20 +01:00
{ " mpeg_quant " , " use MPEG quantizers instead of H.263 " , OFFSET ( mpeg_quant ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2005-09-06 14:51:56 +02:00
{ " stats_out " , NULL , OFFSET ( stats_out ) , FF_OPT_TYPE_STRING , DEFAULT , CHAR_MIN , CHAR_MAX } ,
{ " stats_in " , NULL , OFFSET ( stats_in ) , FF_OPT_TYPE_STRING , DEFAULT , CHAR_MIN , CHAR_MAX } ,
2006-10-02 12:23:59 +02:00
{ " 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 } ,
2006-12-02 19:58:20 +01:00
{ " rc_qmod_amp " , " experimental quantizer modulation " , OFFSET ( rc_qmod_amp ) , FF_OPT_TYPE_FLOAT , DEFAULT , - FLT_MAX , FLT_MAX , V | E } ,
{ " rc_qmod_freq " , " experimental quantizer modulation " , OFFSET ( rc_qmod_freq ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2005-09-06 14:51:56 +02:00
{ " rc_override_count " , NULL , OFFSET ( rc_override_count ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-09-13 11:03:13 +02:00
{ " rc_eq " , " set rate control equation " , OFFSET ( rc_eq ) , FF_OPT_TYPE_STRING , DEFAULT , CHAR_MIN , CHAR_MAX , V | E } ,
2006-09-15 12:57:20 +02:00
{ " maxrate " , " set max video bitrate tolerance (in bits/s) " , OFFSET ( rc_max_rate ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " minrate " , " set min video bitrate tolerance (in bits/s) " , OFFSET ( rc_min_rate ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2007-12-03 11:02:26 +01:00
{ " bufsize " , " set ratecontrol buffer size (in bits) " , OFFSET ( rc_buffer_size ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , A | V | E } ,
2008-07-17 19:42:44 +02:00
{ " rc_buf_aggressivity " , " currently useless " , OFFSET ( rc_buffer_aggressivity ) , FF_OPT_TYPE_FLOAT , 1.0 , - FLT_MAX , FLT_MAX , V | E } ,
2008-03-13 00:58:46 +01:00
{ " 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 } ,
{ " 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 } ,
2006-09-20 10:27:18 +02:00
{ " rc_init_cplx " , " initial complexity for 1-pass encoding " , OFFSET ( rc_initial_cplx ) , FF_OPT_TYPE_FLOAT , DEFAULT , - FLT_MAX , FLT_MAX , V | E } ,
2006-12-02 19:58:20 +01:00
{ " dct " , " DCT algorithm " , OFFSET ( dct_algo ) , FF_OPT_TYPE_INT , DEFAULT , 0 , INT_MAX , V | E , " dct " } ,
{ " auto " , " autoselect a good one (default) " , 0 , FF_OPT_TYPE_CONST , FF_DCT_AUTO , INT_MIN , INT_MAX , V | E , " dct " } ,
{ " fastint " , " fast integer " , 0 , FF_OPT_TYPE_CONST , FF_DCT_FASTINT , INT_MIN , INT_MAX , V | E , " dct " } ,
{ " int " , " accurate integer " , 0 , FF_OPT_TYPE_CONST , FF_DCT_INT , INT_MIN , INT_MAX , V | E , " dct " } ,
2005-09-12 21:16:07 +02:00
{ " mmx " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DCT_MMX , INT_MIN , INT_MAX , V | E , " dct " } ,
{ " mlib " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DCT_MLIB , INT_MIN , INT_MAX , V | E , " dct " } ,
{ " altivec " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DCT_ALTIVEC , INT_MIN , INT_MAX , V | E , " dct " } ,
2006-12-04 13:04:53 +01:00
{ " faan " , " floating point AAN DCT " , 0 , FF_OPT_TYPE_CONST , FF_DCT_FAAN , INT_MIN , INT_MAX , V | E , " dct " } ,
2006-12-02 19:58:20 +01:00
{ " lumi_mask " , " compresses bright areas stronger than medium ones " , OFFSET ( lumi_masking ) , FF_OPT_TYPE_FLOAT , 0 , - FLT_MAX , FLT_MAX , V | E } ,
2006-09-20 10:27:18 +02:00
{ " tcplx_mask " , " temporal complexity masking " , OFFSET ( temporal_cplx_masking ) , FF_OPT_TYPE_FLOAT , 0 , - FLT_MAX , FLT_MAX , V | E } ,
{ " scplx_mask " , " spatial complexity masking " , OFFSET ( spatial_cplx_masking ) , FF_OPT_TYPE_FLOAT , 0 , - FLT_MAX , FLT_MAX , V | E } ,
{ " p_mask " , " inter masking " , OFFSET ( p_masking ) , FF_OPT_TYPE_FLOAT , 0 , - FLT_MAX , FLT_MAX , V | E } ,
2006-12-02 19:58:20 +01:00
{ " dark_mask " , " compresses dark areas stronger than medium ones " , OFFSET ( dark_masking ) , FF_OPT_TYPE_FLOAT , 0 , - FLT_MAX , FLT_MAX , V | E } ,
2005-09-06 14:51:56 +02:00
{ " unused " , NULL , OFFSET ( unused ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-12-11 11:51:42 +01:00
{ " idct " , " select IDCT implementation " , OFFSET ( idct_algo ) , FF_OPT_TYPE_INT , DEFAULT , 0 , INT_MAX , V | E | D , " idct " } ,
2005-09-12 21:16:07 +02:00
{ " auto " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_AUTO , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " int " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_INT , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " simple " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_SIMPLE , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " simplemmx " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_SIMPLEMMX , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " libmpeg2mmx " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_LIBMPEG2MMX , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " ps2 " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_PS2 , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " mlib " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_MLIB , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " arm " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_ARM , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " altivec " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_ALTIVEC , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " sh4 " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_SH4 , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " simplearm " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_SIMPLEARM , INT_MIN , INT_MAX , V | E | D , " idct " } ,
2006-09-26 22:26:22 +02:00
{ " simplearmv5te " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_SIMPLEARMV5TE , INT_MIN , INT_MAX , V | E | D , " idct " } ,
2008-06-29 10:32:27 +02:00
{ " simplearmv6 " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_SIMPLEARMV6 , INT_MIN , INT_MAX , V | E | D , " idct " } ,
2005-09-12 21:16:07 +02:00
{ " h264 " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_H264 , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " vp3 " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_VP3 , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " ipp " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_IPP , INT_MIN , INT_MAX , V | E | D , " idct " } ,
{ " xvidmmx " , NULL , 0 , FF_OPT_TYPE_CONST , FF_IDCT_XVIDMMX , INT_MIN , INT_MAX , V | E | D , " idct " } ,
2008-02-26 15:59:11 +01:00
{ " faani " , " floating point AAN IDCT " , 0 , FF_OPT_TYPE_CONST , FF_IDCT_FAAN , INT_MIN , INT_MAX , V | D | E , " idct " } ,
2005-09-06 14:51:56 +02:00
{ " slice_count " , NULL , OFFSET ( slice_count ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-12-02 19:58:20 +01:00
{ " ec " , " set error concealment strategy " , OFFSET ( error_concealment ) , FF_OPT_TYPE_FLAGS , 3 , INT_MIN , INT_MAX , V | D , " ec " } ,
{ " guess_mvs " , " iterative motion vector (MV) search (slow) " , 0 , FF_OPT_TYPE_CONST , FF_EC_GUESS_MVS , INT_MIN , INT_MAX , V | D , " ec " } ,
{ " deblock " , " use strong deblock filter for damaged MBs " , 0 , FF_OPT_TYPE_CONST , FF_EC_DEBLOCK , INT_MIN , INT_MAX , V | D , " ec " } ,
2005-09-06 14:51:56 +02:00
{ " bits_per_sample " , NULL , OFFSET ( bits_per_sample ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2005-09-20 23:43:45 +02:00
{ " pred " , " prediction method " , OFFSET ( prediction_method ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E , " pred " } ,
2005-09-12 21:16:07 +02:00
{ " left " , NULL , 0 , FF_OPT_TYPE_CONST , FF_PRED_LEFT , INT_MIN , INT_MAX , V | E , " pred " } ,
{ " plane " , NULL , 0 , FF_OPT_TYPE_CONST , FF_PRED_PLANE , INT_MIN , INT_MAX , V | E , " pred " } ,
{ " median " , NULL , 0 , FF_OPT_TYPE_CONST , FF_PRED_MEDIAN , INT_MIN , INT_MAX , V | E , " pred " } ,
2006-12-06 09:24:29 +01:00
{ " aspect " , " sample aspect ratio " , OFFSET ( sample_aspect_ratio ) , FF_OPT_TYPE_RATIONAL , DEFAULT , 0 , 10 , V | E } ,
2005-09-12 12:23:52 +02:00
{ " debug " , " print specific debug info " , OFFSET ( debug ) , FF_OPT_TYPE_FLAGS , DEFAULT , 0 , INT_MAX , V | A | S | E | D , " debug " } ,
2006-12-02 19:58:20 +01:00
{ " pict " , " picture info " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_PICT_INFO , INT_MIN , INT_MAX , V | D , " debug " } ,
{ " rc " , " rate control " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_RC , INT_MIN , INT_MAX , V | E , " debug " } ,
2005-09-12 21:16:07 +02:00
{ " bitstream " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_BITSTREAM , INT_MIN , INT_MAX , V | D , " debug " } ,
2006-12-02 19:58:20 +01:00
{ " mb_type " , " macroblock (MB) type " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_MB_TYPE , INT_MIN , INT_MAX , V | D , " debug " } ,
{ " qp " , " per-block quantization parameter (QP) " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_QP , INT_MIN , INT_MAX , V | D , " debug " } ,
{ " mv " , " motion vector " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_MV , INT_MIN , INT_MAX , V | D , " debug " } ,
2005-09-12 21:16:07 +02:00
{ " dct_coeff " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_DCT_COEFF , INT_MIN , INT_MAX , V | D , " debug " } ,
{ " skip " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_SKIP , INT_MIN , INT_MAX , V | D , " debug " } ,
{ " startcode " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_STARTCODE , INT_MIN , INT_MAX , V | D , " debug " } ,
{ " pts " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_PTS , INT_MIN , INT_MAX , V | D , " debug " } ,
2006-12-02 19:58:20 +01:00
{ " er " , " error resilience " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_ER , INT_MIN , INT_MAX , V | D , " debug " } ,
{ " mmco " , " memory management control operations (H.264) " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_MMCO , INT_MIN , INT_MAX , V | D , " debug " } ,
2005-09-12 21:16:07 +02:00
{ " bugs " , NULL , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_BUGS , INT_MIN , INT_MAX , V | D , " debug " } ,
2006-12-02 19:58:20 +01:00
{ " 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 " } ,
{ " vis_mb_type " , " visualize block types " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_VIS_MB_TYPE , INT_MIN , INT_MAX , V | D , " debug " } ,
2008-07-26 03:57:10 +02:00
{ " buffers " , " picture buffer allocations " , 0 , FF_OPT_TYPE_CONST , FF_DEBUG_BUFFERS , INT_MIN , INT_MAX , V | D , " debug " } ,
2006-12-02 19:58:20 +01:00
{ " vismv " , " visualize motion vectors (MVs) " , OFFSET ( debug_mv ) , FF_OPT_TYPE_INT , DEFAULT , 0 , INT_MAX , V | D , " debug_mv " } ,
{ " 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 " } ,
{ " 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 " } ,
{ " 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 " } ,
2006-12-13 12:10:41 +01:00
{ " mb_qmin " , " obsolete, use qmin " , OFFSET ( mb_qmin ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " mb_qmax " , " obsolete, use qmax " , OFFSET ( mb_qmax ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2005-09-12 21:16:07 +02:00
{ " cmp " , " full pel me compare function " , OFFSET ( me_cmp ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " subcmp " , " sub pel me compare function " , OFFSET ( me_sub_cmp ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
2005-09-12 14:07:08 +02:00
{ " mbcmp " , " macroblock compare function " , OFFSET ( mb_cmp ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
2006-09-10 23:51:08 +02:00
{ " ildctcmp " , " interlaced dct compare function " , OFFSET ( ildct_cmp ) , FF_OPT_TYPE_INT , FF_CMP_VSAD , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
2006-12-02 19:58:20 +01:00
{ " dia_size " , " diamond type & size for motion estimation " , OFFSET ( dia_size ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " 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 } ,
2006-09-13 11:03:13 +02:00
{ " preme " , " pre motion estimation " , OFFSET ( pre_me ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2005-09-12 14:07:08 +02:00
{ " precmp " , " pre motion estimation compare function " , OFFSET ( me_pre_cmp ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
2006-12-02 19:58:20 +01:00
{ " sad " , " sum of absolute differences, fast (default) " , 0 , FF_OPT_TYPE_CONST , FF_CMP_SAD , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " sse " , " sum of squared errors " , 0 , FF_OPT_TYPE_CONST , FF_CMP_SSE , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " satd " , " sum of absolute Hadamard transformed differences " , 0 , FF_OPT_TYPE_CONST , FF_CMP_SATD , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " dct " , " sum of absolute DCT transformed differences " , 0 , FF_OPT_TYPE_CONST , FF_CMP_DCT , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " 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 " } ,
{ " bit " , " number of bits needed for the block " , 0 , FF_OPT_TYPE_CONST , FF_CMP_BIT , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " rd " , " rate distortion optimal, slow " , 0 , FF_OPT_TYPE_CONST , FF_CMP_RD , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " zero " , " 0 " , 0 , FF_OPT_TYPE_CONST , FF_CMP_ZERO , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " vsad " , " sum of absolute vertical differences " , 0 , FF_OPT_TYPE_CONST , FF_CMP_VSAD , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " vsse " , " sum of squared vertical differences " , 0 , FF_OPT_TYPE_CONST , FF_CMP_VSSE , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " nsse " , " noise preserving sum of squared differences " , 0 , FF_OPT_TYPE_CONST , FF_CMP_NSSE , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
2006-06-30 09:50:30 +02:00
# ifdef CONFIG_SNOW_ENCODER
2006-12-02 19:58:20 +01:00
{ " w53 " , " 5/3 wavelet, only used in snow " , 0 , FF_OPT_TYPE_CONST , FF_CMP_W53 , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " w97 " , " 9/7 wavelet, only used in snow " , 0 , FF_OPT_TYPE_CONST , FF_CMP_W97 , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
2006-06-30 09:50:30 +02:00
# endif
2005-09-12 21:16:07 +02:00
{ " dctmax " , NULL , 0 , FF_OPT_TYPE_CONST , FF_CMP_DCTMAX , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
{ " chroma " , NULL , 0 , FF_OPT_TYPE_CONST , FF_CMP_CHROMA , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
2006-12-02 19:58:20 +01:00
{ " 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 } ,
2006-09-10 23:51:08 +02:00
{ " subq " , " sub pel motion estimation quality " , OFFSET ( me_subpel_quality ) , FF_OPT_TYPE_INT , 8 , INT_MIN , INT_MAX , V | E } ,
2005-09-06 14:51:56 +02:00
{ " dtg_active_format " , NULL , OFFSET ( dtg_active_format ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-09-13 11:03:13 +02:00
{ " me_range " , " limit motion vectors range (1023 for DivX player) " , OFFSET ( me_range ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " ibias " , " intra quant bias " , OFFSET ( intra_quant_bias ) , FF_OPT_TYPE_INT , FF_DEFAULT_QUANT_BIAS , INT_MIN , INT_MAX , V | E } ,
{ " pbias " , " inter quant bias " , OFFSET ( inter_quant_bias ) , FF_OPT_TYPE_INT , FF_DEFAULT_QUANT_BIAS , INT_MIN , INT_MAX , V | E } ,
2005-09-06 14:51:56 +02:00
{ " color_table_id " , NULL , OFFSET ( color_table_id ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " internal_buffer_count " , NULL , OFFSET ( internal_buffer_count ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " global_quality " , NULL , OFFSET ( global_quality ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2005-09-12 14:07:08 +02:00
{ " coder " , NULL , OFFSET ( coder_type ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E , " coder " } ,
2005-09-20 23:43:45 +02:00
{ " vlc " , " variable length coder / huffman coder " , 0 , FF_OPT_TYPE_CONST , FF_CODER_TYPE_VLC , INT_MIN , INT_MAX , V | E , " coder " } ,
{ " ac " , " arithmetic coder " , 0 , FF_OPT_TYPE_CONST , FF_CODER_TYPE_AC , INT_MIN , INT_MAX , V | E , " coder " } ,
2007-04-03 15:52:00 +02:00
{ " raw " , " raw (no encoding) " , 0 , FF_OPT_TYPE_CONST , FF_CODER_TYPE_RAW , INT_MIN , INT_MAX , V | E , " coder " } ,
2007-04-03 15:53:25 +02:00
{ " rle " , " run-length coder " , 0 , FF_OPT_TYPE_CONST , FF_CODER_TYPE_RLE , INT_MIN , INT_MAX , V | E , " coder " } ,
2007-04-03 15:52:00 +02:00
{ " deflate " , " deflate-based coder " , 0 , FF_OPT_TYPE_CONST , FF_CODER_TYPE_DEFLATE , INT_MIN , INT_MAX , V | E , " coder " } ,
2005-09-20 23:43:45 +02:00
{ " context " , " context model " , OFFSET ( context_model ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2005-09-06 14:51:56 +02:00
{ " slice_flags " , NULL , OFFSET ( slice_flags ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
{ " xvmc_acceleration " , NULL , OFFSET ( xvmc_acceleration ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2007-09-27 05:16:25 +02:00
{ " mbd " , " macroblock decision algorithm (high quality mode) " , OFFSET ( mb_decision ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E , " mbd " } ,
2006-12-02 19:58:20 +01:00
{ " simple " , " use mbcmp (default) " , 0 , FF_OPT_TYPE_CONST , FF_MB_DECISION_SIMPLE , INT_MIN , INT_MAX , V | E , " mbd " } ,
{ " bits " , " use fewest bits " , 0 , FF_OPT_TYPE_CONST , FF_MB_DECISION_BITS , INT_MIN , INT_MAX , V | E , " mbd " } ,
{ " rd " , " use best rate distortion " , 0 , FF_OPT_TYPE_CONST , FF_MB_DECISION_RD , INT_MIN , INT_MAX , V | E , " mbd " } ,
2005-09-06 14:51:56 +02:00
{ " stream_codec_tag " , NULL , OFFSET ( stream_codec_tag ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-09-13 11:03:13 +02:00
{ " sc_threshold " , " scene change threshold " , OFFSET ( scenechange_threshold ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " lmin " , " min lagrange factor (VBR) " , OFFSET ( lmin ) , FF_OPT_TYPE_INT , 2 * FF_QP2LAMBDA , 0 , INT_MAX , V | E } ,
{ " lmax " , " max lagrange factor (VBR) " , OFFSET ( lmax ) , FF_OPT_TYPE_INT , 31 * FF_QP2LAMBDA , 0 , INT_MAX , V | E } ,
2005-09-20 23:43:45 +02:00
{ " nr " , " noise reduction " , OFFSET ( noise_reduction ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2006-12-06 09:24:29 +01:00
{ " 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 } ,
2005-09-11 13:10:25 +02:00
{ " inter_threshold " , NULL , OFFSET ( inter_threshold ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2008-03-29 23:27:25 +01:00
{ " flags2 " , NULL , OFFSET ( flags2 ) , FF_OPT_TYPE_FLAGS , CODEC_FLAG2_FASTPSKIP | CODEC_FLAG2_BIT_RESERVOIR , 0 , UINT_MAX , V | A | E | D , " flags2 " } ,
2006-09-22 17:05:27 +02:00
{ " error " , NULL , OFFSET ( error_rate ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2006-12-06 09:24:29 +01:00
{ " antialias " , " MP3 antialias algorithm " , OFFSET ( antialias_algo ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | D , " aa " } ,
2005-09-12 21:16:07 +02:00
{ " auto " , NULL , 0 , FF_OPT_TYPE_CONST , FF_AA_AUTO , INT_MIN , INT_MAX , V | D , " aa " } ,
{ " fastint " , NULL , 0 , FF_OPT_TYPE_CONST , FF_AA_FASTINT , INT_MIN , INT_MAX , V | D , " aa " } ,
{ " int " , NULL , 0 , FF_OPT_TYPE_CONST , FF_AA_INT , INT_MIN , INT_MAX , V | D , " aa " } ,
{ " float " , NULL , 0 , FF_OPT_TYPE_CONST , FF_AA_FLOAT , INT_MIN , INT_MAX , V | D , " aa " } ,
2005-09-20 23:43:45 +02:00
{ " qns " , " quantizer noise shaping " , OFFSET ( quantizer_noise_shaping ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2006-09-15 12:57:20 +02:00
{ " threads " , NULL , OFFSET ( thread_count ) , FF_OPT_TYPE_INT , 1 , INT_MIN , INT_MAX , V | E | D } ,
2005-09-12 12:23:52 +02:00
{ " me_threshold " , " motion estimaton threshold " , OFFSET ( me_threshold ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX } ,
2006-09-22 15:55:56 +02:00
{ " mb_threshold " , " macroblock threshold " , OFFSET ( mb_threshold ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2006-09-26 10:49:24 +02:00
{ " dc " , " intra_dc_precision " , OFFSET ( intra_dc_precision ) , FF_OPT_TYPE_INT , 0 , INT_MIN , INT_MAX , V | E } ,
2005-09-20 23:43:45 +02:00
{ " nssew " , " nsse weight " , OFFSET ( nsse_weight ) , FF_OPT_TYPE_INT , 8 , INT_MIN , INT_MAX , V | E } ,
2006-12-06 09:24:29 +01:00
{ " 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 } ,
{ " 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 } ,
2005-09-12 14:07:08 +02:00
{ " profile " , NULL , OFFSET ( profile ) , FF_OPT_TYPE_INT , FF_PROFILE_UNKNOWN , INT_MIN , INT_MAX , V | A | E , " profile " } ,
2005-09-12 21:16:07 +02:00
{ " unknown " , NULL , 0 , FF_OPT_TYPE_CONST , FF_PROFILE_UNKNOWN , INT_MIN , INT_MAX , V | A | E , " profile " } ,
2007-05-02 15:49:08 +02:00
{ " aac_main " , NULL , 0 , FF_OPT_TYPE_CONST , FF_PROFILE_AAC_MAIN , INT_MIN , INT_MAX , A | E , " profile " } ,
{ " aac_low " , NULL , 0 , FF_OPT_TYPE_CONST , FF_PROFILE_AAC_LOW , INT_MIN , INT_MAX , A | E , " profile " } ,
{ " aac_ssr " , NULL , 0 , FF_OPT_TYPE_CONST , FF_PROFILE_AAC_SSR , INT_MIN , INT_MAX , A | E , " profile " } ,
{ " aac_ltp " , NULL , 0 , FF_OPT_TYPE_CONST , FF_PROFILE_AAC_LTP , INT_MIN , INT_MAX , A | E , " profile " } ,
2005-09-12 14:07:08 +02:00
{ " level " , NULL , OFFSET ( level ) , FF_OPT_TYPE_INT , FF_LEVEL_UNKNOWN , INT_MIN , INT_MAX , V | A | E , " level " } ,
2005-09-12 21:16:07 +02:00
{ " unknown " , NULL , 0 , FF_OPT_TYPE_CONST , FF_LEVEL_UNKNOWN , INT_MIN , INT_MAX , V | A | E , " level " } ,
2006-12-02 19:58:20 +01:00
{ " 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 } ,
2006-09-15 12:57:20 +02:00
{ " skip_threshold " , " frame skip threshold " , OFFSET ( frame_skip_threshold ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " skip_factor " , " frame skip factor " , OFFSET ( frame_skip_factor ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " skip_exp " , " frame skip exponent " , OFFSET ( frame_skip_exp ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2005-11-02 10:18:32 +01:00
{ " skipcmp " , " frame skip compare function " , OFFSET ( frame_skip_cmp ) , FF_OPT_TYPE_INT , FF_CMP_DCTMAX , INT_MIN , INT_MAX , V | E , " cmp_func " } ,
2006-12-02 19:58:20 +01:00
{ " border_mask " , " increases the quantizer for macroblocks close to borders " , OFFSET ( border_masking ) , FF_OPT_TYPE_FLOAT , DEFAULT , - FLT_MAX , FLT_MAX , V | E } ,
2006-11-03 00:08:09 +01:00
{ " mblmin " , " min macroblock lagrange factor (VBR) " , OFFSET ( mb_lmin ) , FF_OPT_TYPE_INT , FF_QP2LAMBDA * 2 , 1 , FF_LAMBDA_MAX , V | E } ,
{ " mblmax " , " max macroblock lagrange factor (VBR) " , OFFSET ( mb_lmax ) , FF_OPT_TYPE_INT , FF_QP2LAMBDA * 31 , 1 , FF_LAMBDA_MAX , V | E } ,
2006-09-22 17:04:56 +02:00
{ " mepc " , " motion estimation bitrate penalty compensation (1.0 = 256) " , OFFSET ( me_penalty_compensation ) , FF_OPT_TYPE_INT , 256 , INT_MIN , INT_MAX , V | E } ,
2008-07-20 18:02:49 +02:00
{ " skip_loop_filter " , NULL , OFFSET ( skip_loop_filter ) , FF_OPT_TYPE_INT , AVDISCARD_DEFAULT , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
{ " skip_idct " , NULL , OFFSET ( skip_idct ) , FF_OPT_TYPE_INT , AVDISCARD_DEFAULT , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
{ " skip_frame " , NULL , OFFSET ( skip_frame ) , FF_OPT_TYPE_INT , AVDISCARD_DEFAULT , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
{ " none " , NULL , 0 , FF_OPT_TYPE_CONST , AVDISCARD_NONE , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
{ " default " , NULL , 0 , FF_OPT_TYPE_CONST , AVDISCARD_DEFAULT , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
{ " noref " , NULL , 0 , FF_OPT_TYPE_CONST , AVDISCARD_NONREF , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
{ " bidir " , NULL , 0 , FF_OPT_TYPE_CONST , AVDISCARD_BIDIR , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
{ " nokey " , NULL , 0 , FF_OPT_TYPE_CONST , AVDISCARD_NONKEY , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
{ " all " , NULL , 0 , FF_OPT_TYPE_CONST , AVDISCARD_ALL , INT_MIN , INT_MAX , V | D , " avdiscard " } ,
2006-12-02 19:58:20 +01:00
{ " bidir_refine " , " refine the two motion vectors used in bidirectional macroblocks " , OFFSET ( bidir_refine ) , FF_OPT_TYPE_INT , DEFAULT , 0 , 4 , V | E } ,
{ " brd_scale " , " downscales frames for dynamic B-frame decision " , OFFSET ( brd_scale ) , FF_OPT_TYPE_INT , DEFAULT , 0 , 10 , V | E } ,
{ " crf " , " enables constant quality mode, and selects the quality (x264) " , OFFSET ( crf ) , FF_OPT_TYPE_FLOAT , DEFAULT , 0 , 51 , V | E } ,
2006-12-06 09:24:29 +01:00
{ " cqp " , " constant quantization parameter rate control method " , OFFSET ( cqp ) , FF_OPT_TYPE_INT , - 1 , INT_MIN , INT_MAX , V | E } ,
2006-12-02 19:58:20 +01:00
{ " keyint_min " , " minimum interval between IDR-frames (x264) " , OFFSET ( keyint_min ) , FF_OPT_TYPE_INT , 25 , INT_MIN , INT_MAX , V | E } ,
{ " refs " , " reference frames to consider for motion compensation (Snow) " , OFFSET ( refs ) , FF_OPT_TYPE_INT , 1 , INT_MIN , INT_MAX , V | E } ,
2006-12-06 09:24:29 +01:00
{ " chromaoffset " , " chroma qp offset from luma " , OFFSET ( chromaoffset ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
{ " bframebias " , " influences how often B-frames are used " , OFFSET ( bframebias ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | E } ,
2006-12-02 19:58:20 +01:00
{ " trellis " , " rate-distortion optimal quantization " , OFFSET ( trellis ) , FF_OPT_TYPE_INT , DEFAULT , INT_MIN , INT_MAX , V | A | E } ,
2006-12-06 09:24:29 +01:00
{ " directpred " , " direct mv prediction mode - 0 (none), 1 (spatial), 2 (temporal) " , OFFSET ( directpred ) , FF_OPT_TYPE_INT , 2 , INT_MIN , INT_MAX , V | E } ,
2006-12-02 19:58:20 +01:00
{ " 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 " } ,
2006-12-06 09:24:29 +01:00
{ " wpred " , " weighted biprediction for b-frames (H.264) " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_WPRED , INT_MIN , INT_MAX , V | E , " flags2 " } ,
2006-12-06 18:04:23 +01:00
{ " 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 " } ,
2007-03-24 13:07:07 +01:00
{ " dct8x8 " , " high profile 8x8 transform (H.264) " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_8X8DCT , INT_MIN , INT_MAX , V | E , " flags2 " } ,
2006-12-06 09:24:29 +01:00
{ " fastpskip " , " fast pskip (H.264) " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_FASTPSKIP , INT_MIN , INT_MAX , V | E , " flags2 " } ,
{ " aud " , " access unit delimiters (H.264) " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_AUD , INT_MIN , INT_MAX , V | E , " flags2 " } ,
{ " brdo " , " b-frame rate-distortion optimization " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_BRDO , INT_MIN , INT_MAX , V | E , " flags2 " } ,
2007-04-07 16:10:02 +02:00
{ " skiprd " , " RD optimal MB level residual skipping " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_SKIP_RD , INT_MIN , INT_MAX , V | E , " flags2 " } ,
2006-12-06 09:24:29 +01:00
{ " complexityblur " , " reduce fluctuations in qp (before curve compression) " , OFFSET ( complexityblur ) , FF_OPT_TYPE_FLOAT , 20.0 , FLT_MIN , FLT_MAX , V | E } ,
{ " deblockalpha " , " in-loop deblocking filter alphac0 parameter " , OFFSET ( deblockalpha ) , FF_OPT_TYPE_INT , DEFAULT , - 6 , 6 , V | E } ,
{ " deblockbeta " , " in-loop deblocking filter beta parameter " , OFFSET ( deblockbeta ) , FF_OPT_TYPE_INT , DEFAULT , - 6 , 6 , V | E } ,
{ " partitions " , " macroblock subpartition sizes to consider " , OFFSET ( partitions ) , FF_OPT_TYPE_FLAGS , DEFAULT , INT_MIN , INT_MAX , V | E , " partitions " } ,
2005-12-29 08:24:23 +01:00
{ " parti4x4 " , NULL , 0 , FF_OPT_TYPE_CONST , X264_PART_I4X4 , INT_MIN , INT_MAX , V | E , " partitions " } ,
{ " parti8x8 " , NULL , 0 , FF_OPT_TYPE_CONST , X264_PART_I8X8 , INT_MIN , INT_MAX , V | E , " partitions " } ,
{ " partp4x4 " , NULL , 0 , FF_OPT_TYPE_CONST , X264_PART_P4X4 , INT_MIN , INT_MAX , V | E , " partitions " } ,
{ " partp8x8 " , NULL , 0 , FF_OPT_TYPE_CONST , X264_PART_P8X8 , INT_MIN , INT_MAX , V | E , " partitions " } ,
{ " partb8x8 " , NULL , 0 , FF_OPT_TYPE_CONST , X264_PART_B8X8 , INT_MIN , INT_MAX , V | E , " partitions " } ,
2006-12-06 09:24:29 +01:00
{ " 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 } ,
2006-05-07 13:48:07 +02:00
{ " mv0_threshold " , NULL , OFFSET ( mv0_threshold ) , FF_OPT_TYPE_INT , 256 , 0 , INT_MAX , V | E } ,
2006-05-13 19:16:58 +02:00
{ " ivlc " , " intra vlc table " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_INTRA_VLC , INT_MIN , INT_MAX , V | E , " flags2 " } ,
2006-12-06 09:24:29 +01:00
{ " b_sensitivity " , " adjusts sensitivity of b_frame_strategy 1 " , OFFSET ( b_sensitivity ) , FF_OPT_TYPE_INT , 40 , 1 , INT_MAX , V | E } ,
2006-07-02 12:22:31 +02:00
{ " compression_level " , NULL , OFFSET ( compression_level ) , FF_OPT_TYPE_INT , FF_COMPRESSION_DEFAULT , INT_MIN , INT_MAX , V | A | E } ,
2006-12-06 09:24:29 +01:00
{ " use_lpc " , " sets whether to use LPC mode (FLAC) " , OFFSET ( use_lpc ) , FF_OPT_TYPE_INT , - 1 , INT_MIN , INT_MAX , A | E } ,
{ " lpc_coeff_precision " , " LPC coefficient precision (FLAC) " , OFFSET ( lpc_coeff_precision ) , FF_OPT_TYPE_INT , DEFAULT , 0 , INT_MAX , A | E } ,
2006-07-02 12:22:31 +02:00
{ " min_prediction_order " , NULL , OFFSET ( min_prediction_order ) , FF_OPT_TYPE_INT , - 1 , INT_MIN , INT_MAX , A | E } ,
{ " max_prediction_order " , NULL , OFFSET ( max_prediction_order ) , FF_OPT_TYPE_INT , - 1 , INT_MIN , INT_MAX , A | E } ,
2006-12-06 09:24:29 +01:00
{ " prediction_order_method " , " search method for selecting prediction order " , OFFSET ( prediction_order_method ) , FF_OPT_TYPE_INT , - 1 , INT_MIN , INT_MAX , A | E } ,
2006-07-02 12:22:31 +02:00
{ " min_partition_order " , NULL , OFFSET ( min_partition_order ) , FF_OPT_TYPE_INT , - 1 , INT_MIN , INT_MAX , A | E } ,
{ " max_partition_order " , NULL , OFFSET ( max_partition_order ) , FF_OPT_TYPE_INT , - 1 , INT_MIN , INT_MAX , A | E } ,
2006-12-06 09:24:29 +01:00
{ " 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 } ,
2006-11-07 14:45:08 +01:00
{ " drop_frame_timecode " , NULL , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_DROP_FRAME_TIMECODE , INT_MIN , INT_MAX , V | E , " flags2 " } ,
2007-03-04 03:26:20 +01:00
{ " non_linear_q " , " use non linear quantizer " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_NON_LINEAR_QUANT , INT_MIN , INT_MAX , V | E , " flags2 " } ,
2007-08-23 22:28:28 +02:00
{ " request_channels " , " set desired number of audio channels " , OFFSET ( request_channels ) , FF_OPT_TYPE_INT , DEFAULT , 0 , INT_MAX , A | D } ,
2007-12-20 01:55:08 +01:00
{ " drc_scale " , " percentage of dynamic range compression to apply " , OFFSET ( drc_scale ) , FF_OPT_TYPE_FLOAT , 1.0 , 0.0 , 1.0 , A | D } ,
2008-02-11 09:01:07 +01:00
{ " reservoir " , " use bit reservoir " , 0 , FF_OPT_TYPE_CONST , CODEC_FLAG2_BIT_RESERVOIR , INT_MIN , INT_MAX , A | E , " flags2 " } ,
2005-09-06 14:51:56 +02:00
{ NULL } ,
} ;
2005-09-11 13:10:25 +02:00
# undef A
# undef V
2006-09-09 10:49:28 +02:00
# undef S
# undef E
# undef D
# undef DEFAULT
2005-09-11 13:10:25 +02:00
2008-03-06 18:41:31 +01:00
static const AVClass av_codec_context_class = { " AVCodecContext " , context_to_name , options } ;
2004-03-03 18:53:55 +01:00
2007-03-07 10:29:44 +01:00
void avcodec_get_context_defaults2 ( AVCodecContext * s , enum CodecType codec_type ) {
int flags = 0 ;
2004-02-25 18:35:52 +01:00
memset ( s , 0 , sizeof ( AVCodecContext ) ) ;
2004-03-03 18:53:55 +01:00
s - > av_class = & av_codec_context_class ;
2006-09-10 22:21:40 +02:00
2007-07-17 15:35:16 +02:00
s - > codec_type = codec_type ;
2007-03-07 10:29:44 +01:00
if ( codec_type = = CODEC_TYPE_AUDIO )
flags = AV_OPT_FLAG_AUDIO_PARAM ;
else if ( codec_type = = CODEC_TYPE_VIDEO )
flags = AV_OPT_FLAG_VIDEO_PARAM ;
else if ( codec_type = = CODEC_TYPE_SUBTITLE )
flags = AV_OPT_FLAG_SUBTITLE_PARAM ;
av_opt_set_defaults2 ( s , flags , flags ) ;
2006-09-10 22:21:40 +02:00
2005-04-30 23:43:59 +02:00
s - > time_base = ( AVRational ) { 0 , 1 } ;
2002-12-04 11:04:03 +01:00
s - > get_buffer = avcodec_default_get_buffer ;
s - > release_buffer = avcodec_default_release_buffer ;
2003-01-12 01:48:29 +01:00
s - > get_format = avcodec_default_get_format ;
2004-02-13 18:54:10 +01:00
s - > execute = avcodec_default_execute ;
2003-10-20 22:23:46 +02:00
s - > sample_aspect_ratio = ( AVRational ) { 0 , 1 } ;
2005-04-25 20:29:06 +02:00
s - > pix_fmt = PIX_FMT_NONE ;
2006-02-21 23:05:13 +01:00
s - > sample_fmt = SAMPLE_FMT_S16 ; // FIXME: set to NONE
2006-09-10 23:51:08 +02:00
2003-10-30 06:40:58 +01:00
s - > palctrl = NULL ;
2003-11-26 21:57:15 +01:00
s - > reget_buffer = avcodec_default_reget_buffer ;
2002-09-19 11:13:43 +02:00
}
2007-03-07 10:29:44 +01:00
AVCodecContext * avcodec_alloc_context2 ( enum CodecType codec_type ) {
2004-02-25 18:35:52 +01:00
AVCodecContext * avctx = av_malloc ( sizeof ( AVCodecContext ) ) ;
2005-12-17 19:14:38 +01:00
2002-09-19 11:13:43 +02:00
if ( avctx = = NULL ) return NULL ;
2005-12-17 19:14:38 +01:00
2007-03-07 10:29:44 +01:00
avcodec_get_context_defaults2 ( avctx , codec_type ) ;
2005-12-17 19:14:38 +01:00
2002-09-19 11:13:43 +02:00
return avctx ;
}
2007-03-07 10:29:44 +01:00
void avcodec_get_context_defaults ( AVCodecContext * s ) {
avcodec_get_context_defaults2 ( s , CODEC_TYPE_UNKNOWN ) ;
}
AVCodecContext * avcodec_alloc_context ( void ) {
return avcodec_alloc_context2 ( CODEC_TYPE_UNKNOWN ) ;
}
2004-02-25 18:35:52 +01:00
void avcodec_get_frame_defaults ( AVFrame * pic ) {
memset ( pic , 0 , sizeof ( AVFrame ) ) ;
pic - > pts = AV_NOPTS_VALUE ;
2005-02-01 19:36:51 +01:00
pic - > key_frame = 1 ;
2004-02-25 18:35:52 +01:00
}
2002-12-09 13:03:43 +01:00
AVFrame * avcodec_alloc_frame ( void ) {
2004-02-25 18:35:52 +01:00
AVFrame * pic = av_malloc ( sizeof ( AVFrame ) ) ;
2005-12-17 19:14:38 +01:00
2004-02-25 18:35:52 +01:00
if ( pic = = NULL ) return NULL ;
2005-12-17 19:14:38 +01:00
2004-02-25 18:35:52 +01:00
avcodec_get_frame_defaults ( pic ) ;
2005-12-17 19:14:38 +01:00
2002-12-04 11:04:03 +01:00
return pic ;
}
2007-08-13 17:28:29 +02:00
int attribute_align_arg avcodec_open ( AVCodecContext * avctx , AVCodec * codec )
2001-07-22 16:18:56 +02:00
{
2005-07-25 16:35:01 +02:00
int ret = - 1 ;
2005-12-17 19:14:38 +01:00
2005-07-25 16:35:01 +02:00
entangled_thread_counter + + ;
if ( entangled_thread_counter ! = 1 ) {
av_log ( avctx , AV_LOG_ERROR , " insufficient thread locking around avcodec_open/close() \n " ) ;
goto end ;
}
2001-07-22 16:18:56 +02:00
2007-12-25 16:36:12 +01:00
if ( avctx - > codec | | ! codec )
2005-07-25 16:35:01 +02:00
goto end ;
2003-09-10 10:20:14 +02:00
2002-05-09 03:24:27 +02:00
if ( codec - > priv_data_size > 0 ) {
avctx - > priv_data = av_mallocz ( codec - > priv_data_size ) ;
2007-07-20 17:08:10 +02:00
if ( ! avctx - > priv_data ) {
ret = AVERROR ( ENOMEM ) ;
2005-07-25 16:35:01 +02:00
goto end ;
2007-07-20 17:08:10 +02:00
}
2002-05-09 03:24:27 +02:00
} else {
avctx - > priv_data = NULL ;
}
2004-09-27 13:50:56 +02:00
if ( avctx - > coded_width & & avctx - > coded_height )
avcodec_set_dimensions ( avctx , avctx - > coded_width , avctx - > coded_height ) ;
else if ( avctx - > width & & avctx - > height )
avcodec_set_dimensions ( avctx , avctx - > width , avctx - > height ) ;
2005-01-12 01:16:25 +01:00
if ( ( avctx - > coded_width | | avctx - > coded_height ) & & avcodec_check_dimensions ( avctx , avctx - > coded_width , avctx - > coded_height ) ) {
av_freep ( & avctx - > priv_data ) ;
2007-07-20 17:09:10 +02:00
ret = AVERROR ( EINVAL ) ;
2005-07-25 16:35:01 +02:00
goto end ;
2005-01-12 01:16:25 +01:00
}
2006-03-03 21:36:08 +01:00
avctx - > codec = codec ;
avctx - > codec_id = codec - > id ;
avctx - > frame_number = 0 ;
2007-04-01 18:13:24 +02:00
if ( avctx - > codec - > init ) {
2007-04-01 18:14:19 +02:00
ret = avctx - > codec - > init ( avctx ) ;
if ( ret < 0 ) {
av_freep ( & avctx - > priv_data ) ;
avctx - > codec = NULL ;
goto end ;
}
2007-04-01 18:13:24 +02:00
}
2005-07-25 16:35:01 +02:00
ret = 0 ;
end :
entangled_thread_counter - - ;
return ret ;
2001-07-22 16:18:56 +02:00
}
2007-08-13 17:28:29 +02:00
int attribute_align_arg avcodec_encode_audio ( AVCodecContext * avctx , uint8_t * buf , int buf_size ,
2001-07-22 16:18:56 +02:00
const short * samples )
{
2005-01-12 01:16:25 +01:00
if ( buf_size < FF_MIN_BUFFER_SIZE & & 0 ) {
2007-02-15 13:57:51 +01:00
av_log ( avctx , AV_LOG_ERROR , " buffer smaller than minimum size \n " ) ;
2005-01-12 01:16:25 +01:00
return - 1 ;
}
2004-06-22 23:14:01 +02:00
if ( ( avctx - > codec - > capabilities & CODEC_CAP_DELAY ) | | samples ) {
int ret = avctx - > codec - > encode ( avctx , buf , buf_size , ( void * ) samples ) ;
avctx - > frame_number + + ;
return ret ;
} else
return 0 ;
2001-07-22 16:18:56 +02:00
}
2007-08-13 17:28:29 +02:00
int attribute_align_arg avcodec_encode_video ( AVCodecContext * avctx , uint8_t * buf , int buf_size ,
2002-12-09 13:03:43 +01:00
const AVFrame * pict )
2001-07-22 16:18:56 +02:00
{
2005-01-12 01:16:25 +01:00
if ( buf_size < FF_MIN_BUFFER_SIZE ) {
2007-02-15 13:57:51 +01:00
av_log ( avctx , AV_LOG_ERROR , " buffer smaller than minimum size \n " ) ;
2005-01-12 01:16:25 +01:00
return - 1 ;
}
if ( avcodec_check_dimensions ( avctx , avctx - > width , avctx - > height ) )
return - 1 ;
2004-06-22 23:14:01 +02:00
if ( ( avctx - > codec - > capabilities & CODEC_CAP_DELAY ) | | pict ) {
int ret = avctx - > codec - > encode ( avctx , buf , buf_size , ( void * ) pict ) ;
avctx - > frame_number + + ;
2005-06-17 17:02:53 +02:00
emms_c ( ) ; //needed to avoid an emms_c() call before every return;
2005-12-17 19:14:38 +01:00
2004-06-22 23:14:01 +02:00
return ret ;
} else
return 0 ;
2001-07-22 16:18:56 +02:00
}
2005-12-17 19:14:38 +01:00
int avcodec_encode_subtitle ( AVCodecContext * avctx , uint8_t * buf , int buf_size ,
2005-06-03 15:59:38 +02:00
const AVSubtitle * sub )
{
int ret ;
ret = avctx - > codec - > encode ( avctx , buf , buf_size , ( void * ) sub ) ;
avctx - > frame_number + + ;
return ret ;
}
2007-08-13 17:28:29 +02:00
int attribute_align_arg avcodec_decode_video ( AVCodecContext * avctx , AVFrame * picture ,
2001-07-22 16:18:56 +02:00
int * got_picture_ptr ,
2008-02-02 23:54:50 +01:00
const uint8_t * buf , int buf_size )
2001-07-22 16:18:56 +02:00
{
int ret ;
2005-12-17 19:14:38 +01:00
2004-05-21 16:37:16 +02:00
* got_picture_ptr = 0 ;
2005-01-12 01:16:25 +01:00
if ( ( avctx - > coded_width | | avctx - > coded_height ) & & avcodec_check_dimensions ( avctx , avctx - > coded_width , avctx - > coded_height ) )
return - 1 ;
2005-01-23 19:09:06 +01:00
if ( ( avctx - > codec - > capabilities & CODEC_CAP_DELAY ) | | buf_size ) {
2005-12-17 19:14:38 +01:00
ret = avctx - > codec - > decode ( avctx , picture , got_picture_ptr ,
2005-01-23 19:09:06 +01:00
buf , buf_size ) ;
2002-10-31 13:11:53 +01:00
2005-06-17 17:02:53 +02:00
emms_c ( ) ; //needed to avoid an emms_c() call before every return;
2005-12-17 19:14:38 +01:00
if ( * got_picture_ptr )
2005-01-23 19:09:06 +01:00
avctx - > frame_number + + ;
} else
ret = 0 ;
2001-07-22 16:18:56 +02:00
return ret ;
}
2007-08-13 17:28:29 +02:00
int attribute_align_arg avcodec_decode_audio2 ( AVCodecContext * avctx , int16_t * samples ,
2001-07-22 16:18:56 +02:00
int * frame_size_ptr ,
2008-02-02 23:54:50 +01:00
const uint8_t * buf , int buf_size )
2001-07-22 16:18:56 +02:00
{
int ret ;
2005-07-14 17:30:39 +02:00
if ( ( avctx - > codec - > capabilities & CODEC_CAP_DELAY ) | | buf_size ) {
2007-02-23 01:47:21 +01:00
//FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
if ( * frame_size_ptr < AVCODEC_MAX_AUDIO_FRAME_SIZE ) {
av_log ( avctx , AV_LOG_ERROR , " buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE \n " ) ;
return - 1 ;
}
if ( * frame_size_ptr < FF_MIN_BUFFER_SIZE | |
2007-09-24 18:50:32 +02:00
* frame_size_ptr < avctx - > channels * avctx - > frame_size * sizeof ( int16_t ) ) {
2007-02-23 01:47:21 +01:00
av_log ( avctx , AV_LOG_ERROR , " buffer %d too small \n " , * frame_size_ptr ) ;
return - 1 ;
}
2005-12-17 19:14:38 +01:00
ret = avctx - > codec - > decode ( avctx , samples , frame_size_ptr ,
2005-07-14 17:30:39 +02:00
buf , buf_size ) ;
avctx - > frame_number + + ;
2007-01-15 00:50:06 +01:00
} else {
2005-07-14 17:30:39 +02:00
ret = 0 ;
2007-01-15 00:50:06 +01:00
* frame_size_ptr = 0 ;
}
2001-07-22 16:18:56 +02:00
return ret ;
}
2007-01-15 00:50:06 +01:00
# if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
int avcodec_decode_audio ( AVCodecContext * avctx , int16_t * samples ,
int * frame_size_ptr ,
2008-02-02 23:54:50 +01:00
const uint8_t * buf , int buf_size ) {
2007-01-15 00:50:06 +01:00
* frame_size_ptr = AVCODEC_MAX_AUDIO_FRAME_SIZE ;
return avcodec_decode_audio2 ( avctx , samples , frame_size_ptr , buf , buf_size ) ;
}
# endif
2005-06-03 15:59:38 +02:00
int avcodec_decode_subtitle ( AVCodecContext * avctx , AVSubtitle * sub ,
int * got_sub_ptr ,
const uint8_t * buf , int buf_size )
{
int ret ;
* got_sub_ptr = 0 ;
2005-12-17 19:14:38 +01:00
ret = avctx - > codec - > decode ( avctx , sub , got_sub_ptr ,
2008-02-01 04:29:43 +01:00
buf , buf_size ) ;
2005-06-03 15:59:38 +02:00
if ( * got_sub_ptr )
avctx - > frame_number + + ;
return ret ;
}
2001-07-22 16:18:56 +02:00
int avcodec_close ( AVCodecContext * avctx )
{
2005-07-25 16:35:01 +02:00
entangled_thread_counter + + ;
if ( entangled_thread_counter ! = 1 ) {
av_log ( avctx , AV_LOG_ERROR , " insufficient thread locking around avcodec_open/close() \n " ) ;
entangled_thread_counter - - ;
return - 1 ;
}
2007-07-06 17:24:08 +02:00
if ( ENABLE_THREADS & & avctx - > thread_opaque )
avcodec_thread_free ( avctx ) ;
2001-07-22 16:18:56 +02:00
if ( avctx - > codec - > close )
avctx - > codec - > close ( avctx ) ;
2004-04-30 19:42:58 +02:00
avcodec_default_free_buffers ( avctx ) ;
2002-05-19 00:59:50 +02:00
av_freep ( & avctx - > priv_data ) ;
2001-07-22 16:18:56 +02:00
avctx - > codec = NULL ;
2005-07-25 16:35:01 +02:00
entangled_thread_counter - - ;
2001-07-22 16:18:56 +02:00
return 0 ;
}
AVCodec * avcodec_find_encoder ( enum CodecID id )
{
AVCodec * p ;
p = first_avcodec ;
while ( p ) {
if ( p - > encode ! = NULL & & p - > id = = id )
return p ;
p = p - > next ;
}
return NULL ;
}
2001-12-23 23:25:18 +01:00
AVCodec * avcodec_find_encoder_by_name ( const char * name )
{
AVCodec * p ;
p = first_avcodec ;
while ( p ) {
if ( p - > encode ! = NULL & & strcmp ( name , p - > name ) = = 0 )
return p ;
p = p - > next ;
}
return NULL ;
}
2001-07-22 16:18:56 +02:00
AVCodec * avcodec_find_decoder ( enum CodecID id )
{
AVCodec * p ;
p = first_avcodec ;
while ( p ) {
if ( p - > decode ! = NULL & & p - > id = = id )
return p ;
p = p - > next ;
}
return NULL ;
}
AVCodec * avcodec_find_decoder_by_name ( const char * name )
{
AVCodec * p ;
p = first_avcodec ;
while ( p ) {
if ( p - > decode ! = NULL & & strcmp ( name , p - > name ) = = 0 )
return p ;
p = p - > next ;
}
return NULL ;
}
void avcodec_string ( char * buf , int buf_size , AVCodecContext * enc , int encode )
{
const char * codec_name ;
AVCodec * p ;
char buf1 [ 32 ] ;
2002-04-22 21:57:26 +02:00
char channels_str [ 100 ] ;
2001-09-23 19:16:51 +02:00
int bitrate ;
2007-10-18 16:01:20 +02:00
AVRational display_aspect_ratio ;
2001-07-22 16:18:56 +02:00
if ( encode )
p = avcodec_find_encoder ( enc - > codec_id ) ;
else
p = avcodec_find_decoder ( enc - > codec_id ) ;
if ( p ) {
codec_name = p - > name ;
2003-09-09 00:49:26 +02:00
if ( ! encode & & enc - > codec_id = = CODEC_ID_MP3 ) {
if ( enc - > sub_id = = 2 )
codec_name = " mp2 " ;
else if ( enc - > sub_id = = 1 )
codec_name = " mp1 " ;
}
2003-10-29 15:08:18 +01:00
} else if ( enc - > codec_id = = CODEC_ID_MPEG2TS ) {
/* fake mpeg2 transport stream codec (currently not
registered ) */
codec_name = " mpeg2ts " ;
2001-07-22 16:18:56 +02:00
} else if ( enc - > codec_name [ 0 ] ! = ' \0 ' ) {
codec_name = enc - > codec_name ;
} else {
/* output avi tags */
2005-12-17 19:14:38 +01:00
if ( isprint ( enc - > codec_tag & 0xFF ) & & isprint ( ( enc - > codec_tag > > 8 ) & 0xFF )
2005-09-03 22:36:24 +02:00
& & isprint ( ( enc - > codec_tag > > 16 ) & 0xFF ) & & isprint ( ( enc - > codec_tag > > 24 ) & 0xFF ) ) {
2005-12-17 19:14:38 +01:00
snprintf ( buf1 , sizeof ( buf1 ) , " %c%c%c%c / 0x%04X " ,
2001-07-22 16:18:56 +02:00
enc - > codec_tag & 0xff ,
( enc - > codec_tag > > 8 ) & 0xff ,
( enc - > codec_tag > > 16 ) & 0xff ,
2005-09-03 22:36:24 +02:00
( enc - > codec_tag > > 24 ) & 0xff ,
enc - > codec_tag ) ;
2001-07-22 16:18:56 +02:00
} else {
snprintf ( buf1 , sizeof ( buf1 ) , " 0x%04x " , enc - > codec_tag ) ;
}
codec_name = buf1 ;
}
switch ( enc - > codec_type ) {
case CODEC_TYPE_VIDEO :
snprintf ( buf , buf_size ,
" Video: %s%s " ,
2003-07-29 04:09:12 +02:00
codec_name , enc - > mb_decision ? " (hq) " : " " ) ;
2005-04-25 20:41:38 +02:00
if ( enc - > pix_fmt ! = PIX_FMT_NONE ) {
2001-08-11 21:04:31 +02:00
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
" , %s " ,
2003-01-11 01:07:06 +01:00
avcodec_get_pix_fmt_name ( enc - > pix_fmt ) ) ;
2001-08-11 21:04:31 +02:00
}
2001-07-22 16:18:56 +02:00
if ( enc - > width ) {
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
2005-09-18 16:45:17 +02:00
" , %dx%d " ,
enc - > width , enc - > height ) ;
2008-03-07 00:09:16 +01:00
if ( enc - > sample_aspect_ratio . num ) {
2008-03-07 00:10:47 +01:00
av_reduce ( & display_aspect_ratio . num , & display_aspect_ratio . den ,
enc - > width * enc - > sample_aspect_ratio . num ,
enc - > height * enc - > sample_aspect_ratio . den ,
1024 * 1024 ) ;
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
" [PAR %d:%d DAR %d:%d] " ,
enc - > sample_aspect_ratio . num , enc - > sample_aspect_ratio . den ,
display_aspect_ratio . num , display_aspect_ratio . den ) ;
2008-03-07 00:09:16 +01:00
}
2007-12-12 22:48:50 +01:00
if ( av_log_get_level ( ) > = AV_LOG_DEBUG ) {
2005-09-18 16:45:17 +02:00
int g = ff_gcd ( enc - > time_base . num , enc - > time_base . den ) ;
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
" , %d/%d " ,
enc - > time_base . num / g , enc - > time_base . den / g ) ;
}
2001-07-22 16:18:56 +02:00
}
2002-10-10 19:12:55 +02:00
if ( encode ) {
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
" , q=%d-%d " , enc - > qmin , enc - > qmax ) ;
}
2001-09-23 19:16:51 +02:00
bitrate = enc - > bit_rate ;
2001-07-22 16:18:56 +02:00
break ;
case CODEC_TYPE_AUDIO :
snprintf ( buf , buf_size ,
" Audio: %s " ,
codec_name ) ;
2002-04-09 06:52:49 +02:00
switch ( enc - > channels ) {
case 1 :
2002-04-22 21:57:26 +02:00
strcpy ( channels_str , " mono " ) ;
2002-04-09 06:52:49 +02:00
break ;
case 2 :
2002-04-22 21:57:26 +02:00
strcpy ( channels_str , " stereo " ) ;
2002-04-09 06:52:49 +02:00
break ;
case 6 :
2002-04-22 21:57:26 +02:00
strcpy ( channels_str , " 5:1 " ) ;
2002-04-09 06:52:49 +02:00
break ;
default :
2005-01-12 01:59:42 +01:00
snprintf ( channels_str , sizeof ( channels_str ) , " %d channels " , enc - > channels ) ;
2002-04-09 06:52:49 +02:00
break ;
}
2001-07-22 16:18:56 +02:00
if ( enc - > sample_rate ) {
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
" , %d Hz, %s " ,
enc - > sample_rate ,
2002-04-09 06:52:49 +02:00
channels_str ) ;
2001-07-22 16:18:56 +02:00
}
2008-07-31 14:56:56 +02:00
if ( enc - > sample_fmt ! = SAMPLE_FMT_NONE ) {
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
" , %s " , avcodec_get_sample_fmt_name ( enc - > sample_fmt ) ) ;
}
2005-12-17 19:14:38 +01:00
2001-09-23 19:16:51 +02:00
/* for PCM codecs, compute bitrate directly */
switch ( enc - > codec_id ) {
2008-08-19 12:43:47 +02:00
case CODEC_ID_PCM_F64BE :
case CODEC_ID_PCM_F64LE :
bitrate = enc - > sample_rate * enc - > channels * 64 ;
break ;
2005-09-02 21:16:48 +02:00
case CODEC_ID_PCM_S32LE :
case CODEC_ID_PCM_S32BE :
case CODEC_ID_PCM_U32LE :
case CODEC_ID_PCM_U32BE :
2008-07-26 09:08:15 +02:00
case CODEC_ID_PCM_F32BE :
2008-08-19 12:43:47 +02:00
case CODEC_ID_PCM_F32LE :
2005-09-02 21:16:48 +02:00
bitrate = enc - > sample_rate * enc - > channels * 32 ;
break ;
case CODEC_ID_PCM_S24LE :
case CODEC_ID_PCM_S24BE :
case CODEC_ID_PCM_U24LE :
case CODEC_ID_PCM_U24BE :
case CODEC_ID_PCM_S24DAUD :
bitrate = enc - > sample_rate * enc - > channels * 24 ;
break ;
2001-09-23 19:16:51 +02:00
case CODEC_ID_PCM_S16LE :
case CODEC_ID_PCM_S16BE :
2007-11-25 17:32:47 +01:00
case CODEC_ID_PCM_S16LE_PLANAR :
2001-09-23 19:16:51 +02:00
case CODEC_ID_PCM_U16LE :
case CODEC_ID_PCM_U16BE :
2001-09-25 01:29:46 +02:00
bitrate = enc - > sample_rate * enc - > channels * 16 ;
2001-09-23 19:16:51 +02:00
break ;
case CODEC_ID_PCM_S8 :
case CODEC_ID_PCM_U8 :
case CODEC_ID_PCM_ALAW :
case CODEC_ID_PCM_MULAW :
2008-08-04 09:40:07 +02:00
case CODEC_ID_PCM_ZORK :
2001-09-25 01:29:46 +02:00
bitrate = enc - > sample_rate * enc - > channels * 8 ;
2001-09-23 19:16:51 +02:00
break ;
default :
bitrate = enc - > bit_rate ;
break ;
}
2001-07-22 16:18:56 +02:00
break ;
2003-10-29 15:08:18 +01:00
case CODEC_TYPE_DATA :
snprintf ( buf , buf_size , " Data: %s " , codec_name ) ;
2005-06-03 15:59:38 +02:00
bitrate = enc - > bit_rate ;
break ;
case CODEC_TYPE_SUBTITLE :
snprintf ( buf , buf_size , " Subtitle: %s " , codec_name ) ;
2003-10-29 15:08:18 +01:00
bitrate = enc - > bit_rate ;
break ;
2008-01-27 16:43:17 +01:00
case CODEC_TYPE_ATTACHMENT :
snprintf ( buf , buf_size , " Attachment: %s " , codec_name ) ;
bitrate = enc - > bit_rate ;
break ;
2001-07-22 16:18:56 +02:00
default :
2004-10-01 14:31:11 +02:00
snprintf ( buf , buf_size , " Invalid Codec type %d " , enc - > codec_type ) ;
return ;
2001-07-22 16:18:56 +02:00
}
2002-10-10 19:12:55 +02:00
if ( encode ) {
if ( enc - > flags & CODEC_FLAG_PASS1 )
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
" , pass 1 " ) ;
if ( enc - > flags & CODEC_FLAG_PASS2 )
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
" , pass 2 " ) ;
}
2001-09-23 19:16:51 +02:00
if ( bitrate ! = 0 ) {
2005-12-17 19:14:38 +01:00
snprintf ( buf + strlen ( buf ) , buf_size - strlen ( buf ) ,
2001-09-23 19:16:51 +02:00
" , %d kb/s " , bitrate / 1000 ) ;
2001-07-22 16:18:56 +02:00
}
}
2002-05-05 11:56:13 +02:00
unsigned avcodec_version ( void )
{
return LIBAVCODEC_VERSION_INT ;
}
2001-08-11 21:04:31 +02:00
2008-07-11 17:25:12 +02:00
# if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0)
2002-05-12 17:53:25 +02:00
unsigned avcodec_build ( void )
{
return LIBAVCODEC_BUILD ;
}
2008-07-11 17:25:12 +02:00
# endif
2002-05-12 17:53:25 +02:00
2001-07-22 16:18:56 +02:00
void avcodec_init ( void )
{
2008-02-13 10:26:10 +01:00
static int initialized = 0 ;
2002-04-01 15:24:47 +02:00
2008-02-13 10:26:10 +01:00
if ( initialized ! = 0 )
2005-12-22 02:10:11 +01:00
return ;
2008-02-13 10:26:10 +01:00
initialized = 1 ;
2002-04-01 15:24:47 +02:00
2006-11-14 04:18:09 +01:00
dsputil_static_init ( ) ;
2001-07-22 16:18:56 +02:00
}
2002-04-24 03:24:06 +02:00
void avcodec_flush_buffers ( AVCodecContext * avctx )
{
2003-07-17 14:29:07 +02:00
if ( avctx - > codec - > flush )
avctx - > codec - > flush ( avctx ) ;
2002-04-24 03:24:06 +02:00
}
2004-09-15 02:35:18 +02:00
void avcodec_default_free_buffers ( AVCodecContext * s ) {
2003-04-25 02:29:48 +02:00
int i , j ;
if ( s - > internal_buffer = = NULL ) return ;
2005-12-17 19:14:38 +01:00
2003-04-25 02:29:48 +02:00
for ( i = 0 ; i < INTERNAL_BUFFER_SIZE ; i + + ) {
InternalBuffer * buf = & ( ( InternalBuffer * ) s - > internal_buffer ) [ i ] ;
for ( j = 0 ; j < 4 ; j + + ) {
av_freep ( & buf - > base [ j ] ) ;
buf - > data [ j ] = NULL ;
}
}
av_freep ( & s - > internal_buffer ) ;
2005-12-17 19:14:38 +01:00
2003-04-25 02:29:48 +02:00
s - > internal_buffer_count = 0 ;
}
2003-05-15 01:08:01 +02:00
char av_get_pict_type_char ( int pict_type ) {
switch ( pict_type ) {
2008-03-05 01:43:11 +01:00
case FF_I_TYPE : return ' I ' ;
case FF_P_TYPE : return ' P ' ;
case FF_B_TYPE : return ' B ' ;
case FF_S_TYPE : return ' S ' ;
case FF_SI_TYPE : return ' i ' ;
case FF_SP_TYPE : return ' p ' ;
2008-03-05 16:19:26 +01:00
case FF_BI_TYPE : return ' b ' ;
2008-03-05 16:15:07 +01:00
default : return ' ? ' ;
2003-05-15 01:08:01 +02:00
}
}
2006-07-07 19:50:09 +02:00
int av_get_bits_per_sample ( enum CodecID codec_id ) {
switch ( codec_id ) {
2006-07-08 00:42:36 +02:00
case CODEC_ID_ADPCM_SBPRO_2 :
2006-07-08 09:14:00 +02:00
return 2 ;
2006-07-08 00:42:36 +02:00
case CODEC_ID_ADPCM_SBPRO_3 :
2006-07-08 09:14:00 +02:00
return 3 ;
2006-07-08 00:42:36 +02:00
case CODEC_ID_ADPCM_SBPRO_4 :
2006-07-08 09:14:00 +02:00
case CODEC_ID_ADPCM_CT :
return 4 ;
2006-07-07 19:50:09 +02:00
case CODEC_ID_PCM_ALAW :
case CODEC_ID_PCM_MULAW :
case CODEC_ID_PCM_S8 :
case CODEC_ID_PCM_U8 :
2008-08-04 09:40:07 +02:00
case CODEC_ID_PCM_ZORK :
2006-07-07 19:50:09 +02:00
return 8 ;
case CODEC_ID_PCM_S16BE :
case CODEC_ID_PCM_S16LE :
2007-11-25 17:32:47 +01:00
case CODEC_ID_PCM_S16LE_PLANAR :
2006-07-07 19:50:09 +02:00
case CODEC_ID_PCM_U16BE :
case CODEC_ID_PCM_U16LE :
return 16 ;
case CODEC_ID_PCM_S24DAUD :
case CODEC_ID_PCM_S24BE :
case CODEC_ID_PCM_S24LE :
case CODEC_ID_PCM_U24BE :
case CODEC_ID_PCM_U24LE :
return 24 ;
case CODEC_ID_PCM_S32BE :
case CODEC_ID_PCM_S32LE :
case CODEC_ID_PCM_U32BE :
case CODEC_ID_PCM_U32LE :
2008-07-26 09:08:15 +02:00
case CODEC_ID_PCM_F32BE :
2008-08-19 12:43:47 +02:00
case CODEC_ID_PCM_F32LE :
2006-07-07 19:50:09 +02:00
return 32 ;
2008-08-19 12:43:47 +02:00
case CODEC_ID_PCM_F64BE :
case CODEC_ID_PCM_F64LE :
return 64 ;
2006-07-07 19:50:09 +02:00
default :
return 0 ;
}
}
2007-08-13 07:23:38 +02:00
int av_get_bits_per_sample_format ( enum SampleFormat sample_fmt ) {
switch ( sample_fmt ) {
case SAMPLE_FMT_U8 :
return 8 ;
case SAMPLE_FMT_S16 :
return 16 ;
case SAMPLE_FMT_S24 :
return 24 ;
case SAMPLE_FMT_S32 :
case SAMPLE_FMT_FLT :
return 32 ;
2008-08-19 12:36:30 +02:00
case SAMPLE_FMT_DBL :
return 64 ;
2007-08-13 07:23:38 +02:00
default :
return 0 ;
}
}
2004-11-21 19:04:56 +01:00
# if !defined(HAVE_THREADS)
2004-05-11 01:38:53 +02:00
int avcodec_thread_init ( AVCodecContext * s , int thread_count ) {
return - 1 ;
}
# endif
2005-05-13 20:10:23 +02:00
unsigned int av_xiphlacing ( unsigned char * s , unsigned int v )
{
unsigned int n = 0 ;
while ( v > = 0xff ) {
* s + + = 0xff ;
v - = 0xff ;
n + + ;
}
* s = v ;
n + + ;
return n ;
}
2006-03-30 06:33:05 +02:00
/* Wrapper to work around the lack of mkstemp() on mingw/cygin.
* Also , tries to create file in / tmp first , if possible .
* * prefix can be a character constant ; * filename will be allocated internally .
* Returns file descriptor of opened file ( or - 1 on error )
* and opened file name in * * filename . */
int av_tempfile ( char * prefix , char * * filename ) {
int fd = - 1 ;
2007-07-11 15:57:22 +02:00
# if !defined(HAVE_MKSTEMP)
2006-03-30 06:33:05 +02:00
* filename = tempnam ( " . " , prefix ) ;
# else
size_t len = strlen ( prefix ) + 12 ; /* room for "/tmp/" and "XXXXXX\0" */
2006-06-30 07:53:28 +02:00
* filename = av_malloc ( len ) ;
2006-03-30 06:33:05 +02:00
# endif
/* -----common section-----*/
if ( * filename = = NULL ) {
av_log ( NULL , AV_LOG_ERROR , " ff_tempfile: Cannot allocate file name \n " ) ;
return - 1 ;
}
2007-07-11 15:57:22 +02:00
# if !defined(HAVE_MKSTEMP)
2007-07-11 17:21:24 +02:00
fd = open ( * filename , O_RDWR | O_BINARY | O_CREAT , 0444 ) ;
2006-03-30 06:33:05 +02:00
# else
snprintf ( * filename , len , " /tmp/%sXXXXXX " , prefix ) ;
fd = mkstemp ( * filename ) ;
if ( fd < 0 ) {
snprintf ( * filename , len , " ./%sXXXXXX " , prefix ) ;
fd = mkstemp ( * filename ) ;
}
# endif
/* -----common section-----*/
if ( fd < 0 ) {
av_log ( NULL , AV_LOG_ERROR , " ff_tempfile: Cannot open temporary file %s \n " , * filename ) ;
return - 1 ;
}
return fd ; /* success */
}
2007-06-12 10:06:54 +02:00
typedef struct {
2007-06-21 09:46:48 +02:00
const char * abbr ;
2007-06-12 10:06:54 +02:00
int width , height ;
2007-06-21 09:46:48 +02:00
} VideoFrameSizeAbbr ;
typedef struct {
const char * abbr ;
int rate_num , rate_den ;
} VideoFrameRateAbbr ;
2008-06-24 22:01:31 +02:00
static const VideoFrameSizeAbbr video_frame_size_abbrs [ ] = {
2007-06-21 09:46:48 +02:00
{ " ntsc " , 720 , 480 } ,
{ " pal " , 720 , 576 } ,
{ " qntsc " , 352 , 240 } , /* VCD compliant NTSC */
{ " qpal " , 352 , 288 } , /* VCD compliant PAL */
{ " sntsc " , 640 , 480 } , /* square pixel NTSC */
{ " spal " , 768 , 576 } , /* square pixel PAL */
{ " film " , 352 , 240 } ,
{ " ntsc-film " , 352 , 240 } ,
{ " sqcif " , 128 , 96 } ,
{ " qcif " , 176 , 144 } ,
{ " cif " , 352 , 288 } ,
{ " 4cif " , 704 , 576 } ,
{ " qqvga " , 160 , 120 } ,
{ " qvga " , 320 , 240 } ,
{ " vga " , 640 , 480 } ,
{ " svga " , 800 , 600 } ,
{ " xga " , 1024 , 768 } ,
{ " uxga " , 1600 , 1200 } ,
{ " qxga " , 2048 , 1536 } ,
{ " sxga " , 1280 , 1024 } ,
{ " qsxga " , 2560 , 2048 } ,
{ " hsxga " , 5120 , 4096 } ,
{ " wvga " , 852 , 480 } ,
{ " wxga " , 1366 , 768 } ,
{ " wsxga " , 1600 , 1024 } ,
{ " wuxga " , 1920 , 1200 } ,
{ " woxga " , 2560 , 1600 } ,
{ " wqsxga " , 3200 , 2048 } ,
{ " wquxga " , 3840 , 2400 } ,
{ " whsxga " , 6400 , 4096 } ,
{ " whuxga " , 7680 , 4800 } ,
{ " cga " , 320 , 200 } ,
{ " ega " , 640 , 350 } ,
{ " hd480 " , 852 , 480 } ,
{ " hd720 " , 1280 , 720 } ,
{ " hd1080 " , 1920 , 1080 } ,
} ;
2008-06-24 22:01:31 +02:00
static const VideoFrameRateAbbr video_frame_rate_abbrs [ ] = {
2007-06-21 09:46:48 +02:00
{ " ntsc " , 30000 , 1001 } ,
{ " pal " , 25 , 1 } ,
{ " qntsc " , 30000 , 1001 } , /* VCD compliant NTSC */
{ " qpal " , 25 , 1 } , /* VCD compliant PAL */
{ " sntsc " , 30000 , 1001 } , /* square pixel NTSC */
{ " spal " , 25 , 1 } , /* square pixel PAL */
{ " film " , 24 , 1 } ,
{ " ntsc-film " , 24000 , 1001 } ,
2007-06-12 10:06:54 +02:00
} ;
int av_parse_video_frame_size ( int * width_ptr , int * height_ptr , const char * str )
{
int i ;
2007-06-21 09:46:48 +02:00
int n = sizeof ( video_frame_size_abbrs ) / sizeof ( VideoFrameSizeAbbr ) ;
2007-06-12 10:06:54 +02:00
const char * p ;
int frame_width = 0 , frame_height = 0 ;
for ( i = 0 ; i < n ; i + + ) {
2007-06-21 09:46:48 +02:00
if ( ! strcmp ( video_frame_size_abbrs [ i ] . abbr , str ) ) {
frame_width = video_frame_size_abbrs [ i ] . width ;
frame_height = video_frame_size_abbrs [ i ] . height ;
2007-06-12 10:06:54 +02:00
break ;
}
}
if ( i = = n ) {
p = str ;
frame_width = strtol ( p , ( char * * ) & p , 10 ) ;
if ( * p )
p + + ;
frame_height = strtol ( p , ( char * * ) & p , 10 ) ;
}
if ( frame_width < = 0 | | frame_height < = 0 )
return - 1 ;
* width_ptr = frame_width ;
* height_ptr = frame_height ;
return 0 ;
}
int av_parse_video_frame_rate ( AVRational * frame_rate , const char * arg )
{
int i ;
2007-06-21 09:46:48 +02:00
int n = sizeof ( video_frame_rate_abbrs ) / sizeof ( VideoFrameRateAbbr ) ;
2007-06-12 10:06:54 +02:00
char * cp ;
/* First, we check our abbreviation table */
2007-06-21 09:46:48 +02:00
for ( i = 0 ; i < n ; + + i )
if ( ! strcmp ( video_frame_rate_abbrs [ i ] . abbr , arg ) ) {
frame_rate - > num = video_frame_rate_abbrs [ i ] . rate_num ;
frame_rate - > den = video_frame_rate_abbrs [ i ] . rate_den ;
2007-06-12 10:06:54 +02:00
return 0 ;
}
/* Then, we try to parse it as fraction */
cp = strchr ( arg , ' / ' ) ;
if ( ! cp )
cp = strchr ( arg , ' : ' ) ;
if ( cp ) {
char * cpp ;
frame_rate - > num = strtol ( arg , & cpp , 10 ) ;
if ( cpp ! = arg | | cpp = = cp )
frame_rate - > den = strtol ( cp + 1 , & cpp , 10 ) ;
else
frame_rate - > num = 0 ;
}
else {
/* Finally we give up and parse it as double */
AVRational time_base = av_d2q ( strtod ( arg , 0 ) , DEFAULT_FRAME_RATE_BASE ) ;
frame_rate - > den = time_base . den ;
frame_rate - > num = time_base . num ;
}
if ( ! frame_rate - > num | | ! frame_rate - > den )
return - 1 ;
else
return 0 ;
}
2008-08-10 22:29:43 +02:00
void av_log_missing_feature ( void * avc , const char * feature , int want_sample )
{
av_log ( avc , AV_LOG_WARNING , " %s not implemented. Update your FFmpeg "
" version to the newest one from SVN. If the problem still "
" occurs, it means that your file has a feature which has not "
" been implemented. " , feature ) ;
if ( want_sample )
av_log ( avc , AV_LOG_WARNING , " If you want to help, upload a sample "
" of this file to ftp://upload.mplayerhq.hu/MPlayer/incoming/ "
" and contact the FFmpeg-devel mailing list. " ) ;
av_log ( avc , AV_LOG_WARNING , " \n " ) ;
}