Remove RefBase from plugin-side DataSource

Extractor plugins now use DataSourceBase, which is not refcounted.
Framework-side DataSource derives from DataSourceBase and RefBase.
Also remove MediaExtractor::release, because it is not needed
anymore due to the way the extractor/track/datasource lifecycle
is managed now.
Also add source and target pid to CallbackDataSource name, to
make the extractor dumpsys more useful.

Bug: 67908556
Test: build, boot, CTS, skia test app for heif
Change-Id: I6b9cbe903f76b0cf27ba87f4a456f424803efd08
gugelfrei
Marco Nelissen 7 years ago
parent 58bce94756
commit 2a243f0819

@ -0,0 +1 @@
../../media/libmediaextractor/include/media/DataSourceBase.h

@ -19,7 +19,7 @@
#include <utils/Log.h> #include <utils/Log.h>
#include "AACExtractor.h" #include "AACExtractor.h"
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABuffer.h> #include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/AMessage.h> #include <media/stagefright/foundation/AMessage.h>
@ -35,7 +35,7 @@ namespace android {
class AACSource : public MediaSourceBase { class AACSource : public MediaSourceBase {
public: public:
AACSource(const sp<DataSource> &source, AACSource(DataSourceBase *source,
const sp<MetaData> &meta, const sp<MetaData> &meta,
const Vector<uint64_t> &offset_vector, const Vector<uint64_t> &offset_vector,
int64_t frame_duration_us); int64_t frame_duration_us);
@ -53,7 +53,7 @@ protected:
private: private:
static const size_t kMaxFrameSize; static const size_t kMaxFrameSize;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<MetaData> mMeta; sp<MetaData> mMeta;
off64_t mOffset; off64_t mOffset;
@ -91,7 +91,7 @@ uint32_t get_sample_rate(const uint8_t sf_index)
// The returned value is the AAC frame size with the ADTS header length (regardless of // The returned value is the AAC frame size with the ADTS header length (regardless of
// the presence of the CRC). // the presence of the CRC).
// If headerSize is non-NULL, it will be used to return the size of the header of this ADTS frame. // If headerSize is non-NULL, it will be used to return the size of the header of this ADTS frame.
static size_t getAdtsFrameLength(const sp<DataSource> &source, off64_t offset, size_t* headerSize) { static size_t getAdtsFrameLength(DataSourceBase *source, off64_t offset, size_t* headerSize) {
const size_t kAdtsHeaderLengthNoCrc = 7; const size_t kAdtsHeaderLengthNoCrc = 7;
const size_t kAdtsHeaderLengthWithCrc = 9; const size_t kAdtsHeaderLengthWithCrc = 9;
@ -132,7 +132,7 @@ static size_t getAdtsFrameLength(const sp<DataSource> &source, off64_t offset, s
} }
AACExtractor::AACExtractor( AACExtractor::AACExtractor(
const sp<DataSource> &source, const sp<AMessage> &_meta) DataSourceBase *source, const sp<AMessage> &_meta)
: mDataSource(source), : mDataSource(source),
mInitCheck(NO_INIT), mInitCheck(NO_INIT),
mFrameDurationUs(0) { mFrameDurationUs(0) {
@ -229,7 +229,7 @@ sp<MetaData> AACExtractor::getTrackMetaData(size_t index, uint32_t /* flags */)
const size_t AACSource::kMaxFrameSize = 8192; const size_t AACSource::kMaxFrameSize = 8192;
AACSource::AACSource( AACSource::AACSource(
const sp<DataSource> &source, const sp<MetaData> &meta, DataSourceBase *source, const sp<MetaData> &meta,
const Vector<uint64_t> &offset_vector, const Vector<uint64_t> &offset_vector,
int64_t frame_duration_us) int64_t frame_duration_us)
: mDataSource(source), : mDataSource(source),
@ -332,13 +332,13 @@ status_t AACSource::read(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static MediaExtractor* CreateExtractor( static MediaExtractor* CreateExtractor(
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta) { const sp<AMessage>& meta) {
return new AACExtractor(source, meta); return new AACExtractor(source, meta);
} }
static MediaExtractor::CreatorFunc Sniff( static MediaExtractor::CreatorFunc Sniff(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *meta) { sp<AMessage> *meta) {
off64_t pos = 0; off64_t pos = 0;

@ -29,7 +29,7 @@ class String8;
class AACExtractor : public MediaExtractor { class AACExtractor : public MediaExtractor {
public: public:
AACExtractor(const sp<DataSource> &source, const sp<AMessage> &meta); AACExtractor(DataSourceBase *source, const sp<AMessage> &meta);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -42,7 +42,7 @@ protected:
virtual ~AACExtractor(); virtual ~AACExtractor();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<MetaData> mMeta; sp<MetaData> mMeta;
status_t mInitCheck; status_t mInitCheck;
@ -54,7 +54,7 @@ private:
}; };
bool SniffAAC( bool SniffAAC(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *); sp<AMessage> *);
} // namespace android } // namespace android

@ -20,7 +20,7 @@
#include "AMRExtractor.h" #include "AMRExtractor.h"
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaBufferGroup.h> #include <media/stagefright/MediaBufferGroup.h>
@ -33,7 +33,7 @@ namespace android {
class AMRSource : public MediaSourceBase { class AMRSource : public MediaSourceBase {
public: public:
AMRSource(const sp<DataSource> &source, AMRSource(DataSourceBase *source,
const sp<MetaData> &meta, const sp<MetaData> &meta,
bool isWide, bool isWide,
const off64_t *offset_table, const off64_t *offset_table,
@ -51,7 +51,7 @@ protected:
virtual ~AMRSource(); virtual ~AMRSource();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<MetaData> mMeta; sp<MetaData> mMeta;
bool mIsWide; bool mIsWide;
@ -97,7 +97,7 @@ static size_t getFrameSize(bool isWide, unsigned FT) {
return frameSize; return frameSize;
} }
static status_t getFrameSizeByOffset(const sp<DataSource> &source, static status_t getFrameSizeByOffset(DataSourceBase *source,
off64_t offset, bool isWide, size_t *frameSize) { off64_t offset, bool isWide, size_t *frameSize) {
uint8_t header; uint8_t header;
ssize_t count = source->readAt(offset, &header, 1); ssize_t count = source->readAt(offset, &header, 1);
@ -116,7 +116,7 @@ static status_t getFrameSizeByOffset(const sp<DataSource> &source,
return OK; return OK;
} }
AMRExtractor::AMRExtractor(const sp<DataSource> &source) AMRExtractor::AMRExtractor(DataSourceBase *source)
: mDataSource(source), : mDataSource(source),
mInitCheck(NO_INIT), mInitCheck(NO_INIT),
mOffsetTableLength(0) { mOffsetTableLength(0) {
@ -206,7 +206,7 @@ sp<MetaData> AMRExtractor::getTrackMetaData(size_t index, uint32_t /* flags */)
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
AMRSource::AMRSource( AMRSource::AMRSource(
const sp<DataSource> &source, const sp<MetaData> &meta, DataSourceBase *source, const sp<MetaData> &meta,
bool isWide, const off64_t *offset_table, size_t offset_table_length) bool isWide, const off64_t *offset_table, size_t offset_table_length)
: mDataSource(source), : mDataSource(source),
mMeta(meta), mMeta(meta),
@ -339,7 +339,7 @@ status_t AMRSource::read(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
bool SniffAMR( bool SniffAMR(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *) { sp<AMessage> *) {
char header[9]; char header[9];
@ -372,13 +372,13 @@ MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
1, 1,
"AMR Extractor", "AMR Extractor",
[]( [](
const sp<DataSource> &source, DataSourceBase *source,
String8 *mimeType, String8 *mimeType,
float *confidence, float *confidence,
sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc { sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc {
if (SniffAMR(source, mimeType, confidence, meta)) { if (SniffAMR(source, mimeType, confidence, meta)) {
return []( return [](
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) -> MediaExtractor* { const sp<AMessage>& meta __unused) -> MediaExtractor* {
return new AMRExtractor(source);}; return new AMRExtractor(source);};
} }

@ -29,7 +29,7 @@ class String8;
class AMRExtractor : public MediaExtractor { class AMRExtractor : public MediaExtractor {
public: public:
explicit AMRExtractor(const sp<DataSource> &source); explicit AMRExtractor(DataSourceBase *source);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -42,7 +42,7 @@ protected:
virtual ~AMRExtractor(); virtual ~AMRExtractor();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<MetaData> mMeta; sp<MetaData> mMeta;
status_t mInitCheck; status_t mInitCheck;
bool mIsWide; bool mIsWide;
@ -55,7 +55,7 @@ private:
}; };
bool SniffAMR( bool SniffAMR(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *); sp<AMessage> *);
} // namespace android } // namespace android

@ -22,7 +22,7 @@
// libFLAC parser // libFLAC parser
#include "FLAC/stream_decoder.h" #include "FLAC/stream_decoder.h"
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABuffer.h> #include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
@ -165,7 +165,7 @@ class FLACSource : public MediaSourceBase {
public: public:
FLACSource( FLACSource(
const sp<DataSource> &dataSource, DataSourceBase *dataSource,
const sp<MetaData> &trackMetadata); const sp<MetaData> &trackMetadata);
virtual status_t start(MetaData *params); virtual status_t start(MetaData *params);
@ -179,7 +179,7 @@ protected:
virtual ~FLACSource(); virtual ~FLACSource();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<MetaData> mTrackMetadata; sp<MetaData> mTrackMetadata;
sp<FLACParser> mParser; sp<FLACParser> mParser;
bool mInitCheck; bool mInitCheck;
@ -203,7 +203,7 @@ public:
}; };
explicit FLACParser( explicit FLACParser(
const sp<DataSource> &dataSource, DataSourceBase *dataSource,
// If metadata pointers aren't provided, we don't fill them // If metadata pointers aren't provided, we don't fill them
const sp<MetaData> &fileMetadata = 0, const sp<MetaData> &fileMetadata = 0,
const sp<MetaData> &trackMetadata = 0); const sp<MetaData> &trackMetadata = 0);
@ -243,7 +243,7 @@ protected:
virtual ~FLACParser(); virtual ~FLACParser();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<MetaData> mFileMetadata; sp<MetaData> mFileMetadata;
sp<MetaData> mTrackMetadata; sp<MetaData> mTrackMetadata;
bool mInitCheck; bool mInitCheck;
@ -612,7 +612,7 @@ static void copyTrespass(
// FLACParser // FLACParser
FLACParser::FLACParser( FLACParser::FLACParser(
const sp<DataSource> &dataSource, DataSourceBase *dataSource,
const sp<MetaData> &fileMetadata, const sp<MetaData> &fileMetadata,
const sp<MetaData> &trackMetadata) const sp<MetaData> &trackMetadata)
: mDataSource(dataSource), : mDataSource(dataSource),
@ -833,7 +833,7 @@ MediaBuffer *FLACParser::readBuffer(bool doSeek, FLAC__uint64 sample)
// FLACsource // FLACsource
FLACSource::FLACSource( FLACSource::FLACSource(
const sp<DataSource> &dataSource, DataSourceBase *dataSource,
const sp<MetaData> &trackMetadata) const sp<MetaData> &trackMetadata)
: mDataSource(dataSource), : mDataSource(dataSource),
mTrackMetadata(trackMetadata), mTrackMetadata(trackMetadata),
@ -918,7 +918,7 @@ status_t FLACSource::init()
// FLACExtractor // FLACExtractor
FLACExtractor::FLACExtractor( FLACExtractor::FLACExtractor(
const sp<DataSource> &dataSource) DataSourceBase *dataSource)
: mDataSource(dataSource), : mDataSource(dataSource),
mInitCheck(false) mInitCheck(false)
{ {
@ -969,7 +969,7 @@ sp<MetaData> FLACExtractor::getMetaData()
// Sniffer // Sniffer
bool SniffFLAC( bool SniffFLAC(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *) sp<AMessage> *)
{ {
// first 4 is the signature word // first 4 is the signature word
@ -1000,13 +1000,13 @@ MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
1, 1,
"FLAC Extractor", "FLAC Extractor",
[]( [](
const sp<DataSource> &source, DataSourceBase *source,
String8 *mimeType, String8 *mimeType,
float *confidence, float *confidence,
sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc { sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc {
if (SniffFLAC(source, mimeType, confidence, meta)) { if (SniffFLAC(source, mimeType, confidence, meta)) {
return []( return [](
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) -> MediaExtractor* { const sp<AMessage>& meta __unused) -> MediaExtractor* {
return new FLACExtractor(source);}; return new FLACExtractor(source);};
} }

@ -17,7 +17,7 @@
#ifndef FLAC_EXTRACTOR_H_ #ifndef FLAC_EXTRACTOR_H_
#define FLAC_EXTRACTOR_H_ #define FLAC_EXTRACTOR_H_
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaExtractor.h> #include <media/MediaExtractor.h>
#include <utils/String8.h> #include <utils/String8.h>
@ -28,8 +28,7 @@ class FLACParser;
class FLACExtractor : public MediaExtractor { class FLACExtractor : public MediaExtractor {
public: public:
// Extractor assumes ownership of source explicit FLACExtractor(DataSourceBase *source);
explicit FLACExtractor(const sp<DataSource> &source);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -42,7 +41,7 @@ protected:
virtual ~FLACExtractor(); virtual ~FLACExtractor();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<FLACParser> mParser; sp<FLACParser> mParser;
status_t mInitCheck; status_t mInitCheck;
sp<MetaData> mFileMetadata; sp<MetaData> mFileMetadata;
@ -57,7 +56,7 @@ private:
}; };
bool SniffFLAC(const sp<DataSource> &source, String8 *mimeType, bool SniffFLAC(DataSourceBase *source, String8 *mimeType,
float *confidence, sp<AMessage> *); float *confidence, sp<AMessage> *);
} // namespace android } // namespace android

@ -141,7 +141,7 @@ status_t MidiSource::init()
// MidiEngine // MidiEngine
MidiEngine::MidiEngine(const sp<DataSource> &dataSource, MidiEngine::MidiEngine(DataSourceBase *dataSource,
const sp<MetaData> &fileMetadata, const sp<MetaData> &fileMetadata,
const sp<MetaData> &trackMetadata) : const sp<MetaData> &trackMetadata) :
mGroup(NULL), mGroup(NULL),
@ -261,7 +261,7 @@ MediaBuffer* MidiEngine::readBuffer() {
// MidiExtractor // MidiExtractor
MidiExtractor::MidiExtractor( MidiExtractor::MidiExtractor(
const sp<DataSource> &dataSource) DataSourceBase *dataSource)
: mDataSource(dataSource), : mDataSource(dataSource),
mInitCheck(false) mInitCheck(false)
{ {
@ -308,7 +308,7 @@ sp<MetaData> MidiExtractor::getMetaData()
// Sniffer // Sniffer
bool SniffMidi( bool SniffMidi(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *) sp<AMessage> *)
{ {
sp<MidiEngine> p = new MidiEngine(source, NULL, NULL); sp<MidiEngine> p = new MidiEngine(source, NULL, NULL);
@ -333,13 +333,13 @@ MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
1, 1,
"MIDI Extractor", "MIDI Extractor",
[]( [](
const sp<DataSource> &source, DataSourceBase *source,
String8 *mimeType, String8 *mimeType,
float *confidence, float *confidence,
sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc { sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc {
if (SniffMidi(source, mimeType, confidence, meta)) { if (SniffMidi(source, mimeType, confidence, meta)) {
return []( return [](
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) -> MediaExtractor* { const sp<AMessage>& meta __unused) -> MediaExtractor* {
return new MidiExtractor(source);}; return new MidiExtractor(source);};
} }

@ -17,7 +17,7 @@
#ifndef MIDI_EXTRACTOR_H_ #ifndef MIDI_EXTRACTOR_H_
#define MIDI_EXTRACTOR_H_ #define MIDI_EXTRACTOR_H_
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaExtractor.h> #include <media/MediaExtractor.h>
#include <media/stagefright/MediaBuffer.h> #include <media/stagefright/MediaBuffer.h>
#include <media/stagefright/MediaBufferGroup.h> #include <media/stagefright/MediaBufferGroup.h>
@ -29,7 +29,7 @@ namespace android {
class MidiEngine : public RefBase { class MidiEngine : public RefBase {
public: public:
MidiEngine(const sp<DataSource> &dataSource, MidiEngine(DataSourceBase *dataSource,
const sp<MetaData> &fileMetadata, const sp<MetaData> &fileMetadata,
const sp<MetaData> &trackMetadata); const sp<MetaData> &trackMetadata);
~MidiEngine(); ~MidiEngine();
@ -52,8 +52,7 @@ private:
class MidiExtractor : public MediaExtractor { class MidiExtractor : public MediaExtractor {
public: public:
// Extractor assumes ownership of source explicit MidiExtractor(DataSourceBase *source);
explicit MidiExtractor(const sp<DataSource> &source);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -66,7 +65,7 @@ protected:
virtual ~MidiExtractor(); virtual ~MidiExtractor();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
status_t mInitCheck; status_t mInitCheck;
sp<MetaData> mFileMetadata; sp<MetaData> mFileMetadata;
@ -88,7 +87,7 @@ private:
}; };
bool SniffMidi(const sp<DataSource> &source, String8 *mimeType, bool SniffMidi(DataSourceBase *source, String8 *mimeType,
float *confidence, sp<AMessage> *); float *confidence, sp<AMessage> *);
} // namespace android } // namespace android

@ -21,7 +21,7 @@
#include "FLACDecoder.h" #include "FLACDecoder.h"
#include "MatroskaExtractor.h" #include "MatroskaExtractor.h"
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AUtils.h> #include <media/stagefright/foundation/AUtils.h>
@ -40,8 +40,8 @@
namespace android { namespace android {
struct DataSourceReader : public mkvparser::IMkvReader { struct DataSourceBaseReader : public mkvparser::IMkvReader {
explicit DataSourceReader(const sp<DataSource> &source) explicit DataSourceBaseReader(DataSourceBase *source)
: mSource(source) { : mSource(source) {
} }
@ -83,10 +83,10 @@ struct DataSourceReader : public mkvparser::IMkvReader {
} }
private: private:
sp<DataSource> mSource; DataSourceBase *mSource;
DataSourceReader(const DataSourceReader &); DataSourceBaseReader(const DataSourceBaseReader &);
DataSourceReader &operator=(const DataSourceReader &); DataSourceBaseReader &operator=(const DataSourceBaseReader &);
}; };
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -852,9 +852,9 @@ status_t MatroskaSource::read(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
MatroskaExtractor::MatroskaExtractor(const sp<DataSource> &source) MatroskaExtractor::MatroskaExtractor(DataSourceBase *source)
: mDataSource(source), : mDataSource(source),
mReader(new DataSourceReader(mDataSource)), mReader(new DataSourceBaseReader(mDataSource)),
mSegment(NULL), mSegment(NULL),
mExtractedThumbnails(false), mExtractedThumbnails(false),
mIsWebm(false), mIsWebm(false),
@ -862,8 +862,8 @@ MatroskaExtractor::MatroskaExtractor(const sp<DataSource> &source)
off64_t size; off64_t size;
mIsLiveStreaming = mIsLiveStreaming =
(mDataSource->flags() (mDataSource->flags()
& (DataSource::kWantsPrefetching & (DataSourceBase::kWantsPrefetching
| DataSource::kIsCachingDataSource)) | DataSourceBase::kIsCachingDataSource))
&& mDataSource->getSize(&size) != OK; && mDataSource->getSize(&size) != OK;
mkvparser::EBMLHeader ebmlHeader; mkvparser::EBMLHeader ebmlHeader;
@ -1548,9 +1548,9 @@ uint32_t MatroskaExtractor::flags() const {
} }
bool SniffMatroska( bool SniffMatroska(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *) { sp<AMessage> *) {
DataSourceReader reader(source); DataSourceBaseReader reader(source);
mkvparser::EBMLHeader ebmlHeader; mkvparser::EBMLHeader ebmlHeader;
long long pos; long long pos;
if (ebmlHeader.Parse(&reader, pos) < 0) { if (ebmlHeader.Parse(&reader, pos) < 0) {
@ -1574,13 +1574,13 @@ MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
1, 1,
"Matroska Extractor", "Matroska Extractor",
[]( [](
const sp<DataSource> &source, DataSourceBase *source,
String8 *mimeType, String8 *mimeType,
float *confidence, float *confidence,
sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc { sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc {
if (SniffMatroska(source, mimeType, confidence, meta)) { if (SniffMatroska(source, mimeType, confidence, meta)) {
return []( return [](
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) -> MediaExtractor* { const sp<AMessage>& meta __unused) -> MediaExtractor* {
return new MatroskaExtractor(source);}; return new MatroskaExtractor(source);};
} }

@ -30,11 +30,11 @@ struct AMessage;
class String8; class String8;
class MetaData; class MetaData;
struct DataSourceReader; struct DataSourceBaseReader;
struct MatroskaSource; struct MatroskaSource;
struct MatroskaExtractor : public MediaExtractor { struct MatroskaExtractor : public MediaExtractor {
explicit MatroskaExtractor(const sp<DataSource> &source); explicit MatroskaExtractor(DataSourceBase *source);
virtual size_t countTracks(); virtual size_t countTracks();
@ -76,8 +76,8 @@ private:
Mutex mLock; Mutex mLock;
Vector<TrackInfo> mTracks; Vector<TrackInfo> mTracks;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
DataSourceReader *mReader; DataSourceBaseReader *mReader;
mkvparser::Segment *mSegment; mkvparser::Segment *mSegment;
bool mExtractedThumbnails; bool mExtractedThumbnails;
bool mIsLiveStreaming; bool mIsLiveStreaming;
@ -96,7 +96,7 @@ private:
}; };
bool SniffMatroska( bool SniffMatroska(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *); sp<AMessage> *);
} // namespace android } // namespace android

@ -24,7 +24,7 @@
#include "VBRISeeker.h" #include "VBRISeeker.h"
#include "XINGSeeker.h" #include "XINGSeeker.h"
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AMessage.h> #include <media/stagefright/foundation/AMessage.h>
@ -46,7 +46,7 @@ namespace android {
static const uint32_t kMask = 0xfffe0c00; static const uint32_t kMask = 0xfffe0c00;
static bool Resync( static bool Resync(
const sp<DataSource> &source, uint32_t match_header, DataSourceBase *source, uint32_t match_header,
off64_t *inout_pos, off64_t *post_id3_pos, uint32_t *out_header) { off64_t *inout_pos, off64_t *post_id3_pos, uint32_t *out_header) {
if (post_id3_pos != NULL) { if (post_id3_pos != NULL) {
*post_id3_pos = 0; *post_id3_pos = 0;
@ -212,7 +212,7 @@ static bool Resync(
class MP3Source : public MediaSourceBase { class MP3Source : public MediaSourceBase {
public: public:
MP3Source( MP3Source(
const sp<MetaData> &meta, const sp<DataSource> &source, const sp<MetaData> &meta, DataSourceBase *source,
off64_t first_frame_pos, uint32_t fixed_header, off64_t first_frame_pos, uint32_t fixed_header,
const sp<MP3Seeker> &seeker); const sp<MP3Seeker> &seeker);
@ -230,7 +230,7 @@ protected:
private: private:
static const size_t kMaxFrameSize; static const size_t kMaxFrameSize;
sp<MetaData> mMeta; sp<MetaData> mMeta;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
off64_t mFirstFramePos; off64_t mFirstFramePos;
uint32_t mFixedHeader; uint32_t mFixedHeader;
off64_t mCurrentPos; off64_t mCurrentPos;
@ -247,7 +247,7 @@ private:
}; };
MP3Extractor::MP3Extractor( MP3Extractor::MP3Extractor(
const sp<DataSource> &source, const sp<AMessage> &meta) DataSourceBase *source, const sp<AMessage> &meta)
: mInitCheck(NO_INIT), : mInitCheck(NO_INIT),
mDataSource(source), mDataSource(source),
mFirstFramePos(-1), mFirstFramePos(-1),
@ -436,7 +436,7 @@ sp<MetaData> MP3Extractor::getTrackMetaData(
// Set our max frame size to the nearest power of 2 above this size (aka, 4kB) // 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 */ const size_t MP3Source::kMaxFrameSize = (1 << 12); /* 4096 bytes */
MP3Source::MP3Source( MP3Source::MP3Source(
const sp<MetaData> &meta, const sp<DataSource> &source, const sp<MetaData> &meta, DataSourceBase *source,
off64_t first_frame_pos, uint32_t fixed_header, off64_t first_frame_pos, uint32_t fixed_header,
const sp<MP3Seeker> &seeker) const sp<MP3Seeker> &seeker)
: mMeta(meta), : mMeta(meta),
@ -667,13 +667,13 @@ sp<MetaData> MP3Extractor::getMetaData() {
} }
static MediaExtractor* CreateExtractor( static MediaExtractor* CreateExtractor(
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta) { const sp<AMessage>& meta) {
return new MP3Extractor(source, meta); return new MP3Extractor(source, meta);
} }
static MediaExtractor::CreatorFunc Sniff( static MediaExtractor::CreatorFunc Sniff(
const sp<DataSource> &source, String8 *mimeType, DataSourceBase *source, String8 *mimeType,
float *confidence, sp<AMessage> *meta) { float *confidence, sp<AMessage> *meta) {
off64_t pos = 0; off64_t pos = 0;
off64_t post_id3_pos; off64_t post_id3_pos;

@ -24,14 +24,13 @@
namespace android { namespace android {
struct AMessage; struct AMessage;
class DataSource; class DataSourceBase;
struct MP3Seeker; struct MP3Seeker;
class String8; class String8;
class MP3Extractor : public MediaExtractor { class MP3Extractor : public MediaExtractor {
public: public:
// Extractor assumes ownership of "source". MP3Extractor(DataSourceBase *source, const sp<AMessage> &meta);
MP3Extractor(const sp<DataSource> &source, const sp<AMessage> &meta);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -43,7 +42,7 @@ public:
private: private:
status_t mInitCheck; status_t mInitCheck;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
off64_t mFirstFramePos; off64_t mFirstFramePos;
sp<MetaData> mMeta; sp<MetaData> mMeta;
uint32_t mFixedHeader; uint32_t mFixedHeader;
@ -54,7 +53,7 @@ private:
}; };
bool SniffMP3( bool SniffMP3(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *meta); sp<AMessage> *meta);
} // namespace android } // namespace android

@ -27,7 +27,7 @@
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/ByteUtils.h> #include <media/stagefright/foundation/ByteUtils.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
namespace android { namespace android {
@ -37,7 +37,7 @@ static uint32_t U24_AT(const uint8_t *ptr) {
// static // static
sp<VBRISeeker> VBRISeeker::CreateFromSource( sp<VBRISeeker> VBRISeeker::CreateFromSource(
const sp<DataSource> &source, off64_t post_id3_pos) { DataSourceBase *source, off64_t post_id3_pos) {
off64_t pos = post_id3_pos; off64_t pos = post_id3_pos;
uint8_t header[4]; uint8_t header[4];

@ -24,11 +24,11 @@
namespace android { namespace android {
class DataSource; class DataSourceBase;
struct VBRISeeker : public MP3Seeker { struct VBRISeeker : public MP3Seeker {
static sp<VBRISeeker> CreateFromSource( static sp<VBRISeeker> CreateFromSource(
const sp<DataSource> &source, off64_t post_id3_pos); DataSourceBase *source, off64_t post_id3_pos);
virtual bool getDuration(int64_t *durationUs); virtual bool getDuration(int64_t *durationUs);
virtual bool getOffsetForTime(int64_t *timeUs, off64_t *pos); virtual bool getOffsetForTime(int64_t *timeUs, off64_t *pos);

@ -21,7 +21,7 @@
#include <media/stagefright/foundation/avc_utils.h> #include <media/stagefright/foundation/avc_utils.h>
#include <media/stagefright/foundation/ByteUtils.h> #include <media/stagefright/foundation/ByteUtils.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
namespace android { namespace android {
@ -77,7 +77,7 @@ bool XINGSeeker::getOffsetForTime(int64_t *timeUs, off64_t *pos) {
// static // static
sp<XINGSeeker> XINGSeeker::CreateFromSource( sp<XINGSeeker> XINGSeeker::CreateFromSource(
const sp<DataSource> &source, off64_t first_frame_pos) { DataSourceBase *source, off64_t first_frame_pos) {
sp<XINGSeeker> seeker = new XINGSeeker; sp<XINGSeeker> seeker = new XINGSeeker;
seeker->mFirstFramePos = first_frame_pos; seeker->mFirstFramePos = first_frame_pos;

@ -22,11 +22,11 @@
namespace android { namespace android {
class DataSource; class DataSourceBase;
struct XINGSeeker : public MP3Seeker { struct XINGSeeker : public MP3Seeker {
static sp<XINGSeeker> CreateFromSource( static sp<XINGSeeker> CreateFromSource(
const sp<DataSource> &source, off64_t first_frame_pos); DataSourceBase *source, off64_t first_frame_pos);
virtual bool getDuration(int64_t *durationUs); virtual bool getDuration(int64_t *durationUs);
virtual bool getOffsetForTime(int64_t *timeUs, off64_t *pos); virtual bool getOffsetForTime(int64_t *timeUs, off64_t *pos);

@ -18,7 +18,7 @@
#define LOG_TAG "ItemTable" #define LOG_TAG "ItemTable"
#include <ItemTable.h> #include <ItemTable.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/stagefright/MetaData.h> #include <media/stagefright/MetaData.h>
#include <media/stagefright/MediaErrors.h> #include <media/stagefright/MediaErrors.h>
#include <media/stagefright/foundation/ABuffer.h> #include <media/stagefright/foundation/ABuffer.h>
@ -87,7 +87,7 @@ struct ImageItem {
struct Box { struct Box {
protected: protected:
Box(const sp<DataSource> source, uint32_t type) : Box(DataSourceBase *source, uint32_t type) :
mDataSource(source), mType(type) {} mDataSource(source), mType(type) {}
virtual ~Box() {} virtual ~Box() {}
@ -99,14 +99,14 @@ protected:
inline uint32_t type() const { return mType; } inline uint32_t type() const { return mType; }
inline sp<DataSource> source() const { return mDataSource; } inline DataSourceBase *source() const { return mDataSource; }
status_t parseChunk(off64_t *offset); status_t parseChunk(off64_t *offset);
status_t parseChunks(off64_t offset, size_t size); status_t parseChunks(off64_t offset, size_t size);
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
uint32_t mType; uint32_t mType;
}; };
@ -181,7 +181,7 @@ status_t Box::parseChunks(off64_t offset, size_t size) {
struct FullBox : public Box { struct FullBox : public Box {
protected: protected:
FullBox(const sp<DataSource> source, uint32_t type) : FullBox(DataSourceBase *source, uint32_t type) :
Box(source, type), mVersion(0), mFlags(0) {} Box(source, type), mVersion(0), mFlags(0) {}
inline uint8_t version() const { return mVersion; } inline uint8_t version() const { return mVersion; }
@ -216,7 +216,7 @@ status_t FullBox::parseFullBoxHeader(off64_t *offset, size_t *size) {
// //
struct PitmBox : public FullBox { struct PitmBox : public FullBox {
PitmBox(const sp<DataSource> source) : PitmBox(DataSourceBase *source) :
FullBox(source, FOURCC('p', 'i', 't', 'm')) {} FullBox(source, FOURCC('p', 'i', 't', 'm')) {}
status_t parse(off64_t offset, size_t size, uint32_t *primaryItemId); status_t parse(off64_t offset, size_t size, uint32_t *primaryItemId);
@ -296,7 +296,7 @@ struct ItemLoc {
}; };
struct IlocBox : public FullBox { struct IlocBox : public FullBox {
IlocBox(const sp<DataSource> source, KeyedVector<uint32_t, ItemLoc> *itemLocs) : IlocBox(DataSourceBase *source, KeyedVector<uint32_t, ItemLoc> *itemLocs) :
FullBox(source, FOURCC('i', 'l', 'o', 'c')), FullBox(source, FOURCC('i', 'l', 'o', 'c')),
mItemLocs(itemLocs), mHasConstructMethod1(false) {} mItemLocs(itemLocs), mHasConstructMethod1(false) {}
@ -466,7 +466,7 @@ status_t IlocBox::parse(off64_t offset, size_t size) {
// //
struct ItemReference : public Box, public RefBase { struct ItemReference : public Box, public RefBase {
ItemReference(const sp<DataSource> source, uint32_t type, uint32_t itemIdSize) : ItemReference(DataSourceBase *source, uint32_t type, uint32_t itemIdSize) :
Box(source, type), mItemId(0), mRefIdSize(itemIdSize) {} Box(source, type), mItemId(0), mRefIdSize(itemIdSize) {}
status_t parse(off64_t offset, size_t size); status_t parse(off64_t offset, size_t size);
@ -575,7 +575,7 @@ status_t ItemReference::parse(off64_t offset, size_t size) {
} }
struct IrefBox : public FullBox { struct IrefBox : public FullBox {
IrefBox(const sp<DataSource> source, Vector<sp<ItemReference> > *itemRefs) : IrefBox(DataSourceBase *source, Vector<sp<ItemReference> > *itemRefs) :
FullBox(source, FOURCC('i', 'r', 'e', 'f')), mRefIdSize(0), mItemRefs(itemRefs) {} FullBox(source, FOURCC('i', 'r', 'e', 'f')), mRefIdSize(0), mItemRefs(itemRefs) {}
status_t parse(off64_t offset, size_t size); status_t parse(off64_t offset, size_t size);
@ -637,7 +637,7 @@ private:
}; };
struct IspeBox : public FullBox, public ItemProperty { struct IspeBox : public FullBox, public ItemProperty {
IspeBox(const sp<DataSource> source) : IspeBox(DataSourceBase *source) :
FullBox(source, FOURCC('i', 's', 'p', 'e')), mWidth(0), mHeight(0) {} FullBox(source, FOURCC('i', 's', 'p', 'e')), mWidth(0), mHeight(0) {}
status_t parse(off64_t offset, size_t size) override; status_t parse(off64_t offset, size_t size) override;
@ -673,7 +673,7 @@ status_t IspeBox::parse(off64_t offset, size_t size) {
} }
struct HvccBox : public Box, public ItemProperty { struct HvccBox : public Box, public ItemProperty {
HvccBox(const sp<DataSource> source) : HvccBox(DataSourceBase *source) :
Box(source, FOURCC('h', 'v', 'c', 'C')) {} Box(source, FOURCC('h', 'v', 'c', 'C')) {}
status_t parse(off64_t offset, size_t size) override; status_t parse(off64_t offset, size_t size) override;
@ -706,7 +706,7 @@ status_t HvccBox::parse(off64_t offset, size_t size) {
} }
struct IrotBox : public Box, public ItemProperty { struct IrotBox : public Box, public ItemProperty {
IrotBox(const sp<DataSource> source) : IrotBox(DataSourceBase *source) :
Box(source, FOURCC('i', 'r', 'o', 't')), mAngle(0) {} Box(source, FOURCC('i', 'r', 'o', 't')), mAngle(0) {}
status_t parse(off64_t offset, size_t size) override; status_t parse(off64_t offset, size_t size) override;
@ -735,7 +735,7 @@ status_t IrotBox::parse(off64_t offset, size_t size) {
} }
struct ColrBox : public Box, public ItemProperty { struct ColrBox : public Box, public ItemProperty {
ColrBox(const sp<DataSource> source) : ColrBox(DataSourceBase *source) :
Box(source, FOURCC('c', 'o', 'l', 'r')) {} Box(source, FOURCC('c', 'o', 'l', 'r')) {}
status_t parse(off64_t offset, size_t size) override; status_t parse(off64_t offset, size_t size) override;
@ -783,7 +783,7 @@ status_t ColrBox::parse(off64_t offset, size_t size) {
} }
struct IpmaBox : public FullBox { struct IpmaBox : public FullBox {
IpmaBox(const sp<DataSource> source, Vector<AssociationEntry> *associations) : IpmaBox(DataSourceBase *source, Vector<AssociationEntry> *associations) :
FullBox(source, FOURCC('i', 'p', 'm', 'a')), mAssociations(associations) {} FullBox(source, FOURCC('i', 'p', 'm', 'a')), mAssociations(associations) {}
status_t parse(off64_t offset, size_t size); status_t parse(off64_t offset, size_t size);
@ -857,7 +857,7 @@ status_t IpmaBox::parse(off64_t offset, size_t size) {
} }
struct IpcoBox : public Box { struct IpcoBox : public Box {
IpcoBox(const sp<DataSource> source, Vector<sp<ItemProperty> > *properties) : IpcoBox(DataSourceBase *source, Vector<sp<ItemProperty> > *properties) :
Box(source, FOURCC('i', 'p', 'c', 'o')), mItemProperties(properties) {} Box(source, FOURCC('i', 'p', 'c', 'o')), mItemProperties(properties) {}
status_t parse(off64_t offset, size_t size); status_t parse(off64_t offset, size_t size);
@ -914,7 +914,7 @@ status_t IpcoBox::onChunkData(uint32_t type, off64_t offset, size_t size) {
} }
struct IprpBox : public Box { struct IprpBox : public Box {
IprpBox(const sp<DataSource> source, IprpBox(DataSourceBase *source,
Vector<sp<ItemProperty> > *properties, Vector<sp<ItemProperty> > *properties,
Vector<AssociationEntry> *associations) : Vector<AssociationEntry> *associations) :
Box(source, FOURCC('i', 'p', 'r', 'p')), Box(source, FOURCC('i', 'p', 'r', 'p')),
@ -971,7 +971,7 @@ struct ItemInfo {
}; };
struct InfeBox : public FullBox { struct InfeBox : public FullBox {
InfeBox(const sp<DataSource> source) : InfeBox(DataSourceBase *source) :
FullBox(source, FOURCC('i', 'n', 'f', 'e')) {} FullBox(source, FOURCC('i', 'n', 'f', 'e')) {}
status_t parse(off64_t offset, size_t size, ItemInfo *itemInfo); status_t parse(off64_t offset, size_t size, ItemInfo *itemInfo);
@ -1075,7 +1075,7 @@ status_t InfeBox::parse(off64_t offset, size_t size, ItemInfo *itemInfo) {
} }
struct IinfBox : public FullBox { struct IinfBox : public FullBox {
IinfBox(const sp<DataSource> source, Vector<ItemInfo> *itemInfos) : IinfBox(DataSourceBase *source, Vector<ItemInfo> *itemInfos) :
FullBox(source, FOURCC('i', 'i', 'n', 'f')), FullBox(source, FOURCC('i', 'i', 'n', 'f')),
mItemInfos(itemInfos), mHasGrids(false) {} mItemInfos(itemInfos), mHasGrids(false) {}
@ -1144,7 +1144,7 @@ status_t IinfBox::onChunkData(uint32_t type, off64_t offset, size_t size) {
////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////
ItemTable::ItemTable(const sp<DataSource> &source) ItemTable::ItemTable(DataSourceBase *source)
: mDataSource(source), : mDataSource(source),
mPrimaryItemId(0), mPrimaryItemId(0),
mIdatOffset(0), mIdatOffset(0),

@ -25,7 +25,7 @@
namespace android { namespace android {
class DataSource; class DataSourceBase;
class MetaData; class MetaData;
namespace heif { namespace heif {
@ -44,7 +44,7 @@ struct ItemReference;
class ItemTable : public RefBase { class ItemTable : public RefBase {
public: public:
explicit ItemTable(const sp<DataSource> &source); explicit ItemTable(DataSourceBase *source);
status_t parse(uint32_t type, off64_t offset, size_t size); status_t parse(uint32_t type, off64_t offset, size_t size);
@ -60,7 +60,7 @@ protected:
~ItemTable(); ~ItemTable();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
KeyedVector<uint32_t, ItemLoc> mItemLocs; KeyedVector<uint32_t, ItemLoc> mItemLocs;
Vector<ItemInfo> mItemInfos; Vector<ItemInfo> mItemInfos;

@ -69,7 +69,7 @@ class MPEG4Source : public MediaSourceBase {
public: public:
// Caller retains ownership of both "dataSource" and "sampleTable". // Caller retains ownership of both "dataSource" and "sampleTable".
MPEG4Source(const sp<MetaData> &format, MPEG4Source(const sp<MetaData> &format,
const sp<DataSource> &dataSource, DataSourceBase *dataSource,
int32_t timeScale, int32_t timeScale,
const sp<SampleTable> &sampleTable, const sp<SampleTable> &sampleTable,
Vector<SidxEntry> &sidx, Vector<SidxEntry> &sidx,
@ -93,7 +93,7 @@ private:
Mutex mLock; Mutex mLock;
sp<MetaData> mFormat; sp<MetaData> mFormat;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
int32_t mTimescale; int32_t mTimescale;
sp<SampleTable> mSampleTable; sp<SampleTable> mSampleTable;
uint32_t mCurrentSampleIndex; uint32_t mCurrentSampleIndex;
@ -186,47 +186,51 @@ private:
// all remaining requests to the wrapped datasource. // all remaining requests to the wrapped datasource.
// This is used to cache the full sampletable metadata for a single track, // This is used to cache the full sampletable metadata for a single track,
// possibly wrapping multiple times to cover all tracks, i.e. // possibly wrapping multiple times to cover all tracks, i.e.
// Each MPEG4DataSource caches the sampletable metadata for a single track. // Each CachedRangedDataSource caches the sampletable metadata for a single track.
struct MPEG4DataSource : public DataSource { struct CachedRangedDataSource : public DataSourceBase {
explicit MPEG4DataSource(const sp<DataSource> &source); explicit CachedRangedDataSource(DataSourceBase *source);
virtual ~CachedRangedDataSource();
virtual status_t initCheck() const; virtual status_t initCheck() const;
virtual ssize_t readAt(off64_t offset, void *data, size_t size); virtual ssize_t readAt(off64_t offset, void *data, size_t size);
virtual status_t getSize(off64_t *size); virtual status_t getSize(off64_t *size);
virtual uint32_t flags(); virtual uint32_t flags();
status_t setCachedRange(off64_t offset, size_t size); status_t setCachedRange(off64_t offset, size_t size, bool assumeSourceOwnershipOnSuccess);
protected:
virtual ~MPEG4DataSource();
private: private:
Mutex mLock; Mutex mLock;
sp<DataSource> mSource; DataSourceBase *mSource;
bool mOwnsDataSource;
off64_t mCachedOffset; off64_t mCachedOffset;
size_t mCachedSize; size_t mCachedSize;
uint8_t *mCache; uint8_t *mCache;
void clearCache(); void clearCache();
MPEG4DataSource(const MPEG4DataSource &); CachedRangedDataSource(const CachedRangedDataSource &);
MPEG4DataSource &operator=(const MPEG4DataSource &); CachedRangedDataSource &operator=(const CachedRangedDataSource &);
}; };
MPEG4DataSource::MPEG4DataSource(const sp<DataSource> &source) CachedRangedDataSource::CachedRangedDataSource(DataSourceBase *source)
: mSource(source), : mSource(source),
mOwnsDataSource(false),
mCachedOffset(0), mCachedOffset(0),
mCachedSize(0), mCachedSize(0),
mCache(NULL) { mCache(NULL) {
} }
MPEG4DataSource::~MPEG4DataSource() { CachedRangedDataSource::~CachedRangedDataSource() {
clearCache(); clearCache();
if (mOwnsDataSource) {
delete (CachedRangedDataSource*)mSource;
}
} }
void MPEG4DataSource::clearCache() { void CachedRangedDataSource::clearCache() {
if (mCache) { if (mCache) {
free(mCache); free(mCache);
mCache = NULL; mCache = NULL;
@ -236,11 +240,11 @@ void MPEG4DataSource::clearCache() {
mCachedSize = 0; mCachedSize = 0;
} }
status_t MPEG4DataSource::initCheck() const { status_t CachedRangedDataSource::initCheck() const {
return mSource->initCheck(); return mSource->initCheck();
} }
ssize_t MPEG4DataSource::readAt(off64_t offset, void *data, size_t size) { ssize_t CachedRangedDataSource::readAt(off64_t offset, void *data, size_t size) {
Mutex::Autolock autoLock(mLock); Mutex::Autolock autoLock(mLock);
if (isInRange(mCachedOffset, mCachedSize, offset, size)) { if (isInRange(mCachedOffset, mCachedSize, offset, size)) {
@ -251,15 +255,17 @@ ssize_t MPEG4DataSource::readAt(off64_t offset, void *data, size_t size) {
return mSource->readAt(offset, data, size); return mSource->readAt(offset, data, size);
} }
status_t MPEG4DataSource::getSize(off64_t *size) { status_t CachedRangedDataSource::getSize(off64_t *size) {
return mSource->getSize(size); return mSource->getSize(size);
} }
uint32_t MPEG4DataSource::flags() { uint32_t CachedRangedDataSource::flags() {
return mSource->flags(); return mSource->flags();
} }
status_t MPEG4DataSource::setCachedRange(off64_t offset, size_t size) { status_t CachedRangedDataSource::setCachedRange(off64_t offset,
size_t size,
bool assumeSourceOwnershipOnSuccess) {
Mutex::Autolock autoLock(mLock); Mutex::Autolock autoLock(mLock);
clearCache(); clearCache();
@ -280,7 +286,7 @@ status_t MPEG4DataSource::setCachedRange(off64_t offset, size_t size) {
return ERROR_IO; return ERROR_IO;
} }
mOwnsDataSource = assumeSourceOwnershipOnSuccess;
return OK; return OK;
} }
@ -334,11 +340,12 @@ static bool AdjustChannelsAndRate(uint32_t fourcc, uint32_t *channels, uint32_t
return false; return false;
} }
MPEG4Extractor::MPEG4Extractor(const sp<DataSource> &source, const char *mime) MPEG4Extractor::MPEG4Extractor(DataSourceBase *source, const char *mime)
: mMoofOffset(0), : mMoofOffset(0),
mMoofFound(false), mMoofFound(false),
mMdatFound(false), mMdatFound(false),
mDataSource(source), mDataSource(source),
mCachedSource(NULL),
mInitCheck(NO_INIT), mInitCheck(NO_INIT),
mHeaderTimescale(0), mHeaderTimescale(0),
mIsQT(false), mIsQT(false),
@ -354,10 +361,6 @@ MPEG4Extractor::MPEG4Extractor(const sp<DataSource> &source, const char *mime)
} }
MPEG4Extractor::~MPEG4Extractor() { MPEG4Extractor::~MPEG4Extractor() {
release();
}
void MPEG4Extractor::release() {
Track *track = mFirstTrack; Track *track = mFirstTrack;
while (track) { while (track) {
Track *next = track->next; Track *next = track->next;
@ -381,10 +384,7 @@ void MPEG4Extractor::release() {
} }
mPssh.clear(); mPssh.clear();
if (mDataSource != NULL) { delete mCachedSource;
mDataSource->close();
mDataSource.clear();
}
} }
uint32_t MPEG4Extractor::flags() const { uint32_t MPEG4Extractor::flags() const {
@ -692,14 +692,14 @@ char* MPEG4Extractor::getDrmTrackInfo(size_t trackID, int *len) {
// Reads an encoded integer 7 bits at a time until it encounters the high bit clear. // Reads an encoded integer 7 bits at a time until it encounters the high bit clear.
static int32_t readSize(off64_t offset, static int32_t readSize(off64_t offset,
const sp<DataSource> &DataSource, uint8_t *numOfBytes) { DataSourceBase *DataSourceBase, uint8_t *numOfBytes) {
uint32_t size = 0; uint32_t size = 0;
uint8_t data; uint8_t data;
bool moreData = true; bool moreData = true;
*numOfBytes = 0; *numOfBytes = 0;
while (moreData) { while (moreData) {
if (DataSource->readAt(offset, &data, 1) < 1) { if (DataSourceBase->readAt(offset, &data, 1) < 1) {
return -1; return -1;
} }
offset ++; offset ++;
@ -1045,13 +1045,17 @@ status_t MPEG4Extractor::parseChunk(off64_t *offset, int depth) {
ALOGV("sampleTable chunk is %" PRIu64 " bytes long.", chunk_size); ALOGV("sampleTable chunk is %" PRIu64 " bytes long.", chunk_size);
if (mDataSource->flags() if (mDataSource->flags()
& (DataSource::kWantsPrefetching & (DataSourceBase::kWantsPrefetching
| DataSource::kIsCachingDataSource)) { | DataSourceBase::kIsCachingDataSource)) {
sp<MPEG4DataSource> cachedSource = CachedRangedDataSource *cachedSource =
new MPEG4DataSource(mDataSource); new CachedRangedDataSource(mDataSource);
if (cachedSource->setCachedRange(*offset, chunk_size) == OK) { if (cachedSource->setCachedRange(
mDataSource = cachedSource; *offset, chunk_size,
mCachedSource != NULL /* assume ownership on success */) == OK) {
mDataSource = mCachedSource = cachedSource;
} else {
delete cachedSource;
} }
} }
@ -3890,7 +3894,7 @@ status_t MPEG4Extractor::updateAudioTrackInfoFromESDS_MPEG4Audio(
MPEG4Source::MPEG4Source( MPEG4Source::MPEG4Source(
const sp<MetaData> &format, const sp<MetaData> &format,
const sp<DataSource> &dataSource, DataSourceBase *dataSource,
int32_t timeScale, int32_t timeScale,
const sp<SampleTable> &sampleTable, const sp<SampleTable> &sampleTable,
Vector<SidxEntry> &sidx, Vector<SidxEntry> &sidx,
@ -5379,7 +5383,7 @@ MPEG4Extractor::Track *MPEG4Extractor::findTrackByMimePrefix(
} }
static bool LegacySniffMPEG4( static bool LegacySniffMPEG4(
const sp<DataSource> &source, String8 *mimeType, float *confidence) { DataSourceBase *source, String8 *mimeType, float *confidence) {
uint8_t header[8]; uint8_t header[8];
ssize_t n = source->readAt(4, header, sizeof(header)); ssize_t n = source->readAt(4, header, sizeof(header));
@ -5446,7 +5450,7 @@ static bool isCompatibleBrand(uint32_t fourcc) {
// (end of the 'moov' atom) and report it to the caller as part of // (end of the 'moov' atom) and report it to the caller as part of
// the metadata. // the metadata.
static bool BetterSniffMPEG4( static bool BetterSniffMPEG4(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *meta) { sp<AMessage> *meta) {
// We scan up to 128 bytes to identify this file as an MP4. // We scan up to 128 bytes to identify this file as an MP4.
static const off64_t kMaxScanOffset = 128ll; static const off64_t kMaxScanOffset = 128ll;
@ -5563,13 +5567,13 @@ static bool BetterSniffMPEG4(
} }
static MediaExtractor* CreateExtractor( static MediaExtractor* CreateExtractor(
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) { const sp<AMessage>& meta __unused) {
return new MPEG4Extractor(source); return new MPEG4Extractor(source);
} }
static MediaExtractor::CreatorFunc Sniff( static MediaExtractor::CreatorFunc Sniff(
const sp<DataSource> &source, DataSourceBase *source,
String8 *mimeType, String8 *mimeType,
float *confidence, float *confidence,
sp<AMessage> *meta) { sp<AMessage> *meta) {

@ -20,7 +20,7 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaExtractor.h> #include <media/MediaExtractor.h>
#include <media/stagefright/foundation/AString.h> #include <media/stagefright/foundation/AString.h>
#include <utils/List.h> #include <utils/List.h>
@ -29,7 +29,8 @@
namespace android { namespace android {
struct AMessage; struct AMessage;
class DataSource; class DataSourceBase;
struct CachedRangedDataSource;
class SampleTable; class SampleTable;
class String8; class String8;
namespace heif { namespace heif {
@ -52,8 +53,7 @@ struct Trex {
class MPEG4Extractor : public MediaExtractor { class MPEG4Extractor : public MediaExtractor {
public: public:
// Extractor assumes ownership of "source". explicit MPEG4Extractor(DataSourceBase *source, const char *mime = NULL);
explicit MPEG4Extractor(const sp<DataSource> &source, const char *mime = NULL);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -62,7 +62,6 @@ public:
virtual sp<MetaData> getMetaData(); virtual sp<MetaData> getMetaData();
virtual uint32_t flags() const; virtual uint32_t flags() const;
virtual const char * name() { return "MPEG4Extractor"; } virtual const char * name() { return "MPEG4Extractor"; }
virtual void release();
// for DRM // for DRM
virtual char* getDrmTrackInfo(size_t trackID, int *len); virtual char* getDrmTrackInfo(size_t trackID, int *len);
@ -98,7 +97,8 @@ private:
Vector<Trex> mTrex; Vector<Trex> mTrex;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
CachedRangedDataSource *mCachedSource;
status_t mInitCheck; status_t mInitCheck;
uint32_t mHeaderTimescale; uint32_t mHeaderTimescale;
bool mIsQT; bool mIsQT;
@ -160,7 +160,7 @@ private:
}; };
bool SniffMPEG4( bool SniffMPEG4(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *); sp<AMessage> *);
} // namespace android } // namespace android

@ -22,7 +22,7 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/ByteUtils.h> #include <media/stagefright/foundation/ByteUtils.h>

@ -25,7 +25,7 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/ByteUtils.h> #include <media/stagefright/foundation/ByteUtils.h>
@ -114,7 +114,7 @@ int32_t SampleTable::CompositionDeltaLookup::getCompositionTimeOffset(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
SampleTable::SampleTable(const sp<DataSource> &source) SampleTable::SampleTable(DataSourceBase *source)
: mDataSource(source), : mDataSource(source),
mChunkOffsetOffset(-1), mChunkOffsetOffset(-1),
mChunkOffsetType(0), mChunkOffsetType(0),

@ -27,12 +27,12 @@
namespace android { namespace android {
class DataSource; class DataSourceBase;
struct SampleIterator; struct SampleIterator;
class SampleTable : public RefBase { class SampleTable : public RefBase {
public: public:
explicit SampleTable(const sp<DataSource> &source); explicit SampleTable(DataSourceBase *source);
bool isValid() const; bool isValid() const;
@ -99,7 +99,7 @@ private:
// Limit the total size of all internal tables to 200MiB. // Limit the total size of all internal tables to 200MiB.
static const size_t kMaxTotalSize = 200 * (1 << 20); static const size_t kMaxTotalSize = 200 * (1 << 20);
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
Mutex mLock; Mutex mLock;
off64_t mChunkOffsetOffset; off64_t mChunkOffsetOffset;

@ -34,18 +34,18 @@ MediaExtractor::ExtractorDef GETEXTRACTORDEF() {
1, 1,
"MPEG2-PS/TS Extractor", "MPEG2-PS/TS Extractor",
[]( [](
const sp<DataSource> &source, DataSourceBase *source,
String8 *mimeType, String8 *mimeType,
float *confidence, float *confidence,
sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc { sp<AMessage> *meta __unused) -> MediaExtractor::CreatorFunc {
if (SniffMPEG2TS(source, mimeType, confidence, meta)) { if (SniffMPEG2TS(source, mimeType, confidence, meta)) {
return []( return [](
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) -> MediaExtractor* { const sp<AMessage>& meta __unused) -> MediaExtractor* {
return new MPEG2TSExtractor(source);}; return new MPEG2TSExtractor(source);};
} else if (SniffMPEG2PS(source, mimeType, confidence, meta)) { } else if (SniffMPEG2PS(source, mimeType, confidence, meta)) {
return []( return [](
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) -> MediaExtractor* { const sp<AMessage>& meta __unused) -> MediaExtractor* {
return new MPEG2PSExtractor(source);}; return new MPEG2PSExtractor(source);};
} }

@ -23,7 +23,7 @@
#include "mpeg2ts/AnotherPacketSource.h" #include "mpeg2ts/AnotherPacketSource.h"
#include "mpeg2ts/ESQueue.h" #include "mpeg2ts/ESQueue.h"
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABitReader.h> #include <media/stagefright/foundation/ABitReader.h>
#include <media/stagefright/foundation/ABuffer.h> #include <media/stagefright/foundation/ABuffer.h>
@ -94,7 +94,7 @@ private:
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
MPEG2PSExtractor::MPEG2PSExtractor(const sp<DataSource> &source) MPEG2PSExtractor::MPEG2PSExtractor(DataSourceBase *source)
: mDataSource(source), : mDataSource(source),
mOffset(0), mOffset(0),
mFinalResult(OK), mFinalResult(OK),
@ -751,7 +751,7 @@ status_t MPEG2PSExtractor::WrappedTrack::read(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
bool SniffMPEG2PS( bool SniffMPEG2PS(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *) { sp<AMessage> *) {
uint8_t header[5]; uint8_t header[5];
if (source->readAt(0, header, sizeof(header)) < (ssize_t)sizeof(header)) { if (source->readAt(0, header, sizeof(header)) < (ssize_t)sizeof(header)) {

@ -31,7 +31,7 @@ struct Track;
class String8; class String8;
struct MPEG2PSExtractor : public MediaExtractor { struct MPEG2PSExtractor : public MediaExtractor {
explicit MPEG2PSExtractor(const sp<DataSource> &source); explicit MPEG2PSExtractor(DataSourceBase *source);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -50,7 +50,7 @@ private:
struct WrappedTrack; struct WrappedTrack;
mutable Mutex mLock; mutable Mutex mLock;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
off64_t mOffset; off64_t mOffset;
status_t mFinalResult; status_t mFinalResult;
@ -72,7 +72,7 @@ private:
}; };
bool SniffMPEG2PS( bool SniffMPEG2PS(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *); sp<AMessage> *);
} // namespace android } // namespace android

@ -22,7 +22,7 @@
#include "MPEG2TSExtractor.h" #include "MPEG2TSExtractor.h"
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/IStreamSource.h> #include <media/IStreamSource.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABuffer.h> #include <media/stagefright/foundation/ABuffer.h>
@ -121,7 +121,7 @@ status_t MPEG2TSSource::read(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
MPEG2TSExtractor::MPEG2TSExtractor(const sp<DataSource> &source) MPEG2TSExtractor::MPEG2TSExtractor(DataSourceBase *source)
: mDataSource(source), : mDataSource(source),
mParser(new ATSParser), mParser(new ATSParser),
mLastSyncEvent(0), mLastSyncEvent(0),
@ -367,7 +367,7 @@ void MPEG2TSExtractor::addSyncPoint_l(const ATSParser::SyncEvent &event) {
} }
status_t MPEG2TSExtractor::estimateDurationsFromTimesUsAtEnd() { status_t MPEG2TSExtractor::estimateDurationsFromTimesUsAtEnd() {
if (!(mDataSource->flags() & DataSource::kIsLocalFileSource)) { if (!(mDataSource->flags() & DataSourceBase::kIsLocalFileSource)) {
return ERROR_UNSUPPORTED; return ERROR_UNSUPPORTED;
} }
@ -646,7 +646,7 @@ status_t MPEG2TSExtractor::feedUntilBufferAvailable(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
bool SniffMPEG2TS( bool SniffMPEG2TS(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *) { sp<AMessage> *) {
for (int i = 0; i < 5; ++i) { for (int i = 0; i < 5; ++i) {
char header; char header;

@ -32,12 +32,12 @@ namespace android {
struct AMessage; struct AMessage;
struct AnotherPacketSource; struct AnotherPacketSource;
struct ATSParser; struct ATSParser;
class DataSource; class DataSourceBase;
struct MPEG2TSSource; struct MPEG2TSSource;
class String8; class String8;
struct MPEG2TSExtractor : public MediaExtractor { struct MPEG2TSExtractor : public MediaExtractor {
explicit MPEG2TSExtractor(const sp<DataSource> &source); explicit MPEG2TSExtractor(DataSourceBase *source);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -55,7 +55,7 @@ private:
mutable Mutex mLock; mutable Mutex mLock;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<ATSParser> mParser; sp<ATSParser> mParser;
@ -79,9 +79,9 @@ private:
// Try to feed more data from source to parser. // Try to feed more data from source to parser.
// |isInit| means this function is called inside init(). This is a signal to // |isInit| means this function is called inside init(). This is a signal to
// save SyncEvent so that init() can add SyncPoint after it updates |mSourceImpls|. // save SyncEvent so that init() can add SyncPoint after it updates |mSourceImpls|.
// This function returns OK if expected amount of data is fed from DataSource to // This function returns OK if expected amount of data is fed from DataSourceBase to
// parser and is successfully parsed. Otherwise, various error codes could be // parser and is successfully parsed. Otherwise, various error codes could be
// returned, e.g., ERROR_END_OF_STREAM, or no data availalbe from DataSource, or // returned, e.g., ERROR_END_OF_STREAM, or no data availalbe from DataSourceBase, or
// the data has syntax error during parsing, etc. // the data has syntax error during parsing, etc.
status_t feedMore(bool isInit = false); status_t feedMore(bool isInit = false);
status_t seek(int64_t seekTimeUs, status_t seek(int64_t seekTimeUs,
@ -100,7 +100,7 @@ private:
}; };
bool SniffMPEG2TS( bool SniffMPEG2TS(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *); sp<AMessage> *);
} // namespace android } // namespace android

@ -21,7 +21,7 @@
#include "OggExtractor.h" #include "OggExtractor.h"
#include <cutils/properties.h> #include <cutils/properties.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABuffer.h> #include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
@ -69,7 +69,7 @@ private:
struct MyOggExtractor { struct MyOggExtractor {
MyOggExtractor( MyOggExtractor(
const sp<DataSource> &source, DataSourceBase *source,
const char *mimeType, const char *mimeType,
size_t numHeaders, size_t numHeaders,
int64_t seekPreRollUs); int64_t seekPreRollUs);
@ -105,7 +105,7 @@ protected:
int64_t mTimeUs; int64_t mTimeUs;
}; };
sp<DataSource> mSource; DataSourceBase *mSource;
off64_t mOffset; off64_t mOffset;
Page mCurrentPage; Page mCurrentPage;
uint64_t mCurGranulePosition; uint64_t mCurGranulePosition;
@ -164,7 +164,7 @@ protected:
}; };
struct MyVorbisExtractor : public MyOggExtractor { struct MyVorbisExtractor : public MyOggExtractor {
explicit MyVorbisExtractor(const sp<DataSource> &source) explicit MyVorbisExtractor(DataSourceBase *source)
: MyOggExtractor(source, : MyOggExtractor(source,
MEDIA_MIMETYPE_AUDIO_VORBIS, MEDIA_MIMETYPE_AUDIO_VORBIS,
/* numHeaders */ 3, /* numHeaders */ 3,
@ -192,7 +192,7 @@ struct MyOpusExtractor : public MyOggExtractor {
static const int32_t kOpusSampleRate = 48000; static const int32_t kOpusSampleRate = 48000;
static const int64_t kOpusSeekPreRollUs = 80000; // 80 ms static const int64_t kOpusSeekPreRollUs = 80000; // 80 ms
explicit MyOpusExtractor(const sp<DataSource> &source) explicit MyOpusExtractor(DataSourceBase *source)
: MyOggExtractor(source, MEDIA_MIMETYPE_AUDIO_OPUS, /*numHeaders*/ 2, kOpusSeekPreRollUs), : MyOggExtractor(source, MEDIA_MIMETYPE_AUDIO_OPUS, /*numHeaders*/ 2, kOpusSeekPreRollUs),
mChannelCount(0), mChannelCount(0),
mCodecDelay(0), mCodecDelay(0),
@ -294,7 +294,7 @@ status_t OggSource::read(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
MyOggExtractor::MyOggExtractor( MyOggExtractor::MyOggExtractor(
const sp<DataSource> &source, DataSourceBase *source,
const char *mimeType, const char *mimeType,
size_t numHeaders, size_t numHeaders,
int64_t seekPreRollUs) int64_t seekPreRollUs)
@ -852,7 +852,7 @@ status_t MyOggExtractor::init() {
off64_t size; off64_t size;
uint64_t lastGranulePosition; uint64_t lastGranulePosition;
if (!(mSource->flags() & DataSource::kIsCachingDataSource) if (!(mSource->flags() & DataSourceBase::kIsCachingDataSource)
&& mSource->getSize(&size) == OK && mSource->getSize(&size) == OK
&& findPrevGranulePosition(size, &lastGranulePosition) == OK) { && findPrevGranulePosition(size, &lastGranulePosition) == OK) {
// Let's assume it's cheap to seek to the end. // Let's assume it's cheap to seek to the end.
@ -1315,7 +1315,7 @@ void MyOggExtractor::parseFileMetaData() {
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
OggExtractor::OggExtractor(const sp<DataSource> &source) OggExtractor::OggExtractor(DataSourceBase *source)
: mDataSource(source), : mDataSource(source),
mInitCheck(NO_INIT), mInitCheck(NO_INIT),
mImpl(NULL) { mImpl(NULL) {
@ -1370,13 +1370,13 @@ sp<MetaData> OggExtractor::getMetaData() {
} }
static MediaExtractor* CreateExtractor( static MediaExtractor* CreateExtractor(
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) { const sp<AMessage>& meta __unused) {
return new OggExtractor(source); return new OggExtractor(source);
} }
static MediaExtractor::CreatorFunc Sniff( static MediaExtractor::CreatorFunc Sniff(
const sp<DataSource> &source, DataSourceBase *source,
String8 *mimeType, String8 *mimeType,
float *confidence, float *confidence,
sp<AMessage> *) { sp<AMessage> *) {

@ -24,14 +24,14 @@
namespace android { namespace android {
struct AMessage; struct AMessage;
class DataSource; class DataSourceBase;
class String8; class String8;
struct MyOggExtractor; struct MyOggExtractor;
struct OggSource; struct OggSource;
struct OggExtractor : public MediaExtractor { struct OggExtractor : public MediaExtractor {
explicit OggExtractor(const sp<DataSource> &source); explicit OggExtractor(DataSourceBase *source);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -46,7 +46,7 @@ protected:
private: private:
friend struct OggSource; friend struct OggSource;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
status_t mInitCheck; status_t mInitCheck;
MyOggExtractor *mImpl; MyOggExtractor *mImpl;
@ -56,7 +56,7 @@ private:
}; };
bool SniffOgg( bool SniffOgg(
const sp<DataSource> &source, String8 *mimeType, float *confidence, DataSourceBase *source, String8 *mimeType, float *confidence,
sp<AMessage> *); sp<AMessage> *);
} // namespace android } // namespace android

@ -21,7 +21,7 @@
#include "WAVExtractor.h" #include "WAVExtractor.h"
#include <audio_utils/primitives.h> #include <audio_utils/primitives.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/MediaSourceBase.h> #include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaBufferGroup.h> #include <media/stagefright/MediaBufferGroup.h>
@ -57,7 +57,7 @@ static uint16_t U16_LE_AT(const uint8_t *ptr) {
struct WAVSource : public MediaSourceBase { struct WAVSource : public MediaSourceBase {
WAVSource( WAVSource(
const sp<DataSource> &dataSource, DataSourceBase *dataSource,
const sp<MetaData> &meta, const sp<MetaData> &meta,
uint16_t waveFormat, uint16_t waveFormat,
int32_t bitsPerSample, int32_t bitsPerSample,
@ -78,7 +78,7 @@ protected:
private: private:
static const size_t kMaxFrameSize; static const size_t kMaxFrameSize;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
sp<MetaData> mMeta; sp<MetaData> mMeta;
uint16_t mWaveFormat; uint16_t mWaveFormat;
int32_t mSampleRate; int32_t mSampleRate;
@ -94,7 +94,7 @@ private:
WAVSource &operator=(const WAVSource &); WAVSource &operator=(const WAVSource &);
}; };
WAVExtractor::WAVExtractor(const sp<DataSource> &source) WAVExtractor::WAVExtractor(DataSourceBase *source)
: mDataSource(source), : mDataSource(source),
mValidFormat(false), mValidFormat(false),
mChannelMask(CHANNEL_MASK_USE_CHANNEL_ORDER) { mChannelMask(CHANNEL_MASK_USE_CHANNEL_ORDER) {
@ -348,7 +348,7 @@ status_t WAVExtractor::init() {
const size_t WAVSource::kMaxFrameSize = 32768; const size_t WAVSource::kMaxFrameSize = 32768;
WAVSource::WAVSource( WAVSource::WAVSource(
const sp<DataSource> &dataSource, DataSourceBase *dataSource,
const sp<MetaData> &meta, const sp<MetaData> &meta,
uint16_t waveFormat, uint16_t waveFormat,
int32_t bitsPerSample, int32_t bitsPerSample,
@ -545,13 +545,13 @@ status_t WAVSource::read(
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
static MediaExtractor* CreateExtractor( static MediaExtractor* CreateExtractor(
const sp<DataSource> &source, DataSourceBase *source,
const sp<AMessage>& meta __unused) { const sp<AMessage>& meta __unused) {
return new WAVExtractor(source); return new WAVExtractor(source);
} }
static MediaExtractor::CreatorFunc Sniff( static MediaExtractor::CreatorFunc Sniff(
const sp<DataSource> &source, DataSourceBase *source,
String8 *mimeType, String8 *mimeType,
float *confidence, float *confidence,
sp<AMessage> *) { sp<AMessage> *) {

@ -24,13 +24,12 @@
namespace android { namespace android {
struct AMessage; struct AMessage;
class DataSource; class DataSourceBase;
class String8; class String8;
class WAVExtractor : public MediaExtractor { class WAVExtractor : public MediaExtractor {
public: public:
// Extractor assumes ownership of "source". explicit WAVExtractor(DataSourceBase *source);
explicit WAVExtractor(const sp<DataSource> &source);
virtual size_t countTracks(); virtual size_t countTracks();
virtual MediaSourceBase *getTrack(size_t index); virtual MediaSourceBase *getTrack(size_t index);
@ -42,7 +41,7 @@ public:
virtual ~WAVExtractor(); virtual ~WAVExtractor();
private: private:
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
status_t mInitCheck; status_t mInitCheck;
bool mValidFormat; bool mValidFormat;
uint16_t mWaveFormat; uint16_t mWaveFormat;

@ -39,8 +39,7 @@ enum {
SETMEDIACAS, SETMEDIACAS,
SETUID, SETUID,
NAME, NAME,
GETMETRICS, GETMETRICS
RELEASE,
}; };
class BpMediaExtractor : public BpInterface<IMediaExtractor> { class BpMediaExtractor : public BpInterface<IMediaExtractor> {
@ -140,13 +139,6 @@ public:
ALOGV("name NOT IMPLEMENTED"); ALOGV("name NOT IMPLEMENTED");
return NULL; return NULL;
} }
virtual void release() {
ALOGV("release");
Parcel data, reply;
data.writeInterfaceToken(BpMediaExtractor::getInterfaceDescriptor());
remote()->transact(RELEASE, data, &reply);
}
}; };
IMPLEMENT_META_INTERFACE(MediaExtractor, "android.media.IMediaExtractor"); IMPLEMENT_META_INTERFACE(MediaExtractor, "android.media.IMediaExtractor");
@ -224,12 +216,6 @@ status_t BnMediaExtractor::onTransact(
reply->writeInt32(setMediaCas(casToken)); reply->writeInt32(setMediaCas(casToken));
return OK; return OK;
} }
case RELEASE: {
ALOGV("release");
CHECK_INTERFACE(IMediaExtractor, data, reply);
release();
return OK;
}
default: default:
return BBinder::onTransact(code, data, reply, flags); return BBinder::onTransact(code, data, reply, flags);
} }

@ -47,7 +47,7 @@ MidiIoWrapper::MidiIoWrapper(int fd, off64_t offset, int64_t size) {
mLength = size; mLength = size;
} }
MidiIoWrapper::MidiIoWrapper(const sp<DataSource> &source) { MidiIoWrapper::MidiIoWrapper(DataSourceBase *source) {
ALOGV("MidiIoWrapper(DataSource)"); ALOGV("MidiIoWrapper(DataSource)");
mFd = -1; mFd = -1;
mDataSource = source; mDataSource = source;

@ -68,8 +68,6 @@ public:
virtual void setUID(uid_t uid) = 0; virtual void setUID(uid_t uid) = 0;
virtual const char * name() = 0; virtual const char * name() = 0;
virtual void release() = 0;
}; };

@ -19,7 +19,7 @@
#include <libsonivox/eas_types.h> #include <libsonivox/eas_types.h>
#include <media/DataSource.h> #include <media/DataSourceBase.h>
namespace android { namespace android {
@ -27,7 +27,7 @@ class MidiIoWrapper : public RefBase {
public: public:
MidiIoWrapper(const char *path); MidiIoWrapper(const char *path);
MidiIoWrapper(int fd, off64_t offset, int64_t size); MidiIoWrapper(int fd, off64_t offset, int64_t size);
MidiIoWrapper(const sp<DataSource> &source); MidiIoWrapper(DataSourceBase *source);
~MidiIoWrapper(); ~MidiIoWrapper();
@ -40,7 +40,7 @@ private:
int mFd; int mFd;
off64_t mBase; off64_t mBase;
int64_t mLength; int64_t mLength;
sp<DataSource> mDataSource; DataSourceBase *mDataSource;
EAS_FILE mEasFile; EAS_FILE mEasFile;
}; };

@ -23,7 +23,7 @@ cc_library {
], ],
srcs: [ srcs: [
"DataSource.cpp", "DataSourceBase.cpp",
"MediaBuffer.cpp", "MediaBuffer.cpp",
"MediaBufferGroup.cpp", "MediaBufferGroup.cpp",
"MediaSourceBase.cpp", "MediaSourceBase.cpp",

@ -14,16 +14,16 @@
* limitations under the License. * limitations under the License.
*/ */
//#define LOG_NDEBUG 0 //#define LOG_NDEBUG 0
#define LOG_TAG "DataSource" #define LOG_TAG "DataSourceBase"
#include <media/DataSource.h> #include <media/DataSourceBase.h>
#include <media/stagefright/foundation/ByteUtils.h> #include <media/stagefright/foundation/ByteUtils.h>
#include <media/stagefright/MediaErrors.h> #include <media/stagefright/MediaErrors.h>
#include <utils/String8.h> #include <utils/String8.h>
namespace android { namespace android {
bool DataSource::getUInt16(off64_t offset, uint16_t *x) { bool DataSourceBase::getUInt16(off64_t offset, uint16_t *x) {
*x = 0; *x = 0;
uint8_t byte[2]; uint8_t byte[2];
@ -36,7 +36,7 @@ bool DataSource::getUInt16(off64_t offset, uint16_t *x) {
return true; return true;
} }
bool DataSource::getUInt24(off64_t offset, uint32_t *x) { bool DataSourceBase::getUInt24(off64_t offset, uint32_t *x) {
*x = 0; *x = 0;
uint8_t byte[3]; uint8_t byte[3];
@ -49,7 +49,7 @@ bool DataSource::getUInt24(off64_t offset, uint32_t *x) {
return true; return true;
} }
bool DataSource::getUInt32(off64_t offset, uint32_t *x) { bool DataSourceBase::getUInt32(off64_t offset, uint32_t *x) {
*x = 0; *x = 0;
uint32_t tmp; uint32_t tmp;
@ -62,7 +62,7 @@ bool DataSource::getUInt32(off64_t offset, uint32_t *x) {
return true; return true;
} }
bool DataSource::getUInt64(off64_t offset, uint64_t *x) { bool DataSourceBase::getUInt64(off64_t offset, uint64_t *x) {
*x = 0; *x = 0;
uint64_t tmp; uint64_t tmp;
@ -75,7 +75,7 @@ bool DataSource::getUInt64(off64_t offset, uint64_t *x) {
return true; return true;
} }
bool DataSource::getUInt16Var(off64_t offset, uint16_t *x, size_t size) { bool DataSourceBase::getUInt16Var(off64_t offset, uint16_t *x, size_t size) {
if (size == 2) { if (size == 2) {
return getUInt16(offset, x); return getUInt16(offset, x);
} }
@ -89,7 +89,7 @@ bool DataSource::getUInt16Var(off64_t offset, uint16_t *x, size_t size) {
return false; return false;
} }
bool DataSource::getUInt32Var(off64_t offset, uint32_t *x, size_t size) { bool DataSourceBase::getUInt32Var(off64_t offset, uint32_t *x, size_t size) {
if (size == 4) { if (size == 4) {
return getUInt32(offset, x); return getUInt32(offset, x);
} }
@ -103,7 +103,7 @@ bool DataSource::getUInt32Var(off64_t offset, uint32_t *x, size_t size) {
return false; return false;
} }
bool DataSource::getUInt64Var(off64_t offset, uint64_t *x, size_t size) { bool DataSourceBase::getUInt64Var(off64_t offset, uint64_t *x, size_t size) {
if (size == 8) { if (size == 8) {
return getUInt64(offset, x); return getUInt64(offset, x);
} }
@ -117,13 +117,13 @@ bool DataSource::getUInt64Var(off64_t offset, uint64_t *x, size_t size) {
return false; return false;
} }
status_t DataSource::getSize(off64_t *size) { status_t DataSourceBase::getSize(off64_t *size) {
*size = 0; *size = 0;
return ERROR_UNSUPPORTED; return ERROR_UNSUPPORTED;
} }
String8 DataSource::getMIMEType() const { String8 DataSourceBase::getMIMEType() const {
return String8("application/octet-stream"); return String8("application/octet-stream");
} }

@ -20,75 +20,21 @@
#include <sys/types.h> #include <sys/types.h>
#include <media/stagefright/MediaErrors.h> #include <media/stagefright/MediaErrors.h>
#include <media/DataSourceBase.h>
#include <utils/Errors.h> #include <utils/Errors.h>
#include <utils/RefBase.h> #include <utils/RefBase.h>
#include <utils/threads.h> #include <utils/threads.h>
#include <drm/DrmManagerClient.h> #include <drm/DrmManagerClient.h>
namespace android { namespace android {
class String8; class String8;
class DataSource : public RefBase { class DataSource : public DataSourceBase, public virtual RefBase {
public: public:
enum Flags {
kWantsPrefetching = 1,
kStreamedFromLocalHost = 2,
kIsCachingDataSource = 4,
kIsHTTPBasedSource = 8,
kIsLocalFileSource = 16,
};
DataSource() {} DataSource() {}
virtual status_t initCheck() const = 0;
// Returns the number of bytes read, or -1 on failure. It's not an error if
// this returns zero; it just means the given offset is equal to, or
// beyond, the end of the source.
virtual ssize_t readAt(off64_t offset, void *data, size_t size) = 0;
// Convenience methods:
bool getUInt16(off64_t offset, uint16_t *x);
bool getUInt24(off64_t offset, uint32_t *x); // 3 byte int, returned as a 32-bit int
bool getUInt32(off64_t offset, uint32_t *x);
bool getUInt64(off64_t offset, uint64_t *x);
// read either int<N> or int<2N> into a uint<2N>_t, size is the int size in bytes.
bool getUInt16Var(off64_t offset, uint16_t *x, size_t size);
bool getUInt32Var(off64_t offset, uint32_t *x, size_t size);
bool getUInt64Var(off64_t offset, uint64_t *x, size_t size);
// May return ERROR_UNSUPPORTED.
virtual status_t getSize(off64_t *size);
virtual uint32_t flags() {
return 0;
}
virtual String8 toString() {
return String8("<unspecified>");
}
virtual status_t reconnectAtOffset(off64_t /*offset*/) {
return ERROR_UNSUPPORTED;
}
////////////////////////////////////////////////////////////////////////////
// for DRM
virtual sp<DecryptHandle> DrmInitialization(const char * /*mime*/ = NULL) {
return NULL;
}
virtual String8 getUri() {
return String8();
}
virtual String8 getMIMEType() const;
virtual void close() {};
protected: protected:
virtual ~DataSource() {} virtual ~DataSource() {}

@ -0,0 +1,160 @@
/*
* 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.
*/
#ifndef DATA_SOURCE_BASE_H_
#define DATA_SOURCE_BASE_H_
#include <sys/types.h>
#include <media/stagefright/MediaErrors.h>
#include <utils/Errors.h>
#include <utils/threads.h>
#include <drm/DrmManagerClient.h>
namespace android {
class String8;
class DataSourceBase {
public:
enum Flags {
kWantsPrefetching = 1,
kStreamedFromLocalHost = 2,
kIsCachingDataSource = 4,
kIsHTTPBasedSource = 8,
kIsLocalFileSource = 16,
};
DataSourceBase() {}
virtual status_t initCheck() const = 0;
// Returns the number of bytes read, or -1 on failure. It's not an error if
// this returns zero; it just means the given offset is equal to, or
// beyond, the end of the source.
virtual ssize_t readAt(off64_t offset, void *data, size_t size) = 0;
// Convenience methods:
bool getUInt16(off64_t offset, uint16_t *x);
bool getUInt24(off64_t offset, uint32_t *x); // 3 byte int, returned as a 32-bit int
bool getUInt32(off64_t offset, uint32_t *x);
bool getUInt64(off64_t offset, uint64_t *x);
// read either int<N> or int<2N> into a uint<2N>_t, size is the int size in bytes.
bool getUInt16Var(off64_t offset, uint16_t *x, size_t size);
bool getUInt32Var(off64_t offset, uint32_t *x, size_t size);
bool getUInt64Var(off64_t offset, uint64_t *x, size_t size);
// Reads in "count" entries of type T into vector *x.
// Returns true if "count" entries can be read.
// If fewer than "count" entries can be read, return false. In this case,
// the output vector *x will still have those entries that were read. Call
// x->size() to obtain the number of entries read.
// The optional parameter chunkSize specifies how many entries should be
// read from the data source at one time into a temporary buffer. Increasing
// chunkSize can improve the performance at the cost of extra memory usage.
// The default value for chunkSize is set to read at least 4k bytes at a
// time, depending on sizeof(T).
template <typename T>
bool getVector(off64_t offset, Vector<T>* x, size_t count,
size_t chunkSize = (4095 / sizeof(T)) + 1);
// May return ERROR_UNSUPPORTED.
virtual status_t getSize(off64_t *size);
virtual uint32_t flags() {
return 0;
}
virtual String8 toString() {
return String8("<unspecified>");
}
virtual status_t reconnectAtOffset(off64_t /*offset*/) {
return ERROR_UNSUPPORTED;
}
////////////////////////////////////////////////////////////////////////////
// for DRM
virtual sp<DecryptHandle> DrmInitialization(const char * /*mime*/ = NULL) {
return NULL;
}
virtual String8 getUri() {
return String8();
}
virtual String8 getMIMEType() const;
virtual void close() {};
protected:
virtual ~DataSourceBase() {}
private:
DataSourceBase(const DataSourceBase &);
DataSourceBase &operator=(const DataSourceBase &);
};
template <typename T>
bool DataSourceBase::getVector(off64_t offset, Vector<T>* x, size_t count,
size_t chunkSize)
{
x->clear();
if (chunkSize == 0) {
return false;
}
if (count == 0) {
return true;
}
T tmp[chunkSize];
ssize_t numBytesRead;
size_t numBytesPerChunk = chunkSize * sizeof(T);
size_t i;
for (i = 0; i + chunkSize < count; i += chunkSize) {
// This loops is executed when more than chunkSize records need to be
// read.
numBytesRead = this->readAt(offset, (void*)&tmp, numBytesPerChunk);
if (numBytesRead == -1) { // If readAt() returns -1, there is an error.
return false;
}
if (static_cast<size_t>(numBytesRead) < numBytesPerChunk) {
// This case is triggered when the stream ends before the whole
// chunk is read.
x->appendArray(tmp, (size_t)numBytesRead / sizeof(T));
return false;
}
x->appendArray(tmp, chunkSize);
offset += numBytesPerChunk;
}
// There are (count - i) more records to read.
// Right now, (count - i) <= chunkSize.
// We do the same thing as above, but with chunkSize replaced by count - i.
numBytesRead = this->readAt(offset, (void*)&tmp, (count - i) * sizeof(T));
if (numBytesRead == -1) {
return false;
}
x->appendArray(tmp, (size_t)numBytesRead / sizeof(T));
return x->size() == count;
}
} // namespace android
#endif // DATA_SOURCE_BASE_H_

@ -27,7 +27,7 @@
namespace android { namespace android {
class DataSource; class DataSourceBase;
class MetaData; class MetaData;
class String8; class String8;
struct AMessage; struct AMessage;
@ -87,15 +87,14 @@ public:
virtual const char * name() { return "<unspecified>"; } virtual const char * name() { return "<unspecified>"; }
virtual void release() {}
typedef MediaExtractor* (*CreatorFunc)( typedef MediaExtractor* (*CreatorFunc)(
const sp<DataSource> &source, const sp<AMessage> &meta); DataSourceBase *source, const sp<AMessage> &meta);
// The sniffer can optionally fill in "meta" with an AMessage containing // The sniffer can optionally fill in "meta" with an AMessage containing
// a dictionary of values that helps the corresponding extractor initialize // a dictionary of values that helps the corresponding extractor initialize
// its state without duplicating effort already exerted by the sniffer. // its state without duplicating effort already exerted by the sniffer.
typedef CreatorFunc (*SnifferFunc)( typedef CreatorFunc (*SnifferFunc)(
const sp<DataSource> &source, String8 *mimeType, DataSourceBase *source, String8 *mimeType,
float *confidence, sp<AMessage> *meta); float *confidence, sp<AMessage> *meta);
typedef struct { typedef struct {

@ -21,6 +21,7 @@
#include "include/CallbackDataSource.h" #include "include/CallbackDataSource.h"
#include <binder/IMemory.h> #include <binder/IMemory.h>
#include <binder/IPCThreadState.h>
#include <media/IDataSource.h> #include <media/IDataSource.h>
#include <media/stagefright/foundation/ADebug.h> #include <media/stagefright/foundation/ADebug.h>
@ -34,7 +35,10 @@ CallbackDataSource::CallbackDataSource(
mIsClosed(false) { mIsClosed(false) {
// Set up the buffer to read into. // Set up the buffer to read into.
mMemory = mIDataSource->getIMemory(); mMemory = mIDataSource->getIMemory();
mName = String8::format("CallbackDataSource(%s)", mIDataSource->toString().string()); mName = String8::format("CallbackDataSource(%d->%d, %s)",
getpid(),
IPCThreadState::self()->getCallingPid(),
mIDataSource->toString().string());
} }

@ -38,11 +38,13 @@ sp<IDataSource> CreateIDataSourceFromDataSource(const sp<DataSource> &source) {
} }
sp<IMediaExtractor> CreateIMediaExtractorFromMediaExtractor( sp<IMediaExtractor> CreateIMediaExtractorFromMediaExtractor(
MediaExtractor *extractor, const sp<RefBase> &plugin) { MediaExtractor *extractor,
const sp<DataSource> &source,
const sp<RefBase> &plugin) {
if (extractor == nullptr) { if (extractor == nullptr) {
return nullptr; return nullptr;
} }
return RemoteMediaExtractor::wrap(extractor, plugin); return RemoteMediaExtractor::wrap(extractor, source, plugin);
} }
sp<MediaSource> CreateMediaSourceFromIMediaSource(const sp<IMediaSource> &source) { sp<MediaSource> CreateMediaSourceFromIMediaSource(const sp<IMediaSource> &source) {

@ -118,7 +118,7 @@ sp<IMediaExtractor> MediaExtractorFactory::CreateFromService(
String8 tmp; String8 tmp;
float confidence; float confidence;
sp<ExtractorPlugin> plugin; sp<ExtractorPlugin> plugin;
creator = sniff(source, &tmp, &confidence, &meta, plugin); creator = sniff(source.get(), &tmp, &confidence, &meta, plugin);
if (!creator) { if (!creator) {
ALOGV("FAILED to autodetect media content."); ALOGV("FAILED to autodetect media content.");
return NULL; return NULL;
@ -128,8 +128,8 @@ sp<IMediaExtractor> MediaExtractorFactory::CreateFromService(
ALOGV("Autodetected media content as '%s' with confidence %.2f", ALOGV("Autodetected media content as '%s' with confidence %.2f",
mime, confidence); mime, confidence);
MediaExtractor *ret = creator(source, meta); MediaExtractor *ret = creator(source.get(), meta);
return CreateIMediaExtractorFromMediaExtractor(ret, plugin); return CreateIMediaExtractorFromMediaExtractor(ret, source, plugin);
} }
//static //static
@ -165,7 +165,7 @@ bool MediaExtractorFactory::gPluginsRegistered = false;
// static // static
MediaExtractor::CreatorFunc MediaExtractorFactory::sniff( MediaExtractor::CreatorFunc MediaExtractorFactory::sniff(
const sp<DataSource> &source, String8 *mimeType, float *confidence, sp<AMessage> *meta, DataSourceBase *source, String8 *mimeType, float *confidence, sp<AMessage> *meta,
sp<ExtractorPlugin> &plugin) { sp<ExtractorPlugin> &plugin) {
*mimeType = ""; *mimeType = "";
*confidence = 0.0f; *confidence = 0.0f;

@ -37,9 +37,12 @@ static const char *kExtractorTracks = "android.media.mediaextractor.ntrk";
static const char *kExtractorFormat = "android.media.mediaextractor.fmt"; static const char *kExtractorFormat = "android.media.mediaextractor.fmt";
RemoteMediaExtractor::RemoteMediaExtractor( RemoteMediaExtractor::RemoteMediaExtractor(
MediaExtractor *extractor, const sp<RefBase> &plugin) MediaExtractor *extractor,
const sp<DataSource> &source,
const sp<RefBase> &plugin)
:mExtractor(extractor), :mExtractor(extractor),
mExtractorPlugin(plugin) { mSource(source),
mExtractorPlugin(plugin) {
mAnalyticsItem = nullptr; mAnalyticsItem = nullptr;
if (MEDIA_LOG) { if (MEDIA_LOG) {
@ -67,6 +70,8 @@ RemoteMediaExtractor::RemoteMediaExtractor(
RemoteMediaExtractor::~RemoteMediaExtractor() { RemoteMediaExtractor::~RemoteMediaExtractor() {
delete mExtractor; delete mExtractor;
mSource->close();
mSource.clear();
mExtractorPlugin = nullptr; mExtractorPlugin = nullptr;
// log the current record, provided it has some information worth recording // log the current record, provided it has some information worth recording
if (MEDIA_LOG) { if (MEDIA_LOG) {
@ -129,19 +134,17 @@ const char * RemoteMediaExtractor::name() {
return mExtractor->name(); return mExtractor->name();
} }
void RemoteMediaExtractor::release() {
return mExtractor->release();
}
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// static // static
sp<IMediaExtractor> RemoteMediaExtractor::wrap( sp<IMediaExtractor> RemoteMediaExtractor::wrap(
MediaExtractor *extractor, const sp<RefBase> &plugin) { MediaExtractor *extractor,
const sp<DataSource> &source,
const sp<RefBase> &plugin) {
if (extractor == nullptr) { if (extractor == nullptr) {
return nullptr; return nullptr;
} }
return new RemoteMediaExtractor(extractor, plugin); return new RemoteMediaExtractor(extractor, source, plugin);
} }
} // namespace android } // namespace android

@ -47,12 +47,6 @@ StagefrightMetadataRetriever::StagefrightMetadataRetriever()
StagefrightMetadataRetriever::~StagefrightMetadataRetriever() { StagefrightMetadataRetriever::~StagefrightMetadataRetriever() {
ALOGV("~StagefrightMetadataRetriever()"); ALOGV("~StagefrightMetadataRetriever()");
clearMetadata(); clearMetadata();
// Explicitly release extractor before continuing with the destructor,
// some extractors might need to callback to close off the DataSource
// and we need to make sure it's still there.
if (mExtractor != NULL) {
mExtractor->release();
}
if (mSource != NULL) { if (mSource != NULL) {
mSource->close(); mSource->close();
} }

@ -30,7 +30,7 @@ namespace android {
static const size_t kMaxMetadataSize = 3 * 1024 * 1024; static const size_t kMaxMetadataSize = 3 * 1024 * 1024;
struct MemorySource : public DataSource { struct MemorySource : public DataSourceBase {
MemorySource(const uint8_t *data, size_t size) MemorySource(const uint8_t *data, size_t size)
: mData(data), : mData(data),
mSize(size) { mSize(size) {
@ -56,7 +56,7 @@ private:
DISALLOW_EVIL_CONSTRUCTORS(MemorySource); DISALLOW_EVIL_CONSTRUCTORS(MemorySource);
}; };
ID3::ID3(const sp<DataSource> &source, bool ignoreV1, off64_t offset) ID3::ID3(DataSourceBase *source, bool ignoreV1, off64_t offset)
: mIsValid(false), : mIsValid(false),
mData(NULL), mData(NULL),
mSize(0), mSize(0),
@ -77,7 +77,7 @@ ID3::ID3(const uint8_t *data, size_t size, bool ignoreV1)
mFirstFrameOffset(0), mFirstFrameOffset(0),
mVersion(ID3_UNKNOWN), mVersion(ID3_UNKNOWN),
mRawSize(0) { mRawSize(0) {
sp<MemorySource> source = new (std::nothrow) MemorySource(data, size); MemorySource *source = new (std::nothrow) MemorySource(data, size);
if (source == NULL) if (source == NULL)
return; return;
@ -87,6 +87,7 @@ ID3::ID3(const uint8_t *data, size_t size, bool ignoreV1)
if (!mIsValid && !ignoreV1) { if (!mIsValid && !ignoreV1) {
mIsValid = parseV1(source); mIsValid = parseV1(source);
} }
delete source;
} }
ID3::~ID3() { ID3::~ID3() {
@ -118,7 +119,7 @@ bool ID3::ParseSyncsafeInteger(const uint8_t encoded[4], size_t *x) {
return true; return true;
} }
bool ID3::parseV2(const sp<DataSource> &source, off64_t offset) { bool ID3::parseV2(DataSourceBase *source, off64_t offset) {
struct id3_header { struct id3_header {
char id[3]; char id[3];
uint8_t version_major; uint8_t version_major;
@ -960,7 +961,7 @@ ID3::getAlbumArt(size_t *length, String8 *mime) const {
return NULL; return NULL;
} }
bool ID3::parseV1(const sp<DataSource> &source) { bool ID3::parseV1(DataSourceBase *source) {
const size_t V1_TAG_SIZE = 128; const size_t V1_TAG_SIZE = 128;
off64_t size; off64_t size;

@ -72,7 +72,7 @@ void scanFile(const char *path) {
sp<FileSource> file = new FileSource(path); sp<FileSource> file = new FileSource(path);
CHECK_EQ(file->initCheck(), (status_t)OK); CHECK_EQ(file->initCheck(), (status_t)OK);
ID3 tag(file); ID3 tag(file.get());
if (!tag.isValid()) { if (!tag.isValid()) {
printf("FAIL %s\n", path); printf("FAIL %s\n", path);
} else { } else {

@ -22,7 +22,7 @@
namespace android { namespace android {
class DataSource; class DataSourceBase;
class String8; class String8;
struct ID3 { struct ID3 {
@ -35,7 +35,7 @@ struct ID3 {
ID3_V2_4, ID3_V2_4,
}; };
explicit ID3(const sp<DataSource> &source, bool ignoreV1 = false, off64_t offset = 0); explicit ID3(DataSourceBase *source, bool ignoreV1 = false, off64_t offset = 0);
ID3(const uint8_t *data, size_t size, bool ignoreV1 = false); ID3(const uint8_t *data, size_t size, bool ignoreV1 = false);
~ID3(); ~ID3();
@ -85,8 +85,8 @@ private:
// only valid for IDV2+ // only valid for IDV2+
size_t mRawSize; size_t mRawSize;
bool parseV1(const sp<DataSource> &source); bool parseV1(DataSourceBase *source);
bool parseV2(const sp<DataSource> &source, off64_t offset); bool parseV2(DataSourceBase *source, off64_t offset);
void removeUnsynchronization(); void removeUnsynchronization();
bool removeUnsynchronizationV2_4(bool iTunesHack); bool removeUnsynchronizationV2_4(bool iTunesHack);

@ -41,7 +41,9 @@ sp<IDataSource> CreateIDataSourceFromDataSource(const sp<DataSource> &source);
// Creates an IMediaExtractor wrapper to the given MediaExtractor. // Creates an IMediaExtractor wrapper to the given MediaExtractor.
sp<IMediaExtractor> CreateIMediaExtractorFromMediaExtractor( sp<IMediaExtractor> CreateIMediaExtractorFromMediaExtractor(
MediaExtractor *extractor, const sp<RefBase> &plugin); MediaExtractor *extractor,
const sp<DataSource> &source,
const sp<RefBase> &plugin);
// Creates a MediaSource which wraps the given IMediaSource object. // Creates a MediaSource which wraps the given IMediaSource object.
sp<MediaSource> CreateMediaSourceFromIMediaSource(const sp<IMediaSource> &source); sp<MediaSource> CreateMediaSourceFromIMediaSource(const sp<IMediaSource> &source);

@ -56,7 +56,7 @@ private:
static void RegisterExtractor( static void RegisterExtractor(
const sp<ExtractorPlugin> &plugin, List<sp<ExtractorPlugin>> &pluginList); const sp<ExtractorPlugin> &plugin, List<sp<ExtractorPlugin>> &pluginList);
static MediaExtractor::CreatorFunc sniff(const sp<DataSource> &source, static MediaExtractor::CreatorFunc sniff(DataSourceBase *source,
String8 *mimeType, float *confidence, sp<AMessage> *meta, String8 *mimeType, float *confidence, sp<AMessage> *meta,
sp<ExtractorPlugin> &plugin); sp<ExtractorPlugin> &plugin);

@ -28,7 +28,10 @@ class MediaAnalyticsItem;
// IMediaExtractor wrapper to the MediaExtractor. // IMediaExtractor wrapper to the MediaExtractor.
class RemoteMediaExtractor : public BnMediaExtractor { class RemoteMediaExtractor : public BnMediaExtractor {
public: public:
static sp<IMediaExtractor> wrap(MediaExtractor *extractor, const sp<RefBase> &plugin); static sp<IMediaExtractor> wrap(
MediaExtractor *extractor,
const sp<DataSource> &source,
const sp<RefBase> &plugin);
virtual ~RemoteMediaExtractor(); virtual ~RemoteMediaExtractor();
virtual size_t countTracks(); virtual size_t countTracks();
@ -41,15 +44,18 @@ public:
virtual void setUID(uid_t uid); virtual void setUID(uid_t uid);
virtual status_t setMediaCas(const HInterfaceToken &casToken); virtual status_t setMediaCas(const HInterfaceToken &casToken);
virtual const char * name(); virtual const char * name();
virtual void release();
private: private:
MediaExtractor *mExtractor; MediaExtractor *mExtractor;
sp<DataSource> mSource;
sp<RefBase> mExtractorPlugin; sp<RefBase> mExtractorPlugin;
MediaAnalyticsItem *mAnalyticsItem; MediaAnalyticsItem *mAnalyticsItem;
explicit RemoteMediaExtractor(MediaExtractor *extractor, const sp<RefBase> &plugin); explicit RemoteMediaExtractor(
MediaExtractor *extractor,
const sp<DataSource> &source,
const sp<RefBase> &plugin);
DISALLOW_EVIL_CONSTRUCTORS(RemoteMediaExtractor); DISALLOW_EVIL_CONSTRUCTORS(RemoteMediaExtractor);
}; };

Loading…
Cancel
Save