summaryrefslogtreecommitdiffstats
path: root/dom/media/mediasource/MediaSource.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/media/mediasource/MediaSource.cpp')
-rw-r--r--dom/media/mediasource/MediaSource.cpp704
1 files changed, 704 insertions, 0 deletions
diff --git a/dom/media/mediasource/MediaSource.cpp b/dom/media/mediasource/MediaSource.cpp
new file mode 100644
index 0000000000..94e9904262
--- /dev/null
+++ b/dom/media/mediasource/MediaSource.cpp
@@ -0,0 +1,704 @@
+/* -*- 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 "MediaSource.h"
+
+#include "AsyncEventRunner.h"
+#include "Benchmark.h"
+#include "DecoderDoctorDiagnostics.h"
+#include "DecoderTraits.h"
+#include "MP4Decoder.h"
+#include "MediaContainerType.h"
+#include "MediaResult.h"
+#include "MediaSourceDemuxer.h"
+#include "MediaSourceUtils.h"
+#include "SourceBuffer.h"
+#include "SourceBufferList.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/FloatingPoint.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Sprintf.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/HTMLMediaElement.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/mozalloc.h"
+#include "nsDebug.h"
+#include "nsError.h"
+#include "nsIRunnable.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsMimeTypes.h"
+#include "nsPIDOMWindow.h"
+#include "nsServiceManagerUtils.h"
+#include "nsString.h"
+#include "nsThreadUtils.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+# include "AndroidBridge.h"
+# include "mozilla/java/HardwareCodecCapabilityUtilsWrappers.h"
+#endif
+
+struct JSContext;
+class JSObject;
+
+mozilla::LogModule* GetMediaSourceLog() {
+ static mozilla::LazyLogModule sLogModule("MediaSource");
+ return sLogModule;
+}
+
+mozilla::LogModule* GetMediaSourceAPILog() {
+ static mozilla::LazyLogModule sLogModule("MediaSource");
+ return sLogModule;
+}
+
+#define MSE_DEBUG(arg, ...) \
+ DDMOZ_LOG(GetMediaSourceLog(), mozilla::LogLevel::Debug, "::%s: " arg, \
+ __func__, ##__VA_ARGS__)
+#define MSE_API(arg, ...) \
+ DDMOZ_LOG(GetMediaSourceAPILog(), mozilla::LogLevel::Debug, "::%s: " arg, \
+ __func__, ##__VA_ARGS__)
+
+// Arbitrary limit.
+static const unsigned int MAX_SOURCE_BUFFERS = 16;
+
+namespace mozilla {
+
+// Returns true if we should enable MSE webm regardless of preferences.
+// 1. If MP4/H264 isn't supported:
+// * Windows XP
+// * Windows Vista and Server 2008 without the optional "Platform Update
+// Supplement"
+// * N/KN editions (Europe and Korea) of Windows 7/8/8.1/10 without the
+// optional "Windows Media Feature Pack"
+// 2. If H264 hardware acceleration is not available.
+// 3. The CPU is considered to be fast enough
+static bool IsVP9Forced(DecoderDoctorDiagnostics* aDiagnostics) {
+ bool mp4supported = MP4Decoder::IsSupportedType(
+ MediaContainerType(MEDIAMIMETYPE(VIDEO_MP4)), aDiagnostics);
+ bool hwsupported = gfx::gfxVars::CanUseHardwareVideoDecoding();
+#ifdef MOZ_WIDGET_ANDROID
+ return !mp4supported || !hwsupported || VP9Benchmark::IsVP9DecodeFast() ||
+ java::HardwareCodecCapabilityUtils::HasHWVP9(false /* aIsEncoder */);
+#else
+ return !mp4supported || !hwsupported || VP9Benchmark::IsVP9DecodeFast();
+#endif
+}
+
+namespace dom {
+
+static void RecordTypeForTelemetry(const nsAString& aType,
+ nsPIDOMWindowInner* aWindow) {
+ Maybe<MediaContainerType> containerType = MakeMediaContainerType(aType);
+ if (!containerType) {
+ return;
+ }
+
+ const MediaMIMEType& mimeType = containerType->Type();
+ if (mimeType == MEDIAMIMETYPE(VIDEO_WEBM)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::VideoWebm);
+ } else if (mimeType == MEDIAMIMETYPE(AUDIO_WEBM)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::AudioWebm);
+ } else if (mimeType == MEDIAMIMETYPE(VIDEO_MP4)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::VideoMp4);
+ const auto& codecString = containerType->ExtendedType().Codecs().AsString();
+ if (StringBeginsWith(codecString, u"hev1"_ns) ||
+ StringBeginsWith(codecString, u"hvc1"_ns)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::VideoHevc);
+ }
+ } else if (mimeType == MEDIAMIMETYPE(AUDIO_MP4)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::AudioMp4);
+ } else if (mimeType == MEDIAMIMETYPE(VIDEO_MPEG_TS)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::VideoMp2t);
+ } else if (mimeType == MEDIAMIMETYPE(AUDIO_MPEG_TS)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::AudioMp2t);
+ } else if (mimeType == MEDIAMIMETYPE(AUDIO_MP3)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::AudioMpeg);
+ } else if (mimeType == MEDIAMIMETYPE(AUDIO_AAC)) {
+ AccumulateCategorical(
+ mozilla::Telemetry::LABELS_MSE_SOURCE_BUFFER_TYPE::AudioAac);
+ }
+}
+
+/* static */
+void MediaSource::IsTypeSupported(const nsAString& aType,
+ DecoderDoctorDiagnostics* aDiagnostics,
+ ErrorResult& aRv) {
+ if (aType.IsEmpty()) {
+ return aRv.ThrowTypeError("Empty type");
+ }
+
+ Maybe<MediaContainerType> containerType = MakeMediaContainerType(aType);
+ if (!containerType) {
+ return aRv.ThrowNotSupportedError("Unknown type");
+ }
+
+ if (DecoderTraits::CanHandleContainerType(*containerType, aDiagnostics) ==
+ CANPLAY_NO) {
+ return aRv.ThrowNotSupportedError("Can't play type");
+ }
+
+ bool hasVP9 = false;
+ const MediaCodecs& codecs = containerType->ExtendedType().Codecs();
+ for (const auto& codec : codecs.Range()) {
+ if (IsVP9CodecString(codec)) {
+ hasVP9 = true;
+ break;
+ }
+ }
+
+ // Now we know that this media type could be played.
+ // MediaSource imposes extra restrictions, and some prefs.
+ const MediaMIMEType& mimeType = containerType->Type();
+ if (mimeType == MEDIAMIMETYPE("video/mp4") ||
+ mimeType == MEDIAMIMETYPE("audio/mp4")) {
+ if (!StaticPrefs::media_mediasource_mp4_enabled()) {
+ // Don't leak information about the fact that it's pref-disabled; just act
+ // like we can't play it. Or should this throw "Unknown type"?
+ return aRv.ThrowNotSupportedError("Can't play type");
+ }
+ if (!StaticPrefs::media_mediasource_vp9_enabled() && hasVP9 &&
+ !IsVP9Forced(aDiagnostics)) {
+ // Don't leak information about the fact that it's pref-disabled; just act
+ // like we can't play it. Or should this throw "Unknown type"?
+ return aRv.ThrowNotSupportedError("Can't play type");
+ }
+
+ return;
+ }
+ if (mimeType == MEDIAMIMETYPE("video/webm")) {
+ if (!StaticPrefs::media_mediasource_webm_enabled()) {
+ // Don't leak information about the fact that it's pref-disabled; just act
+ // like we can't play it. Or should this throw "Unknown type"?
+ return aRv.ThrowNotSupportedError("Can't play type");
+ }
+ if (!StaticPrefs::media_mediasource_vp9_enabled() && hasVP9 &&
+ !IsVP9Forced(aDiagnostics)) {
+ // Don't leak information about the fact that it's pref-disabled; just act
+ // like we can't play it. Or should this throw "Unknown type"?
+ return aRv.ThrowNotSupportedError("Can't play type");
+ }
+ return;
+ }
+ if (mimeType == MEDIAMIMETYPE("audio/webm")) {
+ if (!(StaticPrefs::media_mediasource_webm_enabled() ||
+ StaticPrefs::media_mediasource_webm_audio_enabled())) {
+ // Don't leak information about the fact that it's pref-disabled; just act
+ // like we can't play it. Or should this throw "Unknown type"?
+ return aRv.ThrowNotSupportedError("Can't play type");
+ }
+ return;
+ }
+
+ return aRv.ThrowNotSupportedError("Type not supported in MediaSource");
+}
+
+/* static */
+already_AddRefed<MediaSource> MediaSource::Constructor(
+ const GlobalObject& aGlobal, ErrorResult& aRv) {
+ nsCOMPtr<nsPIDOMWindowInner> window =
+ do_QueryInterface(aGlobal.GetAsSupports());
+ if (!window) {
+ aRv.Throw(NS_ERROR_UNEXPECTED);
+ return nullptr;
+ }
+
+ RefPtr<MediaSource> mediaSource = new MediaSource(window);
+ return mediaSource.forget();
+}
+
+MediaSource::~MediaSource() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_API("");
+ if (mDecoder) {
+ mDecoder->DetachMediaSource();
+ }
+}
+
+SourceBufferList* MediaSource::SourceBuffers() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT_IF(mReadyState == MediaSourceReadyState::Closed,
+ mSourceBuffers->IsEmpty());
+ return mSourceBuffers;
+}
+
+SourceBufferList* MediaSource::ActiveSourceBuffers() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT_IF(mReadyState == MediaSourceReadyState::Closed,
+ mActiveSourceBuffers->IsEmpty());
+ return mActiveSourceBuffers;
+}
+
+MediaSourceReadyState MediaSource::ReadyState() {
+ MOZ_ASSERT(NS_IsMainThread());
+ return mReadyState;
+}
+
+double MediaSource::Duration() {
+ MOZ_ASSERT(NS_IsMainThread());
+ if (mReadyState == MediaSourceReadyState::Closed) {
+ return UnspecifiedNaN<double>();
+ }
+ MOZ_ASSERT(mDecoder);
+ return mDecoder->GetDuration();
+}
+
+void MediaSource::SetDuration(double aDuration, ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+ if (aDuration < 0 || std::isnan(aDuration)) {
+ nsPrintfCString error("Invalid duration value %f", aDuration);
+ MSE_API("SetDuration(aDuration=%f, invalid value)", aDuration);
+ aRv.ThrowTypeError(error);
+ return;
+ }
+ if (mReadyState != MediaSourceReadyState::Open ||
+ mSourceBuffers->AnyUpdating()) {
+ MSE_API("SetDuration(aDuration=%f, invalid state)", aDuration);
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return;
+ }
+ DurationChange(aDuration, aRv);
+ MSE_API("SetDuration(aDuration=%f, errorCode=%d)", aDuration,
+ aRv.ErrorCodeAsInt());
+}
+
+void MediaSource::SetDuration(const media::TimeUnit& aDuration) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_API("SetDuration(aDuration=%f)", aDuration.ToSeconds());
+ mDecoder->SetMediaSourceDuration(aDuration);
+}
+
+already_AddRefed<SourceBuffer> MediaSource::AddSourceBuffer(
+ const nsAString& aType, ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+ DecoderDoctorDiagnostics diagnostics;
+ IsTypeSupported(aType, &diagnostics, aRv);
+ RecordTypeForTelemetry(aType, GetOwner());
+ bool supported = !aRv.Failed();
+ diagnostics.StoreFormatDiagnostics(
+ GetOwner() ? GetOwner()->GetExtantDoc() : nullptr, aType, supported,
+ __func__);
+ MSE_API("AddSourceBuffer(aType=%s)%s", NS_ConvertUTF16toUTF8(aType).get(),
+ supported ? "" : " [not supported]");
+ if (!supported) {
+ return nullptr;
+ }
+ if (mSourceBuffers->Length() >= MAX_SOURCE_BUFFERS) {
+ aRv.Throw(NS_ERROR_DOM_MEDIA_SOURCE_MAX_BUFFER_QUOTA_EXCEEDED_ERR);
+ return nullptr;
+ }
+ if (mReadyState != MediaSourceReadyState::Open) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return nullptr;
+ }
+ Maybe<MediaContainerType> containerType = MakeMediaContainerType(aType);
+ if (!containerType) {
+ aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+ return nullptr;
+ }
+ RefPtr<SourceBuffer> sourceBuffer = new SourceBuffer(this, *containerType);
+ mSourceBuffers->Append(sourceBuffer);
+ DDLINKCHILD("sourcebuffer[]", sourceBuffer.get());
+ MSE_DEBUG("sourceBuffer=%p", sourceBuffer.get());
+ return sourceBuffer.forget();
+}
+
+RefPtr<MediaSource::ActiveCompletionPromise> MediaSource::SourceBufferIsActive(
+ SourceBuffer* aSourceBuffer) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mActiveSourceBuffers->ClearSimple();
+ bool initMissing = false;
+ bool found = false;
+ for (uint32_t i = 0; i < mSourceBuffers->Length(); i++) {
+ SourceBuffer* sourceBuffer = mSourceBuffers->IndexedGetter(i, found);
+ MOZ_ALWAYS_TRUE(found);
+ if (sourceBuffer == aSourceBuffer) {
+ mActiveSourceBuffers->Append(aSourceBuffer);
+ } else if (sourceBuffer->IsActive()) {
+ mActiveSourceBuffers->AppendSimple(sourceBuffer);
+ } else {
+ // Some source buffers haven't yet received an init segment.
+ // There's nothing more we can do at this stage.
+ initMissing = true;
+ }
+ }
+ if (initMissing || !mDecoder) {
+ return ActiveCompletionPromise::CreateAndResolve(true, __func__);
+ }
+
+ mDecoder->NotifyInitDataArrived();
+
+ // Add our promise to the queue.
+ // It will be resolved once the HTMLMediaElement modifies its readyState.
+ MozPromiseHolder<ActiveCompletionPromise> holder;
+ RefPtr<ActiveCompletionPromise> promise = holder.Ensure(__func__);
+ mCompletionPromises.AppendElement(std::move(holder));
+ return promise;
+}
+
+void MediaSource::CompletePendingTransactions() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_DEBUG("Resolving %u promises", unsigned(mCompletionPromises.Length()));
+ for (auto& promise : mCompletionPromises) {
+ promise.Resolve(true, __func__);
+ }
+ mCompletionPromises.Clear();
+}
+
+void MediaSource::RemoveSourceBuffer(SourceBuffer& aSourceBuffer,
+ ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+ SourceBuffer* sourceBuffer = &aSourceBuffer;
+ MSE_API("RemoveSourceBuffer(aSourceBuffer=%p)", sourceBuffer);
+ if (!mSourceBuffers->Contains(sourceBuffer)) {
+ aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
+ return;
+ }
+
+ sourceBuffer->AbortBufferAppend();
+ // TODO:
+ // abort stream append loop (if running)
+
+ // TODO:
+ // For all sourceBuffer audioTracks, videoTracks, textTracks:
+ // set sourceBuffer to null
+ // remove sourceBuffer video, audio, text Tracks from MediaElement tracks
+ // remove sourceBuffer video, audio, text Tracks and fire "removetrack" at
+ // affected lists fire "removetrack" at modified MediaElement track lists
+ // If removed enabled/selected, fire "change" at affected MediaElement list.
+ if (mActiveSourceBuffers->Contains(sourceBuffer)) {
+ mActiveSourceBuffers->Remove(sourceBuffer);
+ }
+ mSourceBuffers->Remove(sourceBuffer);
+ DDUNLINKCHILD(sourceBuffer);
+ // TODO: Free all resources associated with sourceBuffer
+}
+
+void MediaSource::EndOfStream(
+ const Optional<MediaSourceEndOfStreamError>& aError, ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_API("EndOfStream(aError=%d)",
+ aError.WasPassed() ? uint32_t(aError.Value()) : 0);
+ if (mReadyState != MediaSourceReadyState::Open ||
+ mSourceBuffers->AnyUpdating()) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return;
+ }
+
+ SetReadyState(MediaSourceReadyState::Ended);
+ mSourceBuffers->Ended();
+ if (!aError.WasPassed()) {
+ DurationChange(mSourceBuffers->GetHighestBufferedEndTime().ToBase(1000000),
+ aRv);
+ // Notify reader that all data is now available.
+ mDecoder->Ended(true);
+ return;
+ }
+ switch (aError.Value()) {
+ case MediaSourceEndOfStreamError::Network:
+ mDecoder->NetworkError(MediaResult(NS_ERROR_FAILURE, "MSE network"));
+ break;
+ case MediaSourceEndOfStreamError::Decode:
+ mDecoder->DecodeError(NS_ERROR_DOM_MEDIA_FATAL_ERR);
+ break;
+ default:
+ MOZ_ASSERT_UNREACHABLE(
+ "Someone added a MediaSourceReadyState value and didn't handle it "
+ "here");
+ break;
+ }
+}
+
+void MediaSource::EndOfStream(const MediaResult& aError) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_API("EndOfStream(aError=%s)", aError.ErrorName().get());
+
+ SetReadyState(MediaSourceReadyState::Ended);
+ mSourceBuffers->Ended();
+ mDecoder->DecodeError(aError);
+}
+
+/* static */
+bool MediaSource::IsTypeSupported(const GlobalObject& aOwner,
+ const nsAString& aType) {
+ MOZ_ASSERT(NS_IsMainThread());
+ DecoderDoctorDiagnostics diagnostics;
+ IgnoredErrorResult rv;
+ IsTypeSupported(aType, &diagnostics, rv);
+ bool supported = !rv.Failed();
+ nsCOMPtr<nsPIDOMWindowInner> window =
+ do_QueryInterface(aOwner.GetAsSupports());
+ RecordTypeForTelemetry(aType, window);
+ diagnostics.StoreFormatDiagnostics(window ? window->GetExtantDoc() : nullptr,
+ aType, supported, __func__);
+ MOZ_LOG(GetMediaSourceAPILog(), mozilla::LogLevel::Debug,
+ ("MediaSource::%s: IsTypeSupported(aType=%s) %s", __func__,
+ NS_ConvertUTF16toUTF8(aType).get(),
+ supported ? "OK" : "[not supported]"));
+ return supported;
+}
+
+void MediaSource::SetLiveSeekableRange(double aStart, double aEnd,
+ ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // 1. If the readyState attribute is not "open" then throw an
+ // InvalidStateError exception and abort these steps.
+ if (mReadyState != MediaSourceReadyState::Open) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return;
+ }
+
+ // 2. If start is negative or greater than end, then throw a TypeError
+ // exception and abort these steps.
+ if (aStart < 0 || aStart > aEnd) {
+ aRv.ThrowTypeError("Invalid start value");
+ return;
+ }
+
+ // 3. Set live seekable range to be a new normalized TimeRanges object
+ // containing a single range whose start position is start and end position is
+ // end.
+ mLiveSeekableRange = Some(media::TimeRanges(media::TimeRange(aStart, aEnd)));
+}
+
+void MediaSource::ClearLiveSeekableRange(ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ // 1. If the readyState attribute is not "open" then throw an
+ // InvalidStateError exception and abort these steps.
+ if (mReadyState != MediaSourceReadyState::Open) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return;
+ }
+
+ // 2. If live seekable range contains a range, then set live seekable range to
+ // be a new empty TimeRanges object.
+ mLiveSeekableRange.reset();
+}
+
+bool MediaSource::Attach(MediaSourceDecoder* aDecoder) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_DEBUG("Attach(aDecoder=%p) owner=%p", aDecoder, aDecoder->GetOwner());
+ MOZ_ASSERT(aDecoder);
+ MOZ_ASSERT(aDecoder->GetOwner());
+ if (mReadyState != MediaSourceReadyState::Closed) {
+ return false;
+ }
+ MOZ_ASSERT(!mMediaElement);
+ mMediaElement = aDecoder->GetOwner()->GetMediaElement();
+ MOZ_ASSERT(!mDecoder);
+ mDecoder = aDecoder;
+ mDecoder->AttachMediaSource(this);
+ SetReadyState(MediaSourceReadyState::Open);
+ return true;
+}
+
+void MediaSource::Detach() {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_RELEASE_ASSERT(mCompletionPromises.IsEmpty());
+ MSE_DEBUG("mDecoder=%p owner=%p", mDecoder.get(),
+ mDecoder ? mDecoder->GetOwner() : nullptr);
+ if (!mDecoder) {
+ MOZ_ASSERT(mReadyState == MediaSourceReadyState::Closed);
+ MOZ_ASSERT(mActiveSourceBuffers->IsEmpty() && mSourceBuffers->IsEmpty());
+ return;
+ }
+ mMediaElement = nullptr;
+ SetReadyState(MediaSourceReadyState::Closed);
+ if (mActiveSourceBuffers) {
+ mActiveSourceBuffers->Clear();
+ }
+ if (mSourceBuffers) {
+ mSourceBuffers->Clear();
+ }
+ mDecoder->DetachMediaSource();
+ mDecoder = nullptr;
+}
+
+MediaSource::MediaSource(nsPIDOMWindowInner* aWindow)
+ : DOMEventTargetHelper(aWindow),
+ mDecoder(nullptr),
+ mPrincipal(nullptr),
+ mAbstractMainThread(AbstractThread::MainThread()),
+ mReadyState(MediaSourceReadyState::Closed) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mSourceBuffers = new SourceBufferList(this);
+ mActiveSourceBuffers = new SourceBufferList(this);
+
+ nsCOMPtr<nsIScriptObjectPrincipal> sop = do_QueryInterface(aWindow);
+ if (sop) {
+ mPrincipal = sop->GetPrincipal();
+ }
+
+ MSE_API("MediaSource(aWindow=%p) mSourceBuffers=%p mActiveSourceBuffers=%p",
+ aWindow, mSourceBuffers.get(), mActiveSourceBuffers.get());
+}
+
+void MediaSource::SetReadyState(MediaSourceReadyState aState) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MOZ_ASSERT(aState != mReadyState);
+ MSE_DEBUG("SetReadyState(aState=%" PRIu32 ") mReadyState=%" PRIu32,
+ static_cast<uint32_t>(aState), static_cast<uint32_t>(mReadyState));
+
+ MediaSourceReadyState oldState = mReadyState;
+ mReadyState = aState;
+
+ if (mReadyState == MediaSourceReadyState::Open &&
+ (oldState == MediaSourceReadyState::Closed ||
+ oldState == MediaSourceReadyState::Ended)) {
+ QueueAsyncSimpleEvent("sourceopen");
+ if (oldState == MediaSourceReadyState::Ended) {
+ // Notify reader that more data may come.
+ mDecoder->Ended(false);
+ }
+ return;
+ }
+
+ if (mReadyState == MediaSourceReadyState::Ended &&
+ oldState == MediaSourceReadyState::Open) {
+ QueueAsyncSimpleEvent("sourceended");
+ return;
+ }
+
+ if (mReadyState == MediaSourceReadyState::Closed &&
+ (oldState == MediaSourceReadyState::Open ||
+ oldState == MediaSourceReadyState::Ended)) {
+ QueueAsyncSimpleEvent("sourceclose");
+ return;
+ }
+
+ NS_WARNING("Invalid MediaSource readyState transition");
+}
+
+void MediaSource::DispatchSimpleEvent(const char* aName) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_API("Dispatch event '%s'", aName);
+ DispatchTrustedEvent(NS_ConvertUTF8toUTF16(aName));
+}
+
+void MediaSource::QueueAsyncSimpleEvent(const char* aName) {
+ MSE_DEBUG("Queuing event '%s'", aName);
+ nsCOMPtr<nsIRunnable> event = new AsyncEventRunner<MediaSource>(this, aName);
+ mAbstractMainThread->Dispatch(event.forget());
+}
+
+void MediaSource::DurationChange(const media::TimeUnit& aNewDuration,
+ ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_DEBUG("DurationChange(aNewDuration=%s)", aNewDuration.ToString().get());
+
+ // 1. If the current value of duration is equal to new duration, then return.
+ if (mDecoder->GetDuration() == aNewDuration.ToSeconds()) {
+ return;
+ }
+
+ // 2. If new duration is less than the highest starting presentation timestamp
+ // of any buffered coded frames for all SourceBuffer objects in sourceBuffers,
+ // then throw an InvalidStateError exception and abort these steps.
+ if (aNewDuration < mSourceBuffers->HighestStartTime()) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return;
+ }
+
+ // 3. Let highest end time be the largest track buffer ranges end time across
+ // all the track buffers across all SourceBuffer objects in sourceBuffers.
+ media::TimeUnit highestEndTime = mSourceBuffers->HighestEndTime();
+ // 4. If new duration is less than highest end time, then
+ // 4.1 Update new duration to equal highest end time.
+ media::TimeUnit newDuration = std::max(aNewDuration, highestEndTime);
+
+ // 5. Update the media duration to new duration and run the HTMLMediaElement
+ // duration change algorithm.
+ mDecoder->SetMediaSourceDuration(newDuration);
+}
+
+void MediaSource::DurationChange(double aNewDuration, ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+ MSE_DEBUG("DurationChange(aNewDuration=%f)", aNewDuration);
+
+ // 1. If the current value of duration is equal to new duration, then return.
+ if (mDecoder->GetDuration() == aNewDuration) {
+ return;
+ }
+
+ // 2. If new duration is less than the highest starting presentation timestamp
+ // of any buffered coded frames for all SourceBuffer objects in sourceBuffers,
+ // then throw an InvalidStateError exception and abort these steps.
+ if (aNewDuration < mSourceBuffers->HighestStartTime().ToSeconds()) {
+ aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+ return;
+ }
+
+ // 3. Let highest end time be the largest track buffer ranges end time across
+ // all the track buffers across all SourceBuffer objects in sourceBuffers.
+ double highestEndTime = mSourceBuffers->HighestEndTime().ToSeconds();
+ // 4. If new duration is less than highest end time, then
+ // 4.1 Update new duration to equal highest end time.
+ double newDuration = std::max(aNewDuration, highestEndTime);
+
+ // 5. Update the media duration to new duration and run the HTMLMediaElement
+ // duration change algorithm.
+ mDecoder->SetMediaSourceDuration(newDuration);
+}
+
+already_AddRefed<Promise> MediaSource::MozDebugReaderData(ErrorResult& aRv) {
+ // Creating a JS promise
+ nsPIDOMWindowInner* win = GetOwner();
+ if (!win) {
+ aRv.Throw(NS_ERROR_UNEXPECTED);
+ return nullptr;
+ }
+ RefPtr<Promise> domPromise = Promise::Create(win->AsGlobal(), aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+ MOZ_ASSERT(domPromise);
+ UniquePtr<MediaSourceDecoderDebugInfo> info =
+ MakeUnique<MediaSourceDecoderDebugInfo>();
+ mDecoder->RequestDebugInfo(*info)->Then(
+ mAbstractMainThread, __func__,
+ [domPromise, infoPtr = std::move(info)] {
+ domPromise->MaybeResolve(infoPtr.get());
+ },
+ [] {
+ MOZ_ASSERT_UNREACHABLE("Unexpected rejection while getting debug data");
+ });
+
+ return domPromise.forget();
+}
+
+nsPIDOMWindowInner* MediaSource::GetParentObject() const { return GetOwner(); }
+
+JSObject* MediaSource::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return MediaSource_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(MediaSource, DOMEventTargetHelper,
+ mMediaElement, mSourceBuffers,
+ mActiveSourceBuffers)
+
+NS_IMPL_ADDREF_INHERITED(MediaSource, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(MediaSource, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MediaSource)
+ NS_INTERFACE_MAP_ENTRY_CONCRETE(mozilla::dom::MediaSource)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+#undef MSE_DEBUG
+#undef MSE_API
+
+} // namespace dom
+
+} // namespace mozilla