← Back to branch summary

~ppsspp/ppsspp/ffmpeg

« back to all changes in this revision

Viewing changes to libavutil/opt.c

  • Committer: Henrik Rydgård
  • Date: 2014-01-03 10:44:32 UTC
  • Revision ID: git-v1:87c6c126784b1718bfa448ecf2e6a9fef781eb4e
Update our ffmpeg snapshot to a clone of the official repository.

This is because Maxim's at3plus support has been officially merged!

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavutil/opt.c
27
27
 
28
28
#include "avutil.h"
29
29
#include "avstring.h"
 
30
#include "channel_layout.h"
30
31
#include "common.h"
31
32
#include "opt.h"
32
33
#include "eval.h"
77
78
    case AV_OPT_TYPE_PIXEL_FMT:
78
79
    case AV_OPT_TYPE_SAMPLE_FMT:
79
80
    case AV_OPT_TYPE_INT:       *intnum = *(int         *)dst;return 0;
 
81
    case AV_OPT_TYPE_CHANNEL_LAYOUT:
80
82
    case AV_OPT_TYPE_DURATION:
81
83
    case AV_OPT_TYPE_INT64:     *intnum = *(int64_t     *)dst;return 0;
82
84
    case AV_OPT_TYPE_FLOAT:     *num    = *(float       *)dst;return 0;
91
93
 
92
94
static int write_number(void *obj, const AVOption *o, void *dst, double num, int den, int64_t intnum)
93
95
{
94
 
    if (o->max*den < num*intnum || o->min*den > num*intnum) {
 
96
    if (o->type != AV_OPT_TYPE_FLAGS &&
 
97
        (o->max * den < num * intnum || o->min * den > num * intnum)) {
95
98
        av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
96
99
               num*intnum/den, o->name, o->min, o->max);
97
100
        return AVERROR(ERANGE);
98
101
    }
 
102
    if (o->type == AV_OPT_TYPE_FLAGS) {
 
103
        double d = num*intnum/den;
 
104
        if (d < -1.5 || d > 0xFFFFFFFF+0.5 || (llrint(d*256) & 255)) {
 
105
            av_log(obj, AV_LOG_ERROR,
 
106
                   "Value %f for parameter '%s' is not a valid set of 32bit integer flags\n",
 
107
                   num*intnum/den, o->name);
 
108
            return AVERROR(ERANGE);
 
109
        }
 
110
    }
99
111
 
100
112
    switch (o->type) {
101
113
    case AV_OPT_TYPE_FLAGS:
103
115
    case AV_OPT_TYPE_SAMPLE_FMT:
104
116
    case AV_OPT_TYPE_INT:   *(int       *)dst= llrint(num/den)*intnum; break;
105
117
    case AV_OPT_TYPE_DURATION:
 
118
    case AV_OPT_TYPE_CHANNEL_LAYOUT:
106
119
    case AV_OPT_TYPE_INT64: *(int64_t   *)dst= llrint(num/den)*intnum; break;
107
120
    case AV_OPT_TYPE_FLOAT: *(float     *)dst= num*intnum/den;         break;
108
121
    case AV_OPT_TYPE_DOUBLE:*(double    *)dst= num*intnum/den;         break;
239
252
    return 0;
240
253
}
241
254
 
 
255
static int set_string_image_size(void *obj, const AVOption *o, const char *val, int *dst)
 
256
{
 
257
    int ret;
 
258
 
 
259
    if (!val || !strcmp(val, "none")) {
 
260
        dst[0] =
 
261
        dst[1] = 0;
 
262
        return 0;
 
263
    }
 
264
    ret = av_parse_video_size(dst, dst + 1, val);
 
265
    if (ret < 0)
 
266
        av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as image size\n", val);
 
267
    return ret;
 
268
}
 
269
 
 
270
static int set_string_video_rate(void *obj, const AVOption *o, const char *val, AVRational *dst)
 
271
{
 
272
    int ret;
 
273
    if (!val) {
 
274
        ret = AVERROR(EINVAL);
 
275
    } else {
 
276
        ret = av_parse_video_rate(dst, val);
 
277
    }
 
278
    if (ret < 0)
 
279
        av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as video rate\n", val);
 
280
    return ret;
 
281
}
 
282
 
 
283
static int set_string_color(void *obj, const AVOption *o, const char *val, uint8_t *dst)
 
284
{
 
285
    int ret;
 
286
 
 
287
    if (!val) {
 
288
        return 0;
 
289
    } else {
 
290
        ret = av_parse_color(dst, val, -1, obj);
 
291
        if (ret < 0)
 
292
            av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as color\n", val);
 
293
        return ret;
 
294
    }
 
295
    return 0;
 
296
}
 
297
 
 
298
static int set_string_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst,
 
299
                          int fmt_nb, int ((*get_fmt)(const char *)), const char *desc)
 
300
{
 
301
    int fmt, min, max;
 
302
 
 
303
    if (!val || !strcmp(val, "none")) {
 
304
        fmt = -1;
 
305
    } else {
 
306
        fmt = get_fmt(val);
 
307
        if (fmt == -1) {
 
308
            char *tail;
 
309
            fmt = strtol(val, &tail, 0);
 
310
            if (*tail || (unsigned)fmt >= fmt_nb) {
 
311
                av_log(obj, AV_LOG_ERROR,
 
312
                       "Unable to parse option value \"%s\" as %s\n", val, desc);
 
313
                return AVERROR(EINVAL);
 
314
            }
 
315
        }
 
316
    }
 
317
 
 
318
    min = FFMAX(o->min, -1);
 
319
    max = FFMIN(o->max, fmt_nb-1);
 
320
 
 
321
    if (fmt < min || fmt > max) {
 
322
        av_log(obj, AV_LOG_ERROR,
 
323
               "Value %d for parameter '%s' out of %s format range [%d - %d]\n",
 
324
               fmt, o->name, desc, min, max);
 
325
        return AVERROR(ERANGE);
 
326
    }
 
327
 
 
328
    *(int *)dst = fmt;
 
329
    return 0;
 
330
}
 
331
 
 
332
static int set_string_pixel_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
 
333
{
 
334
    return set_string_fmt(obj, o, val, dst,
 
335
                          AV_PIX_FMT_NB, av_get_pix_fmt, "pixel format");
 
336
}
 
337
 
 
338
static int set_string_sample_fmt(void *obj, const AVOption *o, const char *val, uint8_t *dst)
 
339
{
 
340
    return set_string_fmt(obj, o, val, dst,
 
341
                          AV_SAMPLE_FMT_NB, av_get_sample_fmt, "sample format");
 
342
}
 
343
 
242
344
#if FF_API_OLD_AVOPTIONS
243
345
int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out)
244
346
{
251
353
 
252
354
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
253
355
{
254
 
    int ret;
 
356
    int ret = 0;
255
357
    void *dst, *target_obj;
256
358
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
257
359
    if (!o || !target_obj)
259
361
    if (!val && (o->type != AV_OPT_TYPE_STRING &&
260
362
                 o->type != AV_OPT_TYPE_PIXEL_FMT && o->type != AV_OPT_TYPE_SAMPLE_FMT &&
261
363
                 o->type != AV_OPT_TYPE_IMAGE_SIZE && o->type != AV_OPT_TYPE_VIDEO_RATE &&
262
 
                 o->type != AV_OPT_TYPE_DURATION && o->type != AV_OPT_TYPE_COLOR))
 
364
                 o->type != AV_OPT_TYPE_DURATION && o->type != AV_OPT_TYPE_COLOR &&
 
365
                 o->type != AV_OPT_TYPE_CHANNEL_LAYOUT))
263
366
        return AVERROR(EINVAL);
264
367
 
265
368
    dst = ((uint8_t*)target_obj) + o->offset;
272
375
    case AV_OPT_TYPE_FLOAT:
273
376
    case AV_OPT_TYPE_DOUBLE:
274
377
    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;
 
378
    case AV_OPT_TYPE_IMAGE_SIZE: return set_string_image_size(obj, o, val, dst);
 
379
    case AV_OPT_TYPE_VIDEO_RATE: return set_string_video_rate(obj, o, val, dst);
 
380
    case AV_OPT_TYPE_PIXEL_FMT:  return set_string_pixel_fmt(obj, o, val, dst);
 
381
    case AV_OPT_TYPE_SAMPLE_FMT: return set_string_sample_fmt(obj, o, val, dst);
325
382
    case AV_OPT_TYPE_DURATION:
326
383
        if (!val) {
327
384
            *(int64_t *)dst = 0;
332
389
            return ret;
333
390
        }
334
391
        break;
335
 
    case AV_OPT_TYPE_COLOR:
336
 
        if (!val) {
337
 
            return 0;
 
392
    case AV_OPT_TYPE_COLOR:      return set_string_color(obj, o, val, dst);
 
393
    case AV_OPT_TYPE_CHANNEL_LAYOUT:
 
394
        if (!val || !strcmp(val, "none")) {
 
395
            *(int64_t *)dst = 0;
338
396
        } else {
339
 
            ret = av_parse_color(dst, val, -1, obj);
340
 
            if (ret < 0)
341
 
                av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as color\n", val);
 
397
#if FF_API_GET_CHANNEL_LAYOUT_COMPAT
 
398
            int64_t cl = ff_get_channel_layout(val, 0);
 
399
#else
 
400
            int64_t cl = av_get_channel_layout(val);
 
401
#endif
 
402
            if (!cl) {
 
403
                av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
 
404
                ret = AVERROR(EINVAL);
 
405
            }
 
406
            *(int64_t *)dst = cl;
342
407
            return ret;
343
408
        }
 
409
        break;
344
410
    }
345
411
 
346
412
    av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
502
568
        return AVERROR(EINVAL);
503
569
    }
504
570
 
505
 
#if LIBAVUTIL_VERSION_MAJOR < 53
 
571
#if LIBAVUTIL_VERSION_MAJOR < 54
506
572
    if (class->version && class->version < AV_VERSION_INT(52, 11, 100)) {
507
573
        min = -1;
508
574
        max = nb_fmts-1;
509
575
    } else
510
576
#endif
511
577
    {
512
 
        min = FFMIN(o->min, -1);
513
 
        max = FFMAX(o->max, nb_fmts-1);
 
578
        min = FFMAX(o->min, -1);
 
579
        max = FFMIN(o->max, nb_fmts-1);
514
580
    }
515
581
    if (fmt < min || fmt > max) {
516
582
        av_log(obj, AV_LOG_ERROR,
532
598
    return set_format(obj, name, fmt, search_flags, AV_OPT_TYPE_SAMPLE_FMT, "sample", AV_SAMPLE_FMT_NB);
533
599
}
534
600
 
 
601
int av_opt_set_channel_layout(void *obj, const char *name, int64_t cl, int search_flags)
 
602
{
 
603
    void *target_obj;
 
604
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
 
605
 
 
606
    if (!o || !target_obj)
 
607
        return AVERROR_OPTION_NOT_FOUND;
 
608
    if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
 
609
        av_log(obj, AV_LOG_ERROR,
 
610
               "The value set by option '%s' is not a channel layout.\n", o->name);
 
611
        return AVERROR(EINVAL);
 
612
    }
 
613
    *(int *)(((int64_t *)target_obj) + o->offset) = cl;
 
614
    return 0;
 
615
}
 
616
 
535
617
#if FF_API_OLD_AVOPTIONS
536
618
/**
537
619
 *
630
712
    case AV_OPT_TYPE_COLOR:
631
713
        ret = snprintf(buf, sizeof(buf), "0x%02x%02x%02x%02x", ((int *)dst)[0], ((int *)dst)[1], ((int *)dst)[2], ((int *)dst)[3]);
632
714
        break;
 
715
    case AV_OPT_TYPE_CHANNEL_LAYOUT:
 
716
        i64 = *(int64_t *)dst;
 
717
        ret = snprintf(buf, sizeof(buf), "0x%"PRIx64, i64);
 
718
        break;
633
719
    default:
634
720
        return AVERROR(EINVAL);
635
721
    }
799
885
    return get_format(obj, name, search_flags, out_fmt, AV_OPT_TYPE_SAMPLE_FMT, "sample");
800
886
}
801
887
 
 
888
int av_opt_get_channel_layout(void *obj, const char *name, int search_flags, int64_t *cl)
 
889
{
 
890
    void *dst, *target_obj;
 
891
    const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
 
892
    if (!o || !target_obj)
 
893
        return AVERROR_OPTION_NOT_FOUND;
 
894
    if (o->type != AV_OPT_TYPE_CHANNEL_LAYOUT) {
 
895
        av_log(obj, AV_LOG_ERROR,
 
896
               "The value for option '%s' is not a channel layout.\n", name);
 
897
        return AVERROR(EINVAL);
 
898
    }
 
899
 
 
900
    dst = ((uint8_t*)target_obj) + o->offset;
 
901
    *cl = *(int64_t *)dst;
 
902
    return 0;
 
903
}
 
904
 
802
905
int av_opt_flag_is_set(void *obj, const char *field_name, const char *flag_name)
803
906
{
804
907
    const AVOption *field = av_opt_find(obj, field_name, NULL, 0, 0);
902
1005
            case AV_OPT_TYPE_COLOR:
903
1006
                av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<color>");
904
1007
                break;
 
1008
            case AV_OPT_TYPE_CHANNEL_LAYOUT:
 
1009
                av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "<channel_layout>");
 
1010
                break;
905
1011
            case AV_OPT_TYPE_CONST:
906
1012
            default:
907
1013
                av_log(av_log_obj, AV_LOG_INFO, "%-12s ", "");
972
1078
            case AV_OPT_TYPE_STRING:
973
1079
            case AV_OPT_TYPE_VIDEO_RATE:
974
1080
                av_log(av_log_obj, AV_LOG_INFO, "\"%s\"", opt->default_val.str);
 
1081
                break;
 
1082
            case AV_OPT_TYPE_CHANNEL_LAYOUT:
 
1083
                av_log(av_log_obj, AV_LOG_INFO, "0x%"PRIx64, opt->default_val.i64);
 
1084
                break;
975
1085
            }
976
1086
            av_log(av_log_obj, AV_LOG_INFO, ")");
977
1087
        }
1007
1117
    const AVClass *class = *(AVClass **)s;
1008
1118
    const AVOption *opt = NULL;
1009
1119
    while ((opt = av_opt_next(s, opt)) != NULL) {
 
1120
        void *dst = ((uint8_t*)s) + opt->offset;
1010
1121
#if FF_API_OLD_AVOPTIONS
1011
1122
        if ((opt->flags & mask) != flags)
1012
1123
            continue;
1019
1130
            case AV_OPT_TYPE_INT:
1020
1131
            case AV_OPT_TYPE_INT64:
1021
1132
            case AV_OPT_TYPE_DURATION:
1022
 
                av_opt_set_int(s, opt->name, opt->default_val.i64, 0);
 
1133
            case AV_OPT_TYPE_CHANNEL_LAYOUT:
 
1134
                write_number(s, opt, dst, 1, 1, opt->default_val.i64);
1023
1135
            break;
1024
1136
            case AV_OPT_TYPE_DOUBLE:
1025
1137
            case AV_OPT_TYPE_FLOAT: {
1026
1138
                double val;
1027
1139
                val = opt->default_val.dbl;
1028
 
                av_opt_set_double(s, opt->name, val, 0);
 
1140
                write_number(s, opt, dst, val, 1, 1);
1029
1141
            }
1030
1142
            break;
1031
1143
            case AV_OPT_TYPE_RATIONAL: {
1032
1144
                AVRational val;
1033
1145
                val = av_d2q(opt->default_val.dbl, INT_MAX);
1034
 
                av_opt_set_q(s, opt->name, val, 0);
 
1146
                write_number(s, opt, dst, 1, val.den, val.num);
1035
1147
            }
1036
1148
            break;
1037
1149
            case AV_OPT_TYPE_COLOR:
 
1150
                set_string_color(s, opt, opt->default_val.str, dst);
 
1151
                break;
1038
1152
            case AV_OPT_TYPE_STRING:
 
1153
                set_string(s, opt, opt->default_val.str, dst);
 
1154
                break;
1039
1155
            case AV_OPT_TYPE_IMAGE_SIZE:
 
1156
                set_string_image_size(s, opt, opt->default_val.str, dst);
 
1157
                break;
1040
1158
            case AV_OPT_TYPE_VIDEO_RATE:
1041
 
                av_opt_set(s, opt->name, opt->default_val.str, 0);
 
1159
                set_string_video_rate(s, opt, opt->default_val.str, dst);
1042
1160
                break;
1043
1161
            case AV_OPT_TYPE_PIXEL_FMT:
1044
 
#if LIBAVUTIL_VERSION_MAJOR < 53
 
1162
#if LIBAVUTIL_VERSION_MAJOR < 54
1045
1163
                if (class->version && class->version < AV_VERSION_INT(52, 10, 100))
1046
1164
                    av_opt_set(s, opt->name, opt->default_val.str, 0);
1047
1165
                else
1048
1166
#endif
1049
 
                    av_opt_set_pixel_fmt(s, opt->name, opt->default_val.i64, 0);
 
1167
                    write_number(s, opt, dst, 1, 1, opt->default_val.i64);
1050
1168
                break;
1051
1169
            case AV_OPT_TYPE_SAMPLE_FMT:
1052
 
#if LIBAVUTIL_VERSION_MAJOR < 53
 
1170
#if LIBAVUTIL_VERSION_MAJOR < 54
1053
1171
                if (class->version && class->version < AV_VERSION_INT(52, 10, 100))
1054
1172
                    av_opt_set(s, opt->name, opt->default_val.str, 0);
1055
1173
                else
1056
1174
#endif
1057
 
                    av_opt_set_sample_fmt(s, opt->name, opt->default_val.i64, 0);
 
1175
                    write_number(s, opt, dst, 1, 1, opt->default_val.i64);
1058
1176
                break;
1059
1177
            case AV_OPT_TYPE_BINARY:
1060
1178
                /* Cannot set default for binary */
1395
1513
    case AV_OPT_TYPE_DOUBLE:
1396
1514
    case AV_OPT_TYPE_DURATION:
1397
1515
    case AV_OPT_TYPE_COLOR:
 
1516
    case AV_OPT_TYPE_CHANNEL_LAYOUT:
1398
1517
        break;
1399
1518
    case AV_OPT_TYPE_STRING:
1400
1519
        range->component_min = 0;
1462
1581
    enum AVSampleFormat sample_fmt;
1463
1582
    int64_t duration;
1464
1583
    uint8_t color[4];
 
1584
    int64_t channel_layout;
1465
1585
} TestContext;
1466
1586
 
1467
1587
#define OFFSET(x) offsetof(TestContext, x)
1480
1600
{"lame",     "set lame flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_LAME}, INT_MIN,  INT_MAX, 0, "flags" },
1481
1601
{"mu",       "set mu flag ",   0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_MU},   INT_MIN,  INT_MAX, 0, "flags" },
1482
1602
{"size",     "set size",       OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE,{0},             0,        0                   },
1483
 
{"pix_fmt",  "set pixfmt",     OFFSET(pix_fmt),  AV_OPT_TYPE_PIXEL_FMT, {.i64 = AV_PIX_FMT_NONE}, -1, AV_PIX_FMT_NB-1},
1484
 
{"sample_fmt", "set samplefmt", OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, {.i64 = AV_SAMPLE_FMT_NONE}, -1, AV_SAMPLE_FMT_NB-1},
 
1603
{"pix_fmt",  "set pixfmt",     OFFSET(pix_fmt),  AV_OPT_TYPE_PIXEL_FMT, {.i64 = AV_PIX_FMT_NONE}, -1, INT_MAX},
 
1604
{"sample_fmt", "set samplefmt", OFFSET(sample_fmt), AV_OPT_TYPE_SAMPLE_FMT, {.i64 = AV_SAMPLE_FMT_NONE}, -1, INT_MAX},
1485
1605
{"video_rate", "set videorate", OFFSET(video_rate), AV_OPT_TYPE_VIDEO_RATE,  {.str = "25"}, 0,     0                   },
1486
1606
{"duration", "set duration",   OFFSET(duration), AV_OPT_TYPE_DURATION, {.i64 = 0}, 0, INT64_MAX},
1487
1607
{"color", "set color",   OFFSET(color), AV_OPT_TYPE_COLOR, {.str = "pink"}, 0, 0},
 
1608
{"cl", "set channel layout", OFFSET(channel_layout), AV_OPT_TYPE_CHANNEL_LAYOUT, {.i64 = AV_CH_LAYOUT_HEXAGONAL}, 0, INT64_MAX},
1488
1609
{NULL},
1489
1610
};
1490
1611
 
1546
1667
            "color=blue",
1547
1668
            "color=0x223300",
1548
1669
            "color=0x42FF07AA",
 
1670
            "cl=stereo+downmix",
 
1671
            "cl=foo",
1549
1672
        };
1550
1673
 
1551
1674
        test_ctx.class = &test_class;
1559
1682
                av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
1560
1683
            printf("\n");
1561
1684
        }
1562
 
        av_freep(&test_ctx.string);
 
1685
        av_opt_free(&test_ctx);
1563
1686
    }
1564
1687
 
1565
1688
    printf("\nTesting av_opt_set_from_string()\n");
1580
1703
 
1581
1704
        test_ctx.class = &test_class;
1582
1705
        av_opt_set_defaults(&test_ctx);
1583
 
        test_ctx.string = av_strdup("default");
1584
1706
 
1585
1707
        av_log_set_level(AV_LOG_DEBUG);
1586
1708
 
1590
1712
                av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
1591
1713
            printf("\n");
1592
1714
        }
1593
 
        av_freep(&test_ctx.string);
 
1715
        av_opt_free(&test_ctx);
1594
1716
    }
1595
1717
 
1596
1718
    return 0;