From: Clément Bœsch <[email protected]>
---
libavformat/adtsenc.c | 4 ++--
libavformat/aiffenc.c | 2 +-
libavformat/apngdec.c | 2 +-
libavformat/asfdec_f.c | 4 ++--
libavformat/assenc.c | 2 +-
libavformat/avidec.c | 2 +-
libavformat/concatdec.c | 4 ++--
libavformat/dashenc.c | 8 ++++----
libavformat/file.c | 2 +-
libavformat/flacenc.c | 2 +-
libavformat/flvdec.c | 2 +-
libavformat/ftp.c | 2 +-
libavformat/gifdec.c | 2 +-
libavformat/hdsenc.c | 2 +-
libavformat/hlsenc.c | 2 +-
libavformat/http.c | 16 ++++++++--------
libavformat/icecast.c | 4 ++--
libavformat/img2dec.c | 2 +-
libavformat/img2enc.c | 6 +++---
libavformat/matroskadec.c | 2 +-
libavformat/matroskaenc.c | 6 +++---
libavformat/mov.c | 6 +++---
libavformat/movenc.c | 4 ++--
libavformat/mp3enc.c | 4 ++--
libavformat/mpegts.c | 10 +++++-----
libavformat/mpegtsenc.c | 6 +++---
libavformat/nutenc.c | 2 +-
libavformat/options_table.h | 6 +++---
libavformat/rtmphttp.c | 2 +-
libavformat/rtpproto.c | 4 ++--
libavformat/rtsp.c | 2 +-
libavformat/sctp.c | 2 +-
libavformat/segment.c | 12 ++++++------
libavformat/smoothstreamingenc.c | 2 +-
libavformat/udp.c | 10 +++++-----
libavformat/unix.c | 2 +-
libavformat/webmdashenc.c | 4 ++--
37 files changed, 78 insertions(+), 78 deletions(-)
diff --git a/libavformat/adtsenc.c b/libavformat/adtsenc.c
index 7448ec7..242d738 100644
--- a/libavformat/adtsenc.c
+++ b/libavformat/adtsenc.c
@@ -183,8 +183,8 @@ static int adts_write_trailer(AVFormatContext *s)
#define ENC AV_OPT_FLAG_ENCODING_PARAM
#define OFFSET(obj) offsetof(ADTSContext, obj)
static const AVOption options[] = {
- { "write_id3v2", "Enable ID3v2 tag writing", OFFSET(id3v2tag),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, ENC},
- { "write_apetag", "Enable APE tag writing", OFFSET(apetag),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, ENC},
+ { "write_id3v2", "Enable ID3v2 tag writing", OFFSET(id3v2tag),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, ENC},
+ { "write_apetag", "Enable APE tag writing", OFFSET(apetag),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, ENC},
{ NULL },
};
diff --git a/libavformat/aiffenc.c b/libavformat/aiffenc.c
index 09d91a7..25dc5e6 100644
--- a/libavformat/aiffenc.c
+++ b/libavformat/aiffenc.c
@@ -305,7 +305,7 @@ static int aiff_write_trailer(AVFormatContext *s)
#define ENC AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
{ "write_id3v2", "Enable ID3 tags writing.",
- OFFSET(write_id3v2), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, ENC },
+ OFFSET(write_id3v2), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, ENC },
{ "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are
supported.",
OFFSET(id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 3, 4, ENC },
{ NULL },
diff --git a/libavformat/apngdec.c b/libavformat/apngdec.c
index 84298ae..c6403a1 100644
--- a/libavformat/apngdec.c
+++ b/libavformat/apngdec.c
@@ -419,7 +419,7 @@ static int apng_read_packet(AVFormatContext *s, AVPacket
*pkt)
static const AVOption options[] = {
{ "ignore_loop", "ignore loop setting" ,
offsetof(APNGDemuxContext, ignore_loop),
- AV_OPT_TYPE_INT, { .i64 = 1 } , 0, 1 ,
AV_OPT_FLAG_DECODING_PARAM },
+ AV_OPT_TYPE_BOOL, { .i64 = 1 } , 0, 1 ,
AV_OPT_FLAG_DECODING_PARAM },
{ "max_fps" , "maximum framerate (0 is no limit)" ,
offsetof(APNGDemuxContext, max_fps),
AV_OPT_TYPE_INT, { .i64 = DEFAULT_APNG_FPS }, 0, INT_MAX,
AV_OPT_FLAG_DECODING_PARAM },
{ "default_fps", "default framerate (0 is as fast as possible)",
offsetof(APNGDemuxContext, default_fps),
diff --git a/libavformat/asfdec_f.c b/libavformat/asfdec_f.c
index 8b89a1a..3ee0fcd 100644
--- a/libavformat/asfdec_f.c
+++ b/libavformat/asfdec_f.c
@@ -118,8 +118,8 @@ typedef struct ASFContext {
} ASFContext;
static const AVOption options[] = {
- { "no_resync_search", "Don't try to resynchronize by looking for a certain
optional start code", offsetof(ASFContext, no_resync_search), AV_OPT_TYPE_INT,
{ .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
- { "export_xmp", "Export full XMP metadata", offsetof(ASFContext,
export_xmp), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
+ { "no_resync_search", "Don't try to resynchronize by looking for a certain
optional start code", offsetof(ASFContext, no_resync_search), AV_OPT_TYPE_BOOL,
{ .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
+ { "export_xmp", "Export full XMP metadata", offsetof(ASFContext,
export_xmp), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
{ NULL },
};
diff --git a/libavformat/assenc.c b/libavformat/assenc.c
index 5222616..e59c266 100644
--- a/libavformat/assenc.c
+++ b/libavformat/assenc.c
@@ -223,7 +223,7 @@ static int write_trailer(AVFormatContext *s)
#define OFFSET(x) offsetof(ASSContext, x)
#define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
- { "ignore_readorder", "write events immediately, even if they're
out-of-order", OFFSET(ignore_readorder), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
+ { "ignore_readorder", "write events immediately, even if they're
out-of-order", OFFSET(ignore_readorder), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E
},
{ NULL },
};
diff --git a/libavformat/avidec.c b/libavformat/avidec.c
index b7bd54d..be54b14 100644
--- a/libavformat/avidec.c
+++ b/libavformat/avidec.c
@@ -87,7 +87,7 @@ typedef struct AVIContext {
static const AVOption options[] = {
- { "use_odml", "use odml index", offsetof(AVIContext, use_odml),
AV_OPT_TYPE_INT, {.i64 = 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
+ { "use_odml", "use odml index", offsetof(AVIContext, use_odml),
AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
{ NULL },
};
diff --git a/libavformat/concatdec.c b/libavformat/concatdec.c
index 0180a7e..f1500e4 100644
--- a/libavformat/concatdec.c
+++ b/libavformat/concatdec.c
@@ -701,9 +701,9 @@ static int concat_seek(AVFormatContext *avf, int stream,
static const AVOption options[] = {
{ "safe", "enable safe mode",
- OFFSET(safe), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, DEC },
+ OFFSET(safe), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, DEC },
{ "auto_convert", "automatically convert bitstream format",
- OFFSET(auto_convert), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, DEC },
+ OFFSET(auto_convert), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DEC },
{ NULL }
};
diff --git a/libavformat/dashenc.c b/libavformat/dashenc.c
index 9c2b4dd..4509ee4 100644
--- a/libavformat/dashenc.c
+++ b/libavformat/dashenc.c
@@ -1004,10 +1004,10 @@ static const AVOption options[] = {
{ "window_size", "number of segments kept in the manifest",
OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },
{ "extra_window_size", "number of segments kept outside of the manifest
before removing from disk", OFFSET(extra_window_size), AV_OPT_TYPE_INT, { .i64
= 5 }, 0, INT_MAX, E },
{ "min_seg_duration", "minimum segment duration (in microseconds)",
OFFSET(min_seg_duration), AV_OPT_TYPE_INT64, { .i64 = 5000000 }, 0, INT_MAX, E
},
- { "remove_at_exit", "remove all segments when finished",
OFFSET(remove_at_exit), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
- { "use_template", "Use SegmentTemplate instead of SegmentList",
OFFSET(use_template), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, E },
- { "use_timeline", "Use SegmentTimeline in SegmentTemplate",
OFFSET(use_timeline), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, E },
- { "single_file", "Store all segments in one file, accessed using byte
ranges", OFFSET(single_file), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
+ { "remove_at_exit", "remove all segments when finished",
OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
+ { "use_template", "Use SegmentTemplate instead of SegmentList",
OFFSET(use_template), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
+ { "use_timeline", "Use SegmentTimeline in SegmentTemplate",
OFFSET(use_timeline), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
+ { "single_file", "Store all segments in one file, accessed using byte
ranges", OFFSET(single_file), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
{ "single_file_name", "DASH-templated name to be used for baseURL. Implies
storing all segments in one file, accessed using byte ranges",
OFFSET(single_file_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
{ "init_seg_name", "DASH-templated name to used for the initialization
segment", OFFSET(init_seg_name), AV_OPT_TYPE_STRING, {.str =
"init-stream$RepresentationID$.m4s"}, 0, 0, E },
{ "media_seg_name", "DASH-templated name to used for the media segments",
OFFSET(media_seg_name), AV_OPT_TYPE_STRING, {.str =
"chunk-stream$RepresentationID$-$Number%05d$.m4s"}, 0, 0, E },
diff --git a/libavformat/file.c b/libavformat/file.c
index d59aa42..a318408 100644
--- a/libavformat/file.c
+++ b/libavformat/file.c
@@ -78,7 +78,7 @@ typedef struct FileContext {
} FileContext;
static const AVOption file_options[] = {
- { "truncate", "truncate existing files on write", offsetof(FileContext,
trunc), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
+ { "truncate", "truncate existing files on write", offsetof(FileContext,
trunc), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
{ "blocksize", "set I/O operation maximum block size",
offsetof(FileContext, blocksize), AV_OPT_TYPE_INT, { .i64 = INT_MAX }, 1,
INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
{ NULL }
};
diff --git a/libavformat/flacenc.c b/libavformat/flacenc.c
index a45f83e..321af50 100644
--- a/libavformat/flacenc.c
+++ b/libavformat/flacenc.c
@@ -187,7 +187,7 @@ static int flac_write_packet(struct AVFormatContext *s,
AVPacket *pkt)
}
static const AVOption flacenc_options[] = {
- { "write_header", "Write the file header", offsetof(FlacMuxerContext,
write_header), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
+ { "write_header", "Write the file header", offsetof(FlacMuxerContext,
write_header), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
{ NULL },
};
diff --git a/libavformat/flvdec.c b/libavformat/flvdec.c
index ca73969..113d61e 100644
--- a/libavformat/flvdec.c
+++ b/libavformat/flvdec.c
@@ -1162,7 +1162,7 @@ static int flv_read_seek(AVFormatContext *s, int
stream_index,
#define OFFSET(x) offsetof(FLVContext, x)
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = {
- { "flv_metadata", "Allocate streams according to the onMetaData array",
OFFSET(trust_metadata), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
+ { "flv_metadata", "Allocate streams according to the onMetaData array",
OFFSET(trust_metadata), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VD },
{ NULL }
};
diff --git a/libavformat/ftp.c b/libavformat/ftp.c
index dcb588d..4526dd7 100644
--- a/libavformat/ftp.c
+++ b/libavformat/ftp.c
@@ -76,7 +76,7 @@ typedef struct {
#define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
{"timeout", "set timeout of socket I/O operations", OFFSET(rw_timeout),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, D|E },
- {"ftp-write-seekable", "control seekability of connection during
encoding", OFFSET(write_seekable), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
+ {"ftp-write-seekable", "control seekability of connection during
encoding", OFFSET(write_seekable), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
{"ftp-anonymous-password", "password for anonymous login. E-mail address
should be used.", OFFSET(anonymous_password), AV_OPT_TYPE_STRING, { 0 }, 0, 0,
D|E },
{NULL}
};
diff --git a/libavformat/gifdec.c b/libavformat/gifdec.c
index 1ac47fe..48bd603 100644
--- a/libavformat/gifdec.c
+++ b/libavformat/gifdec.c
@@ -322,7 +322,7 @@ static const AVOption options[] = {
{ "min_delay" , "minimum valid delay between frames (in hundredths of
second)", offsetof(GIFDemuxContext, min_delay) , AV_OPT_TYPE_INT, {.i64 =
GIF_MIN_DELAY} , 0, 100 * 60, AV_OPT_FLAG_DECODING_PARAM },
{ "max_gif_delay", "maximum valid delay between frames (in hundredths of
seconds)", offsetof(GIFDemuxContext, max_delay) , AV_OPT_TYPE_INT, {.i64 =
65535} , 0, 65535 , AV_OPT_FLAG_DECODING_PARAM },
{ "default_delay", "default delay between frames (in hundredths of
second)" , offsetof(GIFDemuxContext, default_delay), AV_OPT_TYPE_INT,
{.i64 = GIF_DEFAULT_DELAY}, 0, 100 * 60, AV_OPT_FLAG_DECODING_PARAM },
- { "ignore_loop" , "ignore loop setting (netscape extension)"
, offsetof(GIFDemuxContext, ignore_loop) , AV_OPT_TYPE_INT, {.i64 = 1}
, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
+ { "ignore_loop" , "ignore loop setting (netscape extension)"
, offsetof(GIFDemuxContext, ignore_loop) , AV_OPT_TYPE_BOOL,{.i64 = 1}
, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
{ NULL },
};
diff --git a/libavformat/hdsenc.c b/libavformat/hdsenc.c
index 575cc20..7670185 100644
--- a/libavformat/hdsenc.c
+++ b/libavformat/hdsenc.c
@@ -569,7 +569,7 @@ static const AVOption options[] = {
{ "window_size", "number of fragments kept in the manifest",
OFFSET(window_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, E },
{ "extra_window_size", "number of fragments kept outside of the manifest
before removing from disk", OFFSET(extra_window_size), AV_OPT_TYPE_INT, { .i64
= 5 }, 0, INT_MAX, E },
{ "min_frag_duration", "minimum fragment duration (in microseconds)",
OFFSET(min_frag_duration), AV_OPT_TYPE_INT64, { .i64 = 10000000 }, 0, INT_MAX,
E },
- { "remove_at_exit", "remove all fragments when finished",
OFFSET(remove_at_exit), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
+ { "remove_at_exit", "remove all fragments when finished",
OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
{ NULL },
};
diff --git a/libavformat/hlsenc.c b/libavformat/hlsenc.c
index d7884e5..3181cc7 100644
--- a/libavformat/hlsenc.c
+++ b/libavformat/hlsenc.c
@@ -871,7 +871,7 @@ static const AVOption options[] = {
{"round_durations", "round durations in m3u8 to whole numbers", 0,
AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX, E, "flags"},
{"discont_start", "start the playlist with a discontinuity tag", 0,
AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX, E, "flags"},
{"omit_endlist", "Do not append an endlist when ending stream", 0,
AV_OPT_TYPE_CONST, {.i64 = HLS_OMIT_ENDLIST }, 0, UINT_MAX, E, "flags"},
- { "use_localtime", "set filename expansion with strftime at
segment creation", OFFSET(use_localtime), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, E
},
+ { "use_localtime", "set filename expansion with strftime at segment
creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
{"method", "set the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING,
{.str = NULL}, 0, 0, E},
{ NULL },
diff --git a/libavformat/http.c b/libavformat/http.c
index 4b4a225..e755fd1 100644
--- a/libavformat/http.c
+++ b/libavformat/http.c
@@ -124,31 +124,31 @@ typedef struct HTTPContext {
#define DEFAULT_USER_AGENT "Lavf/" AV_STRINGIFY(LIBAVFORMAT_VERSION)
static const AVOption options[] = {
- { "seekable", "control seekability of connection", OFFSET(seekable),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, D },
- { "chunked_post", "use chunked transfer-encoding for posts",
OFFSET(chunked_post), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, E },
+ { "seekable", "control seekability of connection", OFFSET(seekable),
AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, D },
+ { "chunked_post", "use chunked transfer-encoding for posts",
OFFSET(chunked_post), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, E },
{ "headers", "set custom HTTP headers, can override built in default
headers", OFFSET(headers), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, D | E },
{ "content_type", "set a specific content type for the POST messages",
OFFSET(content_type), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, D | E },
{ "user_agent", "override User-Agent header", OFFSET(user_agent),
AV_OPT_TYPE_STRING, { .str = DEFAULT_USER_AGENT }, 0, 0, D },
{ "user-agent", "override User-Agent header", OFFSET(user_agent),
AV_OPT_TYPE_STRING, { .str = DEFAULT_USER_AGENT }, 0, 0, D },
- { "multiple_requests", "use persistent connections",
OFFSET(multiple_requests), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, D | E },
+ { "multiple_requests", "use persistent connections",
OFFSET(multiple_requests), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, D | E },
{ "post_data", "set custom HTTP post data", OFFSET(post_data),
AV_OPT_TYPE_BINARY, .flags = D | E },
{ "mime_type", "export the MIME type", OFFSET(mime_type),
AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_EXPORT |
AV_OPT_FLAG_READONLY },
{ "cookies", "set cookies to be sent in applicable future requests, use
newline delimited Set-Cookie HTTP field value syntax", OFFSET(cookies),
AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, D },
- { "icy", "request ICY metadata", OFFSET(icy), AV_OPT_TYPE_INT, { .i64 = 1
}, 0, 1, D },
+ { "icy", "request ICY metadata", OFFSET(icy), AV_OPT_TYPE_BOOL, { .i64 = 1
}, 0, 1, D },
{ "icy_metadata_headers", "return ICY metadata headers",
OFFSET(icy_metadata_headers), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0,
AV_OPT_FLAG_EXPORT },
{ "icy_metadata_packet", "return current ICY metadata packet",
OFFSET(icy_metadata_packet), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0,
AV_OPT_FLAG_EXPORT },
{ "metadata", "metadata read from the bitstream", OFFSET(metadata),
AV_OPT_TYPE_DICT, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
{ "auth_type", "HTTP authentication type", OFFSET(auth_state.auth_type),
AV_OPT_TYPE_INT, { .i64 = HTTP_AUTH_NONE }, HTTP_AUTH_NONE, HTTP_AUTH_BASIC, D
| E, "auth_type"},
{ "none", "No auth method set, autodetect", 0, AV_OPT_TYPE_CONST, { .i64 =
HTTP_AUTH_NONE }, 0, 0, D | E, "auth_type"},
{ "basic", "HTTP basic authentication", 0, AV_OPT_TYPE_CONST, { .i64 =
HTTP_AUTH_BASIC }, 0, 0, D | E, "auth_type"},
- { "send_expect_100", "Force sending an Expect: 100-continue header for
POST", OFFSET(send_expect_100), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
+ { "send_expect_100", "Force sending an Expect: 100-continue header for
POST", OFFSET(send_expect_100), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
{ "location", "The actual location of the data received",
OFFSET(location), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, D | E },
{ "offset", "initial byte offset", OFFSET(off), AV_OPT_TYPE_INT64, { .i64
= 0 }, 0, INT64_MAX, D },
{ "end_offset", "try to limit the request to bytes preceding this offset",
OFFSET(end_off), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, D },
{ "method", "Override the HTTP method or set the expected HTTP method from
a client", OFFSET(method), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, D | E },
- { "reconnect", "auto reconnect after disconnect before EOF",
OFFSET(reconnect), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, D },
- { "reconnect_at_eof", "auto reconnect at EOF", OFFSET(reconnect_at_eof),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, D },
- { "reconnect_streamed", "auto reconnect streamed / non seekable streams",
OFFSET(reconnect_streamed), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, D },
+ { "reconnect", "auto reconnect after disconnect before EOF",
OFFSET(reconnect), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, D },
+ { "reconnect_at_eof", "auto reconnect at EOF", OFFSET(reconnect_at_eof),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, D },
+ { "reconnect_streamed", "auto reconnect streamed / non seekable streams",
OFFSET(reconnect_streamed), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, D },
{ "reconnect_delay_max", "max reconnect delay in seconds after which to
give up", OFFSET(reconnect_delay_max), AV_OPT_TYPE_INT, { .i64 = 120 }, 0,
UINT_MAX/1000/1000, D },
{ "listen", "listen on HTTP", OFFSET(listen), AV_OPT_TYPE_INT, { .i64 = 0
}, 0, 2, D | E },
{ "resource", "The resource requested by a client", OFFSET(resource),
AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
diff --git a/libavformat/icecast.c b/libavformat/icecast.c
index ace2044..f4dca6f 100644
--- a/libavformat/icecast.c
+++ b/libavformat/icecast.c
@@ -57,11 +57,11 @@ static const AVOption options[] = {
{ "ice_name", "set stream description", OFFSET(name), AV_OPT_TYPE_STRING,
{ .str = NULL }, 0, 0, E },
{ "ice_description", "set stream description", OFFSET(description),
AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
{ "ice_url", "set stream website", OFFSET(url), AV_OPT_TYPE_STRING, { .str
= NULL }, 0, 0, E },
- { "ice_public", "set if stream is public", OFFSET(public),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
+ { "ice_public", "set if stream is public", OFFSET(public),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
{ "user_agent", "override User-Agent header", OFFSET(user_agent),
AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
{ "password", "set password", OFFSET(pass), AV_OPT_TYPE_STRING, { .str =
NULL }, 0, 0, E },
{ "content_type", "set content-type, MUST be set if not audio/mpeg",
OFFSET(content_type), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
- { "legacy_icecast", "use legacy SOURCE method, for Icecast < v2.4",
OFFSET(legacy_icecast), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
+ { "legacy_icecast", "use legacy SOURCE method, for Icecast < v2.4",
OFFSET(legacy_icecast), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
{ NULL }
};
diff --git a/libavformat/img2dec.c b/libavformat/img2dec.c
index 91caf0e..603398e 100644
--- a/libavformat/img2dec.c
+++ b/libavformat/img2dec.c
@@ -549,7 +549,7 @@ static int img_read_seek(AVFormatContext *s, int
stream_index, int64_t timestamp
#define DEC AV_OPT_FLAG_DECODING_PARAM
const AVOption ff_img_options[] = {
{ "framerate", "set the video framerate",
OFFSET(framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "25"}, 0, 0, DEC },
- { "loop", "force loop over input file sequence", OFFSET(loop),
AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, DEC },
+ { "loop", "force loop over input file sequence", OFFSET(loop),
AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, DEC },
{ "pattern_type", "set pattern type",
OFFSET(pattern_type), AV_OPT_TYPE_INT, {.i64=PT_GLOB_SEQUENCE}, 0,
INT_MAX, DEC, "pattern_type"},
{ "glob_sequence","select glob/sequence pattern type", 0,
AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC,
"pattern_type" },
diff --git a/libavformat/img2enc.c b/libavformat/img2enc.c
index cd4a9a8..c2e6e4d 100644
--- a/libavformat/img2enc.c
+++ b/libavformat/img2enc.c
@@ -202,10 +202,10 @@ static int query_codec(enum AVCodecID id, int
std_compliance)
#define OFFSET(x) offsetof(VideoMuxData, x)
#define ENC AV_OPT_FLAG_ENCODING_PARAM
static const AVOption muxoptions[] = {
- { "updatefirst", "continuously overwrite one file", OFFSET(update),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, ENC },
- { "update", "continuously overwrite one file", OFFSET(update),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, ENC },
+ { "updatefirst", "continuously overwrite one file", OFFSET(update),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
+ { "update", "continuously overwrite one file", OFFSET(update),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
{ "start_number", "set first number in the sequence", OFFSET(img_number),
AV_OPT_TYPE_INT, { .i64 = 1 }, 0, INT_MAX, ENC },
- { "strftime", "use strftime for filename", OFFSET(use_strftime),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, ENC },
+ { "strftime", "use strftime for filename", OFFSET(use_strftime),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ENC },
{ NULL },
};
diff --git a/libavformat/matroskadec.c b/libavformat/matroskadec.c
index 424d7bf..74f3e04 100644
--- a/libavformat/matroskadec.c
+++ b/libavformat/matroskadec.c
@@ -3484,7 +3484,7 @@ static int webm_dash_manifest_read_packet(AVFormatContext
*s, AVPacket *pkt)
#define OFFSET(x) offsetof(MatroskaDemuxContext, x)
static const AVOption options[] = {
- { "live", "flag indicating that the input is a live file that only has the
headers.", OFFSET(is_live), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1,
AV_OPT_FLAG_DECODING_PARAM },
+ { "live", "flag indicating that the input is a live file that only has the
headers.", OFFSET(is_live), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
AV_OPT_FLAG_DECODING_PARAM },
{ NULL },
};
diff --git a/libavformat/matroskaenc.c b/libavformat/matroskaenc.c
index 10cf0a0..26b9b96 100644
--- a/libavformat/matroskaenc.c
+++ b/libavformat/matroskaenc.c
@@ -2135,10 +2135,10 @@ static const AVOption options[] = {
{ "reserve_index_space", "Reserve a given amount of space (in bytes) at
the beginning of the file for the index (cues).", OFFSET(reserve_cues_space),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, FLAGS },
{ "cluster_size_limit", "Store at most the provided amount of bytes in a
cluster. ", OFFSET(cluster_size_limit),
AV_OPT_TYPE_INT , { .i64 = -1 }, -1, INT_MAX, FLAGS },
{ "cluster_time_limit", "Store at most the provided number of
milliseconds in a cluster.",
OFFSET(cluster_time_limit), AV_OPT_TYPE_INT64, { .i64 = -1 }, -1, INT64_MAX,
FLAGS },
- { "dash", "Create a WebM file conforming to WebM DASH specification",
OFFSET(is_dash), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
+ { "dash", "Create a WebM file conforming to WebM DASH specification",
OFFSET(is_dash), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
{ "dash_track_number", "Track number for the DASH stream",
OFFSET(dash_track_number), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 127, FLAGS },
- { "live", "Write files assuming it is a live stream.", OFFSET(is_live),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
- { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS },
+ { "live", "Write files assuming it is a live stream.", OFFSET(is_live),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
+ { "allow_raw_vfw", "allow RAW VFW mode", OFFSET(allow_raw_vfw),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
{ NULL },
};
diff --git a/libavformat/mov.c b/libavformat/mov.c
index 8493de9..fad2c8b 100644
--- a/libavformat/mov.c
+++ b/libavformat/mov.c
@@ -5045,13 +5045,13 @@ static int mov_read_seek(AVFormatContext *s, int
stream_index, int64_t sample_ti
static const AVOption mov_options[] = {
{"use_absolute_path",
"allow using absolute path when opening alias, this is a possible
security issue",
- OFFSET(use_absolute_path), AV_OPT_TYPE_INT, {.i64 = 0},
+ OFFSET(use_absolute_path), AV_OPT_TYPE_BOOL, {.i64 = 0},
0, 1, FLAGS},
{"seek_streams_individually",
"Seek each stream individually to the to the closest point",
- OFFSET(seek_individually), AV_OPT_TYPE_INT, { .i64 = 1 },
+ OFFSET(seek_individually), AV_OPT_TYPE_BOOL, { .i64 = 1 },
0, 1, FLAGS},
- {"ignore_editlist", "", OFFSET(ignore_editlist), AV_OPT_TYPE_INT, {.i64 =
0},
+ {"ignore_editlist", "", OFFSET(ignore_editlist), AV_OPT_TYPE_BOOL, {.i64 =
0},
0, 1, FLAGS},
{"ignore_chapters", "", OFFSET(ignore_chapters), AV_OPT_TYPE_BOOL, {.i64 =
0},
0, 1, FLAGS},
diff --git a/libavformat/movenc.c b/libavformat/movenc.c
index 372c41f..72f948a 100644
--- a/libavformat/movenc.c
+++ b/libavformat/movenc.c
@@ -70,7 +70,7 @@ static const AVOption options[] = {
{ "write_colr", "Write colr atom (Experimental, may be renamed or changed,
do not use from scripts)", 0, AV_OPT_TYPE_CONST, {.i64 =
FF_MOV_FLAG_WRITE_COLR}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM,
"movflags" },
{ "write_gama", "Write deprecated gama atom", 0, AV_OPT_TYPE_CONST, {.i64
= FF_MOV_FLAG_WRITE_GAMA}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM,
"movflags" },
FF_RTP_FLAG_OPTS(MOVMuxContext, rtp_flags),
- { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext,
iods_skip), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
+ { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext,
iods_skip), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
{ "iods_audio_profile", "iods audio profile atom.",
offsetof(MOVMuxContext, iods_audio_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1,
255, AV_OPT_FLAG_ENCODING_PARAM},
{ "iods_video_profile", "iods video profile atom.",
offsetof(MOVMuxContext, iods_video_profile), AV_OPT_TYPE_INT, {.i64 = -1}, -1,
255, AV_OPT_FLAG_ENCODING_PARAM},
{ "frag_duration", "Maximum fragment duration", offsetof(MOVMuxContext,
max_fragment_duration), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM},
@@ -79,7 +79,7 @@ static const AVOption options[] = {
{ "ism_lookahead", "Number of lookahead entries for ISM files",
offsetof(MOVMuxContext, ism_lookahead), AV_OPT_TYPE_INT, {.i64 = 0}, 0,
INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
{ "video_track_timescale", "set timescale of all video tracks",
offsetof(MOVMuxContext, video_track_timescale), AV_OPT_TYPE_INT, {.i64 = 0}, 0,
INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
{ "brand", "Override major brand", offsetof(MOVMuxContext,
major_brand), AV_OPT_TYPE_STRING, {.str = NULL}, .flags =
AV_OPT_FLAG_ENCODING_PARAM },
- { "use_editlist", "use edit list", offsetof(MOVMuxContext, use_editlist),
AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_ENCODING_PARAM},
+ { "use_editlist", "use edit list", offsetof(MOVMuxContext, use_editlist),
AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AV_OPT_FLAG_ENCODING_PARAM},
{ "fragment_index", "Fragment number of the next fragment",
offsetof(MOVMuxContext, fragments), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM},
{ "mov_gamma", "gamma value for gama atom", offsetof(MOVMuxContext,
gamma), AV_OPT_TYPE_FLOAT, {.dbl = 0.0 }, 0.0, 10, AV_OPT_FLAG_ENCODING_PARAM},
{ "frag_interleave", "Interleave samples within fragments (max number of
consecutive samples, lower is tighter interleaving, but with more overhead)",
offsetof(MOVMuxContext, frag_interleave), AV_OPT_TYPE_INT, {.i64 = 0}, 0,
INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
diff --git a/libavformat/mp3enc.c b/libavformat/mp3enc.c
index 9d2fbb1..40f0672 100644
--- a/libavformat/mp3enc.c
+++ b/libavformat/mp3enc.c
@@ -485,9 +485,9 @@ static const AVOption options[] = {
{ "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are
supported.",
offsetof(MP3Context, id3v2_version), AV_OPT_TYPE_INT, {.i64 = 4}, 0, 4,
AV_OPT_FLAG_ENCODING_PARAM},
{ "write_id3v1", "Enable ID3v1 writing. ID3v1 tags are written in UTF-8
which may not be supported by most software.",
- offsetof(MP3Context, write_id3v1), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1,
AV_OPT_FLAG_ENCODING_PARAM},
+ offsetof(MP3Context, write_id3v1), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
AV_OPT_FLAG_ENCODING_PARAM},
{ "write_xing", "Write the Xing header containing file duration.",
- offsetof(MP3Context, write_xing), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1,
AV_OPT_FLAG_ENCODING_PARAM},
+ offsetof(MP3Context, write_xing), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1,
AV_OPT_FLAG_ENCODING_PARAM},
{ NULL },
};
diff --git a/libavformat/mpegts.c b/libavformat/mpegts.c
index bc1e03e..cb2a5ec 100644
--- a/libavformat/mpegts.c
+++ b/libavformat/mpegts.c
@@ -166,15 +166,15 @@ struct MpegTSContext {
static const AVOption options[] = {
MPEGTS_OPTIONS,
- {"fix_teletext_pts", "try to fix pts values of dvb teletext streams",
offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_INT,
+ {"fix_teletext_pts", "try to fix pts values of dvb teletext streams",
offsetof(MpegTSContext, fix_teletext_pts), AV_OPT_TYPE_BOOL,
{.i64 = 1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
{"ts_packetsize", "output option carrying the raw packet size",
offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
{.i64 = 0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_EXPORT |
AV_OPT_FLAG_READONLY },
- {"scan_all_pmts", "scan and combine all PMTs", offsetof(MpegTSContext,
scan_all_pmts), AV_OPT_TYPE_INT,
+ {"scan_all_pmts", "scan and combine all PMTs", offsetof(MpegTSContext,
scan_all_pmts), AV_OPT_TYPE_BOOL,
{ .i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM },
- {"skip_changes", "skip changing / adding streams / programs",
offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_INT,
+ {"skip_changes", "skip changing / adding streams / programs",
offsetof(MpegTSContext, skip_changes), AV_OPT_TYPE_BOOL,
{.i64 = 0}, 0, 1, 0 },
- {"skip_clear", "skip clearing programs", offsetof(MpegTSContext,
skip_clear), AV_OPT_TYPE_INT,
+ {"skip_clear", "skip clearing programs", offsetof(MpegTSContext,
skip_clear), AV_OPT_TYPE_BOOL,
{.i64 = 0}, 0, 1, 0 },
{ NULL },
};
@@ -189,7 +189,7 @@ static const AVClass mpegts_class = {
static const AVOption raw_options[] = {
MPEGTS_OPTIONS,
{ "compute_pcr", "compute exact PCR for each transport stream packet",
- offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_INT,
+ offsetof(MpegTSContext, mpeg2ts_compute_pcr), AV_OPT_TYPE_BOOL,
{ .i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM },
{ "ts_packetsize", "output option carrying the raw packet size",
offsetof(MpegTSContext, raw_packet_size), AV_OPT_TYPE_INT,
diff --git a/libavformat/mpegtsenc.c b/libavformat/mpegtsenc.c
index 468bad4..34e5edd 100644
--- a/libavformat/mpegtsenc.c
+++ b/libavformat/mpegtsenc.c
@@ -1743,7 +1743,7 @@ static const AVOption options[] = {
offsetof(MpegTSWrite, start_pid), AV_OPT_TYPE_INT,
{ .i64 = 0x0100 }, 0x0020, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM },
{ "mpegts_m2ts_mode", "Enable m2ts mode.",
- offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_INT,
+ offsetof(MpegTSWrite, m2ts_mode), AV_OPT_TYPE_BOOL,
{ .i64 = -1 }, -1, 1, AV_OPT_FLAG_ENCODING_PARAM },
{ "muxrate", NULL,
offsetof(MpegTSWrite, mux_rate), AV_OPT_TYPE_INT,
@@ -1768,13 +1768,13 @@ static const AVOption options[] = {
offsetof(MpegTSWrite, reemit_pat_pmt), AV_OPT_TYPE_INT,
{ .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
{ "mpegts_copyts", "don't offset dts/pts",
- offsetof(MpegTSWrite, copyts), AV_OPT_TYPE_INT,
+ offsetof(MpegTSWrite, copyts), AV_OPT_TYPE_BOOL,
{ .i64 = -1 }, -1, 1, AV_OPT_FLAG_ENCODING_PARAM },
{ "tables_version", "set PAT, PMT and SDT version",
offsetof(MpegTSWrite, tables_version), AV_OPT_TYPE_INT,
{ .i64 = 0 }, 0, 31, AV_OPT_FLAG_ENCODING_PARAM },
{ "omit_video_pes_length", "Omit the PES packet length for video packets",
- offsetof(MpegTSWrite, omit_video_pes_length), AV_OPT_TYPE_INT,
+ offsetof(MpegTSWrite, omit_video_pes_length), AV_OPT_TYPE_BOOL,
{ .i64 = 1 }, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
{ "pcr_period", "PCR retransmission time",
offsetof(MpegTSWrite, pcr_period), AV_OPT_TYPE_INT,
diff --git a/libavformat/nutenc.c b/libavformat/nutenc.c
index cad31f8..ae097b3 100644
--- a/libavformat/nutenc.c
+++ b/libavformat/nutenc.c
@@ -1204,7 +1204,7 @@ static const AVOption options[] = {
{ "default", "", 0,
AV_OPT_TYPE_CONST, {.i64 = 0}, INT_MIN, INT_MAX, E,
"syncpoints" },
{ "none", "Disable syncpoints, low overhead and unseekable", 0,
AV_OPT_TYPE_CONST, {.i64 = NUT_PIPE}, INT_MIN, INT_MAX, E,
"syncpoints" },
{ "timestamped", "Extend syncpoints with a wallclock timestamp", 0,
AV_OPT_TYPE_CONST, {.i64 = NUT_BROADCAST}, INT_MIN, INT_MAX, E,
"syncpoints" },
- { "write_index", "Write index",
OFFSET(write_index), AV_OPT_TYPE_INT, {.i64 = 1}, 0,
1, E, },
+ { "write_index", "Write index",
OFFSET(write_index), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0,
1, E, },
{ NULL },
};
diff --git a/libavformat/options_table.h b/libavformat/options_table.h
index 76fa4a0..cc64bea 100644
--- a/libavformat/options_table.h
+++ b/libavformat/options_table.h
@@ -52,7 +52,7 @@ static const AVOption avformat_options[] = {
{"fastseek", "fast but inaccurate seeks", 0, AV_OPT_TYPE_CONST, {.i64 =
AVFMT_FLAG_FAST_SEEK }, INT_MIN, INT_MAX, D, "fflags"},
{"latm", "enable RTP MP4A-LATM payload", 0, AV_OPT_TYPE_CONST, {.i64 =
AVFMT_FLAG_MP4A_LATM }, INT_MIN, INT_MAX, E, "fflags"},
{"nobuffer", "reduce the latency introduced by optional buffering", 0,
AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_NOBUFFER }, 0, INT_MAX, D, "fflags"},
-{"seek2any", "allow seeking to non-keyframes on demuxer level when supported",
OFFSET(seek2any), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, D},
+{"seek2any", "allow seeking to non-keyframes on demuxer level when supported",
OFFSET(seek2any), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, D},
{"bitexact", "do not write random/volatile data", 0, AV_OPT_TYPE_CONST, { .i64
= AVFMT_FLAG_BITEXACT }, 0, 0, E, "fflags" },
{"analyzeduration", "specify how many microseconds are analyzed to probe the
input", OFFSET(max_analyze_duration), AV_OPT_TYPE_INT64, {.i64 = 0 }, 0,
INT64_MAX, D},
{"cryptokey", "decryption key", OFFSET(key), AV_OPT_TYPE_BINARY, {.dbl = 0},
0, 0, D},
@@ -80,8 +80,8 @@ static const AVOption avformat_options[] = {
{"aggressive", "consider things that a sane encoder shouldn't do as an error",
0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, D,
"err_detect"},
{"use_wallclock_as_timestamps", "use wallclock as timestamps",
OFFSET(use_wallclock_as_timestamps), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX-1,
D},
{"skip_initial_bytes", "set number of bytes to skip before reading header and
frames", OFFSET(skip_initial_bytes), AV_OPT_TYPE_INT64, {.i64 = 0}, 0,
INT64_MAX-1, D},
-{"correct_ts_overflow", "correct single timestamp overflows",
OFFSET(correct_ts_overflow), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, D},
-{"flush_packets", "enable flushing of the I/O context after each packet",
OFFSET(flush_packets), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E},
+{"correct_ts_overflow", "correct single timestamp overflows",
OFFSET(correct_ts_overflow), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, D},
+{"flush_packets", "enable flushing of the I/O context after each packet",
OFFSET(flush_packets), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E},
{"metadata_header_padding", "set number of bytes to be written as padding in a
metadata header", OFFSET(metadata_header_padding), AV_OPT_TYPE_INT, {.i64 =
-1}, -1, INT_MAX, E},
{"output_ts_offset", "set output timestamp offset", OFFSET(output_ts_offset),
AV_OPT_TYPE_DURATION, {.i64 = 0}, -INT64_MAX, INT64_MAX, E},
{"max_interleave_delta", "maximum buffering duration for interleaving",
OFFSET(max_interleave_delta), AV_OPT_TYPE_INT64, { .i64 = 10000000 }, 0,
INT64_MAX, E },
diff --git a/libavformat/rtmphttp.c b/libavformat/rtmphttp.c
index 0334ba5..8ed5eb1 100644
--- a/libavformat/rtmphttp.c
+++ b/libavformat/rtmphttp.c
@@ -254,7 +254,7 @@ fail:
#define DEC AV_OPT_FLAG_DECODING_PARAM
static const AVOption ffrtmphttp_options[] = {
- {"ffrtmphttp_tls", "Use a HTTPS tunneling connection (RTMPTS).",
OFFSET(tls), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC},
+ {"ffrtmphttp_tls", "Use a HTTPS tunneling connection (RTMPTS).",
OFFSET(tls), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC},
{ NULL },
};
diff --git a/libavformat/rtpproto.c b/libavformat/rtpproto.c
index d3e2ca0..e0aa23e 100644
--- a/libavformat/rtpproto.c
+++ b/libavformat/rtpproto.c
@@ -69,8 +69,8 @@ static const AVOption options[] = {
{ "rtcp_port", "Custom rtcp port",
OFFSET(rtcp_port), AV_OPT_TYPE_INT, { .i64 = -1 },
-1, INT_MAX, .flags = D|E },
{ "local_rtpport", "Local rtp port",
OFFSET(local_rtpport), AV_OPT_TYPE_INT, { .i64 = -1 },
-1, INT_MAX, .flags = D|E },
{ "local_rtcpport", "Local rtcp port",
OFFSET(local_rtcpport), AV_OPT_TYPE_INT, { .i64 = -1 },
-1, INT_MAX, .flags = D|E },
- { "connect", "Connect socket",
OFFSET(connect), AV_OPT_TYPE_INT, { .i64 = 0 },
0, 1, .flags = D|E },
- { "write_to_source", "Send packets to the source address of the latest
received packet", OFFSET(write_to_source), AV_OPT_TYPE_INT, { .i64 = 0 },
0, 1, .flags = D|E },
+ { "connect", "Connect socket",
OFFSET(connect), AV_OPT_TYPE_BOOL, { .i64 = 0 },
0, 1, .flags = D|E },
+ { "write_to_source", "Send packets to the source address of the latest
received packet", OFFSET(write_to_source), AV_OPT_TYPE_BOOL, { .i64 = 0 },
0, 1, .flags = D|E },
{ "pkt_size", "Maximum packet size",
OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = -1 },
-1, INT_MAX, .flags = D|E },
{ "dscp", "DSCP class",
OFFSET(dscp), AV_OPT_TYPE_INT, { .i64 = -1 },
-1, INT_MAX, .flags = D|E },
{ "sources", "Source list",
OFFSET(sources), AV_OPT_TYPE_STRING, { .str = NULL },
.flags = D|E },
diff --git a/libavformat/rtsp.c b/libavformat/rtsp.c
index e01dfd7..17fee03 100644
--- a/libavformat/rtsp.c
+++ b/libavformat/rtsp.c
@@ -80,7 +80,7 @@
const AVOption ff_rtsp_options[] = {
- { "initial_pause", "do not start playing the stream immediately",
OFFSET(initial_pause), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, DEC },
+ { "initial_pause", "do not start playing the stream immediately",
OFFSET(initial_pause), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },
FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),
{ "rtsp_transport", "set RTSP transport protocols",
OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX,
DEC|ENC, "rtsp_transport" }, \
{ "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 <<
RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, "rtsp_transport" }, \
diff --git a/libavformat/sctp.c b/libavformat/sctp.c
index 1d82615..5fee7e3 100644
--- a/libavformat/sctp.c
+++ b/libavformat/sctp.c
@@ -161,7 +161,7 @@ typedef struct SCTPContext {
#define D AV_OPT_FLAG_DECODING_PARAM
#define E AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
- { "listen", "Listen for incoming connections", OFFSET(listen),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, .flags = D|E },
+ { "listen", "Listen for incoming connections", OFFSET(listen),
AV_OPT_TYPE_BOOL,{ .i64 = 0 }, 0, 1, .flags = D|E },
{ "timeout", "Connection timeout (in milliseconds)",
OFFSET(timeout), AV_OPT_TYPE_INT, { .i64 = 10000 }, INT_MIN, INT_MAX,
.flags = D|E },
{ "listen_timeout", "Bind timeout (in milliseconds)",
OFFSET(listen_timeout), AV_OPT_TYPE_INT, { .i64 = -1 }, INT_MIN, INT_MAX,
.flags = D|E },
{ "max_streams", "Max stream to allocate",
OFFSET(max_streams), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT16_MAX,
.flags = D|E },
diff --git a/libavformat/segment.c b/libavformat/segment.c
index 36417f2..8432d0f 100644
--- a/libavformat/segment.c
+++ b/libavformat/segment.c
@@ -925,7 +925,7 @@ static const AVOption options[] = {
{ "m3u8", "M3U8 format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_M3U8 },
INT_MIN, INT_MAX, E, "list_type" },
{ "hls", "Apple HTTP Live Streaming compatible", 0, AV_OPT_TYPE_CONST,
{.i64=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, E, "list_type" },
- { "segment_atclocktime", "set segment to be cut at clocktime",
OFFSET(use_clocktime), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E},
+ { "segment_atclocktime", "set segment to be cut at clocktime",
OFFSET(use_clocktime), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E},
{ "segment_time", "set segment duration",
OFFSET(time_str),AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
{ "segment_time_delta","set approximation value used for the segment
times", OFFSET(time_delta), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, 0, E },
{ "segment_times", "set segment split time points",
OFFSET(times_str),AV_OPT_TYPE_STRING,{.str = NULL}, 0, 0, E },
@@ -934,12 +934,12 @@ static const AVOption options[] = {
{ "segment_list_entry_prefix", "set base url prefix for segments",
OFFSET(entry_prefix), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E },
{ "segment_start_number", "set the sequence number of the first segment",
OFFSET(segment_idx), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E },
{ "segment_wrap_number", "set the number of wrap before the first
segment", OFFSET(segment_idx_wrap_nb), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
E },
- { "strftime", "set filename expansion with strftime at segment
creation", OFFSET(use_strftime), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, E },
- { "break_non_keyframes", "allow breaking segments on non-keyframes",
OFFSET(break_non_keyframes), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
+ { "strftime", "set filename expansion with strftime at segment
creation", OFFSET(use_strftime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
+ { "break_non_keyframes", "allow breaking segments on non-keyframes",
OFFSET(break_non_keyframes), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
- { "individual_header_trailer", "write header/trailer to each segment",
OFFSET(individual_header_trailer), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E },
- { "write_header_trailer", "write a header to the first segment and a
trailer to the last one", OFFSET(write_header_trailer), AV_OPT_TYPE_INT, {.i64
= 1}, 0, 1, E },
- { "reset_timestamps", "reset timestamps at the begin of each segment",
OFFSET(reset_timestamps), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
+ { "individual_header_trailer", "write header/trailer to each segment",
OFFSET(individual_header_trailer), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, E },
+ { "write_header_trailer", "write a header to the first segment and a
trailer to the last one", OFFSET(write_header_trailer), AV_OPT_TYPE_BOOL, {.i64
= 1}, 0, 1, E },
+ { "reset_timestamps", "reset timestamps at the begin of each segment",
OFFSET(reset_timestamps), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E },
{ "initial_offset", "set initial timestamp offset",
OFFSET(initial_offset), AV_OPT_TYPE_DURATION, {.i64 = 0}, -INT64_MAX,
INT64_MAX, E },
{ NULL },
};
diff --git a/libavformat/smoothstreamingenc.c b/libavformat/smoothstreamingenc.c
index 1ae3b49..a26f8fe 100644
--- a/libavformat/smoothstreamingenc.c
+++ b/libavformat/smoothstreamingenc.c
@@ -622,7 +622,7 @@ static const AVOption options[] = {
{ "extra_window_size", "number of fragments kept outside of the manifest
before removing from disk", OFFSET(extra_window_size), AV_OPT_TYPE_INT, { .i64
= 5 }, 0, INT_MAX, E },
{ "lookahead_count", "number of lookahead fragments",
OFFSET(lookahead_count), AV_OPT_TYPE_INT, { .i64 = 2 }, 0, INT_MAX, E },
{ "min_frag_duration", "minimum fragment duration (in microseconds)",
OFFSET(min_frag_duration), AV_OPT_TYPE_INT64, { .i64 = 5000000 }, 0, INT_MAX, E
},
- { "remove_at_exit", "remove all fragments when finished",
OFFSET(remove_at_exit), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
+ { "remove_at_exit", "remove all fragments when finished",
OFFSET(remove_at_exit), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
{ NULL },
};
diff --git a/libavformat/udp.c b/libavformat/udp.c
index 1bda5af..91d57e9 100644
--- a/libavformat/udp.c
+++ b/libavformat/udp.c
@@ -117,13 +117,13 @@ static const AVOption options[] = {
{ "localaddr", "Local address",
OFFSET(localaddr), AV_OPT_TYPE_STRING, { .str = NULL },
.flags = D|E },
{ "udplite_coverage", "choose UDPLite head size which should be validated
by checksum", OFFSET(udplite_coverage), AV_OPT_TYPE_INT, {.i64 = 0}, 0,
INT_MAX, D|E },
{ "pkt_size", "Maximum UDP packet size",
OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = 1472 }, -1, INT_MAX,
.flags = D|E },
- { "reuse", "explicitly allow reusing UDP sockets",
OFFSET(reuse_socket), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, D|E
},
- { "reuse_socket", "explicitly allow reusing UDP sockets",
OFFSET(reuse_socket), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1,
.flags = D|E },
- { "broadcast", "explicitly allow or disallow broadcast destination",
OFFSET(is_broadcast), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
+ { "reuse", "explicitly allow reusing UDP sockets",
OFFSET(reuse_socket), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, D|E
},
+ { "reuse_socket", "explicitly allow reusing UDP sockets",
OFFSET(reuse_socket), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1,
.flags = D|E },
+ { "broadcast", "explicitly allow or disallow broadcast destination",
OFFSET(is_broadcast), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
{ "ttl", "Time to live (multicast only)",
OFFSET(ttl), AV_OPT_TYPE_INT, { .i64 = 16 }, 0, INT_MAX, E },
- { "connect", "set if connect() should be called on socket",
OFFSET(is_connected), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1,
.flags = D|E },
+ { "connect", "set if connect() should be called on socket",
OFFSET(is_connected), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1,
.flags = D|E },
{ "fifo_size", "set the UDP receiving circular buffer size, expressed
as a number of packets with size of 188 bytes", OFFSET(circular_buffer_size),
AV_OPT_TYPE_INT, {.i64 = 7*4096}, 0, INT_MAX, D },
- { "overrun_nonfatal", "survive in case of UDP receiving circular buffer
overrun", OFFSET(overrun_nonfatal), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D },
+ { "overrun_nonfatal", "survive in case of UDP receiving circular buffer
overrun", OFFSET(overrun_nonfatal), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, D },
{ "timeout", "set raise error timeout (only in read mode)",
OFFSET(timeout), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, D },
{ "sources", "Source list",
OFFSET(sources), AV_OPT_TYPE_STRING, { .str = NULL },
.flags = D|E },
{ "block", "Block list",
OFFSET(block), AV_OPT_TYPE_STRING, { .str = NULL },
.flags = D|E },
diff --git a/libavformat/unix.c b/libavformat/unix.c
index 63d1db2..b3d5fac 100644
--- a/libavformat/unix.c
+++ b/libavformat/unix.c
@@ -45,7 +45,7 @@ typedef struct UnixContext {
#define OFFSET(x) offsetof(UnixContext, x)
#define ED AV_OPT_FLAG_DECODING_PARAM|AV_OPT_FLAG_ENCODING_PARAM
static const AVOption unix_options[] = {
- { "listen", "Open socket for listening", OFFSET(listen),
AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, ED },
+ { "listen", "Open socket for listening", OFFSET(listen),
AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, ED },
{ "timeout", "Timeout in ms", OFFSET(timeout),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, ED },
{ "type", "Socket type", OFFSET(type),
AV_OPT_TYPE_INT, { .i64 = SOCK_STREAM }, INT_MIN, INT_MAX, ED, "type" },
{ "stream", "Stream (reliable stream-oriented)", 0,
AV_OPT_TYPE_CONST, { .i64 = SOCK_STREAM }, INT_MIN, INT_MAX, ED, "type" },
diff --git a/libavformat/webmdashenc.c b/libavformat/webmdashenc.c
index 76e7eda..301c045 100644
--- a/libavformat/webmdashenc.c
+++ b/libavformat/webmdashenc.c
@@ -518,8 +518,8 @@ static int webm_dash_manifest_write_trailer(AVFormatContext
*s)
#define OFFSET(x) offsetof(WebMDashMuxContext, x)
static const AVOption options[] = {
{ "adaptation_sets", "Adaptation sets. Syntax: id=0,streams=0,1,2
id=1,streams=3,4 and so on", OFFSET(adaptation_sets), AV_OPT_TYPE_STRING, { 0
}, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },
- { "debug_mode", "[private option - users should never set this]. set this
to 1 to create deterministic output", OFFSET(debug_mode), AV_OPT_TYPE_INT,
{.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
- { "live", "set this to 1 to create a live stream manifest",
OFFSET(is_live), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM
},
+ { "debug_mode", "[private option - users should never set this]. Create
deterministic output", OFFSET(debug_mode), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1,
AV_OPT_FLAG_ENCODING_PARAM },
+ { "live", "create a live stream manifest", OFFSET(is_live),
AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },
{ "chunk_start_index", "start index of the chunk",
OFFSET(chunk_start_index), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM },
{ "chunk_duration_ms", "duration of each chunk (in milliseconds)",
OFFSET(chunk_duration), AV_OPT_TYPE_INT, {.i64 = 1000}, 0, INT_MAX,
AV_OPT_FLAG_ENCODING_PARAM },
{ "utc_timing_url", "URL of the page that will return the UTC timestamp in
ISO format", OFFSET(utc_timing_url), AV_OPT_TYPE_STRING, { 0 }, 0, 0,
AV_OPT_FLAG_ENCODING_PARAM },
--
2.6.2
_______________________________________________
ffmpeg-devel mailing list
[email protected]
http://ffmpeg.org/mailman/listinfo/ffmpeg-devel
