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
40 namespace 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...
46 static const uint32_t kMask = 0xfffe0c00;
47
Resync(const sp<DataSource> & source,uint32_t match_header,off64_t * inout_pos,off64_t * post_id3_pos,uint32_t * out_header)48 static 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
212 class MP3Source : public MediaSource {
213 public:
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
227 protected:
228 virtual ~MP3Source();
229
230 private:
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
MP3Extractor(const sp<DataSource> & source,const sp<AMessage> & meta)249 MP3Extractor::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
countTracks()399 size_t MP3Extractor::countTracks() {
400 return mInitCheck != OK ? 0 : 1;
401 }
402
getTrack(size_t index)403 sp<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
getTrackMetaData(size_t index,uint32_t)413 sp<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)
430 const size_t MP3Source::kMaxFrameSize = (1 << 12); /* 4096 bytes */
MP3Source(const sp<MetaData> & meta,const sp<DataSource> & source,off64_t first_frame_pos,uint32_t fixed_header,const sp<MP3Seeker> & seeker)431 MP3Source::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
~MP3Source()448 MP3Source::~MP3Source() {
449 if (mStarted) {
450 stop();
451 }
452 }
453
start(MetaData *)454 status_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
stop()472 status_t MP3Source::stop() {
473 CHECK(mStarted);
474
475 delete mGroup;
476 mGroup = NULL;
477
478 mStarted = false;
479
480 return OK;
481 }
482
getFormat()483 sp<MetaData> MP3Source::getFormat() {
484 return mMeta;
485 }
486
read(MediaBuffer ** out,const ReadOptions * options)487 status_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
getMetaData()596 sp<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
SniffMP3(const sp<DataSource> & source,String8 * mimeType,float * confidence,sp<AMessage> * meta)662 bool 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