opt.c 26.6 KB
Newer Older
1 2 3 4
/*
 * AVOptions
 * Copyright (c) 2005 Michael Niedermayer <michaelni@gmx.at>
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8 9 10 11
 * 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.
 *
12
 * Libav is distributed in the hope that it will be useful,
13 14 15 16 17
 * 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
18
 * License along with Libav; if not, write to the Free Software
19 20 21 22 23 24 25 26 27 28
 * 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 "mathematics.h"
36

37
const AVOption *av_opt_next(void *obj, const AVOption *last)
38
{
39
    AVClass *class = *(AVClass**)obj;
40 41 42 43
    if (!last && class->option && class->option[0].name)
        return class->option;
    if (last && last[1].name)
        return ++last;
44
    return NULL;
45 46
}

47 48 49
static int read_number(const AVOption *o, void *dst, double *num, int *den, int64_t *intnum)
{
    switch (o->type) {
50 51 52 53 54 55
    case AV_OPT_TYPE_FLAGS:     *intnum = *(unsigned int*)dst;return 0;
    case AV_OPT_TYPE_INT:       *intnum = *(int         *)dst;return 0;
    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;
56 57 58 59 60 61
                                *den    = ((AVRational*)dst)->den;
                                                        return 0;
    }
    return AVERROR(EINVAL);
}

62
static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
63
{
64 65
    if (o->type != AV_OPT_TYPE_FLAGS &&
        (o->max * den < num * intnum || o->min * den > num * intnum)) {
66
        av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range\n",
67
               num*intnum/den, o->name);
68 69 70
        return AVERROR(ERANGE);
    }

71
    switch (o->type) {
72 73 74 75 76 77
    case AV_OPT_TYPE_FLAGS:
    case AV_OPT_TYPE_INT:   *(int       *)dst= llrint(num/den)*intnum; break;
    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:
78 79
        if ((int)num == num) *(AVRational*)dst= (AVRational){num*intnum, den};
        else                 *(AVRational*)dst= av_d2q(num*intnum/den, 1<<24);
80 81 82 83 84 85 86
        break;
    default:
        return AVERROR(EINVAL);
    }
    return 0;
}

87
static const double const_values[] = {
88 89 90 91 92 93
    M_PI,
    M_E,
    FF_QP2LAMBDA,
    0
};

94
static const char * const const_names[] = {
95 96 97 98 99 100 101 102 103 104 105 106 107
    "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;
}

108
static int set_string_binary(void *obj, const AVOption *o, const char *val, uint8_t **dst)
109
{
110 111 112 113 114 115 116 117
    int *lendst = (int *)(dst + 1);
    uint8_t *bin, *ptr;
    int len = strlen(val);

    av_freep(dst);
    *lendst = 0;

    if (len & 1)
118
        return AVERROR(EINVAL);
119
    len /= 2;
120

121
    ptr = bin = av_malloc(len);
122 123
    if (!ptr)
        return AVERROR(ENOMEM);
124 125 126 127 128 129
    while (*val) {
        int a = hexchar2int(*val++);
        int b = hexchar2int(*val++);
        if (a < 0 || b < 0) {
            av_free(bin);
            return AVERROR(EINVAL);
130
        }
131
        *ptr++ = (a << 4) | b;
132
    }
133 134 135 136 137 138 139 140 141 142
    *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);
143
    return *dst ? 0 : AVERROR(ENOMEM);
144 145
}

146
#define DEFAULT_NUMVAL(opt) ((opt->type == AV_OPT_TYPE_INT64 || \
147
                              opt->type == AV_OPT_TYPE_CONST || \
148 149
                              opt->type == AV_OPT_TYPE_FLAGS || \
                              opt->type == AV_OPT_TYPE_INT) ? \
150 151
                             opt->default_val.i64 : opt->default_val.dbl)

152
static int set_string_number(void *obj, void *target_obj, const AVOption *o, const char *val, void *dst)
153 154 155
{
    int ret = 0, notfirst = 0;
    for (;;) {
156
        int i, den = 1;
157 158
        char buf[256];
        int cmd = 0;
159 160
        double d, num = 1;
        int64_t intnum = 1;
161

162 163 164 165 166 167 168
        i = 0;
        if (*val == '+' || *val == '-') {
            if (o->type == AV_OPT_TYPE_FLAGS)
                cmd = *(val++);
            else if (!notfirst)
                buf[i++] = *val;
        }
169

170
        for (; i < sizeof(buf) - 1 && val[i] && val[i] != '+' && val[i] != '-'; i++)
171 172 173 174
            buf[i] = val[i];
        buf[i] = 0;

        {
175
            const AVOption *o_named = av_opt_find(target_obj, buf, o->unit, 0, 0);
176
            if (o_named && o_named->type == AV_OPT_TYPE_CONST)
177 178
                d = DEFAULT_NUMVAL(o_named);
            else if (!strcmp(buf, "default")) d = DEFAULT_NUMVAL(o);
179 180 181 182 183 184 185 186 187
            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;
188 189 190
                }
            }
        }
191
        if (o->type == AV_OPT_TYPE_FLAGS) {
192 193 194
            read_number(o, dst, NULL, NULL, &intnum);
            if      (cmd == '+') d = intnum | (int64_t)d;
            else if (cmd == '-') d = intnum &~(int64_t)d;
195
        } else {
196 197 198
            read_number(o, dst, &num, &den, &intnum);
            if      (cmd == '+') d = notfirst*num*intnum/den + d;
            else if (cmd == '-') d = notfirst*num*intnum/den - d;
199
        }
200

201
        if ((ret = write_number(obj, o, dst, d, 1, 1)) < 0)
202 203 204 205 206
            return ret;
        val += i;
        if (!*val)
            return 0;
        notfirst = 1;
207 208 209 210 211
    }

    return 0;
}

212 213 214 215 216
int av_opt_set(void *obj, const char *name, const char *val, 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)
217
        return AVERROR_OPTION_NOT_FOUND;
218
    if (!val || o->flags & AV_OPT_FLAG_READONLY)
219 220
        return AVERROR(EINVAL);

221
    dst = ((uint8_t*)target_obj) + o->offset;
222
    switch (o->type) {
223 224 225 226 227 228 229
    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:
230
    case AV_OPT_TYPE_RATIONAL: return set_string_number(obj, target_obj, o, val, dst);
231 232 233 234 235 236
    }

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

237 238 239
#define OPT_EVAL_NUMBER(name, opttype, vartype)\
    int av_opt_eval_ ## name(void *obj, const AVOption *o, const char *val, vartype *name ## _out)\
    {\
240
        if (!o || o->type != opttype || o->flags & AV_OPT_FLAG_READONLY)\
241
            return AVERROR(EINVAL);\
242
        return set_string_number(obj, obj, o, val, name ## _out);\
243 244
    }

245 246 247 248 249 250
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)
251

252 253
static int set_number(void *obj, const char *name, double num, int den, int64_t intnum,
                                  int search_flags)
254
{
255 256
    void *dst, *target_obj;
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
257

258 259
    if (!o || !target_obj)
        return AVERROR_OPTION_NOT_FOUND;
260

261 262 263
    if (o->flags & AV_OPT_FLAG_READONLY)
        return AVERROR(EINVAL);

264 265
    dst = ((uint8_t*)target_obj) + o->offset;
    return write_number(obj, o, dst, num, den, intnum);
266 267
}

268 269 270 271 272 273 274 275 276 277 278 279 280
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);
281 282
}

283 284 285 286 287 288 289 290 291 292 293
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;

294
    if (o->type != AV_OPT_TYPE_BINARY || o->flags & AV_OPT_FLAG_READONLY)
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311
        return AVERROR(EINVAL);

    ptr = av_malloc(len);
    if (!ptr)
        return AVERROR(ENOMEM);

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

    av_free(*dst);
    *dst = ptr;
    *lendst = len;
    memcpy(ptr, val, len);

    return 0;
}

312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
int av_opt_set_dict_val(void *obj, const char *name, const AVDictionary *val, int search_flags)
{
    void *target_obj;
    AVDictionary **dst;
    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->flags & AV_OPT_FLAG_READONLY)
        return AVERROR(EINVAL);

    dst = (AVDictionary **)(((uint8_t *)target_obj) + o->offset);
    av_dict_free(dst);
    av_dict_copy(dst, val, 0);

    return 0;
}

330
int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)
331
{
332 333 334 335 336 337 338 339 340 341 342 343
    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;

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

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

    buf[0] = 0;
    switch (o->type) {
344 345 346 347 348 349 350
    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;
    case AV_OPT_TYPE_RATIONAL:  ret = snprintf(buf, sizeof(buf), "%d/%d",   ((AVRational*)dst)->num, ((AVRational*)dst)->den);break;
    case AV_OPT_TYPE_STRING:
351 352 353 354
        if (*(uint8_t**)dst)
            *out_val = av_strdup(*(uint8_t**)dst);
        else
            *out_val = av_strdup("");
355
        return *out_val ? 0 : AVERROR(ENOMEM);
356
    case AV_OPT_TYPE_BINARY:
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
        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;
    default:
        return AVERROR(EINVAL);
    }

    if (ret >= sizeof(buf))
        return AVERROR(EINVAL);
    *out_val = av_strdup(buf);
373
    return *out_val ? 0 : AVERROR(ENOMEM);
374 375
}

376
static int get_number(void *obj, const char *name, double *num, int *den, int64_t *intnum,
377 378 379 380 381
                      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)
382 383
        goto error;

384
    dst = ((uint8_t*)target_obj) + o->offset;
385

386 387
    return read_number(o, dst, num, den, intnum);

388 389 390 391 392
error:
    *den=*intnum=0;
    return -1;
}

393 394 395 396 397 398
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;

399
    if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
400 401 402 403 404 405 406 407 408 409 410
        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;

411
    if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
412 413 414 415 416 417 418 419 420 421 422
        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;

423
    if ((ret = get_number(obj, name, &num, &den, &intnum, search_flags)) < 0)
424 425 426 427 428 429 430 431
        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;
}
432

433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449
int av_opt_get_dict_val(void *obj, const char *name, int search_flags, AVDictionary **out_val)
{
    void *target_obj;
    AVDictionary *src;
    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_DICT)
        return AVERROR(EINVAL);

    src = *(AVDictionary **)(((uint8_t *)target_obj) + o->offset);
    av_dict_copy(out_val, src, 0);

    return 0;
}

450 451
int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
{
452
    const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
453 454
    const AVOption *flag  = av_opt_find(obj, flag_name,
                                        field ? field->unit : NULL, 0, 0);
455
    int64_t res;
456

457
    if (!field || !flag || flag->type != AV_OPT_TYPE_CONST ||
458
        av_opt_get_int(obj, field_name, 0, &res) < 0)
459
        return 0;
460
    return res & flag->default_val.i64;
461 462
}

463 464 465 466 467
static void opt_list(void *obj, void *av_log_obj, const char *unit,
                     int req_flags, int rej_flags)
{
    const AVOption *opt=NULL;

468
    while ((opt = av_opt_next(obj, opt))) {
469 470 471 472 473 474 475
        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.
         */
476
        if (!unit && opt->type==AV_OPT_TYPE_CONST)
477
            continue;
478
        else if (unit && opt->type!=AV_OPT_TYPE_CONST)
479
            continue;
480
        else if (unit && opt->type==AV_OPT_TYPE_CONST && strcmp(unit, opt->unit))
481
            continue;
482
        else if (unit && opt->type == AV_OPT_TYPE_CONST)
483 484 485 486
            av_log(av_log_obj, AV_LOG_INFO, "   %-15s ", opt->name);
        else
            av_log(av_log_obj, AV_LOG_INFO, "-%-17s ", opt->name);

487
        switch (opt->type) {
488
            case AV_OPT_TYPE_FLAGS:
489
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<flags>");
490
                break;
491
            case AV_OPT_TYPE_INT:
492
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int>");
493
                break;
494
            case AV_OPT_TYPE_INT64:
495
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<int64>");
496
                break;
497
            case AV_OPT_TYPE_DOUBLE:
498
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<double>");
499
                break;
500
            case AV_OPT_TYPE_FLOAT:
501
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<float>");
502
                break;
503
            case AV_OPT_TYPE_STRING:
504
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<string>");
505
                break;
506
            case AV_OPT_TYPE_RATIONAL:
507
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<rational>");
508
                break;
509
            case AV_OPT_TYPE_BINARY:
510
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "<binary>");
511
                break;
512
            case AV_OPT_TYPE_CONST:
513
            default:
514
                av_log(av_log_obj, AV_LOG_INFO, "%-7s ", "");
515 516 517 518 519 520 521
                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' : '.');
        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' : '.');
522 523
        av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_EXPORT)         ? 'X' : '.');
        av_log(av_log_obj, AV_LOG_INFO, "%c", (opt->flags & AV_OPT_FLAG_READONLY)       ? 'R' : '.');
524

525
        if (opt->help)
526 527
            av_log(av_log_obj, AV_LOG_INFO, " %s", opt->help);
        av_log(av_log_obj, AV_LOG_INFO, "\n");
528
        if (opt->unit && opt->type != AV_OPT_TYPE_CONST) {
529 530 531 532 533 534 535
            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)
{
536
    if (!obj)
537 538 539 540 541 542 543 544 545
        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;
}

546 547
void av_opt_set_defaults(void *s)
{
548
    const AVOption *opt = NULL;
549
    while ((opt = av_opt_next(s, opt))) {
550 551 552
        if (opt->flags & AV_OPT_FLAG_READONLY)
            continue;

553
        switch (opt->type) {
554
            case AV_OPT_TYPE_CONST:
555 556
                /* Nothing to be done here */
            break;
557
            case AV_OPT_TYPE_FLAGS:
558
            case AV_OPT_TYPE_INT:
559
            case AV_OPT_TYPE_INT64:
560
                av_opt_set_int(s, opt->name, opt->default_val.i64, 0);
561
            break;
562 563
            case AV_OPT_TYPE_DOUBLE:
            case AV_OPT_TYPE_FLOAT: {
564
                double val;
565
                val = opt->default_val.dbl;
566
                av_opt_set_double(s, opt->name, val, 0);
567 568
            }
            break;
569
            case AV_OPT_TYPE_RATIONAL: {
570
                AVRational val;
571
                val = av_d2q(opt->default_val.dbl, INT_MAX);
572
                av_opt_set_q(s, opt->name, val, 0);
573 574
            }
            break;
575
            case AV_OPT_TYPE_STRING:
576
                av_opt_set(s, opt->name, opt->default_val.str, 0);
577
                break;
578
            case AV_OPT_TYPE_BINARY:
579 580
            case AV_OPT_TYPE_DICT:
                /* Cannot set defaults for these types */
581 582 583 584 585 586 587
            break;
            default:
                av_log(s, AV_LOG_DEBUG, "AVOption type %d of option %s not implemented yet\n", opt->type, opt->name);
        }
    }
}

588 589 590 591 592 593 594 595 596 597 598 599 600 601
/**
 * 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,
602
 * the error code issued by av_opt_set() if the key/value pair
603 604 605 606 607 608 609 610 611
 * 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;

612 613 614
    if (!key)
        return AVERROR(ENOMEM);

615 616 617
    if (*key && strspn(*buf, key_val_sep)) {
        (*buf)++;
        val = av_get_token(buf, pairs_sep);
618 619 620 621
        if (!val) {
            av_freep(&key);
            return AVERROR(ENOMEM);
        }
622 623 624 625 626 627 628 629
    } 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);
    }

    av_log(ctx, AV_LOG_DEBUG, "Setting value '%s' for key '%s'\n", val, key);

630
    ret = av_opt_set(ctx, key, val, AV_OPT_SEARCH_CHILDREN);
631
    if (ret == AVERROR_OPTION_NOT_FOUND)
632 633 634 635 636 637 638 639 640 641 642 643
        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;

644 645 646
    if (!opts)
        return 0;

647 648 649 650 651 652 653 654 655 656 657 658
    while (*opts) {
        if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
            return ret;
        count++;

        if (*opts)
            opts++;
    }

    return count;
}

659 660 661
void av_opt_free(void *obj)
{
    const AVOption *o = NULL;
662 663 664 665
    while ((o = av_opt_next(obj, o))) {
        switch (o->type) {
        case AV_OPT_TYPE_STRING:
        case AV_OPT_TYPE_BINARY:
666
            av_freep((uint8_t *)obj + o->offset);
667 668 669 670 671 672 673 674 675 676
            break;

        case AV_OPT_TYPE_DICT:
            av_dict_free((AVDictionary **)(((uint8_t *)obj) + o->offset));
            break;

        default:
            break;
        }
    }
677 678
}

679 680 681 682 683 684 685
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))) {
686
        ret = av_opt_set(obj, t->key, t->value, 0);
687 688 689 690 691 692 693 694 695 696 697 698 699
        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;
}

700 701 702
const AVOption *av_opt_find(void *obj, const char *name, const char *unit,
                            int opt_flags, int search_flags)
{
703 704 705 706 707 708 709
    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)
{
    const AVClass  *c = *(AVClass**)obj;
710 711
    const AVOption *o = NULL;

712 713 714
    if (!c)
        return NULL;

715 716 717 718 719 720 721 722 723 724 725 726 727
    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;
        }
    }
728

729
    while (o = av_opt_next(obj, o)) {
730
        if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
731
            ((!unit && o->type != AV_OPT_TYPE_CONST) ||
732 733 734 735 736 737 738
             (unit  && o->unit && !strcmp(o->unit, unit)))) {
            if (target_obj) {
                if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
                    *target_obj = obj;
                else
                    *target_obj = NULL;
            }
739
            return o;
740
        }
741 742 743 744
    }
    return NULL;
}

745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
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;
}

760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778
#ifdef TEST

typedef struct TestContext
{
    const AVClass *class;
    int num;
    int toggle;
    char *string;
    int flags;
    AVRational rational;
} 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[]= {
779 780
{"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                   },
781
{"rational", "set rational",   OFFSET(rational), AV_OPT_TYPE_RATIONAL, {.dbl = 0},  0,        10                  },
782
{"string",   "set string",     OFFSET(string),   AV_OPT_TYPE_STRING,   {0},              CHAR_MIN, CHAR_MAX            },
783
{"flags",    "set flags",      OFFSET(flags),    AV_OPT_TYPE_FLAGS,    {.i64 = 0},       0,        INT_MAX, 0, "flags" },
784 785 786
{"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" },
787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
{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");
    {
        TestContext test_ctx;
        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",
        };

        test_ctx.class = &test_class;
831
        av_opt_set_defaults(&test_ctx);
832
        test_ctx.string = av_strdup("default");
833 834
        if (!test_ctx.string)
            return AVERROR(ENOMEM);
835 836 837 838 839 840 841 842 843 844 845 846 847 848 849

        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");
        }
    }

    return 0;
}

#endif