You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
691 lines
19 KiB
691 lines
19 KiB
/*
|
|
* Copyright (C) 2009 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "MP3Extractor"
|
|
#include <utils/Log.h>
|
|
|
|
#include "include/MP3Extractor.h"
|
|
|
|
#include "include/avc_utils.h"
|
|
#include "include/ID3.h"
|
|
#include "include/VBRISeeker.h"
|
|
#include "include/XINGSeeker.h"
|
|
|
|
#include <media/stagefright/foundation/ADebug.h>
|
|
#include <media/stagefright/foundation/AMessage.h>
|
|
#include <media/stagefright/DataSource.h>
|
|
#include <media/stagefright/MediaBuffer.h>
|
|
#include <media/stagefright/MediaBufferGroup.h>
|
|
#include <media/stagefright/MediaDefs.h>
|
|
#include <media/stagefright/MediaErrors.h>
|
|
#include <media/stagefright/MediaSource.h>
|
|
#include <media/stagefright/MetaData.h>
|
|
#include <media/stagefright/Utils.h>
|
|
#include <utils/String8.h>
|
|
|
|
namespace android {
|
|
|
|
// Everything must match except for
|
|
// protection, bitrate, padding, private bits, mode, mode extension,
|
|
// copyright bit, original bit and emphasis.
|
|
// Yes ... there are things that must indeed match...
|
|
static const uint32_t kMask = 0xfffe0c00;
|
|
|
|
static bool Resync(
|
|
const sp<DataSource> &source, uint32_t match_header,
|
|
off64_t *inout_pos, off64_t *post_id3_pos, uint32_t *out_header) {
|
|
if (post_id3_pos != NULL) {
|
|
*post_id3_pos = 0;
|
|
}
|
|
|
|
if (*inout_pos == 0) {
|
|
// Skip an optional ID3 header if syncing at the very beginning
|
|
// of the datasource.
|
|
|
|
for (;;) {
|
|
uint8_t id3header[10];
|
|
if (source->readAt(*inout_pos, id3header, sizeof(id3header))
|
|
< (ssize_t)sizeof(id3header)) {
|
|
// If we can't even read these 10 bytes, we might as well bail
|
|
// out, even if there _were_ 10 bytes of valid mp3 audio data...
|
|
return false;
|
|
}
|
|
|
|
if (memcmp("ID3", id3header, 3)) {
|
|
break;
|
|
}
|
|
|
|
// Skip the ID3v2 header.
|
|
|
|
size_t len =
|
|
((id3header[6] & 0x7f) << 21)
|
|
| ((id3header[7] & 0x7f) << 14)
|
|
| ((id3header[8] & 0x7f) << 7)
|
|
| (id3header[9] & 0x7f);
|
|
|
|
len += 10;
|
|
|
|
*inout_pos += len;
|
|
|
|
ALOGV("skipped ID3 tag, new starting offset is %lld (0x%016llx)",
|
|
(long long)*inout_pos, (long long)*inout_pos);
|
|
}
|
|
|
|
if (post_id3_pos != NULL) {
|
|
*post_id3_pos = *inout_pos;
|
|
}
|
|
}
|
|
|
|
off64_t pos = *inout_pos;
|
|
bool valid = false;
|
|
|
|
const size_t kMaxReadBytes = 1024;
|
|
const size_t kMaxBytesChecked = 128 * 1024;
|
|
uint8_t buf[kMaxReadBytes];
|
|
ssize_t bytesToRead = kMaxReadBytes;
|
|
ssize_t totalBytesRead = 0;
|
|
ssize_t remainingBytes = 0;
|
|
bool reachEOS = false;
|
|
uint8_t *tmp = buf;
|
|
|
|
do {
|
|
if (pos >= (off64_t)(*inout_pos + kMaxBytesChecked)) {
|
|
// Don't scan forever.
|
|
ALOGV("giving up at offset %lld", (long long)pos);
|
|
break;
|
|
}
|
|
|
|
if (remainingBytes < 4) {
|
|
if (reachEOS) {
|
|
break;
|
|
} else {
|
|
memcpy(buf, tmp, remainingBytes);
|
|
bytesToRead = kMaxReadBytes - remainingBytes;
|
|
|
|
/*
|
|
* The next read position should start from the end of
|
|
* the last buffer, and thus should include the remaining
|
|
* bytes in the buffer.
|
|
*/
|
|
totalBytesRead = source->readAt(pos + remainingBytes,
|
|
buf + remainingBytes,
|
|
bytesToRead);
|
|
if (totalBytesRead <= 0) {
|
|
break;
|
|
}
|
|
reachEOS = (totalBytesRead != bytesToRead);
|
|
totalBytesRead += remainingBytes;
|
|
remainingBytes = totalBytesRead;
|
|
tmp = buf;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
uint32_t header = U32_AT(tmp);
|
|
|
|
if (match_header != 0 && (header & kMask) != (match_header & kMask)) {
|
|
++pos;
|
|
++tmp;
|
|
--remainingBytes;
|
|
continue;
|
|
}
|
|
|
|
size_t frame_size;
|
|
int sample_rate, num_channels, bitrate;
|
|
if (!GetMPEGAudioFrameSize(
|
|
header, &frame_size,
|
|
&sample_rate, &num_channels, &bitrate)) {
|
|
++pos;
|
|
++tmp;
|
|
--remainingBytes;
|
|
continue;
|
|
}
|
|
|
|
ALOGV("found possible 1st frame at %lld (header = 0x%08x)", (long long)pos, header);
|
|
|
|
// We found what looks like a valid frame,
|
|
// now find its successors.
|
|
|
|
off64_t test_pos = pos + frame_size;
|
|
|
|
valid = true;
|
|
for (int j = 0; j < 3; ++j) {
|
|
uint8_t tmp[4];
|
|
if (source->readAt(test_pos, tmp, 4) < 4) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
|
|
uint32_t test_header = U32_AT(tmp);
|
|
|
|
ALOGV("subsequent header is %08x", test_header);
|
|
|
|
if ((test_header & kMask) != (header & kMask)) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
|
|
size_t test_frame_size;
|
|
if (!GetMPEGAudioFrameSize(
|
|
test_header, &test_frame_size)) {
|
|
valid = false;
|
|
break;
|
|
}
|
|
|
|
ALOGV("found subsequent frame #%d at %lld", j + 2, (long long)test_pos);
|
|
|
|
test_pos += test_frame_size;
|
|
}
|
|
|
|
if (valid) {
|
|
*inout_pos = pos;
|
|
|
|
if (out_header != NULL) {
|
|
*out_header = header;
|
|
}
|
|
} else {
|
|
ALOGV("no dice, no valid sequence of frames found.");
|
|
}
|
|
|
|
++pos;
|
|
++tmp;
|
|
--remainingBytes;
|
|
} while (!valid);
|
|
|
|
return valid;
|
|
}
|
|
|
|
class MP3Source : public MediaSource {
|
|
public:
|
|
MP3Source(
|
|
const sp<MetaData> &meta, const sp<DataSource> &source,
|
|
off64_t first_frame_pos, uint32_t fixed_header,
|
|
const sp<MP3Seeker> &seeker);
|
|
|
|
virtual status_t start(MetaData *params = NULL);
|
|
virtual status_t stop();
|
|
|
|
virtual sp<MetaData> getFormat();
|
|
|
|
virtual status_t read(
|
|
MediaBuffer **buffer, const ReadOptions *options = NULL);
|
|
|
|
protected:
|
|
virtual ~MP3Source();
|
|
|
|
private:
|
|
static const size_t kMaxFrameSize;
|
|
sp<MetaData> mMeta;
|
|
sp<DataSource> mDataSource;
|
|
off64_t mFirstFramePos;
|
|
uint32_t mFixedHeader;
|
|
off64_t mCurrentPos;
|
|
int64_t mCurrentTimeUs;
|
|
bool mStarted;
|
|
sp<MP3Seeker> mSeeker;
|
|
MediaBufferGroup *mGroup;
|
|
|
|
int64_t mBasisTimeUs;
|
|
int64_t mSamplesRead;
|
|
|
|
MP3Source(const MP3Source &);
|
|
MP3Source &operator=(const MP3Source &);
|
|
};
|
|
|
|
MP3Extractor::MP3Extractor(
|
|
const sp<DataSource> &source, const sp<AMessage> &meta)
|
|
: mInitCheck(NO_INIT),
|
|
mDataSource(source),
|
|
mFirstFramePos(-1),
|
|
mFixedHeader(0) {
|
|
|
|
off64_t pos = 0;
|
|
off64_t post_id3_pos;
|
|
uint32_t header;
|
|
bool success;
|
|
|
|
int64_t meta_offset;
|
|
uint32_t meta_header;
|
|
int64_t meta_post_id3_offset;
|
|
if (meta != NULL
|
|
&& meta->findInt64("offset", &meta_offset)
|
|
&& meta->findInt32("header", (int32_t *)&meta_header)
|
|
&& meta->findInt64("post-id3-offset", &meta_post_id3_offset)) {
|
|
// The sniffer has already done all the hard work for us, simply
|
|
// accept its judgement.
|
|
pos = (off64_t)meta_offset;
|
|
header = meta_header;
|
|
post_id3_pos = (off64_t)meta_post_id3_offset;
|
|
|
|
success = true;
|
|
} else {
|
|
success = Resync(mDataSource, 0, &pos, &post_id3_pos, &header);
|
|
}
|
|
|
|
if (!success) {
|
|
// mInitCheck will remain NO_INIT
|
|
return;
|
|
}
|
|
|
|
mFirstFramePos = pos;
|
|
mFixedHeader = header;
|
|
mMeta = new MetaData;
|
|
sp<XINGSeeker> seeker = XINGSeeker::CreateFromSource(mDataSource, mFirstFramePos);
|
|
|
|
if (seeker == NULL) {
|
|
mSeeker = VBRISeeker::CreateFromSource(mDataSource, post_id3_pos);
|
|
} else {
|
|
mSeeker = seeker;
|
|
int encd = seeker->getEncoderDelay();
|
|
int encp = seeker->getEncoderPadding();
|
|
if (encd != 0 || encp != 0) {
|
|
mMeta->setInt32(kKeyEncoderDelay, encd);
|
|
mMeta->setInt32(kKeyEncoderPadding, encp);
|
|
}
|
|
}
|
|
|
|
if (mSeeker != NULL) {
|
|
// While it is safe to send the XING/VBRI frame to the decoder, this will
|
|
// result in an extra 1152 samples being output. In addition, the bitrate
|
|
// of the Xing header might not match the rest of the file, which could
|
|
// lead to problems when seeking. The real first frame to decode is after
|
|
// the XING/VBRI frame, so skip there.
|
|
size_t frame_size;
|
|
int sample_rate;
|
|
int num_channels;
|
|
int bitrate;
|
|
GetMPEGAudioFrameSize(
|
|
header, &frame_size, &sample_rate, &num_channels, &bitrate);
|
|
pos += frame_size;
|
|
if (!Resync(mDataSource, 0, &pos, &post_id3_pos, &header)) {
|
|
// mInitCheck will remain NO_INIT
|
|
return;
|
|
}
|
|
mFirstFramePos = pos;
|
|
mFixedHeader = header;
|
|
}
|
|
|
|
size_t frame_size;
|
|
int sample_rate;
|
|
int num_channels;
|
|
int bitrate;
|
|
GetMPEGAudioFrameSize(
|
|
header, &frame_size, &sample_rate, &num_channels, &bitrate);
|
|
|
|
unsigned layer = 4 - ((header >> 17) & 3);
|
|
|
|
switch (layer) {
|
|
case 1:
|
|
mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_I);
|
|
break;
|
|
case 2:
|
|
mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II);
|
|
break;
|
|
case 3:
|
|
mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_MPEG);
|
|
break;
|
|
default:
|
|
TRESPASS();
|
|
}
|
|
|
|
mMeta->setInt32(kKeySampleRate, sample_rate);
|
|
mMeta->setInt32(kKeyBitRate, bitrate * 1000);
|
|
mMeta->setInt32(kKeyChannelCount, num_channels);
|
|
|
|
int64_t durationUs;
|
|
|
|
if (mSeeker == NULL || !mSeeker->getDuration(&durationUs)) {
|
|
off64_t fileSize;
|
|
if (mDataSource->getSize(&fileSize) == OK) {
|
|
off64_t dataLength = fileSize - mFirstFramePos;
|
|
if (dataLength > INT64_MAX / 8000LL) {
|
|
// duration would overflow
|
|
durationUs = INT64_MAX;
|
|
} else {
|
|
durationUs = 8000LL * dataLength / bitrate;
|
|
}
|
|
} else {
|
|
durationUs = -1;
|
|
}
|
|
}
|
|
|
|
if (durationUs >= 0) {
|
|
mMeta->setInt64(kKeyDuration, durationUs);
|
|
}
|
|
|
|
mInitCheck = OK;
|
|
|
|
// Get iTunes-style gapless info if present.
|
|
// When getting the id3 tag, skip the V1 tags to prevent the source cache
|
|
// from being iterated to the end of the file.
|
|
ID3 id3(mDataSource, true);
|
|
if (id3.isValid()) {
|
|
ID3::Iterator *com = new ID3::Iterator(id3, "COM");
|
|
if (com->done()) {
|
|
delete com;
|
|
com = new ID3::Iterator(id3, "COMM");
|
|
}
|
|
while(!com->done()) {
|
|
String8 commentdesc;
|
|
String8 commentvalue;
|
|
com->getString(&commentdesc, &commentvalue);
|
|
const char * desc = commentdesc.string();
|
|
const char * value = commentvalue.string();
|
|
|
|
// first 3 characters are the language, which we don't care about
|
|
if(strlen(desc) > 3 && strcmp(desc + 3, "iTunSMPB") == 0) {
|
|
|
|
int32_t delay, padding;
|
|
if (sscanf(value, " %*x %x %x %*x", &delay, &padding) == 2) {
|
|
mMeta->setInt32(kKeyEncoderDelay, delay);
|
|
mMeta->setInt32(kKeyEncoderPadding, padding);
|
|
}
|
|
break;
|
|
}
|
|
com->next();
|
|
}
|
|
delete com;
|
|
com = NULL;
|
|
}
|
|
}
|
|
|
|
size_t MP3Extractor::countTracks() {
|
|
return mInitCheck != OK ? 0 : 1;
|
|
}
|
|
|
|
sp<IMediaSource> MP3Extractor::getTrack(size_t index) {
|
|
if (mInitCheck != OK || index != 0) {
|
|
return NULL;
|
|
}
|
|
|
|
return new MP3Source(
|
|
mMeta, mDataSource, mFirstFramePos, mFixedHeader,
|
|
mSeeker);
|
|
}
|
|
|
|
sp<MetaData> MP3Extractor::getTrackMetaData(
|
|
size_t index, uint32_t /* flags */) {
|
|
if (mInitCheck != OK || index != 0) {
|
|
return NULL;
|
|
}
|
|
|
|
return mMeta;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// The theoretical maximum frame size for an MPEG audio stream should occur
|
|
// while playing a Layer 2, MPEGv2.5 audio stream at 160kbps (with padding).
|
|
// The size of this frame should be...
|
|
// ((1152 samples/frame * 160000 bits/sec) /
|
|
// (8000 samples/sec * 8 bits/byte)) + 1 padding byte/frame = 2881 bytes/frame.
|
|
// Set our max frame size to the nearest power of 2 above this size (aka, 4kB)
|
|
const size_t MP3Source::kMaxFrameSize = (1 << 12); /* 4096 bytes */
|
|
MP3Source::MP3Source(
|
|
const sp<MetaData> &meta, const sp<DataSource> &source,
|
|
off64_t first_frame_pos, uint32_t fixed_header,
|
|
const sp<MP3Seeker> &seeker)
|
|
: mMeta(meta),
|
|
mDataSource(source),
|
|
mFirstFramePos(first_frame_pos),
|
|
mFixedHeader(fixed_header),
|
|
mCurrentPos(0),
|
|
mCurrentTimeUs(0),
|
|
mStarted(false),
|
|
mSeeker(seeker),
|
|
mGroup(NULL),
|
|
mBasisTimeUs(0),
|
|
mSamplesRead(0) {
|
|
}
|
|
|
|
MP3Source::~MP3Source() {
|
|
if (mStarted) {
|
|
stop();
|
|
}
|
|
}
|
|
|
|
status_t MP3Source::start(MetaData *) {
|
|
CHECK(!mStarted);
|
|
|
|
mGroup = new MediaBufferGroup;
|
|
|
|
mGroup->add_buffer(new MediaBuffer(kMaxFrameSize));
|
|
|
|
mCurrentPos = mFirstFramePos;
|
|
mCurrentTimeUs = 0;
|
|
|
|
mBasisTimeUs = mCurrentTimeUs;
|
|
mSamplesRead = 0;
|
|
|
|
mStarted = true;
|
|
|
|
return OK;
|
|
}
|
|
|
|
status_t MP3Source::stop() {
|
|
CHECK(mStarted);
|
|
|
|
delete mGroup;
|
|
mGroup = NULL;
|
|
|
|
mStarted = false;
|
|
|
|
return OK;
|
|
}
|
|
|
|
sp<MetaData> MP3Source::getFormat() {
|
|
return mMeta;
|
|
}
|
|
|
|
status_t MP3Source::read(
|
|
MediaBuffer **out, const ReadOptions *options) {
|
|
*out = NULL;
|
|
|
|
int64_t seekTimeUs;
|
|
ReadOptions::SeekMode mode;
|
|
bool seekCBR = false;
|
|
|
|
if (options != NULL && options->getSeekTo(&seekTimeUs, &mode)) {
|
|
int64_t actualSeekTimeUs = seekTimeUs;
|
|
if (mSeeker == NULL
|
|
|| !mSeeker->getOffsetForTime(&actualSeekTimeUs, &mCurrentPos)) {
|
|
int32_t bitrate;
|
|
if (!mMeta->findInt32(kKeyBitRate, &bitrate)) {
|
|
// bitrate is in bits/sec.
|
|
ALOGI("no bitrate");
|
|
|
|
return ERROR_UNSUPPORTED;
|
|
}
|
|
|
|
mCurrentTimeUs = seekTimeUs;
|
|
mCurrentPos = mFirstFramePos + seekTimeUs * bitrate / 8000000;
|
|
seekCBR = true;
|
|
} else {
|
|
mCurrentTimeUs = actualSeekTimeUs;
|
|
}
|
|
|
|
mBasisTimeUs = mCurrentTimeUs;
|
|
mSamplesRead = 0;
|
|
}
|
|
|
|
MediaBuffer *buffer;
|
|
status_t err = mGroup->acquire_buffer(&buffer);
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
size_t frame_size;
|
|
int bitrate;
|
|
int num_samples;
|
|
int sample_rate;
|
|
for (;;) {
|
|
ssize_t n = mDataSource->readAt(mCurrentPos, buffer->data(), 4);
|
|
if (n < 4) {
|
|
buffer->release();
|
|
buffer = NULL;
|
|
|
|
return (n < 0 ? n : ERROR_END_OF_STREAM);
|
|
}
|
|
|
|
uint32_t header = U32_AT((const uint8_t *)buffer->data());
|
|
|
|
if ((header & kMask) == (mFixedHeader & kMask)
|
|
&& GetMPEGAudioFrameSize(
|
|
header, &frame_size, &sample_rate, NULL,
|
|
&bitrate, &num_samples)) {
|
|
|
|
// re-calculate mCurrentTimeUs because we might have called Resync()
|
|
if (seekCBR) {
|
|
mCurrentTimeUs = (mCurrentPos - mFirstFramePos) * 8000 / bitrate;
|
|
mBasisTimeUs = mCurrentTimeUs;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// Lost sync.
|
|
ALOGV("lost sync! header = 0x%08x, old header = 0x%08x\n", header, mFixedHeader);
|
|
|
|
off64_t pos = mCurrentPos;
|
|
if (!Resync(mDataSource, mFixedHeader, &pos, NULL, NULL)) {
|
|
ALOGE("Unable to resync. Signalling end of stream.");
|
|
|
|
buffer->release();
|
|
buffer = NULL;
|
|
|
|
return ERROR_END_OF_STREAM;
|
|
}
|
|
|
|
mCurrentPos = pos;
|
|
|
|
// Try again with the new position.
|
|
}
|
|
|
|
CHECK(frame_size <= buffer->size());
|
|
|
|
ssize_t n = mDataSource->readAt(mCurrentPos, buffer->data(), frame_size);
|
|
if (n < (ssize_t)frame_size) {
|
|
buffer->release();
|
|
buffer = NULL;
|
|
|
|
return (n < 0 ? n : ERROR_END_OF_STREAM);
|
|
}
|
|
|
|
buffer->set_range(0, frame_size);
|
|
|
|
buffer->meta_data()->setInt64(kKeyTime, mCurrentTimeUs);
|
|
buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1);
|
|
|
|
mCurrentPos += frame_size;
|
|
|
|
mSamplesRead += num_samples;
|
|
mCurrentTimeUs = mBasisTimeUs + ((mSamplesRead * 1000000) / sample_rate);
|
|
|
|
*out = buffer;
|
|
|
|
return OK;
|
|
}
|
|
|
|
sp<MetaData> MP3Extractor::getMetaData() {
|
|
sp<MetaData> meta = new MetaData;
|
|
|
|
if (mInitCheck != OK) {
|
|
return meta;
|
|
}
|
|
|
|
meta->setCString(kKeyMIMEType, "audio/mpeg");
|
|
|
|
ID3 id3(mDataSource);
|
|
|
|
if (!id3.isValid()) {
|
|
return meta;
|
|
}
|
|
|
|
struct Map {
|
|
int key;
|
|
const char *tag1;
|
|
const char *tag2;
|
|
};
|
|
static const Map kMap[] = {
|
|
{ kKeyAlbum, "TALB", "TAL" },
|
|
{ kKeyArtist, "TPE1", "TP1" },
|
|
{ kKeyAlbumArtist, "TPE2", "TP2" },
|
|
{ kKeyComposer, "TCOM", "TCM" },
|
|
{ kKeyGenre, "TCON", "TCO" },
|
|
{ kKeyTitle, "TIT2", "TT2" },
|
|
{ kKeyYear, "TYE", "TYER" },
|
|
{ kKeyAuthor, "TXT", "TEXT" },
|
|
{ kKeyCDTrackNumber, "TRK", "TRCK" },
|
|
{ kKeyDiscNumber, "TPA", "TPOS" },
|
|
{ kKeyCompilation, "TCP", "TCMP" },
|
|
};
|
|
static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
|
|
|
|
for (size_t i = 0; i < kNumMapEntries; ++i) {
|
|
ID3::Iterator *it = new ID3::Iterator(id3, kMap[i].tag1);
|
|
if (it->done()) {
|
|
delete it;
|
|
it = new ID3::Iterator(id3, kMap[i].tag2);
|
|
}
|
|
|
|
if (it->done()) {
|
|
delete it;
|
|
continue;
|
|
}
|
|
|
|
String8 s;
|
|
it->getString(&s);
|
|
delete it;
|
|
|
|
meta->setCString(kMap[i].key, s);
|
|
}
|
|
|
|
size_t dataSize;
|
|
String8 mime;
|
|
const void *data = id3.getAlbumArt(&dataSize, &mime);
|
|
|
|
if (data) {
|
|
meta->setData(kKeyAlbumArt, MetaData::TYPE_NONE, data, dataSize);
|
|
meta->setCString(kKeyAlbumArtMIME, mime.string());
|
|
}
|
|
|
|
return meta;
|
|
}
|
|
|
|
bool SniffMP3(
|
|
const sp<DataSource> &source, String8 *mimeType,
|
|
float *confidence, sp<AMessage> *meta) {
|
|
off64_t pos = 0;
|
|
off64_t post_id3_pos;
|
|
uint32_t header;
|
|
if (!Resync(source, 0, &pos, &post_id3_pos, &header)) {
|
|
return false;
|
|
}
|
|
|
|
*meta = new AMessage;
|
|
(*meta)->setInt64("offset", pos);
|
|
(*meta)->setInt32("header", header);
|
|
(*meta)->setInt64("post-id3-offset", post_id3_pos);
|
|
|
|
*mimeType = MEDIA_MIMETYPE_AUDIO_MPEG;
|
|
*confidence = 0.2f;
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace android
|