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