1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "media/formats/webm/webm_parser.h" 6 7 // This file contains code to parse WebM file elements. It was created 8 // from information in the Matroska spec. 9 // http://www.matroska.org/technical/specs/index.html 10 // This file contains code for encrypted WebM. Current WebM 11 // encrypted request for comments specification is here 12 // http://wiki.webmproject.org/encryption/webm-encryption-rfc 13 14 #include <iomanip> 15 16 #include "base/logging.h" 17 #include "base/numerics/safe_conversions.h" 18 #include "media/formats/webm/webm_constants.h" 19 20 namespace media { 21 22 enum ElementType { 23 UNKNOWN, 24 LIST, // Referred to as Master Element in the Matroska spec. 25 UINT, 26 FLOAT, 27 BINARY, 28 STRING, 29 SKIP, 30 }; 31 32 struct ElementIdInfo { 33 ElementType type_; 34 int id_; 35 }; 36 37 struct ListElementInfo { 38 int id_; 39 int level_; 40 const ElementIdInfo* id_info_; 41 int id_info_count_; 42 }; 43 44 // The following are tables indicating what IDs are valid sub-elements 45 // of particular elements. If an element is encountered that doesn't 46 // appear in the list, a parsing error is signalled. Some elements are 47 // marked as SKIP because they are valid, but we don't care about them 48 // right now. 49 static const ElementIdInfo kEBMLHeaderIds[] = { 50 {UINT, kWebMIdEBMLVersion}, 51 {UINT, kWebMIdEBMLReadVersion}, 52 {UINT, kWebMIdEBMLMaxIDLength}, 53 {UINT, kWebMIdEBMLMaxSizeLength}, 54 {STRING, kWebMIdDocType}, 55 {UINT, kWebMIdDocTypeVersion}, 56 {UINT, kWebMIdDocTypeReadVersion}, 57 }; 58 59 static const ElementIdInfo kSegmentIds[] = { 60 {LIST, kWebMIdSeekHead}, 61 {LIST, kWebMIdInfo}, 62 {LIST, kWebMIdCluster}, 63 {LIST, kWebMIdTracks}, 64 {LIST, kWebMIdCues}, 65 {LIST, kWebMIdAttachments}, 66 {LIST, kWebMIdChapters}, 67 {LIST, kWebMIdTags}, 68 }; 69 70 static const ElementIdInfo kSeekHeadIds[] = { 71 {LIST, kWebMIdSeek}, 72 }; 73 74 static const ElementIdInfo kSeekIds[] = { 75 {BINARY, kWebMIdSeekID}, 76 {UINT, kWebMIdSeekPosition}, 77 }; 78 79 static const ElementIdInfo kInfoIds[] = { 80 {BINARY, kWebMIdSegmentUID}, 81 {STRING, kWebMIdSegmentFilename}, 82 {BINARY, kWebMIdPrevUID}, 83 {STRING, kWebMIdPrevFilename}, 84 {BINARY, kWebMIdNextUID}, 85 {STRING, kWebMIdNextFilename}, 86 {BINARY, kWebMIdSegmentFamily}, 87 {LIST, kWebMIdChapterTranslate}, 88 {UINT, kWebMIdTimecodeScale}, 89 {FLOAT, kWebMIdDuration}, 90 {BINARY, kWebMIdDateUTC}, 91 {STRING, kWebMIdTitle}, 92 {STRING, kWebMIdMuxingApp}, 93 {STRING, kWebMIdWritingApp}, 94 }; 95 96 static const ElementIdInfo kChapterTranslateIds[] = { 97 {UINT, kWebMIdChapterTranslateEditionUID}, 98 {UINT, kWebMIdChapterTranslateCodec}, 99 {BINARY, kWebMIdChapterTranslateID}, 100 }; 101 102 static const ElementIdInfo kClusterIds[] = { 103 {BINARY, kWebMIdSimpleBlock}, 104 {UINT, kWebMIdTimecode}, 105 {LIST, kWebMIdSilentTracks}, 106 {UINT, kWebMIdPosition}, 107 {UINT, kWebMIdPrevSize}, 108 {LIST, kWebMIdBlockGroup}, 109 }; 110 111 static const ElementIdInfo kSilentTracksIds[] = { 112 {UINT, kWebMIdSilentTrackNumber}, 113 }; 114 115 static const ElementIdInfo kBlockGroupIds[] = { 116 {BINARY, kWebMIdBlock}, 117 {LIST, kWebMIdBlockAdditions}, 118 {UINT, kWebMIdBlockDuration}, 119 {UINT, kWebMIdReferencePriority}, 120 {BINARY, kWebMIdReferenceBlock}, 121 {BINARY, kWebMIdCodecState}, 122 {BINARY, kWebMIdDiscardPadding}, 123 {LIST, kWebMIdSlices}, 124 }; 125 126 static const ElementIdInfo kBlockAdditionsIds[] = { 127 {LIST, kWebMIdBlockMore}, 128 }; 129 130 static const ElementIdInfo kBlockMoreIds[] = { 131 {UINT, kWebMIdBlockAddID}, 132 {BINARY, kWebMIdBlockAdditional}, 133 }; 134 135 static const ElementIdInfo kSlicesIds[] = { 136 {LIST, kWebMIdTimeSlice}, 137 }; 138 139 static const ElementIdInfo kTimeSliceIds[] = { 140 {UINT, kWebMIdLaceNumber}, 141 }; 142 143 static const ElementIdInfo kTracksIds[] = { 144 {LIST, kWebMIdTrackEntry}, 145 }; 146 147 static const ElementIdInfo kTrackEntryIds[] = { 148 {UINT, kWebMIdTrackNumber}, 149 {BINARY, kWebMIdTrackUID}, 150 {UINT, kWebMIdTrackType}, 151 {UINT, kWebMIdFlagEnabled}, 152 {UINT, kWebMIdFlagDefault}, 153 {UINT, kWebMIdFlagForced}, 154 {UINT, kWebMIdFlagLacing}, 155 {UINT, kWebMIdMinCache}, 156 {UINT, kWebMIdMaxCache}, 157 {UINT, kWebMIdDefaultDuration}, 158 {FLOAT, kWebMIdTrackTimecodeScale}, 159 {UINT, kWebMIdMaxBlockAdditionId}, 160 {STRING, kWebMIdName}, 161 {STRING, kWebMIdLanguage}, 162 {STRING, kWebMIdCodecID}, 163 {BINARY, kWebMIdCodecPrivate}, 164 {STRING, kWebMIdCodecName}, 165 {UINT, kWebMIdAttachmentLink}, 166 {UINT, kWebMIdCodecDecodeAll}, 167 {UINT, kWebMIdTrackOverlay}, 168 {UINT, kWebMIdCodecDelay}, 169 {UINT, kWebMIdSeekPreRoll}, 170 {LIST, kWebMIdTrackTranslate}, 171 {LIST, kWebMIdVideo}, 172 {LIST, kWebMIdAudio}, 173 {LIST, kWebMIdTrackOperation}, 174 {LIST, kWebMIdContentEncodings}, 175 }; 176 177 static const ElementIdInfo kTrackTranslateIds[] = { 178 {UINT, kWebMIdTrackTranslateEditionUID}, 179 {UINT, kWebMIdTrackTranslateCodec}, 180 {BINARY, kWebMIdTrackTranslateTrackID}, 181 }; 182 183 static const ElementIdInfo kVideoIds[] = { 184 {UINT, kWebMIdFlagInterlaced}, 185 {UINT, kWebMIdStereoMode}, 186 {UINT, kWebMIdAlphaMode}, 187 {UINT, kWebMIdPixelWidth}, 188 {UINT, kWebMIdPixelHeight}, 189 {UINT, kWebMIdPixelCropBottom}, 190 {UINT, kWebMIdPixelCropTop}, 191 {UINT, kWebMIdPixelCropLeft}, 192 {UINT, kWebMIdPixelCropRight}, 193 {UINT, kWebMIdDisplayWidth}, 194 {UINT, kWebMIdDisplayHeight}, 195 {UINT, kWebMIdDisplayUnit}, 196 {UINT, kWebMIdAspectRatioType}, 197 {BINARY, kWebMIdColorSpace}, 198 {FLOAT, kWebMIdFrameRate}, 199 }; 200 201 static const ElementIdInfo kAudioIds[] = { 202 {FLOAT, kWebMIdSamplingFrequency}, 203 {FLOAT, kWebMIdOutputSamplingFrequency}, 204 {UINT, kWebMIdChannels}, 205 {UINT, kWebMIdBitDepth}, 206 }; 207 208 static const ElementIdInfo kTrackOperationIds[] = { 209 {LIST, kWebMIdTrackCombinePlanes}, 210 {LIST, kWebMIdJoinBlocks}, 211 }; 212 213 static const ElementIdInfo kTrackCombinePlanesIds[] = { 214 {LIST, kWebMIdTrackPlane}, 215 }; 216 217 static const ElementIdInfo kTrackPlaneIds[] = { 218 {UINT, kWebMIdTrackPlaneUID}, 219 {UINT, kWebMIdTrackPlaneType}, 220 }; 221 222 static const ElementIdInfo kJoinBlocksIds[] = { 223 {UINT, kWebMIdTrackJoinUID}, 224 }; 225 226 static const ElementIdInfo kContentEncodingsIds[] = { 227 {LIST, kWebMIdContentEncoding}, 228 }; 229 230 static const ElementIdInfo kContentEncodingIds[] = { 231 {UINT, kWebMIdContentEncodingOrder}, 232 {UINT, kWebMIdContentEncodingScope}, 233 {UINT, kWebMIdContentEncodingType}, 234 {LIST, kWebMIdContentCompression}, 235 {LIST, kWebMIdContentEncryption}, 236 }; 237 238 static const ElementIdInfo kContentCompressionIds[] = { 239 {UINT, kWebMIdContentCompAlgo}, 240 {BINARY, kWebMIdContentCompSettings}, 241 }; 242 243 static const ElementIdInfo kContentEncryptionIds[] = { 244 {LIST, kWebMIdContentEncAESSettings}, 245 {UINT, kWebMIdContentEncAlgo}, 246 {BINARY, kWebMIdContentEncKeyID}, 247 {BINARY, kWebMIdContentSignature}, 248 {BINARY, kWebMIdContentSigKeyID}, 249 {UINT, kWebMIdContentSigAlgo}, 250 {UINT, kWebMIdContentSigHashAlgo}, 251 }; 252 253 static const ElementIdInfo kContentEncAESSettingsIds[] = { 254 {UINT, kWebMIdAESSettingsCipherMode}, 255 }; 256 257 static const ElementIdInfo kCuesIds[] = { 258 {LIST, kWebMIdCuePoint}, 259 }; 260 261 static const ElementIdInfo kCuePointIds[] = { 262 {UINT, kWebMIdCueTime}, 263 {LIST, kWebMIdCueTrackPositions}, 264 }; 265 266 static const ElementIdInfo kCueTrackPositionsIds[] = { 267 {UINT, kWebMIdCueTrack}, 268 {UINT, kWebMIdCueClusterPosition}, 269 {UINT, kWebMIdCueBlockNumber}, 270 {UINT, kWebMIdCueCodecState}, 271 {LIST, kWebMIdCueReference}, 272 }; 273 274 static const ElementIdInfo kCueReferenceIds[] = { 275 {UINT, kWebMIdCueRefTime}, 276 }; 277 278 static const ElementIdInfo kAttachmentsIds[] = { 279 {LIST, kWebMIdAttachedFile}, 280 }; 281 282 static const ElementIdInfo kAttachedFileIds[] = { 283 {STRING, kWebMIdFileDescription}, 284 {STRING, kWebMIdFileName}, 285 {STRING, kWebMIdFileMimeType}, 286 {BINARY, kWebMIdFileData}, 287 {UINT, kWebMIdFileUID}, 288 }; 289 290 static const ElementIdInfo kChaptersIds[] = { 291 {LIST, kWebMIdEditionEntry}, 292 }; 293 294 static const ElementIdInfo kEditionEntryIds[] = { 295 {UINT, kWebMIdEditionUID}, 296 {UINT, kWebMIdEditionFlagHidden}, 297 {UINT, kWebMIdEditionFlagDefault}, 298 {UINT, kWebMIdEditionFlagOrdered}, 299 {LIST, kWebMIdChapterAtom}, 300 }; 301 302 static const ElementIdInfo kChapterAtomIds[] = { 303 {UINT, kWebMIdChapterUID}, 304 {UINT, kWebMIdChapterTimeStart}, 305 {UINT, kWebMIdChapterTimeEnd}, 306 {UINT, kWebMIdChapterFlagHidden}, 307 {UINT, kWebMIdChapterFlagEnabled}, 308 {BINARY, kWebMIdChapterSegmentUID}, 309 {UINT, kWebMIdChapterSegmentEditionUID}, 310 {UINT, kWebMIdChapterPhysicalEquiv}, 311 {LIST, kWebMIdChapterTrack}, 312 {LIST, kWebMIdChapterDisplay}, 313 {LIST, kWebMIdChapProcess}, 314 }; 315 316 static const ElementIdInfo kChapterTrackIds[] = { 317 {UINT, kWebMIdChapterTrackNumber}, 318 }; 319 320 static const ElementIdInfo kChapterDisplayIds[] = { 321 {STRING, kWebMIdChapString}, 322 {STRING, kWebMIdChapLanguage}, 323 {STRING, kWebMIdChapCountry}, 324 }; 325 326 static const ElementIdInfo kChapProcessIds[] = { 327 {UINT, kWebMIdChapProcessCodecID}, 328 {BINARY, kWebMIdChapProcessPrivate}, 329 {LIST, kWebMIdChapProcessCommand}, 330 }; 331 332 static const ElementIdInfo kChapProcessCommandIds[] = { 333 {UINT, kWebMIdChapProcessTime}, 334 {BINARY, kWebMIdChapProcessData}, 335 }; 336 337 static const ElementIdInfo kTagsIds[] = { 338 {LIST, kWebMIdTag}, 339 }; 340 341 static const ElementIdInfo kTagIds[] = { 342 {LIST, kWebMIdTargets}, 343 {LIST, kWebMIdSimpleTag}, 344 }; 345 346 static const ElementIdInfo kTargetsIds[] = { 347 {UINT, kWebMIdTargetTypeValue}, 348 {STRING, kWebMIdTargetType}, 349 {UINT, kWebMIdTagTrackUID}, 350 {UINT, kWebMIdTagEditionUID}, 351 {UINT, kWebMIdTagChapterUID}, 352 {UINT, kWebMIdTagAttachmentUID}, 353 }; 354 355 static const ElementIdInfo kSimpleTagIds[] = { 356 {STRING, kWebMIdTagName}, 357 {STRING, kWebMIdTagLanguage}, 358 {UINT, kWebMIdTagDefault}, 359 {STRING, kWebMIdTagString}, 360 {BINARY, kWebMIdTagBinary}, 361 }; 362 363 #define LIST_ELEMENT_INFO(id, level, id_info) \ 364 { (id), (level), (id_info), arraysize(id_info) } 365 366 static const ListElementInfo kListElementInfo[] = { 367 LIST_ELEMENT_INFO(kWebMIdCluster, 1, kClusterIds), 368 LIST_ELEMENT_INFO(kWebMIdEBMLHeader, 0, kEBMLHeaderIds), 369 LIST_ELEMENT_INFO(kWebMIdSegment, 0, kSegmentIds), 370 LIST_ELEMENT_INFO(kWebMIdSeekHead, 1, kSeekHeadIds), 371 LIST_ELEMENT_INFO(kWebMIdSeek, 2, kSeekIds), 372 LIST_ELEMENT_INFO(kWebMIdInfo, 1, kInfoIds), 373 LIST_ELEMENT_INFO(kWebMIdChapterTranslate, 2, kChapterTranslateIds), 374 LIST_ELEMENT_INFO(kWebMIdSilentTracks, 2, kSilentTracksIds), 375 LIST_ELEMENT_INFO(kWebMIdBlockGroup, 2, kBlockGroupIds), 376 LIST_ELEMENT_INFO(kWebMIdBlockAdditions, 3, kBlockAdditionsIds), 377 LIST_ELEMENT_INFO(kWebMIdBlockMore, 4, kBlockMoreIds), 378 LIST_ELEMENT_INFO(kWebMIdSlices, 3, kSlicesIds), 379 LIST_ELEMENT_INFO(kWebMIdTimeSlice, 4, kTimeSliceIds), 380 LIST_ELEMENT_INFO(kWebMIdTracks, 1, kTracksIds), 381 LIST_ELEMENT_INFO(kWebMIdTrackEntry, 2, kTrackEntryIds), 382 LIST_ELEMENT_INFO(kWebMIdTrackTranslate, 3, kTrackTranslateIds), 383 LIST_ELEMENT_INFO(kWebMIdVideo, 3, kVideoIds), 384 LIST_ELEMENT_INFO(kWebMIdAudio, 3, kAudioIds), 385 LIST_ELEMENT_INFO(kWebMIdTrackOperation, 3, kTrackOperationIds), 386 LIST_ELEMENT_INFO(kWebMIdTrackCombinePlanes, 4, kTrackCombinePlanesIds), 387 LIST_ELEMENT_INFO(kWebMIdTrackPlane, 5, kTrackPlaneIds), 388 LIST_ELEMENT_INFO(kWebMIdJoinBlocks, 4, kJoinBlocksIds), 389 LIST_ELEMENT_INFO(kWebMIdContentEncodings, 3, kContentEncodingsIds), 390 LIST_ELEMENT_INFO(kWebMIdContentEncoding, 4, kContentEncodingIds), 391 LIST_ELEMENT_INFO(kWebMIdContentCompression, 5, kContentCompressionIds), 392 LIST_ELEMENT_INFO(kWebMIdContentEncryption, 5, kContentEncryptionIds), 393 LIST_ELEMENT_INFO(kWebMIdContentEncAESSettings, 6, kContentEncAESSettingsIds), 394 LIST_ELEMENT_INFO(kWebMIdCues, 1, kCuesIds), 395 LIST_ELEMENT_INFO(kWebMIdCuePoint, 2, kCuePointIds), 396 LIST_ELEMENT_INFO(kWebMIdCueTrackPositions, 3, kCueTrackPositionsIds), 397 LIST_ELEMENT_INFO(kWebMIdCueReference, 4, kCueReferenceIds), 398 LIST_ELEMENT_INFO(kWebMIdAttachments, 1, kAttachmentsIds), 399 LIST_ELEMENT_INFO(kWebMIdAttachedFile, 2, kAttachedFileIds), 400 LIST_ELEMENT_INFO(kWebMIdChapters, 1, kChaptersIds), 401 LIST_ELEMENT_INFO(kWebMIdEditionEntry, 2, kEditionEntryIds), 402 LIST_ELEMENT_INFO(kWebMIdChapterAtom, 3, kChapterAtomIds), 403 LIST_ELEMENT_INFO(kWebMIdChapterTrack, 4, kChapterTrackIds), 404 LIST_ELEMENT_INFO(kWebMIdChapterDisplay, 4, kChapterDisplayIds), 405 LIST_ELEMENT_INFO(kWebMIdChapProcess, 4, kChapProcessIds), 406 LIST_ELEMENT_INFO(kWebMIdChapProcessCommand, 5, kChapProcessCommandIds), 407 LIST_ELEMENT_INFO(kWebMIdTags, 1, kTagsIds), 408 LIST_ELEMENT_INFO(kWebMIdTag, 2, kTagIds), 409 LIST_ELEMENT_INFO(kWebMIdTargets, 3, kTargetsIds), 410 LIST_ELEMENT_INFO(kWebMIdSimpleTag, 3, kSimpleTagIds), 411 }; 412 413 // Parses an element header id or size field. These fields are variable length 414 // encoded. The first byte indicates how many bytes the field occupies. 415 // |buf| - The buffer to parse. 416 // |size| - The number of bytes in |buf| 417 // |max_bytes| - The maximum number of bytes the field can be. ID fields 418 // set this to 4 & element size fields set this to 8. If the 419 // first byte indicates a larger field size than this it is a 420 // parser error. 421 // |mask_first_byte| - For element size fields the field length encoding bits 422 // need to be masked off. This parameter is true for 423 // element size fields and is false for ID field values. 424 // 425 // Returns: The number of bytes parsed on success. -1 on error. 426 static int ParseWebMElementHeaderField(const uint8* buf, int size, 427 int max_bytes, bool mask_first_byte, 428 int64* num) { 429 DCHECK(buf); 430 DCHECK(num); 431 432 if (size < 0) 433 return -1; 434 435 if (size == 0) 436 return 0; 437 438 int mask = 0x80; 439 uint8 ch = buf[0]; 440 int extra_bytes = -1; 441 bool all_ones = false; 442 for (int i = 0; i < max_bytes; ++i) { 443 if ((ch & mask) != 0) { 444 mask = ~mask & 0xff; 445 *num = mask_first_byte ? ch & mask : ch; 446 all_ones = (ch & mask) == mask; 447 extra_bytes = i; 448 break; 449 } 450 mask = 0x80 | mask >> 1; 451 } 452 453 if (extra_bytes == -1) 454 return -1; 455 456 // Return 0 if we need more data. 457 if ((1 + extra_bytes) > size) 458 return 0; 459 460 int bytes_used = 1; 461 462 for (int i = 0; i < extra_bytes; ++i) { 463 ch = buf[bytes_used++]; 464 all_ones &= (ch == 0xff); 465 *num = (*num << 8) | ch; 466 } 467 468 if (all_ones) 469 *num = kint64max; 470 471 return bytes_used; 472 } 473 474 int WebMParseElementHeader(const uint8* buf, int size, 475 int* id, int64* element_size) { 476 DCHECK(buf); 477 DCHECK_GE(size, 0); 478 DCHECK(id); 479 DCHECK(element_size); 480 481 if (size == 0) 482 return 0; 483 484 int64 tmp = 0; 485 int num_id_bytes = ParseWebMElementHeaderField(buf, size, 4, false, &tmp); 486 487 if (num_id_bytes <= 0) 488 return num_id_bytes; 489 490 if (tmp == kint64max) 491 tmp = kWebMReservedId; 492 493 *id = static_cast<int>(tmp); 494 495 int num_size_bytes = ParseWebMElementHeaderField(buf + num_id_bytes, 496 size - num_id_bytes, 497 8, true, &tmp); 498 499 if (num_size_bytes <= 0) 500 return num_size_bytes; 501 502 if (tmp == kint64max) 503 tmp = kWebMUnknownSize; 504 505 *element_size = tmp; 506 DVLOG(3) << "WebMParseElementHeader() : id " << std::hex << *id << std::dec 507 << " size " << *element_size; 508 return num_id_bytes + num_size_bytes; 509 } 510 511 // Finds ElementType for a specific ID. 512 static ElementType FindIdType(int id, 513 const ElementIdInfo* id_info, 514 int id_info_count) { 515 516 // Check for global element IDs that can be anywhere. 517 if (id == kWebMIdVoid || id == kWebMIdCRC32) 518 return SKIP; 519 520 for (int i = 0; i < id_info_count; ++i) { 521 if (id == id_info[i].id_) 522 return id_info[i].type_; 523 } 524 525 return UNKNOWN; 526 } 527 528 // Finds ListElementInfo for a specific ID. 529 static const ListElementInfo* FindListInfo(int id) { 530 for (size_t i = 0; i < arraysize(kListElementInfo); ++i) { 531 if (id == kListElementInfo[i].id_) 532 return &kListElementInfo[i]; 533 } 534 535 return NULL; 536 } 537 538 static int FindListLevel(int id) { 539 const ListElementInfo* list_info = FindListInfo(id); 540 if (list_info) 541 return list_info->level_; 542 543 return -1; 544 } 545 546 static int ParseUInt(const uint8* buf, int size, int id, 547 WebMParserClient* client) { 548 if ((size <= 0) || (size > 8)) 549 return -1; 550 551 // Read in the big-endian integer. 552 uint64 value = 0; 553 for (int i = 0; i < size; ++i) 554 value = (value << 8) | buf[i]; 555 556 // We use int64 in place of uint64 everywhere for convenience. See this bug 557 // for more details: http://crbug.com/366750#c3 558 if (!base::IsValueInRangeForNumericType<int64>(value)) 559 return -1; 560 561 if (!client->OnUInt(id, value)) 562 return -1; 563 564 return size; 565 } 566 567 static int ParseFloat(const uint8* buf, int size, int id, 568 WebMParserClient* client) { 569 570 if ((size != 4) && (size != 8)) 571 return -1; 572 573 double value = -1; 574 575 // Read the bytes from big-endian form into a native endian integer. 576 int64 tmp = 0; 577 for (int i = 0; i < size; ++i) 578 tmp = (tmp << 8) | buf[i]; 579 580 // Use a union to convert the integer bit pattern into a floating point 581 // number. 582 if (size == 4) { 583 union { 584 int32 src; 585 float dst; 586 } tmp2; 587 tmp2.src = static_cast<int32>(tmp); 588 value = tmp2.dst; 589 } else if (size == 8) { 590 union { 591 int64 src; 592 double dst; 593 } tmp2; 594 tmp2.src = tmp; 595 value = tmp2.dst; 596 } else { 597 return -1; 598 } 599 600 if (!client->OnFloat(id, value)) 601 return -1; 602 603 return size; 604 } 605 606 static int ParseBinary(const uint8* buf, int size, int id, 607 WebMParserClient* client) { 608 return client->OnBinary(id, buf, size) ? size : -1; 609 } 610 611 static int ParseString(const uint8* buf, int size, int id, 612 WebMParserClient* client) { 613 const uint8* end = static_cast<const uint8*>(memchr(buf, '\0', size)); 614 int length = (end != NULL) ? static_cast<int>(end - buf) : size; 615 std::string str(reinterpret_cast<const char*>(buf), length); 616 return client->OnString(id, str) ? size : -1; 617 } 618 619 static int ParseNonListElement(ElementType type, int id, int64 element_size, 620 const uint8* buf, int size, 621 WebMParserClient* client) { 622 DCHECK_GE(size, element_size); 623 624 int result = -1; 625 switch(type) { 626 case LIST: 627 NOTIMPLEMENTED(); 628 result = -1; 629 break; 630 case UINT: 631 result = ParseUInt(buf, element_size, id, client); 632 break; 633 case FLOAT: 634 result = ParseFloat(buf, element_size, id, client); 635 break; 636 case BINARY: 637 result = ParseBinary(buf, element_size, id, client); 638 break; 639 case STRING: 640 result = ParseString(buf, element_size, id, client); 641 break; 642 case SKIP: 643 result = element_size; 644 break; 645 default: 646 DVLOG(1) << "Unhandled ID type " << type; 647 return -1; 648 }; 649 650 DCHECK_LE(result, size); 651 return result; 652 } 653 654 WebMParserClient::WebMParserClient() {} 655 WebMParserClient::~WebMParserClient() {} 656 657 WebMParserClient* WebMParserClient::OnListStart(int id) { 658 DVLOG(1) << "Unexpected list element start with ID " << std::hex << id; 659 return NULL; 660 } 661 662 bool WebMParserClient::OnListEnd(int id) { 663 DVLOG(1) << "Unexpected list element end with ID " << std::hex << id; 664 return false; 665 } 666 667 bool WebMParserClient::OnUInt(int id, int64 val) { 668 DVLOG(1) << "Unexpected unsigned integer element with ID " << std::hex << id; 669 return false; 670 } 671 672 bool WebMParserClient::OnFloat(int id, double val) { 673 DVLOG(1) << "Unexpected float element with ID " << std::hex << id; 674 return false; 675 } 676 677 bool WebMParserClient::OnBinary(int id, const uint8* data, int size) { 678 DVLOG(1) << "Unexpected binary element with ID " << std::hex << id; 679 return false; 680 } 681 682 bool WebMParserClient::OnString(int id, const std::string& str) { 683 DVLOG(1) << "Unexpected string element with ID " << std::hex << id; 684 return false; 685 } 686 687 WebMListParser::WebMListParser(int id, WebMParserClient* client) 688 : state_(NEED_LIST_HEADER), 689 root_id_(id), 690 root_level_(FindListLevel(id)), 691 root_client_(client) { 692 DCHECK_GE(root_level_, 0); 693 DCHECK(client); 694 } 695 696 WebMListParser::~WebMListParser() {} 697 698 void WebMListParser::Reset() { 699 ChangeState(NEED_LIST_HEADER); 700 list_state_stack_.clear(); 701 } 702 703 int WebMListParser::Parse(const uint8* buf, int size) { 704 DCHECK(buf); 705 706 if (size < 0 || state_ == PARSE_ERROR || state_ == DONE_PARSING_LIST) 707 return -1; 708 709 if (size == 0) 710 return 0; 711 712 const uint8* cur = buf; 713 int cur_size = size; 714 int bytes_parsed = 0; 715 716 while (cur_size > 0 && state_ != PARSE_ERROR && state_ != DONE_PARSING_LIST) { 717 int element_id = 0; 718 int64 element_size = 0; 719 int result = WebMParseElementHeader(cur, cur_size, &element_id, 720 &element_size); 721 722 if (result < 0) 723 return result; 724 725 if (result == 0) 726 return bytes_parsed; 727 728 switch(state_) { 729 case NEED_LIST_HEADER: { 730 if (element_id != root_id_) { 731 ChangeState(PARSE_ERROR); 732 return -1; 733 } 734 735 // Only allow Segment & Cluster to have an unknown size. 736 if (element_size == kWebMUnknownSize && 737 (element_id != kWebMIdSegment) && 738 (element_id != kWebMIdCluster)) { 739 ChangeState(PARSE_ERROR); 740 return -1; 741 } 742 743 ChangeState(INSIDE_LIST); 744 if (!OnListStart(root_id_, element_size)) 745 return -1; 746 747 break; 748 } 749 750 case INSIDE_LIST: { 751 int header_size = result; 752 const uint8* element_data = cur + header_size; 753 int element_data_size = cur_size - header_size; 754 755 if (element_size < element_data_size) 756 element_data_size = element_size; 757 758 result = ParseListElement(header_size, element_id, element_size, 759 element_data, element_data_size); 760 761 DCHECK_LE(result, header_size + element_data_size); 762 if (result < 0) { 763 ChangeState(PARSE_ERROR); 764 return -1; 765 } 766 767 if (result == 0) 768 return bytes_parsed; 769 770 break; 771 } 772 case DONE_PARSING_LIST: 773 case PARSE_ERROR: 774 // Shouldn't be able to get here. 775 NOTIMPLEMENTED(); 776 break; 777 } 778 779 cur += result; 780 cur_size -= result; 781 bytes_parsed += result; 782 } 783 784 return (state_ == PARSE_ERROR) ? -1 : bytes_parsed; 785 } 786 787 bool WebMListParser::IsParsingComplete() const { 788 return state_ == DONE_PARSING_LIST; 789 } 790 791 void WebMListParser::ChangeState(State new_state) { 792 state_ = new_state; 793 } 794 795 int WebMListParser::ParseListElement(int header_size, 796 int id, int64 element_size, 797 const uint8* data, int size) { 798 DCHECK_GT(list_state_stack_.size(), 0u); 799 800 ListState& list_state = list_state_stack_.back(); 801 DCHECK(list_state.element_info_); 802 803 const ListElementInfo* element_info = list_state.element_info_; 804 ElementType id_type = 805 FindIdType(id, element_info->id_info_, element_info->id_info_count_); 806 807 // Unexpected ID. 808 if (id_type == UNKNOWN) { 809 if (list_state.size_ != kWebMUnknownSize || 810 !IsSiblingOrAncestor(list_state.id_, id)) { 811 DVLOG(1) << "No ElementType info for ID 0x" << std::hex << id; 812 return -1; 813 } 814 815 // We've reached the end of a list of unknown size. Update the size now that 816 // we know it and dispatch the end of list calls. 817 list_state.size_ = list_state.bytes_parsed_; 818 819 if (!OnListEnd()) 820 return -1; 821 822 // Check to see if all open lists have ended. 823 if (list_state_stack_.size() == 0) 824 return 0; 825 826 list_state = list_state_stack_.back(); 827 } 828 829 // Make sure the whole element can fit inside the current list. 830 int64 total_element_size = header_size + element_size; 831 if (list_state.size_ != kWebMUnknownSize && 832 list_state.size_ < list_state.bytes_parsed_ + total_element_size) { 833 return -1; 834 } 835 836 if (id_type == LIST) { 837 list_state.bytes_parsed_ += header_size; 838 839 if (!OnListStart(id, element_size)) 840 return -1; 841 return header_size; 842 } 843 844 // Make sure we have the entire element before trying to parse a non-list 845 // element. 846 if (size < element_size) 847 return 0; 848 849 int bytes_parsed = ParseNonListElement(id_type, id, element_size, 850 data, size, list_state.client_); 851 DCHECK_LE(bytes_parsed, size); 852 853 // Return if an error occurred or we need more data. 854 // Note: bytes_parsed is 0 for a successful parse of a size 0 element. We 855 // need to check the element_size to disambiguate the "need more data" case 856 // from a successful parse. 857 if (bytes_parsed < 0 || (bytes_parsed == 0 && element_size != 0)) 858 return bytes_parsed; 859 860 int result = header_size + bytes_parsed; 861 list_state.bytes_parsed_ += result; 862 863 // See if we have reached the end of the current list. 864 if (list_state.bytes_parsed_ == list_state.size_) { 865 if (!OnListEnd()) 866 return -1; 867 } 868 869 return result; 870 } 871 872 bool WebMListParser::OnListStart(int id, int64 size) { 873 const ListElementInfo* element_info = FindListInfo(id); 874 if (!element_info) 875 return false; 876 877 int current_level = root_level_ + list_state_stack_.size() - 1; 878 if (current_level + 1 != element_info->level_) 879 return false; 880 881 WebMParserClient* current_list_client = NULL; 882 if (!list_state_stack_.empty()) { 883 // Make sure the new list doesn't go past the end of the current list. 884 ListState current_list_state = list_state_stack_.back(); 885 if (current_list_state.size_ != kWebMUnknownSize && 886 current_list_state.size_ < current_list_state.bytes_parsed_ + size) 887 return false; 888 current_list_client = current_list_state.client_; 889 } else { 890 current_list_client = root_client_; 891 } 892 893 WebMParserClient* new_list_client = current_list_client->OnListStart(id); 894 if (!new_list_client) 895 return false; 896 897 ListState new_list_state = { id, size, 0, element_info, new_list_client }; 898 list_state_stack_.push_back(new_list_state); 899 900 if (size == 0) 901 return OnListEnd(); 902 903 return true; 904 } 905 906 bool WebMListParser::OnListEnd() { 907 int lists_ended = 0; 908 for (; !list_state_stack_.empty(); ++lists_ended) { 909 const ListState& list_state = list_state_stack_.back(); 910 int64 bytes_parsed = list_state.bytes_parsed_; 911 int id = list_state.id_; 912 913 if (bytes_parsed != list_state.size_) 914 break; 915 916 list_state_stack_.pop_back(); 917 918 WebMParserClient* client = NULL; 919 if (!list_state_stack_.empty()) { 920 // Update the bytes_parsed_ for the parent element. 921 list_state_stack_.back().bytes_parsed_ += bytes_parsed; 922 client = list_state_stack_.back().client_; 923 } else { 924 client = root_client_; 925 } 926 927 if (!client->OnListEnd(id)) 928 return false; 929 } 930 931 DCHECK_GE(lists_ended, 1); 932 933 if (list_state_stack_.empty()) 934 ChangeState(DONE_PARSING_LIST); 935 936 return true; 937 } 938 939 bool WebMListParser::IsSiblingOrAncestor(int id_a, int id_b) const { 940 DCHECK((id_a == kWebMIdSegment) || (id_a == kWebMIdCluster)); 941 942 if (id_a == kWebMIdCluster) { 943 // kWebMIdCluster siblings. 944 for (size_t i = 0; i < arraysize(kSegmentIds); i++) { 945 if (kSegmentIds[i].id_ == id_b) 946 return true; 947 } 948 } 949 950 // kWebMIdSegment siblings. 951 return ((id_b == kWebMIdSegment) || (id_b == kWebMIdEBMLHeader)); 952 } 953 954 } // namespace media 955
