summaryrefslogtreecommitdiffstats
path: root/dom/media/webcodecs
diff options
context:
space:
mode:
Diffstat (limited to 'dom/media/webcodecs')
-rw-r--r--dom/media/webcodecs/DecoderAgent.cpp491
-rw-r--r--dom/media/webcodecs/DecoderAgent.h117
-rw-r--r--dom/media/webcodecs/DecoderTemplate.cpp891
-rw-r--r--dom/media/webcodecs/DecoderTemplate.h260
-rw-r--r--dom/media/webcodecs/DecoderTypes.h117
-rw-r--r--dom/media/webcodecs/EncodedVideoChunk.cpp261
-rw-r--r--dom/media/webcodecs/EncodedVideoChunk.h119
-rw-r--r--dom/media/webcodecs/EncoderAgent.cpp441
-rw-r--r--dom/media/webcodecs/EncoderAgent.h116
-rw-r--r--dom/media/webcodecs/EncoderTemplate.cpp1228
-rw-r--r--dom/media/webcodecs/EncoderTemplate.h290
-rw-r--r--dom/media/webcodecs/EncoderTypes.h103
-rw-r--r--dom/media/webcodecs/VideoColorSpace.cpp48
-rw-r--r--dom/media/webcodecs/VideoColorSpace.h64
-rw-r--r--dom/media/webcodecs/VideoDecoder.cpp977
-rw-r--r--dom/media/webcodecs/VideoDecoder.h79
-rw-r--r--dom/media/webcodecs/VideoEncoder.cpp624
-rw-r--r--dom/media/webcodecs/VideoEncoder.h78
-rw-r--r--dom/media/webcodecs/VideoFrame.cpp2417
-rw-r--r--dom/media/webcodecs/VideoFrame.h266
-rw-r--r--dom/media/webcodecs/WebCodecsUtils.cpp578
-rw-r--r--dom/media/webcodecs/WebCodecsUtils.h239
-rw-r--r--dom/media/webcodecs/crashtests/1839270.html13
-rw-r--r--dom/media/webcodecs/crashtests/1848460.html17
-rw-r--r--dom/media/webcodecs/crashtests/1849271.html27
-rw-r--r--dom/media/webcodecs/crashtests/1864475.html14
-rw-r--r--dom/media/webcodecs/crashtests/crashtests.list4
-rw-r--r--dom/media/webcodecs/moz.build54
-rw-r--r--dom/media/webcodecs/test/mochitest.toml6
-rw-r--r--dom/media/webcodecs/test/test_videoFrame_mismatched_codedSize.html30
30 files changed, 9969 insertions, 0 deletions
diff --git a/dom/media/webcodecs/DecoderAgent.cpp b/dom/media/webcodecs/DecoderAgent.cpp
new file mode 100644
index 0000000000..5c63e27d48
--- /dev/null
+++ b/dom/media/webcodecs/DecoderAgent.cpp
@@ -0,0 +1,491 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "DecoderAgent.h"
+
+#include <atomic>
+
+#include "ImageContainer.h"
+#include "MediaDataDecoderProxy.h"
+#include "PDMFactory.h"
+#include "VideoUtils.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Logging.h"
+#include "mozilla/layers/ImageBridgeChild.h"
+#include "nsThreadUtils.h"
+
+extern mozilla::LazyLogModule gWebCodecsLog;
+
+namespace mozilla {
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+
+#ifdef LOG
+# undef LOG
+#endif // LOG
+#define LOG(msg, ...) LOG_INTERNAL(Debug, msg, ##__VA_ARGS__)
+
+#ifdef LOGW
+# undef LOGW
+#endif // LOGE
+#define LOGW(msg, ...) LOG_INTERNAL(Warning, msg, ##__VA_ARGS__)
+
+#ifdef LOGE
+# undef LOGE
+#endif // LOGE
+#define LOGE(msg, ...) LOG_INTERNAL(Error, msg, ##__VA_ARGS__)
+
+#ifdef LOGV
+# undef LOGV
+#endif // LOGV
+#define LOGV(msg, ...) LOG_INTERNAL(Verbose, msg, ##__VA_ARGS__)
+
+DecoderAgent::DecoderAgent(Id aId, UniquePtr<TrackInfo>&& aInfo)
+ : mId(aId),
+ mInfo(std::move(aInfo)),
+ mOwnerThread(GetCurrentSerialEventTarget()),
+ mPDMFactory(MakeRefPtr<PDMFactory>()),
+ mImageContainer(MakeAndAddRef<layers::ImageContainer>(
+ layers::ImageContainer::ASYNCHRONOUS)),
+ mDecoder(nullptr),
+ mState(State::Unconfigured) {
+ MOZ_ASSERT(mInfo);
+ MOZ_ASSERT(mOwnerThread);
+ MOZ_ASSERT(mPDMFactory);
+ MOZ_ASSERT(mImageContainer);
+ LOG("DecoderAgent #%d (%p) ctor", mId, this);
+}
+
+DecoderAgent::~DecoderAgent() {
+ LOG("DecoderAgent #%d (%p) dtor", mId, this);
+ MOZ_ASSERT(mState == State::Unconfigured, "decoder release in wrong state");
+ MOZ_ASSERT(!mDecoder, "decoder must be shutdown");
+}
+
+RefPtr<DecoderAgent::ConfigurePromise> DecoderAgent::Configure(
+ bool aPreferSoftwareDecoder, bool aLowLatency) {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(mState == State::Unconfigured || mState == State::Error);
+ MOZ_ASSERT(mConfigurePromise.IsEmpty());
+ MOZ_ASSERT(!mCreateRequest.Exists());
+ MOZ_ASSERT(!mInitRequest.Exists());
+
+ if (mState == State::Error) {
+ LOGE("DecoderAgent #%d (%p) tried to configure in error state", mId, this);
+ return ConfigurePromise::CreateAndReject(
+ MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
+ "Cannot configure in error state"),
+ __func__);
+ }
+
+ MOZ_ASSERT(mState == State::Unconfigured);
+ MOZ_ASSERT(!mDecoder);
+ SetState(State::Configuring);
+
+ RefPtr<layers::KnowsCompositor> knowsCompositor =
+ layers::ImageBridgeChild::GetSingleton();
+ // Bug 1839993: FFmpegDataDecoder ignores all decode errors when draining so
+ // WPT cannot receive error callbacks. Forcibly enable LowLatency for now to
+ // get the decoded results immediately to avoid this.
+
+ auto params = CreateDecoderParams{
+ *mInfo,
+ CreateDecoderParams::OptionSet(
+ CreateDecoderParams::Option::LowLatency,
+ aPreferSoftwareDecoder
+ ? CreateDecoderParams::Option::HardwareDecoderNotAllowed
+ : CreateDecoderParams::Option::Default),
+ mInfo->GetType(), mImageContainer, knowsCompositor};
+
+ LOG("DecoderAgent #%d (%p) is creating a decoder - PreferSW: %s, "
+ "low-latency: %syes",
+ mId, this, aPreferSoftwareDecoder ? "yes" : "no",
+ aLowLatency ? "" : "forcibly ");
+
+ RefPtr<ConfigurePromise> p = mConfigurePromise.Ensure(__func__);
+
+ mPDMFactory->CreateDecoder(params)
+ ->Then(
+ mOwnerThread, __func__,
+ [self = RefPtr{this}](RefPtr<MediaDataDecoder>&& aDecoder) {
+ self->mCreateRequest.Complete();
+
+ // If DecoderAgent has been shut down, shut the created decoder down
+ // and return.
+ if (!self->mShutdownWhileCreationPromise.IsEmpty()) {
+ MOZ_ASSERT(self->mState == State::ShuttingDown);
+ MOZ_ASSERT(self->mConfigurePromise.IsEmpty(),
+ "configuration should have been rejected");
+
+ LOGW(
+ "DecoderAgent #%d (%p) has been shut down. We need to shut "
+ "the newly created decoder down",
+ self->mId, self.get());
+ aDecoder->Shutdown()->Then(
+ self->mOwnerThread, __func__,
+ [self](const ShutdownPromise::ResolveOrRejectValue& aValue) {
+ MOZ_ASSERT(self->mState == State::ShuttingDown);
+
+ LOGW(
+ "DecoderAgent #%d (%p), newly created decoder shutdown "
+ "has been %s",
+ self->mId, self.get(),
+ aValue.IsResolve() ? "resolved" : "rejected");
+
+ self->SetState(State::Unconfigured);
+
+ self->mShutdownWhileCreationPromise.ResolveOrReject(
+ aValue, __func__);
+ });
+ return;
+ }
+
+ self->mDecoder = new MediaDataDecoderProxy(
+ aDecoder.forget(),
+ CreateMediaDecodeTaskQueue("DecoderAgent TaskQueue"));
+ LOG("DecoderAgent #%d (%p) has created a decoder, now initialize "
+ "it",
+ self->mId, self.get());
+ self->mDecoder->Init()
+ ->Then(
+ self->mOwnerThread, __func__,
+ [self](const TrackInfo::TrackType aTrackType) {
+ self->mInitRequest.Complete();
+ LOG("DecoderAgent #%d (%p) has initialized the decoder",
+ self->mId, self.get());
+ MOZ_ASSERT(aTrackType == self->mInfo->GetType());
+ self->SetState(State::Configured);
+ self->mConfigurePromise.Resolve(true, __func__);
+ },
+ [self](const MediaResult& aError) {
+ self->mInitRequest.Complete();
+ LOGE(
+ "DecoderAgent #%d (%p) failed to initialize the "
+ "decoder",
+ self->mId, self.get());
+ self->SetState(State::Error);
+ self->mConfigurePromise.Reject(aError, __func__);
+ })
+ ->Track(self->mInitRequest);
+ },
+ [self = RefPtr{this}](const MediaResult& aError) {
+ self->mCreateRequest.Complete();
+ LOGE("DecoderAgent #%d (%p) failed to create a decoder", self->mId,
+ self.get());
+
+ // If DecoderAgent has been shut down, we need to resolve the
+ // shutdown promise.
+ if (!self->mShutdownWhileCreationPromise.IsEmpty()) {
+ MOZ_ASSERT(self->mState == State::ShuttingDown);
+ MOZ_ASSERT(self->mConfigurePromise.IsEmpty(),
+ "configuration should have been rejected");
+
+ LOGW(
+ "DecoderAgent #%d (%p) has been shut down. Resolve the "
+ "shutdown promise right away since decoder creation failed",
+ self->mId, self.get());
+
+ self->SetState(State::Unconfigured);
+ self->mShutdownWhileCreationPromise.Resolve(true, __func__);
+ return;
+ }
+
+ self->SetState(State::Error);
+ self->mConfigurePromise.Reject(aError, __func__);
+ })
+ ->Track(mCreateRequest);
+
+ return p;
+}
+
+RefPtr<ShutdownPromise> DecoderAgent::Shutdown() {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+
+ auto r =
+ MediaResult(NS_ERROR_DOM_MEDIA_CANCELED, "Canceled by decoder shutdown");
+
+ // If the decoder creation has not been completed yet, wait until the decoder
+ // being created has been shut down.
+ if (mCreateRequest.Exists()) {
+ MOZ_ASSERT(!mInitRequest.Exists());
+ MOZ_ASSERT(!mConfigurePromise.IsEmpty());
+ MOZ_ASSERT(!mDecoder);
+ MOZ_ASSERT(mState == State::Configuring);
+ MOZ_ASSERT(mShutdownWhileCreationPromise.IsEmpty());
+
+ LOGW(
+ "DecoderAgent #%d (%p) shutdown while the decoder-creation for "
+ "configuration is in flight. Reject the configuration now and defer "
+ "the shutdown until the created decoder has been shut down",
+ mId, this);
+
+ // Reject the configuration in flight.
+ mConfigurePromise.Reject(r, __func__);
+
+ // Get the promise that will be resolved when the decoder being created has
+ // been destroyed.
+ SetState(State::ShuttingDown);
+ return mShutdownWhileCreationPromise.Ensure(__func__);
+ }
+
+ // If decoder creation has been completed, we must have the decoder now.
+ MOZ_ASSERT(mDecoder);
+
+ // Cancel pending initialization for configuration in flight if any.
+ mInitRequest.DisconnectIfExists();
+ mConfigurePromise.RejectIfExists(r, __func__);
+
+ // Cancel decode in flight if any.
+ mDecodeRequest.DisconnectIfExists();
+ mDecodePromise.RejectIfExists(r, __func__);
+
+ // Cancel flush-out in flight if any.
+ mDrainRequest.DisconnectIfExists();
+ mFlushRequest.DisconnectIfExists();
+ mDryRequest.DisconnectIfExists();
+ mDryPromise.RejectIfExists(r, __func__);
+ mDrainAndFlushPromise.RejectIfExists(r, __func__);
+ mDryData.Clear();
+ mDrainAndFlushData.Clear();
+
+ SetState(State::Unconfigured);
+
+ RefPtr<MediaDataDecoder> decoder = std::move(mDecoder);
+ return decoder->Shutdown();
+}
+
+RefPtr<DecoderAgent::DecodePromise> DecoderAgent::Decode(
+ MediaRawData* aSample) {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(aSample);
+ MOZ_ASSERT(mState == State::Configured || mState == State::Error);
+ MOZ_ASSERT(mDecodePromise.IsEmpty());
+ MOZ_ASSERT(!mDecodeRequest.Exists());
+
+ if (mState == State::Error) {
+ LOGE("DecoderAgent #%d (%p) tried to decode in error state", mId, this);
+ return DecodePromise::CreateAndReject(
+ MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
+ "Cannot decode in error state"),
+ __func__);
+ }
+
+ MOZ_ASSERT(mState == State::Configured);
+ MOZ_ASSERT(mDecoder);
+ SetState(State::Decoding);
+
+ RefPtr<DecodePromise> p = mDecodePromise.Ensure(__func__);
+
+ mDecoder->Decode(aSample)
+ ->Then(
+ mOwnerThread, __func__,
+ [self = RefPtr{this}](MediaDataDecoder::DecodedData&& aData) {
+ self->mDecodeRequest.Complete();
+ LOGV("DecoderAgent #%d (%p) decode successfully", self->mId,
+ self.get());
+ self->SetState(State::Configured);
+ self->mDecodePromise.Resolve(std::move(aData), __func__);
+ },
+ [self = RefPtr{this}](const MediaResult& aError) {
+ self->mDecodeRequest.Complete();
+ LOGV("DecoderAgent #%d (%p) failed to decode", self->mId,
+ self.get());
+ self->SetState(State::Error);
+ self->mDecodePromise.Reject(aError, __func__);
+ })
+ ->Track(mDecodeRequest);
+
+ return p;
+}
+
+RefPtr<DecoderAgent::DecodePromise> DecoderAgent::DrainAndFlush() {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(mState == State::Configured || mState == State::Error);
+ MOZ_ASSERT(mDrainAndFlushPromise.IsEmpty());
+ MOZ_ASSERT(mDrainAndFlushData.IsEmpty());
+ MOZ_ASSERT(!mDryRequest.Exists());
+ MOZ_ASSERT(mDryPromise.IsEmpty());
+ MOZ_ASSERT(mDryData.IsEmpty());
+ MOZ_ASSERT(!mDrainRequest.Exists());
+ MOZ_ASSERT(!mFlushRequest.Exists());
+
+ if (mState == State::Error) {
+ LOGE("DecoderAgent #%d (%p) tried to flush-out in error state", mId, this);
+ return DecodePromise::CreateAndReject(
+ MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
+ "Cannot flush in error state"),
+ __func__);
+ }
+
+ MOZ_ASSERT(mState == State::Configured);
+ MOZ_ASSERT(mDecoder);
+ SetState(State::Flushing);
+
+ RefPtr<DecoderAgent::DecodePromise> p =
+ mDrainAndFlushPromise.Ensure(__func__);
+
+ Dry()
+ ->Then(
+ mOwnerThread, __func__,
+ [self = RefPtr{this}](MediaDataDecoder::DecodedData&& aData) {
+ self->mDryRequest.Complete();
+ LOG("DecoderAgent #%d (%p) has dried the decoder. Now flushing the "
+ "decoder",
+ self->mId, self.get());
+ MOZ_ASSERT(self->mDrainAndFlushData.IsEmpty());
+ self->mDrainAndFlushData.AppendElements(std::move(aData));
+ self->mDecoder->Flush()
+ ->Then(
+ self->mOwnerThread, __func__,
+ [self](const bool /* aUnUsed */) {
+ self->mFlushRequest.Complete();
+ LOG("DecoderAgent #%d (%p) has flushed the decoder",
+ self->mId, self.get());
+ self->SetState(State::Configured);
+ self->mDrainAndFlushPromise.Resolve(
+ std::move(self->mDrainAndFlushData), __func__);
+ },
+ [self](const MediaResult& aError) {
+ self->mFlushRequest.Complete();
+ LOGE("DecoderAgent #%d (%p) failed to flush the decoder",
+ self->mId, self.get());
+ self->SetState(State::Error);
+ self->mDrainAndFlushData.Clear();
+ self->mDrainAndFlushPromise.Reject(aError, __func__);
+ })
+ ->Track(self->mFlushRequest);
+ },
+ [self = RefPtr{this}](const MediaResult& aError) {
+ self->mDryRequest.Complete();
+ LOGE("DecoderAgent #%d (%p) failed to dry the decoder", self->mId,
+ self.get());
+ self->SetState(State::Error);
+ self->mDrainAndFlushPromise.Reject(aError, __func__);
+ })
+ ->Track(mDryRequest);
+
+ return p;
+}
+
+RefPtr<DecoderAgent::DecodePromise> DecoderAgent::Dry() {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(mState == State::Flushing);
+ MOZ_ASSERT(mDryPromise.IsEmpty());
+ MOZ_ASSERT(!mDryRequest.Exists());
+ MOZ_ASSERT(mDryData.IsEmpty());
+ MOZ_ASSERT(mDecoder);
+
+ RefPtr<DecodePromise> p = mDryPromise.Ensure(__func__);
+ DrainUntilDry();
+ return p;
+}
+
+void DecoderAgent::DrainUntilDry() {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(mState == State::Flushing);
+ MOZ_ASSERT(!mDryPromise.IsEmpty());
+ MOZ_ASSERT(!mDrainRequest.Exists());
+ MOZ_ASSERT(mDecoder);
+
+ LOG("DecoderAgent #%d (%p) is drainng the decoder", mId, this);
+ mDecoder->Drain()
+ ->Then(
+ mOwnerThread, __func__,
+ [self = RefPtr{this}](MediaDataDecoder::DecodedData&& aData) {
+ self->mDrainRequest.Complete();
+
+ if (aData.IsEmpty()) {
+ LOG("DecoderAgent #%d (%p) is dry now", self->mId, self.get());
+ self->mDryPromise.Resolve(std::move(self->mDryData), __func__);
+ return;
+ }
+
+ LOG("DecoderAgent #%d (%p) drained %zu decoded data. Keep draining "
+ "until dry",
+ self->mId, self.get(), aData.Length());
+ self->mDryData.AppendElements(std::move(aData));
+ self->DrainUntilDry();
+ },
+ [self = RefPtr{this}](const MediaResult& aError) {
+ self->mDrainRequest.Complete();
+
+ LOGE("DecoderAgent %p failed to drain decoder", self.get());
+ self->mDryData.Clear();
+ self->mDryPromise.Reject(aError, __func__);
+ })
+ ->Track(mDrainRequest);
+}
+
+void DecoderAgent::SetState(State aState) {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+
+ auto validateStateTransition = [](State aOldState, State aNewState) {
+ switch (aOldState) {
+ case State::Unconfigured:
+ return aNewState == State::Configuring;
+ case State::Configuring:
+ return aNewState == State::Configured || aNewState == State::Error ||
+ aNewState == State::Unconfigured ||
+ aNewState == State::ShuttingDown;
+ case State::Configured:
+ return aNewState == State::Unconfigured ||
+ aNewState == State::Decoding || aNewState == State::Flushing;
+ case State::Decoding:
+ case State::Flushing:
+ return aNewState == State::Configured || aNewState == State::Error ||
+ aNewState == State::Unconfigured;
+ case State::ShuttingDown:
+ return aNewState == State::Unconfigured;
+ case State::Error:
+ return aNewState == State::Unconfigured;
+ default:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("Unhandled state transition");
+ return false;
+ };
+
+ auto stateToString = [](State aState) -> const char* {
+ switch (aState) {
+ case State::Unconfigured:
+ return "Unconfigured";
+ case State::Configuring:
+ return "Configuring";
+ case State::Configured:
+ return "Configured";
+ case State::Decoding:
+ return "Decoding";
+ case State::Flushing:
+ return "Flushing";
+ case State::ShuttingDown:
+ return "ShuttingDown";
+ case State::Error:
+ return "Error";
+ default:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("Unhandled state type");
+ return "Unknown";
+ };
+
+ DebugOnly<bool> isValid = validateStateTransition(mState, aState);
+ MOZ_ASSERT(isValid);
+ LOG("DecoderAgent #%d (%p) state change: %s -> %s", mId, this,
+ stateToString(mState), stateToString(aState));
+ mState = aState;
+}
+
+#undef LOG
+#undef LOGW
+#undef LOGE
+#undef LOGV
+#undef LOG_INTERNAL
+
+} // namespace mozilla
diff --git a/dom/media/webcodecs/DecoderAgent.h b/dom/media/webcodecs/DecoderAgent.h
new file mode 100644
index 0000000000..f8107b27a6
--- /dev/null
+++ b/dom/media/webcodecs/DecoderAgent.h
@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef DOM_MEDIA_WEBCODECS_DECODERAGENT_H
+#define DOM_MEDIA_WEBCODECS_DECODERAGENT_H
+
+#include "MediaResult.h"
+#include "PlatformDecoderModule.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/TaskQueue.h"
+#include "mozilla/UniquePtr.h"
+
+class nsISerialEventTarget;
+
+namespace mozilla {
+
+class PDMFactory;
+class TrackInfo;
+
+namespace layers {
+class ImageContainer;
+} // namespace layers
+
+// DecoderAgent is a wrapper that contains a MediaDataDecoder. It adapts the
+// MediaDataDecoder APIs for use in WebCodecs.
+//
+// If Configure() is called, Shutdown() must be called to release the resources
+// gracefully. Except Shutdown(), all the methods can't be called concurrently,
+// meaning a method can only be called when the previous API call has completed.
+// The responsability of arranging the method calls is on the caller.
+//
+// When Shutdown() is called, all the operations in flight are canceled and the
+// MediaDataDecoder is shut down. On the other hand, errors are final. A new
+// DecoderAgent must be created when an error is encountered.
+//
+// All the methods need to be called on the DecoderAgent's owner thread. In
+// WebCodecs, it's either on the main thread or worker thread.
+class DecoderAgent final {
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DecoderAgent);
+
+ using Id = uint32_t;
+ DecoderAgent(Id aId, UniquePtr<TrackInfo>&& aInfo);
+
+ // The following APIs are owner thread only.
+
+ using ConfigurePromise = MozPromise<bool, MediaResult, true /* exclusive */>;
+ RefPtr<ConfigurePromise> Configure(bool aPreferSoftwareDecoder,
+ bool aLowLatency);
+ RefPtr<ShutdownPromise> Shutdown();
+ using DecodePromise = MediaDataDecoder::DecodePromise;
+ RefPtr<DecodePromise> Decode(MediaRawData* aSample);
+ // WebCodecs's flush() flushes out all the pending decoded data in the
+ // MediaDataDecoder so it is a combination of Drain and Flush. To distinguish
+ // the term from MediaDataDecoder's one, we call it DrainAndFlush() here.
+ RefPtr<DecodePromise> DrainAndFlush();
+
+ const Id mId; // A unique id.
+ const UniquePtr<TrackInfo> mInfo;
+
+ private:
+ ~DecoderAgent();
+
+ // Push out all the data in the MediaDataDecoder's pipeline.
+ // TODO: MediaDataDecoder should implement this, instead of asking call site
+ // to run `Drain` multiple times.
+ RefPtr<DecodePromise> Dry();
+ void DrainUntilDry();
+
+ enum class State {
+ Unconfigured,
+ Configuring,
+ Configured,
+ Decoding,
+ Flushing,
+ ShuttingDown,
+ Error,
+ };
+ void SetState(State aState);
+
+ const RefPtr<nsISerialEventTarget> mOwnerThread;
+ const RefPtr<PDMFactory> mPDMFactory;
+ const RefPtr<layers::ImageContainer> mImageContainer;
+ RefPtr<MediaDataDecoder> mDecoder;
+ State mState;
+
+ // Configure
+ MozPromiseHolder<ConfigurePromise> mConfigurePromise;
+ using CreateDecoderPromise = PlatformDecoderModule::CreateDecoderPromise;
+ MozPromiseRequestHolder<CreateDecoderPromise> mCreateRequest;
+ using InitPromise = MediaDataDecoder::InitPromise;
+ MozPromiseRequestHolder<InitPromise> mInitRequest;
+
+ // Shutdown
+ MozPromiseHolder<ShutdownPromise> mShutdownWhileCreationPromise;
+
+ // Decode
+ MozPromiseHolder<DecodePromise> mDecodePromise;
+ MozPromiseRequestHolder<DecodePromise> mDecodeRequest;
+
+ // DrainAndFlush
+ MozPromiseHolder<DecodePromise> mDrainAndFlushPromise;
+ MediaDataDecoder::DecodedData mDrainAndFlushData;
+ MozPromiseRequestHolder<DecodePromise> mDryRequest;
+ MozPromiseHolder<DecodePromise> mDryPromise;
+ MediaDataDecoder::DecodedData mDryData;
+ MozPromiseRequestHolder<DecodePromise> mDrainRequest;
+ using FlushPromise = MediaDataDecoder::FlushPromise;
+ MozPromiseRequestHolder<FlushPromise> mFlushRequest;
+};
+
+} // namespace mozilla
+
+#endif // DOM_MEDIA_WEBCODECS_DECODERAGENT_H
diff --git a/dom/media/webcodecs/DecoderTemplate.cpp b/dom/media/webcodecs/DecoderTemplate.cpp
new file mode 100644
index 0000000000..0fa25a208b
--- /dev/null
+++ b/dom/media/webcodecs/DecoderTemplate.cpp
@@ -0,0 +1,891 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "DecoderTemplate.h"
+
+#include <atomic>
+#include <utility>
+
+#include "DecoderTypes.h"
+#include "MediaInfo.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Try.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/VideoDecoderBinding.h"
+#include "mozilla/dom/VideoFrame.h"
+#include "mozilla/dom/WorkerCommon.h"
+#include "nsGkAtoms.h"
+#include "nsString.h"
+#include "nsThreadUtils.h"
+
+mozilla::LazyLogModule gWebCodecsLog("WebCodecs");
+
+namespace mozilla::dom {
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+
+#ifdef LOG
+# undef LOG
+#endif // LOG
+#define LOG(msg, ...) LOG_INTERNAL(Debug, msg, ##__VA_ARGS__)
+
+#ifdef LOGW
+# undef LOGW
+#endif // LOGW
+#define LOGW(msg, ...) LOG_INTERNAL(Warning, msg, ##__VA_ARGS__)
+
+#ifdef LOGE
+# undef LOGE
+#endif // LOGE
+#define LOGE(msg, ...) LOG_INTERNAL(Error, msg, ##__VA_ARGS__)
+
+#ifdef LOGV
+# undef LOGV
+#endif // LOGV
+#define LOGV(msg, ...) LOG_INTERNAL(Verbose, msg, ##__VA_ARGS__)
+
+/*
+ * Below are ControlMessage classes implementations
+ */
+
+template <typename DecoderType>
+DecoderTemplate<DecoderType>::ControlMessage::ControlMessage(
+ const nsACString& aTitle)
+ : mTitle(aTitle) {}
+
+template <typename DecoderType>
+DecoderTemplate<DecoderType>::ConfigureMessage::ConfigureMessage(
+ Id aId, UniquePtr<ConfigTypeInternal>&& aConfig)
+ : ControlMessage(
+ nsPrintfCString("configure #%d (%s)", aId,
+ NS_ConvertUTF16toUTF8(aConfig->mCodec).get())),
+ mId(aId),
+ mConfig(std::move(aConfig)) {}
+
+/* static */
+template <typename DecoderType>
+typename DecoderTemplate<DecoderType>::ConfigureMessage*
+DecoderTemplate<DecoderType>::ConfigureMessage::Create(
+ UniquePtr<ConfigTypeInternal>&& aConfig) {
+ // This needs to be atomic since this can run on the main thread or worker
+ // thread.
+ static std::atomic<Id> sNextId = NoId;
+ return new ConfigureMessage(++sNextId, std::move(aConfig));
+}
+
+template <typename DecoderType>
+DecoderTemplate<DecoderType>::DecodeMessage::DecodeMessage(
+ Id aId, ConfigId aConfigId, UniquePtr<InputTypeInternal>&& aData)
+ : ControlMessage(
+ nsPrintfCString("decode #%zu (config #%d)", aId, aConfigId)),
+ mId(aId),
+ mData(std::move(aData)) {}
+
+template <typename DecoderType>
+DecoderTemplate<DecoderType>::FlushMessage::FlushMessage(Id aId,
+ ConfigId aConfigId,
+ Promise* aPromise)
+ : ControlMessage(
+ nsPrintfCString("flush #%zu (config #%d)", aId, aConfigId)),
+ mId(aId),
+ mPromise(aPromise) {}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::FlushMessage::RejectPromiseIfAny(
+ const nsresult& aReason) {
+ if (mPromise) {
+ mPromise->MaybeReject(aReason);
+ }
+}
+
+/*
+ * Below are DecoderTemplate implementation
+ */
+
+template <typename DecoderType>
+DecoderTemplate<DecoderType>::DecoderTemplate(
+ nsIGlobalObject* aGlobalObject,
+ RefPtr<WebCodecsErrorCallback>&& aErrorCallback,
+ RefPtr<OutputCallbackType>&& aOutputCallback)
+ : DOMEventTargetHelper(aGlobalObject),
+ mErrorCallback(std::move(aErrorCallback)),
+ mOutputCallback(std::move(aOutputCallback)),
+ mState(CodecState::Unconfigured),
+ mKeyChunkRequired(true),
+ mMessageQueueBlocked(false),
+ mDecodeQueueSize(0),
+ mDequeueEventScheduled(false),
+ mLatestConfigureId(ConfigureMessage::NoId),
+ mDecodeCounter(0),
+ mFlushCounter(0) {}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::Configure(const ConfigType& aConfig,
+ ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s %p, Configure: codec %s", DecoderType::Name.get(), this,
+ NS_ConvertUTF16toUTF8(aConfig.mCodec).get());
+
+ nsCString errorMessage;
+ if (!DecoderType::Validate(aConfig, errorMessage)) {
+ aRv.ThrowTypeError(
+ nsPrintfCString("config is invalid: %s", errorMessage.get()));
+ return;
+ }
+
+ if (mState == CodecState::Closed) {
+ LOG("Configure: CodecState::Closed, rejecting with InvalidState");
+ aRv.ThrowInvalidStateError("The codec is no longer usable");
+ return;
+ }
+
+ // Clone a ConfigType as the active decoder config.
+ UniquePtr<ConfigTypeInternal> config =
+ DecoderType::CreateConfigInternal(aConfig);
+ if (!config) {
+ aRv.Throw(NS_ERROR_UNEXPECTED); // Invalid description data.
+ return;
+ }
+
+ mState = CodecState::Configured;
+ mKeyChunkRequired = true;
+ mDecodeCounter = 0;
+ mFlushCounter = 0;
+
+ mControlMessageQueue.emplace(
+ UniquePtr<ControlMessage>(ConfigureMessage::Create(std::move(config))));
+ mLatestConfigureId = mControlMessageQueue.back()->AsConfigureMessage()->mId;
+ LOG("%s %p enqueues %s", DecoderType::Name.get(), this,
+ mControlMessageQueue.back()->ToString().get());
+ ProcessControlMessageQueue();
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::Decode(InputType& aInput, ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s %p, Decode", DecoderType::Name.get(), this);
+
+ if (mState != CodecState::Configured) {
+ aRv.ThrowInvalidStateError("Decoder must be configured first");
+ return;
+ }
+
+ if (mKeyChunkRequired) {
+ // TODO: Verify input's data is truly a key chunk
+ if (!DecoderType::IsKeyChunk(aInput)) {
+ aRv.ThrowDataError(
+ nsPrintfCString("%s needs a key chunk", DecoderType::Name.get()));
+ return;
+ }
+ mKeyChunkRequired = false;
+ }
+
+ mDecodeQueueSize += 1;
+ mControlMessageQueue.emplace(UniquePtr<ControlMessage>(
+ new DecodeMessage(++mDecodeCounter, mLatestConfigureId,
+ DecoderType::CreateInputInternal(aInput))));
+ LOGV("%s %p enqueues %s", DecoderType::Name.get(), this,
+ mControlMessageQueue.back()->ToString().get());
+ ProcessControlMessageQueue();
+}
+
+template <typename DecoderType>
+already_AddRefed<Promise> DecoderTemplate<DecoderType>::Flush(
+ ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s %p, Flush", DecoderType::Name.get(), this);
+
+ if (mState != CodecState::Configured) {
+ LOG("%s %p, wrong state!", DecoderType::Name.get(), this);
+ aRv.ThrowInvalidStateError("Decoder must be configured first");
+ return nullptr;
+ }
+
+ RefPtr<Promise> p = Promise::Create(GetParentObject(), aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return p.forget();
+ }
+
+ mKeyChunkRequired = true;
+
+ mControlMessageQueue.emplace(UniquePtr<ControlMessage>(
+ new FlushMessage(++mFlushCounter, mLatestConfigureId, p)));
+ LOG("%s %p enqueues %s", DecoderType::Name.get(), this,
+ mControlMessageQueue.back()->ToString().get());
+ ProcessControlMessageQueue();
+ return p.forget();
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::Reset(ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s %p, Reset", DecoderType::Name.get(), this);
+
+ if (auto r = ResetInternal(NS_ERROR_DOM_ABORT_ERR); r.isErr()) {
+ aRv.Throw(r.unwrapErr());
+ }
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::Close(ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s %p, Close", DecoderType::Name.get(), this);
+
+ if (auto r = CloseInternalWithAbort(); r.isErr()) {
+ aRv.Throw(r.unwrapErr());
+ }
+}
+
+template <typename DecoderType>
+Result<Ok, nsresult> DecoderTemplate<DecoderType>::ResetInternal(
+ const nsresult& aResult) {
+ AssertIsOnOwningThread();
+
+ if (mState == CodecState::Closed) {
+ return Err(NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ mState = CodecState::Unconfigured;
+ mDecodeCounter = 0;
+ mFlushCounter = 0;
+
+ CancelPendingControlMessages(aResult);
+ DestroyDecoderAgentIfAny();
+
+ if (mDecodeQueueSize > 0) {
+ mDecodeQueueSize = 0;
+ ScheduleDequeueEventIfNeeded();
+ }
+
+ LOG("%s %p now has its message queue unblocked", DecoderType::Name.get(),
+ this);
+ mMessageQueueBlocked = false;
+
+ return Ok();
+}
+template <typename DecoderType>
+Result<Ok, nsresult> DecoderTemplate<DecoderType>::CloseInternalWithAbort() {
+ AssertIsOnOwningThread();
+
+ MOZ_TRY(ResetInternal(NS_ERROR_DOM_ABORT_ERR));
+ mState = CodecState::Closed;
+ return Ok();
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::CloseInternal(const nsresult& aResult) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aResult != NS_ERROR_DOM_ABORT_ERR, "Use CloseInternalWithAbort");
+
+ auto r = ResetInternal(aResult);
+ if (r.isErr()) {
+ nsCString name;
+ GetErrorName(r.unwrapErr(), name);
+ LOGE("Error in ResetInternal: %s", name.get());
+ MOZ_CRASH();
+ }
+ mState = CodecState::Closed;
+ nsCString error;
+ GetErrorName(aResult, error);
+ LOGE("%s %p Close on error: %s", DecoderType::Name.get(), this, error.get());
+ ReportError(aResult);
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::ReportError(const nsresult& aResult) {
+ AssertIsOnOwningThread();
+
+ RefPtr<DOMException> e = DOMException::Create(aResult);
+ RefPtr<WebCodecsErrorCallback> cb(mErrorCallback);
+ cb->Call(*e);
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::OutputDecodedData(
+ const nsTArray<RefPtr<MediaData>>&& aData) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(mActiveConfig);
+
+ nsTArray<RefPtr<VideoFrame>> frames = DecodedDataToOutputType(
+ GetParentObject(), std::move(aData), *mActiveConfig);
+ RefPtr<VideoFrameOutputCallback> cb(mOutputCallback);
+ for (RefPtr<VideoFrame>& frame : frames) {
+ LOG("Outputing decoded data: ts: %" PRId64, frame->Timestamp());
+ RefPtr<VideoFrame> f = frame;
+ cb->Call((VideoFrame&)(*f));
+ }
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::ScheduleDequeueEventIfNeeded() {
+ AssertIsOnOwningThread();
+
+ if (mDequeueEventScheduled) {
+ return;
+ }
+ mDequeueEventScheduled = true;
+
+ QueueATask("dequeue event task", [self = RefPtr{this}]() {
+ self->FireEvent(nsGkAtoms::ondequeue, u"dequeue"_ns);
+ self->mDequeueEventScheduled = false;
+ });
+}
+
+template <typename DecoderType>
+nsresult DecoderTemplate<DecoderType>::FireEvent(nsAtom* aTypeWithOn,
+ const nsAString& aEventType) {
+ if (aTypeWithOn && !HasListenersFor(aTypeWithOn)) {
+ LOGV("%s %p has no %s event listener", DecoderType::Name.get(), this,
+ NS_ConvertUTF16toUTF8(aEventType).get());
+ return NS_ERROR_ABORT;
+ }
+
+ LOGV("Dispatch %s event to %s %p", NS_ConvertUTF16toUTF8(aEventType).get(),
+ DecoderType::Name.get(), this);
+ RefPtr<Event> event = new Event(this, nullptr, nullptr);
+ event->InitEvent(aEventType, true, true);
+ event->SetTrusted(true);
+ this->DispatchEvent(*event);
+ return NS_OK;
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::ProcessControlMessageQueue() {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+
+ while (!mMessageQueueBlocked && !mControlMessageQueue.empty()) {
+ UniquePtr<ControlMessage>& msg = mControlMessageQueue.front();
+ if (msg->AsConfigureMessage()) {
+ if (ProcessConfigureMessage(msg) ==
+ MessageProcessedResult::NotProcessed) {
+ break;
+ }
+ } else if (msg->AsDecodeMessage()) {
+ if (ProcessDecodeMessage(msg) == MessageProcessedResult::NotProcessed) {
+ break;
+ }
+ } else {
+ MOZ_ASSERT(msg->AsFlushMessage());
+ if (ProcessFlushMessage(msg) == MessageProcessedResult::NotProcessed) {
+ break;
+ }
+ }
+ }
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::CancelPendingControlMessages(
+ const nsresult& aResult) {
+ AssertIsOnOwningThread();
+
+ // Cancel the message that is being processed.
+ if (mProcessingMessage) {
+ LOG("%s %p cancels current %s", DecoderType::Name.get(), this,
+ mProcessingMessage->ToString().get());
+ mProcessingMessage->Cancel();
+
+ if (FlushMessage* flush = mProcessingMessage->AsFlushMessage()) {
+ flush->RejectPromiseIfAny(aResult);
+ }
+
+ mProcessingMessage.reset();
+ }
+
+ // Clear the message queue.
+ while (!mControlMessageQueue.empty()) {
+ LOG("%s %p cancels pending %s", DecoderType::Name.get(), this,
+ mControlMessageQueue.front()->ToString().get());
+
+ MOZ_ASSERT(!mControlMessageQueue.front()->IsProcessing());
+ if (FlushMessage* flush = mControlMessageQueue.front()->AsFlushMessage()) {
+ flush->RejectPromiseIfAny(aResult);
+ }
+
+ mControlMessageQueue.pop();
+ }
+}
+
+template <typename DecoderType>
+template <typename Func>
+void DecoderTemplate<DecoderType>::QueueATask(const char* aName,
+ Func&& aSteps) {
+ AssertIsOnOwningThread();
+ MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(
+ NS_NewRunnableFunction(aName, std::forward<Func>(aSteps))));
+}
+
+template <typename DecoderType>
+MessageProcessedResult DecoderTemplate<DecoderType>::ProcessConfigureMessage(
+ UniquePtr<ControlMessage>& aMessage) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(aMessage->AsConfigureMessage());
+
+ if (mProcessingMessage) {
+ LOG("%s %p is processing %s. Defer %s", DecoderType::Name.get(), this,
+ mProcessingMessage->ToString().get(), aMessage->ToString().get());
+ return MessageProcessedResult::NotProcessed;
+ }
+
+ mProcessingMessage.reset(aMessage.release());
+ mControlMessageQueue.pop();
+
+ ConfigureMessage* msg = mProcessingMessage->AsConfigureMessage();
+ LOG("%s %p starts processing %s", DecoderType::Name.get(), this,
+ msg->ToString().get());
+
+ DestroyDecoderAgentIfAny();
+
+ mMessageQueueBlocked = true;
+
+ nsAutoCString errorMessage;
+ auto i = DecoderType::CreateTrackInfo(msg->Config());
+ if (i.isErr()) {
+ nsCString res;
+ GetErrorName(i.unwrapErr(), res);
+ errorMessage.AppendPrintf("CreateTrackInfo failed: %s", res.get());
+ } else if (!DecoderType::IsSupported(msg->Config())) {
+ errorMessage.Append("Not supported.");
+ } else if (!CreateDecoderAgent(msg->mId, msg->TakeConfig(), i.unwrap())) {
+ errorMessage.Append("DecoderAgent creation failed.");
+ }
+ if (!errorMessage.IsEmpty()) {
+ LOGE("%s %p ProcessConfigureMessage error (sync): %s",
+ DecoderType::Name.get(), this, errorMessage.get());
+
+ mProcessingMessage.reset();
+ QueueATask("Error while configuring decoder",
+ [self = RefPtr{this}]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ MOZ_ASSERT(self->mState != CodecState::Closed);
+ self->CloseInternal(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+ });
+ return MessageProcessedResult::Processed;
+ }
+
+ MOZ_ASSERT(mAgent);
+ MOZ_ASSERT(mActiveConfig);
+
+ LOG("%s %p now blocks message-queue-processing", DecoderType::Name.get(),
+ this);
+
+ bool preferSW = mActiveConfig->mHardwareAcceleration ==
+ HardwareAcceleration::Prefer_software;
+ bool lowLatency = mActiveConfig->mOptimizeForLatency.isSome() &&
+ mActiveConfig->mOptimizeForLatency.value();
+ mAgent->Configure(preferSW, lowLatency)
+ ->Then(GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId](
+ const DecoderAgent::ConfigurePromise::ResolveOrRejectValue&
+ aResult) {
+ MOZ_ASSERT(self->mProcessingMessage);
+ MOZ_ASSERT(self->mProcessingMessage->AsConfigureMessage());
+ MOZ_ASSERT(self->mState == CodecState::Configured);
+ MOZ_ASSERT(self->mAgent);
+ MOZ_ASSERT(id == self->mAgent->mId);
+ MOZ_ASSERT(self->mActiveConfig);
+
+ ConfigureMessage* msg =
+ self->mProcessingMessage->AsConfigureMessage();
+ LOG("%s %p, DecoderAgent #%d %s has been %s. now unblocks "
+ "message-queue-processing",
+ DecoderType::Name.get(), self.get(), id,
+ msg->ToString().get(),
+ aResult.IsResolve() ? "resolved" : "rejected");
+
+ msg->Complete();
+ self->mProcessingMessage.reset();
+
+ if (aResult.IsReject()) {
+ // The spec asks to close the decoder with an
+ // NotSupportedError so we log the exact error here.
+ const MediaResult& error = aResult.RejectValue();
+ LOGE("%s %p, DecoderAgent #%d failed to configure: %s",
+ DecoderType::Name.get(), self.get(), id,
+ error.Description().get());
+
+ self->QueueATask(
+ "Error during configure",
+ [self = RefPtr{self}]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ MOZ_ASSERT(self->mState != CodecState::Closed);
+ self->CloseInternal(
+ NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ });
+ return;
+ }
+
+ self->mMessageQueueBlocked = false;
+ self->ProcessControlMessageQueue();
+ })
+ ->Track(msg->Request());
+
+ return MessageProcessedResult::Processed;
+}
+
+template <typename DecoderType>
+MessageProcessedResult DecoderTemplate<DecoderType>::ProcessDecodeMessage(
+ UniquePtr<ControlMessage>& aMessage) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(aMessage->AsDecodeMessage());
+
+ if (mProcessingMessage) {
+ LOGV("%s %p is processing %s. Defer %s", DecoderType::Name.get(), this,
+ mProcessingMessage->ToString().get(), aMessage->ToString().get());
+ return MessageProcessedResult::NotProcessed;
+ }
+
+ mProcessingMessage.reset(aMessage.release());
+ mControlMessageQueue.pop();
+
+ DecodeMessage* msg = mProcessingMessage->AsDecodeMessage();
+ LOGV("%s %p starts processing %s", DecoderType::Name.get(), this,
+ msg->ToString().get());
+
+ mDecodeQueueSize -= 1;
+ ScheduleDequeueEventIfNeeded();
+
+ // Treat it like decode error if no DecoderAgent is available or the encoded
+ // data is invalid.
+ auto closeOnError = [&]() {
+ mProcessingMessage.reset();
+ QueueATask("Error during decode",
+ [self = RefPtr{this}]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ MOZ_ASSERT(self->mState != CodecState::Closed);
+ self->CloseInternal(NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ });
+ return MessageProcessedResult::Processed;
+ };
+
+ if (!mAgent) {
+ LOGE("%s %p is not configured", DecoderType::Name.get(), this);
+ return closeOnError();
+ }
+
+ MOZ_ASSERT(mActiveConfig);
+ RefPtr<MediaRawData> data = InputDataToMediaRawData(
+ std::move(msg->mData), *(mAgent->mInfo), *mActiveConfig);
+ if (!data) {
+ LOGE("%s %p, data for %s is empty or invalid", DecoderType::Name.get(),
+ this, msg->ToString().get());
+ return closeOnError();
+ }
+
+ mAgent->Decode(data.get())
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId](
+ DecoderAgent::DecodePromise::ResolveOrRejectValue&& aResult) {
+ MOZ_ASSERT(self->mProcessingMessage);
+ MOZ_ASSERT(self->mProcessingMessage->AsDecodeMessage());
+ MOZ_ASSERT(self->mState == CodecState::Configured);
+ MOZ_ASSERT(self->mAgent);
+ MOZ_ASSERT(id == self->mAgent->mId);
+ MOZ_ASSERT(self->mActiveConfig);
+
+ DecodeMessage* msg = self->mProcessingMessage->AsDecodeMessage();
+ LOGV("%s %p, DecoderAgent #%d %s has been %s",
+ DecoderType::Name.get(), self.get(), id, msg->ToString().get(),
+ aResult.IsResolve() ? "resolved" : "rejected");
+
+ nsCString msgStr = msg->ToString();
+
+ msg->Complete();
+ self->mProcessingMessage.reset();
+
+ if (aResult.IsReject()) {
+ // The spec asks to queue a task to run close the decoder
+ // with an EncodingError so we log the exact error here.
+ const MediaResult& error = aResult.RejectValue();
+ LOGE("%s %p, DecoderAgent #%d %s failed: %s",
+ DecoderType::Name.get(), self.get(), id, msgStr.get(),
+ error.Description().get());
+ self->QueueATask(
+ "Error during decode runnable",
+ [self = RefPtr{self}]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ MOZ_ASSERT(self->mState != CodecState::Closed);
+ self->CloseInternal(
+ NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ });
+ return;
+ }
+
+ MOZ_ASSERT(aResult.IsResolve());
+ nsTArray<RefPtr<MediaData>> data =
+ std::move(aResult.ResolveValue());
+ if (data.IsEmpty()) {
+ LOGV("%s %p got no data for %s", DecoderType::Name.get(),
+ self.get(), msgStr.get());
+ } else {
+ LOGV("%s %p, schedule %zu decoded data output for %s",
+ DecoderType::Name.get(), self.get(), data.Length(),
+ msgStr.get());
+ self->QueueATask("Output Decoded Data",
+ [self = RefPtr{self}, data = std::move(data)]()
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ self->OutputDecodedData(std::move(data));
+ });
+ }
+ self->ProcessControlMessageQueue();
+ })
+ ->Track(msg->Request());
+
+ return MessageProcessedResult::Processed;
+}
+
+template <typename DecoderType>
+MessageProcessedResult DecoderTemplate<DecoderType>::ProcessFlushMessage(
+ UniquePtr<ControlMessage>& aMessage) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(aMessage->AsFlushMessage());
+
+ if (mProcessingMessage) {
+ LOG("%s %p is processing %s. Defer %s", DecoderType::Name.get(), this,
+ mProcessingMessage->ToString().get(), aMessage->ToString().get());
+ return MessageProcessedResult::NotProcessed;
+ }
+
+ mProcessingMessage.reset(aMessage.release());
+ mControlMessageQueue.pop();
+
+ FlushMessage* msg = mProcessingMessage->AsFlushMessage();
+ LOG("%s %p starts processing %s", DecoderType::Name.get(), this,
+ msg->ToString().get());
+
+ // No agent, no thing to do. The promise has been rejected with the
+ // appropriate error in ResetInternal already.
+ if (!mAgent) {
+ LOGE("%s %p no agent, nothing to do", DecoderType::Name.get(), this);
+ mProcessingMessage.reset();
+ return MessageProcessedResult::Processed;
+ }
+
+ mAgent->DrainAndFlush()
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId,
+ this](DecoderAgent::DecodePromise::ResolveOrRejectValue&& aResult) {
+ MOZ_ASSERT(self->mProcessingMessage);
+ MOZ_ASSERT(self->mProcessingMessage->AsFlushMessage());
+ MOZ_ASSERT(self->mState == CodecState::Configured);
+ MOZ_ASSERT(self->mAgent);
+ MOZ_ASSERT(id == self->mAgent->mId);
+ MOZ_ASSERT(self->mActiveConfig);
+
+ FlushMessage* msg = self->mProcessingMessage->AsFlushMessage();
+ LOG("%s %p, DecoderAgent #%d %s has been %s",
+ DecoderType::Name.get(), self.get(), id, msg->ToString().get(),
+ aResult.IsResolve() ? "resolved" : "rejected");
+
+ nsCString msgStr = msg->ToString();
+
+ msg->Complete();
+
+ // If flush failed, it means decoder fails to decode the data
+ // sent before, so we treat it like decode error. We reject
+ // the promise first and then queue a task to close
+ // VideoDecoder with an EncodingError.
+ if (aResult.IsReject()) {
+ const MediaResult& error = aResult.RejectValue();
+ LOGE("%s %p, DecoderAgent #%d failed to flush: %s",
+ DecoderType::Name.get(), self.get(), id,
+ error.Description().get());
+ RefPtr<Promise> promise = msg->TakePromise();
+ // Reject with an EncodingError instead of the error we got
+ // above.
+ self->QueueATask(
+ "Error during flush runnable",
+ [self = RefPtr{this}, promise]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ promise->MaybeReject(
+ NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ self->mProcessingMessage.reset();
+ MOZ_ASSERT(self->mState != CodecState::Closed);
+ self->CloseInternal(
+ NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ });
+ return;
+ }
+
+ nsTArray<RefPtr<MediaData>> data =
+ std::move(aResult.ResolveValue());
+
+ if (data.IsEmpty()) {
+ LOG("%s %p gets no data for %s", DecoderType::Name.get(),
+ self.get(), msgStr.get());
+ } else {
+ LOG("%s %p, schedule %zu decoded data output for %s",
+ DecoderType::Name.get(), self.get(), data.Length(),
+ msgStr.get());
+ }
+
+ RefPtr<Promise> promise = msg->TakePromise();
+ self->QueueATask(
+ "Flush: output decoding data task",
+ [self = RefPtr{self}, promise, data = std::move(data)]()
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ self->OutputDecodedData(std::move(data));
+ promise->MaybeResolveWithUndefined();
+ });
+ self->mProcessingMessage.reset();
+ self->ProcessControlMessageQueue();
+ })
+ ->Track(msg->Request());
+
+ return MessageProcessedResult::Processed;
+}
+
+// CreateDecoderAgent will create an DecoderAgent paired with a xpcom-shutdown
+// blocker and a worker-reference. Besides the needs mentioned in the header
+// file, the blocker and the worker-reference also provides an entry point for
+// us to clean up the resources. Other than the decoder dtor, Reset(), or
+// Close(), the resources should be cleaned up in the following situations:
+// 1. Decoder on window, closing document
+// 2. Decoder on worker, closing document
+// 3. Decoder on worker, terminating worker
+//
+// In case 1, the entry point to clean up is in the mShutdownBlocker's
+// ShutdownpPomise-resolver. In case 2, the entry point is in mWorkerRef's
+// shutting down callback. In case 3, the entry point is in mWorkerRef's
+// shutting down callback.
+
+template <typename DecoderType>
+bool DecoderTemplate<DecoderType>::CreateDecoderAgent(
+ DecoderAgent::Id aId, UniquePtr<ConfigTypeInternal>&& aConfig,
+ UniquePtr<TrackInfo>&& aInfo) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(!mAgent);
+ MOZ_ASSERT(!mActiveConfig);
+ MOZ_ASSERT(!mShutdownBlocker);
+ MOZ_ASSERT_IF(!NS_IsMainThread(), !mWorkerRef);
+
+ auto resetOnFailure = MakeScopeExit([&]() {
+ mAgent = nullptr;
+ mActiveConfig = nullptr;
+ mShutdownBlocker = nullptr;
+ mWorkerRef = nullptr;
+ });
+
+ // If the decoder is on worker, get a worker reference.
+ if (!NS_IsMainThread()) {
+ WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
+ if (NS_WARN_IF(!workerPrivate)) {
+ return false;
+ }
+
+ // Clean up all the resources when worker is going away.
+ RefPtr<StrongWorkerRef> workerRef = StrongWorkerRef::Create(
+ workerPrivate, "DecoderTemplate::CreateDecoderAgent",
+ [self = RefPtr{this}]() {
+ LOG("%s %p, worker is going away", DecoderType::Name.get(),
+ self.get());
+ Unused << self->ResetInternal(NS_ERROR_DOM_ABORT_ERR);
+ });
+ if (NS_WARN_IF(!workerRef)) {
+ return false;
+ }
+
+ mWorkerRef = new ThreadSafeWorkerRef(workerRef);
+ }
+
+ mAgent = MakeRefPtr<DecoderAgent>(aId, std::move(aInfo));
+ mActiveConfig = std::move(aConfig);
+
+ // ShutdownBlockingTicket requires an unique name to register its own
+ // nsIAsyncShutdownBlocker since each blocker needs a distinct name.
+ // To do that, we use DecoderAgent's unique id to create a unique name.
+ nsAutoString uniqueName;
+ uniqueName.AppendPrintf(
+ "Blocker for DecoderAgent #%d (codec: %s) @ %p", mAgent->mId,
+ NS_ConvertUTF16toUTF8(mActiveConfig->mCodec).get(), mAgent.get());
+
+ mShutdownBlocker = media::ShutdownBlockingTicket::Create(
+ uniqueName, NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__);
+ if (!mShutdownBlocker) {
+ LOGE("%s %p failed to create %s", DecoderType::Name.get(), this,
+ NS_ConvertUTF16toUTF8(uniqueName).get());
+ return false;
+ }
+
+ // Clean up all the resources when xpcom-will-shutdown arrives since the page
+ // is going to be closed.
+ mShutdownBlocker->ShutdownPromise()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId,
+ ref = mWorkerRef](bool /* aUnUsed*/) {
+ LOG("%s %p gets xpcom-will-shutdown notification for DecoderAgent #%d",
+ DecoderType::Name.get(), self.get(), id);
+ Unused << self->ResetInternal(NS_ERROR_DOM_ABORT_ERR);
+ },
+ [self = RefPtr{this}, id = mAgent->mId,
+ ref = mWorkerRef](bool /* aUnUsed*/) {
+ LOG("%s %p removes shutdown-blocker #%d before getting any "
+ "notification. DecoderAgent #%d should have been dropped",
+ DecoderType::Name.get(), self.get(), id, id);
+ MOZ_ASSERT(!self->mAgent || self->mAgent->mId != id);
+ });
+
+ LOG("%s %p creates DecoderAgent #%d @ %p and its shutdown-blocker",
+ DecoderType::Name.get(), this, mAgent->mId, mAgent.get());
+
+ resetOnFailure.release();
+ return true;
+}
+
+template <typename DecoderType>
+void DecoderTemplate<DecoderType>::DestroyDecoderAgentIfAny() {
+ AssertIsOnOwningThread();
+
+ if (!mAgent) {
+ LOG("%s %p has no DecoderAgent to destroy", DecoderType::Name.get(), this);
+ return;
+ }
+
+ MOZ_ASSERT(mActiveConfig);
+ MOZ_ASSERT(mShutdownBlocker);
+ MOZ_ASSERT_IF(!NS_IsMainThread(), mWorkerRef);
+
+ LOG("%s %p destroys DecoderAgent #%d @ %p", DecoderType::Name.get(), this,
+ mAgent->mId, mAgent.get());
+ mActiveConfig = nullptr;
+ RefPtr<DecoderAgent> agent = std::move(mAgent);
+ // mShutdownBlocker should be kept alive until the shutdown is done.
+ // mWorkerRef is used to ensure this task won't be discarded in worker.
+ agent->Shutdown()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = agent->mId, ref = std::move(mWorkerRef),
+ blocker = std::move(mShutdownBlocker)](
+ const ShutdownPromise::ResolveOrRejectValue& aResult) {
+ LOG("%s %p, DecoderAgent #%d's shutdown has been %s. Drop its "
+ "shutdown-blocker now",
+ DecoderType::Name.get(), self.get(), id,
+ aResult.IsResolve() ? "resolved" : "rejected");
+ });
+}
+
+template class DecoderTemplate<VideoDecoderTraits>;
+
+#undef LOG
+#undef LOGW
+#undef LOGE
+#undef LOGV
+#undef LOG_INTERNAL
+
+} // namespace mozilla::dom
diff --git a/dom/media/webcodecs/DecoderTemplate.h b/dom/media/webcodecs/DecoderTemplate.h
new file mode 100644
index 0000000000..fe0cb5baee
--- /dev/null
+++ b/dom/media/webcodecs/DecoderTemplate.h
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_DecoderTemplate_h
+#define mozilla_dom_DecoderTemplate_h
+
+#include <queue>
+
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/DecoderAgent.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Result.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/dom/WorkerRef.h"
+#include "mozilla/media/MediaUtils.h"
+#include "nsStringFwd.h"
+#include "WebCodecsUtils.h"
+
+namespace mozilla {
+
+class TrackInfo;
+
+namespace dom {
+
+class WebCodecsErrorCallback;
+class Promise;
+enum class CodecState : uint8_t;
+
+template <typename DecoderType>
+class DecoderTemplate : public DOMEventTargetHelper {
+ using Self = DecoderTemplate<DecoderType>;
+ using ConfigType = typename DecoderType::ConfigType;
+ using ConfigTypeInternal = typename DecoderType::ConfigTypeInternal;
+ using InputType = typename DecoderType::InputType;
+ using InputTypeInternal = typename DecoderType::InputTypeInternal;
+ using OutputType = typename DecoderType::OutputType;
+ using OutputCallbackType = typename DecoderType::OutputCallbackType;
+
+ /* ControlMessage classes */
+ protected:
+ class ConfigureMessage;
+ class DecodeMessage;
+ class FlushMessage;
+
+ class ControlMessage {
+ public:
+ explicit ControlMessage(const nsACString& aTitle);
+ virtual ~ControlMessage() = default;
+ virtual void Cancel() = 0;
+ virtual bool IsProcessing() = 0;
+
+ virtual const nsCString& ToString() const { return mTitle; }
+ virtual ConfigureMessage* AsConfigureMessage() { return nullptr; }
+ virtual DecodeMessage* AsDecodeMessage() { return nullptr; }
+ virtual FlushMessage* AsFlushMessage() { return nullptr; }
+
+ const nsCString mTitle; // Used to identify the message in the logs.
+ };
+
+ class ConfigureMessage final
+ : public ControlMessage,
+ public MessageRequestHolder<DecoderAgent::ConfigurePromise> {
+ public:
+ using Id = DecoderAgent::Id;
+ static constexpr Id NoId = 0;
+ static ConfigureMessage* Create(UniquePtr<ConfigTypeInternal>&& aConfig);
+
+ ~ConfigureMessage() = default;
+ virtual void Cancel() override { Disconnect(); }
+ virtual bool IsProcessing() override { return Exists(); };
+ virtual ConfigureMessage* AsConfigureMessage() override { return this; }
+ const ConfigTypeInternal& Config() { return *mConfig; }
+ UniquePtr<ConfigTypeInternal> TakeConfig() { return std::move(mConfig); }
+
+ const Id mId; // A unique id shown in log.
+
+ private:
+ ConfigureMessage(Id aId, UniquePtr<ConfigTypeInternal>&& aConfig);
+
+ UniquePtr<ConfigTypeInternal> mConfig;
+ };
+
+ class DecodeMessage final
+ : public ControlMessage,
+ public MessageRequestHolder<DecoderAgent::DecodePromise> {
+ public:
+ using Id = size_t;
+ using ConfigId = typename Self::ConfigureMessage::Id;
+ DecodeMessage(Id aId, ConfigId aConfigId,
+ UniquePtr<InputTypeInternal>&& aData);
+ ~DecodeMessage() = default;
+ virtual void Cancel() override { Disconnect(); }
+ virtual bool IsProcessing() override { return Exists(); };
+ virtual DecodeMessage* AsDecodeMessage() override { return this; }
+ const Id mId; // A unique id shown in log.
+
+ UniquePtr<InputTypeInternal> mData;
+ };
+
+ class FlushMessage final
+ : public ControlMessage,
+ public MessageRequestHolder<DecoderAgent::DecodePromise> {
+ public:
+ using Id = size_t;
+ using ConfigId = typename Self::ConfigureMessage::Id;
+ FlushMessage(Id aId, ConfigId aConfigId, Promise* aPromise);
+ ~FlushMessage() = default;
+ virtual void Cancel() override { Disconnect(); }
+ virtual bool IsProcessing() override { return Exists(); };
+ virtual FlushMessage* AsFlushMessage() override { return this; }
+ already_AddRefed<Promise> TakePromise() { return mPromise.forget(); }
+ void RejectPromiseIfAny(const nsresult& aReason);
+
+ const Id mId; // A unique id shown in log.
+
+ private:
+ RefPtr<Promise> mPromise;
+ };
+
+ protected:
+ DecoderTemplate(nsIGlobalObject* aGlobalObject,
+ RefPtr<WebCodecsErrorCallback>&& aErrorCallback,
+ RefPtr<OutputCallbackType>&& aOutputCallback);
+
+ virtual ~DecoderTemplate() = default;
+
+ /* WebCodecs interfaces */
+ public:
+ IMPL_EVENT_HANDLER(dequeue)
+
+ CodecState State() const { return mState; };
+
+ uint32_t DecodeQueueSize() const { return mDecodeQueueSize; };
+
+ void Configure(const ConfigType& aConfig, ErrorResult& aRv);
+
+ void Decode(InputType& aInput, ErrorResult& aRv);
+
+ already_AddRefed<Promise> Flush(ErrorResult& aRv);
+
+ void Reset(ErrorResult& aRv);
+
+ void Close(ErrorResult& aRv);
+
+ /* Type conversion functions for the Decoder implementation */
+ protected:
+ virtual already_AddRefed<MediaRawData> InputDataToMediaRawData(
+ UniquePtr<InputTypeInternal>&& aData, TrackInfo& aInfo,
+ const ConfigTypeInternal& aConfig) = 0;
+ virtual nsTArray<RefPtr<OutputType>> DecodedDataToOutputType(
+ nsIGlobalObject* aGlobalObject, const nsTArray<RefPtr<MediaData>>&& aData,
+ ConfigTypeInternal& aConfig) = 0;
+
+ protected:
+ // DecoderTemplate can run on either main thread or worker thread.
+ void AssertIsOnOwningThread() const {
+ NS_ASSERT_OWNINGTHREAD(DecoderTemplate);
+ }
+
+ Result<Ok, nsresult> ResetInternal(const nsresult& aResult);
+ // Calling this method calls the error callback synchronously.
+ MOZ_CAN_RUN_SCRIPT
+ void CloseInternal(const nsresult& aResult);
+ // Calling this method doesn't call the error calback.
+ Result<Ok, nsresult> CloseInternalWithAbort();
+
+ MOZ_CAN_RUN_SCRIPT void ReportError(const nsresult& aResult);
+ MOZ_CAN_RUN_SCRIPT void OutputDecodedData(
+ const nsTArray<RefPtr<MediaData>>&& aData);
+
+ void ScheduleDequeueEventIfNeeded();
+ nsresult FireEvent(nsAtom* aTypeWithOn, const nsAString& aEventType);
+
+ void ProcessControlMessageQueue();
+ void CancelPendingControlMessages(const nsresult& aResult);
+
+ // Queue a task to the control thread. This is to be used when a task needs to
+ // perform multiple steps.
+ template <typename Func>
+ void QueueATask(const char* aName, Func&& aSteps);
+
+ MessageProcessedResult ProcessConfigureMessage(
+ UniquePtr<ControlMessage>& aMessage);
+
+ MessageProcessedResult ProcessDecodeMessage(
+ UniquePtr<ControlMessage>& aMessage);
+
+ MessageProcessedResult ProcessFlushMessage(
+ UniquePtr<ControlMessage>& aMessage);
+
+ // Returns true when mAgent can be created.
+ bool CreateDecoderAgent(DecoderAgent::Id aId,
+ UniquePtr<ConfigTypeInternal>&& aConfig,
+ UniquePtr<TrackInfo>&& aInfo);
+ void DestroyDecoderAgentIfAny();
+
+ // Constant in practice, only set in ctor.
+ RefPtr<WebCodecsErrorCallback> mErrorCallback;
+ RefPtr<OutputCallbackType> mOutputCallback;
+
+ CodecState mState;
+ bool mKeyChunkRequired;
+
+ bool mMessageQueueBlocked;
+ std::queue<UniquePtr<ControlMessage>> mControlMessageQueue;
+ UniquePtr<ControlMessage> mProcessingMessage;
+
+ uint32_t mDecodeQueueSize;
+ bool mDequeueEventScheduled;
+
+ // A unique id tracking the ConfigureMessage and will be used as the
+ // DecoderAgent's Id.
+ uint32_t mLatestConfigureId;
+ // Tracking how many decode data has been enqueued and this number will be
+ // used as the DecodeMessage's Id.
+ size_t mDecodeCounter;
+ // Tracking how many flush request has been enqueued and this number will be
+ // used as the FlushMessage's Id.
+ size_t mFlushCounter;
+
+ // DecoderAgent will be created every time "configure" is being processed, and
+ // will be destroyed when "reset" or another "configure" is called (spec
+ // allows calling two "configure" without a "reset" in between).
+ RefPtr<DecoderAgent> mAgent;
+ UniquePtr<ConfigTypeInternal> mActiveConfig;
+
+ // Used to add a nsIAsyncShutdownBlocker on main thread to block
+ // xpcom-shutdown before the underlying MediaDataDecoder is created. The
+ // blocker will be held until the underlying MediaDataDecoder has been shut
+ // down. This blocker guarantees RemoteDecoderManagerChild's thread, where the
+ // underlying RemoteMediaDataDecoder is on, outlives the
+ // RemoteMediaDataDecoder, since the thread releasing, which happens on main
+ // thread when getting a xpcom-shutdown signal, is blocked by the added
+ // blocker. As a result, RemoteMediaDataDecoder can safely work on worker
+ // thread with a holding blocker (otherwise, if RemoteDecoderManagerChild
+ // releases its thread on main thread before RemoteMediaDataDecoder's
+ // Shutdown() task run on worker thread, RemoteMediaDataDecoder has no thread
+ // to run).
+ UniquePtr<media::ShutdownBlockingTicket> mShutdownBlocker;
+
+ // Held to make sure the dispatched tasks can be done before worker is going
+ // away. As long as this worker-ref is held somewhere, the tasks dispatched to
+ // the worker can be executed (otherwise the tasks would be canceled). This
+ // ref should be activated as long as the underlying MediaDataDecoder is
+ // alive, and should keep alive until mShutdownBlocker is dropped, so all
+ // MediaDataDecoder's tasks and mShutdownBlocker-releasing task can be
+ // executed.
+ // TODO: Use StrongWorkerRef instead if this is always used in the same
+ // thread?
+ RefPtr<ThreadSafeWorkerRef> mWorkerRef;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_DecoderTemplate_h
diff --git a/dom/media/webcodecs/DecoderTypes.h b/dom/media/webcodecs/DecoderTypes.h
new file mode 100644
index 0000000000..56aa82046f
--- /dev/null
+++ b/dom/media/webcodecs/DecoderTypes.h
@@ -0,0 +1,117 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_DecoderTypes_h
+#define mozilla_dom_DecoderTypes_h
+
+#include "MediaData.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/dom/EncodedVideoChunk.h"
+#include "mozilla/dom/VideoColorSpaceBinding.h"
+#include "mozilla/dom/VideoDecoderBinding.h"
+#include "mozilla/dom/VideoFrame.h"
+#include "nsStringFwd.h"
+#include "nsTLiteralString.h"
+
+namespace mozilla {
+
+class TrackInfo;
+class MediaByteBuffer;
+
+namespace dom {
+
+struct VideoColorSpaceInternal {
+ explicit VideoColorSpaceInternal(const VideoColorSpaceInit& aColorSpaceInit);
+ VideoColorSpaceInternal() = default;
+ VideoColorSpaceInit ToColorSpaceInit() const;
+
+ bool operator==(const VideoColorSpaceInternal& aOther) const {
+ return mFullRange == aOther.mFullRange && mMatrix == aOther.mMatrix &&
+ mPrimaries == aOther.mPrimaries && mTransfer == aOther.mTransfer;
+ }
+
+ Maybe<bool> mFullRange;
+ Maybe<VideoMatrixCoefficients> mMatrix;
+ Maybe<VideoColorPrimaries> mPrimaries;
+ Maybe<VideoTransferCharacteristics> mTransfer;
+};
+
+class VideoDecoderConfigInternal {
+ public:
+ static UniquePtr<VideoDecoderConfigInternal> Create(
+ const VideoDecoderConfig& aConfig);
+ VideoDecoderConfigInternal(const nsAString& aCodec,
+ Maybe<uint32_t>&& aCodedHeight,
+ Maybe<uint32_t>&& aCodedWidth,
+ Maybe<VideoColorSpaceInternal>&& aColorSpace,
+ Maybe<RefPtr<MediaByteBuffer>>&& aDescription,
+ Maybe<uint32_t>&& aDisplayAspectHeight,
+ Maybe<uint32_t>&& aDisplayAspectWidth,
+ const HardwareAcceleration& aHardwareAcceleration,
+ Maybe<bool>&& aOptimizeForLatency);
+ ~VideoDecoderConfigInternal() = default;
+
+ nsString ToString() const;
+
+ bool Equals(const VideoDecoderConfigInternal& aOther) const {
+ if (mDescription.isSome() != aOther.mDescription.isSome()) {
+ return false;
+ }
+ if (mDescription.isSome() && aOther.mDescription.isSome()) {
+ auto lhs = mDescription.value();
+ auto rhs = aOther.mDescription.value();
+ if (lhs->Length() != rhs->Length()) {
+ return false;
+ }
+ if (!ArrayEqual(lhs->Elements(), rhs->Elements(), lhs->Length())) {
+ return false;
+ }
+ }
+ return mCodec.Equals(aOther.mCodec) &&
+ mCodedHeight == aOther.mCodedHeight &&
+ mCodedWidth == aOther.mCodedWidth &&
+ mColorSpace == aOther.mColorSpace &&
+ mDisplayAspectHeight == aOther.mDisplayAspectWidth &&
+ mHardwareAcceleration == aOther.mHardwareAcceleration &&
+ mOptimizeForLatency == aOther.mOptimizeForLatency;
+ }
+
+ nsString mCodec;
+ Maybe<uint32_t> mCodedHeight;
+ Maybe<uint32_t> mCodedWidth;
+ Maybe<VideoColorSpaceInternal> mColorSpace;
+ Maybe<RefPtr<MediaByteBuffer>> mDescription;
+ Maybe<uint32_t> mDisplayAspectHeight;
+ Maybe<uint32_t> mDisplayAspectWidth;
+ HardwareAcceleration mHardwareAcceleration;
+ Maybe<bool> mOptimizeForLatency;
+};
+
+class VideoDecoderTraits {
+ public:
+ static constexpr nsLiteralCString Name = "VideoDecoder"_ns;
+ using ConfigType = VideoDecoderConfig;
+ using ConfigTypeInternal = VideoDecoderConfigInternal;
+ using InputType = EncodedVideoChunk;
+ using InputTypeInternal = EncodedVideoChunkData;
+ using OutputType = VideoFrame;
+ using OutputCallbackType = VideoFrameOutputCallback;
+
+ static bool IsSupported(const ConfigTypeInternal& aConfig);
+ static Result<UniquePtr<TrackInfo>, nsresult> CreateTrackInfo(
+ const ConfigTypeInternal& aConfig);
+ static bool Validate(const ConfigType& aConfig, nsCString& aErrorMessage);
+ static UniquePtr<ConfigTypeInternal> CreateConfigInternal(
+ const ConfigType& aConfig);
+ static bool IsKeyChunk(const InputType& aInput);
+ static UniquePtr<InputTypeInternal> CreateInputInternal(
+ const InputType& aInput);
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_DecoderTypes_h
diff --git a/dom/media/webcodecs/EncodedVideoChunk.cpp b/dom/media/webcodecs/EncodedVideoChunk.cpp
new file mode 100644
index 0000000000..c231740d05
--- /dev/null
+++ b/dom/media/webcodecs/EncodedVideoChunk.cpp
@@ -0,0 +1,261 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/EncodedVideoChunk.h"
+#include <utility>
+#include "mozilla/dom/EncodedVideoChunkBinding.h"
+
+#include "MediaData.h"
+#include "TimeUnits.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/Logging.h"
+#include "mozilla/PodOperations.h"
+#include "mozilla/dom/StructuredCloneHolder.h"
+#include "mozilla/dom/StructuredCloneTags.h"
+#include "mozilla/dom/WebCodecsUtils.h"
+
+extern mozilla::LazyLogModule gWebCodecsLog;
+using mozilla::media::TimeUnit;
+
+namespace mozilla::dom {
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+
+#ifdef LOGW
+# undef LOGW
+#endif // LOGW
+#define LOGW(msg, ...) LOG_INTERNAL(Warning, msg, ##__VA_ARGS__)
+
+#ifdef LOGE
+# undef LOGE
+#endif // LOGE
+#define LOGE(msg, ...) LOG_INTERNAL(Error, msg, ##__VA_ARGS__)
+
+// Only needed for refcounted objects.
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(EncodedVideoChunk, mParent)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(EncodedVideoChunk)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(EncodedVideoChunk)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(EncodedVideoChunk)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+EncodedVideoChunkData::EncodedVideoChunkData(
+ already_AddRefed<MediaAlignedByteBuffer> aBuffer,
+ const EncodedVideoChunkType& aType, int64_t aTimestamp,
+ Maybe<uint64_t>&& aDuration)
+ : mBuffer(aBuffer),
+ mType(aType),
+ mTimestamp(aTimestamp),
+ mDuration(aDuration) {
+ MOZ_ASSERT(mBuffer);
+ MOZ_ASSERT(mBuffer->Length() == mBuffer->Size());
+ MOZ_ASSERT(mBuffer->Length() <=
+ static_cast<size_t>(std::numeric_limits<uint32_t>::max()));
+}
+
+EncodedVideoChunkData::~EncodedVideoChunkData() = default;
+
+UniquePtr<EncodedVideoChunkData> EncodedVideoChunkData::Clone() const {
+ if (!mBuffer) {
+ LOGE("No buffer in EncodedVideoChunkData %p to clone!", this);
+ return nullptr;
+ }
+
+ // Since EncodedVideoChunkData can be zero-sized, cloning a zero-sized chunk
+ // is allowed.
+ if (mBuffer->Size() == 0) {
+ LOGW("Cloning an empty EncodedVideoChunkData %p", this);
+ }
+
+ auto buffer =
+ MakeRefPtr<MediaAlignedByteBuffer>(mBuffer->Data(), mBuffer->Length());
+ if (!buffer || buffer->Size() != mBuffer->Size()) {
+ LOGE("OOM to copy EncodedVideoChunkData %p", this);
+ return nullptr;
+ }
+
+ return MakeUnique<EncodedVideoChunkData>(buffer.forget(), mType, mTimestamp,
+ Maybe<uint64_t>(mDuration));
+}
+
+already_AddRefed<MediaRawData> EncodedVideoChunkData::TakeData() {
+ if (!mBuffer || !(*mBuffer)) {
+ LOGE("EncodedVideoChunkData %p has no data!", this);
+ return nullptr;
+ }
+
+ RefPtr<MediaRawData> sample(new MediaRawData(std::move(*mBuffer)));
+ sample->mKeyframe = mType == EncodedVideoChunkType::Key;
+ sample->mTime = TimeUnit::FromMicroseconds(mTimestamp);
+ sample->mTimecode = TimeUnit::FromMicroseconds(mTimestamp);
+
+ if (mDuration) {
+ CheckedInt64 duration(*mDuration);
+ if (!duration.isValid()) {
+ LOGE("EncodedVideoChunkData %p 's duration exceeds TimeUnit's limit",
+ this);
+ return nullptr;
+ }
+ sample->mDuration = TimeUnit::FromMicroseconds(duration.value());
+ }
+
+ return sample.forget();
+}
+
+EncodedVideoChunk::EncodedVideoChunk(
+ nsIGlobalObject* aParent, already_AddRefed<MediaAlignedByteBuffer> aBuffer,
+ const EncodedVideoChunkType& aType, int64_t aTimestamp,
+ Maybe<uint64_t>&& aDuration)
+ : EncodedVideoChunkData(std::move(aBuffer), aType, aTimestamp,
+ std::move(aDuration)),
+ mParent(aParent) {}
+
+EncodedVideoChunk::EncodedVideoChunk(nsIGlobalObject* aParent,
+ const EncodedVideoChunkData& aData)
+ : EncodedVideoChunkData(aData), mParent(aParent) {}
+
+nsIGlobalObject* EncodedVideoChunk::GetParentObject() const {
+ AssertIsOnOwningThread();
+
+ return mParent.get();
+}
+
+JSObject* EncodedVideoChunk::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ AssertIsOnOwningThread();
+
+ return EncodedVideoChunk_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+// https://w3c.github.io/webcodecs/#encodedvideochunk-constructors
+/* static */
+already_AddRefed<EncodedVideoChunk> EncodedVideoChunk::Constructor(
+ const GlobalObject& aGlobal, const EncodedVideoChunkInit& aInit,
+ ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ auto buffer = ProcessTypedArrays(
+ aInit.mData,
+ [&](const Span<uint8_t>& aData,
+ JS::AutoCheckCannotGC&&) -> RefPtr<MediaAlignedByteBuffer> {
+ // Make sure it's in uint32_t's range.
+ CheckedUint32 byteLength(aData.Length());
+ if (!byteLength.isValid()) {
+ aRv.Throw(NS_ERROR_INVALID_ARG);
+ return nullptr;
+ }
+ if (aData.Length() == 0) {
+ LOGW("Buffer for constructing EncodedVideoChunk is empty!");
+ }
+ RefPtr<MediaAlignedByteBuffer> buf = MakeRefPtr<MediaAlignedByteBuffer>(
+ aData.Elements(), aData.Length());
+
+ // Instead of checking *buf, size comparision is used to allow
+ // constructing a zero-sized EncodedVideoChunk.
+ if (!buf || buf->Size() != aData.Length()) {
+ aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+ return nullptr;
+ }
+ return buf;
+ });
+
+ RefPtr<EncodedVideoChunk> chunk(new EncodedVideoChunk(
+ global, buffer.forget(), aInit.mType, aInit.mTimestamp,
+ OptionalToMaybe(aInit.mDuration)));
+ return aRv.Failed() ? nullptr : chunk.forget();
+}
+
+EncodedVideoChunkType EncodedVideoChunk::Type() const {
+ AssertIsOnOwningThread();
+
+ return mType;
+}
+
+int64_t EncodedVideoChunk::Timestamp() const {
+ AssertIsOnOwningThread();
+
+ return mTimestamp;
+}
+
+Nullable<uint64_t> EncodedVideoChunk::GetDuration() const {
+ AssertIsOnOwningThread();
+ return MaybeToNullable(mDuration);
+}
+
+uint32_t EncodedVideoChunk::ByteLength() const {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mBuffer);
+
+ return static_cast<uint32_t>(mBuffer->Length());
+}
+
+// https://w3c.github.io/webcodecs/#dom-encodedvideochunk-copyto
+void EncodedVideoChunk::CopyTo(
+ const MaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aDestination,
+ ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ ProcessTypedArraysFixed(aDestination, [&](const Span<uint8_t>& aData) {
+ if (mBuffer->Size() > aData.size_bytes()) {
+ aRv.ThrowTypeError(
+ "Destination ArrayBuffer smaller than source EncodedVideoChunk");
+ return;
+ }
+
+ PodCopy(aData.data(), mBuffer->Data(), mBuffer->Size());
+ });
+}
+
+// https://w3c.github.io/webcodecs/#ref-for-deserialization-steps%E2%91%A0
+/* static */
+JSObject* EncodedVideoChunk::ReadStructuredClone(
+ JSContext* aCx, nsIGlobalObject* aGlobal, JSStructuredCloneReader* aReader,
+ const EncodedVideoChunkData& aData) {
+ JS::Rooted<JS::Value> value(aCx, JS::NullValue());
+ // To avoid a rooting hazard error from returning a raw JSObject* before
+ // running the RefPtr destructor, RefPtr needs to be destructed before
+ // returning the raw JSObject*, which is why the RefPtr<EncodedVideoChunk> is
+ // created in the scope below. Otherwise, the static analysis infers the
+ // RefPtr cannot be safely destructed while the unrooted return JSObject* is
+ // on the stack.
+ {
+ auto frame = MakeRefPtr<EncodedVideoChunk>(aGlobal, aData);
+ if (!GetOrCreateDOMReflector(aCx, frame, &value) || !value.isObject()) {
+ return nullptr;
+ }
+ }
+ return value.toObjectOrNull();
+}
+
+// https://w3c.github.io/webcodecs/#ref-for-serialization-steps%E2%91%A0
+bool EncodedVideoChunk::WriteStructuredClone(
+ JSStructuredCloneWriter* aWriter, StructuredCloneHolder* aHolder) const {
+ AssertIsOnOwningThread();
+
+ // Indexing the chunk and send the index to the receiver.
+ const uint32_t index =
+ static_cast<uint32_t>(aHolder->EncodedVideoChunks().Length());
+ // The serialization is limited to the same process scope so it's ok to
+ // serialize a reference instead of a copy.
+ aHolder->EncodedVideoChunks().AppendElement(EncodedVideoChunkData(*this));
+ return !NS_WARN_IF(
+ !JS_WriteUint32Pair(aWriter, SCTAG_DOM_ENCODEDVIDEOCHUNK, index));
+}
+
+#undef LOGW
+#undef LOGE
+#undef LOG_INTERNAL
+
+} // namespace mozilla::dom
diff --git a/dom/media/webcodecs/EncodedVideoChunk.h b/dom/media/webcodecs/EncodedVideoChunk.h
new file mode 100644
index 0000000000..3a9fb1e368
--- /dev/null
+++ b/dom/media/webcodecs/EncodedVideoChunk.h
@@ -0,0 +1,119 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_EncodedVideoChunk_h
+#define mozilla_dom_EncodedVideoChunk_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Buffer.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+
+class nsIGlobalObject;
+
+namespace mozilla {
+
+class MediaAlignedByteBuffer;
+class MediaRawData;
+
+namespace dom {
+
+class MaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer;
+class OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer;
+class StructuredCloneHolder;
+
+enum class EncodedVideoChunkType : uint8_t;
+struct EncodedVideoChunkInit;
+
+} // namespace dom
+} // namespace mozilla
+
+namespace mozilla::dom {
+
+class EncodedVideoChunkData {
+ public:
+ EncodedVideoChunkData(already_AddRefed<MediaAlignedByteBuffer> aBuffer,
+ const EncodedVideoChunkType& aType, int64_t aTimestamp,
+ Maybe<uint64_t>&& aDuration);
+ EncodedVideoChunkData(const EncodedVideoChunkData& aData) = default;
+ ~EncodedVideoChunkData();
+
+ UniquePtr<EncodedVideoChunkData> Clone() const;
+ already_AddRefed<MediaRawData> TakeData();
+
+ protected:
+ // mBuffer's byte length is guaranteed to be smaller than UINT32_MAX.
+ RefPtr<MediaAlignedByteBuffer> mBuffer;
+ EncodedVideoChunkType mType;
+ int64_t mTimestamp;
+ Maybe<uint64_t> mDuration;
+};
+
+class EncodedVideoChunk final : public EncodedVideoChunkData,
+ public nsISupports,
+ public nsWrapperCache {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(EncodedVideoChunk)
+
+ public:
+ EncodedVideoChunk(nsIGlobalObject* aParent,
+ already_AddRefed<MediaAlignedByteBuffer> aBuffer,
+ const EncodedVideoChunkType& aType, int64_t aTimestamp,
+ Maybe<uint64_t>&& aDuration);
+
+ EncodedVideoChunk(nsIGlobalObject* aParent,
+ const EncodedVideoChunkData& aData);
+
+ protected:
+ ~EncodedVideoChunk() = default;
+
+ public:
+ nsIGlobalObject* GetParentObject() const;
+
+ JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ static already_AddRefed<EncodedVideoChunk> Constructor(
+ const GlobalObject& aGlobal, const EncodedVideoChunkInit& aInit,
+ ErrorResult& aRv);
+
+ EncodedVideoChunkType Type() const;
+
+ int64_t Timestamp() const;
+
+ Nullable<uint64_t> GetDuration() const;
+
+ uint32_t ByteLength() const;
+
+ void CopyTo(
+ const MaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aDestination,
+ ErrorResult& aRv);
+
+ // [Serializable] implementations: {Read, Write}StructuredClone
+ static JSObject* ReadStructuredClone(JSContext* aCx, nsIGlobalObject* aGlobal,
+ JSStructuredCloneReader* aReader,
+ const EncodedVideoChunkData& aData);
+
+ bool WriteStructuredClone(JSStructuredCloneWriter* aWriter,
+ StructuredCloneHolder* aHolder) const;
+
+ private:
+ // EncodedVideoChunk can run on either main thread or worker thread.
+ void AssertIsOnOwningThread() const {
+ NS_ASSERT_OWNINGTHREAD(EncodedVideoChunk);
+ }
+
+ nsCOMPtr<nsIGlobalObject> mParent;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_EncodedVideoChunk_h
diff --git a/dom/media/webcodecs/EncoderAgent.cpp b/dom/media/webcodecs/EncoderAgent.cpp
new file mode 100644
index 0000000000..e6af17a0be
--- /dev/null
+++ b/dom/media/webcodecs/EncoderAgent.cpp
@@ -0,0 +1,441 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "EncoderAgent.h"
+
+#include "PDMFactory.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Logging.h"
+#include "nsThreadUtils.h"
+
+extern mozilla::LazyLogModule gWebCodecsLog;
+
+namespace mozilla {
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+
+#ifdef LOG
+# undef LOG
+#endif // LOG
+#define LOG(msg, ...) LOG_INTERNAL(Debug, msg, ##__VA_ARGS__)
+
+#ifdef LOGW
+# undef LOGW
+#endif // LOGE
+#define LOGW(msg, ...) LOG_INTERNAL(Warning, msg, ##__VA_ARGS__)
+
+#ifdef LOGE
+# undef LOGE
+#endif // LOGE
+#define LOGE(msg, ...) LOG_INTERNAL(Error, msg, ##__VA_ARGS__)
+
+#ifdef LOGV
+# undef LOGV
+#endif // LOGV
+#define LOGV(msg, ...) LOG_INTERNAL(Verbose, msg, ##__VA_ARGS__)
+
+EncoderAgent::EncoderAgent(WebCodecsId aId)
+ : mId(aId),
+ mOwnerThread(GetCurrentSerialEventTarget()),
+ mPEMFactory(MakeRefPtr<PEMFactory>()),
+ mEncoder(nullptr),
+ mState(State::Unconfigured) {
+ MOZ_ASSERT(mOwnerThread);
+ MOZ_ASSERT(mPEMFactory);
+ LOG("EncoderAgent #%zu (%p) ctor", mId, this);
+}
+
+EncoderAgent::~EncoderAgent() {
+ LOG("EncoderAgent #%zu (%p) dtor", mId, this);
+ MOZ_ASSERT(mState == State::Unconfigured, "encoder released in wrong state");
+ MOZ_ASSERT(!mEncoder, "encoder must be shutdown");
+}
+
+RefPtr<EncoderAgent::ConfigurePromise> EncoderAgent::Configure(
+ const EncoderConfig& aConfig) {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(mState == State::Unconfigured || mState == State::Error);
+ MOZ_ASSERT(mConfigurePromise.IsEmpty());
+ MOZ_ASSERT(!mCreateRequest.Exists());
+ MOZ_ASSERT(!mInitRequest.Exists());
+
+ if (mState == State::Error) {
+ LOGE("EncoderAgent #%zu (%p) tried to configure in error state", mId, this);
+ return ConfigurePromise::CreateAndReject(
+ MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
+ "Cannot configure in error state"),
+ __func__);
+ }
+
+ MOZ_ASSERT(mState == State::Unconfigured);
+ MOZ_ASSERT(!mEncoder);
+ SetState(State::Configuring);
+
+ LOG("EncoderAgent #%zu (%p) is creating an encoder (%s)", mId, this,
+ GetCodecTypeString(aConfig.mCodec));
+
+ RefPtr<ConfigurePromise> p = mConfigurePromise.Ensure(__func__);
+
+ mPEMFactory->CreateEncoderAsync(aConfig, dom::GetWebCodecsEncoderTaskQueue())
+ ->Then(
+ mOwnerThread, __func__,
+ [self = RefPtr{this}](RefPtr<MediaDataEncoder>&& aEncoder) {
+ self->mCreateRequest.Complete();
+
+ // If EncoderAgent has been shut down, shut the created encoder down
+ // and return.
+ if (!self->mShutdownWhileCreationPromise.IsEmpty()) {
+ MOZ_ASSERT(self->mState == State::ShuttingDown);
+ MOZ_ASSERT(self->mConfigurePromise.IsEmpty(),
+ "configuration should have been rejected");
+
+ LOGW(
+ "EncoderAgent #%zu (%p) has been shut down. We need to shut "
+ "the newly created encoder down",
+ self->mId, self.get());
+ aEncoder->Shutdown()->Then(
+ self->mOwnerThread, __func__,
+ [self](const ShutdownPromise::ResolveOrRejectValue& aValue) {
+ MOZ_ASSERT(self->mState == State::ShuttingDown);
+
+ LOGW(
+ "EncoderAgent #%zu (%p), newly created encoder "
+ "shutdown "
+ "has been %s",
+ self->mId, self.get(),
+ aValue.IsResolve() ? "resolved" : "rejected");
+
+ self->SetState(State::Unconfigured);
+
+ self->mShutdownWhileCreationPromise.ResolveOrReject(
+ aValue, __func__);
+ });
+ return;
+ }
+
+ self->mEncoder = aEncoder.forget();
+ LOG("EncoderAgent #%zu (%p) has created a encoder, now initialize "
+ "it",
+ self->mId, self.get());
+ self->mEncoder->Init()
+ ->Then(
+ self->mOwnerThread, __func__,
+ [self]() {
+ self->mInitRequest.Complete();
+ LOG("EncoderAgent #%zu (%p) has initialized the encoder",
+ self->mId, self.get());
+ self->SetState(State::Configured);
+ self->mConfigurePromise.Resolve(true, __func__);
+ },
+ [self](const MediaResult& aError) {
+ self->mInitRequest.Complete();
+ LOGE(
+ "EncoderAgent #%zu (%p) failed to initialize the "
+ "encoder",
+ self->mId, self.get());
+ self->SetState(State::Error);
+ self->mConfigurePromise.Reject(aError, __func__);
+ })
+ ->Track(self->mInitRequest);
+ },
+ [self = RefPtr{this}](const MediaResult& aError) {
+ self->mCreateRequest.Complete();
+ LOGE("EncoderAgent #%zu (%p) failed to create a encoder", self->mId,
+ self.get());
+
+ // If EncoderAgent has been shut down, we need to resolve the
+ // shutdown promise.
+ if (!self->mShutdownWhileCreationPromise.IsEmpty()) {
+ MOZ_ASSERT(self->mState == State::ShuttingDown);
+ MOZ_ASSERT(self->mConfigurePromise.IsEmpty(),
+ "configuration should have been rejected");
+
+ LOGW(
+ "EncoderAgent #%zu (%p) has been shut down. Resolve the "
+ "shutdown promise right away since encoder creation failed",
+ self->mId, self.get());
+
+ self->SetState(State::Unconfigured);
+ self->mShutdownWhileCreationPromise.Resolve(true, __func__);
+ return;
+ }
+
+ self->SetState(State::Error);
+ self->mConfigurePromise.Reject(aError, __func__);
+ })
+ ->Track(mCreateRequest);
+
+ return p;
+}
+
+RefPtr<EncoderAgent::ReconfigurationPromise> EncoderAgent::Reconfigure(
+ const RefPtr<const EncoderConfigurationChangeList>& aConfigChanges) {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(mState == State::Configured || mState == State::Error);
+ MOZ_ASSERT(mReconfigurationPromise.IsEmpty());
+
+ if (mState == State::Error) {
+ LOGE("EncoderAgent #%zu (%p) tried to reconfigure in error state", mId,
+ this);
+ return ReconfigurationPromise::CreateAndReject(
+ MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
+ "Cannot reconfigure in error state"),
+ __func__);
+ }
+
+ MOZ_ASSERT(mEncoder);
+ SetState(State::Configuring);
+
+ LOG("EncoderAgent #%zu (%p) is reconfiguring its encoder (%s)", mId, this,
+ NS_ConvertUTF16toUTF8(aConfigChanges->ToString().get()).get());
+
+ RefPtr<ReconfigurationPromise> p = mReconfigurationPromise.Ensure(__func__);
+
+ mEncoder->Reconfigure(aConfigChanges)
+ ->Then(
+ mOwnerThread, __func__,
+ [self = RefPtr{this}](bool) {
+ self->mReconfigurationRequest.Complete();
+ LOGE("EncoderAgent #%zu (%p) reconfigure success", self->mId,
+ self.get());
+ self->mReconfigurationPromise.Resolve(true, __func__);
+ },
+ [self = RefPtr{this}](const MediaResult& aError) {
+ self->mReconfigurationRequest.Complete();
+ LOGE("EncoderAgent #%zu (%p) reconfigure failure", self->mId,
+ self.get());
+ // Not a a fatal error per se, the owner will deal with it.
+ self->mReconfigurationPromise.Reject(aError, __func__);
+ })
+ ->Track(mReconfigurationRequest);
+
+ return p;
+}
+
+RefPtr<ShutdownPromise> EncoderAgent::Shutdown() {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+
+ auto r =
+ MediaResult(NS_ERROR_DOM_MEDIA_CANCELED, "Canceled by encoder shutdown");
+
+ // If the encoder creation has not been completed yet, wait until the encoder
+ // being created has been shut down.
+ if (mCreateRequest.Exists()) {
+ MOZ_ASSERT(!mInitRequest.Exists());
+ MOZ_ASSERT(!mConfigurePromise.IsEmpty());
+ MOZ_ASSERT(!mEncoder);
+ MOZ_ASSERT(mState == State::Configuring);
+ MOZ_ASSERT(mShutdownWhileCreationPromise.IsEmpty());
+
+ LOGW(
+ "EncoderAgent #%zu (%p) shutdown while the encoder creation for "
+ "configuration is in flight. Reject the configuration now and defer "
+ "the shutdown until the created encoder has been shut down",
+ mId, this);
+
+ // Reject the configuration in flight.
+ mConfigurePromise.Reject(r, __func__);
+
+ // Get the promise that will be resolved when the encoder being created has
+ // been destroyed.
+ SetState(State::ShuttingDown);
+ return mShutdownWhileCreationPromise.Ensure(__func__);
+ }
+
+ // If encoder creation has been completed, we must have the encoder now.
+ MOZ_ASSERT(mEncoder);
+
+ // Cancel pending initialization for configuration in flight if any.
+ mInitRequest.DisconnectIfExists();
+ mConfigurePromise.RejectIfExists(r, __func__);
+
+ mReconfigurationRequest.DisconnectIfExists();
+ mReconfigurationPromise.RejectIfExists(r, __func__);
+
+ // Cancel encoder in flight if any.
+ mEncodeRequest.DisconnectIfExists();
+ mEncodePromise.RejectIfExists(r, __func__);
+
+ // Cancel flush-out in flight if any.
+ mDrainRequest.DisconnectIfExists();
+ mEncodeRequest.DisconnectIfExists();
+
+ mDrainRequest.DisconnectIfExists();
+ mDrainPromise.RejectIfExists(r, __func__);
+
+ SetState(State::Unconfigured);
+
+ RefPtr<MediaDataEncoder> encoder = std::move(mEncoder);
+ return encoder->Shutdown();
+}
+
+RefPtr<EncoderAgent::EncodePromise> EncoderAgent::Encode(MediaData* aInput) {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(aInput);
+ MOZ_ASSERT(mState == State::Configured || mState == State::Error);
+ MOZ_ASSERT(mEncodePromise.IsEmpty());
+ MOZ_ASSERT(!mEncodeRequest.Exists());
+
+ if (mState == State::Error) {
+ LOGE("EncoderAgent #%zu (%p) tried to encoder in error state", mId, this);
+ return EncodePromise::CreateAndReject(
+ MediaResult(NS_ERROR_DOM_MEDIA_FATAL_ERR,
+ "Cannot encoder in error state"),
+ __func__);
+ }
+
+ MOZ_ASSERT(mState == State::Configured);
+ MOZ_ASSERT(mEncoder);
+ SetState(State::Encoding);
+
+ RefPtr<EncodePromise> p = mEncodePromise.Ensure(__func__);
+
+ mEncoder->Encode(aInput)
+ ->Then(
+ mOwnerThread, __func__,
+ [self = RefPtr{this}](MediaDataEncoder::EncodedData&& aData) {
+ self->mEncodeRequest.Complete();
+ LOGV("EncoderAgent #%zu (%p) encode successful", self->mId,
+ self.get());
+ self->SetState(State::Configured);
+ self->mEncodePromise.Resolve(std::move(aData), __func__);
+ },
+ [self = RefPtr{this}](const MediaResult& aError) {
+ self->mEncodeRequest.Complete();
+ LOGV("EncoderAgent #%zu (%p) failed to encode", self->mId,
+ self.get());
+ self->SetState(State::Error);
+ self->mEncodePromise.Reject(aError, __func__);
+ })
+ ->Track(mEncodeRequest);
+
+ return p;
+}
+
+RefPtr<EncoderAgent::EncodePromise> EncoderAgent::Drain() {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ // This can be called when reconfiguring the encoder.
+ MOZ_ASSERT(mState == State::Configured || mState == State::Configuring);
+ MOZ_ASSERT(mDrainPromise.IsEmpty());
+ MOZ_ASSERT(mEncoder);
+
+ SetState(State::Flushing);
+
+ RefPtr<EncodePromise> p = mDrainPromise.Ensure(__func__);
+ DryUntilDrain();
+ return p;
+}
+
+void EncoderAgent::DryUntilDrain() {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+ MOZ_ASSERT(mState == State::Flushing);
+ MOZ_ASSERT(!mDrainRequest.Exists());
+ MOZ_ASSERT(mEncoder);
+
+ LOG("EncoderAgent #%zu (%p) is draining the encoder", mId, this);
+ mEncoder->Drain()
+ ->Then(
+ mOwnerThread, __func__,
+ [self = RefPtr{this}](MediaDataEncoder::EncodedData&& aData) {
+ self->mDrainRequest.Complete();
+
+ if (aData.IsEmpty()) {
+ LOG("EncoderAgent #%zu (%p) is dry now", self->mId, self.get());
+ self->SetState(State::Configured);
+ self->mDrainPromise.Resolve(std::move(self->mDrainData),
+ __func__);
+ return;
+ }
+
+ LOG("EncoderAgent #%zu (%p) drained %zu encoder data. Keep "
+ "draining "
+ "until dry",
+ self->mId, self.get(), aData.Length());
+ self->mDrainData.AppendElements(std::move(aData));
+ self->DryUntilDrain();
+ },
+ [self = RefPtr{this}](const MediaResult& aError) {
+ self->mDrainRequest.Complete();
+
+ LOGE("EncoderAgent %p failed to drain encoder", self.get());
+ self->mDrainData.Clear();
+ self->mDrainPromise.Reject(aError, __func__);
+ })
+ ->Track(mDrainRequest);
+}
+
+void EncoderAgent::SetState(State aState) {
+ MOZ_ASSERT(mOwnerThread->IsOnCurrentThread());
+
+ auto validateStateTransition = [](State aOldState, State aNewState) {
+ switch (aOldState) {
+ case State::Unconfigured:
+ return aNewState == State::Configuring;
+ case State::Configuring:
+ return aNewState == State::Configured || aNewState == State::Error ||
+ aNewState == State::Flushing ||
+ aNewState == State::Unconfigured ||
+ aNewState == State::ShuttingDown;
+ case State::Configured:
+ return aNewState == State::Unconfigured ||
+ aNewState == State::Configuring ||
+ aNewState == State::Encoding || aNewState == State::Flushing;
+ case State::Encoding:
+ case State::Flushing:
+ return aNewState == State::Configured || aNewState == State::Error ||
+ aNewState == State::Unconfigured;
+ case State::ShuttingDown:
+ return aNewState == State::Unconfigured;
+ case State::Error:
+ return aNewState == State::Unconfigured;
+ default:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("Unhandled state transition");
+ return false;
+ };
+
+ auto stateToString = [](State aState) -> const char* {
+ switch (aState) {
+ case State::Unconfigured:
+ return "Unconfigured";
+ case State::Configuring:
+ return "Configuring";
+ case State::Configured:
+ return "Configured";
+ case State::Encoding:
+ return "Encoding";
+ case State::Flushing:
+ return "Flushing";
+ case State::ShuttingDown:
+ return "ShuttingDown";
+ case State::Error:
+ return "Error";
+ default:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("Unhandled state type");
+ return "Unknown";
+ };
+
+ DebugOnly<bool> isValid = validateStateTransition(mState, aState);
+ LOGV("EncoderAgent #%zu (%p) state change: %s -> %s", mId, this,
+ stateToString(mState), stateToString(aState));
+ MOZ_ASSERT(isValid);
+ mState = aState;
+}
+
+#undef LOG
+#undef LOGW
+#undef LOGE
+#undef LOGV
+#undef LOG_INTERNAL
+
+} // namespace mozilla
diff --git a/dom/media/webcodecs/EncoderAgent.h b/dom/media/webcodecs/EncoderAgent.h
new file mode 100644
index 0000000000..387f218e29
--- /dev/null
+++ b/dom/media/webcodecs/EncoderAgent.h
@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef DOM_MEDIA_WEBCODECS_EncoderAgent_H
+#define DOM_MEDIA_WEBCODECS_EncoderAgent_H
+
+#include "MediaResult.h"
+#include "PlatformEncoderModule.h"
+#include "PEMFactory.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/TaskQueue.h"
+#include "WebCodecsUtils.h"
+
+class nsISerialEventTarget;
+
+namespace mozilla {
+
+class PDMFactory;
+class TrackInfo;
+
+namespace layers {
+class ImageContainer;
+} // namespace layers
+
+// EncoderAgent is a wrapper that contains a MediaDataEncoder. It adapts the
+// MediaDataEncoder APIs for use in WebCodecs.
+//
+// If Configure() is called, Shutdown() must be called to release the resources
+// gracefully. Except Shutdown(), all the methods can't be called concurrently,
+// meaning a method can only be called when the previous API call has completed.
+// The responsability of arranging the method calls is on the caller.
+//
+// When Shutdown() is called, all the operations in flight are canceled and the
+// MediaDataEncoder is shut down. On the other hand, errors are final. A new
+// EncoderAgent must be created when an error is encountered.
+//
+// All the methods need to be called on the EncoderAgent's owner thread. In
+// WebCodecs, it's either on the main thread or worker thread.
+class EncoderAgent final {
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(EncoderAgent);
+
+ explicit EncoderAgent(WebCodecsId aId);
+
+ // The following APIs are owner thread only.
+
+ using ConfigurePromise = MozPromise<bool, MediaResult, true /* exclusive */>;
+ using ReconfigurationPromise = MediaDataEncoder::ReconfigurationPromise;
+ RefPtr<ConfigurePromise> Configure(const EncoderConfig& aConfig);
+ RefPtr<ReconfigurationPromise> Reconfigure(
+ const RefPtr<const EncoderConfigurationChangeList>& aConfigChange);
+ RefPtr<ShutdownPromise> Shutdown();
+ using EncodePromise = MediaDataEncoder::EncodePromise;
+ RefPtr<EncodePromise> Encode(MediaData* aInput);
+ // WebCodecs's flush() flushes out all the pending encoded data in the
+ // encoder. It's called Drain internally.
+ RefPtr<EncodePromise> Drain();
+
+ const WebCodecsId mId;
+
+ private:
+ ~EncoderAgent();
+
+ // Push out all the data in the MediaDataEncoder's pipeline.
+ // TODO: MediaDataEncoder should implement this, instead of asking call site
+ // to run `Drain` multiple times.
+ RefPtr<EncodePromise> Dry();
+ void DryUntilDrain();
+
+ enum class State {
+ Unconfigured,
+ Configuring,
+ Configured,
+ Encoding,
+ Flushing,
+ ShuttingDown,
+ Error,
+ };
+ void SetState(State aState);
+
+ const RefPtr<nsISerialEventTarget> mOwnerThread;
+ const RefPtr<PEMFactory> mPEMFactory;
+ RefPtr<MediaDataEncoder> mEncoder;
+ State mState;
+
+ // Configure
+ MozPromiseHolder<ConfigurePromise> mConfigurePromise;
+ using CreateEncoderPromise = PlatformEncoderModule::CreateEncoderPromise;
+ MozPromiseRequestHolder<CreateEncoderPromise> mCreateRequest;
+ using InitPromise = MediaDataEncoder::InitPromise;
+ MozPromiseRequestHolder<InitPromise> mInitRequest;
+
+ // Reconfigure
+ MozPromiseHolder<ReconfigurationPromise> mReconfigurationPromise;
+ using ReconfigureEncoderRequest = ReconfigurationPromise;
+ MozPromiseRequestHolder<ReconfigureEncoderRequest> mReconfigurationRequest;
+
+ // Shutdown
+ MozPromiseHolder<ShutdownPromise> mShutdownWhileCreationPromise;
+
+ // Encoding
+ MozPromiseHolder<EncodePromise> mEncodePromise;
+ MozPromiseRequestHolder<EncodePromise> mEncodeRequest;
+
+ // Drain
+ MozPromiseRequestHolder<EncodePromise> mDrainRequest;
+ MozPromiseHolder<EncodePromise> mDrainPromise;
+ MediaDataEncoder::EncodedData mDrainData;
+};
+
+} // namespace mozilla
+
+#endif // DOM_MEDIA_WEBCODECS_EncoderAgent_H
diff --git a/dom/media/webcodecs/EncoderTemplate.cpp b/dom/media/webcodecs/EncoderTemplate.cpp
new file mode 100644
index 0000000000..35c8feb3f8
--- /dev/null
+++ b/dom/media/webcodecs/EncoderTemplate.cpp
@@ -0,0 +1,1228 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "EncoderTemplate.h"
+
+#include "EncoderTypes.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Try.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/VideoFrame.h"
+#include "mozilla/dom/WorkerCommon.h"
+#include "nsGkAtoms.h"
+#include "nsString.h"
+#include "nsThreadUtils.h"
+
+extern mozilla::LazyLogModule gWebCodecsLog;
+
+namespace mozilla::dom {
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+
+#ifdef LOG
+# undef LOG
+#endif // LOG
+#define LOG(msg, ...) LOG_INTERNAL(Debug, msg, ##__VA_ARGS__)
+
+#ifdef LOGW
+# undef LOGW
+#endif // LOGW
+#define LOGW(msg, ...) LOG_INTERNAL(Warning, msg, ##__VA_ARGS__)
+
+#ifdef LOGE
+# undef LOGE
+#endif // LOGE
+#define LOGE(msg, ...) LOG_INTERNAL(Error, msg, ##__VA_ARGS__)
+
+#ifdef LOGV
+# undef LOGV
+#endif // LOGV
+#define LOGV(msg, ...) LOG_INTERNAL(Verbose, msg, ##__VA_ARGS__)
+
+/*
+ * Below are ControlMessage classes implementations
+ */
+
+template <typename EncoderType>
+EncoderTemplate<EncoderType>::ControlMessage::ControlMessage(
+ WebCodecsId aConfigureId)
+ : mConfigureId(aConfigureId), mMessageId(sNextId++) {}
+
+template <typename EncoderType>
+EncoderTemplate<EncoderType>::ConfigureMessage::ConfigureMessage(
+ WebCodecsId aConfigureId, const RefPtr<ConfigTypeInternal>& aConfig)
+ : ControlMessage(aConfigureId), mConfig(aConfig) {}
+
+template <typename EncoderType>
+EncoderTemplate<EncoderType>::EncodeMessage::EncodeMessage(
+ WebCodecsId aConfigureId, RefPtr<InputTypeInternal>&& aData,
+ Maybe<VideoEncoderEncodeOptions>&& aOptions)
+ : ControlMessage(aConfigureId), mData(aData) {}
+
+template <typename EncoderType>
+EncoderTemplate<EncoderType>::FlushMessage::FlushMessage(
+ WebCodecsId aConfigureId, Promise* aPromise)
+ : ControlMessage(aConfigureId), mPromise(aPromise) {}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::FlushMessage::RejectPromiseIfAny(
+ const nsresult& aReason) {
+ if (mPromise) {
+ mPromise->MaybeReject(aReason);
+ }
+}
+
+/*
+ * Below are EncoderTemplate implementation
+ */
+
+template <typename EncoderType>
+EncoderTemplate<EncoderType>::EncoderTemplate(
+ nsIGlobalObject* aGlobalObject,
+ RefPtr<WebCodecsErrorCallback>&& aErrorCallback,
+ RefPtr<OutputCallbackType>&& aOutputCallback)
+ : DOMEventTargetHelper(aGlobalObject),
+ mErrorCallback(std::move(aErrorCallback)),
+ mOutputCallback(std::move(aOutputCallback)),
+ mState(CodecState::Unconfigured),
+ mMessageQueueBlocked(false),
+ mEncodeQueueSize(0),
+ mDequeueEventScheduled(false),
+ mLatestConfigureId(0),
+ mEncodeCounter(0),
+ mFlushCounter(0) {}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::Configure(const ConfigType& aConfig,
+ ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s::Configure %p codec %s", EncoderType::Name.get(), this,
+ NS_ConvertUTF16toUTF8(aConfig.mCodec).get());
+
+ nsCString errorMessage;
+ if (!EncoderType::Validate(aConfig, errorMessage)) {
+ LOG("Configure: Validate error: %s", errorMessage.get());
+ aRv.ThrowTypeError(errorMessage);
+ return;
+ }
+
+ if (mState == CodecState::Closed) {
+ LOG("Configure: CodecState::Closed, rejecting with InvalidState");
+ aRv.ThrowInvalidStateError("The codec is no longer usable");
+ return;
+ }
+
+ // Clone a ConfigType as the active Encode config.
+ RefPtr<ConfigTypeInternal> config =
+ EncoderType::CreateConfigInternal(aConfig);
+ if (!config) {
+ aRv.Throw(NS_ERROR_UNEXPECTED); // Invalid description data.
+ return;
+ }
+
+ mState = CodecState::Configured;
+ mEncodeCounter = 0;
+ mFlushCounter = 0;
+
+ mControlMessageQueue.push(MakeRefPtr<ConfigureMessage>(sNextId++, config));
+ mLatestConfigureId = mControlMessageQueue.back()->mMessageId;
+ LOG("%s %p enqueues %s", EncoderType::Name.get(), this,
+ mControlMessageQueue.back()->ToString().get());
+ ProcessControlMessageQueue();
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::EncodeAudioData(InputType& aInput,
+ ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s %p, EncodeAudioData", EncoderType::Name.get(), this);
+
+ if (mState != CodecState::Configured) {
+ aRv.ThrowInvalidStateError("Encoder must be configured first");
+ return;
+ }
+
+ if (aInput.IsClosed()) {
+ aRv.ThrowTypeError("input AudioData has been closed");
+ return;
+ }
+
+ mEncodeQueueSize += 1;
+ // Dummy options here as a shortcut
+ mControlMessageQueue.push(MakeRefPtr<EncodeMessage>(
+ mLatestConfigureId,
+ EncoderType::CreateInputInternal(aInput, VideoEncoderEncodeOptions())));
+ LOGV("%s %p enqueues %s", EncoderType::Name.get(), this,
+ mControlMessageQueue.back()->ToString().get());
+ ProcessControlMessageQueue();
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::EncodeVideoFrame(
+ InputType& aInput, const VideoEncoderEncodeOptions& aOptions,
+ ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s::Encode %p %s", EncoderType::Name.get(), this,
+ aInput.ToString().get());
+
+ if (mState != CodecState::Configured) {
+ aRv.ThrowInvalidStateError("Encoder must be configured first");
+ return;
+ }
+
+ if (aInput.IsClosed()) {
+ aRv.ThrowTypeError("input VideoFrame has been closed");
+ return;
+ }
+
+ mEncodeQueueSize += 1;
+ mControlMessageQueue.push(MakeRefPtr<EncodeMessage>(
+ mLatestConfigureId, EncoderType::CreateInputInternal(aInput, aOptions),
+ Some(aOptions)));
+ LOGV("%s %p enqueues %s", EncoderType::Name.get(), this,
+ mControlMessageQueue.back()->ToString().get());
+ ProcessControlMessageQueue();
+}
+
+template <typename EncoderType>
+already_AddRefed<Promise> EncoderTemplate<EncoderType>::Flush(
+ ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s::Flush %p", EncoderType::Name.get(), this);
+
+ if (mState != CodecState::Configured) {
+ LOG("%s %p, wrong state!", EncoderType::Name.get(), this);
+ aRv.ThrowInvalidStateError("Encoder must be configured first");
+ return nullptr;
+ }
+
+ RefPtr<Promise> p = Promise::Create(GetParentObject(), aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return p.forget();
+ }
+
+ mControlMessageQueue.push(MakeRefPtr<FlushMessage>(mLatestConfigureId, p));
+ LOG("%s %p enqueues %s", EncoderType::Name.get(), this,
+ mControlMessageQueue.back()->ToString().get());
+ ProcessControlMessageQueue();
+ return p.forget();
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::Reset(ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s %p, Reset", EncoderType::Name.get(), this);
+
+ if (auto r = ResetInternal(NS_ERROR_DOM_ABORT_ERR); r.isErr()) {
+ aRv.Throw(r.unwrapErr());
+ }
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::Close(ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ LOG("%s::Close %p", EncoderType::Name.get(), this);
+
+ if (auto r = CloseInternal(NS_ERROR_DOM_ABORT_ERR); r.isErr()) {
+ aRv.Throw(r.unwrapErr());
+ }
+}
+
+template <typename EncoderType>
+Result<Ok, nsresult> EncoderTemplate<EncoderType>::ResetInternal(
+ const nsresult& aResult) {
+ AssertIsOnOwningThread();
+
+ LOG("%s::Reset %p", EncoderType::Name.get(), this);
+
+ if (mState == CodecState::Closed) {
+ return Err(NS_ERROR_DOM_INVALID_STATE_ERR);
+ }
+
+ mState = CodecState::Unconfigured;
+ mEncodeCounter = 0;
+ mFlushCounter = 0;
+
+ CancelPendingControlMessages(aResult);
+ DestroyEncoderAgentIfAny();
+
+ if (mEncodeQueueSize > 0) {
+ mEncodeQueueSize = 0;
+ ScheduleDequeueEvent();
+ }
+
+ StopBlockingMessageQueue();
+
+ return Ok();
+}
+
+template <typename EncoderType>
+Result<Ok, nsresult> EncoderTemplate<EncoderType>::CloseInternal(
+ const nsresult& aResult) {
+ AssertIsOnOwningThread();
+
+ MOZ_TRY(ResetInternal(aResult));
+ mState = CodecState::Closed;
+ if (aResult != NS_ERROR_DOM_ABORT_ERR) {
+ nsCString error;
+ GetErrorName(aResult, error);
+ LOGE("%s %p Close on error: %s", EncoderType::Name.get(), this,
+ error.get());
+ ReportError(aResult);
+ }
+ return Ok();
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::ReportError(const nsresult& aResult) {
+ AssertIsOnOwningThread();
+
+ RefPtr<DOMException> e = DOMException::Create(aResult);
+ RefPtr<WebCodecsErrorCallback> cb(mErrorCallback);
+ cb->Call(*e);
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::OutputEncodedData(
+ nsTArray<RefPtr<MediaRawData>>&& aData) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(mActiveConfig);
+
+ // Get JSContext for RootedDictionary.
+ // The EncoderType::MetadataType, VideoDecoderConfig, and VideoColorSpaceInit
+ // below are rooted to work around the JS hazard issues.
+ AutoJSAPI jsapi;
+ DebugOnly<bool> ok =
+ jsapi.Init(GetParentObject()); // TODO: check returned value?
+ JSContext* cx = jsapi.cx();
+
+ RefPtr<typename EncoderType::OutputCallbackType> cb(mOutputCallback);
+ for (auto& data : aData) {
+ // It's possible to have reset() called in between this task having been
+ // dispatched, and running -- no output callback should happen when that's
+ // the case.
+ // This is imprecise in the spec, but discussed in
+ // https://github.com/w3c/webcodecs/issues/755 and agreed upon.
+ if (!mActiveConfig) {
+ return;
+ }
+ RefPtr<typename EncoderType::OutputType> encodedData =
+ EncodedDataToOutputType(GetParentObject(), data);
+
+ RootedDictionary<typename EncoderType::MetadataType> metadata(cx);
+ if (mOutputNewDecoderConfig) {
+ VideoDecoderConfigInternal decoderConfigInternal =
+ EncoderConfigToDecoderConfig(GetParentObject(), data, *mActiveConfig);
+
+ // Convert VideoDecoderConfigInternal to VideoDecoderConfig
+ RootedDictionary<VideoDecoderConfig> decoderConfig(cx);
+ decoderConfig.mCodec = decoderConfigInternal.mCodec;
+ if (decoderConfigInternal.mCodedHeight) {
+ decoderConfig.mCodedHeight.Construct(
+ decoderConfigInternal.mCodedHeight.value());
+ }
+ if (decoderConfigInternal.mCodedWidth) {
+ decoderConfig.mCodedWidth.Construct(
+ decoderConfigInternal.mCodedWidth.value());
+ }
+ if (decoderConfigInternal.mColorSpace) {
+ RootedDictionary<VideoColorSpaceInit> colorSpace(cx);
+ colorSpace.mFullRange =
+ MaybeToNullable(decoderConfigInternal.mColorSpace->mFullRange);
+ colorSpace.mMatrix =
+ MaybeToNullable(decoderConfigInternal.mColorSpace->mMatrix);
+ colorSpace.mPrimaries =
+ MaybeToNullable(decoderConfigInternal.mColorSpace->mPrimaries);
+ colorSpace.mTransfer =
+ MaybeToNullable(decoderConfigInternal.mColorSpace->mTransfer);
+ decoderConfig.mColorSpace.Construct(std::move(colorSpace));
+ }
+ if (decoderConfigInternal.mDescription &&
+ !decoderConfigInternal.mDescription.value()->IsEmpty()) {
+ auto& abov = decoderConfig.mDescription.Construct();
+ AutoEntryScript aes(GetParentObject(), "EncoderConfigToDecoderConfig");
+ size_t lengthBytes =
+ decoderConfigInternal.mDescription.value()->Length();
+ UniquePtr<uint8_t[], JS::FreePolicy> extradata(
+ new uint8_t[lengthBytes]);
+ PodCopy(extradata.get(),
+ decoderConfigInternal.mDescription.value()->Elements(),
+ lengthBytes);
+ JS::Rooted<JSObject*> description(
+ aes.cx(), JS::NewArrayBufferWithContents(aes.cx(), lengthBytes,
+ std::move(extradata)));
+ JS::Rooted<JS::Value> value(aes.cx(), JS::ObjectValue(*description));
+ DebugOnly<bool> rv = abov.Init(aes.cx(), value);
+ }
+ if (decoderConfigInternal.mDisplayAspectHeight) {
+ decoderConfig.mDisplayAspectHeight.Construct(
+ decoderConfigInternal.mDisplayAspectHeight.value());
+ }
+ if (decoderConfigInternal.mDisplayAspectWidth) {
+ decoderConfig.mDisplayAspectWidth.Construct(
+ decoderConfigInternal.mDisplayAspectWidth.value());
+ }
+ if (decoderConfigInternal.mOptimizeForLatency) {
+ decoderConfig.mOptimizeForLatency.Construct(
+ decoderConfigInternal.mOptimizeForLatency.value());
+ }
+
+ metadata.mDecoderConfig.Construct(std::move(decoderConfig));
+ mOutputNewDecoderConfig = false;
+ LOGE("New config passed to output callback: %s",
+ NS_ConvertUTF16toUTF8(decoderConfigInternal.ToString()).get());
+ }
+
+ nsAutoCString metadataInfo;
+
+ if (data->mTemporalLayerId) {
+ RootedDictionary<SvcOutputMetadata> svc(cx);
+ svc.mTemporalLayerId.Construct(data->mTemporalLayerId.value());
+ metadata.mSvc.Construct(std::move(svc));
+ metadataInfo.Append(
+ nsPrintfCString(", temporal layer id %d",
+ metadata.mSvc.Value().mTemporalLayerId.Value()));
+ }
+
+ if (metadata.mDecoderConfig.WasPassed()) {
+ metadataInfo.Append(", new decoder config");
+ }
+
+ LOG("EncoderTemplate:: output callback (ts: % " PRId64 ")%s",
+ encodedData->Timestamp(), metadataInfo.get());
+ cb->Call((typename EncoderType::OutputType&)(*encodedData), metadata);
+ }
+}
+
+template <typename EncoderType>
+class EncoderTemplate<EncoderType>::ErrorRunnable final
+ : public DiscardableRunnable {
+ public:
+ ErrorRunnable(Self* aEncoder, const nsresult& aError)
+ : DiscardableRunnable("Decoder ErrorRunnable"),
+ mEncoder(aEncoder),
+ mError(aError) {
+ MOZ_ASSERT(mEncoder);
+ }
+ ~ErrorRunnable() = default;
+
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT.
+ // See bug 1535398.
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
+ nsCString error;
+ GetErrorName(mError, error);
+ LOGE("%s %p report error: %s", EncoderType::Name.get(), mEncoder.get(),
+ error.get());
+ RefPtr<Self> d = std::move(mEncoder);
+ d->ReportError(mError);
+ return NS_OK;
+ }
+
+ private:
+ RefPtr<Self> mEncoder;
+ const nsresult mError;
+};
+
+template <typename EncoderType>
+class EncoderTemplate<EncoderType>::OutputRunnable final
+ : public DiscardableRunnable {
+ public:
+ OutputRunnable(Self* aEncoder, WebCodecsId aConfigureId,
+ const nsACString& aLabel,
+ nsTArray<RefPtr<MediaRawData>>&& aData)
+ : DiscardableRunnable("Decoder OutputRunnable"),
+ mEncoder(aEncoder),
+ mConfigureId(aConfigureId),
+ mLabel(aLabel),
+ mData(std::move(aData)) {
+ MOZ_ASSERT(mEncoder);
+ }
+ ~OutputRunnable() = default;
+
+ // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT.
+ // See bug 1535398.
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
+ if (mEncoder->mState != CodecState::Configured) {
+ LOGV("%s %p has been %s. Discard %s-result for EncoderAgent #%zu",
+ EncoderType::Name.get(), mEncoder.get(),
+ mEncoder->mState == CodecState::Closed ? "closed" : "reset",
+ mLabel.get(), mConfigureId);
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(mEncoder->mAgent);
+ if (mConfigureId != mEncoder->mAgent->mId) {
+ LOGW(
+ "%s %p has been re-configured. Still yield %s-result for "
+ "EncoderAgent #%zu",
+ EncoderType::Name.get(), mEncoder.get(), mLabel.get(), mConfigureId);
+ }
+
+ LOGV("%s %p, yields %s-result for EncoderAgent #%zu",
+ EncoderType::Name.get(), mEncoder.get(), mLabel.get(), mConfigureId);
+ RefPtr<Self> d = std::move(mEncoder);
+ d->OutputEncodedData(std::move(mData));
+
+ return NS_OK;
+ }
+
+ private:
+ RefPtr<Self> mEncoder;
+ const WebCodecsId mConfigureId;
+ const nsCString mLabel;
+ nsTArray<RefPtr<MediaRawData>> mData;
+};
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::ScheduleOutputEncodedData(
+ nsTArray<RefPtr<MediaRawData>>&& aData, const nsACString& aLabel) {
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(mAgent);
+
+ MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(MakeAndAddRef<OutputRunnable>(
+ this, mAgent->mId, aLabel, std::move(aData))));
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::ScheduleClose(const nsresult& aResult) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+
+ auto task = [self = RefPtr{this}, result = aResult] {
+ if (self->mState == CodecState::Closed) {
+ nsCString error;
+ GetErrorName(result, error);
+ LOGW("%s %p has been closed. Ignore close with %s",
+ EncoderType::Name.get(), self.get(), error.get());
+ return;
+ }
+ DebugOnly<Result<Ok, nsresult>> r = self->CloseInternal(result);
+ MOZ_ASSERT(r.value.isOk());
+ };
+ nsISerialEventTarget* target = GetCurrentSerialEventTarget();
+
+ if (NS_IsMainThread()) {
+ MOZ_ALWAYS_SUCCEEDS(target->Dispatch(
+ NS_NewRunnableFunction("ScheduleClose Runnable (main)", task)));
+ return;
+ }
+
+ MOZ_ALWAYS_SUCCEEDS(target->Dispatch(NS_NewCancelableRunnableFunction(
+ "ScheduleClose Runnable (worker)", task)));
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::ScheduleDequeueEvent() {
+ AssertIsOnOwningThread();
+
+ if (mDequeueEventScheduled) {
+ return;
+ }
+ mDequeueEventScheduled = true;
+
+ auto dispatcher = [self = RefPtr{this}] {
+ self->FireEvent(nsGkAtoms::ondequeue, u"dequeue"_ns);
+ self->mDequeueEventScheduled = false;
+ };
+ nsISerialEventTarget* target = GetCurrentSerialEventTarget();
+
+ if (NS_IsMainThread()) {
+ MOZ_ALWAYS_SUCCEEDS(target->Dispatch(NS_NewRunnableFunction(
+ "ScheduleDequeueEvent Runnable (main)", dispatcher)));
+ return;
+ }
+
+ MOZ_ALWAYS_SUCCEEDS(target->Dispatch(NS_NewCancelableRunnableFunction(
+ "ScheduleDequeueEvent Runnable (worker)", dispatcher)));
+}
+
+template <typename EncoderType>
+nsresult EncoderTemplate<EncoderType>::FireEvent(nsAtom* aTypeWithOn,
+ const nsAString& aEventType) {
+ if (aTypeWithOn && !HasListenersFor(aTypeWithOn)) {
+ return NS_ERROR_ABORT;
+ }
+
+ LOGV("Dispatching %s event to %s %p", NS_ConvertUTF16toUTF8(aEventType).get(),
+ EncoderType::Name.get(), this);
+ RefPtr<Event> event = new Event(this, nullptr, nullptr);
+ event->InitEvent(aEventType, true, true);
+ event->SetTrusted(true);
+ this->DispatchEvent(*event);
+ return NS_OK;
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::SchedulePromiseResolveOrReject(
+ already_AddRefed<Promise> aPromise, const nsresult& aResult) {
+ AssertIsOnOwningThread();
+
+ RefPtr<Promise> p = aPromise;
+ auto resolver = [p, result = aResult] {
+ if (NS_FAILED(result)) {
+ p->MaybeReject(NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ return;
+ }
+ p->MaybeResolveWithUndefined();
+ };
+ nsISerialEventTarget* target = GetCurrentSerialEventTarget();
+
+ if (NS_IsMainThread()) {
+ MOZ_ALWAYS_SUCCEEDS(target->Dispatch(NS_NewRunnableFunction(
+ "SchedulePromiseResolveOrReject Runnable (main)", resolver)));
+ return;
+ }
+
+ MOZ_ALWAYS_SUCCEEDS(target->Dispatch(NS_NewCancelableRunnableFunction(
+ "SchedulePromiseResolveOrReject Runnable (worker)", resolver)));
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::ProcessControlMessageQueue() {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+
+ while (!mMessageQueueBlocked && !mControlMessageQueue.empty()) {
+ RefPtr<ControlMessage>& msg = mControlMessageQueue.front();
+ if (msg->AsConfigureMessage()) {
+ if (ProcessConfigureMessage(msg->AsConfigureMessage()) ==
+ MessageProcessedResult::NotProcessed) {
+ break;
+ }
+ } else if (msg->AsEncodeMessage()) {
+ if (ProcessEncodeMessage(msg->AsEncodeMessage()) ==
+ MessageProcessedResult::NotProcessed) {
+ break;
+ }
+ } else {
+ MOZ_ASSERT(msg->AsFlushMessage());
+ if (ProcessFlushMessage(msg->AsFlushMessage()) ==
+ MessageProcessedResult::NotProcessed) {
+ break;
+ }
+ }
+ }
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::CancelPendingControlMessages(
+ const nsresult& aResult) {
+ AssertIsOnOwningThread();
+
+ // Cancel the message that is being processed.
+ if (mProcessingMessage) {
+ LOG("%s %p cancels current %s", EncoderType::Name.get(), this,
+ mProcessingMessage->ToString().get());
+ mProcessingMessage->Cancel();
+
+ if (RefPtr<FlushMessage> flush = mProcessingMessage->AsFlushMessage()) {
+ flush->RejectPromiseIfAny(aResult);
+ }
+
+ mProcessingMessage = nullptr;
+ }
+
+ // Clear the message queue.
+ while (!mControlMessageQueue.empty()) {
+ LOG("%s %p cancels pending %s", EncoderType::Name.get(), this,
+ mControlMessageQueue.front()->ToString().get());
+
+ MOZ_ASSERT(!mControlMessageQueue.front()->IsProcessing());
+ if (RefPtr<FlushMessage> flush =
+ mControlMessageQueue.front()->AsFlushMessage()) {
+ flush->RejectPromiseIfAny(aResult);
+ }
+
+ mControlMessageQueue.pop();
+ }
+}
+
+template <typename EncoderType>
+MessageProcessedResult EncoderTemplate<EncoderType>::ProcessConfigureMessage(
+ RefPtr<ConfigureMessage> aMessage) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(aMessage->AsConfigureMessage());
+
+ if (mProcessingMessage) {
+ return MessageProcessedResult::NotProcessed;
+ }
+
+ mProcessingMessage = aMessage;
+ mControlMessageQueue.pop();
+ LOG("%s %p Configuring, message queue processing blocked(%s)",
+ EncoderType::Name.get(), this, aMessage->ToString().get());
+ StartBlockingMessageQueue();
+
+ bool supported = EncoderType::IsSupported(*aMessage->Config());
+
+ if (!supported) {
+ LOGE("%s %p ProcessConfigureMessage error (sync): Not supported",
+ EncoderType::Name.get(), this);
+ mProcessingMessage = nullptr;
+ NS_DispatchToCurrentThread(NS_NewRunnableFunction(
+ "ProcessConfigureMessage (async): not supported",
+ [self = RefPtr(this)]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ LOGE("%s %p ProcessConfigureMessage (async close): Not supported",
+ EncoderType::Name.get(), self.get());
+ DebugOnly<Result<Ok, nsresult>> r =
+ self->CloseInternal(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+ MOZ_ASSERT(r.value.isOk());
+ }));
+ return MessageProcessedResult::Processed;
+ }
+
+ if (mAgent) {
+ Reconfigure(aMessage);
+ } else {
+ Configure(aMessage);
+ }
+
+ return MessageProcessedResult::Processed;
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::StartBlockingMessageQueue() {
+ LOG("=== Message queue blocked");
+ mMessageQueueBlocked = true;
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::StopBlockingMessageQueue() {
+ LOG("=== Message queue unblocked");
+ mMessageQueueBlocked = false;
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::Reconfigure(
+ RefPtr<ConfigureMessage> aMessage) {
+ MOZ_ASSERT(mAgent);
+
+ LOG("Reconfiguring encoder: %s",
+ NS_ConvertUTF16toUTF8(aMessage->Config()->ToString()).get());
+
+ RefPtr<ConfigTypeInternal> config = aMessage->Config();
+ RefPtr<WebCodecsConfigurationChangeList> configDiff =
+ config->Diff(*mActiveConfig);
+
+ // Nothing to do, return now
+ if (configDiff->Empty()) {
+ LOG("Reconfigure with identical config, returning.");
+ mProcessingMessage = nullptr;
+ StopBlockingMessageQueue();
+ return;
+ }
+
+ LOG("Attempting to reconfigure encoder: old: %s new: %s, diff: %s",
+ NS_ConvertUTF16toUTF8(mActiveConfig->ToString()).get(),
+ NS_ConvertUTF16toUTF8(config->ToString()).get(),
+ NS_ConvertUTF16toUTF8(configDiff->ToString()).get());
+
+ RefPtr<EncoderConfigurationChangeList> changeList =
+ configDiff->ToPEMChangeList();
+
+ // Attempt to reconfigure the encoder, if the config is similar enough.
+ // Otherwise, or if reconfiguring on the fly didn't work, flush the encoder
+ // and recreate a new one.
+
+ mAgent->Reconfigure(changeList)
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId,
+ message = std::move(aMessage)](
+ const EncoderAgent::ReconfigurationPromise::ResolveOrRejectValue&
+ aResult) {
+ MOZ_ASSERT(self->mProcessingMessage);
+ MOZ_ASSERT(self->mProcessingMessage->AsConfigureMessage());
+ MOZ_ASSERT(self->mState == CodecState::Configured);
+ MOZ_ASSERT(self->mAgent);
+ MOZ_ASSERT(id == self->mAgent->mId);
+ MOZ_ASSERT(self->mActiveConfig);
+
+ if (aResult.IsReject()) {
+ LOGE(
+ "Reconfiguring on the fly didn't succeed, flushing and "
+ "configuring a new encoder");
+ self->mAgent->Drain()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self, id,
+ message](EncoderAgent::EncodePromise::ResolveOrRejectValue&&
+ aResult) {
+ if (aResult.IsReject()) {
+ const MediaResult& error = aResult.RejectValue();
+ LOGE(
+ "%s %p, EncoderAgent #%zu failed to flush during "
+ "reconfigure, closing: %s",
+ EncoderType::Name.get(), self.get(), id,
+ error.Description().get());
+
+ self->mProcessingMessage = nullptr;
+ self->ScheduleClose(
+ NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ return;
+ }
+
+ LOG("%s %p flush during reconfiguration succeeded.",
+ EncoderType::Name.get(), self.get());
+
+ // If flush succeeded, schedule to output encoded data
+ // first, destroy the current encoder, and proceed to create
+ // a new one.
+ MOZ_ASSERT(aResult.IsResolve());
+ nsTArray<RefPtr<MediaRawData>> data =
+ std::move(aResult.ResolveValue());
+
+ if (data.IsEmpty()) {
+ LOG("%s %p no data during flush for reconfiguration with "
+ "encoder destruction",
+ EncoderType::Name.get(), self.get());
+ } else {
+ LOG("%s %p Outputing %zu frames during flush "
+ " for reconfiguration with encoder destruction",
+ EncoderType::Name.get(), self.get(), data.Length());
+ self->ScheduleOutputEncodedData(
+ std::move(data),
+ nsLiteralCString("Flush before reconfigure"));
+ }
+
+ NS_DispatchToCurrentThread(NS_NewRunnableFunction(
+ "Destroy + recreate encoder after failed reconfigure",
+ [self = RefPtr(self), message]()
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ // Destroy the agent, and finally create a fresh
+ // encoder with the new configuration.
+ self->DestroyEncoderAgentIfAny();
+ self->Configure(message);
+ }));
+ });
+ return;
+ }
+
+ LOG("%s %p, EncoderAgent #%zu has been reconfigured on the fly to "
+ "%s",
+ EncoderType::Name.get(), self.get(), id,
+ message->ToString().get());
+
+ self->mOutputNewDecoderConfig = true;
+ self->mActiveConfig = message->Config();
+ self->mProcessingMessage = nullptr;
+ self->StopBlockingMessageQueue();
+ self->ProcessControlMessageQueue();
+ });
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::Configure(
+ RefPtr<ConfigureMessage> aMessage) {
+ MOZ_ASSERT(!mAgent);
+
+ LOG("Configuring encoder: %s",
+ NS_ConvertUTF16toUTF8(aMessage->Config()->ToString()).get());
+
+ mOutputNewDecoderConfig = true;
+ mActiveConfig = aMessage->Config();
+
+ bool decoderAgentCreated =
+ CreateEncoderAgent(aMessage->mMessageId, aMessage->Config());
+ if (!decoderAgentCreated) {
+ LOGE(
+ "%s %p ProcessConfigureMessage error (sync): encoder agent "
+ "creation "
+ "failed",
+ EncoderType::Name.get(), this);
+ mProcessingMessage = nullptr;
+ NS_DispatchToCurrentThread(NS_NewRunnableFunction(
+ "ProcessConfigureMessage (async): encoder agent creating failed",
+ [self = RefPtr(this)]() MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ LOGE(
+ "%s %p ProcessConfigureMessage (async close): encoder agent "
+ "creation failed",
+ EncoderType::Name.get(), self.get());
+ DebugOnly<Result<Ok, nsresult>> r =
+ self->CloseInternal(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+ MOZ_ASSERT(r.value.isOk());
+ }));
+ return;
+ }
+
+ MOZ_ASSERT(mAgent);
+ MOZ_ASSERT(mActiveConfig);
+
+ LOG("Real configuration with fresh config: %s",
+ NS_ConvertUTF16toUTF8(mActiveConfig->ToString().get()).get());
+
+ EncoderConfig config = mActiveConfig->ToEncoderConfig();
+ mAgent->Configure(config)
+ ->Then(GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId, aMessage](
+ const EncoderAgent::ConfigurePromise::ResolveOrRejectValue&
+ aResult) MOZ_CAN_RUN_SCRIPT_BOUNDARY {
+ MOZ_ASSERT(self->mProcessingMessage);
+ MOZ_ASSERT(self->mProcessingMessage->AsConfigureMessage());
+ MOZ_ASSERT(self->mState == CodecState::Configured);
+ MOZ_ASSERT(self->mAgent);
+ MOZ_ASSERT(id == self->mAgent->mId);
+ MOZ_ASSERT(self->mActiveConfig);
+
+ LOG("%s %p, EncoderAgent #%zu %s has been %s. now unblocks "
+ "message-queue-processing",
+ EncoderType::Name.get(), self.get(), id,
+ aMessage->ToString().get(),
+ aResult.IsResolve() ? "resolved" : "rejected");
+
+ aMessage->Complete();
+ self->mProcessingMessage = nullptr;
+
+ if (aResult.IsReject()) {
+ // The spec asks to close the decoder with an
+ // NotSupportedError so we log the exact error here.
+ const MediaResult& error = aResult.RejectValue();
+ LOGE("%s %p, EncoderAgent #%zu failed to configure: %s",
+ EncoderType::Name.get(), self.get(), id,
+ error.Description().get());
+ DebugOnly<Result<Ok, nsresult>> r = self->CloseInternal(
+ NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ MOZ_ASSERT(r.value.isOk());
+ return; // No further process
+ }
+
+ self->StopBlockingMessageQueue();
+ self->ProcessControlMessageQueue();
+ })
+ ->Track(aMessage->Request());
+}
+
+template <typename EncoderType>
+MessageProcessedResult EncoderTemplate<EncoderType>::ProcessEncodeMessage(
+ RefPtr<EncodeMessage> aMessage) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(aMessage->AsEncodeMessage());
+
+ if (mProcessingMessage) {
+ return MessageProcessedResult::NotProcessed;
+ }
+
+ mProcessingMessage = aMessage;
+ mControlMessageQueue.pop();
+
+ LOGV("%s %p processing %s", EncoderType::Name.get(), this,
+ aMessage->ToString().get());
+
+ mEncodeQueueSize -= 1;
+ ScheduleDequeueEvent();
+
+ // Treat it like decode error if no EncoderAgent is available or the encoded
+ // data is invalid.
+ auto closeOnError = [&]() {
+ mProcessingMessage = nullptr;
+ ScheduleClose(NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ return MessageProcessedResult::Processed;
+ };
+
+ if (!mAgent) {
+ LOGE("%s %p is not configured", EncoderType::Name.get(), this);
+ return closeOnError();
+ }
+
+ MOZ_ASSERT(mActiveConfig);
+ RefPtr<InputTypeInternal> data = aMessage->mData;
+ if (!data) {
+ LOGE("%s %p, data for %s is empty or invalid", EncoderType::Name.get(),
+ this, aMessage->ToString().get());
+ return closeOnError();
+ }
+
+ mAgent->Encode(data.get())
+ ->Then(GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId, aMessage](
+ EncoderAgent::EncodePromise::ResolveOrRejectValue&& aResult) {
+ MOZ_ASSERT(self->mProcessingMessage);
+ MOZ_ASSERT(self->mProcessingMessage->AsEncodeMessage());
+ MOZ_ASSERT(self->mState == CodecState::Configured);
+ MOZ_ASSERT(self->mAgent);
+ MOZ_ASSERT(id == self->mAgent->mId);
+ MOZ_ASSERT(self->mActiveConfig);
+
+ nsCString msgStr = aMessage->ToString();
+
+ aMessage->Complete();
+ self->mProcessingMessage = nullptr;
+
+ if (aResult.IsReject()) {
+ // The spec asks to queue a task to run close the decoder
+ // with an EncodingError so we log the exact error here.
+ const MediaResult& error = aResult.RejectValue();
+ LOGE("%s %p, EncoderAgent #%zu %s failed: %s",
+ EncoderType::Name.get(), self.get(), id, msgStr.get(),
+ error.Description().get());
+ self->ScheduleClose(NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ return; // No further process
+ }
+
+ MOZ_ASSERT(aResult.IsResolve());
+ nsTArray<RefPtr<MediaRawData>> data =
+ std::move(aResult.ResolveValue());
+ if (data.IsEmpty()) {
+ LOGV("%s %p got no data for %s", EncoderType::Name.get(),
+ self.get(), msgStr.get());
+ } else {
+ LOGV("%s %p, schedule %zu encoded data output",
+ EncoderType::Name.get(), self.get(), data.Length());
+ self->ScheduleOutputEncodedData(std::move(data), msgStr);
+ }
+
+ self->ProcessControlMessageQueue();
+ })
+ ->Track(aMessage->Request());
+
+ return MessageProcessedResult::Processed;
+}
+
+template <typename EncoderType>
+MessageProcessedResult EncoderTemplate<EncoderType>::ProcessFlushMessage(
+ RefPtr<FlushMessage> aMessage) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(aMessage->AsFlushMessage());
+
+ if (mProcessingMessage) {
+ return MessageProcessedResult::NotProcessed;
+ }
+
+ mProcessingMessage = aMessage;
+ mControlMessageQueue.pop();
+
+ LOG("%s %p starts processing %s", EncoderType::Name.get(), this,
+ aMessage->ToString().get());
+
+ // No agent, no thing to do. The promise has been rejected with the
+ // appropriate error in ResetInternal already.
+ if (!mAgent) {
+ LOGE("%s %p no agent, nothing to do", EncoderType::Name.get(), this);
+ mProcessingMessage = nullptr;
+ return MessageProcessedResult::Processed;
+ }
+
+ mAgent->Drain()
+ ->Then(GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId, aMessage](
+ EncoderAgent::EncodePromise::ResolveOrRejectValue&& aResult) {
+ MOZ_ASSERT(self->mProcessingMessage);
+ MOZ_ASSERT(self->mProcessingMessage->AsFlushMessage());
+ MOZ_ASSERT(self->mState == CodecState::Configured);
+ MOZ_ASSERT(self->mAgent);
+ MOZ_ASSERT(id == self->mAgent->mId);
+ MOZ_ASSERT(self->mActiveConfig);
+
+ LOG("%s %p, EncoderAgent #%zu %s has been %s",
+ EncoderType::Name.get(), self.get(), id,
+ aMessage->ToString().get(),
+ aResult.IsResolve() ? "resolved" : "rejected");
+
+ nsCString msgStr = aMessage->ToString();
+
+ aMessage->Complete();
+
+ // If flush failed, it means encoder fails to encode the data
+ // sent before, so we treat it like an encode error. We reject
+ // the promise first and then queue a task to close VideoEncoder
+ // with an EncodingError.
+ if (aResult.IsReject()) {
+ const MediaResult& error = aResult.RejectValue();
+ LOGE("%s %p, EncoderAgent #%zu failed to flush: %s",
+ EncoderType::Name.get(), self.get(), id,
+ error.Description().get());
+
+ // Reject with an EncodingError instead of the error we got
+ // above.
+ self->SchedulePromiseResolveOrReject(
+ aMessage->TakePromise(),
+ NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+
+ self->mProcessingMessage = nullptr;
+
+ self->ScheduleClose(NS_ERROR_DOM_ENCODING_NOT_SUPPORTED_ERR);
+ return; // No further process
+ }
+
+ // If flush succeeded, schedule to output encoded data first
+ // and then resolve the promise, then keep processing the
+ // control messages.
+ MOZ_ASSERT(aResult.IsResolve());
+ nsTArray<RefPtr<MediaRawData>> data =
+ std::move(aResult.ResolveValue());
+
+ if (data.IsEmpty()) {
+ LOG("%s %p gets no data for %s", EncoderType::Name.get(),
+ self.get(), msgStr.get());
+ } else {
+ LOG("%s %p, schedule %zu encoded data output for %s",
+ EncoderType::Name.get(), self.get(), data.Length(),
+ msgStr.get());
+ self->ScheduleOutputEncodedData(std::move(data), msgStr);
+ }
+
+ self->SchedulePromiseResolveOrReject(aMessage->TakePromise(),
+ NS_OK);
+ self->mProcessingMessage = nullptr;
+ self->ProcessControlMessageQueue();
+ })
+ ->Track(aMessage->Request());
+
+ return MessageProcessedResult::Processed;
+}
+
+// CreateEncoderAgent will create an EncoderAgent paired with a xpcom-shutdown
+// blocker and a worker-reference. Besides the needs mentioned in the header
+// file, the blocker and the worker-reference also provides an entry point for
+// us to clean up the resources. Other than the encoder dtor, Reset(), or
+// Close(), the resources should be cleaned up in the following situations:
+// 1. Encoder on window, closing document
+// 2. Encoder on worker, closing document
+// 3. Encoder on worker, terminating worker
+//
+// In case 1, the entry point to clean up is in the mShutdownBlocker's
+// ShutdownpPomise-resolver. In case 2, the entry point is in mWorkerRef's
+// shutting down callback. In case 3, the entry point is in mWorkerRef's
+// shutting down callback.
+
+template <typename EncoderType>
+bool EncoderTemplate<EncoderType>::CreateEncoderAgent(
+ WebCodecsId aId, RefPtr<ConfigTypeInternal> aConfig) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(mState == CodecState::Configured);
+ MOZ_ASSERT(!mAgent);
+ MOZ_ASSERT(!mShutdownBlocker);
+ MOZ_ASSERT_IF(!NS_IsMainThread(), !mWorkerRef);
+
+ auto resetOnFailure = MakeScopeExit([&]() {
+ mAgent = nullptr;
+ mActiveConfig = nullptr;
+ mShutdownBlocker = nullptr;
+ mWorkerRef = nullptr;
+ });
+
+ // If the encoder is on worker, get a worker reference.
+ if (!NS_IsMainThread()) {
+ WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
+ if (NS_WARN_IF(!workerPrivate)) {
+ return false;
+ }
+
+ // Clean up all the resources when worker is going away.
+ RefPtr<StrongWorkerRef> workerRef = StrongWorkerRef::Create(
+ workerPrivate, "EncoderTemplate::CreateEncoderAgent",
+ [self = RefPtr{this}]() {
+ LOG("%s %p, worker is going away", EncoderType::Name.get(),
+ self.get());
+ Unused << self->ResetInternal(NS_ERROR_DOM_ABORT_ERR);
+ });
+ if (NS_WARN_IF(!workerRef)) {
+ return false;
+ }
+
+ mWorkerRef = new ThreadSafeWorkerRef(workerRef);
+ }
+
+ mAgent = MakeRefPtr<EncoderAgent>(aId);
+
+ // ShutdownBlockingTicket requires an unique name to register its own
+ // nsIAsyncShutdownBlocker since each blocker needs a distinct name.
+ // To do that, we use EncoderAgent's unique id to create a unique name.
+ nsAutoString uniqueName;
+ uniqueName.AppendPrintf(
+ "Blocker for EncoderAgent #%zu (codec: %s) @ %p", mAgent->mId,
+ NS_ConvertUTF16toUTF8(mActiveConfig->mCodec).get(), mAgent.get());
+
+ mShutdownBlocker = media::ShutdownBlockingTicket::Create(
+ uniqueName, NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__);
+ if (!mShutdownBlocker) {
+ LOGE("%s %p failed to create %s", EncoderType::Name.get(), this,
+ NS_ConvertUTF16toUTF8(uniqueName).get());
+ return false;
+ }
+
+ // Clean up all the resources when xpcom-will-shutdown arrives since the
+ // page is going to be closed.
+ mShutdownBlocker->ShutdownPromise()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = mAgent->mId,
+ ref = mWorkerRef](bool /* aUnUsed*/) {
+ LOG("%s %p gets xpcom-will-shutdown notification for EncoderAgent "
+ "#%zu",
+ EncoderType::Name.get(), self.get(), id);
+ Unused << self->ResetInternal(NS_ERROR_DOM_ABORT_ERR);
+ },
+ [self = RefPtr{this}, id = mAgent->mId,
+ ref = mWorkerRef](bool /* aUnUsed*/) {
+ LOG("%s %p removes shutdown-blocker #%zu before getting any "
+ "notification. EncoderAgent should have been dropped",
+ EncoderType::Name.get(), self.get(), id);
+ MOZ_ASSERT(!self->mAgent || self->mAgent->mId != id);
+ });
+
+ LOG("%s %p creates EncoderAgent #%zu @ %p and its shutdown-blocker",
+ EncoderType::Name.get(), this, mAgent->mId, mAgent.get());
+
+ resetOnFailure.release();
+ return true;
+}
+
+template <typename EncoderType>
+void EncoderTemplate<EncoderType>::DestroyEncoderAgentIfAny() {
+ AssertIsOnOwningThread();
+
+ if (!mAgent) {
+ LOG("%s %p has no EncoderAgent to destroy", EncoderType::Name.get(), this);
+ return;
+ }
+
+ MOZ_ASSERT(mActiveConfig);
+ MOZ_ASSERT(mShutdownBlocker);
+ MOZ_ASSERT_IF(!NS_IsMainThread(), mWorkerRef);
+
+ LOG("%s %p destroys EncoderAgent #%zu @ %p", EncoderType::Name.get(), this,
+ mAgent->mId, mAgent.get());
+ mActiveConfig = nullptr;
+ RefPtr<EncoderAgent> agent = std::move(mAgent);
+ // mShutdownBlocker should be kept alive until the shutdown is done.
+ // mWorkerRef is used to ensure this task won't be discarded in worker.
+ agent->Shutdown()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}, id = agent->mId, ref = std::move(mWorkerRef),
+ blocker = std::move(mShutdownBlocker)](
+ const ShutdownPromise::ResolveOrRejectValue& aResult) {
+ LOG("%s %p, EncoderAgent #%zu's shutdown has been %s. Drop its "
+ "shutdown-blocker now",
+ EncoderType::Name.get(), self.get(), id,
+ aResult.IsResolve() ? "resolved" : "rejected");
+ });
+}
+
+template class EncoderTemplate<VideoEncoderTraits>;
+
+#undef LOG
+#undef LOGW
+#undef LOGE
+#undef LOGV
+#undef LOG_INTERNAL
+
+} // namespace mozilla::dom
diff --git a/dom/media/webcodecs/EncoderTemplate.h b/dom/media/webcodecs/EncoderTemplate.h
new file mode 100644
index 0000000000..e53d7166d1
--- /dev/null
+++ b/dom/media/webcodecs/EncoderTemplate.h
@@ -0,0 +1,290 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_EncoderTemplate_h
+#define mozilla_dom_EncoderTemplate_h
+
+#include <queue>
+
+#include "EncoderAgent.h"
+#include "MediaData.h"
+#include "WebCodecsUtils.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/Result.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/dom/VideoEncoderBinding.h"
+#include "mozilla/dom/WorkerRef.h"
+#include "mozilla/media/MediaUtils.h"
+#include "nsStringFwd.h"
+
+namespace mozilla::dom {
+
+class WebCodecsErrorCallback;
+class Promise;
+enum class CodecState : uint8_t;
+
+using Id = size_t;
+
+template <typename EncoderType>
+class EncoderTemplate : public DOMEventTargetHelper {
+ using Self = EncoderTemplate<EncoderType>;
+ using ConfigType = typename EncoderType::ConfigType;
+ using ConfigTypeInternal = typename EncoderType::ConfigTypeInternal;
+ using OutputConfigType = typename EncoderType::OutputConfigType;
+ using InputType = typename EncoderType::InputType;
+ using InputTypeInternal = typename EncoderType::InputTypeInternal;
+ using OutputType = typename EncoderType::OutputType;
+ using OutputCallbackType = typename EncoderType::OutputCallbackType;
+
+ /* ControlMessage classes */
+ protected:
+ class ConfigureMessage;
+ class EncodeMessage;
+ class FlushMessage;
+
+ class ControlMessage {
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ControlMessage)
+ explicit ControlMessage(Id aConfigureId);
+ virtual void Cancel() = 0;
+ virtual bool IsProcessing() = 0;
+
+ virtual nsCString ToString() const = 0;
+ virtual RefPtr<ConfigureMessage> AsConfigureMessage() { return nullptr; }
+ virtual RefPtr<EncodeMessage> AsEncodeMessage() { return nullptr; }
+ virtual RefPtr<FlushMessage> AsFlushMessage() { return nullptr; }
+
+ // For logging purposes
+ const WebCodecsId mConfigureId;
+ const WebCodecsId mMessageId;
+
+ protected:
+ virtual ~ControlMessage() = default;
+ };
+
+ class ConfigureMessage final
+ : public ControlMessage,
+ public MessageRequestHolder<EncoderAgent::ConfigurePromise> {
+ public:
+ ConfigureMessage(Id aConfigureId,
+ const RefPtr<ConfigTypeInternal>& aConfig);
+ virtual void Cancel() override { Disconnect(); }
+ virtual bool IsProcessing() override { return Exists(); };
+ virtual RefPtr<ConfigureMessage> AsConfigureMessage() override {
+ return this;
+ }
+ RefPtr<ConfigTypeInternal> Config() { return mConfig; }
+ nsCString ToString() const override {
+ nsCString rv;
+ rv.AppendPrintf(
+ "ConfigureMessage(#%zu): %s", this->mMessageId,
+ mConfig ? NS_ConvertUTF16toUTF8(mConfig->ToString().get()).get()
+ : "null cfg");
+ return rv;
+ }
+
+ private:
+ const RefPtr<ConfigTypeInternal> mConfig;
+ };
+
+ class EncodeMessage final
+ : public ControlMessage,
+ public MessageRequestHolder<EncoderAgent::EncodePromise> {
+ public:
+ EncodeMessage(WebCodecsId aConfigureId, RefPtr<InputTypeInternal>&& aData,
+ Maybe<VideoEncoderEncodeOptions>&& aOptions = Nothing());
+ nsCString ToString() const override {
+ nsCString rv;
+ bool isKeyFrame = mOptions.isSome() && mOptions.ref().mKeyFrame;
+ rv.AppendPrintf("EncodeMessage(#%zu,#%zu): %s (%s)", this->mConfigureId,
+ this->mMessageId, mData->ToString().get(),
+ isKeyFrame ? "kf" : "");
+ return rv;
+ }
+ virtual void Cancel() override { Disconnect(); }
+ virtual bool IsProcessing() override { return Exists(); };
+ virtual RefPtr<EncodeMessage> AsEncodeMessage() override { return this; }
+ RefPtr<InputTypeInternal> mData;
+ Maybe<VideoEncoderEncodeOptions> mOptions;
+ };
+
+ class FlushMessage final
+ : public ControlMessage,
+ public MessageRequestHolder<EncoderAgent::EncodePromise> {
+ public:
+ FlushMessage(WebCodecsId aConfigureId, Promise* aPromise);
+ virtual void Cancel() override { Disconnect(); }
+ virtual bool IsProcessing() override { return Exists(); };
+ virtual RefPtr<FlushMessage> AsFlushMessage() override { return this; }
+ already_AddRefed<Promise> TakePromise() { return mPromise.forget(); }
+ void RejectPromiseIfAny(const nsresult& aReason);
+
+ nsCString ToString() const override {
+ nsCString rv;
+ rv.AppendPrintf("FlushMessage(#%zu,#%zu)", this->mConfigureId,
+ this->mMessageId);
+ return rv;
+ }
+
+ private:
+ RefPtr<Promise> mPromise;
+ };
+
+ protected:
+ EncoderTemplate(nsIGlobalObject* aGlobalObject,
+ RefPtr<WebCodecsErrorCallback>&& aErrorCallback,
+ RefPtr<OutputCallbackType>&& aOutputCallback);
+
+ virtual ~EncoderTemplate() = default;
+
+ /* WebCodecs interfaces */
+ public:
+ IMPL_EVENT_HANDLER(dequeue)
+
+ void StartBlockingMessageQueue();
+ void StopBlockingMessageQueue();
+
+ CodecState State() const { return mState; };
+
+ uint32_t EncodeQueueSize() const { return mEncodeQueueSize; };
+
+ void Configure(const ConfigType& aConfig, ErrorResult& aRv);
+
+ void EncodeAudioData(InputType& aInput, ErrorResult& aRv);
+ void EncodeVideoFrame(InputType& aInput,
+ const VideoEncoderEncodeOptions& aOptions,
+ ErrorResult& aRv);
+
+ already_AddRefed<Promise> Flush(ErrorResult& aRv);
+
+ void Reset(ErrorResult& aRv);
+
+ MOZ_CAN_RUN_SCRIPT
+ void Close(ErrorResult& aRv);
+
+ /* Type conversion functions for the Encoder implementation */
+ protected:
+ virtual RefPtr<OutputType> EncodedDataToOutputType(
+ nsIGlobalObject* aGlobalObject, RefPtr<MediaRawData>& aData) = 0;
+ virtual OutputConfigType EncoderConfigToDecoderConfig(
+ nsIGlobalObject* aGlobalObject, const RefPtr<MediaRawData>& aData,
+ const ConfigTypeInternal& aOutputConfig) const = 0;
+ /* Internal member variables and functions */
+ protected:
+ // EncoderTemplate can run on either main thread or worker thread.
+ void AssertIsOnOwningThread() const {
+ NS_ASSERT_OWNINGTHREAD(EncoderTemplate);
+ }
+
+ Result<Ok, nsresult> ResetInternal(const nsresult& aResult);
+ MOZ_CAN_RUN_SCRIPT_BOUNDARY
+ Result<Ok, nsresult> CloseInternal(const nsresult& aResult);
+
+ MOZ_CAN_RUN_SCRIPT void ReportError(const nsresult& aResult);
+ MOZ_CAN_RUN_SCRIPT void OutputEncodedData(
+ nsTArray<RefPtr<MediaRawData>>&& aData);
+
+ class ErrorRunnable;
+ void ScheduleReportError(const nsresult& aResult);
+
+ class OutputRunnable;
+ void ScheduleOutputEncodedData(nsTArray<RefPtr<MediaRawData>>&& aData,
+ const nsACString& aLabel);
+
+ void ScheduleClose(const nsresult& aResult);
+
+ void ScheduleDequeueEvent();
+ nsresult FireEvent(nsAtom* aTypeWithOn, const nsAString& aEventType);
+
+ void SchedulePromiseResolveOrReject(already_AddRefed<Promise> aPromise,
+ const nsresult& aResult);
+
+ void ProcessControlMessageQueue();
+ void CancelPendingControlMessages(const nsresult& aResult);
+
+ MessageProcessedResult ProcessConfigureMessage(
+ RefPtr<ConfigureMessage> aMessage);
+
+ MessageProcessedResult ProcessEncodeMessage(RefPtr<EncodeMessage> aMessage);
+
+ MessageProcessedResult ProcessFlushMessage(RefPtr<FlushMessage> aMessage);
+
+ void Configure(RefPtr<ConfigureMessage> aMessage);
+ void Reconfigure(RefPtr<ConfigureMessage> aMessage);
+
+ // Returns true when mAgent can be created.
+ bool CreateEncoderAgent(WebCodecsId aId, RefPtr<ConfigTypeInternal> aConfig);
+ void DestroyEncoderAgentIfAny();
+
+ // Constant in practice, only set in ctor.
+ RefPtr<WebCodecsErrorCallback> mErrorCallback;
+ RefPtr<OutputCallbackType> mOutputCallback;
+
+ CodecState mState;
+
+ bool mMessageQueueBlocked;
+ std::queue<RefPtr<ControlMessage>> mControlMessageQueue;
+ RefPtr<ControlMessage> mProcessingMessage;
+
+ uint32_t mEncodeQueueSize;
+ bool mDequeueEventScheduled;
+
+ // A unique id tracking the ConfigureMessage and will be used as the
+ // EncoderAgent's Id.
+ uint32_t mLatestConfigureId;
+ // Tracking how many encoded data has been enqueued and this number will be
+ // used as the EncodeMessage's Id.
+ size_t mEncodeCounter;
+ // Tracking how many flush request has been enqueued and this number will be
+ // used as the FlushMessage's Id.
+ size_t mFlushCounter;
+
+ // EncoderAgent will be created the first time "configure" is being processed,
+ // and will be destroyed when "reset" is called. If another "configure" is
+ // called, either it's possible to reconfigure the underlying encoder without
+ // tearing eveyrthing down (e.g. a bitrate change), or it's not possible, and
+ // the current encoder will be destroyed and a new one create.
+ // In both cases, the encoder is implicitely flushed before the configuration
+ // change.
+ // See CanReconfigure on the {Audio,Video}EncoderConfigInternal
+ RefPtr<EncoderAgent> mAgent;
+ RefPtr<ConfigTypeInternal> mActiveConfig;
+ // This is true when a configure call has just been processed, and it's
+ // necessary to pass the new decoding configuration when the callback is
+ // called. Read and modified on owner thread only.
+ bool mOutputNewDecoderConfig = false;
+
+ // Used to add a nsIAsyncShutdownBlocker on main thread to block
+ // xpcom-shutdown before the underlying MediaDataEncoder is created. The
+ // blocker will be held until the underlying MediaDataEncoder has been shut
+ // down. This blocker guarantees RemoteEncoderManagerChild's thread, where
+ // the underlying RemoteMediaDataEncoder is on, outlives the
+ // RemoteMediaDataEncoder since the thread releasing, which happens on main
+ // thread when getting a xpcom-shutdown signal, is blocked by the added
+ // blocker. As a result, RemoteMediaDataEncoder can safely work on worker
+ // thread with a holding blocker (otherwise, if RemoteEncoderManagerChild
+ // releases its thread on main thread before RemoteMediaDataEncoder's
+ // Shutdown() task run on worker thread, RemoteMediaDataEncoder has no
+ // thread to run).
+ UniquePtr<media::ShutdownBlockingTicket> mShutdownBlocker;
+
+ // Held to make sure the dispatched tasks can be done before worker is going
+ // away. As long as this worker-ref is held somewhere, the tasks dispatched
+ // to the worker can be executed (otherwise the tasks would be canceled).
+ // This ref should be activated as long as the underlying MediaDataEncoder
+ // is alive, and should keep alive until mShutdownBlocker is dropped, so all
+ // MediaDataEncoder's tasks and mShutdownBlocker-releasing task can be
+ // executed.
+ // TODO: Use StrongWorkerRef instead if this is always used in the same
+ // thread?
+ RefPtr<ThreadSafeWorkerRef> mWorkerRef;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_EncoderTemplate_h
diff --git a/dom/media/webcodecs/EncoderTypes.h b/dom/media/webcodecs/EncoderTypes.h
new file mode 100644
index 0000000000..d58d7c54c8
--- /dev/null
+++ b/dom/media/webcodecs/EncoderTypes.h
@@ -0,0 +1,103 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_EncoderTypes_h
+#define mozilla_dom_EncoderTypes_h
+
+#include "mozilla/Maybe.h"
+#include "mozilla/dom/EncodedVideoChunk.h"
+#include "mozilla/dom/VideoEncoderBinding.h"
+#include "mozilla/dom/VideoFrame.h"
+#include "mozilla/dom/VideoFrameBinding.h"
+#include "nsStringFwd.h"
+#include "nsTLiteralString.h"
+#include "VideoDecoder.h"
+#include "PlatformEncoderModule.h"
+
+namespace mozilla {
+
+class TrackInfo;
+class MediaByteBuffer;
+
+namespace dom {
+
+class VideoEncoderConfigInternal {
+ public:
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoEncoderConfigInternal);
+ explicit VideoEncoderConfigInternal(const VideoEncoderConfig& aConfig);
+ explicit VideoEncoderConfigInternal(
+ const VideoEncoderConfigInternal& aConfig);
+
+ // Returns an EncoderConfig struct with as many filled members as
+ // possible.
+ // TODO: handle codec specific things
+ EncoderConfig ToEncoderConfig() const;
+
+ bool Equals(const VideoEncoderConfigInternal& aOther) const;
+ bool CanReconfigure(const VideoEncoderConfigInternal& aOther) const;
+ already_AddRefed<WebCodecsConfigurationChangeList> Diff(
+ const VideoEncoderConfigInternal& aOther) const;
+ nsString ToString() const;
+
+ nsString mCodec;
+ uint32_t mWidth;
+ uint32_t mHeight;
+ Maybe<uint32_t> mDisplayWidth;
+ Maybe<uint32_t> mDisplayHeight;
+ Maybe<uint32_t> mBitrate;
+ Maybe<double> mFramerate;
+ HardwareAcceleration mHardwareAcceleration;
+ AlphaOption mAlpha;
+ Maybe<nsString> mScalabilityMode;
+ VideoEncoderBitrateMode mBitrateMode;
+ LatencyMode mLatencyMode;
+ Maybe<nsString> mContentHint;
+ Maybe<AvcEncoderConfig> mAvc;
+
+ private:
+ VideoEncoderConfigInternal(
+ const nsAString& aCodec, uint32_t aWidth, uint32_t aHeight,
+ Maybe<uint32_t>&& aDisplayWidth, Maybe<uint32_t>&& aDisplayHeight,
+ Maybe<uint32_t>&& aBitrate, Maybe<double>&& aFramerate,
+ const HardwareAcceleration& aHardwareAcceleration,
+ const AlphaOption& aAlpha, Maybe<nsString>&& aScalabilityMode,
+ const VideoEncoderBitrateMode& aBitrateMode,
+ const LatencyMode& aLatencyMode, Maybe<nsString>&& aContentHint);
+
+ ~VideoEncoderConfigInternal() = default;
+};
+
+class VideoEncoderTraits {
+ public:
+ static constexpr nsLiteralCString Name = "VideoEncoder"_ns;
+ using ConfigType = VideoEncoderConfig;
+ using ConfigTypeInternal = VideoEncoderConfigInternal;
+ using InputType = dom::VideoFrame;
+ using InputTypeInternal = mozilla::VideoData;
+ using OutputConfigType = mozilla::dom::VideoDecoderConfigInternal;
+ using OutputType = EncodedVideoChunk;
+ using OutputCallbackType = EncodedVideoChunkOutputCallback;
+ using MetadataType = EncodedVideoChunkMetadata;
+
+ static bool IsSupported(const ConfigTypeInternal& aConfig);
+ static bool CanEncodeVideo(const ConfigTypeInternal& aConfig);
+ static Result<UniquePtr<TrackInfo>, nsresult> CreateTrackInfo(
+ const ConfigTypeInternal& aConfig);
+ static bool Validate(const ConfigType& aConfig, nsCString& aErrorMessage);
+ static RefPtr<ConfigTypeInternal> CreateConfigInternal(
+ const ConfigType& aConfig);
+ static RefPtr<InputTypeInternal> CreateInputInternal(
+ const InputType& aInput, const VideoEncoderEncodeOptions& aOptions);
+ static already_AddRefed<OutputConfigType> EncoderConfigToDecoderConfig(
+ nsIGlobalObject* aGlobal,
+ const RefPtr<MediaRawData>& aData,
+ const ConfigTypeInternal& mOutputConfig);
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_EncoderTypes_h
diff --git a/dom/media/webcodecs/VideoColorSpace.cpp b/dom/media/webcodecs/VideoColorSpace.cpp
new file mode 100644
index 0000000000..5b0dad0f31
--- /dev/null
+++ b/dom/media/webcodecs/VideoColorSpace.cpp
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/VideoColorSpace.h"
+#include "mozilla/dom/VideoColorSpaceBinding.h"
+#include "nsIGlobalObject.h"
+
+namespace mozilla::dom {
+
+// Only needed for refcounted objects.
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(VideoColorSpace, mParent)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(VideoColorSpace)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(VideoColorSpace)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(VideoColorSpace)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+VideoColorSpace::VideoColorSpace(nsIGlobalObject* aParent,
+ const VideoColorSpaceInit& aInit)
+ : mParent(aParent), mInit(aInit) {
+ MOZ_ASSERT(mParent);
+}
+
+nsIGlobalObject* VideoColorSpace::GetParentObject() const { return mParent; }
+
+JSObject* VideoColorSpace::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return VideoColorSpace_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+/* static */
+already_AddRefed<VideoColorSpace> VideoColorSpace::Constructor(
+ const GlobalObject& aGlobal, const VideoColorSpaceInit& aInit,
+ ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+ RefPtr<VideoColorSpace> videoColorSpace(new VideoColorSpace(global, aInit));
+ return aRv.Failed() ? nullptr : videoColorSpace.forget();
+}
+
+} // namespace mozilla::dom
diff --git a/dom/media/webcodecs/VideoColorSpace.h b/dom/media/webcodecs/VideoColorSpace.h
new file mode 100644
index 0000000000..e6fdc22317
--- /dev/null
+++ b/dom/media/webcodecs/VideoColorSpace.h
@@ -0,0 +1,64 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_VideoColorSpace_h
+#define mozilla_dom_VideoColorSpace_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/VideoColorSpaceBinding.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+
+class nsIGlobalObject;
+
+namespace mozilla::dom {
+
+class VideoColorSpace final : public nsISupports, public nsWrapperCache {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(VideoColorSpace)
+
+ public:
+ VideoColorSpace(nsIGlobalObject* aParent, const VideoColorSpaceInit& aInit);
+
+ protected:
+ ~VideoColorSpace() = default;
+
+ public:
+ nsIGlobalObject* GetParentObject() const;
+
+ JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ static already_AddRefed<VideoColorSpace> Constructor(
+ const GlobalObject& aGlobal, const VideoColorSpaceInit& aInit,
+ ErrorResult& aRv);
+
+ const Nullable<VideoColorPrimaries>& GetPrimaries() const {
+ return mInit.mPrimaries;
+ }
+
+ const Nullable<VideoTransferCharacteristics>& GetTransfer() const {
+ return mInit.mTransfer;
+ }
+
+ const Nullable<VideoMatrixCoefficients>& GetMatrix() const {
+ return mInit.mMatrix;
+ }
+
+ const Nullable<bool>& GetFullRange() const { return mInit.mFullRange; }
+
+ private:
+ nsCOMPtr<nsIGlobalObject> mParent;
+ const VideoColorSpaceInit mInit;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_VideoColorSpace_h
diff --git a/dom/media/webcodecs/VideoDecoder.cpp b/dom/media/webcodecs/VideoDecoder.cpp
new file mode 100644
index 0000000000..47ca5bb459
--- /dev/null
+++ b/dom/media/webcodecs/VideoDecoder.cpp
@@ -0,0 +1,977 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/VideoDecoder.h"
+#include "mozilla/dom/VideoDecoderBinding.h"
+
+#include "DecoderTraits.h"
+#include "GPUVideoImage.h"
+#include "H264.h"
+#include "ImageContainer.h"
+#include "MediaContainerType.h"
+#include "MediaData.h"
+#include "VideoUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/Try.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/EncodedVideoChunk.h"
+#include "mozilla/dom/EncodedVideoChunkBinding.h"
+#include "mozilla/dom/ImageUtils.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/VideoColorSpaceBinding.h"
+#include "mozilla/dom/VideoFrameBinding.h"
+#include "mozilla/dom/WebCodecsUtils.h"
+#include "nsPrintfCString.h"
+#include "nsReadableUtils.h"
+#include "nsThreadUtils.h"
+
+#ifdef XP_MACOSX
+# include "MacIOSurfaceImage.h"
+#elif MOZ_WAYLAND
+# include "mozilla/layers/DMABUFSurfaceImage.h"
+# include "mozilla/widget/DMABufSurface.h"
+#endif
+
+extern mozilla::LazyLogModule gWebCodecsLog;
+
+namespace mozilla::dom {
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+
+#ifdef LOG
+# undef LOG
+#endif // LOG
+#define LOG(msg, ...) LOG_INTERNAL(Debug, msg, ##__VA_ARGS__)
+
+#ifdef LOGW
+# undef LOGW
+#endif // LOGW
+#define LOGW(msg, ...) LOG_INTERNAL(Warning, msg, ##__VA_ARGS__)
+
+#ifdef LOGE
+# undef LOGE
+#endif // LOGE
+#define LOGE(msg, ...) LOG_INTERNAL(Error, msg, ##__VA_ARGS__)
+
+#ifdef LOGV
+# undef LOGV
+#endif // LOGV
+#define LOGV(msg, ...) LOG_INTERNAL(Verbose, msg, ##__VA_ARGS__)
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(VideoDecoder, DOMEventTargetHelper,
+ mErrorCallback, mOutputCallback)
+NS_IMPL_ADDREF_INHERITED(VideoDecoder, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(VideoDecoder, DOMEventTargetHelper)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(VideoDecoder)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+/*
+ * Below are helper classes
+ */
+
+VideoColorSpaceInternal::VideoColorSpaceInternal(
+ const VideoColorSpaceInit& aColorSpaceInit)
+ : mFullRange(NullableToMaybe(aColorSpaceInit.mFullRange)),
+ mMatrix(NullableToMaybe(aColorSpaceInit.mMatrix)),
+ mPrimaries(NullableToMaybe(aColorSpaceInit.mPrimaries)),
+ mTransfer(NullableToMaybe(aColorSpaceInit.mTransfer)) {}
+
+VideoColorSpaceInit VideoColorSpaceInternal::ToColorSpaceInit() const {
+ VideoColorSpaceInit init;
+ init.mFullRange = MaybeToNullable(mFullRange);
+ init.mMatrix = MaybeToNullable(mMatrix);
+ init.mPrimaries = MaybeToNullable(mPrimaries);
+ init.mTransfer = MaybeToNullable(mTransfer);
+ return init;
+};
+
+static Result<RefPtr<MediaByteBuffer>, nsresult> GetExtraData(
+ const OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aBuffer);
+
+VideoDecoderConfigInternal::VideoDecoderConfigInternal(
+ const nsAString& aCodec, Maybe<uint32_t>&& aCodedHeight,
+ Maybe<uint32_t>&& aCodedWidth, Maybe<VideoColorSpaceInternal>&& aColorSpace,
+ Maybe<RefPtr<MediaByteBuffer>>&& aDescription,
+ Maybe<uint32_t>&& aDisplayAspectHeight,
+ Maybe<uint32_t>&& aDisplayAspectWidth,
+ const HardwareAcceleration& aHardwareAcceleration,
+ Maybe<bool>&& aOptimizeForLatency)
+ : mCodec(aCodec),
+ mCodedHeight(std::move(aCodedHeight)),
+ mCodedWidth(std::move(aCodedWidth)),
+ mColorSpace(std::move(aColorSpace)),
+ mDescription(std::move(aDescription)),
+ mDisplayAspectHeight(std::move(aDisplayAspectHeight)),
+ mDisplayAspectWidth(std::move(aDisplayAspectWidth)),
+ mHardwareAcceleration(aHardwareAcceleration),
+ mOptimizeForLatency(std::move(aOptimizeForLatency)){};
+
+/*static*/
+UniquePtr<VideoDecoderConfigInternal> VideoDecoderConfigInternal::Create(
+ const VideoDecoderConfig& aConfig) {
+ nsCString errorMessage;
+ if (!VideoDecoderTraits::Validate(aConfig, errorMessage)) {
+ LOGE("Failed to create VideoDecoderConfigInternal: %s", errorMessage.get());
+ return nullptr;
+ }
+
+ Maybe<RefPtr<MediaByteBuffer>> description;
+ if (aConfig.mDescription.WasPassed()) {
+ auto rv = GetExtraData(aConfig.mDescription.Value());
+ if (rv.isErr()) { // Invalid description data.
+ LOGE(
+ "Failed to create VideoDecoderConfigInternal due to invalid "
+ "description data. Error: 0x%08" PRIx32,
+ static_cast<uint32_t>(rv.unwrapErr()));
+ return nullptr;
+ }
+ description.emplace(rv.unwrap());
+ }
+
+ Maybe<VideoColorSpaceInternal> colorSpace;
+ if (aConfig.mColorSpace.WasPassed()) {
+ colorSpace.emplace(VideoColorSpaceInternal(aConfig.mColorSpace.Value()));
+ }
+
+ return UniquePtr<VideoDecoderConfigInternal>(new VideoDecoderConfigInternal(
+ aConfig.mCodec, OptionalToMaybe(aConfig.mCodedHeight),
+ OptionalToMaybe(aConfig.mCodedWidth), std::move(colorSpace),
+ std::move(description), OptionalToMaybe(aConfig.mDisplayAspectHeight),
+ OptionalToMaybe(aConfig.mDisplayAspectWidth),
+ aConfig.mHardwareAcceleration,
+ OptionalToMaybe(aConfig.mOptimizeForLatency)));
+}
+
+nsString VideoDecoderConfigInternal::ToString() const {
+ nsString rv;
+
+ rv.Append(mCodec);
+ if (mCodedWidth.isSome()) {
+ rv.AppendPrintf("coded: %dx%d", mCodedWidth.value(), mCodedHeight.value());
+ }
+ if (mDisplayAspectWidth.isSome()) {
+ rv.AppendPrintf("display %dx%d", mDisplayAspectWidth.value(),
+ mDisplayAspectHeight.value());
+ }
+ if (mColorSpace.isSome()) {
+ rv.AppendPrintf("colorspace %s", "todo");
+ }
+ if (mDescription.isSome()) {
+ rv.AppendPrintf("extradata: %zu bytes", mDescription.value()->Length());
+ }
+ rv.AppendPrintf(
+ "hw accel: %s",
+ HardwareAccelerationValues::GetString(mHardwareAcceleration).data());
+ if (mOptimizeForLatency.isSome()) {
+ rv.AppendPrintf("optimize for latency: %s",
+ mOptimizeForLatency.value() ? "true" : "false");
+ }
+
+ return rv;
+}
+
+/*
+ * The followings are helpers for VideoDecoder methods
+ */
+
+struct MIMECreateParam {
+ explicit MIMECreateParam(const VideoDecoderConfigInternal& aConfig)
+ : mParsedCodec(ParseCodecString(aConfig.mCodec).valueOr(EmptyString())),
+ mWidth(aConfig.mCodedWidth),
+ mHeight(aConfig.mCodedHeight) {}
+ explicit MIMECreateParam(const VideoDecoderConfig& aConfig)
+ : mParsedCodec(ParseCodecString(aConfig.mCodec).valueOr(EmptyString())),
+ mWidth(OptionalToMaybe(aConfig.mCodedWidth)),
+ mHeight(OptionalToMaybe(aConfig.mCodedHeight)) {}
+
+ const nsString mParsedCodec;
+ const Maybe<uint32_t> mWidth;
+ const Maybe<uint32_t> mHeight;
+};
+
+static nsTArray<nsCString> GuessMIMETypes(const MIMECreateParam& aParam) {
+ const auto codec = NS_ConvertUTF16toUTF8(aParam.mParsedCodec);
+ nsTArray<nsCString> types;
+ for (const nsCString& container : GuessContainers(aParam.mParsedCodec)) {
+ nsPrintfCString mime("video/%s; codecs=%s", container.get(), codec.get());
+ if (aParam.mWidth) {
+ mime.AppendPrintf("; width=%d", *aParam.mWidth);
+ }
+ if (aParam.mHeight) {
+ mime.AppendPrintf("; height=%d", *aParam.mHeight);
+ }
+ types.AppendElement(mime);
+ }
+ return types;
+}
+
+static bool IsSupportedCodec(const nsAString& aCodec) {
+ // H265 is unsupported.
+ if (!IsAV1CodecString(aCodec) && !IsVP9CodecString(aCodec) &&
+ !IsVP8CodecString(aCodec) && !IsH264CodecString(aCodec)) {
+ return false;
+ }
+
+ // Gecko allows codec string starts with vp9 or av1 but Webcodecs requires to
+ // starts with av01 and vp09.
+ // https://www.w3.org/TR/webcodecs-codec-registry/#video-codec-registry
+ if (StringBeginsWith(aCodec, u"vp9"_ns) ||
+ StringBeginsWith(aCodec, u"av1"_ns)) {
+ return false;
+ }
+
+ return true;
+}
+
+// https://w3c.github.io/webcodecs/#check-configuration-support
+template <typename Config>
+static bool CanDecode(const Config& aConfig) {
+ auto param = MIMECreateParam(aConfig);
+ // TODO: Enable WebCodecs on Android (Bug 1840508)
+ if (IsOnAndroid()) {
+ return false;
+ }
+ if (!IsSupportedCodec(param.mParsedCodec)) {
+ return false;
+ }
+ if (IsOnMacOS() && IsH264CodecString(param.mParsedCodec) &&
+ !StaticPrefs::dom_media_webcodecs_force_osx_h264_enabled()) {
+ // This will be fixed in Bug 1846796.
+ return false;
+ }
+ // TODO: Instead of calling CanHandleContainerType with the guessed the
+ // containers, DecoderTraits should provide an API to tell if a codec is
+ // decodable or not.
+ for (const nsCString& mime : GuessMIMETypes(param)) {
+ if (Maybe<MediaContainerType> containerType =
+ MakeMediaExtendedMIMEType(mime)) {
+ if (DecoderTraits::CanHandleContainerType(
+ *containerType, nullptr /* DecoderDoctorDiagnostics */) !=
+ CANPLAY_NO) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+static nsTArray<UniquePtr<TrackInfo>> GetTracksInfo(
+ const VideoDecoderConfigInternal& aConfig) {
+ // TODO: Instead of calling GetTracksInfo with the guessed containers,
+ // DecoderTraits should provide an API to create the TrackInfo directly.
+ for (const nsCString& mime : GuessMIMETypes(MIMECreateParam(aConfig))) {
+ if (Maybe<MediaContainerType> containerType =
+ MakeMediaExtendedMIMEType(mime)) {
+ if (nsTArray<UniquePtr<TrackInfo>> tracks =
+ DecoderTraits::GetTracksInfo(*containerType);
+ !tracks.IsEmpty()) {
+ return tracks;
+ }
+ }
+ }
+ return {};
+}
+
+static Result<RefPtr<MediaByteBuffer>, nsresult> GetExtraData(
+ const OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aBuffer) {
+ RefPtr<MediaByteBuffer> data = MakeRefPtr<MediaByteBuffer>();
+ if (!AppendTypedArrayDataTo(aBuffer, *data)) {
+ return Err(NS_ERROR_OUT_OF_MEMORY);
+ }
+ return data->Length() > 0 ? data : nullptr;
+}
+
+static Result<Ok, nsresult> CloneConfiguration(
+ RootedDictionary<VideoDecoderConfig>& aDest, JSContext* aCx,
+ const VideoDecoderConfig& aConfig) {
+ DebugOnly<nsCString> str;
+ MOZ_ASSERT(VideoDecoderTraits::Validate(aConfig, str));
+
+ aDest.mCodec = aConfig.mCodec;
+ if (aConfig.mCodedHeight.WasPassed()) {
+ aDest.mCodedHeight.Construct(aConfig.mCodedHeight.Value());
+ }
+ if (aConfig.mCodedWidth.WasPassed()) {
+ aDest.mCodedWidth.Construct(aConfig.mCodedWidth.Value());
+ }
+ if (aConfig.mColorSpace.WasPassed()) {
+ aDest.mColorSpace.Construct(aConfig.mColorSpace.Value());
+ }
+ if (aConfig.mDescription.WasPassed()) {
+ aDest.mDescription.Construct();
+ MOZ_TRY(CloneBuffer(aCx, aDest.mDescription.Value(),
+ aConfig.mDescription.Value()));
+ }
+ if (aConfig.mDisplayAspectHeight.WasPassed()) {
+ aDest.mDisplayAspectHeight.Construct(aConfig.mDisplayAspectHeight.Value());
+ }
+ if (aConfig.mDisplayAspectWidth.WasPassed()) {
+ aDest.mDisplayAspectWidth.Construct(aConfig.mDisplayAspectWidth.Value());
+ }
+ aDest.mHardwareAcceleration = aConfig.mHardwareAcceleration;
+ if (aConfig.mOptimizeForLatency.WasPassed()) {
+ aDest.mOptimizeForLatency.Construct(aConfig.mOptimizeForLatency.Value());
+ }
+
+ return Ok();
+}
+
+static Maybe<VideoPixelFormat> GuessPixelFormat(layers::Image* aImage) {
+ if (aImage) {
+ // TODO: Implement ImageUtils::Impl for MacIOSurfaceImage and
+ // DMABUFSurfaceImage?
+ if (aImage->AsPlanarYCbCrImage() || aImage->AsNVImage()) {
+ const ImageUtils imageUtils(aImage);
+ Maybe<VideoPixelFormat> f =
+ ImageBitmapFormatToVideoPixelFormat(imageUtils.GetFormat());
+
+ // ImageBitmapFormat cannot distinguish YUV420 or YUV420A.
+ bool hasAlpha = aImage->AsPlanarYCbCrImage() &&
+ aImage->AsPlanarYCbCrImage()->GetData() &&
+ aImage->AsPlanarYCbCrImage()->GetData()->mAlpha;
+ if (f && *f == VideoPixelFormat::I420 && hasAlpha) {
+ return Some(VideoPixelFormat::I420A);
+ }
+ return f;
+ }
+ if (layers::GPUVideoImage* image = aImage->AsGPUVideoImage()) {
+ RefPtr<layers::ImageBridgeChild> imageBridge =
+ layers::ImageBridgeChild::GetSingleton();
+ layers::TextureClient* texture = image->GetTextureClient(imageBridge);
+ if (NS_WARN_IF(!texture)) {
+ return Nothing();
+ }
+ return SurfaceFormatToVideoPixelFormat(texture->GetFormat());
+ }
+#ifdef XP_MACOSX
+ if (layers::MacIOSurfaceImage* image = aImage->AsMacIOSurfaceImage()) {
+ MOZ_ASSERT(image->GetSurface());
+ return SurfaceFormatToVideoPixelFormat(image->GetSurface()->GetFormat());
+ }
+#endif
+#ifdef MOZ_WAYLAND
+ if (layers::DMABUFSurfaceImage* image = aImage->AsDMABUFSurfaceImage()) {
+ MOZ_ASSERT(image->GetSurface());
+ return SurfaceFormatToVideoPixelFormat(image->GetSurface()->GetFormat());
+ }
+#endif
+ }
+ LOGW("Failed to get pixel format from layers::Image");
+ return Nothing();
+}
+
+static VideoColorSpaceInternal GuessColorSpace(
+ const layers::PlanarYCbCrData* aData) {
+ if (!aData) {
+ LOGE("nullptr in GuessColorSpace");
+ return {};
+ }
+
+ VideoColorSpaceInternal colorSpace;
+ colorSpace.mFullRange = Some(ToFullRange(aData->mColorRange));
+ if (Maybe<VideoMatrixCoefficients> m =
+ ToMatrixCoefficients(aData->mYUVColorSpace)) {
+ colorSpace.mMatrix = ToMatrixCoefficients(aData->mYUVColorSpace);
+ colorSpace.mPrimaries = ToPrimaries(aData->mColorPrimaries);
+ }
+ if (!colorSpace.mPrimaries) {
+ LOG("Missing primaries, guessing from colorspace");
+ // Make an educated guess based on the coefficients.
+ colorSpace.mPrimaries = colorSpace.mMatrix.map([](const auto& aMatrix) {
+ switch (aMatrix) {
+ case VideoMatrixCoefficients::EndGuard_:
+ MOZ_CRASH("This should not happen");
+ case VideoMatrixCoefficients::Bt2020_ncl:
+ return VideoColorPrimaries::Bt2020;
+ case VideoMatrixCoefficients::Rgb:
+ case VideoMatrixCoefficients::Bt470bg:
+ case VideoMatrixCoefficients::Smpte170m:
+ LOGW(
+ "Warning: Falling back to BT709 when attempting to determine the "
+ "primaries function of a YCbCr buffer");
+ [[fallthrough]];
+ case VideoMatrixCoefficients::Bt709:
+ return VideoColorPrimaries::Bt709;
+ }
+ MOZ_ASSERT_UNREACHABLE("Unexpected matrix coefficients");
+ LOGW(
+ "Warning: Falling back to BT709 due to unexpected matrix "
+ "coefficients "
+ "when attempting to determine the primaries function of a YCbCr "
+ "buffer");
+ return VideoColorPrimaries::Bt709;
+ });
+ }
+
+ if (Maybe<VideoTransferCharacteristics> c =
+ ToTransferCharacteristics(aData->mTransferFunction)) {
+ colorSpace.mTransfer = Some(*c);
+ }
+ if (!colorSpace.mTransfer) {
+ LOG("Missing transfer characteristics, guessing from colorspace");
+ colorSpace.mTransfer = Some(([&] {
+ switch (aData->mYUVColorSpace) {
+ case gfx::YUVColorSpace::Identity:
+ return VideoTransferCharacteristics::Iec61966_2_1;
+ case gfx::YUVColorSpace::BT2020:
+ return VideoTransferCharacteristics::Pq;
+ case gfx::YUVColorSpace::BT601:
+ LOGW(
+ "Warning: Falling back to BT709 when attempting to determine the "
+ "transfer function of a MacIOSurface");
+ [[fallthrough]];
+ case gfx::YUVColorSpace::BT709:
+ return VideoTransferCharacteristics::Bt709;
+ }
+ MOZ_ASSERT_UNREACHABLE("Unexpected color space");
+ LOGW(
+ "Warning: Falling back to BT709 due to unexpected color space "
+ "when attempting to determine the transfer function of a "
+ "MacIOSurface");
+ return VideoTransferCharacteristics::Bt709;
+ })());
+ }
+
+ return colorSpace;
+}
+
+#ifdef XP_MACOSX
+static VideoColorSpaceInternal GuessColorSpace(const MacIOSurface* aSurface) {
+ if (!aSurface) {
+ return {};
+ }
+ VideoColorSpaceInternal colorSpace;
+ colorSpace.mFullRange = Some(aSurface->IsFullRange());
+ if (Maybe<dom::VideoMatrixCoefficients> m =
+ ToMatrixCoefficients(aSurface->GetYUVColorSpace())) {
+ colorSpace.mMatrix = Some(*m);
+ }
+ if (Maybe<VideoColorPrimaries> p = ToPrimaries(aSurface->mColorPrimaries)) {
+ colorSpace.mPrimaries = Some(*p);
+ }
+ // Make an educated guess based on the coefficients.
+ if (aSurface->GetYUVColorSpace() == gfx::YUVColorSpace::Identity) {
+ colorSpace.mTransfer = Some(VideoTransferCharacteristics::Iec61966_2_1);
+ } else if (aSurface->GetYUVColorSpace() == gfx::YUVColorSpace::BT709) {
+ colorSpace.mTransfer = Some(VideoTransferCharacteristics::Bt709);
+ } else if (aSurface->GetYUVColorSpace() == gfx::YUVColorSpace::BT2020) {
+ colorSpace.mTransfer = Some(VideoTransferCharacteristics::Pq);
+ } else {
+ LOGW(
+ "Warning: Falling back to BT709 when attempting to determine the "
+ "transfer function of a MacIOSurface");
+ colorSpace.mTransfer = Some(VideoTransferCharacteristics::Bt709);
+ }
+
+ return colorSpace;
+}
+#endif
+#ifdef MOZ_WAYLAND
+// TODO: Set DMABufSurface::IsFullRange() to const so aSurface can be const.
+static VideoColorSpaceInternal GuessColorSpace(DMABufSurface* aSurface) {
+ if (!aSurface) {
+ return {};
+ }
+ VideoColorSpaceInternal colorSpace;
+ colorSpace.mFullRange = Some(aSurface->IsFullRange());
+ if (Maybe<dom::VideoMatrixCoefficients> m =
+ ToMatrixCoefficients(aSurface->GetYUVColorSpace())) {
+ colorSpace.mMatrix = Some(*m);
+ }
+ // No other color space information.
+ return colorSpace;
+}
+#endif
+
+static VideoColorSpaceInternal GuessColorSpace(layers::Image* aImage) {
+ if (aImage) {
+ if (layers::PlanarYCbCrImage* image = aImage->AsPlanarYCbCrImage()) {
+ return GuessColorSpace(image->GetData());
+ }
+ if (layers::NVImage* image = aImage->AsNVImage()) {
+ return GuessColorSpace(image->GetData());
+ }
+ if (layers::GPUVideoImage* image = aImage->AsGPUVideoImage()) {
+ VideoColorSpaceInternal colorSpace;
+ colorSpace.mFullRange =
+ Some(image->GetColorRange() != gfx::ColorRange::LIMITED);
+ colorSpace.mMatrix = ToMatrixCoefficients(image->GetYUVColorSpace());
+ colorSpace.mPrimaries = ToPrimaries(image->GetColorPrimaries());
+ colorSpace.mTransfer =
+ ToTransferCharacteristics(image->GetTransferFunction());
+ // In some circumstances, e.g. on Linux software decoding when using
+ // VPXDecoder and RDD, the primaries aren't set correctly. Make a good
+ // guess based on the other params. Fixing this is tracked in
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1869825
+ if (!colorSpace.mPrimaries) {
+ if (colorSpace.mMatrix.isSome()) {
+ switch (colorSpace.mMatrix.value()) {
+ case VideoMatrixCoefficients::Rgb:
+ case VideoMatrixCoefficients::Bt709:
+ colorSpace.mPrimaries = Some(VideoColorPrimaries::Bt709);
+ break;
+ case VideoMatrixCoefficients::Bt470bg:
+ case VideoMatrixCoefficients::Smpte170m:
+ colorSpace.mPrimaries = Some(VideoColorPrimaries::Bt470bg);
+ break;
+ case VideoMatrixCoefficients::Bt2020_ncl:
+ colorSpace.mPrimaries = Some(VideoColorPrimaries::Bt2020);
+ break;
+ case VideoMatrixCoefficients::EndGuard_:
+ MOZ_ASSERT_UNREACHABLE("bad enum value");
+ break;
+ };
+ }
+ }
+ return colorSpace;
+ }
+#ifdef XP_MACOSX
+ // TODO: Make sure VideoFrame can interpret its internal data in different
+ // formats.
+ if (layers::MacIOSurfaceImage* image = aImage->AsMacIOSurfaceImage()) {
+ return GuessColorSpace(image->GetSurface());
+ }
+#endif
+#ifdef MOZ_WAYLAND
+ // TODO: Make sure VideoFrame can interpret its internal data in different
+ // formats.
+ if (layers::DMABUFSurfaceImage* image = aImage->AsDMABUFSurfaceImage()) {
+ return GuessColorSpace(image->GetSurface());
+ }
+#endif
+ }
+ LOGW("Failed to get color space from layers::Image");
+ return {};
+}
+
+static Result<gfx::IntSize, nsresult> AdjustDisplaySize(
+ const uint32_t aDisplayAspectWidth, const uint32_t aDisplayAspectHeight,
+ const gfx::IntSize& aDisplaySize) {
+ if (aDisplayAspectHeight == 0) {
+ return Err(NS_ERROR_ILLEGAL_VALUE);
+ }
+
+ const double aspectRatio =
+ static_cast<double>(aDisplayAspectWidth) / aDisplayAspectHeight;
+
+ double w = aDisplaySize.width;
+ double h = aDisplaySize.height;
+
+ if (aspectRatio >= w / h) {
+ // Adjust w to match the aspect ratio
+ w = aspectRatio * h;
+ } else {
+ // Adjust h to match the aspect ratio
+ h = w / aspectRatio;
+ }
+
+ w = std::round(w);
+ h = std::round(h);
+ constexpr double MAX = static_cast<double>(
+ std::numeric_limits<decltype(gfx::IntSize::width)>::max());
+ if (w > MAX || h > MAX || w < 1.0 || h < 1.0) {
+ return Err(NS_ERROR_ILLEGAL_VALUE);
+ }
+ return gfx::IntSize(static_cast<decltype(gfx::IntSize::width)>(w),
+ static_cast<decltype(gfx::IntSize::height)>(h));
+}
+
+// https://w3c.github.io/webcodecs/#create-a-videoframe
+static RefPtr<VideoFrame> CreateVideoFrame(
+ nsIGlobalObject* aGlobalObject, const VideoData* aData, int64_t aTimestamp,
+ uint64_t aDuration, const Maybe<uint32_t> aDisplayAspectWidth,
+ const Maybe<uint32_t> aDisplayAspectHeight,
+ const VideoColorSpaceInternal& aColorSpace) {
+ MOZ_ASSERT(aGlobalObject);
+ MOZ_ASSERT(aData);
+ MOZ_ASSERT((!!aDisplayAspectWidth) == (!!aDisplayAspectHeight));
+
+ Maybe<VideoPixelFormat> format = GuessPixelFormat(aData->mImage.get());
+ gfx::IntSize displaySize = aData->mDisplay;
+ if (aDisplayAspectWidth && aDisplayAspectHeight) {
+ auto r = AdjustDisplaySize(*aDisplayAspectWidth, *aDisplayAspectHeight,
+ displaySize);
+ if (r.isOk()) {
+ displaySize = r.unwrap();
+ }
+ }
+
+ return MakeRefPtr<VideoFrame>(
+ aGlobalObject, aData->mImage, format, aData->mImage->GetSize(),
+ aData->mImage->GetPictureRect(), displaySize, Some(aDuration), aTimestamp,
+ aColorSpace.ToColorSpaceInit());
+}
+
+/* static */
+bool VideoDecoderTraits::IsSupported(
+ const VideoDecoderConfigInternal& aConfig) {
+ return CanDecode(aConfig);
+}
+
+/* static */
+Result<UniquePtr<TrackInfo>, nsresult> VideoDecoderTraits::CreateTrackInfo(
+ const VideoDecoderConfigInternal& aConfig) {
+ LOG("Create a VideoInfo from %s config",
+ NS_ConvertUTF16toUTF8(aConfig.ToString()).get());
+
+ nsTArray<UniquePtr<TrackInfo>> tracks = GetTracksInfo(aConfig);
+ if (tracks.Length() != 1 || tracks[0]->GetType() != TrackInfo::kVideoTrack) {
+ LOGE("Failed to get TrackInfo");
+ return Err(NS_ERROR_INVALID_ARG);
+ }
+
+ UniquePtr<TrackInfo> track(std::move(tracks[0]));
+ VideoInfo* vi = track->GetAsVideoInfo();
+ if (!vi) {
+ LOGE("Failed to get VideoInfo");
+ return Err(NS_ERROR_INVALID_ARG);
+ }
+
+ constexpr uint32_t MAX = static_cast<uint32_t>(
+ std::numeric_limits<decltype(gfx::IntSize::width)>::max());
+ if (aConfig.mCodedHeight.isSome()) {
+ if (aConfig.mCodedHeight.value() > MAX) {
+ LOGE("codedHeight overflows");
+ return Err(NS_ERROR_INVALID_ARG);
+ }
+ vi->mImage.height = static_cast<decltype(gfx::IntSize::height)>(
+ aConfig.mCodedHeight.value());
+ }
+ if (aConfig.mCodedWidth.isSome()) {
+ if (aConfig.mCodedWidth.value() > MAX) {
+ LOGE("codedWidth overflows");
+ return Err(NS_ERROR_INVALID_ARG);
+ }
+ vi->mImage.width =
+ static_cast<decltype(gfx::IntSize::width)>(aConfig.mCodedWidth.value());
+ }
+
+ if (aConfig.mDisplayAspectHeight.isSome()) {
+ if (aConfig.mDisplayAspectHeight.value() > MAX) {
+ LOGE("displayAspectHeight overflows");
+ return Err(NS_ERROR_INVALID_ARG);
+ }
+ vi->mDisplay.height = static_cast<decltype(gfx::IntSize::height)>(
+ aConfig.mDisplayAspectHeight.value());
+ }
+ if (aConfig.mDisplayAspectWidth.isSome()) {
+ if (aConfig.mDisplayAspectWidth.value() > MAX) {
+ LOGE("displayAspectWidth overflows");
+ return Err(NS_ERROR_INVALID_ARG);
+ }
+ vi->mDisplay.width = static_cast<decltype(gfx::IntSize::width)>(
+ aConfig.mDisplayAspectWidth.value());
+ }
+
+ if (aConfig.mColorSpace.isSome()) {
+ const VideoColorSpaceInternal& colorSpace(aConfig.mColorSpace.value());
+ if (colorSpace.mFullRange.isSome()) {
+ vi->mColorRange = ToColorRange(colorSpace.mFullRange.value());
+ }
+ if (colorSpace.mMatrix.isSome()) {
+ vi->mColorSpace.emplace(ToColorSpace(colorSpace.mMatrix.value()));
+ }
+ // Some decoders get their primaries and transfer function from the codec
+ // string, and it's already set here. This is the case for VP9 decoders.
+ if (colorSpace.mPrimaries.isSome()) {
+ auto primaries = ToPrimaries(colorSpace.mPrimaries.value());
+ if (vi->mColorPrimaries.isSome()) {
+ if (vi->mColorPrimaries.value() != primaries) {
+ LOG("Conflict between decoder config and codec string, keeping codec "
+ "string primaries of %d",
+ static_cast<int>(primaries));
+ }
+ } else {
+ vi->mColorPrimaries.emplace(primaries);
+ }
+ }
+ if (colorSpace.mTransfer.isSome()) {
+ auto primaries = ToTransferFunction(colorSpace.mTransfer.value());
+ if (vi->mTransferFunction.isSome()) {
+ if (vi->mTransferFunction.value() != primaries) {
+ LOG("Conflict between decoder config and codec string, keeping codec "
+ "string transfer function of %d",
+ static_cast<int>(vi->mTransferFunction.value()));
+ }
+ } else {
+ vi->mTransferFunction.emplace(
+ ToTransferFunction(colorSpace.mTransfer.value()));
+ }
+ }
+ }
+
+ if (aConfig.mDescription.isSome()) {
+ RefPtr<MediaByteBuffer> buf;
+ buf = aConfig.mDescription.value();
+ if (buf) {
+ LOG("The given config has %zu bytes of description data", buf->Length());
+ if (vi->mExtraData) {
+ LOGW("The default extra data is overwritten");
+ }
+ vi->mExtraData = buf;
+ }
+
+ // TODO: Make this utility and replace the similar one in MP4Demuxer.cpp.
+ if (vi->mExtraData && !vi->mExtraData->IsEmpty() &&
+ IsH264CodecString(aConfig.mCodec)) {
+ SPSData spsdata;
+ if (H264::DecodeSPSFromExtraData(vi->mExtraData.get(), spsdata) &&
+ spsdata.pic_width > 0 && spsdata.pic_height > 0 &&
+ H264::EnsureSPSIsSane(spsdata)) {
+ LOG("H264 sps data - pic size: %d x %d, display size: %d x %d",
+ spsdata.pic_width, spsdata.pic_height, spsdata.display_width,
+ spsdata.display_height);
+
+ if (spsdata.pic_width > MAX || spsdata.pic_height > MAX ||
+ spsdata.display_width > MAX || spsdata.display_height > MAX) {
+ LOGE("H264 width or height in sps data overflows");
+ return Err(NS_ERROR_INVALID_ARG);
+ }
+
+ vi->mImage.width =
+ static_cast<decltype(gfx::IntSize::width)>(spsdata.pic_width);
+ vi->mImage.height =
+ static_cast<decltype(gfx::IntSize::height)>(spsdata.pic_height);
+ vi->mDisplay.width =
+ static_cast<decltype(gfx::IntSize::width)>(spsdata.display_width);
+ vi->mDisplay.height =
+ static_cast<decltype(gfx::IntSize::height)>(spsdata.display_height);
+ }
+ }
+ } else {
+ vi->mExtraData = new MediaByteBuffer();
+ }
+
+ LOG("Created a VideoInfo for decoder - %s",
+ NS_ConvertUTF16toUTF8(vi->ToString()).get());
+
+ return track;
+}
+
+// https://w3c.github.io/webcodecs/#valid-videodecoderconfig
+/* static */
+bool VideoDecoderTraits::Validate(const VideoDecoderConfig& aConfig,
+ nsCString& aErrorMessage) {
+ Maybe<nsString> codec = ParseCodecString(aConfig.mCodec);
+ if (!codec || codec->IsEmpty()) {
+ LOGE("Invalid codec string");
+ return false;
+ }
+
+ if (aConfig.mCodedWidth.WasPassed() != aConfig.mCodedHeight.WasPassed()) {
+ LOGE("Missing coded %s",
+ aConfig.mCodedWidth.WasPassed() ? "height" : "width");
+ return false;
+ }
+ if (aConfig.mCodedWidth.WasPassed() &&
+ (aConfig.mCodedWidth.Value() == 0 || aConfig.mCodedHeight.Value() == 0)) {
+ LOGE("codedWidth and/or codedHeight can't be zero");
+ return false;
+ }
+
+ if (aConfig.mDisplayAspectWidth.WasPassed() !=
+ aConfig.mDisplayAspectHeight.WasPassed()) {
+ LOGE("Missing display aspect %s",
+ aConfig.mDisplayAspectWidth.WasPassed() ? "height" : "width");
+ return false;
+ }
+ if (aConfig.mDisplayAspectWidth.WasPassed() &&
+ (aConfig.mDisplayAspectWidth.Value() == 0 ||
+ aConfig.mDisplayAspectHeight.Value() == 0)) {
+ LOGE("display aspect width and height cannot be zero");
+ return false;
+ }
+
+ return true;
+}
+
+/* static */
+UniquePtr<VideoDecoderConfigInternal> VideoDecoderTraits::CreateConfigInternal(
+ const VideoDecoderConfig& aConfig) {
+ return VideoDecoderConfigInternal::Create(aConfig);
+}
+
+/* static */
+bool VideoDecoderTraits::IsKeyChunk(const EncodedVideoChunk& aInput) {
+ return aInput.Type() == EncodedVideoChunkType::Key;
+}
+
+/* static */
+UniquePtr<EncodedVideoChunkData> VideoDecoderTraits::CreateInputInternal(
+ const EncodedVideoChunk& aInput) {
+ return aInput.Clone();
+}
+
+/*
+ * Below are VideoDecoder implementation
+ */
+
+VideoDecoder::VideoDecoder(nsIGlobalObject* aParent,
+ RefPtr<WebCodecsErrorCallback>&& aErrorCallback,
+ RefPtr<VideoFrameOutputCallback>&& aOutputCallback)
+ : DecoderTemplate(aParent, std::move(aErrorCallback),
+ std::move(aOutputCallback)) {
+ MOZ_ASSERT(mErrorCallback);
+ MOZ_ASSERT(mOutputCallback);
+ LOG("VideoDecoder %p ctor", this);
+}
+
+VideoDecoder::~VideoDecoder() {
+ LOG("VideoDecoder %p dtor", this);
+}
+
+JSObject* VideoDecoder::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ AssertIsOnOwningThread();
+
+ return VideoDecoder_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+// https://w3c.github.io/webcodecs/#dom-videodecoder-videodecoder
+/* static */
+already_AddRefed<VideoDecoder> VideoDecoder::Constructor(
+ const GlobalObject& aGlobal, const VideoDecoderInit& aInit,
+ ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ return MakeAndAddRef<VideoDecoder>(
+ global.get(), RefPtr<WebCodecsErrorCallback>(aInit.mError),
+ RefPtr<VideoFrameOutputCallback>(aInit.mOutput));
+}
+
+// https://w3c.github.io/webcodecs/#dom-videodecoder-isconfigsupported
+/* static */
+already_AddRefed<Promise> VideoDecoder::IsConfigSupported(
+ const GlobalObject& aGlobal, const VideoDecoderConfig& aConfig,
+ ErrorResult& aRv) {
+ LOG("VideoDecoder::IsConfigSupported, config: %s",
+ NS_ConvertUTF16toUTF8(aConfig.mCodec).get());
+
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ RefPtr<Promise> p = Promise::Create(global.get(), aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return p.forget();
+ }
+
+ nsCString errorMessage;
+ if (!VideoDecoderTraits::Validate(aConfig, errorMessage)) {
+ p->MaybeRejectWithTypeError(nsPrintfCString(
+ "VideoDecoderConfig is invalid: %s", errorMessage.get()));
+ return p.forget();
+ }
+
+ // TODO: Move the following works to another thread to unblock the current
+ // thread, as what spec suggests.
+
+ RootedDictionary<VideoDecoderConfig> config(aGlobal.Context());
+ auto r = CloneConfiguration(config, aGlobal.Context(), aConfig);
+ if (r.isErr()) {
+ nsresult e = r.unwrapErr();
+ LOGE("Failed to clone VideoDecoderConfig. Error: 0x%08" PRIx32,
+ static_cast<uint32_t>(e));
+ p->MaybeRejectWithTypeError("Failed to clone VideoDecoderConfig");
+ aRv.Throw(e);
+ return p.forget();
+ }
+
+ bool canDecode = CanDecode(config);
+ RootedDictionary<VideoDecoderSupport> s(aGlobal.Context());
+ s.mConfig.Construct(std::move(config));
+ s.mSupported.Construct(canDecode);
+
+ p->MaybeResolve(s);
+ return p.forget();
+}
+
+already_AddRefed<MediaRawData> VideoDecoder::InputDataToMediaRawData(
+ UniquePtr<EncodedVideoChunkData>&& aData, TrackInfo& aInfo,
+ const VideoDecoderConfigInternal& aConfig) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aInfo.GetAsVideoInfo());
+
+ if (!aData) {
+ LOGE("No data for conversion");
+ return nullptr;
+ }
+
+ RefPtr<MediaRawData> sample = aData->TakeData();
+ if (!sample) {
+ LOGE("Take no data for conversion");
+ return nullptr;
+ }
+
+ // aExtraData is either provided by Configure() or a default one created for
+ // the decoder creation. If it's created for decoder creation only, we don't
+ // set it to sample.
+ if (aConfig.mDescription && aInfo.GetAsVideoInfo()->mExtraData) {
+ sample->mExtraData = aInfo.GetAsVideoInfo()->mExtraData;
+ }
+
+ LOGV(
+ "EncodedVideoChunkData %p converted to %zu-byte MediaRawData - time: "
+ "%" PRIi64 "us, timecode: %" PRIi64 "us, duration: %" PRIi64
+ "us, key-frame: %s, has extra data: %s",
+ aData.get(), sample->Size(), sample->mTime.ToMicroseconds(),
+ sample->mTimecode.ToMicroseconds(), sample->mDuration.ToMicroseconds(),
+ sample->mKeyframe ? "yes" : "no", sample->mExtraData ? "yes" : "no");
+
+ return sample.forget();
+}
+
+nsTArray<RefPtr<VideoFrame>> VideoDecoder::DecodedDataToOutputType(
+ nsIGlobalObject* aGlobalObject, const nsTArray<RefPtr<MediaData>>&& aData,
+ VideoDecoderConfigInternal& aConfig) {
+ AssertIsOnOwningThread();
+
+ nsTArray<RefPtr<VideoFrame>> frames;
+ for (const RefPtr<MediaData>& data : aData) {
+ MOZ_RELEASE_ASSERT(data->mType == MediaData::Type::VIDEO_DATA);
+ RefPtr<const VideoData> d(data->As<const VideoData>());
+ VideoColorSpaceInternal colorSpace;
+ // Determine which color space to use: prefer the color space as configured
+ // at the decoder level, if it has one, otherwise look at the underlying
+ // image and make a guess.
+ if (aConfig.mColorSpace.isSome() &&
+ aConfig.mColorSpace->mPrimaries.isSome() &&
+ aConfig.mColorSpace->mTransfer.isSome() &&
+ aConfig.mColorSpace->mMatrix.isSome()) {
+ colorSpace = aConfig.mColorSpace.value();
+ } else {
+ colorSpace = GuessColorSpace(d->mImage.get());
+ }
+ frames.AppendElement(CreateVideoFrame(
+ aGlobalObject, d.get(), d->mTime.ToMicroseconds(),
+ static_cast<uint64_t>(d->mDuration.ToMicroseconds()),
+ aConfig.mDisplayAspectWidth, aConfig.mDisplayAspectHeight, colorSpace));
+ }
+ return frames;
+}
+
+#undef LOG
+#undef LOGW
+#undef LOGE
+#undef LOGV
+#undef LOG_INTERNAL
+
+} // namespace mozilla::dom
diff --git a/dom/media/webcodecs/VideoDecoder.h b/dom/media/webcodecs/VideoDecoder.h
new file mode 100644
index 0000000000..f4b3fe10ed
--- /dev/null
+++ b/dom/media/webcodecs/VideoDecoder.h
@@ -0,0 +1,79 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_VideoDecoder_h
+#define mozilla_dom_VideoDecoder_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/DecoderTemplate.h"
+#include "mozilla/dom/DecoderTypes.h"
+#include "mozilla/dom/VideoFrame.h"
+#include "nsCycleCollectionParticipant.h"
+
+class nsIGlobalObject;
+
+namespace mozilla {
+
+namespace dom {
+
+class EncodedVideoChunk;
+class EncodedVideoChunkData;
+class EventHandlerNonNull;
+class GlobalObject;
+class Promise;
+class VideoFrameOutputCallback;
+class WebCodecsErrorCallback;
+struct VideoDecoderConfig;
+struct VideoDecoderInit;
+
+} // namespace dom
+
+} // namespace mozilla
+
+namespace mozilla::dom {
+
+class VideoDecoder final : public DecoderTemplate<VideoDecoderTraits> {
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(VideoDecoder, DOMEventTargetHelper)
+
+ public:
+ VideoDecoder(nsIGlobalObject* aParent,
+ RefPtr<WebCodecsErrorCallback>&& aErrorCallback,
+ RefPtr<VideoFrameOutputCallback>&& aOutputCallback);
+
+ protected:
+ ~VideoDecoder();
+
+ public:
+ JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ static already_AddRefed<VideoDecoder> Constructor(
+ const GlobalObject& aGlobal, const VideoDecoderInit& aInit,
+ ErrorResult& aRv);
+
+ static already_AddRefed<Promise> IsConfigSupported(
+ const GlobalObject& aGlobal, const VideoDecoderConfig& aConfig,
+ ErrorResult& aRv);
+
+ protected:
+ virtual already_AddRefed<MediaRawData> InputDataToMediaRawData(
+ UniquePtr<EncodedVideoChunkData>&& aData, TrackInfo& aInfo,
+ const VideoDecoderConfigInternal& aConfig) override;
+
+ virtual nsTArray<RefPtr<VideoFrame>> DecodedDataToOutputType(
+ nsIGlobalObject* aGlobalObject, const nsTArray<RefPtr<MediaData>>&& aData,
+ VideoDecoderConfigInternal& aConfig) override;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_VideoDecoder_h
diff --git a/dom/media/webcodecs/VideoEncoder.cpp b/dom/media/webcodecs/VideoEncoder.cpp
new file mode 100644
index 0000000000..0e71417cb0
--- /dev/null
+++ b/dom/media/webcodecs/VideoEncoder.cpp
@@ -0,0 +1,624 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/VideoEncoder.h"
+#include "mozilla/dom/VideoEncoderBinding.h"
+#include "mozilla/dom/VideoColorSpaceBinding.h"
+#include "mozilla/dom/VideoColorSpace.h"
+#include "mozilla/dom/VideoFrame.h"
+
+#include "EncoderTraits.h"
+#include "ImageContainer.h"
+#include "VideoUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/Unused.h"
+#include "mozilla/dom/EncodedVideoChunk.h"
+#include "mozilla/dom/EncodedVideoChunkBinding.h"
+#include "mozilla/dom/ImageUtils.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/VideoColorSpaceBinding.h"
+#include "mozilla/dom/VideoFrameBinding.h"
+#include "mozilla/dom/WebCodecsUtils.h"
+#include "nsPrintfCString.h"
+#include "nsReadableUtils.h"
+
+extern mozilla::LazyLogModule gWebCodecsLog;
+
+namespace mozilla::dom {
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+
+#ifdef LOG
+# undef LOG
+#endif // LOG
+#define LOG(msg, ...) LOG_INTERNAL(Debug, msg, ##__VA_ARGS__)
+
+#ifdef LOGW
+# undef LOGW
+#endif // LOGW
+#define LOGW(msg, ...) LOG_INTERNAL(Warning, msg, ##__VA_ARGS__)
+
+#ifdef LOGE
+# undef LOGE
+#endif // LOGE
+#define LOGE(msg, ...) LOG_INTERNAL(Error, msg, ##__VA_ARGS__)
+
+#ifdef LOGV
+# undef LOGV
+#endif // LOGV
+#define LOGV(msg, ...) LOG_INTERNAL(Verbose, msg, ##__VA_ARGS__)
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(VideoEncoder, DOMEventTargetHelper,
+ mErrorCallback, mOutputCallback)
+NS_IMPL_ADDREF_INHERITED(VideoEncoder, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(VideoEncoder, DOMEventTargetHelper)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(VideoEncoder)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+VideoEncoderConfigInternal::VideoEncoderConfigInternal(
+ const nsAString& aCodec, uint32_t aWidth, uint32_t aHeight,
+ Maybe<uint32_t>&& aDisplayWidth, Maybe<uint32_t>&& aDisplayHeight,
+ Maybe<uint32_t>&& aBitrate, Maybe<double>&& aFramerate,
+ const HardwareAcceleration& aHardwareAcceleration,
+ const AlphaOption& aAlpha, Maybe<nsString>&& aScalabilityMode,
+ const VideoEncoderBitrateMode& aBitrateMode,
+ const LatencyMode& aLatencyMode, Maybe<nsString>&& aContentHint)
+ : mCodec(aCodec),
+ mWidth(aWidth),
+ mHeight(aHeight),
+ mDisplayWidth(std::move(aDisplayWidth)),
+ mDisplayHeight(std::move(aDisplayHeight)),
+ mBitrate(std::move(aBitrate)),
+ mFramerate(std::move(aFramerate)),
+ mHardwareAcceleration(aHardwareAcceleration),
+ mAlpha(aAlpha),
+ mScalabilityMode(std::move(aScalabilityMode)),
+ mBitrateMode(aBitrateMode),
+ mLatencyMode(aLatencyMode),
+ mContentHint(std::move(aContentHint)) {}
+
+VideoEncoderConfigInternal::VideoEncoderConfigInternal(
+ const VideoEncoderConfigInternal& aConfig)
+ : mCodec(aConfig.mCodec),
+ mWidth(aConfig.mWidth),
+ mHeight(aConfig.mHeight),
+ mDisplayWidth(aConfig.mDisplayWidth),
+ mDisplayHeight(aConfig.mDisplayHeight),
+ mBitrate(aConfig.mBitrate),
+ mFramerate(aConfig.mFramerate),
+ mHardwareAcceleration(aConfig.mHardwareAcceleration),
+ mAlpha(aConfig.mAlpha),
+ mScalabilityMode(aConfig.mScalabilityMode),
+ mBitrateMode(aConfig.mBitrateMode),
+ mLatencyMode(aConfig.mLatencyMode),
+ mContentHint(aConfig.mContentHint),
+ mAvc(aConfig.mAvc) {
+}
+
+VideoEncoderConfigInternal::VideoEncoderConfigInternal(
+ const VideoEncoderConfig& aConfig)
+ : mCodec(aConfig.mCodec),
+ mWidth(aConfig.mWidth),
+ mHeight(aConfig.mHeight),
+ mDisplayWidth(OptionalToMaybe(aConfig.mDisplayWidth)),
+ mDisplayHeight(OptionalToMaybe(aConfig.mDisplayHeight)),
+ mBitrate(OptionalToMaybe(aConfig.mBitrate)),
+ mFramerate(OptionalToMaybe(aConfig.mFramerate)),
+ mHardwareAcceleration(aConfig.mHardwareAcceleration),
+ mAlpha(aConfig.mAlpha),
+ mScalabilityMode(OptionalToMaybe(aConfig.mScalabilityMode)),
+ mBitrateMode(aConfig.mBitrateMode),
+ mLatencyMode(aConfig.mLatencyMode),
+ mContentHint(OptionalToMaybe(aConfig.mContentHint)),
+ mAvc(OptionalToMaybe(aConfig.mAvc)) {
+}
+
+nsString VideoEncoderConfigInternal::ToString() const {
+ nsString rv;
+
+ rv.AppendPrintf("Codec: %s, [%" PRIu32 "x%" PRIu32 "],",
+ NS_ConvertUTF16toUTF8(mCodec).get(), mWidth, mHeight);
+ if (mDisplayWidth.isSome()) {
+ rv.AppendPrintf(", display[%" PRIu32 "x%" PRIu32 "]", mDisplayWidth.value(),
+ mDisplayHeight.value());
+ }
+ if (mBitrate.isSome()) {
+ rv.AppendPrintf(", %" PRIu32 "kbps", mBitrate.value());
+ }
+ if (mFramerate.isSome()) {
+ rv.AppendPrintf(", %lfHz", mFramerate.value());
+ }
+ rv.AppendPrintf(
+ " hw: %s",
+ HardwareAccelerationValues::GetString(mHardwareAcceleration).data());
+ rv.AppendPrintf(", alpha: %s", AlphaOptionValues::GetString(mAlpha).data());
+ if (mScalabilityMode.isSome()) {
+ rv.AppendPrintf(", scalability mode: %s",
+ NS_ConvertUTF16toUTF8(mScalabilityMode.value()).get());
+ }
+ rv.AppendPrintf(
+ ", bitrate mode: %s",
+ VideoEncoderBitrateModeValues::GetString(mBitrateMode).data());
+ rv.AppendPrintf(", latency mode: %s",
+ LatencyModeValues::GetString(mLatencyMode).data());
+ if (mContentHint.isSome()) {
+ rv.AppendPrintf(", content hint: %s",
+ NS_ConvertUTF16toUTF8(mContentHint.value()).get());
+ }
+ if (mAvc.isSome()) {
+ rv.AppendPrintf(", avc-specific: %s",
+ AvcBitstreamFormatValues::GetString(mAvc->mFormat).data());
+ }
+
+ return rv;
+}
+
+template <typename T>
+bool MaybeAreEqual(const Maybe<T>& aLHS, const Maybe<T> aRHS) {
+ if (aLHS.isSome() && aRHS.isSome()) {
+ return aLHS.value() == aRHS.value();
+ }
+ if (aLHS.isNothing() && aRHS.isNothing()) {
+ return true;
+ }
+ return false;
+}
+
+bool VideoEncoderConfigInternal::Equals(
+ const VideoEncoderConfigInternal& aOther) const {
+ bool sameCodecSpecific = true;
+ if ((mAvc.isSome() && aOther.mAvc.isSome() &&
+ mAvc->mFormat != aOther.mAvc->mFormat) ||
+ mAvc.isSome() != aOther.mAvc.isSome()) {
+ sameCodecSpecific = false;
+ }
+ return mCodec.Equals(aOther.mCodec) && mWidth == aOther.mWidth &&
+ mHeight == aOther.mHeight &&
+ MaybeAreEqual(mDisplayWidth, aOther.mDisplayWidth) &&
+ MaybeAreEqual(mDisplayHeight, aOther.mDisplayHeight) &&
+ MaybeAreEqual(mBitrate, aOther.mBitrate) &&
+ MaybeAreEqual(mFramerate, aOther.mFramerate) &&
+ mHardwareAcceleration == aOther.mHardwareAcceleration &&
+ mAlpha == aOther.mAlpha &&
+ MaybeAreEqual(mScalabilityMode, aOther.mScalabilityMode) &&
+ mBitrateMode == aOther.mBitrateMode &&
+ mLatencyMode == aOther.mLatencyMode &&
+ MaybeAreEqual(mContentHint, aOther.mContentHint) && sameCodecSpecific;
+}
+
+bool VideoEncoderConfigInternal::CanReconfigure(
+ const VideoEncoderConfigInternal& aOther) const {
+ return mCodec.Equals(aOther.mCodec) &&
+ mHardwareAcceleration == aOther.mHardwareAcceleration;
+}
+
+EncoderConfig VideoEncoderConfigInternal::ToEncoderConfig() const {
+ MediaDataEncoder::Usage usage;
+ if (mLatencyMode == LatencyMode::Quality) {
+ usage = MediaDataEncoder::Usage::Record;
+ } else {
+ usage = MediaDataEncoder::Usage::Realtime;
+ }
+ MediaDataEncoder::HardwarePreference hwPref =
+ MediaDataEncoder::HardwarePreference::None;
+ if (mHardwareAcceleration ==
+ mozilla::dom::HardwareAcceleration::Prefer_hardware) {
+ hwPref = MediaDataEncoder::HardwarePreference::RequireHardware;
+ } else if (mHardwareAcceleration ==
+ mozilla::dom::HardwareAcceleration::Prefer_software) {
+ hwPref = MediaDataEncoder::HardwarePreference::RequireSoftware;
+ }
+ CodecType codecType;
+ auto maybeCodecType = CodecStringToCodecType(mCodec);
+ if (maybeCodecType.isSome()) {
+ codecType = maybeCodecType.value();
+ } else {
+ MOZ_CRASH("The string should always contain a valid codec at this point.");
+ }
+ Maybe<EncoderConfig::CodecSpecific> specific;
+ if (codecType == CodecType::H264) {
+ uint8_t profile, constraints, level;
+ H264BitStreamFormat format;
+ if (mAvc) {
+ format = mAvc->mFormat == AvcBitstreamFormat::Annexb
+ ? H264BitStreamFormat::ANNEXB
+ : H264BitStreamFormat::AVC;
+ } else {
+ format = H264BitStreamFormat::AVC;
+ }
+ if (ExtractH264CodecDetails(mCodec, profile, constraints, level)) {
+ if (profile == H264_PROFILE_BASE || profile == H264_PROFILE_MAIN ||
+ profile == H264_PROFILE_EXTENDED || profile == H264_PROFILE_HIGH) {
+ specific.emplace(
+ H264Specific(static_cast<H264_PROFILE>(profile), static_cast<H264_LEVEL>(level), format));
+ }
+ }
+ }
+ // Only for vp9, not vp8
+ if (codecType == CodecType::VP9) {
+ uint8_t profile, level, bitdepth, chromasubsampling;
+ mozilla::VideoColorSpace colorspace;
+ DebugOnly<bool> rv = ExtractVPXCodecDetails(
+ mCodec, profile, level, bitdepth, chromasubsampling, colorspace);
+#ifdef DEBUG
+ if (!rv) {
+ LOGE("Error extracting VPX codec details, non fatal");
+ }
+#endif
+ specific.emplace(VP9Specific());
+ }
+ MediaDataEncoder::ScalabilityMode scalabilityMode;
+ if (mScalabilityMode) {
+ if (mScalabilityMode->EqualsLiteral("L1T2")) {
+ scalabilityMode = MediaDataEncoder::ScalabilityMode::L1T2;
+ } else if (mScalabilityMode->EqualsLiteral("L1T3")) {
+ scalabilityMode = MediaDataEncoder::ScalabilityMode::L1T3;
+ } else {
+ scalabilityMode = MediaDataEncoder::ScalabilityMode::None;
+ }
+ } else {
+ scalabilityMode = MediaDataEncoder::ScalabilityMode::None;
+ }
+ return EncoderConfig(
+ codecType, {mWidth, mHeight}, usage, ImageBitmapFormat::RGBA32, ImageBitmapFormat::RGBA32,
+ AssertedCast<uint8_t>(mFramerate.refOr(0.f)), 0, mBitrate.refOr(0),
+ mBitrateMode == VideoEncoderBitrateMode::Constant
+ ? MediaDataEncoder::BitrateMode::Constant
+ : MediaDataEncoder::BitrateMode::Variable,
+ hwPref, scalabilityMode, specific);
+}
+already_AddRefed<WebCodecsConfigurationChangeList>
+VideoEncoderConfigInternal::Diff(
+ const VideoEncoderConfigInternal& aOther) const {
+ auto list = MakeRefPtr<WebCodecsConfigurationChangeList>();
+ if (!mCodec.Equals(aOther.mCodec)) {
+ list->Push(CodecChange{aOther.mCodec});
+ }
+ // Both must always be present, when a `VideoEncoderConfig` is passed to
+ // `configure`.
+ if (mWidth != aOther.mWidth || mHeight != aOther.mHeight) {
+ list->Push(DimensionsChange{gfx::IntSize{aOther.mWidth, aOther.mHeight}});
+ }
+ // Similarly, both must always be present, when a `VideoEncoderConfig` is
+ // passed to `configure`.
+ if (!MaybeAreEqual(mDisplayWidth, aOther.mDisplayWidth) ||
+ !MaybeAreEqual(mDisplayHeight, aOther.mDisplayHeight)) {
+ Maybe<gfx::IntSize> displaySize =
+ aOther.mDisplayWidth.isSome()
+ ? Some(gfx::IntSize{aOther.mDisplayWidth.value(),
+ aOther.mDisplayHeight.value()})
+ : Nothing();
+ list->Push(DisplayDimensionsChange{displaySize});
+ }
+ if (!MaybeAreEqual(mBitrate, aOther.mBitrate)) {
+ list->Push(BitrateChange{aOther.mBitrate});
+ }
+ if (!MaybeAreEqual(mFramerate, aOther.mFramerate)) {
+ list->Push(FramerateChange{aOther.mFramerate});
+ }
+ if (mHardwareAcceleration != aOther.mHardwareAcceleration) {
+ list->Push(HardwareAccelerationChange{aOther.mHardwareAcceleration});
+ }
+ if (mAlpha != aOther.mAlpha) {
+ list->Push(AlphaChange{aOther.mAlpha});
+ }
+ if (!MaybeAreEqual(mScalabilityMode, aOther.mScalabilityMode)) {
+ list->Push(ScalabilityModeChange{aOther.mScalabilityMode});
+ }
+ if (mBitrateMode != aOther.mBitrateMode) {
+ list->Push(BitrateModeChange{aOther.mBitrateMode});
+ }
+ if (mLatencyMode != aOther.mLatencyMode) {
+ list->Push(LatencyModeChange{aOther.mLatencyMode});
+ }
+ if (!MaybeAreEqual(mContentHint, aOther.mContentHint)) {
+ list->Push(ContentHintChange{aOther.mContentHint});
+ }
+ return list.forget();
+}
+
+/*
+ * The followings are helpers for VideoEncoder methods
+ */
+static bool IsEncodeSupportedCodec(const nsAString& aCodec) {
+ LOG("IsEncodeSupported: %s", NS_ConvertUTF16toUTF8(aCodec).get());
+ if (!IsVP9CodecString(aCodec) && !IsVP8CodecString(aCodec) &&
+ !IsH264CodecString(aCodec) && !IsAV1CodecString(aCodec)) {
+ return false;
+ }
+
+ // Gecko allows codec string starts with vp9 or av1 but Webcodecs requires to
+ // starts with av01 and vp09.
+ // https://www.w3.org/TR/webcodecs-codec-registry/#video-codec-registry
+ if (StringBeginsWith(aCodec, u"vp9"_ns) ||
+ StringBeginsWith(aCodec, u"av1"_ns)) {
+ return false;
+ }
+
+ return true;
+}
+
+// https://w3c.github.io/webcodecs/#check-configuration-support
+static bool CanEncode(const RefPtr<VideoEncoderConfigInternal>& aConfig) {
+ auto parsedCodecString =
+ ParseCodecString(aConfig->mCodec).valueOr(EmptyString());
+ // TODO: Enable WebCodecs on Android (Bug 1840508)
+ if (IsOnAndroid()) {
+ return false;
+ }
+ if (!IsEncodeSupportedCodec(parsedCodecString)) {
+ return false;
+ }
+
+ // TODO (bug 1872879, bug 1872880): Support this on Windows and Mac.
+ if (aConfig->mScalabilityMode.isSome()) {
+ // We only support L1T2 and L1T3 ScalabilityMode in VP8 and VP9 encoders on
+ // Linux.
+ bool supported = IsOnLinux() && (IsVP8CodecString(parsedCodecString) ||
+ IsVP9CodecString(parsedCodecString))
+ ? aConfig->mScalabilityMode->EqualsLiteral("L1T2") ||
+ aConfig->mScalabilityMode->EqualsLiteral("L1T3")
+ : false;
+
+ if (!supported) {
+ LOGE("Scalability mode %s not supported for codec: %s",
+ NS_ConvertUTF16toUTF8(aConfig->mScalabilityMode.value()).get(),
+ NS_ConvertUTF16toUTF8(parsedCodecString).get());
+ return false;
+ }
+ }
+
+ return EncoderSupport::Supports(aConfig);
+}
+
+static Result<Ok, nsresult> CloneConfiguration(
+ VideoEncoderConfig& aDest, JSContext* aCx,
+ const VideoEncoderConfig& aConfig) {
+ nsCString errorMessage;
+ MOZ_ASSERT(VideoEncoderTraits::Validate(aConfig, errorMessage));
+
+ aDest.mCodec = aConfig.mCodec;
+ aDest.mWidth = aConfig.mWidth;
+ aDest.mHeight = aConfig.mHeight;
+ aDest.mAlpha = aConfig.mAlpha;
+ if (aConfig.mBitrate.WasPassed()) {
+ aDest.mBitrate.Construct(aConfig.mBitrate.Value());
+ }
+ aDest.mBitrateMode = aConfig.mBitrateMode;
+ if (aConfig.mContentHint.WasPassed()) {
+ aDest.mContentHint.Construct(aConfig.mContentHint.Value());
+ }
+ if (aConfig.mDisplayWidth.WasPassed()) {
+ aDest.mDisplayWidth.Construct(aConfig.mDisplayWidth.Value());
+ }
+ if (aConfig.mDisplayHeight.WasPassed()) {
+ aDest.mDisplayHeight.Construct(aConfig.mDisplayHeight.Value());
+ }
+ if (aConfig.mFramerate.WasPassed()) {
+ aDest.mFramerate.Construct(aConfig.mFramerate.Value());
+ }
+ aDest.mHardwareAcceleration = aConfig.mHardwareAcceleration;
+ aDest.mLatencyMode = aConfig.mLatencyMode;
+ if (aConfig.mScalabilityMode.WasPassed()) {
+ aDest.mScalabilityMode.Construct(aConfig.mScalabilityMode.Value());
+ }
+
+ // AVC specific
+ if (aConfig.mAvc.WasPassed()) {
+ aDest.mAvc.Construct(aConfig.mAvc.Value());
+ }
+
+ return Ok();
+}
+
+/* static */
+bool VideoEncoderTraits::IsSupported(
+ const VideoEncoderConfigInternal& aConfig) {
+ return CanEncode(MakeRefPtr<VideoEncoderConfigInternal>(aConfig));
+}
+
+// https://w3c.github.io/webcodecs/#valid-videoencoderconfig
+/* static */
+bool VideoEncoderTraits::Validate(const VideoEncoderConfig& aConfig,
+ nsCString& aErrorMessage) {
+ Maybe<nsString> codec = ParseCodecString(aConfig.mCodec);
+ // 1.
+ if (!codec || codec->IsEmpty()) {
+ LOGE("Invalid VideoEncoderConfig: invalid codec string");
+ return false;
+ }
+
+ // 2.
+ if (aConfig.mWidth == 0 || aConfig.mHeight == 0) {
+ LOGE("Invalid VideoEncoderConfig: %s equal to 0",
+ aConfig.mWidth == 0 ? "width" : "height");
+ return false;
+ }
+
+ // 3.
+ if ((aConfig.mDisplayWidth.WasPassed() &&
+ aConfig.mDisplayWidth.Value() == 0)) {
+ LOGE("Invalid VideoEncoderConfig: displayWidth equal to 0");
+ return false;
+ }
+ if ((aConfig.mDisplayHeight.WasPassed() &&
+ aConfig.mDisplayHeight.Value() == 0)) {
+ LOGE("Invalid VideoEncoderConfig: displayHeight equal to 0");
+ return false;
+ }
+
+ return true;
+}
+
+/* static */
+RefPtr<VideoEncoderConfigInternal> VideoEncoderTraits::CreateConfigInternal(
+ const VideoEncoderConfig& aConfig) {
+ return MakeRefPtr<VideoEncoderConfigInternal>(aConfig);
+}
+
+/* static */
+RefPtr<mozilla::VideoData> VideoEncoderTraits::CreateInputInternal(
+ const dom::VideoFrame& aInput,
+ const dom::VideoEncoderEncodeOptions& aOptions) {
+ media::TimeUnit duration =
+ aInput.GetDuration().IsNull()
+ ? media::TimeUnit::Zero()
+ : media::TimeUnit::FromMicroseconds(
+ AssertedCast<int64_t>(aInput.GetDuration().Value()));
+ media::TimeUnit pts = media::TimeUnit::FromMicroseconds(aInput.Timestamp());
+ return VideoData::CreateFromImage(
+ gfx::IntSize{aInput.DisplayWidth(), aInput.DisplayHeight()},
+ 0 /* bytestream offset */, pts, duration, aInput.GetImage(),
+ aOptions.mKeyFrame, pts);
+}
+
+/*
+ * Below are VideoEncoder implementation
+ */
+
+VideoEncoder::VideoEncoder(
+ nsIGlobalObject* aParent, RefPtr<WebCodecsErrorCallback>&& aErrorCallback,
+ RefPtr<EncodedVideoChunkOutputCallback>&& aOutputCallback)
+ : EncoderTemplate(aParent, std::move(aErrorCallback),
+ std::move(aOutputCallback)) {
+ MOZ_ASSERT(mErrorCallback);
+ MOZ_ASSERT(mOutputCallback);
+ LOG("VideoEncoder %p ctor", this);
+}
+
+VideoEncoder::~VideoEncoder() {
+ LOG("VideoEncoder %p dtor", this);
+ Unused << ResetInternal(NS_ERROR_DOM_ABORT_ERR);
+}
+
+JSObject* VideoEncoder::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ AssertIsOnOwningThread();
+
+ return VideoEncoder_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoencoder-videoencoder
+/* static */
+already_AddRefed<VideoEncoder> VideoEncoder::Constructor(
+ const GlobalObject& aGlobal, const VideoEncoderInit& aInit,
+ ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ return MakeAndAddRef<VideoEncoder>(
+ global.get(), RefPtr<WebCodecsErrorCallback>(aInit.mError),
+ RefPtr<EncodedVideoChunkOutputCallback>(aInit.mOutput));
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoencoder-isconfigsupported
+/* static */
+already_AddRefed<Promise> VideoEncoder::IsConfigSupported(
+ const GlobalObject& aGlobal, const VideoEncoderConfig& aConfig,
+ ErrorResult& aRv) {
+ LOG("VideoEncoder::IsConfigSupported, config: %s",
+ NS_ConvertUTF16toUTF8(aConfig.mCodec).get());
+
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ RefPtr<Promise> p = Promise::Create(global.get(), aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return p.forget();
+ }
+
+ nsCString errorMessage;
+ if (!VideoEncoderTraits::Validate(aConfig, errorMessage)) {
+ p->MaybeRejectWithTypeError(nsPrintfCString(
+ "IsConfigSupported: config is invalid: %s", errorMessage.get()));
+ return p.forget();
+ }
+
+ // TODO: Move the following works to another thread to unblock the current
+ // thread, as what spec suggests.
+
+ VideoEncoderConfig config;
+ auto r = CloneConfiguration(config, aGlobal.Context(), aConfig);
+ if (r.isErr()) {
+ nsresult e = r.unwrapErr();
+ LOGE("Failed to clone VideoEncoderConfig. Error: 0x%08" PRIx32,
+ static_cast<uint32_t>(e));
+ p->MaybeRejectWithTypeError("Failed to clone VideoEncoderConfig");
+ aRv.Throw(e);
+ return p.forget();
+ }
+
+ bool canEncode = CanEncode(MakeRefPtr<VideoEncoderConfigInternal>(config));
+ VideoEncoderSupport s;
+ s.mConfig.Construct(std::move(config));
+ s.mSupported.Construct(canEncode);
+
+ p->MaybeResolve(s);
+ return p.forget();
+}
+
+RefPtr<EncodedVideoChunk> VideoEncoder::EncodedDataToOutputType(
+ nsIGlobalObject* aGlobalObject, RefPtr<MediaRawData>& aData) {
+ AssertIsOnOwningThread();
+
+ MOZ_RELEASE_ASSERT(aData->mType == MediaData::Type::RAW_DATA);
+ // Package into an EncodedVideoChunk
+ auto buffer =
+ MakeRefPtr<MediaAlignedByteBuffer>(aData->Data(), aData->Size());
+ auto encodedVideoChunk = MakeRefPtr<EncodedVideoChunk>(
+ aGlobalObject, buffer.forget(),
+ aData->mKeyframe ? EncodedVideoChunkType::Key
+ : EncodedVideoChunkType::Delta,
+ aData->mTime.ToMicroseconds(),
+ aData->mDuration.IsZero() ? Nothing()
+ : Some(aData->mDuration.ToMicroseconds()));
+ return encodedVideoChunk;
+}
+
+VideoDecoderConfigInternal VideoEncoder::EncoderConfigToDecoderConfig(
+ nsIGlobalObject* aGlobal, const RefPtr<MediaRawData>& aRawData,
+ const VideoEncoderConfigInternal& mOutputConfig) const {
+ // Colorspace is mandatory when outputing a decoder config after encode
+ VideoColorSpaceInternal init;
+ init.mFullRange.emplace(false);
+ init.mMatrix.emplace(VideoMatrixCoefficients::Bt709);
+ init.mPrimaries.emplace(VideoColorPrimaries::Bt709);
+ init.mTransfer.emplace(VideoTransferCharacteristics::Bt709);
+
+ return VideoDecoderConfigInternal(
+ mOutputConfig.mCodec, /* aCodec */
+ Some(mOutputConfig.mHeight), /* aCodedHeight */
+ Some(mOutputConfig.mWidth), /* aCodedWidth */
+ Some(init), /* aColorSpace */
+ aRawData->mExtraData && !aRawData->mExtraData->IsEmpty()
+ ? Some(aRawData->mExtraData)
+ : Nothing(), /* aDescription*/
+ Maybe<uint32_t>(mOutputConfig.mDisplayHeight), /* aDisplayAspectHeight*/
+ Maybe<uint32_t>(mOutputConfig.mDisplayWidth), /* aDisplayAspectWidth */
+ mOutputConfig.mHardwareAcceleration, /* aHardwareAcceleration */
+ Nothing() /* aOptimizeForLatency */
+ );
+}
+
+#undef LOG
+#undef LOGW
+#undef LOGE
+#undef LOGV
+#undef LOG_INTERNAL
+
+} // namespace mozilla::dom
diff --git a/dom/media/webcodecs/VideoEncoder.h b/dom/media/webcodecs/VideoEncoder.h
new file mode 100644
index 0000000000..9251b5023a
--- /dev/null
+++ b/dom/media/webcodecs/VideoEncoder.h
@@ -0,0 +1,78 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_VideoEncoder_h
+#define mozilla_dom_VideoEncoder_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/EncoderTemplate.h"
+#include "mozilla/dom/EncoderTypes.h"
+#include "mozilla/dom/VideoFrame.h"
+#include "nsCycleCollectionParticipant.h"
+
+class nsIGlobalObject;
+
+namespace mozilla {
+
+namespace dom {
+
+class EncodedVideoChunk;
+class EncodedVideoChunkData;
+class EventHandlerNonNull;
+class GlobalObject;
+class Promise;
+class VideoFrameOutputCallback;
+class WebCodecsErrorCallback;
+struct VideoEncoderConfig;
+struct VideoEncoderInit;
+
+} // namespace dom
+
+} // namespace mozilla
+
+namespace mozilla::dom {
+
+class VideoEncoder final : public EncoderTemplate<VideoEncoderTraits> {
+ public:
+ NS_DECL_ISUPPORTS_INHERITED
+ NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(VideoEncoder, DOMEventTargetHelper)
+
+ public:
+ VideoEncoder(nsIGlobalObject* aParent,
+ RefPtr<WebCodecsErrorCallback>&& aErrorCallback,
+ RefPtr<EncodedVideoChunkOutputCallback>&& aOutputCallback);
+
+ protected:
+ ~VideoEncoder();
+
+ public:
+ JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ static already_AddRefed<VideoEncoder> Constructor(
+ const GlobalObject& aGlobal, const VideoEncoderInit& aInit,
+ ErrorResult& aRv);
+
+ static already_AddRefed<Promise> IsConfigSupported(
+ const GlobalObject& aGlobal, const VideoEncoderConfig& aConfig,
+ ErrorResult& aRv);
+
+ protected:
+ virtual RefPtr<EncodedVideoChunk> EncodedDataToOutputType(
+ nsIGlobalObject* aGlobal, RefPtr<MediaRawData>& aData) override;
+
+ virtual VideoDecoderConfigInternal EncoderConfigToDecoderConfig(
+ nsIGlobalObject* aGlobal /* TODO: delete */,
+ const RefPtr<MediaRawData>& aRawData,
+ const VideoEncoderConfigInternal& mOutputConfig) const override;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_VideoEncoder_h
diff --git a/dom/media/webcodecs/VideoFrame.cpp b/dom/media/webcodecs/VideoFrame.cpp
new file mode 100644
index 0000000000..602bc95c29
--- /dev/null
+++ b/dom/media/webcodecs/VideoFrame.cpp
@@ -0,0 +1,2417 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "mozilla/dom/VideoFrame.h"
+#include "mozilla/dom/VideoFrameBinding.h"
+
+#include <math.h>
+#include <limits>
+#include <utility>
+
+#include "ImageContainer.h"
+#include "VideoColorSpace.h"
+#include "WebCodecsUtils.h"
+#include "js/StructuredClone.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/ResultVariant.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/Try.h"
+
+#include "mozilla/UniquePtr.h"
+#include "mozilla/dom/CanvasUtils.h"
+#include "mozilla/dom/DOMRect.h"
+#include "mozilla/dom/HTMLCanvasElement.h"
+#include "mozilla/dom/HTMLImageElement.h"
+#include "mozilla/dom/HTMLVideoElement.h"
+#include "mozilla/dom/ImageBitmap.h"
+#include "mozilla/dom/ImageUtils.h"
+#include "mozilla/dom/OffscreenCanvas.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/SVGImageElement.h"
+#include "mozilla/dom/StructuredCloneHolder.h"
+#include "mozilla/dom/StructuredCloneTags.h"
+#include "mozilla/dom/UnionTypes.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Swizzle.h"
+#include "mozilla/layers/LayersSurfaces.h"
+#include "nsLayoutUtils.h"
+#include "nsIPrincipal.h"
+#include "nsIURI.h"
+
+extern mozilla::LazyLogModule gWebCodecsLog;
+
+namespace mozilla::dom {
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+
+#ifdef LOG
+# undef LOG
+#endif // LOG
+#define LOG(msg, ...) LOG_INTERNAL(Debug, msg, ##__VA_ARGS__)
+
+#ifdef LOGW
+# undef LOGW
+#endif // LOGW
+#define LOGW(msg, ...) LOG_INTERNAL(Warning, msg, ##__VA_ARGS__)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(VideoFrame)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(VideoFrame)
+ tmp->CloseIfNeeded();
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(VideoFrame)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(VideoFrame)
+// VideoFrame should be released as soon as its refcount drops to zero,
+// without waiting for async deletion by the cycle collector, since it may hold
+// a large-size image.
+NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(VideoFrame, CloseIfNeeded())
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(VideoFrame)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+/*
+ * The following are helpers to read the image data from the given buffer and
+ * the format. The data layout is illustrated in the comments for
+ * `VideoFrame::Format` below.
+ */
+
+static int32_t CeilingOfHalf(int32_t aValue) {
+ MOZ_ASSERT(aValue >= 0);
+ return aValue / 2 + (aValue % 2);
+}
+
+class YUVBufferReaderBase {
+ public:
+ YUVBufferReaderBase(const Span<uint8_t>& aBuffer, int32_t aWidth,
+ int32_t aHeight)
+ : mWidth(aWidth), mHeight(aHeight), mStrideY(aWidth), mBuffer(aBuffer) {}
+ virtual ~YUVBufferReaderBase() = default;
+
+ const uint8_t* DataY() const { return mBuffer.data(); }
+ const int32_t mWidth;
+ const int32_t mHeight;
+ const int32_t mStrideY;
+
+ protected:
+ CheckedInt<size_t> YByteSize() const {
+ return CheckedInt<size_t>(mStrideY) * mHeight;
+ }
+
+ const Span<uint8_t> mBuffer;
+};
+
+class I420ABufferReader;
+class I420BufferReader : public YUVBufferReaderBase {
+ public:
+ I420BufferReader(const Span<uint8_t>& aBuffer, int32_t aWidth,
+ int32_t aHeight)
+ : YUVBufferReaderBase(aBuffer, aWidth, aHeight),
+ mStrideU(CeilingOfHalf(aWidth)),
+ mStrideV(CeilingOfHalf(aWidth)) {}
+ virtual ~I420BufferReader() = default;
+
+ const uint8_t* DataU() const { return &mBuffer[YByteSize().value()]; }
+ const uint8_t* DataV() const {
+ return &mBuffer[YByteSize().value() + UByteSize().value()];
+ }
+ virtual I420ABufferReader* AsI420ABufferReader() { return nullptr; }
+
+ const int32_t mStrideU;
+ const int32_t mStrideV;
+
+ protected:
+ CheckedInt<size_t> UByteSize() const {
+ return CheckedInt<size_t>(CeilingOfHalf(mHeight)) * mStrideU;
+ }
+
+ CheckedInt<size_t> VSize() const {
+ return CheckedInt<size_t>(CeilingOfHalf(mHeight)) * mStrideV;
+ }
+};
+
+class I420ABufferReader final : public I420BufferReader {
+ public:
+ I420ABufferReader(const Span<uint8_t>& aBuffer, int32_t aWidth,
+ int32_t aHeight)
+ : I420BufferReader(aBuffer, aWidth, aHeight), mStrideA(aWidth) {
+ MOZ_ASSERT(mStrideA == mStrideY);
+ }
+ virtual ~I420ABufferReader() = default;
+
+ const uint8_t* DataA() const {
+ return &mBuffer[YByteSize().value() + UByteSize().value() +
+ VSize().value()];
+ }
+
+ virtual I420ABufferReader* AsI420ABufferReader() override { return this; }
+
+ const int32_t mStrideA;
+};
+
+class NV12BufferReader final : public YUVBufferReaderBase {
+ public:
+ NV12BufferReader(const Span<uint8_t>& aBuffer, int32_t aWidth,
+ int32_t aHeight)
+ : YUVBufferReaderBase(aBuffer, aWidth, aHeight),
+ mStrideUV(aWidth + aWidth % 2) {}
+ virtual ~NV12BufferReader() = default;
+
+ const uint8_t* DataUV() const { return &mBuffer[YByteSize().value()]; }
+
+ const int32_t mStrideUV;
+};
+
+/*
+ * The followings are helpers defined in
+ * https://w3c.github.io/webcodecs/#videoframe-algorithms
+ */
+
+static bool IsSameOrigin(nsIGlobalObject* aGlobal, const VideoFrame& aFrame) {
+ MOZ_ASSERT(aGlobal);
+ MOZ_ASSERT(aFrame.GetParentObject());
+
+ nsIPrincipal* principalX = aGlobal->PrincipalOrNull();
+ nsIPrincipal* principalY = aFrame.GetParentObject()->PrincipalOrNull();
+
+ // If both of VideoFrames are created in worker, they are in the same origin
+ // domain.
+ if (!principalX) {
+ return !principalY;
+ }
+ // Otherwise, check their domains.
+ return principalX->Equals(principalY);
+}
+
+static bool IsSameOrigin(nsIGlobalObject* aGlobal,
+ HTMLVideoElement& aVideoElement) {
+ MOZ_ASSERT(aGlobal);
+
+ // If CORS is in use, consider the video source is same-origin.
+ if (aVideoElement.GetCORSMode() != CORS_NONE) {
+ return true;
+ }
+
+ // Otherwise, check if video source has cross-origin redirect or not.
+ if (aVideoElement.HadCrossOriginRedirects()) {
+ return false;
+ }
+
+ // Finally, compare the VideoFrame's domain and video's one.
+ nsIPrincipal* principal = aGlobal->PrincipalOrNull();
+ nsCOMPtr<nsIPrincipal> elementPrincipal =
+ aVideoElement.GetCurrentVideoPrincipal();
+ // <video> cannot be created in worker, so it should have a valid principal.
+ if (NS_WARN_IF(!elementPrincipal) || !principal) {
+ return false;
+ }
+ return principal->Subsumes(elementPrincipal);
+}
+
+// A sub-helper to convert DOMRectInit to gfx::IntRect.
+static Result<gfx::IntRect, nsCString> ToIntRect(const DOMRectInit& aRectInit) {
+ auto EQ = [](const double& a, const double& b) {
+ constexpr double e = std::numeric_limits<double>::epsilon();
+ return std::fabs(a - b) <= e;
+ };
+ auto GT = [&](const double& a, const double& b) {
+ return !EQ(a, b) && a > b;
+ };
+
+ // Make sure the double values are in the gfx::IntRect's valid range, before
+ // checking the spec's valid range. The double's infinity value is larger than
+ // gfx::IntRect's max value so it will be filtered out here.
+ constexpr double MAX = static_cast<double>(
+ std::numeric_limits<decltype(gfx::IntRect::x)>::max());
+ constexpr double MIN = static_cast<double>(
+ std::numeric_limits<decltype(gfx::IntRect::x)>::min());
+ if (GT(aRectInit.mX, MAX) || GT(MIN, aRectInit.mX)) {
+ return Err(nsCString("x is out of the valid range"));
+ }
+ if (GT(aRectInit.mY, MAX) || GT(MIN, aRectInit.mY)) {
+ return Err(nsCString("y is out of the valid range"));
+ }
+ if (GT(aRectInit.mWidth, MAX) || GT(MIN, aRectInit.mWidth)) {
+ return Err(nsCString("width is out of the valid range"));
+ }
+ if (GT(aRectInit.mHeight, MAX) || GT(MIN, aRectInit.mHeight)) {
+ return Err(nsCString("height is out of the valid range"));
+ }
+
+ gfx::IntRect rect(
+ static_cast<decltype(gfx::IntRect::x)>(aRectInit.mX),
+ static_cast<decltype(gfx::IntRect::y)>(aRectInit.mY),
+ static_cast<decltype(gfx::IntRect::width)>(aRectInit.mWidth),
+ static_cast<decltype(gfx::IntRect::height)>(aRectInit.mHeight));
+ // Check the spec's valid range.
+ if (rect.X() < 0) {
+ return Err(nsCString("x must be non-negative"));
+ }
+ if (rect.Y() < 0) {
+ return Err(nsCString("y must be non-negative"));
+ }
+ if (rect.Width() <= 0) {
+ return Err(nsCString("width must be positive"));
+ }
+ if (rect.Height() <= 0) {
+ return Err(nsCString("height must be positive"));
+ }
+
+ return rect;
+}
+
+// A sub-helper to convert a (width, height) pair to gfx::IntRect.
+static Result<gfx::IntSize, nsCString> ToIntSize(const uint32_t& aWidth,
+ const uint32_t& aHeight) {
+ // Make sure the given values are in the gfx::IntSize's valid range, before
+ // checking the spec's valid range.
+ constexpr uint32_t MAX = static_cast<uint32_t>(
+ std::numeric_limits<decltype(gfx::IntRect::width)>::max());
+ if (aWidth > MAX) {
+ return Err(nsCString("Width exceeds the implementation's range"));
+ }
+ if (aHeight > MAX) {
+ return Err(nsCString("Height exceeds the implementation's range"));
+ }
+
+ gfx::IntSize size(static_cast<decltype(gfx::IntRect::width)>(aWidth),
+ static_cast<decltype(gfx::IntRect::height)>(aHeight));
+ // Check the spec's valid range.
+ if (size.Width() <= 0) {
+ return Err(nsCString("Width must be positive"));
+ }
+ if (size.Height() <= 0) {
+ return Err(nsCString("Height must be positive"));
+ }
+ return size;
+}
+
+// A sub-helper to make sure visible range is in the picture.
+static Result<Ok, nsCString> ValidateVisibility(
+ const gfx::IntRect& aVisibleRect, const gfx::IntSize& aPicSize) {
+ MOZ_ASSERT(aVisibleRect.X() >= 0);
+ MOZ_ASSERT(aVisibleRect.Y() >= 0);
+ MOZ_ASSERT(aVisibleRect.Width() > 0);
+ MOZ_ASSERT(aVisibleRect.Height() > 0);
+
+ const auto w = CheckedInt<uint32_t>(aVisibleRect.Width()) + aVisibleRect.X();
+ if (w.value() > static_cast<uint32_t>(aPicSize.Width())) {
+ return Err(nsCString(
+ "Sum of visible rectangle's x and width exceeds the picture's width"));
+ }
+
+ const auto h = CheckedInt<uint32_t>(aVisibleRect.Height()) + aVisibleRect.Y();
+ if (h.value() > static_cast<uint32_t>(aPicSize.Height())) {
+ return Err(
+ nsCString("Sum of visible rectangle's y and height exceeds the "
+ "picture's height"));
+ }
+
+ return Ok();
+}
+
+// A sub-helper to check and get display{Width, Height} in
+// VideoFrame(Buffer)Init.
+template <class T>
+static Result<Maybe<gfx::IntSize>, nsCString> MaybeGetDisplaySize(
+ const T& aInit) {
+ if (aInit.mDisplayWidth.WasPassed() != aInit.mDisplayHeight.WasPassed()) {
+ return Err(nsCString(
+ "displayWidth and displayHeight cannot be set without the other"));
+ }
+
+ Maybe<gfx::IntSize> displaySize;
+ if (aInit.mDisplayWidth.WasPassed() && aInit.mDisplayHeight.WasPassed()) {
+ displaySize.emplace();
+ MOZ_TRY_VAR(displaySize.ref(), ToIntSize(aInit.mDisplayWidth.Value(),
+ aInit.mDisplayHeight.Value())
+ .mapErr([](nsCString error) {
+ error.Insert("display", 0);
+ return error;
+ }));
+ }
+ return displaySize;
+}
+
+// https://w3c.github.io/webcodecs/#valid-videoframebufferinit
+static Result<
+ std::tuple<gfx::IntSize, Maybe<gfx::IntRect>, Maybe<gfx::IntSize>>,
+ nsCString>
+ValidateVideoFrameBufferInit(const VideoFrameBufferInit& aInit) {
+ gfx::IntSize codedSize;
+ MOZ_TRY_VAR(codedSize, ToIntSize(aInit.mCodedWidth, aInit.mCodedHeight)
+ .mapErr([](nsCString error) {
+ error.Insert("coded", 0);
+ return error;
+ }));
+
+ Maybe<gfx::IntRect> visibleRect;
+ if (aInit.mVisibleRect.WasPassed()) {
+ visibleRect.emplace();
+ MOZ_TRY_VAR(
+ visibleRect.ref(),
+ ToIntRect(aInit.mVisibleRect.Value()).mapErr([](nsCString error) {
+ error.Insert("visibleRect's ", 0);
+ return error;
+ }));
+ MOZ_TRY(ValidateVisibility(visibleRect.ref(), codedSize));
+ }
+
+ Maybe<gfx::IntSize> displaySize;
+ MOZ_TRY_VAR(displaySize, MaybeGetDisplaySize(aInit));
+
+ return std::make_tuple(codedSize, visibleRect, displaySize);
+}
+
+// https://w3c.github.io/webcodecs/#videoframe-verify-rect-offset-alignment
+static Result<Ok, nsCString> VerifyRectOffsetAlignment(
+ const Maybe<VideoFrame::Format>& aFormat, const gfx::IntRect& aRect) {
+ if (!aFormat) {
+ return Ok();
+ }
+ for (const VideoFrame::Format::Plane& p : aFormat->Planes()) {
+ const gfx::IntSize sample = aFormat->SampleSize(p);
+ if (aRect.X() % sample.Width() != 0) {
+ return Err(nsCString("Mismatch between format and given left offset"));
+ }
+
+ if (aRect.Y() % sample.Height() != 0) {
+ return Err(nsCString("Mismatch between format and given top offset"));
+ }
+ }
+ return Ok();
+}
+
+// https://w3c.github.io/webcodecs/#videoframe-parse-visible-rect
+static Result<gfx::IntRect, nsCString> ParseVisibleRect(
+ const gfx::IntRect& aDefaultRect, const Maybe<gfx::IntRect>& aOverrideRect,
+ const gfx::IntSize& aCodedSize, const VideoFrame::Format& aFormat) {
+ MOZ_ASSERT(ValidateVisibility(aDefaultRect, aCodedSize).isOk());
+
+ gfx::IntRect rect = aDefaultRect;
+ if (aOverrideRect) {
+ // Skip checking overrideRect's width and height here. They should be
+ // checked before reaching here, and ValidateVisibility will assert it.
+
+ MOZ_TRY(ValidateVisibility(aOverrideRect.ref(), aCodedSize));
+ rect = *aOverrideRect;
+ }
+
+ MOZ_TRY(VerifyRectOffsetAlignment(Some(aFormat), rect));
+
+ return rect;
+}
+
+// https://w3c.github.io/webcodecs/#computed-plane-layout
+struct ComputedPlaneLayout {
+ // The offset from the beginning of the buffer in one plane.
+ uint32_t mDestinationOffset = 0;
+ // The stride of the image data in one plane.
+ uint32_t mDestinationStride = 0;
+ // Sample count of picture's top offset (a.k.a samples of y).
+ uint32_t mSourceTop = 0;
+ // Sample count of the picture's height.
+ uint32_t mSourceHeight = 0;
+ // Byte count of the picture's left offset (a.k.a bytes of x).
+ uint32_t mSourceLeftBytes = 0;
+ // Byte count of the picture's width.
+ uint32_t mSourceWidthBytes = 0;
+};
+
+// https://w3c.github.io/webcodecs/#combined-buffer-layout
+struct CombinedBufferLayout {
+ CombinedBufferLayout() : mAllocationSize(0) {}
+ CombinedBufferLayout(uint32_t aAllocationSize,
+ nsTArray<ComputedPlaneLayout>&& aLayout)
+ : mAllocationSize(aAllocationSize),
+ mComputedLayouts(std::move(aLayout)) {}
+ uint32_t mAllocationSize = 0;
+ nsTArray<ComputedPlaneLayout> mComputedLayouts;
+};
+
+// https://w3c.github.io/webcodecs/#videoframe-compute-layout-and-allocation-size
+static Result<CombinedBufferLayout, nsCString> ComputeLayoutAndAllocationSize(
+ const gfx::IntRect& aRect, const VideoFrame::Format& aFormat,
+ const Sequence<PlaneLayout>* aPlaneLayouts) {
+ nsTArray<VideoFrame::Format::Plane> planes = aFormat.Planes();
+
+ if (aPlaneLayouts && aPlaneLayouts->Length() != planes.Length()) {
+ return Err(nsCString("Mismatch between format and layout"));
+ }
+
+ uint32_t minAllocationSize = 0;
+ nsTArray<ComputedPlaneLayout> layouts;
+ nsTArray<uint32_t> endOffsets;
+
+ for (size_t i = 0; i < planes.Length(); ++i) {
+ const VideoFrame::Format::Plane& p = planes[i];
+ const gfx::IntSize sampleSize = aFormat.SampleSize(p);
+ MOZ_RELEASE_ASSERT(!sampleSize.IsEmpty());
+
+ // aRect's x, y, width, and height are int32_t, and sampleSize's width and
+ // height >= 1, so (aRect.* / sampleSize.*) must be in int32_t range.
+
+ CheckedUint32 sourceTop(aRect.Y());
+ sourceTop /= sampleSize.Height();
+ MOZ_RELEASE_ASSERT(sourceTop.isValid());
+
+ CheckedUint32 sourceHeight(aRect.Height());
+ sourceHeight /= sampleSize.Height();
+ MOZ_RELEASE_ASSERT(sourceHeight.isValid());
+
+ CheckedUint32 sourceLeftBytes(aRect.X());
+ sourceLeftBytes /= sampleSize.Width();
+ MOZ_RELEASE_ASSERT(sourceLeftBytes.isValid());
+ sourceLeftBytes *= aFormat.SampleBytes(p);
+ if (!sourceLeftBytes.isValid()) {
+ return Err(nsPrintfCString(
+ "The parsed-rect's x-offset is too large for %s plane",
+ aFormat.PlaneName(p)));
+ }
+
+ CheckedUint32 sourceWidthBytes(aRect.Width());
+ sourceWidthBytes /= sampleSize.Width();
+ MOZ_RELEASE_ASSERT(sourceWidthBytes.isValid());
+ sourceWidthBytes *= aFormat.SampleBytes(p);
+ if (!sourceWidthBytes.isValid()) {
+ return Err(
+ nsPrintfCString("The parsed-rect's width is too large for %s plane",
+ aFormat.PlaneName(p)));
+ }
+
+ // TODO: Spec here is wrong so we do differently:
+ // https://github.com/w3c/webcodecs/issues/511
+ // This comment should be removed once the issue is resolved.
+ ComputedPlaneLayout layout{.mDestinationOffset = 0,
+ .mDestinationStride = 0,
+ .mSourceTop = sourceTop.value(),
+ .mSourceHeight = sourceHeight.value(),
+ .mSourceLeftBytes = sourceLeftBytes.value(),
+ .mSourceWidthBytes = sourceWidthBytes.value()};
+ if (aPlaneLayouts) {
+ const PlaneLayout& planeLayout = aPlaneLayouts->ElementAt(i);
+ if (planeLayout.mStride < layout.mSourceWidthBytes) {
+ return Err(nsPrintfCString("The stride in %s plane is too small",
+ aFormat.PlaneName(p)));
+ }
+ layout.mDestinationOffset = planeLayout.mOffset;
+ layout.mDestinationStride = planeLayout.mStride;
+ } else {
+ layout.mDestinationOffset = minAllocationSize;
+ layout.mDestinationStride = layout.mSourceWidthBytes;
+ }
+
+ const CheckedInt<uint32_t> planeSize =
+ CheckedInt<uint32_t>(layout.mDestinationStride) * layout.mSourceHeight;
+ if (!planeSize.isValid()) {
+ return Err(nsCString("Invalid layout with an over-sized plane"));
+ }
+ const CheckedInt<uint32_t> planeEnd = planeSize + layout.mDestinationOffset;
+ if (!planeEnd.isValid()) {
+ return Err(nsCString("Invalid layout with the out-out-bound offset"));
+ }
+ endOffsets.AppendElement(planeEnd.value());
+
+ minAllocationSize = std::max(minAllocationSize, planeEnd.value());
+
+ for (size_t j = 0; j < i; ++j) {
+ const ComputedPlaneLayout& earlier = layouts[j];
+ // If the current data's end is smaller or equal to the previous one's
+ // head, or if the previous data's end is smaller or equal to the current
+ // one's head, then they do not overlap. Otherwise, they do.
+ if (endOffsets[i] > earlier.mDestinationOffset &&
+ endOffsets[j] > layout.mDestinationOffset) {
+ return Err(nsCString("Invalid layout with the overlapped planes"));
+ }
+ }
+ layouts.AppendElement(layout);
+ }
+
+ return CombinedBufferLayout(minAllocationSize, std::move(layouts));
+}
+
+// https://w3c.github.io/webcodecs/#videoframe-verify-rect-size-alignment
+static Result<Ok, nsCString> VerifyRectSizeAlignment(
+ const VideoFrame::Format& aFormat, const gfx::IntRect& aRect) {
+ for (const VideoFrame::Format::Plane& p : aFormat.Planes()) {
+ const gfx::IntSize sample = aFormat.SampleSize(p);
+ if (aRect.Width() % sample.Width() != 0) {
+ return Err(nsCString("Mismatch between format and given rect's width"));
+ }
+
+ if (aRect.Height() % sample.Height() != 0) {
+ return Err(nsCString("Mismatch between format and given rect's height"));
+ }
+ }
+ return Ok();
+}
+
+// https://w3c.github.io/webcodecs/#videoframe-parse-videoframecopytooptions
+static Result<CombinedBufferLayout, nsCString> ParseVideoFrameCopyToOptions(
+ const VideoFrameCopyToOptions& aOptions, const gfx::IntRect& aVisibleRect,
+ const gfx::IntSize& aCodedSize, const VideoFrame::Format& aFormat) {
+ Maybe<gfx::IntRect> overrideRect;
+ if (aOptions.mRect.WasPassed()) {
+ // TODO: We handle some edge cases that spec misses:
+ // https://github.com/w3c/webcodecs/issues/513
+ // This comment should be removed once the issue is resolved.
+ overrideRect.emplace();
+ MOZ_TRY_VAR(overrideRect.ref(),
+ ToIntRect(aOptions.mRect.Value()).mapErr([](nsCString error) {
+ error.Insert("rect's ", 0);
+ return error;
+ }));
+
+ MOZ_TRY(VerifyRectSizeAlignment(aFormat, overrideRect.ref()));
+ }
+
+ gfx::IntRect parsedRect;
+ MOZ_TRY_VAR(parsedRect, ParseVisibleRect(aVisibleRect, overrideRect,
+ aCodedSize, aFormat));
+
+ const Sequence<PlaneLayout>* optLayout = OptionalToPointer(aOptions.mLayout);
+
+ return ComputeLayoutAndAllocationSize(parsedRect, aFormat, optLayout);
+}
+
+static bool IsYUVFormat(const VideoPixelFormat& aFormat) {
+ switch (aFormat) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::NV12:
+ return true;
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ return false;
+ case VideoPixelFormat::EndGuard_:
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+ }
+ return false;
+}
+
+// https://w3c.github.io/webcodecs/#videoframe-pick-color-space
+static VideoColorSpaceInit PickColorSpace(
+ const VideoColorSpaceInit* aInitColorSpace,
+ const VideoPixelFormat& aFormat) {
+ VideoColorSpaceInit colorSpace;
+ if (aInitColorSpace) {
+ colorSpace = *aInitColorSpace;
+ // By spec, we MAY replace null members of aInitColorSpace with guessed
+ // values so we can always use these in CreateYUVImageFromBuffer.
+ if (IsYUVFormat(aFormat) && colorSpace.mMatrix.IsNull()) {
+ colorSpace.mMatrix.SetValue(VideoMatrixCoefficients::Bt709);
+ }
+ return colorSpace;
+ }
+
+ switch (aFormat) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::NV12:
+ // https://w3c.github.io/webcodecs/#rec709-color-space
+ colorSpace.mFullRange.SetValue(false);
+ colorSpace.mMatrix.SetValue(VideoMatrixCoefficients::Bt709);
+ colorSpace.mPrimaries.SetValue(VideoColorPrimaries::Bt709);
+ colorSpace.mTransfer.SetValue(VideoTransferCharacteristics::Bt709);
+ break;
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ // https://w3c.github.io/webcodecs/#srgb-color-space
+ colorSpace.mFullRange.SetValue(true);
+ colorSpace.mMatrix.SetValue(VideoMatrixCoefficients::Rgb);
+ colorSpace.mPrimaries.SetValue(VideoColorPrimaries::Bt709);
+ colorSpace.mTransfer.SetValue(VideoTransferCharacteristics::Iec61966_2_1);
+ break;
+ case VideoPixelFormat::EndGuard_:
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+ }
+
+ return colorSpace;
+}
+
+// https://w3c.github.io/webcodecs/#validate-videoframeinit
+static Result<std::pair<Maybe<gfx::IntRect>, Maybe<gfx::IntSize>>, nsCString>
+ValidateVideoFrameInit(const VideoFrameInit& aInit,
+ const Maybe<VideoFrame::Format>& aFormat,
+ const gfx::IntSize& aCodedSize) {
+ if (aCodedSize.Width() <= 0 || aCodedSize.Height() <= 0) {
+ return Err(nsCString("codedWidth and codedHeight must be positive"));
+ }
+
+ Maybe<gfx::IntRect> visibleRect;
+ if (aInit.mVisibleRect.WasPassed()) {
+ visibleRect.emplace();
+ MOZ_TRY_VAR(
+ visibleRect.ref(),
+ ToIntRect(aInit.mVisibleRect.Value()).mapErr([](nsCString error) {
+ error.Insert("visibleRect's ", 0);
+ return error;
+ }));
+ MOZ_TRY(ValidateVisibility(visibleRect.ref(), aCodedSize));
+
+ MOZ_TRY(VerifyRectOffsetAlignment(aFormat, visibleRect.ref()));
+ }
+
+ Maybe<gfx::IntSize> displaySize;
+ MOZ_TRY_VAR(displaySize, MaybeGetDisplaySize(aInit));
+
+ return std::make_pair(visibleRect, displaySize);
+}
+
+/*
+ * The followings are helpers to create a VideoFrame from a given buffer
+ */
+
+static Result<RefPtr<gfx::DataSourceSurface>, nsCString> AllocateBGRASurface(
+ gfx::DataSourceSurface* aSurface) {
+ MOZ_ASSERT(aSurface);
+
+ // Memory allocation relies on CreateDataSourceSurfaceWithStride so we still
+ // need to do this even if the format is SurfaceFormat::BGR{A, X}.
+
+ gfx::DataSourceSurface::ScopedMap surfaceMap(aSurface,
+ gfx::DataSourceSurface::READ);
+ if (!surfaceMap.IsMapped()) {
+ return Err(nsCString("The source surface is not readable"));
+ }
+
+ RefPtr<gfx::DataSourceSurface> bgraSurface =
+ gfx::Factory::CreateDataSourceSurfaceWithStride(
+ aSurface->GetSize(), gfx::SurfaceFormat::B8G8R8A8,
+ surfaceMap.GetStride());
+ if (!bgraSurface) {
+ return Err(nsCString("Failed to allocate a BGRA surface"));
+ }
+
+ gfx::DataSourceSurface::ScopedMap bgraMap(bgraSurface,
+ gfx::DataSourceSurface::WRITE);
+ if (!bgraMap.IsMapped()) {
+ return Err(nsCString("The allocated BGRA surface is not writable"));
+ }
+
+ gfx::SwizzleData(surfaceMap.GetData(), surfaceMap.GetStride(),
+ aSurface->GetFormat(), bgraMap.GetData(),
+ bgraMap.GetStride(), bgraSurface->GetFormat(),
+ bgraSurface->GetSize());
+
+ return bgraSurface;
+}
+
+static Result<RefPtr<layers::Image>, nsCString> CreateImageFromRawData(
+ const gfx::IntSize& aSize, int32_t aStride, gfx::SurfaceFormat aFormat,
+ const Span<uint8_t>& aBuffer) {
+ MOZ_ASSERT(!aSize.IsEmpty());
+
+ // Wrap the source buffer into a DataSourceSurface.
+ RefPtr<gfx::DataSourceSurface> surface =
+ gfx::Factory::CreateWrappingDataSourceSurface(aBuffer.data(), aStride,
+ aSize, aFormat);
+ if (!surface) {
+ return Err(nsCString("Failed to wrap the raw data into a surface"));
+ }
+
+ // Gecko favors BGRA so we convert surface into BGRA format first.
+ RefPtr<gfx::DataSourceSurface> bgraSurface;
+ MOZ_TRY_VAR(bgraSurface, AllocateBGRASurface(surface));
+ MOZ_ASSERT(bgraSurface);
+
+ return RefPtr<layers::Image>(
+ new layers::SourceSurfaceImage(bgraSurface.get()));
+}
+
+static Result<RefPtr<layers::Image>, nsCString> CreateRGBAImageFromBuffer(
+ const VideoFrame::Format& aFormat, const gfx::IntSize& aSize,
+ const Span<uint8_t>& aBuffer) {
+ const gfx::SurfaceFormat format = aFormat.ToSurfaceFormat();
+ MOZ_ASSERT(format == gfx::SurfaceFormat::R8G8B8A8 ||
+ format == gfx::SurfaceFormat::R8G8B8X8 ||
+ format == gfx::SurfaceFormat::B8G8R8A8 ||
+ format == gfx::SurfaceFormat::B8G8R8X8);
+ // TODO: Use aFormat.SampleBytes() instead?
+ CheckedInt<int32_t> stride(BytesPerPixel(format));
+ stride *= aSize.Width();
+ if (!stride.isValid()) {
+ return Err(nsCString("Image size exceeds implementation's limit"));
+ }
+ return CreateImageFromRawData(aSize, stride.value(), format, aBuffer);
+}
+
+static Result<RefPtr<layers::Image>, nsCString> CreateYUVImageFromBuffer(
+ const VideoFrame::Format& aFormat, const VideoColorSpaceInit& aColorSpace,
+ const gfx::IntSize& aSize, const Span<uint8_t>& aBuffer) {
+ if (aFormat.PixelFormat() == VideoPixelFormat::I420 ||
+ aFormat.PixelFormat() == VideoPixelFormat::I420A) {
+ UniquePtr<I420BufferReader> reader;
+ if (aFormat.PixelFormat() == VideoPixelFormat::I420) {
+ reader.reset(
+ new I420BufferReader(aBuffer, aSize.Width(), aSize.Height()));
+ } else {
+ reader.reset(
+ new I420ABufferReader(aBuffer, aSize.Width(), aSize.Height()));
+ }
+
+ layers::PlanarYCbCrData data;
+ data.mPictureRect = gfx::IntRect(0, 0, reader->mWidth, reader->mHeight);
+
+ // Y plane.
+ data.mYChannel = const_cast<uint8_t*>(reader->DataY());
+ data.mYStride = reader->mStrideY;
+ data.mYSkip = 0;
+ // Cb plane.
+ data.mCbChannel = const_cast<uint8_t*>(reader->DataU());
+ data.mCbSkip = 0;
+ // Cr plane.
+ data.mCrChannel = const_cast<uint8_t*>(reader->DataV());
+ data.mCbSkip = 0;
+ // A plane.
+ if (aFormat.PixelFormat() == VideoPixelFormat::I420A) {
+ data.mAlpha.emplace();
+ data.mAlpha->mChannel =
+ const_cast<uint8_t*>(reader->AsI420ABufferReader()->DataA());
+ data.mAlpha->mSize = data.mPictureRect.Size();
+ // No values for mDepth and mPremultiplied.
+ }
+
+ // CbCr plane vector.
+ MOZ_RELEASE_ASSERT(reader->mStrideU == reader->mStrideV);
+ data.mCbCrStride = reader->mStrideU;
+ data.mChromaSubsampling = gfx::ChromaSubsampling::HALF_WIDTH_AND_HEIGHT;
+ // Color settings.
+ if (!aColorSpace.mFullRange.IsNull()) {
+ data.mColorRange = ToColorRange(aColorSpace.mFullRange.Value());
+ }
+ MOZ_RELEASE_ASSERT(!aColorSpace.mMatrix.IsNull());
+ data.mYUVColorSpace = ToColorSpace(aColorSpace.mMatrix.Value());
+ if (!aColorSpace.mTransfer.IsNull()) {
+ data.mTransferFunction =
+ ToTransferFunction(aColorSpace.mTransfer.Value());
+ }
+ if (!aColorSpace.mPrimaries.IsNull()) {
+ data.mColorPrimaries = ToPrimaries(aColorSpace.mPrimaries.Value());
+ }
+
+ RefPtr<layers::PlanarYCbCrImage> image =
+ new layers::RecyclingPlanarYCbCrImage(new layers::BufferRecycleBin());
+ if (NS_FAILED(image->CopyData(data))) {
+ return Err(nsPrintfCString(
+ "Failed to create I420%s image",
+ (aFormat.PixelFormat() == VideoPixelFormat::I420A ? "A" : "")));
+ }
+ // Manually cast type to make Result work.
+ return RefPtr<layers::Image>(image.forget());
+ }
+
+ if (aFormat.PixelFormat() == VideoPixelFormat::NV12) {
+ NV12BufferReader reader(aBuffer, aSize.Width(), aSize.Height());
+
+ layers::PlanarYCbCrData data;
+ data.mPictureRect = gfx::IntRect(0, 0, reader.mWidth, reader.mHeight);
+
+ // Y plane.
+ data.mYChannel = const_cast<uint8_t*>(reader.DataY());
+ data.mYStride = reader.mStrideY;
+ data.mYSkip = 0;
+ // Cb plane.
+ data.mCbChannel = const_cast<uint8_t*>(reader.DataUV());
+ data.mCbSkip = 1;
+ // Cr plane.
+ data.mCrChannel = data.mCbChannel + 1;
+ data.mCrSkip = 1;
+ // CbCr plane vector.
+ data.mCbCrStride = reader.mStrideUV;
+ data.mChromaSubsampling = gfx::ChromaSubsampling::HALF_WIDTH_AND_HEIGHT;
+ // Color settings.
+ if (!aColorSpace.mFullRange.IsNull()) {
+ data.mColorRange = ToColorRange(aColorSpace.mFullRange.Value());
+ }
+ MOZ_RELEASE_ASSERT(!aColorSpace.mMatrix.IsNull());
+ data.mYUVColorSpace = ToColorSpace(aColorSpace.mMatrix.Value());
+ if (!aColorSpace.mTransfer.IsNull()) {
+ data.mTransferFunction =
+ ToTransferFunction(aColorSpace.mTransfer.Value());
+ }
+ if (!aColorSpace.mPrimaries.IsNull()) {
+ data.mColorPrimaries = ToPrimaries(aColorSpace.mPrimaries.Value());
+ }
+
+ RefPtr<layers::NVImage> image = new layers::NVImage();
+ if (!image->SetData(data)) {
+ return Err(nsCString("Failed to create NV12 image"));
+ }
+ // Manually cast type to make Result work.
+ return RefPtr<layers::Image>(image.forget());
+ }
+
+ return Err(nsCString("Unsupported image format"));
+}
+
+static Result<RefPtr<layers::Image>, nsCString> CreateImageFromBuffer(
+ const VideoFrame::Format& aFormat, const VideoColorSpaceInit& aColorSpace,
+ const gfx::IntSize& aSize, const Span<uint8_t>& aBuffer) {
+ switch (aFormat.PixelFormat()) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::NV12:
+ return CreateYUVImageFromBuffer(aFormat, aColorSpace, aSize, aBuffer);
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ // Not yet support for now.
+ break;
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ return CreateRGBAImageFromBuffer(aFormat, aSize, aBuffer);
+ case VideoPixelFormat::EndGuard_:
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+ }
+ return Err(nsCString("Invalid image format"));
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-videoframe-data-init
+template <class T>
+static Result<RefPtr<VideoFrame>, nsCString> CreateVideoFrameFromBuffer(
+ nsIGlobalObject* aGlobal, const T& aBuffer,
+ const VideoFrameBufferInit& aInit) {
+ if (aInit.mColorSpace.WasPassed() &&
+ !aInit.mColorSpace.Value().mTransfer.IsNull() &&
+ aInit.mColorSpace.Value().mTransfer.Value() ==
+ VideoTransferCharacteristics::Linear) {
+ return Err(nsCString("linear RGB is not supported"));
+ }
+
+ std::tuple<gfx::IntSize, Maybe<gfx::IntRect>, Maybe<gfx::IntSize>> init;
+ MOZ_TRY_VAR(init, ValidateVideoFrameBufferInit(aInit));
+ gfx::IntSize codedSize = std::get<0>(init);
+ Maybe<gfx::IntRect> visibleRect = std::get<1>(init);
+ Maybe<gfx::IntSize> displaySize = std::get<2>(init);
+
+ VideoFrame::Format format(aInit.mFormat);
+ // TODO: Spec doesn't ask for this in ctor but Pixel Format does. See
+ // https://github.com/w3c/webcodecs/issues/512
+ // This comment should be removed once the issue is resolved.
+ if (!format.IsValidSize(codedSize)) {
+ return Err(nsCString("coded width and/or height is invalid"));
+ }
+
+ gfx::IntRect parsedRect;
+ MOZ_TRY_VAR(parsedRect, ParseVisibleRect(gfx::IntRect({0, 0}, codedSize),
+ visibleRect, codedSize, format));
+
+ const Sequence<PlaneLayout>* optLayout = OptionalToPointer(aInit.mLayout);
+
+ CombinedBufferLayout combinedLayout;
+ MOZ_TRY_VAR(combinedLayout,
+ ComputeLayoutAndAllocationSize(parsedRect, format, optLayout));
+
+ Maybe<uint64_t> duration = OptionalToMaybe(aInit.mDuration);
+
+ VideoColorSpaceInit colorSpace =
+ PickColorSpace(OptionalToPointer(aInit.mColorSpace), aInit.mFormat);
+
+ RefPtr<layers::Image> data;
+ MOZ_TRY_VAR(
+ data,
+ aBuffer.ProcessFixedData([&](const Span<uint8_t>& aData)
+ -> Result<RefPtr<layers::Image>, nsCString> {
+ if (aData.Length() <
+ static_cast<size_t>(combinedLayout.mAllocationSize)) {
+ return Err(nsCString("data is too small"));
+ }
+
+ // TODO: If codedSize is (3, 3) and visibleRect is (0, 0, 1, 1) but the
+ // data is 2 x 2 RGBA buffer (2 x 2 x 4 bytes), it pass the above check.
+ // In this case, we can crop it to a 1 x 1-codedSize image (Bug
+ // 1782128).
+ if (aData.Length() < format.SampleCount(codedSize)) { // 1 byte/sample
+ return Err(nsCString("data is too small"));
+ }
+
+ return CreateImageFromBuffer(format, colorSpace, codedSize, aData);
+ }));
+
+ MOZ_ASSERT(data);
+ MOZ_ASSERT(data->GetSize() == codedSize);
+
+ // By spec, we should set visible* here. But if we don't change the image,
+ // visible* is same as parsedRect here. The display{Width, Height} is
+ // visible{Width, Height} if it's not set.
+
+ // TODO: Spec should assign aInit.mFormat to inner format value:
+ // https://github.com/w3c/webcodecs/issues/509.
+ // This comment should be removed once the issue is resolved.
+ return MakeRefPtr<VideoFrame>(aGlobal, data, Some(aInit.mFormat), codedSize,
+ parsedRect,
+ displaySize ? *displaySize : parsedRect.Size(),
+ duration, aInit.mTimestamp, colorSpace);
+}
+
+template <class T>
+static already_AddRefed<VideoFrame> CreateVideoFrameFromBuffer(
+ const GlobalObject& aGlobal, const T& aBuffer,
+ const VideoFrameBufferInit& aInit, ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ auto r = CreateVideoFrameFromBuffer(global, aBuffer, aInit);
+ if (r.isErr()) {
+ aRv.ThrowTypeError(r.unwrapErr());
+ return nullptr;
+ }
+ return r.unwrap().forget();
+}
+
+// https://w3c.github.io/webcodecs/#videoframe-initialize-visible-rect-and-display-size
+static void InitializeVisibleRectAndDisplaySize(
+ Maybe<gfx::IntRect>& aVisibleRect, Maybe<gfx::IntSize>& aDisplaySize,
+ gfx::IntRect aDefaultVisibleRect, gfx::IntSize aDefaultDisplaySize) {
+ if (!aVisibleRect) {
+ aVisibleRect.emplace(aDefaultVisibleRect);
+ }
+ if (!aDisplaySize) {
+ double wScale = static_cast<double>(aDefaultDisplaySize.Width()) /
+ aDefaultVisibleRect.Width();
+ double hScale = static_cast<double>(aDefaultDisplaySize.Height()) /
+ aDefaultVisibleRect.Height();
+ double w = wScale * aVisibleRect->Width();
+ double h = hScale * aVisibleRect->Height();
+ aDisplaySize.emplace(gfx::IntSize(static_cast<uint32_t>(round(w)),
+ static_cast<uint32_t>(round(h))));
+ }
+}
+
+// https://w3c.github.io/webcodecs/#videoframe-initialize-frame-with-resource-and-size
+static Result<already_AddRefed<VideoFrame>, nsCString>
+InitializeFrameWithResourceAndSize(
+ nsIGlobalObject* aGlobal, const VideoFrameInit& aInit,
+ already_AddRefed<layers::SourceSurfaceImage> aImage) {
+ MOZ_ASSERT(aInit.mTimestamp.WasPassed());
+
+ RefPtr<layers::SourceSurfaceImage> image(aImage);
+ MOZ_ASSERT(image);
+
+ RefPtr<gfx::SourceSurface> surface = image->GetAsSourceSurface();
+ Maybe<VideoFrame::Format> format =
+ SurfaceFormatToVideoPixelFormat(surface->GetFormat())
+ .map([](const VideoPixelFormat& aFormat) {
+ return VideoFrame::Format(aFormat);
+ });
+
+ std::pair<Maybe<gfx::IntRect>, Maybe<gfx::IntSize>> init;
+ MOZ_TRY_VAR(init, ValidateVideoFrameInit(aInit, format, image->GetSize()));
+ Maybe<gfx::IntRect> visibleRect = init.first;
+ Maybe<gfx::IntSize> displaySize = init.second;
+
+ if (format && aInit.mAlpha == AlphaOption::Discard) {
+ format->MakeOpaque();
+ // Keep the alpha data in image for now until it's being rendered.
+ // TODO: The alpha will still be rendered if the format is unrecognized
+ // since no additional flag keeping this request. Should spec address what
+ // to do in this case?
+ }
+
+ InitializeVisibleRectAndDisplaySize(visibleRect, displaySize,
+ gfx::IntRect({0, 0}, image->GetSize()),
+ image->GetSize());
+
+ Maybe<uint64_t> duration = OptionalToMaybe(aInit.mDuration);
+
+ VideoColorSpaceInit colorSpace{};
+ if (IsYUVFormat(
+ SurfaceFormatToVideoPixelFormat(surface->GetFormat()).ref())) {
+ colorSpace = FallbackColorSpaceForVideoContent();
+ } else {
+ colorSpace = FallbackColorSpaceForWebContent();
+ }
+ return MakeAndAddRef<VideoFrame>(
+ aGlobal, image, format ? Some(format->PixelFormat()) : Nothing(),
+ image->GetSize(), visibleRect.value(), displaySize.value(), duration,
+ aInit.mTimestamp.Value(), colorSpace);
+}
+
+// https://w3c.github.io/webcodecs/#videoframe-initialize-frame-from-other-frame
+static Result<already_AddRefed<VideoFrame>, nsCString>
+InitializeFrameFromOtherFrame(nsIGlobalObject* aGlobal, VideoFrameData&& aData,
+ const VideoFrameInit& aInit) {
+ MOZ_ASSERT(aGlobal);
+ MOZ_ASSERT(aData.mImage);
+
+ Maybe<VideoFrame::Format> format =
+ aData.mFormat ? Some(VideoFrame::Format(*aData.mFormat)) : Nothing();
+ if (format && aInit.mAlpha == AlphaOption::Discard) {
+ format->MakeOpaque();
+ // Keep the alpha data in image for now until it's being rendered.
+ // TODO: The alpha will still be rendered if the format is unrecognized
+ // since no additional flag keeping this request. Should spec address what
+ // to do in this case?
+ }
+
+ std::pair<Maybe<gfx::IntRect>, Maybe<gfx::IntSize>> init;
+ MOZ_TRY_VAR(init,
+ ValidateVideoFrameInit(aInit, format, aData.mImage->GetSize()));
+ Maybe<gfx::IntRect> visibleRect = init.first;
+ Maybe<gfx::IntSize> displaySize = init.second;
+
+ InitializeVisibleRectAndDisplaySize(visibleRect, displaySize,
+ aData.mVisibleRect, aData.mDisplaySize);
+
+ Maybe<uint64_t> duration = OptionalToMaybe(aInit.mDuration);
+
+ int64_t timestamp = aInit.mTimestamp.WasPassed() ? aInit.mTimestamp.Value()
+ : aData.mTimestamp;
+
+ return MakeAndAddRef<VideoFrame>(
+ aGlobal, aData.mImage, format ? Some(format->PixelFormat()) : Nothing(),
+ aData.mImage->GetSize(), *visibleRect, *displaySize, duration, timestamp,
+ aData.mColorSpace);
+}
+
+/*
+ * Helper classes carrying VideoFrame data
+ */
+
+VideoFrameData::VideoFrameData(layers::Image* aImage,
+ const Maybe<VideoPixelFormat>& aFormat,
+ gfx::IntRect aVisibleRect,
+ gfx::IntSize aDisplaySize,
+ Maybe<uint64_t> aDuration, int64_t aTimestamp,
+ const VideoColorSpaceInit& aColorSpace)
+ : mImage(aImage),
+ mFormat(aFormat),
+ mVisibleRect(aVisibleRect),
+ mDisplaySize(aDisplaySize),
+ mDuration(aDuration),
+ mTimestamp(aTimestamp),
+ mColorSpace(aColorSpace) {}
+
+VideoFrameSerializedData::VideoFrameSerializedData(const VideoFrameData& aData,
+ gfx::IntSize aCodedSize)
+ : VideoFrameData(aData), mCodedSize(aCodedSize) {}
+
+/*
+ * W3C Webcodecs VideoFrame implementation
+ */
+
+VideoFrame::VideoFrame(nsIGlobalObject* aParent,
+ const RefPtr<layers::Image>& aImage,
+ const Maybe<VideoPixelFormat>& aFormat,
+ gfx::IntSize aCodedSize, gfx::IntRect aVisibleRect,
+ gfx::IntSize aDisplaySize,
+ const Maybe<uint64_t>& aDuration, int64_t aTimestamp,
+ const VideoColorSpaceInit& aColorSpace)
+ : mParent(aParent),
+ mCodedSize(aCodedSize),
+ mVisibleRect(aVisibleRect),
+ mDisplaySize(aDisplaySize),
+ mDuration(aDuration),
+ mTimestamp(aTimestamp),
+ mColorSpace(aColorSpace) {
+ MOZ_ASSERT(mParent);
+ LOG("VideoFrame %p ctor", this);
+ mResource.emplace(
+ Resource(aImage, aFormat.map([](const VideoPixelFormat& aPixelFormat) {
+ return VideoFrame::Format(aPixelFormat);
+ })));
+ if (!mResource->mFormat) {
+ LOGW("Create a VideoFrame with an unrecognized image format");
+ }
+ StartAutoClose();
+}
+
+VideoFrame::VideoFrame(nsIGlobalObject* aParent,
+ const VideoFrameSerializedData& aData)
+ : mParent(aParent),
+ mCodedSize(aData.mCodedSize),
+ mVisibleRect(aData.mVisibleRect),
+ mDisplaySize(aData.mDisplaySize),
+ mDuration(aData.mDuration),
+ mTimestamp(aData.mTimestamp),
+ mColorSpace(aData.mColorSpace) {
+ MOZ_ASSERT(mParent);
+ LOG("VideoFrame %p ctor", this);
+ mResource.emplace(Resource(
+ aData.mImage, aData.mFormat.map([](const VideoPixelFormat& aPixelFormat) {
+ return VideoFrame::Format(aPixelFormat);
+ })));
+ if (!mResource->mFormat) {
+ LOGW("Create a VideoFrame with an unrecognized image format");
+ }
+ StartAutoClose();
+}
+
+VideoFrame::VideoFrame(const VideoFrame& aOther)
+ : mParent(aOther.mParent),
+ mResource(aOther.mResource),
+ mCodedSize(aOther.mCodedSize),
+ mVisibleRect(aOther.mVisibleRect),
+ mDisplaySize(aOther.mDisplaySize),
+ mDuration(aOther.mDuration),
+ mTimestamp(aOther.mTimestamp),
+ mColorSpace(aOther.mColorSpace) {
+ MOZ_ASSERT(mParent);
+ LOG("VideoFrame %p ctor", this);
+ StartAutoClose();
+}
+
+VideoFrame::~VideoFrame() {
+ MOZ_ASSERT(IsClosed());
+ LOG("VideoFrame %p dtor", this);
+}
+
+nsIGlobalObject* VideoFrame::GetParentObject() const {
+ AssertIsOnOwningThread();
+
+ return mParent.get();
+}
+
+JSObject* VideoFrame::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ AssertIsOnOwningThread();
+
+ return VideoFrame_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+// The following constructors are defined in
+// https://w3c.github.io/webcodecs/#dom-videoframe-videoframe
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, HTMLImageElement& aImageElement,
+ const VideoFrameInit& aInit, ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ // Check the usability.
+ if (aImageElement.State().HasState(ElementState::BROKEN)) {
+ aRv.ThrowInvalidStateError("The image's state is broken");
+ return nullptr;
+ }
+ if (!aImageElement.Complete()) {
+ aRv.ThrowInvalidStateError("The image is not completely loaded yet");
+ return nullptr;
+ }
+ if (aImageElement.NaturalWidth() == 0) {
+ aRv.ThrowInvalidStateError("The image has a width of 0");
+ return nullptr;
+ }
+ if (aImageElement.NaturalHeight() == 0) {
+ aRv.ThrowInvalidStateError("The image has a height of 0");
+ return nullptr;
+ }
+
+ // If the origin of HTMLImageElement's image data is not same origin with the
+ // entry settings object's origin, then throw a SecurityError DOMException.
+ SurfaceFromElementResult res = nsLayoutUtils::SurfaceFromElement(
+ &aImageElement, nsLayoutUtils::SFE_WANT_FIRST_FRAME_IF_IMAGE);
+ if (res.mIsWriteOnly) {
+ // Being write-only implies its image is cross-origin w/out CORS headers.
+ aRv.ThrowSecurityError("The image is not same-origin");
+ return nullptr;
+ }
+
+ RefPtr<gfx::SourceSurface> surface = res.GetSourceSurface();
+ if (NS_WARN_IF(!surface)) {
+ aRv.ThrowInvalidStateError("The image's surface acquisition failed");
+ return nullptr;
+ }
+
+ if (!aInit.mTimestamp.WasPassed()) {
+ aRv.ThrowTypeError("Missing timestamp");
+ return nullptr;
+ }
+
+ RefPtr<layers::SourceSurfaceImage> image =
+ new layers::SourceSurfaceImage(surface.get());
+ auto r = InitializeFrameWithResourceAndSize(global, aInit, image.forget());
+ if (r.isErr()) {
+ aRv.ThrowTypeError(r.unwrapErr());
+ return nullptr;
+ }
+ return r.unwrap();
+}
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, SVGImageElement& aSVGImageElement,
+ const VideoFrameInit& aInit, ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ // Check the usability.
+ if (aSVGImageElement.State().HasState(ElementState::BROKEN)) {
+ aRv.ThrowInvalidStateError("The SVG's state is broken");
+ return nullptr;
+ }
+
+ // If the origin of SVGImageElement's image data is not same origin with the
+ // entry settings object's origin, then throw a SecurityError DOMException.
+ SurfaceFromElementResult res = nsLayoutUtils::SurfaceFromElement(
+ &aSVGImageElement, nsLayoutUtils::SFE_WANT_FIRST_FRAME_IF_IMAGE);
+ if (res.mIsWriteOnly) {
+ // Being write-only implies its image is cross-origin w/out CORS headers.
+ aRv.ThrowSecurityError("The SVG is not same-origin");
+ return nullptr;
+ }
+
+ RefPtr<gfx::SourceSurface> surface = res.GetSourceSurface();
+ if (NS_WARN_IF(!surface)) {
+ aRv.ThrowInvalidStateError("The SVG's surface acquisition failed");
+ return nullptr;
+ }
+
+ if (!aInit.mTimestamp.WasPassed()) {
+ aRv.ThrowTypeError("Missing timestamp");
+ return nullptr;
+ }
+
+ RefPtr<layers::SourceSurfaceImage> image =
+ new layers::SourceSurfaceImage(surface.get());
+ auto r = InitializeFrameWithResourceAndSize(global, aInit, image.forget());
+ if (r.isErr()) {
+ aRv.ThrowTypeError(r.unwrapErr());
+ return nullptr;
+ }
+ return r.unwrap();
+}
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, HTMLCanvasElement& aCanvasElement,
+ const VideoFrameInit& aInit, ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ // Check the usability.
+ if (aCanvasElement.Width() == 0) {
+ aRv.ThrowInvalidStateError("The canvas has a width of 0");
+ return nullptr;
+ }
+
+ if (aCanvasElement.Height() == 0) {
+ aRv.ThrowInvalidStateError("The canvas has a height of 0");
+ return nullptr;
+ }
+
+ // If the origin of HTMLCanvasElement's image data is not same origin with the
+ // entry settings object's origin, then throw a SecurityError DOMException.
+ SurfaceFromElementResult res = nsLayoutUtils::SurfaceFromElement(
+ &aCanvasElement, nsLayoutUtils::SFE_WANT_FIRST_FRAME_IF_IMAGE);
+ if (res.mIsWriteOnly) {
+ // Being write-only implies its image is cross-origin w/out CORS headers.
+ aRv.ThrowSecurityError("The canvas is not same-origin");
+ return nullptr;
+ }
+
+ RefPtr<gfx::SourceSurface> surface = res.GetSourceSurface();
+ if (NS_WARN_IF(!surface)) {
+ aRv.ThrowInvalidStateError("The canvas' surface acquisition failed");
+ return nullptr;
+ }
+
+ if (!aInit.mTimestamp.WasPassed()) {
+ aRv.ThrowTypeError("Missing timestamp");
+ return nullptr;
+ }
+
+ RefPtr<layers::SourceSurfaceImage> image =
+ new layers::SourceSurfaceImage(surface.get());
+ auto r = InitializeFrameWithResourceAndSize(global, aInit, image.forget());
+ if (r.isErr()) {
+ aRv.ThrowTypeError(r.unwrapErr());
+ return nullptr;
+ }
+ return r.unwrap();
+}
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, HTMLVideoElement& aVideoElement,
+ const VideoFrameInit& aInit, ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ aVideoElement.LogVisibility(
+ mozilla::dom::HTMLVideoElement::CallerAPI::CREATE_VIDEOFRAME);
+
+ // Check the usability.
+ if (aVideoElement.NetworkState() == HTMLMediaElement_Binding::NETWORK_EMPTY) {
+ aRv.ThrowInvalidStateError("The video has not been initialized yet");
+ return nullptr;
+ }
+ if (aVideoElement.ReadyState() <= HTMLMediaElement_Binding::HAVE_METADATA) {
+ aRv.ThrowInvalidStateError("The video is not ready yet");
+ return nullptr;
+ }
+ RefPtr<layers::Image> image = aVideoElement.GetCurrentImage();
+ if (!image) {
+ aRv.ThrowInvalidStateError("The video doesn't have any image yet");
+ return nullptr;
+ }
+
+ // If the origin of HTMLVideoElement's image data is not same origin with the
+ // entry settings object's origin, then throw a SecurityError DOMException.
+ if (!IsSameOrigin(global.get(), aVideoElement)) {
+ aRv.ThrowSecurityError("The video is not same-origin");
+ return nullptr;
+ }
+
+ const ImageUtils imageUtils(image);
+ Maybe<VideoPixelFormat> format =
+ ImageBitmapFormatToVideoPixelFormat(imageUtils.GetFormat());
+
+ // TODO: Retrive/infer the duration, and colorspace.
+ auto r = InitializeFrameFromOtherFrame(
+ global.get(),
+ VideoFrameData(image.get(), format, image->GetPictureRect(),
+ image->GetSize(), Nothing(),
+ static_cast<int64_t>(aVideoElement.CurrentTime()), {}),
+ aInit);
+ if (r.isErr()) {
+ aRv.ThrowTypeError(r.unwrapErr());
+ return nullptr;
+ }
+ return r.unwrap();
+}
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, OffscreenCanvas& aOffscreenCanvas,
+ const VideoFrameInit& aInit, ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ // Check the usability.
+ if (aOffscreenCanvas.Width() == 0) {
+ aRv.ThrowInvalidStateError("The canvas has a width of 0");
+ return nullptr;
+ }
+ if (aOffscreenCanvas.Height() == 0) {
+ aRv.ThrowInvalidStateError("The canvas has a height of 0");
+ return nullptr;
+ }
+
+ // If the origin of the OffscreenCanvas's image data is not same origin with
+ // the entry settings object's origin, then throw a SecurityError
+ // DOMException.
+ SurfaceFromElementResult res = nsLayoutUtils::SurfaceFromOffscreenCanvas(
+ &aOffscreenCanvas, nsLayoutUtils::SFE_WANT_FIRST_FRAME_IF_IMAGE);
+ if (res.mIsWriteOnly) {
+ // Being write-only implies its image is cross-origin w/out CORS headers.
+ aRv.ThrowSecurityError("The canvas is not same-origin");
+ return nullptr;
+ }
+
+ RefPtr<gfx::SourceSurface> surface = res.GetSourceSurface();
+ if (NS_WARN_IF(!surface)) {
+ aRv.ThrowInvalidStateError("The canvas' surface acquisition failed");
+ return nullptr;
+ }
+
+ if (!aInit.mTimestamp.WasPassed()) {
+ aRv.ThrowTypeError("Missing timestamp");
+ return nullptr;
+ }
+
+ RefPtr<layers::SourceSurfaceImage> image =
+ new layers::SourceSurfaceImage(surface.get());
+ auto r = InitializeFrameWithResourceAndSize(global, aInit, image.forget());
+ if (r.isErr()) {
+ aRv.ThrowTypeError(r.unwrapErr());
+ return nullptr;
+ }
+ return r.unwrap();
+}
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, ImageBitmap& aImageBitmap,
+ const VideoFrameInit& aInit, ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ // Check the usability.
+ UniquePtr<ImageBitmapCloneData> data = aImageBitmap.ToCloneData();
+ if (!data || !data->mSurface) {
+ aRv.ThrowInvalidStateError(
+ "The ImageBitmap is closed or its surface acquisition failed");
+ return nullptr;
+ }
+
+ // If the origin of the ImageBitmap's image data is not same origin with the
+ // entry settings object's origin, then throw a SecurityError DOMException.
+ if (data->mWriteOnly) {
+ // Being write-only implies its image is cross-origin w/out CORS headers.
+ aRv.ThrowSecurityError("The ImageBitmap is not same-origin");
+ return nullptr;
+ }
+
+ if (!aInit.mTimestamp.WasPassed()) {
+ aRv.ThrowTypeError("Missing timestamp");
+ return nullptr;
+ }
+
+ RefPtr<layers::SourceSurfaceImage> image =
+ new layers::SourceSurfaceImage(data->mSurface.get());
+ // TODO: Take care of data->mAlphaType
+ auto r = InitializeFrameWithResourceAndSize(global, aInit, image.forget());
+ if (r.isErr()) {
+ aRv.ThrowTypeError(r.unwrapErr());
+ return nullptr;
+ }
+ return r.unwrap();
+}
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, VideoFrame& aVideoFrame,
+ const VideoFrameInit& aInit, ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ // Check the usability.
+ if (!aVideoFrame.mResource) {
+ aRv.ThrowInvalidStateError(
+ "The VideoFrame is closed or no image found there");
+ return nullptr;
+ }
+ MOZ_ASSERT(aVideoFrame.mResource->mImage->GetSize() ==
+ aVideoFrame.mCodedSize);
+ MOZ_ASSERT(!aVideoFrame.mCodedSize.IsEmpty());
+ MOZ_ASSERT(!aVideoFrame.mVisibleRect.IsEmpty());
+ MOZ_ASSERT(!aVideoFrame.mDisplaySize.IsEmpty());
+
+ // If the origin of the VideoFrame is not same origin with the entry settings
+ // object's origin, then throw a SecurityError DOMException.
+ if (!IsSameOrigin(global.get(), aVideoFrame)) {
+ aRv.ThrowSecurityError("The VideoFrame is not same-origin");
+ return nullptr;
+ }
+
+ auto r = InitializeFrameFromOtherFrame(
+ global.get(), aVideoFrame.GetVideoFrameData(), aInit);
+ if (r.isErr()) {
+ aRv.ThrowTypeError(r.unwrapErr());
+ return nullptr;
+ }
+ return r.unwrap();
+}
+
+// The following constructors are defined in
+// https://w3c.github.io/webcodecs/#dom-videoframe-videoframe-data-init
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, const ArrayBufferView& aBufferView,
+ const VideoFrameBufferInit& aInit, ErrorResult& aRv) {
+ return CreateVideoFrameFromBuffer(aGlobal, aBufferView, aInit, aRv);
+}
+
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::Constructor(
+ const GlobalObject& aGlobal, const ArrayBuffer& aBuffer,
+ const VideoFrameBufferInit& aInit, ErrorResult& aRv) {
+ return CreateVideoFrameFromBuffer(aGlobal, aBuffer, aInit, aRv);
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-format
+Nullable<VideoPixelFormat> VideoFrame::GetFormat() const {
+ AssertIsOnOwningThread();
+
+ return mResource ? MaybeToNullable(mResource->TryPixelFormat())
+ : Nullable<VideoPixelFormat>();
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-codedwidth
+uint32_t VideoFrame::CodedWidth() const {
+ AssertIsOnOwningThread();
+
+ return static_cast<uint32_t>(mCodedSize.Width());
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-codedheight
+uint32_t VideoFrame::CodedHeight() const {
+ AssertIsOnOwningThread();
+
+ return static_cast<uint32_t>(mCodedSize.Height());
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-codedrect
+already_AddRefed<DOMRectReadOnly> VideoFrame::GetCodedRect() const {
+ AssertIsOnOwningThread();
+
+ return mResource
+ ? MakeAndAddRef<DOMRectReadOnly>(
+ mParent, 0.0f, 0.0f, static_cast<double>(mCodedSize.Width()),
+ static_cast<double>(mCodedSize.Height()))
+ : nullptr;
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-visiblerect
+already_AddRefed<DOMRectReadOnly> VideoFrame::GetVisibleRect() const {
+ AssertIsOnOwningThread();
+
+ return mResource ? MakeAndAddRef<DOMRectReadOnly>(
+ mParent, static_cast<double>(mVisibleRect.X()),
+ static_cast<double>(mVisibleRect.Y()),
+ static_cast<double>(mVisibleRect.Width()),
+ static_cast<double>(mVisibleRect.Height()))
+ : nullptr;
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-displaywidth
+uint32_t VideoFrame::DisplayWidth() const {
+ AssertIsOnOwningThread();
+
+ return static_cast<uint32_t>(mDisplaySize.Width());
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-displayheight
+uint32_t VideoFrame::DisplayHeight() const {
+ AssertIsOnOwningThread();
+
+ return static_cast<uint32_t>(mDisplaySize.Height());
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-duration
+Nullable<uint64_t> VideoFrame::GetDuration() const {
+ AssertIsOnOwningThread();
+ return MaybeToNullable(mDuration);
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-timestamp
+int64_t VideoFrame::Timestamp() const {
+ AssertIsOnOwningThread();
+
+ return mTimestamp;
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-colorspace
+already_AddRefed<VideoColorSpace> VideoFrame::ColorSpace() const {
+ AssertIsOnOwningThread();
+
+ return MakeAndAddRef<VideoColorSpace>(mParent, mColorSpace);
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-allocationsize
+uint32_t VideoFrame::AllocationSize(const VideoFrameCopyToOptions& aOptions,
+ ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ if (!mResource) {
+ aRv.ThrowInvalidStateError("No media resource in VideoFrame");
+ return 0;
+ }
+
+ if (!mResource->mFormat) {
+ aRv.ThrowAbortError("The VideoFrame image format is not VideoPixelFormat");
+ return 0;
+ }
+
+ auto r = ParseVideoFrameCopyToOptions(aOptions, mVisibleRect, mCodedSize,
+ mResource->mFormat.ref());
+ if (r.isErr()) {
+ // TODO: Should throw layout.
+ aRv.ThrowTypeError(r.unwrapErr());
+ return 0;
+ }
+ CombinedBufferLayout layout = r.unwrap();
+
+ return layout.mAllocationSize;
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-copyto
+already_AddRefed<Promise> VideoFrame::CopyTo(
+ const MaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aDestination,
+ const VideoFrameCopyToOptions& aOptions, ErrorResult& aRv) {
+ AssertIsOnOwningThread();
+
+ if (!mResource) {
+ aRv.ThrowInvalidStateError("No media resource in VideoFrame");
+ return nullptr;
+ }
+
+ if (!mResource->mFormat) {
+ aRv.ThrowNotSupportedError("VideoFrame's image format is unrecognized");
+ return nullptr;
+ }
+
+ RefPtr<Promise> p = Promise::Create(mParent.get(), aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return p.forget();
+ }
+
+ CombinedBufferLayout layout;
+ auto r1 = ParseVideoFrameCopyToOptions(aOptions, mVisibleRect, mCodedSize,
+ mResource->mFormat.ref());
+ if (r1.isErr()) {
+ // TODO: Should reject with layout.
+ p->MaybeRejectWithTypeError(r1.unwrapErr());
+ return p.forget();
+ }
+ layout = r1.unwrap();
+
+ return ProcessTypedArraysFixed(aDestination, [&](const Span<uint8_t>& aData) {
+ if (aData.size_bytes() < layout.mAllocationSize) {
+ p->MaybeRejectWithTypeError("Destination buffer is too small");
+ return p.forget();
+ }
+
+ Sequence<PlaneLayout> planeLayouts;
+
+ nsTArray<Format::Plane> planes = mResource->mFormat->Planes();
+ MOZ_ASSERT(layout.mComputedLayouts.Length() == planes.Length());
+
+ // TODO: These jobs can be run in a thread pool (bug 1780656) to unblock
+ // the current thread.
+ for (size_t i = 0; i < layout.mComputedLayouts.Length(); ++i) {
+ ComputedPlaneLayout& l = layout.mComputedLayouts[i];
+ uint32_t destinationOffset = l.mDestinationOffset;
+
+ PlaneLayout* pl = planeLayouts.AppendElement(fallible);
+ if (!pl) {
+ p->MaybeRejectWithTypeError("Out of memory");
+ return p.forget();
+ }
+ pl->mOffset = l.mDestinationOffset;
+ pl->mStride = l.mDestinationStride;
+
+ // Copy pixels of `size` starting from `origin` on planes[i] to
+ // `aDestination`.
+ gfx::IntPoint origin(
+ l.mSourceLeftBytes / mResource->mFormat->SampleBytes(planes[i]),
+ l.mSourceTop);
+ gfx::IntSize size(
+ l.mSourceWidthBytes / mResource->mFormat->SampleBytes(planes[i]),
+ l.mSourceHeight);
+ if (!mResource->CopyTo(planes[i], {origin, size},
+ aData.From(destinationOffset),
+ static_cast<size_t>(l.mDestinationStride))) {
+ p->MaybeRejectWithTypeError(
+ nsPrintfCString("Failed to copy image data in %s plane",
+ mResource->mFormat->PlaneName(planes[i])));
+ return p.forget();
+ }
+ }
+
+ MOZ_ASSERT(layout.mComputedLayouts.Length() == planes.Length());
+ // TODO: Spec doesn't resolve with a value. See
+ // https://github.com/w3c/webcodecs/issues/510 This comment should be
+ // removed once the issue is resolved.
+ p->MaybeResolve(planeLayouts);
+ return p.forget();
+ });
+}
+
+// https://w3c.github.io/webcodecs/#dom-videoframe-clone
+already_AddRefed<VideoFrame> VideoFrame::Clone(ErrorResult& aRv) const {
+ AssertIsOnOwningThread();
+
+ if (!mResource) {
+ aRv.ThrowInvalidStateError("No media resource in the VideoFrame now");
+ return nullptr;
+ }
+ // The VideoFrame's data must be shared instead of copied:
+ // https://w3c.github.io/webcodecs/#raw-media-memory-model-reference-counting
+ return MakeAndAddRef<VideoFrame>(*this);
+}
+
+// https://w3c.github.io/webcodecs/#close-videoframe
+void VideoFrame::Close() {
+ AssertIsOnOwningThread();
+ LOG("VideoFrame %p is closed", this);
+
+ mResource.reset();
+ mCodedSize = gfx::IntSize();
+ mVisibleRect = gfx::IntRect();
+ mDisplaySize = gfx::IntSize();
+ mColorSpace = VideoColorSpaceInit();
+
+ StopAutoClose();
+}
+
+bool VideoFrame::IsClosed() const { return !mResource; }
+
+already_AddRefed<layers::Image> VideoFrame::GetImage() const {
+ if (!mResource) {
+ return nullptr;
+ }
+ return do_AddRef(mResource->mImage);
+}
+
+nsCString VideoFrame::ToString() const {
+ nsCString rv;
+
+ if (IsClosed()) {
+ rv.AppendPrintf("VideoFrame (closed)");
+ return rv;
+ }
+
+ rv.AppendPrintf(
+ "VideoFrame ts: %" PRId64
+ ", %s, coded[%dx%d] visible[%dx%d], display[%dx%d] color: %s",
+ mTimestamp,
+ dom::VideoPixelFormatValues::GetString(mResource->mFormat->PixelFormat())
+ .data(),
+ mCodedSize.width, mCodedSize.height, mVisibleRect.width,
+ mVisibleRect.height, mDisplaySize.width, mDisplaySize.height,
+ ColorSpaceInitToString(mColorSpace).get());
+
+ if (mDuration) {
+ rv.AppendPrintf(" dur: %" PRId64, mDuration.value());
+ }
+
+ return rv;
+}
+
+// https://w3c.github.io/webcodecs/#ref-for-deserialization-steps%E2%91%A0
+/* static */
+JSObject* VideoFrame::ReadStructuredClone(
+ JSContext* aCx, nsIGlobalObject* aGlobal, JSStructuredCloneReader* aReader,
+ const VideoFrameSerializedData& aData) {
+ JS::Rooted<JS::Value> value(aCx, JS::NullValue());
+ // To avoid a rooting hazard error from returning a raw JSObject* before
+ // running the RefPtr destructor, RefPtr needs to be destructed before
+ // returning the raw JSObject*, which is why the RefPtr<VideoFrame> is created
+ // in the scope below. Otherwise, the static analysis infers the RefPtr cannot
+ // be safely destructed while the unrooted return JSObject* is on the stack.
+ {
+ RefPtr<VideoFrame> frame = MakeAndAddRef<VideoFrame>(aGlobal, aData);
+ if (!GetOrCreateDOMReflector(aCx, frame, &value) || !value.isObject()) {
+ return nullptr;
+ }
+ }
+ return value.toObjectOrNull();
+}
+
+// https://w3c.github.io/webcodecs/#ref-for-serialization-steps%E2%91%A0
+bool VideoFrame::WriteStructuredClone(JSStructuredCloneWriter* aWriter,
+ StructuredCloneHolder* aHolder) const {
+ AssertIsOnOwningThread();
+
+ if (!mResource) {
+ return false;
+ }
+
+ // Indexing the image and send the index to the receiver.
+ const uint32_t index = aHolder->VideoFrames().Length();
+ // The serialization is limited to the same process scope so it's ok to
+ // serialize a reference instead of a copy.
+ aHolder->VideoFrames().AppendElement(
+ VideoFrameSerializedData(GetVideoFrameData(), mCodedSize));
+
+ return !NS_WARN_IF(!JS_WriteUint32Pair(aWriter, SCTAG_DOM_VIDEOFRAME, index));
+}
+
+// https://w3c.github.io/webcodecs/#ref-for-transfer-steps%E2%91%A0
+UniquePtr<VideoFrame::TransferredData> VideoFrame::Transfer() {
+ AssertIsOnOwningThread();
+
+ if (!mResource) {
+ return nullptr;
+ }
+
+ auto frame = MakeUnique<TransferredData>(GetVideoFrameData(), mCodedSize);
+ Close();
+ return frame;
+}
+
+// https://w3c.github.io/webcodecs/#ref-for-transfer-receiving-steps%E2%91%A0
+/* static */
+already_AddRefed<VideoFrame> VideoFrame::FromTransferred(
+ nsIGlobalObject* aGlobal, TransferredData* aData) {
+ MOZ_ASSERT(aData);
+
+ return MakeAndAddRef<VideoFrame>(aGlobal, *aData);
+}
+
+VideoFrameData VideoFrame::GetVideoFrameData() const {
+ return VideoFrameData(mResource->mImage.get(), mResource->TryPixelFormat(),
+ mVisibleRect, mDisplaySize, mDuration, mTimestamp,
+ mColorSpace);
+}
+
+void VideoFrame::StartAutoClose() {
+ AssertIsOnOwningThread();
+
+ LOG("VideoFrame %p, start monitoring resource release", this);
+
+ if (NS_IsMainThread()) {
+ mShutdownBlocker = media::ShutdownBlockingTicket::Create(
+ u"VideoFrame::mShutdownBlocker"_ns,
+ NS_LITERAL_STRING_FROM_CSTRING(__FILE__), __LINE__);
+ if (mShutdownBlocker) {
+ mShutdownBlocker->ShutdownPromise()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr{this}](bool /* aUnUsed*/) {
+ LOG("VideoFrame %p gets shutdown notification", self.get());
+ self->CloseIfNeeded();
+ },
+ [self = RefPtr{this}](bool /* aUnUsed*/) {
+ LOG("VideoFrame %p removes shutdown-blocker before getting "
+ "shutdown "
+ "notification",
+ self.get());
+ });
+ }
+ } else if (WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate()) {
+ // Clean up all the resources when the worker is going away.
+ mWorkerRef = WeakWorkerRef::Create(workerPrivate, [self = RefPtr{this}]() {
+ LOG("VideoFrame %p, worker is going away", self.get());
+ self->CloseIfNeeded();
+ });
+ }
+}
+
+void VideoFrame::StopAutoClose() {
+ AssertIsOnOwningThread();
+
+ LOG("VideoFrame %p, stop monitoring resource release", this);
+
+ mShutdownBlocker = nullptr;
+ mWorkerRef = nullptr;
+}
+
+void VideoFrame::CloseIfNeeded() {
+ AssertIsOnOwningThread();
+
+ LOG("VideoFrame %p, needs to close itself? %s", this,
+ IsClosed() ? "no" : "yes");
+ if (!IsClosed()) {
+ LOG("Close VideoFrame %p obligatorily", this);
+ Close();
+ }
+}
+
+/*
+ * VideoFrame::Format
+ *
+ * This class wraps a VideoPixelFormat defined in [1] and provides some
+ * utilities for the VideoFrame's functions. Each sample in the format is 8
+ * bits. The pixel layouts for a 4 x 2 image in the spec are illustrated below:
+ * [1] https://w3c.github.io/webcodecs/#pixel-format
+ *
+ * I420 - 3 planes: Y, U, V
+ * ------
+ * <- width ->
+ * Y: Y1 Y2 Y3 Y4 ^ height
+ * Y5 Y6 Y7 Y8 v
+ * U: U1 U2 => 1/2 Y's width, 1/2 Y's height
+ * V: V1 V2 => 1/2 Y's width, 1/2 Y's height
+ *
+ * I420A - 4 planes: Y, U, V, A
+ * ------
+ * <- width ->
+ * Y: Y1 Y2 Y3 Y4 ^ height
+ * Y5 Y6 Y7 Y8 v
+ * U: U1 U2 => 1/2 Y's width, 1/2 Y's height
+ * V: V1 V2 => 1/2 Y's width, 1/2 Y's height
+ * A: A1 A2 A3 A4 => Y's width, Y's height
+ * A5 A6 A7 A8
+ *
+ * I422 - 3 planes: Y, U, V
+ * ------
+ * <- width ->
+ * Y: Y1 Y2 Y3 Y4 ^ height
+ * Y5 Y6 Y7 Y8 v
+ * U: U1 U2 U3 U4 => Y's width, 1/2 Y's height
+ * V: V1 V2 V3 V4 => Y's width, 1/2 Y's height
+ *
+ * I444 - 3 planes: Y, U, V
+ * ------
+ * <- width ->
+ * Y: Y1 Y2 Y3 Y4 ^ height
+ * Y5 Y6 Y7 Y8 v
+ * U: U1 U2 U3 U4 => Y's width, Y's height
+ * U5 U6 U7 U8
+ * V: V1 V2 V3 V4 => Y's width, Y's height
+ * V5 V6 V7 B8
+ *
+ * NV12 - 2 planes: Y, UV
+ * ------
+ * <- width ->
+ * Y: Y1 Y2 Y3 Y4 ^ height
+ * Y5 Y6 Y7 Y8 v
+ * UV: U1 V1 U2 V2 => Y's width, 1/2 Y's height
+ *
+ * RGBA - 1 plane encoding 3 colors: Red, Green, Blue, and an Alpha value
+ * ------
+ * <---------------------- width ---------------------->
+ * R1 G1 B1 A1 | R2 G2 B2 A2 | R3 G3 B3 A3 | R4 G4 B4 A4 ^ height
+ * R5 G5 B5 A5 | R6 G6 B6 A6 | R7 G7 B7 A7 | R8 G8 B8 A8 v
+ *
+ * RGBX - 1 plane encoding 3 colors: Red, Green, Blue, and an padding value
+ * This is the opaque version of RGBA
+ * ------
+ * <---------------------- width ---------------------->
+ * R1 G1 B1 X1 | R2 G2 B2 X2 | R3 G3 B3 X3 | R4 G4 B4 X4 ^ height
+ * R5 G5 B5 X5 | R6 G6 B6 X6 | R7 G7 B7 X7 | R8 G8 B8 X8 v
+ *
+ * BGRA - 1 plane encoding 3 colors: Blue, Green, Red, and an Alpha value
+ * ------
+ * <---------------------- width ---------------------->
+ * B1 G1 R1 A1 | B2 G2 R2 A2 | B3 G3 R3 A3 | B4 G4 R4 A4 ^ height
+ * B5 G5 R5 A5 | B6 G6 R6 A6 | B7 G7 R7 A7 | B8 G8 R8 A8 v
+ *
+ * BGRX - 1 plane encoding 3 colors: Blue, Green, Red, and an padding value
+ * This is the opaque version of BGRA
+ * ------
+ * <---------------------- width ---------------------->
+ * B1 G1 R1 X1 | B2 G2 R2 X2 | B3 G3 R3 X3 | B4 G4 R4 X4 ^ height
+ * B5 G5 R5 X5 | B6 G6 R6 X6 | B7 G7 R7 X7 | B8 G8 R8 X8 v
+ */
+
+VideoFrame::Format::Format(const VideoPixelFormat& aFormat)
+ : mFormat(aFormat) {}
+
+const VideoPixelFormat& VideoFrame::Format::PixelFormat() const {
+ return mFormat;
+}
+
+gfx::SurfaceFormat VideoFrame::Format::ToSurfaceFormat() const {
+ gfx::SurfaceFormat format = gfx::SurfaceFormat::UNKNOWN;
+ switch (mFormat) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::NV12:
+ // Not yet support for now.
+ break;
+ case VideoPixelFormat::RGBA:
+ format = gfx::SurfaceFormat::R8G8B8A8;
+ break;
+ case VideoPixelFormat::RGBX:
+ format = gfx::SurfaceFormat::R8G8B8X8;
+ break;
+ case VideoPixelFormat::BGRA:
+ format = gfx::SurfaceFormat::B8G8R8A8;
+ break;
+ case VideoPixelFormat::BGRX:
+ format = gfx::SurfaceFormat::B8G8R8X8;
+ break;
+ case VideoPixelFormat::EndGuard_:
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+ }
+ return format;
+}
+
+void VideoFrame::Format::MakeOpaque() {
+ switch (mFormat) {
+ case VideoPixelFormat::I420A:
+ mFormat = VideoPixelFormat::I420;
+ return;
+ case VideoPixelFormat::RGBA:
+ mFormat = VideoPixelFormat::RGBX;
+ return;
+ case VideoPixelFormat::BGRA:
+ mFormat = VideoPixelFormat::BGRX;
+ return;
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::NV12:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRX:
+ return;
+ case VideoPixelFormat::EndGuard_:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+}
+
+nsTArray<VideoFrame::Format::Plane> VideoFrame::Format::Planes() const {
+ switch (mFormat) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ return {Plane::Y, Plane::U, Plane::V};
+ case VideoPixelFormat::I420A:
+ return {Plane::Y, Plane::U, Plane::V, Plane::A};
+ case VideoPixelFormat::NV12:
+ return {Plane::Y, Plane::UV};
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ return {Plane::RGBA};
+ case VideoPixelFormat::EndGuard_:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+ return {};
+}
+
+const char* VideoFrame::Format::PlaneName(const Plane& aPlane) const {
+ switch (aPlane) {
+ case Format::Plane::Y: // and RGBA
+ return IsYUV() ? "Y" : "RGBA";
+ case Format::Plane::U: // and UV
+ MOZ_ASSERT(IsYUV());
+ return mFormat == VideoPixelFormat::NV12 ? "UV" : "U";
+ case Format::Plane::V:
+ MOZ_ASSERT(IsYUV());
+ return "V";
+ case Format::Plane::A:
+ MOZ_ASSERT(IsYUV());
+ return "A";
+ }
+ MOZ_ASSERT_UNREACHABLE("invalid plane");
+ return "Unknown";
+}
+
+uint32_t VideoFrame::Format::SampleBytes(const Plane& aPlane) const {
+ switch (mFormat) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ return 1; // 8 bits/sample on the Y, U, V, A plane.
+ case VideoPixelFormat::NV12:
+ switch (aPlane) {
+ case Plane::Y:
+ return 1; // 8 bits/sample on the Y plane
+ case Plane::UV:
+ return 2; // Interleaved U and V values on the UV plane.
+ case Plane::V:
+ case Plane::A:
+ MOZ_ASSERT_UNREACHABLE("invalid plane");
+ }
+ return 0;
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ return 4; // 8 bits/sample, 32 bits/pixel
+ case VideoPixelFormat::EndGuard_:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+ return 0;
+}
+
+gfx::IntSize VideoFrame::Format::SampleSize(const Plane& aPlane) const {
+ // The sample width and height refers to
+ // https://w3c.github.io/webcodecs/#sub-sampling-factor
+ switch (aPlane) {
+ case Plane::Y: // and RGBA
+ case Plane::A:
+ return gfx::IntSize(1, 1);
+ case Plane::U: // and UV
+ case Plane::V:
+ switch (mFormat) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::NV12:
+ return gfx::IntSize(2, 2);
+ case VideoPixelFormat::I422:
+ return gfx::IntSize(2, 1);
+ case VideoPixelFormat::I444:
+ return gfx::IntSize(1, 1);
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ case VideoPixelFormat::EndGuard_:
+ MOZ_ASSERT_UNREACHABLE("invalid format");
+ return {0, 0};
+ }
+ }
+ MOZ_ASSERT_UNREACHABLE("invalid plane");
+ return {0, 0};
+}
+
+bool VideoFrame::Format::IsValidSize(const gfx::IntSize& aSize) const {
+ switch (mFormat) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::NV12:
+ return (aSize.Width() % 2 == 0) && (aSize.Height() % 2 == 0);
+ case VideoPixelFormat::I422:
+ return aSize.Height() % 2 == 0;
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ return true;
+ case VideoPixelFormat::EndGuard_:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+ return false;
+}
+
+size_t VideoFrame::Format::SampleCount(const gfx::IntSize& aSize) const {
+ MOZ_ASSERT(IsValidSize(aSize));
+
+ CheckedInt<size_t> count(aSize.Width());
+ count *= aSize.Height();
+
+ switch (mFormat) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::NV12:
+ return (count + count / 2).value();
+ case VideoPixelFormat::I420A:
+ return (count * 2 + count / 2).value();
+ case VideoPixelFormat::I422:
+ return (count * 2).value();
+ case VideoPixelFormat::I444:
+ return (count * 3).value();
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ return (count * 4).value();
+ case VideoPixelFormat::EndGuard_:
+ break;
+ }
+
+ MOZ_ASSERT_UNREACHABLE("unsupported format");
+ return 0;
+}
+
+bool VideoFrame::Format::IsYUV() const { return IsYUVFormat(mFormat); }
+
+/*
+ * VideoFrame::Resource
+ */
+
+VideoFrame::Resource::Resource(const RefPtr<layers::Image>& aImage,
+ Maybe<class Format>&& aFormat)
+ : mImage(aImage), mFormat(aFormat) {
+ MOZ_ASSERT(mImage);
+}
+
+VideoFrame::Resource::Resource(const Resource& aOther)
+ : mImage(aOther.mImage), mFormat(aOther.mFormat) {
+ MOZ_ASSERT(mImage);
+}
+
+Maybe<VideoPixelFormat> VideoFrame::Resource::TryPixelFormat() const {
+ return mFormat ? Some(mFormat->PixelFormat()) : Nothing();
+}
+
+uint32_t VideoFrame::Resource::Stride(const Format::Plane& aPlane) const {
+ MOZ_RELEASE_ASSERT(mFormat);
+
+ CheckedInt<uint32_t> width(mImage->GetSize().Width());
+ switch (aPlane) {
+ case Format::Plane::Y: // and RGBA
+ case Format::Plane::A:
+ switch (mFormat->PixelFormat()) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::NV12:
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ return (width * mFormat->SampleBytes(aPlane)).value();
+ case VideoPixelFormat::EndGuard_:
+ MOZ_ASSERT_UNREACHABLE("invalid format");
+ }
+ return 0;
+ case Format::Plane::U: // and UV
+ case Format::Plane::V:
+ switch (mFormat->PixelFormat()) {
+ case VideoPixelFormat::I420:
+ case VideoPixelFormat::I420A:
+ case VideoPixelFormat::I422:
+ case VideoPixelFormat::I444:
+ case VideoPixelFormat::NV12:
+ return (((width + 1) / 2) * mFormat->SampleBytes(aPlane)).value();
+ case VideoPixelFormat::RGBA:
+ case VideoPixelFormat::RGBX:
+ case VideoPixelFormat::BGRA:
+ case VideoPixelFormat::BGRX:
+ case VideoPixelFormat::EndGuard_:
+ MOZ_ASSERT_UNREACHABLE("invalid format");
+ }
+ return 0;
+ }
+ MOZ_ASSERT_UNREACHABLE("invalid plane");
+ return 0;
+}
+
+bool VideoFrame::Resource::CopyTo(const Format::Plane& aPlane,
+ const gfx::IntRect& aRect,
+ Span<uint8_t>&& aPlaneDest,
+ size_t aDestinationStride) const {
+ if (!mFormat) {
+ return false;
+ }
+
+ auto copyPlane = [&](const uint8_t* aPlaneData) {
+ MOZ_ASSERT(aPlaneData);
+
+ CheckedInt<size_t> offset(aRect.Y());
+ offset *= Stride(aPlane);
+ offset += aRect.X() * mFormat->SampleBytes(aPlane);
+ if (!offset.isValid()) {
+ return false;
+ }
+
+ CheckedInt<size_t> elementsBytes(aRect.Width());
+ elementsBytes *= mFormat->SampleBytes(aPlane);
+ if (!elementsBytes.isValid()) {
+ return false;
+ }
+
+ aPlaneData += offset.value();
+ for (int32_t row = 0; row < aRect.Height(); ++row) {
+ PodCopy(aPlaneDest.data(), aPlaneData, elementsBytes.value());
+ aPlaneData += Stride(aPlane);
+ // Spec asks to move `aDestinationStride` bytes instead of
+ // `Stride(aPlane)` forward.
+ aPlaneDest = aPlaneDest.From(aDestinationStride);
+ }
+ return true;
+ };
+
+ if (mImage->GetFormat() == ImageFormat::MOZ2D_SURFACE) {
+ RefPtr<gfx::SourceSurface> surface = mImage->GetAsSourceSurface();
+ if (NS_WARN_IF(!surface)) {
+ return false;
+ }
+
+ RefPtr<gfx::DataSourceSurface> dataSurface = surface->GetDataSurface();
+ if (NS_WARN_IF(!dataSurface)) {
+ return false;
+ }
+
+ gfx::DataSourceSurface::ScopedMap map(dataSurface,
+ gfx::DataSourceSurface::READ);
+ if (NS_WARN_IF(!map.IsMapped())) {
+ return false;
+ }
+
+ const gfx::SurfaceFormat format = dataSurface->GetFormat();
+
+ if (format == gfx::SurfaceFormat::R8G8B8A8 ||
+ format == gfx::SurfaceFormat::R8G8B8X8 ||
+ format == gfx::SurfaceFormat::B8G8R8A8 ||
+ format == gfx::SurfaceFormat::B8G8R8X8) {
+ MOZ_ASSERT(aPlane == Format::Plane::RGBA);
+
+ // The mImage's format can be different from mFormat (since Gecko prefers
+ // BGRA). To get the data in the matched format, we create a temp buffer
+ // holding the image data in that format and then copy them to
+ // `aDestination`.
+ const gfx::SurfaceFormat f = mFormat->ToSurfaceFormat();
+ MOZ_ASSERT(f == gfx::SurfaceFormat::R8G8B8A8 ||
+ f == gfx::SurfaceFormat::R8G8B8X8 ||
+ f == gfx::SurfaceFormat::B8G8R8A8 ||
+ f == gfx::SurfaceFormat::B8G8R8X8);
+
+ // TODO: We could use Factory::CreateWrappingDataSourceSurface to wrap
+ // `aDestination` to avoid extra copy.
+ RefPtr<gfx::DataSourceSurface> tempSurface =
+ gfx::Factory::CreateDataSourceSurfaceWithStride(
+ dataSurface->GetSize(), f, map.GetStride());
+ if (NS_WARN_IF(!tempSurface)) {
+ return false;
+ }
+
+ gfx::DataSourceSurface::ScopedMap tempMap(tempSurface,
+ gfx::DataSourceSurface::WRITE);
+ if (NS_WARN_IF(!tempMap.IsMapped())) {
+ return false;
+ }
+
+ if (!gfx::SwizzleData(map.GetData(), map.GetStride(),
+ dataSurface->GetFormat(), tempMap.GetData(),
+ tempMap.GetStride(), tempSurface->GetFormat(),
+ tempSurface->GetSize())) {
+ return false;
+ }
+
+ return copyPlane(tempMap.GetData());
+ }
+
+ return false;
+ }
+
+ if (mImage->GetFormat() == ImageFormat::PLANAR_YCBCR) {
+ switch (aPlane) {
+ case Format::Plane::Y:
+ return copyPlane(mImage->AsPlanarYCbCrImage()->GetData()->mYChannel);
+ case Format::Plane::U:
+ return copyPlane(mImage->AsPlanarYCbCrImage()->GetData()->mCbChannel);
+ case Format::Plane::V:
+ return copyPlane(mImage->AsPlanarYCbCrImage()->GetData()->mCrChannel);
+ case Format::Plane::A:
+ MOZ_ASSERT(mFormat->PixelFormat() == VideoPixelFormat::I420A);
+ MOZ_ASSERT(mImage->AsPlanarYCbCrImage()->GetData()->mAlpha);
+ return copyPlane(
+ mImage->AsPlanarYCbCrImage()->GetData()->mAlpha->mChannel);
+ }
+ MOZ_ASSERT_UNREACHABLE("invalid plane");
+ }
+
+ if (mImage->GetFormat() == ImageFormat::NV_IMAGE) {
+ switch (aPlane) {
+ case Format::Plane::Y:
+ return copyPlane(mImage->AsNVImage()->GetData()->mYChannel);
+ case Format::Plane::UV:
+ return copyPlane(mImage->AsNVImage()->GetData()->mCbChannel);
+ case Format::Plane::V:
+ case Format::Plane::A:
+ MOZ_ASSERT_UNREACHABLE("invalid plane");
+ }
+ }
+
+ // TODO: ImageFormat::MAC_IOSURFACE or ImageFormat::DMABUF
+ LOGW("Cannot copy image data of an unrecognized format");
+
+ return false;
+}
+
+#undef LOGW
+#undef LOG_INTERNAL
+
+} // namespace mozilla::dom
diff --git a/dom/media/webcodecs/VideoFrame.h b/dom/media/webcodecs/VideoFrame.h
new file mode 100644
index 0000000000..0bef496b79
--- /dev/null
+++ b/dom/media/webcodecs/VideoFrame.h
@@ -0,0 +1,266 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef mozilla_dom_VideoFrame_h
+#define mozilla_dom_VideoFrame_h
+
+#include "js/TypeDecls.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/ErrorResult.h"
+#include "mozilla/NotNull.h"
+#include "mozilla/Span.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/TypedArray.h"
+#include "mozilla/dom/VideoColorSpaceBinding.h"
+#include "mozilla/dom/WorkerRef.h"
+#include "mozilla/gfx/Point.h"
+#include "mozilla/gfx/Rect.h"
+#include "mozilla/media/MediaUtils.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+
+class nsIGlobalObject;
+class nsIURI;
+
+namespace mozilla {
+
+namespace layers {
+class Image;
+} // namespace layers
+
+namespace dom {
+
+class DOMRectReadOnly;
+class HTMLCanvasElement;
+class HTMLImageElement;
+class HTMLVideoElement;
+class ImageBitmap;
+class MaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer;
+class OffscreenCanvas;
+class OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer;
+class Promise;
+class SVGImageElement;
+class StructuredCloneHolder;
+class VideoColorSpace;
+class VideoFrame;
+enum class VideoPixelFormat : uint8_t;
+struct VideoFrameBufferInit;
+struct VideoFrameInit;
+struct VideoFrameCopyToOptions;
+
+} // namespace dom
+} // namespace mozilla
+
+namespace mozilla::dom {
+
+struct VideoFrameData {
+ VideoFrameData(layers::Image* aImage, const Maybe<VideoPixelFormat>& aFormat,
+ gfx::IntRect aVisibleRect, gfx::IntSize aDisplaySize,
+ Maybe<uint64_t> aDuration, int64_t aTimestamp,
+ const VideoColorSpaceInit& aColorSpace);
+ VideoFrameData(const VideoFrameData& aData) = default;
+
+ const RefPtr<layers::Image> mImage;
+ const Maybe<VideoPixelFormat> mFormat;
+ const gfx::IntRect mVisibleRect;
+ const gfx::IntSize mDisplaySize;
+ const Maybe<uint64_t> mDuration;
+ const int64_t mTimestamp;
+ const VideoColorSpaceInit mColorSpace;
+};
+
+struct VideoFrameSerializedData : VideoFrameData {
+ VideoFrameSerializedData(const VideoFrameData& aData,
+ gfx::IntSize aCodedSize);
+
+ const gfx::IntSize mCodedSize;
+};
+
+class VideoFrame final : public nsISupports, public nsWrapperCache {
+ public:
+ NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+ NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(VideoFrame)
+
+ public:
+ VideoFrame(nsIGlobalObject* aParent, const RefPtr<layers::Image>& aImage,
+ const Maybe<VideoPixelFormat>& aFormat, gfx::IntSize aCodedSize,
+ gfx::IntRect aVisibleRect, gfx::IntSize aDisplaySize,
+ const Maybe<uint64_t>& aDuration, int64_t aTimestamp,
+ const VideoColorSpaceInit& aColorSpace);
+ VideoFrame(nsIGlobalObject* aParent, const VideoFrameSerializedData& aData);
+ VideoFrame(const VideoFrame& aOther);
+
+ protected:
+ ~VideoFrame();
+
+ public:
+ nsIGlobalObject* GetParentObject() const;
+
+ JSObject* WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) override;
+
+ static already_AddRefed<VideoFrame> Constructor(
+ const GlobalObject& aGlobal, HTMLImageElement& aImageElement,
+ const VideoFrameInit& aInit, ErrorResult& aRv);
+ static already_AddRefed<VideoFrame> Constructor(
+ const GlobalObject& aGlobal, SVGImageElement& aSVGImageElement,
+ const VideoFrameInit& aInit, ErrorResult& aRv);
+ static already_AddRefed<VideoFrame> Constructor(
+ const GlobalObject& aGlobal, HTMLCanvasElement& aCanvasElement,
+ const VideoFrameInit& aInit, ErrorResult& aRv);
+ static already_AddRefed<VideoFrame> Constructor(
+ const GlobalObject& aGlobal, HTMLVideoElement& aVideoElement,
+ const VideoFrameInit& aInit, ErrorResult& aRv);
+ static already_AddRefed<VideoFrame> Constructor(
+ const GlobalObject& aGlobal, OffscreenCanvas& aOffscreenCanvas,
+ const VideoFrameInit& aInit, ErrorResult& aRv);
+ static already_AddRefed<VideoFrame> Constructor(const GlobalObject& aGlobal,
+ ImageBitmap& aImageBitmap,
+ const VideoFrameInit& aInit,
+ ErrorResult& aRv);
+ static already_AddRefed<VideoFrame> Constructor(const GlobalObject& aGlobal,
+ VideoFrame& aVideoFrame,
+ const VideoFrameInit& aInit,
+ ErrorResult& aRv);
+ static already_AddRefed<VideoFrame> Constructor(
+ const GlobalObject& aGlobal, const ArrayBufferView& aBufferView,
+ const VideoFrameBufferInit& aInit, ErrorResult& aRv);
+ static already_AddRefed<VideoFrame> Constructor(
+ const GlobalObject& aGlobal, const ArrayBuffer& aBuffer,
+ const VideoFrameBufferInit& aInit, ErrorResult& aRv);
+
+ Nullable<VideoPixelFormat> GetFormat() const;
+
+ uint32_t CodedWidth() const;
+
+ uint32_t CodedHeight() const;
+
+ already_AddRefed<DOMRectReadOnly> GetCodedRect() const;
+
+ already_AddRefed<DOMRectReadOnly> GetVisibleRect() const;
+
+ uint32_t DisplayWidth() const;
+
+ uint32_t DisplayHeight() const;
+
+ Nullable<uint64_t> GetDuration() const;
+
+ int64_t Timestamp() const;
+
+ already_AddRefed<VideoColorSpace> ColorSpace() const;
+
+ uint32_t AllocationSize(const VideoFrameCopyToOptions& aOptions,
+ ErrorResult& aRv);
+
+ already_AddRefed<Promise> CopyTo(
+ const MaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aDestination,
+ const VideoFrameCopyToOptions& aOptions, ErrorResult& aRv);
+
+ already_AddRefed<VideoFrame> Clone(ErrorResult& aRv) const;
+
+ void Close();
+ bool IsClosed() const;
+
+ // [Serializable] implementations: {Read, Write}StructuredClone
+ static JSObject* ReadStructuredClone(JSContext* aCx, nsIGlobalObject* aGlobal,
+ JSStructuredCloneReader* aReader,
+ const VideoFrameSerializedData& aData);
+
+ bool WriteStructuredClone(JSStructuredCloneWriter* aWriter,
+ StructuredCloneHolder* aHolder) const;
+
+ // [Transferable] implementations: Transfer, FromTransferred
+ using TransferredData = VideoFrameSerializedData;
+
+ UniquePtr<TransferredData> Transfer();
+
+ static already_AddRefed<VideoFrame> FromTransferred(nsIGlobalObject* aGlobal,
+ TransferredData* aData);
+
+ // Native only methods.
+ const gfx::IntSize& NativeCodedSize() const { return mCodedSize; }
+ const gfx::IntSize& NativeDisplaySize() const { return mDisplaySize; }
+ const gfx::IntRect& NativeVisibleRect() const { return mVisibleRect; }
+ already_AddRefed<layers::Image> GetImage() const;
+
+ nsCString ToString() const;
+
+ public:
+ // A VideoPixelFormat wrapper providing utilities for VideoFrame.
+ class Format final {
+ public:
+ explicit Format(const VideoPixelFormat& aFormat);
+ ~Format() = default;
+ const VideoPixelFormat& PixelFormat() const;
+ gfx::SurfaceFormat ToSurfaceFormat() const;
+ void MakeOpaque();
+
+ // TODO: Assign unique value for each plane?
+ // The value indicates the order of the plane in format.
+ enum class Plane : uint8_t { Y = 0, RGBA = Y, U = 1, UV = U, V = 2, A = 3 };
+ nsTArray<Plane> Planes() const;
+ const char* PlaneName(const Plane& aPlane) const;
+ uint32_t SampleBytes(const Plane& aPlane) const;
+ gfx::IntSize SampleSize(const Plane& aPlane) const;
+ bool IsValidSize(const gfx::IntSize& aSize) const;
+ size_t SampleCount(const gfx::IntSize& aSize) const;
+
+ private:
+ bool IsYUV() const;
+ VideoPixelFormat mFormat;
+ };
+
+ private:
+ // VideoFrame can run on either main thread or worker thread.
+ void AssertIsOnOwningThread() const { NS_ASSERT_OWNINGTHREAD(VideoFrame); }
+
+ VideoFrameData GetVideoFrameData() const;
+
+ // Below helpers are used to automatically release the holding Resource if
+ // VideoFrame is never Close()d by the users.
+ void StartAutoClose();
+ void StopAutoClose();
+ void CloseIfNeeded();
+
+ // A class representing the VideoFrame's data.
+ class Resource final {
+ public:
+ Resource(const RefPtr<layers::Image>& aImage, Maybe<Format>&& aFormat);
+ Resource(const Resource& aOther);
+ ~Resource() = default;
+ Maybe<VideoPixelFormat> TryPixelFormat() const;
+ uint32_t Stride(const Format::Plane& aPlane) const;
+ bool CopyTo(const Format::Plane& aPlane, const gfx::IntRect& aRect,
+ Span<uint8_t>&& aPlaneDest, size_t aDestinationStride) const;
+
+ const RefPtr<layers::Image> mImage;
+ // Nothing() if mImage is not in VideoPixelFormat
+ const Maybe<Format> mFormat;
+ };
+
+ nsCOMPtr<nsIGlobalObject> mParent;
+
+ // Use Maybe instead of UniquePtr to allow copy ctor.
+ // The mResource's existence is used as the [[Detached]] for [Transferable].
+ Maybe<const Resource> mResource; // Nothing() after `Close()`d
+
+ // TODO: Replace this by mResource->mImage->GetSize()?
+ gfx::IntSize mCodedSize;
+ gfx::IntRect mVisibleRect;
+ gfx::IntSize mDisplaySize;
+
+ Maybe<uint64_t> mDuration;
+ int64_t mTimestamp;
+ VideoColorSpaceInit mColorSpace;
+
+ // The following are used to help monitoring mResource release.
+ UniquePtr<media::ShutdownBlockingTicket> mShutdownBlocker = nullptr;
+ RefPtr<WeakWorkerRef> mWorkerRef = nullptr;
+};
+
+} // namespace mozilla::dom
+
+#endif // mozilla_dom_VideoFrame_h
diff --git a/dom/media/webcodecs/WebCodecsUtils.cpp b/dom/media/webcodecs/WebCodecsUtils.cpp
new file mode 100644
index 0000000000..1e03f616db
--- /dev/null
+++ b/dom/media/webcodecs/WebCodecsUtils.cpp
@@ -0,0 +1,578 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "WebCodecsUtils.h"
+
+#include "DecoderTypes.h"
+#include "VideoUtils.h"
+#include "js/experimental/TypedData.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/dom/ImageBitmapBinding.h"
+#include "mozilla/dom/VideoColorSpaceBinding.h"
+#include "mozilla/dom/VideoFrameBinding.h"
+#include "mozilla/gfx/Types.h"
+#include "nsDebug.h"
+#include "PlatformEncoderModule.h"
+#include "PlatformEncoderModule.h"
+
+extern mozilla::LazyLogModule gWebCodecsLog;
+
+#ifdef LOG_INTERNAL
+# undef LOG_INTERNAL
+#endif // LOG_INTERNAL
+#define LOG_INTERNAL(level, msg, ...) \
+ MOZ_LOG(gWebCodecsLog, LogLevel::level, (msg, ##__VA_ARGS__))
+#ifdef LOG
+# undef LOG
+#endif // LOG
+#define LOG(msg, ...) LOG_INTERNAL(Debug, msg, ##__VA_ARGS__)
+
+namespace mozilla {
+std::atomic<WebCodecsId> sNextId = 0;
+};
+
+namespace mozilla::dom {
+
+/*
+ * The followings are helpers for VideoDecoder methods
+ */
+
+nsTArray<nsCString> GuessContainers(const nsAString& aCodec) {
+ if (IsAV1CodecString(aCodec)) {
+ return {"mp4"_ns, "webm"_ns};
+ }
+
+ if (IsVP9CodecString(aCodec)) {
+ return {"mp4"_ns, "webm"_ns, "ogg"_ns};
+ }
+
+ if (IsVP8CodecString(aCodec)) {
+ return {"webm"_ns, "ogg"_ns, "3gpp"_ns, "3gpp2"_ns, "3gp2"_ns};
+ }
+
+ if (IsH264CodecString(aCodec)) {
+ return {"mp4"_ns, "3gpp"_ns, "3gpp2"_ns, "3gp2"_ns};
+ }
+
+ return {};
+}
+
+Maybe<nsString> ParseCodecString(const nsAString& aCodec) {
+ // Trim the spaces on each end.
+ nsString str(aCodec);
+ str.Trim(" ");
+ nsTArray<nsString> codecs;
+ if (!ParseCodecsString(str, codecs) || codecs.Length() != 1 ||
+ codecs[0] != str) {
+ return Nothing();
+ }
+ return Some(codecs[0]);
+}
+
+/*
+ * The below are helpers to operate ArrayBuffer or ArrayBufferView.
+ */
+
+static std::tuple<JS::ArrayBufferOrView, size_t, size_t> GetArrayBufferInfo(
+ JSContext* aCx,
+ const OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aBuffer) {
+ if (aBuffer.IsArrayBuffer()) {
+ const ArrayBuffer& buffer = aBuffer.GetAsArrayBuffer();
+ size_t length;
+ {
+ bool isShared;
+ uint8_t* data;
+ JS::GetArrayBufferMaybeSharedLengthAndData(buffer.Obj(), &length,
+ &isShared, &data);
+ }
+ return std::make_tuple(JS::ArrayBufferOrView::fromObject(buffer.Obj()),
+ (size_t)0, length);
+ }
+
+ MOZ_ASSERT(aBuffer.IsArrayBufferView());
+ const ArrayBufferView& view = aBuffer.GetAsArrayBufferView();
+ bool isSharedMemory;
+ JS::Rooted<JSObject*> obj(aCx, view.Obj());
+ return std::make_tuple(
+ JS::ArrayBufferOrView::fromObject(
+ JS_GetArrayBufferViewBuffer(aCx, obj, &isSharedMemory)),
+ JS_GetArrayBufferViewByteOffset(obj),
+ JS_GetArrayBufferViewByteLength(obj));
+}
+
+Result<Ok, nsresult> CloneBuffer(
+ JSContext* aCx,
+ OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aDest,
+ const OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aSrc) {
+ std::tuple<JS::ArrayBufferOrView, size_t, size_t> info =
+ GetArrayBufferInfo(aCx, aSrc);
+ JS::Rooted<JS::ArrayBufferOrView> abov(aCx);
+ abov.set(std::get<0>(info));
+ size_t offset = std::get<1>(info);
+ size_t len = std::get<2>(info);
+ if (NS_WARN_IF(!abov)) {
+ return Err(NS_ERROR_UNEXPECTED);
+ }
+
+ JS::Rooted<JSObject*> obj(aCx, abov.asObject());
+ JS::Rooted<JSObject*> cloned(aCx,
+ JS::ArrayBufferClone(aCx, obj, offset, len));
+ if (NS_WARN_IF(!cloned)) {
+ return Err(NS_ERROR_OUT_OF_MEMORY);
+ }
+
+ JS::Rooted<JS::Value> value(aCx, JS::ObjectValue(*cloned));
+ if (NS_WARN_IF(!aDest.Init(aCx, value))) {
+ return Err(NS_ERROR_UNEXPECTED);
+ }
+ return Ok();
+}
+
+/*
+ * The following are utilities to convert between VideoColorSpace values to
+ * gfx's values.
+ */
+
+gfx::ColorRange ToColorRange(bool aIsFullRange) {
+ return aIsFullRange ? gfx::ColorRange::FULL : gfx::ColorRange::LIMITED;
+}
+
+gfx::YUVColorSpace ToColorSpace(VideoMatrixCoefficients aMatrix) {
+ switch (aMatrix) {
+ case VideoMatrixCoefficients::Rgb:
+ return gfx::YUVColorSpace::Identity;
+ case VideoMatrixCoefficients::Bt709:
+ case VideoMatrixCoefficients::Bt470bg:
+ return gfx::YUVColorSpace::BT709;
+ case VideoMatrixCoefficients::Smpte170m:
+ return gfx::YUVColorSpace::BT601;
+ case VideoMatrixCoefficients::Bt2020_ncl:
+ return gfx::YUVColorSpace::BT2020;
+ case VideoMatrixCoefficients::EndGuard_:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported VideoMatrixCoefficients");
+ return gfx::YUVColorSpace::Default;
+}
+
+gfx::TransferFunction ToTransferFunction(
+ VideoTransferCharacteristics aTransfer) {
+ switch (aTransfer) {
+ case VideoTransferCharacteristics::Bt709:
+ case VideoTransferCharacteristics::Smpte170m:
+ return gfx::TransferFunction::BT709;
+ case VideoTransferCharacteristics::Iec61966_2_1:
+ return gfx::TransferFunction::SRGB;
+ case VideoTransferCharacteristics::Pq:
+ return gfx::TransferFunction::PQ;
+ case VideoTransferCharacteristics::Hlg:
+ return gfx::TransferFunction::HLG;
+ case VideoTransferCharacteristics::Linear:
+ case VideoTransferCharacteristics::EndGuard_:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported VideoTransferCharacteristics");
+ return gfx::TransferFunction::Default;
+}
+
+gfx::ColorSpace2 ToPrimaries(VideoColorPrimaries aPrimaries) {
+ switch (aPrimaries) {
+ case VideoColorPrimaries::Bt709:
+ return gfx::ColorSpace2::BT709;
+ case VideoColorPrimaries::Bt470bg:
+ return gfx::ColorSpace2::BT601_625;
+ case VideoColorPrimaries::Smpte170m:
+ return gfx::ColorSpace2::BT601_525;
+ case VideoColorPrimaries::Bt2020:
+ return gfx::ColorSpace2::BT2020;
+ case VideoColorPrimaries::Smpte432:
+ return gfx::ColorSpace2::DISPLAY_P3;
+ case VideoColorPrimaries::EndGuard_:
+ break;
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported VideoTransferCharacteristics");
+ return gfx::ColorSpace2::UNKNOWN;
+}
+
+bool ToFullRange(const gfx::ColorRange& aColorRange) {
+ return aColorRange == gfx::ColorRange::FULL;
+}
+
+Maybe<VideoMatrixCoefficients> ToMatrixCoefficients(
+ const gfx::YUVColorSpace& aColorSpace) {
+ switch (aColorSpace) {
+ case gfx::YUVColorSpace::BT601:
+ return Some(VideoMatrixCoefficients::Smpte170m);
+ case gfx::YUVColorSpace::BT709:
+ return Some(VideoMatrixCoefficients::Bt709);
+ case gfx::YUVColorSpace::BT2020:
+ return Some(VideoMatrixCoefficients::Bt2020_ncl);
+ case gfx::YUVColorSpace::Identity:
+ return Some(VideoMatrixCoefficients::Rgb);
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported gfx::YUVColorSpace");
+ return Nothing();
+}
+
+Maybe<VideoTransferCharacteristics> ToTransferCharacteristics(
+ const gfx::TransferFunction& aTransferFunction) {
+ switch (aTransferFunction) {
+ case gfx::TransferFunction::BT709:
+ return Some(VideoTransferCharacteristics::Bt709);
+ case gfx::TransferFunction::SRGB:
+ return Some(VideoTransferCharacteristics::Iec61966_2_1);
+ case gfx::TransferFunction::PQ:
+ return Some(VideoTransferCharacteristics::Pq);
+ case gfx::TransferFunction::HLG:
+ return Some(VideoTransferCharacteristics::Hlg);
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported gfx::TransferFunction");
+ return Nothing();
+}
+
+Maybe<VideoColorPrimaries> ToPrimaries(const gfx::ColorSpace2& aColorSpace) {
+ switch (aColorSpace) {
+ case gfx::ColorSpace2::UNKNOWN:
+ return Nothing();
+ case gfx::ColorSpace2::DISPLAY_P3:
+ return Some(VideoColorPrimaries::Smpte432);
+ case gfx::ColorSpace2::BT601_525:
+ return Some(VideoColorPrimaries::Smpte170m);
+ case gfx::ColorSpace2::SRGB:
+ case gfx::ColorSpace2::BT709:
+ return Some(VideoColorPrimaries::Bt709);
+ case gfx::ColorSpace2::BT2020:
+ return Some(VideoColorPrimaries::Bt2020);
+ }
+ MOZ_ASSERT_UNREACHABLE("unsupported gfx::ColorSpace2");
+ return Nothing();
+}
+
+/*
+ * The following are utilities to convert from gfx's formats to
+ * VideoPixelFormats.
+ */
+
+Maybe<VideoPixelFormat> SurfaceFormatToVideoPixelFormat(
+ gfx::SurfaceFormat aFormat) {
+ switch (aFormat) {
+ case gfx::SurfaceFormat::B8G8R8A8:
+ return Some(VideoPixelFormat::BGRA);
+ case gfx::SurfaceFormat::B8G8R8X8:
+ return Some(VideoPixelFormat::BGRX);
+ case gfx::SurfaceFormat::R8G8B8A8:
+ return Some(VideoPixelFormat::RGBA);
+ case gfx::SurfaceFormat::R8G8B8X8:
+ return Some(VideoPixelFormat::RGBX);
+ case gfx::SurfaceFormat::YUV:
+ return Some(VideoPixelFormat::I420);
+ case gfx::SurfaceFormat::NV12:
+ return Some(VideoPixelFormat::NV12);
+ case gfx::SurfaceFormat::YUV422:
+ return Some(VideoPixelFormat::I422);
+ default:
+ break;
+ }
+ return Nothing();
+}
+
+Maybe<VideoPixelFormat> ImageBitmapFormatToVideoPixelFormat(
+ ImageBitmapFormat aFormat) {
+ switch (aFormat) {
+ case ImageBitmapFormat::RGBA32:
+ return Some(VideoPixelFormat::RGBA);
+ case ImageBitmapFormat::BGRA32:
+ return Some(VideoPixelFormat::BGRA);
+ case ImageBitmapFormat::YUV444P:
+ return Some(VideoPixelFormat::I444);
+ case ImageBitmapFormat::YUV422P:
+ return Some(VideoPixelFormat::I422);
+ case ImageBitmapFormat::YUV420P:
+ return Some(VideoPixelFormat::I420);
+ case ImageBitmapFormat::YUV420SP_NV12:
+ return Some(VideoPixelFormat::NV12);
+ default:
+ break;
+ }
+ return Nothing();
+}
+
+Result<RefPtr<MediaByteBuffer>, nsresult> GetExtraDataFromArrayBuffer(
+ const OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aBuffer) {
+ RefPtr<MediaByteBuffer> data = MakeRefPtr<MediaByteBuffer>();
+ Unused << AppendTypedArrayDataTo(aBuffer, *data);
+ return data->Length() > 0 ? data : nullptr;
+}
+
+bool IsOnAndroid() {
+#if defined(ANDROID)
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool IsOnMacOS() {
+#if defined(XP_MACOSX)
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool IsOnLinux() {
+#if defined(XP_LINUX)
+ return true;
+#else
+ return false;
+#endif
+}
+
+template <typename T>
+nsCString MaybeToString(const Maybe<T>& aMaybe) {
+ return nsPrintfCString(
+ "%s", aMaybe.isSome() ? ToString(aMaybe.value()).c_str() : "nothing");
+}
+
+struct ConfigurationChangeToString {
+ nsCString operator()(const CodecChange& aCodecChange) {
+ return nsPrintfCString("Codec: %s",
+ NS_ConvertUTF16toUTF8(aCodecChange.get()).get());
+ }
+ nsCString operator()(const DimensionsChange& aDimensionChange) {
+ return nsPrintfCString("Dimensions: %dx%d", aDimensionChange.get().width,
+ aDimensionChange.get().height);
+ }
+ nsCString operator()(const DisplayDimensionsChange& aDisplayDimensionChange) {
+ if (aDisplayDimensionChange.get().isNothing()) {
+ return nsPrintfCString("Display dimensions: nothing");
+ }
+ gfx::IntSize displayDimensions = aDisplayDimensionChange.get().value();
+ return nsPrintfCString("Dimensions: %dx%d", displayDimensions.width,
+ displayDimensions.height);
+ }
+ nsCString operator()(const BitrateChange& aBitrateChange) {
+ return nsPrintfCString("Bitrate: %skbps",
+ MaybeToString(aBitrateChange.get()).get());
+ }
+ nsCString operator()(const FramerateChange& aFramerateChange) {
+ return nsPrintfCString("Framerate: %sHz",
+ MaybeToString(aFramerateChange.get()).get());
+ }
+ nsCString operator()(
+ const HardwareAccelerationChange& aHardwareAccelerationChange) {
+ return nsPrintfCString("HW acceleration: %s",
+ dom::HardwareAccelerationValues::GetString(
+ aHardwareAccelerationChange.get())
+ .data());
+ }
+ nsCString operator()(const AlphaChange& aAlphaChange) {
+ return nsPrintfCString(
+ "Alpha: %s",
+ dom::AlphaOptionValues::GetString(aAlphaChange.get()).data());
+ }
+ nsCString operator()(const ScalabilityModeChange& aScalabilityModeChange) {
+ if (aScalabilityModeChange.get().isNothing()) {
+ return nsCString("Scalability mode: nothing");
+ }
+ return nsPrintfCString(
+ "Scalability mode: %s",
+ NS_ConvertUTF16toUTF8(aScalabilityModeChange.get().value()).get());
+ }
+ nsCString operator()(const BitrateModeChange& aBitrateModeChange) {
+ return nsPrintfCString(
+ "Bitrate mode: %s",
+ dom::VideoEncoderBitrateModeValues::GetString(aBitrateModeChange.get())
+ .data());
+ }
+ nsCString operator()(const LatencyModeChange& aLatencyModeChange) {
+ return nsPrintfCString(
+ "Latency mode: %s",
+ dom::LatencyModeValues::GetString(aLatencyModeChange.get()).data());
+ }
+ nsCString operator()(const ContentHintChange& aContentHintChange) {
+ return nsPrintfCString("Content hint: %s",
+ MaybeToString(aContentHintChange.get()).get());
+ }
+ template <typename T>
+ nsCString operator()(const T& aNewBitrate) {
+ return nsPrintfCString("Not implemented");
+ }
+};
+
+nsString WebCodecsConfigurationChangeList::ToString() const {
+ nsString rv;
+ for (const WebCodecsEncoderConfigurationItem& change : mChanges) {
+ nsCString str = change.match(ConfigurationChangeToString());
+ rv.AppendPrintf("- %s\n", str.get());
+ }
+ return rv;
+}
+
+using CodecChange = StrongTypedef<nsString, struct CodecChangeTypeWebCodecs>;
+using DimensionsChange =
+ StrongTypedef<gfx::IntSize, struct DimensionsChangeTypeWebCodecs>;
+using DisplayDimensionsChange =
+ StrongTypedef<Maybe<gfx::IntSize>,
+ struct DisplayDimensionsChangeTypeWebCodecs>;
+using BitrateChange =
+ StrongTypedef<Maybe<uint32_t>, struct BitrateChangeTypeWebCodecs>;
+using FramerateChange =
+ StrongTypedef<Maybe<double>, struct FramerateChangeTypeWebCodecs>;
+using HardwareAccelerationChange =
+ StrongTypedef<dom::HardwareAcceleration,
+ struct HardwareAccelerationChangeTypeWebCodecs>;
+using AlphaChange =
+ StrongTypedef<dom::AlphaOption, struct AlphaChangeTypeWebCodecs>;
+using ScalabilityModeChange =
+ StrongTypedef<Maybe<nsString>, struct ScalabilityModeChangeTypeWebCodecs>;
+using BitrateModeChange = StrongTypedef<dom::VideoEncoderBitrateMode,
+ struct BitrateModeChangeTypeWebCodecs>;
+using LatencyModeChange =
+ StrongTypedef<dom::LatencyMode, struct LatencyModeTypeChangeTypeWebCodecs>;
+using ContentHintChange =
+ StrongTypedef<Maybe<nsString>, struct ContentHintTypeTypeWebCodecs>;
+
+bool WebCodecsConfigurationChangeList::CanAttemptReconfigure() const {
+ for (const auto& change : mChanges) {
+ if (change.is<CodecChange>() || change.is<HardwareAccelerationChange>() ||
+ change.is<AlphaChange>() || change.is<ScalabilityModeChange>()) {
+ return false;
+ }
+ }
+ return true;
+}
+
+RefPtr<EncoderConfigurationChangeList>
+WebCodecsConfigurationChangeList::ToPEMChangeList() const {
+ auto rv = MakeRefPtr<EncoderConfigurationChangeList>();
+ MOZ_ASSERT(CanAttemptReconfigure());
+ for (const auto& change : mChanges) {
+ if (change.is<dom::DimensionsChange>()) {
+ rv->Push(mozilla::DimensionsChange(change.as<DimensionsChange>().get()));
+ } else if (change.is<dom::DisplayDimensionsChange>()) {
+ rv->Push(mozilla::DisplayDimensionsChange(
+ change.as<DisplayDimensionsChange>().get()));
+ } else if (change.is<dom::BitrateChange>()) {
+ rv->Push(mozilla::BitrateChange(change.as<BitrateChange>().get()));
+ } else if (change.is<FramerateChange>()) {
+ rv->Push(mozilla::FramerateChange(change.as<FramerateChange>().get()));
+ } else if (change.is<dom::BitrateModeChange>()) {
+ MediaDataEncoder::BitrateMode mode;
+ if (change.as<dom::BitrateModeChange>().get() ==
+ dom::VideoEncoderBitrateMode::Constant) {
+ mode = MediaDataEncoder::BitrateMode::Constant;
+ } else if (change.as<BitrateModeChange>().get() ==
+ dom::VideoEncoderBitrateMode::Variable) {
+ mode = MediaDataEncoder::BitrateMode::Variable;
+ } else {
+ // Quantizer, not underlying support yet.
+ mode = MediaDataEncoder::BitrateMode::Variable;
+ }
+ rv->Push(mozilla::BitrateModeChange(mode));
+ } else if (change.is<LatencyModeChange>()) {
+ MediaDataEncoder::Usage usage;
+ if (change.as<LatencyModeChange>().get() == dom::LatencyMode::Quality) {
+ usage = MediaDataEncoder::Usage::Record;
+ } else {
+ usage = MediaDataEncoder::Usage::Realtime;
+ }
+ rv->Push(UsageChange(usage));
+ } else if (change.is<ContentHintChange>()) {
+ rv->Push(
+ mozilla::ContentHintChange(change.as<ContentHintChange>().get()));
+ }
+ }
+ return rv.forget();
+}
+
+#define ENUM_TO_STRING(enumType, enumValue) \
+ enumType##Values::GetString(enumValue).data()
+
+nsCString ColorSpaceInitToString(
+ const dom::VideoColorSpaceInit& aColorSpaceInit) {
+ nsCString rv("VideoColorSpace");
+
+ if (!aColorSpaceInit.mFullRange.IsNull()) {
+ rv.AppendPrintf(" range: %s",
+ aColorSpaceInit.mFullRange.Value() ? "true" : "false");
+ }
+ if (!aColorSpaceInit.mMatrix.IsNull()) {
+ rv.AppendPrintf(" matrix: %s",
+ ENUM_TO_STRING(dom::VideoMatrixCoefficients,
+ aColorSpaceInit.mMatrix.Value()));
+ }
+ if (!aColorSpaceInit.mTransfer.IsNull()) {
+ rv.AppendPrintf(" transfer: %s",
+ ENUM_TO_STRING(dom::VideoTransferCharacteristics,
+ aColorSpaceInit.mTransfer.Value()));
+ }
+ if (!aColorSpaceInit.mPrimaries.IsNull()) {
+ rv.AppendPrintf(" primaries: %s",
+ ENUM_TO_STRING(dom::VideoColorPrimaries,
+ aColorSpaceInit.mPrimaries.Value()));
+ }
+
+ return rv;
+}
+
+RefPtr<TaskQueue> GetWebCodecsEncoderTaskQueue() {
+ return TaskQueue::Create(
+ GetMediaThreadPool(MediaThreadType::PLATFORM_ENCODER),
+ "WebCodecs encoding", false);
+}
+
+VideoColorSpaceInit FallbackColorSpaceForVideoContent() {
+ // If we're unable to determine the color space, but we think this is video
+ // content (e.g. because it's in YUV or NV12 or something like that,
+ // consider it's in BT709).
+ // This is step 3 of
+ // https://w3c.github.io/webcodecs/#videoframe-pick-color-space
+ VideoColorSpaceInit colorSpace;
+ colorSpace.mFullRange = false;
+ colorSpace.mMatrix = VideoMatrixCoefficients::Bt709;
+ colorSpace.mTransfer = VideoTransferCharacteristics::Bt709;
+ colorSpace.mPrimaries = VideoColorPrimaries::Bt709;
+ return colorSpace;
+}
+VideoColorSpaceInit FallbackColorSpaceForWebContent() {
+ // If we're unable to determine the color space, but we think this is from
+ // Web content (canvas, image, svg, etc.), consider it's in sRGB.
+ // This is step 2 of
+ // https://w3c.github.io/webcodecs/#videoframe-pick-color-space
+ VideoColorSpaceInit colorSpace;
+ colorSpace.mFullRange = true;
+ colorSpace.mMatrix = VideoMatrixCoefficients::Rgb;
+ colorSpace.mTransfer = VideoTransferCharacteristics::Iec61966_2_1;
+ colorSpace.mPrimaries = VideoColorPrimaries::Bt709;
+ return colorSpace;
+}
+
+Maybe<CodecType> CodecStringToCodecType(const nsAString& aCodecString) {
+ if (StringBeginsWith(aCodecString, u"av01"_ns)) {
+ return Some(CodecType::AV1);
+ }
+ if (StringBeginsWith(aCodecString, u"vp8"_ns)) {
+ return Some(CodecType::VP8);
+ }
+ if (StringBeginsWith(aCodecString, u"vp09"_ns)) {
+ return Some(CodecType::VP9);
+ }
+ if (StringBeginsWith(aCodecString, u"avc1"_ns)) {
+ return Some(CodecType::H264);
+ }
+ return Nothing();
+}
+
+nsString ConfigToString(const VideoDecoderConfig& aConfig) {
+ nsString rv;
+
+ auto internal = VideoDecoderConfigInternal::Create(aConfig);
+
+ return internal->ToString();
+}
+
+}; // namespace mozilla::dom
diff --git a/dom/media/webcodecs/WebCodecsUtils.h b/dom/media/webcodecs/WebCodecsUtils.h
new file mode 100644
index 0000000000..7c0e6b6bbc
--- /dev/null
+++ b/dom/media/webcodecs/WebCodecsUtils.h
@@ -0,0 +1,239 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/. */
+
+#ifndef MOZILLA_DOM_WEBCODECS_WEBCODECSUTILS_H
+#define MOZILLA_DOM_WEBCODECS_WEBCODECSUTILS_H
+
+#include "ErrorList.h"
+#include "js/TypeDecls.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/MozPromise.h"
+#include "mozilla/Result.h"
+#include "mozilla/TaskQueue.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/dom/Nullable.h"
+#include "mozilla/dom/UnionTypes.h"
+#include "mozilla/dom/VideoEncoderBinding.h"
+#include "mozilla/dom/VideoFrameBinding.h"
+#include "PlatformEncoderModule.h"
+
+namespace mozilla {
+
+namespace gfx {
+enum class ColorRange : uint8_t;
+enum class ColorSpace2 : uint8_t;
+enum class SurfaceFormat : int8_t;
+enum class TransferFunction : uint8_t;
+enum class YUVColorSpace : uint8_t;
+} // namespace gfx
+
+using WebCodecsId = size_t;
+
+extern std::atomic<WebCodecsId> sNextId;
+
+struct EncoderConfigurationChangeList;
+
+namespace dom {
+
+/*
+ * The followings are helpers for WebCodecs methods.
+ */
+
+nsTArray<nsCString> GuessContainers(const nsAString& aCodec);
+
+Maybe<nsString> ParseCodecString(const nsAString& aCodec);
+
+/*
+ * Below are helpers for conversion among Maybe, Optional, and Nullable.
+ */
+
+template <typename T>
+Maybe<T> OptionalToMaybe(const Optional<T>& aOptional) {
+ if (aOptional.WasPassed()) {
+ return Some(aOptional.Value());
+ }
+ return Nothing();
+}
+
+template <typename T>
+const T* OptionalToPointer(const Optional<T>& aOptional) {
+ return aOptional.WasPassed() ? &aOptional.Value() : nullptr;
+}
+
+template <typename T>
+Maybe<T> NullableToMaybe(const Nullable<T>& aNullable) {
+ if (!aNullable.IsNull()) {
+ return Some(aNullable.Value());
+ }
+ return Nothing();
+}
+
+template <typename T>
+Nullable<T> MaybeToNullable(const Maybe<T>& aOptional) {
+ if (aOptional.isSome()) {
+ return Nullable<T>(aOptional.value());
+ }
+ return Nullable<T>();
+}
+
+/*
+ * Below are helpers to operate ArrayBuffer or ArrayBufferView.
+ */
+
+Result<Ok, nsresult> CloneBuffer(
+ JSContext* aCx,
+ OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aDest,
+ const OwningMaybeSharedArrayBufferViewOrMaybeSharedArrayBuffer& aSrc);
+
+/*
+ * The following are utilities to convert between VideoColorSpace values to
+ * gfx's values.
+ */
+
+enum class VideoColorPrimaries : uint8_t;
+enum class VideoMatrixCoefficients : uint8_t;
+enum class VideoTransferCharacteristics : uint8_t;
+
+gfx::ColorRange ToColorRange(bool aIsFullRange);
+
+gfx::YUVColorSpace ToColorSpace(VideoMatrixCoefficients aMatrix);
+
+gfx::TransferFunction ToTransferFunction(
+ VideoTransferCharacteristics aTransfer);
+
+gfx::ColorSpace2 ToPrimaries(VideoColorPrimaries aPrimaries);
+
+bool ToFullRange(const gfx::ColorRange& aColorRange);
+
+Maybe<VideoMatrixCoefficients> ToMatrixCoefficients(
+ const gfx::YUVColorSpace& aColorSpace);
+
+Maybe<VideoTransferCharacteristics> ToTransferCharacteristics(
+ const gfx::TransferFunction& aTransferFunction);
+
+Maybe<VideoColorPrimaries> ToPrimaries(const gfx::ColorSpace2& aColorSpace);
+
+/*
+ * The following are utilities to convert from gfx's formats to
+ * VideoPixelFormats.
+ */
+
+enum class ImageBitmapFormat : uint8_t;
+enum class VideoPixelFormat : uint8_t;
+
+Maybe<VideoPixelFormat> SurfaceFormatToVideoPixelFormat(
+ gfx::SurfaceFormat aFormat);
+
+Maybe<VideoPixelFormat> ImageBitmapFormatToVideoPixelFormat(
+ ImageBitmapFormat aFormat);
+
+template <typename T>
+class MessageRequestHolder {
+ public:
+ MessageRequestHolder() = default;
+ ~MessageRequestHolder() = default;
+
+ MozPromiseRequestHolder<T>& Request() { return mRequest; }
+ void Disconnect() { mRequest.DisconnectIfExists(); }
+ void Complete() { mRequest.Complete(); }
+ bool Exists() const { return mRequest.Exists(); }
+
+ protected:
+ MozPromiseRequestHolder<T> mRequest{};
+};
+
+enum class MessageProcessedResult { NotProcessed, Processed };
+
+bool IsOnAndroid();
+bool IsOnMacOS();
+bool IsOnLinux();
+
+// Wrap a type to make it unique. This allows using ergonomically in the Variant
+// below. Simply aliasing with `using` isn't enough, because typedefs in C++
+// don't produce strong types, so two integer variants result in
+// the same type, making it ambiguous to the Variant code.
+// T is the type to be wrapped. Phantom is a type that is only used to
+// disambiguate and should be unique in the program.
+template <typename T, typename Phantom>
+class StrongTypedef {
+ public:
+ explicit StrongTypedef(T const& value) : mValue(value) {}
+ explicit StrongTypedef(T&& value) : mValue(std::move(value)) {}
+ T& get() { return mValue; }
+ T const& get() const { return mValue; }
+
+ private:
+ T mValue;
+};
+
+using CodecChange = StrongTypedef<nsString, struct CodecChangeTypeWebCodecs>;
+using DimensionsChange =
+ StrongTypedef<gfx::IntSize, struct DimensionsChangeTypeWebCodecs>;
+using DisplayDimensionsChange =
+ StrongTypedef<Maybe<gfx::IntSize>,
+ struct DisplayDimensionsChangeTypeWebCodecs>;
+using BitrateChange =
+ StrongTypedef<Maybe<uint32_t>, struct BitrateChangeTypeWebCodecs>;
+using FramerateChange =
+ StrongTypedef<Maybe<double>, struct FramerateChangeTypeWebCodecs>;
+using HardwareAccelerationChange =
+ StrongTypedef<dom::HardwareAcceleration,
+ struct HardwareAccelerationChangeTypeWebCodecs>;
+using AlphaChange =
+ StrongTypedef<dom::AlphaOption, struct AlphaChangeTypeWebCodecs>;
+using ScalabilityModeChange =
+ StrongTypedef<Maybe<nsString>, struct ScalabilityModeChangeTypeWebCodecs>;
+using BitrateModeChange = StrongTypedef<dom::VideoEncoderBitrateMode,
+ struct BitrateModeChangeTypeWebCodecs>;
+using LatencyModeChange =
+ StrongTypedef<dom::LatencyMode, struct LatencyModeTypeChangeTypeWebCodecs>;
+using ContentHintChange =
+ StrongTypedef<Maybe<nsString>, struct ContentHintTypeTypeWebCodecs>;
+
+using WebCodecsEncoderConfigurationItem =
+ Variant<CodecChange, DimensionsChange, DisplayDimensionsChange,
+ BitrateModeChange, BitrateChange, FramerateChange,
+ HardwareAccelerationChange, AlphaChange, ScalabilityModeChange,
+ LatencyModeChange, ContentHintChange>;
+
+struct WebCodecsConfigurationChangeList {
+ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(WebCodecsConfigurationChangeList)
+ bool Empty() const { return mChanges.IsEmpty(); }
+ template <typename T>
+ void Push(const T& aItem) {
+ mChanges.AppendElement(aItem);
+ }
+ // This returns true if it should be possible to attempt to reconfigure the
+ // encoder on the fly. It can fail, in which case the encoder will be flushed
+ // and a new one will be created with the new set of parameters.
+ bool CanAttemptReconfigure() const;
+
+ // Convert this to the format the underlying PEM can understand
+ RefPtr<EncoderConfigurationChangeList> ToPEMChangeList() const;
+ nsString ToString() const;
+
+ nsTArray<WebCodecsEncoderConfigurationItem> mChanges;
+
+ private:
+ ~WebCodecsConfigurationChangeList() = default;
+};
+
+nsCString ColorSpaceInitToString(
+ const dom::VideoColorSpaceInit& aColorSpaceInit);
+
+RefPtr<TaskQueue> GetWebCodecsEncoderTaskQueue();
+VideoColorSpaceInit FallbackColorSpaceForVideoContent();
+VideoColorSpaceInit FallbackColorSpaceForWebContent();
+
+Maybe<CodecType> CodecStringToCodecType(const nsAString& aCodecString);
+
+nsString ConfigToString(const VideoDecoderConfig& aConfig);
+
+} // namespace dom
+
+} // namespace mozilla
+
+#endif // MOZILLA_DOM_WEBCODECS_WEBCODECSUTILS_H
diff --git a/dom/media/webcodecs/crashtests/1839270.html b/dom/media/webcodecs/crashtests/1839270.html
new file mode 100644
index 0000000000..3b8f7908e5
--- /dev/null
+++ b/dom/media/webcodecs/crashtests/1839270.html
@@ -0,0 +1,13 @@
+<script>
+window.addEventListener("load", async () => {
+ let _ = new Response("", {"headers": []})
+ let a = new ArrayBuffer(60005)
+ let v = new VideoFrame(a, {
+ "format": "RGBA",
+ "codedWidth": 1458585599,
+ "codedHeight": 84,
+ "timestamp": 0.541,
+ "layout": [{"offset": 168, "stride": 198}],
+ })
+})
+</script>
diff --git a/dom/media/webcodecs/crashtests/1848460.html b/dom/media/webcodecs/crashtests/1848460.html
new file mode 100644
index 0000000000..2f6f8b930e
--- /dev/null
+++ b/dom/media/webcodecs/crashtests/1848460.html
@@ -0,0 +1,17 @@
+<script id="worker" type="javascript/worker">
+self.onmessage = async function(e) {
+ let a = new ArrayBuffer(12583)
+ let b = new DataView(a)
+ await VideoDecoder.isConfigSupported({
+ "codec": "7󠎢ﷺ۹.9",
+ "description": b,
+ })
+}
+</script>
+<script>
+window.addEventListener("load", async () => {
+ const blob = new Blob([document.querySelector('#worker').textContent], { type: "text/javascript" })
+ const worker = new Worker(window.URL.createObjectURL(blob))
+ worker.postMessage([], [])
+})
+</script>
diff --git a/dom/media/webcodecs/crashtests/1849271.html b/dom/media/webcodecs/crashtests/1849271.html
new file mode 100644
index 0000000000..67e170d8bf
--- /dev/null
+++ b/dom/media/webcodecs/crashtests/1849271.html
@@ -0,0 +1,27 @@
+<html class="reftest-wait">
+ <script>
+ var cfg = {
+ codec: "vp8",
+ colorSpace: { primaries: "bt709" },
+ };
+ var decoder = new VideoDecoder({
+ output: () => {},
+ error: e => {
+ document.documentElement.removeAttribute("class");
+ },
+ });
+ decoder.configure(cfg);
+ try {
+ decoder.decode(
+ new EncodedVideoChunk({
+ type: "key",
+ timestamp: 0,
+ duration: 10,
+ data: new Uint8Array(10),
+ })
+ );
+ } catch (e) {
+ document.documentElement.removeAttribute("class");
+ }
+ </script>
+</html>
diff --git a/dom/media/webcodecs/crashtests/1864475.html b/dom/media/webcodecs/crashtests/1864475.html
new file mode 100644
index 0000000000..d7164b2854
--- /dev/null
+++ b/dom/media/webcodecs/crashtests/1864475.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<script>
+ document.addEventListener('DOMContentLoaded', async () => {
+ const buffer = new ArrayBuffer(26838)
+ const array = new Uint8ClampedArray(buffer)
+ const frame = new VideoFrame(array, {
+ 'format': 'I420A',
+ 'codedWidth': 192,
+ 'codedHeight': 2,
+ 'timestamp': 14.19024535832334,
+ })
+ await frame.copyTo(buffer, {})
+ })
+</script>
diff --git a/dom/media/webcodecs/crashtests/crashtests.list b/dom/media/webcodecs/crashtests/crashtests.list
new file mode 100644
index 0000000000..cea5139fe9
--- /dev/null
+++ b/dom/media/webcodecs/crashtests/crashtests.list
@@ -0,0 +1,4 @@
+skip-if(Android) pref(dom.media.webcodecs.enabled,true) load 1839270.html
+skip-if(Android) pref(dom.media.webcodecs.enabled,true) load 1848460.html
+skip-if(Android) pref(dom.media.webcodecs.enabled,true) load 1849271.html
+skip-if(Android) pref(dom.media.webcodecs.enabled,true) load 1864475.html \ No newline at end of file
diff --git a/dom/media/webcodecs/moz.build b/dom/media/webcodecs/moz.build
new file mode 100644
index 0000000000..267a822286
--- /dev/null
+++ b/dom/media/webcodecs/moz.build
@@ -0,0 +1,54 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+with Files("*"):
+ BUG_COMPONENT = ("Core", "Audio/Video: Web Codecs")
+
+MOCHITEST_MANIFESTS += ["test/mochitest.toml"]
+CRASHTEST_MANIFESTS += ["crashtests/crashtests.list"]
+
+# For mozilla/layers/ImageBridgeChild.h
+LOCAL_INCLUDES += [
+ "!/ipc/ipdl/_ipdlheaders",
+ "/ipc/chromium/src/",
+]
+
+EXPORTS.mozilla += [
+ "DecoderAgent.h",
+]
+
+EXPORTS.mozilla.dom += [
+ "DecoderTemplate.h",
+ "DecoderTypes.h",
+ "EncodedVideoChunk.h",
+ "EncoderAgent.h",
+ "EncoderTemplate.h",
+ "EncoderTypes.h",
+ "VideoColorSpace.h",
+ "VideoDecoder.h",
+ "VideoEncoder.h",
+ "VideoFrame.h",
+ "WebCodecsUtils.h",
+]
+
+UNIFIED_SOURCES += [
+ "DecoderAgent.cpp",
+ "DecoderTemplate.cpp",
+ "EncodedVideoChunk.cpp",
+ "EncoderAgent.cpp",
+ "EncoderTemplate.cpp",
+ "VideoColorSpace.cpp",
+ "VideoDecoder.cpp",
+ "VideoEncoder.cpp",
+ "VideoFrame.cpp",
+ "WebCodecsUtils.cpp",
+]
+
+if CONFIG["MOZ_WAYLAND"]:
+ CXXFLAGS += CONFIG["MOZ_WAYLAND_CFLAGS"]
+ CFLAGS += CONFIG["MOZ_WAYLAND_CFLAGS"]
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/media/webcodecs/test/mochitest.toml b/dom/media/webcodecs/test/mochitest.toml
new file mode 100644
index 0000000000..061bfd12fb
--- /dev/null
+++ b/dom/media/webcodecs/test/mochitest.toml
@@ -0,0 +1,6 @@
+[DEFAULT]
+subsuite = "media"
+tags = "webcodecs"
+prefs = ["dom.media.webcodecs.enabled=true"]
+
+["test_videoFrame_mismatched_codedSize.html"]
diff --git a/dom/media/webcodecs/test/test_videoFrame_mismatched_codedSize.html b/dom/media/webcodecs/test/test_videoFrame_mismatched_codedSize.html
new file mode 100644
index 0000000000..52e26f7854
--- /dev/null
+++ b/dom/media/webcodecs/test/test_videoFrame_mismatched_codedSize.html
@@ -0,0 +1,30 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+ <title></title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<script>
+let data = new Uint8Array([
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+]);
+// TODO: Crop the image instead of returning errors (Bug 1782128).
+try {
+ // Bug 1793814: Remove eslint-disable-line below
+ let frame = new VideoFrame(data, { // eslint-disable-line no-undef
+ timestamp: 10,
+ codedWidth: 3,
+ codedHeight: 3,
+ visibleRect: { x: 0, y: 0, width: 1, height: 1 },
+ format: "RGBA",
+ });
+ frame.close();
+ ok(false, "Should not create a VideoFrame from a mismatched-size buffer");
+} catch (e) {
+ ok(e instanceof TypeError, "Should throw a TypeError");
+}
+</script>
+</body>
+</html>