diff --git a/dom/media/MediaDecoder.cpp b/dom/media/MediaDecoder.cpp index dede98f583..b9dd8ddc9c 100644 --- a/dom/media/MediaDecoder.cpp +++ b/dom/media/MediaDecoder.cpp @@ -279,7 +279,6 @@ void MediaDecoder::Pause() MOZ_ASSERT(NS_IsMainThread()); ReentrantMonitorAutoEnter mon(GetReentrantMonitor()); if (mPlayState == PLAY_STATE_LOADING || - mPlayState == PLAY_STATE_SEEKING || IsEnded()) { mNextState = PLAY_STATE_PAUSED; return; @@ -438,6 +437,20 @@ MediaDecoder::OutputStreamData::~OutputStreamData() mListener->Forget(); } +void MediaDecoder::UpdateDecodedStream() +{ + MOZ_ASSERT(NS_IsMainThread()); + GetReentrantMonitor().AssertCurrentThreadIn(); + + if (mDecodedStream) { + bool blockForPlayState = mPlayState != PLAY_STATE_PLAYING || mLogicallySeeking; + if (mDecodedStream->mHaveBlockedForPlayState != blockForPlayState) { + mDecodedStream->mStream->ChangeExplicitBlockerCount(blockForPlayState ? 1 : -1); + mDecodedStream->mHaveBlockedForPlayState = blockForPlayState; + } + } +} + void MediaDecoder::DestroyDecodedStream() { MOZ_ASSERT(NS_IsMainThread()); @@ -604,6 +617,8 @@ MediaDecoder::MediaDecoder() : "MediaDecoder::mPlayState (Canonical)"), mNextState(AbstractThread::MainThread(), PLAY_STATE_PAUSED, "MediaDecoder::mNextState (Canonical)"), + mLogicallySeeking(AbstractThread::MainThread(), false, + "MediaDecoder::mLogicallySeeking (Canonical)"), mIgnoreProgressData(false), mInfiniteStream(false), mOwner(nullptr), @@ -795,7 +810,7 @@ nsresult MediaDecoder::Play() ScheduleStateMachineThread(); if (IsEnded()) { return Seek(0, SeekTarget::PrevSyncPoint); - } else if (mPlayState == PLAY_STATE_LOADING || mPlayState == PLAY_STATE_SEEKING) { + } else if (mPlayState == PLAY_STATE_LOADING) { mNextState = PLAY_STATE_PLAYING; return NS_OK; } @@ -808,6 +823,8 @@ nsresult MediaDecoder::Seek(double aTime, SeekTarget::Type aSeekType) { MOZ_ASSERT(NS_IsMainThread()); ReentrantMonitorAutoEnter mon(GetReentrantMonitor()); + NS_ENSURE_TRUE(!mShuttingDown, NS_ERROR_FAILURE); + UpdateDormantState(false /* aDormantTimeout */, true /* aActivity */); MOZ_ASSERT(aTime >= 0.0, "Cannot seek to a negative value."); @@ -816,23 +833,33 @@ nsresult MediaDecoder::Seek(double aTime, SeekTarget::Type aSeekType) nsresult rv = SecondsToUsecs(aTime, timeUsecs); NS_ENSURE_SUCCESS(rv, rv); - mRequestedSeekTarget = SeekTarget(timeUsecs, aSeekType); mLogicalPosition = aTime; mWasEndedWhenEnteredDormant = false; - // If we are already in the seeking state, the new seek overrides the old one. - if (mPlayState != PLAY_STATE_LOADING) { - mSeekRequest.DisconnectIfExists(); + mLogicallySeeking = true; + UpdateDecodedStream(); + SeekTarget target = SeekTarget(timeUsecs, aSeekType); + CallSeek(target); + + if (mPlayState == PLAY_STATE_ENDED) { bool paused = false; if (mOwner) { paused = mOwner->GetPaused(); } - mNextState = paused ? PLAY_STATE_PAUSED : PLAY_STATE_PLAYING; PinForSeek(); - ChangeState(PLAY_STATE_SEEKING); + ChangeState(paused ? PLAY_STATE_PAUSED : PLAY_STATE_PLAYING); } + return NS_OK; +} - return ScheduleStateMachineThread(); +void MediaDecoder::CallSeek(const SeekTarget& aTarget) +{ + mSeekRequest.DisconnectIfExists(); + mSeekRequest.Begin(ProxyMediaCall(mDecoderStateMachine->TaskQueue(), + mDecoderStateMachine.get(), __func__, + &MediaDecoderStateMachine::Seek, aTarget) + ->Then(AbstractThread::MainThread(), __func__, this, + &MediaDecoder::OnSeekResolved, &MediaDecoder::OnSeekRejected)); } double MediaDecoder::GetCurrentTime() @@ -921,7 +948,6 @@ MediaDecoder::PlayStateStr() case PLAY_STATE_LOADING: return "PLAY_STATE_LOADING"; case PLAY_STATE_PAUSED: return "PLAY_STATE_PAUSED"; case PLAY_STATE_PLAYING: return "PLAY_STATE_PLAYING"; - case PLAY_STATE_SEEKING: return "PLAY_STATE_SEEKING"; case PLAY_STATE_ENDED: return "PLAY_STATE_ENDED"; case PLAY_STATE_SHUTDOWN: return "PLAY_STATE_SHUTDOWN"; default: return "INVALID_PLAY_STATE"; @@ -958,12 +984,7 @@ void MediaDecoder::FirstFrameLoaded(nsAutoPtr aInfo, // state if we're still set to the original // loading state. if (mPlayState == PLAY_STATE_LOADING && !mIsDormant) { - if (mRequestedSeekTarget.IsValid()) { - ChangeState(PLAY_STATE_SEEKING); - } - else { - ChangeState(mNextState); - } + ChangeState(mNextState); } // Run NotifySuspendedStatusChanged now to give us a chance to notice @@ -1027,8 +1048,7 @@ bool MediaDecoder::IsSameOriginMedia() bool MediaDecoder::IsSeeking() const { MOZ_ASSERT(NS_IsMainThread()); - return !mIsDormant && (mPlayState == PLAY_STATE_SEEKING || - (mPlayState == PLAY_STATE_LOADING && mRequestedSeekTarget.IsValid())); + return mLogicallySeeking; } bool MediaDecoder::IsEndedOrShutdown() const @@ -1048,7 +1068,7 @@ void MediaDecoder::PlaybackEnded() MOZ_ASSERT(NS_IsMainThread()); if (mShuttingDown || - mPlayState == PLAY_STATE_SEEKING || + mLogicallySeeking || mPlayState == PLAY_STATE_LOADING) { return; } @@ -1232,24 +1252,19 @@ void MediaDecoder::OnSeekResolved(SeekResolveValue aVal) // An additional seek was requested while the current seek was // in operation. - if (mRequestedSeekTarget.IsValid()) { - ChangeState(PLAY_STATE_SEEKING); - seekWasAborted = true; - } else { - UnpinForSeek(); - fireEnded = aVal.mAtEnd; - if (aVal.mAtEnd) { - ChangeState(PLAY_STATE_ENDED); - } else if (aVal.mEventVisibility != MediaDecoderEventVisibility::Suppressed) { - ChangeState(aVal.mAtEnd ? PLAY_STATE_ENDED : mNextState); - } + UnpinForSeek(); + fireEnded = aVal.mAtEnd; + if (aVal.mAtEnd) { + ChangeState(PLAY_STATE_ENDED); } + mLogicallySeeking = false; + UpdateDecodedStream(); } UpdateLogicalPosition(aVal.mEventVisibility); if (mOwner) { - if (!seekWasAborted && (aVal.mEventVisibility != MediaDecoderEventVisibility::Suppressed)) { + if (aVal.mEventVisibility != MediaDecoderEventVisibility::Suppressed) { mOwner->SeekCompleted(); if (fireEnded) { mOwner->PlaybackEnded(); @@ -1285,34 +1300,18 @@ void MediaDecoder::ChangeState(PlayState aState) return; } - if (mDecodedStream) { - bool blockForPlayState = aState != PLAY_STATE_PLAYING; - if (mDecodedStream->mHaveBlockedForPlayState != blockForPlayState) { - mDecodedStream->mStream->ChangeExplicitBlockerCount(blockForPlayState ? 1 : -1); - mDecodedStream->mHaveBlockedForPlayState = blockForPlayState; - } - } - DECODER_LOG("ChangeState %s => %s", gPlayStateStr[mPlayState], gPlayStateStr[aState]); mPlayState = aState; + UpdateDecodedStream(); + if (mPlayState == PLAY_STATE_PLAYING) { ConstructMediaTracks(); } else if (IsEnded()) { RemoveMediaTracks(); } - // We should move this to the code that actually initiates the seek. - if (mPlayState == PLAY_STATE_SEEKING) { - mSeekRequest.Begin(ProxyMediaCall(mDecoderStateMachine->TaskQueue(), - mDecoderStateMachine.get(), __func__, - &MediaDecoderStateMachine::Seek, mRequestedSeekTarget) - ->Then(AbstractThread::MainThread(), __func__, this, - &MediaDecoder::OnSeekResolved, &MediaDecoder::OnSeekRejected)); - mRequestedSeekTarget.Reset(); - } - ScheduleStateMachineThread(); CancelDormantTimer(); diff --git a/dom/media/MediaDecoder.h b/dom/media/MediaDecoder.h index 7f276aff06..870bc2773b 100644 --- a/dom/media/MediaDecoder.h +++ b/dom/media/MediaDecoder.h @@ -286,7 +286,6 @@ public: PLAY_STATE_LOADING, PLAY_STATE_PAUSED, PLAY_STATE_PLAYING, - PLAY_STATE_SEEKING, PLAY_STATE_ENDED, PLAY_STATE_SHUTDOWN }; @@ -504,6 +503,9 @@ public: * Connects mDecodedStream->mStream to aStream->mStream. */ void ConnectDecodedStreamToOutputStream(OutputStreamData* aStream); + + void UpdateDecodedStream(); + /** * Disconnects mDecodedStream->mStream from all outputs and clears * mDecodedStream. @@ -745,9 +747,6 @@ public: nsAutoPtr aInfo, nsAutoPtr aTags) override; - int64_t GetSeekTime() { return mRequestedSeekTarget.mTime; } - void ResetSeekTime() { mRequestedSeekTarget.Reset(); } - /****** * The following methods must only be called on the main * thread. @@ -793,7 +792,11 @@ public: // Call on the main thread only. void PlaybackEnded(); - void OnSeekRejected() { mSeekRequest.Complete(); } + void OnSeekRejected() + { + mSeekRequest.Complete(); + mLogicallySeeking = false; + } void OnSeekResolved(SeekResolveValue aVal); // Seeking has started. Inform the element on the main @@ -1137,19 +1140,16 @@ protected: // Any change to the state must call NotifyAll on the monitor. // This can only be PLAY_STATE_PAUSED or PLAY_STATE_PLAYING. Canonical mNextState; + + // True if the decoder is seeking. + Canonical mLogicallySeeking; public: AbstractCanonical* CanonicalPlayState() { return &mPlayState; } AbstractCanonical* CanonicalNextPlayState() { return &mNextState; } + AbstractCanonical* CanonicalLogicallySeeking() { return &mLogicallySeeking; } protected: - // Position to seek to when the seek notification is received by the - // decode thread. - // This can only be changed on the main thread while holding the decoder - // monitor. Thus, it can be safely read while holding the decoder monitor - // OR on the main thread. - // If the SeekTarget's IsValid() accessor returns false, then no seek has - // been requested. When a seek is started this is reset to invalid. - SeekTarget mRequestedSeekTarget; + virtual void CallSeek(const SeekTarget& aTarget); MediaPromiseRequestHolder mSeekRequest; diff --git a/dom/media/MediaDecoderStateMachine.cpp b/dom/media/MediaDecoderStateMachine.cpp index f3475d9ca3..8480e24f05 100644 --- a/dom/media/MediaDecoderStateMachine.cpp +++ b/dom/media/MediaDecoderStateMachine.cpp @@ -211,6 +211,8 @@ MediaDecoderStateMachine::MediaDecoderStateMachine(MediaDecoder* aDecoder, "MediaDecoderStateMachine::mPlayState (Mirror)"), mNextPlayState(mTaskQueue, MediaDecoder::PLAY_STATE_PAUSED, "MediaDecoderStateMachine::mNextPlayState (Mirror)"), + mLogicallySeeking(mTaskQueue, false, + "MediaDecoderStateMachine::mLogicallySeeking (Mirror)"), mNextFrameStatus(mTaskQueue, MediaDecoderOwner::NEXT_FRAME_UNINITIALIZED, "MediaDecoderStateMachine::mNextFrameStatus (Canonical)"), mFragmentEndTime(-1), @@ -304,6 +306,7 @@ MediaDecoderStateMachine::InitializationTask() // Connect mirrors. mPlayState.Connect(mDecoder->CanonicalPlayState()); mNextPlayState.Connect(mDecoder->CanonicalNextPlayState()); + mLogicallySeeking.Connect(mDecoder->CanonicalLogicallySeeking()); mVolume.Connect(mDecoder->CanonicalVolume()); mLogicalPlaybackRate.Connect(mDecoder->CanonicalPlaybackRate()); mPreservesPitch.Connect(mDecoder->CanonicalPreservesPitch()); @@ -315,6 +318,7 @@ MediaDecoderStateMachine::InitializationTask() mWatchManager.Watch(mLogicalPlaybackRate, &MediaDecoderStateMachine::LogicalPlaybackRateChanged); mWatchManager.Watch(mPreservesPitch, &MediaDecoderStateMachine::PreservesPitchChanged); mWatchManager.Watch(mPlayState, &MediaDecoderStateMachine::PlayStateChanged); + mWatchManager.Watch(mLogicallySeeking, &MediaDecoderStateMachine::LogicallySeekingChanged); } bool MediaDecoderStateMachine::HasFutureAudio() { @@ -1648,6 +1652,13 @@ void MediaDecoderStateMachine::PlayStateChanged() ScheduleStateMachine(); } +void MediaDecoderStateMachine::LogicallySeekingChanged() +{ + MOZ_ASSERT(OnTaskQueue()); + ReentrantMonitorAutoEnter mon(mDecoder->GetReentrantMonitor()); + ScheduleStateMachine(); +} + void MediaDecoderStateMachine::NotifyDataArrived(const char* aBuffer, uint32_t aLength, int64_t aOffset) @@ -2514,6 +2525,7 @@ MediaDecoderStateMachine::FinishShutdown() // Disconnect canonicals and mirrors before shutting down our task queue. mPlayState.DisconnectIfConnected(); mNextPlayState.DisconnectIfConnected(); + mLogicallySeeking.DisconnectIfConnected(); mVolume.DisconnectIfConnected(); mLogicalPlaybackRate.DisconnectIfConnected(); mPreservesPitch.DisconnectIfConnected(); @@ -2634,6 +2646,7 @@ nsresult MediaDecoderStateMachine::RunStateMachine() AdvanceFrame(); NS_ASSERTION(mPlayState != MediaDecoder::PLAY_STATE_PLAYING || + mLogicallySeeking || IsStateMachineScheduled() || mPlaybackRate == 0.0, "Must have timer scheduled"); return NS_OK; @@ -2702,6 +2715,7 @@ nsresult MediaDecoderStateMachine::RunStateMachine() { AdvanceFrame(); NS_ASSERTION(mPlayState != MediaDecoder::PLAY_STATE_PLAYING || + mLogicallySeeking || mPlaybackRate == 0 || IsStateMachineScheduled(), "Must have timer scheduled"); return NS_OK; @@ -2903,7 +2917,7 @@ void MediaDecoderStateMachine::AdvanceFrame() NS_ASSERTION(!HasAudio() || mAudioStartTime != -1, "Should know audio start time if we have audio."); - if (mPlayState != MediaDecoder::PLAY_STATE_PLAYING) { + if (mPlayState != MediaDecoder::PLAY_STATE_PLAYING || mLogicallySeeking) { return; } diff --git a/dom/media/MediaDecoderStateMachine.h b/dom/media/MediaDecoderStateMachine.h index 5ac83c31ca..f16644b9b0 100644 --- a/dom/media/MediaDecoderStateMachine.h +++ b/dom/media/MediaDecoderStateMachine.h @@ -571,6 +571,9 @@ protected: // Notification method invoked when mPlayState changes. void PlayStateChanged(); + // Notification method invoked when mLogicallySeeking changes. + void LogicallySeekingChanged(); + // Sets internal state which causes playback of media to pause. // The decoder monitor must be held. void StopPlayback(); @@ -882,6 +885,7 @@ public: // The current play state and next play state, mirrored from the main thread. Mirror mPlayState; Mirror mNextPlayState; + Mirror mLogicallySeeking; // Returns true if we're logically playing, that is, if the Play() has // been called and Pause() has not or we have not yet reached the end diff --git a/dom/media/omx/AudioOffloadPlayer.cpp b/dom/media/omx/AudioOffloadPlayer.cpp index 03c723b37d..77f5d932cc 100644 --- a/dom/media/omx/AudioOffloadPlayer.cpp +++ b/dom/media/omx/AudioOffloadPlayer.cpp @@ -687,7 +687,7 @@ nsresult AudioOffloadPlayer::StopTimeUpdate() MediaDecoderOwner::NextFrameStatus AudioOffloadPlayer::GetNextFrameStatus() { MOZ_ASSERT(NS_IsMainThread()); - if (mPlayState == MediaDecoder::PLAY_STATE_SEEKING) { + if (mSeekTarget.IsValid()) { return MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_SEEKING; } else if (mPlayState == MediaDecoder::PLAY_STATE_ENDED) { return MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE; diff --git a/dom/media/omx/MediaOmxCommonDecoder.cpp b/dom/media/omx/MediaOmxCommonDecoder.cpp index d4e2d1f006..a7217a0b2b 100644 --- a/dom/media/omx/MediaOmxCommonDecoder.cpp +++ b/dom/media/omx/MediaOmxCommonDecoder.cpp @@ -84,17 +84,26 @@ MediaOmxCommonDecoder::FirstFrameLoaded(nsAutoPtr aInfo, mAudioOffloadPlayer->SetSource(mReader->GetAudioOffloadTrack()); status_t err = mAudioOffloadPlayer->Start(false); - if (err == OK) { - PauseStateMachine(); - // Call ChangeState() to run AudioOffloadPlayer since offload state enabled - ChangeState(mPlayState); + if (err != OK) { + mAudioOffloadPlayer = nullptr; + mFallbackToStateMachine = true; + DECODER_LOG(PR_LOG_DEBUG, ("In %s Unable to start offload audio %d." + "Switching to normal mode", __PRETTY_FUNCTION__, err)); return; } - mAudioOffloadPlayer = nullptr; - mFallbackToStateMachine = true; - DECODER_LOG(PR_LOG_DEBUG, ("In %s Unable to start offload audio %d." - "Switching to normal mode", __PRETTY_FUNCTION__, err)); + PauseStateMachine(); + if (mLogicallySeeking) { + SeekTarget target = SeekTarget(mLogicalPosition, + SeekTarget::Accurate, + MediaDecoderEventVisibility::Observable); + mSeekRequest.DisconnectIfExists(); + mSeekRequest.Begin(mAudioOffloadPlayer->Seek(target) + ->RefableThen(AbstractThread::MainThread(), __func__, static_cast(this), + &MediaDecoder::OnSeekResolved, &MediaDecoder::OnSeekRejected)); + } + // Call ChangeState() to run AudioOffloadPlayer since offload state enabled + ChangeState(mPlayState); } void @@ -137,9 +146,9 @@ MediaOmxCommonDecoder::ResumeStateMachine() mFallbackToStateMachine = true; mAudioOffloadPlayer = nullptr; - mRequestedSeekTarget = SeekTarget(mLogicalPosition, - SeekTarget::Accurate, - MediaDecoderEventVisibility::Suppressed); + SeekTarget target = SeekTarget(mLogicalPosition, + SeekTarget::Accurate, + MediaDecoderEventVisibility::Suppressed); mNextState = mPlayState; ChangeState(PLAY_STATE_LOADING); // exit dormant state @@ -209,31 +218,20 @@ MediaOmxCommonDecoder::ChangeState(PlayState aState) ResumeStateMachine(); return; } - - switch (mPlayState) { - case PLAY_STATE_SEEKING: - mSeekRequest.Begin(mAudioOffloadPlayer->Seek(mRequestedSeekTarget) - ->Then(AbstractThread::MainThread(), __func__, static_cast(this), - &MediaDecoder::OnSeekResolved, &MediaDecoder::OnSeekRejected)); - mRequestedSeekTarget.Reset(); - break; - default: { - break; - } - } } void -MediaOmxCommonDecoder::ApplyStateToStateMachine(PlayState aState) +MediaOmxCommonDecoder::CallSeek(const SeekTarget& aTarget) { - MOZ_ASSERT(NS_IsMainThread()); - // During offload playback, state machine should be in dormant state. - // ApplyStateToStateMachine() can change state machine state to - // something else or reset the seek time. So don't call this when audio is - // offloaded if (!mAudioOffloadPlayer) { - MediaDecoder::ApplyStateToStateMachine(aState); + MediaDecoder::CallSeek(aTarget); + return; } + + mSeekRequest.DisconnectIfExists(); + mSeekRequest.Begin(mAudioOffloadPlayer->Seek(aTarget) + ->Then(AbstractThread::MainThread(), __func__, static_cast(this), + &MediaDecoder::OnSeekResolved, &MediaDecoder::OnSeekRejected)); } int64_t diff --git a/dom/media/omx/MediaOmxCommonDecoder.h b/dom/media/omx/MediaOmxCommonDecoder.h index ebed0737f4..c06fd90e5d 100644 --- a/dom/media/omx/MediaOmxCommonDecoder.h +++ b/dom/media/omx/MediaOmxCommonDecoder.h @@ -24,22 +24,22 @@ public: MediaOmxCommonDecoder(); virtual void FirstFrameLoaded(nsAutoPtr aInfo, - MediaDecoderEventVisibility aEventVisibility); - virtual void ChangeState(PlayState aState); - virtual void ApplyStateToStateMachine(PlayState aState); - virtual void SetVolume(double aVolume); + MediaDecoderEventVisibility aEventVisibility) override; + virtual void ChangeState(PlayState aState) override; + virtual void CallSeek(const SeekTarget& aTarget) override; + virtual void SetVolume(double aVolume) override; virtual int64_t CurrentPosition() override; virtual MediaDecoderOwner::NextFrameStatus NextFrameStatus() override; - virtual void SetElementVisibility(bool aIsVisible); - virtual void SetPlatformCanOffloadAudio(bool aCanOffloadAudio); - virtual bool CheckDecoderCanOffloadAudio(); + virtual void SetElementVisibility(bool aIsVisible) override; + virtual void SetPlatformCanOffloadAudio(bool aCanOffloadAudio) override; + virtual bool CheckDecoderCanOffloadAudio() override; virtual void AddOutputStream(ProcessedMediaStream* aStream, - bool aFinishWhenEnded); - virtual void SetPlaybackRate(double aPlaybackRate); + bool aFinishWhenEnded) override; + virtual void SetPlaybackRate(double aPlaybackRate) override; void AudioOffloadTearDown(); - virtual MediaDecoderStateMachine* CreateStateMachine(); + virtual MediaDecoderStateMachine* CreateStateMachine() override; virtual MediaOmxCommonReader* CreateReader() = 0; virtual MediaDecoderStateMachine* CreateStateMachineFromReader(MediaOmxCommonReader* aReader) = 0; diff --git a/dom/media/omx/RtspMediaCodecDecoder.cpp b/dom/media/omx/RtspMediaCodecDecoder.cpp index b65dbc4624..680df8fd00 100644 --- a/dom/media/omx/RtspMediaCodecDecoder.cpp +++ b/dom/media/omx/RtspMediaCodecDecoder.cpp @@ -32,15 +32,15 @@ RtspMediaCodecDecoder::CreateStateMachineFromReader(MediaOmxCommonReader* aReade } void -RtspMediaCodecDecoder::ApplyStateToStateMachine(PlayState aState) +RtspMediaCodecDecoder::ChangeState(PlayState aState) { MOZ_ASSERT(NS_IsMainThread()); - MediaDecoder::ApplyStateToStateMachine(aState); + MediaDecoder::ChangeState(aState); // Notify RTSP controller if the play state is ended. // This is necessary for RTSP controller to transit its own state. - if (aState == PLAY_STATE_ENDED) { + if (mPlayState == PLAY_STATE_ENDED) { nsRefPtr resource = mResource->GetRtspPointer(); if (resource) { nsIStreamingProtocolController* controller = diff --git a/dom/media/omx/RtspMediaCodecDecoder.h b/dom/media/omx/RtspMediaCodecDecoder.h index 896985d27b..746eb74333 100644 --- a/dom/media/omx/RtspMediaCodecDecoder.h +++ b/dom/media/omx/RtspMediaCodecDecoder.h @@ -20,7 +20,7 @@ public: virtual MediaDecoderStateMachine* CreateStateMachineFromReader(MediaOmxCommonReader* aReader) override; - virtual void ApplyStateToStateMachine(PlayState aState) override; + virtual void ChangeState(PlayState aState) override; }; } // namespace mozilla diff --git a/dom/media/omx/RtspOmxDecoder.cpp b/dom/media/omx/RtspOmxDecoder.cpp index cf70be21e8..7b083e36cc 100644 --- a/dom/media/omx/RtspOmxDecoder.cpp +++ b/dom/media/omx/RtspOmxDecoder.cpp @@ -16,22 +16,24 @@ MediaDecoder* RtspOmxDecoder::Clone() return new RtspOmxDecoder(); } -MediaDecoderStateMachine* RtspOmxDecoder::CreateStateMachine() +MediaDecoderStateMachine* +RtspOmxDecoder::CreateStateMachine() { return new MediaDecoderStateMachine(this, new RtspOmxReader(this), mResource->IsRealTime()); } -void RtspOmxDecoder::ApplyStateToStateMachine(PlayState aState) +void +RtspOmxDecoder::ChangeState(PlayState aState) { MOZ_ASSERT(NS_IsMainThread()); - MediaDecoder::ApplyStateToStateMachine(aState); + MediaDecoder::ChangeState(aState); // Notify RTSP controller if the play state is ended. // This is necessary for RTSP controller to transit its own state. - if (aState == PLAY_STATE_ENDED) { + if (mPlayState == PLAY_STATE_ENDED) { nsRefPtr resource = mResource->GetRtspPointer(); if (resource) { nsIStreamingProtocolController* controller = diff --git a/dom/media/omx/RtspOmxDecoder.h b/dom/media/omx/RtspOmxDecoder.h index 852aac5d9e..384a5b5efc 100644 --- a/dom/media/omx/RtspOmxDecoder.h +++ b/dom/media/omx/RtspOmxDecoder.h @@ -32,8 +32,7 @@ public: virtual MediaDecoder* Clone() override final; virtual MediaDecoderStateMachine* CreateStateMachine() override final; - virtual void ApplyStateToStateMachine(PlayState aState) - override final; + virtual void ChangeState(PlayState aState) override final; }; } // namespace mozilla