/root/firefox-clang/media/ffvpx/libavutil/opt.c

Bug Summary

File:	root/firefox-clang/media/ffvpx/libavutil/opt.c
Warning:	line 421, column 13 Value stored to 'ret' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name opt.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/media/ffvpx/libavutil -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/media/ffvpx/libavutil -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -include libavutil_visibility.h -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D HAVE_AV_CONFIG_H -D ASSERT_LEVEL=2 -I /root/firefox-clang/media/ffvpx/libavutil -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/media/ffvpx/libavutil -I /root/firefox-clang/third_party/khronos/vulkan-headers/include -I /root/firefox-clang/media/mozva -I /root/firefox-clang/media/ffvpx -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=tautological-type-limit-compare -Wno-range-loop-analysis -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-unknown-warning-option -Wno-character-conversion -Wno-parentheses -Wno-pointer-sign -Wno-sign-compare -Wno-switch -Wno-type-limits -Wno-unused-function -Wno-deprecated-declarations -Wno-absolute-value -Wno-incompatible-pointer-types -Wno-string-conversion -Wno-visibility -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-09-01-224014-2642839-1 -x c /root/firefox-clang/media/ffvpx/libavutil/opt.c

1	/*
2	* AVOptions
3	* Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
4	*
5	* This file is part of FFmpeg.
6	*
7	* FFmpeg is free software; you can redistribute it and/or
8	* modify it under the terms of the GNU Lesser General Public
9	* License as published by the Free Software Foundation; either
10	* version 2.1 of the License, or (at your option) any later version.
11	*
12	* FFmpeg is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15	* Lesser General Public License for more details.
16	*
17	* You should have received a copy of the GNU Lesser General Public
18	* License along with FFmpeg; if not, write to the Free Software
19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20	*/
21
22	/**
23	* @file
24	* AVOptions
25	* @author Michael Niedermayer <michaelni@gmx.at>
26	*/
27
28	#include "avutil.h"
29	#include "avassert.h"
30	#include "avstring.h"
31	#include "channel_layout.h"
32	#include "dict.h"
33	#include "eval.h"
34	#include "log.h"
35	#include "mem.h"
36	#include "parseutils.h"
37	#include "pixdesc.h"
38	#include "mathematics.h"
39	#include "opt.h"
40	#include "samplefmt.h"
41	#include "bprint.h"
42	#include "version.h"
43
44	#include <float.h>
45
46	#define TYPE_BASE(type)((type) & ~AV_OPT_TYPE_FLAG_ARRAY) ((type) & ~AV_OPT_TYPE_FLAG_ARRAY)
47
48	const AVOption av_opt_next(const void obj, const AVOption *last)
49	{
50	const AVClass *class;
51	if (!obj)
52	return NULL((void*)0);
53	class = (const AVClass*)obj;
54	if (!last && class && class->option && class->option[0].name)
55	return class->option;
56	if (last && last[1].name)
57	return ++last;
58	return NULL((void*)0);
59	}
60
61	static const struct {
62	size_t size;
63	const char *name;
64	} opt_type_desc[] = {
65	[AV_OPT_TYPE_FLAGS] = { sizeof(unsigned), "<flags>" },
66	[AV_OPT_TYPE_INT] = { sizeof(int), "<int>" },
67	[AV_OPT_TYPE_INT64] = { sizeof(int64_t), "<int64>" },
68	[AV_OPT_TYPE_UINT] = { sizeof(unsigned), "<unsigned>" },
69	[AV_OPT_TYPE_UINT64] = { sizeof(uint64_t), "<uint64>" },
70	[AV_OPT_TYPE_DOUBLE] = { sizeof(double), "<double>" },
71	[AV_OPT_TYPE_FLOAT] = { sizeof(float), "<float>" },
72	[AV_OPT_TYPE_STRING] = { sizeof(char *), "<string>" },
73	[AV_OPT_TYPE_RATIONAL] = { sizeof(AVRational), "<rational>" },
74	[AV_OPT_TYPE_BINARY] = { sizeof(uint8_t *), "<binary>" },
75	[AV_OPT_TYPE_DICT] = { sizeof(AVDictionary *), "<dictionary>" },
76	[AV_OPT_TYPE_IMAGE_SIZE] = { sizeof(int[2]), "<image_size>" },
77	[AV_OPT_TYPE_VIDEO_RATE] = { sizeof(AVRational), "<video_rate>" },
78	[AV_OPT_TYPE_PIXEL_FMT] = { sizeof(int), "<pix_fmt>" },
79	[AV_OPT_TYPE_SAMPLE_FMT] = { sizeof(int), "<sample_fmt>" },
80	[AV_OPT_TYPE_DURATION] = { sizeof(int64_t), "<duration>" },
81	[AV_OPT_TYPE_COLOR] = { sizeof(uint8_t[4]), "<color>" },
82	[AV_OPT_TYPE_CHLAYOUT] = { sizeof(AVChannelLayout),"<channel_layout>" },
83	[AV_OPT_TYPE_BOOL] = { sizeof(int), "<boolean>" },
84	};
85
86	// option is plain old data
87	static int opt_is_pod(enum AVOptionType type)
88	{
89	switch (type) {
90	case AV_OPT_TYPE_FLAGS:
91	case AV_OPT_TYPE_INT:
92	case AV_OPT_TYPE_INT64:
93	case AV_OPT_TYPE_DOUBLE:
94	case AV_OPT_TYPE_FLOAT:
95	case AV_OPT_TYPE_RATIONAL:
96	case AV_OPT_TYPE_UINT64:
97	case AV_OPT_TYPE_IMAGE_SIZE:
98	case AV_OPT_TYPE_PIXEL_FMT:
99	case AV_OPT_TYPE_SAMPLE_FMT:
100	case AV_OPT_TYPE_VIDEO_RATE:
101	case AV_OPT_TYPE_DURATION:
102	case AV_OPT_TYPE_COLOR:
103	case AV_OPT_TYPE_BOOL:
104	case AV_OPT_TYPE_UINT:
105	return 1;
106	}
107	return 0;
108	}
109
110	static uint8_t opt_array_sep(const AVOption *o)
111	{
112	const AVOptionArrayDef *d = o->default_val.arr;
113	av_assert1(o->type & AV_OPT_TYPE_FLAG_ARRAY)do { if (!(o->type & AV_OPT_TYPE_FLAG_ARRAY)) { av_log (((void*)0), 0, "Assertion %s failed at %s:%d\n", "o->type & AV_OPT_TYPE_FLAG_ARRAY" , "/root/firefox-clang/media/ffvpx/libavutil/opt.c", 113); abort (); } } while (0);
114	return (d && d->sep) ? d->sep : ',';
115	}
116
117	static void opt_array_pelem(const AVOption o, void *array, unsigned idx)
118	{
119	av_assert1(o->type & AV_OPT_TYPE_FLAG_ARRAY)do { if (!(o->type & AV_OPT_TYPE_FLAG_ARRAY)) { av_log (((void*)0), 0, "Assertion %s failed at %s:%d\n", "o->type & AV_OPT_TYPE_FLAG_ARRAY" , "/root/firefox-clang/media/ffvpx/libavutil/opt.c", 119); abort (); } } while (0);
120	return (uint8_t )array + idx opt_type_desc[TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY)].size;
121	}
122
123	static unsigned opt_array_pcount(const void parray)
124	{
125	return (unsigned )((const void const *)parray + 1);
126	}
127
128	static void opt_free_elem(enum AVOptionType type, void *ptr)
129	{
130	switch (TYPE_BASE(type)((type) & ~AV_OPT_TYPE_FLAG_ARRAY)) {
131	case AV_OPT_TYPE_STRING:
132	case AV_OPT_TYPE_BINARY:
133	av_freep(ptr);
134	break;
135
136	case AV_OPT_TYPE_DICT:
137	av_dict_free((AVDictionary **)ptr);
138	break;
139
140	case AV_OPT_TYPE_CHLAYOUT:
141	av_channel_layout_uninit((AVChannelLayout *)ptr);
142	break;
143
144	default:
145	break;
146	}
147	}
148
149	static void opt_free_array(const AVOption o, void parray, unsigned *count)
150	{
151	for (unsigned i = 0; i < *count; i++)
152	opt_free_elem(o->type, opt_array_pelem(o, (void *)parray, i));
153
154	av_freep(parray);
155	*count = 0;
156	}
157
158	/**
159	* Perform common setup for option-setting functions.
160	*
161	* @param require_type when non-0, require the option to be of this type
162	* @param ptgt target object is written here
163	* @param po the option is written here
164	* @param pdst pointer to option value is written here
165	*/
166	static int opt_set_init(void obj, const char name, int search_flags,
167	int require_type,
168	void ptgt, const AVOption po, void **pdst)
169	{
170	const AVOption *o;
171	void *tgt;
172
173	o = av_opt_find2(obj, name, NULL((void*)0), 0, search_flags, &tgt);
174	if (!o \|\| !tgt)
175	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
176
177	if (o->flags & AV_OPT_FLAG_READONLY(1 << 7))
178	return AVERROR(EINVAL)(-(22));
179
180	if (require_type && (o->type != require_type)) {
181	av_log(obj, AV_LOG_ERROR16,
182	"Tried to set option '%s' of type %s from value of type %s, "
183	"this is not supported\n", o->name, opt_type_desc[o->type].name,
184	opt_type_desc[require_type].name);
185	return AVERROR(EINVAL)(-(22));
186	}
187
188	if (!(o->flags & AV_OPT_FLAG_RUNTIME_PARAM(1 << 15))) {
189	unsigned state_flags = NULL((void)0);
190	const AVClass *class;
191
192	// try state flags first from the target (child), then from its parent
193	class = (const AVClass*)tgt;
194	if (class->state_flags_offset)
195	state_flags = (unsigned)((uint8_t)tgt + class->state_flags_offset);
196
197	if (!state_flags && obj != tgt) {
198	class = (const AVClass*)obj;
199	if (class->state_flags_offset)
200	state_flags = (unsigned)((uint8_t)obj + class->state_flags_offset);
201	}
202
203	if (state_flags && (*state_flags & AV_CLASS_STATE_INITIALIZED)) {
204	av_log(obj, AV_LOG_ERROR16, "Option '%s' is not a runtime option and "
205	"so cannot be set after the object has been initialized\n",
206	o->name);
207	return AVERROR(EINVAL)(-(22));
208	}
209	}
210
211	if (o->flags & AV_OPT_FLAG_DEPRECATED(1 << 17))
212	av_log(obj, AV_LOG_WARNING24, "The \"%s\" option is deprecated: %s\n", name, o->help);
213
214	if (po)
215	*po = o;
216	if (ptgt)
217	*ptgt = tgt;
218	if (pdst)
219	pdst = ((uint8_t )tgt) + o->offset;
220
221	return 0;
222	}
223
224	static AVRational double_to_rational(double d)
225	{
226	AVRational r = av_d2q(d, 1 << 24);
227	if ((!r.num \|\| !r.den) && d)
228	r = av_d2q(d, INT_MAX2147483647);
229	return r;
230	}
231
232	static int read_number(const AVOption o, const void dst, double num, int den, int64_t *intnum)
233	{
234	switch (TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY)) {
235	case AV_OPT_TYPE_FLAGS:
236	intnum = (unsigned int*)dst;
237	return 0;
238	case AV_OPT_TYPE_PIXEL_FMT:
239	intnum = (enum AVPixelFormat *)dst;
240	return 0;
241	case AV_OPT_TYPE_SAMPLE_FMT:
242	intnum = (enum AVSampleFormat *)dst;
243	return 0;
244	case AV_OPT_TYPE_BOOL:
245	case AV_OPT_TYPE_INT:
246	intnum = (int *)dst;
247	return 0;
248	case AV_OPT_TYPE_UINT:
249	intnum = (unsigned int *)dst;
250	return 0;
251	case AV_OPT_TYPE_DURATION:
252	case AV_OPT_TYPE_INT64:
253	case AV_OPT_TYPE_UINT64:
254	intnum = (int64_t *)dst;
255	return 0;
256	case AV_OPT_TYPE_FLOAT:
257	num = (float *)dst;
258	return 0;
259	case AV_OPT_TYPE_DOUBLE:
260	num = (double *)dst;
261	return 0;
262	case AV_OPT_TYPE_RATIONAL:
263	intnum = ((AVRational )dst)->num;
264	den = ((AVRational )dst)->den;
265	return 0;
266	case AV_OPT_TYPE_CONST:
267	*intnum = o->default_val.i64;
268	return 0;
269	}
270	return AVERROR(EINVAL)(-(22));
271	}
272
273	static int write_number(void obj, const AVOption o, void *dst, double num, int den, int64_t intnum)
274	{
275	const enum AVOptionType type = TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY);
276
277	if (type != AV_OPT_TYPE_FLAGS &&
278	(!den \|\| o->max * den < num * intnum \|\| o->min * den > num * intnum)) {
279	num = den ? num * intnum / den : (num && intnum ? INFINITY(__builtin_inff()) : NAN(__builtin_nanf("")));
280	av_log(obj, AV_LOG_ERROR16, "Value %f for parameter '%s' out of range [%g - %g]\n",
281	num, o->name, o->min, o->max);
282	return AVERROR(ERANGE)(-(34));
283	}
284	if (type == AV_OPT_TYPE_FLAGS) {
285	double d = num*intnum/den;
286	if (d < -1.5 \|\| d > 0xFFFFFFFF+0.5 \|\| (llrint(d*256) & 255)) {
287	av_log(obj, AV_LOG_ERROR16,
288	"Value %f for parameter '%s' is not a valid set of 32bit integer flags\n",
289	num*intnum/den, o->name);
290	return AVERROR(ERANGE)(-(34));
291	}
292	}
293
294	switch (type) {
295	case AV_OPT_TYPE_PIXEL_FMT:
296	(enum AVPixelFormat )dst = llrint(num / den) * intnum;
297	break;
298	case AV_OPT_TYPE_SAMPLE_FMT:
299	(enum AVSampleFormat )dst = llrint(num / den) * intnum;
300	break;
301	case AV_OPT_TYPE_BOOL:
302	case AV_OPT_TYPE_FLAGS:
303	case AV_OPT_TYPE_INT:
304	case AV_OPT_TYPE_UINT:
305	(int )dst = llrint(num / den) * intnum;
306	break;
307	case AV_OPT_TYPE_DURATION:
308	case AV_OPT_TYPE_INT64:{
309	double d = num / den;
310	if (intnum == 1 && d == (double)INT64_MAX(9223372036854775807L)) {
311	(int64_t )dst = INT64_MAX(9223372036854775807L);
312	} else
313	(int64_t )dst = llrint(d) * intnum;
314	break;}
315	case AV_OPT_TYPE_UINT64:{
316	double d = num / den;
317	// We must special case uint64_t here as llrint() does not support values
318	// outside the int64_t range and there is no portable function which does
319	// "INT64_MAX + 1ULL" is used as it is representable exactly as IEEE double
320	// while INT64_MAX is not
321	if (intnum == 1 && d == (double)UINT64_MAX(18446744073709551615UL)) {
322	(uint64_t )dst = UINT64_MAX(18446744073709551615UL);
323	} else if (d > INT64_MAX(9223372036854775807L) + 1ULL) {
324	(uint64_t )dst = (llrint(d - (INT64_MAX(9223372036854775807L) + 1ULL)) + (INT64_MAX(9223372036854775807L) + 1ULL))*intnum;
325	} else {
326	(uint64_t )dst = llrint(d) * intnum;
327	}
328	break;}
329	case AV_OPT_TYPE_FLOAT:
330	(float )dst = num * intnum / den;
331	break;
332	case AV_OPT_TYPE_DOUBLE:
333	(double )dst = num * intnum / den;
334	break;
335	case AV_OPT_TYPE_RATIONAL:
336	case AV_OPT_TYPE_VIDEO_RATE:
337	if ((int) num == num)
338	(AVRational )dst = (AVRational) { num *intnum, den };
339	else
340	(AVRational )dst = double_to_rational(num * intnum / den);
341	break;
342	default:
343	return AVERROR(EINVAL)(-(22));
344	}
345	return 0;
346	}
347
348	static int hexchar2int(char c) {
349	if (c >= '0' && c <= '9')
350	return c - '0';
351	if (c >= 'a' && c <= 'f')
352	return c - 'a' + 10;
353	if (c >= 'A' && c <= 'F')
354	return c - 'A' + 10;
355	return -1;
356	}
357
358	static int set_string_binary(void obj, const AVOption o, const char val, uint8_t *dst)
359	{
360	int lendst = (int )(dst + 1);
361	uint8_t bin, ptr;
362	int len;
363
364	av_freep(dst);
365	*lendst = 0;
366
367	if (!val \|\| !(len = strlen(val)))
368	return 0;
369
370	if (len & 1)
371	return AVERROR(EINVAL)(-(22));
372	len /= 2;
373
374	ptr = bin = av_malloc(len);
375	if (!ptr)
376	return AVERROR(ENOMEM)(-(12));
377	while (*val) {
378	int a = hexchar2int(*val++);
379	int b = hexchar2int(*val++);
380	if (a < 0 \|\| b < 0) {
381	av_free(bin);
382	return AVERROR(EINVAL)(-(22));
383	}
384	*ptr++ = (a << 4) \| b;
385	}
386	*dst = bin;
387	*lendst = len;
388
389	return 0;
390	}
391
392	static int set_string(void obj, const AVOption o, const char val, uint8_t *dst)
393	{
394	av_freep(dst);
395	if (!val)
396	return 0;
397	*dst = av_strdup(val);
398	return *dst ? 0 : AVERROR(ENOMEM)(-(12));
399	}
400
401	#define DEFAULT_NUMVAL(opt)((opt->type == AV_OPT_TYPE_INT64 \|\| opt->type == AV_OPT_TYPE_UINT64 \|\| opt->type == AV_OPT_TYPE_CONST \|\| opt->type == AV_OPT_TYPE_FLAGS \|\| opt->type == AV_OPT_TYPE_UINT \|\| opt->type == AV_OPT_TYPE_INT ) ? opt->default_val.i64 : opt->default_val.dbl) ((opt->type == AV_OPT_TYPE_INT64 \|\| \
402	opt->type == AV_OPT_TYPE_UINT64 \|\| \
403	opt->type == AV_OPT_TYPE_CONST \|\| \
404	opt->type == AV_OPT_TYPE_FLAGS \|\| \
405	opt->type == AV_OPT_TYPE_UINT \|\| \
406	opt->type == AV_OPT_TYPE_INT) \
407	? opt->default_val.i64 \
408	: opt->default_val.dbl)
409
410	static int set_string_number(void obj, void target_obj, const AVOption o, const char val, void *dst)
411	{
412	const enum AVOptionType type = TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY);
413	int ret = 0;
414
415	if (type == AV_OPT_TYPE_RATIONAL \|\| type == AV_OPT_TYPE_VIDEO_RATE) {
416	int num, den;
417	char c;
418	if (sscanf(val, "%d%*1[:/]%d%c", &num, &den, &c) == 2) {
419	if ((ret = write_number(obj, o, dst, 1, den, num)) >= 0)
420	return ret;
421	ret = 0;
	Value stored to 'ret' is never read
422	}
423	}
424
425	for (;;) {
426	int i = 0;
427	char buf[256];
428	int cmd = 0;
429	double d;
430	int64_t intnum = 1;
431
432	if (type == AV_OPT_TYPE_FLAGS) {
433	if (val == '+' \|\| val == '-')
434	cmd = *(val++);
435	for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
436	buf[i] = val[i];
437	buf[i] = 0;
438	}
439
440	{
441	int res;
442	int ci = 0;
443	double const_values[64];
444	const char * const_names[64];
445	int search_flags = (o->flags & AV_OPT_FLAG_CHILD_CONSTS(1 << 18)) ? AV_OPT_SEARCH_CHILDREN(1 << 0) : 0;
446	const AVOption *o_named = av_opt_find(target_obj, i ? buf : val, o->unit, 0, search_flags);
447	if (o_named && o_named->type == AV_OPT_TYPE_CONST) {
448	d = DEFAULT_NUMVAL(o_named)((o_named->type == AV_OPT_TYPE_INT64 \|\| o_named->type == AV_OPT_TYPE_UINT64 \|\| o_named->type == AV_OPT_TYPE_CONST \|\| o_named->type == AV_OPT_TYPE_FLAGS \|\| o_named->type == AV_OPT_TYPE_UINT \|\| o_named->type == AV_OPT_TYPE_INT) ? o_named ->default_val.i64 : o_named->default_val.dbl);
449	if (o_named->flags & AV_OPT_FLAG_DEPRECATED(1 << 17))
450	av_log(obj, AV_LOG_WARNING24, "The \"%s\" option is deprecated: %s\n",
451	o_named->name, o_named->help);
452	} else {
453	if (o->unit) {
454	for (o_named = NULL((void*)0); o_named = av_opt_next(target_obj, o_named); ) {
455	if (o_named->type == AV_OPT_TYPE_CONST &&
456	o_named->unit &&
457	!strcmp(o_named->unit, o->unit)) {
458	if (ci + 6 >= FF_ARRAY_ELEMS(const_values)(sizeof(const_values) / sizeof((const_values)[0]))) {
459	av_log(obj, AV_LOG_ERROR16, "const_values array too small for %s\n", o->unit);
460	return AVERROR_PATCHWELCOME(-(int)(('P') \| (('A') << 8) \| (('W') << 16) \| (( unsigned)('E') << 24)));
461	}
462	const_names [ci ] = o_named->name;
463	const_values[ci++] = DEFAULT_NUMVAL(o_named)((o_named->type == AV_OPT_TYPE_INT64 \|\| o_named->type == AV_OPT_TYPE_UINT64 \|\| o_named->type == AV_OPT_TYPE_CONST \|\| o_named->type == AV_OPT_TYPE_FLAGS \|\| o_named->type == AV_OPT_TYPE_UINT \|\| o_named->type == AV_OPT_TYPE_INT) ? o_named ->default_val.i64 : o_named->default_val.dbl);
464	}
465	}
466	}
467	const_names [ci ] = "default";
468	const_values[ci++] = DEFAULT_NUMVAL(o)((o->type == AV_OPT_TYPE_INT64 \|\| o->type == AV_OPT_TYPE_UINT64 \|\| o->type == AV_OPT_TYPE_CONST \|\| o->type == AV_OPT_TYPE_FLAGS \|\| o->type == AV_OPT_TYPE_UINT \|\| o->type == AV_OPT_TYPE_INT ) ? o->default_val.i64 : o->default_val.dbl);
469	const_names [ci ] = "max";
470	const_values[ci++] = o->max;
471	const_names [ci ] = "min";
472	const_values[ci++] = o->min;
473	const_names [ci ] = "none";
474	const_values[ci++] = 0;
475	const_names [ci ] = "all";
476	const_values[ci++] = ~0;
477	const_names [ci] = NULL((void*)0);
478	const_values[ci] = 0;
479
480	res = av_expr_parse_and_eval(&d, i ? buf : val, const_names,
481	const_values, NULL((void)0), NULL((void)0), NULL((void)0), NULL((void)0), NULL((void*)0), 0, obj);
482	if (res < 0) {
483	av_log(obj, AV_LOG_ERROR16, "Unable to parse \"%s\" option value \"%s\"\n", o->name, val);
484	return res;
485	}
486	}
487	}
488	if (type == AV_OPT_TYPE_FLAGS) {
489	intnum = (unsigned int)dst;
490	if (cmd == '+')
491	d = intnum \| (int64_t)d;
492	else if (cmd == '-')
493	d = intnum &~(int64_t)d;
494	}
495
496	if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
497	return ret;
498	val += i;
499	if (!i \|\| !*val)
500	return 0;
501	}
502	}
503
504	static int set_string_image_size(void obj, const AVOption o, const char val, int dst)
505	{
506	int ret;
507
508	if (!val \|\| !strcmp(val, "none")) {
509	dst[0] =
510	dst[1] = 0;
511	return 0;
512	}
513	ret = av_parse_video_size(dst, dst + 1, val);
514	if (ret < 0)
515	av_log(obj, AV_LOG_ERROR16, "Unable to parse \"%s\" option value \"%s\" as image size\n", o->name, val);
516	return ret;
517	}
518
519	static int set_string_video_rate(void obj, const AVOption o, const char val, AVRational dst)
520	{
521	int ret = av_parse_video_rate(dst, val);
522	if (ret < 0)
523	av_log(obj, AV_LOG_ERROR16, "Unable to parse \"%s\" option value \"%s\" as video rate\n", o->name, val);
524	return ret;
525	}
526
527	static int set_string_color(void obj, const AVOption o, const char val, uint8_t dst)
528	{
529	int ret;
530
531	if (!val) {
532	return 0;
533	} else {
534	ret = av_parse_color(dst, val, -1, obj);
535	if (ret < 0)
536	av_log(obj, AV_LOG_ERROR16, "Unable to parse \"%s\" option value \"%s\" as color\n", o->name, val);
537	return ret;
538	}
539	return 0;
540	}
541
542	static const char *get_bool_name(int val)
543	{
544	if (val < 0)
545	return "auto";
546	return val ? "true" : "false";
547	}
548
549	static int set_string_bool(void obj, const AVOption o, const char val, int dst)
550	{
551	int n;
552
553	if (!val)
554	return 0;
555
556	if (!strcmp(val, "auto")) {
557	n = -1;
558	} else if (av_match_name(val, "true,y,yes,enable,enabled,on")) {
559	n = 1;
560	} else if (av_match_name(val, "false,n,no,disable,disabled,off")) {
561	n = 0;
562	} else {
563	char end = NULL((void)0);
564	n = strtol(val, &end, 10);
565	if (val + strlen(val) != end)
566	goto fail;
567	}
568
569	if (n < o->min \|\| n > o->max)
570	goto fail;
571
572	*dst = n;
573	return 0;
574
575	fail:
576	av_log(obj, AV_LOG_ERROR16, "Unable to parse \"%s\" option value \"%s\" as boolean\n", o->name, val);
577	return AVERROR(EINVAL)(-(22));
578	}
579
580	static int set_string_fmt(void obj, const AVOption o, const char val, uint8_t dst,
581	int fmt_nb, int ((get_fmt)(const char )), const char *desc)
582	{
583	int fmt, min, max;
584
585	if (!val \|\| !strcmp(val, "none")) {
586	fmt = -1;
587	} else {
588	fmt = get_fmt(val);
589	if (fmt == -1) {
590	char *tail;
591	fmt = strtol(val, &tail, 0);
592	if (*tail \|\| (unsigned)fmt >= fmt_nb) {
593	av_log(obj, AV_LOG_ERROR16,
594	"Unable to parse \"%s\" option value \"%s\" as %s\n", o->name, val, desc);
595	return AVERROR(EINVAL)(-(22));
596	}
597	}
598	}
599
600	min = FFMAX(o->min, -1)((o->min) > (-1) ? (o->min) : (-1));
601	max = FFMIN(o->max, fmt_nb-1)((o->max) > (fmt_nb-1) ? (fmt_nb-1) : (o->max));
602
603	// hack for compatibility with old ffmpeg
604	if(min == 0 && max == 0) {
605	min = -1;
606	max = fmt_nb-1;
607	}
608
609	if (fmt < min \|\| fmt > max) {
610	av_log(obj, AV_LOG_ERROR16,
611	"Value %d for parameter '%s' out of %s format range [%d - %d]\n",
612	fmt, o->name, desc, min, max);
613	return AVERROR(ERANGE)(-(34));
614	}
615
616	(int )dst = fmt;
617	return 0;
618	}
619
620	static int get_pix_fmt(const char *name)
621	{
622	return av_get_pix_fmt(name);
623	}
624
625	static int set_string_pixel_fmt(void obj, const AVOption o, const char val, uint8_t dst)
626	{
627	return set_string_fmt(obj, o, val, dst,
628	AV_PIX_FMT_NB, get_pix_fmt, "pixel format");
629	}
630
631	static int get_sample_fmt(const char *name)
632	{
633	return av_get_sample_fmt(name);
634	}
635
636	static int set_string_sample_fmt(void obj, const AVOption o, const char val, uint8_t dst)
637	{
638	return set_string_fmt(obj, o, val, dst,
639	AV_SAMPLE_FMT_NB, get_sample_fmt, "sample format");
640	}
641
642	static int set_string_dict(void obj, const AVOption o, const char val, uint8_t *dst)
643	{
644	AVDictionary options = NULL((void)0);
645
646	if (val) {
647	int ret = av_dict_parse_string(&options, val, "=", ":", 0);
648	if (ret < 0) {
649	av_dict_free(&options);
650	return ret;
651	}
652	}
653
654	av_dict_free((AVDictionary **)dst);
655	dst = (uint8_t )options;
656
657	return 0;
658	}
659
660	static int set_string_channel_layout(void obj, const AVOption o,
661	const char val, void dst)
662	{
663	AVChannelLayout *channel_layout = dst;
664	av_channel_layout_uninit(channel_layout);
665	if (!val)
666	return 0;
667	return av_channel_layout_from_string(channel_layout, val);
668	}
669
670	static int opt_set_elem(void obj, void target_obj, const AVOption *o,
671	const char val, void dst)
672	{
673	const enum AVOptionType type = TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY);
674	int ret;
675
676	if (!val && (type != AV_OPT_TYPE_STRING &&
677	type != AV_OPT_TYPE_PIXEL_FMT && type != AV_OPT_TYPE_SAMPLE_FMT &&
678	type != AV_OPT_TYPE_IMAGE_SIZE &&
679	type != AV_OPT_TYPE_DURATION && type != AV_OPT_TYPE_COLOR &&
680	type != AV_OPT_TYPE_BOOL))
681	return AVERROR(EINVAL)(-(22));
682
683	switch (type) {
684	case AV_OPT_TYPE_BOOL:
685	return set_string_bool(obj, o, val, dst);
686	case AV_OPT_TYPE_STRING:
687	return set_string(obj, o, val, dst);
688	case AV_OPT_TYPE_BINARY:
689	return set_string_binary(obj, o, val, dst);
690	case AV_OPT_TYPE_FLAGS:
691	case AV_OPT_TYPE_INT:
692	case AV_OPT_TYPE_UINT:
693	case AV_OPT_TYPE_INT64:
694	case AV_OPT_TYPE_UINT64:
695	case AV_OPT_TYPE_FLOAT:
696	case AV_OPT_TYPE_DOUBLE:
697	case AV_OPT_TYPE_RATIONAL:
698	return set_string_number(obj, target_obj, o, val, dst);
699	case AV_OPT_TYPE_IMAGE_SIZE:
700	return set_string_image_size(obj, o, val, dst);
701	case AV_OPT_TYPE_VIDEO_RATE: {
702	AVRational tmp;
703	ret = set_string_video_rate(obj, o, val, &tmp);
704	if (ret < 0)
705	return ret;
706	return write_number(obj, o, dst, 1, tmp.den, tmp.num);
707	}
708	case AV_OPT_TYPE_PIXEL_FMT:
709	return set_string_pixel_fmt(obj, o, val, dst);
710	case AV_OPT_TYPE_SAMPLE_FMT:
711	return set_string_sample_fmt(obj, o, val, dst);
712	case AV_OPT_TYPE_DURATION:
713	{
714	int64_t usecs = 0;
715	if (val) {
716	if ((ret = av_parse_time(&usecs, val, 1)) < 0) {
717	av_log(obj, AV_LOG_ERROR16, "Unable to parse \"%s\" option value \"%s\" as duration\n", o->name, val);
718	return ret;
719	}
720	}
721	if (usecs < o->min \|\| usecs > o->max) {
722	av_log(obj, AV_LOG_ERROR16, "Value %f for parameter '%s' out of range [%g - %g]\n",
723	usecs / 1000000.0, o->name, o->min / 1000000.0, o->max / 1000000.0);
724	return AVERROR(ERANGE)(-(34));
725	}
726	(int64_t )dst = usecs;
727	return 0;
728	}
729	case AV_OPT_TYPE_COLOR:
730	return set_string_color(obj, o, val, dst);
731	case AV_OPT_TYPE_CHLAYOUT:
732	ret = set_string_channel_layout(obj, o, val, dst);
733	if (ret < 0) {
734	av_log(obj, AV_LOG_ERROR16, "Unable to parse \"%s\" option value \"%s\" as channel layout\n", o->name, val);
735	ret = AVERROR(EINVAL)(-(22));
736	}
737	return ret;
738	case AV_OPT_TYPE_DICT:
739	return set_string_dict(obj, o, val, dst);
740	}
741
742	av_log(obj, AV_LOG_ERROR16, "Invalid option type.\n");
743	return AVERROR(EINVAL)(-(22));
744	}
745
746	static int opt_set_array(void obj, void target_obj, const AVOption *o,
747	const char val, void dst)
748	{
749	const AVOptionArrayDef *arr = o->default_val.arr;
750	const size_t elem_size = opt_type_desc[TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY)].size;
751	const uint8_t sep = opt_array_sep(o);
752	uint8_t str = NULL((void)0);
753
754	void elems = NULL((void)0);
755	unsigned nb_elems = 0;
756	int ret;
757
758	if (val && *val) {
759	str = av_malloc(strlen(val) + 1);
760	if (!str)
761	return AVERROR(ENOMEM)(-(12));
762	}
763
764	// split and unescape the string
765	while (val && *val) {
766	uint8_t *p = str;
767	void *tmp;
768
769	if (arr && arr->size_max && nb_elems >= arr->size_max) {
770	av_log(obj, AV_LOG_ERROR16,
771	"Cannot assign more than %u elements to array option %s\n",
772	arr->size_max, o->name);
773	ret = AVERROR(EINVAL)(-(22));
774	goto fail;
775	}
776
777	for (; *val; val++, p++) {
778	if (*val == '\\' && val[1])
779	val++;
780	else if (*val == sep) {
781	val++;
782	break;
783	}
784	p = val;
785	}
786	*p = 0;
787
788	tmp = av_realloc_array(elems, nb_elems + 1, elem_size);
789	if (!tmp) {
790	ret = AVERROR(ENOMEM)(-(12));
791	goto fail;
792	}
793	elems = tmp;
794
795	tmp = opt_array_pelem(o, elems, nb_elems);
796	memset(tmp, 0, elem_size);
797
798	ret = opt_set_elem(obj, target_obj, o, str, tmp);
799	if (ret < 0)
800	goto fail;
801	nb_elems++;
802	}
803	av_freep(&str);
804
805	opt_free_array(o, dst, opt_array_pcount(dst));
806
807	if (arr && nb_elems < arr->size_min) {
808	av_log(obj, AV_LOG_ERROR16,
809	"Cannot assign fewer than %u elements to array option %s\n",
810	arr->size_min, o->name);
811	ret = AVERROR(EINVAL)(-(22));
812	goto fail;
813	}
814
815	((void *)dst) = elems;
816	*opt_array_pcount(dst) = nb_elems;
817
818	return 0;
819	fail:
820	av_freep(&str);
821	opt_free_array(o, &elems, &nb_elems);
822	return ret;
823	}
824
825	int av_opt_set(void obj, const char name, const char *val, int search_flags)
826	{
827	void dst, target_obj;
828	const AVOption *o;
829	int ret;
830
831	ret = opt_set_init(obj, name, search_flags, 0, &target_obj, &o, &dst);
832	if (ret < 0)
833	return ret;
834
835	return ((o->type & AV_OPT_TYPE_FLAG_ARRAY) ?
836	opt_set_array : opt_set_elem)(obj, target_obj, o, val, dst);
837	}
838
839	#define OPT_EVAL_NUMBER(name, opttype, vartype)int av_opt_eval_name(void obj, const AVOption o, const char val, vartype name_out) { if (!o \|\| o->type != opttype \|\| o->flags & (1 << 7)) return (-(22)); return set_string_number (obj, obj, o, val, name_out); } \
840	int av_opt_eval_ ## name(void obj, const AVOption o, \
841	const char val, vartype name ## _out) \
842	{ \
843	if (!o \|\| o->type != opttype \|\| o->flags & AV_OPT_FLAG_READONLY(1 << 7)) \
844	return AVERROR(EINVAL)(-(22)); \
845	return set_string_number(obj, obj, o, val, name ## _out); \
846	}
847
848	OPT_EVAL_NUMBER(flags, AV_OPT_TYPE_FLAGS, int)int av_opt_eval_flags(void obj, const AVOption o, const char val, int flags_out) { if (!o \|\| o->type != AV_OPT_TYPE_FLAGS \|\| o->flags & (1 << 7)) return (-(22)); return set_string_number (obj, obj, o, val, flags_out); }
849	OPT_EVAL_NUMBER(int, AV_OPT_TYPE_INT, int)int av_opt_eval_int(void obj, const AVOption o, const char * val, int *int_out) { if (!o \|\| o->type != AV_OPT_TYPE_INT \|\| o->flags & (1 << 7)) return (-(22)); return set_string_number (obj, obj, o, val, int_out); }
850	OPT_EVAL_NUMBER(uint, AV_OPT_TYPE_UINT, unsigned)int av_opt_eval_uint(void obj, const AVOption o, const char val, unsigned uint_out) { if (!o \|\| o->type != AV_OPT_TYPE_UINT \|\| o->flags & (1 << 7)) return (-(22)); return set_string_number (obj, obj, o, val, uint_out); }
851	OPT_EVAL_NUMBER(int64, AV_OPT_TYPE_INT64, int64_t)int av_opt_eval_int64(void obj, const AVOption o, const char val, int64_t int64_out) { if (!o \|\| o->type != AV_OPT_TYPE_INT64 \|\| o->flags & (1 << 7)) return (-(22)); return set_string_number (obj, obj, o, val, int64_out); }
852	OPT_EVAL_NUMBER(float, AV_OPT_TYPE_FLOAT, float)int av_opt_eval_float(void obj, const AVOption o, const char val, float float_out) { if (!o \|\| o->type != AV_OPT_TYPE_FLOAT \|\| o->flags & (1 << 7)) return (-(22)); return set_string_number (obj, obj, o, val, float_out); }
853	OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE, double)int av_opt_eval_double(void obj, const AVOption o, const char val, double double_out) { if (!o \|\| o->type != AV_OPT_TYPE_DOUBLE \|\| o->flags & (1 << 7)) return (-(22)); return set_string_number (obj, obj, o, val, double_out); }
854	OPT_EVAL_NUMBER(q, AV_OPT_TYPE_RATIONAL, AVRational)int av_opt_eval_q(void obj, const AVOption o, const char val , AVRational q_out) { if (!o \|\| o->type != AV_OPT_TYPE_RATIONAL \|\| o->flags & (1 << 7)) return (-(22)); return set_string_number (obj, obj, o, val, q_out); }
855
856	static int set_number(void obj, const char name, double num, int den, int64_t intnum,
857	int search_flags, int require_type)
858	{
859	void *dst;
860	const AVOption *o;
861	int ret;
862
863	ret = opt_set_init(obj, name, search_flags, require_type, NULL((void*)0), &o, &dst);
864	if (ret < 0)
865	return ret;
866
867	return write_number(obj, o, dst, num, den, intnum);
868	}
869
870	int av_opt_set_int(void obj, const char name, int64_t val, int search_flags)
871	{
872	return set_number(obj, name, 1, 1, val, search_flags, 0);
873	}
874
875	int av_opt_set_double(void obj, const char name, double val, int search_flags)
876	{
877	return set_number(obj, name, val, 1, 1, search_flags, 0);
878	}
879
880	int av_opt_set_q(void obj, const char name, AVRational val, int search_flags)
881	{
882	return set_number(obj, name, val.num, val.den, 1, search_flags, 0);
883	}
884
885	int av_opt_set_bin(void obj, const char name, const uint8_t *val, int len, int search_flags)
886	{
887	uint8_t *ptr;
888	uint8_t **dst;
889	int *lendst;
890	int ret;
891
892	ret = opt_set_init(obj, name, search_flags, AV_OPT_TYPE_BINARY,
893	NULL((void)0), NULL((void)0), (void**)&dst);
894	if (ret < 0)
895	return ret;
896
897	ptr = len ? av_malloc(len) : NULL((void*)0);
898	if (len && !ptr)
899	return AVERROR(ENOMEM)(-(12));
900
901	lendst = (int *)(dst + 1);
902
903	av_free(*dst);
904	*dst = ptr;
905	*lendst = len;
906	if (len)
907	memcpy(ptr, val, len);
908
909	return 0;
910	}
911
912	int av_opt_set_image_size(void obj, const char name, int w, int h, int search_flags)
913	{
914	const AVOption *o;
915	int *dst;
916	int ret;
917
918	ret = opt_set_init(obj, name, search_flags, AV_OPT_TYPE_IMAGE_SIZE,
919	NULL((void)0), &o, (void*)&dst);
920	if (ret < 0)
921	return ret;
922
923	if (w<0 \|\| h<0) {
924	av_log(obj, AV_LOG_ERROR16,
925	"Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
926	return AVERROR(EINVAL)(-(22));
927	}
928
929	dst[0] = w;
930	dst[1] = h;
931
932	return 0;
933	}
934
935	int av_opt_set_video_rate(void obj, const char name, AVRational val, int search_flags)
936	{
937	return set_number(obj, name, val.num, val.den, 1, search_flags, AV_OPT_TYPE_VIDEO_RATE);
938	}
939
940	static int set_format(void obj, const char name, int fmt, int search_flags,
941	enum AVOptionType type, const char *desc, int nb_fmts)
942	{
943	const AVOption *o;
944	int *dst;
945	int min, max, ret;
946
947	ret = opt_set_init(obj, name, search_flags, type, NULL((void)0), &o, (void*)&dst);
948	if (ret < 0)
949	return ret;
950
951	min = FFMAX(o->min, -1)((o->min) > (-1) ? (o->min) : (-1));
952	max = FFMIN(o->max, nb_fmts-1)((o->max) > (nb_fmts-1) ? (nb_fmts-1) : (o->max));
953
954	if (fmt < min \|\| fmt > max) {
955	av_log(obj, AV_LOG_ERROR16,
956	"Value %d for parameter '%s' out of %s format range [%d - %d]\n",
957	fmt, name, desc, min, max);
958	return AVERROR(ERANGE)(-(34));
959	}
960	*dst = fmt;
961	return 0;
962	}
963
964	int av_opt_set_pixel_fmt(void obj, const char name, enum AVPixelFormat fmt, int search_flags)
965	{
966	return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
967	}
968
969	int av_opt_set_sample_fmt(void obj, const char name, enum AVSampleFormat fmt, int search_flags)
970	{
971	return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
972	}
973
974	int av_opt_set_dict_val(void obj, const char name, const AVDictionary *val,
975	int search_flags)
976	{
977	AVDictionary **dst;
978	int ret;
979
980	ret = opt_set_init(obj, name, search_flags, AV_OPT_TYPE_DICT, NULL((void)0), NULL((void)0),
981	(void**)&dst);
982	if (ret < 0)
983	return ret;
984
985	av_dict_free(dst);
986
987	return av_dict_copy(dst, val, 0);
988	}
989
990	int av_opt_set_chlayout(void obj, const char name,
991	const AVChannelLayout *channel_layout,
992	int search_flags)
993	{
994	AVChannelLayout *dst;
995	int ret;
996
997	ret = opt_set_init(obj, name, search_flags, AV_OPT_TYPE_CHLAYOUT, NULL((void)0), NULL((void)0),
998	(void**)&dst);
999	if (ret < 0)
1000	return ret;
1001
1002	return av_channel_layout_copy(dst, channel_layout);
1003	}
1004
1005	static void format_duration(char *buf, size_t size, int64_t d)
1006	{
1007	char *e;
1008
1009	av_assert0(size >= 25)do { if (!(size >= 25)) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n" , "size >= 25", "/root/firefox-clang/media/ffvpx/libavutil/opt.c" , 1009); abort(); } } while (0);
1010	if (d < 0 && d != INT64_MIN(-9223372036854775807L -1)) {
1011	*(buf++) = '-';
1012	size--;
1013	d = -d;
1014	}
1015	if (d == INT64_MAX(9223372036854775807L))
1016	snprintf(buf, size, "INT64_MAX");
1017	else if (d == INT64_MIN(-9223372036854775807L -1))
1018	snprintf(buf, size, "INT64_MIN");
1019	else if (d > (int64_t)3600*1000000)
1020	snprintf(buf, size, "%"PRId64"l" "d"":%02d:%02d.%06d", d / 3600000000,
1021	(int)((d / 60000000) % 60),
1022	(int)((d / 1000000) % 60),
1023	(int)(d % 1000000));
1024	else if (d > 60*1000000)
1025	snprintf(buf, size, "%d:%02d.%06d",
1026	(int)(d / 60000000),
1027	(int)((d / 1000000) % 60),
1028	(int)(d % 1000000));
1029	else
1030	snprintf(buf, size, "%d.%06d",
1031	(int)(d / 1000000),
1032	(int)(d % 1000000));
1033	e = buf + strlen(buf);
1034	while (e > buf && e[-1] == '0')
1035	*(--e) = 0;
1036	if (e > buf && e[-1] == '.')
1037	*(--e) = 0;
1038	}
1039
1040	static int opt_get_elem(const AVOption o, uint8_t *pbuf, size_t buf_len,
1041	const void *dst, int search_flags)
1042	{
1043	int ret;
1044
1045	switch (TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY)) {
1046	case AV_OPT_TYPE_BOOL:
1047	ret = snprintf(pbuf, buf_len, "%s", get_bool_name((int *)dst));
1048	break;
1049	case AV_OPT_TYPE_FLAGS:
1050	ret = snprintf(pbuf, buf_len, "0x%08X", (int *)dst);
1051	break;
1052	case AV_OPT_TYPE_INT:
1053	ret = snprintf(pbuf, buf_len, "%d", (int *)dst);
1054	break;
1055	case AV_OPT_TYPE_UINT:
1056	ret = snprintf(pbuf, buf_len, "%u", (unsigned *)dst);
1057	break;
1058	case AV_OPT_TYPE_INT64:
1059	ret = snprintf(pbuf, buf_len, "%"PRId64"l" "d", (int64_t *)dst);
1060	break;
1061	case AV_OPT_TYPE_UINT64:
1062	ret = snprintf(pbuf, buf_len, "%"PRIu64"l" "u", (uint64_t *)dst);
1063	break;
1064	case AV_OPT_TYPE_FLOAT:
1065	ret = snprintf(pbuf, buf_len, "%f", (float *)dst);
1066	break;
1067	case AV_OPT_TYPE_DOUBLE:
1068	ret = snprintf(pbuf, buf_len, "%f", (double *)dst);
1069	break;
1070	case AV_OPT_TYPE_VIDEO_RATE:
1071	case AV_OPT_TYPE_RATIONAL:
1072	ret = snprintf(pbuf, buf_len, "%d/%d", ((AVRational )dst)->num, ((AVRational *)dst)->den);
1073	break;
1074	case AV_OPT_TYPE_CONST:
1075	ret = snprintf(*pbuf, buf_len, "%"PRId64"l" "d", o->default_val.i64);
1076	break;
1077	case AV_OPT_TYPE_STRING:
1078	if ((uint8_t *)dst) {
1079	pbuf = av_strdup((uint8_t **)dst);
1080	} else if (search_flags & AV_OPT_ALLOW_NULL(1 << 2)) {
1081	pbuf = NULL((void)0);
1082	return 0;
1083	} else {
1084	*pbuf = av_strdup("");
1085	}
1086	return *pbuf ? 0 : AVERROR(ENOMEM)(-(12));
1087	case AV_OPT_TYPE_BINARY: {
1088	const uint8_t *bin;
1089	int len;
1090
1091	if (!(uint8_t *)dst && (search_flags & AV_OPT_ALLOW_NULL(1 << 2))) {
1092	pbuf = NULL((void)0);
1093	return 0;
1094	}
1095	len = (int )(((uint8_t )dst) + sizeof(uint8_t ));
1096	if ((uint64_t)len * 2 + 1 > INT_MAX2147483647)
1097	return AVERROR(EINVAL)(-(22));
1098	if (!(pbuf = av_malloc(len 2 + 1)))
1099	return AVERROR(ENOMEM)(-(12));
1100	if (!len) {
1101	*pbuf[0] = '\0';
1102	return 0;
1103	}
1104	bin = (uint8_t *)dst;
1105	for (int i = 0; i < len; i++)
1106	snprintf(pbuf + i 2, 3, "%02X", bin[i]);
1107	return 0;
1108	}
1109	case AV_OPT_TYPE_IMAGE_SIZE:
1110	ret = snprintf(pbuf, buf_len, "%dx%d", ((int )dst)[0], ((int *)dst)[1]);
1111	break;
1112	case AV_OPT_TYPE_PIXEL_FMT:
1113	ret = snprintf(pbuf, buf_len, "%s", (char )av_x_if_null(av_get_pix_fmt_name((enum AVPixelFormat )dst), "none"));
1114	break;
1115	case AV_OPT_TYPE_SAMPLE_FMT:
1116	ret = snprintf(pbuf, buf_len, "%s", (char )av_x_if_null(av_get_sample_fmt_name((enum AVSampleFormat )dst), "none"));
1117	break;
1118	case AV_OPT_TYPE_DURATION: {
1119	int64_t i64 = (int64_t )dst;
1120	format_duration(*pbuf, buf_len, i64);
1121	ret = strlen(*pbuf); // no overflow possible, checked by an assert
1122	break;
1123	}
1124	case AV_OPT_TYPE_COLOR:
1125	ret = snprintf(*pbuf, buf_len, "0x%02x%02x%02x%02x",
1126	(int)((uint8_t )dst)[0], (int)((uint8_t )dst)[1],
1127	(int)((uint8_t )dst)[2], (int)((uint8_t )dst)[3]);
1128	break;
1129	case AV_OPT_TYPE_CHLAYOUT:
1130	ret = av_channel_layout_describe(dst, *pbuf, buf_len);
1131	break;
1132	case AV_OPT_TYPE_DICT:
1133	if (!(AVDictionary *)dst && (search_flags & AV_OPT_ALLOW_NULL(1 << 2))) {
1134	pbuf = NULL((void)0);
1135	return 0;
1136	}
1137	return av_dict_get_string((AVDictionary )dst, (char *)pbuf, '=', ':');
1138	default:
1139	return AVERROR(EINVAL)(-(22));
1140	}
1141
1142	return ret;
1143	}
1144
1145	static int opt_get_array(const AVOption o, void dst, uint8_t **out_val)
1146	{
1147	const unsigned count = *opt_array_pcount(dst);
1148	const uint8_t sep = opt_array_sep(o);
1149
1150	uint8_t str = NULL((void)0);
1151	size_t str_len = 0;
1152	int ret;
1153
1154	out_val = NULL((void)0);
1155
1156	for (unsigned i = 0; i < count; i++) {
1157	uint8_t buf[128], *out = buf;
1158	size_t out_len;
1159
1160	ret = opt_get_elem(o, &out, sizeof(buf),
1161	opt_array_pelem(o, (void *)dst, i), 0);
1162	if (ret < 0)
1163	goto fail;
1164
1165	out_len = strlen(out);
1166	if (out_len > SIZE_MAX(18446744073709551615UL) / 2 - !!i \|\|
1167	!!i + out_len * 2 > SIZE_MAX(18446744073709551615UL) - str_len - 1) {
1168	ret = AVERROR(ERANGE)(-(34));
1169	goto fail;
1170	}
1171
1172	// terminator escaping separator
1173	// ↓ ↓ ↓
1174	ret = av_reallocp(&str, str_len + 1 + out_len * 2 + !!i);
1175	if (ret < 0)
1176	goto fail;
1177
1178	// add separator if needed
1179	if (i)
1180	str[str_len++] = sep;
1181
1182	// escape the element
1183	for (unsigned j = 0; j < out_len; j++) {
1184	uint8_t val = out[j];
1185	if (val == sep \|\| val == '\\')
1186	str[str_len++] = '\\';
1187	str[str_len++] = val;
1188	}
1189	str[str_len] = 0;
1190
1191	fail:
1192	if (out != buf)
1193	av_freep(&out);
1194	if (ret < 0) {
1195	av_freep(&str);
1196	return ret;
1197	}
1198	}
1199
1200	*out_val = str;
1201
1202	return 0;
1203	}
1204
1205	int av_opt_get(void obj, const char name, int search_flags, uint8_t **out_val)
1206	{
1207	void dst, target_obj;
1208	const AVOption o = av_opt_find2(obj, name, NULL((void)0), 0, search_flags, &target_obj);
1209	uint8_t *out, buf[128];
1210	int ret;
1211
1212	if (!o \|\| !target_obj \|\| (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
1213	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
1214
1215	if (o->flags & AV_OPT_FLAG_DEPRECATED(1 << 17))
1216	av_log(obj, AV_LOG_WARNING24, "The \"%s\" option is deprecated: %s\n", name, o->help);
1217
1218	dst = (uint8_t *)target_obj + o->offset;
1219
1220	if (o->type & AV_OPT_TYPE_FLAG_ARRAY) {
1221	ret = opt_get_array(o, dst, out_val);
1222	if (ret < 0)
1223	return ret;
1224	if (!*out_val && !(search_flags & AV_OPT_ALLOW_NULL(1 << 2))) {
1225	*out_val = av_strdup("");
1226	if (!*out_val)
1227	return AVERROR(ENOMEM)(-(12));
1228	}
1229	return 0;
1230	}
1231
1232	buf[0] = 0;
1233	out = buf;
1234	ret = opt_get_elem(o, &out, sizeof(buf), dst, search_flags);
1235	if (ret < 0)
1236	return ret;
1237	if (out != buf) {
1238	*out_val = out;
1239	return 0;
1240	}
1241
1242	if (ret >= sizeof(buf))
1243	return AVERROR(EINVAL)(-(22));
1244	*out_val = av_strdup(out);
1245	return *out_val ? 0 : AVERROR(ENOMEM)(-(12));
1246	}
1247
1248	static int get_number(void obj, const char name, double num, int den, int64_t *intnum,
1249	int search_flags)
1250	{
1251	void dst, target_obj;
1252	const AVOption o = av_opt_find2(obj, name, NULL((void)0), 0, search_flags, &target_obj);
1253	if (!o \|\| !target_obj)
1254	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
1255	if (o->type & AV_OPT_TYPE_FLAG_ARRAY)
1256	return AVERROR(EINVAL)(-(22));
1257
1258	dst = ((uint8_t *)target_obj) + o->offset;
1259
1260	return read_number(o, dst, num, den, intnum);
1261	}
1262
1263	int av_opt_get_int(void obj, const char name, int search_flags, int64_t *out_val)
1264	{
1265	int64_t intnum = 1;
1266	double num = 1;
1267	int ret, den = 1;
1268
1269	if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
1270	return ret;
1271	if (num == den)
1272	*out_val = intnum;
1273	else
1274	out_val = num intnum / den;
1275	return 0;
1276	}
1277
1278	int av_opt_get_double(void obj, const char name, int search_flags, double *out_val)
1279	{
1280	int64_t intnum = 1;
1281	double num = 1;
1282	int ret, den = 1;
1283
1284	if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
1285	return ret;
1286	out_val = num intnum / den;
1287	return 0;
1288	}
1289
1290	int av_opt_get_q(void obj, const char name, int search_flags, AVRational *out_val)
1291	{
1292	int64_t intnum = 1;
1293	double num = 1;
1294	int ret, den = 1;
1295
1296	if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
1297	return ret;
1298
1299	if (num == 1.0 && (int)intnum == intnum)
1300	*out_val = (AVRational){intnum, den};
1301	else
1302	out_val = double_to_rational(numintnum/den);
1303	return 0;
1304	}
1305
1306	int av_opt_get_image_size(void obj, const char name, int search_flags, int w_out, int h_out)
1307	{
1308	void dst, target_obj;
1309	const AVOption o = av_opt_find2(obj, name, NULL((void)0), 0, search_flags, &target_obj);
1310	if (!o \|\| !target_obj)
1311	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
1312	if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
1313	av_log(obj, AV_LOG_ERROR16,
1314	"The value for option '%s' is not a image size.\n", name);
1315	return AVERROR(EINVAL)(-(22));
1316	}
1317
1318	dst = ((uint8_t*)target_obj) + o->offset;
1319	if (w_out) w_out = (int *)dst;
1320	if (h_out) h_out = ((int *)dst+1);
1321	return 0;
1322	}
1323
1324	int av_opt_get_video_rate(void obj, const char name, int search_flags, AVRational *out_val)
1325	{
1326	return av_opt_get_q(obj, name, search_flags, out_val);
1327	}
1328
1329	static int get_format(void obj, const char name, int search_flags, void *out_fmt,
1330	enum AVOptionType type, const char *desc)
1331	{
1332	void dst, target_obj;
1333	const AVOption o = av_opt_find2(obj, name, NULL((void)0), 0, search_flags, &target_obj);
1334	if (!o \|\| !target_obj)
1335	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
1336	if (o->type != type) {
1337	av_log(obj, AV_LOG_ERROR16,
1338	"The value for option '%s' is not a %s format.\n", desc, name);
1339	return AVERROR(EINVAL)(-(22));
1340	}
1341
1342	dst = ((uint8_t*)target_obj) + o->offset;
1343	if (type == AV_OPT_TYPE_PIXEL_FMT)
1344	(enum AVPixelFormat )out_fmt = (enum AVPixelFormat )dst;
1345	else
1346	(enum AVSampleFormat)out_fmt = (enum AVSampleFormat)dst;
1347
1348	return 0;
1349	}
1350
1351	int av_opt_get_pixel_fmt(void obj, const char name, int search_flags, enum AVPixelFormat *out_fmt)
1352	{
1353	return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
1354	}
1355
1356	int av_opt_get_sample_fmt(void obj, const char name, int search_flags, enum AVSampleFormat *out_fmt)
1357	{
1358	return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
1359	}
1360
1361	int av_opt_get_chlayout(void obj, const char name, int search_flags, AVChannelLayout *cl)
1362	{
1363	void dst, target_obj;
1364	const AVOption o = av_opt_find2(obj, name, NULL((void)0), 0, search_flags, &target_obj);
1365	if (!o \|\| !target_obj)
1366	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
1367	if (o->type != AV_OPT_TYPE_CHLAYOUT) {
1368	av_log(obj, AV_LOG_ERROR16,
1369	"The value for option '%s' is not a channel layout.\n", name);
1370	return AVERROR(EINVAL)(-(22));
1371	}
1372
1373	dst = ((uint8_t*)target_obj) + o->offset;
1374	return av_channel_layout_copy(cl, dst);
1375	}
1376
1377	int av_opt_get_dict_val(void obj, const char name, int search_flags, AVDictionary **out_val)
1378	{
1379	void *target_obj;
1380	AVDictionary *src;
1381	const AVOption o = av_opt_find2(obj, name, NULL((void)0), 0, search_flags, &target_obj);
1382
1383	if (!o \|\| !target_obj)
1384	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
1385	if (o->type != AV_OPT_TYPE_DICT)
1386	return AVERROR(EINVAL)(-(22));
1387
1388	src = (AVDictionary )(((uint8_t )target_obj) + o->offset);
1389
1390	return av_dict_copy(out_val, src, 0);
1391	}
1392
1393	int av_opt_flag_is_set(void obj, const char field_name, const char *flag_name)
1394	{
1395	const AVOption field = av_opt_find(obj, field_name, NULL((void)0), 0, 0);
1396	const AVOption *flag = av_opt_find(obj, flag_name,
1397	field ? field->unit : NULL((void*)0), 0, 0);
1398	int64_t res;
1399
1400	if (!field \|\| !flag \|\| flag->type != AV_OPT_TYPE_CONST \|\|
1401	av_opt_get_int(obj, field_name, 0, &res) < 0)
1402	return 0;
1403	return res & flag->default_val.i64;
1404	}
1405
1406	static void log_int_value(void *av_log_obj, int level, int64_t i)
1407	{
1408	if (i == INT_MAX2147483647) {
1409	av_log(av_log_obj, level, "INT_MAX");
1410	} else if (i == INT_MIN(-2147483647 -1)) {
1411	av_log(av_log_obj, level, "INT_MIN");
1412	} else if (i == UINT32_MAX(4294967295U)) {
1413	av_log(av_log_obj, level, "UINT32_MAX");
1414	} else if (i == INT64_MAX(9223372036854775807L)) {
1415	av_log(av_log_obj, level, "I64_MAX");
1416	} else if (i == INT64_MIN(-9223372036854775807L -1)) {
1417	av_log(av_log_obj, level, "I64_MIN");
1418	} else {
1419	av_log(av_log_obj, level, "%"PRId64"l" "d", i);
1420	}
1421	}
1422
1423	static void log_value(void *av_log_obj, int level, double d)
1424	{
1425	if (d == INT_MAX2147483647) {
1426	av_log(av_log_obj, level, "INT_MAX");
1427	} else if (d == INT_MIN(-2147483647 -1)) {
1428	av_log(av_log_obj, level, "INT_MIN");
1429	} else if (d == UINT32_MAX(4294967295U)) {
1430	av_log(av_log_obj, level, "UINT32_MAX");
1431	} else if (d == (double)INT64_MAX(9223372036854775807L)) {
1432	av_log(av_log_obj, level, "I64_MAX");
1433	} else if (d == INT64_MIN(-9223372036854775807L -1)) {
1434	av_log(av_log_obj, level, "I64_MIN");
1435	} else if (d == FLT_MAX3.40282347e+38F) {
1436	av_log(av_log_obj, level, "FLT_MAX");
1437	} else if (d == FLT_MIN1.17549435e-38F) {
1438	av_log(av_log_obj, level, "FLT_MIN");
1439	} else if (d == -FLT_MAX3.40282347e+38F) {
1440	av_log(av_log_obj, level, "-FLT_MAX");
1441	} else if (d == -FLT_MIN1.17549435e-38F) {
1442	av_log(av_log_obj, level, "-FLT_MIN");
1443	} else if (d == DBL_MAX1.7976931348623157e+308) {
1444	av_log(av_log_obj, level, "DBL_MAX");
1445	} else if (d == DBL_MIN2.2250738585072014e-308) {
1446	av_log(av_log_obj, level, "DBL_MIN");
1447	} else if (d == -DBL_MAX1.7976931348623157e+308) {
1448	av_log(av_log_obj, level, "-DBL_MAX");
1449	} else if (d == -DBL_MIN2.2250738585072014e-308) {
1450	av_log(av_log_obj, level, "-DBL_MIN");
1451	} else {
1452	av_log(av_log_obj, level, "%g", d);
1453	}
1454	}
1455
1456	static const char get_opt_const_name(void obj, const char *unit, int64_t value)
1457	{
1458	const AVOption opt = NULL((void)0);
1459
1460	if (!unit)
1461	return NULL((void*)0);
1462	while ((opt = av_opt_next(obj, opt)))
1463	if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1464	opt->default_val.i64 == value)
1465	return opt->name;
1466	return NULL((void*)0);
1467	}
1468
1469	static char get_opt_flags_string(void obj, const char *unit, int64_t value)
1470	{
1471	const AVOption opt = NULL((void)0);
1472	char flags[512];
1473
1474	flags[0] = 0;
1475	if (!unit)
1476	return NULL((void*)0);
1477	while ((opt = av_opt_next(obj, opt))) {
1478	if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1479	opt->default_val.i64 & value) {
1480	if (flags[0])
1481	av_strlcatf(flags, sizeof(flags), "+");
1482	av_strlcatf(flags, sizeof(flags), "%s", opt->name);
1483	}
1484	}
1485	if (flags[0])
1486	return av_strdup(flags);
1487	return NULL((void*)0);
1488	}
1489
1490	static void log_type(void av_log_obj, const AVOption o,
1491	enum AVOptionType parent_type)
1492	{
1493	const enum AVOptionType type = TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY);
1494
1495	if (o->type == AV_OPT_TYPE_CONST && (TYPE_BASE(parent_type)((parent_type) & ~AV_OPT_TYPE_FLAG_ARRAY) == AV_OPT_TYPE_INT \|\| TYPE_BASE(parent_type)((parent_type) & ~AV_OPT_TYPE_FLAG_ARRAY) == AV_OPT_TYPE_INT64))
1496	av_log(av_log_obj, AV_LOG_INFO32, "%-12"PRId64"l" "d"" ", o->default_val.i64);
1497	else if (type < FF_ARRAY_ELEMS(opt_type_desc)(sizeof(opt_type_desc) / sizeof((opt_type_desc)[0])) && opt_type_desc[type].name) {
1498	if (o->type & AV_OPT_TYPE_FLAG_ARRAY)
1499	av_log(av_log_obj, AV_LOG_INFO32, "[%-10s]", opt_type_desc[type].name);
1500	else
1501	av_log(av_log_obj, AV_LOG_INFO32, "%-12s ", opt_type_desc[type].name);
1502	}
1503	else
1504	av_log(av_log_obj, AV_LOG_INFO32, "%-12s ", "");
1505	}
1506
1507	static void log_default(void obj, void av_log_obj, const AVOption *opt)
1508	{
1509	if (opt->type == AV_OPT_TYPE_CONST \|\| opt->type == AV_OPT_TYPE_BINARY)
1510	return;
1511	if ((opt->type == AV_OPT_TYPE_COLOR \|\|
1512	opt->type == AV_OPT_TYPE_IMAGE_SIZE \|\|
1513	opt->type == AV_OPT_TYPE_STRING \|\|
1514	opt->type == AV_OPT_TYPE_DICT \|\|
1515	opt->type == AV_OPT_TYPE_CHLAYOUT \|\|
1516	opt->type == AV_OPT_TYPE_VIDEO_RATE) &&
1517	!opt->default_val.str)
1518	return;
1519
1520	if (opt->type & AV_OPT_TYPE_FLAG_ARRAY) {
1521	const AVOptionArrayDef *arr = opt->default_val.arr;
1522	if (arr && arr->def)
1523	av_log(av_log_obj, AV_LOG_INFO32, " (default %s)", arr->def);
1524	return;
1525	}
1526
1527	av_log(av_log_obj, AV_LOG_INFO32, " (default ");
1528	switch (opt->type) {
1529	case AV_OPT_TYPE_BOOL:
1530	av_log(av_log_obj, AV_LOG_INFO32, "%s", get_bool_name(opt->default_val.i64));
1531	break;
1532	case AV_OPT_TYPE_FLAGS: {
1533	char *def_flags = get_opt_flags_string(obj, opt->unit, opt->default_val.i64);
1534	if (def_flags) {
1535	av_log(av_log_obj, AV_LOG_INFO32, "%s", def_flags);
1536	av_freep(&def_flags);
1537	} else {
1538	av_log(av_log_obj, AV_LOG_INFO32, "%"PRIX64"l" "X", opt->default_val.i64);
1539	}
1540	break;
1541	}
1542	case AV_OPT_TYPE_DURATION: {
1543	char buf[25];
1544	format_duration(buf, sizeof(buf), opt->default_val.i64);
1545	av_log(av_log_obj, AV_LOG_INFO32, "%s", buf);
1546	break;
1547	}
1548	case AV_OPT_TYPE_UINT:
1549	case AV_OPT_TYPE_INT:
1550	case AV_OPT_TYPE_UINT64:
1551	case AV_OPT_TYPE_INT64: {
1552	const char *def_const = get_opt_const_name(obj, opt->unit, opt->default_val.i64);
1553	if (def_const)
1554	av_log(av_log_obj, AV_LOG_INFO32, "%s", def_const);
1555	else
1556	log_int_value(av_log_obj, AV_LOG_INFO32, opt->default_val.i64);
1557	break;
1558	}
1559	case AV_OPT_TYPE_DOUBLE:
1560	case AV_OPT_TYPE_FLOAT:
1561	log_value(av_log_obj, AV_LOG_INFO32, opt->default_val.dbl);
1562	break;
1563	case AV_OPT_TYPE_RATIONAL: {
1564	AVRational q = av_d2q(opt->default_val.dbl, INT_MAX2147483647);
1565	av_log(av_log_obj, AV_LOG_INFO32, "%d/%d", q.num, q.den); }
1566	break;
1567	case AV_OPT_TYPE_PIXEL_FMT:
1568	av_log(av_log_obj, AV_LOG_INFO32, "%s", (char *)av_x_if_null(av_get_pix_fmt_name(opt->default_val.i64), "none"));
1569	break;
1570	case AV_OPT_TYPE_SAMPLE_FMT:
1571	av_log(av_log_obj, AV_LOG_INFO32, "%s", (char *)av_x_if_null(av_get_sample_fmt_name(opt->default_val.i64), "none"));
1572	break;
1573	case AV_OPT_TYPE_COLOR:
1574	case AV_OPT_TYPE_IMAGE_SIZE:
1575	case AV_OPT_TYPE_STRING:
1576	case AV_OPT_TYPE_DICT:
1577	case AV_OPT_TYPE_VIDEO_RATE:
1578	case AV_OPT_TYPE_CHLAYOUT:
1579	av_log(av_log_obj, AV_LOG_INFO32, "\"%s\"", opt->default_val.str);
1580	break;
1581	}
1582	av_log(av_log_obj, AV_LOG_INFO32, ")");
1583	}
1584
1585	static void opt_list(void obj, void av_log_obj, const char *unit,
1586	int req_flags, int rej_flags, enum AVOptionType parent_type)
1587	{
1588	const AVOption opt = NULL((void)0);
1589	AVOptionRanges *r;
1590	int i;
1591
1592	while ((opt = av_opt_next(obj, opt))) {
1593	if (!(opt->flags & req_flags) \|\| (opt->flags & rej_flags))
1594	continue;
1595
1596	/* Don't print CONST's on level one.
1597	* Don't print anything but CONST's on level two.
1598	* Only print items from the requested unit.
1599	*/
1600	if (!unit && opt->type == AV_OPT_TYPE_CONST)
1601	continue;
1602	else if (unit && opt->type != AV_OPT_TYPE_CONST)
1603	continue;
1604	else if (unit && opt->type == AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
1605	continue;
1606	else if (unit && opt->type == AV_OPT_TYPE_CONST)
1607	av_log(av_log_obj, AV_LOG_INFO32, " %-15s ", opt->name);
1608	else
1609	av_log(av_log_obj, AV_LOG_INFO32, " %s%-17s ",
1610	(opt->flags & AV_OPT_FLAG_FILTERING_PARAM(1 << 16)) ? " " : "-",
1611	opt->name);
1612
1613	log_type(av_log_obj, opt, parent_type);
1614
1615	av_log(av_log_obj, AV_LOG_INFO32, "%c%c%c%c%c%c%c%c%c%c%c",
1616	(opt->flags & AV_OPT_FLAG_ENCODING_PARAM(1 << 0)) ? 'E' : '.',
1617	(opt->flags & AV_OPT_FLAG_DECODING_PARAM(1 << 1)) ? 'D' : '.',
1618	(opt->flags & AV_OPT_FLAG_FILTERING_PARAM(1 << 16)) ? 'F' : '.',
1619	(opt->flags & AV_OPT_FLAG_VIDEO_PARAM(1 << 4)) ? 'V' : '.',
1620	(opt->flags & AV_OPT_FLAG_AUDIO_PARAM(1 << 3)) ? 'A' : '.',
1621	(opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM(1 << 5)) ? 'S' : '.',
1622	(opt->flags & AV_OPT_FLAG_EXPORT(1 << 6)) ? 'X' : '.',
1623	(opt->flags & AV_OPT_FLAG_READONLY(1 << 7)) ? 'R' : '.',
1624	(opt->flags & AV_OPT_FLAG_BSF_PARAM(1 << 8)) ? 'B' : '.',
1625	(opt->flags & AV_OPT_FLAG_RUNTIME_PARAM(1 << 15)) ? 'T' : '.',
1626	(opt->flags & AV_OPT_FLAG_DEPRECATED(1 << 17)) ? 'P' : '.');
1627
1628	if (opt->help)
1629	av_log(av_log_obj, AV_LOG_INFO32, " %s", opt->help);
1630
1631	if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ(1 << 1)) >= 0) {
1632	switch (opt->type) {
1633	case AV_OPT_TYPE_INT:
1634	case AV_OPT_TYPE_UINT:
1635	case AV_OPT_TYPE_INT64:
1636	case AV_OPT_TYPE_UINT64:
1637	case AV_OPT_TYPE_DOUBLE:
1638	case AV_OPT_TYPE_FLOAT:
1639	case AV_OPT_TYPE_RATIONAL:
1640	for (i = 0; i < r->nb_ranges; i++) {
1641	av_log(av_log_obj, AV_LOG_INFO32, " (from ");
1642	log_value(av_log_obj, AV_LOG_INFO32, r->range[i]->value_min);
1643	av_log(av_log_obj, AV_LOG_INFO32, " to ");
1644	log_value(av_log_obj, AV_LOG_INFO32, r->range[i]->value_max);
1645	av_log(av_log_obj, AV_LOG_INFO32, ")");
1646	}
1647	break;
1648	}
1649	av_opt_freep_ranges(&r);
1650	}
1651
1652	log_default(obj, av_log_obj, opt);
1653
1654	av_log(av_log_obj, AV_LOG_INFO32, "\n");
1655	if (opt->unit && opt->type != AV_OPT_TYPE_CONST)
1656	opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags, opt->type);
1657	}
1658	}
1659
1660	int av_opt_show2(void obj, void av_log_obj, int req_flags, int rej_flags)
1661	{
1662	if (!obj)
1663	return -1;
1664
1665	av_log(av_log_obj, AV_LOG_INFO32, "%s AVOptions:\n", ((AVClass *)obj)->class_name);
1666
1667	opt_list(obj, av_log_obj, NULL((void*)0), req_flags, rej_flags, -1);
1668
1669	return 0;
1670	}
1671
1672	void av_opt_set_defaults(void *s)
1673	{
1674	av_opt_set_defaults2(s, 0, 0);
1675	}
1676
1677	void av_opt_set_defaults2(void *s, int mask, int flags)
1678	{
1679	const AVOption opt = NULL((void)0);
1680	while ((opt = av_opt_next(s, opt))) {
1681	void dst = ((uint8_t)s) + opt->offset;
1682
1683	if ((opt->flags & mask) != flags)
1684	continue;
1685
1686	if (opt->flags & AV_OPT_FLAG_READONLY(1 << 7))
1687	continue;
1688
1689	if (opt->type & AV_OPT_TYPE_FLAG_ARRAY) {
1690	const AVOptionArrayDef *arr = opt->default_val.arr;
1691	const char sep = opt_array_sep(opt);
1692
1693	av_assert0(sep && sep != '\\' &&do { if (!(sep && sep != '\\' && (sep < 'a' \|\| sep > 'z') && (sep < 'A' \|\| sep > 'Z') && (sep < '0' \|\| sep > '9'))) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n" , "sep && sep != '\\\\' && (sep < 'a' \|\| sep > 'z') && (sep < 'A' \|\| sep > 'Z') && (sep < '0' \|\| sep > '9')" , "/root/firefox-clang/media/ffvpx/libavutil/opt.c", 1696); abort (); } } while (0)
1694	(sep < 'a' \|\| sep > 'z') &&do { if (!(sep && sep != '\\' && (sep < 'a' \|\| sep > 'z') && (sep < 'A' \|\| sep > 'Z') && (sep < '0' \|\| sep > '9'))) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n" , "sep && sep != '\\\\' && (sep < 'a' \|\| sep > 'z') && (sep < 'A' \|\| sep > 'Z') && (sep < '0' \|\| sep > '9')" , "/root/firefox-clang/media/ffvpx/libavutil/opt.c", 1696); abort (); } } while (0)
1695	(sep < 'A' \|\| sep > 'Z') &&do { if (!(sep && sep != '\\' && (sep < 'a' \|\| sep > 'z') && (sep < 'A' \|\| sep > 'Z') && (sep < '0' \|\| sep > '9'))) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n" , "sep && sep != '\\\\' && (sep < 'a' \|\| sep > 'z') && (sep < 'A' \|\| sep > 'Z') && (sep < '0' \|\| sep > '9')" , "/root/firefox-clang/media/ffvpx/libavutil/opt.c", 1696); abort (); } } while (0)
1696	(sep < '0' \|\| sep > '9'))do { if (!(sep && sep != '\\' && (sep < 'a' \|\| sep > 'z') && (sep < 'A' \|\| sep > 'Z') && (sep < '0' \|\| sep > '9'))) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n" , "sep && sep != '\\\\' && (sep < 'a' \|\| sep > 'z') && (sep < 'A' \|\| sep > 'Z') && (sep < '0' \|\| sep > '9')" , "/root/firefox-clang/media/ffvpx/libavutil/opt.c", 1696); abort (); } } while (0);
1697
1698	if (arr && arr->def)
1699	opt_set_array(s, s, opt, arr->def, dst);
1700
1701	continue;
1702	}
1703
1704	switch (opt->type) {
1705	case AV_OPT_TYPE_CONST:
1706	/* Nothing to be done here */
1707	break;
1708	case AV_OPT_TYPE_BOOL:
1709	case AV_OPT_TYPE_FLAGS:
1710	case AV_OPT_TYPE_INT:
1711	case AV_OPT_TYPE_UINT:
1712	case AV_OPT_TYPE_INT64:
1713	case AV_OPT_TYPE_UINT64:
1714	case AV_OPT_TYPE_DURATION:
1715	case AV_OPT_TYPE_PIXEL_FMT:
1716	case AV_OPT_TYPE_SAMPLE_FMT:
1717	write_number(s, opt, dst, 1, 1, opt->default_val.i64);
1718	break;
1719	case AV_OPT_TYPE_DOUBLE:
1720	case AV_OPT_TYPE_FLOAT: {
1721	double val;
1722	val = opt->default_val.dbl;
1723	write_number(s, opt, dst, val, 1, 1);
1724	}
1725	break;
1726	case AV_OPT_TYPE_RATIONAL: {
1727	AVRational val;
1728	val = av_d2q(opt->default_val.dbl, INT_MAX2147483647);
1729	write_number(s, opt, dst, 1, val.den, val.num);
1730	}
1731	break;
1732	case AV_OPT_TYPE_COLOR:
1733	set_string_color(s, opt, opt->default_val.str, dst);
1734	break;
1735	case AV_OPT_TYPE_STRING:
1736	set_string(s, opt, opt->default_val.str, dst);
1737	break;
1738	case AV_OPT_TYPE_IMAGE_SIZE:
1739	set_string_image_size(s, opt, opt->default_val.str, dst);
1740	break;
1741	case AV_OPT_TYPE_VIDEO_RATE:
1742	set_string_video_rate(s, opt, opt->default_val.str, dst);
1743	break;
1744	case AV_OPT_TYPE_BINARY:
1745	set_string_binary(s, opt, opt->default_val.str, dst);
1746	break;
1747	case AV_OPT_TYPE_CHLAYOUT:
1748	set_string_channel_layout(s, opt, opt->default_val.str, dst);
1749	break;
1750	case AV_OPT_TYPE_DICT:
1751	set_string_dict(s, opt, opt->default_val.str, dst);
1752	break;
1753	default:
1754	av_log(s, AV_LOG_DEBUG48, "AVOption type %d of option %s not implemented yet\n",
1755	opt->type, opt->name);
1756	}
1757	}
1758	}
1759
1760	/**
1761	* Store the value in the field in ctx that is named like key.
1762	* ctx must be an AVClass context, storing is done using AVOptions.
1763	*
1764	* @param buf the string to parse, buf will be updated to point at the
1765	* separator just after the parsed key/value pair
1766	* @param key_val_sep a 0-terminated list of characters used to
1767	* separate key from value
1768	* @param pairs_sep a 0-terminated list of characters used to separate
1769	* two pairs from each other
1770	* @return 0 if the key/value pair has been successfully parsed and
1771	* set, or a negative value corresponding to an AVERROR code in case
1772	* of error:
1773	* AVERROR(EINVAL) if the key/value pair cannot be parsed,
1774	* the error code issued by av_opt_set() if the key/value pair
1775	* cannot be set
1776	*/
1777	static int parse_key_value_pair(void ctx, const char *buf,
1778	const char key_val_sep, const char pairs_sep)
1779	{
1780	char *key = av_get_token(buf, key_val_sep);
1781	char *val;
1782	int ret;
1783
1784	if (!key)
1785	return AVERROR(ENOMEM)(-(12));
1786
1787	if (key && strspn(buf, key_val_sep)) {
1788	(*buf)++;
1789	val = av_get_token(buf, pairs_sep);
1790	if (!val) {
1791	av_freep(&key);
1792	return AVERROR(ENOMEM)(-(12));
1793	}
1794	} else {
1795	av_log(ctx, AV_LOG_ERROR16, "Missing key or no key/value separator found after key '%s'\n", key);
1796	av_free(key);
1797	return AVERROR(EINVAL)(-(22));
1798	}
1799
1800	av_log(ctx, AV_LOG_DEBUG48, "Setting entry with key '%s' to value '%s'\n", key, val);
1801
1802	ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN(1 << 0));
1803	if (ret == AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24))))
1804	av_log(ctx, AV_LOG_ERROR16, "Key '%s' not found.\n", key);
1805
1806	av_free(key);
1807	av_free(val);
1808	return ret;
1809	}
1810
1811	int av_set_options_string(void ctx, const char opts,
1812	const char key_val_sep, const char pairs_sep)
1813	{
1814	int ret, count = 0;
1815
1816	if (!opts)
1817	return 0;
1818
1819	while (*opts) {
1820	if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
1821	return ret;
1822	count++;
1823
1824	if (*opts)
1825	opts++;
1826	}
1827
1828	return count;
1829	}
1830
1831	#define WHITESPACES" \n\t\r" " \n\t\r"
1832
1833	static int is_key_char(char c)
1834	{
1835	return (unsigned)((c \| 32) - 'a') < 26 \|\|
1836	(unsigned)(c - '0') < 10 \|\|
1837	c == '-' \|\| c == '_' \|\| c == '/' \|\| c == '.';
1838	}
1839
1840	/**
1841	* Read a key from a string.
1842	*
1843	* The key consists of is_key_char characters and must be terminated by a
1844	* character from the delim string; spaces are ignored.
1845	*
1846	* @return 0 for success (even with ellipsis), <0 for failure
1847	*/
1848	static int get_key(const char *ropts, const char delim, char **rkey)
1849	{
1850	const char opts = ropts;
1851	const char key_start, key_end;
1852
1853	key_start = opts += strspn(opts, WHITESPACES" \n\t\r");
1854	while (is_key_char(*opts))
1855	opts++;
1856	key_end = opts;
1857	opts += strspn(opts, WHITESPACES" \n\t\r");
1858	if (!opts \|\| !strchr(delim, opts))
1859	return AVERROR(EINVAL)(-(22));
1860	opts++;
1861	if (!(*rkey = av_malloc(key_end - key_start + 1)))
1862	return AVERROR(ENOMEM)(-(12));
1863	memcpy(*rkey, key_start, key_end - key_start);
1864	(*rkey)[key_end - key_start] = 0;
1865	*ropts = opts;
1866	return 0;
1867	}
1868
1869	int av_opt_get_key_value(const char **ropts,
1870	const char key_val_sep, const char pairs_sep,
1871	unsigned flags,
1872	char rkey, char rval)
1873	{
1874	int ret;
1875	char key = NULL((void)0), *val;
1876	const char opts = ropts;
1877
1878	if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
1879	!(flags & AV_OPT_FLAG_IMPLICIT_KEY))
1880	return AVERROR(EINVAL)(-(22));
1881	if (!(val = av_get_token(&opts, pairs_sep))) {
1882	av_free(key);
1883	return AVERROR(ENOMEM)(-(12));
1884	}
1885	*ropts = opts;
1886	*rkey = key;
1887	*rval = val;
1888	return 0;
1889	}
1890
1891	int av_opt_set_from_string(void ctx, const char opts,
1892	const char const shorthand,
1893	const char key_val_sep, const char pairs_sep)
1894	{
1895	int ret, count = 0;
1896	const char dummy_shorthand = NULL((void)0);
1897	const char *key;
1898
1899	if (!opts)
1900	return 0;
1901	if (!shorthand)
1902	shorthand = &dummy_shorthand;
1903
1904	while (*opts) {
1905	char parsed_key, value;
1906	ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
1907	*shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
1908	&parsed_key, &value);
1909	if (ret < 0) {
1910	if (ret == AVERROR(EINVAL)(-(22)))
1911	av_log(ctx, AV_LOG_ERROR16, "No option name near '%s'\n", opts);
1912	else
1913	av_log(ctx, AV_LOG_ERROR16, "Unable to parse '%s': %s\n", opts,
1914	av_err2str(ret)av_make_error_string((char[64]){0}, 64, ret));
1915	return ret;
1916	}
1917	if (*opts)
1918	opts++;
1919	if (parsed_key) {
1920	key = parsed_key;
1921	while (shorthand) / discard all remaining shorthand */
1922	shorthand++;
1923	} else {
1924	key = *(shorthand++);
1925	}
1926
1927	av_log(ctx, AV_LOG_DEBUG48, "Setting '%s' to value '%s'\n", key, value);
1928	if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
1929	if (ret == AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24))))
1930	av_log(ctx, AV_LOG_ERROR16, "Option '%s' not found\n", key);
1931	av_free(value);
1932	av_free(parsed_key);
1933	return ret;
1934	}
1935
1936	av_free(value);
1937	av_free(parsed_key);
1938	count++;
1939	}
1940	return count;
1941	}
1942
1943	void av_opt_free(void *obj)
1944	{
1945	const AVOption o = NULL((void)0);
1946	while ((o = av_opt_next(obj, o))) {
1947	void pitem = (uint8_t )obj + o->offset;
1948
1949	if (o->type & AV_OPT_TYPE_FLAG_ARRAY)
1950	opt_free_array(o, pitem, opt_array_pcount(pitem));
1951	else
1952	opt_free_elem(o->type, pitem);
1953	}
1954	}
1955
1956	int av_opt_set_dict2(void obj, AVDictionary *options, int search_flags)
1957	{
1958	const AVDictionaryEntry t = NULL((void)0);
1959	AVDictionary tmp = NULL((void)0);
1960	int ret;
1961
1962	if (!options)
1963	return 0;
1964
1965	while ((t = av_dict_iterate(*options, t))) {
1966	ret = av_opt_set(obj, t->key, t->value, search_flags);
1967	if (ret == AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24))))
1968	ret = av_dict_set(&tmp, t->key, t->value, AV_DICT_MULTIKEY64);
1969	if (ret < 0) {
1970	av_log(obj, AV_LOG_ERROR16, "Error setting option %s to value %s.\n", t->key, t->value);
1971	av_dict_free(&tmp);
1972	return ret;
1973	}
1974	}
1975	av_dict_free(options);
1976	*options = tmp;
1977	return 0;
1978	}
1979
1980	int av_opt_set_dict(void obj, AVDictionary *options)
1981	{
1982	return av_opt_set_dict2(obj, options, 0);
1983	}
1984
1985	const AVOption av_opt_find(void obj, const char name, const char unit,
1986	int opt_flags, int search_flags)
1987	{
1988	return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL((void*)0));
1989	}
1990
1991	const AVOption av_opt_find2(void obj, const char name, const char unit,
1992	int opt_flags, int search_flags, void **target_obj)
1993	{
1994	const AVClass *c;
1995	const AVOption o = NULL((void)0);
1996
1997	if(!obj)
1998	return NULL((void*)0);
1999
2000	c= (AVClass*)obj;
2001
2002	if (!c)
2003	return NULL((void*)0);
2004
2005	if (search_flags & AV_OPT_SEARCH_CHILDREN(1 << 0)) {
2006	if (search_flags & AV_OPT_SEARCH_FAKE_OBJ(1 << 1)) {
2007	void iter = NULL((void)0);
2008	const AVClass *child;
2009	while (child = av_opt_child_class_iterate(c, &iter))
2010	if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL((void*)0)))
2011	return o;
2012	} else {
2013	void child = NULL((void)0);
2014	while (child = av_opt_child_next(obj, child))
2015	if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
2016	return o;
2017	}
2018	}
2019
2020	while (o = av_opt_next(obj, o)) {
2021	if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
2022	((!unit && o->type != AV_OPT_TYPE_CONST) \|\|
2023	(unit && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
2024	if (target_obj) {
2025	if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ(1 << 1)))
2026	*target_obj = obj;
2027	else
2028	target_obj = NULL((void)0);
2029	}
2030	return o;
2031	}
2032	}
2033	return NULL((void*)0);
2034	}
2035
2036	void av_opt_child_next(void obj, void *prev)
2037	{
2038	const AVClass c = (AVClass **)obj;
2039	if (c->child_next)
2040	return c->child_next(obj, prev);
2041	return NULL((void*)0);
2042	}
2043
2044	const AVClass av_opt_child_class_iterate(const AVClass parent, void **iter)
2045	{
2046	if (parent->child_class_iterate)
2047	return parent->child_class_iterate(iter);
2048	return NULL((void*)0);
2049	}
2050
2051	#if FF_API_OPT_PTR(60 < 61)
2052	void av_opt_ptr(const AVClass class, void obj, const char name)
2053	{
2054	const AVOption opt= av_opt_find2(&class, name, NULL((void)0), 0, AV_OPT_SEARCH_FAKE_OBJ(1 << 1), NULL((void*)0));
2055
2056	// no direct access to array-type options
2057	if (!opt \|\| (opt->type & AV_OPT_TYPE_FLAG_ARRAY))
2058	return NULL((void*)0);
2059	return (uint8_t*)obj + opt->offset;
2060	}
2061	#endif
2062
2063	static int opt_copy_elem(void *logctx, enum AVOptionType type,
2064	void dst, const void src)
2065	{
2066	if (type == AV_OPT_TYPE_STRING) {
2067	const char src_str = (const char const )src;
2068	char dstp = (char )dst;
2069	if (*dstp != src_str)
2070	av_freep(dstp);
2071	if (src_str) {
2072	*dstp = av_strdup(src_str);
2073	if (!*dstp)
2074	return AVERROR(ENOMEM)(-(12));
2075	}
2076	} else if (type == AV_OPT_TYPE_BINARY) {
2077	const uint8_t const src8 = (const uint8_t const )src;
2078	uint8_t dst8 = (uint8_t )dst;
2079	int len = (const int )(src8 + 1);
2080	if (dst8 != src8)
2081	av_freep(dst8);
2082	dst8 = av_memdup(src8, len);
2083	if (len && !*dst8) {
2084	(int )(dst8 + 1) = 0;
2085	return AVERROR(ENOMEM)(-(12));
2086	}
2087	(int )(dst8 + 1) = len;
2088	} else if (type == AV_OPT_TYPE_CONST) {
2089	// do nothing
2090	} else if (type == AV_OPT_TYPE_DICT) {
2091	const AVDictionary sdict = (const AVDictionary * const *)src;
2092	AVDictionary ddictp = (AVDictionary )dst;
2093	if (sdict != *ddictp)
2094	av_dict_free(ddictp);
2095	ddictp = NULL((void)0);
2096	return av_dict_copy(ddictp, sdict, 0);
2097	} else if (type == AV_OPT_TYPE_CHLAYOUT) {
2098	if (dst != src)
2099	return av_channel_layout_copy(dst, src);
2100	} else if (opt_is_pod(type)) {
2101	size_t size = opt_type_desc[type].size;
2102	memcpy(dst, src, size);
2103	} else {
2104	av_log(logctx, AV_LOG_ERROR16, "Unhandled option type: %d\n", type);
2105	return AVERROR(EINVAL)(-(22));
2106	}
2107
2108	return 0;
2109	}
2110
2111	static int opt_copy_array(void logctx, const AVOption o,
2112	void *pdst, const void const *psrc)
2113	{
2114	unsigned nb_elems = *opt_array_pcount(psrc);
2115	void dst = NULL((void)0);
2116	int ret;
2117
2118	if (pdst == psrc) {
2119	pdst = NULL((void)0);
2120	*opt_array_pcount(pdst) = 0;
2121	}
2122
2123	opt_free_array(o, pdst, opt_array_pcount(pdst));
2124
2125	dst = av_calloc(nb_elems, opt_type_desc[TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY)].size);
2126	if (!dst)
2127	return AVERROR(ENOMEM)(-(12));
2128
2129	for (unsigned i = 0; i < nb_elems; i++) {
2130	ret = opt_copy_elem(logctx, TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY),
2131	opt_array_pelem(o, dst, i),
2132	opt_array_pelem(o, (void*)psrc, i));
2133	if (ret < 0) {
2134	opt_free_array(o, &dst, &nb_elems);
2135	return ret;
2136	}
2137	}
2138
2139	*pdst = dst;
2140	*opt_array_pcount(pdst) = nb_elems;
2141
2142	return 0;
2143	}
2144
2145	int av_opt_copy(void dst, const void src)
2146	{
2147	const AVOption o = NULL((void)0);
2148	const AVClass *c;
2149	int ret = 0;
2150
2151	if (!src)
2152	return AVERROR(EINVAL)(-(22));
2153
2154	c = (AVClass *)src;
2155	if (!c \|\| c != (AVClass *)dst)
2156	return AVERROR(EINVAL)(-(22));
2157
2158	while ((o = av_opt_next(src, o))) {
2159	void field_dst = (uint8_t )dst + o->offset;
2160	void field_src = (uint8_t )src + o->offset;
2161
2162	int err = (o->type & AV_OPT_TYPE_FLAG_ARRAY) ?
2163	opt_copy_array(dst, o, field_dst, field_src) :
2164	opt_copy_elem (dst, o->type, field_dst, field_src);
2165	if (err < 0)
2166	ret = err;
2167	}
2168	return ret;
2169	}
2170
2171	int av_opt_get_array_size(void obj, const char name, int search_flags,
2172	unsigned int *out_val)
2173	{
2174	void target_obj, parray;
2175	const AVOption *o;
2176
2177	o = av_opt_find2(obj, name, NULL((void*)0), 0, search_flags, &target_obj);
2178	if (!o \|\| !target_obj)
2179	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
2180	if (!(o->type & AV_OPT_TYPE_FLAG_ARRAY))
2181	return AVERROR(EINVAL)(-(22));
2182
2183	parray = (uint8_t *)target_obj + o->offset;
2184	out_val = opt_array_pcount(parray);
2185
2186	return 0;
2187	}
2188
2189	int av_opt_get_array(void obj, const char name, int search_flags,
2190	unsigned int start_elem, unsigned int nb_elems,
2191	enum AVOptionType out_type, void *out_val)
2192	{
2193	const size_t elem_size_out = opt_type_desc[TYPE_BASE(out_type)((out_type) & ~AV_OPT_TYPE_FLAG_ARRAY)].size;
2194
2195	const AVOption *o;
2196	void *target_obj;
2197
2198	const void *parray;
2199	unsigned array_size;
2200
2201	int ret;
2202
2203	o = av_opt_find2(obj, name, NULL((void*)0), 0, search_flags, &target_obj);
2204	if (!o \|\| !target_obj)
2205	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
2206	if (!(o->type & AV_OPT_TYPE_FLAG_ARRAY) \|\|
2207	(out_type & AV_OPT_TYPE_FLAG_ARRAY))
2208	return AVERROR(EINVAL)(-(22));
2209
2210	parray = (uint8_t *)target_obj + o->offset;
2211	array_size = *opt_array_pcount(parray);
2212
2213	if (start_elem >= array_size \|\|
2214	array_size - start_elem < nb_elems)
2215	return AVERROR(EINVAL)(-(22));
2216
2217	for (unsigned i = 0; i < nb_elems; i++) {
2218	const void src = opt_array_pelem(o, (void**)parray, start_elem + i);
2219	void dst = (uint8_t)out_val + i * elem_size_out;
2220
2221	if (out_type == TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY)) {
2222	ret = opt_copy_elem(obj, out_type, dst, src);
2223	if (ret < 0)
2224	goto fail;
2225	} else if (out_type == AV_OPT_TYPE_STRING) {
2226	uint8_t buf[128], *out = buf;
2227
2228	ret = opt_get_elem(o, &out, sizeof(buf), src, search_flags);
2229	if (ret < 0)
2230	goto fail;
2231
2232	if (out == buf) {
2233	out = av_strdup(buf);
2234	if (!out) {
2235	ret = AVERROR(ENOMEM)(-(12));
2236	goto fail;
2237	}
2238	}
2239
2240	(uint8_t*)dst = out;
2241	} else if (out_type == AV_OPT_TYPE_INT64 \|\|
2242	out_type == AV_OPT_TYPE_DOUBLE \|\|
2243	out_type == AV_OPT_TYPE_RATIONAL) {
2244	double num = 1.0;
2245	int den = 1;
2246	int64_t intnum = 1;
2247
2248	ret = read_number(o, src, &num, &den, &intnum);
2249	if (ret < 0)
2250	goto fail;
2251
2252	switch (out_type) {
2253	case AV_OPT_TYPE_INT64:
2254	(int64_t)dst = (num == den) ? intnum : num * intnum / den;
2255	break;
2256	case AV_OPT_TYPE_DOUBLE:
2257	(double)dst = num * intnum / den;
2258	break;
2259	case AV_OPT_TYPE_RATIONAL:
2260	(AVRational)dst = (num == 1.0 && (int)intnum == intnum) ?
2261	(AVRational){ intnum, den } :
2262	double_to_rational(num * intnum / den);
2263	break;
2264	default: av_assert0(0)do { if (!(0)) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n" , "0", "/root/firefox-clang/media/ffvpx/libavutil/opt.c", 2264 ); abort(); } } while (0);
2265	}
2266	} else
2267	return AVERROR(ENOSYS)(-(38));
2268	}
2269
2270	return 0;
2271	fail:
2272	for (unsigned i = 0; i < nb_elems; i++)
2273	opt_free_elem(out_type, (uint8_t)out_val + i elem_size_out);
2274	return ret;
2275	}
2276
2277	int av_opt_set_array(void obj, const char name, int search_flags,
2278	unsigned int start_elem, unsigned int nb_elems,
2279	enum AVOptionType val_type, const void *val)
2280	{
2281	const size_t elem_size_val = opt_type_desc[TYPE_BASE(val_type)((val_type) & ~AV_OPT_TYPE_FLAG_ARRAY)].size;
2282
2283	const AVOption *o;
2284	const AVOptionArrayDef *arr;
2285	void *target_obj;
2286
2287	void *parray;
2288	void *new_elems;
2289	unsigned *array_size, new_size;
2290	size_t elem_size;
2291
2292	int ret = 0;
2293
2294	ret = opt_set_init(obj, name, search_flags, 0, &target_obj, &o, &parray);
2295	if (ret < 0)
2296	return ret;
2297
2298	if (!(o->type & AV_OPT_TYPE_FLAG_ARRAY) \|\|
2299	(val_type & AV_OPT_TYPE_FLAG_ARRAY))
2300	return AVERROR(EINVAL)(-(22));
2301
2302	arr = o->default_val.arr;
2303	array_size = opt_array_pcount(parray);
2304	elem_size = opt_type_desc[TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY)].size;
2305
2306	if (start_elem > *array_size)
2307	return AVERROR(EINVAL)(-(22));
2308
2309	// compute new array size
2310	if (!val) {
2311	if (*array_size - start_elem < nb_elems)
2312	return AVERROR(EINVAL)(-(22));
2313
2314	new_size = *array_size - nb_elems;
2315	} else if (search_flags & AV_OPT_ARRAY_REPLACE(1 << 3)) {
2316	if (start_elem >= UINT_MAX(2147483647 *2U +1U) - nb_elems)
2317	return AVERROR(EINVAL)(-(22));
2318
2319	new_size = FFMAX(array_size, start_elem + nb_elems)((array_size) > (start_elem + nb_elems) ? (*array_size) : (start_elem + nb_elems));
2320	} else {
2321	if (nb_elems >= UINT_MAX(2147483647 2U +1U) - array_size)
2322	return AVERROR(EINVAL)(-(22));
2323
2324	new_size = *array_size + nb_elems;
2325	}
2326
2327	if (arr &&
2328	((arr->size_max && new_size > arr->size_max) \|\|
2329	(arr->size_min && new_size < arr->size_min)))
2330	return AVERROR(EINVAL)(-(22));
2331
2332	// desired operation is shrinking the array
2333	if (!val) {
2334	void array = (void**)parray;
2335
2336	for (unsigned i = 0; i < nb_elems; i++) {
2337	opt_free_elem(o->type,
2338	opt_array_pelem(o, array, start_elem + i));
2339	}
2340
2341	if (new_size > 0) {
2342	memmove(opt_array_pelem(o, array, start_elem),
2343	opt_array_pelem(o, array, start_elem + nb_elems),
2344	elem_size * (*array_size - start_elem - nb_elems));
2345
2346	array = av_realloc_array(array, new_size, elem_size);
2347	if (!array)
2348	return AVERROR(ENOMEM)(-(12));
2349
2350	(void*)parray = array;
2351	} else
2352	av_freep(parray);
2353
2354	*array_size = new_size;
2355
2356	return 0;
2357	}
2358
2359	// otherwise, desired operation is insert/replace;
2360	// first, store new elements in a separate array to simplify
2361	// rollback on failure
2362	new_elems = av_calloc(nb_elems, elem_size);
2363	if (!new_elems)
2364	return AVERROR(ENOMEM)(-(12));
2365
2366	// convert/validate each new element
2367	for (unsigned i = 0; i < nb_elems; i++) {
2368	void *dst = opt_array_pelem(o, new_elems, i);
2369	const void src = (uint8_t)val + i * elem_size_val;
2370
2371	double num = 1.0;
2372	int den = 1;
2373	int64_t intnum = 1;
2374
2375	if (val_type == TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY)) {
2376	int err;
2377
2378	ret = opt_copy_elem(obj, val_type, dst, src);
2379	if (ret < 0)
2380	goto fail;
2381
2382	// validate the range for numeric options
2383	err = read_number(o, dst, &num, &den, &intnum);
2384	if (err >= 0 && TYPE_BASE(o->type)((o->type) & ~AV_OPT_TYPE_FLAG_ARRAY) != AV_OPT_TYPE_FLAGS &&
2385	(!den \|\| o->max * den < num * intnum \|\| o->min * den > num * intnum)) {
2386	num = den ? num * intnum / den : (num && intnum ? INFINITY(__builtin_inff()) : NAN(__builtin_nanf("")));
2387	av_log(obj, AV_LOG_ERROR16, "Cannot set array element %u for "
2388	"parameter '%s': value %f out of range [%g - %g]\n",
2389	start_elem + i, o->name, num, o->min, o->max);
2390	ret = AVERROR(ERANGE)(-(34));
2391	goto fail;
2392	}
2393	} else if (val_type == AV_OPT_TYPE_STRING) {
2394	ret = opt_set_elem(obj, target_obj, o, (const char *)src, dst);
2395	if (ret < 0)
2396	goto fail;
2397	} else if (val_type == AV_OPT_TYPE_INT \|\|
2398	val_type == AV_OPT_TYPE_INT64 \|\|
2399	val_type == AV_OPT_TYPE_FLOAT \|\|
2400	val_type == AV_OPT_TYPE_DOUBLE \|\|
2401	val_type == AV_OPT_TYPE_RATIONAL) {
2402
2403	switch (val_type) {
2404	case AV_OPT_TYPE_INT: intnum = (int)src; break;
2405	case AV_OPT_TYPE_INT64: intnum = (int64_t)src; break;
2406	case AV_OPT_TYPE_FLOAT: num = (float)src; break;
2407	case AV_OPT_TYPE_DOUBLE: num = (double)src; break;
2408	case AV_OPT_TYPE_RATIONAL: intnum = ((AVRational*)src)->num;
2409	den = ((AVRational*)src)->den; break;
2410	default: av_assert0(0)do { if (!(0)) { av_log(((void*)0), 0, "Assertion %s failed at %s:%d\n" , "0", "/root/firefox-clang/media/ffvpx/libavutil/opt.c", 2410 ); abort(); } } while (0);
2411	}
2412
2413	ret = write_number(obj, o, dst, num, den, intnum);
2414	if (ret < 0)
2415	goto fail;
2416	} else {
2417	ret = AVERROR(ENOSYS)(-(38));
2418	goto fail;
2419	}
2420	}
2421
2422	// commit new elements to the array
2423	if (start_elem == 0 && nb_elems == new_size) {
2424	// replacing the existing array entirely
2425	opt_free_array(o, parray, array_size);
2426	(void*)parray = new_elems;
2427	*array_size = nb_elems;
2428
2429	new_elems = NULL((void*)0);
2430	nb_elems = 0;
2431	} else {
2432	void array = av_realloc_array((void**)parray, new_size, elem_size);
2433	if (!array) {
2434	ret = AVERROR(ENOMEM)(-(12));
2435	goto fail;
2436	}
2437
2438	if (search_flags & AV_OPT_ARRAY_REPLACE(1 << 3)) {
2439	// free the elements being overwritten
2440	for (unsigned i = start_elem; i < FFMIN(start_elem + nb_elems, array_size)((start_elem + nb_elems) > (array_size) ? (*array_size) : (start_elem + nb_elems)); i++)
2441	opt_free_elem(o->type, opt_array_pelem(o, array, i));
2442	} else {
2443	// shift existing elements to the end
2444	memmove(opt_array_pelem(o, array, start_elem + nb_elems),
2445	opt_array_pelem(o, array, start_elem),
2446	elem_size * (*array_size - start_elem));
2447	}
2448
2449	memcpy((uint8_t)array + elem_size start_elem, new_elems, elem_size * nb_elems);
2450
2451	av_freep(&new_elems);
2452	nb_elems = 0;
2453
2454	(void*)parray = array;
2455	*array_size = new_size;
2456	}
2457
2458	fail:
2459	opt_free_array(o, &new_elems, &nb_elems);
2460
2461	return ret;
2462	}
2463
2464	int av_opt_query_ranges(AVOptionRanges *ranges_arg, void obj, const char *key, int flags)
2465	{
2466	int ret;
2467	const AVClass c = (AVClass**)obj;
2468	int (callback)(AVOptionRanges , void obj, const char *key, int flags) = c->query_ranges;
2469
2470	if (!callback)
2471	callback = av_opt_query_ranges_default;
2472
2473	ret = callback(ranges_arg, obj, key, flags);
2474	if (ret >= 0) {
2475	if (!(flags & AV_OPT_MULTI_COMPONENT_RANGE(1 << 12)))
2476	ret = 1;
2477	(*ranges_arg)->nb_components = ret;
2478	}
2479	return ret;
2480	}
2481
2482	int av_opt_query_ranges_default(AVOptionRanges *ranges_arg, void obj, const char *key, int flags)
2483	{
2484	AVOptionRanges ranges = av_mallocz(sizeof(ranges));
2485	AVOptionRange *range_array = av_mallocz(sizeof(void));
2486	AVOptionRange range = av_mallocz(sizeof(range));
2487	const AVOption field = av_opt_find(obj, key, NULL((void)0), 0, flags);
2488	int ret;
2489
2490	ranges_arg = NULL((void)0);
2491
2492	if (!ranges \|\| !range \|\| !range_array \|\| !field) {
2493	ret = AVERROR(ENOMEM)(-(12));
2494	goto fail;
2495	}
2496
2497	ranges->range = range_array;
2498	ranges->range[0] = range;
2499	ranges->nb_ranges = 1;
2500	ranges->nb_components = 1;
2501	range->is_range = 1;
2502	range->value_min = field->min;
2503	range->value_max = field->max;
2504
2505	switch (field->type) {
2506	case AV_OPT_TYPE_BOOL:
2507	case AV_OPT_TYPE_INT:
2508	case AV_OPT_TYPE_UINT:
2509	case AV_OPT_TYPE_INT64:
2510	case AV_OPT_TYPE_UINT64:
2511	case AV_OPT_TYPE_PIXEL_FMT:
2512	case AV_OPT_TYPE_SAMPLE_FMT:
2513	case AV_OPT_TYPE_FLOAT:
2514	case AV_OPT_TYPE_DOUBLE:
2515	case AV_OPT_TYPE_DURATION:
2516	case AV_OPT_TYPE_COLOR:
2517	break;
2518	case AV_OPT_TYPE_STRING:
2519	range->component_min = 0;
2520	range->component_max = 0x10FFFF; // max unicode value
2521	range->value_min = -1;
2522	range->value_max = INT_MAX2147483647;
2523	break;
2524	case AV_OPT_TYPE_RATIONAL:
2525	range->component_min = INT_MIN(-2147483647 -1);
2526	range->component_max = INT_MAX2147483647;
2527	break;
2528	case AV_OPT_TYPE_IMAGE_SIZE:
2529	range->component_min = 0;
2530	range->component_max = INT_MAX2147483647/128/8;
2531	range->value_min = 0;
2532	range->value_max = INT_MAX2147483647/8;
2533	break;
2534	case AV_OPT_TYPE_VIDEO_RATE:
2535	range->component_min = 1;
2536	range->component_max = INT_MAX2147483647;
2537	range->value_min = 1;
2538	range->value_max = INT_MAX2147483647;
2539	break;
2540	default:
2541	ret = AVERROR(ENOSYS)(-(38));
2542	goto fail;
2543	}
2544
2545	*ranges_arg = ranges;
2546	return 1;
2547	fail:
2548	av_free(ranges);
2549	av_free(range);
2550	av_free(range_array);
2551	return ret;
2552	}
2553
2554	void av_opt_freep_ranges(AVOptionRanges **rangesp)
2555	{
2556	int i;
2557	AVOptionRanges ranges = rangesp;
2558
2559	if (!ranges)
2560	return;
2561
2562	for (i = 0; i < ranges->nb_ranges * ranges->nb_components; i++) {
2563	AVOptionRange *range = ranges->range[i];
2564	if (range) {
2565	av_freep(&range->str);
2566	av_freep(&ranges->range[i]);
2567	}
2568	}
2569	av_freep(&ranges->range);
2570	av_freep(rangesp);
2571	}
2572
2573	int av_opt_is_set_to_default(void obj, const AVOption o)
2574	{
2575	int64_t i64;
2576	double d;
2577	AVRational q;
2578	int ret, w, h;
2579	char *str;
2580	void *dst;
2581
2582	if (!o \|\| !obj)
2583	return AVERROR(EINVAL)(-(22));
2584
2585	dst = ((uint8_t*)obj) + o->offset;
2586
2587	if (o->type & AV_OPT_TYPE_FLAG_ARRAY) {
2588	const char def = o->default_val.arr ? o->default_val.arr->def : NULL((void)0);
2589	uint8_t *val;
2590
2591	ret = opt_get_array(o, dst, &val);
2592	if (ret < 0)
2593	return ret;
2594
2595	if (!!val != !!def)
2596	ret = 0;
2597	else if (val)
2598	ret = !strcmp(val, def);
2599	else
2600	ret = 1;
2601
2602	av_freep(&val);
2603
2604	return ret;
2605	}
2606
2607	switch (o->type) {
2608	case AV_OPT_TYPE_CONST:
2609	return 1;
2610	case AV_OPT_TYPE_BOOL:
2611	case AV_OPT_TYPE_FLAGS:
2612	case AV_OPT_TYPE_PIXEL_FMT:
2613	case AV_OPT_TYPE_SAMPLE_FMT:
2614	case AV_OPT_TYPE_INT:
2615	case AV_OPT_TYPE_UINT:
2616	case AV_OPT_TYPE_DURATION:
2617	case AV_OPT_TYPE_INT64:
2618	case AV_OPT_TYPE_UINT64:
2619	read_number(o, dst, NULL((void)0), NULL((void)0), &i64);
2620	return o->default_val.i64 == i64;
2621	case AV_OPT_TYPE_CHLAYOUT: {
2622	AVChannelLayout ch_layout = { 0 };
2623	if (o->default_val.str) {
2624	if ((ret = av_channel_layout_from_string(&ch_layout, o->default_val.str)) < 0)
2625	return ret;
2626	}
2627	ret = !av_channel_layout_compare((AVChannelLayout *)dst, &ch_layout);
2628	av_channel_layout_uninit(&ch_layout);
2629	return ret;
2630	}
2631	case AV_OPT_TYPE_STRING:
2632	str = (char *)dst;
2633	if (str == o->default_val.str) //2 NULLs
2634	return 1;
2635	if (!str \|\| !o->default_val.str) //1 NULL
2636	return 0;
2637	return !strcmp(str, o->default_val.str);
2638	case AV_OPT_TYPE_DOUBLE:
2639	d = (double )dst;
2640	return o->default_val.dbl == d;
2641	case AV_OPT_TYPE_FLOAT:
2642	d = (float )dst;
2643	return (float)o->default_val.dbl == d;
2644	case AV_OPT_TYPE_RATIONAL:
2645	q = av_d2q(o->default_val.dbl, INT_MAX2147483647);
2646	return !av_cmp_q((AVRational)dst, q);
2647	case AV_OPT_TYPE_BINARY: {
2648	struct {
2649	uint8_t *data;
2650	int size;
2651	} tmp = {0};
2652	int opt_size = (int )((void **)dst + 1);
2653	void opt_ptr = (void **)dst;
2654	if (!opt_size && (!o->default_val.str \|\| !strlen(o->default_val.str)))
2655	return 1;
2656	if (!opt_size \|\| !o->default_val.str \|\| !strlen(o->default_val.str ))
2657	return 0;
2658	if (opt_size != strlen(o->default_val.str) / 2)
2659	return 0;
2660	ret = set_string_binary(NULL((void)0), NULL((void)0), o->default_val.str, &tmp.data);
2661	if (!ret)
2662	ret = !memcmp(opt_ptr, tmp.data, tmp.size);
2663	av_free(tmp.data);
2664	return ret;
2665	}
2666	case AV_OPT_TYPE_DICT: {
2667	AVDictionary dict1 = NULL((void)0);
2668	AVDictionary dict2 = (AVDictionary **)dst;
2669	const AVDictionaryEntry en1 = NULL((void)0);
2670	const AVDictionaryEntry en2 = NULL((void)0);
2671	ret = av_dict_parse_string(&dict1, o->default_val.str, "=", ":", 0);
2672	if (ret < 0) {
2673	av_dict_free(&dict1);
2674	return ret;
2675	}
2676	do {
2677	en1 = av_dict_iterate(dict1, en1);
2678	en2 = av_dict_iterate(dict2, en2);
2679	} while (en1 && en2 && !strcmp(en1->key, en2->key) && !strcmp(en1->value, en2->value));
2680	av_dict_free(&dict1);
2681	return (!en1 && !en2);
2682	}
2683	case AV_OPT_TYPE_IMAGE_SIZE:
2684	if (!o->default_val.str \|\| !strcmp(o->default_val.str, "none"))
2685	w = h = 0;
2686	else if ((ret = av_parse_video_size(&w, &h, o->default_val.str)) < 0)
2687	return ret;
2688	return (w == (int )dst) && (h == ((int )dst+1));
2689	case AV_OPT_TYPE_VIDEO_RATE:
2690	q = (AVRational){0, 0};
2691	if (o->default_val.str) {
2692	if ((ret = av_parse_video_rate(&q, o->default_val.str)) < 0)
2693	return ret;
2694	}
2695	return !av_cmp_q((AVRational)dst, q);
2696	case AV_OPT_TYPE_COLOR: {
2697	uint8_t color[4] = {0, 0, 0, 0};
2698	if (o->default_val.str) {
2699	if ((ret = av_parse_color(color, o->default_val.str, -1, NULL((void*)0))) < 0)
2700	return ret;
2701	}
2702	return !memcmp(color, dst, sizeof(color));
2703	}
2704	default:
2705	av_log(obj, AV_LOG_WARNING24, "Not supported option type: %d, option name: %s\n", o->type, o->name);
2706	break;
2707	}
2708	return AVERROR_PATCHWELCOME(-(int)(('P') \| (('A') << 8) \| (('W') << 16) \| (( unsigned)('E') << 24)));
2709	}
2710
2711	int av_opt_is_set_to_default_by_name(void obj, const char name, int search_flags)
2712	{
2713	const AVOption *o;
2714	void *target;
2715	if (!obj)
2716	return AVERROR(EINVAL)(-(22));
2717	o = av_opt_find2(obj, name, NULL((void*)0), 0, search_flags, &target);
2718	if (!o)
2719	return AVERROR_OPTION_NOT_FOUND(-(int)((0xF8) \| (('O') << 8) \| (('P') << 16) \| ( (unsigned)('T') << 24)));
2720	return av_opt_is_set_to_default(target, o);
2721	}
2722
2723	static int opt_serialize(void obj, int opt_flags, int flags, int cnt,
2724	AVBPrint *bprint, const char key_val_sep, const char pairs_sep)
2725	{
2726	const AVOption o = NULL((void)0);
2727	void child = NULL((void)0);
2728	uint8_t *buf;
2729	int ret;
2730	const char special_chars[] = {pairs_sep, key_val_sep, '\0'};
2731
2732	if (flags & AV_OPT_SERIALIZE_SEARCH_CHILDREN0x00000004)
2733	while (child = av_opt_child_next(obj, child)) {
2734	ret = opt_serialize(child, opt_flags, flags, cnt, bprint,
2735	key_val_sep, pairs_sep);
2736	if (ret < 0)
2737	return ret;
2738	}
2739
2740	while (o = av_opt_next(obj, o)) {
2741	if (o->type == AV_OPT_TYPE_CONST)
2742	continue;
2743	if ((flags & AV_OPT_SERIALIZE_OPT_FLAGS_EXACT0x00000002) && o->flags != opt_flags)
2744	continue;
2745	else if (((o->flags & opt_flags) != opt_flags))
2746	continue;
2747	if (flags & AV_OPT_SERIALIZE_SKIP_DEFAULTS0x00000001 && av_opt_is_set_to_default(obj, o) > 0)
2748	continue;
2749	if ((ret = av_opt_get(obj, o->name, 0, &buf)) < 0) {
2750	av_bprint_finalize(bprint, NULL((void*)0));
2751	return ret;
2752	}
2753	if (buf) {
2754	if ((*cnt)++)
2755	av_bprint_append_data(bprint, &pairs_sep, 1);
2756	av_bprint_escape(bprint, o->name, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
2757	av_bprint_append_data(bprint, &key_val_sep, 1);
2758	av_bprint_escape(bprint, buf, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
2759	av_freep(&buf);
2760	}
2761	}
2762
2763	return 0;
2764	}
2765
2766	int av_opt_serialize(void obj, int opt_flags, int flags, char *buffer,
2767	const char key_val_sep, const char pairs_sep)
2768	{
2769	AVBPrint bprint;
2770	int ret, cnt = 0;
2771
2772	if (pairs_sep == '\0' \|\| key_val_sep == '\0' \|\| pairs_sep == key_val_sep \|\|
2773	pairs_sep == '\\' \|\| key_val_sep == '\\') {
2774	av_log(obj, AV_LOG_ERROR16, "Invalid separator(s) found.");
2775	return AVERROR(EINVAL)(-(22));
2776	}
2777
2778	if (!obj \|\| !buffer)
2779	return AVERROR(EINVAL)(-(22));
2780
2781	buffer = NULL((void)0);
2782	av_bprint_init(&bprint, 64, AV_BPRINT_SIZE_UNLIMITED((unsigned)-1));
2783
2784	ret = opt_serialize(obj, opt_flags, flags, &cnt, &bprint,
2785	key_val_sep, pairs_sep);
2786	if (ret < 0)
2787	return ret;
2788
2789	ret = av_bprint_finalize(&bprint, buffer);
2790	if (ret < 0)
2791	return ret;
2792	return 0;
2793	}