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