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

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 /**
  20  * @file
  21  * misc parsing utilities
  22  */
  23
  24 #include <time.h>
  25
  26 #include "avstring.h"
  27 #include "avutil.h"
  28 #include "eval.h"
  29 #include "log.h"
  30 #include "random_seed.h"
  31 #include "parseutils.h"
  32
  33 #undef time
  34
  35 #ifdef TEST
  36
  37 #define av_get_random_seed av_get_random_seed_deterministic
  38 static uint32_t av_get_random_seed_deterministic(void);
  39
  40 #define time(t) 1331972053
  41
  42 #endif
  43
  44 int av_parse_ratio(AVRational *q, const char *str, int max,
  45                    int log_offset, void *log_ctx)
  46 {
  47     char c;
  48     int ret;
  49     int64_t gcd;
  50
  51     if (sscanf(str, "%d:%d%c", &q->num, &q->den, &c) != 2) {
  52         double d;
  53         ret = av_expr_parse_and_eval(&d, str, NULL, NULL,
  54                                      NULL, NULL, NULL, NULL,
  55                                      NULL, log_offset, log_ctx);
  56         if (ret < 0)
  57             return ret;
  58         *q = av_d2q(d, max);
  59     }
  60
  61     gcd = av_gcd(FFABS(q->num), FFABS(q->den));
  62     if (gcd) {
  63         q->num /= gcd;
  64         q->den /= gcd;
  65     }
  66
  67     return 0;
  68 }
  69
  70 typedef struct {
  71     const char *abbr;
  72     int width, height;
  73 } VideoSizeAbbr;
  74
  75 typedef struct {
  76     const char *abbr;
  77     AVRational rate;
  78 } VideoRateAbbr;
  79
  80 static const VideoSizeAbbr video_size_abbrs[] = {
  81     { "ntsc",      720, 480 },
  82     { "pal",       720, 576 },
  83     { "qntsc",     352, 240 }, /* VCD compliant NTSC */
  84     { "qpal",      352, 288 }, /* VCD compliant PAL */
  85     { "sntsc",     640, 480 }, /* square pixel NTSC */
  86     { "spal",      768, 576 }, /* square pixel PAL */
  87     { "film",      352, 240 },
  88     { "ntsc-film", 352, 240 },
  89     { "sqcif",     128,  96 },
  90     { "qcif",      176, 144 },
  91     { "cif",       352, 288 },
  92     { "4cif",      704, 576 },
  93     { "16cif",    1408,1152 },
  94     { "qqvga",     160, 120 },
  95     { "qvga",      320, 240 },
  96     { "vga",       640, 480 },
  97     { "svga",      800, 600 },
  98     { "xga",      1024, 768 },
  99     { "uxga",     1600,1200 },
 100     { "qxga",     2048,1536 },
 101     { "sxga",     1280,1024 },
 102     { "qsxga",    2560,2048 },
 103     { "hsxga",    5120,4096 },
 104     { "wvga",      852, 480 },
 105     { "wxga",     1366, 768 },
 106     { "wsxga",    1600,1024 },
 107     { "wuxga",    1920,1200 },
 108     { "woxga",    2560,1600 },
 109     { "wqsxga",   3200,2048 },
 110     { "wquxga",   3840,2400 },
 111     { "whsxga",   6400,4096 },
 112     { "whuxga",   7680,4800 },
 113     { "cga",       320, 200 },
 114     { "ega",       640, 350 },
 115     { "hd480",     852, 480 },
 116     { "hd720",    1280, 720 },
 117     { "hd1080",   1920,1080 },
 118 };
 119
 120 static const VideoRateAbbr video_rate_abbrs[]= {
 121     { "ntsc",      { 30000, 1001 } },
 122     { "pal",       {    25,    1 } },
 123     { "qntsc",     { 30000, 1001 } }, /* VCD compliant NTSC */
 124     { "qpal",      {    25,    1 } }, /* VCD compliant PAL */
 125     { "sntsc",     { 30000, 1001 } }, /* square pixel NTSC */
 126     { "spal",      {    25,    1 } }, /* square pixel PAL */
 127     { "film",      {    24,    1 } },
 128     { "ntsc-film", { 24000, 1001 } },
 129 };
 130
 131 int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
 132 {
 133     int i;
 134     int n = FF_ARRAY_ELEMS(video_size_abbrs);
 135     const char *p;
 136     int width = 0, height = 0;
 137
 138     for (i = 0; i < n; i++) {
 139         if (!strcmp(video_size_abbrs[i].abbr, str)) {
 140             width  = video_size_abbrs[i].width;
 141             height = video_size_abbrs[i].height;
 142             break;
 143         }
 144     }
 145     if (i == n) {
 146         p = str;
 147         width = strtol(p, (void*)&p, 10);
 148         if (*p)
 149             p++;
 150         height = strtol(p, (void*)&p, 10);
 151     }
 152     if (width <= 0 || height <= 0)
 153         return AVERROR(EINVAL);
 154     *width_ptr  = width;
 155     *height_ptr = height;
 156     return 0;
 157 }
 158
 159 int av_parse_video_rate(AVRational *rate, const char *arg)
 160 {
 161     int i, ret;
 162     int n = FF_ARRAY_ELEMS(video_rate_abbrs);
 163
 164     /* First, we check our abbreviation table */
 165     for (i = 0; i < n; ++i)
 166         if (!strcmp(video_rate_abbrs[i].abbr, arg)) {
 167             *rate = video_rate_abbrs[i].rate;
 168             return 0;
 169         }
 170
 171     /* Then, we try to parse it as fraction */
 172     if ((ret = av_parse_ratio_quiet(rate, arg, 1001000)) < 0)
 173         return ret;
 174     if (rate->num <= 0 || rate->den <= 0)
 175         return AVERROR(EINVAL);
 176     return 0;
 177 }
 178
 179 typedef struct {
 180     const char *name;            ///< a string representing the name of the color
 181     uint8_t     rgb_color[3];    ///< RGB values for the color
 182 } ColorEntry;
 183
 184 static const ColorEntry color_table[] = {
 185     { "AliceBlue",            { 0xF0, 0xF8, 0xFF } },
 186     { "AntiqueWhite",         { 0xFA, 0xEB, 0xD7 } },
 187     { "Aqua",                 { 0x00, 0xFF, 0xFF } },
 188     { "Aquamarine",           { 0x7F, 0xFF, 0xD4 } },
 189     { "Azure",                { 0xF0, 0xFF, 0xFF } },
 190     { "Beige",                { 0xF5, 0xF5, 0xDC } },
 191     { "Bisque",               { 0xFF, 0xE4, 0xC4 } },
 192     { "Black",                { 0x00, 0x00, 0x00 } },
 193     { "BlanchedAlmond",       { 0xFF, 0xEB, 0xCD } },
 194     { "Blue",                 { 0x00, 0x00, 0xFF } },
 195     { "BlueViolet",           { 0x8A, 0x2B, 0xE2 } },
 196     { "Brown",                { 0xA5, 0x2A, 0x2A } },
 197     { "BurlyWood",            { 0xDE, 0xB8, 0x87 } },
 198     { "CadetBlue",            { 0x5F, 0x9E, 0xA0 } },
 199     { "Chartreuse",           { 0x7F, 0xFF, 0x00 } },
 200     { "Chocolate",            { 0xD2, 0x69, 0x1E } },
 201     { "Coral",                { 0xFF, 0x7F, 0x50 } },
 202     { "CornflowerBlue",       { 0x64, 0x95, 0xED } },
 203     { "Cornsilk",             { 0xFF, 0xF8, 0xDC } },
 204     { "Crimson",              { 0xDC, 0x14, 0x3C } },
 205     { "Cyan",                 { 0x00, 0xFF, 0xFF } },
 206     { "DarkBlue",             { 0x00, 0x00, 0x8B } },
 207     { "DarkCyan",             { 0x00, 0x8B, 0x8B } },
 208     { "DarkGoldenRod",        { 0xB8, 0x86, 0x0B } },
 209     { "DarkGray",             { 0xA9, 0xA9, 0xA9 } },
 210     { "DarkGreen",            { 0x00, 0x64, 0x00 } },
 211     { "DarkKhaki",            { 0xBD, 0xB7, 0x6B } },
 212     { "DarkMagenta",          { 0x8B, 0x00, 0x8B } },
 213     { "DarkOliveGreen",       { 0x55, 0x6B, 0x2F } },
 214     { "Darkorange",           { 0xFF, 0x8C, 0x00 } },
 215     { "DarkOrchid",           { 0x99, 0x32, 0xCC } },
 216     { "DarkRed",              { 0x8B, 0x00, 0x00 } },
 217     { "DarkSalmon",           { 0xE9, 0x96, 0x7A } },
 218     { "DarkSeaGreen",         { 0x8F, 0xBC, 0x8F } },
 219     { "DarkSlateBlue",        { 0x48, 0x3D, 0x8B } },
 220     { "DarkSlateGray",        { 0x2F, 0x4F, 0x4F } },
 221     { "DarkTurquoise",        { 0x00, 0xCE, 0xD1 } },
 222     { "DarkViolet",           { 0x94, 0x00, 0xD3 } },
 223     { "DeepPink",             { 0xFF, 0x14, 0x93 } },
 224     { "DeepSkyBlue",          { 0x00, 0xBF, 0xFF } },
 225     { "DimGray",              { 0x69, 0x69, 0x69 } },
 226     { "DodgerBlue",           { 0x1E, 0x90, 0xFF } },
 227     { "FireBrick",            { 0xB2, 0x22, 0x22 } },
 228     { "FloralWhite",          { 0xFF, 0xFA, 0xF0 } },
 229     { "ForestGreen",          { 0x22, 0x8B, 0x22 } },
 230     { "Fuchsia",              { 0xFF, 0x00, 0xFF } },
 231     { "Gainsboro",            { 0xDC, 0xDC, 0xDC } },
 232     { "GhostWhite",           { 0xF8, 0xF8, 0xFF } },
 233     { "Gold",                 { 0xFF, 0xD7, 0x00 } },
 234     { "GoldenRod",            { 0xDA, 0xA5, 0x20 } },
 235     { "Gray",                 { 0x80, 0x80, 0x80 } },
 236     { "Green",                { 0x00, 0x80, 0x00 } },
 237     { "GreenYellow",          { 0xAD, 0xFF, 0x2F } },
 238     { "HoneyDew",             { 0xF0, 0xFF, 0xF0 } },
 239     { "HotPink",              { 0xFF, 0x69, 0xB4 } },
 240     { "IndianRed",            { 0xCD, 0x5C, 0x5C } },
 241     { "Indigo",               { 0x4B, 0x00, 0x82 } },
 242     { "Ivory",                { 0xFF, 0xFF, 0xF0 } },
 243     { "Khaki",                { 0xF0, 0xE6, 0x8C } },
 244     { "Lavender",             { 0xE6, 0xE6, 0xFA } },
 245     { "LavenderBlush",        { 0xFF, 0xF0, 0xF5 } },
 246     { "LawnGreen",            { 0x7C, 0xFC, 0x00 } },
 247     { "LemonChiffon",         { 0xFF, 0xFA, 0xCD } },
 248     { "LightBlue",            { 0xAD, 0xD8, 0xE6 } },
 249     { "LightCoral",           { 0xF0, 0x80, 0x80 } },
 250     { "LightCyan",            { 0xE0, 0xFF, 0xFF } },
 251     { "LightGoldenRodYellow", { 0xFA, 0xFA, 0xD2 } },
 252     { "LightGrey",            { 0xD3, 0xD3, 0xD3 } },
 253     { "LightGreen",           { 0x90, 0xEE, 0x90 } },
 254     { "LightPink",            { 0xFF, 0xB6, 0xC1 } },
 255     { "LightSalmon",          { 0xFF, 0xA0, 0x7A } },
 256     { "LightSeaGreen",        { 0x20, 0xB2, 0xAA } },
 257     { "LightSkyBlue",         { 0x87, 0xCE, 0xFA } },
 258     { "LightSlateGray",       { 0x77, 0x88, 0x99 } },
 259     { "LightSteelBlue",       { 0xB0, 0xC4, 0xDE } },
 260     { "LightYellow",          { 0xFF, 0xFF, 0xE0 } },
 261     { "Lime",                 { 0x00, 0xFF, 0x00 } },
 262     { "LimeGreen",            { 0x32, 0xCD, 0x32 } },
 263     { "Linen",                { 0xFA, 0xF0, 0xE6 } },
 264     { "Magenta",              { 0xFF, 0x00, 0xFF } },
 265     { "Maroon",               { 0x80, 0x00, 0x00 } },
 266     { "MediumAquaMarine",     { 0x66, 0xCD, 0xAA } },
 267     { "MediumBlue",           { 0x00, 0x00, 0xCD } },
 268     { "MediumOrchid",         { 0xBA, 0x55, 0xD3 } },
 269     { "MediumPurple",         { 0x93, 0x70, 0xD8 } },
 270     { "MediumSeaGreen",       { 0x3C, 0xB3, 0x71 } },
 271     { "MediumSlateBlue",      { 0x7B, 0x68, 0xEE } },
 272     { "MediumSpringGreen",    { 0x00, 0xFA, 0x9A } },
 273     { "MediumTurquoise",      { 0x48, 0xD1, 0xCC } },
 274     { "MediumVioletRed",      { 0xC7, 0x15, 0x85 } },
 275     { "MidnightBlue",         { 0x19, 0x19, 0x70 } },
 276     { "MintCream",            { 0xF5, 0xFF, 0xFA } },
 277     { "MistyRose",            { 0xFF, 0xE4, 0xE1 } },
 278     { "Moccasin",             { 0xFF, 0xE4, 0xB5 } },
 279     { "NavajoWhite",          { 0xFF, 0xDE, 0xAD } },
 280     { "Navy",                 { 0x00, 0x00, 0x80 } },
 281     { "OldLace",              { 0xFD, 0xF5, 0xE6 } },
 282     { "Olive",                { 0x80, 0x80, 0x00 } },
 283     { "OliveDrab",            { 0x6B, 0x8E, 0x23 } },
 284     { "Orange",               { 0xFF, 0xA5, 0x00 } },
 285     { "OrangeRed",            { 0xFF, 0x45, 0x00 } },
 286     { "Orchid",               { 0xDA, 0x70, 0xD6 } },
 287     { "PaleGoldenRod",        { 0xEE, 0xE8, 0xAA } },
 288     { "PaleGreen",            { 0x98, 0xFB, 0x98 } },
 289     { "PaleTurquoise",        { 0xAF, 0xEE, 0xEE } },
 290     { "PaleVioletRed",        { 0xD8, 0x70, 0x93 } },
 291     { "PapayaWhip",           { 0xFF, 0xEF, 0xD5 } },
 292     { "PeachPuff",            { 0xFF, 0xDA, 0xB9 } },
 293     { "Peru",                 { 0xCD, 0x85, 0x3F } },
 294     { "Pink",                 { 0xFF, 0xC0, 0xCB } },
 295     { "Plum",                 { 0xDD, 0xA0, 0xDD } },
 296     { "PowderBlue",           { 0xB0, 0xE0, 0xE6 } },
 297     { "Purple",               { 0x80, 0x00, 0x80 } },
 298     { "Red",                  { 0xFF, 0x00, 0x00 } },
 299     { "RosyBrown",            { 0xBC, 0x8F, 0x8F } },
 300     { "RoyalBlue",            { 0x41, 0x69, 0xE1 } },
 301     { "SaddleBrown",          { 0x8B, 0x45, 0x13 } },
 302     { "Salmon",               { 0xFA, 0x80, 0x72 } },
 303     { "SandyBrown",           { 0xF4, 0xA4, 0x60 } },
 304     { "SeaGreen",             { 0x2E, 0x8B, 0x57 } },
 305     { "SeaShell",             { 0xFF, 0xF5, 0xEE } },
 306     { "Sienna",               { 0xA0, 0x52, 0x2D } },
 307     { "Silver",               { 0xC0, 0xC0, 0xC0 } },
 308     { "SkyBlue",              { 0x87, 0xCE, 0xEB } },
 309     { "SlateBlue",            { 0x6A, 0x5A, 0xCD } },
 310     { "SlateGray",            { 0x70, 0x80, 0x90 } },
 311     { "Snow",                 { 0xFF, 0xFA, 0xFA } },
 312     { "SpringGreen",          { 0x00, 0xFF, 0x7F } },
 313     { "SteelBlue",            { 0x46, 0x82, 0xB4 } },
 314     { "Tan",                  { 0xD2, 0xB4, 0x8C } },
 315     { "Teal",                 { 0x00, 0x80, 0x80 } },
 316     { "Thistle",              { 0xD8, 0xBF, 0xD8 } },
 317     { "Tomato",               { 0xFF, 0x63, 0x47 } },
 318     { "Turquoise",            { 0x40, 0xE0, 0xD0 } },
 319     { "Violet",               { 0xEE, 0x82, 0xEE } },
 320     { "Wheat",                { 0xF5, 0xDE, 0xB3 } },
 321     { "White",                { 0xFF, 0xFF, 0xFF } },
 322     { "WhiteSmoke",           { 0xF5, 0xF5, 0xF5 } },
 323     { "Yellow",               { 0xFF, 0xFF, 0x00 } },
 324     { "YellowGreen",          { 0x9A, 0xCD, 0x32 } },
 325 };
 326
 327 static int color_table_compare(const void *lhs, const void *rhs)
 328 {
 329     return av_strcasecmp(lhs, ((const ColorEntry *)rhs)->name);
 330 }
 331
 332 #define ALPHA_SEP '@'
 333
 334 int av_parse_color(uint8_t *rgba_color, const char *color_string, int slen,
 335                    void *log_ctx)
 336 {
 337     char *tail, color_string2[128];
 338     const ColorEntry *entry;
 339     int len, hex_offset = 0;
 340
 341     if (color_string[0] == '#') {
 342         hex_offset = 1;
 343     } else if (!strncmp(color_string, "0x", 2))
 344         hex_offset = 2;
 345
 346     if (slen < 0)
 347         slen = strlen(color_string);
 348     av_strlcpy(color_string2, color_string + hex_offset,
 349                FFMIN(slen-hex_offset+1, sizeof(color_string2)));
 350     if ((tail = strchr(color_string2, ALPHA_SEP)))
 351         *tail++ = 0;
 352     len = strlen(color_string2);
 353     rgba_color[3] = 255;
 354
 355     if (!av_strcasecmp(color_string2, "random") || !av_strcasecmp(color_string2, "bikeshed")) {
 356         int rgba = av_get_random_seed();
 357         rgba_color[0] = rgba >> 24;
 358         rgba_color[1] = rgba >> 16;
 359         rgba_color[2] = rgba >> 8;
 360         rgba_color[3] = rgba;
 361     } else if (hex_offset ||
 362                strspn(color_string2, "0123456789ABCDEFabcdef") == len) {
 363         char *tail;
 364         unsigned int rgba = strtoul(color_string2, &tail, 16);
 365
 366         if (*tail || (len != 6 && len != 8)) {
 367             av_log(log_ctx, AV_LOG_ERROR, "Invalid 0xRRGGBB[AA] color string: '%s'\n", color_string2);
 368             return AVERROR(EINVAL);
 369         }
 370         if (len == 8) {
 371             rgba_color[3] = rgba;
 372             rgba >>= 8;
 373         }
 374         rgba_color[0] = rgba >> 16;
 375         rgba_color[1] = rgba >> 8;
 376         rgba_color[2] = rgba;
 377     } else {
 378         entry = bsearch(color_string2,
 379                         color_table,
 380                         FF_ARRAY_ELEMS(color_table),
 381                         sizeof(ColorEntry),
 382                         color_table_compare);
 383         if (!entry) {
 384             av_log(log_ctx, AV_LOG_ERROR, "Cannot find color '%s'\n", color_string2);
 385             return AVERROR(EINVAL);
 386         }
 387         memcpy(rgba_color, entry->rgb_color, 3);
 388     }
 389
 390     if (tail) {
 391         unsigned long int alpha;
 392         const char *alpha_string = tail;
 393         if (!strncmp(alpha_string, "0x", 2)) {
 394             alpha = strtoul(alpha_string, &tail, 16);
 395         } else {
 396             double norm_alpha = strtod(alpha_string, &tail);
 397             if (norm_alpha < 0.0 || norm_alpha > 1.0)
 398                 alpha = 256;
 399             else
 400                 alpha = 255 * norm_alpha;
 401         }
 402
 403         if (tail == alpha_string || *tail || alpha > 255) {
 404             av_log(log_ctx, AV_LOG_ERROR, "Invalid alpha value specifier '%s' in '%s'\n",
 405                    alpha_string, color_string);
 406             return AVERROR(EINVAL);
 407         }
 408         rgba_color[3] = alpha;
 409     }
 410
 411     return 0;
 412 }
 413
 414 /* get a positive number between n_min and n_max, for a maximum length
 415    of len_max. Return -1 if error. */
 416 static int date_get_num(const char **pp,
 417                         int n_min, int n_max, int len_max)
 418 {
 419     int i, val, c;
 420     const char *p;
 421
 422     p = *pp;
 423     val = 0;
 424     for(i = 0; i < len_max; i++) {
 425         c = *p;
 426         if (!isdigit(c))
 427             break;
 428         val = (val * 10) + c - '0';
 429         p++;
 430     }
 431     /* no number read ? */
 432     if (p == *pp)
 433         return -1;
 434     if (val < n_min || val > n_max)
 435         return -1;
 436     *pp = p;
 437     return val;
 438 }
 439
 440 /**
 441  * Parse the input string p according to the format string fmt and
 442  * store its results in the structure dt.
 443  * This implementation supports only a subset of the formats supported
 444  * by the standard strptime().
 445  *
 446  * @return a pointer to the first character not processed in this
 447  * function call, or NULL in case the function fails to match all of
 448  * the fmt string and therefore an error occurred
 449  */
 450 static const char *small_strptime(const char *p, const char *fmt, struct tm *dt)
 451 {
 452     int c, val;
 453
 454     for(;;) {
 455         c = *fmt++;
 456         if (c == '\0') {
 457             return p;
 458         } else if (c == '%') {
 459             c = *fmt++;
 460             switch(c) {
 461             case 'H':
 462                 val = date_get_num(&p, 0, 23, 2);
 463                 if (val == -1)
 464                     return NULL;
 465                 dt->tm_hour = val;
 466                 break;
 467             case 'M':
 468                 val = date_get_num(&p, 0, 59, 2);
 469                 if (val == -1)
 470                     return NULL;
 471                 dt->tm_min = val;
 472                 break;
 473             case 'S':
 474                 val = date_get_num(&p, 0, 59, 2);
 475                 if (val == -1)
 476                     return NULL;
 477                 dt->tm_sec = val;
 478                 break;
 479             case 'Y':
 480                 val = date_get_num(&p, 0, 9999, 4);
 481                 if (val == -1)
 482                     return NULL;
 483                 dt->tm_year = val - 1900;
 484                 break;
 485             case 'm':
 486                 val = date_get_num(&p, 1, 12, 2);
 487                 if (val == -1)
 488                     return NULL;
 489                 dt->tm_mon = val - 1;
 490                 break;
 491             case 'd':
 492                 val = date_get_num(&p, 1, 31, 2);
 493                 if (val == -1)
 494                     return NULL;
 495                 dt->tm_mday = val;
 496                 break;
 497             case '%':
 498                 goto match;
 499             default:
 500                 return NULL;
 501             }
 502         } else {
 503         match:
 504             if (c != *p)
 505                 return NULL;
 506             p++;
 507         }
 508     }
 509 }
 510
 511 time_t av_timegm(struct tm *tm)
 512 {
 513     time_t t;
 514
 515     int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
 516
 517     if (m < 3) {
 518         m += 12;
 519         y--;
 520     }
 521
 522     t = 86400 *
 523         (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + y / 400 - 719469);
 524
 525     t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
 526
 527     return t;
 528 }
 529
 530 int av_parse_time(int64_t *timeval, const char *timestr, int duration)
 531 {
 532     const char *p, *q;
 533     int64_t t;
 534     time_t now;
 535     struct tm dt = { 0 };
 536     int today = 0, negative = 0, microseconds = 0;
 537     int i;
 538     static const char * const date_fmt[] = {
 539         "%Y-%m-%d",
 540         "%Y%m%d",
 541     };
 542     static const char * const time_fmt[] = {
 543         "%H:%M:%S",
 544         "%H%M%S",
 545     };
 546
 547     p = timestr;
 548     q = NULL;
 549     *timeval = INT64_MIN;
 550     if (!duration) {
 551         now = time(0);
 552
 553         if (!av_strcasecmp(timestr, "now")) {
 554             *timeval = (int64_t) now * 1000000;
 555             return 0;
 556         }
 557
 558         /* parse the year-month-day part */
 559         for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
 560             q = small_strptime(p, date_fmt[i], &dt);
 561             if (q)
 562                 break;
 563         }
 564
 565         /* if the year-month-day part is missing, then take the
 566          * current year-month-day time */
 567         if (!q) {
 568             today = 1;
 569             q = p;
 570         }
 571         p = q;
 572
 573         if (*p == 'T' || *p == 't' || *p == ' ')
 574             p++;
 575
 576         /* parse the hour-minute-second part */
 577         for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
 578             q = small_strptime(p, time_fmt[i], &dt);
 579             if (q)
 580                 break;
 581         }
 582     } else {
 583         /* parse timestr as a duration */
 584         if (p[0] == '-') {
 585             negative = 1;
 586             ++p;
 587         }
 588         /* parse timestr as HH:MM:SS */
 589         q = small_strptime(p, time_fmt[0], &dt);
 590         if (!q) {
 591             /* parse timestr as S+ */
 592             dt.tm_sec = strtol(p, (void *)&q, 10);
 593             if (q == p) /* the parsing didn't succeed */
 594                 return AVERROR(EINVAL);
 595             dt.tm_min = 0;
 596             dt.tm_hour = 0;
 597         }
 598     }
 599
 600     /* Now we have all the fields that we can get */
 601     if (!q)
 602         return AVERROR(EINVAL);
 603
 604     /* parse the .m... part */
 605     if (*q == '.') {
 606         int n;
 607         q++;
 608         for (n = 100000; n >= 1; n /= 10, q++) {
 609             if (!isdigit(*q))
 610                 break;
 611             microseconds += n * (*q - '0');
 612         }
 613     }
 614
 615     if (duration) {
 616         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
 617     } else {
 618         int is_utc = *q == 'Z' || *q == 'z';
 619         q += is_utc;
 620         if (today) { /* fill in today's date */
 621             struct tm dt2 = is_utc ? *gmtime(&now) : *localtime(&now);
 622             dt2.tm_hour = dt.tm_hour;
 623             dt2.tm_min  = dt.tm_min;
 624             dt2.tm_sec  = dt.tm_sec;
 625             dt = dt2;
 626         }
 627         t = is_utc ? av_timegm(&dt) : mktime(&dt);
 628     }
 629
 630     /* Check that we are at the end of the string */
 631     if (*q)
 632         return AVERROR(EINVAL);
 633
 634     t *= 1000000;
 635     t += microseconds;
 636     *timeval = negative ? -t : t;
 637     return 0;
 638 }
 639
 640 int av_find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
 641 {
 642     const char *p;
 643     char tag[128], *q;
 644
 645     p = info;
 646     if (*p == '?')
 647         p++;
 648     for(;;) {
 649         q = tag;
 650         while (*p != '\0' && *p != '=' && *p != '&') {
 651             if ((q - tag) < sizeof(tag) - 1)
 652                 *q++ = *p;
 653             p++;
 654         }
 655         *q = '\0';
 656         q = arg;
 657         if (*p == '=') {
 658             p++;
 659             while (*p != '&' && *p != '\0') {
 660                 if ((q - arg) < arg_size - 1) {
 661                     if (*p == '+')
 662                         *q++ = ' ';
 663                     else
 664                         *q++ = *p;
 665                 }
 666                 p++;
 667             }
 668         }
 669         *q = '\0';
 670         if (!strcmp(tag, tag1))
 671             return 1;
 672         if (*p != '&')
 673             break;
 674         p++;
 675     }
 676     return 0;
 677 }
 678
 679 #ifdef TEST
 680
 681 static uint32_t random = MKTAG('L','A','V','U');
 682
 683 static uint32_t av_get_random_seed_deterministic(void)
 684 {
 685     return random = random * 1664525 + 1013904223;
 686 }
 687
 688 #undef printf
 689
 690 int main(void)
 691 {
 692     printf("Testing av_parse_video_rate()\n");
 693     {
 694         int i;
 695         const char *rates[] = {
 696             "-inf",
 697             "inf",
 698             "nan",
 699             "123/0",
 700             "-123 / 0",
 701             "",
 702             "/",
 703             " 123  /  321",
 704             "foo/foo",
 705             "foo/1",
 706             "1/foo",
 707             "0/0",
 708             "/0",
 709             "1/",
 710             "1",
 711             "0",
 712             "-123/123",
 713             "-foo",
 714             "123.23",
 715             ".23",
 716             "-.23",
 717             "-0.234",
 718             "-0.0000001",
 719             "  21332.2324   ",
 720             " -21332.2324   ",
 721         };
 722
 723         for (i = 0; i < FF_ARRAY_ELEMS(rates); i++) {
 724             int ret;
 725             AVRational q = (AVRational){0, 0};
 726             ret = av_parse_video_rate(&q, rates[i]);
 727             printf("'%s' -> %d/%d%s\n",
 728                    rates[i], q.num, q.den, ret ? " error" : "");
 729         }
 730     }
 731
 732     printf("\nTesting av_parse_color()\n");
 733     {
 734         int i;
 735         uint8_t rgba[4];
 736         const char *color_names[] = {
 737             "bikeshed",
 738             "RaNdOm",
 739             "foo",
 740             "red",
 741             "Red ",
 742             "RED",
 743             "Violet",
 744             "Yellow",
 745             "Red",
 746             "0x000000",
 747             "0x0000000",
 748             "0xff000000",
 749             "0x3e34ff",
 750             "0x3e34ffaa",
 751             "0xffXXee",
 752             "0xfoobar",
 753             "0xffffeeeeeeee",
 754             "#ff0000",
 755             "#ffXX00",
 756             "ff0000",
 757             "ffXX00",
 758             "red@foo",
 759             "random@10",
 760             "0xff0000@1.0",
 761             "red@",
 762             "red@0xfff",
 763             "red@0xf",
 764             "red@2",
 765             "red@0.1",
 766             "red@-1",
 767             "red@0.5",
 768             "red@1.0",
 769             "red@256",
 770             "red@10foo",
 771             "red@-1.0",
 772             "red@-0.0",
 773         };
 774
 775         av_log_set_level(AV_LOG_DEBUG);
 776
 777         for (i = 0;  i < FF_ARRAY_ELEMS(color_names); i++) {
 778             if (av_parse_color(rgba, color_names[i], -1, NULL) >= 0)
 779                 printf("%s -> R(%d) G(%d) B(%d) A(%d)\n", color_names[i], rgba[0], rgba[1], rgba[2], rgba[3]);
 780             else
 781                 printf("%s -> error\n", color_names[i]);
 782         }
 783     }
 784
 785     printf("\nTesting av_parse_time()\n");
 786     {
 787         int i;
 788         int64_t tv;
 789         time_t tvi;
 790         struct tm *tm;
 791         static char tzstr[] = "TZ=CET-1";
 792         const char *time_string[] = {
 793             "now",
 794             "12:35:46",
 795             "2000-12-20 0:02:47.5z",
 796             "2000-12-20T010247.6",
 797         };
 798         const char *duration_string[] = {
 799             "2:34:56.79",
 800             "-1:23:45.67",
 801             "42.1729",
 802             "-1729.42",
 803             "12:34",
 804         };
 805
 806         av_log_set_level(AV_LOG_DEBUG);
 807         putenv(tzstr);
 808         printf("(now is 2012-03-17 09:14:13 +0100, local time is UTC+1)\n");
 809         for (i = 0;  i < FF_ARRAY_ELEMS(time_string); i++) {
 810             printf("%-24s -> ", time_string[i]);
 811             if (av_parse_time(&tv, time_string[i], 0)) {
 812                 printf("error\n");
 813             } else {
 814                 tvi = tv / 1000000;
 815                 tm = gmtime(&tvi);
 816                 printf("%14"PRIi64".%06d = %04d-%02d-%02dT%02d:%02d:%02dZ\n",
 817                        tv / 1000000, (int)(tv % 1000000),
 818                        tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
 819                        tm->tm_hour, tm->tm_min, tm->tm_sec);
 820             }
 821         }
 822         for (i = 0;  i < FF_ARRAY_ELEMS(duration_string); i++) {
 823             printf("%-24s -> ", duration_string[i]);
 824             if (av_parse_time(&tv, duration_string[i], 1)) {
 825                 printf("error\n");
 826             } else {
 827                 printf("%+21"PRIi64"\n", tv);
 828             }
 829         }
 830     }
 831
 832     return 0;
 833 }
 834
 835 #endif /* TEST */