FFmpeg: libavutil/parseutils.c Source File

FFmpeg

[フレーム]

libavutil

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 */

19 /**

20 * @file

21 * misc parsing utilities

22 */

24 #include <time.h>

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"

34 #ifdef TEST

36 #define av_get_random_seed av_get_random_seed_deterministic

37 static uint32_t av_get_random_seed_deterministic(void);

39 #define time(t) 1331972053

41 #endif

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;

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 }

61 return 0;

62 }

64 typedef struct {

65 const char *abbr;

66 int width, height;

67 } VideoSizeAbbr;

69 typedef struct {

70 const char *abbr;

71 AVRational rate;

72 } VideoRateAbbr;

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月20日T010247.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 Sep 14 2014 18:56:17 for FFmpeg by doxygen 1.8.2