Bug 1318225 - Part2 - Remove demux-only APIs.
MozReview-Commit-ID: ONS7mMr8mZ
--- a/dom/media/MediaDecoderReader.h
+++ b/dom/media/MediaDecoderReader.h
@@ -147,24 +147,16 @@ public:
// they notify the state machine when the data arrives.
virtual bool IsWaitForDataSupported() const { return false; }
virtual RefPtr<WaitForDataPromise> WaitForData(MediaData::Type aType)
{
MOZ_CRASH();
}
- // By default, the reader return the decoded data. Some readers support
- // retuning demuxed data.
- virtual bool IsDemuxOnlySupported() const { return false; }
-
- // Configure the reader to return demuxed or decoded data
- // upon calls to Request{Audio,Video}Data.
- virtual void SetDemuxOnly(bool /*aDemuxedOnly*/) {}
-
// The default implementation of AsyncReadMetadata is implemented in terms of
// synchronous ReadMetadata() calls. Implementations may also
// override AsyncReadMetadata to create a more proper async implementation.
virtual RefPtr<MetadataPromise> AsyncReadMetadata();
// Fills aInfo with the latest cached data required to present the media,
// ReadUpdatedMetadata will always be called once ReadMetadata has succeeded.
virtual void ReadUpdatedMetadata(MediaInfo* aInfo) {}
--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -482,23 +482,23 @@ public:
State GetState() const override
{
return DECODER_STATE_DECODING_FIRSTFRAME;
}
void HandleAudioDecoded(MediaData* aAudio) override
{
- mMaster->Push(aAudio, MediaData::AUDIO_DATA);
+ mMaster->Push(aAudio);
MaybeFinishDecodeFirstFrame();
}
void HandleVideoDecoded(MediaData* aVideo, TimeStamp aDecodeStart) override
{
- mMaster->Push(aVideo, MediaData::VIDEO_DATA);
+ mMaster->Push(aVideo);
MaybeFinishDecodeFirstFrame();
}
void HandleEndOfStream() override
{
MaybeFinishDecodeFirstFrame();
}
@@ -579,23 +579,23 @@ public:
State GetState() const override
{
return DECODER_STATE_DECODING;
}
void HandleAudioDecoded(MediaData* aAudio) override
{
- mMaster->Push(aAudio, MediaData::AUDIO_DATA);
+ mMaster->Push(aAudio);
MaybeStopPrerolling();
}
void HandleVideoDecoded(MediaData* aVideo, TimeStamp aDecodeStart) override
{
- mMaster->Push(aVideo, MediaData::VIDEO_DATA);
+ mMaster->Push(aVideo);
MaybeStopPrerolling();
CheckSlowDecoding(aDecodeStart);
}
void HandleEndOfStream() override;
void HandleWaitingForData() override
{
@@ -873,23 +873,23 @@ public:
}
private:
void OnSeekTaskResolved(const SeekTaskResolveValue& aValue)
{
mSeekTaskRequest.Complete();
if (aValue.mSeekedAudioData) {
- mMaster->Push(aValue.mSeekedAudioData, MediaData::AUDIO_DATA);
+ mMaster->Push(aValue.mSeekedAudioData);
mMaster->mDecodedAudioEndTime = std::max(
aValue.mSeekedAudioData->GetEndTime(), mMaster->mDecodedAudioEndTime);
}
if (aValue.mSeekedVideoData) {
- mMaster->Push(aValue.mSeekedVideoData, MediaData::VIDEO_DATA);
+ mMaster->Push(aValue.mSeekedVideoData);
mMaster->mDecodedVideoEndTime = std::max(
aValue.mSeekedVideoData->GetEndTime(), mMaster->mDecodedVideoEndTime);
}
if (aValue.mIsAudioQueueFinished) {
AudioQueue().Finish();
}
@@ -962,25 +962,25 @@ public:
{
return DECODER_STATE_BUFFERING;
}
void HandleAudioDecoded(MediaData* aAudio) override
{
// This might be the sample we need to exit buffering.
// Schedule Step() to check it.
- mMaster->Push(aAudio, MediaData::AUDIO_DATA);
+ mMaster->Push(aAudio);
mMaster->ScheduleStateMachine();
}
void HandleVideoDecoded(MediaData* aVideo, TimeStamp aDecodeStart) override
{
// This might be the sample we need to exit buffering.
// Schedule Step() to check it.
- mMaster->Push(aVideo, MediaData::VIDEO_DATA);
+ mMaster->Push(aVideo);
mMaster->ScheduleStateMachine();
}
void HandleEndOfStream() override;
void HandleVideoSuspendTimeout() override
{
if (mMaster->HasVideo()) {
@@ -1925,35 +1925,34 @@ MediaDecoderStateMachine::OnAudioDecoded
mDecodedAudioEndTime = std::max(aAudio->GetEndTime(), mDecodedAudioEndTime);
SAMPLE_LOG("OnAudioDecoded [%lld,%lld]", aAudio->mTime, aAudio->GetEndTime());
mStateObj->HandleAudioDecoded(aAudio);
}
void
-MediaDecoderStateMachine::Push(MediaData* aSample, MediaData::Type aSampleType)
+MediaDecoderStateMachine::Push(MediaData* aSample)
{
MOZ_ASSERT(OnTaskQueue());
MOZ_ASSERT(aSample);
if (aSample->mType == MediaData::AUDIO_DATA) {
// TODO: Send aSample to MSG and recalculate readystate before pushing,
// otherwise AdvanceFrame may pop the sample before we have a chance
// to reach playing.
AudioQueue().Push(aSample);
} else if (aSample->mType == MediaData::VIDEO_DATA) {
// TODO: Send aSample to MSG and recalculate readystate before pushing,
// otherwise AdvanceFrame may pop the sample before we have a chance
// to reach playing.
aSample->As<VideoData>()->mFrameID = ++mCurrentFrameID;
VideoQueue().Push(aSample);
- } else {
- // TODO: Handle MediaRawData, determine which queue should be pushed.
}
+
DispatchDecodeTasksIfNeeded();
}
void
MediaDecoderStateMachine::OnAudioPopped(const RefPtr<MediaData>& aSample)
{
MOZ_ASSERT(OnTaskQueue());
--- a/dom/media/MediaDecoderStateMachine.h
+++ b/dom/media/MediaDecoderStateMachine.h
@@ -321,18 +321,16 @@ private:
// True if shutdown process has begun.
bool IsShutdown() const;
// Returns true if we're currently playing. The decoder monitor must
// be held.
bool IsPlaying() const;
- // TODO: Those callback function may receive demuxed-only data.
- // Need to figure out a suitable API name for this case.
void OnAudioDecoded(MediaData* aAudio);
void OnVideoDecoded(MediaData* aVideo, TimeStamp aDecodeStartTime);
void OnNotDecoded(MediaData::Type aType, const MediaResult& aError);
// Resets all state related to decoding and playback, emptying all buffers
// and aborting all pending operations on the decode task queue.
void Reset(TrackSet aTracks = TrackSet(TrackInfo::kAudioTrack,
TrackInfo::kVideoTrack));
@@ -341,18 +339,17 @@ protected:
virtual ~MediaDecoderStateMachine();
void BufferedRangeUpdated();
void ReaderSuspendedChanged();
// Inserts MediaData* samples into their respective MediaQueues.
// aSample must not be null.
-
- void Push(MediaData* aSample, MediaData::Type aSampleType);
+ void Push(MediaData* aSample);
void OnAudioPopped(const RefPtr<MediaData>& aSample);
void OnVideoPopped(const RefPtr<MediaData>& aSample);
void AudioAudibleChanged(bool aAudible);
void VolumeChanged();
void SetPlaybackRate(double aPlaybackRate);
--- a/dom/media/MediaFormatReader.cpp
+++ b/dom/media/MediaFormatReader.cpp
@@ -432,17 +432,16 @@ MediaFormatReader::MediaFormatReader(Abs
, mVideo(this, MediaData::VIDEO_DATA,
Preferences::GetUint("media.video-max-decode-error", 2))
, mDemuxer(aDemuxer)
, mDemuxerInitDone(false)
, mLastReportedNumDecodedFrames(0)
, mPreviousDecodedKeyframeTime_us(sNoPreviousDecodedKeyframe)
, mInitDone(false)
, mTrackDemuxersMayBlock(false)
- , mDemuxOnly(false)
, mSeekScheduled(false)
, mVideoFrameContainer(aVideoFrameContainer)
, mDecoderFactory(new DecoderFactory(this))
{
MOZ_ASSERT(aDemuxer);
MOZ_COUNT_CTOR(MediaFormatReader);
if (aDecoder && aDecoder->CompositorUpdatedEvent()) {
@@ -1323,28 +1322,19 @@ MediaFormatReader::HandleDemuxedSamples(
sample->mTime, sample->mTimecode, sample->mKeyframe);
decoder.mOutputRequested = true;
decoder.mNumSamplesInput++;
decoder.mSizeOfQueue++;
if (aTrack == TrackInfo::kVideoTrack) {
aA.mStats.mParsedFrames++;
}
- if (mDemuxOnly) {
- ReturnOutput(sample, aTrack);
- } else {
- DecodeDemuxedSamples(aTrack, sample);
- }
+ DecodeDemuxedSamples(aTrack, sample);
decoder.mQueuedSamples.RemoveElementAt(0);
- if (mDemuxOnly) {
- // If demuxed-only case, ReturnOutput will resolve with one demuxed data.
- // Then we should stop doing the iteration.
- return;
- }
samplesPending = true;
}
}
void
MediaFormatReader::InternalSeek(TrackType aTrack, const InternalSeekTarget& aTarget)
{
MOZ_ASSERT(OnTaskQueue());
@@ -1635,39 +1625,35 @@ void
MediaFormatReader::ReturnOutput(MediaData* aData, TrackType aTrack)
{
MOZ_ASSERT(GetDecoderData(aTrack).HasPromise());
MOZ_DIAGNOSTIC_ASSERT(aData->mType != MediaData::NULL_DATA);
LOG("Resolved data promise for %s [%lld, %lld]", TrackTypeToStr(aTrack),
aData->mTime, aData->GetEndTime());
if (aTrack == TrackInfo::kAudioTrack) {
- if (aData->mType != MediaData::RAW_DATA) {
- AudioData* audioData = static_cast<AudioData*>(aData);
+ AudioData* audioData = static_cast<AudioData*>(aData);
- if (audioData->mChannels != mInfo.mAudio.mChannels ||
- audioData->mRate != mInfo.mAudio.mRate) {
- LOG("change of audio format (rate:%d->%d). "
- "This is an unsupported configuration",
- mInfo.mAudio.mRate, audioData->mRate);
- mInfo.mAudio.mRate = audioData->mRate;
- mInfo.mAudio.mChannels = audioData->mChannels;
- }
+ if (audioData->mChannels != mInfo.mAudio.mChannels ||
+ audioData->mRate != mInfo.mAudio.mRate) {
+ LOG("change of audio format (rate:%d->%d). "
+ "This is an unsupported configuration",
+ mInfo.mAudio.mRate, audioData->mRate);
+ mInfo.mAudio.mRate = audioData->mRate;
+ mInfo.mAudio.mChannels = audioData->mChannels;
}
mAudio.ResolvePromise(aData, __func__);
} else if (aTrack == TrackInfo::kVideoTrack) {
- if (aData->mType != MediaData::RAW_DATA) {
- VideoData* videoData = static_cast<VideoData*>(aData);
+ VideoData* videoData = static_cast<VideoData*>(aData);
- if (videoData->mDisplay != mInfo.mVideo.mDisplay) {
- LOG("change of video display size (%dx%d->%dx%d)",
- mInfo.mVideo.mDisplay.width, mInfo.mVideo.mDisplay.height,
- videoData->mDisplay.width, videoData->mDisplay.height);
- mInfo.mVideo.mDisplay = videoData->mDisplay;
- }
+ if (videoData->mDisplay != mInfo.mVideo.mDisplay) {
+ LOG("change of video display size (%dx%d->%dx%d)",
+ mInfo.mVideo.mDisplay.width, mInfo.mVideo.mDisplay.height,
+ videoData->mDisplay.width, videoData->mDisplay.height);
+ mInfo.mVideo.mDisplay = videoData->mDisplay;
}
mVideo.ResolvePromise(aData, __func__);
}
}
size_t
MediaFormatReader::SizeOfVideoQueueInFrames()
{
--- a/dom/media/MediaFormatReader.h
+++ b/dom/media/MediaFormatReader.h
@@ -69,30 +69,16 @@ public:
bool IsAsync() const override { return true; }
bool VideoIsHardwareAccelerated() const override;
bool IsWaitForDataSupported() const override { return true; }
RefPtr<WaitForDataPromise> WaitForData(MediaData::Type aType) override;
- // MediaFormatReader supports demuxed-only mode.
- bool IsDemuxOnlySupported() const override { return true; }
-
- void SetDemuxOnly(bool aDemuxedOnly) override
- {
- if (OnTaskQueue()) {
- mDemuxOnly = aDemuxedOnly;
- return;
- }
- nsCOMPtr<nsIRunnable> r = NewRunnableMethod<bool>(
- this, &MediaDecoderReader::SetDemuxOnly, aDemuxedOnly);
- OwnerThread()->Dispatch(r.forget());
- }
-
bool UseBufferingHeuristics() const override
{
return mTrackDemuxersMayBlock;
}
void SetCDMProxy(CDMProxy* aProxy) override;
// Returns a string describing the state of the decoder data.
@@ -543,19 +529,16 @@ private:
// True if we've read the streams' metadata.
bool mInitDone;
MozPromiseHolder<MetadataPromise> mMetadataPromise;
bool IsEncrypted() const;
// Set to true if any of our track buffers may be blocking.
bool mTrackDemuxersMayBlock;
- // Set the demuxed-only flag.
- Atomic<bool> mDemuxOnly;
-
// Seeking objects.
void SetSeekTarget(const SeekTarget& aTarget);
bool IsSeeking() const { return mPendingSeekTime.isSome(); }
bool IsVideoSeeking() const
{
return IsSeeking() && mOriginalSeekTarget.IsVideoOnly();
}
void ScheduleSeek();