opt: attempt to improve options dump output.
[ffmpeg.git] / 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 "avstring.h"
30 #include "common.h"
31 #include "opt.h"
32 #include "eval.h"
33 #include "dict.h"
34 #include "log.h"
35 #include "parseutils.h"
36 #include "pixdesc.h"
37 #include "mathematics.h"
38 #include "samplefmt.h"
39
40 #include <float.h>
41
42 #if FF_API_FIND_OPT
43 //FIXME order them and do a bin search
44 const AVOption *av_find_opt(void *v, const char *name, const char *unit, int mask, int flags)
45 {
46     const AVOption *o = NULL;
47
48     while ((o = av_next_option(v, o))) {
49         if (!strcmp(o->name, name) && (!unit || (o->unit && !strcmp(o->unit, unit))) && (o->flags & mask) == flags)
50             return o;
51     }
52     return NULL;
53 }
54 #endif
55
56 #if FF_API_OLD_AVOPTIONS
57 const AVOption *av_next_option(void *obj, const AVOption *last)
58 {
59     return av_opt_next(obj, last);
60 }
61 #endif
62
63 const AVOption *av_opt_next(void *obj, const AVOption *last)
64 {
65     AVClass *class = *(AVClass**)obj;
66     if (!last && class->option && class->option[0].name)
67         return class->option;
68     if (last && last[1].name)
69         return ++last;
70     return NULL;
71 }
72
73 static int read_number(const AVOption *o, void *dst, double *num, int *den, int64_t *intnum)
74 {
75     switch (o->type) {
76     case AV_OPT_TYPE_FLAGS:     *intnum = *(unsigned int*)dst;return 0;
77     case AV_OPT_TYPE_PIXEL_FMT:
78     case AV_OPT_TYPE_SAMPLE_FMT:
79     case AV_OPT_TYPE_INT:       *intnum = *(int         *)dst;return 0;
80     case AV_OPT_TYPE_DURATION:
81     case AV_OPT_TYPE_INT64:     *intnum = *(int64_t     *)dst;return 0;
82     case AV_OPT_TYPE_FLOAT:     *num    = *(float       *)dst;return 0;
83     case AV_OPT_TYPE_DOUBLE:    *num    = *(double      *)dst;return 0;
84     case AV_OPT_TYPE_RATIONAL:  *intnum = ((AVRational*)dst)->num;
85                                 *den    = ((AVRational*)dst)->den;
86                                                         return 0;
87     case AV_OPT_TYPE_CONST:     *num    = o->default_val.dbl; return 0;
88     }
89     return AVERROR(EINVAL);
90 }
91
92 static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
93 {
94     if (o->max*den < num*intnum || o->min*den > num*intnum) {
95         av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
96                num*intnum/den, o->name, o->min, o->max);
97         return AVERROR(ERANGE);
98     }
99
100     switch (o->type) {
101     case AV_OPT_TYPE_FLAGS:
102     case AV_OPT_TYPE_PIXEL_FMT:
103     case AV_OPT_TYPE_SAMPLE_FMT:
104     case AV_OPT_TYPE_INT:   *(int       *)dst= llrint(num/den)*intnum; break;
105     case AV_OPT_TYPE_DURATION:
106     case AV_OPT_TYPE_INT64: *(int64_t   *)dst= llrint(num/den)*intnum; break;
107     case AV_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
108     case AV_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
109     case AV_OPT_TYPE_RATIONAL:
110         if ((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
111         else                 *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
112         break;
113     default:
114         return AVERROR(EINVAL);
115     }
116     return 0;
117 }
118
119 static const double const_values[] = {
120     M_PI,
121     M_E,
122     FF_QP2LAMBDA,
123     0
124 };
125
126 static const char * const const_names[] = {
127     "PI",
128     "E",
129     "QP2LAMBDA",
130     0
131 };
132
133 static int hexchar2int(char c) {
134     if (c >= '0' && c <= '9') return c - '0';
135     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
136     if (c >= 'A' && c <= 'F') return c - 'A' + 10;
137     return -1;
138 }
139
140 static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
141 {
142     int *lendst = (int *)(dst + 1);
143     uint8_t *bin, *ptr;
144     int len = strlen(val);
145
146     av_freep(dst);
147     *lendst = 0;
148
149     if (len & 1)
150         return AVERROR(EINVAL);
151     len /= 2;
152
153     ptr = bin = av_malloc(len);
154     while (*val) {
155         int a = hexchar2int(*val++);
156         int b = hexchar2int(*val++);
157         if (a < 0 || b < 0) {
158             av_free(bin);
159             return AVERROR(EINVAL);
160         }
161         *ptr++ = (a << 4) | b;
162     }
163     *dst = bin;
164     *lendst = len;
165
166     return 0;
167 }
168
169 static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
170 {
171     av_freep(dst);
172     *dst = av_strdup(val);
173     return 0;
174 }
175
176 #define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
177                               opt->type == AV_OPT_TYPE_CONST || \
178                               opt->type == AV_OPT_TYPE_FLAGS || \
179                               opt->type == AV_OPT_TYPE_INT) ? \
180                              opt->default_val.i64 : opt->default_val.dbl)
181
182 static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
183 {
184     int ret = 0, notfirst = 0;
185     for (;;) {
186         int i, den = 1;
187         char buf[256];
188         int cmd = 0;
189         double d, num = 1;
190         int64_t intnum = 1;
191
192         i = 0;
193         if (*val == '+' || *val == '-') {
194             if (o->type == AV_OPT_TYPE_FLAGS)
195                 cmd = *(val++);
196             else if (!notfirst)
197                 buf[i++] = *val;
198         }
199
200         for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
201             buf[i] = val[i];
202         buf[i] = 0;
203
204         {
205             const AVOption *o_named = av_opt_find(target_obj, buf, o->unit, 0, 0);
206             if (o_named && o_named->type == AV_OPT_TYPE_CONST)
207                 d = DEFAULT_NUMVAL(o_named);
208             else if (!strcmp(buf, "default")) d = DEFAULT_NUMVAL(o);
209             else if (!strcmp(buf, "max"    )) d = o->max;
210             else if (!strcmp(buf, "min"    )) d = o->min;
211             else if (!strcmp(buf, "none"   )) d = 0;
212             else if (!strcmp(buf, "all"    )) d = ~0;
213             else {
214                 int res = av_expr_parse_and_eval(&d, buf, const_names, const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
215                 if (res < 0) {
216                     av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
217                     return res;
218                 }
219             }
220         }
221         if (o->type == AV_OPT_TYPE_FLAGS) {
222             read_number(o, dst, NULL, NULL, &intnum);
223             if      (cmd == '+') d = intnum | (int64_t)d;
224             else if (cmd == '-') d = intnum &~(int64_t)d;
225         } else {
226             read_number(o, dst, &num, &den, &intnum);
227             if      (cmd == '+') d = notfirst*num*intnum/den + d;
228             else if (cmd == '-') d = notfirst*num*intnum/den - d;
229         }
230
231         if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
232             return ret;
233         val += i;
234         if (!*val)
235             return 0;
236         notfirst = 1;
237     }
238
239     return 0;
240 }
241
242 #if FF_API_OLD_AVOPTIONS
243 int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out)
244 {
245     const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
246     if (o_out)
247         *o_out = o;
248     return av_opt_set(obj, name, val, 0);
249 }
250 #endif
251
252 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
253 {
254     int ret;
255     void *dst, *target_obj;
256     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
257     if (!o || !target_obj)
258         return AVERROR_OPTION_NOT_FOUND;
259     if (!val && (o->type != AV_OPT_TYPE_STRING &&
260                  o->type != AV_OPT_TYPE_PIXEL_FMT && o->type != AV_OPT_TYPE_SAMPLE_FMT &&
261                  o->type != AV_OPT_TYPE_IMAGE_SIZE && o->type != AV_OPT_TYPE_VIDEO_RATE &&
262                  o->type != AV_OPT_TYPE_DURATION))
263         return AVERROR(EINVAL);
264
265     dst = ((uint8_t*)target_obj) + o->offset;
266     switch (o->type) {
267     case AV_OPT_TYPE_STRING:   return set_string(obj, o, val, dst);
268     case AV_OPT_TYPE_BINARY:   return set_string_binary(obj, o, val, dst);
269     case AV_OPT_TYPE_FLAGS:
270     case AV_OPT_TYPE_INT:
271     case AV_OPT_TYPE_INT64:
272     case AV_OPT_TYPE_FLOAT:
273     case AV_OPT_TYPE_DOUBLE:
274     case AV_OPT_TYPE_RATIONAL: return set_string_number(obj, target_obj, o, val, dst);
275     case AV_OPT_TYPE_IMAGE_SIZE:
276         if (!val || !strcmp(val, "none")) {
277             *(int *)dst = *((int *)dst + 1) = 0;
278             return 0;
279         }
280         ret = av_parse_video_size(dst, ((int *)dst) + 1, val);
281         if (ret < 0)
282             av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as image size\n", val);
283         return ret;
284     case AV_OPT_TYPE_VIDEO_RATE:
285         if (!val) {
286             ret = AVERROR(EINVAL);
287         } else {
288             ret = av_parse_video_rate(dst, val);
289         }
290         if (ret < 0)
291             av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as video rate\n", val);
292         return ret;
293     case AV_OPT_TYPE_PIXEL_FMT:
294         if (!val || !strcmp(val, "none")) {
295             ret = AV_PIX_FMT_NONE;
296         } else {
297             ret = av_get_pix_fmt(val);
298             if (ret == AV_PIX_FMT_NONE) {
299                 char *tail;
300                 ret = strtol(val, &tail, 0);
301                 if (*tail || (unsigned)ret >= AV_PIX_FMT_NB) {
302                     av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as pixel format\n", val);
303                     return AVERROR(EINVAL);
304                 }
305             }
306         }
307         *(enum AVPixelFormat *)dst = ret;
308         return 0;
309     case AV_OPT_TYPE_SAMPLE_FMT:
310         if (!val || !strcmp(val, "none")) {
311             ret = AV_SAMPLE_FMT_NONE;
312         } else {
313             ret = av_get_sample_fmt(val);
314             if (ret == AV_SAMPLE_FMT_NONE) {
315                 char *tail;
316                 ret = strtol(val, &tail, 0);
317                 if (*tail || (unsigned)ret >= AV_SAMPLE_FMT_NB) {
318                     av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as sample format\n", val);
319                     return AVERROR(EINVAL);
320                 }
321             }
322         }
323         *(enum AVSampleFormat *)dst = ret;
324         return 0;
325     case AV_OPT_TYPE_DURATION:
326         if (!val) {
327             *(int64_t *)dst = 0;
328             return 0;
329         } else {
330             if ((ret = av_parse_time(dst, val, 1)) < 0)
331                 av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
332             return ret;
333         }
334     }
335
336     av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
337     return AVERROR(EINVAL);
338 }
339
340 #define OPT_EVAL_NUMBER(name, opttype, vartype)\
341     int av_opt_eval_ ## name(void *obj, const AVOption *o, const char *val, vartype *name ## _out)\
342     {\
343         if (!o || o->type != opttype)\
344             return AVERROR(EINVAL);\
345         return set_string_number(obj, obj, o, val, name ## _out);\
346     }
347
348 OPT_EVAL_NUMBER(flags,  AV_OPT_TYPE_FLAGS,    int)
349 OPT_EVAL_NUMBER(int,    AV_OPT_TYPE_INT,      int)
350 OPT_EVAL_NUMBER(int64,  AV_OPT_TYPE_INT64,    int64_t)
351 OPT_EVAL_NUMBER(float,  AV_OPT_TYPE_FLOAT,    float)
352 OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE,   double)
353 OPT_EVAL_NUMBER(q,      AV_OPT_TYPE_RATIONAL, AVRational)
354
355 static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
356                                   int search_flags)
357 {
358     void *dst, *target_obj;
359     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
360
361     if (!o || !target_obj)
362         return AVERROR_OPTION_NOT_FOUND;
363
364     dst = ((uint8_t*)target_obj) + o->offset;
365     return write_number(obj, o, dst, num, den, intnum);
366 }
367
368 #if FF_API_OLD_AVOPTIONS
369 const AVOption *av_set_double(void *obj, const char *name, double n)
370 {
371     const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
372     if (set_number(obj, name, n, 1, 1, 0) < 0)
373         return NULL;
374     return o;
375 }
376
377 const AVOption *av_set_q(void *obj, const char *name, AVRational n)
378 {
379     const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
380     if (set_number(obj, name, n.num, n.den, 1, 0) < 0)
381         return NULL;
382     return o;
383 }
384
385 const AVOption *av_set_int(void *obj, const char *name, int64_t n)
386 {
387     const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
388     if (set_number(obj, name, 1, 1, n, 0) < 0)
389         return NULL;
390     return o;
391 }
392 #endif
393
394 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
395 {
396     return set_number(obj, name, 1, 1, val, search_flags);
397 }
398
399 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
400 {
401     return set_number(obj, name, val, 1, 1, search_flags);
402 }
403
404 int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
405 {
406     return set_number(obj, name, val.num, val.den, 1, search_flags);
407 }
408
409 int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
410 {
411     void *target_obj;
412     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
413     uint8_t *ptr;
414     uint8_t **dst;
415     int *lendst;
416
417     if (!o || !target_obj)
418         return AVERROR_OPTION_NOT_FOUND;
419
420     if (o->type != AV_OPT_TYPE_BINARY)
421         return AVERROR(EINVAL);
422
423     ptr = av_malloc(len);
424     if (!ptr)
425         return AVERROR(ENOMEM);
426
427     dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
428     lendst = (int *)(dst + 1);
429
430     av_free(*dst);
431     *dst = ptr;
432     *lendst = len;
433     memcpy(ptr, val, len);
434
435     return 0;
436 }
437
438 int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
439 {
440     void *target_obj;
441     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
442
443     if (!o || !target_obj)
444         return AVERROR_OPTION_NOT_FOUND;
445     if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
446         av_log(obj, AV_LOG_ERROR,
447                "The value set by option '%s' is not an image size.\n", o->name);
448         return AVERROR(EINVAL);
449     }
450     if (w<0 || h<0) {
451         av_log(obj, AV_LOG_ERROR,
452                "Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
453         return AVERROR(EINVAL);
454     }
455     *(int *)(((uint8_t *)target_obj)             + o->offset) = w;
456     *(int *)(((uint8_t *)target_obj+sizeof(int)) + o->offset) = h;
457     return 0;
458 }
459
460 int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
461 {
462     void *target_obj;
463     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
464
465     if (!o || !target_obj)
466         return AVERROR_OPTION_NOT_FOUND;
467     if (o->type != AV_OPT_TYPE_VIDEO_RATE) {
468         av_log(obj, AV_LOG_ERROR,
469                "The value set by option '%s' is not a video rate.\n", o->name);
470         return AVERROR(EINVAL);
471     }
472     if (val.num <= 0 || val.den <= 0)
473         return AVERROR(EINVAL);
474     return set_number(obj, name, val.num, val.den, 1, search_flags);
475 }
476
477 static int set_format(void *obj, const char *name, int fmt, int search_flags,
478                       enum AVOptionType type, const char *desc, int nb_fmts)
479 {
480     void *target_obj;
481     const AVOption *o = av_opt_find2(obj, name, NULL, 0,
482                                      search_flags, &target_obj);
483     int min, max;
484     const AVClass *class = *(AVClass **)obj;
485
486     if (!o || !target_obj)
487         return AVERROR_OPTION_NOT_FOUND;
488     if (o->type != type) {
489         av_log(obj, AV_LOG_ERROR,
490                "The value set by option '%s' is not a %s format", name, desc);
491         return AVERROR(EINVAL);
492     }
493
494 #if LIBAVUTIL_VERSION_MAJOR < 53
495     if (class->version && class->version < AV_VERSION_INT(52, 11, 100)) {
496         min = -1;
497         max = nb_fmts-1;
498     } else
499 #endif
500     {
501         min = FFMIN(o->min, -1);
502         max = FFMAX(o->max, nb_fmts-1);
503     }
504     if (fmt < min || fmt > max) {
505         av_log(obj, AV_LOG_ERROR,
506                "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
507                fmt, name, desc, min, max);
508         return AVERROR(ERANGE);
509     }
510     *(int *)(((uint8_t *)target_obj) + o->offset) = fmt;
511     return 0;
512 }
513
514 int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
515 {
516     return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
517 }
518
519 int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
520 {
521     return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
522 }
523
524 #if FF_API_OLD_AVOPTIONS
525 /**
526  *
527  * @param buf a buffer which is used for returning non string values as strings, can be NULL
528  * @param buf_len allocated length in bytes of buf
529  */
530 const char *av_get_string(void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len)
531 {
532     const AVOption *o = av_opt_find(obj, name, NULL, 0, AV_OPT_SEARCH_CHILDREN);
533     void *dst;
534     uint8_t *bin;
535     int len, i;
536     if (!o)
537         return NULL;
538     if (o->type != AV_OPT_TYPE_STRING && (!buf || !buf_len))
539         return NULL;
540
541     dst= ((uint8_t*)obj) + o->offset;
542     if (o_out) *o_out= o;
543
544     switch (o->type) {
545     case AV_OPT_TYPE_FLAGS:     snprintf(buf, buf_len, "0x%08X",*(int    *)dst);break;
546     case AV_OPT_TYPE_INT:       snprintf(buf, buf_len, "%d" , *(int    *)dst);break;
547     case AV_OPT_TYPE_INT64:     snprintf(buf, buf_len, "%"PRId64, *(int64_t*)dst);break;
548     case AV_OPT_TYPE_FLOAT:     snprintf(buf, buf_len, "%f" , *(float  *)dst);break;
549     case AV_OPT_TYPE_DOUBLE:    snprintf(buf, buf_len, "%f" , *(double *)dst);break;
550     case AV_OPT_TYPE_RATIONAL:  snprintf(buf, buf_len, "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
551     case AV_OPT_TYPE_CONST:     snprintf(buf, buf_len, "%f" , o->default_val.dbl);break;
552     case AV_OPT_TYPE_STRING:    return *(void**)dst;
553     case AV_OPT_TYPE_BINARY:
554         len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
555         if (len >= (buf_len + 1)/2) return NULL;
556         bin = *(uint8_t**)dst;
557         for (i = 0; i < len; i++) snprintf(buf + i*2, 3, "%02X", bin[i]);
558         break;
559     default: return NULL;
560     }
561     return buf;
562 }
563 #endif
564
565 int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
566 {
567     void *dst, *target_obj;
568     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
569     uint8_t *bin, buf[128];
570     int len, i, ret;
571     int64_t i64;
572
573     if (!o || !target_obj || (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
574         return AVERROR_OPTION_NOT_FOUND;
575
576     dst = (uint8_t*)target_obj + o->offset;
577
578     buf[0] = 0;
579     switch (o->type) {
580     case AV_OPT_TYPE_FLAGS:     ret = snprintf(buf, sizeof(buf), "0x%08X",  *(int    *)dst);break;
581     case AV_OPT_TYPE_INT:       ret = snprintf(buf, sizeof(buf), "%d" ,     *(int    *)dst);break;
582     case AV_OPT_TYPE_INT64:     ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t*)dst);break;
583     case AV_OPT_TYPE_FLOAT:     ret = snprintf(buf, sizeof(buf), "%f" ,     *(float  *)dst);break;
584     case AV_OPT_TYPE_DOUBLE:    ret = snprintf(buf, sizeof(buf), "%f" ,     *(double *)dst);break;
585     case AV_OPT_TYPE_VIDEO_RATE:
586     case AV_OPT_TYPE_RATIONAL:  ret = snprintf(buf, sizeof(buf), "%d/%d",   ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
587     case AV_OPT_TYPE_CONST:     ret = snprintf(buf, sizeof(buf), "%f" ,     o->default_val.dbl);break;
588     case AV_OPT_TYPE_STRING:
589         if (*(uint8_t**)dst)
590             *out_val = av_strdup(*(uint8_t**)dst);
591         else
592             *out_val = av_strdup("");
593         return 0;
594     case AV_OPT_TYPE_BINARY:
595         len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
596         if ((uint64_t)len*2 + 1 > INT_MAX)
597             return AVERROR(EINVAL);
598         if (!(*out_val = av_malloc(len*2 + 1)))
599             return AVERROR(ENOMEM);
600         bin = *(uint8_t**)dst;
601         for (i = 0; i < len; i++)
602             snprintf(*out_val + i*2, 3, "%02X", bin[i]);
603         return 0;
604     case AV_OPT_TYPE_IMAGE_SIZE:
605         ret = snprintf(buf, sizeof(buf), "%dx%d", ((int *)dst)[0], ((int *)dst)[1]);
606         break;
607     case AV_OPT_TYPE_PIXEL_FMT:
608         ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_pix_fmt_name(*(enum AVPixelFormat *)dst), "none"));
609         break;
610     case AV_OPT_TYPE_SAMPLE_FMT:
611         ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_sample_fmt_name(*(enum AVSampleFormat *)dst), "none"));
612         break;
613     case AV_OPT_TYPE_DURATION:
614         i64 = *(int64_t *)dst;
615         ret = snprintf(buf, sizeof(buf), "%"PRIi64"d:%02d:%02d.%06d",
616                        i64 / 3600000000, (int)((i64 / 60000000) % 60),
617                        (int)((i64 / 1000000) % 60), (int)(i64 % 1000000));
618         break;
619     default:
620         return AVERROR(EINVAL);
621     }
622
623     if (ret >= sizeof(buf))
624         return AVERROR(EINVAL);
625     *out_val = av_strdup(buf);
626     return 0;
627 }
628
629 static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
630                       int search_flags)
631 {
632     void *dst, *target_obj;
633     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
634     if (!o || !target_obj)
635         goto error;
636
637     dst = ((uint8_t*)target_obj) + o->offset;
638
639     if (o_out) *o_out= o;
640
641     return read_number(o, dst, num, den, intnum);
642
643 error:
644     *den=*intnum=0;
645     return -1;
646 }
647
648 #if FF_API_OLD_AVOPTIONS
649 double av_get_double(void *obj, const char *name, const AVOption **o_out)
650 {
651     int64_t intnum=1;
652     double num=1;
653     int den=1;
654
655     if (get_number(obj, name, o_out, &num, &den, &intnum, 0) < 0)
656         return NAN;
657     return num*intnum/den;
658 }
659
660 AVRational av_get_q(void *obj, const char *name, const AVOption **o_out)
661 {
662     int64_t intnum=1;
663     double num=1;
664     int den=1;
665
666     if (get_number(obj, name, o_out, &num, &den, &intnum, 0) < 0)
667         return (AVRational){0, 0};
668     if (num == 1.0 && (int)intnum == intnum)
669         return (AVRational){intnum, den};
670     else
671         return av_d2q(num*intnum/den, 1<<24);
672 }
673
674 int64_t av_get_int(void *obj, const char *name, const AVOption **o_out)
675 {
676     int64_t intnum=1;
677     double num=1;
678     int den=1;
679
680     if (get_number(obj, name, o_out, &num, &den, &intnum, 0) < 0)
681         return -1;
682     return num*intnum/den;
683 }
684 #endif
685
686 int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
687 {
688     int64_t intnum = 1;
689     double     num = 1;
690     int   ret, den = 1;
691
692     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
693         return ret;
694     *out_val = num*intnum/den;
695     return 0;
696 }
697
698 int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
699 {
700     int64_t intnum = 1;
701     double     num = 1;
702     int   ret, den = 1;
703
704     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
705         return ret;
706     *out_val = num*intnum/den;
707     return 0;
708 }
709
710 int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
711 {
712     int64_t intnum = 1;
713     double     num = 1;
714     int   ret, den = 1;
715
716     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
717         return ret;
718
719     if (num == 1.0 && (int)intnum == intnum)
720         *out_val = (AVRational){intnum, den};
721     else
722         *out_val = av_d2q(num*intnum/den, 1<<24);
723     return 0;
724 }
725
726 int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
727 {
728     void *dst, *target_obj;
729     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
730     if (!o || !target_obj)
731         return AVERROR_OPTION_NOT_FOUND;
732     if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
733         av_log(obj, AV_LOG_ERROR,
734                "The value for option '%s' is not an image size.\n", name);
735         return AVERROR(EINVAL);
736     }
737
738     dst = ((uint8_t*)target_obj) + o->offset;
739     if (w_out) *w_out = *(int *)dst;
740     if (h_out) *h_out = *((int *)dst+1);
741     return 0;
742 }
743
744 int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
745 {
746     int64_t intnum = 1;
747     double     num = 1;
748     int   ret, den = 1;
749
750     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
751         return ret;
752
753     if (num == 1.0 && (int)intnum == intnum)
754         *out_val = (AVRational){intnum, den};
755     else
756         *out_val = av_d2q(num*intnum/den, 1<<24);
757     return 0;
758 }
759
760 static int get_format(void *obj, const char *name, int search_flags, int *out_fmt,
761                       enum AVOptionType type, const char *desc)
762 {
763     void *dst, *target_obj;
764     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
765     if (!o || !target_obj)
766         return AVERROR_OPTION_NOT_FOUND;
767     if (o->type != type) {
768         av_log(obj, AV_LOG_ERROR,
769                "The value for option '%s' is not a %s format.\n", desc, name);
770         return AVERROR(EINVAL);
771     }
772
773     dst = ((uint8_t*)target_obj) + o->offset;
774     *out_fmt = *(int *)dst;
775     return 0;
776 }
777
778 int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
779 {
780     return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
781 }
782
783 int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
784 {
785     return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
786 }
787
788 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
789 {
790     const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
791     const AVOption *flag  = av_opt_find(obj, flag_name,
792                                         field ? field->unit : NULL, 0, 0);
793     int64_t res;
794
795     if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
796         av_opt_get_int(obj, field_name, 0, &res) < 0)
797         return 0;
798     return res & flag->default_val.i64;
799 }
800
801 static void log_value(void *av_log_obj, int level, double d)
802 {
803     if      (d == INT_MAX) {
804         av_log(av_log_obj, level, "INT_MAX");
805     } else if (d == INT_MIN) {
806         av_log(av_log_obj, level, "INT_MIN");
807     } else if (d == (double)INT64_MAX) {
808         av_log(av_log_obj, level, "I64_MAX");
809     } else if (d == INT64_MIN) {
810         av_log(av_log_obj, level, "I64_MIN");
811     } else if (d == FLT_MAX) {
812         av_log(av_log_obj, level, "FLT_MAX");
813     } else if (d == FLT_MIN) {
814         av_log(av_log_obj, level, "FLT_MIN");
815     } else {
816         av_log(av_log_obj, level, "%g", d);
817     }
818 }
819
820 static void opt_list(void *obj, void *av_log_obj, const char *unit,
821                      int req_flags, int rej_flags)
822 {
823     const AVOption *opt=NULL;
824     AVOptionRanges *r;
825     int i;
826
827     while ((opt = av_opt_next(obj, opt))) {
828         if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
829             continue;
830
831         /* Don't print CONST's on level one.
832          * Don't print anything but CONST's on level two.
833          * Only print items from the requested unit.
834          */
835         if (!unit && opt->type==AV_OPT_TYPE_CONST)
836             continue;
837         else if (unit && opt->type!=AV_OPT_TYPE_CONST)
838             continue;
839         else if (unit && opt->type==AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
840             continue;
841         else if (unit && opt->type == AV_OPT_TYPE_CONST)
842             av_log(av_log_obj, AV_LOG_INFO, "     %-15s ", opt->name);
843         else
844             av_log(av_log_obj, AV_LOG_INFO, "  %s%-17s ",
845                    (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
846                    opt->name);
847
848         switch (opt->type) {
849             case AV_OPT_TYPE_FLAGS:
850                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<flags>");
851                 break;
852             case AV_OPT_TYPE_INT:
853                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int>");
854                 break;
855             case AV_OPT_TYPE_INT64:
856                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int64>");
857                 break;
858             case AV_OPT_TYPE_DOUBLE:
859                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<double>");
860                 break;
861             case AV_OPT_TYPE_FLOAT:
862                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<float>");
863                 break;
864             case AV_OPT_TYPE_STRING:
865                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<string>");
866                 break;
867             case AV_OPT_TYPE_RATIONAL:
868                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<rational>");
869                 break;
870             case AV_OPT_TYPE_BINARY:
871                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<binary>");
872                 break;
873             case AV_OPT_TYPE_IMAGE_SIZE:
874                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<image_size>");
875                 break;
876             case AV_OPT_TYPE_VIDEO_RATE:
877                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<video_rate>");
878                 break;
879             case AV_OPT_TYPE_PIXEL_FMT:
880                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<pix_fmt>");
881                 break;
882             case AV_OPT_TYPE_SAMPLE_FMT:
883                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<sample_fmt>");
884                 break;
885             case AV_OPT_TYPE_DURATION:
886                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<duration>");
887                 break;
888             case AV_OPT_TYPE_CONST:
889             default:
890                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
891                 break;
892         }
893         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
894         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
895         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_FILTERING_PARAM)? 'F' : '.');
896         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM   ) ? 'V' : '.');
897         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM   ) ? 'A' : '.');
898         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
899
900         if (opt->help)
901             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
902
903         if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) >= 0) {
904             switch (opt->type) {
905             case AV_OPT_TYPE_INT:
906             case AV_OPT_TYPE_INT64:
907             case AV_OPT_TYPE_DOUBLE:
908             case AV_OPT_TYPE_FLOAT:
909             case AV_OPT_TYPE_RATIONAL:
910                 for (i = 0; i < r->nb_ranges; i++) {
911                     av_log(av_log_obj, AV_LOG_INFO, " (from ");
912                     log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_min);
913                     av_log(av_log_obj, AV_LOG_INFO, " to ");
914                     log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_max);
915                     av_log(av_log_obj, AV_LOG_INFO, ")");
916                 }
917                 break;
918             }
919             av_opt_freep_ranges(&r);
920         }
921
922         av_log(av_log_obj, AV_LOG_INFO, "\n");
923         if (opt->unit && opt->type != AV_OPT_TYPE_CONST) {
924             opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
925         }
926     }
927 }
928
929 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
930 {
931     if (!obj)
932         return -1;
933
934     av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);
935
936     opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
937
938     return 0;
939 }
940
941 void av_opt_set_defaults(void *s)
942 {
943 #if FF_API_OLD_AVOPTIONS
944     av_opt_set_defaults2(s, 0, 0);
945 }
946
947 void av_opt_set_defaults2(void *s, int mask, int flags)
948 {
949 #endif
950     const AVClass *class = *(AVClass **)s;
951     const AVOption *opt = NULL;
952     while ((opt = av_opt_next(s, opt)) != NULL) {
953 #if FF_API_OLD_AVOPTIONS
954         if ((opt->flags & mask) != flags)
955             continue;
956 #endif
957         switch (opt->type) {
958             case AV_OPT_TYPE_CONST:
959                 /* Nothing to be done here */
960             break;
961             case AV_OPT_TYPE_FLAGS:
962             case AV_OPT_TYPE_INT:
963             case AV_OPT_TYPE_INT64:
964             case AV_OPT_TYPE_DURATION:
965                 av_opt_set_int(s, opt->name, opt->default_val.i64, 0);
966             break;
967             case AV_OPT_TYPE_DOUBLE:
968             case AV_OPT_TYPE_FLOAT: {
969                 double val;
970                 val = opt->default_val.dbl;
971                 av_opt_set_double(s, opt->name, val, 0);
972             }
973             break;
974             case AV_OPT_TYPE_RATIONAL: {
975                 AVRational val;
976                 val = av_d2q(opt->default_val.dbl, INT_MAX);
977                 av_opt_set_q(s, opt->name, val, 0);
978             }
979             break;
980             case AV_OPT_TYPE_STRING:
981             case AV_OPT_TYPE_IMAGE_SIZE:
982             case AV_OPT_TYPE_VIDEO_RATE:
983                 av_opt_set(s, opt->name, opt->default_val.str, 0);
984                 break;
985             case AV_OPT_TYPE_PIXEL_FMT:
986 #if LIBAVUTIL_VERSION_MAJOR < 53
987                 if (class->version && class->version < AV_VERSION_INT(52, 10, 100))
988                     av_opt_set(s, opt->name, opt->default_val.str, 0);
989                 else
990 #endif
991                     av_opt_set_pixel_fmt(s, opt->name, opt->default_val.i64, 0);
992                 break;
993             case AV_OPT_TYPE_SAMPLE_FMT:
994 #if LIBAVUTIL_VERSION_MAJOR < 53
995                 if (class->version && class->version < AV_VERSION_INT(52, 10, 100))
996                     av_opt_set(s, opt->name, opt->default_val.str, 0);
997                 else
998 #endif
999                     av_opt_set_sample_fmt(s, opt->name, opt->default_val.i64, 0);
1000                 break;
1001             case AV_OPT_TYPE_BINARY:
1002                 /* Cannot set default for binary */
1003             break;
1004             default:
1005                 av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
1006         }
1007     }
1008 }
1009
1010 /**
1011  * Store the value in the field in ctx that is named like key.
1012  * ctx must be an AVClass context, storing is done using AVOptions.
1013  *
1014  * @param buf the string to parse, buf will be updated to point at the
1015  * separator just after the parsed key/value pair
1016  * @param key_val_sep a 0-terminated list of characters used to
1017  * separate key from value
1018  * @param pairs_sep a 0-terminated list of characters used to separate
1019  * two pairs from each other
1020  * @return 0 if the key/value pair has been successfully parsed and
1021  * set, or a negative value corresponding to an AVERROR code in case
1022  * of error:
1023  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
1024  * the error code issued by av_opt_set() if the key/value pair
1025  * cannot be set
1026  */
1027 static int parse_key_value_pair(void *ctx, const char **buf,
1028                                 const char *key_val_sep, const char *pairs_sep)
1029 {
1030     char *key = av_get_token(buf, key_val_sep);
1031     char *val;
1032     int ret;
1033
1034     if (*key && strspn(*buf, key_val_sep)) {
1035         (*buf)++;
1036         val = av_get_token(buf, pairs_sep);
1037     } else {
1038         av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
1039         av_free(key);
1040         return AVERROR(EINVAL);
1041     }
1042
1043     av_log(ctx, AV_LOG_DEBUG, "Setting entry with key '%s' to value '%s'\n", key, val);
1044
1045     ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
1046     if (ret == AVERROR_OPTION_NOT_FOUND)
1047         av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
1048
1049     av_free(key);
1050     av_free(val);
1051     return ret;
1052 }
1053
1054 int av_set_options_string(void *ctx, const char *opts,
1055                           const char *key_val_sep, const char *pairs_sep)
1056 {
1057     int ret, count = 0;
1058
1059     if (!opts)
1060         return 0;
1061
1062     while (*opts) {
1063         if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
1064             return ret;
1065         count++;
1066
1067         if (*opts)
1068             opts++;
1069     }
1070
1071     return count;
1072 }
1073
1074 #define WHITESPACES " \n\t"
1075
1076 static int is_key_char(char c)
1077 {
1078     return (unsigned)((c | 32) - 'a') < 26 ||
1079            (unsigned)(c - '0') < 10 ||
1080            c == '-' || c == '_' || c == '/' || c == '.';
1081 }
1082
1083 /**
1084  * Read a key from a string.
1085  *
1086  * The key consists of is_key_char characters and must be terminated by a
1087  * character from the delim string; spaces are ignored.
1088  *
1089  * @return  0 for success (even with ellipsis), <0 for failure
1090  */
1091 static int get_key(const char **ropts, const char *delim, char **rkey)
1092 {
1093     const char *opts = *ropts;
1094     const char *key_start, *key_end;
1095
1096     key_start = opts += strspn(opts, WHITESPACES);
1097     while (is_key_char(*opts))
1098         opts++;
1099     key_end = opts;
1100     opts += strspn(opts, WHITESPACES);
1101     if (!*opts || !strchr(delim, *opts))
1102         return AVERROR(EINVAL);
1103     opts++;
1104     if (!(*rkey = av_malloc(key_end - key_start + 1)))
1105         return AVERROR(ENOMEM);
1106     memcpy(*rkey, key_start, key_end - key_start);
1107     (*rkey)[key_end - key_start] = 0;
1108     *ropts = opts;
1109     return 0;
1110 }
1111
1112 int av_opt_get_key_value(const char **ropts,
1113                          const char *key_val_sep, const char *pairs_sep,
1114                          unsigned flags,
1115                          char **rkey, char **rval)
1116 {
1117     int ret;
1118     char *key = NULL, *val;
1119     const char *opts = *ropts;
1120
1121     if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
1122         !(flags & AV_OPT_FLAG_IMPLICIT_KEY))
1123         return AVERROR(EINVAL);
1124     if (!(val = av_get_token(&opts, pairs_sep))) {
1125         av_free(key);
1126         return AVERROR(ENOMEM);
1127     }
1128     *ropts = opts;
1129     *rkey  = key;
1130     *rval  = val;
1131     return 0;
1132 }
1133
1134 int av_opt_set_from_string(void *ctx, const char *opts,
1135                            const char *const *shorthand,
1136                            const char *key_val_sep, const char *pairs_sep)
1137 {
1138     int ret, count = 0;
1139     const char *dummy_shorthand = NULL;
1140     char *av_uninit(parsed_key), *av_uninit(value);
1141     const char *key;
1142
1143     if (!opts)
1144         return 0;
1145     if (!shorthand)
1146         shorthand = &dummy_shorthand;
1147
1148     while (*opts) {
1149         ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
1150                                    *shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
1151                                    &parsed_key, &value);
1152         if (ret < 0) {
1153             if (ret == AVERROR(EINVAL))
1154                 av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", opts);
1155             else
1156                 av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", opts,
1157                        av_err2str(ret));
1158             return ret;
1159         }
1160         if (*opts)
1161             opts++;
1162         if (parsed_key) {
1163             key = parsed_key;
1164             while (*shorthand) /* discard all remaining shorthand */
1165                 shorthand++;
1166         } else {
1167             key = *(shorthand++);
1168         }
1169
1170         av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
1171         if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
1172             if (ret == AVERROR_OPTION_NOT_FOUND)
1173                 av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
1174             av_free(value);
1175             av_free(parsed_key);
1176             return ret;
1177         }
1178
1179         av_free(value);
1180         av_free(parsed_key);
1181         count++;
1182     }
1183     return count;
1184 }
1185
1186 void av_opt_free(void *obj)
1187 {
1188     const AVOption *o = NULL;
1189     while ((o = av_opt_next(obj, o)))
1190         if (o->type == AV_OPT_TYPE_STRING || o->type == AV_OPT_TYPE_BINARY)
1191             av_freep((uint8_t *)obj + o->offset);
1192 }
1193
1194 int av_opt_set_dict(void *obj, AVDictionary **options)
1195 {
1196     AVDictionaryEntry *t = NULL;
1197     AVDictionary    *tmp = NULL;
1198     int ret = 0;
1199
1200     while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
1201         ret = av_opt_set(obj, t->key, t->value, 0);
1202         if (ret == AVERROR_OPTION_NOT_FOUND)
1203             av_dict_set(&tmp, t->key, t->value, 0);
1204         else if (ret < 0) {
1205             av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
1206             break;
1207         }
1208         ret = 0;
1209     }
1210     av_dict_free(options);
1211     *options = tmp;
1212     return ret;
1213 }
1214
1215 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
1216                             int opt_flags, int search_flags)
1217 {
1218     return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
1219 }
1220
1221 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
1222                              int opt_flags, int search_flags, void **target_obj)
1223 {
1224     const AVClass  *c;
1225     const AVOption *o = NULL;
1226
1227     if(!obj)
1228         return NULL;
1229
1230     c= *(AVClass**)obj;
1231
1232     if (search_flags & AV_OPT_SEARCH_CHILDREN) {
1233         if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
1234             const AVClass *child = NULL;
1235             while (child = av_opt_child_class_next(c, child))
1236                 if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
1237                     return o;
1238         } else {
1239             void *child = NULL;
1240             while (child = av_opt_child_next(obj, child))
1241                 if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
1242                     return o;
1243         }
1244     }
1245
1246     while (o = av_opt_next(obj, o)) {
1247         if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
1248             ((!unit && o->type != AV_OPT_TYPE_CONST) ||
1249              (unit  && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
1250             if (target_obj) {
1251                 if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
1252                     *target_obj = obj;
1253                 else
1254                     *target_obj = NULL;
1255             }
1256             return o;
1257         }
1258     }
1259     return NULL;
1260 }
1261
1262 void *av_opt_child_next(void *obj, void *prev)
1263 {
1264     const AVClass *c = *(AVClass**)obj;
1265     if (c->child_next)
1266         return c->child_next(obj, prev);
1267     return NULL;
1268 }
1269
1270 const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
1271 {
1272     if (parent->child_class_next)
1273         return parent->child_class_next(prev);
1274     return NULL;
1275 }
1276
1277 void *av_opt_ptr(const AVClass *class, void *obj, const char *name)
1278 {
1279     const AVOption *opt= av_opt_find2(&class, name, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ, NULL);
1280     if(!opt)
1281         return NULL;
1282     return (uint8_t*)obj + opt->offset;
1283 }
1284
1285 int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1286 {
1287     const AVClass *c = *(AVClass**)obj;
1288     int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;
1289
1290     if (c->version > (52 << 16 | 11 << 8))
1291         callback = c->query_ranges;
1292
1293     if (!callback)
1294         callback = av_opt_query_ranges_default;
1295
1296     return callback(ranges_arg, obj, key, flags);
1297 }
1298
1299 int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1300 {
1301     AVOptionRanges *ranges = av_mallocz(sizeof(*ranges));
1302     AVOptionRange **range_array = av_mallocz(sizeof(void*));
1303     AVOptionRange *range = av_mallocz(sizeof(*range));
1304     const AVOption *field = av_opt_find(obj, key, NULL, 0, flags);
1305     int ret;
1306
1307     *ranges_arg = NULL;
1308
1309     if (!ranges || !range || !range_array || !field) {
1310         ret = AVERROR(ENOMEM);
1311         goto fail;
1312     }
1313
1314     ranges->range = range_array;
1315     ranges->range[0] = range;
1316     ranges->nb_ranges = 1;
1317     range->is_range = 1;
1318     range->value_min = field->min;
1319     range->value_max = field->max;
1320
1321     switch (field->type) {
1322     case AV_OPT_TYPE_INT:
1323     case AV_OPT_TYPE_INT64:
1324     case AV_OPT_TYPE_PIXEL_FMT:
1325     case AV_OPT_TYPE_SAMPLE_FMT:
1326     case AV_OPT_TYPE_FLOAT:
1327     case AV_OPT_TYPE_DOUBLE:
1328     case AV_OPT_TYPE_DURATION:
1329         break;
1330     case AV_OPT_TYPE_STRING:
1331         range->component_min = 0;
1332         range->component_max = 0x10FFFF; // max unicode value
1333         range->value_min = -1;
1334         range->value_max = INT_MAX;
1335         break;
1336     case AV_OPT_TYPE_RATIONAL:
1337         range->component_min = INT_MIN;
1338         range->component_max = INT_MAX;
1339         break;
1340     case AV_OPT_TYPE_IMAGE_SIZE:
1341         range->component_min = 0;
1342         range->component_max = INT_MAX/128/8;
1343         range->value_min = 0;
1344         range->value_max = INT_MAX/8;
1345         break;
1346     case AV_OPT_TYPE_VIDEO_RATE:
1347         range->component_min = 1;
1348         range->component_max = INT_MAX;
1349         range->value_min = 1;
1350         range->value_max = INT_MAX;
1351         break;
1352     default:
1353         ret = AVERROR(ENOSYS);
1354         goto fail;
1355     }
1356
1357     *ranges_arg = ranges;
1358     return 0;
1359 fail:
1360     av_free(ranges);
1361     av_free(range);
1362     av_free(range_array);
1363     return ret;
1364 }
1365
1366 void av_opt_freep_ranges(AVOptionRanges **rangesp)
1367 {
1368     int i;
1369     AVOptionRanges *ranges = *rangesp;
1370
1371     for (i = 0; i < ranges->nb_ranges; i++) {
1372         AVOptionRange *range = ranges->range[i];
1373         av_freep(&range->str);
1374         av_freep(&ranges->range[i]);
1375     }
1376     av_freep(&ranges->range);
1377     av_freep(rangesp);
1378 }
1379
1380 #ifdef TEST
1381
1382 typedef struct TestContext
1383 {
1384     const AVClass *class;
1385     int num;
1386     int toggle;
1387     char *string;
1388     int flags;
1389     AVRational rational;
1390     AVRational video_rate;
1391     int w, h;
1392     enum AVPixelFormat pix_fmt;
1393     enum AVSampleFormat sample_fmt;
1394     int64_t duration;
1395 } TestContext;
1396
1397 #define OFFSET(x) offsetof(TestContext, x)
1398
1399 #define TEST_FLAG_COOL 01
1400 #define TEST_FLAG_LAME 02
1401 #define TEST_FLAG_MU   04
1402
1403 static const AVOption test_options[]= {
1404 {"num",      "set num",        OFFSET(num),      AV_OPT_TYPE_INT,      {.i64 = 0},       0,        100                 },
1405 {"toggle",   "set toggle",     OFFSET(toggle),   AV_OPT_TYPE_INT,      {.i64 = 0},       0,        1                   },
1406 {"rational", "set rational",   OFFSET(rational), AV_OPT_TYPE_RATIONAL, {.dbl = 0},       0,        10                  },
1407 {"string",   "set string",     OFFSET(string),   AV_OPT_TYPE_STRING,   {.str = "default"}, CHAR_MIN, CHAR_MAX          },
1408 {"flags",    "set flags",      OFFSET(flags),    AV_OPT_TYPE_FLAGS,    {.i64 = 0},       0,        INT_MAX, 0, "flags" },
1409 {"cool",     "set cool flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_COOL}, INT_MIN,  INT_MAX, 0, "flags" },
1410 {"lame",     "set lame flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_LAME}, INT_MIN,  INT_MAX, 0, "flags" },
1411 {"mu",       "set mu flag ",   0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_MU},   INT_MIN,  INT_MAX, 0, "flags" },
1412 {"size",     "set size",       OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE,{0},             0,        0                   },
1413 {"pix_fmt",  "set pixfmt",     OFFSET(pix_fmt),  AV_OPT_TYPE_PIXEL_FMT, {.i64 = AV_PIX_FMT_NONE}, -1, AV_PIX_FMT_NB-1},
1414 {"sample_fmt", "set samplefmt", OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, {.i64 = AV_SAMPLE_FMT_NONE}, -1, AV_SAMPLE_FMT_NB-1},
1415 {"video_rate", "set videorate", OFFSET(video_rate), AV_OPT_TYPE_VIDEO_RATE,  {.str = "25"}, 0,     0                   },
1416 {"duration", "set duration",   OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX},
1417 {NULL},
1418 };
1419
1420 static const char *test_get_name(void *ctx)
1421 {
1422     return "test";
1423 }
1424
1425 static const AVClass test_class = {
1426     "TestContext",
1427     test_get_name,
1428     test_options
1429 };
1430
1431 int main(void)
1432 {
1433     int i;
1434
1435     printf("\nTesting av_set_options_string()\n");
1436     {
1437         TestContext test_ctx = { 0 };
1438         const char *options[] = {
1439             "",
1440             ":",
1441             "=",
1442             "foo=:",
1443             ":=foo",
1444             "=foo",
1445             "foo=",
1446             "foo",
1447             "foo=val",
1448             "foo==val",
1449             "toggle=:",
1450             "string=:",
1451             "toggle=1 : foo",
1452             "toggle=100",
1453             "toggle==1",
1454             "flags=+mu-lame : num=42: toggle=0",
1455             "num=42 : string=blahblah",
1456             "rational=0 : rational=1/2 : rational=1/-1",
1457             "rational=-1/0",
1458             "size=1024x768",
1459             "size=pal",
1460             "size=bogus",
1461             "pix_fmt=yuv420p",
1462             "pix_fmt=2",
1463             "pix_fmt=bogus",
1464             "sample_fmt=s16",
1465             "sample_fmt=2",
1466             "sample_fmt=bogus",
1467             "video_rate=pal",
1468             "video_rate=25",
1469             "video_rate=30000/1001",
1470             "video_rate=30/1.001",
1471             "video_rate=bogus",
1472             "duration=bogus",
1473             "duration=123.45",
1474             "duration=1\\:23\\:45.67",
1475         };
1476
1477         test_ctx.class = &test_class;
1478         av_opt_set_defaults(&test_ctx);
1479
1480         av_log_set_level(AV_LOG_DEBUG);
1481
1482         for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
1483             av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
1484             if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
1485                 av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
1486             printf("\n");
1487         }
1488         av_freep(&test_ctx.string);
1489     }
1490
1491     printf("\nTesting av_opt_set_from_string()\n");
1492     {
1493         TestContext test_ctx = { 0 };
1494         const char *options[] = {
1495             "",
1496             "5",
1497             "5:hello",
1498             "5:hello:size=pal",
1499             "5:size=pal:hello",
1500             ":",
1501             "=",
1502             " 5 : hello : size = pal ",
1503             "a_very_long_option_name_that_will_need_to_be_ellipsized_around_here=42"
1504         };
1505         const char *shorthand[] = { "num", "string", NULL };
1506
1507         test_ctx.class = &test_class;
1508         av_opt_set_defaults(&test_ctx);
1509         test_ctx.string = av_strdup("default");
1510
1511         av_log_set_level(AV_LOG_DEBUG);
1512
1513         for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
1514             av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
1515             if (av_opt_set_from_string(&test_ctx, options[i], shorthand, "=", ":") < 0)
1516                 av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
1517             printf("\n");
1518         }
1519         av_freep(&test_ctx.string);
1520     }
1521
1522     return 0;
1523 }
1524
1525 #endif