opt.c 49.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
/*
 * AVOptions
 * Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * AVOptions
 * @author Michael Niedermayer <michaelni@gmx.at>
 */

#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 41
#include <float.h>

42
#if FF_API_FIND_OPT
43
//FIXME order them and do a bin search
44 45
const AVOption *av_find_opt(void *v, const char *name, const char *unit, int mask, int flags)
{
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 51 52 53
            return o;
    }
    return NULL;
}
54
#endif
55

56
#if FF_API_OLD_AVOPTIONS
57
const AVOption *av_next_option(void *obj, const AVOption *last)
58 59 60 61 62 63
{
    return av_opt_next(obj, last);
}
#endif

const AVOption *av_opt_next(void *obj, const AVOption *last)
64
{
65
    AVClass *class = *(AVClass**)obj;
66 67
    if (!last && class->option && class->option[0].name)
        return class->option;
68 69
    if (last && last[1].name)
        return ++last;
70
    return NULL;
71 72
}

73 74 75
static int read_number(const AVOption *o, void *dst, double *num, int *den, int64_t *intnum)
{
    switch (o->type) {
76
    case AV_OPT_TYPE_FLAGS:     *intnum = *(unsigned int*)dst;return 0;
77 78
    case AV_OPT_TYPE_PIXEL_FMT:
    case AV_OPT_TYPE_SAMPLE_FMT:
79
    case AV_OPT_TYPE_INT:       *intnum = *(int         *)dst;return 0;
80
    case AV_OPT_TYPE_DURATION:
81 82 83 84
    case AV_OPT_TYPE_INT64:     *intnum = *(int64_t     *)dst;return 0;
    case AV_OPT_TYPE_FLOAT:     *num    = *(float       *)dst;return 0;
    case AV_OPT_TYPE_DOUBLE:    *num    = *(double      *)dst;return 0;
    case AV_OPT_TYPE_RATIONAL:  *intnum = ((AVRational*)dst)->num;
85 86
                                *den    = ((AVRational*)dst)->den;
                                                        return 0;
87
    case AV_OPT_TYPE_CONST:     *num    = o->default_val.dbl; return 0;
88 89 90 91
    }
    return AVERROR(EINVAL);
}

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 96
        av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
               num*intnum/den, o->name, o->min, o->max);
97 98 99
        return AVERROR(ERANGE);
    }

100
    switch (o->type) {
101
    case AV_OPT_TYPE_FLAGS:
102 103
    case AV_OPT_TYPE_PIXEL_FMT:
    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 107 108 109
    case AV_OPT_TYPE_INT64: *(int64_t   *)dst= llrint(num/den)*intnum; break;
    case AV_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
    case AV_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
    case AV_OPT_TYPE_RATIONAL:
110 111
        if ((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
        else                 *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
112 113 114 115 116 117 118
        break;
    default:
        return AVERROR(EINVAL);
    }
    return 0;
}

119
static const double const_values[] = {
120 121 122 123 124 125
    M_PI,
    M_E,
    FF_QP2LAMBDA,
    0
};

126
static const char * const const_names[] = {
127 128 129 130 131 132 133 134 135 136 137 138 139
    "PI",
    "E",
    "QP2LAMBDA",
    0
};

static int hexchar2int(char c) {
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    return -1;
}

140
static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
141
{
142 143 144 145 146 147 148 149
    int *lendst = (int *)(dst + 1);
    uint8_t *bin, *ptr;
    int len = strlen(val);

    av_freep(dst);
    *lendst = 0;

    if (len & 1)
150
        return AVERROR(EINVAL);
151
    len /= 2;
152

153 154 155 156 157 158 159
    ptr = bin = av_malloc(len);
    while (*val) {
        int a = hexchar2int(*val++);
        int b = hexchar2int(*val++);
        if (a < 0 || b < 0) {
            av_free(bin);
            return AVERROR(EINVAL);
160
        }
161
        *ptr++ = (a << 4) | b;
162
    }
163 164 165 166 167 168 169 170 171 172 173 174 175
    *dst = bin;
    *lendst = len;

    return 0;
}

static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
{
    av_freep(dst);
    *dst = av_strdup(val);
    return 0;
}

176
#define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
177
                              opt->type == AV_OPT_TYPE_CONST || \
178 179
                              opt->type == AV_OPT_TYPE_FLAGS || \
                              opt->type == AV_OPT_TYPE_INT) ? \
180 181
                             opt->default_val.i64 : opt->default_val.dbl)

182
static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
183 184 185
{
    int ret = 0, notfirst = 0;
    for (;;) {
186
        int i, den = 1;
187 188
        char buf[256];
        int cmd = 0;
189 190
        double d, num = 1;
        int64_t intnum = 1;
191

192 193 194 195 196 197 198
        i = 0;
        if (*val == '+' || *val == '-') {
            if (o->type == AV_OPT_TYPE_FLAGS)
                cmd = *(val++);
            else if (!notfirst)
                buf[i++] = *val;
        }
199

200
        for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
201 202 203 204
            buf[i] = val[i];
        buf[i] = 0;

        {
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 208
                d = DEFAULT_NUMVAL(o_named);
            else if (!strcmp(buf, "default")) d = DEFAULT_NUMVAL(o);
209 210 211 212 213 214 215 216 217
            else if (!strcmp(buf, "max"    )) d = o->max;
            else if (!strcmp(buf, "min"    )) d = o->min;
            else if (!strcmp(buf, "none"   )) d = 0;
            else if (!strcmp(buf, "all"    )) d = ~0;
            else {
                int res = av_expr_parse_and_eval(&d, buf, const_names, const_values, NULL, NULL, NULL, NULL, NULL, 0, obj);
                if (res < 0) {
                    av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\"\n", val);
                    return res;
218 219 220
                }
            }
        }
221
        if (o->type == AV_OPT_TYPE_FLAGS) {
222 223 224
            read_number(o, dst, NULL, NULL, &intnum);
            if      (cmd == '+') d = intnum | (int64_t)d;
            else if (cmd == '-') d = intnum &~(int64_t)d;
225
        } else {
226 227 228
            read_number(o, dst, &num, &den, &intnum);
            if      (cmd == '+') d = notfirst*num*intnum/den + d;
            else if (cmd == '-') d = notfirst*num*intnum/den - d;
229
        }
230

231
        if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
232 233 234 235 236
            return ret;
        val += i;
        if (!*val)
            return 0;
        notfirst = 1;
237 238 239 240 241
    }

    return 0;
}

242
#if FF_API_OLD_AVOPTIONS
243 244
int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out)
{
245
    const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
246 247
    if (o_out)
        *o_out = o;
248 249 250 251 252 253
    return av_opt_set(obj, name, val, 0);
}
#endif

int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
{
254
    int ret;
255 256 257
    void *dst, *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
    if (!o || !target_obj)
258
        return AVERROR_OPTION_NOT_FOUND;
259 260
    if (!val && (o->type != AV_OPT_TYPE_STRING &&
                 o->type != AV_OPT_TYPE_PIXEL_FMT && o->type != AV_OPT_TYPE_SAMPLE_FMT &&
261 262
                 o->type != AV_OPT_TYPE_IMAGE_SIZE && o->type != AV_OPT_TYPE_VIDEO_RATE &&
                 o->type != AV_OPT_TYPE_DURATION))
263 264
        return AVERROR(EINVAL);

265
    dst = ((uint8_t*)target_obj) + o->offset;
266
    switch (o->type) {
267 268 269 270 271 272 273
    case AV_OPT_TYPE_STRING:   return set_string(obj, o, val, dst);
    case AV_OPT_TYPE_BINARY:   return set_string_binary(obj, o, val, dst);
    case AV_OPT_TYPE_FLAGS:
    case AV_OPT_TYPE_INT:
    case AV_OPT_TYPE_INT64:
    case AV_OPT_TYPE_FLOAT:
    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 277 278 279
        if (!val || !strcmp(val, "none")) {
            *(int *)dst = *((int *)dst + 1) = 0;
            return 0;
        }
280 281 282 283
        ret = av_parse_video_size(dst, ((int *)dst) + 1, val);
        if (ret < 0)
            av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as image size\n", val);
        return ret;
284 285 286 287 288 289 290 291 292
    case AV_OPT_TYPE_VIDEO_RATE:
        if (!val) {
            ret = AVERROR(EINVAL);
        } else {
            ret = av_parse_video_rate(dst, val);
        }
        if (ret < 0)
            av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as video rate\n", val);
        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 300
                char *tail;
                ret = strtol(val, &tail, 0);
301
                if (*tail || (unsigned)ret >= AV_PIX_FMT_NB) {
302 303 304
                    av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as pixel format\n", val);
                    return AVERROR(EINVAL);
                }
305 306
            }
        }
307
        *(enum AVPixelFormat *)dst = ret;
308
        return 0;
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
    case AV_OPT_TYPE_SAMPLE_FMT:
        if (!val || !strcmp(val, "none")) {
            ret = AV_SAMPLE_FMT_NONE;
        } else {
            ret = av_get_sample_fmt(val);
            if (ret == AV_SAMPLE_FMT_NONE) {
                char *tail;
                ret = strtol(val, &tail, 0);
                if (*tail || (unsigned)ret >= AV_SAMPLE_FMT_NB) {
                    av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as sample format\n", val);
                    return AVERROR(EINVAL);
                }
            }
        }
        *(enum AVSampleFormat *)dst = ret;
        return 0;
325 326 327 328 329 330 331 332 333
    case AV_OPT_TYPE_DURATION:
        if (!val) {
            *(int64_t *)dst = 0;
            return 0;
        } else {
            if ((ret = av_parse_time(dst, val, 1)) < 0)
                av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
            return ret;
        }
334 335
    }

336 337 338
    av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
    return AVERROR(EINVAL);
}
339

340 341 342 343 344
#define OPT_EVAL_NUMBER(name, opttype, vartype)\
    int av_opt_eval_ ## name(void *obj, const AVOption *o, const char *val, vartype *name ## _out)\
    {\
        if (!o || o->type != opttype)\
            return AVERROR(EINVAL);\
345
        return set_string_number(obj, obj, o, val, name ## _out);\
346 347
    }

348 349 350 351 352 353
OPT_EVAL_NUMBER(flags,  AV_OPT_TYPE_FLAGS,    int)
OPT_EVAL_NUMBER(int,    AV_OPT_TYPE_INT,      int)
OPT_EVAL_NUMBER(int64,  AV_OPT_TYPE_INT64,    int64_t)
OPT_EVAL_NUMBER(float,  AV_OPT_TYPE_FLOAT,    float)
OPT_EVAL_NUMBER(double, AV_OPT_TYPE_DOUBLE,   double)
OPT_EVAL_NUMBER(q,      AV_OPT_TYPE_RATIONAL, AVRational)
354

355 356
static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
                                  int search_flags)
357
{
358 359
    void *dst, *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
360

361 362
    if (!o || !target_obj)
        return AVERROR_OPTION_NOT_FOUND;
363

364 365
    dst = ((uint8_t*)target_obj) + o->offset;
    return write_number(obj, o, dst, num, den, intnum);
366 367
}

368
#if FF_API_OLD_AVOPTIONS
369 370
const AVOption *av_set_double(void *obj, const char *name, double n)
{
371 372 373 374
    const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
    if (set_number(obj, name, n, 1, 1, 0) < 0)
        return NULL;
    return o;
375 376
}

377 378
const AVOption *av_set_q(void *obj, const char *name, AVRational n)
{
379 380 381 382
    const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
    if (set_number(obj, name, n.num, n.den, 1, 0) < 0)
        return NULL;
    return o;
383 384
}

385 386
const AVOption *av_set_int(void *obj, const char *name, int64_t n)
{
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
    const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
    if (set_number(obj, name, 1, 1, n, 0) < 0)
        return NULL;
    return o;
}
#endif

int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
{
    return set_number(obj, name, 1, 1, val, search_flags);
}

int av_opt_set_double(void *obj, const char *name, double val, int search_flags)
{
    return set_number(obj, name, val, 1, 1, search_flags);
}

int av_opt_set_q(void *obj, const char *name, AVRational val, int search_flags)
{
    return set_number(obj, name, val.num, val.den, 1, search_flags);
407 408
}

409 410 411 412 413 414 415 416 417 418 419 420 421 422
int av_opt_set_bin(void *obj, const char *name, const uint8_t *val, int len, int search_flags)
{
    void *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
    uint8_t *ptr;
    uint8_t **dst;
    int *lendst;

    if (!o || !target_obj)
        return AVERROR_OPTION_NOT_FOUND;

    if (o->type != AV_OPT_TYPE_BINARY)
        return AVERROR(EINVAL);

423 424
    ptr = len ? av_malloc(len) : NULL;
    if (len && !ptr)
425 426 427 428 429 430 431 432
        return AVERROR(ENOMEM);

    dst = (uint8_t **)(((uint8_t *)target_obj) + o->offset);
    lendst = (int *)(dst + 1);

    av_free(*dst);
    *dst = ptr;
    *lendst = len;
433 434
    if (len)
        memcpy(ptr, val, len);
435 436 437 438

    return 0;
}

439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
int av_opt_set_image_size(void *obj, const char *name, int w, int h, int search_flags)
{
    void *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);

    if (!o || !target_obj)
        return AVERROR_OPTION_NOT_FOUND;
    if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
        av_log(obj, AV_LOG_ERROR,
               "The value set by option '%s' is not an image size.\n", o->name);
        return AVERROR(EINVAL);
    }
    if (w<0 || h<0) {
        av_log(obj, AV_LOG_ERROR,
               "Invalid negative size value %dx%d for size '%s'\n", w, h, o->name);
        return AVERROR(EINVAL);
    }
    *(int *)(((uint8_t *)target_obj)             + o->offset) = w;
    *(int *)(((uint8_t *)target_obj+sizeof(int)) + o->offset) = h;
    return 0;
}

461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
int av_opt_set_video_rate(void *obj, const char *name, AVRational val, int search_flags)
{
    void *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);

    if (!o || !target_obj)
        return AVERROR_OPTION_NOT_FOUND;
    if (o->type != AV_OPT_TYPE_VIDEO_RATE) {
        av_log(obj, AV_LOG_ERROR,
               "The value set by option '%s' is not a video rate.\n", o->name);
        return AVERROR(EINVAL);
    }
    if (val.num <= 0 || val.den <= 0)
        return AVERROR(EINVAL);
    return set_number(obj, name, val.num, val.den, 1, search_flags);
}

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 482 483
{
    void *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0,
                                     search_flags, &target_obj);
484 485 486
    int min, max;
    const AVClass *class = *(AVClass **)obj;

487 488 489 490 491 492 493 494
    if (!o || !target_obj)
        return AVERROR_OPTION_NOT_FOUND;
    if (o->type != type) {
        av_log(obj, AV_LOG_ERROR,
               "The value set by option '%s' is not a %s format", name, desc);
        return AVERROR(EINVAL);
    }

495 496 497 498 499 500 501 502 503 504 505
#if LIBAVUTIL_VERSION_MAJOR < 53
    if (class->version && class->version < AV_VERSION_INT(52, 11, 100)) {
        min = -1;
        max = nb_fmts-1;
    } else
#endif
    {
        min = FFMIN(o->min, -1);
        max = FFMAX(o->max, nb_fmts-1);
    }
    if (fmt < min || fmt > max) {
506
        av_log(obj, AV_LOG_ERROR,
507 508
               "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
               fmt, name, desc, min, max);
509 510 511 512 513 514 515 516
        return AVERROR(ERANGE);
    }
    *(int *)(((uint8_t *)target_obj) + o->offset) = fmt;
    return 0;
}

int av_opt_set_pixel_fmt(void *obj, const char *name, enum AVPixelFormat fmt, int search_flags)
{
517
    return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_PIXEL_FMT, "pixel", AV_PIX_FMT_NB);
518 519 520 521
}

int av_opt_set_sample_fmt(void *obj, const char *name, enum AVSampleFormat fmt, int search_flags)
{
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 529 530
/**
 *
 * @param buf a buffer which is used for returning non string values as strings, can be NULL
 * @param buf_len allocated length in bytes of buf
 */
531 532
const char *av_get_string(void *obj, const char *name, const AVOption **o_out, char *buf, int buf_len)
{
533
    const AVOption *o = av_opt_find(obj, name, NULL, 0, AV_OPT_SEARCH_CHILDREN);
534 535 536
    void *dst;
    uint8_t *bin;
    int len, i;
537
    if (!o)
538
        return NULL;
539
    if (o->type != AV_OPT_TYPE_STRING && (!buf || !buf_len))
540 541 542
        return NULL;

    dst= ((uint8_t*)obj) + o->offset;
543
    if (o_out) *o_out= o;
544

545
    switch (o->type) {
546 547 548 549 550 551
    case AV_OPT_TYPE_FLAGS:     snprintf(buf, buf_len, "0x%08X",*(int    *)dst);break;
    case AV_OPT_TYPE_INT:       snprintf(buf, buf_len, "%d" , *(int    *)dst);break;
    case AV_OPT_TYPE_INT64:     snprintf(buf, buf_len, "%"PRId64, *(int64_t*)dst);break;
    case AV_OPT_TYPE_FLOAT:     snprintf(buf, buf_len, "%f" , *(float  *)dst);break;
    case AV_OPT_TYPE_DOUBLE:    snprintf(buf, buf_len, "%f" , *(double *)dst);break;
    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 554
    case AV_OPT_TYPE_STRING:    return *(void**)dst;
    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 560 561 562 563
        break;
    default: return NULL;
    }
    return buf;
}
564
#endif
565

566
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
567
{
568 569 570 571
    void *dst, *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
    uint8_t *bin, buf[128];
    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 582 583 584 585
    case AV_OPT_TYPE_FLAGS:     ret = snprintf(buf, sizeof(buf), "0x%08X",  *(int    *)dst);break;
    case AV_OPT_TYPE_INT:       ret = snprintf(buf, sizeof(buf), "%d" ,     *(int    *)dst);break;
    case AV_OPT_TYPE_INT64:     ret = snprintf(buf, sizeof(buf), "%"PRId64, *(int64_t*)dst);break;
    case AV_OPT_TYPE_FLOAT:     ret = snprintf(buf, sizeof(buf), "%f" ,     *(float  *)dst);break;
    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 591 592 593 594
        if (*(uint8_t**)dst)
            *out_val = av_strdup(*(uint8_t**)dst);
        else
            *out_val = av_strdup("");
        return 0;
595
    case AV_OPT_TYPE_BINARY:
596 597 598 599 600 601 602 603 604
        len = *(int*)(((uint8_t *)dst) + sizeof(uint8_t *));
        if ((uint64_t)len*2 + 1 > INT_MAX)
            return AVERROR(EINVAL);
        if (!(*out_val = av_malloc(len*2 + 1)))
            return AVERROR(ENOMEM);
        bin = *(uint8_t**)dst;
        for (i = 0; i < len; i++)
            snprintf(*out_val + i*2, 3, "%02X", bin[i]);
        return 0;
605 606 607
    case AV_OPT_TYPE_IMAGE_SIZE:
        ret = snprintf(buf, sizeof(buf), "%dx%d", ((int *)dst)[0], ((int *)dst)[1]);
        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 612 613
    case AV_OPT_TYPE_SAMPLE_FMT:
        ret = snprintf(buf, sizeof(buf), "%s", (char *)av_x_if_null(av_get_sample_fmt_name(*(enum AVSampleFormat *)dst), "none"));
        break;
614 615 616 617 618 619
    case AV_OPT_TYPE_DURATION:
        i64 = *(int64_t *)dst;
        ret = snprintf(buf, sizeof(buf), "%"PRIi64"d:%02d:%02d.%06d",
                       i64 / 3600000000, (int)((i64 / 60000000) % 60),
                       (int)((i64 / 1000000) % 60), (int)(i64 % 1000000));
        break;
620 621
    default:
        return AVERROR(EINVAL);
622
    }
623 624 625 626 627 628 629 630 631 632 633 634 635

    if (ret >= sizeof(buf))
        return AVERROR(EINVAL);
    *out_val = av_strdup(buf);
    return 0;
}

static int get_number(void *obj, const char *name, const AVOption **o_out, double *num, int *den, int64_t *intnum,
                      int search_flags)
{
    void *dst, *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
    if (!o || !target_obj)
636 637
        goto error;

638
    dst = ((uint8_t*)target_obj) + o->offset;
639

640
    if (o_out) *o_out= o;
641

642 643
    return read_number(o, dst, num, den, intnum);

644 645 646 647 648
error:
    *den=*intnum=0;
    return -1;
}

649
#if FF_API_OLD_AVOPTIONS
650 651
double av_get_double(void *obj, const char *name, const AVOption **o_out)
{
652 653 654 655
    int64_t intnum=1;
    double num=1;
    int den=1;

656
    if (get_number(obj, name, o_out, &num, &den, &intnum, 0) < 0)
657
        return NAN;
658 659 660
    return num*intnum/den;
}

661 662
AVRational av_get_q(void *obj, const char *name, const AVOption **o_out)
{
663 664 665 666
    int64_t intnum=1;
    double num=1;
    int den=1;

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 671 672 673 674
        return (AVRational){intnum, den};
    else
        return av_d2q(num*intnum/den, 1<<24);
}

675 676
int64_t av_get_int(void *obj, const char *name, const AVOption **o_out)
{
677 678 679 680
    int64_t intnum=1;
    double num=1;
    int den=1;

681
    if (get_number(obj, name, o_out, &num, &den, &intnum, 0) < 0)
682
        return -1;
683 684
    return num*intnum/den;
}
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
#endif

int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
{
    int64_t intnum = 1;
    double     num = 1;
    int   ret, den = 1;

    if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
        return ret;
    *out_val = num*intnum/den;
    return 0;
}

int av_opt_get_double(void *obj, const char *name, int search_flags, double *out_val)
{
    int64_t intnum = 1;
    double     num = 1;
    int   ret, den = 1;

    if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
        return ret;
    *out_val = num*intnum/den;
    return 0;
}

int av_opt_get_q(void *obj, const char *name, int search_flags, AVRational *out_val)
{
    int64_t intnum = 1;
    double     num = 1;
    int   ret, den = 1;

    if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
        return ret;

    if (num == 1.0 && (int)intnum == intnum)
        *out_val = (AVRational){intnum, den};
    else
        *out_val = av_d2q(num*intnum/den, 1<<24);
    return 0;
}
726

727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
int av_opt_get_image_size(void *obj, const char *name, int search_flags, int *w_out, int *h_out)
{
    void *dst, *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
    if (!o || !target_obj)
        return AVERROR_OPTION_NOT_FOUND;
    if (o->type != AV_OPT_TYPE_IMAGE_SIZE) {
        av_log(obj, AV_LOG_ERROR,
               "The value for option '%s' is not an image size.\n", name);
        return AVERROR(EINVAL);
    }

    dst = ((uint8_t*)target_obj) + o->offset;
    if (w_out) *w_out = *(int *)dst;
    if (h_out) *h_out = *((int *)dst+1);
    return 0;
}

745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760
int av_opt_get_video_rate(void *obj, const char *name, int search_flags, AVRational *out_val)
{
    int64_t intnum = 1;
    double     num = 1;
    int   ret, den = 1;

    if ((ret = get_number(obj, name, NULL, &num, &den, &intnum, search_flags)) < 0)
        return ret;

    if (num == 1.0 && (int)intnum == intnum)
        *out_val = (AVRational){intnum, den};
    else
        *out_val = av_d2q(num*intnum/den, 1<<24);
    return 0;
}

761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
static int get_format(void *obj, const char *name, int search_flags, int *out_fmt,
                      enum AVOptionType type, const char *desc)
{
    void *dst, *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
    if (!o || !target_obj)
        return AVERROR_OPTION_NOT_FOUND;
    if (o->type != type) {
        av_log(obj, AV_LOG_ERROR,
               "The value for option '%s' is not a %s format.\n", desc, name);
        return AVERROR(EINVAL);
    }

    dst = ((uint8_t*)target_obj) + o->offset;
    *out_fmt = *(int *)dst;
    return 0;
}

int av_opt_get_pixel_fmt(void *obj, const char *name, int search_flags, enum AVPixelFormat *out_fmt)
{
    return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_PIXEL_FMT, "pixel");
}

int av_opt_get_sample_fmt(void *obj, const char *name, int search_flags, enum AVSampleFormat *out_fmt)
{
    return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
}

789 790
int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
{
791
    const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
792 793
    const AVOption *flag  = av_opt_find(obj, flag_name,
                                        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 803 804 805 806 807 808 809 810 811 812 813 814 815 816
static void log_value(void *av_log_obj, int level, double d)
{
    if      (d == INT_MAX) {
        av_log(av_log_obj, level, "INT_MAX");
    } else if (d == INT_MIN) {
        av_log(av_log_obj, level, "INT_MIN");
    } else if (d == (double)INT64_MAX) {
        av_log(av_log_obj, level, "I64_MAX");
    } else if (d == INT64_MIN) {
        av_log(av_log_obj, level, "I64_MIN");
    } else if (d == FLT_MAX) {
        av_log(av_log_obj, level, "FLT_MAX");
    } else if (d == FLT_MIN) {
        av_log(av_log_obj, level, "FLT_MIN");
    } else {
817
        av_log(av_log_obj, level, "%g", d);
818 819 820
    }
}

821 822 823 824
static void opt_list(void *obj, void *av_log_obj, const char *unit,
                     int req_flags, int rej_flags)
{
    const AVOption *opt=NULL;
825 826
    AVOptionRanges *r;
    int i;
827

828
    while ((opt = av_opt_next(obj, opt))) {
829 830 831 832 833 834 835
        if (!(opt->flags & req_flags) || (opt->flags & rej_flags))
            continue;

        /* Don't print CONST's on level one.
         * Don't print anything but CONST's on level two.
         * Only print items from the requested unit.
         */
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 846 847
            av_log(av_log_obj, AV_LOG_INFO, "  %s%-17s ",
                   (opt->flags & AV_OPT_FLAG_FILTERING_PARAM) ? "" : "-",
                   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 878 879
            case AV_OPT_TYPE_VIDEO_RATE:
                av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<video_rate>");
                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 887 888
            case AV_OPT_TYPE_DURATION:
                av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<duration>");
                break;
889
            case AV_OPT_TYPE_CONST:
890
            default:
891
                av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
892 893 894 895
                break;
        }
        av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_ENCODING_PARAM) ? 'E' : '.');
        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 898 899 900
        av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_VIDEO_PARAM   ) ? 'V' : '.');
        av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_AUDIO_PARAM   ) ? 'A' : '.');
        av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) ? 'S' : '.');

901 902 903
        if (opt->help)
            av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);

904
        if (av_opt_query_ranges(&r, obj, opt->name, AV_OPT_SEARCH_FAKE_OBJ) >= 0) {
905 906 907 908 909 910
            switch (opt->type) {
            case AV_OPT_TYPE_INT:
            case AV_OPT_TYPE_INT64:
            case AV_OPT_TYPE_DOUBLE:
            case AV_OPT_TYPE_FLOAT:
            case AV_OPT_TYPE_RATIONAL:
911 912
                for (i = 0; i < r->nb_ranges; i++) {
                    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 919 920 921 922
                }
                break;
            }
            av_opt_freep_ranges(&r);
        }

923
        av_log(av_log_obj, AV_LOG_INFO, "\n");
924
        if (opt->unit && opt->type != AV_OPT_TYPE_CONST) {
925 926 927 928 929 930 931
            opt_list(obj, av_log_obj, opt->unit, req_flags, rej_flags);
        }
    }
}

int av_opt_show2(void *obj, void *av_log_obj, int req_flags, int rej_flags)
{
932
    if (!obj)
933 934 935 936 937 938 939 940 941
        return -1;

    av_log(av_log_obj, AV_LOG_INFO, "%s AVOptions:\n", (*(AVClass**)obj)->class_name);

    opt_list(obj, av_log_obj, NULL, req_flags, rej_flags);

    return 0;
}

942 943 944 945 946 947
void av_opt_set_defaults(void *s)
{
#if FF_API_OLD_AVOPTIONS
    av_opt_set_defaults2(s, 0, 0);
}

948 949
void av_opt_set_defaults2(void *s, int mask, int flags)
{
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 961
                /* Nothing to be done here */
            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 969
            case AV_OPT_TYPE_DOUBLE:
            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 985
                av_opt_set(s, opt->name, opt->default_val.str, 0);
                break;
986
            case AV_OPT_TYPE_PIXEL_FMT:
987 988 989 990 991 992 993
#if LIBAVUTIL_VERSION_MAJOR < 53
                if (class->version && class->version < AV_VERSION_INT(52, 10, 100))
                    av_opt_set(s, opt->name, opt->default_val.str, 0);
                else
#endif
                    av_opt_set_pixel_fmt(s, opt->name, opt->default_val.i64, 0);
                break;
994
            case AV_OPT_TYPE_SAMPLE_FMT:
995 996 997 998 999 1000
#if LIBAVUTIL_VERSION_MAJOR < 53
                if (class->version && class->version < AV_VERSION_INT(52, 10, 100))
                    av_opt_set(s, opt->name, opt->default_val.str, 0);
                else
#endif
                    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 1005 1006 1007 1008 1009 1010
            break;
            default:
                av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
        }
    }
}

1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
/**
 * Store the value in the field in ctx that is named like key.
 * ctx must be an AVClass context, storing is done using AVOptions.
 *
 * @param buf the string to parse, buf will be updated to point at the
 * separator just after the parsed key/value pair
 * @param key_val_sep a 0-terminated list of characters used to
 * separate key from value
 * @param pairs_sep a 0-terminated list of characters used to separate
 * two pairs from each other
 * @return 0 if the key/value pair has been successfully parsed and
 * set, or a negative value corresponding to an AVERROR code in case
 * of error:
 * 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 1027 1028 1029 1030 1031 1032 1033 1034
 * cannot be set
 */
static int parse_key_value_pair(void *ctx, const char **buf,
                                const char *key_val_sep, const char *pairs_sep)
{
    char *key = av_get_token(buf, key_val_sep);
    char *val;
    int ret;

1035 1036 1037
    if (!key)
        return AVERROR(ENOMEM);

1038 1039 1040
    if (*key && strspn(*buf, key_val_sep)) {
        (*buf)++;
        val = av_get_token(buf, pairs_sep);
1041 1042 1043 1044
        if (!val) {
            av_freep(&key);
            return AVERROR(ENOMEM);
        }
1045 1046 1047 1048 1049 1050
    } else {
        av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
        av_free(key);
        return AVERROR(EINVAL);
    }

1051
    av_log(ctx, AV_LOG_DEBUG, "Setting entry with key '%s' to value '%s'\n", key, val);
1052

1053
    ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
1054
    if (ret == AVERROR_OPTION_NOT_FOUND)
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066
        av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);

    av_free(key);
    av_free(val);
    return ret;
}

int av_set_options_string(void *ctx, const char *opts,
                          const char *key_val_sep, const char *pairs_sep)
{
    int ret, count = 0;

1067 1068
    if (!opts)
        return 0;
1069

1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
    while (*opts) {
        if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
            return ret;
        count++;

        if (*opts)
            opts++;
    }

    return count;
}

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
#define WHITESPACES " \n\t"

static int is_key_char(char c)
{
    return (unsigned)((c | 32) - 'a') < 26 ||
           (unsigned)(c - '0') < 10 ||
           c == '-' || c == '_' || c == '/' || c == '.';
}

/**
1092 1093 1094
 * Read a key from a string.
 *
 * The key consists of is_key_char characters and must be terminated by a
1095
 * character from the delim string; spaces are ignored.
1096 1097
 *
 * @return  0 for success (even with ellipsis), <0 for failure
1098
 */
1099
static int get_key(const char **ropts, const char *delim, char **rkey)
1100 1101
{
    const char *opts = *ropts;
1102
    const char *key_start, *key_end;
1103

1104 1105 1106 1107
    key_start = opts += strspn(opts, WHITESPACES);
    while (is_key_char(*opts))
        opts++;
    key_end = opts;
1108 1109 1110 1111
    opts += strspn(opts, WHITESPACES);
    if (!*opts || !strchr(delim, *opts))
        return AVERROR(EINVAL);
    opts++;
1112 1113 1114 1115
    if (!(*rkey = av_malloc(key_end - key_start + 1)))
        return AVERROR(ENOMEM);
    memcpy(*rkey, key_start, key_end - key_start);
    (*rkey)[key_end - key_start] = 0;
1116 1117 1118 1119
    *ropts = opts;
    return 0;
}

1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
int av_opt_get_key_value(const char **ropts,
                         const char *key_val_sep, const char *pairs_sep,
                         unsigned flags,
                         char **rkey, char **rval)
{
    int ret;
    char *key = NULL, *val;
    const char *opts = *ropts;

    if ((ret = get_key(&opts, key_val_sep, &key)) < 0 &&
        !(flags & AV_OPT_FLAG_IMPLICIT_KEY))
        return AVERROR(EINVAL);
    if (!(val = av_get_token(&opts, pairs_sep))) {
        av_free(key);
        return AVERROR(ENOMEM);
    }
    *ropts = opts;
    *rkey  = key;
    *rval  = val;
    return 0;
}

1142 1143 1144 1145 1146 1147
int av_opt_set_from_string(void *ctx, const char *opts,
                           const char *const *shorthand,
                           const char *key_val_sep, const char *pairs_sep)
{
    int ret, count = 0;
    const char *dummy_shorthand = NULL;
1148
    char *av_uninit(parsed_key), *av_uninit(value);
1149 1150 1151 1152 1153 1154 1155 1156
    const char *key;

    if (!opts)
        return 0;
    if (!shorthand)
        shorthand = &dummy_shorthand;

    while (*opts) {
1157 1158 1159 1160 1161
        ret = av_opt_get_key_value(&opts, key_val_sep, pairs_sep,
                                   *shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
                                   &parsed_key, &value);
        if (ret < 0) {
            if (ret == AVERROR(EINVAL))
1162
                av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", opts);
1163 1164 1165 1166 1167
            else
                av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", opts,
                       av_err2str(ret));
            return ret;
        }
1168 1169
        if (*opts)
            opts++;
1170
        if (parsed_key) {
1171
            key = parsed_key;
1172 1173
            while (*shorthand) /* discard all remaining shorthand */
                shorthand++;
1174 1175
        } else {
            key = *(shorthand++);
1176 1177 1178 1179 1180 1181
        }

        av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
        if ((ret = av_opt_set(ctx, key, value, 0)) < 0) {
            if (ret == AVERROR_OPTION_NOT_FOUND)
                av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
1182
            av_free(value);
1183
            av_free(parsed_key);
1184 1185 1186 1187
            return ret;
        }

        av_free(value);
1188
        av_free(parsed_key);
1189 1190 1191 1192 1193
        count++;
    }
    return count;
}

1194 1195 1196
void av_opt_free(void *obj)
{
    const AVOption *o = NULL;
1197
    while ((o = av_opt_next(obj, o)))
1198
        if (o->type == AV_OPT_TYPE_STRING || o->type == AV_OPT_TYPE_BINARY)
1199 1200 1201
            av_freep((uint8_t *)obj + o->offset);
}

1202 1203 1204 1205 1206 1207 1208
int av_opt_set_dict(void *obj, AVDictionary **options)
{
    AVDictionaryEntry *t = NULL;
    AVDictionary    *tmp = NULL;
    int ret = 0;

    while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) {
1209
        ret = av_opt_set(obj, t->key, t->value, 0);
1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222
        if (ret == AVERROR_OPTION_NOT_FOUND)
            av_dict_set(&tmp, t->key, t->value, 0);
        else if (ret < 0) {
            av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
            break;
        }
        ret = 0;
    }
    av_dict_free(options);
    *options = tmp;
    return ret;
}

1223 1224 1225
const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
                            int opt_flags, int search_flags)
{
1226 1227 1228 1229 1230 1231
    return av_opt_find2(obj, name, unit, opt_flags, search_flags, NULL);
}

const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
                             int opt_flags, int search_flags, void **target_obj)
{
1232
    const AVClass  *c;
1233 1234
    const AVOption *o = NULL;

1235 1236 1237 1238 1239
    if(!obj)
        return NULL;

    c= *(AVClass**)obj;

1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
    if (search_flags & AV_OPT_SEARCH_CHILDREN) {
        if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) {
            const AVClass *child = NULL;
            while (child = av_opt_child_class_next(c, child))
                if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
                    return o;
        } else {
            void *child = NULL;
            while (child = av_opt_child_next(obj, child))
                if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
                    return o;
        }
    }
1253

1254
    while (o = av_opt_next(obj, o)) {
1255
        if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
1256
            ((!unit && o->type != AV_OPT_TYPE_CONST) ||
1257
             (unit  && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) {
1258 1259 1260 1261 1262 1263
            if (target_obj) {
                if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
                    *target_obj = obj;
                else
                    *target_obj = NULL;
            }
1264
            return o;
1265
        }
1266 1267 1268 1269
    }
    return NULL;
}

1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
void *av_opt_child_next(void *obj, void *prev)
{
    const AVClass *c = *(AVClass**)obj;
    if (c->child_next)
        return c->child_next(obj, prev);
    return NULL;
}

const AVClass *av_opt_child_class_next(const AVClass *parent, const AVClass *prev)
{
    if (parent->child_class_next)
        return parent->child_class_next(prev);
    return NULL;
}

1285 1286
void *av_opt_ptr(const AVClass *class, void *obj, const char *name)
{
1287
    const AVOption *opt= av_opt_find2(&class, name, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ, NULL);
1288 1289 1290 1291 1292
    if(!opt)
        return NULL;
    return (uint8_t*)obj + opt->offset;
}

1293 1294
int av_opt_query_ranges(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
{
1295 1296 1297
    const AVClass *c = *(AVClass**)obj;
    int (*callback)(AVOptionRanges **, void *obj, const char *key, int flags) = NULL;

1298
    if (c->version > (52 << 16 | 11 << 8))
1299 1300
        callback = c->query_ranges;

1301
    if (!callback)
1302 1303 1304 1305 1306
        callback = av_opt_query_ranges_default;

    return callback(ranges_arg, obj, key, flags);
}

1307 1308
int av_opt_query_ranges_default(AVOptionRanges **ranges_arg, void *obj, const char *key, int flags)
{
1309 1310 1311 1312
    AVOptionRanges *ranges = av_mallocz(sizeof(*ranges));
    AVOptionRange **range_array = av_mallocz(sizeof(void*));
    AVOptionRange *range = av_mallocz(sizeof(*range));
    const AVOption *field = av_opt_find(obj, key, NULL, 0, flags);
1313
    int ret;
1314 1315 1316

    *ranges_arg = NULL;

1317 1318
    if (!ranges || !range || !range_array || !field) {
        ret = AVERROR(ENOMEM);
1319
        goto fail;
1320
    }
1321 1322 1323 1324 1325 1326 1327 1328

    ranges->range = range_array;
    ranges->range[0] = range;
    ranges->nb_ranges = 1;
    range->is_range = 1;
    range->value_min = field->min;
    range->value_max = field->max;

1329
    switch (field->type) {
1330 1331 1332 1333 1334 1335
    case AV_OPT_TYPE_INT:
    case AV_OPT_TYPE_INT64:
    case AV_OPT_TYPE_PIXEL_FMT:
    case AV_OPT_TYPE_SAMPLE_FMT:
    case AV_OPT_TYPE_FLOAT:
    case AV_OPT_TYPE_DOUBLE:
1336
    case AV_OPT_TYPE_DURATION:
1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
        break;
    case AV_OPT_TYPE_STRING:
        range->component_min = 0;
        range->component_max = 0x10FFFF; // max unicode value
        range->value_min = -1;
        range->value_max = INT_MAX;
        break;
    case AV_OPT_TYPE_RATIONAL:
        range->component_min = INT_MIN;
        range->component_max = INT_MAX;
        break;
    case AV_OPT_TYPE_IMAGE_SIZE:
        range->component_min = 0;
        range->component_max = INT_MAX/128/8;
        range->value_min = 0;
        range->value_max = INT_MAX/8;
        break;
1354 1355 1356 1357 1358 1359
    case AV_OPT_TYPE_VIDEO_RATE:
        range->component_min = 1;
        range->component_max = INT_MAX;
        range->value_min = 1;
        range->value_max = INT_MAX;
        break;
1360
    default:
1361
        ret = AVERROR(ENOSYS);
1362 1363 1364 1365 1366 1367 1368 1369
        goto fail;
    }

    *ranges_arg = ranges;
    return 0;
fail:
    av_free(ranges);
    av_free(range);
1370
    av_free(range_array);
1371
    return ret;
1372 1373
}

1374 1375
void av_opt_freep_ranges(AVOptionRanges **rangesp)
{
1376 1377 1378
    int i;
    AVOptionRanges *ranges = *rangesp;

1379
    for (i = 0; i < ranges->nb_ranges; i++) {
1380 1381 1382 1383 1384 1385 1386 1387
        AVOptionRange *range = ranges->range[i];
        av_freep(&range->str);
        av_freep(&ranges->range[i]);
    }
    av_freep(&ranges->range);
    av_freep(rangesp);
}

1388 1389 1390 1391 1392 1393 1394 1395 1396 1397
#ifdef TEST

typedef struct TestContext
{
    const AVClass *class;
    int num;
    int toggle;
    char *string;
    int flags;
    AVRational rational;
1398
    AVRational video_rate;
1399
    int w, h;
1400
    enum AVPixelFormat pix_fmt;
1401
    enum AVSampleFormat sample_fmt;
1402
    int64_t duration;
1403 1404 1405 1406 1407 1408 1409 1410 1411
} TestContext;

#define OFFSET(x) offsetof(TestContext, x)

#define TEST_FLAG_COOL 01
#define TEST_FLAG_LAME 02
#define TEST_FLAG_MU   04

static const AVOption test_options[]= {
1412 1413
{"num",      "set num",        OFFSET(num),      AV_OPT_TYPE_INT,      {.i64 = 0},       0,        100                 },
{"toggle",   "set toggle",     OFFSET(toggle),   AV_OPT_TYPE_INT,      {.i64 = 0},       0,        1                   },
1414
{"rational", "set rational",   OFFSET(rational), AV_OPT_TYPE_RATIONAL, {.dbl = 0},       0,        10                  },
1415
{"string",   "set string",     OFFSET(string),   AV_OPT_TYPE_STRING,   {.str = "default"}, CHAR_MIN, CHAR_MAX          },
1416
{"flags",    "set flags",      OFFSET(flags),    AV_OPT_TYPE_FLAGS,    {.i64 = 0},       0,        INT_MAX, 0, "flags" },
1417 1418 1419
{"cool",     "set cool flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_COOL}, INT_MIN,  INT_MAX, 0, "flags" },
{"lame",     "set lame flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_LAME}, INT_MIN,  INT_MAX, 0, "flags" },
{"mu",       "set mu flag ",   0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_MU},   INT_MIN,  INT_MAX, 0, "flags" },
1420
{"size",     "set size",       OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE,{0},             0,        0                   },
1421 1422
{"pix_fmt",  "set pixfmt",     OFFSET(pix_fmt),  AV_OPT_TYPE_PIXEL_FMT, {.i64 = AV_PIX_FMT_NONE}, -1, AV_PIX_FMT_NB-1},
{"sample_fmt", "set samplefmt", OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, {.i64 = AV_SAMPLE_FMT_NONE}, -1, AV_SAMPLE_FMT_NB-1},
1423
{"video_rate", "set videorate", OFFSET(video_rate), AV_OPT_TYPE_VIDEO_RATE,  {.str = "25"}, 0,     0                   },
1424
{"duration", "set duration",   OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX},
1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
{NULL},
};

static const char *test_get_name(void *ctx)
{
    return "test";
}

static const AVClass test_class = {
    "TestContext",
    test_get_name,
    test_options
};

int main(void)
{
    int i;

    printf("\nTesting av_set_options_string()\n");
    {
1445
        TestContext test_ctx = { 0 };
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
        const char *options[] = {
            "",
            ":",
            "=",
            "foo=:",
            ":=foo",
            "=foo",
            "foo=",
            "foo",
            "foo=val",
            "foo==val",
            "toggle=:",
            "string=:",
            "toggle=1 : foo",
            "toggle=100",
            "toggle==1",
            "flags=+mu-lame : num=42: toggle=0",
            "num=42 : string=blahblah",
            "rational=0 : rational=1/2 : rational=1/-1",
            "rational=-1/0",
1466 1467 1468 1469 1470 1471
            "size=1024x768",
            "size=pal",
            "size=bogus",
            "pix_fmt=yuv420p",
            "pix_fmt=2",
            "pix_fmt=bogus",
1472 1473 1474
            "sample_fmt=s16",
            "sample_fmt=2",
            "sample_fmt=bogus",
1475 1476 1477 1478 1479
            "video_rate=pal",
            "video_rate=25",
            "video_rate=30000/1001",
            "video_rate=30/1.001",
            "video_rate=bogus",
1480 1481 1482
            "duration=bogus",
            "duration=123.45",
            "duration=1\\:23\\:45.67",
1483 1484 1485
        };

        test_ctx.class = &test_class;
1486
        av_opt_set_defaults(&test_ctx);
1487 1488 1489 1490 1491 1492 1493 1494 1495

        av_log_set_level(AV_LOG_DEBUG);

        for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
            av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
            if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
                av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
            printf("\n");
        }
1496
        av_freep(&test_ctx.string);
1497 1498
    }

1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
    printf("\nTesting av_opt_set_from_string()\n");
    {
        TestContext test_ctx = { 0 };
        const char *options[] = {
            "",
            "5",
            "5:hello",
            "5:hello:size=pal",
            "5:size=pal:hello",
            ":",
            "=",
            " 5 : hello : size = pal ",
            "a_very_long_option_name_that_will_need_to_be_ellipsized_around_here=42"
        };
        const char *shorthand[] = { "num", "string", NULL };

        test_ctx.class = &test_class;
        av_opt_set_defaults(&test_ctx);
        test_ctx.string = av_strdup("default");

        av_log_set_level(AV_LOG_DEBUG);

        for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
            av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
            if (av_opt_set_from_string(&test_ctx, options[i], shorthand, "=", ":") < 0)
                av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
            printf("\n");
        }
        av_freep(&test_ctx.string);
    }

1530 1531 1532 1533
    return 0;
}

#endif