Remove RefBase from plugin-side MediaSource

Extractor plugins now use MediaSourceBase, which is not refcounted.
Framework-side MediaSource derives from MediaSourceBase and RefBase.

Bug: 67908556
Test: build, boot

Change-Id: Ie33ca07f0d0ba783a504d7b7bf1a75ca4acdd745
gugelfrei
Marco Nelissen 7 years ago
parent 7d880c31d2
commit cb30d8477c

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

@ -20,7 +20,7 @@
#include "AACExtractor.h"
#include <media/DataSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/avc_utils.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/AMessage.h>
@ -33,7 +33,7 @@
namespace android {
class AACSource : public MediaSource {
class AACSource : public MediaSourceBase {
public:
AACSource(const sp<DataSource> &source,
const sp<MetaData> &meta,
@ -207,7 +207,7 @@ size_t AACExtractor::countTracks() {
return mInitCheck == OK ? 1 : 0;
}
sp<MediaSource> AACExtractor::getTrack(size_t index) {
MediaSourceBase *AACExtractor::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<MediaSource> getTrack(size_t index);
virtual MediaSourceBase *getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -21,7 +21,7 @@
#include "AMRExtractor.h"
#include <media/DataSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaBufferGroup.h>
#include <media/stagefright/MediaDefs.h>
@ -31,7 +31,7 @@
namespace android {
class AMRSource : public MediaSource {
class AMRSource : public MediaSourceBase {
public:
AMRSource(const sp<DataSource> &source,
const sp<MetaData> &meta,
@ -186,7 +186,7 @@ size_t AMRExtractor::countTracks() {
return mInitCheck == OK ? 1 : 0;
}
sp<MediaSource> AMRExtractor::getTrack(size_t index) {
MediaSourceBase *AMRExtractor::getTrack(size_t index) {
if (mInitCheck != OK || index != 0) {
return NULL;
}

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

@ -23,7 +23,7 @@
#include "FLAC/stream_decoder.h"
#include <media/DataSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/base64.h>
@ -161,7 +161,7 @@ static void parseVorbisComment(
class FLACParser;
class FLACSource : public MediaSource {
class FLACSource : public MediaSourceBase {
public:
FLACSource(
@ -936,7 +936,7 @@ size_t FLACExtractor::countTracks()
return mInitCheck == OK ? 1 : 0;
}
sp<MediaSource> FLACExtractor::getTrack(size_t index)
MediaSourceBase *FLACExtractor::getTrack(size_t index)
{
if (mInitCheck != OK || index > 0) {
return NULL;

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

@ -25,7 +25,7 @@
#include <media/stagefright/MediaBufferGroup.h>
#include <media/stagefright/MediaDefs.h>
#include <media/stagefright/MetaData.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <libsonivox/eas_reverb.h>
namespace android {
@ -33,7 +33,7 @@ namespace android {
// how many Sonivox output buffers to aggregate into one MediaBuffer
static const int NUM_COMBINE_BUFFERS = 4;
class MidiSource : public MediaSource {
class MidiSource : public MediaSourceBase {
public:
MidiSource(
@ -282,7 +282,7 @@ size_t MidiExtractor::countTracks()
return mInitCheck == OK ? 1 : 0;
}
sp<MediaSource> MidiExtractor::getTrack(size_t index)
MediaSourceBase *MidiExtractor::getTrack(size_t index)
{
if (mInitCheck != OK || index > 0) {
return NULL;

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

@ -22,7 +22,7 @@
#include "MatroskaExtractor.h"
#include <media/DataSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AUtils.h>
#include <media/stagefright/foundation/ABuffer.h>
@ -121,7 +121,7 @@ private:
BlockIterator &operator=(const BlockIterator &);
};
struct MatroskaSource : public MediaSource {
struct MatroskaSource : public MediaSourceBase {
MatroskaSource(MatroskaExtractor *extractor, size_t index);
virtual status_t start(MetaData *params);
@ -927,7 +927,7 @@ size_t MatroskaExtractor::countTracks() {
return mTracks.size();
}
sp<MediaSource> MatroskaExtractor::getTrack(size_t index) {
MediaSourceBase *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<MediaSource> getTrack(size_t index);
virtual MediaSourceBase *getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(
size_t index, uint32_t flags);

@ -25,7 +25,7 @@
#include "XINGSeeker.h"
#include <media/DataSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/AMessage.h>
#include <media/stagefright/foundation/avc_utils.h>
@ -209,7 +209,7 @@ static bool Resync(
return valid;
}
class MP3Source : public MediaSource {
class MP3Source : public MediaSourceBase {
public:
MP3Source(
const sp<MetaData> &meta, const sp<DataSource> &source,
@ -407,7 +407,7 @@ size_t MP3Extractor::countTracks() {
return mInitCheck != OK ? 0 : 1;
}
sp<MediaSource> MP3Extractor::getTrack(size_t index) {
MediaSourceBase *MP3Extractor::getTrack(size_t index) {
if (mInitCheck != OK || index != 0) {
return NULL;
}

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

@ -31,7 +31,7 @@
#include "ItemTable.h"
#include "include/ESDS.h"
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABitReader.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h>
@ -65,7 +65,7 @@ enum {
kMaxAtomSize = 64 * 1024 * 1024,
};
class MPEG4Source : public MediaSource {
class MPEG4Source : public MediaSourceBase {
public:
// Caller retains ownership of both "dataSource" and "sampleTable".
MPEG4Source(const sp<MetaData> &format,
@ -87,7 +87,6 @@ public:
virtual bool supportNonblockingRead() { return true; }
virtual status_t fragmentedRead(MediaBuffer **buffer, const ReadOptions *options = NULL);
protected:
virtual ~MPEG4Source();
private:
@ -3409,7 +3408,7 @@ void MPEG4Extractor::parseID3v2MetaData(off64_t offset) {
}
}
sp<MediaSource> MPEG4Extractor::getTrack(size_t index) {
MediaSourceBase *MPEG4Extractor::getTrack(size_t index) {
status_t err;
if ((err = readMetaData()) != OK) {
return NULL;
@ -3485,10 +3484,11 @@ sp<MediaSource> MPEG4Extractor::getTrack(size_t index) {
}
}
sp<MPEG4Source> source = new MPEG4Source(
MPEG4Source *source = new MPEG4Source(
track->meta, mDataSource, track->timescale, track->sampleTable,
mSidxEntries, trex, mMoofOffset, itemTable);
if (source->init() != OK) {
delete source;
return NULL;
}
return source;

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

@ -24,7 +24,7 @@
#include "mpeg2ts/ESQueue.h"
#include <media/DataSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABitReader.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h>
@ -40,7 +40,7 @@
namespace android {
struct MPEG2PSExtractor::Track : public MediaSource {
struct MPEG2PSExtractor::Track : public MediaSourceBase, public RefBase {
Track(MPEG2PSExtractor *extractor,
unsigned stream_id, unsigned stream_type);
@ -72,7 +72,7 @@ private:
DISALLOW_EVIL_CONSTRUCTORS(Track);
};
struct MPEG2PSExtractor::WrappedTrack : public MediaSource {
struct MPEG2PSExtractor::WrappedTrack : public MediaSourceBase {
WrappedTrack(MPEG2PSExtractor *extractor, const sp<Track> &track);
virtual status_t start(MetaData *params);
@ -125,7 +125,7 @@ size_t MPEG2PSExtractor::countTracks() {
return mTracks.size();
}
sp<MediaSource> MPEG2PSExtractor::getTrack(size_t index) {
MediaSourceBase *MPEG2PSExtractor::getTrack(size_t index) {
if (index >= mTracks.size()) {
return NULL;
}

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

@ -24,7 +24,7 @@
#include <media/DataSource.h>
#include <media/IStreamSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/ALooper.h>
@ -49,7 +49,7 @@ static const size_t kTSPacketSize = 188;
static const int kMaxDurationReadSize = 250000LL;
static const int kMaxDurationRetry = 6;
struct MPEG2TSSource : public MediaSource {
struct MPEG2TSSource : public MediaSourceBase {
MPEG2TSSource(
MPEG2TSExtractor *extractor,
const sp<AnotherPacketSource> &impl,
@ -133,7 +133,7 @@ size_t MPEG2TSExtractor::countTracks() {
return mSourceImpls.size();
}
sp<MediaSource> MPEG2TSExtractor::getTrack(size_t index) {
MediaSourceBase *MPEG2TSExtractor::getTrack(size_t index) {
if (index >= mSourceImpls.size()) {
return NULL;
}
@ -470,7 +470,7 @@ uint32_t MPEG2TSExtractor::flags() const {
}
status_t MPEG2TSExtractor::seek(int64_t seekTimeUs,
const MediaSource::ReadOptions::SeekMode &seekMode) {
const MediaSourceBase::ReadOptions::SeekMode &seekMode) {
if (mSeekSyncPoints == NULL || mSeekSyncPoints->isEmpty()) {
ALOGW("No sync point to seek to.");
// ... and therefore we have nothing useful to do here.
@ -491,18 +491,18 @@ status_t MPEG2TSExtractor::seek(int64_t seekTimeUs,
}
switch (seekMode) {
case MediaSource::ReadOptions::SEEK_NEXT_SYNC:
case MediaSourceBase::ReadOptions::SEEK_NEXT_SYNC:
if (index == mSeekSyncPoints->size()) {
ALOGW("Next sync not found; starting from the latest sync.");
--index;
}
break;
case MediaSource::ReadOptions::SEEK_CLOSEST_SYNC:
case MediaSource::ReadOptions::SEEK_CLOSEST:
case MediaSourceBase::ReadOptions::SEEK_CLOSEST_SYNC:
case MediaSourceBase::ReadOptions::SEEK_CLOSEST:
ALOGW("seekMode not supported: %d; falling back to PREVIOUS_SYNC",
seekMode);
// fall-through
case MediaSource::ReadOptions::SEEK_PREVIOUS_SYNC:
case MediaSourceBase::ReadOptions::SEEK_PREVIOUS_SYNC:
if (index == 0) {
ALOGW("Previous sync not found; starting from the earliest "
"sync.");

@ -20,7 +20,7 @@
#include <media/stagefright/foundation/ABase.h>
#include <media/MediaExtractor.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <utils/threads.h>
#include <utils/KeyedVector.h>
#include <utils/Vector.h>
@ -40,7 +40,7 @@ struct MPEG2TSExtractor : public MediaExtractor {
explicit MPEG2TSExtractor(const sp<DataSource> &source);
virtual size_t countTracks();
virtual sp<MediaSource> getTrack(size_t index);
virtual MediaSourceBase *getTrack(size_t index);
virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);
virtual sp<MetaData> getMetaData();

@ -22,7 +22,7 @@
#include <cutils/properties.h>
#include <media/DataSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ABuffer.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/base64.h>
@ -45,7 +45,7 @@ extern "C" {
namespace android {
struct OggSource : public MediaSource {
struct OggSource : public MediaSourceBase {
explicit OggSource(OggExtractor *extractor);
virtual sp<MetaData> getFormat();
@ -1348,7 +1348,7 @@ size_t OggExtractor::countTracks() {
return mInitCheck != OK ? 0 : 1;
}
sp<MediaSource> OggExtractor::getTrack(size_t index) {
MediaSourceBase *OggExtractor::getTrack(size_t index) {
if (index >= 1) {
return NULL;
}

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

@ -22,7 +22,7 @@
#include <audio_utils/primitives.h>
#include <media/DataSource.h>
#include <media/MediaSource.h>
#include <media/MediaSourceBase.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaBufferGroup.h>
#include <media/stagefright/MediaDefs.h>
@ -55,7 +55,7 @@ static uint16_t U16_LE_AT(const uint8_t *ptr) {
return ptr[1] << 8 | ptr[0];
}
struct WAVSource : public MediaSource {
struct WAVSource : public MediaSourceBase {
WAVSource(
const sp<DataSource> &dataSource,
const sp<MetaData> &meta,
@ -120,7 +120,7 @@ size_t WAVExtractor::countTracks() {
return mInitCheck == OK ? 1 : 0;
}
sp<MediaSource> WAVExtractor::getTrack(size_t index) {
MediaSourceBase *WAVExtractor::getTrack(size_t index) {
if (mInitCheck != OK || index > 0) {
return NULL;
}

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

@ -26,6 +26,7 @@ cc_library {
"DataSource.cpp",
"MediaBuffer.cpp",
"MediaBufferGroup.cpp",
"MediaSourceBase.cpp",
"MediaSource.cpp",
"MediaExtractor.cpp",
],

@ -25,45 +25,4 @@ MediaSource::~MediaSource() {}
////////////////////////////////////////////////////////////////////////////////
MediaSource::ReadOptions::ReadOptions() {
reset();
}
void MediaSource::ReadOptions::reset() {
mOptions = 0;
mSeekTimeUs = 0;
mNonBlocking = false;
}
void MediaSource::ReadOptions::setNonBlocking() {
mNonBlocking = true;
}
void MediaSource::ReadOptions::clearNonBlocking() {
mNonBlocking = false;
}
bool MediaSource::ReadOptions::getNonBlocking() const {
return mNonBlocking;
}
void MediaSource::ReadOptions::setSeekTo(int64_t time_us, SeekMode mode) {
mOptions |= kSeekTo_Option;
mSeekTimeUs = time_us;
mSeekMode = mode;
}
void MediaSource::ReadOptions::clearSeekTo() {
mOptions &= ~kSeekTo_Option;
mSeekTimeUs = 0;
mSeekMode = SEEK_CLOSEST_SYNC;
}
bool MediaSource::ReadOptions::getSeekTo(
int64_t *time_us, SeekMode *mode) const {
*time_us = mSeekTimeUs;
*mode = mSeekMode;
return (mOptions & kSeekTo_Option) != 0;
}
} // namespace android

@ -0,0 +1,68 @@
/*
* 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.
*/
#include <media/MediaSourceBase.h>
namespace android {
MediaSourceBase::MediaSourceBase() {}
MediaSourceBase::~MediaSourceBase() {}
////////////////////////////////////////////////////////////////////////////////
MediaSourceBase::ReadOptions::ReadOptions() {
reset();
}
void MediaSourceBase::ReadOptions::reset() {
mOptions = 0;
mSeekTimeUs = 0;
mNonBlocking = false;
}
void MediaSourceBase::ReadOptions::setNonBlocking() {
mNonBlocking = true;
}
void MediaSourceBase::ReadOptions::clearNonBlocking() {
mNonBlocking = false;
}
bool MediaSourceBase::ReadOptions::getNonBlocking() const {
return mNonBlocking;
}
void MediaSourceBase::ReadOptions::setSeekTo(int64_t time_us, SeekMode mode) {
mOptions |= kSeekTo_Option;
mSeekTimeUs = time_us;
mSeekMode = mode;
}
void MediaSourceBase::ReadOptions::clearSeekTo() {
mOptions &= ~kSeekTo_Option;
mSeekTimeUs = 0;
mSeekMode = SEEK_CLOSEST_SYNC;
}
bool MediaSourceBase::ReadOptions::getSeekTo(
int64_t *time_us, SeekMode *mode) const {
*time_us = mSeekTimeUs;
*mode = mSeekMode;
return (mOptions & kSeekTo_Option) != 0;
}
} // namespace android

@ -30,7 +30,7 @@ class DataSource;
class MetaData;
class String8;
struct AMessage;
struct MediaSource;
struct MediaSourceBase;
typedef std::vector<uint8_t> HInterfaceToken;
@ -51,7 +51,7 @@ class MediaExtractor
public:
virtual ~MediaExtractor();
virtual size_t countTracks() = 0;
virtual sp<MediaSource> getTrack(size_t index) = 0;
virtual MediaSourceBase *getTrack(size_t index) = 0;
enum GetTrackMetaDataFlags {
kIncludeExtensiveMetaData = 1

@ -24,105 +24,15 @@
#include <media/stagefright/MetaData.h>
#include <utils/RefBase.h>
#include "media/MediaSourceBase.h"
namespace android {
class MediaBuffer;
struct MediaSource : public virtual RefBase {
struct MediaSource : public MediaSourceBase, public virtual RefBase {
MediaSource();
// To be called before any other methods on this object, except
// getFormat().
virtual status_t start(MetaData *params = NULL) = 0;
// Any blocking read call returns immediately with a result of NO_INIT.
// It is an error to call any methods other than start after this call
// returns. Any buffers the object may be holding onto at the time of
// the stop() call are released.
// Also, it is imperative that any buffers output by this object and
// held onto by callers be released before a call to stop() !!!
virtual status_t stop() = 0;
// Returns the format of the data output by this media source.
virtual sp<MetaData> getFormat() = 0;
// Options that modify read() behaviour. The default is to
// a) not request a seek
// b) not be late, i.e. lateness_us = 0
struct ReadOptions {
enum SeekMode : int32_t {
SEEK_PREVIOUS_SYNC,
SEEK_NEXT_SYNC,
SEEK_CLOSEST_SYNC,
SEEK_CLOSEST,
SEEK_FRAME_INDEX,
};
ReadOptions();
// Reset everything back to defaults.
void reset();
void setSeekTo(int64_t time_us, SeekMode mode = SEEK_CLOSEST_SYNC);
void clearSeekTo();
bool getSeekTo(int64_t *time_us, SeekMode *mode) const;
void setNonBlocking();
void clearNonBlocking();
bool getNonBlocking() const;
// Used to clear all non-persistent options for multiple buffer reads.
void clearNonPersistent() {
clearSeekTo();
}
private:
enum Options {
kSeekTo_Option = 1,
};
uint32_t mOptions;
int64_t mSeekTimeUs;
SeekMode mSeekMode;
bool mNonBlocking;
} __attribute__((packed)); // sent through Binder
// Returns a new buffer of data. Call blocks until a
// buffer is available, an error is encountered of the end of the stream
// is reached.
// End of stream is signalled by a result of ERROR_END_OF_STREAM.
// A result of INFO_FORMAT_CHANGED indicates that the format of this
// MediaSource has changed mid-stream, the client can continue reading
// but should be prepared for buffers of the new configuration.
virtual status_t read(
MediaBuffer **buffer, const ReadOptions *options = NULL) = 0;
// Causes this source to suspend pulling data from its upstream source
// until a subsequent read-with-seek. This is currently not supported
// as such by any source. E.g. MediaCodecSource does not suspend its
// upstream source, and instead discard upstream data while paused.
virtual status_t pause() {
return ERROR_UNSUPPORTED;
}
// The consumer of this media source requests the source stops sending
// buffers with timestamp larger than or equal to stopTimeUs. stopTimeUs
// must be in the same time base as the startTime passed in start(). If
// source does not support this request, ERROR_UNSUPPORTED will be returned.
// If stopTimeUs is invalid, BAD_VALUE will be returned. This could be
// called at any time even before source starts and it could be called
// multiple times. Setting stopTimeUs to be -1 will effectively cancel the stopTimeUs
// set previously. If stopTimeUs is larger than or equal to last buffer's timestamp,
// source will start to drop buffer when it gets a buffer with timestamp larger
// than or equal to stopTimeUs. If stopTimeUs is smaller than or equal to last
// buffer's timestamp, source will drop all the incoming buffers immediately.
// After setting stopTimeUs, source may still stop sending buffers with timestamp
// less than stopTimeUs if it is stopped by the consumer.
virtual status_t setStopTimeUs(int64_t /* stopTimeUs */) {
return ERROR_UNSUPPORTED;
}
protected:
virtual ~MediaSource();
private:

@ -0,0 +1,149 @@
/*
* Copyright (C) 2018 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 MEDIA_SOURCE_BASE_H_
#define MEDIA_SOURCE_BASE_H_
#include <sys/types.h>
#include <binder/IMemory.h>
#include <binder/MemoryDealer.h>
#include <media/stagefright/MediaErrors.h>
#include <media/stagefright/MetaData.h>
#include <utils/RefBase.h>
#include <utils/Vector.h>
namespace android {
class MediaBuffer;
class SourceBaseAllocTracker {
public:
SourceBaseAllocTracker() {
ALOGD("sourcebase allocated: %p", this);
}
virtual ~SourceBaseAllocTracker() {
ALOGD("sourcebase freed: %p", this);
}
};
struct MediaSourceBase
// : public SourceBaseAllocTracker
{
MediaSourceBase();
// To be called before any other methods on this object, except
// getFormat().
virtual status_t start(MetaData *params = NULL) = 0;
// Any blocking read call returns immediately with a result of NO_INIT.
// It is an error to call any methods other than start after this call
// returns. Any buffers the object may be holding onto at the time of
// the stop() call are released.
// Also, it is imperative that any buffers output by this object and
// held onto by callers be released before a call to stop() !!!
virtual status_t stop() = 0;
// Returns the format of the data output by this media source.
virtual sp<MetaData> getFormat() = 0;
// Options that modify read() behaviour. The default is to
// a) not request a seek
// b) not be late, i.e. lateness_us = 0
struct ReadOptions {
enum SeekMode : int32_t {
SEEK_PREVIOUS_SYNC,
SEEK_NEXT_SYNC,
SEEK_CLOSEST_SYNC,
SEEK_CLOSEST,
SEEK_FRAME_INDEX,
};
ReadOptions();
// Reset everything back to defaults.
void reset();
void setSeekTo(int64_t time_us, SeekMode mode = SEEK_CLOSEST_SYNC);
void clearSeekTo();
bool getSeekTo(int64_t *time_us, SeekMode *mode) const;
void setNonBlocking();
void clearNonBlocking();
bool getNonBlocking() const;
// Used to clear all non-persistent options for multiple buffer reads.
void clearNonPersistent() {
clearSeekTo();
}
private:
enum Options {
kSeekTo_Option = 1,
};
uint32_t mOptions;
int64_t mSeekTimeUs;
SeekMode mSeekMode;
bool mNonBlocking;
} __attribute__((packed)); // sent through Binder
// Returns a new buffer of data. Call blocks until a
// buffer is available, an error is encountered of the end of the stream
// is reached.
// End of stream is signalled by a result of ERROR_END_OF_STREAM.
// A result of INFO_FORMAT_CHANGED indicates that the format of this
// MediaSource has changed mid-stream, the client can continue reading
// but should be prepared for buffers of the new configuration.
virtual status_t read(
MediaBuffer **buffer, const ReadOptions *options = NULL) = 0;
// Causes this source to suspend pulling data from its upstream source
// until a subsequent read-with-seek. This is currently not supported
// as such by any source. E.g. MediaCodecSource does not suspend its
// upstream source, and instead discard upstream data while paused.
virtual status_t pause() {
return ERROR_UNSUPPORTED;
}
// The consumer of this media source requests the source stops sending
// buffers with timestamp larger than or equal to stopTimeUs. stopTimeUs
// must be in the same time base as the startTime passed in start(). If
// source does not support this request, ERROR_UNSUPPORTED will be returned.
// If stopTimeUs is invalid, BAD_VALUE will be returned. This could be
// called at any time even before source starts and it could be called
// multiple times. Setting stopTimeUs to be -1 will effectively cancel the stopTimeUs
// set previously. If stopTimeUs is larger than or equal to last buffer's timestamp,
// source will start to drop buffer when it gets a buffer with timestamp larger
// than or equal to stopTimeUs. If stopTimeUs is smaller than or equal to last
// buffer's timestamp, source will drop all the incoming buffers immediately.
// After setting stopTimeUs, source may still stop sending buffers with timestamp
// less than stopTimeUs if it is stopped by the consumer.
virtual status_t setStopTimeUs(int64_t /* stopTimeUs */) {
return ERROR_UNSUPPORTED;
}
virtual ~MediaSourceBase();
private:
MediaSourceBase(const MediaSourceBase &);
MediaSourceBase &operator=(const MediaSourceBase &);
};
} // namespace android
#endif // MEDIA_SOURCE_BASE_H_

@ -52,9 +52,9 @@ sp<MediaSource> CreateMediaSourceFromIMediaSource(const sp<IMediaSource> &source
return new CallbackMediaSource(source);
}
sp<IMediaSource> CreateIMediaSourceFromMediaSource(
sp<IMediaSource> CreateIMediaSourceFromMediaSourceBase(
const sp<RemoteMediaExtractor> &extractor,
const sp<MediaSource> &source, const sp<RefBase> &plugin) {
MediaSourceBase *source, const sp<RefBase> &plugin) {
if (source == nullptr) {
return nullptr;
}

@ -89,9 +89,9 @@ size_t RemoteMediaExtractor::countTracks() {
}
sp<IMediaSource> RemoteMediaExtractor::getTrack(size_t index) {
sp<MediaSource> source = mExtractor->getTrack(index);
return (source.get() == nullptr)
? nullptr : CreateIMediaSourceFromMediaSource(this, source, mExtractorPlugin);
MediaSourceBase *source = mExtractor->getTrack(index);
return (source == nullptr)
? nullptr : CreateIMediaSourceFromMediaSourceBase(this, source, mExtractorPlugin);
}
sp<MetaData> RemoteMediaExtractor::getTrackMetaData(size_t index, uint32_t flags) {

@ -22,14 +22,14 @@ namespace android {
RemoteMediaSource::RemoteMediaSource(
const sp<RemoteMediaExtractor> &extractor,
const sp<MediaSource> &source,
MediaSourceBase *source,
const sp<RefBase> &plugin)
: mExtractor(extractor),
mSource(source),
mExtractorPlugin(plugin) {}
RemoteMediaSource::~RemoteMediaSource() {
mSource = nullptr;
delete mSource;
mExtractorPlugin = nullptr;
}
@ -62,8 +62,8 @@ status_t RemoteMediaSource::setStopTimeUs(int64_t stopTimeUs) {
// static
sp<IMediaSource> RemoteMediaSource::wrap(
const sp<RemoteMediaExtractor> &extractor,
const sp<MediaSource> &source, const sp<RefBase> &plugin) {
if (source.get() == nullptr) {
MediaSourceBase *source, const sp<RefBase> &plugin) {
if (source == nullptr) {
return nullptr;
}
return new RemoteMediaSource(extractor, source, plugin);

@ -47,9 +47,9 @@ sp<IMediaExtractor> CreateIMediaExtractorFromMediaExtractor(
sp<MediaSource> CreateMediaSourceFromIMediaSource(const sp<IMediaSource> &source);
// Creates an IMediaSource wrapper to the given MediaSource.
sp<IMediaSource> CreateIMediaSourceFromMediaSource(
sp<IMediaSource> CreateIMediaSourceFromMediaSourceBase(
const sp<RemoteMediaExtractor> &extractor,
const sp<MediaSource> &source, const sp<RefBase> &plugin);
MediaSourceBase *source, const sp<RefBase> &plugin);
} // namespace android

@ -28,7 +28,7 @@ class RemoteMediaSource : public BnMediaSource {
public:
static sp<IMediaSource> wrap(
const sp<RemoteMediaExtractor> &extractor,
const sp<MediaSource> &source,
MediaSourceBase *source,
const sp<RefBase> &plugin);
virtual ~RemoteMediaSource();
virtual status_t start(MetaData *params = NULL);
@ -42,12 +42,12 @@ public:
private:
sp<RemoteMediaExtractor> mExtractor;
sp<MediaSource> mSource;
MediaSourceBase *mSource;
sp<RefBase> mExtractorPlugin;
explicit RemoteMediaSource(
const sp<RemoteMediaExtractor> &extractor,
const sp<MediaSource> &source,
MediaSourceBase *source,
const sp<RefBase> &plugin);
DISALLOW_EVIL_CONSTRUCTORS(RemoteMediaSource);

Loading…
Cancel
Save