AVOptions: add av_opt_set_dict() mapping a dictionary struct to a context.
[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 "opt.h"
31 #include "eval.h"
32 #include "dict.h"
33
34 //FIXME order them and do a bin search
35 const AVOption *av_find_opt(void *v, const char *name, const char *unit, int mask, int flags)
36 {
37     AVClass *c= *(AVClass**)v; //FIXME silly way of storing AVClass
38     const AVOption *o= c->option;
39
40     for (; o && o->name; o++) {
41         if (!strcmp(o->name, name) && (!unit || (o->unit && !strcmp(o->unit, unit))) && (o->flags & mask) == flags)
42             return o;
43     }
44     return NULL;
45 }
46
47 const AVOption *av_next_option(void *obj, const AVOption *last)
48 {
49     if (last && last[1].name) return ++last;
50     else if (last)            return NULL;
51     else                      return (*(AVClass**)obj)->option;
52 }
53
54 static int av_set_number2(void *obj, const char *name, double num, int den, int64_t intnum, const AVOption **o_out)
55 {
56     const AVOption *o= av_find_opt(obj, name, NULL, 0, 0);
57     void *dst;
58     if (o_out)
59         *o_out= o;
60     if (!o || o->offset<=0)
61         return AVERROR_OPTION_NOT_FOUND;
62
63     if (o->max*den < num*intnum || o->min*den > num*intnum) {
64         av_log(obj, AV_LOG_ERROR, "Value %lf for parameter '%s' out of range\n", num, name);
65         return AVERROR(ERANGE);
66     }
67
68     dst= ((uint8_t*)obj) + o->offset;
69
70     switch (o->type) {
71     case FF_OPT_TYPE_FLAGS:
72     case FF_OPT_TYPE_INT:   *(int       *)dst= llrint(num/den)*intnum; break;
73     case FF_OPT_TYPE_INT64: *(int64_t   *)dst= llrint(num/den)*intnum; break;
74     case FF_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
75     case FF_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
76     case FF_OPT_TYPE_RATIONAL:
77         if ((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
78         else                 *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
79         break;
80     default:
81         return AVERROR(EINVAL);
82     }
83     return 0;
84 }
85
86 static const AVOption *av_set_number(void *obj, const char *name, double num, int den, int64_t intnum)
87 {
88     const AVOption *o = NULL;
89     if (av_set_number2(obj, name, num, den, intnum, &o) < 0)
90         return NULL;
91     else
92         return o;
93 }
94
95 static const double const_values[] = {
96     M_PI,
97     M_E,
98     FF_QP2LAMBDA,
99     0
100 };
101
102 static const char * const const_names[] = {
103     "PI",
104     "E",
105     "QP2LAMBDA",
106     0
107 };
108
109 static int hexchar2int(char c) {
110     if (c >= '0' && c <= '9') return c - '0';
111     if (c >= 'a' && c <= 'f') return c - 'a' + 10;
112     if (c >= 'A' && c <= 'F') return c - 'A' + 10;
113     return -1;
114 }
115
116 int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out)
117 {
118     int ret;
119     const AVOption *o= av_find_opt(obj, name, NULL, 0, 0);
120     if (o_out)
121         *o_out = o;
122     if (!o)
123         return AVERROR_OPTION_NOT_FOUND;
124     if (!val || o->offset<=0)
125         return AVERROR(EINVAL);
126
127     if (o->type == FF_OPT_TYPE_BINARY) {
128         uint8_t **dst = (uint8_t **)(((uint8_t*)obj) + o->offset);
129         int *lendst = (int *)(dst + 1);
130         uint8_t *bin, *ptr;
131         int len = strlen(val);
132         av_freep(dst);
133         *lendst = 0;
134         if (len & 1) return AVERROR(EINVAL);
135         len /= 2;
136         ptr = bin = av_malloc(len);
137         while (*val) {
138             int a = hexchar2int(*val++);
139             int b = hexchar2int(*val++);
140             if (a < 0 || b < 0) {
141                 av_free(bin);
142                 return AVERROR(EINVAL);
143             }
144             *ptr++ = (a << 4) | b;
145         }
146         *dst = bin;
147         *lendst = len;
148         return 0;
149     }
150     if (o->type != FF_OPT_TYPE_STRING) {
151         int notfirst=0;
152         for (;;) {
153             int i;
154             char buf[256];
155             int cmd=0;
156             double d;
157
158             if (*val == '+' || *val == '-')
159                 cmd= *(val++);
160
161             for (i=0; i<sizeof(buf)-1 && val[i] && val[i]!='+' && val[i]!='-'; i++)
162                 buf[i]= val[i];
163             buf[i]=0;
164
165             {
166                 const AVOption *o_named= av_find_opt(obj, buf, o->unit, 0, 0);
167                 if (o_named && o_named->type == FF_OPT_TYPE_CONST)
168                     d= o_named->default_val.dbl;
169                 else if (!strcmp(buf, "default")) d= o->default_val.dbl;
170                 else if (!strcmp(buf, "max"    )) d= o->max;
171                 else if (!strcmp(buf, "min"    )) d= o->min;
172                 else if (!strcmp(buf, "none"   )) d= 0;
173                 else if (!strcmp(buf, "all"    )) d= ~0;
174                 else {
175                     int res = av_expr_parse_and_eval(&d, buf, const_names, const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
176                     if (res < 0) {
177                         av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
178                         return res;
179                     }
180                 }
181             }
182             if (o->type == FF_OPT_TYPE_FLAGS) {
183                 if      (cmd=='+') d= av_get_int(obj, name, NULL) | (int64_t)d;
184                 else if (cmd=='-') d= av_get_int(obj, name, NULL) &~(int64_t)d;
185             } else {
186                 if      (cmd=='+') d= notfirst*av_get_double(obj, name, NULL) + d;
187                 else if (cmd=='-') d= notfirst*av_get_double(obj, name, NULL) - d;
188             }
189
190             if ((ret = av_set_number2(obj, name, d, 1, 1, o_out)) < 0)
191                 return ret;
192             val+= i;
193             if (!*val)
194                 return 0;
195             notfirst=1;
196         }
197         return AVERROR(EINVAL);
198     }
199
200     if (alloc) {
201         av_free(*(void**)(((uint8_t*)obj) + o->offset));
202         val= av_strdup(val);
203     }
204
205     memcpy(((uint8_t*)obj) + o->offset, &val, sizeof(val));
206     return 0;
207 }
208
209 const AVOption *av_set_double(void *obj, const char *name, double n)
210 {
211     return av_set_number(obj, name, n, 1, 1);
212 }
213
214 const AVOption *av_set_q(void *obj, const char *name, AVRational n)
215 {
216     return av_set_number(obj, name, n.num, n.den, 1);
217 }
218
219 const AVOption *av_set_int(void *obj, const char *name, int64_t n)
220 {
221     return av_set_number(obj, name, 1, 1, n);
222 }
223
224 /**
225  *
226  * @param buf a buffer which is used for returning non string values as strings, can be NULL
227  * @param buf_len allocated length in bytes of buf
228  */
229 const char *av_get_string(void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len)
230 {
231     const AVOption *o= av_find_opt(obj, name, NULL, 0, 0);
232     void *dst;
233     uint8_t *bin;
234     int len, i;
235     if (!o || o->offset<=0)
236         return NULL;
237     if (o->type != FF_OPT_TYPE_STRING && (!buf || !buf_len))
238         return NULL;
239
240     dst= ((uint8_t*)obj) + o->offset;
241     if (o_out) *o_out= o;
242
243     switch (o->type) {
244     case FF_OPT_TYPE_FLAGS:     snprintf(buf, buf_len, "0x%08X",*(int    *)dst);break;
245     case FF_OPT_TYPE_INT:       snprintf(buf, buf_len, "%d" , *(int    *)dst);break;
246     case FF_OPT_TYPE_INT64:     snprintf(buf, buf_len, "%"PRId64, *(int64_t*)dst);break;
247     case FF_OPT_TYPE_FLOAT:     snprintf(buf, buf_len, "%f" , *(float  *)dst);break;
248     case FF_OPT_TYPE_DOUBLE:    snprintf(buf, buf_len, "%f" , *(double *)dst);break;
249     case FF_OPT_TYPE_RATIONAL:  snprintf(buf, buf_len, "%d/%d", ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
250     case FF_OPT_TYPE_STRING:    return *(void**)dst;
251     case FF_OPT_TYPE_BINARY:
252         len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
253         if (len >= (buf_len + 1)/2) return NULL;
254         bin = *(uint8_t**)dst;
255         for (i = 0; i < len; i++) snprintf(buf + i*2, 3, "%02X", bin[i]);
256         break;
257     default: return NULL;
258     }
259     return buf;
260 }
261
262 static int av_get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum)
263 {
264     const AVOption *o= av_find_opt(obj, name, NULL, 0, 0);
265     void *dst;
266     if (!o || o->offset<=0)
267         goto error;
268
269     dst= ((uint8_t*)obj) + o->offset;
270
271     if (o_out) *o_out= o;
272
273     switch (o->type) {
274     case FF_OPT_TYPE_FLAGS:     *intnum= *(unsigned int*)dst;return 0;
275     case FF_OPT_TYPE_INT:       *intnum= *(int    *)dst;return 0;
276     case FF_OPT_TYPE_INT64:     *intnum= *(int64_t*)dst;return 0;
277     case FF_OPT_TYPE_FLOAT:     *num=    *(float  *)dst;return 0;
278     case FF_OPT_TYPE_DOUBLE:    *num=    *(double *)dst;return 0;
279     case FF_OPT_TYPE_RATIONAL:  *intnum= ((AVRational*)dst)->num;
280                                 *den   = ((AVRational*)dst)->den;
281                                                         return 0;
282     }
283 error:
284     *den=*intnum=0;
285     return -1;
286 }
287
288 double av_get_double(void *obj, const char *name, const AVOption **o_out)
289 {
290     int64_t intnum=1;
291     double num=1;
292     int den=1;
293
294     if (av_get_number(obj, name, o_out, &num, &den, &intnum) < 0)
295         return NAN;
296     return num*intnum/den;
297 }
298
299 AVRational av_get_q(void *obj, const char *name, const AVOption **o_out)
300 {
301     int64_t intnum=1;
302     double num=1;
303     int den=1;
304
305     if (av_get_number(obj, name, o_out, &num, &den, &intnum) < 0)
306         return (AVRational){0, 0};
307     if (num == 1.0 && (int)intnum == intnum)
308         return (AVRational){intnum, den};
309     else
310         return av_d2q(num*intnum/den, 1<<24);
311 }
312
313 int64_t av_get_int(void *obj, const char *name, const AVOption **o_out)
314 {
315     int64_t intnum=1;
316     double num=1;
317     int den=1;
318
319     if (av_get_number(obj, name, o_out, &num, &den, &intnum) < 0)
320         return -1;
321     return num*intnum/den;
322 }
323
324 int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
325 {
326     const AVOption *field = av_find_opt(obj, field_name, NULL, 0, 0);
327     const AVOption *flag  = av_find_opt(obj, flag_name,  NULL, 0, 0);
328
329     if (!field || !flag || flag->type != FF_OPT_TYPE_CONST)
330         return 0;
331     return av_get_int(obj, field_name, NULL) & (int) flag->default_val.dbl;
332 }
333
334 static void opt_list(void *obj, void *av_log_obj, const char *unit,
335                      int req_flags, int rej_flags)
336 {
337     const AVOption *opt=NULL;
338
339     while ((opt= av_next_option(obj, opt))) {
340         if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
341             continue;
342
343         /* Don't print CONST's on level one.
344          * Don't print anything but CONST's on level two.
345          * Only print items from the requested unit.
346          */
347         if (!unit && opt->type==FF_OPT_TYPE_CONST)
348             continue;
349         else if (unit && opt->type!=FF_OPT_TYPE_CONST)
350             continue;
351         else if (unit && opt->type==FF_OPT_TYPE_CONST && strcmp(unit, opt->unit))
352             continue;
353         else if (unit && opt->type == FF_OPT_TYPE_CONST)
354             av_log(av_log_obj, AV_LOG_INFO, "   %-15s ", opt->name);
355         else
356             av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);
357
358         switch (opt->type) {
359             case FF_OPT_TYPE_FLAGS:
360                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>");
361                 break;
362             case FF_OPT_TYPE_INT:
363                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int>");
364                 break;
365             case FF_OPT_TYPE_INT64:
366                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>");
367                 break;
368             case FF_OPT_TYPE_DOUBLE:
369                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<double>");
370                 break;
371             case FF_OPT_TYPE_FLOAT:
372                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<float>");
373                 break;
374             case FF_OPT_TYPE_STRING:
375                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<string>");
376                 break;
377             case FF_OPT_TYPE_RATIONAL:
378                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>");
379                 break;
380             case FF_OPT_TYPE_BINARY:
381                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<binary>");
382                 break;
383             case FF_OPT_TYPE_CONST:
384             default:
385                 av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "");
386                 break;
387         }
388         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
389         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_DECODING_PARAM) ? 'D' : '.');
390         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM   ) ? 'V' : '.');
391         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM   ) ? 'A' : '.');
392         av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');
393
394         if (opt->help)
395             av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
396         av_log(av_log_obj, AV_LOG_INFO, "\n");
397         if (opt->unit && opt->type != FF_OPT_TYPE_CONST) {
398             opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
399         }
400     }
401 }
402
403 int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
404 {
405     if (!obj)
406         return -1;
407
408     av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);
409
410     opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);
411
412     return 0;
413 }
414
415 /** Set the values of the AVCodecContext or AVFormatContext structure.
416  * They are set to the defaults specified in the according AVOption options
417  * array default_val field.
418  *
419  * @param s AVCodecContext or AVFormatContext for which the defaults will be set
420  */
421 void av_opt_set_defaults2(void *s, int mask, int flags)
422 {
423     const AVOption *opt = NULL;
424     while ((opt = av_next_option(s, opt)) != NULL) {
425         if ((opt->flags & mask) != flags)
426             continue;
427         switch (opt->type) {
428             case FF_OPT_TYPE_CONST:
429                 /* Nothing to be done here */
430             break;
431             case FF_OPT_TYPE_FLAGS:
432             case FF_OPT_TYPE_INT: {
433                 int val;
434                 val = opt->default_val.dbl;
435                 av_set_int(s, opt->name, val);
436             }
437             break;
438             case FF_OPT_TYPE_INT64:
439                 if ((double)(opt->default_val.dbl+0.6) == opt->default_val.dbl)
440                     av_log(s, AV_LOG_DEBUG, "loss of precision in default of %s\n", opt->name);
441                 av_set_int(s, opt->name, opt->default_val.dbl);
442             break;
443             case FF_OPT_TYPE_DOUBLE:
444             case FF_OPT_TYPE_FLOAT: {
445                 double val;
446                 val = opt->default_val.dbl;
447                 av_set_double(s, opt->name, val);
448             }
449             break;
450             case FF_OPT_TYPE_RATIONAL: {
451                 AVRational val;
452                 val = av_d2q(opt->default_val.dbl, INT_MAX);
453                 av_set_q(s, opt->name, val);
454             }
455             break;
456             case FF_OPT_TYPE_STRING:
457                 av_set_string3(s, opt->name, opt->default_val.str, 1, NULL);
458                 break;
459             case FF_OPT_TYPE_BINARY:
460                 /* Cannot set default for binary */
461             break;
462             default:
463                 av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
464         }
465     }
466 }
467
468 void av_opt_set_defaults(void *s)
469 {
470     av_opt_set_defaults2(s, 0, 0);
471 }
472
473 /**
474  * Store the value in the field in ctx that is named like key.
475  * ctx must be an AVClass context, storing is done using AVOptions.
476  *
477  * @param buf the string to parse, buf will be updated to point at the
478  * separator just after the parsed key/value pair
479  * @param key_val_sep a 0-terminated list of characters used to
480  * separate key from value
481  * @param pairs_sep a 0-terminated list of characters used to separate
482  * two pairs from each other
483  * @return 0 if the key/value pair has been successfully parsed and
484  * set, or a negative value corresponding to an AVERROR code in case
485  * of error:
486  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
487  * the error code issued by av_set_string3() if the key/value pair
488  * cannot be set
489  */
490 static int parse_key_value_pair(void *ctx, const char **buf,
491                                 const char *key_val_sep, const char *pairs_sep)
492 {
493     char *key = av_get_token(buf, key_val_sep);
494     char *val;
495     int ret;
496
497     if (*key && strspn(*buf, key_val_sep)) {
498         (*buf)++;
499         val = av_get_token(buf, pairs_sep);
500     } else {
501         av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
502         av_free(key);
503         return AVERROR(EINVAL);
504     }
505
506     av_log(ctx, AV_LOG_DEBUG, "Setting value '%s' for key '%s'\n", val, key);
507
508     ret = av_set_string3(ctx, key, val, 1, NULL);
509     if (ret == AVERROR_OPTION_NOT_FOUND)
510         av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
511
512     av_free(key);
513     av_free(val);
514     return ret;
515 }
516
517 int av_set_options_string(void *ctx, const char *opts,
518                           const char *key_val_sep, const char *pairs_sep)
519 {
520     int ret, count = 0;
521
522     while (*opts) {
523         if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
524             return ret;
525         count++;
526
527         if (*opts)
528             opts++;
529     }
530
531     return count;
532 }
533
534 void av_opt_free(void *obj)
535 {
536     const AVOption *o = NULL;
537     while ((o = av_next_option(obj, o)))
538         if (o->type == FF_OPT_TYPE_STRING || o->type == FF_OPT_TYPE_BINARY)
539             av_freep((uint8_t *)obj + o->offset);
540 }
541
542 int av_opt_set_dict(void *obj, AVDictionary **options)
543 {
544     AVDictionaryEntry *t = NULL;
545     AVDictionary    *tmp = NULL;
546     int ret = 0;
547
548     while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
549         ret = av_set_string3(obj, t->key, t->value, 1, NULL);
550         if (ret == AVERROR_OPTION_NOT_FOUND)
551             av_dict_set(&tmp, t->key, t->value, 0);
552         else if (ret < 0) {
553             av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
554             break;
555         }
556         ret = 0;
557     }
558     av_dict_free(options);
559     *options = tmp;
560     return ret;
561 }
562
563 #ifdef TEST
564
565 #undef printf
566
567 typedef struct TestContext
568 {
569     const AVClass *class;
570     int num;
571     int toggle;
572     char *string;
573     int flags;
574     AVRational rational;
575 } TestContext;
576
577 #define OFFSET(x) offsetof(TestContext, x)
578
579 #define TEST_FLAG_COOL 01
580 #define TEST_FLAG_LAME 02
581 #define TEST_FLAG_MU   04
582
583 static const AVOption test_options[]= {
584 {"num",      "set num",        OFFSET(num),      FF_OPT_TYPE_INT,      0,              0,        100                 },
585 {"toggle",   "set toggle",     OFFSET(toggle),   FF_OPT_TYPE_INT,      0,              0,        1                   },
586 {"rational", "set rational",   OFFSET(rational), FF_OPT_TYPE_RATIONAL, 0,              0,        10                  },
587 {"string",   "set string",     OFFSET(string),   FF_OPT_TYPE_STRING,   0,              CHAR_MIN, CHAR_MAX            },
588 {"flags",    "set flags",      OFFSET(flags),    FF_OPT_TYPE_FLAGS,    0,              0,        INT_MAX, 0, "flags" },
589 {"cool",     "set cool flag ", 0,                FF_OPT_TYPE_CONST,    TEST_FLAG_COOL, INT_MIN,  INT_MAX, 0, "flags" },
590 {"lame",     "set lame flag ", 0,                FF_OPT_TYPE_CONST,    TEST_FLAG_LAME, INT_MIN,  INT_MAX, 0, "flags" },
591 {"mu",       "set mu flag ",   0,                FF_OPT_TYPE_CONST,    TEST_FLAG_MU,   INT_MIN,  INT_MAX, 0, "flags" },
592 {NULL},
593 };
594
595 static const char *test_get_name(void *ctx)
596 {
597     return "test";
598 }
599
600 static const AVClass test_class = {
601     "TestContext",
602     test_get_name,
603     test_options
604 };
605
606 int main(void)
607 {
608     int i;
609
610     printf("\nTesting av_set_options_string()\n");
611     {
612         TestContext test_ctx;
613         const char *options[] = {
614             "",
615             ":",
616             "=",
617             "foo=:",
618             ":=foo",
619             "=foo",
620             "foo=",
621             "foo",
622             "foo=val",
623             "foo==val",
624             "toggle=:",
625             "string=:",
626             "toggle=1 : foo",
627             "toggle=100",
628             "toggle==1",
629             "flags=+mu-lame : num=42: toggle=0",
630             "num=42 : string=blahblah",
631             "rational=0 : rational=1/2 : rational=1/-1",
632             "rational=-1/0",
633         };
634
635         test_ctx.class = &test_class;
636         av_opt_set_defaults2(&test_ctx, 0, 0);
637         test_ctx.string = av_strdup("default");
638
639         av_log_set_level(AV_LOG_DEBUG);
640
641         for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
642             av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
643             if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
644                 av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
645             printf("\n");
646         }
647     }
648
649     return 0;
650 }
651
652 #endif