1/* 2 * Copyright (C) 2009 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 "MP3Extractor" 19#include <utils/Log.h> 20 21#include "include/MP3Extractor.h" 22 23#include "include/avc_utils.h" 24#include "include/ID3.h" 25#include "include/VBRISeeker.h" 26#include "include/XINGSeeker.h" 27 28#include <media/stagefright/foundation/ADebug.h> 29#include <media/stagefright/foundation/AMessage.h> 30#include <media/stagefright/DataSource.h> 31#include <media/stagefright/MediaBuffer.h> 32#include <media/stagefright/MediaBufferGroup.h> 33#include <media/stagefright/MediaDefs.h> 34#include <media/stagefright/MediaErrors.h> 35#include <media/stagefright/MediaSource.h> 36#include <media/stagefright/MetaData.h> 37#include <media/stagefright/Utils.h> 38#include <utils/String8.h> 39 40namespace android { 41 42// Everything must match except for 43// protection, bitrate, padding, private bits, mode, mode extension, 44// copyright bit, original bit and emphasis. 45// Yes ... there are things that must indeed match... 46static const uint32_t kMask = 0xfffe0c00; 47 48static bool Resync( 49 const sp<DataSource> &source, uint32_t match_header, 50 off64_t *inout_pos, off64_t *post_id3_pos, uint32_t *out_header) { 51 if (post_id3_pos != NULL) { 52 *post_id3_pos = 0; 53 } 54 55 if (*inout_pos == 0) { 56 // Skip an optional ID3 header if syncing at the very beginning 57 // of the datasource. 58 59 for (;;) { 60 uint8_t id3header[10]; 61 if (source->readAt(*inout_pos, id3header, sizeof(id3header)) 62 < (ssize_t)sizeof(id3header)) { 63 // If we can't even read these 10 bytes, we might as well bail 64 // out, even if there _were_ 10 bytes of valid mp3 audio data... 65 return false; 66 } 67 68 if (memcmp("ID3", id3header, 3)) { 69 break; 70 } 71 72 // Skip the ID3v2 header. 73 74 size_t len = 75 ((id3header[6] & 0x7f) << 21) 76 | ((id3header[7] & 0x7f) << 14) 77 | ((id3header[8] & 0x7f) << 7) 78 | (id3header[9] & 0x7f); 79 80 len += 10; 81 82 *inout_pos += len; 83 84 ALOGV("skipped ID3 tag, new starting offset is %lld (0x%016llx)", 85 (long long)*inout_pos, (long long)*inout_pos); 86 } 87 88 if (post_id3_pos != NULL) { 89 *post_id3_pos = *inout_pos; 90 } 91 } 92 93 off64_t pos = *inout_pos; 94 bool valid = false; 95 96 const size_t kMaxReadBytes = 1024; 97 const size_t kMaxBytesChecked = 128 * 1024; 98 uint8_t buf[kMaxReadBytes]; 99 ssize_t bytesToRead = kMaxReadBytes; 100 ssize_t totalBytesRead = 0; 101 ssize_t remainingBytes = 0; 102 bool reachEOS = false; 103 uint8_t *tmp = buf; 104 105 do { 106 if (pos >= (off64_t)(*inout_pos + kMaxBytesChecked)) { 107 // Don't scan forever. 108 ALOGV("giving up at offset %lld", (long long)pos); 109 break; 110 } 111 112 if (remainingBytes < 4) { 113 if (reachEOS) { 114 break; 115 } else { 116 memcpy(buf, tmp, remainingBytes); 117 bytesToRead = kMaxReadBytes - remainingBytes; 118 119 /* 120 * The next read position should start from the end of 121 * the last buffer, and thus should include the remaining 122 * bytes in the buffer. 123 */ 124 totalBytesRead = source->readAt(pos + remainingBytes, 125 buf + remainingBytes, 126 bytesToRead); 127 if (totalBytesRead <= 0) { 128 break; 129 } 130 reachEOS = (totalBytesRead != bytesToRead); 131 totalBytesRead += remainingBytes; 132 remainingBytes = totalBytesRead; 133 tmp = buf; 134 continue; 135 } 136 } 137 138 uint32_t header = U32_AT(tmp); 139 140 if (match_header != 0 && (header & kMask) != (match_header & kMask)) { 141 ++pos; 142 ++tmp; 143 --remainingBytes; 144 continue; 145 } 146 147 size_t frame_size; 148 int sample_rate, num_channels, bitrate; 149 if (!GetMPEGAudioFrameSize( 150 header, &frame_size, 151 &sample_rate, &num_channels, &bitrate)) { 152 ++pos; 153 ++tmp; 154 --remainingBytes; 155 continue; 156 } 157 158 ALOGV("found possible 1st frame at %lld (header = 0x%08x)", (long long)pos, header); 159 160 // We found what looks like a valid frame, 161 // now find its successors. 162 163 off64_t test_pos = pos + frame_size; 164 165 valid = true; 166 for (int j = 0; j < 3; ++j) { 167 uint8_t tmp[4]; 168 if (source->readAt(test_pos, tmp, 4) < 4) { 169 valid = false; 170 break; 171 } 172 173 uint32_t test_header = U32_AT(tmp); 174 175 ALOGV("subsequent header is %08x", test_header); 176 177 if ((test_header & kMask) != (header & kMask)) { 178 valid = false; 179 break; 180 } 181 182 size_t test_frame_size; 183 if (!GetMPEGAudioFrameSize( 184 test_header, &test_frame_size)) { 185 valid = false; 186 break; 187 } 188 189 ALOGV("found subsequent frame #%d at %lld", j + 2, (long long)test_pos); 190 191 test_pos += test_frame_size; 192 } 193 194 if (valid) { 195 *inout_pos = pos; 196 197 if (out_header != NULL) { 198 *out_header = header; 199 } 200 } else { 201 ALOGV("no dice, no valid sequence of frames found."); 202 } 203 204 ++pos; 205 ++tmp; 206 --remainingBytes; 207 } while (!valid); 208 209 return valid; 210} 211 212class MP3Source : public MediaSource { 213public: 214 MP3Source( 215 const sp<MetaData> &meta, const sp<DataSource> &source, 216 off64_t first_frame_pos, uint32_t fixed_header, 217 const sp<MP3Seeker> &seeker); 218 219 virtual status_t start(MetaData *params = NULL); 220 virtual status_t stop(); 221 222 virtual sp<MetaData> getFormat(); 223 224 virtual status_t read( 225 MediaBuffer **buffer, const ReadOptions *options = NULL); 226 227protected: 228 virtual ~MP3Source(); 229 230private: 231 static const size_t kMaxFrameSize; 232 sp<MetaData> mMeta; 233 sp<DataSource> mDataSource; 234 off64_t mFirstFramePos; 235 uint32_t mFixedHeader; 236 off64_t mCurrentPos; 237 int64_t mCurrentTimeUs; 238 bool mStarted; 239 sp<MP3Seeker> mSeeker; 240 MediaBufferGroup *mGroup; 241 242 int64_t mBasisTimeUs; 243 int64_t mSamplesRead; 244 245 MP3Source(const MP3Source &); 246 MP3Source &operator=(const MP3Source &); 247}; 248 249MP3Extractor::MP3Extractor( 250 const sp<DataSource> &source, const sp<AMessage> &meta) 251 : mInitCheck(NO_INIT), 252 mDataSource(source), 253 mFirstFramePos(-1), 254 mFixedHeader(0) { 255 off64_t pos = 0; 256 off64_t post_id3_pos; 257 uint32_t header; 258 bool success; 259 260 int64_t meta_offset; 261 uint32_t meta_header; 262 int64_t meta_post_id3_offset; 263 if (meta != NULL 264 && meta->findInt64("offset", &meta_offset) 265 && meta->findInt32("header", (int32_t *)&meta_header) 266 && meta->findInt64("post-id3-offset", &meta_post_id3_offset)) { 267 // The sniffer has already done all the hard work for us, simply 268 // accept its judgement. 269 pos = (off64_t)meta_offset; 270 header = meta_header; 271 post_id3_pos = (off64_t)meta_post_id3_offset; 272 273 success = true; 274 } else { 275 success = Resync(mDataSource, 0, &pos, &post_id3_pos, &header); 276 } 277 278 if (!success) { 279 // mInitCheck will remain NO_INIT 280 return; 281 } 282 283 mFirstFramePos = pos; 284 mFixedHeader = header; 285 mMeta = new MetaData; 286 sp<XINGSeeker> seeker = XINGSeeker::CreateFromSource(mDataSource, mFirstFramePos); 287 288 if (seeker == NULL) { 289 mSeeker = VBRISeeker::CreateFromSource(mDataSource, post_id3_pos); 290 } else { 291 mSeeker = seeker; 292 int encd = seeker->getEncoderDelay(); 293 int encp = seeker->getEncoderPadding(); 294 if (encd != 0 || encp != 0) { 295 mMeta->setInt32(kKeyEncoderDelay, encd); 296 mMeta->setInt32(kKeyEncoderPadding, encp); 297 } 298 } 299 300 if (mSeeker != NULL) { 301 // While it is safe to send the XING/VBRI frame to the decoder, this will 302 // result in an extra 1152 samples being output. In addition, the bitrate 303 // of the Xing header might not match the rest of the file, which could 304 // lead to problems when seeking. The real first frame to decode is after 305 // the XING/VBRI frame, so skip there. 306 size_t frame_size; 307 int sample_rate; 308 int num_channels; 309 int bitrate; 310 GetMPEGAudioFrameSize( 311 header, &frame_size, &sample_rate, &num_channels, &bitrate); 312 pos += frame_size; 313 if (!Resync(mDataSource, 0, &pos, &post_id3_pos, &header)) { 314 // mInitCheck will remain NO_INIT 315 return; 316 } 317 mFirstFramePos = pos; 318 mFixedHeader = header; 319 } 320 321 size_t frame_size; 322 int sample_rate; 323 int num_channels; 324 int bitrate; 325 GetMPEGAudioFrameSize( 326 header, &frame_size, &sample_rate, &num_channels, &bitrate); 327 328 unsigned layer = 4 - ((header >> 17) & 3); 329 330 switch (layer) { 331 case 1: 332 mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I); 333 break; 334 case 2: 335 mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II); 336 break; 337 case 3: 338 mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG); 339 break; 340 default: 341 TRESPASS(); 342 } 343 344 mMeta->setInt32(kKeySampleRate, sample_rate); 345 mMeta->setInt32(kKeyBitRate, bitrate * 1000); 346 mMeta->setInt32(kKeyChannelCount, num_channels); 347 348 int64_t durationUs; 349 350 if (mSeeker == NULL || !mSeeker->getDuration(&durationUs)) { 351 off64_t fileSize; 352 if (mDataSource->getSize(&fileSize) == OK) { 353 durationUs = 8000LL * (fileSize - mFirstFramePos) / bitrate; 354 } else { 355 durationUs = -1; 356 } 357 } 358 359 if (durationUs >= 0) { 360 mMeta->setInt64(kKeyDuration, durationUs); 361 } 362 363 mInitCheck = OK; 364 365 // Get iTunes-style gapless info if present. 366 // When getting the id3 tag, skip the V1 tags to prevent the source cache 367 // from being iterated to the end of the file. 368 ID3 id3(mDataSource, true); 369 if (id3.isValid()) { 370 ID3::Iterator *com = new ID3::Iterator(id3, "COM"); 371 if (com->done()) { 372 delete com; 373 com = new ID3::Iterator(id3, "COMM"); 374 } 375 while(!com->done()) { 376 String8 commentdesc; 377 String8 commentvalue; 378 com->getString(&commentdesc, &commentvalue); 379 const char * desc = commentdesc.string(); 380 const char * value = commentvalue.string(); 381 382 // first 3 characters are the language, which we don't care about 383 if(strlen(desc) > 3 && strcmp(desc + 3, "iTunSMPB") == 0) { 384 385 int32_t delay, padding; 386 if (sscanf(value, " %*x %x %x %*x", &delay, &padding) == 2) { 387 mMeta->setInt32(kKeyEncoderDelay, delay); 388 mMeta->setInt32(kKeyEncoderPadding, padding); 389 } 390 break; 391 } 392 com->next(); 393 } 394 delete com; 395 com = NULL; 396 } 397} 398 399size_t MP3Extractor::countTracks() { 400 return mInitCheck != OK ? 0 : 1; 401} 402 403sp<MediaSource> MP3Extractor::getTrack(size_t index) { 404 if (mInitCheck != OK || index != 0) { 405 return NULL; 406 } 407 408 return new MP3Source( 409 mMeta, mDataSource, mFirstFramePos, mFixedHeader, 410 mSeeker); 411} 412 413sp<MetaData> MP3Extractor::getTrackMetaData( 414 size_t index, uint32_t /* flags */) { 415 if (mInitCheck != OK || index != 0) { 416 return NULL; 417 } 418 419 return mMeta; 420} 421 422//////////////////////////////////////////////////////////////////////////////// 423 424// The theoretical maximum frame size for an MPEG audio stream should occur 425// while playing a Layer 2, MPEGv2.5 audio stream at 160kbps (with padding). 426// The size of this frame should be... 427// ((1152 samples/frame * 160000 bits/sec) / 428// (8000 samples/sec * 8 bits/byte)) + 1 padding byte/frame = 2881 bytes/frame. 429// Set our max frame size to the nearest power of 2 above this size (aka, 4kB) 430const size_t MP3Source::kMaxFrameSize = (1 << 12); /* 4096 bytes */ 431MP3Source::MP3Source( 432 const sp<MetaData> &meta, const sp<DataSource> &source, 433 off64_t first_frame_pos, uint32_t fixed_header, 434 const sp<MP3Seeker> &seeker) 435 : mMeta(meta), 436 mDataSource(source), 437 mFirstFramePos(first_frame_pos), 438 mFixedHeader(fixed_header), 439 mCurrentPos(0), 440 mCurrentTimeUs(0), 441 mStarted(false), 442 mSeeker(seeker), 443 mGroup(NULL), 444 mBasisTimeUs(0), 445 mSamplesRead(0) { 446} 447 448MP3Source::~MP3Source() { 449 if (mStarted) { 450 stop(); 451 } 452} 453 454status_t MP3Source::start(MetaData *) { 455 CHECK(!mStarted); 456 457 mGroup = new MediaBufferGroup; 458 459 mGroup->add_buffer(new MediaBuffer(kMaxFrameSize)); 460 461 mCurrentPos = mFirstFramePos; 462 mCurrentTimeUs = 0; 463 464 mBasisTimeUs = mCurrentTimeUs; 465 mSamplesRead = 0; 466 467 mStarted = true; 468 469 return OK; 470} 471 472status_t MP3Source::stop() { 473 CHECK(mStarted); 474 475 delete mGroup; 476 mGroup = NULL; 477 478 mStarted = false; 479 480 return OK; 481} 482 483sp<MetaData> MP3Source::getFormat() { 484 return mMeta; 485} 486 487status_t MP3Source::read( 488 MediaBuffer **out, const ReadOptions *options) { 489 *out = NULL; 490 491 int64_t seekTimeUs; 492 ReadOptions::SeekMode mode; 493 bool seekCBR = false; 494 495 if (options != NULL && options->getSeekTo(&seekTimeUs, &mode)) { 496 int64_t actualSeekTimeUs = seekTimeUs; 497 if (mSeeker == NULL 498 || !mSeeker->getOffsetForTime(&actualSeekTimeUs, &mCurrentPos)) { 499 int32_t bitrate; 500 if (!mMeta->findInt32(kKeyBitRate, &bitrate)) { 501 // bitrate is in bits/sec. 502 ALOGI("no bitrate"); 503 504 return ERROR_UNSUPPORTED; 505 } 506 507 mCurrentTimeUs = seekTimeUs; 508 mCurrentPos = mFirstFramePos + seekTimeUs * bitrate / 8000000; 509 seekCBR = true; 510 } else { 511 mCurrentTimeUs = actualSeekTimeUs; 512 } 513 514 mBasisTimeUs = mCurrentTimeUs; 515 mSamplesRead = 0; 516 } 517 518 MediaBuffer *buffer; 519 status_t err = mGroup->acquire_buffer(&buffer); 520 if (err != OK) { 521 return err; 522 } 523 524 size_t frame_size; 525 int bitrate; 526 int num_samples; 527 int sample_rate; 528 for (;;) { 529 ssize_t n = mDataSource->readAt(mCurrentPos, buffer->data(), 4); 530 if (n < 4) { 531 buffer->release(); 532 buffer = NULL; 533 534 return ERROR_END_OF_STREAM; 535 } 536 537 uint32_t header = U32_AT((const uint8_t *)buffer->data()); 538 539 if ((header & kMask) == (mFixedHeader & kMask) 540 && GetMPEGAudioFrameSize( 541 header, &frame_size, &sample_rate, NULL, 542 &bitrate, &num_samples)) { 543 544 // re-calculate mCurrentTimeUs because we might have called Resync() 545 if (seekCBR) { 546 mCurrentTimeUs = (mCurrentPos - mFirstFramePos) * 8000 / bitrate; 547 mBasisTimeUs = mCurrentTimeUs; 548 } 549 550 break; 551 } 552 553 // Lost sync. 554 ALOGV("lost sync! header = 0x%08x, old header = 0x%08x\n", header, mFixedHeader); 555 556 off64_t pos = mCurrentPos; 557 if (!Resync(mDataSource, mFixedHeader, &pos, NULL, NULL)) { 558 ALOGE("Unable to resync. Signalling end of stream."); 559 560 buffer->release(); 561 buffer = NULL; 562 563 return ERROR_END_OF_STREAM; 564 } 565 566 mCurrentPos = pos; 567 568 // Try again with the new position. 569 } 570 571 CHECK(frame_size <= buffer->size()); 572 573 ssize_t n = mDataSource->readAt(mCurrentPos, buffer->data(), frame_size); 574 if (n < (ssize_t)frame_size) { 575 buffer->release(); 576 buffer = NULL; 577 578 return ERROR_END_OF_STREAM; 579 } 580 581 buffer->set_range(0, frame_size); 582 583 buffer->meta_data()->setInt64(kKeyTime, mCurrentTimeUs); 584 buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1); 585 586 mCurrentPos += frame_size; 587 588 mSamplesRead += num_samples; 589 mCurrentTimeUs = mBasisTimeUs + ((mSamplesRead * 1000000) / sample_rate); 590 591 *out = buffer; 592 593 return OK; 594} 595 596sp<MetaData> MP3Extractor::getMetaData() { 597 sp<MetaData> meta = new MetaData; 598 599 if (mInitCheck != OK) { 600 return meta; 601 } 602 603 meta->setCString(kKeyMIMEType, "audio/mpeg"); 604 605 ID3 id3(mDataSource); 606 607 if (!id3.isValid()) { 608 return meta; 609 } 610 611 struct Map { 612 int key; 613 const char *tag1; 614 const char *tag2; 615 }; 616 static const Map kMap[] = { 617 { kKeyAlbum, "TALB", "TAL" }, 618 { kKeyArtist, "TPE1", "TP1" }, 619 { kKeyAlbumArtist, "TPE2", "TP2" }, 620 { kKeyComposer, "TCOM", "TCM" }, 621 { kKeyGenre, "TCON", "TCO" }, 622 { kKeyTitle, "TIT2", "TT2" }, 623 { kKeyYear, "TYE", "TYER" }, 624 { kKeyAuthor, "TXT", "TEXT" }, 625 { kKeyCDTrackNumber, "TRK", "TRCK" }, 626 { kKeyDiscNumber, "TPA", "TPOS" }, 627 { kKeyCompilation, "TCP", "TCMP" }, 628 }; 629 static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]); 630 631 for (size_t i = 0; i < kNumMapEntries; ++i) { 632 ID3::Iterator *it = new ID3::Iterator(id3, kMap[i].tag1); 633 if (it->done()) { 634 delete it; 635 it = new ID3::Iterator(id3, kMap[i].tag2); 636 } 637 638 if (it->done()) { 639 delete it; 640 continue; 641 } 642 643 String8 s; 644 it->getString(&s); 645 delete it; 646 647 meta->setCString(kMap[i].key, s); 648 } 649 650 size_t dataSize; 651 String8 mime; 652 const void *data = id3.getAlbumArt(&dataSize, &mime); 653 654 if (data) { 655 meta->setData(kKeyAlbumArt, MetaData::TYPE_NONE, data, dataSize); 656 meta->setCString(kKeyAlbumArtMIME, mime.string()); 657 } 658 659 return meta; 660} 661 662bool SniffMP3( 663 const sp<DataSource> &source, String8 *mimeType, 664 float *confidence, sp<AMessage> *meta) { 665 off64_t pos = 0; 666 off64_t post_id3_pos; 667 uint32_t header; 668 if (!Resync(source, 0, &pos, &post_id3_pos, &header)) { 669 return false; 670 } 671 672 *meta = new AMessage; 673 (*meta)->setInt64("offset", pos); 674 (*meta)->setInt32("header", header); 675 (*meta)->setInt64("post-id3-offset", post_id3_pos); 676 677 *mimeType = MEDIA_MIMETYPE_AUDIO_MPEG; 678 *confidence = 0.2f; 679 680 return true; 681} 682 683} // namespace android 684