diff options
Diffstat (limited to 'dom/media/MediaDecoder.cpp')
| -rw-r--r-- | dom/media/MediaDecoder.cpp | 1803 |
1 files changed, 1803 insertions, 0 deletions
diff --git a/dom/media/MediaDecoder.cpp b/dom/media/MediaDecoder.cpp new file mode 100644 index 000000000..ab39886ba --- /dev/null +++ b/dom/media/MediaDecoder.cpp @@ -0,0 +1,1803 @@ +/* -*- 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 "mozilla/FloatingPoint.h" +#include "mozilla/MathAlgorithms.h" +#include <limits> +#include "nsIObserver.h" +#include "nsTArray.h" +#include "VideoUtils.h" +#include "MediaDecoderStateMachine.h" +#include "ImageContainer.h" +#include "MediaResource.h" +#include "VideoFrameContainer.h" +#include "nsError.h" +#include "mozilla/Preferences.h" +#include "mozilla/StaticPtr.h" +#include "nsIMemoryReporter.h" +#include "nsComponentManagerUtils.h" +#include <algorithm> +#include "MediaShutdownManager.h" +#include "AudioChannelService.h" +#include "mozilla/dom/AudioTrack.h" +#include "mozilla/dom/AudioTrackList.h" +#include "mozilla/dom/HTMLMediaElement.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/VideoTrack.h" +#include "mozilla/dom/VideoTrackList.h" +#include "nsPrintfCString.h" +#include "mozilla/Telemetry.h" +#include "GMPService.h" +#include "Layers.h" +#include "mozilla/layers/ShadowLayers.h" + +#ifdef MOZ_ANDROID_OMX +#include "AndroidBridge.h" +#endif + +using namespace mozilla::dom; +using namespace mozilla::layers; +using namespace mozilla::media; + +namespace mozilla { + +// The amount of instability we tollerate in calls to +// MediaDecoder::UpdateEstimatedMediaDuration(); changes of duration +// less than this are ignored, as they're assumed to be the result of +// instability in the duration estimation. +static const uint64_t ESTIMATED_DURATION_FUZZ_FACTOR_USECS = USECS_PER_S / 2; + +// avoid redefined macro in unified build +#undef DECODER_LOG +#undef DUMP_LOG + +LazyLogModule gMediaDecoderLog("MediaDecoder"); +#define DECODER_LOG(x, ...) \ + MOZ_LOG(gMediaDecoderLog, LogLevel::Debug, ("Decoder=%p " x, this, ##__VA_ARGS__)) + +#define DUMP_LOG(x, ...) \ + NS_DebugBreak(NS_DEBUG_WARNING, nsPrintfCString("Decoder=%p " x, this, ##__VA_ARGS__).get(), nullptr, nullptr, -1) + +static const char* +ToPlayStateStr(MediaDecoder::PlayState aState) +{ + switch (aState) { + case MediaDecoder::PLAY_STATE_START: return "START"; + 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; + } + + typedef nsTArray<MediaDecoder*> DecodersArray; + 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; + } + } +}; + +StaticRefPtr<MediaMemoryTracker> MediaMemoryTracker::sUniqueInstance; + +#if defined(PR_LOGGING) +LazyLogModule gMediaTimerLog("MediaTimer"); +LazyLogModule gMediaSampleLog("MediaSample"); +#endif + +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) + +NS_IMPL_ISUPPORTS0(MediaDecoder) + + +void +MediaDecoder::ResourceCallback::Connect(MediaDecoder* aDecoder) +{ + MOZ_ASSERT(NS_IsMainThread()); + mDecoder = aDecoder; + mTimer = do_CreateInstance("@mozilla.org/timer;1"); +} + +void +MediaDecoder::ResourceCallback::Disconnect() +{ + MOZ_ASSERT(NS_IsMainThread()); + mDecoder = nullptr; + mTimer->Cancel(); + mTimer = nullptr; +} + +MediaDecoderOwner* +MediaDecoder::ResourceCallback::GetMediaOwner() const +{ + MOZ_ASSERT(NS_IsMainThread()); + return mDecoder ? mDecoder->mOwner : nullptr; +} + +void +MediaDecoder::ResourceCallback::SetInfinite(bool aInfinite) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoder) { + mDecoder->SetInfinite(aInfinite); + } +} + +void +MediaDecoder::ResourceCallback::NotifyNetworkError() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoder) { + mDecoder->NetworkError(); + } +} + +void +MediaDecoder::ResourceCallback::NotifyDecodeError() +{ + RefPtr<ResourceCallback> self = this; + nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () { + if (self->mDecoder) { + self->mDecoder->DecodeError(NS_ERROR_DOM_MEDIA_FATAL_ERR); + } + }); + AbstractThread::MainThread()->Dispatch(r.forget()); +} + +/* static */ void +MediaDecoder::ResourceCallback::TimerCallback(nsITimer* aTimer, void* aClosure) +{ + MOZ_ASSERT(NS_IsMainThread()); + ResourceCallback* thiz = static_cast<ResourceCallback*>(aClosure); + MOZ_ASSERT(thiz->mDecoder); + thiz->mDecoder->NotifyDataArrived(); + thiz->mTimerArmed = false; +} + +void +MediaDecoder::ResourceCallback::NotifyDataArrived() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (!mDecoder || mTimerArmed) { + return; + } + // In situations where these notifications come from stochastic network + // activity, we can save significant computation by throttling the + // calls to MediaDecoder::NotifyDataArrived() which will update the buffer + // ranges of the reader. + mTimerArmed = true; + mTimer->InitWithFuncCallback( + TimerCallback, this, sDelay, nsITimer::TYPE_ONE_SHOT); +} + +void +MediaDecoder::ResourceCallback::NotifyBytesDownloaded() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoder) { + mDecoder->NotifyBytesDownloaded(); + } +} + +void +MediaDecoder::ResourceCallback::NotifyDataEnded(nsresult aStatus) +{ + RefPtr<ResourceCallback> self = this; + nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () { + if (!self->mDecoder) { + return; + } + self->mDecoder->NotifyDownloadEnded(aStatus); + if (NS_SUCCEEDED(aStatus)) { + HTMLMediaElement* element = self->GetMediaOwner()->GetMediaElement(); + if (element) { + element->DownloadSuspended(); + } + // NotifySuspendedStatusChanged will tell the element that download + // has been suspended "by the cache", which is true since we never + // download anything. The element can then transition to HAVE_ENOUGH_DATA. + self->mDecoder->NotifySuspendedStatusChanged(); + } + }); + AbstractThread::MainThread()->Dispatch(r.forget()); +} + +void +MediaDecoder::ResourceCallback::NotifyPrincipalChanged() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoder) { + mDecoder->NotifyPrincipalChanged(); + } +} + +void +MediaDecoder::ResourceCallback::NotifySuspendedStatusChanged() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoder) { + mDecoder->NotifySuspendedStatusChanged(); + } +} + +void +MediaDecoder::ResourceCallback::NotifyBytesConsumed(int64_t aBytes, + int64_t aOffset) +{ + RefPtr<ResourceCallback> self = this; + nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () { + if (self->mDecoder) { + self->mDecoder->NotifyBytesConsumed(aBytes, aOffset); + } + }); + AbstractThread::MainThread()->Dispatch(r.forget()); +} + +void +MediaDecoder::NotifyOwnerActivityChanged(bool aIsVisible) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + SetElementVisibility(aIsVisible); + + MediaDecoderOwner* owner = GetOwner(); + NS_ENSURE_TRUE_VOID(owner); + + dom::HTMLMediaElement* element = owner->GetMediaElement(); + NS_ENSURE_TRUE_VOID(element); + + RefPtr<LayerManager> layerManager = + nsContentUtils::LayerManagerForDocument(element->OwnerDoc()); + NS_ENSURE_TRUE_VOID(layerManager); + + RefPtr<KnowsCompositor> knowsCompositor = layerManager->AsShadowForwarder(); + mCompositorUpdatedEvent.Notify(knowsCompositor); +} + +void +MediaDecoder::Pause() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + 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; +} + +void +MediaDecoder::AddOutputStream(ProcessedMediaStream* aStream, + bool aFinishWhenEnded) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load()."); + mDecoderStateMachine->AddOutputStream(aStream, aFinishWhenEnded); +} + +void +MediaDecoder::RemoveOutputStream(MediaStream* aStream) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mDecoderStateMachine, "Must be called after Load()."); + mDecoderStateMachine->RemoveOutputStream(aStream); +} + +double +MediaDecoder::GetDuration() +{ + MOZ_ASSERT(NS_IsMainThread()); + return mDuration; +} + +AbstractCanonical<media::NullableTimeUnit>* +MediaDecoder::CanonicalDurationOrNull() +{ + MOZ_ASSERT(mDecoderStateMachine); + return mDecoderStateMachine->CanonicalDuration(); +} + +void +MediaDecoder::SetInfinite(bool aInfinite) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + mInfiniteStream = aInfinite; + DurationChanged(); +} + +bool +MediaDecoder::IsInfinite() const +{ + MOZ_ASSERT(NS_IsMainThread()); + return mInfiniteStream; +} + +#define INIT_MIRROR(name, val) \ + name(AbstractThread::MainThread(), val, "MediaDecoder::" #name " (Mirror)") +#define INIT_CANONICAL(name, val) \ + name(AbstractThread::MainThread(), val, "MediaDecoder::" #name " (Canonical)") + +MediaDecoder::MediaDecoder(MediaDecoderOwner* aOwner) + : mWatchManager(this, AbstractThread::MainThread()) + , mLogicalPosition(0.0) + , mDuration(std::numeric_limits<double>::quiet_NaN()) + , mResourceCallback(new ResourceCallback()) + , mCDMProxyPromise(mCDMProxyPromiseHolder.Ensure(__func__)) + , mIgnoreProgressData(false) + , mInfiniteStream(false) + , mOwner(aOwner) + , mFrameStats(new FrameStatistics()) + , mVideoFrameContainer(aOwner->GetVideoFrameContainer()) + , mPlaybackStatistics(new MediaChannelStatistics()) + , mPinnedForSeek(false) + , mMinimizePreroll(false) + , mMediaTracksConstructed(false) + , mFiredMetadataLoaded(false) + , mElementVisible(!aOwner->IsHidden()) + , mForcedHidden(false) + , INIT_MIRROR(mStateMachineIsShutdown, true) + , INIT_MIRROR(mBuffered, TimeIntervals()) + , INIT_MIRROR(mNextFrameStatus, MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE) + , INIT_MIRROR(mCurrentPosition, 0) + , INIT_MIRROR(mStateMachineDuration, NullableTimeUnit()) + , INIT_MIRROR(mPlaybackPosition, 0) + , INIT_MIRROR(mIsAudioDataAudible, false) + , INIT_CANONICAL(mVolume, 0.0) + , INIT_CANONICAL(mPreservesPitch, true) + , INIT_CANONICAL(mEstimatedDuration, NullableTimeUnit()) + , INIT_CANONICAL(mExplicitDuration, Maybe<double>()) + , INIT_CANONICAL(mPlayState, PLAY_STATE_LOADING) + , INIT_CANONICAL(mNextState, PLAY_STATE_PAUSED) + , INIT_CANONICAL(mLogicallySeeking, false) + , INIT_CANONICAL(mSameOriginMedia, false) + , INIT_CANONICAL(mMediaPrincipalHandle, PRINCIPAL_HANDLE_NONE) + , INIT_CANONICAL(mPlaybackBytesPerSecond, 0.0) + , INIT_CANONICAL(mPlaybackRateReliable, true) + , INIT_CANONICAL(mDecoderPosition, 0) + , INIT_CANONICAL(mIsVisible, !aOwner->IsHidden()) + , mTelemetryReported(false) +{ + MOZ_COUNT_CTOR(MediaDecoder); + MOZ_ASSERT(NS_IsMainThread()); + MediaMemoryTracker::AddMediaDecoder(this); + + mAudioChannel = AudioChannelService::GetDefaultAudioChannel(); + mResourceCallback->Connect(this); + + // + // Initialize watchers. + // + + // mDuration + mWatchManager.Watch(mStateMachineDuration, &MediaDecoder::DurationChanged); + + // mStateMachineIsShutdown + mWatchManager.Watch(mStateMachineIsShutdown, &MediaDecoder::ShutdownBitChanged); + + // readyState + mWatchManager.Watch(mPlayState, &MediaDecoder::UpdateReadyState); + mWatchManager.Watch(mNextFrameStatus, &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); + + // mIgnoreProgressData + mWatchManager.Watch(mLogicallySeeking, &MediaDecoder::SeekingChanged); + + mWatchManager.Watch(mIsAudioDataAudible, &MediaDecoder::NotifyAudibleStateChanged); + + MediaShutdownManager::InitStatics(); +} + +#undef INIT_MIRROR +#undef INIT_CANONICAL + +void +MediaDecoder::Shutdown() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + // Unwatch all watch targets to prevent further notifications. + mWatchManager.Shutdown(); + + mResourceCallback->Disconnect(); + + mCDMProxyPromiseHolder.RejectIfExists(true, __func__); + + 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) { + mTimedMetadataListener.Disconnect(); + mMetadataLoadedListener.Disconnect(); + mFirstFrameLoadedListener.Disconnect(); + mOnPlaybackEvent.Disconnect(); + mOnPlaybackErrorEvent.Disconnect(); + mOnDecoderDoctorEvent.Disconnect(); + mOnMediaNotSeekable.Disconnect(); + + mDecoderStateMachine->BeginShutdown() + ->Then(AbstractThread::MainThread(), __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([self] () { + self->mVideoFrameContainer = nullptr; + MediaShutdownManager::Instance().Unregister(self); + }); + AbstractThread::MainThread()->Dispatch(r.forget()); + } + + // Force any outstanding seek and byterange requests to complete + // to prevent shutdown from deadlocking. + if (mResource) { + mResource->Close(); + } + + ChangeState(PLAY_STATE_SHUTDOWN); + mOwner = nullptr; +} + +void +MediaDecoder::NotifyXPCOMShutdown() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (auto owner = GetOwner()) { + owner->NotifyXPCOMShutdown(); + } + MOZ_DIAGNOSTIC_ASSERT(IsShutdown()); + + // Don't cause grief to release builds by ensuring Shutdown() + // is always called during shutdown phase. + if (!IsShutdown()) { + Shutdown(); + } +} + +MediaDecoder::~MediaDecoder() +{ + MOZ_ASSERT(NS_IsMainThread()); + MediaMemoryTracker::RemoveMediaDecoder(this); + UnpinForSeek(); + MOZ_COUNT_DTOR(MediaDecoder); +} + +void +MediaDecoder::OnPlaybackEvent(MediaEventType aEvent) +{ + switch (aEvent) { + case MediaEventType::PlaybackStarted: + mPlaybackStatistics->Start(); + break; + case MediaEventType::PlaybackStopped: + mPlaybackStatistics->Stop(); + ComputePlaybackRate(); + break; + case MediaEventType::PlaybackEnded: + PlaybackEnded(); + break; + case MediaEventType::SeekStarted: + SeekingStarted(); + break; + case MediaEventType::Invalidate: + Invalidate(); + break; + case MediaEventType::EnterVideoSuspend: + mOwner->DispatchAsyncEvent(NS_LITERAL_STRING("mozentervideosuspend")); + break; + case MediaEventType::ExitVideoSuspend: + mOwner->DispatchAsyncEvent(NS_LITERAL_STRING("mozexitvideosuspend")); + break; + } +} + +void +MediaDecoder::OnPlaybackErrorEvent(const MediaResult& aError) +{ + DecodeError(aError); +} + +void +MediaDecoder::OnDecoderDoctorEvent(DecoderDoctorEvent aEvent) +{ + MOZ_ASSERT(NS_IsMainThread()); + // OnDecoderDoctorEvent is disconnected at shutdown time. + MOZ_ASSERT(!IsShutdown()); + HTMLMediaElement* element = mOwner->GetMediaElement(); + if (!element) { + return; + } + nsIDocument* doc = element->OwnerDoc(); + if (!doc) { + return; + } + DecoderDoctorDiagnostics diags; + diags.StoreEvent(doc, aEvent, __func__); +} + +void +MediaDecoder::FinishShutdown() +{ + MOZ_ASSERT(NS_IsMainThread()); + mDecoderStateMachine->BreakCycles(); + SetStateMachine(nullptr); + mVideoFrameContainer = nullptr; + MediaShutdownManager::Instance().Unregister(this); +} + +MediaResourceCallback* +MediaDecoder::GetResourceCallback() const +{ + return mResourceCallback; +} + +nsresult +MediaDecoder::OpenResource(nsIStreamListener** aStreamListener) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (aStreamListener) { + *aStreamListener = nullptr; + } + return mResource->Open(aStreamListener); +} + +nsresult +MediaDecoder::Load(nsIStreamListener** aStreamListener) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mResource, "Can't load without a MediaResource"); + + nsresult rv = MediaShutdownManager::Instance().Register(this); + if (NS_WARN_IF(NS_FAILED(rv))) { + return rv; + } + + rv = OpenResource(aStreamListener); + NS_ENSURE_SUCCESS(rv, rv); + + SetStateMachine(CreateStateMachine()); + NS_ENSURE_TRUE(GetStateMachine(), NS_ERROR_FAILURE); + + return InitializeStateMachine(); +} + +nsresult +MediaDecoder::InitializeStateMachine() +{ + MOZ_ASSERT(NS_IsMainThread()); + NS_ASSERTION(mDecoderStateMachine, "Cannot initialize null state machine!"); + + 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 (mMinimizePreroll) { + mDecoderStateMachine->DispatchMinimizePrerollUntilPlaybackStarts(); + } + if (mPlaybackRate != 1 && mPlaybackRate != 0) { + mDecoderStateMachine->DispatchSetPlaybackRate(mPlaybackRate); + } + mTimedMetadataListener = mDecoderStateMachine->TimedMetadataEvent().Connect( + AbstractThread::MainThread(), this, &MediaDecoder::OnMetadataUpdate); + mMetadataLoadedListener = mDecoderStateMachine->MetadataLoadedEvent().Connect( + AbstractThread::MainThread(), this, &MediaDecoder::MetadataLoaded); + mFirstFrameLoadedListener = mDecoderStateMachine->FirstFrameLoadedEvent().Connect( + AbstractThread::MainThread(), this, &MediaDecoder::FirstFrameLoaded); + + mOnPlaybackEvent = mDecoderStateMachine->OnPlaybackEvent().Connect( + AbstractThread::MainThread(), this, &MediaDecoder::OnPlaybackEvent); + mOnPlaybackErrorEvent = mDecoderStateMachine->OnPlaybackErrorEvent().Connect( + AbstractThread::MainThread(), this, &MediaDecoder::OnPlaybackErrorEvent); + mOnDecoderDoctorEvent = mDecoderStateMachine->OnDecoderDoctorEvent().Connect( + AbstractThread::MainThread(), this, &MediaDecoder::OnDecoderDoctorEvent); + mOnMediaNotSeekable = mDecoderStateMachine->OnMediaNotSeekable().Connect( + AbstractThread::MainThread(), this, &MediaDecoder::OnMediaNotSeekable); +} + +void +MediaDecoder::SetMinimizePrerollUntilPlaybackStarts() +{ + MOZ_ASSERT(NS_IsMainThread()); + DECODER_LOG("SetMinimizePrerollUntilPlaybackStarts()"); + mMinimizePreroll = true; + + // This needs to be called before we init the state machine, otherwise it will + // have no effect. + MOZ_DIAGNOSTIC_ASSERT(!mDecoderStateMachine); +} + +nsresult +MediaDecoder::Play() +{ + MOZ_ASSERT(NS_IsMainThread()); + + NS_ASSERTION(mDecoderStateMachine != nullptr, "Should have state machine."); + if (mPlaybackRate == 0) { + return NS_OK; + } + + if (IsEnded()) { + return Seek(0, SeekTarget::PrevSyncPoint); + } else if (mPlayState == PLAY_STATE_LOADING) { + mNextState = PLAY_STATE_PLAYING; + return NS_OK; + } + + ChangeState(PLAY_STATE_PLAYING); + return NS_OK; +} + +nsresult +MediaDecoder::Seek(double aTime, SeekTarget::Type aSeekType, dom::Promise* aPromise /*=nullptr*/) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + MOZ_ASSERT(aTime >= 0.0, "Cannot seek to a negative value."); + + int64_t timeUsecs = TimeUnit::FromSeconds(aTime).ToMicroseconds(); + + mLogicalPosition = aTime; + + mLogicallySeeking = true; + SeekTarget target = SeekTarget(timeUsecs, aSeekType); + CallSeek(target, aPromise); + + if (mPlayState == PLAY_STATE_ENDED) { + PinForSeek(); + ChangeState(mOwner->GetPaused() ? PLAY_STATE_PAUSED : PLAY_STATE_PLAYING); + } + return NS_OK; +} + +void +MediaDecoder::AsyncResolveSeekDOMPromiseIfExists() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mSeekDOMPromise) { + RefPtr<dom::Promise> promise = mSeekDOMPromise; + nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () { + promise->MaybeResolveWithUndefined(); + }); + AbstractThread::MainThread()->Dispatch(r.forget()); + mSeekDOMPromise = nullptr; + } +} + +void +MediaDecoder::AsyncRejectSeekDOMPromiseIfExists() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mSeekDOMPromise) { + RefPtr<dom::Promise> promise = mSeekDOMPromise; + nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction([=] () { + promise->MaybeReject(NS_ERROR_DOM_ABORT_ERR); + }); + AbstractThread::MainThread()->Dispatch(r.forget()); + mSeekDOMPromise = nullptr; + } +} + +void +MediaDecoder::DiscardOngoingSeekIfExists() +{ + MOZ_ASSERT(NS_IsMainThread()); + mSeekRequest.DisconnectIfExists(); + AsyncRejectSeekDOMPromiseIfExists(); +} + +void +MediaDecoder::CallSeek(const SeekTarget& aTarget, dom::Promise* aPromise) +{ + MOZ_ASSERT(NS_IsMainThread()); + DiscardOngoingSeekIfExists(); + + mSeekDOMPromise = aPromise; + mSeekRequest.Begin( + mDecoderStateMachine->InvokeSeek(aTarget) + ->Then(AbstractThread::MainThread(), __func__, this, + &MediaDecoder::OnSeekResolved, &MediaDecoder::OnSeekRejected)); +} + +double +MediaDecoder::GetCurrentTime() +{ + MOZ_ASSERT(NS_IsMainThread()); + return mLogicalPosition; +} + +already_AddRefed<nsIPrincipal> +MediaDecoder::GetCurrentPrincipal() +{ + MOZ_ASSERT(NS_IsMainThread()); + return mResource ? mResource->GetCurrentPrincipal() : nullptr; +} + +void +MediaDecoder::OnMetadataUpdate(TimedMetadata&& aMetadata) +{ + MOZ_ASSERT(NS_IsMainThread()); + RemoveMediaTracks(); + MetadataLoaded(nsAutoPtr<MediaInfo>(new MediaInfo(*aMetadata.mInfo)), + Move(aMetadata.mTags), + MediaDecoderEventVisibility::Observable); + FirstFrameLoaded(Move(aMetadata.mInfo), + MediaDecoderEventVisibility::Observable); +} + +void +MediaDecoder::MetadataLoaded(nsAutoPtr<MediaInfo> aInfo, + nsAutoPtr<MetadataTags> aTags, + MediaDecoderEventVisibility aEventVisibility) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + DECODER_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 = aInfo.forget(); + ConstructMediaTracks(); + + // Make sure the element and the frame (if any) are told about + // our new size. + if (aEventVisibility != MediaDecoderEventVisibility::Suppressed) { + mFiredMetadataLoaded = true; + mOwner->MetadataLoaded(mInfo, nsAutoPtr<const MetadataTags>(aTags.forget())); + } + // Invalidate() will end up calling mOwner->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 mOwner->MetadataLoaded to ensure + // the media element has the latest dimensions. + Invalidate(); + + 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()) { + if (mResource->GetContentType().IsEmpty()) { + NS_WARNING("Somehow the resource's content type is empty"); + return; + } + codecs.AppendElement(nsPrintfCString("resource; %s", mResource->GetContentType().get())); + } + for (const nsCString& codec : codecs) { + DECODER_LOG("Telemetry MEDIA_CODEC_USED= '%s'", codec.get()); + Telemetry::Accumulate(Telemetry::ID::MEDIA_CODEC_USED, codec); + } + + mTelemetryReported = true; +} + +const char* +MediaDecoder::PlayStateStr() +{ + MOZ_ASSERT(NS_IsMainThread()); + return ToPlayStateStr(mPlayState); +} + +void +MediaDecoder::FirstFrameLoaded(nsAutoPtr<MediaInfo> aInfo, + MediaDecoderEventVisibility aEventVisibility) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + DECODER_LOG("FirstFrameLoaded, channels=%u rate=%u hasAudio=%d hasVideo=%d mPlayState=%s", + aInfo->mAudio.mChannels, aInfo->mAudio.mRate, + aInfo->HasAudio(), aInfo->HasVideo(), PlayStateStr()); + + mInfo = aInfo.forget(); + + Invalidate(); + + // This can run cache callbacks. + mResource->EnsureCacheUpToDate(); + + // 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); + } + + // Run NotifySuspendedStatusChanged now to give us a chance to notice + // that autoplay should run. + NotifySuspendedStatusChanged(); + + // mOwner->FirstFrameLoaded() might call us back. Put it at the bottom of + // this function to avoid unexpected shutdown from reentrant calls. + if (aEventVisibility != MediaDecoderEventVisibility::Suppressed) { + mOwner->FirstFrameLoaded(); + } +} + +void +MediaDecoder::NetworkError() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + mOwner->NetworkError(); +} + +void +MediaDecoder::DecodeError(const MediaResult& aError) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + mOwner->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_ASSERT(!IsShutdown()); + return mOwner->HasError(); +} + +class MediaElementGMPCrashHelper : public GMPCrashHelper +{ +public: + explicit MediaElementGMPCrashHelper(HTMLMediaElement* aElement) + : mElement(aElement) + { + MOZ_ASSERT(NS_IsMainThread()); // WeakPtr isn't thread safe. + } + already_AddRefed<nsPIDOMWindowInner> GetPluginCrashedEventTarget() override + { + MOZ_ASSERT(NS_IsMainThread()); // WeakPtr isn't thread safe. + if (!mElement) { + return nullptr; + } + return do_AddRef(mElement->OwnerDoc()->GetInnerWindow()); + } +private: + WeakPtr<HTMLMediaElement> mElement; +}; + +already_AddRefed<GMPCrashHelper> +MediaDecoder::GetCrashHelper() +{ + MOZ_ASSERT(NS_IsMainThread()); + return mOwner->GetMediaElement() ? + MakeAndAddRef<MediaElementGMPCrashHelper>(mOwner->GetMediaElement()) : nullptr; +} + +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_ASSERT(!IsShutdown()); + + if (mLogicallySeeking || mPlayState == PLAY_STATE_LOADING) { + return; + } + + ChangeState(PLAY_STATE_ENDED); + InvalidateWithFlags(VideoFrameContainer::INVALIDATE_FORCE); + mOwner->PlaybackEnded(); + + // This must be called after |mOwner->PlaybackEnded()| call above, in order + // to fire the required durationchange. + if (IsInfinite()) { + SetInfinite(false); + } +} + +MediaStatistics +MediaDecoder::GetStatistics() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mResource); + + MediaStatistics result; + result.mDownloadRate = mResource->GetDownloadRate(&result.mDownloadRateReliable); + result.mDownloadPosition = mResource->GetCachedDataEnd(mDecoderPosition); + result.mTotalBytes = mResource->GetLength(); + result.mPlaybackRate = mPlaybackBytesPerSecond; + result.mPlaybackRateReliable = mPlaybackRateReliable; + result.mDecoderPosition = mDecoderPosition; + result.mPlaybackPosition = mPlaybackPosition; + return result; +} + +void +MediaDecoder::ComputePlaybackRate() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mResource); + + int64_t length = mResource->GetLength(); + if (!IsNaN(mDuration) && !mozilla::IsInfinite<double>(mDuration) && length >= 0) { + mPlaybackRateReliable = true; + mPlaybackBytesPerSecond = length / mDuration; + return; + } + + bool reliable = false; + mPlaybackBytesPerSecond = mPlaybackStatistics->GetRateAtLastStop(&reliable); + mPlaybackRateReliable = reliable; +} + +void +MediaDecoder::UpdatePlaybackRate() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(mResource); + + ComputePlaybackRate(); + uint32_t rate = mPlaybackBytesPerSecond; + + if (mPlaybackRateReliable) { + // Avoid passing a zero rate + rate = std::max(rate, 1u); + } else { + // Set a minimum rate of 10,000 bytes per second ... sometimes we just + // don't have good data + rate = std::max(rate, 10000u); + } + + mResource->SetPlaybackRate(rate); +} + +void +MediaDecoder::NotifySuspendedStatusChanged() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + if (mResource) { + bool suspended = mResource->IsSuspendedByCache(); + mOwner->NotifySuspendedByCache(suspended); + } +} + +void +MediaDecoder::NotifyBytesDownloaded() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + UpdatePlaybackRate(); + mOwner->DownloadProgressed(); +} + +void +MediaDecoder::NotifyDownloadEnded(nsresult aStatus) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + DECODER_LOG("NotifyDownloadEnded, status=%x", aStatus); + + if (aStatus == NS_BINDING_ABORTED) { + // Download has been cancelled by user. + mOwner->LoadAborted(); + return; + } + + UpdatePlaybackRate(); + + if (NS_SUCCEEDED(aStatus)) { + // A final progress event will be fired by the MediaResource calling + // DownloadSuspended on the element. + // Also NotifySuspendedStatusChanged() will be called to update readyState + // if download ended with success. + } else if (aStatus != NS_BASE_STREAM_CLOSED) { + NetworkError(); + } +} + +void +MediaDecoder::NotifyPrincipalChanged() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + nsCOMPtr<nsIPrincipal> newPrincipal = GetCurrentPrincipal(); + mMediaPrincipalHandle = MakePrincipalHandle(newPrincipal); + mOwner->NotifyDecoderPrincipalChanged(); +} + +void +MediaDecoder::NotifyBytesConsumed(int64_t aBytes, int64_t aOffset) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + if (mIgnoreProgressData) { + return; + } + + MOZ_ASSERT(mDecoderStateMachine); + if (aOffset >= mDecoderPosition) { + mPlaybackStatistics->AddBytes(aBytes); + } + mDecoderPosition = aOffset + aBytes; +} + +void +MediaDecoder::OnSeekResolved(SeekResolveValue aVal) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + mSeekRequest.Complete(); + + bool fireEnded = false; + { + // An additional seek was requested while the current seek was + // in operation. + UnpinForSeek(); + fireEnded = aVal.mAtEnd; + if (aVal.mAtEnd) { + ChangeState(PLAY_STATE_ENDED); + } + mLogicallySeeking = false; + } + + // Ensure logical position is updated after seek. + UpdateLogicalPositionInternal(); + + mOwner->SeekCompleted(); + AsyncResolveSeekDOMPromiseIfExists(); + if (fireEnded) { + mOwner->PlaybackEnded(); + } +} + +void +MediaDecoder::OnSeekRejected() +{ + MOZ_ASSERT(NS_IsMainThread()); + mSeekRequest.Complete(); + mLogicallySeeking = false; + AsyncRejectSeekDOMPromiseIfExists(); +} + +void +MediaDecoder::SeekingStarted() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + mOwner->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; + } + + DECODER_LOG("ChangeState %s => %s", PlayStateStr(), ToPlayStateStr(aState)); + mPlayState = aState; + + if (mPlayState == PLAY_STATE_PLAYING) { + ConstructMediaTracks(); + } else if (IsEnded()) { + RemoveMediaTracks(); + } +} + +void +MediaDecoder::UpdateLogicalPositionInternal() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + double currentPosition = static_cast<double>(CurrentPosition()) / static_cast<double>(USECS_PER_S); + if (mPlayState == PLAY_STATE_ENDED) { + currentPosition = std::max(currentPosition, mDuration); + } + bool logicalPositionChanged = mLogicalPosition != currentPosition; + mLogicalPosition = currentPosition; + + // 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(); + + if (logicalPositionChanged) { + FireTimeUpdate(); + } +} + +void +MediaDecoder::DurationChanged() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + double oldDuration = mDuration; + if (IsInfinite()) { + mDuration = std::numeric_limits<double>::infinity(); + } else if (mExplicitDuration.Ref().isSome()) { + mDuration = mExplicitDuration.Ref().ref(); + } else if (mStateMachineDuration.Ref().isSome()) { + mDuration = mStateMachineDuration.Ref().ref().ToSeconds(); + } + + if (mDuration == oldDuration || IsNaN(mDuration)) { + return; + } + + DECODER_LOG("Duration changed to %f", mDuration); + + // Duration has changed so we should recompute playback rate + UpdatePlaybackRate(); + + // 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 && + (!mozilla::IsInfinite<double>(mDuration) || mExplicitDuration.Ref().isSome())) { + mOwner->DispatchAsyncEvent(NS_LITERAL_STRING("durationchange")); + } + + if (CurrentPosition() > TimeUnit::FromSeconds(mDuration).ToMicroseconds()) { + Seek(mDuration, SeekTarget::Accurate); + } +} + +void +MediaDecoder::SetElementVisibility(bool aIsVisible) +{ + MOZ_ASSERT(NS_IsMainThread()); + mElementVisible = aIsVisible; + mIsVisible = !mForcedHidden && mElementVisible; +} + +void +MediaDecoder::SetForcedHidden(bool aForcedHidden) +{ + MOZ_ASSERT(NS_IsMainThread()); + mForcedHidden = aForcedHidden; + SetElementVisibility(mElementVisible); +} + +void +MediaDecoder::UpdateEstimatedMediaDuration(int64_t aDuration) +{ + MOZ_ASSERT(NS_IsMainThread()); + + if (mPlayState <= PLAY_STATE_LOADING) { + return; + } + + // The duration is only changed if its significantly different than the + // the current estimate, as the incoming duration is an estimate and so + // often is unstable as more data is read and the estimate is updated. + // Can result in a durationchangeevent. aDuration is in microseconds. + if (mEstimatedDuration.Ref().isSome() && + mozilla::Abs(mEstimatedDuration.Ref().ref().ToMicroseconds() - aDuration) < ESTIMATED_DURATION_FUZZ_FACTOR_USECS) { + return; + } + + mEstimatedDuration = Some(TimeUnit::FromMicroseconds(aDuration)); +} + +bool +MediaDecoder::IsTransportSeekable() +{ + MOZ_ASSERT(NS_IsMainThread()); + return GetResource()->IsTransportSeekable(); +} + +bool +MediaDecoder::IsMediaSeekable() +{ + MOZ_ASSERT(NS_IsMainThread()); + NS_ENSURE_TRUE(GetStateMachine(), false); + return mMediaSeekable; +} + +media::TimeIntervals +MediaDecoder::GetSeekable() +{ + MOZ_ASSERT(NS_IsMainThread()); + + if (IsNaN(GetDuration())) { + // We do not have a duration yet, we can't determine the seekable range. + return TimeIntervals(); + } + + // 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 GetBuffered(); + } else if (!IsMediaSeekable()) { + return media::TimeIntervals(); + } else if (!IsTransportSeekable()) { + return GetBuffered(); + } else { + return media::TimeIntervals( + media::TimeInterval(media::TimeUnit::FromMicroseconds(0), + IsInfinite() ? + media::TimeUnit::FromInfinity() : + media::TimeUnit::FromSeconds(GetDuration()))); + } +} + +void +MediaDecoder::SetFragmentEndTime(double aTime) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mDecoderStateMachine) { + mDecoderStateMachine->DispatchSetFragmentEndTime(static_cast<int64_t>(aTime * USECS_PER_S)); + } +} + +void +MediaDecoder::Suspend() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mResource) { + mResource->Suspend(true); + } +} + +void +MediaDecoder::Resume() +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mResource) { + mResource->Resume(); + } +} + +void +MediaDecoder::SetLoadInBackground(bool aLoadInBackground) +{ + MOZ_ASSERT(NS_IsMainThread()); + if (mResource) { + mResource->SetLoadInBackground(aLoadInBackground); + } +} + +void +MediaDecoder::SetPlaybackRate(double aPlaybackRate) +{ + MOZ_ASSERT(NS_IsMainThread()); + + double oldRate = mPlaybackRate; + mPlaybackRate = aPlaybackRate; + if (aPlaybackRate == 0) { + Pause(); + return; + } + + + if (oldRate == 0 && !mOwner->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::ConnectMirrors(MediaDecoderStateMachine* aObject) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aObject); + mStateMachineDuration.Connect(aObject->CanonicalDuration()); + mBuffered.Connect(aObject->CanonicalBuffered()); + mStateMachineIsShutdown.Connect(aObject->CanonicalIsShutdown()); + mNextFrameStatus.Connect(aObject->CanonicalNextFrameStatus()); + mCurrentPosition.Connect(aObject->CanonicalCurrentPosition()); + mPlaybackPosition.Connect(aObject->CanonicalPlaybackOffset()); + mIsAudioDataAudible.Connect(aObject->CanonicalIsAudioDataAudible()); +} + +void +MediaDecoder::DisconnectMirrors() +{ + MOZ_ASSERT(NS_IsMainThread()); + mStateMachineDuration.DisconnectIfConnected(); + mBuffered.DisconnectIfConnected(); + mStateMachineIsShutdown.DisconnectIfConnected(); + mNextFrameStatus.DisconnectIfConnected(); + mCurrentPosition.DisconnectIfConnected(); + mPlaybackPosition.DisconnectIfConnected(); + mIsAudioDataAudible.DisconnectIfConnected(); +} + +void +MediaDecoder::SetStateMachine(MediaDecoderStateMachine* aStateMachine) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT_IF(aStateMachine, !mDecoderStateMachine); + mDecoderStateMachine = aStateMachine; + if (aStateMachine) { + ConnectMirrors(aStateMachine); + } else { + 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(); + } +} + +// 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::AddSizeOfResources(ResourceSizes* aSizes) { + MOZ_ASSERT(NS_IsMainThread()); + if (GetResource()) { + aSizes->mByteSize += GetResource()->SizeOfIncludingThis(aSizes->mMallocSizeOf); + } +} + +void +MediaDecoder::NotifyDataArrived() { + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + mDataArrivedEvent.Notify(); +} + +// Provide access to the state machine object +MediaDecoderStateMachine* +MediaDecoder::GetStateMachine() const { + MOZ_ASSERT(NS_IsMainThread()); + return mDecoderStateMachine; +} + +void +MediaDecoder::FireTimeUpdate() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + mOwner->FireTimeUpdate(true); +} + +void +MediaDecoder::PinForSeek() +{ + MOZ_ASSERT(NS_IsMainThread()); + MediaResource* resource = GetResource(); + if (!resource || mPinnedForSeek) { + return; + } + mPinnedForSeek = true; + resource->Pin(); +} + +void +MediaDecoder::UnpinForSeek() +{ + MOZ_ASSERT(NS_IsMainThread()); + MediaResource* resource = GetResource(); + if (!resource || !mPinnedForSeek) { + return; + } + mPinnedForSeek = false; + resource->Unpin(); +} + +bool +MediaDecoder::CanPlayThrough() +{ + MOZ_ASSERT(NS_IsMainThread()); + NS_ENSURE_TRUE(mDecoderStateMachine, false); + return GetStatistics().CanPlayThrough(); +} + +RefPtr<MediaDecoder::CDMProxyPromise> +MediaDecoder::RequestCDMProxy() const +{ + return mCDMProxyPromise; +} + +void +MediaDecoder::SetCDMProxy(CDMProxy* aProxy) +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(aProxy); + + mCDMProxyPromiseHolder.ResolveIfExists(aProxy, __func__); +} + +bool +MediaDecoder::IsOpusEnabled() +{ + return Preferences::GetBool("media.opus.enabled"); +} + +bool +MediaDecoder::IsOggEnabled() +{ + return Preferences::GetBool("media.ogg.enabled"); +} + +bool +MediaDecoder::IsWaveEnabled() +{ + return Preferences::GetBool("media.wave.enabled"); +} + +bool +MediaDecoder::IsWebMEnabled() +{ + return Preferences::GetBool("media.webm.enabled"); +} + +#ifdef MOZ_ANDROID_OMX +bool +MediaDecoder::IsAndroidMediaPluginEnabled() +{ + return AndroidBridge::Bridge() && + AndroidBridge::Bridge()->GetAPIVersion() < 16 && + Preferences::GetBool("media.plugins.enabled"); +} +#endif + +NS_IMETHODIMP +MediaMemoryTracker::CollectReports(nsIHandleReportCallback* aHandleReport, + nsISupports* aData, bool aAnonymize) +{ + int64_t video = 0, audio = 0; + + // 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( + EmptyCString(), NS_LITERAL_CSTRING("explicit/media/resources"), + KIND_HEAP, UNITS_BYTES, size, + NS_LITERAL_CSTRING("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 */ }); + + DecodersArray& decoders = Decoders(); + for (size_t i = 0; i < decoders.Length(); ++i) { + MediaDecoder* decoder = decoders[i]; + video += decoder->SizeOfVideoQueue(); + audio += 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; +} + +void +MediaDecoder::ConstructMediaTracks() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + if (mMediaTracksConstructed || !mInfo) { + return; + } + + HTMLMediaElement* element = mOwner->GetMediaElement(); + if (!element) { + return; + } + + mMediaTracksConstructed = true; + + AudioTrackList* audioList = element->AudioTracks(); + if (audioList && mInfo->HasAudio()) { + const TrackInfo& info = mInfo->mAudio; + RefPtr<AudioTrack> track = MediaTrackList::CreateAudioTrack( + info.mId, info.mKind, info.mLabel, info.mLanguage, info.mEnabled); + + audioList->AddTrack(track); + } + + VideoTrackList* videoList = element->VideoTracks(); + if (videoList && mInfo->HasVideo()) { + const TrackInfo& info = mInfo->mVideo; + RefPtr<VideoTrack> track = MediaTrackList::CreateVideoTrack( + info.mId, info.mKind, info.mLabel, info.mLanguage); + + videoList->AddTrack(track); + track->SetEnabledInternal(info.mEnabled, MediaTrack::FIRE_NO_EVENTS); + } +} + +void +MediaDecoder::RemoveMediaTracks() +{ + MOZ_ASSERT(NS_IsMainThread()); + MOZ_ASSERT(!IsShutdown()); + + HTMLMediaElement* element = mOwner->GetMediaElement(); + if (!element) { + return; + } + + AudioTrackList* audioList = element->AudioTracks(); + if (audioList) { + audioList->RemoveTracks(); + } + + VideoTrackList* videoList = element->VideoTracks(); + if (videoList) { + videoList->RemoveTracks(); + } + + mMediaTracksConstructed = false; +} + +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. + media::TimeUnit currentPosition = + media::TimeUnit::FromMicroseconds(CurrentPosition()); + media::TimeInterval interval(currentPosition, + currentPosition + media::TimeUnit::FromMicroseconds(DEFAULT_NEXT_FRAME_AVAILABLE_BUFFERED)); + return GetBuffered().Contains(interval) + ? MediaDecoderOwner::NEXT_FRAME_AVAILABLE + : MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE; +} + +void +MediaDecoder::DumpDebugInfo() +{ + MOZ_ASSERT(!IsShutdown()); + DUMP_LOG("metadata: channels=%u rate=%u hasAudio=%d hasVideo=%d, " + "state: mPlayState=%s mdsm=%p", + mInfo ? mInfo->mAudio.mChannels : 0, mInfo ? mInfo->mAudio.mRate : 0, + mInfo ? mInfo->HasAudio() : 0, mInfo ? mInfo->HasVideo() : 0, + PlayStateStr(), GetStateMachine()); + + nsString str; + GetMozDebugReaderData(str); + if (!str.IsEmpty()) { + DUMP_LOG("reader data:\n%s", NS_ConvertUTF16toUTF8(str).get()); + } + + if (GetStateMachine()) { + GetStateMachine()->DumpDebugInfo(); + } +} + +void +MediaDecoder::NotifyAudibleStateChanged() +{ + MOZ_ASSERT(!IsShutdown()); + mOwner->SetAudibleState(mIsAudioDataAudible); +} + +MediaMemoryTracker::MediaMemoryTracker() +{ +} + +void +MediaMemoryTracker::InitMemoryReporter() +{ + RegisterWeakAsyncMemoryReporter(this); +} + +MediaMemoryTracker::~MediaMemoryTracker() +{ + UnregisterWeakMemoryReporter(this); +} + +} // namespace mozilla + +// avoid redefined macro in unified build +#undef DECODER_LOG |