diff options
Diffstat (limited to 'dom/media/MediaDecoder.cpp')
| -rw-r--r-- | dom/media/MediaDecoder.cpp | 1681 |
1 files changed, 1681 insertions, 0 deletions
diff --git a/dom/media/MediaDecoder.cpp b/dom/media/MediaDecoder.cpp new file mode 100644 index 0000000000..f7a8d4e644 --- /dev/null +++ b/dom/media/MediaDecoder.cpp @@ -0,0 +1,1681 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "MediaDecoder.h" + +#include "AudioDeviceInfo.h" +#include "DOMMediaStream.h" +#include "DecoderBenchmark.h" +#include "ImageContainer.h" +#include "MediaDecoderStateMachineBase.h" +#include "MediaFormatReader.h" +#include "MediaResource.h" +#include "MediaShutdownManager.h" +#include "MediaTrackGraph.h" +#include "TelemetryProbesReporter.h" +#include "VideoFrameContainer.h" +#include "VideoUtils.h" +#include "mozilla/AbstractThread.h" +#include "mozilla/dom/DOMTypes.h" +#include "mozilla/FloatingPoint.h" +#include "mozilla/MathAlgorithms.h" +#include "mozilla/Preferences.h" +#include "mozilla/StaticPrefs_media.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/Telemetry.h" +#include "mozilla/Unused.h" +#include "nsComponentManagerUtils.h" +#include "nsContentUtils.h" +#include "nsError.h" +#include "nsIMemoryReporter.h" +#include "nsPrintfCString.h" +#include "nsServiceManagerUtils.h" +#include "nsTArray.h" +#include "WindowRenderer.h" +#include <algorithm> +#include <cmath> +#include <limits> + +using namespace mozilla::dom; +using namespace mozilla::layers; +using namespace mozilla::media; + +namespace mozilla { + +// avoid redefined macro in unified build +#undef LOG +#undef DUMP + +LazyLogModule gMediaDecoderLog("MediaDecoder"); + +#define LOG(x, ...) \ + DDMOZ_LOG(gMediaDecoderLog, LogLevel::Debug, x, ##__VA_ARGS__) + +#define DUMP(x, ...) printf_stderr(x "\n", ##__VA_ARGS__) + +#define NS_DispatchToMainThread(...) CompileError_UseAbstractMainThreadInstead + +static const char* ToPlayStateStr(MediaDecoder::PlayState aState) { + switch (aState) { + case MediaDecoder::PLAY_STATE_LOADING: + return "LOADING"; + case MediaDecoder::PLAY_STATE_PAUSED: + return "PAUSED"; + case MediaDecoder::PLAY_STATE_PLAYING: + return "PLAYING"; + case MediaDecoder::PLAY_STATE_ENDED: + return "ENDED"; + case MediaDecoder::PLAY_STATE_SHUTDOWN: + return "SHUTDOWN"; + default: + MOZ_ASSERT_UNREACHABLE("Invalid playState."); + } + return "UNKNOWN"; +} + +class MediaMemoryTracker : public nsIMemoryReporter { + virtual ~MediaMemoryTracker(); + + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIMEMORYREPORTER + + MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf); + + MediaMemoryTracker(); + void InitMemoryReporter(); + + static StaticRefPtr<MediaMemoryTracker> sUniqueInstance; + + static MediaMemoryTracker* UniqueInstance() { + if (!sUniqueInstance) { + sUniqueInstance = new MediaMemoryTracker(); + sUniqueInstance->InitMemoryReporter(); + } + return sUniqueInstance; + } + + using DecodersArray = nsTArray<MediaDecoder*>; + static DecodersArray& Decoders() { return UniqueInstance()->mDecoders; } + + DecodersArray mDecoders; + + public: + static void AddMediaDecoder(MediaDecoder* aDecoder) { + Decoders().AppendElement(aDecoder); + } + + static void RemoveMediaDecoder(MediaDecoder* aDecoder) { + DecodersArray& decoders = Decoders(); + decoders.RemoveElement(aDecoder); + if (decoders.IsEmpty()) { + sUniqueInstance = nullptr; + } + } + + static RefPtr<MediaMemoryPromise> GetSizes(dom::Document* aDoc) { + MOZ_ASSERT(NS_IsMainThread()); + DecodersArray& decoders = Decoders(); + + // if we don't have any decoder, we can bail + if (decoders.IsEmpty()) { + // and release the instance that was created by calling Decoders() + sUniqueInstance = nullptr; + return MediaMemoryPromise::CreateAndResolve(MediaMemoryInfo(), __func__); + } + + RefPtr<MediaDecoder::ResourceSizes> resourceSizes = + new MediaDecoder::ResourceSizes(MediaMemoryTracker::MallocSizeOf); + + size_t videoSize = 0; + size_t audioSize = 0; + + for (auto&& decoder : decoders) { + if (decoder->GetOwner() && decoder->GetOwner()->GetDocument() == aDoc) { + videoSize += decoder->SizeOfVideoQueue(); + audioSize += decoder->SizeOfAudioQueue(); + decoder->AddSizeOfResources(resourceSizes); + } + } + + return resourceSizes->Promise()->Then( + AbstractThread::MainThread(), __func__, + [videoSize, audioSize](size_t resourceSize) { + return MediaMemoryPromise::CreateAndResolve( + MediaMemoryInfo(videoSize, audioSize, resourceSize), __func__); + }, + [](size_t) { + return MediaMemoryPromise::CreateAndReject(NS_ERROR_FAILURE, + __func__); + }); + } +}; + +StaticRefPtr<MediaMemoryTracker> MediaMemoryTracker::sUniqueInstance; + +RefPtr<MediaMemoryPromise> GetMediaMemorySizes(dom::Document* aDoc) { + return MediaMemoryTracker::GetSizes(aDoc); +} + +LazyLogModule gMediaTimerLog("MediaTimer"); + +constexpr TimeUnit MediaDecoder::DEFAULT_NEXT_FRAME_AVAILABLE_BUFFERED; + +void MediaDecoder::InitStatics() { + MOZ_ASSERT(NS_IsMainThread()); + // Eagerly init gMediaDecoderLog to work around bug 1415441. + MOZ_LOG(gMediaDecoderLog, LogLevel::Info, ("MediaDecoder::InitStatics")); +} + +NS_IMPL_ISUPPORTS(MediaMemoryTracker, nsIMemoryReporter) + +void MediaDecoder::NotifyOwnerActivityChanged(bool aIsOwnerInvisible, + bool aIsOwnerConnected) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + SetElementVisibility(aIsOwnerInvisible, aIsOwnerConnected); + + NotifyCompositor(); +} + +void MediaDecoder::Pause() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + LOG("Pause"); + if (mPlayState == PLAY_STATE_LOADING || IsEnded()) { + mNextState = PLAY_STATE_PAUSED; + return; + } + ChangeState(PLAY_STATE_PAUSED); +} + +void MediaDecoder::SetVolume(double aVolume) { + MOZ_ASSERT(NS_IsMainThread()); + mVolume = aVolume; +} + +RefPtr<GenericPromise> MediaDecoder::SetSink(AudioDeviceInfo* aSinkDevice) { + MOZ_ASSERT(NS_IsMainThread()); + mSinkDevice = aSinkDevice; + return GetStateMachine()->InvokeSetSink(aSinkDevice); +} + +void MediaDecoder::SetOutputCaptureState(OutputCaptureState aState, + SharedDummyTrack* aDummyTrack) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load()."); + MOZ_ASSERT_IF(aState == OutputCaptureState::Capture, aDummyTrack); + mOutputCaptureState = aState; + if (mOutputDummyTrack.Ref().get() != aDummyTrack) { + mOutputDummyTrack = nsMainThreadPtrHandle<SharedDummyTrack>( + MakeAndAddRef<nsMainThreadPtrHolder<SharedDummyTrack>>( + "MediaDecoder::mOutputDummyTrack", aDummyTrack)); + } +} + +void MediaDecoder::AddOutputTrack(RefPtr<ProcessedMediaTrack> aTrack) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load()."); + CopyableTArray<RefPtr<ProcessedMediaTrack>> tracks = mOutputTracks; + tracks.AppendElement(std::move(aTrack)); + mOutputTracks = tracks; +} + +void MediaDecoder::RemoveOutputTrack( + const RefPtr<ProcessedMediaTrack>& aTrack) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load()."); + CopyableTArray<RefPtr<ProcessedMediaTrack>> tracks = mOutputTracks; + if (tracks.RemoveElement(aTrack)) { + mOutputTracks = tracks; + } +} + +void MediaDecoder::SetOutputTracksPrincipal( + const RefPtr<nsIPrincipal>& aPrincipal) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load()."); + mOutputPrincipal = MakePrincipalHandle(aPrincipal); +} + +double MediaDecoder::GetDuration() { + MOZ_ASSERT(NS_IsMainThread()); + return ToMicrosecondResolution(mDuration.match(DurationToDouble())); +} + +bool MediaDecoder::IsInfinite() const { + MOZ_ASSERT(NS_IsMainThread()); + return std::isinf(mDuration.match(DurationToDouble())); +} + +#define INIT_MIRROR(name, val) \ + name(mOwner->AbstractMainThread(), val, "MediaDecoder::" #name " (Mirror)") +#define INIT_CANONICAL(name, val) \ + name(mOwner->AbstractMainThread(), val, "MediaDecoder::" #name " (Canonical)") + +MediaDecoder::MediaDecoder(MediaDecoderInit& aInit) + : mWatchManager(this, aInit.mOwner->AbstractMainThread()), + mLogicalPosition(0.0), + mDuration(TimeUnit::Invalid()), + mOwner(aInit.mOwner), + mAbstractMainThread(aInit.mOwner->AbstractMainThread()), + mFrameStats(new FrameStatistics()), + mDecoderBenchmark(new DecoderBenchmark()), + mVideoFrameContainer(aInit.mOwner->GetVideoFrameContainer()), + mMinimizePreroll(aInit.mMinimizePreroll), + mFiredMetadataLoaded(false), + mIsOwnerInvisible(false), + mIsOwnerConnected(false), + mForcedHidden(false), + mHasSuspendTaint(aInit.mHasSuspendTaint), + mShouldResistFingerprinting( + aInit.mOwner->ShouldResistFingerprinting(RFPTarget::Unknown)), + mPlaybackRate(aInit.mPlaybackRate), + mLogicallySeeking(false, "MediaDecoder::mLogicallySeeking"), + INIT_MIRROR(mBuffered, TimeIntervals()), + INIT_MIRROR(mCurrentPosition, TimeUnit::Zero()), + INIT_MIRROR(mStateMachineDuration, NullableTimeUnit()), + INIT_MIRROR(mIsAudioDataAudible, false), + INIT_CANONICAL(mVolume, aInit.mVolume), + INIT_CANONICAL(mPreservesPitch, aInit.mPreservesPitch), + INIT_CANONICAL(mLooping, aInit.mLooping), + INIT_CANONICAL(mStreamName, aInit.mStreamName), + INIT_CANONICAL(mSinkDevice, nullptr), + INIT_CANONICAL(mSecondaryVideoContainer, nullptr), + INIT_CANONICAL(mOutputCaptureState, OutputCaptureState::None), + INIT_CANONICAL(mOutputDummyTrack, nullptr), + INIT_CANONICAL(mOutputTracks, nsTArray<RefPtr<ProcessedMediaTrack>>()), + INIT_CANONICAL(mOutputPrincipal, PRINCIPAL_HANDLE_NONE), + INIT_CANONICAL(mPlayState, PLAY_STATE_LOADING), + mSameOriginMedia(false), + mVideoDecodingOberver( + new BackgroundVideoDecodingPermissionObserver(this)), + mIsBackgroundVideoDecodingAllowed(false), + mTelemetryReported(false), + mContainerType(aInit.mContainerType), + mTelemetryProbesReporter( + new TelemetryProbesReporter(aInit.mReporterOwner)) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mAbstractMainThread); + MediaMemoryTracker::AddMediaDecoder(this); + + // + // Initialize watchers. + // + + // mDuration + mWatchManager.Watch(mStateMachineDuration, &MediaDecoder::DurationChanged); + + // readyState + mWatchManager.Watch(mPlayState, &MediaDecoder::UpdateReadyState); + // ReadyState computation depends on MediaDecoder::CanPlayThrough, which + // depends on the download rate. + mWatchManager.Watch(mBuffered, &MediaDecoder::UpdateReadyState); + + // mLogicalPosition + mWatchManager.Watch(mCurrentPosition, &MediaDecoder::UpdateLogicalPosition); + mWatchManager.Watch(mPlayState, &MediaDecoder::UpdateLogicalPosition); + mWatchManager.Watch(mLogicallySeeking, &MediaDecoder::UpdateLogicalPosition); + + mWatchManager.Watch(mIsAudioDataAudible, + &MediaDecoder::NotifyAudibleStateChanged); + + mWatchManager.Watch(mVolume, &MediaDecoder::NotifyVolumeChanged); + + mVideoDecodingOberver->RegisterEvent(); +} + +#undef INIT_MIRROR +#undef INIT_CANONICAL + +void MediaDecoder::Shutdown() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + // Unwatch all watch targets to prevent further notifications. + mWatchManager.Shutdown(); + + DiscardOngoingSeekIfExists(); + + // This changes the decoder state to SHUTDOWN and does other things + // necessary to unblock the state machine thread if it's blocked, so + // the asynchronous shutdown in nsDestroyStateMachine won't deadlock. + if (mDecoderStateMachine) { + ShutdownStateMachine()->Then(mAbstractMainThread, __func__, this, + &MediaDecoder::FinishShutdown, + &MediaDecoder::FinishShutdown); + } else { + // Ensure we always unregister asynchronously in order not to disrupt + // the hashtable iterating in MediaShutdownManager::Shutdown(). + RefPtr<MediaDecoder> self = this; + nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction( + "MediaDecoder::Shutdown", [self]() { self->ShutdownInternal(); }); + mAbstractMainThread->Dispatch(r.forget()); + } + + ChangeState(PLAY_STATE_SHUTDOWN); + mVideoDecodingOberver->UnregisterEvent(); + mVideoDecodingOberver = nullptr; + mOwner = nullptr; +} + +void MediaDecoder::NotifyXPCOMShutdown() { + MOZ_ASSERT(NS_IsMainThread()); + // NotifyXPCOMShutdown will clear its reference to mDecoder. So we must ensure + // that this MediaDecoder stays alive until completion. + RefPtr<MediaDecoder> kungFuDeathGrip = this; + if (auto* owner = GetOwner()) { + owner->NotifyXPCOMShutdown(); + } else if (!IsShutdown()) { + Shutdown(); + } + MOZ_DIAGNOSTIC_ASSERT(IsShutdown()); +} + +MediaDecoder::~MediaDecoder() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(IsShutdown()); + MediaMemoryTracker::RemoveMediaDecoder(this); +} + +void MediaDecoder::OnPlaybackEvent(MediaPlaybackEvent&& aEvent) { + switch (aEvent.mType) { + case MediaPlaybackEvent::PlaybackEnded: + PlaybackEnded(); + break; + case MediaPlaybackEvent::SeekStarted: + SeekingStarted(); + break; + case MediaPlaybackEvent::Invalidate: + Invalidate(); + break; + case MediaPlaybackEvent::EnterVideoSuspend: + GetOwner()->DispatchAsyncEvent(u"mozentervideosuspend"_ns); + mTelemetryProbesReporter->OnDecodeSuspended(); + mIsVideoDecodingSuspended = true; + break; + case MediaPlaybackEvent::ExitVideoSuspend: + GetOwner()->DispatchAsyncEvent(u"mozexitvideosuspend"_ns); + mTelemetryProbesReporter->OnDecodeResumed(); + mIsVideoDecodingSuspended = false; + break; + case MediaPlaybackEvent::StartVideoSuspendTimer: + GetOwner()->DispatchAsyncEvent(u"mozstartvideosuspendtimer"_ns); + break; + case MediaPlaybackEvent::CancelVideoSuspendTimer: + GetOwner()->DispatchAsyncEvent(u"mozcancelvideosuspendtimer"_ns); + break; + case MediaPlaybackEvent::VideoOnlySeekBegin: + GetOwner()->DispatchAsyncEvent(u"mozvideoonlyseekbegin"_ns); + break; + case MediaPlaybackEvent::VideoOnlySeekCompleted: + GetOwner()->DispatchAsyncEvent(u"mozvideoonlyseekcompleted"_ns); + break; + default: + break; + } +} + +bool MediaDecoder::IsVideoDecodingSuspended() const { + return mIsVideoDecodingSuspended; +} + +void MediaDecoder::OnPlaybackErrorEvent(const MediaResult& aError) { + MOZ_ASSERT(NS_IsMainThread()); +#ifndef MOZ_WMF_MEDIA_ENGINE + DecodeError(aError); +#else + if (aError != NS_ERROR_DOM_MEDIA_EXTERNAL_ENGINE_NOT_SUPPORTED_ERR && + aError != NS_ERROR_DOM_MEDIA_CDM_PROXY_NOT_SUPPORTED_ERR) { + DecodeError(aError); + return; + } + + // Already in shutting down decoder, no need to create another state machine. + if (mPlayState == PLAY_STATE_SHUTDOWN) { + return; + } + + // External engine can't play the resource or we intentionally disable it, try + // to use our own state machine again. Here we will create a new state machine + // immediately and asynchrously shutdown the old one because we don't want to + // dispatch any task to the old state machine. Therefore, we will disconnect + // anything related with the old state machine, create a new state machine and + // setup events/mirror/etc, then shutdown the old one and release its + // reference once it finishes shutdown. + RefPtr<MediaDecoderStateMachineBase> discardStateMachine = + mDecoderStateMachine; + + // Disconnect mirror and events first. + SetStateMachine(nullptr); + DisconnectEvents(); + + // Recreate a state machine and shutdown the old one. + bool needExternalEngine = false; + if (aError == NS_ERROR_DOM_MEDIA_CDM_PROXY_NOT_SUPPORTED_ERR) { +# ifdef MOZ_WMF_CDM + if (aError.GetCDMProxy()->AsWMFCDMProxy()) { + needExternalEngine = true; + } +# endif + } + LOG("Need to create a new %s state machine", + needExternalEngine ? "external engine" : "normal"); + + nsresult rv = CreateAndInitStateMachine( + false /* live stream */, + !needExternalEngine /* disable external engine */); + if (NS_WARN_IF(NS_FAILED(rv))) { + LOG("Failed to create a new state machine!"); + } + + // Some attributes might have been set on the destroyed state machine, and + // won't be reflected on the new MDSM by the state mirroring. We need to + // update them manually later, after MDSM finished reading the + // metadata because the MDSM might not be ready to perform the operations yet. + mPendingStatusUpdateForNewlyCreatedStateMachine = true; + + // If there is ongoing seek performed on the old MDSM, cancel it because we + // will perform seeking later again and don't want the old seeking affecting + // us. + DiscardOngoingSeekIfExists(); + + discardStateMachine->BeginShutdown()->Then( + AbstractThread::MainThread(), __func__, [discardStateMachine] {}); +#endif +} + +void MediaDecoder::OnDecoderDoctorEvent(DecoderDoctorEvent aEvent) { + MOZ_ASSERT(NS_IsMainThread()); + // OnDecoderDoctorEvent is disconnected at shutdown time. + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + Document* doc = GetOwner()->GetDocument(); + if (!doc) { + return; + } + DecoderDoctorDiagnostics diags; + diags.StoreEvent(doc, aEvent, __func__); +} + +static const char* NextFrameStatusToStr( + MediaDecoderOwner::NextFrameStatus aStatus) { + switch (aStatus) { + case MediaDecoderOwner::NEXT_FRAME_AVAILABLE: + return "NEXT_FRAME_AVAILABLE"; + case MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE: + return "NEXT_FRAME_UNAVAILABLE"; + case MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_BUFFERING: + return "NEXT_FRAME_UNAVAILABLE_BUFFERING"; + case MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE_SEEKING: + return "NEXT_FRAME_UNAVAILABLE_SEEKING"; + case MediaDecoderOwner::NEXT_FRAME_UNINITIALIZED: + return "NEXT_FRAME_UNINITIALIZED"; + } + return "UNKNOWN"; +} + +void MediaDecoder::OnNextFrameStatus( + MediaDecoderOwner::NextFrameStatus aStatus) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + if (mNextFrameStatus != aStatus) { + LOG("Changed mNextFrameStatus to %s", NextFrameStatusToStr(aStatus)); + mNextFrameStatus = aStatus; + UpdateReadyState(); + } +} + +void MediaDecoder::OnTrackInfoUpdated(const VideoInfo& aVideoInfo, + const AudioInfo& aAudioInfo) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + // Note that we don't check HasVideo() or HasAudio() here, because + // those are checks for existing validity. If we always set the values + // to what we receive, then we can go from not-video to video, for + // example. + mInfo->mVideo = aVideoInfo; + mInfo->mAudio = aAudioInfo; + + Invalidate(); + + EnsureTelemetryReported(); +} + +void MediaDecoder::OnSecondaryVideoContainerInstalled( + const RefPtr<VideoFrameContainer>& aSecondaryVideoContainer) { + MOZ_ASSERT(NS_IsMainThread()); + GetOwner()->OnSecondaryVideoContainerInstalled(aSecondaryVideoContainer); +} + +void MediaDecoder::OnStoreDecoderBenchmark(const VideoInfo& aInfo) { + MOZ_ASSERT(NS_IsMainThread()); + + int32_t videoFrameRate = aInfo.GetFrameRate().ref(); + + if (mFrameStats && videoFrameRate) { + DecoderBenchmarkInfo benchmarkInfo{ + aInfo.mMimeType, + aInfo.mDisplay.width, + aInfo.mDisplay.height, + videoFrameRate, + BitDepthForColorDepth(aInfo.mColorDepth), + }; + + LOG("Store benchmark: Video width=%d, height=%d, frameRate=%d, content " + "type = %s\n", + benchmarkInfo.mWidth, benchmarkInfo.mHeight, benchmarkInfo.mFrameRate, + benchmarkInfo.mContentType.BeginReading()); + + mDecoderBenchmark->Store(benchmarkInfo, mFrameStats); + } +} + +void MediaDecoder::ShutdownInternal() { + MOZ_ASSERT(NS_IsMainThread()); + mVideoFrameContainer = nullptr; + mSecondaryVideoContainer = nullptr; + MediaShutdownManager::Instance().Unregister(this); +} + +void MediaDecoder::FinishShutdown() { + MOZ_ASSERT(NS_IsMainThread()); + SetStateMachine(nullptr); + ShutdownInternal(); +} + +nsresult MediaDecoder::CreateAndInitStateMachine(bool aIsLiveStream, + bool aDisableExternalEngine) { + MOZ_ASSERT(NS_IsMainThread()); + SetStateMachine(CreateStateMachine(aDisableExternalEngine)); + + NS_ENSURE_TRUE(GetStateMachine(), NS_ERROR_FAILURE); + GetStateMachine()->DispatchIsLiveStream(aIsLiveStream); + + nsresult rv = mDecoderStateMachine->Init(this); + NS_ENSURE_SUCCESS(rv, rv); + + // If some parameters got set before the state machine got created, + // set them now + SetStateMachineParameters(); + + return NS_OK; +} + +void MediaDecoder::SetStateMachineParameters() { + MOZ_ASSERT(NS_IsMainThread()); + if (mPlaybackRate != 1 && mPlaybackRate != 0) { + mDecoderStateMachine->DispatchSetPlaybackRate(mPlaybackRate); + } + mTimedMetadataListener = mDecoderStateMachine->TimedMetadataEvent().Connect( + mAbstractMainThread, this, &MediaDecoder::OnMetadataUpdate); + mMetadataLoadedListener = mDecoderStateMachine->MetadataLoadedEvent().Connect( + mAbstractMainThread, this, &MediaDecoder::MetadataLoaded); + mFirstFrameLoadedListener = + mDecoderStateMachine->FirstFrameLoadedEvent().Connect( + mAbstractMainThread, this, &MediaDecoder::FirstFrameLoaded); + + mOnPlaybackEvent = mDecoderStateMachine->OnPlaybackEvent().Connect( + mAbstractMainThread, this, &MediaDecoder::OnPlaybackEvent); + mOnPlaybackErrorEvent = mDecoderStateMachine->OnPlaybackErrorEvent().Connect( + mAbstractMainThread, this, &MediaDecoder::OnPlaybackErrorEvent); + mOnDecoderDoctorEvent = mDecoderStateMachine->OnDecoderDoctorEvent().Connect( + mAbstractMainThread, this, &MediaDecoder::OnDecoderDoctorEvent); + mOnMediaNotSeekable = mDecoderStateMachine->OnMediaNotSeekable().Connect( + mAbstractMainThread, this, &MediaDecoder::OnMediaNotSeekable); + mOnNextFrameStatus = mDecoderStateMachine->OnNextFrameStatus().Connect( + mAbstractMainThread, this, &MediaDecoder::OnNextFrameStatus); + mOnTrackInfoUpdated = mDecoderStateMachine->OnTrackInfoUpdatedEvent().Connect( + mAbstractMainThread, this, &MediaDecoder::OnTrackInfoUpdated); + mOnSecondaryVideoContainerInstalled = + mDecoderStateMachine->OnSecondaryVideoContainerInstalled().Connect( + mAbstractMainThread, this, + &MediaDecoder::OnSecondaryVideoContainerInstalled); + mOnStoreDecoderBenchmark = mReader->OnStoreDecoderBenchmark().Connect( + mAbstractMainThread, this, &MediaDecoder::OnStoreDecoderBenchmark); + + mOnEncrypted = mReader->OnEncrypted().Connect( + mAbstractMainThread, GetOwner(), &MediaDecoderOwner::DispatchEncrypted); + mOnWaitingForKey = mReader->OnWaitingForKey().Connect( + mAbstractMainThread, GetOwner(), &MediaDecoderOwner::NotifyWaitingForKey); + mOnDecodeWarning = mReader->OnDecodeWarning().Connect( + mAbstractMainThread, GetOwner(), &MediaDecoderOwner::DecodeWarning); +} + +void MediaDecoder::DisconnectEvents() { + MOZ_ASSERT(NS_IsMainThread()); + mTimedMetadataListener.Disconnect(); + mMetadataLoadedListener.Disconnect(); + mFirstFrameLoadedListener.Disconnect(); + mOnPlaybackEvent.Disconnect(); + mOnPlaybackErrorEvent.Disconnect(); + mOnDecoderDoctorEvent.Disconnect(); + mOnMediaNotSeekable.Disconnect(); + mOnEncrypted.Disconnect(); + mOnWaitingForKey.Disconnect(); + mOnDecodeWarning.Disconnect(); + mOnNextFrameStatus.Disconnect(); + mOnTrackInfoUpdated.Disconnect(); + mOnSecondaryVideoContainerInstalled.Disconnect(); + mOnStoreDecoderBenchmark.Disconnect(); +} + +RefPtr<ShutdownPromise> MediaDecoder::ShutdownStateMachine() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(GetStateMachine()); + DisconnectEvents(); + return mDecoderStateMachine->BeginShutdown(); +} + +void MediaDecoder::Play() { + MOZ_ASSERT(NS_IsMainThread()); + + NS_ASSERTION(mDecoderStateMachine != nullptr, "Should have state machine."); + LOG("Play"); + if (mPlaybackRate == 0) { + return; + } + + if (IsEnded()) { + Seek(0, SeekTarget::PrevSyncPoint); + return; + } + + if (mPlayState == PLAY_STATE_LOADING) { + mNextState = PLAY_STATE_PLAYING; + return; + } + + ChangeState(PLAY_STATE_PLAYING); +} + +void MediaDecoder::Seek(double aTime, SeekTarget::Type aSeekType) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + MOZ_ASSERT(aTime >= 0.0, "Cannot seek to a negative value."); + + LOG("Seek"); + auto time = TimeUnit::FromSeconds(aTime); + + mLogicalPosition = aTime; + mLogicallySeeking = true; + SeekTarget target = SeekTarget(time, aSeekType); + CallSeek(target); + + if (mPlayState == PLAY_STATE_ENDED) { + ChangeState(GetOwner()->GetPaused() ? PLAY_STATE_PAUSED + : PLAY_STATE_PLAYING); + } +} + +void MediaDecoder::SetDelaySeekMode(bool aShouldDelaySeek) { + MOZ_ASSERT(NS_IsMainThread()); + LOG("SetDelaySeekMode, shouldDelaySeek=%d", aShouldDelaySeek); + if (mShouldDelaySeek == aShouldDelaySeek) { + return; + } + mShouldDelaySeek = aShouldDelaySeek; + if (!mShouldDelaySeek && mDelayedSeekTarget) { + Seek(mDelayedSeekTarget->GetTime().ToSeconds(), + mDelayedSeekTarget->GetType()); + mDelayedSeekTarget.reset(); + } +} + +void MediaDecoder::DiscardOngoingSeekIfExists() { + MOZ_ASSERT(NS_IsMainThread()); + mSeekRequest.DisconnectIfExists(); +} + +void MediaDecoder::CallSeek(const SeekTarget& aTarget) { + MOZ_ASSERT(NS_IsMainThread()); + if (mShouldDelaySeek) { + LOG("Delay seek to %f and store it to delayed seek target", + mDelayedSeekTarget->GetTime().ToSeconds()); + mDelayedSeekTarget = Some(aTarget); + return; + } + DiscardOngoingSeekIfExists(); + mDecoderStateMachine->InvokeSeek(aTarget) + ->Then(mAbstractMainThread, __func__, this, &MediaDecoder::OnSeekResolved, + &MediaDecoder::OnSeekRejected) + ->Track(mSeekRequest); +} + +double MediaDecoder::GetCurrentTime() { + MOZ_ASSERT(NS_IsMainThread()); + return mLogicalPosition; +} + +void MediaDecoder::OnMetadataUpdate(TimedMetadata&& aMetadata) { + MOZ_ASSERT(NS_IsMainThread()); + MetadataLoaded(MakeUnique<MediaInfo>(*aMetadata.mInfo), + UniquePtr<MetadataTags>(std::move(aMetadata.mTags)), + MediaDecoderEventVisibility::Observable); + FirstFrameLoaded(std::move(aMetadata.mInfo), + MediaDecoderEventVisibility::Observable); +} + +void MediaDecoder::MetadataLoaded( + UniquePtr<MediaInfo> aInfo, UniquePtr<MetadataTags> aTags, + MediaDecoderEventVisibility aEventVisibility) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + LOG("MetadataLoaded, channels=%u rate=%u hasAudio=%d hasVideo=%d", + aInfo->mAudio.mChannels, aInfo->mAudio.mRate, aInfo->HasAudio(), + aInfo->HasVideo()); + + mMediaSeekable = aInfo->mMediaSeekable; + mMediaSeekableOnlyInBufferedRanges = + aInfo->mMediaSeekableOnlyInBufferedRanges; + mInfo = std::move(aInfo); + + mTelemetryProbesReporter->OnMediaContentChanged( + TelemetryProbesReporter::MediaInfoToMediaContent(*mInfo)); + + // Make sure the element and the frame (if any) are told about + // our new size. + if (aEventVisibility != MediaDecoderEventVisibility::Suppressed) { + mFiredMetadataLoaded = true; + GetOwner()->MetadataLoaded(mInfo.get(), std::move(aTags)); + } + // Invalidate() will end up calling GetOwner()->UpdateMediaSize with the last + // dimensions retrieved from the video frame container. The video frame + // container contains more up to date dimensions than aInfo. + // So we call Invalidate() after calling GetOwner()->MetadataLoaded to ensure + // the media element has the latest dimensions. + Invalidate(); + +#ifdef MOZ_WMF_MEDIA_ENGINE + if (mPendingStatusUpdateForNewlyCreatedStateMachine) { + mPendingStatusUpdateForNewlyCreatedStateMachine = false; + LOG("Set pending statuses if necessary (mLogicallySeeking=%d, " + "mLogicalPosition=%f, mPlaybackRate=%f)", + mLogicallySeeking.Ref(), mLogicalPosition, mPlaybackRate); + if (mLogicalPosition != 0) { + Seek(mLogicalPosition, SeekTarget::Accurate); + } + if (mPlaybackRate != 0 && mPlaybackRate != 1.0) { + mDecoderStateMachine->DispatchSetPlaybackRate(mPlaybackRate); + } + } +#endif + + EnsureTelemetryReported(); +} + +void MediaDecoder::EnsureTelemetryReported() { + MOZ_ASSERT(NS_IsMainThread()); + + if (mTelemetryReported || !mInfo) { + // Note: sometimes we get multiple MetadataLoaded calls (for example + // for chained ogg). So we ensure we don't report duplicate results for + // these resources. + return; + } + + nsTArray<nsCString> codecs; + if (mInfo->HasAudio() && + !mInfo->mAudio.GetAsAudioInfo()->mMimeType.IsEmpty()) { + codecs.AppendElement(mInfo->mAudio.GetAsAudioInfo()->mMimeType); + } + if (mInfo->HasVideo() && + !mInfo->mVideo.GetAsVideoInfo()->mMimeType.IsEmpty()) { + codecs.AppendElement(mInfo->mVideo.GetAsVideoInfo()->mMimeType); + } + if (codecs.IsEmpty()) { + codecs.AppendElement(nsPrintfCString( + "resource; %s", ContainerType().OriginalString().Data())); + } + for (const nsCString& codec : codecs) { + LOG("Telemetry MEDIA_CODEC_USED= '%s'", codec.get()); + Telemetry::Accumulate(Telemetry::HistogramID::MEDIA_CODEC_USED, codec); + } + + mTelemetryReported = true; +} + +const char* MediaDecoder::PlayStateStr() { + MOZ_ASSERT(NS_IsMainThread()); + return ToPlayStateStr(mPlayState); +} + +void MediaDecoder::FirstFrameLoaded( + UniquePtr<MediaInfo> aInfo, MediaDecoderEventVisibility aEventVisibility) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + LOG("FirstFrameLoaded, channels=%u rate=%u hasAudio=%d hasVideo=%d " + "mPlayState=%s transportSeekable=%d", + aInfo->mAudio.mChannels, aInfo->mAudio.mRate, aInfo->HasAudio(), + aInfo->HasVideo(), PlayStateStr(), IsTransportSeekable()); + + mInfo = std::move(aInfo); + mTelemetryProbesReporter->OnMediaContentChanged( + TelemetryProbesReporter::MediaInfoToMediaContent(*mInfo)); + + Invalidate(); + + // The element can run javascript via events + // before reaching here, so only change the + // state if we're still set to the original + // loading state. + if (mPlayState == PLAY_STATE_LOADING) { + ChangeState(mNextState); + } + + // GetOwner()->FirstFrameLoaded() might call us back. Put it at the bottom of + // this function to avoid unexpected shutdown from reentrant calls. + if (aEventVisibility != MediaDecoderEventVisibility::Suppressed) { + GetOwner()->FirstFrameLoaded(); + } +} + +void MediaDecoder::NetworkError(const MediaResult& aError) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + GetOwner()->NetworkError(aError); +} + +void MediaDecoder::DecodeError(const MediaResult& aError) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + GetOwner()->DecodeError(aError); +} + +void MediaDecoder::UpdateSameOriginStatus(bool aSameOrigin) { + MOZ_ASSERT(NS_IsMainThread()); + mSameOriginMedia = aSameOrigin; +} + +bool MediaDecoder::IsSeeking() const { + MOZ_ASSERT(NS_IsMainThread()); + return mLogicallySeeking; +} + +bool MediaDecoder::OwnerHasError() const { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + return GetOwner()->HasError(); +} + +bool MediaDecoder::IsEnded() const { + MOZ_ASSERT(NS_IsMainThread()); + return mPlayState == PLAY_STATE_ENDED; +} + +bool MediaDecoder::IsShutdown() const { + MOZ_ASSERT(NS_IsMainThread()); + return mPlayState == PLAY_STATE_SHUTDOWN; +} + +void MediaDecoder::PlaybackEnded() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + if (mLogicallySeeking || mPlayState == PLAY_STATE_LOADING || + mPlayState == PLAY_STATE_ENDED) { + LOG("MediaDecoder::PlaybackEnded bailed out, " + "mLogicallySeeking=%d mPlayState=%s", + mLogicallySeeking.Ref(), ToPlayStateStr(mPlayState)); + return; + } + + LOG("MediaDecoder::PlaybackEnded"); + + ChangeState(PLAY_STATE_ENDED); + InvalidateWithFlags(VideoFrameContainer::INVALIDATE_FORCE); + GetOwner()->PlaybackEnded(); +} + +void MediaDecoder::NotifyPrincipalChanged() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + GetOwner()->NotifyDecoderPrincipalChanged(); +} + +void MediaDecoder::OnSeekResolved() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + LOG("MediaDecoder::OnSeekResolved"); + mLogicallySeeking = false; + + // Ensure logical position is updated after seek. + UpdateLogicalPositionInternal(); + mSeekRequest.Complete(); + + GetOwner()->SeekCompleted(); +} + +void MediaDecoder::OnSeekRejected() { + MOZ_ASSERT(NS_IsMainThread()); + LOG("MediaDecoder::OnSeekRejected"); + mSeekRequest.Complete(); + mLogicallySeeking = false; + + GetOwner()->SeekAborted(); +} + +void MediaDecoder::SeekingStarted() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + GetOwner()->SeekStarted(); +} + +void MediaDecoder::ChangeState(PlayState aState) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown(), "SHUTDOWN is the final state."); + + if (mNextState == aState) { + mNextState = PLAY_STATE_PAUSED; + } + + if (mPlayState != aState) { + DDLOG(DDLogCategory::Property, "play_state", ToPlayStateStr(aState)); + LOG("Play state changes from %s to %s", ToPlayStateStr(mPlayState), + ToPlayStateStr(aState)); + mPlayState = aState; + UpdateTelemetryHelperBasedOnPlayState(aState); + } +} + +TelemetryProbesReporter::Visibility MediaDecoder::OwnerVisibility() const { + return GetOwner()->IsActuallyInvisible() || mForcedHidden + ? TelemetryProbesReporter::Visibility::eInvisible + : TelemetryProbesReporter::Visibility::eVisible; +} + +void MediaDecoder::UpdateTelemetryHelperBasedOnPlayState( + PlayState aState) const { + if (aState == PlayState::PLAY_STATE_PLAYING) { + mTelemetryProbesReporter->OnPlay( + OwnerVisibility(), + TelemetryProbesReporter::MediaInfoToMediaContent(*mInfo), + mVolume == 0.f); + } else if (aState == PlayState::PLAY_STATE_PAUSED || + aState == PlayState::PLAY_STATE_ENDED) { + mTelemetryProbesReporter->OnPause(OwnerVisibility()); + } else if (aState == PLAY_STATE_SHUTDOWN) { + mTelemetryProbesReporter->OnShutdown(); + } +} + +MediaDecoder::PositionUpdate MediaDecoder::GetPositionUpdateReason( + double aPrevPos, const TimeUnit& aCurPos) const { + MOZ_ASSERT(NS_IsMainThread()); + // If current position is earlier than previous position and we didn't do + // seek, that means we looped back to the start position. + const bool notSeeking = !mSeekRequest.Exists(); + if (mLooping && notSeeking && aCurPos.ToSeconds() < aPrevPos) { + return PositionUpdate::eSeamlessLoopingSeeking; + } + return aPrevPos != aCurPos.ToSeconds() && notSeeking + ? PositionUpdate::ePeriodicUpdate + : PositionUpdate::eOther; +} + +void MediaDecoder::UpdateLogicalPositionInternal() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + TimeUnit currentPosition = CurrentPosition(); + if (mPlayState == PLAY_STATE_ENDED) { + currentPosition = + std::max(currentPosition, mDuration.match(DurationToTimeUnit())); + } + + const PositionUpdate reason = + GetPositionUpdateReason(mLogicalPosition, currentPosition); + switch (reason) { + case PositionUpdate::ePeriodicUpdate: + SetLogicalPosition(currentPosition); + // This is actually defined in `TimeMarchesOn`, but we do that in decoder. + // https://html.spec.whatwg.org/multipage/media.html#playing-the-media-resource:event-media-timeupdate-7 + // TODO (bug 1688137): should we move it back to `TimeMarchesOn`? + GetOwner()->MaybeQueueTimeupdateEvent(); + break; + case PositionUpdate::eSeamlessLoopingSeeking: + // When seamless seeking occurs, seeking was performed on the demuxer so + // the decoder doesn't know. That means decoder still thinks it's in + // playing. Therefore, we have to manually call those methods to notify + // the owner about seeking. + GetOwner()->SeekStarted(); + SetLogicalPosition(currentPosition); + GetOwner()->SeekCompleted(); + break; + default: + MOZ_ASSERT(reason == PositionUpdate::eOther); + SetLogicalPosition(currentPosition); + break; + } + + // Invalidate the frame so any video data is displayed. + // Do this before the timeupdate event so that if that + // event runs JavaScript that queries the media size, the + // frame has reflowed and the size updated beforehand. + Invalidate(); +} + +void MediaDecoder::SetLogicalPosition(const TimeUnit& aNewPosition) { + MOZ_ASSERT(NS_IsMainThread()); + if (TimeUnit::FromSeconds(mLogicalPosition) == aNewPosition || + mLogicalPosition == aNewPosition.ToSeconds()) { + return; + } + mLogicalPosition = aNewPosition.ToSeconds(); + DDLOG(DDLogCategory::Property, "currentTime", mLogicalPosition); +} + +void MediaDecoder::DurationChanged() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + Variant<TimeUnit, double> oldDuration = mDuration; + + // Use the explicit duration if we have one. + // Otherwise use the duration mirrored from MDSM. + if (mExplicitDuration.isSome()) { + mDuration.emplace<double>(mExplicitDuration.ref()); + } else if (mStateMachineDuration.Ref().isSome()) { + MOZ_ASSERT(mStateMachineDuration.Ref().ref().IsValid()); + mDuration.emplace<TimeUnit>(mStateMachineDuration.Ref().ref()); + } + + LOG("New duration: %s", + mDuration.match(DurationToTimeUnit()).ToString().get()); + if (oldDuration.is<TimeUnit>() && oldDuration.as<TimeUnit>().IsValid()) { + LOG("Old Duration %s", + oldDuration.match(DurationToTimeUnit()).ToString().get()); + } + + if ((oldDuration.is<double>() || oldDuration.as<TimeUnit>().IsValid())) { + if (mDuration.match(DurationToDouble()) == + oldDuration.match(DurationToDouble())) { + return; + } + } + + LOG("Duration changed to %s", + mDuration.match(DurationToTimeUnit()).ToString().get()); + + // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=28822 for a discussion + // of whether we should fire durationchange on explicit infinity. + if (mFiredMetadataLoaded && + (!std::isinf(mDuration.match(DurationToDouble())) || + mExplicitDuration.isSome())) { + GetOwner()->DispatchAsyncEvent(u"durationchange"_ns); + } + + if (CurrentPosition().ToSeconds() > mDuration.match(DurationToDouble())) { + Seek(mDuration.match(DurationToDouble()), SeekTarget::Accurate); + } +} + +already_AddRefed<KnowsCompositor> MediaDecoder::GetCompositor() { + MediaDecoderOwner* owner = GetOwner(); + Document* ownerDoc = owner ? owner->GetDocument() : nullptr; + WindowRenderer* renderer = + ownerDoc ? nsContentUtils::WindowRendererForDocument(ownerDoc) : nullptr; + RefPtr<KnowsCompositor> knows = + renderer ? renderer->AsKnowsCompositor() : nullptr; + return knows ? knows->GetForMedia().forget() : nullptr; +} + +void MediaDecoder::NotifyCompositor() { + RefPtr<KnowsCompositor> knowsCompositor = GetCompositor(); + if (knowsCompositor) { + nsCOMPtr<nsIRunnable> r = + NewRunnableMethod<already_AddRefed<KnowsCompositor>&&>( + "MediaFormatReader::UpdateCompositor", mReader, + &MediaFormatReader::UpdateCompositor, knowsCompositor.forget()); + Unused << mReader->OwnerThread()->Dispatch(r.forget()); + } +} + +void MediaDecoder::SetElementVisibility(bool aIsOwnerInvisible, + bool aIsOwnerConnected) { + MOZ_ASSERT(NS_IsMainThread()); + mIsOwnerInvisible = aIsOwnerInvisible; + mIsOwnerConnected = aIsOwnerConnected; + mTelemetryProbesReporter->OnVisibilityChanged(OwnerVisibility()); + UpdateVideoDecodeMode(); +} + +void MediaDecoder::SetForcedHidden(bool aForcedHidden) { + MOZ_ASSERT(NS_IsMainThread()); + mForcedHidden = aForcedHidden; + mTelemetryProbesReporter->OnVisibilityChanged(OwnerVisibility()); + UpdateVideoDecodeMode(); +} + +void MediaDecoder::SetSuspendTaint(bool aTainted) { + MOZ_ASSERT(NS_IsMainThread()); + mHasSuspendTaint = aTainted; + UpdateVideoDecodeMode(); +} + +void MediaDecoder::UpdateVideoDecodeMode() { + MOZ_ASSERT(NS_IsMainThread()); + + // The MDSM may yet be set. + if (!mDecoderStateMachine) { + LOG("UpdateVideoDecodeMode(), early return because we don't have MDSM."); + return; + } + + // Seeking is required when leaving suspend mode. + if (!mMediaSeekable) { + LOG("UpdateVideoDecodeMode(), set Normal because the media is not " + "seekable"); + mDecoderStateMachine->SetVideoDecodeMode(VideoDecodeMode::Normal); + return; + } + + // If mHasSuspendTaint is set, never suspend the video decoder. + if (mHasSuspendTaint) { + LOG("UpdateVideoDecodeMode(), set Normal because the element has been " + "tainted."); + mDecoderStateMachine->SetVideoDecodeMode(VideoDecodeMode::Normal); + return; + } + + // If mSecondaryVideoContainer is set, never suspend the video decoder. + if (mSecondaryVideoContainer.Ref()) { + LOG("UpdateVideoDecodeMode(), set Normal because the element is cloning " + "itself visually to another video container."); + mDecoderStateMachine->SetVideoDecodeMode(VideoDecodeMode::Normal); + return; + } + + // Don't suspend elements that is not in a connected tree. + if (!mIsOwnerConnected) { + LOG("UpdateVideoDecodeMode(), set Normal because the element is not in " + "tree."); + mDecoderStateMachine->SetVideoDecodeMode(VideoDecodeMode::Normal); + return; + } + + // If mForcedHidden is set, suspend the video decoder anyway. + if (mForcedHidden) { + LOG("UpdateVideoDecodeMode(), set Suspend because the element is forced to " + "be suspended."); + mDecoderStateMachine->SetVideoDecodeMode(VideoDecodeMode::Suspend); + return; + } + + // Resume decoding in the advance, even the element is in the background. + if (mIsBackgroundVideoDecodingAllowed) { + LOG("UpdateVideoDecodeMode(), set Normal because the tab is in background " + "and hovered."); + mDecoderStateMachine->SetVideoDecodeMode(VideoDecodeMode::Normal); + return; + } + + if (mIsOwnerInvisible) { + LOG("UpdateVideoDecodeMode(), set Suspend because of invisible element."); + mDecoderStateMachine->SetVideoDecodeMode(VideoDecodeMode::Suspend); + } else { + LOG("UpdateVideoDecodeMode(), set Normal because of visible element."); + mDecoderStateMachine->SetVideoDecodeMode(VideoDecodeMode::Normal); + } +} + +void MediaDecoder::SetIsBackgroundVideoDecodingAllowed(bool aAllowed) { + mIsBackgroundVideoDecodingAllowed = aAllowed; + UpdateVideoDecodeMode(); +} + +bool MediaDecoder::HasSuspendTaint() const { + MOZ_ASSERT(NS_IsMainThread()); + return mHasSuspendTaint; +} + +void MediaDecoder::SetSecondaryVideoContainer( + const RefPtr<VideoFrameContainer>& aSecondaryVideoContainer) { + MOZ_ASSERT(NS_IsMainThread()); + if (mSecondaryVideoContainer.Ref() == aSecondaryVideoContainer) { + return; + } + mSecondaryVideoContainer = aSecondaryVideoContainer; + UpdateVideoDecodeMode(); +} + +bool MediaDecoder::IsMediaSeekable() { + MOZ_ASSERT(NS_IsMainThread()); + NS_ENSURE_TRUE(GetStateMachine(), false); + return mMediaSeekable; +} + +namespace { + +// Returns zero, either as a TimeUnit or as a double. +template <typename T> +constexpr T Zero() { + if constexpr (std::is_same<T, double>::value) { + return 0.0; + } else if constexpr (std::is_same<T, TimeUnit>::value) { + return TimeUnit::Zero(); + } + MOZ_RELEASE_ASSERT(false); +}; + +// Returns Infinity either as a TimeUnit or as a double. +template <typename T> +constexpr T Infinity() { + if constexpr (std::is_same<T, double>::value) { + return std::numeric_limits<double>::infinity(); + } else if constexpr (std::is_same<T, TimeUnit>::value) { + return TimeUnit::FromInfinity(); + } + MOZ_RELEASE_ASSERT(false); +}; + +}; // namespace + +// This method can be made to return either TimeIntervals, that is a set of +// interval that are delimited with TimeUnit, or TimeRanges, that is a set of +// intervals that are delimited by seconds, as doubles. +// seekable often depends on the duration of a media, in the very common case +// where the seekable range is [0, duration]. When playing a MediaSource, the +// duration of a media element can be set as an arbitrary number, that are +// 64-bits floating point values. +// This allows returning an interval that is [0, duration], with duration being +// a double that cannot be represented as a TimeUnit, either because it has too +// many significant digits, or because it's outside of the int64_t range that +// TimeUnit internally uses. +template <typename IntervalType> +IntervalType MediaDecoder::GetSeekableImpl() { + MOZ_ASSERT(NS_IsMainThread()); + if (std::isnan(GetDuration())) { + // We do not have a duration yet, we can't determine the seekable range. + return IntervalType(); + } + + // Compute [0, duration] -- When dealing with doubles, use ::GetDuration to + // avoid rounding the value differently. When dealing with TimeUnit, it's + // returned directly. + typename IntervalType::InnerType duration; + if constexpr (std::is_same<typename IntervalType::InnerType, double>::value) { + duration = GetDuration(); + } else { + duration = mDuration.as<TimeUnit>(); + } + typename IntervalType::ElemType zeroToDuration = + typename IntervalType::ElemType( + Zero<typename IntervalType::InnerType>(), + IsInfinite() ? Infinity<typename IntervalType::InnerType>() + : duration); + auto buffered = IntervalType(GetBuffered()); + // Remove any negative range in the interval -- seeking to a non-positive + // position isn't possible. + auto positiveBuffered = buffered.Intersection(zeroToDuration); + + // We can seek in buffered range if the media is seekable. Also, we can seek + // in unbuffered ranges if the transport level is seekable (local file or the + // server supports range requests, etc.) or in cue-less WebMs + if (mMediaSeekableOnlyInBufferedRanges) { + return IntervalType(positiveBuffered); + } + if (!IsMediaSeekable()) { + return IntervalType(); + } + if (!IsTransportSeekable()) { + return IntervalType(positiveBuffered); + } + + // Common case: seeking is possible at any point of the stream. + return IntervalType(zeroToDuration); +} + +media::TimeIntervals MediaDecoder::GetSeekable() { + return GetSeekableImpl<media::TimeIntervals>(); +} + +media::TimeRanges MediaDecoder::GetSeekableTimeRanges() { + return GetSeekableImpl<media::TimeRanges>(); +} + +void MediaDecoder::SetFragmentEndTime(double aTime) { + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoderStateMachine) { + mDecoderStateMachine->DispatchSetFragmentEndTime( + TimeUnit::FromSeconds(aTime)); + } +} + +void MediaDecoder::SetPlaybackRate(double aPlaybackRate) { + MOZ_ASSERT(NS_IsMainThread()); + + double oldRate = mPlaybackRate; + mPlaybackRate = aPlaybackRate; + if (aPlaybackRate == 0) { + Pause(); + return; + } + + if (oldRate == 0 && !GetOwner()->GetPaused()) { + // PlaybackRate is no longer null. + // Restart the playback if the media was playing. + Play(); + } + + if (mDecoderStateMachine) { + mDecoderStateMachine->DispatchSetPlaybackRate(aPlaybackRate); + } +} + +void MediaDecoder::SetPreservesPitch(bool aPreservesPitch) { + MOZ_ASSERT(NS_IsMainThread()); + mPreservesPitch = aPreservesPitch; +} + +void MediaDecoder::SetLooping(bool aLooping) { + MOZ_ASSERT(NS_IsMainThread()); + mLooping = aLooping; +} + +void MediaDecoder::SetStreamName(const nsAutoString& aStreamName) { + MOZ_ASSERT(NS_IsMainThread()); + mStreamName = aStreamName; +} + +void MediaDecoder::ConnectMirrors(MediaDecoderStateMachineBase* aObject) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aObject); + mStateMachineDuration.Connect(aObject->CanonicalDuration()); + mBuffered.Connect(aObject->CanonicalBuffered()); + mCurrentPosition.Connect(aObject->CanonicalCurrentPosition()); + mIsAudioDataAudible.Connect(aObject->CanonicalIsAudioDataAudible()); +} + +void MediaDecoder::DisconnectMirrors() { + MOZ_ASSERT(NS_IsMainThread()); + mStateMachineDuration.DisconnectIfConnected(); + mBuffered.DisconnectIfConnected(); + mCurrentPosition.DisconnectIfConnected(); + mIsAudioDataAudible.DisconnectIfConnected(); +} + +void MediaDecoder::SetStateMachine( + MediaDecoderStateMachineBase* aStateMachine) { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT_IF(aStateMachine, !mDecoderStateMachine); + if (aStateMachine) { + mDecoderStateMachine = aStateMachine; + LOG("set state machine %p", mDecoderStateMachine.get()); + ConnectMirrors(aStateMachine); + UpdateVideoDecodeMode(); + } else if (mDecoderStateMachine) { + LOG("null out state machine %p", mDecoderStateMachine.get()); + mDecoderStateMachine = nullptr; + DisconnectMirrors(); + } +} + +ImageContainer* MediaDecoder::GetImageContainer() { + return mVideoFrameContainer ? mVideoFrameContainer->GetImageContainer() + : nullptr; +} + +void MediaDecoder::InvalidateWithFlags(uint32_t aFlags) { + if (mVideoFrameContainer) { + mVideoFrameContainer->InvalidateWithFlags(aFlags); + } +} + +void MediaDecoder::Invalidate() { + if (mVideoFrameContainer) { + mVideoFrameContainer->Invalidate(); + } +} + +void MediaDecoder::Suspend() { + MOZ_ASSERT(NS_IsMainThread()); + GetStateMachine()->InvokeSuspendMediaSink(); +} + +void MediaDecoder::Resume() { + MOZ_ASSERT(NS_IsMainThread()); + GetStateMachine()->InvokeResumeMediaSink(); +} + +// Constructs the time ranges representing what segments of the media +// are buffered and playable. +media::TimeIntervals MediaDecoder::GetBuffered() { + MOZ_ASSERT(NS_IsMainThread()); + return mBuffered.Ref(); +} + +size_t MediaDecoder::SizeOfVideoQueue() { + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoderStateMachine) { + return mDecoderStateMachine->SizeOfVideoQueue(); + } + return 0; +} + +size_t MediaDecoder::SizeOfAudioQueue() { + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoderStateMachine) { + return mDecoderStateMachine->SizeOfAudioQueue(); + } + return 0; +} + +void MediaDecoder::NotifyReaderDataArrived() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + + nsresult rv = mReader->OwnerThread()->Dispatch( + NewRunnableMethod("MediaFormatReader::NotifyDataArrived", mReader.get(), + &MediaFormatReader::NotifyDataArrived)); + MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv)); + Unused << rv; +} + +// Provide access to the state machine object +MediaDecoderStateMachineBase* MediaDecoder::GetStateMachine() const { + MOZ_ASSERT(NS_IsMainThread()); + return mDecoderStateMachine; +} + +bool MediaDecoder::CanPlayThrough() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + return CanPlayThroughImpl(); +} + +RefPtr<SetCDMPromise> MediaDecoder::SetCDMProxy(CDMProxy* aProxy) { + MOZ_ASSERT(NS_IsMainThread()); +#ifdef MOZ_WMF_MEDIA_ENGINE + // Switch to another state machine if the current one doesn't support the + // given CDM proxy. + if (aProxy && !GetStateMachine()->IsCDMProxySupported(aProxy)) { + LOG("CDM proxy not supported! Switch to another state machine."); + OnPlaybackErrorEvent( + MediaResult{NS_ERROR_DOM_MEDIA_CDM_PROXY_NOT_SUPPORTED_ERR, aProxy}); + } +#endif + MOZ_DIAGNOSTIC_ASSERT_IF(aProxy, + GetStateMachine()->IsCDMProxySupported(aProxy)); + return GetStateMachine()->SetCDMProxy(aProxy); +} + +bool MediaDecoder::IsOpusEnabled() { return StaticPrefs::media_opus_enabled(); } + +bool MediaDecoder::IsOggEnabled() { return StaticPrefs::media_ogg_enabled(); } + +bool MediaDecoder::IsWaveEnabled() { return StaticPrefs::media_wave_enabled(); } + +bool MediaDecoder::IsWebMEnabled() { return StaticPrefs::media_webm_enabled(); } + +NS_IMETHODIMP +MediaMemoryTracker::CollectReports(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, bool aAnonymize) { + // NB: When resourceSizes' ref count goes to 0 the promise will report the + // resources memory and finish the asynchronous memory report. + RefPtr<MediaDecoder::ResourceSizes> resourceSizes = + new MediaDecoder::ResourceSizes(MediaMemoryTracker::MallocSizeOf); + + nsCOMPtr<nsIHandleReportCallback> handleReport = aHandleReport; + nsCOMPtr<nsISupports> data = aData; + + resourceSizes->Promise()->Then( + AbstractThread::MainThread(), __func__, + [handleReport, data](size_t size) { + handleReport->Callback( + ""_ns, "explicit/media/resources"_ns, KIND_HEAP, UNITS_BYTES, + static_cast<int64_t>(size), + nsLiteralCString("Memory used by media resources including " + "streaming buffers, caches, etc."), + data); + + nsCOMPtr<nsIMemoryReporterManager> imgr = + do_GetService("@mozilla.org/memory-reporter-manager;1"); + + if (imgr) { + imgr->EndReport(); + } + }, + [](size_t) { /* unused reject function */ }); + + int64_t video = 0; + int64_t audio = 0; + DecodersArray& decoders = Decoders(); + for (size_t i = 0; i < decoders.Length(); ++i) { + MediaDecoder* decoder = decoders[i]; + video += static_cast<int64_t>(decoder->SizeOfVideoQueue()); + audio += static_cast<int64_t>(decoder->SizeOfAudioQueue()); + decoder->AddSizeOfResources(resourceSizes); + } + + MOZ_COLLECT_REPORT("explicit/media/decoded/video", KIND_HEAP, UNITS_BYTES, + video, "Memory used by decoded video frames."); + + MOZ_COLLECT_REPORT("explicit/media/decoded/audio", KIND_HEAP, UNITS_BYTES, + audio, "Memory used by decoded audio chunks."); + + return NS_OK; +} + +MediaDecoderOwner* MediaDecoder::GetOwner() const { + MOZ_ASSERT(NS_IsMainThread()); + // mOwner is valid until shutdown. + return mOwner; +} + +MediaDecoderOwner::NextFrameStatus MediaDecoder::NextFrameBufferedStatus() { + MOZ_ASSERT(NS_IsMainThread()); + // Next frame hasn't been decoded yet. + // Use the buffered range to consider if we have the next frame available. + auto currentPosition = CurrentPosition(); + media::TimeInterval interval( + currentPosition, currentPosition + DEFAULT_NEXT_FRAME_AVAILABLE_BUFFERED); + return GetBuffered().Contains(interval) + ? MediaDecoderOwner::NEXT_FRAME_AVAILABLE + : MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE; +} + +void MediaDecoder::GetDebugInfo(dom::MediaDecoderDebugInfo& aInfo) { + MOZ_ASSERT(NS_IsMainThread()); + CopyUTF8toUTF16(nsPrintfCString("%p", this), aInfo.mInstance); + aInfo.mChannels = mInfo ? mInfo->mAudio.mChannels : 0; + aInfo.mRate = mInfo ? mInfo->mAudio.mRate : 0; + aInfo.mHasAudio = mInfo ? mInfo->HasAudio() : false; + aInfo.mHasVideo = mInfo ? mInfo->HasVideo() : false; + CopyUTF8toUTF16(MakeStringSpan(PlayStateStr()), aInfo.mPlayState); + aInfo.mContainerType = + NS_ConvertUTF8toUTF16(ContainerType().Type().AsString()); +} + +RefPtr<GenericPromise> MediaDecoder::RequestDebugInfo( + MediaDecoderDebugInfo& aInfo) { + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + if (!NS_IsMainThread()) { + // Run the request on the main thread if it's not already. + return InvokeAsync(AbstractThread::MainThread(), __func__, + [this, self = RefPtr{this}, &aInfo]() { + return RequestDebugInfo(aInfo); + }); + } + GetDebugInfo(aInfo); + + return mReader->RequestDebugInfo(aInfo.mReader) + ->Then(AbstractThread::MainThread(), __func__, + [this, self = RefPtr{this}, &aInfo] { + if (!GetStateMachine()) { + return GenericPromise::CreateAndResolve(true, __func__); + } + return GetStateMachine()->RequestDebugInfo(aInfo.mStateMachine); + }); +} + +void MediaDecoder::NotifyAudibleStateChanged() { + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + GetOwner()->SetAudibleState(mIsAudioDataAudible); + mTelemetryProbesReporter->OnAudibleChanged( + mIsAudioDataAudible ? TelemetryProbesReporter::AudibleState::eAudible + : TelemetryProbesReporter::AudibleState::eNotAudible); +} + +void MediaDecoder::NotifyVolumeChanged() { + MOZ_DIAGNOSTIC_ASSERT(!IsShutdown()); + mTelemetryProbesReporter->OnMutedChanged(mVolume == 0.f); +} + +double MediaDecoder::GetTotalVideoPlayTimeInSeconds() const { + return mTelemetryProbesReporter->GetTotalVideoPlayTimeInSeconds(); +} + +double MediaDecoder::GetTotalVideoHDRPlayTimeInSeconds() const { + return mTelemetryProbesReporter->GetTotalVideoHDRPlayTimeInSeconds(); +} + +double MediaDecoder::GetVisibleVideoPlayTimeInSeconds() const { + return mTelemetryProbesReporter->GetVisibleVideoPlayTimeInSeconds(); +} + +double MediaDecoder::GetInvisibleVideoPlayTimeInSeconds() const { + return mTelemetryProbesReporter->GetInvisibleVideoPlayTimeInSeconds(); +} + +double MediaDecoder::GetVideoDecodeSuspendedTimeInSeconds() const { + return mTelemetryProbesReporter->GetVideoDecodeSuspendedTimeInSeconds(); +} + +double MediaDecoder::GetTotalAudioPlayTimeInSeconds() const { + return mTelemetryProbesReporter->GetTotalAudioPlayTimeInSeconds(); +} + +double MediaDecoder::GetAudiblePlayTimeInSeconds() const { + return mTelemetryProbesReporter->GetAudiblePlayTimeInSeconds(); +} + +double MediaDecoder::GetInaudiblePlayTimeInSeconds() const { + return mTelemetryProbesReporter->GetInaudiblePlayTimeInSeconds(); +} + +double MediaDecoder::GetMutedPlayTimeInSeconds() const { + return mTelemetryProbesReporter->GetMutedPlayTimeInSeconds(); +} + +MediaMemoryTracker::MediaMemoryTracker() = default; + +void MediaMemoryTracker::InitMemoryReporter() { + RegisterWeakAsyncMemoryReporter(this); +} + +MediaMemoryTracker::~MediaMemoryTracker() { + UnregisterWeakMemoryReporter(this); +} + +} // namespace mozilla + +// avoid redefined macro in unified build +#undef DUMP +#undef LOG +#undef NS_DispatchToMainThread |