Merging upstream version 126.0.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 190 insertions, 0 deletions

diff --git a/dom/media/platforms/EncoderConfig.h b/dom/media/platforms/EncoderConfig.h
new file mode 100644
index 0000000000..e0da1709d6
--- /dev/null
+++ b/dom/media/platforms/EncoderConfig.h
@@ -0,0 +1,190 @@
+/* -*- 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_EncoderConfig_h_
+#define mozilla_EncoderConfig_h_
+
+#include "mozilla/dom/ImageBitmapBinding.h"
+#include "H264.h"
+
+namespace mozilla {
+
+enum class CodecType {
+  _BeginVideo_,
+  H264,
+  VP8,
+  VP9,
+  AV1,
+  _EndVideo_,
+  _BeginAudio_ = _EndVideo_,
+  Opus,
+  Vorbis,
+  Flac,
+  AAC,
+  PCM,
+  G722,
+  _EndAudio_,
+  Unknown,
+};
+
+enum class Usage {
+  Realtime,  // Low latency prefered
+  Record
+};
+enum class BitrateMode { Constant, Variable };
+// Scalable Video Coding (SVC) settings for WebCodecs:
+// https://www.w3.org/TR/webrtc-svc/
+enum class ScalabilityMode { None, L1T2, L1T3 };
+
+enum class HardwarePreference { RequireHardware, RequireSoftware, None };
+
+// TODO: Automatically generate this (Bug 1865896)
+const char* GetCodecTypeString(const CodecType& aCodecType);
+
+enum class H264BitStreamFormat { AVC, ANNEXB };
+
+struct H264Specific final {
+  const H264_PROFILE mProfile;
+  const H264_LEVEL mLevel;
+  const H264BitStreamFormat mFormat;
+
+  H264Specific(H264_PROFILE aProfile, H264_LEVEL aLevel,
+               H264BitStreamFormat aFormat)
+      : mProfile(aProfile), mLevel(aLevel), mFormat(aFormat) {}
+};
+
+enum class OpusBitstreamFormat { Opus, OGG };
+
+// The default values come from the Web Codecs specification.
+struct OpusSpecific final {
+  enum class Application { Unspecified, Voip, Audio, RestricedLowDelay };
+  Application mApplication = Application::Unspecified;
+  uint64_t mFrameDuration = 20000;  // microseconds
+  uint8_t mComplexity = 10;         // 0-10
+  OpusBitstreamFormat mFormat = OpusBitstreamFormat::Opus;
+  uint64_t mPacketLossPerc = 0;  // 0-100
+  bool mUseInBandFEC = false;
+  bool mUseDTX = false;
+};
+
+enum class VPXComplexity { Normal, High, Higher, Max };
+struct VP8Specific {
+  VP8Specific() = default;
+  // Ignore webrtc::VideoCodecVP8::errorConcealmentOn,
+  // for it's always false in the codebase (except libwebrtc test cases).
+  VP8Specific(const VPXComplexity aComplexity, const bool aResilience,
+              const uint8_t aNumTemporalLayers, const bool aDenoising,
+              const bool aAutoResize, const bool aFrameDropping)
+      : mComplexity(aComplexity),
+        mResilience(aResilience),
+        mNumTemporalLayers(aNumTemporalLayers),
+        mDenoising(aDenoising),
+        mAutoResize(aAutoResize),
+        mFrameDropping(aFrameDropping) {}
+  const VPXComplexity mComplexity{VPXComplexity::Normal};
+  const bool mResilience{true};
+  const uint8_t mNumTemporalLayers{1};
+  const bool mDenoising{true};
+  const bool mAutoResize{false};
+  const bool mFrameDropping{false};
+};
+
+struct VP9Specific : public VP8Specific {
+  VP9Specific() = default;
+  VP9Specific(const VPXComplexity aComplexity, const bool aResilience,
+              const uint8_t aNumTemporalLayers, const bool aDenoising,
+              const bool aAutoResize, const bool aFrameDropping,
+              const bool aAdaptiveQp, const uint8_t aNumSpatialLayers,
+              const bool aFlexible)
+      : VP8Specific(aComplexity, aResilience, aNumTemporalLayers, aDenoising,
+                    aAutoResize, aFrameDropping),
+        mAdaptiveQp(aAdaptiveQp),
+        mNumSpatialLayers(aNumSpatialLayers),
+        mFlexible(aFlexible) {}
+  const bool mAdaptiveQp{true};
+  const uint8_t mNumSpatialLayers{1};
+  const bool mFlexible{false};
+};
+
+// A class that holds the intial configuration of an encoder. For simplicity,
+// this is used for both audio and video encoding. Members irrelevant to the
+// instance are to be ignored, and are set at their default value.
+class EncoderConfig final {
+ public:
+  using PixelFormat = dom::ImageBitmapFormat;
+  using CodecSpecific =
+      Variant<H264Specific, OpusSpecific, VP8Specific, VP9Specific>;
+
+  EncoderConfig(const EncoderConfig& aConfig) = default;
+
+  // This constructor is used for video encoders
+  EncoderConfig(const CodecType aCodecType, gfx::IntSize aSize,
+                const Usage aUsage, const PixelFormat aPixelFormat,
+                const PixelFormat aSourcePixelFormat, const uint8_t aFramerate,
+                const size_t aKeyframeInterval, const uint32_t aBitrate,
+                const BitrateMode aBitrateMode,
+                const HardwarePreference aHardwarePreference,
+                const ScalabilityMode aScalabilityMode,
+                const Maybe<CodecSpecific>& aCodecSpecific)
+      : mCodec(aCodecType),
+        mSize(aSize),
+        mBitrateMode(aBitrateMode),
+        mBitrate(aBitrate),
+        mUsage(aUsage),
+        mHardwarePreference(aHardwarePreference),
+        mPixelFormat(aPixelFormat),
+        mSourcePixelFormat(aSourcePixelFormat),
+        mScalabilityMode(aScalabilityMode),
+        mFramerate(aFramerate),
+        mKeyframeInterval(aKeyframeInterval),
+        mCodecSpecific(aCodecSpecific) {
+    MOZ_ASSERT(IsVideo());
+  }
+
+  // This constructor is used for audio encoders
+  EncoderConfig(const CodecType aCodecType, uint32_t aNumberOfChannels,
+                const BitrateMode aBitrateMode, uint32_t aSampleRate,
+                uint32_t aBitrate, const Maybe<CodecSpecific>& aCodecSpecific)
+      : mCodec(aCodecType),
+        mBitrateMode(aBitrateMode),
+        mBitrate(aBitrate),
+        mNumberOfChannels(aNumberOfChannels),
+        mSampleRate(aSampleRate),
+        mCodecSpecific(aCodecSpecific) {
+    MOZ_ASSERT(IsAudio());
+  }
+
+  static CodecType CodecTypeForMime(const nsACString& aMimeType);
+
+  bool IsVideo() const {
+    return mCodec > CodecType::_BeginVideo_ && mCodec < CodecType::_EndVideo_;
+  }
+
+  bool IsAudio() const {
+    return mCodec > CodecType::_BeginAudio_ && mCodec < CodecType::_EndAudio_;
+  }
+
+  CodecType mCodec{};
+  gfx::IntSize mSize{};
+  BitrateMode mBitrateMode{};
+  uint32_t mBitrate{};
+  Usage mUsage{};
+  // Video-only
+  HardwarePreference mHardwarePreference{};
+  PixelFormat mPixelFormat{};
+  PixelFormat mSourcePixelFormat{};
+  ScalabilityMode mScalabilityMode{};
+  uint8_t mFramerate{};
+  size_t mKeyframeInterval{};
+  // Audio-only
+  uint32_t mNumberOfChannels{};
+  uint32_t mSampleRate{};
+  Maybe<CodecSpecific> mCodecSpecific{};
+};
+
+}  // namespace mozilla
+
+#endif  // mozilla_EncoderConfig_h_