blob: 5e79e788816d24150a0d212e8e51a68b87c85959 [file] [log] [blame]
/*
* Copyright (C) 2010 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 "OggExtractor"
#include <utils/Log.h>
#include "include/OggExtractor.h"
#include <cutils/properties.h>
#include <media/stagefright/foundation/ADebug.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>
extern "C" {
#include <Tremolo/codec_internal.h>
int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb);
int _vorbis_unpack_info(vorbis_info *vi,oggpack_buffer *opb);
int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb);
}
namespace android {
struct OggSource : public MediaSource {
OggSource(const sp<OggExtractor> &extractor);
virtual sp<MetaData> getFormat();
virtual status_t start(MetaData *params = NULL);
virtual status_t stop();
virtual status_t read(
MediaBuffer **buffer, const ReadOptions *options = NULL);
protected:
virtual ~OggSource();
private:
sp<OggExtractor> mExtractor;
bool mStarted;
OggSource(const OggSource &);
OggSource &operator=(const OggSource &);
};
struct MyVorbisExtractor {
MyVorbisExtractor(const sp<DataSource> &source);
virtual ~MyVorbisExtractor();
sp<MetaData> getFormat() const;
// Returns an approximate bitrate in bits per second.
uint64_t approxBitrate();
status_t seekToTime(int64_t timeUs);
status_t seekToOffset(off64_t offset);
status_t readNextPacket(MediaBuffer **buffer);
status_t init();
sp<MetaData> getFileMetaData() { return mFileMeta; }
private:
struct Page {
uint64_t mGranulePosition;
uint32_t mSerialNo;
uint32_t mPageNo;
uint8_t mFlags;
uint8_t mNumSegments;
uint8_t mLace[255];
};
struct TOCEntry {
off64_t mPageOffset;
int64_t mTimeUs;
};
sp<DataSource> mSource;
off64_t mOffset;
Page mCurrentPage;
uint64_t mPrevGranulePosition;
size_t mCurrentPageSize;
bool mFirstPacketInPage;
uint64_t mCurrentPageSamples;
size_t mNextLaceIndex;
off64_t mFirstDataOffset;
vorbis_info mVi;
vorbis_comment mVc;
sp<MetaData> mMeta;
sp<MetaData> mFileMeta;
Vector<TOCEntry> mTableOfContents;
ssize_t readPage(off64_t offset, Page *page);
status_t findNextPage(off64_t startOffset, off64_t *pageOffset);
status_t verifyHeader(
MediaBuffer *buffer, uint8_t type);
void parseFileMetaData();
status_t findPrevGranulePosition(off64_t pageOffset, uint64_t *granulePos);
void buildTableOfContents();
MyVorbisExtractor(const MyVorbisExtractor &);
MyVorbisExtractor &operator=(const MyVorbisExtractor &);
};
static void extractAlbumArt(
const sp<MetaData> &fileMeta, const void *data, size_t size);
////////////////////////////////////////////////////////////////////////////////
OggSource::OggSource(const sp<OggExtractor> &extractor)
: mExtractor(extractor),
mStarted(false) {
}
OggSource::~OggSource() {
if (mStarted) {
stop();
}
}
sp<MetaData> OggSource::getFormat() {
return mExtractor->mImpl->getFormat();
}
status_t OggSource::start(MetaData *params) {
if (mStarted) {
return INVALID_OPERATION;
}
mStarted = true;
return OK;
}
status_t OggSource::stop() {
mStarted = false;
return OK;
}
status_t OggSource::read(
MediaBuffer **out, const ReadOptions *options) {
*out = NULL;
int64_t seekTimeUs;
ReadOptions::SeekMode mode;
if (options && options->getSeekTo(&seekTimeUs, &mode)) {
if (mExtractor->mImpl->seekToTime(seekTimeUs) != OK) {
return ERROR_END_OF_STREAM;
}
}
MediaBuffer *packet;
status_t err = mExtractor->mImpl->readNextPacket(&packet);
if (err != OK) {
return err;
}
#if 0
int64_t timeUs;
if (packet->meta_data()->findInt64(kKeyTime, &timeUs)) {
ALOGI("found time = %lld us", timeUs);
} else {
ALOGI("NO time");
}
#endif
packet->meta_data()->setInt32(kKeyIsSyncFrame, 1);
*out = packet;
return OK;
}
////////////////////////////////////////////////////////////////////////////////
MyVorbisExtractor::MyVorbisExtractor(const sp<DataSource> &source)
: mSource(source),
mOffset(0),
mPrevGranulePosition(0),
mCurrentPageSize(0),
mFirstPacketInPage(true),
mCurrentPageSamples(0),
mNextLaceIndex(0),
mFirstDataOffset(-1) {
mCurrentPage.mNumSegments = 0;
vorbis_info_init(&mVi);
vorbis_comment_init(&mVc);
}
MyVorbisExtractor::~MyVorbisExtractor() {
vorbis_comment_clear(&mVc);
vorbis_info_clear(&mVi);
}
sp<MetaData> MyVorbisExtractor::getFormat() const {
return mMeta;
}
status_t MyVorbisExtractor::findNextPage(
off64_t startOffset, off64_t *pageOffset) {
*pageOffset = startOffset;
for (;;) {
char signature[4];
ssize_t n = mSource->readAt(*pageOffset, &signature, 4);
if (n < 4) {
*pageOffset = 0;
return (n < 0) ? n : (status_t)ERROR_END_OF_STREAM;
}
if (!memcmp(signature, "OggS", 4)) {
if (*pageOffset > startOffset) {
ALOGV("skipped %lld bytes of junk to reach next frame",
*pageOffset - startOffset);
}
return OK;
}
++*pageOffset;
}
}
// Given the offset of the "current" page, find the page immediately preceding
// it (if any) and return its granule position.
// To do this we back up from the "current" page's offset until we find any
// page preceding it and then scan forward to just before the current page.
status_t MyVorbisExtractor::findPrevGranulePosition(
off64_t pageOffset, uint64_t *granulePos) {
*granulePos = 0;
off64_t prevPageOffset = 0;
off64_t prevGuess = pageOffset;
for (;;) {
if (prevGuess >= 5000) {
prevGuess -= 5000;
} else {
prevGuess = 0;
}
ALOGV("backing up %lld bytes", pageOffset - prevGuess);
status_t err = findNextPage(prevGuess, &prevPageOffset);
if (err != OK) {
return err;
}
if (prevPageOffset < pageOffset || prevGuess == 0) {
break;
}
}
if (prevPageOffset == pageOffset) {
// We did not find a page preceding this one.
return UNKNOWN_ERROR;
}
ALOGV("prevPageOffset at %lld, pageOffset at %lld",
prevPageOffset, pageOffset);
for (;;) {
Page prevPage;
ssize_t n = readPage(prevPageOffset, &prevPage);
if (n <= 0) {
return (status_t)n;
}
prevPageOffset += n;
if (prevPageOffset == pageOffset) {
*granulePos = prevPage.mGranulePosition;
return OK;
}
}
}
status_t MyVorbisExtractor::seekToTime(int64_t timeUs) {
if (mTableOfContents.isEmpty()) {
// Perform approximate seeking based on avg. bitrate.
off64_t pos = timeUs * approxBitrate() / 8000000ll;
ALOGV("seeking to offset %lld", pos);
return seekToOffset(pos);
}
size_t left = 0;
size_t right = mTableOfContents.size();
while (left < right) {
size_t center = left / 2 + right / 2 + (left & right & 1);
const TOCEntry &entry = mTableOfContents.itemAt(center);
if (timeUs < entry.mTimeUs) {
right = center;
} else if (timeUs > entry.mTimeUs) {
left = center + 1;
} else {
left = right = center;
break;
}
}
const TOCEntry &entry = mTableOfContents.itemAt(left);
ALOGV("seeking to entry %d / %d at offset %lld",
left, mTableOfContents.size(), entry.mPageOffset);
return seekToOffset(entry.mPageOffset);
}
status_t MyVorbisExtractor::seekToOffset(off64_t offset) {
if (mFirstDataOffset >= 0 && offset < mFirstDataOffset) {
// Once we know where the actual audio data starts (past the headers)
// don't ever seek to anywhere before that.
offset = mFirstDataOffset;
}
off64_t pageOffset;
status_t err = findNextPage(offset, &pageOffset);
if (err != OK) {
return err;
}
// We found the page we wanted to seek to, but we'll also need
// the page preceding it to determine how many valid samples are on
// this page.
findPrevGranulePosition(pageOffset, &mPrevGranulePosition);
mOffset = pageOffset;
mCurrentPageSize = 0;
mFirstPacketInPage = true;
mCurrentPageSamples = 0;
mCurrentPage.mNumSegments = 0;
mNextLaceIndex = 0;
// XXX what if new page continues packet from last???
return OK;
}
ssize_t MyVorbisExtractor::readPage(off64_t offset, Page *page) {
uint8_t header[27];
ssize_t n;
if ((n = mSource->readAt(offset, header, sizeof(header)))
< (ssize_t)sizeof(header)) {
ALOGV("failed to read %d bytes at offset 0x%016llx, got %ld bytes",
sizeof(header), offset, n);
if (n < 0) {
return n;
} else if (n == 0) {
return ERROR_END_OF_STREAM;
} else {
return ERROR_IO;
}
}
if (memcmp(header, "OggS", 4)) {
return ERROR_MALFORMED;
}
if (header[4] != 0) {
// Wrong version.
return ERROR_UNSUPPORTED;
}
page->mFlags = header[5];
if (page->mFlags & ~7) {
// Only bits 0-2 are defined in version 0.
return ERROR_MALFORMED;
}
page->mGranulePosition = U64LE_AT(&header[6]);
#if 0
printf("granulePosition = %llu (0x%llx)\n",
page->mGranulePosition, page->mGranulePosition);
#endif
page->mSerialNo = U32LE_AT(&header[14]);
page->mPageNo = U32LE_AT(&header[18]);
page->mNumSegments = header[26];
if (mSource->readAt(
offset + sizeof(header), page->mLace, page->mNumSegments)
< (ssize_t)page->mNumSegments) {
return ERROR_IO;
}
size_t totalSize = 0;;
for (size_t i = 0; i < page->mNumSegments; ++i) {
totalSize += page->mLace[i];
}
#if 0
String8 tmp;
for (size_t i = 0; i < page->mNumSegments; ++i) {
char x[32];
sprintf(x, "%s%u", i > 0 ? ", " : "", (unsigned)page->mLace[i]);
tmp.append(x);
}
ALOGV("%c %s", page->mFlags & 1 ? '+' : ' ', tmp.string());
#endif
return sizeof(header) + page->mNumSegments + totalSize;
}
status_t MyVorbisExtractor::readNextPacket(MediaBuffer **out) {
*out = NULL;
MediaBuffer *buffer = NULL;
int64_t timeUs = -1;
for (;;) {
size_t i;
size_t packetSize = 0;
bool gotFullPacket = false;
for (i = mNextLaceIndex; i < mCurrentPage.mNumSegments; ++i) {
uint8_t lace = mCurrentPage.mLace[i];
packetSize += lace;
if (lace < 255) {
gotFullPacket = true;
++i;
break;
}
}
if (mNextLaceIndex < mCurrentPage.mNumSegments) {
off64_t dataOffset = mOffset + 27 + mCurrentPage.mNumSegments;
for (size_t j = 0; j < mNextLaceIndex; ++j) {
dataOffset += mCurrentPage.mLace[j];
}
size_t fullSize = packetSize;
if (buffer != NULL) {
fullSize += buffer->range_length();
}
MediaBuffer *tmp = new MediaBuffer(fullSize);
if (buffer != NULL) {
memcpy(tmp->data(), buffer->data(), buffer->range_length());
tmp->set_range(0, buffer->range_length());
buffer->release();
} else {
// XXX Not only is this not technically the correct time for
// this packet, we also stamp every packet in this page
// with the same time. This needs fixing later.
if (mVi.rate) {
// Rate may not have been initialized yet if we're currently
// reading the configuration packets...
// Fortunately, the timestamp doesn't matter for those.
timeUs = mCurrentPage.mGranulePosition * 1000000ll / mVi.rate;
}
tmp->set_range(0, 0);
}
buffer = tmp;
ssize_t n = mSource->readAt(
dataOffset,
(uint8_t *)buffer->data() + buffer->range_length(),
packetSize);
if (n < (ssize_t)packetSize) {
ALOGV("failed to read %d bytes at 0x%016llx, got %ld bytes",
packetSize, dataOffset, n);
return ERROR_IO;
}
buffer->set_range(0, fullSize);
mNextLaceIndex = i;
if (gotFullPacket) {
// We've just read the entire packet.
if (timeUs >= 0) {
buffer->meta_data()->setInt64(kKeyTime, timeUs);
}
if (mFirstPacketInPage) {
buffer->meta_data()->setInt32(
kKeyValidSamples, mCurrentPageSamples);
mFirstPacketInPage = false;
}
*out = buffer;
return OK;
}
// fall through, the buffer now contains the start of the packet.
}
CHECK_EQ(mNextLaceIndex, mCurrentPage.mNumSegments);
mOffset += mCurrentPageSize;
ssize_t n = readPage(mOffset, &mCurrentPage);
if (n <= 0) {
if (buffer) {
buffer->release();
buffer = NULL;
}
ALOGV("readPage returned %ld", n);
return n < 0 ? n : (status_t)ERROR_END_OF_STREAM;
}
mCurrentPageSamples =
mCurrentPage.mGranulePosition - mPrevGranulePosition;
mFirstPacketInPage = true;
mPrevGranulePosition = mCurrentPage.mGranulePosition;
mCurrentPageSize = n;
mNextLaceIndex = 0;
if (buffer != NULL) {
if ((mCurrentPage.mFlags & 1) == 0) {
// This page does not continue the packet, i.e. the packet
// is already complete.
if (timeUs >= 0) {
buffer->meta_data()->setInt64(kKeyTime, timeUs);
}
buffer->meta_data()->setInt32(
kKeyValidSamples, mCurrentPageSamples);
mFirstPacketInPage = false;
*out = buffer;
return OK;
}
}
}
}
status_t MyVorbisExtractor::init() {
mMeta = new MetaData;
mMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_AUDIO_VORBIS);
MediaBuffer *packet;
status_t err;
if ((err = readNextPacket(&packet)) != OK) {
return err;
}
ALOGV("read packet of size %d\n", packet->range_length());
err = verifyHeader(packet, 1);
packet->release();
packet = NULL;
if (err != OK) {
return err;
}
if ((err = readNextPacket(&packet)) != OK) {
return err;
}
ALOGV("read packet of size %d\n", packet->range_length());
err = verifyHeader(packet, 3);
packet->release();
packet = NULL;
if (err != OK) {
return err;
}
if ((err = readNextPacket(&packet)) != OK) {
return err;
}
ALOGV("read packet of size %d\n", packet->range_length());
err = verifyHeader(packet, 5);
packet->release();
packet = NULL;
if (err != OK) {
return err;
}
mFirstDataOffset = mOffset + mCurrentPageSize;
off64_t size;
uint64_t lastGranulePosition;
if (!(mSource->flags() & DataSource::kIsCachingDataSource)
&& mSource->getSize(&size) == OK
&& findPrevGranulePosition(size, &lastGranulePosition) == OK) {
// Let's assume it's cheap to seek to the end.
// The granule position of the final page in the stream will
// give us the exact duration of the content, something that
// we can only approximate using avg. bitrate if seeking to
// the end is too expensive or impossible (live streaming).
int64_t durationUs = lastGranulePosition * 1000000ll / mVi.rate;
mMeta->setInt64(kKeyDuration, durationUs);
buildTableOfContents();
}
return OK;
}
void MyVorbisExtractor::buildTableOfContents() {
off64_t offset = mFirstDataOffset;
Page page;
ssize_t pageSize;
while ((pageSize = readPage(offset, &page)) > 0) {
mTableOfContents.push();
TOCEntry &entry =
mTableOfContents.editItemAt(mTableOfContents.size() - 1);
entry.mPageOffset = offset;
entry.mTimeUs = page.mGranulePosition * 1000000ll / mVi.rate;
offset += (size_t)pageSize;
}
// Limit the maximum amount of RAM we spend on the table of contents,
// if necessary thin out the table evenly to trim it down to maximum
// size.
static const size_t kMaxTOCSize = 8192;
static const size_t kMaxNumTOCEntries = kMaxTOCSize / sizeof(TOCEntry);
size_t numerator = mTableOfContents.size();
if (numerator > kMaxNumTOCEntries) {
size_t denom = numerator - kMaxNumTOCEntries;
size_t accum = 0;
for (ssize_t i = mTableOfContents.size() - 1; i >= 0; --i) {
accum += denom;
if (accum >= numerator) {
mTableOfContents.removeAt(i);
accum -= numerator;
}
}
}
}
status_t MyVorbisExtractor::verifyHeader(
MediaBuffer *buffer, uint8_t type) {
const uint8_t *data =
(const uint8_t *)buffer->data() + buffer->range_offset();
size_t size = buffer->range_length();
if (size < 7 || data[0] != type || memcmp(&data[1], "vorbis", 6)) {
return ERROR_MALFORMED;
}
ogg_buffer buf;
buf.data = (uint8_t *)data;
buf.size = size;
buf.refcount = 1;
buf.ptr.owner = NULL;
ogg_reference ref;
ref.buffer = &buf;
ref.begin = 0;
ref.length = size;
ref.next = NULL;
oggpack_buffer bits;
oggpack_readinit(&bits, &ref);
CHECK_EQ(oggpack_read(&bits, 8), type);
for (size_t i = 0; i < 6; ++i) {
oggpack_read(&bits, 8); // skip 'vorbis'
}
switch (type) {
case 1:
{
CHECK_EQ(0, _vorbis_unpack_info(&mVi, &bits));
mMeta->setData(kKeyVorbisInfo, 0, data, size);
mMeta->setInt32(kKeySampleRate, mVi.rate);
mMeta->setInt32(kKeyChannelCount, mVi.channels);
ALOGV("lower-bitrate = %ld", mVi.bitrate_lower);
ALOGV("upper-bitrate = %ld", mVi.bitrate_upper);
ALOGV("nominal-bitrate = %ld", mVi.bitrate_nominal);
ALOGV("window-bitrate = %ld", mVi.bitrate_window);
off64_t size;
if (mSource->getSize(&size) == OK) {
uint64_t bps = approxBitrate();
if (bps != 0) {
mMeta->setInt64(kKeyDuration, size * 8000000ll / bps);
}
}
break;
}
case 3:
{
if (0 != _vorbis_unpack_comment(&mVc, &bits)) {
return ERROR_MALFORMED;
}
parseFileMetaData();
break;
}
case 5:
{
if (0 != _vorbis_unpack_books(&mVi, &bits)) {
return ERROR_MALFORMED;
}
mMeta->setData(kKeyVorbisBooks, 0, data, size);
break;
}
}
return OK;
}
uint64_t MyVorbisExtractor::approxBitrate() {
if (mVi.bitrate_nominal != 0) {
return mVi.bitrate_nominal;
}
return (mVi.bitrate_lower + mVi.bitrate_upper) / 2;
}
void MyVorbisExtractor::parseFileMetaData() {
mFileMeta = new MetaData;
mFileMeta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_CONTAINER_OGG);
for (int i = 0; i < mVc.comments; ++i) {
const char *comment = mVc.user_comments[i];
size_t commentLength = mVc.comment_lengths[i];
parseVorbisComment(mFileMeta, comment, commentLength);
//ALOGI("comment #%d: '%s'", i + 1, mVc.user_comments[i]);
}
}
void parseVorbisComment(
const sp<MetaData> &fileMeta, const char *comment, size_t commentLength)
{
struct {
const char *const mTag;
uint32_t mKey;
} kMap[] = {
{ "TITLE", kKeyTitle },
{ "ARTIST", kKeyArtist },
{ "ALBUMARTIST", kKeyAlbumArtist },
{ "ALBUM ARTIST", kKeyAlbumArtist },
{ "COMPILATION", kKeyCompilation },
{ "ALBUM", kKeyAlbum },
{ "COMPOSER", kKeyComposer },
{ "GENRE", kKeyGenre },
{ "AUTHOR", kKeyAuthor },
{ "TRACKNUMBER", kKeyCDTrackNumber },
{ "DISCNUMBER", kKeyDiscNumber },
{ "DATE", kKeyDate },
{ "LYRICIST", kKeyWriter },
{ "METADATA_BLOCK_PICTURE", kKeyAlbumArt },
{ "ANDROID_LOOP", kKeyAutoLoop },
};
for (size_t j = 0; j < sizeof(kMap) / sizeof(kMap[0]); ++j) {
size_t tagLen = strlen(kMap[j].mTag);
if (!strncasecmp(kMap[j].mTag, comment, tagLen)
&& comment[tagLen] == '=') {
if (kMap[j].mKey == kKeyAlbumArt) {
extractAlbumArt(
fileMeta,
&comment[tagLen + 1],
commentLength - tagLen - 1);
} else if (kMap[j].mKey == kKeyAutoLoop) {
if (!strcasecmp(&comment[tagLen + 1], "true")) {
fileMeta->setInt32(kKeyAutoLoop, true);
}
} else {
fileMeta->setCString(kMap[j].mKey, &comment[tagLen + 1]);
}
}
}
}
// The returned buffer should be free()d.
static uint8_t *DecodeBase64(const char *s, size_t size, size_t *outSize) {
*outSize = 0;
if ((size % 4) != 0) {
return NULL;
}
size_t n = size;
size_t padding = 0;
if (n >= 1 && s[n - 1] == '=') {
padding = 1;
if (n >= 2 && s[n - 2] == '=') {
padding = 2;
}
}
size_t outLen = 3 * size / 4 - padding;
*outSize = outLen;
void *buffer = malloc(outLen);
uint8_t *out = (uint8_t *)buffer;
size_t j = 0;
uint32_t accum = 0;
for (size_t i = 0; i < n; ++i) {
char c = s[i];
unsigned value;
if (c >= 'A' && c <= 'Z') {
value = c - 'A';
} else if (c >= 'a' && c <= 'z') {
value = 26 + c - 'a';
} else if (c >= '0' && c <= '9') {
value = 52 + c - '0';
} else if (c == '+') {
value = 62;
} else if (c == '/') {
value = 63;
} else if (c != '=') {
return NULL;
} else {
if (i < n - padding) {
return NULL;
}
value = 0;
}
accum = (accum << 6) | value;
if (((i + 1) % 4) == 0) {
out[j++] = (accum >> 16);
if (j < outLen) { out[j++] = (accum >> 8) & 0xff; }
if (j < outLen) { out[j++] = accum & 0xff; }
accum = 0;
}
}
return (uint8_t *)buffer;
}
static void extractAlbumArt(
const sp<MetaData> &fileMeta, const void *data, size_t size) {
ALOGV("extractAlbumArt from '%s'", (const char *)data);
size_t flacSize;
uint8_t *flac = DecodeBase64((const char *)data, size, &flacSize);
if (flac == NULL) {
ALOGE("malformed base64 encoded data.");
return;
}
ALOGV("got flac of size %d", flacSize);
uint32_t picType;
uint32_t typeLen;
uint32_t descLen;
uint32_t dataLen;
char type[128];
if (flacSize < 8) {
goto exit;
}
picType = U32_AT(flac);
if (picType != 3) {
// This is not a front cover.
goto exit;
}
typeLen = U32_AT(&flac[4]);
if (typeLen + 1 > sizeof(type)) {
goto exit;
}
if (flacSize < 8 + typeLen) {
goto exit;
}
memcpy(type, &flac[8], typeLen);
type[typeLen] = '\0';
ALOGV("picType = %d, type = '%s'", picType, type);
if (!strcmp(type, "-->")) {
// This is not inline cover art, but an external url instead.
goto exit;
}
descLen = U32_AT(&flac[8 + typeLen]);
if (flacSize < 32 + typeLen + descLen) {
goto exit;
}
dataLen = U32_AT(&flac[8 + typeLen + 4 + descLen + 16]);
if (flacSize < 32 + typeLen + descLen + dataLen) {
goto exit;
}
ALOGV("got image data, %d trailing bytes",
flacSize - 32 - typeLen - descLen - dataLen);
fileMeta->setData(
kKeyAlbumArt, 0, &flac[8 + typeLen + 4 + descLen + 20], dataLen);
fileMeta->setCString(kKeyAlbumArtMIME, type);
exit:
free(flac);
flac = NULL;
}
////////////////////////////////////////////////////////////////////////////////
OggExtractor::OggExtractor(const sp<DataSource> &source)
: mDataSource(source),
mInitCheck(NO_INIT),
mImpl(NULL) {
mImpl = new MyVorbisExtractor(mDataSource);
mInitCheck = mImpl->seekToOffset(0);
if (mInitCheck == OK) {
mInitCheck = mImpl->init();
}
}
OggExtractor::~OggExtractor() {
delete mImpl;
mImpl = NULL;
}
size_t OggExtractor::countTracks() {
return mInitCheck != OK ? 0 : 1;
}
sp<MediaSource> OggExtractor::getTrack(size_t index) {
if (index >= 1) {
return NULL;
}
return new OggSource(this);
}
sp<MetaData> OggExtractor::getTrackMetaData(
size_t index, uint32_t flags) {
if (index >= 1) {
return NULL;
}
return mImpl->getFormat();
}
sp<MetaData> OggExtractor::getMetaData() {
return mImpl->getFileMetaData();
}
bool SniffOgg(
const sp<DataSource> &source, String8 *mimeType, float *confidence,
sp<AMessage> *) {
char tmp[4];
if (source->readAt(0, tmp, 4) < 4 || memcmp(tmp, "OggS", 4)) {
return false;
}
mimeType->setTo(MEDIA_MIMETYPE_CONTAINER_OGG);
*confidence = 0.2f;
return true;
}
} // namespace android