01502435b772eacfa5f23e007420466a5decda1d
[ffmpeg.git] / libavutil / opt.c
1 /*
2  * AVOptions
3  * Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * AVOptions
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27
28 #include "avutil.h"
29 #include "avstring.h"
30 #include "common.h"
31 #include "opt.h"
32 #include "eval.h"
33 #include "dict.h"
34 #include "log.h"
35 #include "mathematics.h"
36
37 const AVOption *av_opt_next(const void *obj, const AVOption *last)
38 {
39     AVClass *class = *(AVClass**)obj;
40     if (!last && class->option && class->option[0].name)
41         return class->option;
42     if (last && last[1].name)
43         return ++last;
44     return NULL;
45 }
46
47 static int read_number(const AVOption *o, const void *dst, double *num, int *den, int64_t *intnum)
48 {
49     switch (o->type) {
50     case AV_OPT_TYPE_FLAGS:     *intnum = *(unsigned int*)dst;return 0;
51     case AV_OPT_TYPE_INT:       *intnum = *(int         *)dst;return 0;
52     case AV_OPT_TYPE_INT64:     *intnum = *(int64_t     *)dst;return 0;
53     case AV_OPT_TYPE_FLOAT:     *num    = *(float       *)dst;return 0;
54     case AV_OPT_TYPE_DOUBLE:    *num    = *(double      *)dst;return 0;
55     case AV_OPT_TYPE_RATIONAL:  *intnum = ((AVRational*)dst)->num;
56                                 *den    = ((AVRational*)dst)->den;
57                                                         return 0;
58     }
59     return AVERROR(EINVAL);
60 }
61
62 static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
63 {
64     if (o->type != AV_OPT_TYPE_FLAGS &&
65         (o->max * den < num * intnum || o->min * den > num * intnum)) {
66         av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range\n",
67                num*intnum/den, o->name);
68         return AVERROR(ERANGE);
69     }
70
71     switch (o->type) {
72     case AV_OPT_TYPE_FLAGS:
73     case AV_OPT_TYPE_INT:   *(int       *)dst= llrint(num/den)*intnum; break;
74     case AV_OPT_TYPE_INT64: *(int64_t   *)dst= llrint(num/den)*intnum; break;
75     case AV_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
76     case AV_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
77     case AV_OPT_TYPE_RATIONAL:
78         if ((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
79         else                 *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
80         break;
81     default:
82         return AVERROR(EINVAL);
83     }
84     return 0;
85 }
86
87 static const double const_values[] = {
88     M_PI,
89     M_E,
90     FF_QP2LAMBDA,
91     0
92 };
93
94 static const char * const const_names[] = {
95     "PI",
96     "E",
97     "QP2LAMBDA",
98     0
99 };
100
101 static int hexchar2int(char c) {
102     if (c >= '0' && c <= '9') return c - '0';
103     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
104     if (c >= 'A' && c <= 'F') return c - 'A' + 10;
105     return -1;
106 }
107
108 static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
109 {
110     int *lendst = (int *)(dst + 1);
111     uint8_t *bin, *ptr;
112     int len = strlen(val);
113
114     av_freep(dst);
115     *lendst = 0;
116
117     if (len & 1)
118         return AVERROR(EINVAL);
119     len /= 2;
120
121     ptr = bin = av_malloc(len);
122     if (!ptr)
123         return AVERROR(ENOMEM);
124     while (*val) {
125         int a = hexchar2int(*val++);
126         int b = hexchar2int(*val++);
127         if (a < 0 || b < 0) {
128             av_free(bin);
129             return AVERROR(EINVAL);
130         }
131         *ptr++ = (a << 4) | b;
132     }
133     *dst = bin;
134     *lendst = len;
135
136     return 0;
137 }
138
139 static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
140 {
141     av_freep(dst);
142     *dst = av_strdup(val);
143     return *dst ? 0 : AVERROR(ENOMEM);
144 }
145
146 #define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
147                               opt->type == AV_OPT_TYPE_CONST || \
148                               opt->type == AV_OPT_TYPE_FLAGS || \
149                               opt->type == AV_OPT_TYPE_INT) ? \
150                              opt->default_val.i64 : opt->default_val.dbl)
151
152 static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
153 {
154     int ret = 0, notfirst = 0;
155     for (;;) {
156         int i, den = 1;
157         char buf[256];
158         int cmd = 0;
159         double d, num = 1;
160         int64_t intnum = 1;
161
162         i = 0;
163         if (*val == '+' || *val == '-') {
164             if (o->type == AV_OPT_TYPE_FLAGS)
165                 cmd = *(val++);
166             else if (!notfirst)
167                 buf[i++] = *val;
168         }
169
170         for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
171             buf[i] = val[i];
172         buf[i] = 0;
173
174         {
175             const AVOption *o_named = av_opt_find(target_obj, buf, o->unit, 0, 0);
176             if (o_named && o_named->type == AV_OPT_TYPE_CONST)
177                 d = DEFAULT_NUMVAL(o_named);
178             else if (!strcmp(buf, "default")) d = DEFAULT_NUMVAL(o);
179             else if (!strcmp(buf, "max"    )) d = o->max;
180             else if (!strcmp(buf, "min"    )) d = o->min;
181             else if (!strcmp(buf, "none"   )) d = 0;
182             else if (!strcmp(buf, "all"    )) d = ~0;
183             else {
184                 int res = av_expr_parse_and_eval(&d, buf, const_names, const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
185                 if (res < 0) {
186                     av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
187                     return res;
188                 }
189             }
190         }
191         if (o->type == AV_OPT_TYPE_FLAGS) {
192             read_number(o, dst, NULL, NULL, &intnum);
193             if      (cmd == '+') d = intnum | (int64_t)d;
194             else if (cmd == '-') d = intnum &~(int64_t)d;
195         } else {
196             read_number(o, dst, &num, &den, &intnum);
197             if      (cmd == '+') d = notfirst*num*intnum/den + d;
198             else if (cmd == '-') d = notfirst*num*intnum/den - d;
199         }
200
201         if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
202             return ret;
203         val += i;
204         if (!*val)
205             return 0;
206         notfirst = 1;
207     }
208
209     return 0;
210 }
211
212 int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
213 {
214     void *dst, *target_obj;
215     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
216     if (!o || !target_obj)
217         return AVERROR_OPTION_NOT_FOUND;
218     if (!val || o->flags & AV_OPT_FLAG_READONLY)
219         return AVERROR(EINVAL);
220
221     dst = ((uint8_t*)target_obj) + o->offset;
222     switch (o->type) {
223     case AV_OPT_TYPE_STRING:   return set_string(obj, o, val, dst);
224     case AV_OPT_TYPE_BINARY:   return set_string_binary(obj, o, val, dst);
225     case AV_OPT_TYPE_FLAGS:
226     case AV_OPT_TYPE_INT:
227     case AV_OPT_TYPE_INT64:
228     case AV_OPT_TYPE_FLOAT:
229     case AV_OPT_TYPE_DOUBLE:
230     case AV_OPT_TYPE_RATIONAL: return set_string_number(obj, target_obj, o, val, dst);
231     }
232
233     av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
234     return AVERROR(EINVAL);
235 }
236
237 #define OPT_EVAL_NUMBER(name, opttype, vartype)\
238     int av_opt_eval_ ## name(void *obj, const AVOption *o, const char *val, vartype *name ## _out)\
239     {\
240         if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY)\
241             return AVERROR(EINVAL);\
242         return set_string_number(obj, obj, o, val, name ## _out);\
243     }
244
245 OPT_EVAL_NUMBER(flags,  AV_OPT_TYPE_FLAGS,    int)
246 OPT_EVAL_NUMBER(int,    AV_OPT_TYPE_INT,      int)
247 OPT_EVAL_NUMBER(int64,  AV_OPT_TYPE_INT64,    int64_t)
248 OPT_EVAL_NUMBER(float,  AV_OPT_TYPE_FLOAT,    float)
249 OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE,   double)
250 OPT_EVAL_NUMBER(q,      AV_OPT_TYPE_RATIONAL, AVRational)
251
252 static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
253                                   int search_flags)
254 {
255     void *dst, *target_obj;
256     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
257
258     if (!o || !target_obj)
259         return AVERROR_OPTION_NOT_FOUND;
260
261     if (o->flags & AV_OPT_FLAG_READONLY)
262         return AVERROR(EINVAL);
263
264     dst = ((uint8_t*)target_obj) + o->offset;
265     return write_number(obj, o, dst, num, den, intnum);
266 }
267
268 int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
269 {
270     return set_number(obj, name, 1, 1, val, search_flags);
271 }
272
273 int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
274 {
275     return set_number(obj, name, val, 1, 1, search_flags);
276 }
277
278 int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
279 {
280     return set_number(obj, name, val.num, val.den, 1, search_flags);
281 }
282
283 int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
284 {
285     void *target_obj;
286     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
287     uint8_t *ptr;
288     uint8_t **dst;
289     int *lendst;
290
291     if (!o || !target_obj)
292         return AVERROR_OPTION_NOT_FOUND;
293
294     if (o->type != AV_OPT_TYPE_BINARY || o->flags & AV_OPT_FLAG_READONLY)
295         return AVERROR(EINVAL);
296
297     ptr = av_malloc(len);
298     if (!ptr)
299         return AVERROR(ENOMEM);
300
301     dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
302     lendst = (int *)(dst + 1);
303
304     av_free(*dst);
305     *dst = ptr;
306     *lendst = len;
307     memcpy(ptr, val, len);
308
309     return 0;
310 }
311
312 int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
313 {
314     void *target_obj;
315     AVDictionary **dst;
316     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
317
318     if (!o || !target_obj)
319         return AVERROR_OPTION_NOT_FOUND;
320     if (o->flags & AV_OPT_FLAG_READONLY)
321         return AVERROR(EINVAL);
322
323     dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
324     av_dict_free(dst);
325     av_dict_copy(dst, val, 0);
326
327     return 0;
328 }
329
330 int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
331 {
332     void *dst, *target_obj;
333     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
334     uint8_t *bin, buf[128];
335     int len, i, ret;
336
337     if (!o || !target_obj)
338         return AVERROR_OPTION_NOT_FOUND;
339
340     dst = (uint8_t*)target_obj + o->offset;
341
342     buf[0] = 0;
343     switch (o->type) {
344     case AV_OPT_TYPE_FLAGS:     ret = snprintf(buf, sizeof(buf), "0x%08X",  *(int    *)dst);break;
345     case AV_OPT_TYPE_INT:       ret = snprintf(buf, sizeof(buf), "%d" ,     *(int    *)dst);break;
346     case AV_OPT_TYPE_INT64:     ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t*)dst);break;
347     case AV_OPT_TYPE_FLOAT:     ret = snprintf(buf, sizeof(buf), "%f" ,     *(float  *)dst);break;
348     case AV_OPT_TYPE_DOUBLE:    ret = snprintf(buf, sizeof(buf), "%f" ,     *(double *)dst);break;
349     case AV_OPT_TYPE_RATIONAL:  ret = snprintf(buf, sizeof(buf), "%d/%d",   ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
350     case AV_OPT_TYPE_STRING:
351         if (*(uint8_t**)dst)
352             *out_val = av_strdup(*(uint8_t**)dst);
353         else
354             *out_val = av_strdup("");
355         return *out_val ? 0 : AVERROR(ENOMEM);
356     case AV_OPT_TYPE_BINARY:
357         len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
358         if ((uint64_t)len*2 + 1 > INT_MAX)
359             return AVERROR(EINVAL);
360         if (!(*out_val = av_malloc(len*2 + 1)))
361             return AVERROR(ENOMEM);
362         bin = *(uint8_t**)dst;
363         for (i = 0; i < len; i++)
364             snprintf(*out_val + i*2, 3, "%02X", bin[i]);
365         return 0;
366     default:
367         return AVERROR(EINVAL);
368     }
369
370     if (ret >= sizeof(buf))
371         return AVERROR(EINVAL);
372     *out_val = av_strdup(buf);
373     return *out_val ? 0 : AVERROR(ENOMEM);
374 }
375
376 static int get_number(void *obj, const char *name, double *num, int *den, int64_t *intnum,
377                       int search_flags)
378 {
379     void *dst, *target_obj;
380     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
381     if (!o || !target_obj)
382         goto error;
383
384     dst = ((uint8_t*)target_obj) + o->offset;
385
386     return read_number(o, dst, num, den, intnum);
387
388 error:
389     *den=*intnum=0;
390     return -1;
391 }
392
393 int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
394 {
395     int64_t intnum = 1;
396     double     num = 1;
397     int   ret, den = 1;
398
399     if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
400         return ret;
401     *out_val = num*intnum/den;
402     return 0;
403 }
404
405 int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
406 {
407     int64_t intnum = 1;
408     double     num = 1;
409     int   ret, den = 1;
410
411     if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
412         return ret;
413     *out_val = num*intnum/den;
414     return 0;
415 }
416
417 int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
418 {
419     int64_t intnum = 1;
420     double     num = 1;
421     int   ret, den = 1;
422
423     if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
424         return ret;
425
426     if (num == 1.0 && (int)intnum == intnum)
427         *out_val = (AVRational){intnum, den};
428     else
429         *out_val = av_d2q(num*intnum/den, 1<<24);
430     return 0;
431 }
432
433 int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
434 {
435     void *target_obj;
436     AVDictionary *src;
437     const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
438
439     if (!o || !target_obj)
440         return AVERROR_OPTION_NOT_FOUND;
441     if (o->type != AV_OPT_TYPE_DICT)
442         return AVERROR(EINVAL);
443
444     src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
445     av_dict_copy(out_val, src, 0);
446
447     return 0;
448 }
449
450 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
451 {
452     const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
453     const AVOption *flag  = av_opt_find(obj, flag_name,
454                                         field ? field->unit : NULL, 0, 0);
455     int64_t res;
456
457     if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
458         av_opt_get_int(obj, field_name, 0, &res) < 0)
459         return 0;
460     return res & flag->default_val.i64;
461 }
462
463 static void opt_list(void *obj, void *av_log_obj, const char *unit,
464                      int req_flags, int rej_flags)
465 {
466     const AVOption *opt=NULL;
467
468     while ((opt = av_opt_next(obj, opt))) {
469         if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
470             continue;
471
472         /* Don't print CONST's on level one.
473          * Don't print anything but CONST's on level two.
474          * Only print items from the requested unit.
475          */
476         if (!unit && opt->type==AV_OPT_TYPE_CONST)
477             continue;
478         else if (unit && opt->type!=AV_OPT_TYPE_CONST)
479             continue;
480         else if (unit && opt->type==AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
481             continue;
482         else if (unit && opt->type == AV_OPT_TYPE_CONST)
483             av_log(av_log_obj, AV_LOG_INFO, "   %-15s ", opt->name);
484         else
485             av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);
486
487         switch (opt->type) {
488             case AV_OPT_TYPE_FLAGS:
489                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>");
490                 break;
491             case AV_OPT_TYPE_INT:
492                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int>");
493                 break;
494             case AV_OPT_TYPE_INT64:
495                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>");
496                 break;
497             case AV_OPT_TYPE_DOUBLE:
498                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<double>");
499                 break;
500             case AV_OPT_TYPE_FLOAT:
501                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<float>");
502                 break;
503             case AV_OPT_TYPE_STRING:
504                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<string>");
505                 break;
506             case AV_OPT_TYPE_RATIONAL:
507                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>");
508                 break;
509             case AV_OPT_TYPE_BINARY:
510                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<binary>");
511                 break;
512             case AV_OPT_TYPE_CONST:
513             default:
514                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "");
515                 break;
516         }
517         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
518         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
519         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM   ) ? 'V' : '.');
520         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM   ) ? 'A' : '.');
521         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
522         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT)         ? 'X' : '.');
523         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY)       ? 'R' : '.');
524
525         if (opt->help)
526             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
527         av_log(av_log_obj, AV_LOG_INFO, "\n");
528         if (opt->unit && opt->type != AV_OPT_TYPE_CONST) {
529             opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
530         }
531     }
532 }
533
534 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
535 {
536     if (!obj)
537         return -1;
538
539     av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);
540
541     opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
542
543     return 0;
544 }
545
546 void av_opt_set_defaults(void *s)
547 {
548     const AVOption *opt = NULL;
549     while ((opt = av_opt_next(s, opt))) {
550         if (opt->flags & AV_OPT_FLAG_READONLY)
551             continue;
552
553         switch (opt->type) {
554             case AV_OPT_TYPE_CONST:
555                 /* Nothing to be done here */
556             break;
557             case AV_OPT_TYPE_FLAGS:
558             case AV_OPT_TYPE_INT:
559             case AV_OPT_TYPE_INT64:
560                 av_opt_set_int(s, opt->name, opt->default_val.i64, 0);
561             break;
562             case AV_OPT_TYPE_DOUBLE:
563             case AV_OPT_TYPE_FLOAT: {
564                 double val;
565                 val = opt->default_val.dbl;
566                 av_opt_set_double(s, opt->name, val, 0);
567             }
568             break;
569             case AV_OPT_TYPE_RATIONAL: {
570                 AVRational val;
571                 val = av_d2q(opt->default_val.dbl, INT_MAX);
572                 av_opt_set_q(s, opt->name, val, 0);
573             }
574             break;
575             case AV_OPT_TYPE_STRING:
576                 av_opt_set(s, opt->name, opt->default_val.str, 0);
577                 break;
578             case AV_OPT_TYPE_BINARY:
579             case AV_OPT_TYPE_DICT:
580                 /* Cannot set defaults for these types */
581             break;
582             default:
583                 av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
584         }
585     }
586 }
587
588 /**
589  * Store the value in the field in ctx that is named like key.
590  * ctx must be an AVClass context, storing is done using AVOptions.
591  *
592  * @param buf the string to parse, buf will be updated to point at the
593  * separator just after the parsed key/value pair
594  * @param key_val_sep a 0-terminated list of characters used to
595  * separate key from value
596  * @param pairs_sep a 0-terminated list of characters used to separate
597  * two pairs from each other
598  * @return 0 if the key/value pair has been successfully parsed and
599  * set, or a negative value corresponding to an AVERROR code in case
600  * of error:
601  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
602  * the error code issued by av_opt_set() if the key/value pair
603  * cannot be set
604  */
605 static int parse_key_value_pair(void *ctx, const char **buf,
606                                 const char *key_val_sep, const char *pairs_sep)
607 {
608     char *key = av_get_token(buf, key_val_sep);
609     char *val;
610     int ret;
611
612     if (!key)
613         return AVERROR(ENOMEM);
614
615     if (*key && strspn(*buf, key_val_sep)) {
616         (*buf)++;
617         val = av_get_token(buf, pairs_sep);
618         if (!val) {
619             av_freep(&key);
620             return AVERROR(ENOMEM);
621         }
622     } else {
623         av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
624         av_free(key);
625         return AVERROR(EINVAL);
626     }
627
628     av_log(ctx, AV_LOG_DEBUG, "Setting value '%s' for key '%s'\n", val, key);
629
630     ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
631     if (ret == AVERROR_OPTION_NOT_FOUND)
632         av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
633
634     av_free(key);
635     av_free(val);
636     return ret;
637 }
638
639 int av_set_options_string(void *ctx, const char *opts,
640                           const char *key_val_sep, const char *pairs_sep)
641 {
642     int ret, count = 0;
643
644     if (!opts)
645         return 0;
646
647     while (*opts) {
648         if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
649             return ret;
650         count++;
651
652         if (*opts)
653             opts++;
654     }
655
656     return count;
657 }
658
659 void av_opt_free(void *obj)
660 {
661     const AVOption *o = NULL;
662     while ((o = av_opt_next(obj, o))) {
663         switch (o->type) {
664         case AV_OPT_TYPE_STRING:
665         case AV_OPT_TYPE_BINARY:
666             av_freep((uint8_t *)obj + o->offset);
667             break;
668
669         case AV_OPT_TYPE_DICT:
670             av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
671             break;
672
673         default:
674             break;
675         }
676     }
677 }
678
679 int av_opt_set_dict(void *obj, AVDictionary **options)
680 {
681     AVDictionaryEntry *t = NULL;
682     AVDictionary    *tmp = NULL;
683     int ret = 0;
684
685     while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
686         ret = av_opt_set(obj, t->key, t->value, 0);
687         if (ret == AVERROR_OPTION_NOT_FOUND)
688             av_dict_set(&tmp, t->key, t->value, 0);
689         else if (ret < 0) {
690             av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
691             break;
692         }
693         ret = 0;
694     }
695     av_dict_free(options);
696     *options = tmp;
697     return ret;
698 }
699
700 const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
701                             int opt_flags, int search_flags)
702 {
703     return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
704 }
705
706 const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
707                              int opt_flags, int search_flags, void **target_obj)
708 {
709     const AVClass  *c = *(AVClass**)obj;
710     const AVOption *o = NULL;
711
712     if (!c)
713         return NULL;
714
715     if (search_flags & AV_OPT_SEARCH_CHILDREN) {
716         if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
717             const AVClass *child = NULL;
718             while (child = av_opt_child_class_next(c, child))
719                 if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
720                     return o;
721         } else {
722             void *child = NULL;
723             while (child = av_opt_child_next(obj, child))
724                 if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
725                     return o;
726         }
727     }
728
729     while (o = av_opt_next(obj, o)) {
730         if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
731             ((!unit && o->type != AV_OPT_TYPE_CONST) ||
732              (unit  && o->unit && !strcmp(o->unit, unit)))) {
733             if (target_obj) {
734                 if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
735                     *target_obj = obj;
736                 else
737                     *target_obj = NULL;
738             }
739             return o;
740         }
741     }
742     return NULL;
743 }
744
745 void *av_opt_child_next(void *obj, void *prev)
746 {
747     const AVClass *c = *(AVClass**)obj;
748     if (c->child_next)
749         return c->child_next(obj, prev);
750     return NULL;
751 }
752
753 const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
754 {
755     if (parent->child_class_next)
756         return parent->child_class_next(prev);
757     return NULL;
758 }
759
760 static int opt_size(enum AVOptionType type)
761 {
762     switch(type) {
763     case AV_OPT_TYPE_INT:
764     case AV_OPT_TYPE_FLAGS:     return sizeof(int);
765     case AV_OPT_TYPE_INT64:     return sizeof(int64_t);
766     case AV_OPT_TYPE_DOUBLE:    return sizeof(double);
767     case AV_OPT_TYPE_FLOAT:     return sizeof(float);
768     case AV_OPT_TYPE_STRING:    return sizeof(uint8_t*);
769     case AV_OPT_TYPE_RATIONAL:  return sizeof(AVRational);
770     case AV_OPT_TYPE_BINARY:    return sizeof(uint8_t*) + sizeof(int);
771     }
772     return AVERROR(EINVAL);
773 }
774
775 int av_opt_copy(void *dst, const void *src)
776 {
777     const AVOption *o = NULL;
778     const AVClass *c;
779     int ret = 0;
780
781     if (!src)
782         return AVERROR(EINVAL);
783
784     c = *(AVClass**)src;
785     if (!c || c != *(AVClass**)dst)
786         return AVERROR(EINVAL);
787
788     while ((o = av_opt_next(src, o))) {
789         void *field_dst = ((uint8_t*)dst) + o->offset;
790         void *field_src = ((uint8_t*)src) + o->offset;
791         uint8_t **field_dst8 = (uint8_t**)field_dst;
792         uint8_t **field_src8 = (uint8_t**)field_src;
793
794         if (o->type == AV_OPT_TYPE_STRING) {
795             set_string(dst, o, *field_src8, field_dst8);
796             if (*field_src8 && !*field_dst8)
797                 ret = AVERROR(ENOMEM);
798         } else if (o->type == AV_OPT_TYPE_BINARY) {
799             int len = *(int*)(field_src8 + 1);
800             if (*field_dst8 != *field_src8)
801                 av_freep(field_dst8);
802             if (len) {
803                 *field_dst8 = av_malloc(len);
804                 if (!*field_dst8) {
805                     ret = AVERROR(ENOMEM);
806                     len = 0;
807                 }
808                 memcpy(*field_dst8, *field_src8, len);
809             } else {
810                 *field_dst8 = NULL;
811             }
812             *(int*)(field_dst8 + 1) = len;
813         } else if (o->type == AV_OPT_TYPE_CONST) {
814             // do nothing
815         } else {
816             int size = opt_size(o->type);
817             if (size < 0)
818                 ret = size;
819             else
820                 memcpy(field_dst, field_src, size);
821         }
822     }
823     return ret;
824 }
825
826 #ifdef TEST
827
828 typedef struct TestContext
829 {
830     const AVClass *class;
831     int num;
832     int toggle;
833     char *string;
834     int flags;
835     AVRational rational;
836 } TestContext;
837
838 #define OFFSET(x) offsetof(TestContext, x)
839
840 #define TEST_FLAG_COOL 01
841 #define TEST_FLAG_LAME 02
842 #define TEST_FLAG_MU   04
843
844 static const AVOption test_options[]= {
845 {"num",      "set num",        OFFSET(num),      AV_OPT_TYPE_INT,      {.i64 = 0},       0,        100                 },
846 {"toggle",   "set toggle",     OFFSET(toggle),   AV_OPT_TYPE_INT,      {.i64 = 0},       0,        1                   },
847 {"rational", "set rational",   OFFSET(rational), AV_OPT_TYPE_RATIONAL, {.dbl = 0},  0,        10                  },
848 {"string",   "set string",     OFFSET(string),   AV_OPT_TYPE_STRING,   {0},              CHAR_MIN, CHAR_MAX            },
849 {"flags",    "set flags",      OFFSET(flags),    AV_OPT_TYPE_FLAGS,    {.i64 = 0},       0,        INT_MAX, 0, "flags" },
850 {"cool",     "set cool flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_COOL}, INT_MIN,  INT_MAX, 0, "flags" },
851 {"lame",     "set lame flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_LAME}, INT_MIN,  INT_MAX, 0, "flags" },
852 {"mu",       "set mu flag ",   0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_MU},   INT_MIN,  INT_MAX, 0, "flags" },
853 {NULL},
854 };
855
856 static const char *test_get_name(void *ctx)
857 {
858     return "test";
859 }
860
861 static const AVClass test_class = {
862     "TestContext",
863     test_get_name,
864     test_options
865 };
866
867 int main(void)
868 {
869     int i;
870     TestContext test_ctx = { .class = &test_class };
871     const char *options[] = {
872         "",
873         ":",
874         "=",
875         "foo=:",
876         ":=foo",
877         "=foo",
878         "foo=",
879         "foo",
880         "foo=val",
881         "foo==val",
882         "toggle=:",
883         "string=:",
884         "toggle=1 : foo",
885         "toggle=100",
886         "toggle==1",
887         "flags=+mu-lame : num=42: toggle=0",
888         "num=42 : string=blahblah",
889         "rational=0 : rational=1/2 : rational=1/-1",
890         "rational=-1/0",
891     };
892
893     printf("\nTesting av_set_options_string()\n");
894
895     av_opt_set_defaults(&test_ctx);
896     test_ctx.string = av_strdup("default");
897     if (!test_ctx.string)
898         return AVERROR(ENOMEM);
899
900     av_log_set_level(AV_LOG_DEBUG);
901
902     for (i = 0; i < FF_ARRAY_ELEMS(options); i++) {
903         av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
904         if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
905             av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
906         printf("\n");
907     }
908
909     return 0;
910 }
911
912 #endif