cd46a56dc47701757762b11fabe62d729efa7bb9
[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 "avassert.h"
30 #include "avstring.h"
31 #include "channel_layout.h"
32 #include "common.h"
33 #include "dict.h"
34 #include "eval.h"
35 #include "log.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
43 #include <float.h>
44
45 const AVOption *av_opt_next(const void *obj, const AVOption *last)
46 {
47     const AVClass *class;
48     if (!obj)
49         return NULL;
50     class = *(const AVClass**)obj;
51     if (!last && class && class->option && class->option[0].name)
52         return class->option;
53     if (last && last[1].name)
54         return ++last;
55     return NULL;
56 }
57
58 static int read_number(const AVOption *o, const void *dst, double *num, int *den, int64_t *intnum)
59 {
60     switch (o->type) {
61     case AV_OPT_TYPE_FLAGS:
62         *intnum = *(unsigned int*)dst;
63         return 0;
64     case AV_OPT_TYPE_PIXEL_FMT:
65         *intnum = *(enum AVPixelFormat *)dst;
66         return 0;
67     case AV_OPT_TYPE_SAMPLE_FMT:
68         *intnum = *(enum AVSampleFormat *)dst;
69         return 0;
70     case AV_OPT_TYPE_BOOL:
71     case AV_OPT_TYPE_INT:
72         *intnum = *(int *)dst;
73         return 0;
74     case AV_OPT_TYPE_CHANNEL_LAYOUT:
75     case AV_OPT_TYPE_DURATION:
76     case AV_OPT_TYPE_INT64:
77         *intnum = *(int64_t *)dst;
78         return 0;
79     case AV_OPT_TYPE_FLOAT:
80         *num = *(float *)dst;
81         return 0;
82     case AV_OPT_TYPE_DOUBLE:
83         *num = *(double *)dst;
84         return 0;
85     case AV_OPT_TYPE_RATIONAL:
86         *intnum = ((AVRational *)dst)->num;
87         *den    = ((AVRational *)dst)->den;
88         return 0;
89     case AV_OPT_TYPE_CONST:
90         *num = o->default_val.dbl;
91         return 0;
92     }
93     return AVERROR(EINVAL);
94 }
95
96 static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
97 {
98     if (o->type != AV_OPT_TYPE_FLAGS &&
99         (o->max * den < num * intnum || o->min * den > num * intnum)) {
100         num = den ? num * intnum / den : (num * intnum ? INFINITY : NAN);
101         av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
102                num, o->name, o->min, o->max);
103         return AVERROR(ERANGE);
104     }
105     if (o->type == AV_OPT_TYPE_FLAGS) {
106         double d = num*intnum/den;
107         if (d < -1.5 || d > 0xFFFFFFFF+0.5 || (llrint(d*256) & 255)) {
108             av_log(obj, AV_LOG_ERROR,
109                    "Value %f for parameter '%s' is not a valid set of 32bit integer flags\n",
110                    num*intnum/den, o->name);
111             return AVERROR(ERANGE);
112         }
113     }
114
115     switch (o->type) {
116     case AV_OPT_TYPE_PIXEL_FMT:
117         *(enum AVPixelFormat *)dst = llrint(num / den) * intnum;
118         break;
119     case AV_OPT_TYPE_SAMPLE_FMT:
120         *(enum AVSampleFormat *)dst = llrint(num / den) * intnum;
121         break;
122     case AV_OPT_TYPE_BOOL:
123     case AV_OPT_TYPE_FLAGS:
124     case AV_OPT_TYPE_INT:
125         *(int *)dst = llrint(num / den) * intnum;
126         break;
127     case AV_OPT_TYPE_DURATION:
128     case AV_OPT_TYPE_CHANNEL_LAYOUT:
129     case AV_OPT_TYPE_INT64:{
130         double d = num / den;
131         if (intnum == 1 && d == (double)INT64_MAX) {
132             *(int64_t *)dst = INT64_MAX;
133         } else
134             *(int64_t *)dst = llrint(d) * intnum;
135         break;}
136     case AV_OPT_TYPE_FLOAT:
137         *(float *)dst = num * intnum / den;
138         break;
139     case AV_OPT_TYPE_DOUBLE:
140         *(double    *)dst = num * intnum / den;
141         break;
142     case AV_OPT_TYPE_RATIONAL:
143     case AV_OPT_TYPE_VIDEO_RATE:
144         if ((int) num == num)
145             *(AVRational *)dst = (AVRational) { num *intnum, den };
146         else
147             *(AVRational *)dst = av_d2q(num * intnum / den, 1 << 24);
148         break;
149     default:
150         return AVERROR(EINVAL);
151     }
152     return 0;
153 }
154
155 static int hexchar2int(char c) {
156     if (c >= '0' && c <= '9')
157         return c - '0';
158     if (c >= 'a' && c <= 'f')
159         return c - 'a' + 10;
160     if (c >= 'A' && c <= 'F')
161         return c - 'A' + 10;
162     return -1;
163 }
164
165 static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
166 {
167     int *lendst = (int *)(dst + 1);
168     uint8_t *bin, *ptr;
169     int len;
170
171     av_freep(dst);
172     *lendst = 0;
173
174     if (!val || !(len = strlen(val)))
175         return 0;
176
177     if (len & 1)
178         return AVERROR(EINVAL);
179     len /= 2;
180
181     ptr = bin = av_malloc(len);
182     if (!ptr)
183         return AVERROR(ENOMEM);
184     while (*val) {
185         int a = hexchar2int(*val++);
186         int b = hexchar2int(*val++);
187         if (a < 0 || b < 0) {
188             av_free(bin);
189             return AVERROR(EINVAL);
190         }
191         *ptr++ = (a << 4) | b;
192     }
193     *dst    = bin;
194     *lendst = len;
195
196     return 0;
197 }
198
199 static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
200 {
201     av_freep(dst);
202     *dst = av_strdup(val);
203     return *dst ? 0 : AVERROR(ENOMEM);
204 }
205
206 #define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
207                               opt->type == AV_OPT_TYPE_CONST || \
208                               opt->type == AV_OPT_TYPE_FLAGS || \
209                               opt->type == AV_OPT_TYPE_INT)     \
210                              ? opt->default_val.i64             \
211                              : opt->default_val.dbl)
212
213 static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
214 {
215     int ret = 0;
216     int num, den;
217     char c;
218
219     if (sscanf(val, "%d%*1[:/]%d%c", &num, &den, &c) == 2) {
220         if ((ret = write_number(obj, o, dst, 1, den, num)) >= 0)
221             return ret;
222         ret = 0;
223     }
224
225     for (;;) {
226         int i = 0;
227         char buf[256];
228         int cmd = 0;
229         double d;
230         int64_t intnum = 1;
231
232         if (o->type == AV_OPT_TYPE_FLAGS) {
233             if (*val == '+' || *val == '-')
234                 cmd = *(val++);
235             for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
236                 buf[i] = val[i];
237             buf[i] = 0;
238         }
239
240         {
241             const AVOption *o_named = av_opt_find(target_obj, i ? buf : val, o->unit, 0, 0);
242             int res;
243             int ci = 0;
244             double const_values[64];
245             const char * const_names[64];
246             if (o_named && o_named->type == AV_OPT_TYPE_CONST)
247                 d = DEFAULT_NUMVAL(o_named);
248             else {
249                 if (o->unit) {
250                     for (o_named = NULL; o_named = av_opt_next(target_obj, o_named); ) {
251                         if (o_named->type == AV_OPT_TYPE_CONST &&
252                             o_named->unit &&
253                             !strcmp(o_named->unit, o->unit)) {
254                             if (ci + 6 >= FF_ARRAY_ELEMS(const_values)) {
255                                 av_log(obj, AV_LOG_ERROR, "const_values array too small for %s\n", o->unit);
256                                 return AVERROR_PATCHWELCOME;
257                             }
258                             const_names [ci  ] = o_named->name;
259                             const_values[ci++] = DEFAULT_NUMVAL(o_named);
260                         }
261                     }
262                 }
263                 const_names [ci  ] = "default";
264                 const_values[ci++] = DEFAULT_NUMVAL(o);
265                 const_names [ci  ] = "max";
266                 const_values[ci++] = o->max;
267                 const_names [ci  ] = "min";
268                 const_values[ci++] = o->min;
269                 const_names [ci  ] = "none";
270                 const_values[ci++] = 0;
271                 const_names [ci  ] = "all";
272                 const_values[ci++] = ~0;
273                 const_names [ci] = NULL;
274                 const_values[ci] = 0;
275
276                 res = av_expr_parse_and_eval(&d, i ? buf : val, const_names,
277                                             const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
278                 if (res < 0) {
279                     av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
280                     return res;
281                 }
282             }
283         }
284         if (o->type == AV_OPT_TYPE_FLAGS) {
285             read_number(o, dst, NULL, NULL, &intnum);
286             if (cmd == '+')
287                 d = intnum | (int64_t)d;
288             else if (cmd == '-')
289                 d = intnum &~(int64_t)d;
290         }
291
292         if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
293             return ret;
294         val += i;
295         if (!i || !*val)
296             return 0;
297     }
298
299     return 0;
300 }
301
302 static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
303 {
304     int ret;
305
306     if (!val || !strcmp(val, "none")) {
307         dst[0] =
308         dst[1] = 0;
309         return 0;
310     }
311     ret = av_parse_video_size(dst, dst + 1, val);
312     if (ret < 0)
313         av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as image size\n", val);
314     return ret;
315 }
316
317 static int set_string_video_rate(void *obj, const AVOption *o, const char *val, AVRational *dst)
318 {
319     int ret;
320     if (!val) {
321         ret = AVERROR(EINVAL);
322     } else {
323         ret = av_parse_video_rate(dst, val);
324     }
325     if (ret < 0)
326         av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as video rate\n", val);
327     return ret;
328 }
329
330 static int set_string_color(void *obj, const AVOption *o, const char *val, uint8_t *dst)
331 {
332     int ret;
333
334     if (!val) {
335         return 0;
336     } else {
337         ret = av_parse_color(dst, val, -1, obj);
338         if (ret < 0)
339             av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as color\n", val);
340         return ret;
341     }
342     return 0;
343 }
344
345 static const char *get_bool_name(int val)
346 {
347     if (val < 0)
348         return "auto";
349     return val ? "true" : "false";
350 }
351
352 static int set_string_bool(void *obj, const AVOption *o, const char *val, int *dst)
353 {
354     int n;
355
356     if (!val)
357         return 0;
358
359     if (!strcmp(val, "auto")) {
360         n = -1;
361     } else if (av_match_name(val, "true,y,yes,enable,enabled,on")) {
362         n = 1;
363     } else if (av_match_name(val, "false,n,no,disable,disabled,off")) {
364         n = 0;
365     } else {
366         char *end = NULL;
367         n = strtol(val, &end, 10);
368         if (val + strlen(val) != end)
369             goto fail;
370     }
371
372     if (n < o->min || n > o->max)
373         goto fail;
374
375     *dst = n;
376     return 0;
377
378 fail:
379     av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as boolean\n", val);
380     return AVERROR(EINVAL);
381 }
382
383 static int set_string_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst,
384                           int fmt_nb, int ((*get_fmt)(const char *)), const char *desc)
385 {
386     int fmt, min, max;
387
388     if (!val || !strcmp(val, "none")) {
389         fmt = -1;
390     } else {
391         fmt = get_fmt(val);
392         if (fmt == -1) {
393             char *tail;
394             fmt = strtol(val, &tail, 0);
395             if (*tail || (unsigned)fmt >= fmt_nb) {
396                 av_log(obj, AV_LOG_ERROR,
397                        "Unable to parse option value \"%s\" as %s\n", val, desc);
398                 return AVERROR(EINVAL);
399             }
400         }
401     }
402
403     min = FFMAX(o->min, -1);
404     max = FFMIN(o->max, fmt_nb-1);
405
406     // hack for compatibility with old ffmpeg
407     if(min == 0 && max == 0) {
408         min = -1;
409         max = fmt_nb-1;
410     }
411
412     if (fmt < min || fmt > max) {
413         av_log(obj, AV_LOG_ERROR,
414                "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
415                fmt, o->name, desc, min, max);
416         return AVERROR(ERANGE);
417     }
418
419     *(int *)dst = fmt;
420     return 0;
421 }
422
423 static int set_string_pixel_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
424 {
425     return set_string_fmt(obj, o, val, dst,
426                           AV_PIX_FMT_NB, av_get_pix_fmt, "pixel format");
427 }
428
429 static int set_string_sample_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
430 {
431     return set_string_fmt(obj, o, val, dst,
432                           AV_SAMPLE_FMT_NB, av_get_sample_fmt, "sample format");
433 }
434
435 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
436 {
437     int ret = 0;
438     void *dst, *target_obj;
439     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
440     if (!o || !target_obj)
441         return AVERROR_OPTION_NOT_FOUND;
442     if (!val && (o->type != AV_OPT_TYPE_STRING &&
443                  o->type != AV_OPT_TYPE_PIXEL_FMT && o->type != AV_OPT_TYPE_SAMPLE_FMT &&
444                  o->type != AV_OPT_TYPE_IMAGE_SIZE && o->type != AV_OPT_TYPE_VIDEO_RATE &&
445                  o->type != AV_OPT_TYPE_DURATION && o->type != AV_OPT_TYPE_COLOR &&
446                  o->type != AV_OPT_TYPE_CHANNEL_LAYOUT && o->type != AV_OPT_TYPE_BOOL))
447         return AVERROR(EINVAL);
448
449     if (o->flags & AV_OPT_FLAG_READONLY)
450         return AVERROR(EINVAL);
451
452     dst = ((uint8_t *)target_obj) + o->offset;
453     switch (o->type) {
454     case AV_OPT_TYPE_BOOL:
455         return set_string_bool(obj, o, val, dst);
456     case AV_OPT_TYPE_STRING:
457         return set_string(obj, o, val, dst);
458     case AV_OPT_TYPE_BINARY:
459         return set_string_binary(obj, o, val, dst);
460     case AV_OPT_TYPE_FLAGS:
461     case AV_OPT_TYPE_INT:
462     case AV_OPT_TYPE_INT64:
463     case AV_OPT_TYPE_FLOAT:
464     case AV_OPT_TYPE_DOUBLE:
465     case AV_OPT_TYPE_RATIONAL:
466         return set_string_number(obj, target_obj, o, val, dst);
467     case AV_OPT_TYPE_IMAGE_SIZE:
468         return set_string_image_size(obj, o, val, dst);
469     case AV_OPT_TYPE_VIDEO_RATE: {
470         AVRational tmp;
471         ret = set_string_video_rate(obj, o, val, &tmp);
472         if (ret < 0)
473             return ret;
474         return write_number(obj, o, dst, 1, tmp.den, tmp.num);
475     }
476     case AV_OPT_TYPE_PIXEL_FMT:
477         return set_string_pixel_fmt(obj, o, val, dst);
478     case AV_OPT_TYPE_SAMPLE_FMT:
479         return set_string_sample_fmt(obj, o, val, dst);
480     case AV_OPT_TYPE_DURATION:
481         if (!val) {
482             *(int64_t *)dst = 0;
483             return 0;
484         } else {
485             if ((ret = av_parse_time(dst, val, 1)) < 0)
486                 av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
487             return ret;
488         }
489         break;
490     case AV_OPT_TYPE_COLOR:
491         return set_string_color(obj, o, val, dst);
492     case AV_OPT_TYPE_CHANNEL_LAYOUT:
493         if (!val || !strcmp(val, "none")) {
494             *(int64_t *)dst = 0;
495         } else {
496             int64_t cl = av_get_channel_layout(val);
497             if (!cl) {
498                 av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
499                 ret = AVERROR(EINVAL);
500             }
501             *(int64_t *)dst = cl;
502             return ret;
503         }
504         break;
505     }
506
507     av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
508     return AVERROR(EINVAL);
509 }
510
511 #define OPT_EVAL_NUMBER(name, opttype, vartype)                         \
512 int av_opt_eval_ ## name(void *obj, const AVOption *o,                  \
513                          const char *val, vartype *name ## _out)        \
514 {                                                                       \
515     if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY)    \
516         return AVERROR(EINVAL);                                         \
517     return set_string_number(obj, obj, o, val, name ## _out);           \
518 }
519
520 OPT_EVAL_NUMBER(flags,  AV_OPT_TYPE_FLAGS,    int)
521 OPT_EVAL_NUMBER(int,    AV_OPT_TYPE_INT,      int)
522 OPT_EVAL_NUMBER(int64,  AV_OPT_TYPE_INT64,    int64_t)
523 OPT_EVAL_NUMBER(float,  AV_OPT_TYPE_FLOAT,    float)
524 OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE,   double)
525 OPT_EVAL_NUMBER(q,      AV_OPT_TYPE_RATIONAL, AVRational)
526
527 static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
528                       int search_flags)
529 {
530     void *dst, *target_obj;
531     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
532
533     if (!o || !target_obj)
534         return AVERROR_OPTION_NOT_FOUND;
535
536     if (o->flags & AV_OPT_FLAG_READONLY)
537         return AVERROR(EINVAL);
538
539     dst = ((uint8_t *)target_obj) + o->offset;
540     return write_number(obj, o, dst, num, den, intnum);
541 }
542
543 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
544 {
545     return set_number(obj, name, 1, 1, val, search_flags);
546 }
547
548 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
549 {
550     return set_number(obj, name, val, 1, 1, search_flags);
551 }
552
553 int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
554 {
555     return set_number(obj, name, val.num, val.den, 1, search_flags);
556 }
557
558 int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
559 {
560     void *target_obj;
561     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
562     uint8_t *ptr;
563     uint8_t **dst;
564     int *lendst;
565
566     if (!o || !target_obj)
567         return AVERROR_OPTION_NOT_FOUND;
568
569     if (o->type != AV_OPT_TYPE_BINARY || o->flags & AV_OPT_FLAG_READONLY)
570         return AVERROR(EINVAL);
571
572     ptr = len ? av_malloc(len) : NULL;
573     if (len && !ptr)
574         return AVERROR(ENOMEM);
575
576     dst    = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
577     lendst = (int *)(dst + 1);
578
579     av_free(*dst);
580     *dst    = ptr;
581     *lendst = len;
582     if (len)
583         memcpy(ptr, val, len);
584
585     return 0;
586 }
587
588 int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
589 {
590     void *target_obj;
591     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
592
593     if (!o || !target_obj)
594         return AVERROR_OPTION_NOT_FOUND;
595     if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
596         av_log(obj, AV_LOG_ERROR,
597                "The value set by option '%s' is not an image size.\n", o->name);
598         return AVERROR(EINVAL);
599     }
600     if (w<0 || h<0) {
601         av_log(obj, AV_LOG_ERROR,
602                "Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
603         return AVERROR(EINVAL);
604     }
605     *(int *)(((uint8_t *)target_obj)             + o->offset) = w;
606     *(int *)(((uint8_t *)target_obj+sizeof(int)) + o->offset) = h;
607     return 0;
608 }
609
610 int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
611 {
612     void *target_obj;
613     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
614
615     if (!o || !target_obj)
616         return AVERROR_OPTION_NOT_FOUND;
617     if (o->type != AV_OPT_TYPE_VIDEO_RATE) {
618         av_log(obj, AV_LOG_ERROR,
619                "The value set by option '%s' is not a video rate.\n", o->name);
620         return AVERROR(EINVAL);
621     }
622     if (val.num <= 0 || val.den <= 0)
623         return AVERROR(EINVAL);
624     return set_number(obj, name, val.num, val.den, 1, search_flags);
625 }
626
627 static int set_format(void *obj, const char *name, int fmt, int search_flags,
628                       enum AVOptionType type, const char *desc, int nb_fmts)
629 {
630     void *target_obj;
631     const AVOption *o = av_opt_find2(obj, name, NULL, 0,
632                                      search_flags, &target_obj);
633     int min, max;
634
635     if (!o || !target_obj)
636         return AVERROR_OPTION_NOT_FOUND;
637     if (o->type != type) {
638         av_log(obj, AV_LOG_ERROR,
639                "The value set by option '%s' is not a %s format", name, desc);
640         return AVERROR(EINVAL);
641     }
642
643     min = FFMAX(o->min, -1);
644     max = FFMIN(o->max, nb_fmts-1);
645
646     if (fmt < min || fmt > max) {
647         av_log(obj, AV_LOG_ERROR,
648                "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
649                fmt, name, desc, min, max);
650         return AVERROR(ERANGE);
651     }
652     *(int *)(((uint8_t *)target_obj) + o->offset) = fmt;
653     return 0;
654 }
655
656 int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
657 {
658     return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
659 }
660
661 int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
662 {
663     return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
664 }
665
666 int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
667 {
668     void *target_obj;
669     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
670
671     if (!o || !target_obj)
672         return AVERROR_OPTION_NOT_FOUND;
673     if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
674         av_log(obj, AV_LOG_ERROR,
675                "The value set by option '%s' is not a channel layout.\n", o->name);
676         return AVERROR(EINVAL);
677     }
678     *(int64_t *)(((uint8_t *)target_obj) + o->offset) = cl;
679     return 0;
680 }
681
682 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val,
683                         int search_flags)
684 {
685     void *target_obj;
686     AVDictionary **dst;
687     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
688
689     if (!o || !target_obj)
690         return AVERROR_OPTION_NOT_FOUND;
691     if (o->flags & AV_OPT_FLAG_READONLY)
692         return AVERROR(EINVAL);
693
694     dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
695     av_dict_free(dst);
696     av_dict_copy(dst, val, 0);
697
698     return 0;
699 }
700
701 static void format_duration(char *buf, size_t size, int64_t d)
702 {
703     char *e;
704
705     av_assert0(size >= 25);
706     if (d < 0 && d != INT64_MIN) {
707         *(buf++) = '-';
708         size--;
709         d = -d;
710     }
711     if (d == INT64_MAX)
712         snprintf(buf, size, "INT64_MAX");
713     else if (d == INT64_MIN)
714         snprintf(buf, size, "INT64_MIN");
715     else if (d > (int64_t)3600*1000000)
716         snprintf(buf, size, "%"PRId64":%02d:%02d.%06d", d / 3600000000,
717                  (int)((d / 60000000) % 60),
718                  (int)((d / 1000000) % 60),
719                  (int)(d % 1000000));
720     else if (d > 60*1000000)
721         snprintf(buf, size, "%d:%02d.%06d",
722                  (int)(d / 60000000),
723                  (int)((d / 1000000) % 60),
724                  (int)(d % 1000000));
725     else
726         snprintf(buf, size, "%d.%06d",
727                  (int)(d / 1000000),
728                  (int)(d % 1000000));
729     e = buf + strlen(buf);
730     while (e > buf && e[-1] == '0')
731         *(--e) = 0;
732     if (e > buf && e[-1] == '.')
733         *(--e) = 0;
734 }
735
736 int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
737 {
738     void *dst, *target_obj;
739     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
740     uint8_t *bin, buf[128];
741     int len, i, ret;
742     int64_t i64;
743
744     if (!o || !target_obj || (o->offset<=0 && o->type != AV_OPT_TYPE_CONST))
745         return AVERROR_OPTION_NOT_FOUND;
746
747     dst = (uint8_t *)target_obj + o->offset;
748
749     buf[0] = 0;
750     switch (o->type) {
751     case AV_OPT_TYPE_BOOL:
752         ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(get_bool_name(*(int *)dst), "invalid"));
753         break;
754     case AV_OPT_TYPE_FLAGS:
755         ret = snprintf(buf, sizeof(buf), "0x%08X", *(int *)dst);
756         break;
757     case AV_OPT_TYPE_INT:
758         ret = snprintf(buf, sizeof(buf), "%d", *(int *)dst);
759         break;
760     case AV_OPT_TYPE_INT64:
761         ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t *)dst);
762         break;
763     case AV_OPT_TYPE_FLOAT:
764         ret = snprintf(buf, sizeof(buf), "%f", *(float *)dst);
765         break;
766     case AV_OPT_TYPE_DOUBLE:
767         ret = snprintf(buf, sizeof(buf), "%f", *(double *)dst);
768         break;
769     case AV_OPT_TYPE_VIDEO_RATE:
770     case AV_OPT_TYPE_RATIONAL:
771         ret = snprintf(buf, sizeof(buf), "%d/%d", ((AVRational *)dst)->num, ((AVRational *)dst)->den);
772         break;
773     case AV_OPT_TYPE_CONST:
774         ret = snprintf(buf, sizeof(buf), "%f", o->default_val.dbl);
775         break;
776     case AV_OPT_TYPE_STRING:
777         if (*(uint8_t **)dst) {
778             *out_val = av_strdup(*(uint8_t **)dst);
779         } else if (search_flags & AV_OPT_ALLOW_NULL) {
780             *out_val = NULL;
781             return 0;
782         } else {
783             *out_val = av_strdup("");
784         }
785         return *out_val ? 0 : AVERROR(ENOMEM);
786     case AV_OPT_TYPE_BINARY:
787         if (!*(uint8_t **)dst && (search_flags & AV_OPT_ALLOW_NULL)) {
788             *out_val = NULL;
789             return 0;
790         }
791         len = *(int *)(((uint8_t *)dst) + sizeof(uint8_t *));
792         if ((uint64_t)len * 2 + 1 > INT_MAX)
793             return AVERROR(EINVAL);
794         if (!(*out_val = av_malloc(len * 2 + 1)))
795             return AVERROR(ENOMEM);
796         if (!len) {
797             *out_val[0] = '\0';
798             return 0;
799         }
800         bin = *(uint8_t **)dst;
801         for (i = 0; i < len; i++)
802             snprintf(*out_val + i * 2, 3, "%02X", bin[i]);
803         return 0;
804     case AV_OPT_TYPE_IMAGE_SIZE:
805         ret = snprintf(buf, sizeof(buf), "%dx%d", ((int *)dst)[0], ((int *)dst)[1]);
806         break;
807     case AV_OPT_TYPE_PIXEL_FMT:
808         ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_pix_fmt_name(*(enum AVPixelFormat *)dst), "none"));
809         break;
810     case AV_OPT_TYPE_SAMPLE_FMT:
811         ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_sample_fmt_name(*(enum AVSampleFormat *)dst), "none"));
812         break;
813     case AV_OPT_TYPE_DURATION:
814         i64 = *(int64_t *)dst;
815         format_duration(buf, sizeof(buf), i64);
816         ret = strlen(buf); // no overflow possible, checked by an assert
817         break;
818     case AV_OPT_TYPE_COLOR:
819         ret = snprintf(buf, sizeof(buf), "0x%02x%02x%02x%02x",
820                        (int)((uint8_t *)dst)[0], (int)((uint8_t *)dst)[1],
821                        (int)((uint8_t *)dst)[2], (int)((uint8_t *)dst)[3]);
822         break;
823     case AV_OPT_TYPE_CHANNEL_LAYOUT:
824         i64 = *(int64_t *)dst;
825         ret = snprintf(buf, sizeof(buf), "0x%"PRIx64, i64);
826         break;
827     default:
828         return AVERROR(EINVAL);
829     }
830
831     if (ret >= sizeof(buf))
832         return AVERROR(EINVAL);
833     *out_val = av_strdup(buf);
834     return *out_val ? 0 : AVERROR(ENOMEM);
835 }
836
837 static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
838                       int search_flags)
839 {
840     void *dst, *target_obj;
841     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
842     if (!o || !target_obj)
843         goto error;
844
845     dst = ((uint8_t *)target_obj) + o->offset;
846
847     if (o_out) *o_out= o;
848
849     return read_number(o, dst, num, den, intnum);
850
851 error:
852     *den    =
853     *intnum = 0;
854     return -1;
855 }
856
857 int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
858 {
859     int64_t intnum = 1;
860     double num = 1;
861     int ret, den = 1;
862
863     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
864         return ret;
865     *out_val = num * intnum / den;
866     return 0;
867 }
868
869 int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
870 {
871     int64_t intnum = 1;
872     double num = 1;
873     int ret, den = 1;
874
875     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
876         return ret;
877     *out_val = num * intnum / den;
878     return 0;
879 }
880
881 int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
882 {
883     int64_t intnum = 1;
884     double num = 1;
885     int ret, den = 1;
886
887     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
888         return ret;
889
890     if (num == 1.0 && (int)intnum == intnum)
891         *out_val = (AVRational){intnum, den};
892     else
893         *out_val = av_d2q(num*intnum/den, 1<<24);
894     return 0;
895 }
896
897 int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
898 {
899     void *dst, *target_obj;
900     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
901     if (!o || !target_obj)
902         return AVERROR_OPTION_NOT_FOUND;
903     if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
904         av_log(obj, AV_LOG_ERROR,
905                "The value for option '%s' is not an image size.\n", name);
906         return AVERROR(EINVAL);
907     }
908
909     dst = ((uint8_t*)target_obj) + o->offset;
910     if (w_out) *w_out = *(int *)dst;
911     if (h_out) *h_out = *((int *)dst+1);
912     return 0;
913 }
914
915 int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
916 {
917     int64_t intnum = 1;
918     double     num = 1;
919     int   ret, den = 1;
920
921     if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
922         return ret;
923
924     if (num == 1.0 && (int)intnum == intnum)
925         *out_val = (AVRational) { intnum, den };
926     else
927         *out_val = av_d2q(num * intnum / den, 1 << 24);
928     return 0;
929 }
930
931 static int get_format(void *obj, const char *name, int search_flags, int *out_fmt,
932                       enum AVOptionType type, const char *desc)
933 {
934     void *dst, *target_obj;
935     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
936     if (!o || !target_obj)
937         return AVERROR_OPTION_NOT_FOUND;
938     if (o->type != type) {
939         av_log(obj, AV_LOG_ERROR,
940                "The value for option '%s' is not a %s format.\n", desc, name);
941         return AVERROR(EINVAL);
942     }
943
944     dst = ((uint8_t*)target_obj) + o->offset;
945     *out_fmt = *(int *)dst;
946     return 0;
947 }
948
949 int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
950 {
951     return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
952 }
953
954 int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
955 {
956     return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
957 }
958
959 int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
960 {
961     void *dst, *target_obj;
962     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
963     if (!o || !target_obj)
964         return AVERROR_OPTION_NOT_FOUND;
965     if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
966         av_log(obj, AV_LOG_ERROR,
967                "The value for option '%s' is not a channel layout.\n", name);
968         return AVERROR(EINVAL);
969     }
970
971     dst = ((uint8_t*)target_obj) + o->offset;
972     *cl = *(int64_t *)dst;
973     return 0;
974 }
975
976 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
977 {
978     void *target_obj;
979     AVDictionary *src;
980     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
981
982     if (!o || !target_obj)
983         return AVERROR_OPTION_NOT_FOUND;
984     if (o->type != AV_OPT_TYPE_DICT)
985         return AVERROR(EINVAL);
986
987     src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
988     av_dict_copy(out_val, src, 0);
989
990     return 0;
991 }
992
993 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
994 {
995     const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
996     const AVOption *flag  = av_opt_find(obj, flag_name,
997                                         field ? field->unit : NULL, 0, 0);
998     int64_t res;
999
1000     if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
1001         av_opt_get_int(obj, field_name, 0, &res) < 0)
1002         return 0;
1003     return res & flag->default_val.i64;
1004 }
1005
1006 static void log_value(void *av_log_obj, int level, double d)
1007 {
1008     if      (d == INT_MAX) {
1009         av_log(av_log_obj, level, "INT_MAX");
1010     } else if (d == INT_MIN) {
1011         av_log(av_log_obj, level, "INT_MIN");
1012     } else if (d == UINT32_MAX) {
1013         av_log(av_log_obj, level, "UINT32_MAX");
1014     } else if (d == (double)INT64_MAX) {
1015         av_log(av_log_obj, level, "I64_MAX");
1016     } else if (d == INT64_MIN) {
1017         av_log(av_log_obj, level, "I64_MIN");
1018     } else if (d == FLT_MAX) {
1019         av_log(av_log_obj, level, "FLT_MAX");
1020     } else if (d == FLT_MIN) {
1021         av_log(av_log_obj, level, "FLT_MIN");
1022     } else if (d == -FLT_MAX) {
1023         av_log(av_log_obj, level, "-FLT_MAX");
1024     } else if (d == -FLT_MIN) {
1025         av_log(av_log_obj, level, "-FLT_MIN");
1026     } else if (d == DBL_MAX) {
1027         av_log(av_log_obj, level, "DBL_MAX");
1028     } else if (d == DBL_MIN) {
1029         av_log(av_log_obj, level, "DBL_MIN");
1030     } else if (d == -DBL_MAX) {
1031         av_log(av_log_obj, level, "-DBL_MAX");
1032     } else if (d == -DBL_MIN) {
1033         av_log(av_log_obj, level, "-DBL_MIN");
1034     } else {
1035         av_log(av_log_obj, level, "%g", d);
1036     }
1037 }
1038
1039 static const char *get_opt_const_name(void *obj, const char *unit, int64_t value)
1040 {
1041     const AVOption *opt = NULL;
1042
1043     if (!unit)
1044         return NULL;
1045     while ((opt = av_opt_next(obj, opt)))
1046         if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1047             opt->default_val.i64 == value)
1048             return opt->name;
1049     return NULL;
1050 }
1051
1052 static char *get_opt_flags_string(void *obj, const char *unit, int64_t value)
1053 {
1054     const AVOption *opt = NULL;
1055     char flags[512];
1056
1057     flags[0] = 0;
1058     if (!unit)
1059         return NULL;
1060     while ((opt = av_opt_next(obj, opt))) {
1061         if (opt->type == AV_OPT_TYPE_CONST && !strcmp(opt->unit, unit) &&
1062             opt->default_val.i64 & value) {
1063             if (flags[0])
1064                 av_strlcatf(flags, sizeof(flags), "+");
1065             av_strlcatf(flags, sizeof(flags), "%s", opt->name);
1066         }
1067     }
1068     if (flags[0])
1069         return av_strdup(flags);
1070     return NULL;
1071 }
1072
1073 static void opt_list(void *obj, void *av_log_obj, const char *unit,
1074                      int req_flags, int rej_flags)
1075 {
1076     const AVOption *opt = NULL;
1077     AVOptionRanges *r;
1078     int i;
1079
1080     while ((opt = av_opt_next(obj, opt))) {
1081         if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
1082             continue;
1083
1084         /* Don't print CONST's on level one.
1085          * Don't print anything but CONST's on level two.
1086          * Only print items from the requested unit.
1087          */
1088         if (!unit && opt->type == AV_OPT_TYPE_CONST)
1089             continue;
1090         else if (unit && opt->type != AV_OPT_TYPE_CONST)
1091             continue;
1092         else if (unit && opt->type == AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
1093             continue;
1094         else if (unit && opt->type == AV_OPT_TYPE_CONST)
1095             av_log(av_log_obj, AV_LOG_INFO, "     %-15s ", opt->name);
1096         else
1097             av_log(av_log_obj, AV_LOG_INFO, "  %s%-17s ",
1098                    (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
1099                    opt->name);
1100
1101         switch (opt->type) {
1102             case AV_OPT_TYPE_FLAGS:
1103                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<flags>");
1104                 break;
1105             case AV_OPT_TYPE_INT:
1106                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int>");
1107                 break;
1108             case AV_OPT_TYPE_INT64:
1109                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<int64>");
1110                 break;
1111             case AV_OPT_TYPE_DOUBLE:
1112                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<double>");
1113                 break;
1114             case AV_OPT_TYPE_FLOAT:
1115                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<float>");
1116                 break;
1117             case AV_OPT_TYPE_STRING:
1118                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<string>");
1119                 break;
1120             case AV_OPT_TYPE_RATIONAL:
1121                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<rational>");
1122                 break;
1123             case AV_OPT_TYPE_BINARY:
1124                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<binary>");
1125                 break;
1126             case AV_OPT_TYPE_IMAGE_SIZE:
1127                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<image_size>");
1128                 break;
1129             case AV_OPT_TYPE_VIDEO_RATE:
1130                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<video_rate>");
1131                 break;
1132             case AV_OPT_TYPE_PIXEL_FMT:
1133                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<pix_fmt>");
1134                 break;
1135             case AV_OPT_TYPE_SAMPLE_FMT:
1136                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<sample_fmt>");
1137                 break;
1138             case AV_OPT_TYPE_DURATION:
1139                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<duration>");
1140                 break;
1141             case AV_OPT_TYPE_COLOR:
1142                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<color>");
1143                 break;
1144             case AV_OPT_TYPE_CHANNEL_LAYOUT:
1145                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<channel_layout>");
1146                 break;
1147             case AV_OPT_TYPE_BOOL:
1148                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<boolean>");
1149                 break;
1150             case AV_OPT_TYPE_CONST:
1151             default:
1152                 av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
1153                 break;
1154         }
1155         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
1156         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
1157         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_FILTERING_PARAM)? 'F' : '.');
1158         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM   ) ? 'V' : '.');
1159         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM   ) ? 'A' : '.');
1160         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
1161         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT)         ? 'X' : '.');
1162         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY)       ? 'R' : '.');
1163
1164         if (opt->help)
1165             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
1166
1167         if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) >= 0) {
1168             switch (opt->type) {
1169             case AV_OPT_TYPE_INT:
1170             case AV_OPT_TYPE_INT64:
1171             case AV_OPT_TYPE_DOUBLE:
1172             case AV_OPT_TYPE_FLOAT:
1173             case AV_OPT_TYPE_RATIONAL:
1174                 for (i = 0; i < r->nb_ranges; i++) {
1175                     av_log(av_log_obj, AV_LOG_INFO, " (from ");
1176                     log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_min);
1177                     av_log(av_log_obj, AV_LOG_INFO, " to ");
1178                     log_value(av_log_obj, AV_LOG_INFO, r->range[i]->value_max);
1179                     av_log(av_log_obj, AV_LOG_INFO, ")");
1180                 }
1181                 break;
1182             }
1183             av_opt_freep_ranges(&r);
1184         }
1185
1186         if (opt->type != AV_OPT_TYPE_CONST  &&
1187             opt->type != AV_OPT_TYPE_BINARY &&
1188                 !((opt->type == AV_OPT_TYPE_COLOR      ||
1189                    opt->type == AV_OPT_TYPE_IMAGE_SIZE ||
1190                    opt->type == AV_OPT_TYPE_STRING     ||
1191                    opt->type == AV_OPT_TYPE_VIDEO_RATE) &&
1192                   !opt->default_val.str)) {
1193             av_log(av_log_obj, AV_LOG_INFO, " (default ");
1194             switch (opt->type) {
1195             case AV_OPT_TYPE_BOOL:
1196                 av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(get_bool_name(opt->default_val.i64), "invalid"));
1197                 break;
1198             case AV_OPT_TYPE_FLAGS: {
1199                 char *def_flags = get_opt_flags_string(obj, opt->unit, opt->default_val.i64);
1200                 if (def_flags) {
1201                     av_log(av_log_obj, AV_LOG_INFO, "%s", def_flags);
1202                     av_freep(&def_flags);
1203                 } else {
1204                     av_log(av_log_obj, AV_LOG_INFO, "%"PRIX64, opt->default_val.i64);
1205                 }
1206                 break;
1207             }
1208             case AV_OPT_TYPE_DURATION: {
1209                 char buf[25];
1210                 format_duration(buf, sizeof(buf), opt->default_val.i64);
1211                 av_log(av_log_obj, AV_LOG_INFO, "%s", buf);
1212                 break;
1213             }
1214             case AV_OPT_TYPE_INT:
1215             case AV_OPT_TYPE_INT64: {
1216                 const char *def_const = get_opt_const_name(obj, opt->unit, opt->default_val.i64);
1217                 if (def_const)
1218                     av_log(av_log_obj, AV_LOG_INFO, "%s", def_const);
1219                 else
1220                     log_value(av_log_obj, AV_LOG_INFO, opt->default_val.i64);
1221                 break;
1222             }
1223             case AV_OPT_TYPE_DOUBLE:
1224             case AV_OPT_TYPE_FLOAT:
1225                 log_value(av_log_obj, AV_LOG_INFO, opt->default_val.dbl);
1226                 break;
1227             case AV_OPT_TYPE_RATIONAL: {
1228                 AVRational q = av_d2q(opt->default_val.dbl, INT_MAX);
1229                 av_log(av_log_obj, AV_LOG_INFO, "%d/%d", q.num, q.den); }
1230                 break;
1231             case AV_OPT_TYPE_PIXEL_FMT:
1232                 av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_pix_fmt_name(opt->default_val.i64), "none"));
1233                 break;
1234             case AV_OPT_TYPE_SAMPLE_FMT:
1235                 av_log(av_log_obj, AV_LOG_INFO, "%s", (char *)av_x_if_null(av_get_sample_fmt_name(opt->default_val.i64), "none"));
1236                 break;
1237             case AV_OPT_TYPE_COLOR:
1238             case AV_OPT_TYPE_IMAGE_SIZE:
1239             case AV_OPT_TYPE_STRING:
1240             case AV_OPT_TYPE_VIDEO_RATE:
1241                 av_log(av_log_obj, AV_LOG_INFO, "\"%s\"", opt->default_val.str);
1242                 break;
1243             case AV_OPT_TYPE_CHANNEL_LAYOUT:
1244                 av_log(av_log_obj, AV_LOG_INFO, "0x%"PRIx64, opt->default_val.i64);
1245                 break;
1246             }
1247             av_log(av_log_obj, AV_LOG_INFO, ")");
1248         }
1249
1250         av_log(av_log_obj, AV_LOG_INFO, "\n");
1251         if (opt->unit && opt->type != AV_OPT_TYPE_CONST)
1252             opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
1253     }
1254 }
1255
1256 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
1257 {
1258     if (!obj)
1259         return -1;
1260
1261     av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass **)obj)->class_name);
1262
1263     opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
1264
1265     return 0;
1266 }
1267
1268 void av_opt_set_defaults(void *s)
1269 {
1270     av_opt_set_defaults2(s, 0, 0);
1271 }
1272
1273 void av_opt_set_defaults2(void *s, int mask, int flags)
1274 {
1275     const AVOption *opt = NULL;
1276     while ((opt = av_opt_next(s, opt))) {
1277         void *dst = ((uint8_t*)s) + opt->offset;
1278
1279         if ((opt->flags & mask) != flags)
1280             continue;
1281
1282         if (opt->flags & AV_OPT_FLAG_READONLY)
1283             continue;
1284
1285         switch (opt->type) {
1286             case AV_OPT_TYPE_CONST:
1287                 /* Nothing to be done here */
1288                 break;
1289             case AV_OPT_TYPE_BOOL:
1290             case AV_OPT_TYPE_FLAGS:
1291             case AV_OPT_TYPE_INT:
1292             case AV_OPT_TYPE_INT64:
1293             case AV_OPT_TYPE_DURATION:
1294             case AV_OPT_TYPE_CHANNEL_LAYOUT:
1295             case AV_OPT_TYPE_PIXEL_FMT:
1296             case AV_OPT_TYPE_SAMPLE_FMT:
1297                 write_number(s, opt, dst, 1, 1, opt->default_val.i64);
1298                 break;
1299             case AV_OPT_TYPE_DOUBLE:
1300             case AV_OPT_TYPE_FLOAT: {
1301                 double val;
1302                 val = opt->default_val.dbl;
1303                 write_number(s, opt, dst, val, 1, 1);
1304             }
1305             break;
1306             case AV_OPT_TYPE_RATIONAL: {
1307                 AVRational val;
1308                 val = av_d2q(opt->default_val.dbl, INT_MAX);
1309                 write_number(s, opt, dst, 1, val.den, val.num);
1310             }
1311             break;
1312             case AV_OPT_TYPE_COLOR:
1313                 set_string_color(s, opt, opt->default_val.str, dst);
1314                 break;
1315             case AV_OPT_TYPE_STRING:
1316                 set_string(s, opt, opt->default_val.str, dst);
1317                 break;
1318             case AV_OPT_TYPE_IMAGE_SIZE:
1319                 set_string_image_size(s, opt, opt->default_val.str, dst);
1320                 break;
1321             case AV_OPT_TYPE_VIDEO_RATE:
1322                 set_string_video_rate(s, opt, opt->default_val.str, dst);
1323                 break;
1324             case AV_OPT_TYPE_BINARY:
1325                 set_string_binary(s, opt, opt->default_val.str, dst);
1326                 break;
1327             case AV_OPT_TYPE_DICT:
1328                 /* Cannot set defaults for these types */
1329             break;
1330         default:
1331             av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n",
1332                    opt->type, opt->name);
1333         }
1334     }
1335 }
1336
1337 /**
1338  * Store the value in the field in ctx that is named like key.
1339  * ctx must be an AVClass context, storing is done using AVOptions.
1340  *
1341  * @param buf the string to parse, buf will be updated to point at the
1342  * separator just after the parsed key/value pair
1343  * @param key_val_sep a 0-terminated list of characters used to
1344  * separate key from value
1345  * @param pairs_sep a 0-terminated list of characters used to separate
1346  * two pairs from each other
1347  * @return 0 if the key/value pair has been successfully parsed and
1348  * set, or a negative value corresponding to an AVERROR code in case
1349  * of error:
1350  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
1351  * the error code issued by av_opt_set() if the key/value pair
1352  * cannot be set
1353  */
1354 static int parse_key_value_pair(void *ctx, const char **buf,
1355                                 const char *key_val_sep, const char *pairs_sep)
1356 {
1357     char *key = av_get_token(buf, key_val_sep);
1358     char *val;
1359     int ret;
1360
1361     if (!key)
1362         return AVERROR(ENOMEM);
1363
1364     if (*key && strspn(*buf, key_val_sep)) {
1365         (*buf)++;
1366         val = av_get_token(buf, pairs_sep);
1367         if (!val) {
1368             av_freep(&key);
1369             return AVERROR(ENOMEM);
1370         }
1371     } else {
1372         av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
1373         av_free(key);
1374         return AVERROR(EINVAL);
1375     }
1376
1377     av_log(ctx, AV_LOG_DEBUG, "Setting entry with key '%s' to value '%s'\n", key, val);
1378
1379     ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
1380     if (ret == AVERROR_OPTION_NOT_FOUND)
1381         av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
1382
1383     av_free(key);
1384     av_free(val);
1385     return ret;
1386 }
1387
1388 int av_set_options_string(void *ctx, const char *opts,
1389                           const char *key_val_sep, const char *pairs_sep)
1390 {
1391     int ret, count = 0;
1392
1393     if (!opts)
1394         return 0;
1395
1396     while (*opts) {
1397         if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
1398             return ret;
1399         count++;
1400
1401         if (*opts)
1402             opts++;
1403     }
1404
1405     return count;
1406 }
1407
1408 #define WHITESPACES " \n\t\r"
1409
1410 static int is_key_char(char c)
1411 {
1412     return (unsigned)((c | 32) - 'a') < 26 ||
1413            (unsigned)(c - '0') < 10 ||
1414            c == '-' || c == '_' || c == '/' || c == '.';
1415 }
1416
1417 /**
1418  * Read a key from a string.
1419  *
1420  * The key consists of is_key_char characters and must be terminated by a
1421  * character from the delim string; spaces are ignored.
1422  *
1423  * @return  0 for success (even with ellipsis), <0 for failure
1424  */
1425 static int get_key(const char **ropts, const char *delim, char **rkey)
1426 {
1427     const char *opts = *ropts;
1428     const char *key_start, *key_end;
1429
1430     key_start = opts += strspn(opts, WHITESPACES);
1431     while (is_key_char(*opts))
1432         opts++;
1433     key_end = opts;
1434     opts += strspn(opts, WHITESPACES);
1435     if (!*opts || !strchr(delim, *opts))
1436         return AVERROR(EINVAL);
1437     opts++;
1438     if (!(*rkey = av_malloc(key_end - key_start + 1)))
1439         return AVERROR(ENOMEM);
1440     memcpy(*rkey, key_start, key_end - key_start);
1441     (*rkey)[key_end - key_start] = 0;
1442     *ropts = opts;
1443     return 0;
1444 }
1445
1446 int av_opt_get_key_value(const char **ropts,
1447                          const char *key_val_sep, const char *pairs_sep,
1448                          unsigned flags,
1449                          char **rkey, char **rval)
1450 {
1451     int ret;
1452     char *key = NULL, *val;
1453     const char *opts = *ropts;
1454
1455     if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
1456         !(flags & AV_OPT_FLAG_IMPLICIT_KEY))
1457         return AVERROR(EINVAL);
1458     if (!(val = av_get_token(&opts, pairs_sep))) {
1459         av_free(key);
1460         return AVERROR(ENOMEM);
1461     }
1462     *ropts = opts;
1463     *rkey  = key;
1464     *rval  = val;
1465     return 0;
1466 }
1467
1468 int av_opt_set_from_string(void *ctx, const char *opts,
1469                            const char *const *shorthand,
1470                            const char *key_val_sep, const char *pairs_sep)
1471 {
1472     int ret, count = 0;
1473     const char *dummy_shorthand = NULL;
1474     char *av_uninit(parsed_key), *av_uninit(value);
1475     const char *key;
1476
1477     if (!opts)
1478         return 0;
1479     if (!shorthand)
1480         shorthand = &dummy_shorthand;
1481
1482     while (*opts) {
1483         ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
1484                                    *shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
1485                                    &parsed_key, &value);
1486         if (ret < 0) {
1487             if (ret == AVERROR(EINVAL))
1488                 av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", opts);
1489             else
1490                 av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", opts,
1491                        av_err2str(ret));
1492             return ret;
1493         }
1494         if (*opts)
1495             opts++;
1496         if (parsed_key) {
1497             key = parsed_key;
1498             while (*shorthand) /* discard all remaining shorthand */
1499                 shorthand++;
1500         } else {
1501             key = *(shorthand++);
1502         }
1503
1504         av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
1505         if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
1506             if (ret == AVERROR_OPTION_NOT_FOUND)
1507                 av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
1508             av_free(value);
1509             av_free(parsed_key);
1510             return ret;
1511         }
1512
1513         av_free(value);
1514         av_free(parsed_key);
1515         count++;
1516     }
1517     return count;
1518 }
1519
1520 void av_opt_free(void *obj)
1521 {
1522     const AVOption *o = NULL;
1523     while ((o = av_opt_next(obj, o))) {
1524         switch (o->type) {
1525         case AV_OPT_TYPE_STRING:
1526         case AV_OPT_TYPE_BINARY:
1527             av_freep((uint8_t *)obj + o->offset);
1528             break;
1529
1530         case AV_OPT_TYPE_DICT:
1531             av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
1532             break;
1533
1534         default:
1535             break;
1536         }
1537     }
1538 }
1539
1540 int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
1541 {
1542     AVDictionaryEntry *t = NULL;
1543     AVDictionary    *tmp = NULL;
1544     int ret = 0;
1545
1546     if (!options)
1547         return 0;
1548
1549     while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
1550         ret = av_opt_set(obj, t->key, t->value, search_flags);
1551         if (ret == AVERROR_OPTION_NOT_FOUND)
1552             ret = av_dict_set(&tmp, t->key, t->value, 0);
1553         if (ret < 0) {
1554             av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
1555             av_dict_free(&tmp);
1556             return ret;
1557         }
1558         ret = 0;
1559     }
1560     av_dict_free(options);
1561     *options = tmp;
1562     return ret;
1563 }
1564
1565 int av_opt_set_dict(void *obj, AVDictionary **options)
1566 {
1567     return av_opt_set_dict2(obj, options, 0);
1568 }
1569
1570 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
1571                             int opt_flags, int search_flags)
1572 {
1573     return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
1574 }
1575
1576 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
1577                              int opt_flags, int search_flags, void **target_obj)
1578 {
1579     const AVClass  *c;
1580     const AVOption *o = NULL;
1581
1582     if(!obj)
1583         return NULL;
1584
1585     c= *(AVClass**)obj;
1586
1587     if (!c)
1588         return NULL;
1589
1590     if (search_flags & AV_OPT_SEARCH_CHILDREN) {
1591         if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
1592             const AVClass *child = NULL;
1593             while (child = av_opt_child_class_next(c, child))
1594                 if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
1595                     return o;
1596         } else {
1597             void *child = NULL;
1598             while (child = av_opt_child_next(obj, child))
1599                 if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
1600                     return o;
1601         }
1602     }
1603
1604     while (o = av_opt_next(obj, o)) {
1605         if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
1606             ((!unit && o->type != AV_OPT_TYPE_CONST) ||
1607              (unit  && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
1608             if (target_obj) {
1609                 if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
1610                     *target_obj = obj;
1611                 else
1612                     *target_obj = NULL;
1613             }
1614             return o;
1615         }
1616     }
1617     return NULL;
1618 }
1619
1620 void *av_opt_child_next(void *obj, void *prev)
1621 {
1622     const AVClass *c = *(AVClass **)obj;
1623     if (c->child_next)
1624         return c->child_next(obj, prev);
1625     return NULL;
1626 }
1627
1628 const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
1629 {
1630     if (parent->child_class_next)
1631         return parent->child_class_next(prev);
1632     return NULL;
1633 }
1634
1635 void *av_opt_ptr(const AVClass *class, void *obj, const char *name)
1636 {
1637     const AVOption *opt= av_opt_find2(&class, name, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ, NULL);
1638     if(!opt)
1639         return NULL;
1640     return (uint8_t*)obj + opt->offset;
1641 }
1642
1643 static int opt_size(enum AVOptionType type)
1644 {
1645     switch(type) {
1646     case AV_OPT_TYPE_BOOL:
1647     case AV_OPT_TYPE_INT:
1648     case AV_OPT_TYPE_FLAGS:
1649         return sizeof(int);
1650     case AV_OPT_TYPE_DURATION:
1651     case AV_OPT_TYPE_CHANNEL_LAYOUT:
1652     case AV_OPT_TYPE_INT64:
1653         return sizeof(int64_t);
1654     case AV_OPT_TYPE_DOUBLE:
1655         return sizeof(double);
1656     case AV_OPT_TYPE_FLOAT:
1657         return sizeof(float);
1658     case AV_OPT_TYPE_STRING:
1659         return sizeof(uint8_t*);
1660     case AV_OPT_TYPE_VIDEO_RATE:
1661     case AV_OPT_TYPE_RATIONAL:
1662         return sizeof(AVRational);
1663     case AV_OPT_TYPE_BINARY:
1664         return sizeof(uint8_t*) + sizeof(int);
1665     case AV_OPT_TYPE_IMAGE_SIZE:
1666         return sizeof(int[2]);
1667     case AV_OPT_TYPE_PIXEL_FMT:
1668         return sizeof(enum AVPixelFormat);
1669     case AV_OPT_TYPE_SAMPLE_FMT:
1670         return sizeof(enum AVSampleFormat);
1671     case AV_OPT_TYPE_COLOR:
1672         return 4;
1673     }
1674     return AVERROR(EINVAL);
1675 }
1676
1677 int av_opt_copy(void *dst, const void *src)
1678 {
1679     const AVOption *o = NULL;
1680     const AVClass *c;
1681     int ret = 0;
1682
1683     if (!src)
1684         return AVERROR(EINVAL);
1685
1686     c = *(AVClass **)src;
1687     if (!c || c != *(AVClass **)dst)
1688         return AVERROR(EINVAL);
1689
1690     while ((o = av_opt_next(src, o))) {
1691         void *field_dst = (uint8_t *)dst + o->offset;
1692         void *field_src = (uint8_t *)src + o->offset;
1693         uint8_t **field_dst8 = (uint8_t **)field_dst;
1694         uint8_t **field_src8 = (uint8_t **)field_src;
1695
1696         if (o->type == AV_OPT_TYPE_STRING) {
1697             if (*field_dst8 != *field_src8)
1698                 av_freep(field_dst8);
1699             *field_dst8 = av_strdup(*field_src8);
1700             if (*field_src8 && !*field_dst8)
1701                 ret = AVERROR(ENOMEM);
1702         } else if (o->type == AV_OPT_TYPE_BINARY) {
1703             int len = *(int *)(field_src8 + 1);
1704             if (*field_dst8 != *field_src8)
1705                 av_freep(field_dst8);
1706             *field_dst8 = av_memdup(*field_src8, len);
1707             if (len && !*field_dst8) {
1708                 ret = AVERROR(ENOMEM);
1709                 len = 0;
1710             }
1711             *(int *)(field_dst8 + 1) = len;
1712         } else if (o->type == AV_OPT_TYPE_CONST) {
1713             // do nothing
1714         } else if (o->type == AV_OPT_TYPE_DICT) {
1715             AVDictionary **sdict = (AVDictionary **) field_src;
1716             AVDictionary **ddict = (AVDictionary **) field_dst;
1717             if (*sdict != *ddict)
1718                 av_dict_free(ddict);
1719             *ddict = NULL;
1720             av_dict_copy(ddict, *sdict, 0);
1721             if (av_dict_count(*sdict) != av_dict_count(*ddict))
1722                 ret = AVERROR(ENOMEM);
1723         } else {
1724             int size = opt_size(o->type);
1725             if (size < 0)
1726                 ret = size;
1727             else
1728                 memcpy(field_dst, field_src, size);
1729         }
1730     }
1731     return ret;
1732 }
1733
1734 int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1735 {
1736     int ret;
1737     const AVClass *c = *(AVClass**)obj;
1738     int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;
1739
1740     if (c->version > (52 << 16 | 11 << 8))
1741         callback = c->query_ranges;
1742
1743     if (!callback)
1744         callback = av_opt_query_ranges_default;
1745
1746     ret = callback(ranges_arg, obj, key, flags);
1747     if (ret >= 0) {
1748         if (!(flags & AV_OPT_MULTI_COMPONENT_RANGE))
1749             ret = 1;
1750         (*ranges_arg)->nb_components = ret;
1751     }
1752     return ret;
1753 }
1754
1755 int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
1756 {
1757     AVOptionRanges *ranges = av_mallocz(sizeof(*ranges));
1758     AVOptionRange **range_array = av_mallocz(sizeof(void*));
1759     AVOptionRange *range = av_mallocz(sizeof(*range));
1760     const AVOption *field = av_opt_find(obj, key, NULL, 0, flags);
1761     int ret;
1762
1763     *ranges_arg = NULL;
1764
1765     if (!ranges || !range || !range_array || !field) {
1766         ret = AVERROR(ENOMEM);
1767         goto fail;
1768     }
1769
1770     ranges->range = range_array;
1771     ranges->range[0] = range;
1772     ranges->nb_ranges = 1;
1773     ranges->nb_components = 1;
1774     range->is_range = 1;
1775     range->value_min = field->min;
1776     range->value_max = field->max;
1777
1778     switch (field->type) {
1779     case AV_OPT_TYPE_BOOL:
1780     case AV_OPT_TYPE_INT:
1781     case AV_OPT_TYPE_INT64:
1782     case AV_OPT_TYPE_PIXEL_FMT:
1783     case AV_OPT_TYPE_SAMPLE_FMT:
1784     case AV_OPT_TYPE_FLOAT:
1785     case AV_OPT_TYPE_DOUBLE:
1786     case AV_OPT_TYPE_DURATION:
1787     case AV_OPT_TYPE_COLOR:
1788     case AV_OPT_TYPE_CHANNEL_LAYOUT:
1789         break;
1790     case AV_OPT_TYPE_STRING:
1791         range->component_min = 0;
1792         range->component_max = 0x10FFFF; // max unicode value
1793         range->value_min = -1;
1794         range->value_max = INT_MAX;
1795         break;
1796     case AV_OPT_TYPE_RATIONAL:
1797         range->component_min = INT_MIN;
1798         range->component_max = INT_MAX;
1799         break;
1800     case AV_OPT_TYPE_IMAGE_SIZE:
1801         range->component_min = 0;
1802         range->component_max = INT_MAX/128/8;
1803         range->value_min = 0;
1804         range->value_max = INT_MAX/8;
1805         break;
1806     case AV_OPT_TYPE_VIDEO_RATE:
1807         range->component_min = 1;
1808         range->component_max = INT_MAX;
1809         range->value_min = 1;
1810         range->value_max = INT_MAX;
1811         break;
1812     default:
1813         ret = AVERROR(ENOSYS);
1814         goto fail;
1815     }
1816
1817     *ranges_arg = ranges;
1818     return 1;
1819 fail:
1820     av_free(ranges);
1821     av_free(range);
1822     av_free(range_array);
1823     return ret;
1824 }
1825
1826 void av_opt_freep_ranges(AVOptionRanges **rangesp)
1827 {
1828     int i;
1829     AVOptionRanges *ranges = *rangesp;
1830
1831     if (!ranges)
1832         return;
1833
1834     for (i = 0; i < ranges->nb_ranges * ranges->nb_components; i++) {
1835         AVOptionRange *range = ranges->range[i];
1836         if (range) {
1837             av_freep(&range->str);
1838             av_freep(&ranges->range[i]);
1839         }
1840     }
1841     av_freep(&ranges->range);
1842     av_freep(rangesp);
1843 }
1844
1845 int av_opt_is_set_to_default(void *obj, const AVOption *o)
1846 {
1847     int64_t i64;
1848     double d, d2;
1849     float f;
1850     AVRational q;
1851     int ret, w, h;
1852     char *str;
1853     void *dst;
1854
1855     if (!o || !obj)
1856         return AVERROR(EINVAL);
1857
1858     dst = ((uint8_t*)obj) + o->offset;
1859
1860     switch (o->type) {
1861     case AV_OPT_TYPE_CONST:
1862         return 1;
1863     case AV_OPT_TYPE_BOOL:
1864     case AV_OPT_TYPE_FLAGS:
1865     case AV_OPT_TYPE_PIXEL_FMT:
1866     case AV_OPT_TYPE_SAMPLE_FMT:
1867     case AV_OPT_TYPE_INT:
1868     case AV_OPT_TYPE_CHANNEL_LAYOUT:
1869     case AV_OPT_TYPE_DURATION:
1870     case AV_OPT_TYPE_INT64:
1871         read_number(o, dst, NULL, NULL, &i64);
1872         return o->default_val.i64 == i64;
1873     case AV_OPT_TYPE_STRING:
1874         str = *(char **)dst;
1875         if (str == o->default_val.str) //2 NULLs
1876             return 1;
1877         if (!str || !o->default_val.str) //1 NULL
1878             return 0;
1879         return !strcmp(str, o->default_val.str);
1880     case AV_OPT_TYPE_DOUBLE:
1881         read_number(o, dst, &d, NULL, NULL);
1882         return o->default_val.dbl == d;
1883     case AV_OPT_TYPE_FLOAT:
1884         read_number(o, dst, &d, NULL, NULL);
1885         f = o->default_val.dbl;
1886         d2 = f;
1887         return d2 == d;
1888     case AV_OPT_TYPE_RATIONAL:
1889         q = av_d2q(o->default_val.dbl, INT_MAX);
1890         return !av_cmp_q(*(AVRational*)dst, q);
1891     case AV_OPT_TYPE_BINARY: {
1892         struct {
1893             uint8_t *data;
1894             int size;
1895         } tmp = {0};
1896         int opt_size = *(int *)((void **)dst + 1);
1897         void *opt_ptr = *(void **)dst;
1898         if (!opt_size && (!o->default_val.str || !strlen(o->default_val.str)))
1899             return 1;
1900         if (!opt_size ||  !o->default_val.str || !strlen(o->default_val.str ))
1901             return 0;
1902         if (opt_size != strlen(o->default_val.str) / 2)
1903             return 0;
1904         ret = set_string_binary(NULL, NULL, o->default_val.str, &tmp.data);
1905         if (!ret)
1906             ret = !memcmp(opt_ptr, tmp.data, tmp.size);
1907         av_free(tmp.data);
1908         return ret;
1909     }
1910     case AV_OPT_TYPE_DICT:
1911         /* Binary and dict have not default support yet. Any pointer is not default. */
1912         return !!(*(void **)dst);
1913     case AV_OPT_TYPE_IMAGE_SIZE:
1914         if (!o->default_val.str || !strcmp(o->default_val.str, "none"))
1915             w = h = 0;
1916         else if ((ret = av_parse_video_size(&w, &h, o->default_val.str)) < 0)
1917             return ret;
1918         return (w == *(int *)dst) && (h == *((int *)dst+1));
1919     case AV_OPT_TYPE_VIDEO_RATE:
1920         q = (AVRational){0, 0};
1921         if (o->default_val.str) {
1922             if ((ret = av_parse_video_rate(&q, o->default_val.str)) < 0)
1923                 return ret;
1924         }
1925         return !av_cmp_q(*(AVRational*)dst, q);
1926     case AV_OPT_TYPE_COLOR: {
1927         uint8_t color[4] = {0, 0, 0, 0};
1928         if (o->default_val.str) {
1929             if ((ret = av_parse_color(color, o->default_val.str, -1, NULL)) < 0)
1930                 return ret;
1931         }
1932         return !memcmp(color, dst, sizeof(color));
1933     }
1934     default:
1935         av_log(obj, AV_LOG_WARNING, "Not supported option type: %d, option name: %s\n", o->type, o->name);
1936         break;
1937     }
1938     return AVERROR_PATCHWELCOME;
1939 }
1940
1941 int av_opt_is_set_to_default_by_name(void *obj, const char *name, int search_flags)
1942 {
1943     const AVOption *o;
1944     void *target;
1945     if (!obj)
1946         return AVERROR(EINVAL);
1947     o = av_opt_find2(obj, name, NULL, 0, search_flags, &target);
1948     if (!o)
1949         return AVERROR_OPTION_NOT_FOUND;
1950     return av_opt_is_set_to_default(target, o);
1951 }
1952
1953 int av_opt_serialize(void *obj, int opt_flags, int flags, char **buffer,
1954                      const char key_val_sep, const char pairs_sep)
1955 {
1956     const AVOption *o = NULL;
1957     uint8_t *buf;
1958     AVBPrint bprint;
1959     int ret, cnt = 0;
1960     const char special_chars[] = {pairs_sep, key_val_sep, '\0'};
1961
1962     if (pairs_sep == '\0' || key_val_sep == '\0' || pairs_sep == key_val_sep ||
1963         pairs_sep == '\\' || key_val_sep == '\\') {
1964         av_log(obj, AV_LOG_ERROR, "Invalid separator(s) found.");
1965         return AVERROR(EINVAL);
1966     }
1967
1968     if (!obj || !buffer)
1969         return AVERROR(EINVAL);
1970
1971     *buffer = NULL;
1972     av_bprint_init(&bprint, 64, AV_BPRINT_SIZE_UNLIMITED);
1973
1974     while (o = av_opt_next(obj, o)) {
1975         if (o->type == AV_OPT_TYPE_CONST)
1976             continue;
1977         if ((flags & AV_OPT_SERIALIZE_OPT_FLAGS_EXACT) && o->flags != opt_flags)
1978             continue;
1979         else if (((o->flags & opt_flags) != opt_flags))
1980             continue;
1981         if (flags & AV_OPT_SERIALIZE_SKIP_DEFAULTS && av_opt_is_set_to_default(obj, o) > 0)
1982             continue;
1983         if ((ret = av_opt_get(obj, o->name, 0, &buf)) < 0) {
1984             av_bprint_finalize(&bprint, NULL);
1985             return ret;
1986         }
1987         if (buf) {
1988             if (cnt++)
1989                 av_bprint_append_data(&bprint, &pairs_sep, 1);
1990             av_bprint_escape(&bprint, o->name, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
1991             av_bprint_append_data(&bprint, &key_val_sep, 1);
1992             av_bprint_escape(&bprint, buf, special_chars, AV_ESCAPE_MODE_BACKSLASH, 0);
1993             av_freep(&buf);
1994         }
1995     }
1996     av_bprint_finalize(&bprint, buffer);
1997     return 0;
1998 }