Remove direct dependency on libbinder from extractor impls

This change removes dependency on IMediaExtractor/Source binder
interfaces from MediaExtractor implementations. Wrapper classes,
RemoteXXX and CallbackXXX, have been added to convert the
implementations to binder objects or the other way around.

Test: build, boot, and play mp4 video file
Bug: 65851881
Change-Id: I351fb7bbaf8e0154295ccf258f85b8b2f2a4b8fb
gugelfrei
Dongwon Kang 7 years ago
parent 161101b0f9
commit ba8128f9db

@ -112,7 +112,7 @@ int main(int argc, char* argv[])
looper->setName("audioloop");
looper->start();
sp<IMediaSource> encoder = MediaCodecSource::Create(looper, meta, source);
sp<MediaSource> encoder = MediaCodecSource::Create(looper, meta, source);
if (fileOut != NULL) {
// target file specified, write encoded AMR output
@ -128,7 +128,7 @@ int main(int argc, char* argv[])
writer->stop();
} else {
// otherwise decode to speaker
sp<IMediaSource> decoder = SimpleDecodingSource::Create(encoder);
sp<MediaSource> decoder = SimpleDecodingSource::Create(encoder);
if (playToSpeaker) {
AudioPlayer *player = new AudioPlayer(NULL);

@ -320,7 +320,7 @@ int main(int /* argc */, char ** /* argv */) {
looper->setName("record");
looper->start();
sp<IMediaSource> encoder =
sp<MediaSource> encoder =
MediaCodecSource::Create(looper, encMeta, audioSource);
encoder->start();

@ -303,7 +303,7 @@ int main(int argc, char **argv) {
looper->setName("recordvideo");
looper->start();
sp<IMediaSource> encoder =
sp<MediaSource> encoder =
MediaCodecSource::Create(
looper, enc_meta, source, NULL /* consumer */,
preferSoftwareCodec ? MediaCodecSource::FLAG_PREFER_SOFTWARE_CODEC : 0);

@ -141,7 +141,7 @@ static void displayAVCProfileLevelIfPossible(const sp<MetaData>& meta) {
}
}
static void dumpSource(const sp<IMediaSource> &source, const String8 &filename) {
static void dumpSource(const sp<MediaSource> &source, const String8 &filename) {
FILE *out = fopen(filename.string(), "wb");
CHECK_EQ((status_t)OK, source->start());
@ -174,13 +174,13 @@ static void dumpSource(const sp<IMediaSource> &source, const String8 &filename)
out = NULL;
}
static void playSource(sp<IMediaSource> &source) {
static void playSource(sp<MediaSource> &source) {
sp<MetaData> meta = source->getFormat();
const char *mime;
CHECK(meta->findCString(kKeyMIMEType, &mime));
sp<IMediaSource> rawSource;
sp<MediaSource> rawSource;
if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_RAW, mime)) {
rawSource = source;
} else {
@ -404,7 +404,7 @@ static void playSource(sp<IMediaSource> &source) {
////////////////////////////////////////////////////////////////////////////////
struct DetectSyncSource : public MediaSource {
explicit DetectSyncSource(const sp<IMediaSource> &source);
explicit DetectSyncSource(const sp<MediaSource> &source);
virtual status_t start(MetaData *params = NULL);
virtual status_t stop();
@ -421,14 +421,14 @@ private:
OTHER,
};
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
StreamType mStreamType;
bool mSawFirstIDRFrame;
DISALLOW_EVIL_CONSTRUCTORS(DetectSyncSource);
};
DetectSyncSource::DetectSyncSource(const sp<IMediaSource> &source)
DetectSyncSource::DetectSyncSource(const sp<MediaSource> &source)
: mSource(source),
mStreamType(OTHER),
mSawFirstIDRFrame(false) {
@ -510,7 +510,7 @@ status_t DetectSyncSource::read(
////////////////////////////////////////////////////////////////////////////////
static void writeSourcesToMP4(
Vector<sp<IMediaSource> > &sources, bool syncInfoPresent) {
Vector<sp<MediaSource> > &sources, bool syncInfoPresent) {
#if 0
sp<MPEG4Writer> writer =
new MPEG4Writer(gWriteMP4Filename.string());
@ -528,7 +528,7 @@ static void writeSourcesToMP4(
writer->setMaxFileDuration(60000000ll);
for (size_t i = 0; i < sources.size(); ++i) {
sp<IMediaSource> source = sources.editItemAt(i);
sp<MediaSource> source = sources.editItemAt(i);
CHECK_EQ(writer->addSource(
syncInfoPresent ? source : new DetectSyncSource(source)),
@ -545,7 +545,7 @@ static void writeSourcesToMP4(
writer->stop();
}
static void performSeekTest(const sp<IMediaSource> &source) {
static void performSeekTest(const sp<MediaSource> &source) {
CHECK_EQ((status_t)OK, source->start());
int64_t durationUs;
@ -1002,8 +1002,8 @@ int main(int argc, char **argv) {
isJPEG = true;
}
Vector<sp<IMediaSource> > mediaSources;
sp<IMediaSource> mediaSource;
Vector<sp<MediaSource> > mediaSources;
sp<MediaSource> mediaSource;
if (isJPEG) {
mediaSource = new JPEGSource(dataSource);
@ -1049,7 +1049,8 @@ int main(int argc, char **argv) {
bool haveAudio = false;
bool haveVideo = false;
for (size_t i = 0; i < numTracks; ++i) {
sp<IMediaSource> source = extractor->getTrack(i);
sp<MediaSource> source = MediaSource::CreateFromIMediaSource(
extractor->getTrack(i));
if (source == nullptr) {
fprintf(stderr, "skip NULL track %zu, track count %zu.\n", i, numTracks);
continue;
@ -1115,7 +1116,7 @@ int main(int argc, char **argv) {
thumbTimeUs, thumbTimeUs / 1E6);
}
mediaSource = extractor->getTrack(i);
mediaSource = MediaSource::CreateFromIMediaSource(extractor->getTrack(i));
if (mediaSource == nullptr) {
fprintf(stderr, "skip NULL track %zu, total tracks %zu.\n", i, numTracks);
return -1;
@ -1128,7 +1129,7 @@ int main(int argc, char **argv) {
} else if (dumpStream) {
dumpSource(mediaSource, dumpStreamFilename);
} else if (dumpPCMStream) {
sp<IMediaSource> decSource = SimpleDecodingSource::Create(mediaSource);
sp<MediaSource> decSource = SimpleDecodingSource::Create(mediaSource);
dumpSource(decSource, dumpStreamFilename);
} else if (seekTest) {
performSeekTest(mediaSource);

@ -182,7 +182,7 @@ MyConvertingStreamSource::MyConvertingStreamSource(const char *filename)
continue;
}
sp<IMediaSource> track = extractor->getTrack(i);
sp<MediaSource> track = MediaSource::CreateFromIMediaSource(extractor->getTrack(i));
if (track == nullptr) {
fprintf(stderr, "skip NULL track %zu, total tracks %zu\n", i, numTracks);
continue;

@ -213,7 +213,7 @@ size_t AACExtractor::countTracks() {
return mInitCheck == OK ? 1 : 0;
}
sp<IMediaSource> AACExtractor::getTrack(size_t index) {
sp<MediaSource> AACExtractor::getTrack(size_t index) {
if (mInitCheck != OK || index != 0) {
return NULL;
}

@ -67,7 +67,7 @@ status_t AACWriter::initCheck() const {
}
status_t AACWriter::addSource(const sp<IMediaSource> &source) {
status_t AACWriter::addSource(const sp<MediaSource> &source) {
if (mInitCheck != OK) {
return mInitCheck;
}

@ -186,7 +186,7 @@ size_t AMRExtractor::countTracks() {
return mInitCheck == OK ? 1 : 0;
}
sp<IMediaSource> AMRExtractor::getTrack(size_t index) {
sp<MediaSource> AMRExtractor::getTrack(size_t index) {
if (mInitCheck != OK || index != 0) {
return NULL;
}

@ -54,7 +54,7 @@ status_t AMRWriter::initCheck() const {
return mInitCheck;
}
status_t AMRWriter::addSource(const sp<IMediaSource> &source) {
status_t AMRWriter::addSource(const sp<MediaSource> &source) {
if (mInitCheck != OK) {
return mInitCheck;
}

@ -19,6 +19,7 @@ cc_library_shared {
"BufferImpl.cpp",
"CodecBase.cpp",
"CallbackDataSource.cpp",
"CallbackMediaSource.cpp",
"CameraSource.cpp",
"CameraSourceTimeLapse.cpp",
"DataConverter.cpp",
@ -53,6 +54,8 @@ cc_library_shared {
"OMXClient.cpp",
"OmxInfoBuilder.cpp",
"OggExtractor.cpp",
"RemoteMediaExtractor.cpp",
"RemoteMediaSource.cpp",
"SampleIterator.cpp",
"SampleTable.cpp",
"SimpleDecodingSource.cpp",

@ -67,7 +67,7 @@ AudioPlayer::~AudioPlayer() {
}
}
void AudioPlayer::setSource(const sp<IMediaSource> &source) {
void AudioPlayer::setSource(const sp<MediaSource> &source) {
CHECK(mSource == NULL);
mSource = source;
}
@ -363,7 +363,7 @@ void AudioPlayer::reset() {
// When offloading, the OMX component is not used so this hack
// is not needed
if (!useOffload()) {
wp<IMediaSource> tmp = mSource;
wp<MediaSource> tmp = mSource;
mSource.clear();
while (tmp.promote() != NULL) {
usleep(1000);

@ -0,0 +1,50 @@
/*
* Copyright 2017, 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.
*/
#include <media/stagefright/CallbackMediaSource.h>
namespace android {
CallbackMediaSource::CallbackMediaSource(const sp<IMediaSource> &source)
:mSource(source) {}
CallbackMediaSource::~CallbackMediaSource() {}
status_t CallbackMediaSource::start(MetaData *params) {
return mSource->start(params);
}
status_t CallbackMediaSource::stop() {
return mSource->stop();
}
sp<MetaData> CallbackMediaSource::getFormat() {
return mSource->getFormat();
}
status_t CallbackMediaSource::read(MediaBuffer **buffer, const ReadOptions *options) {
return mSource->read(buffer, reinterpret_cast<const MediaSource::ReadOptions*>(options));
}
status_t CallbackMediaSource::pause() {
return mSource->pause();
}
status_t CallbackMediaSource::setBuffers(const Vector<MediaBuffer *> &buffers) {
return mSource->setBuffers(buffers);
}
} // namespace android

@ -811,7 +811,7 @@ size_t FLACExtractor::countTracks()
return mInitCheck == OK ? 1 : 0;
}
sp<IMediaSource> FLACExtractor::getTrack(size_t index)
sp<MediaSource> FLACExtractor::getTrack(size_t index)
{
if (mInitCheck != OK || index > 0) {
return NULL;

@ -407,7 +407,7 @@ size_t MP3Extractor::countTracks() {
return mInitCheck != OK ? 0 : 1;
}
sp<IMediaSource> MP3Extractor::getTrack(size_t index) {
sp<MediaSource> MP3Extractor::getTrack(size_t index) {
if (mInitCheck != OK || index != 0) {
return NULL;
}

@ -35,7 +35,7 @@
namespace android {
struct MPEG2TSWriter::SourceInfo : public AHandler {
explicit SourceInfo(const sp<IMediaSource> &source);
explicit SourceInfo(const sp<MediaSource> &source);
void start(const sp<AMessage> &notify, const sp<MetaData> &params);
void stop();
@ -69,7 +69,7 @@ private:
kWhatRead = 'read',
};
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
sp<ALooper> mLooper;
sp<AMessage> mNotify;
@ -91,7 +91,7 @@ private:
DISALLOW_EVIL_CONSTRUCTORS(SourceInfo);
};
MPEG2TSWriter::SourceInfo::SourceInfo(const sp<IMediaSource> &source)
MPEG2TSWriter::SourceInfo::SourceInfo(const sp<MediaSource> &source)
: mSource(source),
mLooper(new ALooper),
mEOSReceived(false),
@ -499,7 +499,7 @@ MPEG2TSWriter::~MPEG2TSWriter() {
}
}
status_t MPEG2TSWriter::addSource(const sp<IMediaSource> &source) {
status_t MPEG2TSWriter::addSource(const sp<MediaSource> &source) {
CHECK(!mStarted);
sp<MetaData> meta = source->getFormat();

@ -3344,7 +3344,7 @@ void MPEG4Extractor::parseID3v2MetaData(off64_t offset) {
}
}
sp<IMediaSource> MPEG4Extractor::getTrack(size_t index) {
sp<MediaSource> MPEG4Extractor::getTrack(size_t index) {
status_t err;
if ((err = readMetaData()) != OK) {
return NULL;

@ -100,7 +100,7 @@ static const uint8_t kHevcNalUnitTypes[5] = {
class MPEG4Writer::Track {
public:
Track(MPEG4Writer *owner, const sp<IMediaSource> &source, size_t trackId);
Track(MPEG4Writer *owner, const sp<MediaSource> &source, size_t trackId);
~Track();
@ -271,7 +271,7 @@ private:
MPEG4Writer *mOwner;
sp<MetaData> mMeta;
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
volatile bool mDone;
volatile bool mPaused;
volatile bool mResumed;
@ -572,7 +572,7 @@ const char *MPEG4Writer::Track::getFourCCForMime(const char *mime) {
return NULL;
}
status_t MPEG4Writer::addSource(const sp<IMediaSource> &source) {
status_t MPEG4Writer::addSource(const sp<MediaSource> &source) {
Mutex::Autolock l(mLock);
if (mStarted) {
ALOGE("Attempt to add source AFTER recording is started");
@ -1626,7 +1626,7 @@ size_t MPEG4Writer::numTracks() {
////////////////////////////////////////////////////////////////////////////////
MPEG4Writer::Track::Track(
MPEG4Writer *owner, const sp<IMediaSource> &source, size_t trackId)
MPEG4Writer *owner, const sp<MediaSource> &source, size_t trackId)
: mOwner(owner),
mMeta(source->getFormat()),
mSource(source),

@ -43,7 +43,10 @@
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MediaExtractor.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/RemoteMediaExtractor.h>
#include <media/IMediaExtractor.h>
#include <media/IMediaExtractorService.h>
#include <media/IMediaSource.h>
#include <cutils/properties.h>
#include <utils/String8.h>
#include <private/android_filesystem_config.h>
@ -92,6 +95,10 @@ MediaExtractor::~MediaExtractor() {
}
}
sp<IMediaExtractor> MediaExtractor::asIMediaExtractor() {
return RemoteMediaExtractor::wrap(sp<MediaExtractor>(this));
}
sp<MetaData> MediaExtractor::getMetaData() {
return new MetaData;
}
@ -125,7 +132,8 @@ sp<IMediaExtractor> MediaExtractor::Create(
if (!property_get_bool("media.stagefright.extractremote", true)) {
// local extractor
ALOGW("creating media extractor in calling process");
return CreateFromService(source, mime);
sp<MediaExtractor> extractor = CreateFromService(source, mime);
return (extractor.get() == nullptr) ? nullptr : extractor->asIMediaExtractor();
} else {
// remote extractor
ALOGV("get service manager");

@ -14,7 +14,9 @@
* limitations under the License.
*/
#include <media/stagefright/CallbackMediaSource.h>
#include <media/stagefright/MediaSource.h>
#include <media/stagefright/RemoteMediaSource.h>
namespace android {
@ -22,4 +24,16 @@ MediaSource::MediaSource() {}
MediaSource::~MediaSource() {}
// static
sp<MediaSource> MediaSource::CreateFromIMediaSource(const sp<IMediaSource> &source) {
if (source == nullptr) {
return nullptr;
}
return new CallbackMediaSource(source);
}
sp<IMediaSource> MediaSource::asIMediaSource() {
return RemoteMediaSource::wrap(sp<MediaSource>(this));
}
} // namespace android

@ -282,7 +282,7 @@ size_t MidiExtractor::countTracks()
return mInitCheck == OK ? 1 : 0;
}
sp<IMediaSource> MidiExtractor::getTrack(size_t index)
sp<MediaSource> MidiExtractor::getTrack(size_t index)
{
if (mInitCheck != OK || index > 0) {
return NULL;

@ -1344,7 +1344,7 @@ size_t OggExtractor::countTracks() {
return mInitCheck != OK ? 0 : 1;
}
sp<IMediaSource> OggExtractor::getTrack(size_t index) {
sp<MediaSource> OggExtractor::getTrack(size_t index) {
if (index >= 1) {
return NULL;
}

@ -0,0 +1,82 @@
/*
* Copyright 2017, 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.
*/
#include <media/stagefright/RemoteMediaExtractor.h>
#include <media/stagefright/MediaSource.h>
namespace android {
RemoteMediaExtractor::RemoteMediaExtractor(const sp<MediaExtractor> &extractor)
:mExtractor(extractor) {}
RemoteMediaExtractor::~RemoteMediaExtractor() {}
size_t RemoteMediaExtractor::countTracks() {
return mExtractor->countTracks();
}
sp<IMediaSource> RemoteMediaExtractor::getTrack(size_t index) {
sp<MediaSource> source = mExtractor->getTrack(index);
return (source.get() == nullptr) ? nullptr : source->asIMediaSource();
}
sp<MetaData> RemoteMediaExtractor::getTrackMetaData(size_t index, uint32_t flags) {
return mExtractor->getTrackMetaData(index, flags);
}
sp<MetaData> RemoteMediaExtractor::getMetaData() {
return mExtractor->getMetaData();
}
status_t RemoteMediaExtractor::getMetrics(Parcel *reply) {
return mExtractor->getMetrics(reply);
}
uint32_t RemoteMediaExtractor::flags() const {
return mExtractor->flags();
}
char* RemoteMediaExtractor::getDrmTrackInfo(size_t trackID, int * len) {
return mExtractor->getDrmTrackInfo(trackID, len);
}
void RemoteMediaExtractor::setUID(uid_t uid) {
return mExtractor->setUID(uid);
}
status_t RemoteMediaExtractor::setMediaCas(const HInterfaceToken &casToken) {
return mExtractor->setMediaCas(casToken);
}
const char * RemoteMediaExtractor::name() {
return mExtractor->name();
}
void RemoteMediaExtractor::release() {
return mExtractor->release();
}
////////////////////////////////////////////////////////////////////////////////
// static
sp<IMediaExtractor> RemoteMediaExtractor::wrap(const sp<MediaExtractor> &extractor) {
if (extractor.get() == nullptr) {
return nullptr;
}
return new RemoteMediaExtractor(extractor);
}
} // namespace android

@ -0,0 +1,64 @@
/*
* Copyright 2017, 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.
*/
#include <media/stagefright/RemoteMediaSource.h>
namespace android {
RemoteMediaSource::RemoteMediaSource(const sp<MediaSource> &source)
:mSource(source) {}
RemoteMediaSource::~RemoteMediaSource() {}
status_t RemoteMediaSource::start(MetaData *params) {
return mSource->start(params);
}
status_t RemoteMediaSource::stop() {
return mSource->stop();
}
sp<MetaData> RemoteMediaSource::getFormat() {
return mSource->getFormat();
}
status_t RemoteMediaSource::read(MediaBuffer **buffer, const ReadOptions *options) {
return mSource->read(buffer, reinterpret_cast<const MediaSource::ReadOptions*>(options));
}
status_t RemoteMediaSource::pause() {
return mSource->pause();
}
status_t RemoteMediaSource::setBuffers(const Vector<MediaBuffer *> &buffers) {
return mSource->setBuffers(buffers);
}
status_t RemoteMediaSource::setStopTimeUs(int64_t stopTimeUs) {
return mSource->setStopTimeUs(stopTimeUs);
}
////////////////////////////////////////////////////////////////////////////////
// static
sp<IMediaSource> RemoteMediaSource::wrap(const sp<MediaSource> &source) {
if (source.get() == nullptr) {
return nullptr;
}
return new RemoteMediaSource(source);
}
} // namespace android

@ -36,13 +36,13 @@ const int64_t kTimeoutWaitForInputUs = 5000; // 5 milliseconds
//static
sp<SimpleDecodingSource> SimpleDecodingSource::Create(
const sp<IMediaSource> &source, uint32_t flags) {
const sp<MediaSource> &source, uint32_t flags) {
return SimpleDecodingSource::Create(source, flags, nullptr, nullptr);
}
//static
sp<SimpleDecodingSource> SimpleDecodingSource::Create(
const sp<IMediaSource> &source, uint32_t flags, const sp<ANativeWindow> &nativeWindow,
const sp<MediaSource> &source, uint32_t flags, const sp<ANativeWindow> &nativeWindow,
const char *desiredCodec) {
sp<Surface> surface = static_cast<Surface*>(nativeWindow.get());
const char *mime = NULL;
@ -99,7 +99,7 @@ sp<SimpleDecodingSource> SimpleDecodingSource::Create(
}
SimpleDecodingSource::SimpleDecodingSource(
const sp<MediaCodec> &codec, const sp<IMediaSource> &source, const sp<ALooper> &looper,
const sp<MediaCodec> &codec, const sp<MediaSource> &source, const sp<ALooper> &looper,
bool usingSurface, bool isVorbis, const sp<AMessage> &format)
: mCodec(codec),
mSource(source),
@ -212,7 +212,7 @@ status_t SimpleDecodingSource::doRead(
status_t res;
// flush codec on seek
IMediaSource::ReadOptions::SeekMode mode;
MediaSource::ReadOptions::SeekMode mode;
if (options != NULL && options->getSeekTo(&out_pts, &mode)) {
me->mQueuedInputEOS = false;
me->mGotOutputEOS = false;

@ -120,7 +120,7 @@ size_t WAVExtractor::countTracks() {
return mInitCheck == OK ? 1 : 0;
}
sp<IMediaSource> WAVExtractor::getTrack(size_t index) {
sp<MediaSource> WAVExtractor::getTrack(size_t index) {
if (mInitCheck != OK || index > 0) {
return NULL;
}

@ -32,7 +32,7 @@ public:
AACExtractor(const sp<DataSource> &source, const sp<AMessage> &meta);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -32,7 +32,7 @@ public:
explicit AMRExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -32,7 +32,7 @@ public:
explicit FLACExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -34,7 +34,7 @@ public:
MP3Extractor(const sp<DataSource> &source, const sp<AMessage> &meta);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -34,7 +34,7 @@ struct MPEG2PSExtractor : public MediaExtractor {
explicit MPEG2PSExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -40,7 +40,7 @@ struct MPEG2TSExtractor : public MediaExtractor {
explicit MPEG2TSExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -56,7 +56,7 @@ public:
explicit MPEG4Extractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -56,7 +56,7 @@ public:
explicit MidiExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -34,7 +34,7 @@ struct OggExtractor : public MediaExtractor {
explicit OggExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -33,7 +33,7 @@ public:
explicit WAVExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -31,7 +31,7 @@ struct AACWriter : public MediaWriter {
status_t initCheck() const;
virtual status_t addSource(const sp<IMediaSource> &source);
virtual status_t addSource(const sp<MediaSource> &source);
virtual bool reachedEOS();
virtual status_t start(MetaData *params = NULL);
virtual status_t stop() { return reset(); }
@ -48,7 +48,7 @@ private:
int mFd;
status_t mInitCheck;
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
bool mStarted;
volatile bool mPaused;
volatile bool mResumed;

@ -20,7 +20,6 @@
#include <stdio.h>
#include <media/IMediaSource.h>
#include <media/stagefright/MediaWriter.h>
#include <utils/threads.h>
@ -33,7 +32,7 @@ struct AMRWriter : public MediaWriter {
status_t initCheck() const;
virtual status_t addSource(const sp<IMediaSource> &source);
virtual status_t addSource(const sp<MediaSource> &source);
virtual bool reachedEOS();
virtual status_t start(MetaData *params = NULL);
virtual status_t stop() { return reset(); }
@ -45,7 +44,7 @@ protected:
private:
int mFd;
status_t mInitCheck;
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
bool mStarted;
volatile bool mPaused;
volatile bool mResumed;

@ -18,9 +18,9 @@
#define AUDIO_PLAYER_H_
#include <media/IMediaSource.h>
#include <media/MediaPlayerInterface.h>
#include <media/stagefright/MediaBuffer.h>
#include <media/stagefright/MediaSource.h>
#include <utils/threads.h>
namespace android {
@ -50,7 +50,7 @@ public:
virtual ~AudioPlayer();
// Caller retains ownership of "source".
void setSource(const sp<IMediaSource> &source);
void setSource(const sp<MediaSource> &source);
status_t start(bool sourceAlreadyStarted = false);
@ -66,7 +66,7 @@ public:
status_t getPlaybackRate(AudioPlaybackRate *rate /* nonnull */);
private:
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
sp<AudioTrack> mAudioTrack;
MediaBuffer *mInputBuffer;

@ -0,0 +1,46 @@
/*
* Copyright 2017, 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 CALLBACK_MEDIA_SOURCE_H_
#define CALLBACK_MEDIA_SOURCE_H_
#include <media/stagefright/MediaSource.h>
#include <media/stagefright/foundation/ABase.h>
namespace android {
// A stagefright MediaSource that wraps a binder IMediaSource.
class CallbackMediaSource : public MediaSource {
public:
explicit CallbackMediaSource(const sp<IMediaSource> &source);
virtual ~CallbackMediaSource();
virtual status_t start(MetaData *params = NULL);
virtual status_t stop();
virtual sp<MetaData> getFormat();
virtual status_t read(
MediaBuffer **buffer, const ReadOptions *options = NULL);
virtual status_t pause();
virtual status_t setBuffers(const Vector<MediaBuffer *> &buffers);
private:
sp<IMediaSource> mSource;
DISALLOW_EVIL_CONSTRUCTORS(CallbackMediaSource);
};
} // namespace android
#endif // CALLBACK_MEDIA_SOURCE_H_

@ -34,7 +34,7 @@ struct MPEG2TSWriter : public MediaWriter {
void *cookie,
ssize_t (*write)(void *cookie, const void *data, size_t size));
virtual status_t addSource(const sp<IMediaSource> &source);
virtual status_t addSource(const sp<MediaSource> &source);
virtual status_t start(MetaData *param = NULL);
virtual status_t stop() { return reset(); }
virtual status_t pause();

@ -20,7 +20,6 @@
#include <stdio.h>
#include <media/IMediaSource.h>
#include <media/stagefright/MediaWriter.h>
#include <utils/List.h>
#include <utils/threads.h>
@ -40,7 +39,7 @@ public:
// Limitations
// No more than one video and/or one audio source can be added, but
// multiple metadata sources can be added.
virtual status_t addSource(const sp<IMediaSource> &source);
virtual status_t addSource(const sp<MediaSource> &source);
// Returns INVALID_OPERATION if there is no source or track.
virtual status_t start(MetaData *param = NULL);

@ -19,15 +19,15 @@
#define MEDIA_EXTRACTOR_H_
#include <media/IMediaExtractor.h>
#include <media/IMediaSource.h>
#include <media/MediaAnalyticsItem.h>
namespace android {
class DataSource;
struct MediaSource;
class MetaData;
class MediaExtractor : public BnMediaExtractor {
class MediaExtractor : public RefBase {
public:
static sp<IMediaExtractor> Create(
const sp<DataSource> &source, const char *mime = NULL);
@ -35,7 +35,7 @@ public:
const sp<DataSource> &source, const char *mime = NULL);
virtual size_t countTracks() = 0;
virtual sp<IMediaSource> getTrack(size_t index) = 0;
virtual sp<MediaSource> getTrack(size_t index) = 0;
enum GetTrackMetaDataFlags {
kIncludeExtensiveMetaData = 1
@ -60,13 +60,16 @@ public:
// CAN_SEEK_BACKWARD | CAN_SEEK_FORWARD | CAN_SEEK | CAN_PAUSE
virtual uint32_t flags() const;
// Creates an IMediaExtractor wrapper to this MediaExtractor.
virtual sp<IMediaExtractor> asIMediaExtractor();
// for DRM
virtual char* getDrmTrackInfo(size_t /*trackID*/, int * /*len*/) {
return NULL;
}
virtual void setUID(uid_t /*uid*/) {
}
virtual status_t setMediaCas(const HInterfaceToken &/*casToken*/) override {
virtual status_t setMediaCas(const HInterfaceToken &/*casToken*/) {
return INVALID_OPERATION;
}

@ -22,6 +22,7 @@
#include <media/IMediaSource.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
#include <utils/RefBase.h>
#include <utils/Vector.h>
@ -29,8 +30,18 @@ namespace android {
class MediaBuffer;
class MetaData;
class IMediaSource;
struct MediaSource : public virtual RefBase {
// TODO: Move ReadOptions implementation from IMediaSource to MediaSource
// once this class moves to a separate extractor lib on which both libmedia
// and libstagefright rely. For now, alias is added to avoid circular
// dependency.
using ReadOptions = IMediaSource::ReadOptions;
// Creates a MediaSource which wraps the given IMediaSource object.
static sp<MediaSource> CreateFromIMediaSource(const sp<IMediaSource> &source);
struct MediaSource : public BnMediaSource {
MediaSource();
// To be called before any other methods on this object, except
@ -92,6 +103,9 @@ struct MediaSource : public BnMediaSource {
return ERROR_UNSUPPORTED;
}
// Creates an IMediaSource wrapper to this MediaSource.
virtual sp<IMediaSource> asIMediaSource();
protected:
virtual ~MediaSource();

@ -20,7 +20,7 @@
#include <utils/RefBase.h>
#include <media/IMediaRecorderClient.h>
#include <media/IMediaSource.h>
#include <media/stagefright/MediaSource.h>
namespace android {
@ -32,7 +32,7 @@ struct MediaWriter : public RefBase {
mMaxFileDurationLimitUs(0) {
}
virtual status_t addSource(const sp<IMediaSource> &source) = 0;
virtual status_t addSource(const sp<MediaSource> &source) = 0;
virtual bool reachedEOS() = 0;
virtual status_t start(MetaData *params = NULL) = 0;
virtual status_t stop() = 0;

@ -0,0 +1,53 @@
/*
* Copyright 2017, 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 REMOTE_MEDIA_EXTRACTOR_H_
#define REMOTE_MEDIA_EXTRACTOR_H_
#include <media/IMediaExtractor.h>
#include <media/stagefright/MediaExtractor.h>
namespace android {
// IMediaExtractor wrapper to the MediaExtractor.
class RemoteMediaExtractor : public BnMediaExtractor {
public:
static sp<IMediaExtractor> wrap(const sp<MediaExtractor> &extractor);
virtual ~RemoteMediaExtractor();
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags = 0);
virtual sp<MetaData> getMetaData();
virtual status_t getMetrics(Parcel *reply);
virtual uint32_t flags() const;
virtual char* getDrmTrackInfo(size_t trackID, int * len);
virtual void setUID(uid_t uid);
virtual status_t setMediaCas(const HInterfaceToken &casToken);
virtual const char * name();
virtual void release();
private:
sp<MediaExtractor> mExtractor;
explicit RemoteMediaExtractor(const sp<MediaExtractor> &extractor);
DISALLOW_EVIL_CONSTRUCTORS(RemoteMediaExtractor);
};
} // namespace android
#endif // REMOTE_MEDIA_EXTRACTOR_H_

@ -0,0 +1,50 @@
/*
* Copyright 2017, 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 REMOTE_MEDIA_SOURCE_H_
#define REMOTE_MEDIA_SOURCE_H_
#include <media/IMediaSource.h>
#include <media/stagefright/MediaSource.h>
#include <media/stagefright/foundation/ABase.h>
namespace android {
// IMediaSrouce wrapper to the MediaSource.
class RemoteMediaSource : public BnMediaSource {
public:
static sp<IMediaSource> wrap(const sp<MediaSource> &source);
virtual ~RemoteMediaSource();
virtual status_t start(MetaData *params = NULL);
virtual status_t stop();
virtual sp<MetaData> getFormat();
virtual status_t read(
MediaBuffer **buffer, const ReadOptions *options = NULL);
virtual status_t pause();
virtual status_t setBuffers(const Vector<MediaBuffer *> &buffers);
virtual status_t setStopTimeUs(int64_t stopTimeUs);
private:
sp<MediaSource> mSource;
explicit RemoteMediaSource(const sp<MediaSource> &source);
DISALLOW_EVIL_CONSTRUCTORS(RemoteMediaSource);
};
} // namespace android
#endif // REMOTE_MEDIA_SOURCE_H_

@ -45,12 +45,12 @@ public:
// does not support secure input or pausing.
// if |desiredCodec| is given, use this specific codec.
static sp<SimpleDecodingSource> Create(
const sp<IMediaSource> &source, uint32_t flags,
const sp<MediaSource> &source, uint32_t flags,
const sp<ANativeWindow> &nativeWindow,
const char *desiredCodec = NULL);
static sp<SimpleDecodingSource> Create(
const sp<IMediaSource> &source, uint32_t flags = 0);
const sp<MediaSource> &source, uint32_t flags = 0);
virtual ~SimpleDecodingSource();
@ -73,11 +73,11 @@ public:
private:
// Construct this using a codec, source and looper.
SimpleDecodingSource(
const sp<MediaCodec> &codec, const sp<IMediaSource> &source, const sp<ALooper> &looper,
const sp<MediaCodec> &codec, const sp<MediaSource> &source, const sp<ALooper> &looper,
bool usingSurface, bool isVorbis, const sp<AMessage> &format);
sp<MediaCodec> mCodec;
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
sp<ALooper> mLooper;
bool mUsingSurface;
bool mIsVorbis;

@ -899,7 +899,7 @@ size_t MatroskaExtractor::countTracks() {
return mTracks.size();
}
sp<IMediaSource> MatroskaExtractor::getTrack(size_t index) {
sp<MediaSource> MatroskaExtractor::getTrack(size_t index) {
if (index >= mTracks.size()) {
return NULL;
}

@ -38,7 +38,7 @@ struct MatroskaExtractor : public MediaExtractor {
virtual size_t countTracks();
virtual sp<IMediaSource> getTrack(size_t index);
virtual sp<MediaSource> getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(
size_t index, uint32_t flags);

@ -125,7 +125,7 @@ size_t MPEG2PSExtractor::countTracks() {
return mTracks.size();
}
sp<IMediaSource> MPEG2PSExtractor::getTrack(size_t index) {
sp<MediaSource> MPEG2PSExtractor::getTrack(size_t index) {
if (index >= mTracks.size()) {
return NULL;
}

@ -129,7 +129,7 @@ size_t MPEG2TSExtractor::countTracks() {
return mSourceImpls.size();
}
sp<IMediaSource> MPEG2TSExtractor::getTrack(size_t index) {
sp<MediaSource> MPEG2TSExtractor::getTrack(size_t index) {
if (index >= mSourceImpls.size()) {
return NULL;
}

@ -543,7 +543,7 @@ static const char *GetURLForMime(const char *mime) {
return NULL;
}
static sp<IMediaSource> CreateSourceForMime(const char *mime) {
static sp<MediaSource> CreateSourceForMime(const char *mime) {
const char *url = GetURLForMime(mime);
if (url == NULL) {
@ -564,7 +564,7 @@ static sp<IMediaSource> CreateSourceForMime(const char *mime) {
CHECK(meta->findCString(kKeyMIMEType, &trackMime));
if (!strcasecmp(mime, trackMime)) {
return extractor->getTrack(i);
return MediaSource::CreateFromIMediaSource(extractor->getTrack(i));
}
}
@ -610,7 +610,7 @@ status_t Harness::testSeek(
return OK;
}
sp<IMediaSource> source = CreateSourceForMime(mime);
sp<MediaSource> source = CreateSourceForMime(mime);
if (source == NULL) {
printf(" * Unable to open test content for type '%s', "
@ -620,14 +620,14 @@ status_t Harness::testSeek(
return OK;
}
sp<IMediaSource> seekSource = CreateSourceForMime(mime);
sp<MediaSource> seekSource = CreateSourceForMime(mime);
if (source == NULL || seekSource == NULL) {
return UNKNOWN_ERROR;
}
CHECK_EQ(seekSource->start(), (status_t)OK);
sp<IMediaSource> codec = SimpleDecodingSource::Create(
sp<MediaSource> codec = SimpleDecodingSource::Create(
source, 0 /* flags */, NULL /* nativeWindow */, componentName);
CHECK(codec != NULL);

@ -104,7 +104,7 @@ ARTPWriter::~ARTPWriter() {
mFd = -1;
}
status_t ARTPWriter::addSource(const sp<IMediaSource> &source) {
status_t ARTPWriter::addSource(const sp<MediaSource> &source) {
mSource = source;
return OK;
}

@ -37,7 +37,7 @@ class MediaBuffer;
struct ARTPWriter : public MediaWriter {
explicit ARTPWriter(int fd);
virtual status_t addSource(const sp<IMediaSource> &source);
virtual status_t addSource(const sp<MediaSource> &source);
virtual bool reachedEOS();
virtual status_t start(MetaData *params);
virtual status_t stop();
@ -72,7 +72,7 @@ private:
int mRTCPFd;
#endif
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
sp<ALooper> mLooper;
sp<AHandlerReflector<ARTPWriter> > mReflector;

@ -252,7 +252,7 @@ void WebmFrameMediaSourceThread::clearFlags() {
}
WebmFrameMediaSourceThread::WebmFrameMediaSourceThread(
const sp<IMediaSource>& source,
const sp<MediaSource>& source,
int type,
LinkedBlockingQueue<const sp<WebmFrame> >& sink,
uint64_t timeCodeScale,

@ -123,7 +123,7 @@ public:
class WebmFrameMediaSourceThread: public WebmFrameSourceThread {
public:
WebmFrameMediaSourceThread(
const sp<IMediaSource>& source,
const sp<MediaSource>& source,
int type,
LinkedBlockingQueue<const sp<WebmFrame> >& sink,
uint64_t timeCodeScale,
@ -142,7 +142,7 @@ public:
}
private:
const sp<IMediaSource> mSource;
const sp<MediaSource> mSource;
const uint64_t mTimeCodeScale;
uint64_t mStartTimeUs;

@ -360,7 +360,7 @@ status_t WebmWriter::reset() {
return err;
}
status_t WebmWriter::addSource(const sp<IMediaSource> &source) {
status_t WebmWriter::addSource(const sp<MediaSource> &source) {
Mutex::Autolock l(mLock);
if (mStarted) {
ALOGE("Attempt to add source AFTER recording is started");

@ -40,7 +40,7 @@ public:
~WebmWriter() { reset(); }
virtual status_t addSource(const sp<IMediaSource> &source);
virtual status_t addSource(const sp<MediaSource> &source);
virtual status_t start(MetaData *param = NULL);
virtual status_t stop();
virtual status_t pause();
@ -85,7 +85,7 @@ private:
const char *mName;
sp<WebmElement> (*mMakeTrack)(const sp<MetaData>&);
sp<IMediaSource> mSource;
sp<MediaSource> mSource;
sp<WebmElement> mTrackEntry;
sp<WebmFrameSourceThread> mThread;
LinkedBlockingQueue<const sp<WebmFrame> > mSink;

@ -33,17 +33,18 @@ sp<IMediaExtractor> MediaExtractorService::makeExtractor(
sp<DataSource> localSource = DataSource::CreateFromIDataSource(remoteSource);
sp<IMediaExtractor> ret = MediaExtractor::CreateFromService(localSource, mime);
sp<MediaExtractor> extractor = MediaExtractor::CreateFromService(localSource, mime);
ALOGV("extractor service created %p (%s)",
ret.get(),
ret == NULL ? "" : ret->name());
extractor.get(),
extractor == nullptr ? "" : extractor->name());
if (ret != NULL) {
if (extractor != nullptr) {
sp<IMediaExtractor> ret = extractor->asIMediaExtractor();
registerMediaExtractor(ret, localSource, mime);
return ret;
}
return ret;
return nullptr;
}
sp<IDataSource> MediaExtractorService::makeIDataSource(int fd, int64_t offset, int64_t length)

Loading…
Cancel
Save