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