@ -2704,14 +2704,16 @@ static int transcode(AVFormatContext **output_files,
return ret ;
}
static void opt_format ( const char * arg )
static int opt_format ( const char * opt , const char * arg )
{
last_asked_format = arg ;
return 0 ;
}
static void opt_video_rc_override_string ( const char * arg )
static int opt_video_rc_override_string ( const char * opt , const char * arg )
{
video_rc_override_string = arg ;
return 0 ;
}
static int opt_me_threshold ( const char * opt , const char * arg )
@ -2753,12 +2755,13 @@ static int opt_frame_crop(const char *opt, const char *arg)
return AVERROR ( EINVAL ) ;
}
static void opt_frame_size ( const char * arg )
static int opt_frame_size ( const char * opt , const char * arg )
{
if ( av_parse_video_size ( & frame_width , & frame_height , arg ) < 0 ) {
fprintf ( stderr , " Incorrect frame size \n " ) ;
ffmpeg_exit ( 1 ) ;
return AVERROR ( EINVAL ) ;
}
return 0 ;
}
static int opt_pad ( const char * opt , const char * arg ) {
@ -2766,21 +2769,22 @@ static int opt_pad(const char *opt, const char *arg) {
return - 1 ;
}
static void opt_frame_pix_fmt ( const char * arg )
static int opt_frame_pix_fmt ( const char * opt , const char * arg )
{
if ( strcmp ( arg , " list " ) ) {
frame_pix_fmt = av_get_pix_fmt ( arg ) ;
if ( frame_pix_fmt = = PIX_FMT_NONE ) {
fprintf ( stderr , " Unknown pixel format requested: %s \n " , arg ) ;
ffmpeg_exit ( 1 ) ;
return AVERROR ( EINVAL ) ;
}
} else {
show_pix_fmts ( ) ;
ffmpeg_exit ( 0 ) ;
}
return 0 ;
}
static void opt_frame_aspect_ratio ( const char * arg )
static int opt_frame_aspect_ratio ( const char * opt , const char * arg )
{
int x = 0 , y = 0 ;
double ar = 0 ;
@ -2799,9 +2803,10 @@ static void opt_frame_aspect_ratio(const char *arg)
if ( ! ar ) {
fprintf ( stderr , " Incorrect aspect ratio specification. \n " ) ;
ffmpeg_exit ( 1 ) ;
return AVERROR ( EINVAL ) ;
}
frame_aspect_ratio = ar ;
return 0 ;
}
static int opt_metadata ( const char * opt , const char * arg )
@ -2845,13 +2850,13 @@ static int opt_thread_count(const char *opt, const char *arg)
return 0 ;
}
static void opt_audio_sample_fmt ( const char * arg )
static int opt_audio_sample_fmt ( const char * opt , const char * arg )
{
if ( strcmp ( arg , " list " ) ) {
audio_sample_fmt = av_get_sample_fmt ( arg ) ;
if ( audio_sample_fmt = = AV_SAMPLE_FMT_NONE ) {
av_log ( NULL , AV_LOG_ERROR , " Invalid sample format '%s' \n " , arg ) ;
ffmpeg_exit ( 1 ) ;
return AVERROR ( EINVAL ) ;
}
} else {
int i ;
@ -2860,6 +2865,7 @@ static void opt_audio_sample_fmt(const char *arg)
printf ( " %s \n " , av_get_sample_fmt_string ( fmt_str , sizeof ( fmt_str ) , i ) ) ;
ffmpeg_exit ( 0 ) ;
}
return 0 ;
}
static int opt_audio_rate ( const char * opt , const char * arg )
@ -2880,12 +2886,13 @@ static int opt_video_channel(const char *opt, const char *arg)
return 0 ;
}
static void opt_video_standard ( const char * arg )
static int opt_video_standard ( const char * opt , const char * arg )
{
video_standard = av_strdup ( arg ) ;
return 0 ;
}
static void opt_codec ( int * pstream_copy , char * * pcodec_name ,
static int opt_codec ( int * pstream_copy , char * * pcodec_name ,
int codec_type , const char * arg )
{
av_freep ( pcodec_name ) ;
@ -2894,26 +2901,27 @@ static void opt_codec(int *pstream_copy, char **pcodec_name,
} else {
* pcodec_name = av_strdup ( arg ) ;
}
return 0 ;
}
static void opt_audio_codec ( const char * arg )
static int opt_audio_codec ( const char * opt , const char * arg )
{
opt_codec ( & audio_stream_copy , & audio_codec_name , AVMEDIA_TYPE_AUDIO , arg ) ;
return opt_codec ( & audio_stream_copy , & audio_codec_name , AVMEDIA_TYPE_AUDIO , arg ) ;
}
static void opt_video_codec ( const char * arg )
static int opt_video_codec ( const char * opt , const char * arg )
{
opt_codec ( & video_stream_copy , & video_codec_name , AVMEDIA_TYPE_VIDEO , arg ) ;
return opt_codec ( & video_stream_copy , & video_codec_name , AVMEDIA_TYPE_VIDEO , arg ) ;
}
static void opt_subtitle_codec ( const char * arg )
static int opt_subtitle_codec ( const char * opt , const char * arg )
{
opt_codec ( & subtitle_stream_copy , & subtitle_codec_name , AVMEDIA_TYPE_SUBTITLE , arg ) ;
return opt_codec ( & subtitle_stream_copy , & subtitle_codec_name , AVMEDIA_TYPE_SUBTITLE , arg ) ;
}
static void opt_data_codec ( const char * arg )
static int opt_data_codec ( const char * opt , const char * arg )
{
opt_codec ( & data_stream_copy , & data_codec_name , AVMEDIA_TYPE_DATA , arg ) ;
return opt_codec ( & data_stream_copy , & data_codec_name , AVMEDIA_TYPE_DATA , arg ) ;
}
static int opt_codec_tag ( const char * opt , const char * arg )
@ -2934,7 +2942,7 @@ static int opt_codec_tag(const char *opt, const char *arg)
return 0 ;
}
static void opt_map ( const char * arg )
static int opt_map ( const char * opt , const char * arg )
{
AVStreamMap * m ;
char * p ;
@ -2957,6 +2965,7 @@ static void opt_map(const char *arg)
m - > sync_file_index = m - > file_index ;
m - > sync_stream_index = m - > stream_index ;
}
return 0 ;
}
static void parse_meta_type ( char * arg , char * type , int * index , char * * endptr )
@ -2980,7 +2989,7 @@ static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
* type = ' g ' ;
}
static void opt_map_metadata ( const char * arg )
static int opt_map_metadata ( const char * opt , const char * arg )
{
AVMetaDataMap * m , * m1 ;
char * p ;
@ -3004,16 +3013,18 @@ static void opt_map_metadata(const char *arg)
metadata_streams_autocopy = 0 ;
if ( m - > type = = ' c ' | | m1 - > type = = ' c ' )
metadata_chapters_autocopy = 0 ;
return 0 ;
}
static void opt_map_meta_data ( const char * arg )
static int opt_map_meta_data ( const char * opt , const char * arg )
{
fprintf ( stderr , " -map_meta_data is deprecated and will be removed soon. "
" Use -map_metadata instead. \n " ) ;
opt_map_metadata ( arg ) ;
return opt_map_metadata ( opt , arg ) ;
}
static void opt_map_chapters ( const char * arg )
static int opt_map_chapters ( const char * opt , const char * arg )
{
AVChapterMap * c ;
char * p ;
@ -3026,9 +3037,10 @@ static void opt_map_chapters(const char *arg)
p + + ;
c - > in_file = strtol ( p , & p , 0 ) ;
return 0 ;
}
static void opt_input_ts_scale ( const char * arg )
static int opt_input_ts_scale ( const char * opt , const char * arg )
{
unsigned int stream ;
double scale ;
@ -3044,6 +3056,7 @@ static void opt_input_ts_scale(const char *arg)
input_files_ts_scale [ nb_input_files ] = grow_array ( input_files_ts_scale [ nb_input_files ] , sizeof ( * input_files_ts_scale [ nb_input_files ] ) , & nb_input_files_ts_scale [ nb_input_files ] , stream + 1 ) ;
input_files_ts_scale [ nb_input_files ] [ stream ] = scale ;
return 0 ;
}
static int opt_recording_time ( const char * opt , const char * arg )
@ -3104,7 +3117,7 @@ static enum CodecID find_codec_or_die(const char *name, int type, int encoder, i
return codec - > id ;
}
static void opt_input_file ( const char * filename )
static int opt_input_file ( const char * opt , const char * filename )
{
AVFormatContext * ic ;
AVFormatParameters params , * ap = & params ;
@ -3330,6 +3343,7 @@ static void opt_input_file(const char *filename)
av_freep ( & subtitle_codec_name ) ;
uninit_opts ( ) ;
init_opts ( ) ;
return 0 ;
}
static void check_inputs ( int * has_video_ptr ,
@ -4016,7 +4030,7 @@ static void show_help(void)
av_opt_show2 ( sws_opts , NULL , AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_DECODING_PARAM , 0 ) ;
}
static void opt_target ( const char * arg )
static int opt_target ( const char * opt , const char * arg )
{
enum { PAL , NTSC , FILM , UNKNOWN } norm = UNKNOWN ;
static const char * const frame_rates [ ] = { " 25 " , " 30000/1001 " , " 24000/1001 " } ;
@ -4073,13 +4087,12 @@ static void opt_target(const char *arg)
}
if ( ! strcmp ( arg , " vcd " ) ) {
opt_video_codec ( " vcodec " , " mpeg1video " ) ;
opt_audio_codec ( " vcodec " , " mp2 " ) ;
opt_format ( " f " , " vcd " ) ;
opt_video_codec ( " mpeg1video " ) ;
opt_audio_codec ( " mp2 " ) ;
opt_format ( " vcd " ) ;
opt_frame_size ( norm = = PAL ? " 352x288 " : " 352x240 " ) ;
opt_frame_rate ( NULL , frame_rates [ norm ] ) ;
opt_frame_size ( " s " , norm = = PAL ? " 352x288 " : " 352x240 " ) ;
opt_frame_rate ( " r " , frame_rates [ norm ] ) ;
opt_default ( " g " , norm = = PAL ? " 15 " : " 18 " ) ;
opt_default ( " b " , " 1150000 " ) ;
@ -4102,12 +4115,12 @@ static void opt_target(const char *arg)
mux_preload = ( 36000 + 3 * 1200 ) / 90000.0 ; //0.44
} else if ( ! strcmp ( arg , " svcd " ) ) {
opt_video_codec ( " mpeg2video " ) ;
opt_audio_codec ( " mp2 " ) ;
opt_format ( " svcd " ) ;
opt_video_codec ( " vcodec " , " mpeg2video " ) ;
opt_audio_codec ( " acodec " , " mp2 " ) ;
opt_format ( " f " , " svcd " ) ;
opt_frame_size ( norm = = PAL ? " 480x576 " : " 480x480 " ) ;
opt_frame_rate ( NULL , frame_rates [ norm ] ) ;
opt_frame_size ( " s " , norm = = PAL ? " 480x576 " : " 480x480 " ) ;
opt_frame_rate ( " r " , frame_rates [ norm ] ) ;
opt_default ( " g " , norm = = PAL ? " 15 " : " 18 " ) ;
opt_default ( " b " , " 2040000 " ) ;
@ -4124,12 +4137,12 @@ static void opt_target(const char *arg)
} else if ( ! strcmp ( arg , " dvd " ) ) {
opt_video_codec ( " mpeg2video " ) ;
opt_audio_codec ( " ac3 " ) ;
opt_format ( " dvd " ) ;
opt_video_codec ( " vcodec " , " mpeg2video " ) ;
opt_audio_codec ( " vcodec " , " ac3 " ) ;
opt_format ( " f " , " dvd " ) ;
opt_frame_size ( norm = = PAL ? " 720x576 " : " 720x480 " ) ;
opt_frame_rate ( NULL , frame_rates [ norm ] ) ;
opt_frame_size ( " vcodec " , norm = = PAL ? " 720x576 " : " 720x480 " ) ;
opt_frame_rate ( " r " , frame_rates [ norm ] ) ;
opt_default ( " g " , norm = = PAL ? " 15 " : " 18 " ) ;
opt_default ( " b " , " 6000000 " ) ;
@ -4145,29 +4158,31 @@ static void opt_target(const char *arg)
} else if ( ! strncmp ( arg , " dv " , 2 ) ) {
opt_format ( " dv " ) ;
opt_format ( " f " , " dv " ) ;
opt_frame_size ( norm = = PAL ? " 720x576 " : " 720x480 " ) ;
opt_frame_pix_fmt ( ! strncmp ( arg , " dv50 " , 4 ) ? " yuv422p " :
( norm = = PAL ? " yuv420p " : " yuv411p " ) ) ;
opt_frame_rate ( NULL , frame_rates [ norm ] ) ;
opt_frame_size ( " s " , norm = = PAL ? " 720x576 " : " 720x480 " ) ;
opt_frame_pix_fmt ( " pix_fmt " , ! strncmp ( arg , " dv50 " , 4 ) ? " yuv422p " :
norm = = PAL ? " yuv420p " : " yuv411p " ) ;
opt_frame_rate ( " r " , frame_rates [ norm ] ) ;
audio_sample_rate = 48000 ;
audio_channels = 2 ;
} else {
fprintf ( stderr , " Unknown target: %s \n " , arg ) ;
ffmpeg_exit ( 1 ) ;
return AVERROR ( EINVAL ) ;
}
return 0 ;
}
static void opt_vstats_file ( const char * arg )
static int opt_vstats_file ( const char * opt , const char * arg )
{
av_free ( vstats_filename ) ;
vstats_filename = av_strdup ( arg ) ;
return 0 ;
}
static void opt_vstats ( void )
static int opt_vstats ( const char * opt , const char * arg )
{
char filename [ 40 ] ;
time_t today2 = time ( NULL ) ;
@ -4175,7 +4190,7 @@ static void opt_vstats (void)
snprintf ( filename , sizeof ( filename ) , " vstats_%02d%02d%02d.log " , today - > tm_hour , today - > tm_min ,
today - > tm_sec ) ;
opt_vstats_file ( filename ) ;
return opt_vstats_file ( opt , filename ) ;
}
static int opt_bsf ( const char * opt , const char * arg )
@ -4222,13 +4237,13 @@ static int opt_preset(const char *opt, const char *arg)
ffmpeg_exit ( 1 ) ;
}
if ( ! strcmp ( tmp , " acodec " ) ) {
opt_audio_codec ( tmp2 ) ;
opt_audio_codec ( tmp , tmp 2) ;
} else if ( ! strcmp ( tmp , " vcodec " ) ) {
opt_video_codec ( tmp2 ) ;
opt_video_codec ( tmp , tmp 2) ;
} else if ( ! strcmp ( tmp , " scodec " ) ) {
opt_subtitle_codec ( tmp2 ) ;
opt_subtitle_codec ( tmp , tmp 2) ;
} else if ( ! strcmp ( tmp , " dcodec " ) ) {
opt_data_codec ( tmp2 ) ;
opt_data_codec ( tmp , tmp 2) ;
} else if ( opt_default ( tmp , tmp2 ) < 0 ) {
fprintf ( stderr , " %s: Invalid option or argument: '%s', parsed as '%s' = '%s' \n " , filename , line , tmp , tmp2 ) ;
ffmpeg_exit ( 1 ) ;
@ -4252,17 +4267,17 @@ static const OptionDef options[] = {
{ " map_metadata " , HAS_ARG | OPT_EXPERT , { ( void * ) opt_map_metadata } , " set metadata information of outfile from infile " ,
" outfile[,metadata]:infile[,metadata] " } ,
{ " map_chapters " , HAS_ARG | OPT_EXPERT , { ( void * ) opt_map_chapters } , " set chapters mapping " , " outfile:infile " } ,
{ " t " , OPT_FUNC2 | HAS_ARG , { ( void * ) opt_recording_time } , " record or transcode \" duration \" seconds of audio/video " , " duration " } ,
{ " t " , HAS_ARG , { ( void * ) opt_recording_time } , " record or transcode \" duration \" seconds of audio/video " , " duration " } ,
{ " fs " , HAS_ARG | OPT_INT64 , { ( void * ) & limit_filesize } , " set the limit file size in bytes " , " limit_size " } , //
{ " ss " , OPT_FUNC2 | HAS_ARG , { ( void * ) opt_start_time } , " set the start time offset " , " time_off " } ,
{ " itsoffset " , OPT_FUNC2 | HAS_ARG , { ( void * ) opt_input_ts_offset } , " set the input ts offset " , " time_off " } ,
{ " ss " , HAS_ARG , { ( void * ) opt_start_time } , " set the start time offset " , " time_off " } ,
{ " itsoffset " , HAS_ARG , { ( void * ) opt_input_ts_offset } , " set the input ts offset " , " time_off " } ,
{ " itsscale " , HAS_ARG , { ( void * ) opt_input_ts_scale } , " set the input ts scale " , " stream:scale " } ,
{ " timestamp " , OPT_FUNC2 | HAS_ARG , { ( void * ) opt_recording_timestamp } , " set the recording timestamp ('now' to set the current time) " , " time " } ,
{ " metadata " , OPT_FUNC2 | HAS_ARG , { ( void * ) opt_metadata } , " add metadata " , " string=string " } ,
{ " timestamp " , HAS_ARG , { ( void * ) opt_recording_timestamp } , " set the recording timestamp ('now' to set the current time) " , " time " } ,
{ " metadata " , HAS_ARG , { ( void * ) opt_metadata } , " add metadata " , " string=string " } ,
{ " dframes " , OPT_INT | HAS_ARG , { ( void * ) & max_frames [ AVMEDIA_TYPE_DATA ] } , " set the number of data frames to record " , " number " } ,
{ " benchmark " , OPT_BOOL | OPT_EXPERT , { ( void * ) & do_benchmark } ,
" add timings for benchmarking " } ,
{ " timelimit " , OPT_FUNC2 | HAS_ARG , { ( void * ) opt_timelimit } , " set max runtime in seconds " , " limit " } ,
{ " timelimit " , HAS_ARG , { ( void * ) opt_timelimit } , " set max runtime in seconds " , " limit " } ,
{ " dump " , OPT_BOOL | OPT_EXPERT , { ( void * ) & do_pkt_dump } ,
" dump each input packet " } ,
{ " hex " , OPT_BOOL | OPT_EXPERT , { ( void * ) & do_hex_dump } ,
@ -4270,9 +4285,9 @@ static const OptionDef options[] = {
{ " re " , OPT_BOOL | OPT_EXPERT , { ( void * ) & rate_emu } , " read input at native frame rate " , " " } ,
{ " loop_input " , OPT_BOOL | OPT_EXPERT , { ( void * ) & loop_input } , " loop (current only works with images) " } ,
{ " loop_output " , HAS_ARG | OPT_INT | OPT_EXPERT , { ( void * ) & loop_output } , " number of times to loop output in formats that support looping (0 loops forever) " , " " } ,
{ " v " , HAS_ARG | OPT_FUNC2 , { ( void * ) opt_verbose } , " set ffmpeg verbosity level " , " number " } ,
{ " v " , HAS_ARG , { ( void * ) opt_verbose } , " set ffmpeg verbosity level " , " number " } ,
{ " target " , HAS_ARG , { ( void * ) opt_target } , " specify target file type ( \" vcd \" , \" svcd \" , \" dvd \" , \" dv \" , \" dv50 \" , \" pal-vcd \" , \" ntsc-svcd \" , ...) " , " type " } ,
{ " threads " , OPT_FUNC2 | HAS_ARG | OPT_EXPERT , { ( void * ) opt_thread_count } , " thread count " , " count " } ,
{ " threads " , HAS_ARG | OPT_EXPERT , { ( void * ) opt_thread_count } , " thread count " , " count " } ,
{ " vsync " , HAS_ARG | OPT_INT | OPT_EXPERT , { ( void * ) & video_sync_method } , " video sync method " , " " } ,
{ " async " , HAS_ARG | OPT_INT | OPT_EXPERT , { ( void * ) & audio_sync_method } , " audio sync method " , " " } ,
{ " adrift_threshold " , HAS_ARG | OPT_FLOAT | OPT_EXPERT , { ( void * ) & audio_drift_threshold } , " audio drift threshold " , " threshold " } ,
@ -4285,32 +4300,32 @@ static const OptionDef options[] = {
{ " copyinkf " , OPT_BOOL | OPT_EXPERT , { ( void * ) & copy_initial_nonkeyframes } , " copy initial non-keyframes " } ,
/* video options */
{ " b " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_bitrate } , " set bitrate (in bits/s) " , " bitrate " } ,
{ " vb " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_bitrate } , " set bitrate (in bits/s) " , " bitrate " } ,
{ " b " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_bitrate } , " set bitrate (in bits/s) " , " bitrate " } ,
{ " vb " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_bitrate } , " set bitrate (in bits/s) " , " bitrate " } ,
{ " vframes " , OPT_INT | HAS_ARG | OPT_VIDEO , { ( void * ) & max_frames [ AVMEDIA_TYPE_VIDEO ] } , " set the number of video frames to record " , " number " } ,
{ " r " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_rate } , " set frame rate (Hz value, fraction or abbreviation) " , " rate " } ,
{ " r " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_rate } , " set frame rate (Hz value, fraction or abbreviation) " , " rate " } ,
{ " s " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_size } , " set frame size (WxH or abbreviation) " , " size " } ,
{ " aspect " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_aspect_ratio } , " set aspect ratio (4:3, 16:9 or 1.3333, 1.7777) " , " aspect " } ,
{ " pix_fmt " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_frame_pix_fmt } , " set pixel format, 'list' as argument shows all the pixel formats supported " , " format " } ,
{ " croptop " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropbottom " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropleft " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropright " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " padtop " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padbottom " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padleft " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padright " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padcolor " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " color " } ,
{ " croptop " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropbottom " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropleft " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " cropright " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_frame_crop } , " Removed, use the crop filter instead " , " size " } ,
{ " padtop " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padbottom " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padleft " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padright " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " size " } ,
{ " padcolor " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pad } , " Removed, use the pad filter instead " , " color " } ,
{ " intra " , OPT_BOOL | OPT_EXPERT | OPT_VIDEO , { ( void * ) & intra_only } , " use only intra frames " } ,
{ " vn " , OPT_BOOL | OPT_VIDEO , { ( void * ) & video_disable } , " disable video " } ,
{ " vdt " , OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) & video_discard } , " discard threshold " , " n " } ,
{ " qscale " , HAS_ARG | OPT_FUNC2 | OPT_ EXPERT | OPT_VIDEO , { ( void * ) opt_qscale } , " use fixed video quantizer scale (VBR) " , " q " } ,
{ " qscale " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_qscale } , " use fixed video quantizer scale (VBR) " , " q " } ,
{ " rc_override " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_video_rc_override_string } , " rate control override for specific intervals " , " override " } ,
{ " vcodec " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_video_codec } , " force video codec ('copy' to copy stream) " , " codec " } ,
{ " me_threshold " , HAS_ARG | OPT_FUNC2 | OPT_ EXPERT | OPT_VIDEO , { ( void * ) opt_me_threshold } , " motion estimaton threshold " , " threshold " } ,
{ " me_threshold " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_me_threshold } , " motion estimaton threshold " , " threshold " } ,
{ " sameq " , OPT_BOOL | OPT_VIDEO , { ( void * ) & same_quality } ,
" use same quantizer as source (implies VBR) " } ,
{ " pass " , HAS_ARG | OPT_FUNC2 | OPT_ VIDEO , { ( void * ) opt_pass } , " select the pass number (1 or 2) " , " n " } ,
{ " pass " , HAS_ARG | OPT_VIDEO , { ( void * ) opt_pass } , " select the pass number (1 or 2) " , " n " } ,
{ " passlogfile " , HAS_ARG | OPT_STRING | OPT_VIDEO , { ( void * ) & pass_logfilename_prefix } , " select two pass log file name prefix " , " prefix " } ,
{ " deinterlace " , OPT_BOOL | OPT_EXPERT | OPT_VIDEO , { ( void * ) & do_deinterlace } ,
" deinterlace pictures " } ,
@ -4322,39 +4337,39 @@ static const OptionDef options[] = {
# endif
{ " intra_matrix " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_intra_matrix } , " specify intra matrix coeffs " , " matrix " } ,
{ " inter_matrix " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_inter_matrix } , " specify inter matrix coeffs " , " matrix " } ,
{ " top " , HAS_ARG | OPT_FUNC2 | OPT_ EXPERT | OPT_VIDEO , { ( void * ) opt_top_field_first } , " top=1/bottom=0/auto=-1 field first " , " " } ,
{ " top " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_top_field_first } , " top=1/bottom=0/auto=-1 field first " , " " } ,
{ " dc " , OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) & intra_dc_precision } , " intra_dc_precision " , " precision " } ,
{ " vtag " , OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_codec_tag } , " force video tag/fourcc " , " fourcc/tag " } ,
{ " newvideo " , OPT_VIDEO | OPT_FUNC2 , { ( void * ) opt_new_stream } , " add a new video stream to the current output stream " } ,
{ " vtag " , HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) opt_codec_tag } , " force video tag/fourcc " , " fourcc/tag " } ,
{ " newvideo " , OPT_VIDEO , { ( void * ) opt_new_stream } , " add a new video stream to the current output stream " } ,
{ " vlang " , HAS_ARG | OPT_STRING | OPT_VIDEO , { ( void * ) & video_language } , " set the ISO 639 language code (3 letters) of the current video stream " , " code " } ,
{ " qphist " , OPT_BOOL | OPT_EXPERT | OPT_VIDEO , { ( void * ) & qp_hist } , " show QP histogram " } ,
{ " force_fps " , OPT_BOOL | OPT_EXPERT | OPT_VIDEO , { ( void * ) & force_fps } , " force the selected framerate, disable the best supported framerate selection " } ,
{ " streamid " , OPT_FUNC2 | HAS_ARG | OPT_EXPERT , { ( void * ) opt_streamid } , " set the value of an outfile streamid " , " streamIndex:value " } ,
{ " streamid " , HAS_ARG | OPT_EXPERT , { ( void * ) opt_streamid } , " set the value of an outfile streamid " , " streamIndex:value " } ,
{ " force_key_frames " , OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO , { ( void * ) & forced_key_frames } , " force key frames at specified timestamps " , " timestamps " } ,
/* audio options */
{ " ab " , OPT_FUNC2 | HAS_ARG | OPT_AUDIO , { ( void * ) opt_bitrate } , " set bitrate (in bits/s) " , " bitrate " } ,
{ " ab " , HAS_ARG | OPT_AUDIO , { ( void * ) opt_bitrate } , " set bitrate (in bits/s) " , " bitrate " } ,
{ " aframes " , OPT_INT | HAS_ARG | OPT_AUDIO , { ( void * ) & max_frames [ AVMEDIA_TYPE_AUDIO ] } , " set the number of audio frames to record " , " number " } ,
{ " aq " , OPT_FLOAT | HAS_ARG | OPT_AUDIO , { ( void * ) & audio_qscale } , " set audio quality (codec-specific) " , " quality " , } ,
{ " ar " , HAS_ARG | OPT_FUNC2 | OPT_ AUDIO , { ( void * ) opt_audio_rate } , " set audio sampling rate (in Hz) " , " rate " } ,
{ " ac " , HAS_ARG | OPT_FUNC2 | OPT_ AUDIO , { ( void * ) opt_audio_channels } , " set number of audio channels " , " channels " } ,
{ " ar " , HAS_ARG | OPT_AUDIO , { ( void * ) opt_audio_rate } , " set audio sampling rate (in Hz) " , " rate " } ,
{ " ac " , HAS_ARG | OPT_AUDIO , { ( void * ) opt_audio_channels } , " set number of audio channels " , " channels " } ,
{ " an " , OPT_BOOL | OPT_AUDIO , { ( void * ) & audio_disable } , " disable audio " } ,
{ " acodec " , HAS_ARG | OPT_AUDIO , { ( void * ) opt_audio_codec } , " force audio codec ('copy' to copy stream) " , " codec " } ,
{ " atag " , OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_AUDIO , { ( void * ) opt_codec_tag } , " force audio tag/fourcc " , " fourcc/tag " } ,
{ " atag " , HAS_ARG | OPT_EXPERT | OPT_AUDIO , { ( void * ) opt_codec_tag } , " force audio tag/fourcc " , " fourcc/tag " } ,
{ " vol " , OPT_INT | HAS_ARG | OPT_AUDIO , { ( void * ) & audio_volume } , " change audio volume (256=normal) " , " volume " } , //
{ " newaudio " , OPT_AUDIO | OPT_FUNC2 , { ( void * ) opt_new_stream } , " add a new audio stream to the current output stream " } ,
{ " newaudio " , OPT_AUDIO , { ( void * ) opt_new_stream } , " add a new audio stream to the current output stream " } ,
{ " alang " , HAS_ARG | OPT_STRING | OPT_AUDIO , { ( void * ) & audio_language } , " set the ISO 639 language code (3 letters) of the current audio stream " , " code " } ,
{ " sample_fmt " , HAS_ARG | OPT_EXPERT | OPT_AUDIO , { ( void * ) opt_audio_sample_fmt } , " set sample format, 'list' as argument shows all the sample formats supported " , " format " } ,
/* subtitle options */
{ " sn " , OPT_BOOL | OPT_SUBTITLE , { ( void * ) & subtitle_disable } , " disable subtitle " } ,
{ " scodec " , HAS_ARG | OPT_SUBTITLE , { ( void * ) opt_subtitle_codec } , " force subtitle codec ('copy' to copy stream) " , " codec " } ,
{ " newsubtitle " , OPT_SUBTITLE | OPT_FUNC2 , { ( void * ) opt_new_stream } , " add a new subtitle stream to the current output stream " } ,
{ " newsubtitle " , OPT_SUBTITLE , { ( void * ) opt_new_stream } , " add a new subtitle stream to the current output stream " } ,
{ " slang " , HAS_ARG | OPT_STRING | OPT_SUBTITLE , { ( void * ) & subtitle_language } , " set the ISO 639 language code (3 letters) of the current subtitle stream " , " code " } ,
{ " stag " , OPT_FUNC2 | HAS_ARG | OPT_EXPERT | OPT_SUBTITLE , { ( void * ) opt_codec_tag } , " force subtitle tag/fourcc " , " fourcc/tag " } ,
{ " stag " , HAS_ARG | OPT_EXPERT | OPT_SUBTITLE , { ( void * ) opt_codec_tag } , " force subtitle tag/fourcc " , " fourcc/tag " } ,
/* grab options */
{ " vc " , HAS_ARG | OPT_FUNC2 | OPT_ EXPERT | OPT_VIDEO | OPT_GRAB , { ( void * ) opt_video_channel } , " set video grab channel (DV1394 only) " , " channel " } ,
{ " vc " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB , { ( void * ) opt_video_channel } , " set video grab channel (DV1394 only) " , " channel " } ,
{ " tvstd " , HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB , { ( void * ) opt_video_standard } , " set television standard (NTSC, PAL (SECAM)) " , " standard " } ,
{ " isync " , OPT_BOOL | OPT_EXPERT | OPT_GRAB , { ( void * ) & input_sync } , " sync read on input " , " " } ,
@ -4362,18 +4377,18 @@ static const OptionDef options[] = {
{ " muxdelay " , OPT_FLOAT | HAS_ARG | OPT_EXPERT , { ( void * ) & mux_max_delay } , " set the maximum demux-decode delay " , " seconds " } ,
{ " muxpreload " , OPT_FLOAT | HAS_ARG | OPT_EXPERT , { ( void * ) & mux_preload } , " set the initial demux-decode delay " , " seconds " } ,
{ " absf " , OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT , { ( void * ) opt_bsf } , " " , " bitstream_filter " } ,
{ " vbsf " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT , { ( void * ) opt_bsf } , " " , " bitstream_filter " } ,
{ " sbsf " , OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT , { ( void * ) opt_bsf } , " " , " bitstream_filter " } ,
{ " absf " , HAS_ARG | OPT_AUDIO | OPT_EXPERT , { ( void * ) opt_bsf } , " " , " bitstream_filter " } ,
{ " vbsf " , HAS_ARG | OPT_VIDEO | OPT_EXPERT , { ( void * ) opt_bsf } , " " , " bitstream_filter " } ,
{ " sbsf " , HAS_ARG | OPT_SUBTITLE | OPT_EXPERT , { ( void * ) opt_bsf } , " " , " bitstream_filter " } ,
{ " apre " , OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT , { ( void * ) opt_preset } , " set the audio options to the indicated preset " , " preset " } ,
{ " vpre " , OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT , { ( void * ) opt_preset } , " set the video options to the indicated preset " , " preset " } ,
{ " spre " , OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT , { ( void * ) opt_preset } , " set the subtitle options to the indicated preset " , " preset " } ,
{ " fpre " , OPT_FUNC2 | HAS_ARG | OPT_EXPERT , { ( void * ) opt_preset } , " set options from indicated preset file " , " filename " } ,
{ " apre " , HAS_ARG | OPT_AUDIO | OPT_EXPERT , { ( void * ) opt_preset } , " set the audio options to the indicated preset " , " preset " } ,
{ " vpre " , HAS_ARG | OPT_VIDEO | OPT_EXPERT , { ( void * ) opt_preset } , " set the video options to the indicated preset " , " preset " } ,
{ " spre " , HAS_ARG | OPT_SUBTITLE | OPT_EXPERT , { ( void * ) opt_preset } , " set the subtitle options to the indicated preset " , " preset " } ,
{ " fpre " , HAS_ARG | OPT_EXPERT , { ( void * ) opt_preset } , " set options from indicated preset file " , " filename " } ,
/* data codec support */
{ " dcodec " , HAS_ARG | OPT_DATA , { ( void * ) opt_data_codec } , " force data codec ('copy' to copy stream) " , " codec " } ,
{ " default " , OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT , { ( void * ) opt_default } , " generic catch all option " , " " } ,
{ " default " , HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT , { ( void * ) opt_default } , " generic catch all option " , " " } ,
{ NULL , } ,
} ;