git.sesse.net Git - ffmpeg/blob - libavfilter/parseutils.c

   1 /*
   2  * copyright (c) 2009 Stefano Sabatini
   3  * This file is part of FFmpeg.
   4  *
   5  * FFmpeg is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * FFmpeg is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with FFmpeg; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  18  */
  19
  20 /**
  21  * @file
  22  * parsing utils
  23  */
  24
  25 #include <strings.h>
  26 #include "libavutil/avutil.h"
  27 #include "libavutil/avstring.h"
  28 #include "libavutil/random_seed.h"
  29 #include "parseutils.h"
  30
  31 #define WHITESPACES " \n\t"
  32
  33 char *av_get_token(const char **buf, const char *term)
  34 {
  35     char *out = av_malloc(strlen(*buf) + 1);
  36     char *ret= out, *end= out;
  37     const char *p = *buf;
  38     if (!out) return NULL;
  39     p += strspn(p, WHITESPACES);
  40
  41     while(*p && !strspn(p, term)) {
  42         char c = *p++;
  43         if(c == '\\' && *p){
  44             *out++ = *p++;
  45             end= out;
  46         }else if(c == '\''){
  47             while(*p && *p != '\'')
  48                 *out++ = *p++;
  49             if(*p){
  50                 p++;
  51                 end= out;
  52             }
  53         }else{
  54             *out++ = c;
  55         }
  56     }
  57
  58     do{
  59         *out-- = 0;
  60     }while(out >= end && strspn(out, WHITESPACES));
  61
  62     *buf = p;
  63
  64     return ret;
  65 }
  66
  67 typedef struct {
  68     const char *name;            ///< a string representing the name of the color
  69     uint8_t     rgb_color[3];    ///< RGB values for the color
  70 } ColorEntry;
  71
  72 static ColorEntry color_table[] = {
  73     { "AliceBlue",            { 0xF0, 0xF8, 0xFF } },
  74     { "AntiqueWhite",         { 0xFA, 0xEB, 0xD7 } },
  75     { "Aqua",                 { 0x00, 0xFF, 0xFF } },
  76     { "Aquamarine",           { 0x7F, 0xFF, 0xD4 } },
  77     { "Azure",                { 0xF0, 0xFF, 0xFF } },
  78     { "Beige",                { 0xF5, 0xF5, 0xDC } },
  79     { "Bisque",               { 0xFF, 0xE4, 0xC4 } },
  80     { "Black",                { 0x00, 0x00, 0x00 } },
  81     { "BlanchedAlmond",       { 0xFF, 0xEB, 0xCD } },
  82     { "Blue",                 { 0x00, 0x00, 0xFF } },
  83     { "BlueViolet",           { 0x8A, 0x2B, 0xE2 } },
  84     { "Brown",                { 0xA5, 0x2A, 0x2A } },
  85     { "BurlyWood",            { 0xDE, 0xB8, 0x87 } },
  86     { "CadetBlue",            { 0x5F, 0x9E, 0xA0 } },
  87     { "Chartreuse",           { 0x7F, 0xFF, 0x00 } },
  88     { "Chocolate",            { 0xD2, 0x69, 0x1E } },
  89     { "Coral",                { 0xFF, 0x7F, 0x50 } },
  90     { "CornflowerBlue",       { 0x64, 0x95, 0xED } },
  91     { "Cornsilk",             { 0xFF, 0xF8, 0xDC } },
  92     { "Crimson",              { 0xDC, 0x14, 0x3C } },
  93     { "Cyan",                 { 0x00, 0xFF, 0xFF } },
  94     { "DarkBlue",             { 0x00, 0x00, 0x8B } },
  95     { "DarkCyan",             { 0x00, 0x8B, 0x8B } },
  96     { "DarkGoldenRod",        { 0xB8, 0x86, 0x0B } },
  97     { "DarkGray",             { 0xA9, 0xA9, 0xA9 } },
  98     { "DarkGreen",            { 0x00, 0x64, 0x00 } },
  99     { "DarkKhaki",            { 0xBD, 0xB7, 0x6B } },
 100     { "DarkMagenta",          { 0x8B, 0x00, 0x8B } },
 101     { "DarkOliveGreen",       { 0x55, 0x6B, 0x2F } },
 102     { "Darkorange",           { 0xFF, 0x8C, 0x00 } },
 103     { "DarkOrchid",           { 0x99, 0x32, 0xCC } },
 104     { "DarkRed",              { 0x8B, 0x00, 0x00 } },
 105     { "DarkSalmon",           { 0xE9, 0x96, 0x7A } },
 106     { "DarkSeaGreen",         { 0x8F, 0xBC, 0x8F } },
 107     { "DarkSlateBlue",        { 0x48, 0x3D, 0x8B } },
 108     { "DarkSlateGray",        { 0x2F, 0x4F, 0x4F } },
 109     { "DarkTurquoise",        { 0x00, 0xCE, 0xD1 } },
 110     { "DarkViolet",           { 0x94, 0x00, 0xD3 } },
 111     { "DeepPink",             { 0xFF, 0x14, 0x93 } },
 112     { "DeepSkyBlue",          { 0x00, 0xBF, 0xFF } },
 113     { "DimGray",              { 0x69, 0x69, 0x69 } },
 114     { "DodgerBlue",           { 0x1E, 0x90, 0xFF } },
 115     { "FireBrick",            { 0xB2, 0x22, 0x22 } },
 116     { "FloralWhite",          { 0xFF, 0xFA, 0xF0 } },
 117     { "ForestGreen",          { 0x22, 0x8B, 0x22 } },
 118     { "Fuchsia",              { 0xFF, 0x00, 0xFF } },
 119     { "Gainsboro",            { 0xDC, 0xDC, 0xDC } },
 120     { "GhostWhite",           { 0xF8, 0xF8, 0xFF } },
 121     { "Gold",                 { 0xFF, 0xD7, 0x00 } },
 122     { "GoldenRod",            { 0xDA, 0xA5, 0x20 } },
 123     { "Gray",                 { 0x80, 0x80, 0x80 } },
 124     { "Green",                { 0x00, 0x80, 0x00 } },
 125     { "GreenYellow",          { 0xAD, 0xFF, 0x2F } },
 126     { "HoneyDew",             { 0xF0, 0xFF, 0xF0 } },
 127     { "HotPink",              { 0xFF, 0x69, 0xB4 } },
 128     { "IndianRed",            { 0xCD, 0x5C, 0x5C } },
 129     { "Indigo",               { 0x4B, 0x00, 0x82 } },
 130     { "Ivory",                { 0xFF, 0xFF, 0xF0 } },
 131     { "Khaki",                { 0xF0, 0xE6, 0x8C } },
 132     { "Lavender",             { 0xE6, 0xE6, 0xFA } },
 133     { "LavenderBlush",        { 0xFF, 0xF0, 0xF5 } },
 134     { "LawnGreen",            { 0x7C, 0xFC, 0x00 } },
 135     { "LemonChiffon",         { 0xFF, 0xFA, 0xCD } },
 136     { "LightBlue",            { 0xAD, 0xD8, 0xE6 } },
 137     { "LightCoral",           { 0xF0, 0x80, 0x80 } },
 138     { "LightCyan",            { 0xE0, 0xFF, 0xFF } },
 139     { "LightGoldenRodYellow", { 0xFA, 0xFA, 0xD2 } },
 140     { "LightGrey",            { 0xD3, 0xD3, 0xD3 } },
 141     { "LightGreen",           { 0x90, 0xEE, 0x90 } },
 142     { "LightPink",            { 0xFF, 0xB6, 0xC1 } },
 143     { "LightSalmon",          { 0xFF, 0xA0, 0x7A } },
 144     { "LightSeaGreen",        { 0x20, 0xB2, 0xAA } },
 145     { "LightSkyBlue",         { 0x87, 0xCE, 0xFA } },
 146     { "LightSlateGray",       { 0x77, 0x88, 0x99 } },
 147     { "LightSteelBlue",       { 0xB0, 0xC4, 0xDE } },
 148     { "LightYellow",          { 0xFF, 0xFF, 0xE0 } },
 149     { "Lime",                 { 0x00, 0xFF, 0x00 } },
 150     { "LimeGreen",            { 0x32, 0xCD, 0x32 } },
 151     { "Linen",                { 0xFA, 0xF0, 0xE6 } },
 152     { "Magenta",              { 0xFF, 0x00, 0xFF } },
 153     { "Maroon",               { 0x80, 0x00, 0x00 } },
 154     { "MediumAquaMarine",     { 0x66, 0xCD, 0xAA } },
 155     { "MediumBlue",           { 0x00, 0x00, 0xCD } },
 156     { "MediumOrchid",         { 0xBA, 0x55, 0xD3 } },
 157     { "MediumPurple",         { 0x93, 0x70, 0xD8 } },
 158     { "MediumSeaGreen",       { 0x3C, 0xB3, 0x71 } },
 159     { "MediumSlateBlue",      { 0x7B, 0x68, 0xEE } },
 160     { "MediumSpringGreen",    { 0x00, 0xFA, 0x9A } },
 161     { "MediumTurquoise",      { 0x48, 0xD1, 0xCC } },
 162     { "MediumVioletRed",      { 0xC7, 0x15, 0x85 } },
 163     { "MidnightBlue",         { 0x19, 0x19, 0x70 } },
 164     { "MintCream",            { 0xF5, 0xFF, 0xFA } },
 165     { "MistyRose",            { 0xFF, 0xE4, 0xE1 } },
 166     { "Moccasin",             { 0xFF, 0xE4, 0xB5 } },
 167     { "NavajoWhite",          { 0xFF, 0xDE, 0xAD } },
 168     { "Navy",                 { 0x00, 0x00, 0x80 } },
 169     { "OldLace",              { 0xFD, 0xF5, 0xE6 } },
 170     { "Olive",                { 0x80, 0x80, 0x00 } },
 171     { "OliveDrab",            { 0x6B, 0x8E, 0x23 } },
 172     { "Orange",               { 0xFF, 0xA5, 0x00 } },
 173     { "OrangeRed",            { 0xFF, 0x45, 0x00 } },
 174     { "Orchid",               { 0xDA, 0x70, 0xD6 } },
 175     { "PaleGoldenRod",        { 0xEE, 0xE8, 0xAA } },
 176     { "PaleGreen",            { 0x98, 0xFB, 0x98 } },
 177     { "PaleTurquoise",        { 0xAF, 0xEE, 0xEE } },
 178     { "PaleVioletRed",        { 0xD8, 0x70, 0x93 } },
 179     { "PapayaWhip",           { 0xFF, 0xEF, 0xD5 } },
 180     { "PeachPuff",            { 0xFF, 0xDA, 0xB9 } },
 181     { "Peru",                 { 0xCD, 0x85, 0x3F } },
 182     { "Pink",                 { 0xFF, 0xC0, 0xCB } },
 183     { "Plum",                 { 0xDD, 0xA0, 0xDD } },
 184     { "PowderBlue",           { 0xB0, 0xE0, 0xE6 } },
 185     { "Purple",               { 0x80, 0x00, 0x80 } },
 186     { "Red",                  { 0xFF, 0x00, 0x00 } },
 187     { "RosyBrown",            { 0xBC, 0x8F, 0x8F } },
 188     { "RoyalBlue",            { 0x41, 0x69, 0xE1 } },
 189     { "SaddleBrown",          { 0x8B, 0x45, 0x13 } },
 190     { "Salmon",               { 0xFA, 0x80, 0x72 } },
 191     { "SandyBrown",           { 0xF4, 0xA4, 0x60 } },
 192     { "SeaGreen",             { 0x2E, 0x8B, 0x57 } },
 193     { "SeaShell",             { 0xFF, 0xF5, 0xEE } },
 194     { "Sienna",               { 0xA0, 0x52, 0x2D } },
 195     { "Silver",               { 0xC0, 0xC0, 0xC0 } },
 196     { "SkyBlue",              { 0x87, 0xCE, 0xEB } },
 197     { "SlateBlue",            { 0x6A, 0x5A, 0xCD } },
 198     { "SlateGray",            { 0x70, 0x80, 0x90 } },
 199     { "Snow",                 { 0xFF, 0xFA, 0xFA } },
 200     { "SpringGreen",          { 0x00, 0xFF, 0x7F } },
 201     { "SteelBlue",            { 0x46, 0x82, 0xB4 } },
 202     { "Tan",                  { 0xD2, 0xB4, 0x8C } },
 203     { "Teal",                 { 0x00, 0x80, 0x80 } },
 204     { "Thistle",              { 0xD8, 0xBF, 0xD8 } },
 205     { "Tomato",               { 0xFF, 0x63, 0x47 } },
 206     { "Turquoise",            { 0x40, 0xE0, 0xD0 } },
 207     { "Violet",               { 0xEE, 0x82, 0xEE } },
 208     { "Wheat",                { 0xF5, 0xDE, 0xB3 } },
 209     { "White",                { 0xFF, 0xFF, 0xFF } },
 210     { "WhiteSmoke",           { 0xF5, 0xF5, 0xF5 } },
 211     { "Yellow",               { 0xFF, 0xFF, 0x00 } },
 212     { "YellowGreen",          { 0x9A, 0xCD, 0x32 } },
 213 };
 214
 215 static int color_table_compare(const void *lhs, const void *rhs)
 216 {
 217     return strcasecmp(lhs, ((const ColorEntry *)rhs)->name);
 218 }
 219
 220 #define ALPHA_SEP '@'
 221
 222 int av_parse_color(uint8_t *rgba_color, const char *color_string, void *log_ctx)
 223 {
 224     char *tail, color_string2[128];
 225     const ColorEntry *entry;
 226     av_strlcpy(color_string2, color_string, sizeof(color_string2));
 227     if ((tail = strchr(color_string2, ALPHA_SEP)))
 228         *tail++ = 0;
 229     rgba_color[3] = 255;
 230
 231     if (!strcasecmp(color_string2, "random") || !strcasecmp(color_string2, "bikeshed")) {
 232         int rgba = av_get_random_seed();
 233         rgba_color[0] = rgba >> 24;
 234         rgba_color[1] = rgba >> 16;
 235         rgba_color[2] = rgba >> 8;
 236         rgba_color[3] = rgba;
 237     } else if (!strncmp(color_string2, "0x", 2)) {
 238         char *tail;
 239         int len = strlen(color_string2);
 240         unsigned int rgba = strtoul(color_string2, &tail, 16);
 241
 242         if (*tail || (len != 8 && len != 10)) {
 243             av_log(log_ctx, AV_LOG_ERROR, "Invalid 0xRRGGBB[AA] color string: '%s'\n", color_string2);
 244             return AVERROR(EINVAL);
 245         }
 246         if (len == 10) {
 247             rgba_color[3] = rgba;
 248             rgba >>= 8;
 249         }
 250         rgba_color[0] = rgba >> 16;
 251         rgba_color[1] = rgba >> 8;
 252         rgba_color[2] = rgba;
 253     } else {
 254         entry = bsearch(color_string2,
 255                         color_table,
 256                         FF_ARRAY_ELEMS(color_table),
 257                         sizeof(ColorEntry),
 258                         color_table_compare);
 259         if (!entry) {
 260             av_log(log_ctx, AV_LOG_ERROR, "Cannot find color '%s'\n", color_string2);
 261             return AVERROR(EINVAL);
 262         }
 263         memcpy(rgba_color, entry->rgb_color, 3);
 264     }
 265
 266     if (tail) {
 267         unsigned long int alpha;
 268         const char *alpha_string = tail;
 269         if (!strncmp(alpha_string, "0x", 2)) {
 270             alpha = strtoul(alpha_string, &tail, 16);
 271         } else {
 272             alpha = strtoul(alpha_string, &tail, 10);
 273             if (*tail) {
 274                 double d = strtod(alpha_string, &tail);
 275                 alpha = d * 255;
 276             }
 277         }
 278
 279         if (tail == alpha_string || *tail || alpha > 255) {
 280             av_log(log_ctx, AV_LOG_ERROR, "Invalid alpha value specifier '%s' in '%s'\n",
 281                    alpha_string, color_string);
 282             return AVERROR(EINVAL);
 283         }
 284         rgba_color[3] = alpha;
 285     }
 286
 287     return 0;
 288 }
 289
 290 /**
 291  * Store the value in the field in ctx that is named like key.
 292  * ctx must be an AVClass context, storing is done using AVOptions.
 293  *
 294  * @param buf the string to parse, buf will be updated to point at the
 295  * separator just after the parsed key/value pair
 296  * @param key_val_sep a 0-terminated list of characters used to
 297  * separate key from value
 298  * @param pairs_sep a 0-terminated list of characters used to separate
 299  * two pairs from each other
 300  * @return 0 if the key/value pair has been successfully parsed and
 301  * set, or a negative value corresponding to an AVERROR code in case
 302  * of error:
 303  * AVERROR(EINVAL) if the key/value pair cannot be parsed,
 304  * the error code issued by av_set_string3() if the key/value pair
 305  * cannot be set
 306  */
 307 static int parse_key_value_pair(void *ctx, const char **buf,
 308                                 const char *key_val_sep, const char *pairs_sep)
 309 {
 310     char *key = av_get_token(buf, key_val_sep);
 311     char *val;
 312     int ret;
 313
 314     if (*key && strspn(*buf, key_val_sep)) {
 315         (*buf)++;
 316         val = av_get_token(buf, pairs_sep);
 317     } else {
 318         av_log(ctx, AV_LOG_ERROR, "Missing key or no key/value separator found after key '%s'\n", key);
 319         av_free(key);
 320         return AVERROR(EINVAL);
 321     }
 322
 323     av_log(ctx, AV_LOG_DEBUG, "Setting value '%s' for key '%s'\n", val, key);
 324
 325     ret = av_set_string3(ctx, key, val, 1, NULL);
 326     if (ret == AVERROR(ENOENT))
 327         av_log(ctx, AV_LOG_ERROR, "Key '%s' not found.\n", key);
 328
 329     av_free(key);
 330     av_free(val);
 331     return ret;
 332 }
 333
 334 int av_set_options_string(void *ctx, const char *opts,
 335                           const char *key_val_sep, const char *pairs_sep)
 336 {
 337     int ret, count = 0;
 338
 339     while (*opts) {
 340         if ((ret = parse_key_value_pair(ctx, &opts, key_val_sep, pairs_sep)) < 0)
 341             return ret;
 342         count++;
 343
 344         if (*opts)
 345             opts++;
 346     }
 347
 348     return count;
 349 }
 350
 351 #ifdef TEST
 352
 353 #undef printf
 354
 355 typedef struct TestContext
 356 {
 357     const AVClass *class;
 358     int num;
 359     int toggle;
 360     char *string;
 361     int flags;
 362     AVRational rational;
 363 } TestContext;
 364
 365 #define OFFSET(x) offsetof(TestContext, x)
 366
 367 #define TEST_FLAG_COOL 01
 368 #define TEST_FLAG_LAME 02
 369 #define TEST_FLAG_MU   04
 370
 371 static const AVOption test_options[]= {
 372 {"num",      "set num",        OFFSET(num),      FF_OPT_TYPE_INT,      0,              0,        100                 },
 373 {"toggle",   "set toggle",     OFFSET(toggle),   FF_OPT_TYPE_INT,      0,              0,        1                   },
 374 {"rational", "set rational",   OFFSET(rational), FF_OPT_TYPE_RATIONAL, 0,              0,        10                  },
 375 {"string",   "set string",     OFFSET(string),   FF_OPT_TYPE_STRING,   0,              CHAR_MIN, CHAR_MAX            },
 376 {"flags",    "set flags",      OFFSET(flags),    FF_OPT_TYPE_FLAGS,    0,              0,        INT_MAX, 0, "flags" },
 377 {"cool",     "set cool flag ", 0,                FF_OPT_TYPE_CONST,    TEST_FLAG_COOL, INT_MIN,  INT_MAX, 0, "flags" },
 378 {"lame",     "set lame flag ", 0,                FF_OPT_TYPE_CONST,    TEST_FLAG_LAME, INT_MIN,  INT_MAX, 0, "flags" },
 379 {"mu",       "set mu flag ",   0,                FF_OPT_TYPE_CONST,    TEST_FLAG_MU,   INT_MIN,  INT_MAX, 0, "flags" },
 380 {NULL},
 381 };
 382
 383 static const char *test_get_name(void *ctx)
 384 {
 385     return "test";
 386 }
 387
 388 static const AVClass test_class = {
 389     "TestContext",
 390     test_get_name,
 391     test_options
 392 };
 393
 394 int main(void)
 395 {
 396     int i;
 397
 398     const char *strings[] = {
 399         "''",
 400         "",
 401         ":",
 402         "\\",
 403         "'",
 404         "    ''    :",
 405         "    ''  ''  :",
 406         "foo   '' :",
 407         "'foo'",
 408         "foo     ",
 409         "foo\\",
 410         "foo':  blah:blah",
 411         "foo\\:  blah:blah",
 412         "foo\'",
 413         "'foo :  '  :blahblah",
 414         "\\ :blah",
 415         "     foo",
 416         "      foo       ",
 417         "      foo     \\ ",
 418         "foo ':blah",
 419         " foo   bar    :   blahblah",
 420         "\\f\\o\\o",
 421         "'foo : \\ \\  '   : blahblah",
 422         "'\\fo\\o:': blahblah",
 423         "\\'fo\\o\\:':  foo  '  :blahblah"
 424     };
 425
 426     for (i=0; i < FF_ARRAY_ELEMS(strings); i++) {
 427         const char *p= strings[i];
 428         printf("|%s|", p);
 429         printf(" -> |%s|", av_get_token(&p, ":"));
 430         printf(" + |%s|\n", p);
 431     }
 432
 433     printf("\nTesting av_parse_color()\n");
 434     {
 435         uint8_t rgba[4];
 436         const char *color_names[] = {
 437             "bikeshed",
 438             "RaNdOm",
 439             "foo",
 440             "red",
 441             "Red ",
 442             "RED",
 443             "Violet",
 444             "Yellow",
 445             "Red",
 446             "0x000000",
 447             "0x0000000",
 448             "0xff000000",
 449             "0x3e34ff",
 450             "0x3e34ffaa",
 451             "0xffXXee",
 452             "0xfoobar",
 453             "0xffffeeeeeeee",
 454             "red@foo",
 455             "random@10",
 456             "0xff0000@1.0",
 457             "red@",
 458             "red@0xfff",
 459             "red@0xf",
 460             "red@2",
 461             "red@0.1",
 462             "red@-1",
 463             "red@0.5",
 464             "red@1.0",
 465             "red@256",
 466             "red@10foo",
 467             "red@-1.0",
 468             "red@-0.0",
 469         };
 470
 471         av_log_set_level(AV_LOG_DEBUG);
 472
 473         for (int i = 0;  i < FF_ARRAY_ELEMS(color_names); i++) {
 474             if (av_parse_color(rgba, color_names[i], NULL) >= 0)
 475                 printf("%s -> R(%d) G(%d) B(%d) A(%d)\n", color_names[i], rgba[0], rgba[1], rgba[2], rgba[3]);
 476         }
 477     }
 478
 479     printf("\nTesting av_set_options_string()\n");
 480     {
 481         TestContext test_ctx;
 482         const char *options[] = {
 483             "",
 484             ":",
 485             "=",
 486             "foo=:",
 487             ":=foo",
 488             "=foo",
 489             "foo=",
 490             "foo",
 491             "foo=val",
 492             "foo==val",
 493             "toggle=:",
 494             "string=:",
 495             "toggle=1 : foo",
 496             "toggle=100",
 497             "toggle==1",
 498             "flags=+mu-lame : num=42: toggle=0",
 499             "num=42 : string=blahblah",
 500             "rational=0 : rational=1/2 : rational=1/-1",
 501             "rational=-1/0",
 502         };
 503
 504         test_ctx.class = &test_class;
 505         av_opt_set_defaults2(&test_ctx, 0, 0);
 506         test_ctx.string = av_strdup("default");
 507
 508         av_log_set_level(AV_LOG_DEBUG);
 509
 510         for (i=0; i < FF_ARRAY_ELEMS(options); i++) {
 511             av_log(&test_ctx, AV_LOG_DEBUG, "Setting options string '%s'\n", options[i]);
 512             if (av_set_options_string(&test_ctx, options[i], "=", ":") < 0)
 513                 av_log(&test_ctx, AV_LOG_ERROR, "Error setting options string: '%s'\n", options[i]);
 514             printf("\n");
 515         }
 516     }
 517
 518     return 0;
 519 }
 520
 521 #endif