AVOptions: make default_val a union, as proposed in AVOption2.

This breaks API and ABI.

Anton Khirnov committed 15 years ago

Commit 85770f21 parent 35ceaa713 files · +495 −552Browse files

Unified · Split

13 files

libavcodec/ac3enc.c +34 −34
libavcodec/dnxhdenc.c +1 −1
libavcodec/libvorbis.c +1 −1
libavcodec/options.c +382 −382
libavfilter/vsrc_movie.c +6 −6
libavformat/http.c +1 −1
libavformat/mp3enc.c +1 −1
libavformat/mpegtsenc.c +5 −5
libavformat/options.c +17 −17
libavformat/spdifenc.c +4 −4
libavutil/opt.c +7 −16
libavutil/opt.h +3 −51
libswscale/options.c +33 −33

libavcodec/dnxhdenc.c+1−1

@@ -33,7 +33,7 @@ · 32 unmodified lines
33	#define VE AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM	33	#define VE AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM
34		34
35	static const AVOption options[]={	35	static const AVOption options[]={
36	{"nitris_compat", "encode with Avid Nitris compatibility", offsetof(DNXHDEncContext, nitris_compat), FF_OPT_TYPE_INT, 0, 0, 1, VE},	36	{"nitris_compat", "encode with Avid Nitris compatibility", offsetof(DNXHDEncContext, nitris_compat), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, VE},
37	{NULL}	37	{NULL}
38	};	38	};
39	static const AVClass class = { "dnxhd", av_default_item_name, options, LIBAVUTIL_VERSION_INT };	39	static const AVClass class = { "dnxhd", av_default_item_name, options, LIBAVUTIL_VERSION_INT };

libavcodec/libvorbis.c+1−1

@@ -55,7 +55,7 @@ typedef struct OggVorbisContext { · 54 unmodified lines
55	} OggVorbisContext ;	55	} OggVorbisContext ;
56		56
57	static const AVOption options[]={	57	static const AVOption options[]={
58	{"iblock", "Sets the impulse block bias", offsetof(OggVorbisContext, iblock), FF_OPT_TYPE_DOUBLE, 0, -15, 0, AV_OPT_FLAG_AUDIO_PARAM\|AV_OPT_FLAG_ENCODING_PARAM},	58	{"iblock", "Sets the impulse block bias", offsetof(OggVorbisContext, iblock), FF_OPT_TYPE_DOUBLE, {.i64 = 0}, -15, 0, AV_OPT_FLAG_AUDIO_PARAM\|AV_OPT_FLAG_ENCODING_PARAM},
59	{NULL}	59	{NULL}
60	};	60	};
61	static const AVClass class = { "libvorbis", av_default_item_name, options, LIBAVUTIL_VERSION_INT };	61	static const AVClass class = { "libvorbis", av_default_item_name, options, LIBAVUTIL_VERSION_INT };

libavcodec/options.c+382−382

libavfilter/vsrc_movie.c+6−6

@@ -57,12 +57,12 @@ typedef struct { · 56 unmodified lines
57	#define OFFSET(x) offsetof(MovieContext, x)	57	#define OFFSET(x) offsetof(MovieContext, x)
58		58
59	static const AVOption movie_options[]= {	59	static const AVOption movie_options[]= {
60	{"format_name", "set format name", OFFSET(format_name), FF_OPT_TYPE_STRING, 0, CHAR_MIN, CHAR_MAX },	60	{"format_name", "set format name", OFFSET(format_name), FF_OPT_TYPE_STRING, {.str = 0}, CHAR_MIN, CHAR_MAX },
61	{"f", "set format name", OFFSET(format_name), FF_OPT_TYPE_STRING, 0, CHAR_MIN, CHAR_MAX },	61	{"f", "set format name", OFFSET(format_name), FF_OPT_TYPE_STRING, {.str = 0}, CHAR_MIN, CHAR_MAX },
62	{"stream_index", "set stream index", OFFSET(stream_index), FF_OPT_TYPE_INT, -1, -1, INT_MAX },	62	{"stream_index", "set stream index", OFFSET(stream_index), FF_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX },
63	{"si", "set stream index", OFFSET(stream_index), FF_OPT_TYPE_INT, -1, -1, INT_MAX },	63	{"si", "set stream index", OFFSET(stream_index), FF_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX },
64	{"seek_point", "set seekpoint (seconds)", OFFSET(seek_point_d), FF_OPT_TYPE_DOUBLE, 0, 0, (INT64_MAX-1) / 1000000 },	64	{"seek_point", "set seekpoint (seconds)", OFFSET(seek_point_d), FF_OPT_TYPE_DOUBLE, {.dbl = 0}, 0, (INT64_MAX-1) / 1000000 },
65	{"sp", "set seekpoint (seconds)", OFFSET(seek_point_d), FF_OPT_TYPE_DOUBLE, 0, 0, (INT64_MAX-1) / 1000000 },	65	{"sp", "set seekpoint (seconds)", OFFSET(seek_point_d), FF_OPT_TYPE_DOUBLE, {.dbl = 0}, 0, (INT64_MAX-1) / 1000000 },
66	{NULL},	66	{NULL},
67	};	67	};
68		68

libavformat/http.c+1−1

@@ -54,7 +54,7 @@ typedef struct { · 53 unmodified lines
54		54
55	#define OFFSET(x) offsetof(HTTPContext, x)	55	#define OFFSET(x) offsetof(HTTPContext, x)
56	static const AVOption options[] = {	56	static const AVOption options[] = {
57	{"chunksize", "use chunked transfer-encoding for posts, -1 disables it, 0 enables it", OFFSET(chunksize), FF_OPT_TYPE_INT64, 0, -1, 0 }, /* Default to 0, for chunked POSTs */	57	{"chunksize", "use chunked transfer-encoding for posts, -1 disables it, 0 enables it", OFFSET(chunksize), FF_OPT_TYPE_INT64, {.i64 = 0}, -1, 0 }, /* Default to 0, for chunked POSTs */
58	{NULL}	58	{NULL}
59	};	59	};
60	static const AVClass httpcontext_class = {	60	static const AVClass httpcontext_class = {

libavformat/mp3enc.c+1−1

@@ -161,7 +161,7 @@ typedef struct MP3Context { · 160 unmodified lines
161		161
162	static const AVOption options[] = {	162	static const AVOption options[] = {
163	{ "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",	163	{ "id3v2_version", "Select ID3v2 version to write. Currently 3 and 4 are supported.",
164	offsetof(MP3Context, id3v2_version), FF_OPT_TYPE_INT, 4, 3, 4, AV_OPT_FLAG_ENCODING_PARAM},	164	offsetof(MP3Context, id3v2_version), FF_OPT_TYPE_INT, {.i64 = 4}, 3, 4, AV_OPT_FLAG_ENCODING_PARAM},
165	{ NULL },	165	{ NULL },
166	};	166	};
167		167

libavformat/mpegtsenc.c+5−5

@@ -76,15 +76,15 @@ typedef struct MpegTSWrite { · 75 unmodified lines
76		76
77	static const AVOption options[] = {	77	static const AVOption options[] = {
78	{ "mpegts_transport_stream_id", "Set transport_stream_id field.",	78	{ "mpegts_transport_stream_id", "Set transport_stream_id field.",
79	offsetof(MpegTSWrite, transport_stream_id), FF_OPT_TYPE_INT, 0x0001, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},	79	offsetof(MpegTSWrite, transport_stream_id), FF_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
80	{ "mpegts_original_network_id", "Set original_network_id field.",	80	{ "mpegts_original_network_id", "Set original_network_id field.",
81	offsetof(MpegTSWrite, original_network_id), FF_OPT_TYPE_INT, 0x0001, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},	81	offsetof(MpegTSWrite, original_network_id), FF_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
82	{ "mpegts_service_id", "Set service_id field.",	82	{ "mpegts_service_id", "Set service_id field.",
83	offsetof(MpegTSWrite, service_id), FF_OPT_TYPE_INT, 0x0001, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},	83	offsetof(MpegTSWrite, service_id), FF_OPT_TYPE_INT, {.i64 = 0x0001 }, 0x0001, 0xffff, AV_OPT_FLAG_ENCODING_PARAM},
84	{ "mpegts_pmt_start_pid", "Set the first pid of the PMT.",	84	{ "mpegts_pmt_start_pid", "Set the first pid of the PMT.",
85	offsetof(MpegTSWrite, pmt_start_pid), FF_OPT_TYPE_INT, 0x1000, 0x1000, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM},	85	offsetof(MpegTSWrite, pmt_start_pid), FF_OPT_TYPE_INT, {.i64 = 0x1000 }, 0x1000, 0x1f00, AV_OPT_FLAG_ENCODING_PARAM},
86	{ "mpegts_start_pid", "Set the first pid.",	86	{ "mpegts_start_pid", "Set the first pid.",
87	offsetof(MpegTSWrite, start_pid), FF_OPT_TYPE_INT, 0x0100, 0x0100, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM},	87	offsetof(MpegTSWrite, start_pid), FF_OPT_TYPE_INT, {.i64 = 0x0100 }, 0x0100, 0x0f00, AV_OPT_FLAG_ENCODING_PARAM},
88	{ NULL },	88	{ NULL },
89	};	89	};
90		90

libavformat/options.c+17−17

libavformat/spdifenc.c+4−4

@@ -86,10 +86,10 @@ typedef struct IEC61937Context { · 85 unmodified lines
86	} IEC61937Context;	86	} IEC61937Context;
87		87
88	static const AVOption options[] = {	88	static const AVOption options[] = {
89	{ "spdif_flags", "IEC 61937 encapsulation flags", offsetof(IEC61937Context, spdif_flags), FF_OPT_TYPE_FLAGS, 0, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },	89	{ "spdif_flags", "IEC 61937 encapsulation flags", offsetof(IEC61937Context, spdif_flags), FF_OPT_TYPE_FLAGS, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },
90	{ "be", "output in big-endian format (for use as s16be)", 0, FF_OPT_TYPE_CONST, SPDIF_FLAG_BIGENDIAN, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },	90	{ "be", "output in big-endian format (for use as s16be)", 0, FF_OPT_TYPE_CONST, {.i64 = SPDIF_FLAG_BIGENDIAN}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "spdif_flags" },
91	{ "dtshd_rate", "mux complete DTS frames in HD mode at the specified IEC958 rate (in Hz, default 0=disabled)", offsetof(IEC61937Context, dtshd_rate), FF_OPT_TYPE_INT, 0, 0, 768000, AV_OPT_FLAG_ENCODING_PARAM },	91	{ "dtshd_rate", "mux complete DTS frames in HD mode at the specified IEC958 rate (in Hz, default 0=disabled)", offsetof(IEC61937Context, dtshd_rate), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 768000, AV_OPT_FLAG_ENCODING_PARAM },
92	{ "dtshd_fallback_time", "min secs to strip HD for after an overflow (-1: till the end, default 60)", offsetof(IEC61937Context, dtshd_fallback), FF_OPT_TYPE_INT, 60, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },	92	{ "dtshd_fallback_time", "min secs to strip HD for after an overflow (-1: till the end, default 60)", offsetof(IEC61937Context, dtshd_fallback), FF_OPT_TYPE_INT, {.i64 = 60}, -1, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },
93	{ NULL },	93	{ NULL },
94	};	94	};
95		95

libavutil/opt.c+7−16

             {
                 const AVOption *o_named= av_find_opt(obj, buf, o->unit, 0, 0);
                 if (o_named && o_named->type == FF_OPT_TYPE_CONST)
-                    d= o_named->default_val;
+                    d= o_named->default_val.dbl;
-                else if (!strcmp(buf, "default")) d= o->default_val;
+                else if (!strcmp(buf, "default")) d= o->default_val.dbl;
                 else if (!strcmp(buf, "max"    )) d= o->max;
                 else if (!strcmp(buf, "min"    )) d= o->min;
                 else if (!strcmp(buf, "none"   )) d= 0;
                 /* Nothing to be done here */
             break;
             case FF_OPT_TYPE_FLAGS:
-            case FF_OPT_TYPE_INT: {
+            case FF_OPT_TYPE_INT:
-                int val;
-                val = opt->default_val;
-                av_set_int(s, opt->name, val);
-            }
-            break;
             case FF_OPT_TYPE_INT64:
-                if ((double)(opt->default_val+0.6) == opt->default_val)
+                av_set_int(s, opt->name, opt->default_val.i64);
-                    av_log(s, AV_LOG_DEBUG, "loss of precision in default of %s\n", opt->name);
+                break;
-                av_set_int(s, opt->name, opt->default_val);
-            break;
             case FF_OPT_TYPE_DOUBLE:
             case FF_OPT_TYPE_FLOAT: {
                 double val;
-                val = opt->default_val;
+                val = opt->default_val.dbl;
                 av_set_double(s, opt->name, val);
             }
             break;
             case FF_OPT_TYPE_RATIONAL: {
-                AVRational val;
+                av_set_q(s, opt->name, opt->default_val.q);
-                val = av_d2q(opt->default_val, INT_MAX);
-                av_set_q(s, opt->name, val);
             }
             break;
             case FF_OPT_TYPE_STRING:

libavutil/opt.h+3−51

@@ -61,72 +61,25 @@ typedef struct AVOption { · 60 unmodified lines
61	int offset;	61	int offset;
62	enum AVOptionType type;	62	enum AVOptionType type;
63		63
64	/**
65	* the default value for scalar options
66	*/
67	double default_val;
68	double min; ///< minimum valid value for the option
69	double max; ///< maximum valid value for the option
70
71	int flags;
72	#define AV_OPT_FLAG_ENCODING_PARAM 1 ///< a generic parameter which can be set by the user for muxing or encoding
73	#define AV_OPT_FLAG_DECODING_PARAM 2 ///< a generic parameter which can be set by the user for demuxing or decoding
74	#define AV_OPT_FLAG_METADATA 4 ///< some data extracted or inserted into the file like title, comment, ...
75	#define AV_OPT_FLAG_AUDIO_PARAM 8
76	#define AV_OPT_FLAG_VIDEO_PARAM 16
77	#define AV_OPT_FLAG_SUBTITLE_PARAM 32
78	//FIXME think about enc-audio, ... style flags
79
80	/**
81	* The logical unit to which the option belongs. Non-constant
82	* options and corresponding named constants share the same
83	* unit. May be NULL.
84	*/
85	const char *unit;
86	} AVOption;
87
88	/**
89	* AVOption2.
90	* THIS IS NOT PART OF THE API/ABI YET!
91	* This is identical to AVOption except that default_val was replaced by
92	* an union, it should be compatible with AVOption on normal platforms.
93	*/
94	typedef struct AVOption2 {
95	const char *name;
96
97	/**
98	* short English help text
99	* @todo What about other languages?
100	*/
101	const char *help;
102
103	/**
104	* The offset relative to the context structure where the option
105	* value is stored. It should be 0 for named constants.
106	*/
107	int offset;
108	enum AVOptionType type;
109
110	/**	64	/**
111	* the default value for scalar options	65	* the default value for scalar options
112	*/	66	*/
113	union {	67	union {
114	double dbl;	68	double dbl;
115	const char *str;	69	const char *str;
		70	int64_t i64;
		71	AVRational q;
116	} default_val;	72	} default_val;
117
118	double min; ///< minimum valid value for the option	73	double min; ///< minimum valid value for the option
119	double max; ///< maximum valid value for the option	74	double max; ///< maximum valid value for the option
120		75
121	int flags;	76	int flags;
122	/*
123	#define AV_OPT_FLAG_ENCODING_PARAM 1 ///< a generic parameter which can be set by the user for muxing or encoding	77	#define AV_OPT_FLAG_ENCODING_PARAM 1 ///< a generic parameter which can be set by the user for muxing or encoding
124	#define AV_OPT_FLAG_DECODING_PARAM 2 ///< a generic parameter which can be set by the user for demuxing or decoding	78	#define AV_OPT_FLAG_DECODING_PARAM 2 ///< a generic parameter which can be set by the user for demuxing or decoding
125	#define AV_OPT_FLAG_METADATA 4 ///< some data extracted or inserted into the file like title, comment, ...	79	#define AV_OPT_FLAG_METADATA 4 ///< some data extracted or inserted into the file like title, comment, ...
126	#define AV_OPT_FLAG_AUDIO_PARAM 8	80	#define AV_OPT_FLAG_AUDIO_PARAM 8
127	#define AV_OPT_FLAG_VIDEO_PARAM 16	81	#define AV_OPT_FLAG_VIDEO_PARAM 16
128	#define AV_OPT_FLAG_SUBTITLE_PARAM 32	82	#define AV_OPT_FLAG_SUBTITLE_PARAM 32
129	*/
130	//FIXME think about enc-audio, ... style flags	83	//FIXME think about enc-audio, ... style flags
131		84
132	/**	85	/**
@@ -135,8 +88,7 @@ typedef struct AVOption2 { · 2 unmodified lines
135	* unit. May be NULL.	88	* unit. May be NULL.
136	*/	89	*/
137	const char *unit;	90	const char *unit;
138	} AVOption2;	91	} AVOption;
139
140		92
141	/**	93	/**
142	* Look for an option in obj. Look only for the options which	94	* Look for an option in obj. Look only for the options which

libswscale/options.c+33−33

AVOptions: make default_val a union, as proposed in AVOption2.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -231,44 +231,44 @@ static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = { · 230 unmodified lines
231		231
232	static const AVOption options[] = {	232	static const AVOption options[] = {
233	/* Metadata Options */	233	/* Metadata Options */
234	{"per_frame_metadata", "Allow Changing Metadata Per-Frame", OFFSET(allow_per_frame_metadata), FF_OPT_TYPE_INT, 0, 0, 1, AC3ENC_PARAM},	234	{"per_frame_metadata", "Allow Changing Metadata Per-Frame", OFFSET(allow_per_frame_metadata), FF_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, AC3ENC_PARAM},
235	/* downmix levels */	235	/* downmix levels */
236	{"center_mixlev", "Center Mix Level", OFFSET(center_mix_level), FF_OPT_TYPE_FLOAT, LEVEL_MINUS_4POINT5DB, 0.0, 1.0, AC3ENC_PARAM},	236	{"center_mixlev", "Center Mix Level", OFFSET(center_mix_level), FF_OPT_TYPE_FLOAT, {.dbl = LEVEL_MINUS_4POINT5DB }, 0.0, 1.0, AC3ENC_PARAM},
237	{"surround_mixlev", "Surround Mix Level", OFFSET(surround_mix_level), FF_OPT_TYPE_FLOAT, LEVEL_MINUS_6DB, 0.0, 1.0, AC3ENC_PARAM},	237	{"surround_mixlev", "Surround Mix Level", OFFSET(surround_mix_level), FF_OPT_TYPE_FLOAT, {.dbl = LEVEL_MINUS_6DB }, 0.0, 1.0, AC3ENC_PARAM},
238	/* audio production information */	238	/* audio production information */
239	{"mixing_level", "Mixing Level", OFFSET(mixing_level), FF_OPT_TYPE_INT, -1, -1, 111, AC3ENC_PARAM},	239	{"mixing_level", "Mixing Level", OFFSET(mixing_level), FF_OPT_TYPE_INT, {.i64 = -1 }, -1, 111, AC3ENC_PARAM},
240	{"room_type", "Room Type", OFFSET(room_type), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "room_type"},	240	{"room_type", "Room Type", OFFSET(room_type), FF_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, AC3ENC_PARAM, "room_type"},
241	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},	241	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, {.i64 = 0 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},
242	{"large", "Large Room", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},	242	{"large", "Large Room", 0, FF_OPT_TYPE_CONST, {.i64 = 1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},
243	{"small", "Small Room", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},	243	{"small", "Small Room", 0, FF_OPT_TYPE_CONST, {.i64 = 2 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "room_type"},
244	/* other metadata options */	244	/* other metadata options */
245	{"copyright", "Copyright Bit", OFFSET(copyright), FF_OPT_TYPE_INT, 0, 0, 1, AC3ENC_PARAM},	245	{"copyright", "Copyright Bit", OFFSET(copyright), FF_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, AC3ENC_PARAM},
246	{"dialnorm", "Dialogue Level (dB)", OFFSET(dialogue_level), FF_OPT_TYPE_INT, -31, -31, -1, AC3ENC_PARAM},	246	{"dialnorm", "Dialogue Level (dB)", OFFSET(dialogue_level), FF_OPT_TYPE_INT, {.i64 = -31 }, -31, -1, AC3ENC_PARAM},
247	{"dsur_mode", "Dolby Surround Mode", OFFSET(dolby_surround_mode), FF_OPT_TYPE_INT, 0, 0, 2, AC3ENC_PARAM, "dsur_mode"},	247	{"dsur_mode", "Dolby Surround Mode", OFFSET(dolby_surround_mode), FF_OPT_TYPE_INT, {.i64 = 0 }, 0, 2, AC3ENC_PARAM, "dsur_mode"},
248	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},	248	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, {.i64 = 0 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},
249	{"on", "Dolby Surround Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},	249	{"on", "Dolby Surround Encoded", 0, FF_OPT_TYPE_CONST, {.i64 = 1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},
250	{"off", "Not Dolby Surround Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},	250	{"off", "Not Dolby Surround Encoded", 0, FF_OPT_TYPE_CONST, {.i64 = 2 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsur_mode"},
251	{"original", "Original Bit Stream", OFFSET(original), FF_OPT_TYPE_INT, 1, 0, 1, AC3ENC_PARAM},	251	{"original", "Original Bit Stream", OFFSET(original), FF_OPT_TYPE_INT, {.i64 = 1 }, 0, 1, AC3ENC_PARAM},
252	/* extended bitstream information */	252	/* extended bitstream information */
253	{"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dmix_mode"},	253	{"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), FF_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, AC3ENC_PARAM, "dmix_mode"},
254	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},	254	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, {.i64 = 0 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},
255	{"ltrt", "Lt/Rt Downmix Preferred", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},	255	{"ltrt", "Lt/Rt Downmix Preferred", 0, FF_OPT_TYPE_CONST, {.i64 = 1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},
256	{"loro", "Lo/Ro Downmix Preferred", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},	256	{"loro", "Lo/Ro Downmix Preferred", 0, FF_OPT_TYPE_CONST, {.i64 = 2 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dmix_mode"},
257	{"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM},	257	{"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), FF_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, AC3ENC_PARAM},
258	{"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM},	258	{"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), FF_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, AC3ENC_PARAM},
259	{"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM},	259	{"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), FF_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, AC3ENC_PARAM},
260	{"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), FF_OPT_TYPE_FLOAT, -1.0, -1.0, 2.0, AC3ENC_PARAM},	260	{"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), FF_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, AC3ENC_PARAM},
261	{"dsurex_mode", "Dolby Surround EX Mode", OFFSET(dolby_surround_ex_mode), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dsurex_mode"},	261	{"dsurex_mode", "Dolby Surround EX Mode", OFFSET(dolby_surround_ex_mode), FF_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, AC3ENC_PARAM, "dsurex_mode"},
262	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},	262	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, {.i64 = 0 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},
263	{"on", "Dolby Surround EX Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},	263	{"on", "Dolby Surround EX Encoded", 0, FF_OPT_TYPE_CONST, {.i64 = 1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},
264	{"off", "Not Dolby Surround EX Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},	264	{"off", "Not Dolby Surround EX Encoded", 0, FF_OPT_TYPE_CONST, {.i64 = 2 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dsurex_mode"},
265	{"dheadphone_mode", "Dolby Headphone Mode", OFFSET(dolby_headphone_mode), FF_OPT_TYPE_INT, -1, -1, 2, AC3ENC_PARAM, "dheadphone_mode"},	265	{"dheadphone_mode", "Dolby Headphone Mode", OFFSET(dolby_headphone_mode), FF_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, AC3ENC_PARAM, "dheadphone_mode"},
266	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},	266	{"notindicated", "Not Indicated (default)", 0, FF_OPT_TYPE_CONST, {.i64 = 0 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},
267	{"on", "Dolby Headphone Encoded", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},	267	{"on", "Dolby Headphone Encoded", 0, FF_OPT_TYPE_CONST, {.i64 = 1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},
268	{"off", "Not Dolby Headphone Encoded", 0, FF_OPT_TYPE_CONST, 2, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},	268	{"off", "Not Dolby Headphone Encoded", 0, FF_OPT_TYPE_CONST, {.i64 = 2 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "dheadphone_mode"},
269	{"ad_conv_type", "A/D Converter Type", OFFSET(ad_converter_type), FF_OPT_TYPE_INT, -1, -1, 1, AC3ENC_PARAM, "ad_conv_type"},	269	{"ad_conv_type", "A/D Converter Type", OFFSET(ad_converter_type), FF_OPT_TYPE_INT, {.i64 = -1 }, -1, 1, AC3ENC_PARAM, "ad_conv_type"},
270	{"standard", "Standard (default)", 0, FF_OPT_TYPE_CONST, 0, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},	270	{"standard", "Standard (default)", 0, FF_OPT_TYPE_CONST, {.i64 = 0 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},
271	{"hdcd", "HDCD", 0, FF_OPT_TYPE_CONST, 1, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},	271	{"hdcd", "HDCD", 0, FF_OPT_TYPE_CONST, {.i64 = 1 }, INT_MIN, INT_MAX, AC3ENC_PARAM, "ad_conv_type"},
272	{NULL}	272	{NULL}
273	};	273	};
274		274

@@ -40,23 +40,23 @@ static const char* format_to_name(void* ptr) · 39 unmodified lines
40	#define D AV_OPT_FLAG_DECODING_PARAM	40	#define D AV_OPT_FLAG_DECODING_PARAM
41		41
42	static const AVOption options[]={	42	static const AVOption options[]={
43	{"probesize", "set probing size", OFFSET(probesize), FF_OPT_TYPE_INT, 5000000, 32, INT_MAX, D},	43	{"probesize", "set probing size", OFFSET(probesize), FF_OPT_TYPE_INT, {.i64 = 5000000 }, 32, INT_MAX, D},
44	{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},	44	{"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, E},
45	{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},	45	{"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, E},
46	{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D\|E, "fflags"},	46	{"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, INT_MIN, INT_MAX, D\|E, "fflags"},
47	{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},	47	{"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_IGNIDX }, INT_MIN, INT_MAX, D, "fflags"},
48	{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},	48	{"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_GENPTS }, INT_MIN, INT_MAX, D, "fflags"},
49	{"nofillin", "do not fill in missing values that can be exactly calculated", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_NOFILLIN, INT_MIN, INT_MAX, D, "fflags"},	49	{"nofillin", "do not fill in missing values that can be exactly calculated", 0, FF_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_NOFILLIN }, INT_MIN, INT_MAX, D, "fflags"},
50	{"noparse", "disable AVParsers, this needs nofillin too", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_NOPARSE, INT_MIN, INT_MAX, D, "fflags"},	50	{"noparse", "disable AVParsers, this needs nofillin too", 0, FF_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_NOPARSE }, INT_MIN, INT_MAX, D, "fflags"},
51	{"igndts", "ignore dts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNDTS, INT_MIN, INT_MAX, D, "fflags"},	51	{"igndts", "ignore dts", 0, FF_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_IGNDTS }, INT_MIN, INT_MAX, D, "fflags"},
52	{"rtphint", "add rtp hinting", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_RTP_HINT, INT_MIN, INT_MAX, E, "fflags"},	52	{"rtphint", "add rtp hinting", 0, FF_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_RTP_HINT }, INT_MIN, INT_MAX, E, "fflags"},
53	{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 5*AV_TIME_BASE, 0, INT_MAX, D},	53	{"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, {.i64 = 5*AV_TIME_BASE }, 0, INT_MAX, D},
54	{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, 0, 0, 0, D},	54	{"cryptokey", "decryption key", OFFSET(key), FF_OPT_TYPE_BINARY, {.i64 = 0}, 0, 0, D},
55	{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, 1<<20, 0, INT_MAX, D},	55	{"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), FF_OPT_TYPE_INT, {.i64 = 1<<20 }, 0, INT_MAX, D},
56	{"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, 3041280, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */	56	{"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), FF_OPT_TYPE_INT, {.i64 = 3041280 }, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
57	{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, DEFAULT, 0, INT_MAX, E\|D, "fdebug"},	57	{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, INT_MAX, E\|D, "fdebug"},
58	{"ts", NULL, 0, FF_OPT_TYPE_CONST, FF_FDEBUG_TS, INT_MIN, INT_MAX, E\|D, "fdebug"},	58	{"ts", NULL, 0, FF_OPT_TYPE_CONST, {.i64 = FF_FDEBUG_TS }, INT_MIN, INT_MAX, E\|D, "fdebug"},
59	{"max_delay", "maximum muxing or demuxing delay in microseconds", OFFSET(max_delay), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E\|D},	59	{"max_delay", "maximum muxing or demuxing delay in microseconds", OFFSET(max_delay), FF_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, INT_MAX, E\|D},
60	{NULL},	60	{NULL},
61	};	61	};
62		62

@@ -34,40 +34,40 @@ static const char * sws_context_to_name(void * ptr) · 33 unmodified lines
34	#define VE AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM	34	#define VE AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM
35		35
36	static const AVOption options[] = {	36	static const AVOption options[] = {
37	{ "sws_flags", "scaler/cpu flags", OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, 0, UINT_MAX, VE, "sws_flags" },	37	{ "sws_flags", "scaler/cpu flags", OFFSET(flags), FF_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, UINT_MAX, VE, "sws_flags" },
38	{ "fast_bilinear", "fast bilinear", 0, FF_OPT_TYPE_CONST, SWS_FAST_BILINEAR, INT_MIN, INT_MAX, VE, "sws_flags" },	38	{ "fast_bilinear", "fast bilinear", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_FAST_BILINEAR }, INT_MIN, INT_MAX, VE, "sws_flags" },
39	{ "bilinear", "bilinear", 0, FF_OPT_TYPE_CONST, SWS_BILINEAR, INT_MIN, INT_MAX, VE, "sws_flags" },	39	{ "bilinear", "bilinear", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_BILINEAR }, INT_MIN, INT_MAX, VE, "sws_flags" },
40	{ "bicubic", "bicubic", 0, FF_OPT_TYPE_CONST, SWS_BICUBIC, INT_MIN, INT_MAX, VE, "sws_flags" },	40	{ "bicubic", "bicubic", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_BICUBIC }, INT_MIN, INT_MAX, VE, "sws_flags" },
41	{ "experimental", "experimental", 0, FF_OPT_TYPE_CONST, SWS_X, INT_MIN, INT_MAX, VE, "sws_flags" },	41	{ "experimental", "experimental", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_X }, INT_MIN, INT_MAX, VE, "sws_flags" },
42	{ "neighbor", "nearest neighbor", 0, FF_OPT_TYPE_CONST, SWS_POINT, INT_MIN, INT_MAX, VE, "sws_flags" },	42	{ "neighbor", "nearest neighbor", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_POINT }, INT_MIN, INT_MAX, VE, "sws_flags" },
43	{ "area", "averaging area", 0, FF_OPT_TYPE_CONST, SWS_AREA, INT_MIN, INT_MAX, VE, "sws_flags" },	43	{ "area", "averaging area", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_AREA }, INT_MIN, INT_MAX, VE, "sws_flags" },
44	{ "bicublin", "luma bicubic, chroma bilinear", 0, FF_OPT_TYPE_CONST, SWS_BICUBLIN, INT_MIN, INT_MAX, VE, "sws_flags" },	44	{ "bicublin", "luma bicubic, chroma bilinear", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_BICUBLIN }, INT_MIN, INT_MAX, VE, "sws_flags" },
45	{ "gauss", "gaussian", 0, FF_OPT_TYPE_CONST, SWS_GAUSS, INT_MIN, INT_MAX, VE, "sws_flags" },	45	{ "gauss", "gaussian", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_GAUSS }, INT_MIN, INT_MAX, VE, "sws_flags" },
46	{ "sinc", "sinc", 0, FF_OPT_TYPE_CONST, SWS_SINC, INT_MIN, INT_MAX, VE, "sws_flags" },	46	{ "sinc", "sinc", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_SINC }, INT_MIN, INT_MAX, VE, "sws_flags" },
47	{ "lanczos", "lanczos", 0, FF_OPT_TYPE_CONST, SWS_LANCZOS, INT_MIN, INT_MAX, VE, "sws_flags" },	47	{ "lanczos", "lanczos", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_LANCZOS }, INT_MIN, INT_MAX, VE, "sws_flags" },
48	{ "spline", "natural bicubic spline", 0, FF_OPT_TYPE_CONST, SWS_SPLINE, INT_MIN, INT_MAX, VE, "sws_flags" },	48	{ "spline", "natural bicubic spline", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_SPLINE }, INT_MIN, INT_MAX, VE, "sws_flags" },
49	{ "print_info", "print info", 0, FF_OPT_TYPE_CONST, SWS_PRINT_INFO, INT_MIN, INT_MAX, VE, "sws_flags" },	49	{ "print_info", "print info", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_PRINT_INFO }, INT_MIN, INT_MAX, VE, "sws_flags" },
50	{ "accurate_rnd", "accurate rounding", 0, FF_OPT_TYPE_CONST, SWS_ACCURATE_RND, INT_MIN, INT_MAX, VE, "sws_flags" },	50	{ "accurate_rnd", "accurate rounding", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_ACCURATE_RND }, INT_MIN, INT_MAX, VE, "sws_flags" },
51	{ "mmx", "MMX SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_MMX, INT_MIN, INT_MAX, VE, "sws_flags" },	51	{ "mmx", "MMX SIMD acceleration", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_CPU_CAPS_MMX }, INT_MIN, INT_MAX, VE, "sws_flags" },
52	{ "mmx2", "MMX2 SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_MMX2, INT_MIN, INT_MAX, VE, "sws_flags" },	52	{ "mmx2", "MMX2 SIMD acceleration", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_CPU_CAPS_MMX2 }, INT_MIN, INT_MAX, VE, "sws_flags" },
53	{ "sse2", "SSE2 SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_SSE2, INT_MIN, INT_MAX, VE, "sws_flags" },	53	{ "sse2", "SSE2 SIMD acceleration", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_CPU_CAPS_SSE2 }, INT_MIN, INT_MAX, VE, "sws_flags" },
54	{ "3dnow", "3DNOW SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_3DNOW, INT_MIN, INT_MAX, VE, "sws_flags" },	54	{ "3dnow", "3DNOW SIMD acceleration", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_CPU_CAPS_3DNOW }, INT_MIN, INT_MAX, VE, "sws_flags" },
55	{ "altivec", "AltiVec SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_ALTIVEC, INT_MIN, INT_MAX, VE, "sws_flags" },	55	{ "altivec", "AltiVec SIMD acceleration", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_CPU_CAPS_ALTIVEC }, INT_MIN, INT_MAX, VE, "sws_flags" },
56	{ "bfin", "Blackfin SIMD acceleration", 0, FF_OPT_TYPE_CONST, SWS_CPU_CAPS_BFIN, INT_MIN, INT_MAX, VE, "sws_flags" },	56	{ "bfin", "Blackfin SIMD acceleration", 0, FF_OPT_TYPE_CONST, {.i64 = SWS_CPU_CAPS_BFIN }, INT_MIN, INT_MAX, VE, "sws_flags" },
57	{ "full_chroma_int", "full chroma interpolation", 0 , FF_OPT_TYPE_CONST, SWS_FULL_CHR_H_INT, INT_MIN, INT_MAX, VE, "sws_flags" },	57	{ "full_chroma_int", "full chroma interpolation", 0 , FF_OPT_TYPE_CONST, {.i64 = SWS_FULL_CHR_H_INT }, INT_MIN, INT_MAX, VE, "sws_flags" },
58	{ "full_chroma_inp", "full chroma input", 0 , FF_OPT_TYPE_CONST, SWS_FULL_CHR_H_INP, INT_MIN, INT_MAX, VE, "sws_flags" },	58	{ "full_chroma_inp", "full chroma input", 0 , FF_OPT_TYPE_CONST, {.i64 = SWS_FULL_CHR_H_INP }, INT_MIN, INT_MAX, VE, "sws_flags" },
59	{ "bitexact", "", 0 , FF_OPT_TYPE_CONST, SWS_BITEXACT, INT_MIN, INT_MAX, VE, "sws_flags" },	59	{ "bitexact", "", 0 , FF_OPT_TYPE_CONST, {.i64 = SWS_BITEXACT }, INT_MIN, INT_MAX, VE, "sws_flags" },
60		60
61	{ "srcw", "source width" , OFFSET(srcW), FF_OPT_TYPE_INT, 16, 1, INT_MAX, VE },	61	{ "srcw", "source width" , OFFSET(srcW), FF_OPT_TYPE_INT, {.i64 = 16 }, 1, INT_MAX, VE },
62	{ "srch", "source height" , OFFSET(srcH), FF_OPT_TYPE_INT, 16, 1, INT_MAX, VE },	62	{ "srch", "source height" , OFFSET(srcH), FF_OPT_TYPE_INT, {.i64 = 16 }, 1, INT_MAX, VE },
63	{ "dstw", "destination width" , OFFSET(dstW), FF_OPT_TYPE_INT, 16, 1, INT_MAX, VE },	63	{ "dstw", "destination width" , OFFSET(dstW), FF_OPT_TYPE_INT, {.i64 = 16 }, 1, INT_MAX, VE },
64	{ "dsth", "destination height", OFFSET(dstH), FF_OPT_TYPE_INT, 16, 1, INT_MAX, VE },	64	{ "dsth", "destination height", OFFSET(dstH), FF_OPT_TYPE_INT, {.i64 = 16 }, 1, INT_MAX, VE },
65	{ "src_format", "source format" , OFFSET(srcFormat), FF_OPT_TYPE_INT, DEFAULT, 0, PIX_FMT_NB-1, VE },	65	{ "src_format", "source format" , OFFSET(srcFormat), FF_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, PIX_FMT_NB-1, VE },
66	{ "dst_format", "destination format", OFFSET(dstFormat), FF_OPT_TYPE_INT, DEFAULT, 0, PIX_FMT_NB-1, VE },	66	{ "dst_format", "destination format", OFFSET(dstFormat), FF_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, PIX_FMT_NB-1, VE },
67	{ "src_range" , "source range" , OFFSET(srcRange) , FF_OPT_TYPE_INT, DEFAULT, 0, 1, VE },	67	{ "src_range" , "source range" , OFFSET(srcRange) , FF_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, 1, VE },
68	{ "dst_range" , "destination range" , OFFSET(dstRange) , FF_OPT_TYPE_INT, DEFAULT, 0, 1, VE },	68	{ "dst_range" , "destination range" , OFFSET(dstRange) , FF_OPT_TYPE_INT, {.i64 = DEFAULT }, 0, 1, VE },
69	{ "param0" , "scaler param 0" , OFFSET(param[0]) , FF_OPT_TYPE_DOUBLE, SWS_PARAM_DEFAULT, INT_MIN, INT_MAX, VE },	69	{ "param0" , "scaler param 0" , OFFSET(param[0]) , FF_OPT_TYPE_DOUBLE, {.dbl = SWS_PARAM_DEFAULT}, INT_MIN, INT_MAX, VE },
70	{ "param1" , "scaler param 1" , OFFSET(param[1]) , FF_OPT_TYPE_DOUBLE, SWS_PARAM_DEFAULT, INT_MIN, INT_MAX, VE },	70	{ "param1" , "scaler param 1" , OFFSET(param[1]) , FF_OPT_TYPE_DOUBLE, {.dbl = SWS_PARAM_DEFAULT}, INT_MIN, INT_MAX, VE },
71		71
72	{ NULL }	72	{ NULL }
73	};	73	};

@@ -49,394 +49,394 @@ static const char* context_to_name(void* ptr) { · 48 unmodified lines
49	#define AV_CODEC_DEFAULT_BITRATE 200*1000	49	#define AV_CODEC_DEFAULT_BITRATE 200*1000
50		50
51	static const AVOption options[]={	51	static const AVOption options[]={
52	{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), FF_OPT_TYPE_INT, AV_CODEC_DEFAULT_BITRATE, INT_MIN, INT_MAX, V\|E},	52	{"b", "set bitrate (in bits/s)", OFFSET(bit_rate), FF_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE }, INT_MIN, INT_MAX, V\|E},
53	{"ab", "set bitrate (in bits/s)", OFFSET(bit_rate), FF_OPT_TYPE_INT, 64*1000, INT_MIN, INT_MAX, A\|E},	53	{"ab", "set bitrate (in bits/s)", OFFSET(bit_rate), FF_OPT_TYPE_INT, {.i64 = 64*1000 }, INT_MIN, INT_MAX, A\|E},
54	{"bt", "set video bitrate tolerance (in bits/s)", OFFSET(bit_rate_tolerance), FF_OPT_TYPE_INT, AV_CODEC_DEFAULT_BITRATE*20, 1, INT_MAX, V\|E},	54	{"bt", "set video bitrate tolerance (in bits/s)", OFFSET(bit_rate_tolerance), FF_OPT_TYPE_INT, {.i64 = AV_CODEC_DEFAULT_BITRATE*20 }, 1, INT_MAX, V\|E},
55	{"flags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, 0, UINT_MAX, V\|A\|E\|D, "flags"},	55	{"flags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, {.i64 = DEFAULT }, 0, UINT_MAX, V\|A\|E\|D, "flags"},
56	{"mv4", "use four motion vector by macroblock (mpeg4)", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_4MV, INT_MIN, INT_MAX, V\|E, "flags"},	56	{"mv4", "use four motion vector by macroblock (mpeg4)", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_4MV }, INT_MIN, INT_MAX, V\|E, "flags"},
57	{"obmc", "use overlapped block motion compensation (h263+)", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_OBMC, INT_MIN, INT_MAX, V\|E, "flags"},	57	{"obmc", "use overlapped block motion compensation (h263+)", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_OBMC }, INT_MIN, INT_MAX, V\|E, "flags"},
58	{"qpel", "use 1/4 pel motion compensation", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_QPEL, INT_MIN, INT_MAX, V\|E, "flags"},	58	{"qpel", "use 1/4 pel motion compensation", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_QPEL }, INT_MIN, INT_MAX, V\|E, "flags"},
59	{"loop", "use loop filter", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_LOOP_FILTER, INT_MIN, INT_MAX, V\|E, "flags"},	59	{"loop", "use loop filter", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_LOOP_FILTER }, INT_MIN, INT_MAX, V\|E, "flags"},
60	{"qscale", "use fixed qscale", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_QSCALE, INT_MIN, INT_MAX, 0, "flags"},	60	{"qscale", "use fixed qscale", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_QSCALE }, INT_MIN, INT_MAX, 0, "flags"},
61	{"gmc", "use gmc", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_GMC, INT_MIN, INT_MAX, V\|E, "flags"},	61	{"gmc", "use gmc", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_GMC }, INT_MIN, INT_MAX, V\|E, "flags"},
62	{"mv0", "always try a mb with mv=<0,0>", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_MV0, INT_MIN, INT_MAX, V\|E, "flags"},	62	{"mv0", "always try a mb with mv=<0,0>", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_MV0 }, INT_MIN, INT_MAX, V\|E, "flags"},
63	{"part", "use data partitioning", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_PART, INT_MIN, INT_MAX, V\|E, "flags"},	63	{"part", "use data partitioning", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_PART }, INT_MIN, INT_MAX, V\|E, "flags"},
64	{"input_preserved", NULL, 0, FF_OPT_TYPE_CONST, CODEC_FLAG_INPUT_PRESERVED, INT_MIN, INT_MAX, 0, "flags"},	64	{"input_preserved", NULL, 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_INPUT_PRESERVED }, INT_MIN, INT_MAX, 0, "flags"},
65	{"pass1", "use internal 2pass ratecontrol in first pass mode", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_PASS1, INT_MIN, INT_MAX, 0, "flags"},	65	{"pass1", "use internal 2pass ratecontrol in first pass mode", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_PASS1 }, INT_MIN, INT_MAX, 0, "flags"},
66	{"pass2", "use internal 2pass ratecontrol in second pass mode", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_PASS2, INT_MIN, INT_MAX, 0, "flags"},	66	{"pass2", "use internal 2pass ratecontrol in second pass mode", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_PASS2 }, INT_MIN, INT_MAX, 0, "flags"},
67	{"extern_huff", "use external huffman table (for mjpeg)", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_EXTERN_HUFF, INT_MIN, INT_MAX, 0, "flags"},	67	{"extern_huff", "use external huffman table (for mjpeg)", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_EXTERN_HUFF }, INT_MIN, INT_MAX, 0, "flags"},
68	{"gray", "only decode/encode grayscale", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_GRAY, INT_MIN, INT_MAX, V\|E\|D, "flags"},	68	{"gray", "only decode/encode grayscale", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_GRAY }, INT_MIN, INT_MAX, V\|E\|D, "flags"},
69	{"emu_edge", "don't draw edges", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_EMU_EDGE, INT_MIN, INT_MAX, 0, "flags"},	69	{"emu_edge", "don't draw edges", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_EMU_EDGE }, INT_MIN, INT_MAX, 0, "flags"},
70	{"psnr", "error[?] variables will be set during encoding", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_PSNR, INT_MIN, INT_MAX, V\|E, "flags"},	70	{"psnr", "error[?] variables will be set during encoding", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_PSNR }, INT_MIN, INT_MAX, V\|E, "flags"},
71	{"truncated", NULL, 0, FF_OPT_TYPE_CONST, CODEC_FLAG_TRUNCATED, INT_MIN, INT_MAX, 0, "flags"},	71	{"truncated", NULL, 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_TRUNCATED }, INT_MIN, INT_MAX, 0, "flags"},
72	{"naq", "normalize adaptive quantization", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_NORMALIZE_AQP, INT_MIN, INT_MAX, V\|E, "flags"},	72	{"naq", "normalize adaptive quantization", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_NORMALIZE_AQP }, INT_MIN, INT_MAX, V\|E, "flags"},
73	{"ildct", "use interlaced dct", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_INTERLACED_DCT, INT_MIN, INT_MAX, V\|E, "flags"},	73	{"ildct", "use interlaced dct", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_INTERLACED_DCT }, INT_MIN, INT_MAX, V\|E, "flags"},
74	{"low_delay", "force low delay", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_LOW_DELAY, INT_MIN, INT_MAX, V\|D\|E, "flags"},	74	{"low_delay", "force low delay", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_LOW_DELAY }, INT_MIN, INT_MAX, V\|D\|E, "flags"},
75	{"alt", "enable alternate scantable (mpeg2/mpeg4)", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_ALT_SCAN, INT_MIN, INT_MAX, V\|E, "flags"},	75	{"alt", "enable alternate scantable (mpeg2/mpeg4)", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_ALT_SCAN }, INT_MIN, INT_MAX, V\|E, "flags"},
76	{"global_header", "place global headers in extradata instead of every keyframe", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_GLOBAL_HEADER, INT_MIN, INT_MAX, V\|A\|E, "flags"},	76	{"global_header", "place global headers in extradata instead of every keyframe", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_GLOBAL_HEADER }, INT_MIN, INT_MAX, V\|A\|E, "flags"},
77	{"bitexact", "use only bitexact stuff (except (i)dct)", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_BITEXACT, INT_MIN, INT_MAX, A\|V\|S\|D\|E, "flags"},	77	{"bitexact", "use only bitexact stuff (except (i)dct)", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_BITEXACT }, INT_MIN, INT_MAX, A\|V\|S\|D\|E, "flags"},
78	{"aic", "h263 advanced intra coding / mpeg4 ac prediction", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_AC_PRED, INT_MIN, INT_MAX, V\|E, "flags"},	78	{"aic", "h263 advanced intra coding / mpeg4 ac prediction", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_AC_PRED }, INT_MIN, INT_MAX, V\|E, "flags"},
79	{"umv", "use unlimited motion vectors", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_H263P_UMV, INT_MIN, INT_MAX, V\|E, "flags"},	79	{"umv", "use unlimited motion vectors", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_H263P_UMV }, INT_MIN, INT_MAX, V\|E, "flags"},
80	{"cbp", "use rate distortion optimization for cbp", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_CBP_RD, INT_MIN, INT_MAX, V\|E, "flags"},	80	{"cbp", "use rate distortion optimization for cbp", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_CBP_RD }, INT_MIN, INT_MAX, V\|E, "flags"},
81	{"qprd", "use rate distortion optimization for qp selection", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_QP_RD, INT_MIN, INT_MAX, V\|E, "flags"},	81	{"qprd", "use rate distortion optimization for qp selection", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_QP_RD }, INT_MIN, INT_MAX, V\|E, "flags"},
82	{"aiv", "h263 alternative inter vlc", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_H263P_AIV, INT_MIN, INT_MAX, V\|E, "flags"},	82	{"aiv", "h263 alternative inter vlc", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_H263P_AIV }, INT_MIN, INT_MAX, V\|E, "flags"},
83	{"slice", NULL, 0, FF_OPT_TYPE_CONST, CODEC_FLAG_H263P_SLICE_STRUCT, INT_MIN, INT_MAX, V\|E, "flags"},	83	{"slice", NULL, 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_H263P_SLICE_STRUCT }, INT_MIN, INT_MAX, V\|E, "flags"},
84	{"ilme", "interlaced motion estimation", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_INTERLACED_ME, INT_MIN, INT_MAX, V\|E, "flags"},	84	{"ilme", "interlaced motion estimation", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_INTERLACED_ME }, INT_MIN, INT_MAX, V\|E, "flags"},
85	{"scan_offset", "will reserve space for svcd scan offset user data", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_SVCD_SCAN_OFFSET, INT_MIN, INT_MAX, V\|E, "flags"},	85	{"scan_offset", "will reserve space for svcd scan offset user data", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_SVCD_SCAN_OFFSET }, INT_MIN, INT_MAX, V\|E, "flags"},
86	{"cgop", "closed gop", 0, FF_OPT_TYPE_CONST, CODEC_FLAG_CLOSED_GOP, INT_MIN, INT_MAX, V\|E, "flags"},	86	{"cgop", "closed gop", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_CLOSED_GOP }, INT_MIN, INT_MAX, V\|E, "flags"},
87	{"fast", "allow non spec compliant speedup tricks", 0, FF_OPT_TYPE_CONST, CODEC_FLAG2_FAST, INT_MIN, INT_MAX, V\|E, "flags2"},	87	{"fast", "allow non spec compliant speedup tricks", 0, FF_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_FAST }, INT_MIN, INT_MAX, V\|E, "flags2"},