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 "OggExtractor" 19 #include <utils/Log.h> 20 21 #include "include/OggExtractor.h" 22 23 #include <cutils/properties.h> 24 #include <media/stagefright/DataSource.h> 25 #include <media/stagefright/MediaBuffer.h> 26 #include <media/stagefright/MediaBufferGroup.h> 27 #include <media/stagefright/MediaDebug.h> 28 #include <media/stagefright/MediaDefs.h> 29 #include <media/stagefright/MediaErrors.h> 30 #include <media/stagefright/MediaSource.h> 31 #include <media/stagefright/MetaData.h> 32 #include <media/stagefright/Utils.h> 33 #include <utils/String8.h> 34 35 extern "C" { 36 #include <Tremolo/codec_internal.h> 37 38 int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb); 39 int _vorbis_unpack_info(vorbis_info *vi,oggpack_buffer *opb); 40 int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb); 41 } 42 43 namespace android { 44 45 struct OggSource : public MediaSource { 46 OggSource(const sp<OggExtractor> &extractor); 47 48 virtual sp<MetaData> getFormat(); 49 50 virtual status_t start(MetaData *params = NULL); 51 virtual status_t stop(); 52 53 virtual status_t read( 54 MediaBuffer **buffer, const ReadOptions *options = NULL); 55 56 protected: 57 virtual ~OggSource(); 58 59 private: 60 sp<OggExtractor> mExtractor; 61 bool mStarted; 62 63 OggSource(const OggSource &); 64 OggSource &operator=(const OggSource &); 65 }; 66 67 struct MyVorbisExtractor { 68 MyVorbisExtractor(const sp<DataSource> &source); 69 virtual ~MyVorbisExtractor(); 70 71 sp<MetaData> getFormat() const; 72 73 // Returns an approximate bitrate in bits per second. 74 uint64_t approxBitrate(); 75 76 status_t seekToTime(int64_t timeUs); 77 status_t seekToOffset(off64_t offset); 78 status_t readNextPacket(MediaBuffer **buffer); 79 80 status_t init(); 81 82 sp<MetaData> getFileMetaData() { return mFileMeta; } 83 84 private: 85 struct Page { 86 uint64_t mGranulePosition; 87 uint32_t mSerialNo; 88 uint32_t mPageNo; 89 uint8_t mFlags; 90 uint8_t mNumSegments; 91 uint8_t mLace[255]; 92 }; 93 94 struct TOCEntry { 95 off64_t mPageOffset; 96 int64_t mTimeUs; 97 }; 98 99 sp<DataSource> mSource; 100 off64_t mOffset; 101 Page mCurrentPage; 102 uint64_t mPrevGranulePosition; 103 size_t mCurrentPageSize; 104 bool mFirstPacketInPage; 105 uint64_t mCurrentPageSamples; 106 size_t mNextLaceIndex; 107 108 off64_t mFirstDataOffset; 109 110 vorbis_info mVi; 111 vorbis_comment mVc; 112 113 sp<MetaData> mMeta; 114 sp<MetaData> mFileMeta; 115 116 Vector<TOCEntry> mTableOfContents; 117 118 ssize_t readPage(off64_t offset, Page *page); 119 status_t findNextPage(off64_t startOffset, off64_t *pageOffset); 120 121 status_t verifyHeader( 122 MediaBuffer *buffer, uint8_t type); 123 124 void parseFileMetaData(); 125 126 status_t findPrevGranulePosition(off64_t pageOffset, uint64_t *granulePos); 127 128 void buildTableOfContents(); 129 130 MyVorbisExtractor(const MyVorbisExtractor &); 131 MyVorbisExtractor &operator=(const MyVorbisExtractor &); 132 }; 133 134 static void extractAlbumArt( 135 const sp<MetaData> &fileMeta, const void *data, size_t size); 136 137 //////////////////////////////////////////////////////////////////////////////// 138 139 OggSource::OggSource(const sp<OggExtractor> &extractor) 140 : mExtractor(extractor), 141 mStarted(false) { 142 } 143 144 OggSource::~OggSource() { 145 if (mStarted) { 146 stop(); 147 } 148 } 149 150 sp<MetaData> OggSource::getFormat() { 151 return mExtractor->mImpl->getFormat(); 152 } 153 154 status_t OggSource::start(MetaData *params) { 155 if (mStarted) { 156 return INVALID_OPERATION; 157 } 158 159 mStarted = true; 160 161 return OK; 162 } 163 164 status_t OggSource::stop() { 165 mStarted = false; 166 167 return OK; 168 } 169 170 status_t OggSource::read( 171 MediaBuffer **out, const ReadOptions *options) { 172 *out = NULL; 173 174 int64_t seekTimeUs; 175 ReadOptions::SeekMode mode; 176 if (options && options->getSeekTo(&seekTimeUs, &mode)) { 177 if (mExtractor->mImpl->seekToTime(seekTimeUs) != OK) { 178 return ERROR_END_OF_STREAM; 179 } 180 } 181 182 MediaBuffer *packet; 183 status_t err = mExtractor->mImpl->readNextPacket(&packet); 184 185 if (err != OK) { 186 return err; 187 } 188 189 #if 0 190 int64_t timeUs; 191 if (packet->meta_data()->findInt64(kKeyTime, &timeUs)) { 192 LOGI("found time = %lld us", timeUs); 193 } else { 194 LOGI("NO time"); 195 } 196 #endif 197 198 packet->meta_data()->setInt32(kKeyIsSyncFrame, 1); 199 200 *out = packet; 201 202 return OK; 203 } 204 205 //////////////////////////////////////////////////////////////////////////////// 206 207 MyVorbisExtractor::MyVorbisExtractor(const sp<DataSource> &source) 208 : mSource(source), 209 mOffset(0), 210 mPrevGranulePosition(0), 211 mCurrentPageSize(0), 212 mFirstPacketInPage(true), 213 mCurrentPageSamples(0), 214 mNextLaceIndex(0), 215 mFirstDataOffset(-1) { 216 mCurrentPage.mNumSegments = 0; 217 218 vorbis_info_init(&mVi); 219 vorbis_comment_init(&mVc); 220 } 221 222 MyVorbisExtractor::~MyVorbisExtractor() { 223 vorbis_comment_clear(&mVc); 224 vorbis_info_clear(&mVi); 225 } 226 227 sp<MetaData> MyVorbisExtractor::getFormat() const { 228 return mMeta; 229 } 230 231 status_t MyVorbisExtractor::findNextPage( 232 off64_t startOffset, off64_t *pageOffset) { 233 *pageOffset = startOffset; 234 235 for (;;) { 236 char signature[4]; 237 ssize_t n = mSource->readAt(*pageOffset, &signature, 4); 238 239 if (n < 4) { 240 *pageOffset = 0; 241 242 return (n < 0) ? n : (status_t)ERROR_END_OF_STREAM; 243 } 244 245 if (!memcmp(signature, "OggS", 4)) { 246 if (*pageOffset > startOffset) { 247 LOGV("skipped %lld bytes of junk to reach next frame", 248 *pageOffset - startOffset); 249 } 250 251 return OK; 252 } 253 254 ++*pageOffset; 255 } 256 } 257 258 // Given the offset of the "current" page, find the page immediately preceding 259 // it (if any) and return its granule position. 260 // To do this we back up from the "current" page's offset until we find any 261 // page preceding it and then scan forward to just before the current page. 262 status_t MyVorbisExtractor::findPrevGranulePosition( 263 off64_t pageOffset, uint64_t *granulePos) { 264 *granulePos = 0; 265 266 off64_t prevPageOffset = 0; 267 off64_t prevGuess = pageOffset; 268 for (;;) { 269 if (prevGuess >= 5000) { 270 prevGuess -= 5000; 271 } else { 272 prevGuess = 0; 273 } 274 275 LOGV("backing up %lld bytes", pageOffset - prevGuess); 276 277 status_t err = findNextPage(prevGuess, &prevPageOffset); 278 if (err != OK) { 279 return err; 280 } 281 282 if (prevPageOffset < pageOffset || prevGuess == 0) { 283 break; 284 } 285 } 286 287 if (prevPageOffset == pageOffset) { 288 // We did not find a page preceding this one. 289 return UNKNOWN_ERROR; 290 } 291 292 LOGV("prevPageOffset at %lld, pageOffset at %lld", 293 prevPageOffset, pageOffset); 294 295 for (;;) { 296 Page prevPage; 297 ssize_t n = readPage(prevPageOffset, &prevPage); 298 299 if (n <= 0) { 300 return (status_t)n; 301 } 302 303 prevPageOffset += n; 304 305 if (prevPageOffset == pageOffset) { 306 *granulePos = prevPage.mGranulePosition; 307 return OK; 308 } 309 } 310 } 311 312 status_t MyVorbisExtractor::seekToTime(int64_t timeUs) { 313 if (mTableOfContents.isEmpty()) { 314 // Perform approximate seeking based on avg. bitrate. 315 316 off64_t pos = timeUs * approxBitrate() / 8000000ll; 317 318 LOGV("seeking to offset %lld", pos); 319 return seekToOffset(pos); 320 } 321 322 size_t left = 0; 323 size_t right = mTableOfContents.size(); 324 while (left < right) { 325 size_t center = left / 2 + right / 2 + (left & right & 1); 326 327 const TOCEntry &entry = mTableOfContents.itemAt(center); 328 329 if (timeUs < entry.mTimeUs) { 330 right = center; 331 } else if (timeUs > entry.mTimeUs) { 332 left = center + 1; 333 } else { 334 left = right = center; 335 break; 336 } 337 } 338 339 const TOCEntry &entry = mTableOfContents.itemAt(left); 340 341 LOGV("seeking to entry %d / %d at offset %lld", 342 left, mTableOfContents.size(), entry.mPageOffset); 343 344 return seekToOffset(entry.mPageOffset); 345 } 346 347 status_t MyVorbisExtractor::seekToOffset(off64_t offset) { 348 if (mFirstDataOffset >= 0 && offset < mFirstDataOffset) { 349 // Once we know where the actual audio data starts (past the headers) 350 // don't ever seek to anywhere before that. 351 offset = mFirstDataOffset; 352 } 353 354 off64_t pageOffset; 355 status_t err = findNextPage(offset, &pageOffset); 356 357 if (err != OK) { 358 return err; 359 } 360 361 // We found the page we wanted to seek to, but we'll also need 362 // the page preceding it to determine how many valid samples are on 363 // this page. 364 findPrevGranulePosition(pageOffset, &mPrevGranulePosition); 365 366 mOffset = pageOffset; 367 368 mCurrentPageSize = 0; 369 mFirstPacketInPage = true; 370 mCurrentPageSamples = 0; 371 mCurrentPage.mNumSegments = 0; 372 mNextLaceIndex = 0; 373 374 // XXX what if new page continues packet from last??? 375 376 return OK; 377 } 378 379 ssize_t MyVorbisExtractor::readPage(off64_t offset, Page *page) { 380 uint8_t header[27]; 381 ssize_t n; 382 if ((n = mSource->readAt(offset, header, sizeof(header))) 383 < (ssize_t)sizeof(header)) { 384 LOGV("failed to read %d bytes at offset 0x%016llx, got %ld bytes", 385 sizeof(header), offset, n); 386 387 if (n < 0) { 388 return n; 389 } else if (n == 0) { 390 return ERROR_END_OF_STREAM; 391 } else { 392 return ERROR_IO; 393 } 394 } 395 396 if (memcmp(header, "OggS", 4)) { 397 return ERROR_MALFORMED; 398 } 399 400 if (header[4] != 0) { 401 // Wrong version. 402 403 return ERROR_UNSUPPORTED; 404 } 405 406 page->mFlags = header[5]; 407 408 if (page->mFlags & ~7) { 409 // Only bits 0-2 are defined in version 0. 410 return ERROR_MALFORMED; 411 } 412 413 page->mGranulePosition = U64LE_AT(&header[6]); 414 415 #if 0 416 printf("granulePosition = %llu (0x%llx)\n", 417 page->mGranulePosition, page->mGranulePosition); 418 #endif 419 420 page->mSerialNo = U32LE_AT(&header[14]); 421 page->mPageNo = U32LE_AT(&header[18]); 422 423 page->mNumSegments = header[26]; 424 if (mSource->readAt( 425 offset + sizeof(header), page->mLace, page->mNumSegments) 426 < (ssize_t)page->mNumSegments) { 427 return ERROR_IO; 428 } 429 430 size_t totalSize = 0;; 431 for (size_t i = 0; i < page->mNumSegments; ++i) { 432 totalSize += page->mLace[i]; 433 } 434 435 #if 0 436 String8 tmp; 437 for (size_t i = 0; i < page->mNumSegments; ++i) { 438 char x[32]; 439 sprintf(x, "%s%u", i > 0 ? ", " : "", (unsigned)page->mLace[i]); 440 441 tmp.append(x); 442 } 443 444 LOGV("%c %s", page->mFlags & 1 ? '+' : ' ', tmp.string()); 445 #endif 446 447 return sizeof(header) + page->mNumSegments + totalSize; 448 } 449 450 status_t MyVorbisExtractor::readNextPacket(MediaBuffer **out) { 451 *out = NULL; 452 453 MediaBuffer *buffer = NULL; 454 int64_t timeUs = -1; 455 456 for (;;) { 457 size_t i; 458 size_t packetSize = 0; 459 bool gotFullPacket = false; 460 for (i = mNextLaceIndex; i < mCurrentPage.mNumSegments; ++i) { 461 uint8_t lace = mCurrentPage.mLace[i]; 462 463 packetSize += lace; 464 465 if (lace < 255) { 466 gotFullPacket = true; 467 ++i; 468 break; 469 } 470 } 471 472 if (mNextLaceIndex < mCurrentPage.mNumSegments) { 473 off64_t dataOffset = mOffset + 27 + mCurrentPage.mNumSegments; 474 for (size_t j = 0; j < mNextLaceIndex; ++j) { 475 dataOffset += mCurrentPage.mLace[j]; 476 } 477 478 size_t fullSize = packetSize; 479 if (buffer != NULL) { 480 fullSize += buffer->range_length(); 481 } 482 MediaBuffer *tmp = new MediaBuffer(fullSize); 483 if (buffer != NULL) { 484 memcpy(tmp->data(), buffer->data(), buffer->range_length()); 485 tmp->set_range(0, buffer->range_length()); 486 buffer->release(); 487 } else { 488 // XXX Not only is this not technically the correct time for 489 // this packet, we also stamp every packet in this page 490 // with the same time. This needs fixing later. 491 492 if (mVi.rate) { 493 // Rate may not have been initialized yet if we're currently 494 // reading the configuration packets... 495 // Fortunately, the timestamp doesn't matter for those. 496 timeUs = mCurrentPage.mGranulePosition * 1000000ll / mVi.rate; 497 } 498 tmp->set_range(0, 0); 499 } 500 buffer = tmp; 501 502 ssize_t n = mSource->readAt( 503 dataOffset, 504 (uint8_t *)buffer->data() + buffer->range_length(), 505 packetSize); 506 507 if (n < (ssize_t)packetSize) { 508 LOGV("failed to read %d bytes at 0x%016llx, got %ld bytes", 509 packetSize, dataOffset, n); 510 return ERROR_IO; 511 } 512 513 buffer->set_range(0, fullSize); 514 515 mNextLaceIndex = i; 516 517 if (gotFullPacket) { 518 // We've just read the entire packet. 519 520 if (timeUs >= 0) { 521 buffer->meta_data()->setInt64(kKeyTime, timeUs); 522 } 523 524 if (mFirstPacketInPage) { 525 buffer->meta_data()->setInt32( 526 kKeyValidSamples, mCurrentPageSamples); 527 mFirstPacketInPage = false; 528 } 529 530 *out = buffer; 531 532 return OK; 533 } 534 535 // fall through, the buffer now contains the start of the packet. 536 } 537 538 CHECK_EQ(mNextLaceIndex, mCurrentPage.mNumSegments); 539 540 mOffset += mCurrentPageSize; 541 ssize_t n = readPage(mOffset, &mCurrentPage); 542 543 if (n <= 0) { 544 if (buffer) { 545 buffer->release(); 546 buffer = NULL; 547 } 548 549 LOGV("readPage returned %ld", n); 550 551 return n < 0 ? n : (status_t)ERROR_END_OF_STREAM; 552 } 553 554 mCurrentPageSamples = 555 mCurrentPage.mGranulePosition - mPrevGranulePosition; 556 mFirstPacketInPage = true; 557 558 mPrevGranulePosition = mCurrentPage.mGranulePosition; 559 560 mCurrentPageSize = n; 561 mNextLaceIndex = 0; 562 563 if (buffer != NULL) { 564 if ((mCurrentPage.mFlags & 1) == 0) { 565 // This page does not continue the packet, i.e. the packet 566 // is already complete. 567 568 if (timeUs >= 0) { 569 buffer->meta_data()->setInt64(kKeyTime, timeUs); 570 } 571 572 buffer->meta_data()->setInt32( 573 kKeyValidSamples, mCurrentPageSamples); 574 mFirstPacketInPage = false; 575 576 *out = buffer; 577 578 return OK; 579 } 580 } 581 } 582 } 583 584 status_t MyVorbisExtractor::init() { 585 mMeta = new MetaData; 586 mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS); 587 588 MediaBuffer *packet; 589 status_t err; 590 if ((err = readNextPacket(&packet)) != OK) { 591 return err; 592 } 593 LOGV("read packet of size %d\n", packet->range_length()); 594 err = verifyHeader(packet, 1); 595 packet->release(); 596 packet = NULL; 597 if (err != OK) { 598 return err; 599 } 600 601 if ((err = readNextPacket(&packet)) != OK) { 602 return err; 603 } 604 LOGV("read packet of size %d\n", packet->range_length()); 605 err = verifyHeader(packet, 3); 606 packet->release(); 607 packet = NULL; 608 if (err != OK) { 609 return err; 610 } 611 612 if ((err = readNextPacket(&packet)) != OK) { 613 return err; 614 } 615 LOGV("read packet of size %d\n", packet->range_length()); 616 err = verifyHeader(packet, 5); 617 packet->release(); 618 packet = NULL; 619 if (err != OK) { 620 return err; 621 } 622 623 mFirstDataOffset = mOffset + mCurrentPageSize; 624 625 off64_t size; 626 uint64_t lastGranulePosition; 627 if (!(mSource->flags() & DataSource::kIsCachingDataSource) 628 && mSource->getSize(&size) == OK 629 && findPrevGranulePosition(size, &lastGranulePosition) == OK) { 630 // Let's assume it's cheap to seek to the end. 631 // The granule position of the final page in the stream will 632 // give us the exact duration of the content, something that 633 // we can only approximate using avg. bitrate if seeking to 634 // the end is too expensive or impossible (live streaming). 635 636 int64_t durationUs = lastGranulePosition * 1000000ll / mVi.rate; 637 638 mMeta->setInt64(kKeyDuration, durationUs); 639 640 buildTableOfContents(); 641 } 642 643 return OK; 644 } 645 646 void MyVorbisExtractor::buildTableOfContents() { 647 off64_t offset = mFirstDataOffset; 648 Page page; 649 ssize_t pageSize; 650 while ((pageSize = readPage(offset, &page)) > 0) { 651 mTableOfContents.push(); 652 653 TOCEntry &entry = 654 mTableOfContents.editItemAt(mTableOfContents.size() - 1); 655 656 entry.mPageOffset = offset; 657 entry.mTimeUs = page.mGranulePosition * 1000000ll / mVi.rate; 658 659 offset += (size_t)pageSize; 660 } 661 662 // Limit the maximum amount of RAM we spend on the table of contents, 663 // if necessary thin out the table evenly to trim it down to maximum 664 // size. 665 666 static const size_t kMaxTOCSize = 8192; 667 static const size_t kMaxNumTOCEntries = kMaxTOCSize / sizeof(TOCEntry); 668 669 size_t numerator = mTableOfContents.size(); 670 671 if (numerator > kMaxNumTOCEntries) { 672 size_t denom = numerator - kMaxNumTOCEntries; 673 674 size_t accum = 0; 675 for (ssize_t i = mTableOfContents.size() - 1; i >= 0; --i) { 676 accum += denom; 677 if (accum >= numerator) { 678 mTableOfContents.removeAt(i); 679 accum -= numerator; 680 } 681 } 682 } 683 } 684 685 status_t MyVorbisExtractor::verifyHeader( 686 MediaBuffer *buffer, uint8_t type) { 687 const uint8_t *data = 688 (const uint8_t *)buffer->data() + buffer->range_offset(); 689 690 size_t size = buffer->range_length(); 691 692 if (size < 7 || data[0] != type || memcmp(&data[1], "vorbis", 6)) { 693 return ERROR_MALFORMED; 694 } 695 696 ogg_buffer buf; 697 buf.data = (uint8_t *)data; 698 buf.size = size; 699 buf.refcount = 1; 700 buf.ptr.owner = NULL; 701 702 ogg_reference ref; 703 ref.buffer = &buf; 704 ref.begin = 0; 705 ref.length = size; 706 ref.next = NULL; 707 708 oggpack_buffer bits; 709 oggpack_readinit(&bits, &ref); 710 711 CHECK_EQ(oggpack_read(&bits, 8), type); 712 for (size_t i = 0; i < 6; ++i) { 713 oggpack_read(&bits, 8); // skip 'vorbis' 714 } 715 716 switch (type) { 717 case 1: 718 { 719 CHECK_EQ(0, _vorbis_unpack_info(&mVi, &bits)); 720 721 mMeta->setData(kKeyVorbisInfo, 0, data, size); 722 mMeta->setInt32(kKeySampleRate, mVi.rate); 723 mMeta->setInt32(kKeyChannelCount, mVi.channels); 724 725 LOGV("lower-bitrate = %ld", mVi.bitrate_lower); 726 LOGV("upper-bitrate = %ld", mVi.bitrate_upper); 727 LOGV("nominal-bitrate = %ld", mVi.bitrate_nominal); 728 LOGV("window-bitrate = %ld", mVi.bitrate_window); 729 730 off64_t size; 731 if (mSource->getSize(&size) == OK) { 732 uint64_t bps = approxBitrate(); 733 if (bps != 0) { 734 mMeta->setInt64(kKeyDuration, size * 8000000ll / bps); 735 } 736 } 737 break; 738 } 739 740 case 3: 741 { 742 if (0 != _vorbis_unpack_comment(&mVc, &bits)) { 743 return ERROR_MALFORMED; 744 } 745 746 parseFileMetaData(); 747 break; 748 } 749 750 case 5: 751 { 752 if (0 != _vorbis_unpack_books(&mVi, &bits)) { 753 return ERROR_MALFORMED; 754 } 755 756 mMeta->setData(kKeyVorbisBooks, 0, data, size); 757 break; 758 } 759 } 760 761 return OK; 762 } 763 764 uint64_t MyVorbisExtractor::approxBitrate() { 765 if (mVi.bitrate_nominal != 0) { 766 return mVi.bitrate_nominal; 767 } 768 769 return (mVi.bitrate_lower + mVi.bitrate_upper) / 2; 770 } 771 772 void MyVorbisExtractor::parseFileMetaData() { 773 mFileMeta = new MetaData; 774 mFileMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_CONTAINER_OGG); 775 776 for (int i = 0; i < mVc.comments; ++i) { 777 const char *comment = mVc.user_comments[i]; 778 size_t commentLength = mVc.comment_lengths[i]; 779 parseVorbisComment(mFileMeta, comment, commentLength); 780 //LOGI("comment #%d: '%s'", i + 1, mVc.user_comments[i]); 781 } 782 } 783 784 void parseVorbisComment( 785 const sp<MetaData> &fileMeta, const char *comment, size_t commentLength) 786 { 787 struct { 788 const char *const mTag; 789 uint32_t mKey; 790 } kMap[] = { 791 { "TITLE", kKeyTitle }, 792 { "ARTIST", kKeyArtist }, 793 { "ALBUMARTIST", kKeyAlbumArtist }, 794 { "ALBUM ARTIST", kKeyAlbumArtist }, 795 { "COMPILATION", kKeyCompilation }, 796 { "ALBUM", kKeyAlbum }, 797 { "COMPOSER", kKeyComposer }, 798 { "GENRE", kKeyGenre }, 799 { "AUTHOR", kKeyAuthor }, 800 { "TRACKNUMBER", kKeyCDTrackNumber }, 801 { "DISCNUMBER", kKeyDiscNumber }, 802 { "DATE", kKeyDate }, 803 { "LYRICIST", kKeyWriter }, 804 { "METADATA_BLOCK_PICTURE", kKeyAlbumArt }, 805 { "ANDROID_LOOP", kKeyAutoLoop }, 806 }; 807 808 for (size_t j = 0; j < sizeof(kMap) / sizeof(kMap[0]); ++j) { 809 size_t tagLen = strlen(kMap[j].mTag); 810 if (!strncasecmp(kMap[j].mTag, comment, tagLen) 811 && comment[tagLen] == '=') { 812 if (kMap[j].mKey == kKeyAlbumArt) { 813 extractAlbumArt( 814 fileMeta, 815 &comment[tagLen + 1], 816 commentLength - tagLen - 1); 817 } else if (kMap[j].mKey == kKeyAutoLoop) { 818 if (!strcasecmp(&comment[tagLen + 1], "true")) { 819 fileMeta->setInt32(kKeyAutoLoop, true); 820 } 821 } else { 822 fileMeta->setCString(kMap[j].mKey, &comment[tagLen + 1]); 823 } 824 } 825 } 826 827 } 828 829 // The returned buffer should be free()d. 830 static uint8_t *DecodeBase64(const char *s, size_t size, size_t *outSize) { 831 *outSize = 0; 832 833 if ((size % 4) != 0) { 834 return NULL; 835 } 836 837 size_t n = size; 838 size_t padding = 0; 839 if (n >= 1 && s[n - 1] == '=') { 840 padding = 1; 841 842 if (n >= 2 && s[n - 2] == '=') { 843 padding = 2; 844 } 845 } 846 847 size_t outLen = 3 * size / 4 - padding; 848 849 *outSize = outLen; 850 851 void *buffer = malloc(outLen); 852 853 uint8_t *out = (uint8_t *)buffer; 854 size_t j = 0; 855 uint32_t accum = 0; 856 for (size_t i = 0; i < n; ++i) { 857 char c = s[i]; 858 unsigned value; 859 if (c >= 'A' && c <= 'Z') { 860 value = c - 'A'; 861 } else if (c >= 'a' && c <= 'z') { 862 value = 26 + c - 'a'; 863 } else if (c >= '0' && c <= '9') { 864 value = 52 + c - '0'; 865 } else if (c == '+') { 866 value = 62; 867 } else if (c == '/') { 868 value = 63; 869 } else if (c != '=') { 870 return NULL; 871 } else { 872 if (i < n - padding) { 873 return NULL; 874 } 875 876 value = 0; 877 } 878 879 accum = (accum << 6) | value; 880 881 if (((i + 1) % 4) == 0) { 882 out[j++] = (accum >> 16); 883 884 if (j < outLen) { out[j++] = (accum >> 8) & 0xff; } 885 if (j < outLen) { out[j++] = accum & 0xff; } 886 887 accum = 0; 888 } 889 } 890 891 return (uint8_t *)buffer; 892 } 893 894 static void extractAlbumArt( 895 const sp<MetaData> &fileMeta, const void *data, size_t size) { 896 LOGV("extractAlbumArt from '%s'", (const char *)data); 897 898 size_t flacSize; 899 uint8_t *flac = DecodeBase64((const char *)data, size, &flacSize); 900 901 if (flac == NULL) { 902 LOGE("malformed base64 encoded data."); 903 return; 904 } 905 906 LOGV("got flac of size %d", flacSize); 907 908 uint32_t picType; 909 uint32_t typeLen; 910 uint32_t descLen; 911 uint32_t dataLen; 912 char type[128]; 913 914 if (flacSize < 8) { 915 goto exit; 916 } 917 918 picType = U32_AT(flac); 919 920 if (picType != 3) { 921 // This is not a front cover. 922 goto exit; 923 } 924 925 typeLen = U32_AT(&flac[4]); 926 if (typeLen + 1 > sizeof(type)) { 927 goto exit; 928 } 929 930 if (flacSize < 8 + typeLen) { 931 goto exit; 932 } 933 934 memcpy(type, &flac[8], typeLen); 935 type[typeLen] = '\0'; 936 937 LOGV("picType = %d, type = '%s'", picType, type); 938 939 if (!strcmp(type, "-->")) { 940 // This is not inline cover art, but an external url instead. 941 goto exit; 942 } 943 944 descLen = U32_AT(&flac[8 + typeLen]); 945 946 if (flacSize < 32 + typeLen + descLen) { 947 goto exit; 948 } 949 950 dataLen = U32_AT(&flac[8 + typeLen + 4 + descLen + 16]); 951 952 if (flacSize < 32 + typeLen + descLen + dataLen) { 953 goto exit; 954 } 955 956 LOGV("got image data, %d trailing bytes", 957 flacSize - 32 - typeLen - descLen - dataLen); 958 959 fileMeta->setData( 960 kKeyAlbumArt, 0, &flac[8 + typeLen + 4 + descLen + 20], dataLen); 961 962 fileMeta->setCString(kKeyAlbumArtMIME, type); 963 964 exit: 965 free(flac); 966 flac = NULL; 967 } 968 969 //////////////////////////////////////////////////////////////////////////////// 970 971 OggExtractor::OggExtractor(const sp<DataSource> &source) 972 : mDataSource(source), 973 mInitCheck(NO_INIT), 974 mImpl(NULL) { 975 mImpl = new MyVorbisExtractor(mDataSource); 976 mInitCheck = mImpl->seekToOffset(0); 977 978 if (mInitCheck == OK) { 979 mInitCheck = mImpl->init(); 980 } 981 } 982 983 OggExtractor::~OggExtractor() { 984 delete mImpl; 985 mImpl = NULL; 986 } 987 988 size_t OggExtractor::countTracks() { 989 return mInitCheck != OK ? 0 : 1; 990 } 991 992 sp<MediaSource> OggExtractor::getTrack(size_t index) { 993 if (index >= 1) { 994 return NULL; 995 } 996 997 return new OggSource(this); 998 } 999 1000 sp<MetaData> OggExtractor::getTrackMetaData( 1001 size_t index, uint32_t flags) { 1002 if (index >= 1) { 1003 return NULL; 1004 } 1005 1006 return mImpl->getFormat(); 1007 } 1008 1009 sp<MetaData> OggExtractor::getMetaData() { 1010 return mImpl->getFileMetaData(); 1011 } 1012 1013 bool SniffOgg( 1014 const sp<DataSource> &source, String8 *mimeType, float *confidence, 1015 sp<AMessage> *) { 1016 char tmp[4]; 1017 if (source->readAt(0, tmp, 4) < 4 || memcmp(tmp, "OggS", 4)) { 1018 return false; 1019 } 1020 1021 mimeType->setTo(MEDIA_MIMETYPE_CONTAINER_OGG); 1022 *confidence = 0.2f; 1023 1024 return true; 1025 } 1026 1027 } // namespace android 1028
