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

Bug Summary

File:	root/firefox-clang/media/ffvpx/libavutil/opt.c
Warning:	line 1878, column 10 Although the value stored to 'ret' is used in the enclosing expression, the value is never actually read from 'ret'

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;
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 &&
	Although the value stored to 'ret' is used in the enclosing expression, the value is never actually read from 'ret'
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	}