Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge commit 'd3810c47fe8c9509c28c65c0244e743c1d353daf'

Browse Source 
* commit 'd3810c47fe8c9509c28c65c0244e743c1d353daf':
  avconv: get rid of ugly casts in the options table.
  avconv: try to match codecs by codec descriptor name as a last resort.
  avtools: fix show_foo() signatures.

Conflicts:
	cmdutils.c
	cmdutils.h
	cmdutils_common_opts.h
	ffmpeg_opt.c
	ffplay.c
	ffprobe.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/28/head
Michael Niedermayer 13 years ago
parent a5a0dedf11 d3810c47fe
commit 927022a753
7 changed files with 134 additions and 106 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 17
      cmdutils.c
  2. 14
      cmdutils.h
  3. 42
      cmdutils_common_opts.h
  4. 158
      ffmpeg_opt.c
  5. 4
      ffplay.c
  6. 3
      ffprobe.c
  7. 2
      ffserver.c

17
cmdutils.c
Unescape View File

@ -674,14 +674,16 @@ void show_banner(int argc, char **argv, const OptionDef *options)
print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO); print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
} }
int opt_version(const char *opt, const char *arg) { int show_version(const char *opt, const char *arg)
{
av_log_set_callback(log_callback_help); av_log_set_callback(log_callback_help);
print_program_info (0 , AV_LOG_INFO); print_program_info (0 , AV_LOG_INFO);
print_all_libs_info(SHOW_VERSION, AV_LOG_INFO); print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
return 0; return 0;
} }
int opt_license(const char *opt, const char *arg) int show_license(const char *opt, const char *arg)
{ {
printf( printf(
#if CONFIG_NONFREE #if CONFIG_NONFREE
@ -748,10 +750,11 @@ int opt_license(const char *opt, const char *arg)
program_name, program_name, program_name program_name, program_name, program_name
#endif #endif
); );
return 0; return 0;
} }
int opt_formats(const char *opt, const char *arg) int show_formats(const char *opt, const char *arg)
{ {
AVInputFormat *ifmt = NULL; AVInputFormat *ifmt = NULL;
AVOutputFormat *ofmt = NULL; AVOutputFormat *ofmt = NULL;
@ -925,7 +928,7 @@ int show_encoders(const char *opt, const char *arg)
return 0; return 0;
} }
int opt_bsfs(const char *opt, const char *arg) int show_bsfs(const char *opt, const char *arg)
{ {
AVBitStreamFilter *bsf = NULL; AVBitStreamFilter *bsf = NULL;
@ -936,7 +939,7 @@ int opt_bsfs(const char *opt, const char *arg)
return 0; return 0;
} }
int opt_protocols(const char *opt, const char *arg) int show_protocols(const char *opt, const char *arg)
{ {
void *opaque = NULL; void *opaque = NULL;
const char *name; const char *name;
@ -951,7 +954,7 @@ int opt_protocols(const char *opt, const char *arg)
return 0; return 0;
} }
int opt_filters(const char *opt, const char *arg) int show_filters(const char *opt, const char *arg)
{ {
AVFilter av_unused(**filter) = NULL; AVFilter av_unused(**filter) = NULL;
char descr[64], *descr_cur; char descr[64], *descr_cur;
@ -983,7 +986,7 @@ int opt_filters(const char *opt, const char *arg)
return 0; return 0;
} }
int opt_pix_fmts(const char *opt, const char *arg) int show_pix_fmts(const char *opt, const char *arg)
{ {
enum PixelFormat pix_fmt; enum PixelFormat pix_fmt;

14
cmdutils.h
Unescape View File

@ -277,21 +277,21 @@ void show_banner(int argc, char **argv, const OptionDef *options);
* libraries. * libraries.
* This option processing function does not utilize the arguments. * This option processing function does not utilize the arguments.
*/ */
int opt_version(const char *opt, const char *arg); int show_version(const char *opt, const char *arg);
/** /**
* Print the license of the program to stdout. The license depends on * Print the license of the program to stdout. The license depends on
* the license of the libraries compiled into the program. * the license of the libraries compiled into the program.
* This option processing function does not utilize the arguments. * This option processing function does not utilize the arguments.
*/ */
int opt_license(const char *opt, const char *arg); int show_license(const char *opt, const char *arg);
/** /**
* Print a listing containing all the formats supported by the * Print a listing containing all the formats supported by the
* program. * program.
* This option processing function does not utilize the arguments. * This option processing function does not utilize the arguments.
*/ */
int opt_formats(const char *opt, const char *arg); int show_formats(const char *opt, const char *arg);
/** /**
* Print a listing containing all the codecs supported by the * Print a listing containing all the codecs supported by the
@ -317,28 +317,28 @@ int show_encoders(const char *opt, const char *arg);
* program. * program.
* This option processing function does not utilize the arguments. * This option processing function does not utilize the arguments.
*/ */
int opt_filters(const char *opt, const char *arg); int show_filters(const char *opt, const char *arg);
/** /**
* Print a listing containing all the bit stream filters supported by the * Print a listing containing all the bit stream filters supported by the
* program. * program.
* This option processing function does not utilize the arguments. * This option processing function does not utilize the arguments.
*/ */
int opt_bsfs(const char *opt, const char *arg); int show_bsfs(const char *opt, const char *arg);
/** /**
* Print a listing containing all the protocols supported by the * Print a listing containing all the protocols supported by the
* program. * program.
* This option processing function does not utilize the arguments. * This option processing function does not utilize the arguments.
*/ */
int opt_protocols(const char *opt, const char *arg); int show_protocols(const char *opt, const char *arg);
/** /**
* Print a listing containing all the pixel formats supported by the * Print a listing containing all the pixel formats supported by the
* program. * program.
* This option processing function does not utilize the arguments. * This option processing function does not utilize the arguments.
*/ */
int opt_pix_fmts(const char *opt, const char *arg); int show_pix_fmts(const char *opt, const char *arg);
/** /**
* Print a listing containing all the sample formats supported by the * Print a listing containing all the sample formats supported by the

42
cmdutils_common_opts.h
Unescape View File

@ -1,22 +1,22 @@
{ "L", OPT_EXIT, {(void*)opt_license}, "show license" }, { "L" , OPT_EXIT, {.func_arg = show_license}, "show license" },
{ "h", OPT_EXIT, {(void*)opt_help}, "show help" }, { "h" , OPT_EXIT, {.func_arg = show_help}, "show help" },
{ "?", OPT_EXIT, {(void*)opt_help}, "show help" }, { "?" , OPT_EXIT, {.func_arg = show_help}, "show help" },
{ "help", OPT_EXIT, {(void*)opt_help}, "show help" }, { "help" , OPT_EXIT, {.func_arg = show_help}, "show help" },
{ "-help", OPT_EXIT, {(void*)opt_help}, "show help" }, { "-help" , OPT_EXIT, {.func_arg = show_help}, "show help" },
{ "version", OPT_EXIT, {(void*)opt_version}, "show version" }, { "version" , OPT_EXIT, {.func_arg = show_version}, "show version" },
{ "formats" , OPT_EXIT, {(void*)opt_formats }, "show available formats" }, { "formats" , OPT_EXIT, {.func_arg = show_formats }, "show available formats" },
{ "codecs" , OPT_EXIT, {(void*)show_codecs }, "show available codecs" }, { "codecs" , OPT_EXIT, {.func_arg = show_codecs }, "show available codecs" },
{ "decoders" , OPT_EXIT, {(void*)show_decoders }, "show available decoders" }, { "decoders" , OPT_EXIT, {.func_arg = show_decoders }, "show available decoders" },
{ "encoders" , OPT_EXIT, {(void*)show_encoders }, "show available encoders" }, { "encoders" , OPT_EXIT, {.func_arg = show_encoders }, "show available encoders" },
{ "bsfs" , OPT_EXIT, {(void*)opt_bsfs }, "show available bit stream filters" }, { "bsfs" , OPT_EXIT, {.func_arg = show_bsfs }, "show available bit stream filters" },
{ "protocols", OPT_EXIT, {(void*)opt_protocols}, "show available protocols" }, { "protocols" , OPT_EXIT, {.func_arg = show_protocols}, "show available protocols" },
{ "filters", OPT_EXIT, {(void*)opt_filters }, "show available filters" }, { "filters" , OPT_EXIT, {.func_arg = show_filters }, "show available filters" },
{ "pix_fmts" , OPT_EXIT, {(void*)opt_pix_fmts }, "show available pixel formats" }, { "pix_fmts" , OPT_EXIT, {.func_arg = show_pix_fmts }, "show available pixel formats" },
{ "sample_fmts", OPT_EXIT, {.func_arg = show_sample_fmts }, "show available audio sample formats" }, { "sample_fmts", OPT_EXIT, {.func_arg = show_sample_fmts }, "show available audio sample formats" },
{ "loglevel", HAS_ARG, {(void*)opt_loglevel}, "set libav* logging level", "loglevel" }, { "loglevel" , HAS_ARG, {.func_arg = opt_loglevel}, "set libav* logging level", "loglevel" },
{ "v", HAS_ARG, {(void*)opt_loglevel}, "set libav* logging level", "loglevel" }, { "v", HAS_ARG, {.func_arg = opt_loglevel}, "set libav* logging level", "loglevel" },
{ "debug", HAS_ARG, {(void*)opt_codec_debug}, "set debug flags", "flags" }, { "debug" , HAS_ARG, {.func_arg = opt_codec_debug}, "set debug flags", "flags" },
{ "fdebug", HAS_ARG, {(void*)opt_codec_debug}, "set debug flags", "flags" }, { "fdebug" , HAS_ARG, {.func_arg = opt_codec_debug}, "set debug flags", "flags" },
{ "report", 0, {(void*)opt_report}, "generate a report" }, { "report" , 0, {(void*)opt_report}, "generate a report" },
{ "max_alloc", HAS_ARG, {(void*)opt_max_alloc}, "set maximum size of a single allocated block", "bytes" }, { "max_alloc" , HAS_ARG, {.func_arg = opt_max_alloc}, "set maximum size of a single allocated block", "bytes" },
{ "cpuflags", HAS_ARG | OPT_EXPERT, {(void*)opt_cpuflags}, "force specific cpu flags", "flags" }, { "cpuflags" , HAS_ARG | OPT_EXPERT, {.func_arg = opt_cpuflags}, "force specific cpu flags", "flags" },

158
ffmpeg_opt.c
Unescape View File

@ -167,31 +167,36 @@ static int opt_video_standard(const char *opt, const char *arg)
return opt_default("standard", arg); return opt_default("standard", arg);
} }
static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg) static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
audio_codec_name = arg; audio_codec_name = arg;
return parse_option(o, "codec:a", arg, options); return parse_option(o, "codec:a", arg, options);
} }
static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg) static int opt_video_codec(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
video_codec_name = arg; video_codec_name = arg;
return parse_option(o, "codec:v", arg, options); return parse_option(o, "codec:v", arg, options);
} }
static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg) static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
subtitle_codec_name = arg; subtitle_codec_name = arg;
return parse_option(o, "codec:s", arg, options); return parse_option(o, "codec:s", arg, options);
} }
static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg) static int opt_data_codec(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
return parse_option(o, "codec:d", arg, options); return parse_option(o, "codec:d", arg, options);
} }
static int opt_map(OptionsContext *o, const char *opt, const char *arg) static int opt_map(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
StreamMap *m = NULL; StreamMap *m = NULL;
int i, negative = 0, file_idx; int i, negative = 0, file_idx;
int sync_file_idx = -1, sync_stream_idx = 0; int sync_file_idx = -1, sync_stream_idx = 0;
@ -286,8 +291,9 @@ static int opt_map(OptionsContext *o, const char *opt, const char *arg)
return 0; return 0;
} }
static int opt_attach(OptionsContext *o, const char *opt, const char *arg) static int opt_attach(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
o->attachments = grow_array(o->attachments, sizeof(*o->attachments), o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
&o->nb_attachments, o->nb_attachments + 1); &o->nb_attachments, o->nb_attachments + 1);
o->attachments[o->nb_attachments - 1] = arg; o->attachments[o->nb_attachments - 1] = arg;
@ -486,12 +492,22 @@ static int opt_recording_timestamp(OptionsContext *o, const char *opt, const cha
static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder) static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
{ {
const AVCodecDescriptor *desc;
const char *codec_string = encoder ? "encoder" : "decoder"; const char *codec_string = encoder ? "encoder" : "decoder";
AVCodec *codec; AVCodec *codec;
codec = encoder ? codec = encoder ?
avcodec_find_encoder_by_name(name) : avcodec_find_encoder_by_name(name) :
avcodec_find_decoder_by_name(name); avcodec_find_decoder_by_name(name);
if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
codec = encoder ? avcodec_find_encoder(desc->id) :
avcodec_find_decoder(desc->id);
if (codec)
av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
codec_string, codec->name, desc->name);
}
if (!codec) { if (!codec) {
av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name); av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
exit_program(1); exit_program(1);
@ -661,8 +677,9 @@ static void dump_attachment(AVStream *st, const char *filename)
avio_close(out); avio_close(out);
} }
static int opt_input_file(OptionsContext *o, const char *opt, const char *filename) static int opt_input_file(void *optctx, const char *opt, const char *filename)
{ {
OptionsContext *o = optctx;
AVFormatContext *ic; AVFormatContext *ic;
AVInputFormat *file_iformat = NULL; AVInputFormat *file_iformat = NULL;
int err, i, ret; int err, i, ret;
@ -1232,8 +1249,9 @@ static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc,
} }
/* arg format is "output-stream-index:streamid-value". */ /* arg format is "output-stream-index:streamid-value". */
static int opt_streamid(OptionsContext *o, const char *opt, const char *arg) static int opt_streamid(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
int idx; int idx;
char *p; char *p;
char idx_str[16]; char idx_str[16];
@ -1748,8 +1766,9 @@ static int opt_pass(const char *opt, const char *arg)
} }
static int opt_target(OptionsContext *o, const char *opt, const char *arg) static int opt_target(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN; enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" }; static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
@ -1904,18 +1923,21 @@ static int opt_vstats(const char *opt, const char *arg)
return opt_vstats_file(opt, filename); return opt_vstats_file(opt, filename);
} }
static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg) static int opt_video_frames(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
return parse_option(o, "frames:v", arg, options); return parse_option(o, "frames:v", arg, options);
} }
static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg) static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
return parse_option(o, "frames:a", arg, options); return parse_option(o, "frames:a", arg, options);
} }
static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg) static int opt_data_frames(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
return parse_option(o, "frames:d", arg, options); return parse_option(o, "frames:d", arg, options);
} }
@ -2012,15 +2034,18 @@ static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
return parse_option(o, "profile:v", arg, options); return parse_option(o, "profile:v", arg, options);
} }
return opt_default(opt, arg); return opt_default(opt, arg);
} }
static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg) static int opt_video_filters(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
return parse_option(o, "filter:v", arg, options); return parse_option(o, "filter:v", arg, options);
} }
static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg) static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
return parse_option(o, "filter:a", arg, options); return parse_option(o, "filter:a", arg, options);
} }
@ -2053,8 +2078,9 @@ static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
return ret; return ret;
} }
static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg) static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
char layout_str[32]; char layout_str[32];
char *stream_str; char *stream_str;
char *ac_str; char *ac_str;
@ -2088,8 +2114,9 @@ static int opt_channel_layout(OptionsContext *o, const char *opt, const char *ar
return ret; return ret;
} }
static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg) static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
{ {
OptionsContext *o = optctx;
return parse_option(o, "q:a", arg, options); return parse_option(o, "q:a", arg, options);
} }
@ -2104,7 +2131,7 @@ static int opt_filter_complex(const char *opt, const char *arg)
return 0; return 0;
} }
static int opt_help(const char *opt, const char *arg) static int show_help(const char *opt, const char *arg)
{ {
int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM; int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
av_log_set_callback(log_callback_help); av_log_set_callback(log_callback_help);
@ -2138,7 +2165,6 @@ static int opt_help(const char *opt, const char *arg)
show_help_children(sws_get_class(), flags); show_help_children(sws_get_class(), flags);
show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM); show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM); show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
return 0; return 0;
} }
@ -2172,14 +2198,14 @@ const OptionDef options[] = {
/* main options */ /* main options */
#include "cmdutils_common_opts.h" #include "cmdutils_common_opts.h"
{ "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" }, { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
{ "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" }, { "i", HAS_ARG | OPT_FUNC2, {.func2_arg = opt_input_file}, "input file name", "filename" },
{ "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" }, { "y", OPT_BOOL, {&file_overwrite}, "overwrite output files" },
{ "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" }, { "n", OPT_BOOL, {&no_file_overwrite}, "do not overwrite output files" },
{ "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" }, { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
{ "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" }, { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
{ "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" }, { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
{ "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" }, { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {.func2_arg = opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
{ "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" }, { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {.func2_arg = opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
{ "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile", { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
"outfile[,metadata]:infile[,metadata]" }, "outfile[,metadata]:infile[,metadata]" },
{ "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" }, { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
@ -2190,8 +2216,8 @@ const OptionDef options[] = {
{ "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" }, { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
{ "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" }, { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
{ "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" }, { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
{ "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" }, { "dframes", HAS_ARG | OPT_FUNC2, {.func2_arg = opt_data_frames}, "set the number of data frames to record", "number" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, { "benchmark", OPT_BOOL | OPT_EXPERT, {&do_benchmark},
"add timings for benchmarking" }, "add timings for benchmarking" },
{ "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all}, { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
"add timings for each task" }, "add timings for each task" },
@ -2199,22 +2225,22 @@ const OptionDef options[] = {
"write program-readable progress information", "url" }, "write program-readable progress information", "url" },
{ "stdin", OPT_BOOL | OPT_EXPERT, {(void*)&stdin_interaction}, { "stdin", OPT_BOOL | OPT_EXPERT, {(void*)&stdin_interaction},
"enable or disable interaction on standard input" }, "enable or disable interaction on standard input" },
{ "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" }, { "timelimit", HAS_ARG, {.func_arg = opt_timelimit}, "set max runtime in seconds", "limit" },
{ "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, { "dump", OPT_BOOL | OPT_EXPERT, {&do_pkt_dump},
"dump each input packet" }, "dump each input packet" },
{ "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, { "hex", OPT_BOOL | OPT_EXPERT, {&do_hex_dump},
"when dumping packets, also dump the payload" }, "when dumping packets, also dump the payload" },
{ "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" }, { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
{ "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" }, { "target", HAS_ARG | OPT_FUNC2, {.func2_arg = opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
{ "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" }, { "vsync", HAS_ARG | OPT_EXPERT, {opt_vsync}, "video sync method", "" },
{ "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" }, { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {&audio_sync_method}, "audio sync method", "" },
{ "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" }, { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {&audio_drift_threshold}, "audio drift threshold", "threshold" },
{ "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" }, { "copyts", OPT_BOOL | OPT_EXPERT, {&copy_ts}, "copy timestamps" },
{ "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying", "mode" }, { "copytb", HAS_ARG | OPT_BOOL | OPT_EXPERT, {.func_arg = &copy_tb}, "copy input stream time base when stream copying", "mode" },
{ "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(shortest)}, "finish encoding within shortest input" }, { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(shortest)}, "finish encoding within shortest input" },
{ "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" }, { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
{ "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" }, { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
{ "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" }, { "xerror", OPT_BOOL, {&exit_on_error}, "exit on error", "error" },
{ "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" }, { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
{ "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" }, { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
{ "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" }, { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
@ -2222,14 +2248,14 @@ const OptionDef options[] = {
{ "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" }, { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
{ "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" }, { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
{ "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" }, { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
{ "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" }, { "filter_complex", HAS_ARG | OPT_EXPERT, {.func_arg = opt_filter_complex}, "create a complex filtergraph", "graph_description" },
{ "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", }, { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
{ "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" }, { "attach", HAS_ARG | OPT_FUNC2, {.func2_arg = opt_attach}, "add an attachment to the output file", "filename" },
{ "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" }, { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
{ "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" }, { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
/* video options */ /* video options */
{ "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" }, { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_video_frames}, "set the number of video frames to record", "number" },
{ "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" }, { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "s", HAS_ARG | OPT_VIDEO | OPT_SUBTITLE | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" }, { "s", HAS_ARG | OPT_VIDEO | OPT_SUBTITLE | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
{ "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" }, { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
@ -2246,55 +2272,55 @@ const OptionDef options[] = {
{ "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" }, { "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}, "deprecated use -g 1"}, { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
{ "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" }, { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
{ "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" }, { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {&video_discard}, "discard threshold", "n" },
{ "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" }, { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
{ "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" }, { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
{ "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" }, { "sameq", OPT_BOOL | OPT_VIDEO, {&same_quant}, "use same quantizer as source (implies VBR)" },
{ "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, { "same_quant", OPT_BOOL | OPT_VIDEO, {&same_quant},
"use same quantizer as source (implies VBR)" }, "use same quantizer as source (implies VBR)" },
{ "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" }, { "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
{ "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" }, { "pass", HAS_ARG | OPT_VIDEO, {opt_pass}, "select the pass number (1 or 2)", "n" },
{ "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" }, { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
{ "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace}, { "deinterlace", OPT_EXPERT | OPT_VIDEO, {opt_deinterlace},
"this option is deprecated, use the yadif filter instead" }, "this option is deprecated, use the yadif filter instead" },
{ "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" }, { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
{ "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" }, { "vstats", OPT_EXPERT | OPT_VIDEO, {&opt_vstats}, "dump video coding statistics to file" },
{ "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" }, { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {opt_vstats_file}, "dump video coding statistics to file", "file" },
{ "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" }, { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_video_filters}, "video filters", "filter list" },
{ "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" }, { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
{ "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" }, { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
{ "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" }, { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(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" }, { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {&intra_dc_precision}, "intra_dc_precision", "precision" },
{ "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" }, { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {.func2_arg = opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
{ "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" }, { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {&qp_hist }, "show QP histogram" },
{ "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" }, { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
{ "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" }, { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {.func2_arg = opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
{ "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" }, { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
{ "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" }, { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
/* audio options */ /* audio options */
{ "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" }, { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_audio_frames}, "set the number of audio frames to record", "number" },
{ "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", }, { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
{ "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" }, { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
{ "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" }, { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
{ "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" }, { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
{ "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" }, { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
{ "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" }, { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
{ "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, // { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
{ "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" }, { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
{ "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" }, { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_channel_layout}, "set channel layout", "layout" },
{ "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" }, { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {.func2_arg = opt_audio_filters}, "audio filters", "filter list" },
/* subtitle options */ /* subtitle options */
{ "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" }, { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
{ "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" }, { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {.func2_arg = opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
{ "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" }, { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {.func2_arg = opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
{ "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, {.off = OFFSET(fix_sub_duration)}, "fix subtitles duration" }, { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, {.off = OFFSET(fix_sub_duration)}, "fix subtitles duration" },
/* grab options */ /* grab options */
{ "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" }, { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
{ "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" }, { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
{ "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" }, { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {&input_sync}, "sync read on input", "" },
/* muxer options */ /* muxer options */
{ "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" }, { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
@ -2309,9 +2335,9 @@ const OptionDef options[] = {
{ "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" }, { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
{ "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" }, { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
/* data codec support */ /* data codec support */
{ "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" }, { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {.func2_arg = opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
{ "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" }, { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
{ "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" }, { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {.func_arg = opt_default}, "generic catch all option", "" },
{ NULL, }, { NULL, },
}; };

4
ffplay.c
Unescape View File

@ -244,7 +244,7 @@ typedef struct AllocEventProps {
AVFrame *frame; AVFrame *frame;
} AllocEventProps; } AllocEventProps;
static int opt_help(const char *opt, const char *arg); static int show_help(const char *opt, const char *arg);
/* options specified by the user */ /* options specified by the user */
static AVInputFormat *file_iformat; static AVInputFormat *file_iformat;
@ -3023,7 +3023,7 @@ static void show_usage(void)
av_log(NULL, AV_LOG_INFO, "\n"); av_log(NULL, AV_LOG_INFO, "\n");
} }
static int opt_help(const char *opt, const char *arg) static int show_help(const char *opt, const char *arg)
{ {
av_log_set_callback(log_callback_help); av_log_set_callback(log_callback_help);
show_usage(); show_usage();

3
ffprobe.c
Unescape View File

@ -2072,7 +2072,7 @@ static void opt_input_file(void *optctx, const char *arg)
input_filename = arg; input_filename = arg;
} }
static int opt_help(const char *opt, const char *arg) static int show_help(const char *opt, const char *arg)
{ {
av_log_set_callback(log_callback_help); av_log_set_callback(log_callback_help);
show_usage(); show_usage();
@ -2080,7 +2080,6 @@ static int opt_help(const char *opt, const char *arg)
printf("\n"); printf("\n");
show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM); show_help_children(avformat_get_class(), AV_OPT_FLAG_DECODING_PARAM);
return 0; return 0;
} }

2
ffserver.c
Unescape View File

@ -4645,7 +4645,7 @@ static void opt_debug(void)
logfilename[0] = '-'; logfilename[0] = '-';
} }
static int opt_help(const char *opt, const char *arg) static int show_help(const char *opt, const char *arg)
{ {
printf("usage: ffserver [options]\n" printf("usage: ffserver [options]\n"
"Hyper fast multi format Audio/Video streaming server\n"); "Hyper fast multi format Audio/Video streaming server\n");

Write Preview
Loading…
Cancel
Save