1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 //#define LOG_NDEBUG 0 18 #define LOG_TAG "MatroskaExtractor" 19 #include <utils/Log.h> 20 21 #include "MatroskaExtractor.h" 22 23 #include "mkvparser.hpp" 24 25 #include <media/stagefright/foundation/ADebug.h> 26 #include <media/stagefright/foundation/hexdump.h> 27 #include <media/stagefright/DataSource.h> 28 #include <media/stagefright/MediaBuffer.h> 29 #include <media/stagefright/MediaDefs.h> 30 #include <media/stagefright/MediaErrors.h> 31 #include <media/stagefright/MediaSource.h> 32 #include <media/stagefright/MetaData.h> 33 #include <media/stagefright/Utils.h> 34 #include <utils/String8.h> 35 36 namespace android { 37 38 struct DataSourceReader : public mkvparser::IMkvReader { 39 DataSourceReader(const sp<DataSource> &source) 40 : mSource(source) { 41 } 42 43 virtual int Read(long long position, long length, unsigned char* buffer) { 44 CHECK(position >= 0); 45 CHECK(length >= 0); 46 47 if (length == 0) { 48 return 0; 49 } 50 51 ssize_t n = mSource->readAt(position, buffer, length); 52 53 if (n <= 0) { 54 return -1; 55 } 56 57 return 0; 58 } 59 60 virtual int Length(long long* total, long long* available) { 61 off64_t size; 62 if (mSource->getSize(&size) != OK) { 63 *total = -1; 64 *available = (long long)((1ull << 63) - 1); 65 66 return 0; 67 } 68 69 if (total) { 70 *total = size; 71 } 72 73 if (available) { 74 *available = size; 75 } 76 77 return 0; 78 } 79 80 private: 81 sp<DataSource> mSource; 82 83 DataSourceReader(const DataSourceReader &); 84 DataSourceReader &operator=(const DataSourceReader &); 85 }; 86 87 //////////////////////////////////////////////////////////////////////////////// 88 89 struct BlockIterator { 90 BlockIterator(MatroskaExtractor *extractor, unsigned long trackNum); 91 92 bool eos() const; 93 94 void advance(); 95 void reset(); 96 void seek(int64_t seekTimeUs, bool seekToKeyFrame); 97 98 const mkvparser::Block *block() const; 99 int64_t blockTimeUs() const; 100 101 private: 102 MatroskaExtractor *mExtractor; 103 unsigned long mTrackNum; 104 105 const mkvparser::Cluster *mCluster; 106 const mkvparser::BlockEntry *mBlockEntry; 107 long mBlockEntryIndex; 108 109 void advance_l(); 110 111 BlockIterator(const BlockIterator &); 112 BlockIterator &operator=(const BlockIterator &); 113 }; 114 115 struct MatroskaSource : public MediaSource { 116 MatroskaSource( 117 const sp<MatroskaExtractor> &extractor, size_t index); 118 119 virtual status_t start(MetaData *params); 120 virtual status_t stop(); 121 122 virtual sp<MetaData> getFormat(); 123 124 virtual status_t read( 125 MediaBuffer **buffer, const ReadOptions *options); 126 127 protected: 128 virtual ~MatroskaSource(); 129 130 private: 131 enum Type { 132 AVC, 133 AAC, 134 OTHER 135 }; 136 137 sp<MatroskaExtractor> mExtractor; 138 size_t mTrackIndex; 139 Type mType; 140 bool mIsAudio; 141 BlockIterator mBlockIter; 142 size_t mNALSizeLen; // for type AVC 143 144 List<MediaBuffer *> mPendingFrames; 145 146 status_t advance(); 147 148 status_t readBlock(); 149 void clearPendingFrames(); 150 151 MatroskaSource(const MatroskaSource &); 152 MatroskaSource &operator=(const MatroskaSource &); 153 }; 154 155 MatroskaSource::MatroskaSource( 156 const sp<MatroskaExtractor> &extractor, size_t index) 157 : mExtractor(extractor), 158 mTrackIndex(index), 159 mType(OTHER), 160 mIsAudio(false), 161 mBlockIter(mExtractor.get(), 162 mExtractor->mTracks.itemAt(index).mTrackNum), 163 mNALSizeLen(0) { 164 sp<MetaData> meta = mExtractor->mTracks.itemAt(index).mMeta; 165 166 const char *mime; 167 CHECK(meta->findCString(kKeyMIMEType, &mime)); 168 169 mIsAudio = !strncasecmp("audio/", mime, 6); 170 171 if (!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_AVC)) { 172 mType = AVC; 173 174 uint32_t dummy; 175 const uint8_t *avcc; 176 size_t avccSize; 177 CHECK(meta->findData( 178 kKeyAVCC, &dummy, (const void **)&avcc, &avccSize)); 179 180 CHECK_GE(avccSize, 5u); 181 182 mNALSizeLen = 1 + (avcc[4] & 3); 183 LOGV("mNALSizeLen = %d", mNALSizeLen); 184 } else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC)) { 185 mType = AAC; 186 } 187 } 188 189 MatroskaSource::~MatroskaSource() { 190 clearPendingFrames(); 191 } 192 193 status_t MatroskaSource::start(MetaData *params) { 194 mBlockIter.reset(); 195 196 return OK; 197 } 198 199 status_t MatroskaSource::stop() { 200 clearPendingFrames(); 201 202 return OK; 203 } 204 205 sp<MetaData> MatroskaSource::getFormat() { 206 return mExtractor->mTracks.itemAt(mTrackIndex).mMeta; 207 } 208 209 //////////////////////////////////////////////////////////////////////////////// 210 211 BlockIterator::BlockIterator( 212 MatroskaExtractor *extractor, unsigned long trackNum) 213 : mExtractor(extractor), 214 mTrackNum(trackNum), 215 mCluster(NULL), 216 mBlockEntry(NULL), 217 mBlockEntryIndex(0) { 218 reset(); 219 } 220 221 bool BlockIterator::eos() const { 222 return mCluster == NULL || mCluster->EOS(); 223 } 224 225 void BlockIterator::advance() { 226 Mutex::Autolock autoLock(mExtractor->mLock); 227 advance_l(); 228 } 229 230 void BlockIterator::advance_l() { 231 for (;;) { 232 long res = mCluster->GetEntry(mBlockEntryIndex, mBlockEntry); 233 LOGV("GetEntry returned %ld", res); 234 235 long long pos; 236 long len; 237 if (res < 0) { 238 // Need to parse this cluster some more 239 240 CHECK_EQ(res, mkvparser::E_BUFFER_NOT_FULL); 241 242 res = mCluster->Parse(pos, len); 243 LOGV("Parse returned %ld", res); 244 245 if (res < 0) { 246 // I/O error 247 248 LOGE("Cluster::Parse returned result %ld", res); 249 250 mCluster = NULL; 251 break; 252 } 253 254 continue; 255 } else if (res == 0) { 256 // We're done with this cluster 257 258 const mkvparser::Cluster *nextCluster; 259 res = mExtractor->mSegment->ParseNext( 260 mCluster, nextCluster, pos, len); 261 LOGV("ParseNext returned %ld", res); 262 263 if (res > 0) { 264 // EOF 265 266 mCluster = NULL; 267 break; 268 } 269 270 CHECK_EQ(res, 0); 271 CHECK(nextCluster != NULL); 272 CHECK(!nextCluster->EOS()); 273 274 mCluster = nextCluster; 275 276 res = mCluster->Parse(pos, len); 277 LOGV("Parse (2) returned %ld", res); 278 CHECK_GE(res, 0); 279 280 mBlockEntryIndex = 0; 281 continue; 282 } 283 284 CHECK(mBlockEntry != NULL); 285 CHECK(mBlockEntry->GetBlock() != NULL); 286 ++mBlockEntryIndex; 287 288 if (mBlockEntry->GetBlock()->GetTrackNumber() == mTrackNum) { 289 break; 290 } 291 } 292 } 293 294 void BlockIterator::reset() { 295 Mutex::Autolock autoLock(mExtractor->mLock); 296 297 mCluster = mExtractor->mSegment->GetFirst(); 298 mBlockEntry = NULL; 299 mBlockEntryIndex = 0; 300 301 do { 302 advance_l(); 303 } while (!eos() && block()->GetTrackNumber() != mTrackNum); 304 } 305 306 void BlockIterator::seek(int64_t seekTimeUs, bool seekToKeyFrame) { 307 Mutex::Autolock autoLock(mExtractor->mLock); 308 309 mCluster = mExtractor->mSegment->FindCluster(seekTimeUs * 1000ll); 310 mBlockEntry = NULL; 311 mBlockEntryIndex = 0; 312 313 do { 314 advance_l(); 315 } 316 while (!eos() && block()->GetTrackNumber() != mTrackNum); 317 318 if (seekToKeyFrame) { 319 while (!eos() && !mBlockEntry->GetBlock()->IsKey()) { 320 advance_l(); 321 } 322 } 323 } 324 325 const mkvparser::Block *BlockIterator::block() const { 326 CHECK(!eos()); 327 328 return mBlockEntry->GetBlock(); 329 } 330 331 int64_t BlockIterator::blockTimeUs() const { 332 return (mBlockEntry->GetBlock()->GetTime(mCluster) + 500ll) / 1000ll; 333 } 334 335 //////////////////////////////////////////////////////////////////////////////// 336 337 static unsigned U24_AT(const uint8_t *ptr) { 338 return ptr[0] << 16 | ptr[1] << 8 | ptr[2]; 339 } 340 341 static size_t clz(uint8_t x) { 342 size_t numLeadingZeroes = 0; 343 344 while (!(x & 0x80)) { 345 ++numLeadingZeroes; 346 x = x << 1; 347 } 348 349 return numLeadingZeroes; 350 } 351 352 void MatroskaSource::clearPendingFrames() { 353 while (!mPendingFrames.empty()) { 354 MediaBuffer *frame = *mPendingFrames.begin(); 355 mPendingFrames.erase(mPendingFrames.begin()); 356 357 frame->release(); 358 frame = NULL; 359 } 360 } 361 362 status_t MatroskaSource::readBlock() { 363 CHECK(mPendingFrames.empty()); 364 365 if (mBlockIter.eos()) { 366 return ERROR_END_OF_STREAM; 367 } 368 369 const mkvparser::Block *block = mBlockIter.block(); 370 371 int64_t timeUs = mBlockIter.blockTimeUs(); 372 373 for (int i = 0; i < block->GetFrameCount(); ++i) { 374 const mkvparser::Block::Frame &frame = block->GetFrame(i); 375 376 MediaBuffer *mbuf = new MediaBuffer(frame.len); 377 mbuf->meta_data()->setInt64(kKeyTime, timeUs); 378 mbuf->meta_data()->setInt32(kKeyIsSyncFrame, block->IsKey()); 379 380 long n = frame.Read(mExtractor->mReader, (unsigned char *)mbuf->data()); 381 if (n != 0) { 382 mPendingFrames.clear(); 383 384 mBlockIter.advance(); 385 return ERROR_IO; 386 } 387 388 mPendingFrames.push_back(mbuf); 389 } 390 391 mBlockIter.advance(); 392 393 return OK; 394 } 395 396 status_t MatroskaSource::read( 397 MediaBuffer **out, const ReadOptions *options) { 398 *out = NULL; 399 400 int64_t seekTimeUs; 401 ReadOptions::SeekMode mode; 402 if (options && options->getSeekTo(&seekTimeUs, &mode) 403 && !mExtractor->isLiveStreaming()) { 404 clearPendingFrames(); 405 406 // Apparently keyframe indication in audio tracks is unreliable, 407 // fortunately in all our currently supported audio encodings every 408 // frame is effectively a keyframe. 409 mBlockIter.seek(seekTimeUs, !mIsAudio); 410 } 411 412 again: 413 while (mPendingFrames.empty()) { 414 status_t err = readBlock(); 415 416 if (err != OK) { 417 clearPendingFrames(); 418 419 return err; 420 } 421 } 422 423 MediaBuffer *frame = *mPendingFrames.begin(); 424 mPendingFrames.erase(mPendingFrames.begin()); 425 426 if (mType != AVC) { 427 *out = frame; 428 429 return OK; 430 } 431 432 // Each input frame contains one or more NAL fragments, each fragment 433 // is prefixed by mNALSizeLen bytes giving the fragment length, 434 // followed by a corresponding number of bytes containing the fragment. 435 // We output all these fragments into a single large buffer separated 436 // by startcodes (0x00 0x00 0x00 0x01). 437 438 const uint8_t *srcPtr = 439 (const uint8_t *)frame->data() + frame->range_offset(); 440 441 size_t srcSize = frame->range_length(); 442 443 size_t dstSize = 0; 444 MediaBuffer *buffer = NULL; 445 uint8_t *dstPtr = NULL; 446 447 for (int32_t pass = 0; pass < 2; ++pass) { 448 size_t srcOffset = 0; 449 size_t dstOffset = 0; 450 while (srcOffset + mNALSizeLen <= srcSize) { 451 size_t NALsize; 452 switch (mNALSizeLen) { 453 case 1: NALsize = srcPtr[srcOffset]; break; 454 case 2: NALsize = U16_AT(srcPtr + srcOffset); break; 455 case 3: NALsize = U24_AT(srcPtr + srcOffset); break; 456 case 4: NALsize = U32_AT(srcPtr + srcOffset); break; 457 default: 458 TRESPASS(); 459 } 460 461 if (srcOffset + mNALSizeLen + NALsize > srcSize) { 462 break; 463 } 464 465 if (pass == 1) { 466 memcpy(&dstPtr[dstOffset], "\x00\x00\x00\x01", 4); 467 468 memcpy(&dstPtr[dstOffset + 4], 469 &srcPtr[srcOffset + mNALSizeLen], 470 NALsize); 471 } 472 473 dstOffset += 4; // 0x00 00 00 01 474 dstOffset += NALsize; 475 476 srcOffset += mNALSizeLen + NALsize; 477 } 478 479 if (srcOffset < srcSize) { 480 // There were trailing bytes or not enough data to complete 481 // a fragment. 482 483 frame->release(); 484 frame = NULL; 485 486 return ERROR_MALFORMED; 487 } 488 489 if (pass == 0) { 490 dstSize = dstOffset; 491 492 buffer = new MediaBuffer(dstSize); 493 494 int64_t timeUs; 495 CHECK(frame->meta_data()->findInt64(kKeyTime, &timeUs)); 496 int32_t isSync; 497 CHECK(frame->meta_data()->findInt32(kKeyIsSyncFrame, &isSync)); 498 499 buffer->meta_data()->setInt64(kKeyTime, timeUs); 500 buffer->meta_data()->setInt32(kKeyIsSyncFrame, isSync); 501 502 dstPtr = (uint8_t *)buffer->data(); 503 } 504 } 505 506 frame->release(); 507 frame = NULL; 508 509 *out = buffer; 510 511 return OK; 512 } 513 514 //////////////////////////////////////////////////////////////////////////////// 515 516 MatroskaExtractor::MatroskaExtractor(const sp<DataSource> &source) 517 : mDataSource(source), 518 mReader(new DataSourceReader(mDataSource)), 519 mSegment(NULL), 520 mExtractedThumbnails(false), 521 mIsWebm(false) { 522 off64_t size; 523 mIsLiveStreaming = 524 (mDataSource->flags() 525 & (DataSource::kWantsPrefetching 526 | DataSource::kIsCachingDataSource)) 527 && mDataSource->getSize(&size) != OK; 528 529 mkvparser::EBMLHeader ebmlHeader; 530 long long pos; 531 if (ebmlHeader.Parse(mReader, pos) < 0) { 532 return; 533 } 534 535 if (ebmlHeader.m_docType && !strcmp("webm", ebmlHeader.m_docType)) { 536 mIsWebm = true; 537 } 538 539 long long ret = 540 mkvparser::Segment::CreateInstance(mReader, pos, mSegment); 541 542 if (ret) { 543 CHECK(mSegment == NULL); 544 return; 545 } 546 547 if (isLiveStreaming()) { 548 ret = mSegment->ParseHeaders(); 549 CHECK_EQ(ret, 0); 550 551 long len; 552 ret = mSegment->LoadCluster(pos, len); 553 CHECK_EQ(ret, 0); 554 } else { 555 ret = mSegment->Load(); 556 } 557 558 if (ret < 0) { 559 delete mSegment; 560 mSegment = NULL; 561 return; 562 } 563 564 #if 0 565 const mkvparser::SegmentInfo *info = mSegment->GetInfo(); 566 LOGI("muxing app: %s, writing app: %s", 567 info->GetMuxingAppAsUTF8(), 568 info->GetWritingAppAsUTF8()); 569 #endif 570 571 addTracks(); 572 } 573 574 MatroskaExtractor::~MatroskaExtractor() { 575 delete mSegment; 576 mSegment = NULL; 577 578 delete mReader; 579 mReader = NULL; 580 } 581 582 size_t MatroskaExtractor::countTracks() { 583 return mTracks.size(); 584 } 585 586 sp<MediaSource> MatroskaExtractor::getTrack(size_t index) { 587 if (index >= mTracks.size()) { 588 return NULL; 589 } 590 591 return new MatroskaSource(this, index); 592 } 593 594 sp<MetaData> MatroskaExtractor::getTrackMetaData( 595 size_t index, uint32_t flags) { 596 if (index >= mTracks.size()) { 597 return NULL; 598 } 599 600 if ((flags & kIncludeExtensiveMetaData) && !mExtractedThumbnails 601 && !isLiveStreaming()) { 602 findThumbnails(); 603 mExtractedThumbnails = true; 604 } 605 606 return mTracks.itemAt(index).mMeta; 607 } 608 609 bool MatroskaExtractor::isLiveStreaming() const { 610 return mIsLiveStreaming; 611 } 612 613 static void addESDSFromAudioSpecificInfo( 614 const sp<MetaData> &meta, const void *asi, size_t asiSize) { 615 static const uint8_t kStaticESDS[] = { 616 0x03, 22, 617 0x00, 0x00, // ES_ID 618 0x00, // streamDependenceFlag, URL_Flag, OCRstreamFlag 619 620 0x04, 17, 621 0x40, // Audio ISO/IEC 14496-3 622 0x00, 0x00, 0x00, 0x00, 623 0x00, 0x00, 0x00, 0x00, 624 0x00, 0x00, 0x00, 0x00, 625 626 0x05, 627 // AudioSpecificInfo (with size prefix) follows 628 }; 629 630 // Make sure all sizes can be coded in a single byte. 631 CHECK(asiSize + 22 - 2 < 128); 632 size_t esdsSize = sizeof(kStaticESDS) + asiSize + 1; 633 uint8_t *esds = new uint8_t[esdsSize]; 634 memcpy(esds, kStaticESDS, sizeof(kStaticESDS)); 635 uint8_t *ptr = esds + sizeof(kStaticESDS); 636 *ptr++ = asiSize; 637 memcpy(ptr, asi, asiSize); 638 639 // Increment by codecPrivateSize less 2 bytes that are accounted for 640 // already in lengths of 22/17 641 esds[1] += asiSize - 2; 642 esds[6] += asiSize - 2; 643 644 meta->setData(kKeyESDS, 0, esds, esdsSize); 645 646 delete[] esds; 647 esds = NULL; 648 } 649 650 void addVorbisCodecInfo( 651 const sp<MetaData> &meta, 652 const void *_codecPrivate, size_t codecPrivateSize) { 653 // printf("vorbis private data follows:\n"); 654 // hexdump(_codecPrivate, codecPrivateSize); 655 656 CHECK(codecPrivateSize >= 3); 657 658 const uint8_t *codecPrivate = (const uint8_t *)_codecPrivate; 659 CHECK(codecPrivate[0] == 0x02); 660 661 size_t len1 = codecPrivate[1]; 662 size_t len2 = codecPrivate[2]; 663 664 CHECK(codecPrivateSize > 3 + len1 + len2); 665 666 CHECK(codecPrivate[3] == 0x01); 667 meta->setData(kKeyVorbisInfo, 0, &codecPrivate[3], len1); 668 669 CHECK(codecPrivate[len1 + 3] == 0x03); 670 671 CHECK(codecPrivate[len1 + len2 + 3] == 0x05); 672 meta->setData( 673 kKeyVorbisBooks, 0, &codecPrivate[len1 + len2 + 3], 674 codecPrivateSize - len1 - len2 - 3); 675 } 676 677 void MatroskaExtractor::addTracks() { 678 const mkvparser::Tracks *tracks = mSegment->GetTracks(); 679 680 for (size_t index = 0; index < tracks->GetTracksCount(); ++index) { 681 const mkvparser::Track *track = tracks->GetTrackByIndex(index); 682 683 if (track == NULL) { 684 // Apparently this is currently valid (if unexpected) behaviour 685 // of the mkv parser lib. 686 continue; 687 } 688 689 const char *const codecID = track->GetCodecId(); 690 LOGV("codec id = %s", codecID); 691 LOGV("codec name = %s", track->GetCodecNameAsUTF8()); 692 693 size_t codecPrivateSize; 694 const unsigned char *codecPrivate = 695 track->GetCodecPrivate(codecPrivateSize); 696 697 enum { VIDEO_TRACK = 1, AUDIO_TRACK = 2 }; 698 699 sp<MetaData> meta = new MetaData; 700 701 switch (track->GetType()) { 702 case VIDEO_TRACK: 703 { 704 const mkvparser::VideoTrack *vtrack = 705 static_cast<const mkvparser::VideoTrack *>(track); 706 707 if (!strcmp("V_MPEG4/ISO/AVC", codecID)) { 708 meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC); 709 meta->setData(kKeyAVCC, 0, codecPrivate, codecPrivateSize); 710 } else if (!strcmp("V_VP8", codecID)) { 711 meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VPX); 712 } else { 713 continue; 714 } 715 716 meta->setInt32(kKeyWidth, vtrack->GetWidth()); 717 meta->setInt32(kKeyHeight, vtrack->GetHeight()); 718 break; 719 } 720 721 case AUDIO_TRACK: 722 { 723 const mkvparser::AudioTrack *atrack = 724 static_cast<const mkvparser::AudioTrack *>(track); 725 726 if (!strcmp("A_AAC", codecID)) { 727 meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_AAC); 728 CHECK(codecPrivateSize >= 2); 729 730 addESDSFromAudioSpecificInfo( 731 meta, codecPrivate, codecPrivateSize); 732 } else if (!strcmp("A_VORBIS", codecID)) { 733 meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS); 734 735 addVorbisCodecInfo(meta, codecPrivate, codecPrivateSize); 736 } else { 737 continue; 738 } 739 740 meta->setInt32(kKeySampleRate, atrack->GetSamplingRate()); 741 meta->setInt32(kKeyChannelCount, atrack->GetChannels()); 742 break; 743 } 744 745 default: 746 continue; 747 } 748 749 long long durationNs = mSegment->GetDuration(); 750 meta->setInt64(kKeyDuration, (durationNs + 500) / 1000); 751 752 mTracks.push(); 753 TrackInfo *trackInfo = &mTracks.editItemAt(mTracks.size() - 1); 754 trackInfo->mTrackNum = track->GetNumber(); 755 trackInfo->mMeta = meta; 756 } 757 } 758 759 void MatroskaExtractor::findThumbnails() { 760 for (size_t i = 0; i < mTracks.size(); ++i) { 761 TrackInfo *info = &mTracks.editItemAt(i); 762 763 const char *mime; 764 CHECK(info->mMeta->findCString(kKeyMIMEType, &mime)); 765 766 if (strncasecmp(mime, "video/", 6)) { 767 continue; 768 } 769 770 BlockIterator iter(this, info->mTrackNum); 771 int32_t i = 0; 772 int64_t thumbnailTimeUs = 0; 773 size_t maxBlockSize = 0; 774 while (!iter.eos() && i < 20) { 775 if (iter.block()->IsKey()) { 776 ++i; 777 778 size_t blockSize = 0; 779 for (int i = 0; i < iter.block()->GetFrameCount(); ++i) { 780 blockSize += iter.block()->GetFrame(i).len; 781 } 782 783 if (blockSize > maxBlockSize) { 784 maxBlockSize = blockSize; 785 thumbnailTimeUs = iter.blockTimeUs(); 786 } 787 } 788 iter.advance(); 789 } 790 info->mMeta->setInt64(kKeyThumbnailTime, thumbnailTimeUs); 791 } 792 } 793 794 sp<MetaData> MatroskaExtractor::getMetaData() { 795 sp<MetaData> meta = new MetaData; 796 797 meta->setCString( 798 kKeyMIMEType, 799 mIsWebm ? "video/webm" : MEDIA_MIMETYPE_CONTAINER_MATROSKA); 800 801 return meta; 802 } 803 804 uint32_t MatroskaExtractor::flags() const { 805 uint32_t x = CAN_PAUSE; 806 if (!isLiveStreaming()) { 807 x |= CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK; 808 } 809 810 return x; 811 } 812 813 bool SniffMatroska( 814 const sp<DataSource> &source, String8 *mimeType, float *confidence, 815 sp<AMessage> *) { 816 DataSourceReader reader(source); 817 mkvparser::EBMLHeader ebmlHeader; 818 long long pos; 819 if (ebmlHeader.Parse(&reader, pos) < 0) { 820 return false; 821 } 822 823 mimeType->setTo(MEDIA_MIMETYPE_CONTAINER_MATROSKA); 824 *confidence = 0.6; 825 826 return true; 827 } 828 829 } // namespace android 830
