Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge change I3b1b7873 into eclair-mr2

Browse Source 
* changes:
  New API to instantiate a MediaExtractor given a URI and optional MIME type.
This commit is contained in:
Android (Google) Code Review
2009-10-23 15:51:44 -04:00
parent 48153e7f7f 9a12baf929
commit d9f3d60df9
20 changed files with 117 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/media/stagefright/CachingDataSource.h
View File

@@ -29,9 +29,9 @@ public:
CachingDataSource( CachingDataSource(
const sp<DataSource> &source, size_t pageSize, int numPages); const sp<DataSource> &source, size_t pageSize, int numPages);
status_t InitCheck() const; virtual status_t initCheck() const;
virtual ssize_t read_at(off_t offset, void *data, size_t size); virtual ssize_t readAt(off_t offset, void *data, size_t size);
protected: protected:
virtual ~CachingDataSource(); virtual ~CachingDataSource();

4
include/media/stagefright/DataSource.h
View File

@@ -33,7 +33,9 @@ class DataSource : public RefBase {
public: public:
DataSource() {} DataSource() {}
virtual ssize_t read_at(off_t offset, void *data, size_t size) = 0; virtual status_t initCheck() const = 0;
virtual ssize_t readAt(off_t offset, void *data, size_t size) = 0;
// Convenience methods: // Convenience methods:
bool getUInt16(off_t offset, uint16_t *x); bool getUInt16(off_t offset, uint16_t *x);

10
include/media/stagefright/FileSource.h
View File

@@ -29,12 +29,14 @@ namespace android {
class FileSource : public DataSource { class FileSource : public DataSource {
public: public:
FileSource(const char *filename); FileSource(const char *filename);
virtual status_t initCheck() const;
virtual ssize_t readAt(off_t offset, void *data, size_t size);
protected:
virtual ~FileSource(); virtual ~FileSource();
status_t InitCheck() const;
virtual ssize_t read_at(off_t offset, void *data, size_t size);
private: private:
FILE *mFile; FILE *mFile;
Mutex mLock; Mutex mLock;

12
include/media/stagefright/HTTPDataSource.h
View File

@@ -29,13 +29,13 @@ public:
HTTPDataSource(const char *host, int port, const char *path); HTTPDataSource(const char *host, int port, const char *path);
HTTPDataSource(const char *uri); HTTPDataSource(const char *uri);
virtual status_t initCheck() const;
virtual ssize_t readAt(off_t offset, void *data, size_t size);
protected:
virtual ~HTTPDataSource(); virtual ~HTTPDataSource();
// XXXandih
status_t InitCheck() const { return OK; }
virtual ssize_t read_at(off_t offset, void *data, size_t size);
private: private:
enum { enum {
kBufferSize = 64 * 1024 kBufferSize = 64 * 1024
@@ -50,6 +50,8 @@ private:
size_t mBufferLength; size_t mBufferLength;
off_t mBufferOffset; off_t mBufferOffset;
status_t mInitCheck;
HTTPDataSource(const HTTPDataSource &); HTTPDataSource(const HTTPDataSource &);
HTTPDataSource &operator=(const HTTPDataSource &); HTTPDataSource &operator=(const HTTPDataSource &);
}; };

3
include/media/stagefright/MediaExtractor.h
View File

@@ -31,6 +31,9 @@ public:
static sp<MediaExtractor> Create( static sp<MediaExtractor> Create(
const sp<DataSource> &source, const char *mime = NULL); const sp<DataSource> &source, const char *mime = NULL);
static sp<MediaExtractor> CreateFromURI(
const char *uri, const char *mime = NULL);
virtual size_t countTracks() = 0; virtual size_t countTracks() = 0;
virtual sp<MediaSource> getTrack(size_t index) = 0; virtual sp<MediaSource> getTrack(size_t index) = 0;

9
include/media/stagefright/MmapSource.h
View File

@@ -30,13 +30,14 @@ public:
// Assumes ownership of "fd". // Assumes ownership of "fd".
MmapSource(int fd, int64_t offset, int64_t length); MmapSource(int fd, int64_t offset, int64_t length);
virtual ~MmapSource(); virtual status_t initCheck() const;
status_t InitCheck() const; virtual ssize_t readAt(off_t offset, void *data, size_t size);
virtual ssize_t read_at(off_t offset, void *data, size_t size);
virtual status_t getSize(off_t *size); virtual status_t getSize(off_t *size);
protected:
virtual ~MmapSource();
private: private:
int mFd; int mFd;
void *mBase; void *mBase;

4
include/media/stagefright/ShoutcastSource.h
View File

@@ -31,7 +31,6 @@ class ShoutcastSource : public MediaSource {
public: public:
// Assumes ownership of "http". // Assumes ownership of "http".
ShoutcastSource(HTTPStream *http); ShoutcastSource(HTTPStream *http);
virtual ~ShoutcastSource();
virtual status_t start(MetaData *params = NULL); virtual status_t start(MetaData *params = NULL);
virtual status_t stop(); virtual status_t stop();
@@ -41,6 +40,9 @@ public:
virtual status_t read( virtual status_t read(
MediaBuffer **buffer, const ReadOptions *options = NULL); MediaBuffer **buffer, const ReadOptions *options = NULL);
protected:
virtual ~ShoutcastSource();
private: private:
HTTPStream *mHttp; HTTPStream *mHttp;
size_t mMetaDataOffset; size_t mMetaDataOffset;

21
media/libmediaplayerservice/StagefrightMetadataRetriever.cpp
View File

@@ -48,26 +48,7 @@ StagefrightMetadataRetriever::~StagefrightMetadataRetriever() {
status_t StagefrightMetadataRetriever::setDataSource(const char *uri) { status_t StagefrightMetadataRetriever::setDataSource(const char *uri) {
LOGV("setDataSource(%s)", uri); LOGV("setDataSource(%s)", uri);
sp<DataSource> source; mExtractor = MediaExtractor::CreateFromURI(uri);
if (!strncasecmp("file://", uri, 7)) {
sp<MmapSource> mmapSource = new MmapSource(uri + 7);
if (mmapSource->InitCheck() != OK) {
return ERROR_IO;
}
source = mmapSource;
} else if (!strncasecmp("http://", uri, 7)) {
source = new HTTPDataSource(uri);
source = new CachingDataSource(source, 64 * 1024, 10);
} else {
// Assume it's a filename.
sp<MmapSource> mmapSource = new MmapSource(uri);
if (mmapSource->InitCheck() != OK) {
return ERROR_IO;
}
source = mmapSource;
}
mExtractor = MediaExtractor::Create(source);
return mExtractor.get() != NULL ? OK : UNKNOWN_ERROR; return mExtractor.get() != NULL ? OK : UNKNOWN_ERROR;
} }

6
media/libstagefright/AMRExtractor.cpp
View File

@@ -156,7 +156,7 @@ status_t AMRSource::read(
*out = NULL; *out = NULL;
uint8_t header; uint8_t header;
ssize_t n = mDataSource->read_at(mOffset, &header, 1); ssize_t n = mDataSource->readAt(mOffset, &header, 1);
if (n < 1) { if (n < 1) {
return ERROR_IO; return ERROR_IO;
@@ -192,7 +192,7 @@ status_t AMRSource::read(
// Round up bits to bytes and add 1 for the header byte. // Round up bits to bytes and add 1 for the header byte.
frameSize = (frameSize + 7) / 8 + 1; frameSize = (frameSize + 7) / 8 + 1;
n = mDataSource->read_at(mOffset, buffer->data(), frameSize); n = mDataSource->readAt(mOffset, buffer->data(), frameSize);
if (n != (ssize_t)frameSize) { if (n != (ssize_t)frameSize) {
buffer->release(); buffer->release();
@@ -218,7 +218,7 @@ bool SniffAMR(
const sp<DataSource> &source, String8 *mimeType, float *confidence) { const sp<DataSource> &source, String8 *mimeType, float *confidence) {
char header[9]; char header[9];
if (source->read_at(0, header, sizeof(header)) != sizeof(header)) { if (source->readAt(0, header, sizeof(header)) != sizeof(header)) {
return false; return false;
} }

8
media/libstagefright/CachingDataSource.cpp
View File

@@ -61,11 +61,11 @@ CachingDataSource::~CachingDataSource() {
mData = NULL; mData = NULL;
} }
status_t CachingDataSource::InitCheck() const { status_t CachingDataSource::initCheck() const {
return OK; return mSource->initCheck();
} }
ssize_t CachingDataSource::read_at(off_t offset, void *data, size_t size) { ssize_t CachingDataSource::readAt(off_t offset, void *data, size_t size) {
Mutex::Autolock autoLock(mLock); Mutex::Autolock autoLock(mLock);
size_t total = 0; size_t total = 0;
@@ -82,7 +82,7 @@ ssize_t CachingDataSource::read_at(off_t offset, void *data, size_t size) {
if (page == NULL) { if (page == NULL) {
page = allocate_page(); page = allocate_page();
page->mOffset = offset - offset % mPageSize; page->mOffset = offset - offset % mPageSize;
ssize_t n = mSource->read_at(page->mOffset, page->mData, mPageSize); ssize_t n = mSource->readAt(page->mOffset, page->mData, mPageSize);
if (n < 0) { if (n < 0) {
page->mLength = 0; page->mLength = 0;
} else { } else {

2
media/libstagefright/DataSource.cpp
View File

@@ -28,7 +28,7 @@ bool DataSource::getUInt16(off_t offset, uint16_t *x) {
*x = 0; *x = 0;
uint8_t byte[2]; uint8_t byte[2];
if (read_at(offset, byte, 2) != 2) { if (readAt(offset, byte, 2) != 2) {
return false; return false;
} }

4
media/libstagefright/FileSource.cpp
View File

@@ -30,11 +30,11 @@ FileSource::~FileSource() {
} }
} }
status_t FileSource::InitCheck() const { status_t FileSource::initCheck() const {
return mFile != NULL ? OK : NO_INIT; return mFile != NULL ? OK : NO_INIT;
} }
ssize_t FileSource::read_at(off_t offset, void *data, size_t size) { ssize_t FileSource::readAt(off_t offset, void *data, size_t size) {
Mutex::Autolock autoLock(mLock); Mutex::Autolock autoLock(mLock);
int err = fseeko(mFile, offset, SEEK_SET); int err = fseeko(mFile, offset, SEEK_SET);

12
media/libstagefright/HTTPDataSource.cpp
View File

@@ -67,8 +67,7 @@ HTTPDataSource::HTTPDataSource(const char *uri)
mPort = port; mPort = port;
mPath = strdup(path.c_str()); mPath = strdup(path.c_str());
status_t err = mHttp->connect(mHost, mPort); mInitCheck = mHttp->connect(mHost, mPort);
CHECK_EQ(err, OK);
} }
HTTPDataSource::HTTPDataSource(const char *host, int port, const char *path) HTTPDataSource::HTTPDataSource(const char *host, int port, const char *path)
@@ -79,8 +78,11 @@ HTTPDataSource::HTTPDataSource(const char *host, int port, const char *path)
mBuffer(malloc(kBufferSize)), mBuffer(malloc(kBufferSize)),
mBufferLength(0), mBufferLength(0),
mBufferOffset(0) { mBufferOffset(0) {
status_t err = mHttp->connect(mHost, mPort); mInitCheck = mHttp->connect(mHost, mPort);
CHECK_EQ(err, OK); }
status_t HTTPDataSource::initCheck() const {
return mInitCheck;
} }
HTTPDataSource::~HTTPDataSource() { HTTPDataSource::~HTTPDataSource() {
@@ -96,7 +98,7 @@ HTTPDataSource::~HTTPDataSource() {
mHttp = NULL; mHttp = NULL;
} }
ssize_t HTTPDataSource::read_at(off_t offset, void *data, size_t size) { ssize_t HTTPDataSource::readAt(off_t offset, void *data, size_t size) {
if (offset >= mBufferOffset if (offset >= mBufferOffset
&& offset < (off_t)(mBufferOffset + mBufferLength)) { && offset < (off_t)(mBufferOffset + mBufferLength)) {
size_t num_bytes_available = mBufferLength - (offset - mBufferOffset); size_t num_bytes_available = mBufferLength - (offset - mBufferOffset);

6
media/libstagefright/JPEGSource.cpp
View File

@@ -119,7 +119,7 @@ status_t JPEGSource::read(
MediaBuffer *buffer; MediaBuffer *buffer;
mGroup->acquire_buffer(&buffer); mGroup->acquire_buffer(&buffer);
ssize_t n = mSource->read_at(mOffset, buffer->data(), mSize - mOffset); ssize_t n = mSource->readAt(mOffset, buffer->data(), mSize - mOffset);
if (n <= 0) { if (n <= 0) {
buffer->release(); buffer->release();
@@ -156,13 +156,13 @@ status_t JPEGSource::parseJPEG() {
for (;;) { for (;;) {
uint8_t marker; uint8_t marker;
if (mSource->read_at(i++, &marker, 1) != 1) { if (mSource->readAt(i++, &marker, 1) != 1) {
return ERROR_IO; return ERROR_IO;
} }
CHECK_EQ(marker, 0xff); CHECK_EQ(marker, 0xff);
if (mSource->read_at(i++, &marker, 1) != 1) { if (mSource->readAt(i++, &marker, 1) != 1) {
return ERROR_IO; return ERROR_IO;
} }

10
media/libstagefright/MP3Extractor.cpp
View File

@@ -177,7 +177,7 @@ static bool Resync(
// of the datasource. // of the datasource.
uint8_t id3header[10]; uint8_t id3header[10];
if (source->read_at(0, id3header, sizeof(id3header)) if (source->readAt(0, id3header, sizeof(id3header))
< (ssize_t)sizeof(id3header)) { < (ssize_t)sizeof(id3header)) {
// If we can't even read these 10 bytes, we might as well bail out, // 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... // even if there _were_ 10 bytes of valid mp3 audio data...
@@ -228,7 +228,7 @@ static bool Resync(
buffer_length = buffer_length - buffer_offset; buffer_length = buffer_length - buffer_offset;
buffer_offset = 0; buffer_offset = 0;
ssize_t n = source->read_at( ssize_t n = source->readAt(
pos, &buffer[buffer_length], kMaxFrameSize - buffer_length); pos, &buffer[buffer_length], kMaxFrameSize - buffer_length);
if (n <= 0) { if (n <= 0) {
@@ -265,7 +265,7 @@ static bool Resync(
valid = true; valid = true;
for (int j = 0; j < 3; ++j) { for (int j = 0; j < 3; ++j) {
uint8_t tmp[4]; uint8_t tmp[4];
if (source->read_at(test_pos, tmp, 4) < 4) { if (source->readAt(test_pos, tmp, 4) < 4) {
valid = false; valid = false;
break; break;
} }
@@ -480,7 +480,7 @@ status_t MP3Source::read(
size_t frame_size; size_t frame_size;
for (;;) { for (;;) {
ssize_t n = mDataSource->read_at(mCurrentPos, buffer->data(), 4); ssize_t n = mDataSource->readAt(mCurrentPos, buffer->data(), 4);
if (n < 4) { if (n < 4) {
buffer->release(); buffer->release();
buffer = NULL; buffer = NULL;
@@ -514,7 +514,7 @@ status_t MP3Source::read(
CHECK(frame_size <= buffer->size()); CHECK(frame_size <= buffer->size());
ssize_t n = mDataSource->read_at(mCurrentPos, buffer->data(), frame_size); ssize_t n = mDataSource->readAt(mCurrentPos, buffer->data(), frame_size);
if (n < (ssize_t)frame_size) { if (n < (ssize_t)frame_size) {
buffer->release(); buffer->release();
buffer = NULL; buffer = NULL;

38
media/libstagefright/MPEG4Extractor.cpp
View File

@@ -249,7 +249,7 @@ static void MakeFourCCString(uint32_t x, char *s) {
status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) { status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
uint32_t hdr[2]; uint32_t hdr[2];
if (mDataSource->read_at(*offset, hdr, 8) < 8) { if (mDataSource->readAt(*offset, hdr, 8) < 8) {
return ERROR_IO; return ERROR_IO;
} }
uint64_t chunk_size = ntohl(hdr[0]); uint64_t chunk_size = ntohl(hdr[0]);
@@ -257,7 +257,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
off_t data_offset = *offset + 8; off_t data_offset = *offset + 8;
if (chunk_size == 1) { if (chunk_size == 1) {
if (mDataSource->read_at(*offset + 8, &chunk_size, 8) < 8) { if (mDataSource->readAt(*offset + 8, &chunk_size, 8) < 8) {
return ERROR_IO; return ERROR_IO;
} }
chunk_size = ntoh64(chunk_size); chunk_size = ntoh64(chunk_size);
@@ -274,7 +274,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
char buffer[256]; char buffer[256];
if (chunk_size <= sizeof(buffer)) { if (chunk_size <= sizeof(buffer)) {
if (mDataSource->read_at(*offset, buffer, chunk_size) < chunk_size) { if (mDataSource->readAt(*offset, buffer, chunk_size) < chunk_size) {
return ERROR_IO; return ERROR_IO;
} }
@@ -320,7 +320,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
CHECK(chunk_data_size >= 4); CHECK(chunk_data_size >= 4);
uint8_t version; uint8_t version;
if (mDataSource->read_at(data_offset, &version, 1) < 1) { if (mDataSource->readAt(data_offset, &version, 1) < 1) {
return ERROR_IO; return ERROR_IO;
} }
@@ -334,7 +334,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
} }
uint8_t buffer[36 + 60]; uint8_t buffer[36 + 60];
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) { data_offset, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -351,7 +351,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
} }
uint8_t buffer[24 + 60]; uint8_t buffer[24 + 60];
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) { data_offset, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -389,7 +389,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
} }
uint8_t version; uint8_t version;
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, &version, sizeof(version)) data_offset, &version, sizeof(version))
< (ssize_t)sizeof(version)) { < (ssize_t)sizeof(version)) {
return ERROR_IO; return ERROR_IO;
@@ -406,7 +406,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
} }
uint32_t timescale; uint32_t timescale;
if (mDataSource->read_at( if (mDataSource->readAt(
timescale_offset, &timescale, sizeof(timescale)) timescale_offset, &timescale, sizeof(timescale))
< (ssize_t)sizeof(timescale)) { < (ssize_t)sizeof(timescale)) {
return ERROR_IO; return ERROR_IO;
@@ -416,7 +416,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
int64_t duration; int64_t duration;
if (version == 1) { if (version == 1) {
if (mDataSource->read_at( if (mDataSource->readAt(
timescale_offset + 4, &duration, sizeof(duration)) timescale_offset + 4, &duration, sizeof(duration))
< (ssize_t)sizeof(duration)) { < (ssize_t)sizeof(duration)) {
return ERROR_IO; return ERROR_IO;
@@ -424,7 +424,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
duration = ntoh64(duration); duration = ntoh64(duration);
} else { } else {
int32_t duration32; int32_t duration32;
if (mDataSource->read_at( if (mDataSource->readAt(
timescale_offset + 4, &duration32, sizeof(duration32)) timescale_offset + 4, &duration32, sizeof(duration32))
< (ssize_t)sizeof(duration32)) { < (ssize_t)sizeof(duration32)) {
return ERROR_IO; return ERROR_IO;
@@ -445,7 +445,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
} }
uint8_t buffer[24]; uint8_t buffer[24];
if (mDataSource->read_at(data_offset, buffer, 24) < 24) { if (mDataSource->readAt(data_offset, buffer, 24) < 24) {
return ERROR_IO; return ERROR_IO;
} }
@@ -472,7 +472,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
uint8_t buffer[8]; uint8_t buffer[8];
CHECK(chunk_data_size >= (off_t)sizeof(buffer)); CHECK(chunk_data_size >= (off_t)sizeof(buffer));
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, buffer, 8) < 8) { data_offset, buffer, 8) < 8) {
return ERROR_IO; return ERROR_IO;
} }
@@ -515,7 +515,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
return ERROR_MALFORMED; return ERROR_MALFORMED;
} }
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) { data_offset, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -567,7 +567,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
return ERROR_MALFORMED; return ERROR_MALFORMED;
} }
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) { data_offset, buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -678,7 +678,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
return ERROR_BUFFER_TOO_SMALL; return ERROR_BUFFER_TOO_SMALL;
} }
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, buffer, chunk_data_size) < chunk_data_size) { data_offset, buffer, chunk_data_size) < chunk_data_size) {
return ERROR_IO; return ERROR_IO;
} }
@@ -702,7 +702,7 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {
return ERROR_BUFFER_TOO_SMALL; return ERROR_BUFFER_TOO_SMALL;
} }
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, buffer, chunk_data_size) < chunk_data_size) { data_offset, buffer, chunk_data_size) < chunk_data_size) {
return ERROR_IO; return ERROR_IO;
} }
@@ -889,7 +889,7 @@ status_t MPEG4Source::read(
if (!mIsAVC || mWantsNALFragments) { if (!mIsAVC || mWantsNALFragments) {
if (newBuffer) { if (newBuffer) {
ssize_t num_bytes_read = ssize_t num_bytes_read =
mDataSource->read_at(offset, (uint8_t *)mBuffer->data(), size); mDataSource->readAt(offset, (uint8_t *)mBuffer->data(), size);
if (num_bytes_read < (ssize_t)size) { if (num_bytes_read < (ssize_t)size) {
mBuffer->release(); mBuffer->release();
@@ -944,7 +944,7 @@ status_t MPEG4Source::read(
// the start code (0x00 00 00 01). // the start code (0x00 00 00 01).
ssize_t num_bytes_read = ssize_t num_bytes_read =
mDataSource->read_at(offset, mSrcBuffer, size); mDataSource->readAt(offset, mSrcBuffer, size);
if (num_bytes_read < (ssize_t)size) { if (num_bytes_read < (ssize_t)size) {
mBuffer->release(); mBuffer->release();
@@ -995,7 +995,7 @@ bool SniffMPEG4(
const sp<DataSource> &source, String8 *mimeType, float *confidence) { const sp<DataSource> &source, String8 *mimeType, float *confidence) {
uint8_t header[8]; uint8_t header[8];
ssize_t n = source->read_at(4, header, sizeof(header)); ssize_t n = source->readAt(4, header, sizeof(header));
if (n < (ssize_t)sizeof(header)) { if (n < (ssize_t)sizeof(header)) {
return false; return false;
} }

24
media/libstagefright/MediaExtractor.cpp
View File

@@ -22,9 +22,12 @@
#include "include/MP3Extractor.h" #include "include/MP3Extractor.h"
#include "include/MPEG4Extractor.h" #include "include/MPEG4Extractor.h"
#include <media/stagefright/CachingDataSource.h>
#include <media/stagefright/DataSource.h> #include <media/stagefright/DataSource.h>
#include <media/stagefright/HTTPDataSource.h>
#include <media/stagefright/MediaDefs.h> #include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaExtractor.h> #include <media/stagefright/MediaExtractor.h>
#include <media/stagefright/MmapSource.h>
#include <utils/String8.h> #include <utils/String8.h>
namespace android { namespace android {
@@ -59,4 +62,25 @@ sp<MediaExtractor> MediaExtractor::Create(
return NULL; return NULL;
} }
// static
sp<MediaExtractor> MediaExtractor::CreateFromURI(
const char *uri, const char *mime) {
sp<DataSource> source;
if (!strncasecmp("file://", uri, 7)) {
source = new MmapSource(uri + 7);
} else if (!strncasecmp("http://", uri, 7)) {
source = new HTTPDataSource(uri);
source = new CachingDataSource(source, 64 * 1024, 10);
} else {
// Assume it's a filename.
source = new MmapSource(uri);
}
if (source == NULL || source->initCheck() != OK) {
return NULL;
}
return Create(source, mime);
}
} // namespace android } // namespace android

15
media/libstagefright/MediaPlayerImpl.cpp
View File

@@ -26,9 +26,7 @@
#include <unistd.h> #include <unistd.h>
#include <media/stagefright/AudioPlayer.h> #include <media/stagefright/AudioPlayer.h>
#include <media/stagefright/CachingDataSource.h>
// #include <media/stagefright/CameraSource.h> // #include <media/stagefright/CameraSource.h>
#include <media/stagefright/HTTPDataSource.h>
#include <media/stagefright/MediaDebug.h> #include <media/stagefright/MediaDebug.h>
#include <media/stagefright/MediaExtractor.h> #include <media/stagefright/MediaExtractor.h>
#include <media/stagefright/MediaPlayerImpl.h> #include <media/stagefright/MediaPlayerImpl.h>
@@ -71,18 +69,7 @@ MediaPlayerImpl::MediaPlayerImpl(const char *uri)
mVideoDecoder = CameraSource::Create(); mVideoDecoder = CameraSource::Create();
#endif #endif
} else { } else {
sp<DataSource> source; mExtractor = MediaExtractor::CreateFromURI(uri);
if (!strncasecmp("file://", uri, 7)) {
source = new MmapSource(uri + 7);
} else if (!strncasecmp("http://", uri, 7)) {
source = new HTTPDataSource(uri);
source = new CachingDataSource(source, 64 * 1024, 10);
} else {
// Assume it's a filename.
source = new MmapSource(uri);
}
mExtractor = MediaExtractor::Create(source);
if (mExtractor == NULL) { if (mExtractor == NULL) {
return; return;

6
media/libstagefright/MmapSource.cpp
View File

@@ -81,12 +81,12 @@ MmapSource::~MmapSource() {
} }
} }
status_t MmapSource::InitCheck() const { status_t MmapSource::initCheck() const {
return mFd == -1 ? NO_INIT : OK; return mFd == -1 ? NO_INIT : OK;
} }
ssize_t MmapSource::read_at(off_t offset, void *data, size_t size) { ssize_t MmapSource::readAt(off_t offset, void *data, size_t size) {
LOGV("read_at offset:%ld data:%p size:%d", offset, data, size); LOGV("readAt offset:%ld data:%p size:%d", offset, data, size);
CHECK(offset >= 0); CHECK(offset >= 0);
size_t avail = 0; size_t avail = 0;

30
media/libstagefright/SampleTable.cpp
View File

@@ -70,7 +70,7 @@ status_t SampleTable::setChunkOffsetParams(
} }
uint8_t header[8]; uint8_t header[8];
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) { data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -108,7 +108,7 @@ status_t SampleTable::setSampleToChunkParams(
} }
uint8_t header[8]; uint8_t header[8];
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) { data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -142,7 +142,7 @@ status_t SampleTable::setSampleSizeParams(
} }
uint8_t header[12]; uint8_t header[12];
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) { data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -194,7 +194,7 @@ status_t SampleTable::setTimeToSampleParams(
} }
uint8_t header[8]; uint8_t header[8];
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) { data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -208,7 +208,7 @@ status_t SampleTable::setTimeToSampleParams(
mTimeToSample = new uint32_t[mTimeToSampleCount * 2]; mTimeToSample = new uint32_t[mTimeToSampleCount * 2];
size_t size = sizeof(uint32_t) * mTimeToSampleCount * 2; size_t size = sizeof(uint32_t) * mTimeToSampleCount * 2;
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset + 8, mTimeToSample, size) < (ssize_t)size) { data_offset + 8, mTimeToSample, size) < (ssize_t)size) {
return ERROR_IO; return ERROR_IO;
} }
@@ -228,7 +228,7 @@ status_t SampleTable::setSyncSampleParams(off_t data_offset, size_t data_size) {
mSyncSampleOffset = data_offset; mSyncSampleOffset = data_offset;
uint8_t header[8]; uint8_t header[8];
if (mDataSource->read_at( if (mDataSource->readAt(
data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) { data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -264,7 +264,7 @@ status_t SampleTable::getChunkOffset(uint32_t chunk_index, off_t *offset) {
if (mChunkOffsetType == kChunkOffsetType32) { if (mChunkOffsetType == kChunkOffsetType32) {
uint32_t offset32; uint32_t offset32;
if (mDataSource->read_at( if (mDataSource->readAt(
mChunkOffsetOffset + 8 + 4 * chunk_index, mChunkOffsetOffset + 8 + 4 * chunk_index,
&offset32, &offset32,
sizeof(offset32)) < (ssize_t)sizeof(offset32)) { sizeof(offset32)) < (ssize_t)sizeof(offset32)) {
@@ -276,7 +276,7 @@ status_t SampleTable::getChunkOffset(uint32_t chunk_index, off_t *offset) {
CHECK_EQ(mChunkOffsetType, kChunkOffsetType64); CHECK_EQ(mChunkOffsetType, kChunkOffsetType64);
uint64_t offset64; uint64_t offset64;
if (mDataSource->read_at( if (mDataSource->readAt(
mChunkOffsetOffset + 8 + 8 * chunk_index, mChunkOffsetOffset + 8 + 8 * chunk_index,
&offset64, &offset64,
sizeof(offset64)) < (ssize_t)sizeof(offset64)) { sizeof(offset64)) < (ssize_t)sizeof(offset64)) {
@@ -313,7 +313,7 @@ status_t SampleTable::getChunkForSample(
uint32_t index = 0; uint32_t index = 0;
while (index < mNumSampleToChunkOffsets) { while (index < mNumSampleToChunkOffsets) {
uint8_t buffer[12]; uint8_t buffer[12];
if (mDataSource->read_at(mSampleToChunkOffset + 8 + index * 12, if (mDataSource->readAt(mSampleToChunkOffset + 8 + index * 12,
buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) { buffer, sizeof(buffer)) < (ssize_t)sizeof(buffer)) {
return ERROR_IO; return ERROR_IO;
} }
@@ -362,7 +362,7 @@ status_t SampleTable::getSampleSize(
switch (mSampleSizeFieldSize) { switch (mSampleSizeFieldSize) {
case 32: case 32:
{ {
if (mDataSource->read_at( if (mDataSource->readAt(
mSampleSizeOffset + 12 + 4 * sample_index, mSampleSizeOffset + 12 + 4 * sample_index,
sample_size, sizeof(*sample_size)) < (ssize_t)sizeof(*sample_size)) { sample_size, sizeof(*sample_size)) < (ssize_t)sizeof(*sample_size)) {
return ERROR_IO; return ERROR_IO;
@@ -375,7 +375,7 @@ status_t SampleTable::getSampleSize(
case 16: case 16:
{ {
uint16_t x; uint16_t x;
if (mDataSource->read_at( if (mDataSource->readAt(
mSampleSizeOffset + 12 + 2 * sample_index, mSampleSizeOffset + 12 + 2 * sample_index,
&x, sizeof(x)) < (ssize_t)sizeof(x)) { &x, sizeof(x)) < (ssize_t)sizeof(x)) {
return ERROR_IO; return ERROR_IO;
@@ -388,7 +388,7 @@ status_t SampleTable::getSampleSize(
case 8: case 8:
{ {
uint8_t x; uint8_t x;
if (mDataSource->read_at( if (mDataSource->readAt(
mSampleSizeOffset + 12 + sample_index, mSampleSizeOffset + 12 + sample_index,
&x, sizeof(x)) < (ssize_t)sizeof(x)) { &x, sizeof(x)) < (ssize_t)sizeof(x)) {
return ERROR_IO; return ERROR_IO;
@@ -403,7 +403,7 @@ status_t SampleTable::getSampleSize(
CHECK_EQ(mSampleSizeFieldSize, 4); CHECK_EQ(mSampleSizeFieldSize, 4);
uint8_t x; uint8_t x;
if (mDataSource->read_at( if (mDataSource->readAt(
mSampleSizeOffset + 12 + sample_index / 2, mSampleSizeOffset + 12 + sample_index / 2,
&x, sizeof(x)) < (ssize_t)sizeof(x)) { &x, sizeof(x)) < (ssize_t)sizeof(x)) {
return ERROR_IO; return ERROR_IO;
@@ -554,7 +554,7 @@ status_t SampleTable::findClosestSyncSample(
uint32_t right = mNumSyncSamples; uint32_t right = mNumSyncSamples;
while (left < right) { while (left < right) {
uint32_t mid = (left + right) / 2; uint32_t mid = (left + right) / 2;
if (mDataSource->read_at( if (mDataSource->readAt(
mSyncSampleOffset + 8 + (mid - 1) * 4, &x, 4) != 4) { mSyncSampleOffset + 8 + (mid - 1) * 4, &x, 4) != 4) {
return ERROR_IO; return ERROR_IO;
} }
@@ -597,7 +597,7 @@ status_t SampleTable::findThumbnailSample(uint32_t *sample_index) {
for (size_t i = 0; i < numSamplesToScan; ++i) { for (size_t i = 0; i < numSamplesToScan; ++i) {
uint32_t x; uint32_t x;
if (mDataSource->read_at( if (mDataSource->readAt(
mSyncSampleOffset + 8 + i * 4, &x, 4) != 4) { mSyncSampleOffset + 8 + i * 4, &x, 4) != 4) {
return ERROR_IO; return ERROR_IO;
} }