har0ke/FFmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fftools: split off option types from other flags

Browse Source 
These values are not actually flags, as only one of them can be
meaningfully set.
This commit is contained in:
Anton Khirnov 2023-12-15 08:50:26 +01:00
parent 074abeb57e
commit d2e479a429
6 changed files with 490 additions and 382 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
fftools/cmdutils.c
View File

@ -83,7 +83,7 @@ void init_dynload(void)
#endif #endif
} }
int parse_number(const char *context, const char *numstr, int type, int parse_number(const char *context, const char *numstr, enum OptionType type,
double min, double max, double *dst) double min, double max, double *dst)
{ {
char *tail; char *tail;
@ -93,9 +93,9 @@ int parse_number(const char *context, const char *numstr, int type,
error = "Expected number for %s but found: %s\n"; error = "Expected number for %s but found: %s\n";
else if (d < min || d > max) else if (d < min || d > max)
error = "The value for %s was %s which is not within %f - %f\n"; error = "The value for %s was %s which is not within %f - %f\n";
else if (type == OPT_INT64 && (int64_t)d != d) else if (type == OPT_TYPE_INT64 && (int64_t)d != d)
error = "Expected int64 for %s but found %s\n"; error = "Expected int64 for %s but found %s\n";
else if (type == OPT_INT && (int)d != d) else if (type == OPT_TYPE_INT && (int)d != d)
error = "Expected int for %s but found %s\n"; error = "Expected int for %s but found %s\n";
else { else {
*dst = d; *dst = d;
@ -225,13 +225,11 @@ static inline void prepare_app_arguments(int *argc_ptr, char ***argv_ptr)
static int opt_has_arg(const OptionDef *o) static int opt_has_arg(const OptionDef *o)
{ {
if (o->flags & OPT_BOOL) if (o->type == OPT_TYPE_BOOL)
return 0; return 0;
if (o->flags & if (o->type == OPT_TYPE_FUNC)
(OPT_STRING | OPT_INT | OPT_FLOAT | OPT_INT64 | return !!(o->flags & HAS_ARG);
OPT_SPEC | OPT_TIME | OPT_DOUBLE)) return 1;
return 1;
return !!(o->flags & HAS_ARG);
} }
static int write_option(void *optctx, const OptionDef *po, const char *opt, static int write_option(void *optctx, const OptionDef *po, const char *opt,
@ -262,46 +260,50 @@ static int write_option(void *optctx, const OptionDef *po, const char *opt,
dst = &(*so)[*dstcount - 1].u; dst = &(*so)[*dstcount - 1].u;
} }
if (po->flags & OPT_STRING) { if (po->type == OPT_TYPE_STRING) {
char *str; char *str;
str = av_strdup(arg); str = av_strdup(arg);
av_freep(dst); av_freep(dst);
if (!str) if (!str)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
*(char **)dst = str; *(char **)dst = str;
} else if (po->flags & OPT_BOOL || po->flags & OPT_INT) { } else if (po->type == OPT_TYPE_BOOL || po->type == OPT_TYPE_INT) {
ret = parse_number(opt, arg, OPT_INT64, INT_MIN, INT_MAX, &num); ret = parse_number(opt, arg, OPT_TYPE_INT64, INT_MIN, INT_MAX, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
*(int *)dst = num; *(int *)dst = num;
} else if (po->flags & OPT_INT64) { } else if (po->type == OPT_TYPE_INT64) {
ret = parse_number(opt, arg, OPT_INT64, INT64_MIN, INT64_MAX, &num); ret = parse_number(opt, arg, OPT_TYPE_INT64, INT64_MIN, INT64_MAX, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
*(int64_t *)dst = num; *(int64_t *)dst = num;
} else if (po->flags & OPT_TIME) { } else if (po->type == OPT_TYPE_TIME) {
ret = av_parse_time(dst, arg, 1); ret = av_parse_time(dst, arg, 1);
if (ret < 0) { if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Invalid duration for option %s: %s\n", av_log(NULL, AV_LOG_ERROR, "Invalid duration for option %s: %s\n",
opt, arg); opt, arg);
return ret; return ret;
} }
} else if (po->flags & OPT_FLOAT) { } else if (po->type == OPT_TYPE_FLOAT) {
ret = parse_number(opt, arg, OPT_FLOAT, -INFINITY, INFINITY, &num); ret = parse_number(opt, arg, OPT_TYPE_FLOAT, -INFINITY, INFINITY, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
*(float *)dst = num; *(float *)dst = num;
} else if (po->flags & OPT_DOUBLE) { } else if (po->type == OPT_TYPE_DOUBLE) {
ret = parse_number(opt, arg, OPT_DOUBLE, -INFINITY, INFINITY, &num); ret = parse_number(opt, arg, OPT_TYPE_DOUBLE, -INFINITY, INFINITY, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
*(double *)dst = num; *(double *)dst = num;
} else if (po->u.func_arg) { } else {
int ret = po->u.func_arg(optctx, opt, arg); int ret;
av_assert0(po->type == OPT_TYPE_FUNC && po->u.func_arg);
ret = po->u.func_arg(optctx, opt, arg);
if (ret < 0) { if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, av_log(NULL, AV_LOG_ERROR,
"Failed to set value '%s' for option '%s': %s\n", "Failed to set value '%s' for option '%s': %s\n",
@ -320,6 +322,7 @@ int parse_option(void *optctx, const char *opt, const char *arg,
{ {
static const OptionDef opt_avoptions = { static const OptionDef opt_avoptions = {
.name = "AVOption passthrough", .name = "AVOption passthrough",
.type = OPT_TYPE_FUNC,
.flags = HAS_ARG, .flags = HAS_ARG,
.u.func_arg = opt_default, .u.func_arg = opt_default,
}; };
@ -331,9 +334,9 @@ int parse_option(void *optctx, const char *opt, const char *arg,
if (!po->name && opt[0] == 'n' && opt[1] == 'o') { if (!po->name && opt[0] == 'n' && opt[1] == 'o') {
/* handle 'no' bool option */ /* handle 'no' bool option */
po = find_option(options, opt + 2); po = find_option(options, opt + 2);
if ((po->name && (po->flags & OPT_BOOL))) if ((po->name && po->type == OPT_TYPE_BOOL))
arg = "0"; arg = "0";
} else if (po->flags & OPT_BOOL) } else if (po->type == OPT_TYPE_BOOL)
arg = "1"; arg = "1";
if (!po->name) if (!po->name)
@ -814,7 +817,7 @@ do { \
/* boolean -nofoo options */ /* boolean -nofoo options */
if (opt[0] == 'n' && opt[1] == 'o' && if (opt[0] == 'n' && opt[1] == 'o' &&
(po = find_option(options, opt + 2)) && (po = find_option(options, opt + 2)) &&
po->name && po->flags & OPT_BOOL) { po->name && po->type == OPT_TYPE_BOOL) {
ret = add_opt(octx, po, opt, "0"); ret = add_opt(octx, po, opt, "0");
if (ret < 0) if (ret < 0)
return ret; return ret;

21
fftools/cmdutils.h
View File

@ -77,6 +77,17 @@ int opt_default(void *optctx, const char *opt, const char *arg);
*/ */
int opt_timelimit(void *optctx, const char *opt, const char *arg); int opt_timelimit(void *optctx, const char *opt, const char *arg);
enum OptionType {
OPT_TYPE_FUNC,
OPT_TYPE_BOOL,
OPT_TYPE_STRING,
OPT_TYPE_INT,
OPT_TYPE_INT64,
OPT_TYPE_FLOAT,
OPT_TYPE_DOUBLE,
OPT_TYPE_TIME,
};
/** /**
* Parse a string and return its corresponding value as a double. * Parse a string and return its corresponding value as a double.
* *
@ -88,7 +99,7 @@ int opt_timelimit(void *optctx, const char *opt, const char *arg);
* @param min the minimum valid accepted value * @param min the minimum valid accepted value
* @param max the maximum valid accepted value * @param max the maximum valid accepted value
*/ */
int parse_number(const char *context, const char *numstr, int type, int parse_number(const char *context, const char *numstr, enum OptionType type,
double min, double max, double *dst); double min, double max, double *dst);
typedef struct SpecifierOpt { typedef struct SpecifierOpt {
@ -105,17 +116,13 @@ typedef struct SpecifierOpt {
typedef struct OptionDef { typedef struct OptionDef {
const char *name; const char *name;
enum OptionType type;
int flags; int flags;
#define HAS_ARG (1 << 0) #define HAS_ARG (1 << 0)
#define OPT_BOOL (1 << 1)
#define OPT_EXPERT (1 << 2) #define OPT_EXPERT (1 << 2)
#define OPT_STRING (1 << 3)
#define OPT_VIDEO (1 << 4) #define OPT_VIDEO (1 << 4)
#define OPT_AUDIO (1 << 5) #define OPT_AUDIO (1 << 5)
#define OPT_INT (1 << 6)
#define OPT_FLOAT (1 << 7)
#define OPT_SUBTITLE (1 << 8) #define OPT_SUBTITLE (1 << 8)
#define OPT_INT64 (1 << 9)
#define OPT_EXIT (1 << 10) #define OPT_EXIT (1 << 10)
#define OPT_DATA (1 << 11) #define OPT_DATA (1 << 11)
/* The option is per-file (currently ffmpeg-only). /* The option is per-file (currently ffmpeg-only).
@ -127,8 +134,6 @@ typedef struct OptionDef {
Next element after the offset is an int containing element count in the Next element after the offset is an int containing element count in the
array. */ array. */
#define OPT_SPEC (1 << 14) #define OPT_SPEC (1 << 14)
#define OPT_TIME (1 << 15)
#define OPT_DOUBLE (1 << 16)
#define OPT_INPUT (1 << 17) #define OPT_INPUT (1 << 17)
#define OPT_OUTPUT (1 << 18) #define OPT_OUTPUT (1 << 18)
union { union {

560
fftools/ffmpeg_opt.c
View File

@ -105,7 +105,7 @@ static void uninit_options(OptionsContext *o)
const OptionDef *po = options; const OptionDef *po = options;
int i; int i;
/* all OPT_SPEC and OPT_STRING can be freed in generic way */ /* all OPT_SPEC and OPT_TYPE_STRING can be freed in generic way */
while (po->name) { while (po->name) {
void *dst = (uint8_t*)o + po->u.off; void *dst = (uint8_t*)o + po->u.off;
@ -114,12 +114,12 @@ static void uninit_options(OptionsContext *o)
int i, *count = (int*)(so + 1); int i, *count = (int*)(so + 1);
for (i = 0; i < *count; i++) { for (i = 0; i < *count; i++) {
av_freep(&(*so)[i].specifier); av_freep(&(*so)[i].specifier);
if (po->flags & OPT_STRING) if (po->type == OPT_TYPE_STRING)
av_freep(&(*so)[i].u.str); av_freep(&(*so)[i].u.str);
} }
av_freep(so); av_freep(so);
*count = 0; *count = 0;
} else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING) } else if (po->flags & OPT_OFFSET && po->type == OPT_TYPE_STRING)
av_freep(dst); av_freep(dst);
po++; po++;
} }
@ -204,7 +204,7 @@ int parse_and_set_vsync(const char *arg, int *vsync_var, int file_idx, int st_id
int ret; int ret;
double num; double num;
ret = parse_number("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR, &num); ret = parse_number("vsync", arg, OPT_TYPE_INT, VSYNC_AUTO, VSYNC_VFR, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -1393,7 +1393,7 @@ int opt_timelimit(void *optctx, const char *opt, const char *arg)
double lim; double lim;
struct rlimit rl; struct rlimit rl;
ret = parse_number(opt, arg, OPT_INT64, 0, INT_MAX, &lim); ret = parse_number(opt, arg, OPT_TYPE_INT64, 0, INT_MAX, &lim);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -1426,437 +1426,537 @@ static int opt_adrift_threshold(void *optctx, const char *opt, const char *arg)
const OptionDef options[] = { const OptionDef options[] = {
/* main options */ /* main options */
CMDUTILS_COMMON_OPTIONS CMDUTILS_COMMON_OPTIONS
{ "f", OPT_STRING | OPT_OFFSET | { "f", OPT_TYPE_STRING, OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) }, { .off = OFFSET(format) },
"force format", "fmt" }, "force format", "fmt" },
{ "y", OPT_BOOL, { &file_overwrite }, { "y", OPT_TYPE_BOOL, 0,
{ &file_overwrite },
"overwrite output files" }, "overwrite output files" },
{ "n", OPT_BOOL, { &no_file_overwrite }, { "n", OPT_TYPE_BOOL, 0,
{ &no_file_overwrite },
"never overwrite output files" }, "never overwrite output files" },
{ "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams }, { "ignore_unknown", OPT_TYPE_BOOL, 0,
{ &ignore_unknown_streams },
"Ignore unknown stream types" }, "Ignore unknown stream types" },
{ "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams }, { "copy_unknown", OPT_TYPE_BOOL, OPT_EXPERT,
{ &copy_unknown_streams },
"Copy unknown stream types" }, "Copy unknown stream types" },
{ "recast_media", OPT_BOOL | OPT_EXPERT, { &recast_media }, { "recast_media", OPT_TYPE_BOOL, OPT_EXPERT,
{ &recast_media },
"allow recasting stream type in order to force a decoder of different media type" }, "allow recasting stream type in order to force a decoder of different media type" },
{ "c", OPT_STRING | OPT_SPEC | { "c", OPT_TYPE_STRING, OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) }, { .off = OFFSET(codec_names) },
"codec name", "codec" }, "codec name", "codec" },
{ "codec", OPT_STRING | OPT_SPEC | { "codec", OPT_TYPE_STRING, OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) }, { .off = OFFSET(codec_names) },
"codec name", "codec" }, "codec name", "codec" },
{ "pre", OPT_STRING | OPT_SPEC | { "pre", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(presets) }, { .off = OFFSET(presets) },
"preset name", "preset" }, "preset name", "preset" },
{ "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE | { "map", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
OPT_OUTPUT, { .func_arg = opt_map }, { .func_arg = opt_map },
"set input stream mapping", "set input stream mapping",
"[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" }, "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
{ "map_metadata", OPT_STRING | OPT_SPEC | { "map_metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(metadata_map) }, { .off = OFFSET(metadata_map) },
"set metadata information of outfile from infile", "set metadata information of outfile from infile",
"outfile[,metadata]:infile[,metadata]" }, "outfile[,metadata]:infile[,metadata]" },
{ "map_chapters", OPT_INT | OPT_EXPERT | OPT_OFFSET | { "map_chapters", OPT_TYPE_INT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(chapters_input_file) }, { .off = OFFSET(chapters_input_file) },
"set chapters mapping", "input_file_index" }, "set chapters mapping", "input_file_index" },
{ "t", OPT_TIME | OPT_OFFSET | { "t", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) }, { .off = OFFSET(recording_time) },
"record or transcode \"duration\" seconds of audio/video", "record or transcode \"duration\" seconds of audio/video",
"duration" }, "duration" },
{ "to", OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(stop_time) }, { "to", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
{ .off = OFFSET(stop_time) },
"record or transcode stop time", "time_stop" }, "record or transcode stop time", "time_stop" },
{ "fs", OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) }, { "fs", OPT_TYPE_INT64, OPT_OFFSET | OPT_OUTPUT,
{ .off = OFFSET(limit_filesize) },
"set the limit file size in bytes", "limit_size" }, "set the limit file size in bytes", "limit_size" },
{ "ss", OPT_TIME | OPT_OFFSET | { "ss", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) }, { .off = OFFSET(start_time) },
"set the start time offset", "time_off" }, "set the start time offset", "time_off" },
{ "sseof", OPT_TIME | OPT_OFFSET | { "sseof", OPT_TYPE_TIME, OPT_OFFSET | OPT_INPUT,
OPT_INPUT, { .off = OFFSET(start_time_eof) }, { .off = OFFSET(start_time_eof) },
"set the start time offset relative to EOF", "time_off" }, "set the start time offset relative to EOF", "time_off" },
{ "seek_timestamp", OPT_INT | OPT_OFFSET | { "seek_timestamp", OPT_TYPE_INT, OPT_OFFSET | OPT_INPUT,
OPT_INPUT, { .off = OFFSET(seek_timestamp) }, { .off = OFFSET(seek_timestamp) },
"enable/disable seeking by timestamp with -ss" }, "enable/disable seeking by timestamp with -ss" },
{ "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT | { "accurate_seek", OPT_TYPE_BOOL, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
OPT_INPUT, { .off = OFFSET(accurate_seek) }, { .off = OFFSET(accurate_seek) },
"enable/disable accurate seeking with -ss" }, "enable/disable accurate seeking with -ss" },
{ "isync", OPT_INT | OPT_OFFSET | { "isync", OPT_TYPE_INT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_sync_ref) }, { .off = OFFSET(input_sync_ref) },
"Indicate the input index for sync reference", "sync ref" }, "Indicate the input index for sync reference", "sync ref" },
{ "itsoffset", OPT_TIME | OPT_OFFSET | { "itsoffset", OPT_TYPE_TIME, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) }, { .off = OFFSET(input_ts_offset) },
"set the input ts offset", "time_off" }, "set the input ts offset", "time_off" },
{ "itsscale", OPT_DOUBLE | OPT_SPEC | { "itsscale", OPT_TYPE_DOUBLE, OPT_SPEC | OPT_EXPERT | OPT_INPUT,
OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) }, { .off = OFFSET(ts_scale) },
"set the input ts scale", "scale" }, "set the input ts scale", "scale" },
{ "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp }, { "timestamp", OPT_TYPE_FUNC, HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_recording_timestamp },
"set the recording timestamp ('now' to set the current time)", "time" }, "set the recording timestamp ('now' to set the current time)", "time" },
{ "metadata", OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) }, { "metadata", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(metadata) },
"add metadata", "string=string" }, "add metadata", "string=string" },
{ "program", OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) }, { "program", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(program) },
"add program with specified streams", "title=string:st=number..." }, "add program with specified streams", "title=string:st=number..." },
{ "stream_group", OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(stream_groups) }, { "stream_group", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(stream_groups) },
"add stream group with specified streams and group type-specific arguments", "id=number:st=number..." }, "add stream group with specified streams and group type-specific arguments", "id=number:st=number..." },
{ "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT | { "dframes", OPT_TYPE_FUNC, HAS_ARG | OPT_PERFILE | OPT_EXPERT | OPT_OUTPUT,
OPT_OUTPUT, { .func_arg = opt_data_frames }, { .func_arg = opt_data_frames },
"set the number of data frames to output", "number" }, "set the number of data frames to output", "number" },
{ "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark }, { "benchmark", OPT_TYPE_BOOL, OPT_EXPERT,
{ &do_benchmark },
"add timings for benchmarking" }, "add timings for benchmarking" },
{ "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all }, { "benchmark_all", OPT_TYPE_BOOL, OPT_EXPERT,
{ &do_benchmark_all },
"add timings for each task" }, "add timings for each task" },
{ "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress }, { "progress", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_progress },
"write program-readable progress information", "url" }, "write program-readable progress information", "url" },
{ "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction }, { "stdin", OPT_TYPE_BOOL, OPT_EXPERT,
{ &stdin_interaction },
"enable or disable interaction on standard input" }, "enable or disable interaction on standard input" },
{ "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit }, { "timelimit", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_timelimit },
"set max runtime in seconds in CPU user time", "limit" }, "set max runtime in seconds in CPU user time", "limit" },
{ "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump }, { "dump", OPT_TYPE_BOOL, OPT_EXPERT,
{ &do_pkt_dump },
"dump each input packet" }, "dump each input packet" },
{ "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump }, { "hex", OPT_TYPE_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 | { "re", OPT_TYPE_BOOL, OPT_EXPERT | OPT_OFFSET | OPT_INPUT,
OPT_INPUT, { .off = OFFSET(rate_emu) }, { .off = OFFSET(rate_emu) },
"read input at native frame rate; equivalent to -readrate 1", "" }, "read input at native frame rate; equivalent to -readrate 1", "" },
{ "readrate", OPT_FLOAT | OPT_OFFSET | { "readrate", OPT_TYPE_FLOAT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
OPT_EXPERT | OPT_INPUT, { .off = OFFSET(readrate) }, { .off = OFFSET(readrate) },
"read input at specified rate", "speed" }, "read input at specified rate", "speed" },
{ "readrate_initial_burst", OPT_DOUBLE | OPT_OFFSET | { "readrate_initial_burst", OPT_TYPE_DOUBLE, OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
OPT_EXPERT | OPT_INPUT, { .off = OFFSET(readrate_initial_burst) }, { .off = OFFSET(readrate_initial_burst) },
"The initial amount of input to burst read before imposing any readrate", "seconds" }, "The initial amount of input to burst read before imposing any readrate", "seconds" },
{ "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target }, { "target", OPT_TYPE_FUNC, HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_target },
"specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" " "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
"with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" }, "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
{ "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync }, { "vsync", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_vsync },
"set video sync method globally; deprecated, use -fps_mode", "" }, "set video sync method globally; deprecated, use -fps_mode", "" },
{ "frame_drop_threshold", OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold }, { "frame_drop_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
{ &frame_drop_threshold },
"frame drop threshold", "" }, "frame drop threshold", "" },
{ "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts }, { "copyts", OPT_TYPE_BOOL, OPT_EXPERT,
{ &copy_ts },
"copy timestamps" }, "copy timestamps" },
{ "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero }, { "start_at_zero", OPT_TYPE_BOOL, OPT_EXPERT,
{ &start_at_zero },
"shift input timestamps to start at 0 when using copyts" }, "shift input timestamps to start at 0 when using copyts" },
{ "copytb", OPT_INT | OPT_EXPERT, { &copy_tb }, { "copytb", OPT_TYPE_INT, OPT_EXPERT,
{ &copy_tb },
"copy input stream time base when stream copying", "mode" }, "copy input stream time base when stream copying", "mode" },
{ "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET | { "shortest", OPT_TYPE_BOOL, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(shortest) }, { .off = OFFSET(shortest) },
"finish encoding within shortest input" }, "finish encoding within shortest input" },
{ "shortest_buf_duration", OPT_FLOAT | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(shortest_buf_duration) }, { "shortest_buf_duration", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
{ .off = OFFSET(shortest_buf_duration) },
"maximum buffering duration (in seconds) for the -shortest option" }, "maximum buffering duration (in seconds) for the -shortest option" },
{ "bitexact", OPT_BOOL | OPT_EXPERT | OPT_OFFSET | { "bitexact", OPT_TYPE_BOOL, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT | OPT_INPUT,
OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(bitexact) }, { .off = OFFSET(bitexact) },
"bitexact mode" }, "bitexact mode" },
{ "apad", OPT_STRING | OPT_SPEC | { "apad", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(apad) }, { .off = OFFSET(apad) },
"audio pad", "" }, "audio pad", "" },
{ "dts_delta_threshold", OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold }, { "dts_delta_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
{ &dts_delta_threshold },
"timestamp discontinuity delta threshold", "threshold" }, "timestamp discontinuity delta threshold", "threshold" },
{ "dts_error_threshold", OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold }, { "dts_error_threshold", OPT_TYPE_FLOAT, OPT_EXPERT,
{ &dts_error_threshold },
"timestamp error delta threshold", "threshold" }, "timestamp error delta threshold", "threshold" },
{ "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error }, { "xerror", OPT_TYPE_BOOL, OPT_EXPERT,
{ &exit_on_error },
"exit on error", "error" }, "exit on error", "error" },
{ "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on }, { "abort_on", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_abort_on },
"abort on the specified condition flags", "flags" }, "abort on the specified condition flags", "flags" },
{ "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC | { "copyinkf", OPT_TYPE_BOOL, OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) }, { .off = OFFSET(copy_initial_nonkeyframes) },
"copy initial non-keyframes" }, "copy initial non-keyframes" },
{ "copypriorss", OPT_INT | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) }, { "copypriorss", OPT_TYPE_INT, OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(copy_prior_start) },
"copy or discard frames before start time" }, "copy or discard frames before start time" },
{ "frames", OPT_INT64 | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) }, { "frames", OPT_TYPE_INT64, OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(max_frames) },
"set the number of frames to output", "number" }, "set the number of frames to output", "number" },
{ "tag", OPT_STRING | OPT_SPEC | { "tag", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,
OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) }, { .off = OFFSET(codec_tags) },
"force codec tag/fourcc", "fourcc/tag" }, "force codec tag/fourcc", "fourcc/tag" },
{ "q", OPT_EXPERT | OPT_DOUBLE | { "q", OPT_TYPE_DOUBLE, OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) }, { .off = OFFSET(qscale) },
"use fixed quality scale (VBR)", "q" }, "use fixed quality scale (VBR)", "q" },
{ "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE | { "qscale", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
OPT_OUTPUT, { .func_arg = opt_qscale }, { .func_arg = opt_qscale },
"use fixed quality scale (VBR)", "q" }, "use fixed quality scale (VBR)", "q" },
{ "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile }, { "profile", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_profile },
"set profile", "profile" }, "set profile", "profile" },
{ "filter", OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) }, { "filter", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(filters) },
"set stream filtergraph", "filter_graph" }, "set stream filtergraph", "filter_graph" },
{ "filter_threads", HAS_ARG, { .func_arg = opt_filter_threads }, { "filter_threads", OPT_TYPE_FUNC, HAS_ARG,
{ .func_arg = opt_filter_threads },
"number of non-complex filter threads" }, "number of non-complex filter threads" },
{ "filter_script", OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) }, { "filter_script", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(filter_scripts) },
"read stream filtergraph description from a file", "filename" }, "read stream filtergraph description from a file", "filename" },
{ "reinit_filter", OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) }, { "reinit_filter", OPT_TYPE_INT, OPT_SPEC | OPT_INPUT,
{ .off = OFFSET(reinit_filters) },
"reinit filtergraph on input parameter changes", "" }, "reinit filtergraph on input parameter changes", "" },
{ "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex }, { "filter_complex", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_filter_complex },
"create a complex filtergraph", "graph_description" }, "create a complex filtergraph", "graph_description" },
{ "filter_complex_threads", OPT_INT, { &filter_complex_nbthreads }, { "filter_complex_threads", OPT_TYPE_INT, 0,
{ &filter_complex_nbthreads },
"number of threads for -filter_complex" }, "number of threads for -filter_complex" },
{ "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex }, { "lavfi", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_filter_complex },
"create a complex filtergraph", "graph_description" }, "create a complex filtergraph", "graph_description" },
{ "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script }, { "filter_complex_script", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_filter_complex_script },
"read complex filtergraph description from a file", "filename" }, "read complex filtergraph description from a file", "filename" },
{ "auto_conversion_filters", OPT_BOOL | OPT_EXPERT, { &auto_conversion_filters }, { "auto_conversion_filters", OPT_TYPE_BOOL, OPT_EXPERT,
{ &auto_conversion_filters },
"enable automatic conversion filters globally" }, "enable automatic conversion filters globally" },
{ "stats", OPT_BOOL, { &print_stats }, { "stats", OPT_TYPE_BOOL, 0,
{ &print_stats },
"print progress report during encoding", }, "print progress report during encoding", },
{ "stats_period", HAS_ARG | OPT_EXPERT, { .func_arg = opt_stats_period }, { "stats_period", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_stats_period },
"set the period at which ffmpeg updates stats and -progress output", "time" }, "set the period at which ffmpeg updates stats and -progress output", "time" },
{ "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT | { "attach", OPT_TYPE_FUNC, HAS_ARG | OPT_PERFILE | OPT_EXPERT | OPT_OUTPUT,
OPT_OUTPUT, { .func_arg = opt_attach }, { .func_arg = opt_attach },
"add an attachment to the output file", "filename" }, "add an attachment to the output file", "filename" },
{ "dump_attachment", OPT_STRING | OPT_SPEC | { "dump_attachment", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_INPUT,
OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) }, { .off = OFFSET(dump_attachment) },
"extract an attachment into a file", "filename" }, "extract an attachment into a file", "filename" },
{ "stream_loop", OPT_INT | OPT_EXPERT | OPT_INPUT | { "stream_loop", OPT_TYPE_INT, OPT_EXPERT | OPT_INPUT | OPT_OFFSET,
OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" }, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
{ "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts }, { "debug_ts", OPT_TYPE_BOOL, OPT_EXPERT,
{ &debug_ts },
"print timestamp debugging info" }, "print timestamp debugging info" },
{ "max_error_rate", OPT_FLOAT, { &max_error_rate }, { "max_error_rate", OPT_TYPE_FLOAT, 0,
{ &max_error_rate },
"ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" }, "ratio of decoding errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
{ "discard", OPT_STRING | OPT_SPEC | { "discard", OPT_TYPE_STRING, OPT_SPEC | OPT_INPUT,
OPT_INPUT, { .off = OFFSET(discard) }, { .off = OFFSET(discard) },
"discard", "" }, "discard", "" },
{ "disposition", OPT_STRING | OPT_SPEC | { "disposition", OPT_TYPE_STRING, OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(disposition) }, { .off = OFFSET(disposition) },
"disposition", "" }, "disposition", "" },
{ "thread_queue_size", OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { "thread_queue_size", OPT_TYPE_INT, OPT_OFFSET | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT,
{ .off = OFFSET(thread_queue_size) }, { .off = OFFSET(thread_queue_size) },
"set the maximum number of queued packets from the demuxer" }, "set the maximum number of queued packets from the demuxer" },
{ "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(find_stream_info) }, { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT | OPT_OFFSET,
{ .off = OFFSET(find_stream_info) },
"read and decode the streams to fill missing information with heuristics" }, "read and decode the streams to fill missing information with heuristics" },
{ "bits_per_raw_sample", OPT_INT | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { "bits_per_raw_sample", OPT_TYPE_INT, OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(bits_per_raw_sample) }, { .off = OFFSET(bits_per_raw_sample) },
"set the number of bits per raw sample", "number" }, "set the number of bits per raw sample", "number" },
{ "stats_enc_pre", OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(enc_stats_pre) }, { "stats_enc_pre", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(enc_stats_pre) },
"write encoding stats before encoding" }, "write encoding stats before encoding" },
{ "stats_enc_post", OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(enc_stats_post) }, { "stats_enc_post", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(enc_stats_post) },
"write encoding stats after encoding" }, "write encoding stats after encoding" },
{ "stats_mux_pre", OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(mux_stats) }, { "stats_mux_pre", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(mux_stats) },
"write packets stats before muxing" }, "write packets stats before muxing" },
{ "stats_enc_pre_fmt", OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(enc_stats_pre_fmt) }, { "stats_enc_pre_fmt", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(enc_stats_pre_fmt) },
"format of the stats written with -stats_enc_pre" }, "format of the stats written with -stats_enc_pre" },
{ "stats_enc_post_fmt", OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(enc_stats_post_fmt) }, { "stats_enc_post_fmt", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(enc_stats_post_fmt) },
"format of the stats written with -stats_enc_post" }, "format of the stats written with -stats_enc_post" },
{ "stats_mux_pre_fmt", OPT_SPEC | OPT_EXPERT | OPT_OUTPUT | OPT_STRING, { .off = OFFSET(mux_stats_fmt) }, { "stats_mux_pre_fmt", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(mux_stats_fmt) },
"format of the stats written with -stats_mux_pre" }, "format of the stats written with -stats_mux_pre" },
/* video options */ /* video options */
{ "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames }, { "vframes", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_video_frames },
"set the number of video frames to output", "number" }, "set the number of video frames to output", "number" },
{ "r", OPT_VIDEO | OPT_STRING | OPT_SPEC | { "r", OPT_TYPE_STRING, OPT_VIDEO | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) }, { .off = OFFSET(frame_rates) },
"set frame rate (Hz value, fraction or abbreviation)", "rate" }, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "fpsmax", OPT_VIDEO | OPT_STRING | OPT_SPEC | { "fpsmax", OPT_TYPE_STRING, OPT_VIDEO | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(max_frame_rates) }, { .off = OFFSET(max_frame_rates) },
"set max frame rate (Hz value, fraction or abbreviation)", "rate" }, "set max frame rate (Hz value, fraction or abbreviation)", "rate" },
{ "s", OPT_VIDEO | OPT_SUBTITLE | OPT_STRING | OPT_SPEC | { "s", OPT_TYPE_STRING, OPT_VIDEO | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) }, { .off = OFFSET(frame_sizes) },
"set frame size (WxH or abbreviation)", "size" }, "set frame size (WxH or abbreviation)", "size" },
{ "aspect", OPT_VIDEO | OPT_STRING | OPT_SPEC | { "aspect", OPT_TYPE_STRING, OPT_VIDEO | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) }, { .off = OFFSET(frame_aspect_ratios) },
"set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" }, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
{ "pix_fmt", OPT_VIDEO | OPT_EXPERT | OPT_STRING | OPT_SPEC | { "pix_fmt", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) }, { .off = OFFSET(frame_pix_fmts) },
"set pixel format", "format" }, "set pixel format", "format" },
{ "display_rotation", OPT_VIDEO | OPT_DOUBLE | OPT_SPEC | { "display_rotation", OPT_TYPE_DOUBLE, OPT_VIDEO | OPT_SPEC | OPT_INPUT,
OPT_INPUT, { .off = OFFSET(display_rotations) }, { .off = OFFSET(display_rotations) },
"set pure counter-clockwise rotation in degrees for stream(s)", "set pure counter-clockwise rotation in degrees for stream(s)",
"angle" }, "angle" },
{ "display_hflip", OPT_VIDEO | OPT_BOOL | OPT_SPEC | OPT_INPUT, { .off = OFFSET(display_hflips) }, { "display_hflip", OPT_TYPE_BOOL, OPT_VIDEO | OPT_SPEC | OPT_INPUT,
{ .off = OFFSET(display_hflips) },
"set display horizontal flip for stream(s) " "set display horizontal flip for stream(s) "
"(overrides any display rotation if it is not set)"}, "(overrides any display rotation if it is not set)"},
{ "display_vflip", OPT_VIDEO | OPT_BOOL | OPT_SPEC | OPT_INPUT, { .off = OFFSET(display_vflips) }, { "display_vflip", OPT_TYPE_BOOL, OPT_VIDEO | OPT_SPEC | OPT_INPUT,
{ .off = OFFSET(display_vflips) },
"set display vertical flip for stream(s) " "set display vertical flip for stream(s) "
"(overrides any display rotation if it is not set)"}, "(overrides any display rotation if it is not set)"},
{ "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) }, { "vn", OPT_TYPE_BOOL, OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
{ .off = OFFSET(video_disable) },
"disable video" }, "disable video" },
{ "rc_override", OPT_VIDEO | OPT_EXPERT | OPT_STRING | OPT_SPEC | { "rc_override", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(rc_overrides) }, { .off = OFFSET(rc_overrides) },
"rate control override for specific intervals", "override" }, "rate control override for specific intervals", "override" },
{ "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT | { "vcodec", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT,
OPT_OUTPUT, { .func_arg = opt_video_codec }, { .func_arg = opt_video_codec },
"force video codec ('copy' to copy stream)", "codec" }, "force video codec ('copy' to copy stream)", "codec" },
{ "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode }, { "timecode", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_timecode },
"set initial TimeCode value.", "hh:mm:ss[:;.]ff" }, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
{ "pass", OPT_VIDEO | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) }, { "pass", OPT_TYPE_INT, OPT_VIDEO | OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(pass) },
"select the pass number (1 to 3)", "n" }, "select the pass number (1 to 3)", "n" },
{ "passlogfile", OPT_VIDEO | OPT_STRING | OPT_EXPERT | OPT_SPEC | { "passlogfile", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(passlogfiles) }, { .off = OFFSET(passlogfiles) },
"select two pass log file name prefix", "prefix" }, "select two pass log file name prefix", "prefix" },
{ "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats }, { "vstats", OPT_TYPE_FUNC, OPT_VIDEO | OPT_EXPERT,
{ .func_arg = opt_vstats },
"dump video coding statistics to file" }, "dump video coding statistics to file" },
{ "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file }, { "vstats_file", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_vstats_file },
"dump video coding statistics to file", "file" }, "dump video coding statistics to file", "file" },
{ "vstats_version", OPT_VIDEO | OPT_INT | OPT_EXPERT , { &vstats_version }, { "vstats_version", OPT_TYPE_INT, OPT_VIDEO | OPT_EXPERT,
{ &vstats_version },
"Version of the vstats format to use."}, "Version of the vstats format to use."},
{ "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters }, { "vf", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_video_filters },
"set video filters", "filter_graph" }, "set video filters", "filter_graph" },
{ "intra_matrix", OPT_VIDEO | OPT_EXPERT | OPT_STRING | OPT_SPEC | { "intra_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(intra_matrices) }, { .off = OFFSET(intra_matrices) },
"specify intra matrix coeffs", "matrix" }, "specify intra matrix coeffs", "matrix" },
{ "inter_matrix", OPT_VIDEO | OPT_EXPERT | OPT_STRING | OPT_SPEC | { "inter_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(inter_matrices) }, { .off = OFFSET(inter_matrices) },
"specify inter matrix coeffs", "matrix" }, "specify inter matrix coeffs", "matrix" },
{ "chroma_intra_matrix", OPT_VIDEO | OPT_EXPERT | OPT_STRING | OPT_SPEC | { "chroma_intra_matrix", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) }, { .off = OFFSET(chroma_intra_matrices) },
"specify intra matrix coeffs", "matrix" }, "specify intra matrix coeffs", "matrix" },
{ "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | { "vtag", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new }, { .func_arg = opt_old2new },
"force video tag/fourcc", "fourcc/tag" }, "force video tag/fourcc", "fourcc/tag" },
{ "fps_mode", OPT_VIDEO | OPT_STRING | OPT_EXPERT | { "fps_mode", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(fps_mode) }, { .off = OFFSET(fps_mode) },
"set framerate mode for matching video streams; overrides vsync" }, "set framerate mode for matching video streams; overrides vsync" },
{ "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC | { "force_fps", OPT_TYPE_BOOL, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_OUTPUT, { .off = OFFSET(force_fps) }, { .off = OFFSET(force_fps) },
"force the selected framerate, disable the best supported framerate selection" }, "force the selected framerate, disable the best supported framerate selection" },
{ "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | { "streamid", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
OPT_OUTPUT, { .func_arg = opt_streamid }, { .func_arg = opt_streamid },
"set the value of an outfile streamid", "streamIndex:value" }, "set the value of an outfile streamid", "streamIndex:value" },
{ "force_key_frames", OPT_VIDEO | OPT_STRING | OPT_EXPERT | { "force_key_frames", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) }, { .off = OFFSET(forced_key_frames) },
"force key frames at specified timestamps", "timestamps" }, "force key frames at specified timestamps", "timestamps" },
{ "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate }, { "b", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_bitrate },
"video bitrate (please use -b:v)", "bitrate" }, "video bitrate (please use -b:v)", "bitrate" },
{ "hwaccel", OPT_VIDEO | OPT_STRING | OPT_EXPERT | { "hwaccel", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_INPUT,
OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) }, { .off = OFFSET(hwaccels) },
"use HW accelerated decoding", "hwaccel name" }, "use HW accelerated decoding", "hwaccel name" },
{ "hwaccel_device", OPT_VIDEO | OPT_STRING | OPT_EXPERT | { "hwaccel_device", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_INPUT,
OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) }, { .off = OFFSET(hwaccel_devices) },
"select a device for HW acceleration", "devicename" }, "select a device for HW acceleration", "devicename" },
{ "hwaccel_output_format", OPT_VIDEO | OPT_STRING | OPT_EXPERT | { "hwaccel_output_format", OPT_TYPE_STRING, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_INPUT,
OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) }, { .off = OFFSET(hwaccel_output_formats) },
"select output format used with HW accelerated decoding", "format" }, "select output format used with HW accelerated decoding", "format" },
{ "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels }, { "hwaccels", OPT_TYPE_FUNC, OPT_EXIT,
{ .func_arg = show_hwaccels },
"show available HW acceleration methods" }, "show available HW acceleration methods" },
{ "autorotate", OPT_BOOL | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) }, { "autorotate", OPT_TYPE_BOOL, OPT_SPEC | OPT_EXPERT | OPT_INPUT,
{ .off = OFFSET(autorotate) },
"automatically insert correct rotate filters" }, "automatically insert correct rotate filters" },
{ "autoscale", OPT_BOOL | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(autoscale) }, { "autoscale", OPT_TYPE_BOOL, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(autoscale) },
"automatically insert a scale filter at the end of the filter graph" }, "automatically insert a scale filter at the end of the filter graph" },
{ "fix_sub_duration_heartbeat", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | { "fix_sub_duration_heartbeat", OPT_TYPE_BOOL, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(fix_sub_duration_heartbeat) }, { .off = OFFSET(fix_sub_duration_heartbeat) },
"set this video output stream to be a heartbeat stream for " "set this video output stream to be a heartbeat stream for "
"fix_sub_duration, according to which subtitles should be split at " "fix_sub_duration, according to which subtitles should be split at "
"random access points" }, "random access points" },
/* audio options */ /* audio options */
{ "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames }, { "aframes", OPT_TYPE_FUNC, OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_audio_frames },
"set the number of audio frames to output", "number" }, "set the number of audio frames to output", "number" },
{ "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale }, { "aq", OPT_TYPE_FUNC, OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_audio_qscale },
"set audio quality (codec-specific)", "quality", }, "set audio quality (codec-specific)", "quality", },
{ "ar", OPT_AUDIO | OPT_INT | OPT_SPEC | { "ar", OPT_TYPE_INT, OPT_AUDIO | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) }, { .off = OFFSET(audio_sample_rate) },
"set audio sampling rate (in Hz)", "rate" }, "set audio sampling rate (in Hz)", "rate" },
{ "ac", OPT_AUDIO | OPT_INT | OPT_SPEC | { "ac", OPT_TYPE_INT, OPT_AUDIO | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) }, { .off = OFFSET(audio_channels) },
"set number of audio channels", "channels" }, "set number of audio channels", "channels" },
{ "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) }, { "an", OPT_TYPE_BOOL, OPT_AUDIO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
{ .off = OFFSET(audio_disable) },
"disable audio" }, "disable audio" },
{ "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE | { "acodec", OPT_TYPE_FUNC, OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec }, { .func_arg = opt_audio_codec },
"force audio codec ('copy' to copy stream)", "codec" }, "force audio codec ('copy' to copy stream)", "codec" },
{ "ab", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate }, { "ab", OPT_TYPE_FUNC, OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_bitrate },
"audio bitrate (please use -b:a)", "bitrate" }, "audio bitrate (please use -b:a)", "bitrate" },
{ "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | { "atag", OPT_TYPE_FUNC, OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
OPT_OUTPUT, { .func_arg = opt_old2new }, { .func_arg = opt_old2new },
"force audio tag/fourcc", "fourcc/tag" }, "force audio tag/fourcc", "fourcc/tag" },
{ "sample_fmt", OPT_AUDIO | OPT_EXPERT | OPT_SPEC | { "sample_fmt", OPT_TYPE_STRING, OPT_AUDIO | OPT_EXPERT | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) }, { .off = OFFSET(sample_fmts) },
"set sample format", "format" }, "set sample format", "format" },
{ "channel_layout", OPT_AUDIO | OPT_EXPERT | OPT_SPEC | { "channel_layout", OPT_TYPE_STRING, OPT_AUDIO | OPT_EXPERT | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_ch_layouts) }, { .off = OFFSET(audio_ch_layouts) },
"set channel layout", "layout" }, "set channel layout", "layout" },
{ "ch_layout", OPT_AUDIO | OPT_EXPERT | OPT_SPEC | { "ch_layout", OPT_TYPE_STRING, OPT_AUDIO | OPT_EXPERT | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_ch_layouts) }, { .off = OFFSET(audio_ch_layouts) },
"set channel layout", "layout" }, "set channel layout", "layout" },
{ "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters }, { "af", OPT_TYPE_FUNC, OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_audio_filters },
"set audio filters", "filter_graph" }, "set audio filters", "filter_graph" },
{ "guess_layout_max", OPT_AUDIO | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) }, { "guess_layout_max", OPT_TYPE_INT, OPT_AUDIO | OPT_SPEC | OPT_EXPERT | OPT_INPUT,
{ .off = OFFSET(guess_layout_max) },
"set the maximum number of channels to try to guess the channel layout" }, "set the maximum number of channels to try to guess the channel layout" },
/* subtitle options */ /* subtitle options */
{ "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) }, { "sn", OPT_TYPE_BOOL, OPT_SUBTITLE | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
{ .off = OFFSET(subtitle_disable) },
"disable subtitle" }, "disable subtitle" },
{ "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec }, { "scodec", OPT_TYPE_FUNC, OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT,
{ .func_arg = opt_subtitle_codec },
"force subtitle codec ('copy' to copy stream)", "codec" }, "force subtitle codec ('copy' to copy stream)", "codec" },
{ "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new } { "stag", OPT_TYPE_FUNC, OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_old2new }
, "force subtitle tag/fourcc", "fourcc/tag" }, , "force subtitle tag/fourcc", "fourcc/tag" },
{ "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) }, { "fix_sub_duration", OPT_TYPE_BOOL, OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT,
{ .off = OFFSET(fix_sub_duration) },
"fix subtitles duration" }, "fix subtitles duration" },
{ "canvas_size", OPT_SUBTITLE | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) }, { "canvas_size", OPT_TYPE_STRING, OPT_SUBTITLE | OPT_SPEC | OPT_INPUT,
{ .off = OFFSET(canvas_sizes) },
"set canvas size (WxH or abbreviation)", "size" }, "set canvas size (WxH or abbreviation)", "size" },
/* muxer options */ /* muxer options */
{ "muxdelay", OPT_FLOAT | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) }, { "muxdelay", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
{ .off = OFFSET(mux_max_delay) },
"set the maximum demux-decode delay", "seconds" }, "set the maximum demux-decode delay", "seconds" },
{ "muxpreload", OPT_FLOAT | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) }, { "muxpreload", OPT_TYPE_FLOAT, OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT,
{ .off = OFFSET(mux_preload) },
"set the initial demux-decode delay", "seconds" }, "set the initial demux-decode delay", "seconds" },
{ "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file }, { "sdp_file", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT | OPT_OUTPUT,
{ .func_arg = opt_sdp_file },
"specify a file in which to print sdp information", "file" }, "specify a file in which to print sdp information", "file" },
{ "time_base", OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) }, { "time_base", OPT_TYPE_STRING, OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(time_bases) },
"set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" }, "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
{ "enc_time_base", OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) }, { "enc_time_base", OPT_TYPE_STRING, OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,
{ .off = OFFSET(enc_time_bases) },
"set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). " "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
"two special values are defined - " "two special values are defined - "
"0 = use frame rate (video) or sample rate (audio)," "0 = use frame rate (video) or sample rate (audio),"
"-1 = match source time base", "ratio" }, "-1 = match source time base", "ratio" },
{ "bsf", OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) }, { "bsf", OPT_TYPE_STRING, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(bitstream_filters) },
"A comma-separated list of bitstream filters", "bitstream_filters" }, "A comma-separated list of bitstream filters", "bitstream_filters" },
{ "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }, { "absf", OPT_TYPE_FUNC, HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_old2new },
"deprecated", "audio bitstream_filters" }, "deprecated", "audio bitstream_filters" },
{ "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }, { "vbsf", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_old2new },
"deprecated", "video bitstream_filters" }, "deprecated", "video bitstream_filters" },
{ "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset }, { "apre", OPT_TYPE_FUNC, HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_preset },
"set the audio options to the indicated preset", "preset" }, "set the audio options to the indicated preset", "preset" },
{ "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset }, { "vpre", OPT_TYPE_FUNC, OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_preset },
"set the video options to the indicated preset", "preset" }, "set the video options to the indicated preset", "preset" },
{ "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset }, { "spre", OPT_TYPE_FUNC, HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_preset },
"set the subtitle options to the indicated preset", "preset" }, "set the subtitle options to the indicated preset", "preset" },
{ "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset }, { "fpre", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_preset },
"set options from indicated preset file", "filename" }, "set options from indicated preset file", "filename" },
{ "max_muxing_queue_size", OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) }, { "max_muxing_queue_size", OPT_TYPE_INT, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(max_muxing_queue_size) },
"maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" }, "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
{ "muxing_queue_data_threshold", OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(muxing_queue_data_threshold) }, { "muxing_queue_data_threshold", OPT_TYPE_INT, OPT_SPEC | OPT_EXPERT | OPT_OUTPUT,
{ .off = OFFSET(muxing_queue_data_threshold) },
"set the threshold after which max_muxing_queue_size is taken into account", "bytes" }, "set the threshold after which max_muxing_queue_size is taken into account", "bytes" },
/* data codec support */ /* data codec support */
{ "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec }, { "dcodec", OPT_TYPE_FUNC, HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT,
{ .func_arg = opt_data_codec },
"force data codec ('copy' to copy stream)", "codec" }, "force data codec ('copy' to copy stream)", "codec" },
{ "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) }, { "dn", OPT_TYPE_BOOL, OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,
"disable data" }, { .off = OFFSET(data_disable) }, "disable data" },
#if CONFIG_VAAPI #if CONFIG_VAAPI
{ "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device }, { "vaapi_device", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_vaapi_device },
"set VAAPI hardware device (DirectX adapter index, DRM path or X11 display name)", "device" }, "set VAAPI hardware device (DirectX adapter index, DRM path or X11 display name)", "device" },
#endif #endif
#if CONFIG_QSV #if CONFIG_QSV
{ "qsv_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_qsv_device }, { "qsv_device", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_qsv_device },
"set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"}, "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
#endif #endif
{ "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device }, { "init_hw_device", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_init_hw_device },
"initialise hardware device", "args" }, "initialise hardware device", "args" },
{ "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device }, { "filter_hw_device", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_filter_hw_device },
"set hardware device used when filtering", "device" }, "set hardware device used when filtering", "device" },
// deprecated options // deprecated options
#if FFMPEG_OPT_MAP_CHANNEL #if FFMPEG_OPT_MAP_CHANNEL
{ "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel }, { "map_channel", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT,
{ .func_arg = opt_map_channel },
"map an audio channel from one stream to another (deprecated)", "file.stream.channel[:syncfile.syncstream]" }, "map an audio channel from one stream to another (deprecated)", "file.stream.channel[:syncfile.syncstream]" },
#endif #endif
#if FFMPEG_OPT_ADRIFT_THRESHOLD #if FFMPEG_OPT_ADRIFT_THRESHOLD
{ "adrift_threshold", HAS_ARG | OPT_EXPERT, { .func_arg = opt_adrift_threshold }, { "adrift_threshold", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT,
{ .func_arg = opt_adrift_threshold },
"deprecated, does nothing", "threshold" }, "deprecated, does nothing", "threshold" },
#endif #endif
#if FFMPEG_OPT_PSNR #if FFMPEG_OPT_PSNR
{ "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr }, { "psnr", OPT_TYPE_BOOL, OPT_VIDEO | OPT_EXPERT,
{ &do_psnr },
"calculate PSNR of compressed frames (deprecated, use -flags +psnr)" }, "calculate PSNR of compressed frames (deprecated, use -flags +psnr)" },
#endif #endif
#if FFMPEG_OPT_TOP #if FFMPEG_OPT_TOP
{ "top", OPT_VIDEO | OPT_EXPERT | OPT_INT| OPT_SPEC | { "top", OPT_TYPE_INT, OPT_VIDEO | OPT_EXPERT | OPT_SPEC | OPT_INPUT | OPT_OUTPUT,
OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) }, { .off = OFFSET(top_field_first) },
"deprecated, use the setfield video filter", "" }, "deprecated, use the setfield video filter", "" },
#endif #endif
#if FFMPEG_OPT_QPHIST #if FFMPEG_OPT_QPHIST
{ "qphist", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_qphist }, { "qphist", OPT_TYPE_FUNC, OPT_VIDEO | OPT_EXPERT,
{ .func_arg = opt_qphist },
"deprecated, does nothing" }, "deprecated, does nothing" },
#endif #endif

102
fftools/ffplay.c
View File

@ -3516,7 +3516,7 @@ static void event_loop(VideoState *cur_stream)
static int opt_width(void *optctx, const char *opt, const char *arg) static int opt_width(void *optctx, const char *opt, const char *arg)
{ {
double num; double num;
int ret = parse_number(opt, arg, OPT_INT64, 1, INT_MAX, &num); int ret = parse_number(opt, arg, OPT_TYPE_INT64, 1, INT_MAX, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -3527,7 +3527,7 @@ static int opt_width(void *optctx, const char *opt, const char *arg)
static int opt_height(void *optctx, const char *opt, const char *arg) static int opt_height(void *optctx, const char *opt, const char *arg)
{ {
double num; double num;
int ret = parse_number(opt, arg, OPT_INT64, 1, INT_MAX, &num); int ret = parse_number(opt, arg, OPT_TYPE_INT64, 1, INT_MAX, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -3568,7 +3568,7 @@ static int opt_show_mode(void *optctx, const char *opt, const char *arg)
if (show_mode == SHOW_MODE_NONE) { if (show_mode == SHOW_MODE_NONE) {
double num; double num;
int ret = parse_number(opt, arg, OPT_INT, 0, SHOW_MODE_NB-1, &num); int ret = parse_number(opt, arg, OPT_TYPE_INT, 0, SHOW_MODE_NB-1, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
show_mode = num; show_mode = num;
@ -3617,55 +3617,55 @@ static int dummy;
static const OptionDef options[] = { static const OptionDef options[] = {
CMDUTILS_COMMON_OPTIONS CMDUTILS_COMMON_OPTIONS
{ "x", HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" }, { "x", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = opt_width }, "force displayed width", "width" },
{ "y", HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" }, { "y", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = opt_height }, "force displayed height", "height" },
{ "fs", OPT_BOOL, { &is_full_screen }, "force full screen" }, { "fs", OPT_TYPE_BOOL, 0, { &is_full_screen }, "force full screen" },
{ "an", OPT_BOOL, { &audio_disable }, "disable audio" }, { "an", OPT_TYPE_BOOL, 0, { &audio_disable }, "disable audio" },
{ "vn", OPT_BOOL, { &video_disable }, "disable video" }, { "vn", OPT_TYPE_BOOL, 0, { &video_disable }, "disable video" },
{ "sn", OPT_BOOL, { &subtitle_disable }, "disable subtitling" }, { "sn", OPT_TYPE_BOOL, 0, { &subtitle_disable }, "disable subtitling" },
{ "ast", OPT_STRING | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" }, { "ast", OPT_TYPE_STRING, OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_AUDIO] }, "select desired audio stream", "stream_specifier" },
{ "vst", OPT_STRING | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" }, { "vst", OPT_TYPE_STRING, OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_VIDEO] }, "select desired video stream", "stream_specifier" },
{ "sst", OPT_STRING | OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" }, { "sst", OPT_TYPE_STRING, OPT_EXPERT, { &wanted_stream_spec[AVMEDIA_TYPE_SUBTITLE] }, "select desired subtitle stream", "stream_specifier" },
{ "ss", OPT_TIME, { &start_time }, "seek to a given position in seconds", "pos" }, { "ss", OPT_TYPE_TIME, 0, { &start_time }, "seek to a given position in seconds", "pos" },
{ "t", OPT_TIME, { &duration }, "play \"duration\" seconds of audio/video", "duration" }, { "t", OPT_TYPE_TIME, 0, { &duration }, "play \"duration\" seconds of audio/video", "duration" },
{ "bytes", OPT_INT, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" }, { "bytes", OPT_TYPE_INT, 0, { &seek_by_bytes }, "seek by bytes 0=off 1=on -1=auto", "val" },
{ "seek_interval", OPT_FLOAT, { &seek_interval }, "set seek interval for left/right keys, in seconds", "seconds" }, { "seek_interval", OPT_TYPE_FLOAT, 0, { &seek_interval }, "set seek interval for left/right keys, in seconds", "seconds" },
{ "nodisp", OPT_BOOL, { &display_disable }, "disable graphical display" }, { "nodisp", OPT_TYPE_BOOL, 0, { &display_disable }, "disable graphical display" },
{ "noborder", OPT_BOOL, { &borderless }, "borderless window" }, { "noborder", OPT_TYPE_BOOL, 0, { &borderless }, "borderless window" },
{ "alwaysontop", OPT_BOOL, { &alwaysontop }, "window always on top" }, { "alwaysontop", OPT_TYPE_BOOL, 0, { &alwaysontop }, "window always on top" },
{ "volume", OPT_INT, { &startup_volume}, "set startup volume 0=min 100=max", "volume" }, { "volume", OPT_TYPE_INT, 0, { &startup_volume}, "set startup volume 0=min 100=max", "volume" },
{ "f", HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" }, { "f", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = opt_format }, "force format", "fmt" },
{ "stats", OPT_BOOL | OPT_EXPERT, { &show_status }, "show status", "" }, { "stats", OPT_TYPE_BOOL, OPT_EXPERT, { &show_status }, "show status", "" },
{ "fast", OPT_BOOL | OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" }, { "fast", OPT_TYPE_BOOL, OPT_EXPERT, { &fast }, "non spec compliant optimizations", "" },
{ "genpts", OPT_BOOL | OPT_EXPERT, { &genpts }, "generate pts", "" }, { "genpts", OPT_TYPE_BOOL, OPT_EXPERT, { &genpts }, "generate pts", "" },
{ "drp", OPT_INT | OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""}, { "drp", OPT_TYPE_INT, OPT_EXPERT, { &decoder_reorder_pts }, "let decoder reorder pts 0=off 1=on -1=auto", ""},
{ "lowres", OPT_INT | OPT_EXPERT, { &lowres }, "", "" }, { "lowres", OPT_TYPE_INT, OPT_EXPERT, { &lowres }, "", "" },
{ "sync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" }, { "sync", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT, { .func_arg = opt_sync }, "set audio-video sync. type (type=audio/video/ext)", "type" },
{ "autoexit", OPT_BOOL | OPT_EXPERT, { &autoexit }, "exit at the end", "" }, { "autoexit", OPT_TYPE_BOOL, OPT_EXPERT, { &autoexit }, "exit at the end", "" },
{ "exitonkeydown", OPT_BOOL | OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" }, { "exitonkeydown", OPT_TYPE_BOOL, OPT_EXPERT, { &exit_on_keydown }, "exit on key down", "" },
{ "exitonmousedown", OPT_BOOL | OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" }, { "exitonmousedown", OPT_TYPE_BOOL, OPT_EXPERT, { &exit_on_mousedown }, "exit on mouse down", "" },
{ "loop", OPT_INT | OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" }, { "loop", OPT_TYPE_INT, OPT_EXPERT, { &loop }, "set number of times the playback shall be looped", "loop count" },
{ "framedrop", OPT_BOOL | OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" }, { "framedrop", OPT_TYPE_BOOL, OPT_EXPERT, { &framedrop }, "drop frames when cpu is too slow", "" },
{ "infbuf", OPT_BOOL | OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" }, { "infbuf", OPT_TYPE_BOOL, OPT_EXPERT, { &infinite_buffer }, "don't limit the input buffer size (useful with realtime streams)", "" },
{ "window_title", OPT_STRING, { &window_title }, "set window title", "window title" }, { "window_title", OPT_TYPE_STRING, 0, { &window_title }, "set window title", "window title" },
{ "left", OPT_INT | OPT_EXPERT, { &screen_left }, "set the x position for the left of the window", "x pos" }, { "left", OPT_TYPE_INT, OPT_EXPERT, { &screen_left }, "set the x position for the left of the window", "x pos" },
{ "top", OPT_INT | OPT_EXPERT, { &screen_top }, "set the y position for the top of the window", "y pos" }, { "top", OPT_TYPE_INT, OPT_EXPERT, { &screen_top }, "set the y position for the top of the window", "y pos" },
{ "vf", OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" }, { "vf", OPT_TYPE_FUNC, OPT_EXPERT | HAS_ARG, { .func_arg = opt_add_vfilter }, "set video filters", "filter_graph" },
{ "af", OPT_STRING, { &afilters }, "set audio filters", "filter_graph" }, { "af", OPT_TYPE_STRING, 0, { &afilters }, "set audio filters", "filter_graph" },
{ "rdftspeed", OPT_INT | OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" }, { "rdftspeed", OPT_TYPE_INT, OPT_AUDIO | OPT_EXPERT, { &rdftspeed }, "rdft speed", "msecs" },
{ "showmode", HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" }, { "showmode", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = opt_show_mode}, "select show mode (0 = video, 1 = waves, 2 = RDFT)", "mode" },
{ "i", OPT_BOOL, { &dummy}, "read specified file", "input_file"}, { "i", OPT_TYPE_BOOL, 0, { &dummy}, "read specified file", "input_file"},
{ "codec", HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" }, { "codec", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = opt_codec}, "force decoder", "decoder_name" },
{ "acodec", OPT_STRING | OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" }, { "acodec", OPT_TYPE_STRING, OPT_EXPERT, { &audio_codec_name }, "force audio decoder", "decoder_name" },
{ "scodec", OPT_STRING | OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" }, { "scodec", OPT_TYPE_STRING, OPT_EXPERT, { &subtitle_codec_name }, "force subtitle decoder", "decoder_name" },
{ "vcodec", OPT_STRING | OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" }, { "vcodec", OPT_TYPE_STRING, OPT_EXPERT, { &video_codec_name }, "force video decoder", "decoder_name" },
{ "autorotate", OPT_BOOL, { &autorotate }, "automatically rotate video", "" }, { "autorotate", OPT_TYPE_BOOL, 0, { &autorotate }, "automatically rotate video", "" },
{ "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info }, { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT, { &find_stream_info },
"read and decode the streams to fill missing information with heuristics" }, "read and decode the streams to fill missing information with heuristics" },
{ "filter_threads", OPT_INT | OPT_EXPERT, { &filter_nbthreads }, "number of filter threads per graph" }, { "filter_threads", OPT_TYPE_INT, OPT_EXPERT, { &filter_nbthreads }, "number of filter threads per graph" },
{ "enable_vulkan", OPT_BOOL, { &enable_vulkan }, "enable vulkan renderer" }, { "enable_vulkan", OPT_TYPE_BOOL, 0, { &enable_vulkan }, "enable vulkan renderer" },
{ "vulkan_params", OPT_STRING | OPT_EXPERT, { &vulkan_params }, "vulkan configuration using a list of key=value pairs separated by ':'" }, { "vulkan_params", OPT_TYPE_STRING, OPT_EXPERT, { &vulkan_params }, "vulkan configuration using a list of key=value pairs separated by ':'" },
{ "hwaccel", OPT_STRING | OPT_EXPERT, { &hwaccel }, "use HW accelerated decoding" }, { "hwaccel", OPT_TYPE_STRING, OPT_EXPERT, { &hwaccel }, "use HW accelerated decoding" },
{ NULL, }, { NULL, },
}; };

76
fftools/ffprobe.c
View File

@ -3716,7 +3716,7 @@ static int opt_show_optional_fields(void *optctx, const char *opt, const char *a
if (show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO && av_strcasecmp(arg, "auto")) { if (show_optional_fields == SHOW_OPTIONAL_FIELDS_AUTO && av_strcasecmp(arg, "auto")) {
double num; double num;
int ret = parse_number("show_optional_fields", arg, OPT_INT, int ret = parse_number("show_optional_fields", arg, OPT_TYPE_INT,
SHOW_OPTIONAL_FIELDS_AUTO, SHOW_OPTIONAL_FIELDS_ALWAYS, &num); SHOW_OPTIONAL_FIELDS_AUTO, SHOW_OPTIONAL_FIELDS_ALWAYS, &num);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -4078,50 +4078,50 @@ DEFINE_OPT_SHOW_SECTION(programs, PROGRAMS)
static const OptionDef real_options[] = { static const OptionDef real_options[] = {
CMDUTILS_COMMON_OPTIONS CMDUTILS_COMMON_OPTIONS
{ "f", HAS_ARG, {.func_arg = opt_format}, "force format", "format" }, { "f", OPT_TYPE_FUNC, HAS_ARG, {.func_arg = opt_format}, "force format", "format" },
{ "unit", OPT_BOOL, {&show_value_unit}, "show unit of the displayed values" }, { "unit", OPT_TYPE_BOOL, 0, {&show_value_unit}, "show unit of the displayed values" },
{ "prefix", OPT_BOOL, {&use_value_prefix}, "use SI prefixes for the displayed values" }, { "prefix", OPT_TYPE_BOOL, 0, {&use_value_prefix}, "use SI prefixes for the displayed values" },
{ "byte_binary_prefix", OPT_BOOL, {&use_byte_value_binary_prefix}, { "byte_binary_prefix", OPT_TYPE_BOOL, 0, {&use_byte_value_binary_prefix},
"use binary prefixes for byte units" }, "use binary prefixes for byte units" },
{ "sexagesimal", OPT_BOOL, {&use_value_sexagesimal_format}, { "sexagesimal", OPT_TYPE_BOOL, 0, {&use_value_sexagesimal_format},
"use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" }, "use sexagesimal format HOURS:MM:SS.MICROSECONDS for time units" },
{ "pretty", 0, {.func_arg = opt_pretty}, { "pretty", OPT_TYPE_FUNC, 0, {.func_arg = opt_pretty},
"prettify the format of displayed values, make it more human readable" }, "prettify the format of displayed values, make it more human readable" },
{ "output_format", OPT_STRING, { &output_format }, { "output_format", OPT_TYPE_STRING, 0, { &output_format },
"set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" }, "set the output printing format (available formats are: default, compact, csv, flat, ini, json, xml)", "format" },
{ "print_format", OPT_STRING, { &output_format }, "alias for -output_format (deprecated)" }, { "print_format", OPT_TYPE_STRING, 0, { &output_format }, "alias for -output_format (deprecated)" },
{ "of", OPT_STRING, { &output_format }, "alias for -output_format", "format" }, { "of", OPT_TYPE_STRING, 0, { &output_format }, "alias for -output_format", "format" },
{ "select_streams", OPT_STRING, { &stream_specifier }, "select the specified streams", "stream_specifier" }, { "select_streams", OPT_TYPE_STRING, 0, { &stream_specifier }, "select the specified streams", "stream_specifier" },
{ "sections", OPT_EXIT, {.func_arg = opt_sections}, "print sections structure and section information, and exit" }, { "sections", OPT_TYPE_FUNC, OPT_EXIT, {.func_arg = opt_sections}, "print sections structure and section information, and exit" },
{ "show_data", OPT_BOOL, { &do_show_data }, "show packets data" }, { "show_data", OPT_TYPE_BOOL, 0, { &do_show_data }, "show packets data" },
{ "show_data_hash", OPT_STRING, { &show_data_hash }, "show packets data hash" }, { "show_data_hash", OPT_TYPE_STRING, 0, { &show_data_hash }, "show packets data hash" },
{ "show_error", 0, { .func_arg = &opt_show_error }, "show probing error" }, { "show_error", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_error }, "show probing error" },
{ "show_format", 0, { .func_arg = &opt_show_format }, "show format/container info" }, { "show_format", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_format }, "show format/container info" },
{ "show_frames", 0, { .func_arg = &opt_show_frames }, "show frames info" }, { "show_frames", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_frames }, "show frames info" },
{ "show_entries", HAS_ARG, {.func_arg = opt_show_entries}, { "show_entries", OPT_TYPE_FUNC, HAS_ARG, {.func_arg = opt_show_entries},
"show a set of specified entries", "entry_list" }, "show a set of specified entries", "entry_list" },
#if HAVE_THREADS #if HAVE_THREADS
{ "show_log", OPT_INT, { &do_show_log }, "show log" }, { "show_log", OPT_TYPE_INT, 0, { &do_show_log }, "show log" },
#endif #endif
{ "show_packets", 0, { .func_arg = &opt_show_packets }, "show packets info" }, { "show_packets", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_packets }, "show packets info" },
{ "show_programs", 0, { .func_arg = &opt_show_programs }, "show programs info" }, { "show_programs", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_programs }, "show programs info" },
{ "show_streams", 0, { .func_arg = &opt_show_streams }, "show streams info" }, { "show_streams", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_streams }, "show streams info" },
{ "show_chapters", 0, { .func_arg = &opt_show_chapters }, "show chapters info" }, { "show_chapters", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_chapters }, "show chapters info" },
{ "count_frames", OPT_BOOL, { &do_count_frames }, "count the number of frames per stream" }, { "count_frames", OPT_TYPE_BOOL, 0, { &do_count_frames }, "count the number of frames per stream" },
{ "count_packets", OPT_BOOL, { &do_count_packets }, "count the number of packets per stream" }, { "count_packets", OPT_TYPE_BOOL, 0, { &do_count_packets }, "count the number of packets per stream" },
{ "show_program_version", 0, { .func_arg = &opt_show_program_version }, "show ffprobe version" }, { "show_program_version", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_program_version }, "show ffprobe version" },
{ "show_library_versions", 0, { .func_arg = &opt_show_library_versions }, "show library versions" }, { "show_library_versions", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_library_versions }, "show library versions" },
{ "show_versions", 0, { .func_arg = &opt_show_versions }, "show program and library versions" }, { "show_versions", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_versions }, "show program and library versions" },
{ "show_pixel_formats", 0, { .func_arg = &opt_show_pixel_formats }, "show pixel format descriptions" }, { "show_pixel_formats", OPT_TYPE_FUNC, 0, { .func_arg = &opt_show_pixel_formats }, "show pixel format descriptions" },
{ "show_optional_fields", HAS_ARG, { .func_arg = &opt_show_optional_fields }, "show optional fields" }, { "show_optional_fields", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = &opt_show_optional_fields }, "show optional fields" },
{ "show_private_data", OPT_BOOL, { &show_private_data }, "show private data" }, { "show_private_data", OPT_TYPE_BOOL, 0, { &show_private_data }, "show private data" },
{ "private", OPT_BOOL, { &show_private_data }, "same as show_private_data" }, { "private", OPT_TYPE_BOOL, 0, { &show_private_data }, "same as show_private_data" },
{ "bitexact", OPT_BOOL, {&do_bitexact}, "force bitexact output" }, { "bitexact", OPT_TYPE_BOOL, 0, {&do_bitexact}, "force bitexact output" },
{ "read_intervals", HAS_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" }, { "read_intervals", OPT_TYPE_FUNC, HAS_ARG, {.func_arg = opt_read_intervals}, "set read intervals", "read_intervals" },
{ "i", HAS_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"}, { "i", OPT_TYPE_FUNC, HAS_ARG, {.func_arg = opt_input_file_i}, "read specified file", "input_file"},
{ "o", HAS_ARG, {.func_arg = opt_output_file_o}, "write to specified output", "output_file"}, { "o", OPT_TYPE_FUNC, HAS_ARG, {.func_arg = opt_output_file_o}, "write to specified output", "output_file"},
{ "print_filename", HAS_ARG, {.func_arg = opt_print_filename}, "override the printed input filename", "print_file"}, { "print_filename", OPT_TYPE_FUNC, HAS_ARG, {.func_arg = opt_print_filename}, "override the printed input filename", "print_file"},
{ "find_stream_info", OPT_BOOL | OPT_INPUT | OPT_EXPERT, { &find_stream_info }, { "find_stream_info", OPT_TYPE_BOOL, OPT_INPUT | OPT_EXPERT, { &find_stream_info },
"read and decode the streams to fill missing information with heuristics" }, "read and decode the streams to fill missing information with heuristics" },
{ NULL, }, { NULL, },
}; };

62
fftools/opt_common.h
View File

@ -41,9 +41,9 @@ int show_sources(void *optctx, const char *opt, const char *arg);
#if CONFIG_AVDEVICE #if CONFIG_AVDEVICE
#define CMDUTILS_COMMON_OPTIONS_AVDEVICE \ #define CMDUTILS_COMMON_OPTIONS_AVDEVICE \
{ "sources" , OPT_EXIT | HAS_ARG, { .func_arg = show_sources }, \ { "sources" , OPT_TYPE_FUNC, OPT_EXIT | HAS_ARG, { .func_arg = show_sources }, \
"list sources of the input device", "device" }, \ "list sources of the input device", "device" }, \
{ "sinks" , OPT_EXIT | HAS_ARG, { .func_arg = show_sinks }, \ { "sinks" , OPT_TYPE_FUNC, OPT_EXIT | HAS_ARG, { .func_arg = show_sinks }, \
"list sinks of the output device", "device" }, \ "list sinks of the output device", "device" }, \
#else #else
@ -197,35 +197,35 @@ int opt_cpuflags(void *optctx, const char *opt, const char *arg);
int opt_cpucount(void *optctx, const char *opt, const char *arg); int opt_cpucount(void *optctx, const char *opt, const char *arg);
#define CMDUTILS_COMMON_OPTIONS \ #define CMDUTILS_COMMON_OPTIONS \
{ "L", OPT_EXIT, { .func_arg = show_license }, "show license" }, \ { "L", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_license }, "show license" }, \
{ "h", OPT_EXIT, { .func_arg = show_help }, "show help", "topic" }, \ { "h", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_help }, "show help", "topic" }, \
{ "?", OPT_EXIT, { .func_arg = show_help }, "show help", "topic" }, \ { "?", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_help }, "show help", "topic" }, \
{ "help", OPT_EXIT, { .func_arg = show_help }, "show help", "topic" }, \ { "help", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_help }, "show help", "topic" }, \
{ "-help", OPT_EXIT, { .func_arg = show_help }, "show help", "topic" }, \ { "-help", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_help }, "show help", "topic" }, \
{ "version", OPT_EXIT, { .func_arg = show_version }, "show version" }, \ { "version", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_version }, "show version" }, \
{ "buildconf", OPT_EXIT, { .func_arg = show_buildconf }, "show build configuration" }, \ { "buildconf", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_buildconf }, "show build configuration" }, \
{ "formats", OPT_EXIT, { .func_arg = show_formats }, "show available formats" }, \ { "formats", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_formats }, "show available formats" }, \
{ "muxers", OPT_EXIT, { .func_arg = show_muxers }, "show available muxers" }, \ { "muxers", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_muxers }, "show available muxers" }, \
{ "demuxers", OPT_EXIT, { .func_arg = show_demuxers }, "show available demuxers" }, \ { "demuxers", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_demuxers }, "show available demuxers" }, \
{ "devices", OPT_EXIT, { .func_arg = show_devices }, "show available devices" }, \ { "devices", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_devices }, "show available devices" }, \
{ "codecs", OPT_EXIT, { .func_arg = show_codecs }, "show available codecs" }, \ { "codecs", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_codecs }, "show available codecs" }, \
{ "decoders", OPT_EXIT, { .func_arg = show_decoders }, "show available decoders" }, \ { "decoders", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_decoders }, "show available decoders" }, \
{ "encoders", OPT_EXIT, { .func_arg = show_encoders }, "show available encoders" }, \ { "encoders", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_encoders }, "show available encoders" }, \
{ "bsfs", OPT_EXIT, { .func_arg = show_bsfs }, "show available bit stream filters" }, \ { "bsfs", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_bsfs }, "show available bit stream filters" }, \
{ "protocols", OPT_EXIT, { .func_arg = show_protocols }, "show available protocols" }, \ { "protocols", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_protocols }, "show available protocols" }, \
{ "filters", OPT_EXIT, { .func_arg = show_filters }, "show available filters" }, \ { "filters", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_filters }, "show available filters" }, \
{ "pix_fmts", OPT_EXIT, { .func_arg = show_pix_fmts }, "show available pixel formats" }, \ { "pix_fmts", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_pix_fmts }, "show available pixel formats" }, \
{ "layouts", OPT_EXIT, { .func_arg = show_layouts }, "show standard channel layouts" }, \ { "layouts", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_layouts }, "show standard channel layouts" }, \
{ "sample_fmts", OPT_EXIT, { .func_arg = show_sample_fmts }, "show available audio sample formats" }, \ { "sample_fmts", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_sample_fmts }, "show available audio sample formats" }, \
{ "dispositions", OPT_EXIT, { .func_arg = show_dispositions}, "show available stream dispositions" }, \ { "dispositions", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_dispositions}, "show available stream dispositions" }, \
{ "colors", OPT_EXIT, { .func_arg = show_colors }, "show available color names" }, \ { "colors", OPT_TYPE_FUNC, OPT_EXIT, { .func_arg = show_colors }, "show available color names" }, \
{ "loglevel", HAS_ARG, { .func_arg = opt_loglevel }, "set logging level", "loglevel" }, \ { "loglevel", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = opt_loglevel }, "set logging level", "loglevel" }, \
{ "v", HAS_ARG, { .func_arg = opt_loglevel }, "set logging level", "loglevel" }, \ { "v", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = opt_loglevel }, "set logging level", "loglevel" }, \
{ "report", 0, { .func_arg = opt_report }, "generate a report" }, \ { "report", OPT_TYPE_FUNC, 0, { .func_arg = opt_report }, "generate a report" }, \
{ "max_alloc", HAS_ARG, { .func_arg = opt_max_alloc }, "set maximum size of a single allocated block", "bytes" }, \ { "max_alloc", OPT_TYPE_FUNC, HAS_ARG, { .func_arg = opt_max_alloc }, "set maximum size of a single allocated block", "bytes" }, \
{ "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags }, "force specific cpu flags", "flags" }, \ { "cpuflags", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags }, "force specific cpu flags", "flags" }, \
{ "cpucount", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpucount }, "force specific cpu count", "count" }, \ { "cpucount", OPT_TYPE_FUNC, HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpucount }, "force specific cpu count", "count" }, \
{ "hide_banner", OPT_BOOL | OPT_EXPERT, {&hide_banner}, "do not show program banner", "hide_banner" }, \ { "hide_banner", OPT_TYPE_BOOL, OPT_EXPERT, {&hide_banner}, "do not show program banner", "hide_banner" }, \
CMDUTILS_COMMON_OPTIONS_AVDEVICE \ CMDUTILS_COMMON_OPTIONS_AVDEVICE \
#endif /* FFTOOLS_OPT_COMMON_H */ #endif /* FFTOOLS_OPT_COMMON_H */