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 *inout_pos, *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 >= *inout_pos + kMaxBytesChecked) { 107 // Don't scan forever. 108 ALOGV("giving up at offset %lld", 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)", 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, 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 286 size_t frame_size; 287 int sample_rate; 288 int num_channels; 289 int bitrate; 290 GetMPEGAudioFrameSize( 291 header, &frame_size, &sample_rate, &num_channels, &bitrate); 292 293 unsigned layer = 4 - ((header >> 17) & 3); 294 295 mMeta = new MetaData; 296 297 switch (layer) { 298 case 1: 299 mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I); 300 break; 301 case 2: 302 mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II); 303 break; 304 case 3: 305 mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG); 306 break; 307 default: 308 TRESPASS(); 309 } 310 311 mMeta->setInt32(kKeySampleRate, sample_rate); 312 mMeta->setInt32(kKeyBitRate, bitrate * 1000); 313 mMeta->setInt32(kKeyChannelCount, num_channels); 314 315 sp<XINGSeeker> seeker = XINGSeeker::CreateFromSource(mDataSource, mFirstFramePos); 316 317 if (seeker == NULL) { 318 mSeeker = VBRISeeker::CreateFromSource(mDataSource, post_id3_pos); 319 } else { 320 mSeeker = seeker; 321 int encd = seeker->getEncoderDelay(); 322 int encp = seeker->getEncoderPadding(); 323 if (encd != 0 || encp != 0) { 324 mMeta->setInt32(kKeyEncoderDelay, encd); 325 mMeta->setInt32(kKeyEncoderPadding, encp); 326 } 327 } 328 329 if (mSeeker != NULL) { 330 // While it is safe to send the XING/VBRI frame to the decoder, this will 331 // result in an extra 1152 samples being output. The real first frame to 332 // decode is after the XING/VBRI frame, so skip there. 333 mFirstFramePos += frame_size; 334 } 335 336 int64_t durationUs; 337 338 if (mSeeker == NULL || !mSeeker->getDuration(&durationUs)) { 339 off64_t fileSize; 340 if (mDataSource->getSize(&fileSize) == OK) { 341 durationUs = 8000LL * (fileSize - mFirstFramePos) / bitrate; 342 } else { 343 durationUs = -1; 344 } 345 } 346 347 if (durationUs >= 0) { 348 mMeta->setInt64(kKeyDuration, durationUs); 349 } 350 351 mInitCheck = OK; 352 353 // get iTunes-style gapless info if present 354 ID3 id3(mDataSource); 355 if (id3.isValid()) { 356 ID3::Iterator *com = new ID3::Iterator(id3, "COM"); 357 if (com->done()) { 358 delete com; 359 com = new ID3::Iterator(id3, "COMM"); 360 } 361 while(!com->done()) { 362 String8 commentdesc; 363 String8 commentvalue; 364 com->getString(&commentdesc, &commentvalue); 365 const char * desc = commentdesc.string(); 366 const char * value = commentvalue.string(); 367 368 // first 3 characters are the language, which we don't care about 369 if(strlen(desc) > 3 && strcmp(desc + 3, "iTunSMPB") == 0) { 370 371 int32_t delay, padding; 372 if (sscanf(value, " %*x %x %x %*x", &delay, &padding) == 2) { 373 mMeta->setInt32(kKeyEncoderDelay, delay); 374 mMeta->setInt32(kKeyEncoderPadding, padding); 375 } 376 break; 377 } 378 com->next(); 379 } 380 delete com; 381 com = NULL; 382 } 383} 384 385size_t MP3Extractor::countTracks() { 386 return mInitCheck != OK ? 0 : 1; 387} 388 389sp<MediaSource> MP3Extractor::getTrack(size_t index) { 390 if (mInitCheck != OK || index != 0) { 391 return NULL; 392 } 393 394 return new MP3Source( 395 mMeta, mDataSource, mFirstFramePos, mFixedHeader, 396 mSeeker); 397} 398 399sp<MetaData> MP3Extractor::getTrackMetaData(size_t index, uint32_t flags) { 400 if (mInitCheck != OK || index != 0) { 401 return NULL; 402 } 403 404 return mMeta; 405} 406 407//////////////////////////////////////////////////////////////////////////////// 408 409// The theoretical maximum frame size for an MPEG audio stream should occur 410// while playing a Layer 2, MPEGv2.5 audio stream at 160kbps (with padding). 411// The size of this frame should be... 412// ((1152 samples/frame * 160000 bits/sec) / 413// (8000 samples/sec * 8 bits/byte)) + 1 padding byte/frame = 2881 bytes/frame. 414// Set our max frame size to the nearest power of 2 above this size (aka, 4kB) 415const size_t MP3Source::kMaxFrameSize = (1 << 12); /* 4096 bytes */ 416MP3Source::MP3Source( 417 const sp<MetaData> &meta, const sp<DataSource> &source, 418 off64_t first_frame_pos, uint32_t fixed_header, 419 const sp<MP3Seeker> &seeker) 420 : mMeta(meta), 421 mDataSource(source), 422 mFirstFramePos(first_frame_pos), 423 mFixedHeader(fixed_header), 424 mCurrentPos(0), 425 mCurrentTimeUs(0), 426 mStarted(false), 427 mSeeker(seeker), 428 mGroup(NULL), 429 mBasisTimeUs(0), 430 mSamplesRead(0) { 431} 432 433MP3Source::~MP3Source() { 434 if (mStarted) { 435 stop(); 436 } 437} 438 439status_t MP3Source::start(MetaData *) { 440 CHECK(!mStarted); 441 442 mGroup = new MediaBufferGroup; 443 444 mGroup->add_buffer(new MediaBuffer(kMaxFrameSize)); 445 446 mCurrentPos = mFirstFramePos; 447 mCurrentTimeUs = 0; 448 449 mBasisTimeUs = mCurrentTimeUs; 450 mSamplesRead = 0; 451 452 mStarted = true; 453 454 return OK; 455} 456 457status_t MP3Source::stop() { 458 CHECK(mStarted); 459 460 delete mGroup; 461 mGroup = NULL; 462 463 mStarted = false; 464 465 return OK; 466} 467 468sp<MetaData> MP3Source::getFormat() { 469 return mMeta; 470} 471 472status_t MP3Source::read( 473 MediaBuffer **out, const ReadOptions *options) { 474 *out = NULL; 475 476 int64_t seekTimeUs; 477 ReadOptions::SeekMode mode; 478 bool seekCBR = false; 479 480 if (options != NULL && options->getSeekTo(&seekTimeUs, &mode)) { 481 int64_t actualSeekTimeUs = seekTimeUs; 482 if (mSeeker == NULL 483 || !mSeeker->getOffsetForTime(&actualSeekTimeUs, &mCurrentPos)) { 484 int32_t bitrate; 485 if (!mMeta->findInt32(kKeyBitRate, &bitrate)) { 486 // bitrate is in bits/sec. 487 ALOGI("no bitrate"); 488 489 return ERROR_UNSUPPORTED; 490 } 491 492 mCurrentTimeUs = seekTimeUs; 493 mCurrentPos = mFirstFramePos + seekTimeUs * bitrate / 8000000; 494 seekCBR = true; 495 } else { 496 mCurrentTimeUs = actualSeekTimeUs; 497 } 498 499 mBasisTimeUs = mCurrentTimeUs; 500 mSamplesRead = 0; 501 } 502 503 MediaBuffer *buffer; 504 status_t err = mGroup->acquire_buffer(&buffer); 505 if (err != OK) { 506 return err; 507 } 508 509 size_t frame_size; 510 int bitrate; 511 int num_samples; 512 int sample_rate; 513 for (;;) { 514 ssize_t n = mDataSource->readAt(mCurrentPos, buffer->data(), 4); 515 if (n < 4) { 516 buffer->release(); 517 buffer = NULL; 518 519 return ERROR_END_OF_STREAM; 520 } 521 522 uint32_t header = U32_AT((const uint8_t *)buffer->data()); 523 524 if ((header & kMask) == (mFixedHeader & kMask) 525 && GetMPEGAudioFrameSize( 526 header, &frame_size, &sample_rate, NULL, 527 &bitrate, &num_samples)) { 528 529 // re-calculate mCurrentTimeUs because we might have called Resync() 530 if (seekCBR) { 531 mCurrentTimeUs = (mCurrentPos - mFirstFramePos) * 8000 / bitrate; 532 mBasisTimeUs = mCurrentTimeUs; 533 } 534 535 break; 536 } 537 538 // Lost sync. 539 ALOGV("lost sync! header = 0x%08x, old header = 0x%08x\n", header, mFixedHeader); 540 541 off64_t pos = mCurrentPos; 542 if (!Resync(mDataSource, mFixedHeader, &pos, NULL, NULL)) { 543 ALOGE("Unable to resync. Signalling end of stream."); 544 545 buffer->release(); 546 buffer = NULL; 547 548 return ERROR_END_OF_STREAM; 549 } 550 551 mCurrentPos = pos; 552 553 // Try again with the new position. 554 } 555 556 CHECK(frame_size <= buffer->size()); 557 558 ssize_t n = mDataSource->readAt(mCurrentPos, buffer->data(), frame_size); 559 if (n < (ssize_t)frame_size) { 560 buffer->release(); 561 buffer = NULL; 562 563 return ERROR_END_OF_STREAM; 564 } 565 566 buffer->set_range(0, frame_size); 567 568 buffer->meta_data()->setInt64(kKeyTime, mCurrentTimeUs); 569 buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1); 570 571 mCurrentPos += frame_size; 572 573 mSamplesRead += num_samples; 574 mCurrentTimeUs = mBasisTimeUs + ((mSamplesRead * 1000000) / sample_rate); 575 576 *out = buffer; 577 578 return OK; 579} 580 581sp<MetaData> MP3Extractor::getMetaData() { 582 sp<MetaData> meta = new MetaData; 583 584 if (mInitCheck != OK) { 585 return meta; 586 } 587 588 meta->setCString(kKeyMIMEType, "audio/mpeg"); 589 590 ID3 id3(mDataSource); 591 592 if (!id3.isValid()) { 593 return meta; 594 } 595 596 struct Map { 597 int key; 598 const char *tag1; 599 const char *tag2; 600 }; 601 static const Map kMap[] = { 602 { kKeyAlbum, "TALB", "TAL" }, 603 { kKeyArtist, "TPE1", "TP1" }, 604 { kKeyAlbumArtist, "TPE2", "TP2" }, 605 { kKeyComposer, "TCOM", "TCM" }, 606 { kKeyGenre, "TCON", "TCO" }, 607 { kKeyTitle, "TIT2", "TT2" }, 608 { kKeyYear, "TYE", "TYER" }, 609 { kKeyAuthor, "TXT", "TEXT" }, 610 { kKeyCDTrackNumber, "TRK", "TRCK" }, 611 { kKeyDiscNumber, "TPA", "TPOS" }, 612 { kKeyCompilation, "TCP", "TCMP" }, 613 }; 614 static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]); 615 616 for (size_t i = 0; i < kNumMapEntries; ++i) { 617 ID3::Iterator *it = new ID3::Iterator(id3, kMap[i].tag1); 618 if (it->done()) { 619 delete it; 620 it = new ID3::Iterator(id3, kMap[i].tag2); 621 } 622 623 if (it->done()) { 624 delete it; 625 continue; 626 } 627 628 String8 s; 629 it->getString(&s); 630 delete it; 631 632 meta->setCString(kMap[i].key, s); 633 } 634 635 size_t dataSize; 636 String8 mime; 637 const void *data = id3.getAlbumArt(&dataSize, &mime); 638 639 if (data) { 640 meta->setData(kKeyAlbumArt, MetaData::TYPE_NONE, data, dataSize); 641 meta->setCString(kKeyAlbumArtMIME, mime.string()); 642 } 643 644 return meta; 645} 646 647bool SniffMP3( 648 const sp<DataSource> &source, String8 *mimeType, 649 float *confidence, sp<AMessage> *meta) { 650 off64_t pos = 0; 651 off64_t post_id3_pos; 652 uint32_t header; 653 if (!Resync(source, 0, &pos, &post_id3_pos, &header)) { 654 return false; 655 } 656 657 *meta = new AMessage; 658 (*meta)->setInt64("offset", pos); 659 (*meta)->setInt32("header", header); 660 (*meta)->setInt64("post-id3-offset", post_id3_pos); 661 662 *mimeType = MEDIA_MIMETYPE_AUDIO_MPEG; 663 *confidence = 0.2f; 664 665 return true; 666} 667 668} // namespace android 669