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