Adding upstream version 110.0.1.upstream/110.0.1upstream

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

1 files changed, 237 insertions, 0 deletions

diff --git a/dom/media/webrtc/libwebrtcglue/CodecConfig.h b/dom/media/webrtc/libwebrtcglue/CodecConfig.h
new file mode 100644
index 0000000000..023ea98783
--- /dev/null
+++ b/dom/media/webrtc/libwebrtcglue/CodecConfig.h
@@ -0,0 +1,237 @@
+
+/* 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 CODEC_CONFIG_H_
+#define CODEC_CONFIG_H_
+
+#include <string>
+#include <vector>
+
+#include "common/EncodingConstraints.h"
+
+namespace mozilla {
+
+/**
+ * Minimalistic Audio Codec Config Params
+ */
+struct AudioCodecConfig {
+  /*
+   * The data-types for these properties mimic the
+   * corresponding webrtc::CodecInst data-types.
+   */
+  int mType;
+  std::string mName;
+  int mFreq;
+  int mChannels;
+
+  bool mFECEnabled;
+  bool mDtmfEnabled;
+  uint32_t mFrameSizeMs;
+  uint32_t mMaxFrameSizeMs;
+  uint32_t mMinFrameSizeMs;
+
+  // OPUS-specific
+  bool mDTXEnabled;
+  uint32_t mMaxAverageBitrate;
+  int mMaxPlaybackRate;
+  bool mCbrEnabled;
+
+  AudioCodecConfig(int type, std::string name, int freq, int channels,
+                   bool FECEnabled)
+      : mType(type),
+        mName(name),
+        mFreq(freq),
+        mChannels(channels),
+        mFECEnabled(FECEnabled),
+        mDtmfEnabled(false),
+        mFrameSizeMs(0),
+        mMaxFrameSizeMs(0),
+        mMinFrameSizeMs(0),
+        mDTXEnabled(false),
+        mMaxAverageBitrate(0),
+        mMaxPlaybackRate(0),
+        mCbrEnabled(false) {}
+
+  bool operator==(const AudioCodecConfig& aOther) const {
+    return mType == aOther.mType && mName == aOther.mName &&
+           mFreq == aOther.mFreq && mChannels == aOther.mChannels &&
+           mFECEnabled == aOther.mFECEnabled &&
+           mDtmfEnabled == aOther.mDtmfEnabled &&
+           mFrameSizeMs == aOther.mFrameSizeMs &&
+           mMaxFrameSizeMs == aOther.mMaxFrameSizeMs &&
+           mMinFrameSizeMs == aOther.mMinFrameSizeMs &&
+           mDTXEnabled == aOther.mDTXEnabled &&
+           mMaxAverageBitrate == aOther.mMaxAverageBitrate &&
+           mMaxPlaybackRate == aOther.mMaxPlaybackRate &&
+           mCbrEnabled == aOther.mCbrEnabled;
+  }
+};
+
+/*
+ * Minimalistic video codec configuration
+ * More to be added later depending on the use-case
+ */
+
+#define MAX_SPROP_LEN 128
+
+// used for holding SDP negotiation results
+struct VideoCodecConfigH264 {
+  char sprop_parameter_sets[MAX_SPROP_LEN];
+  int packetization_mode;
+  int profile_level_id;
+  int tias_bw;
+
+  bool operator==(const VideoCodecConfigH264& aOther) const {
+    return strncmp(sprop_parameter_sets, aOther.sprop_parameter_sets,
+                   MAX_SPROP_LEN) == 0 &&
+           packetization_mode == aOther.packetization_mode &&
+           profile_level_id == aOther.profile_level_id &&
+           tias_bw == aOther.tias_bw;
+  }
+};
+
+// class so the std::strings can get freed more easily/reliably
+class VideoCodecConfig {
+ public:
+  /*
+   * The data-types for these properties mimic the
+   * corresponding webrtc::VideoCodec data-types.
+   */
+  int mType;  // payload type
+  std::string mName;
+
+  std::vector<std::string> mAckFbTypes;
+  std::vector<std::string> mNackFbTypes;
+  std::vector<std::string> mCcmFbTypes;
+  // Don't pass mOtherFbTypes from JsepVideoCodecDescription because we'd have
+  // to drag SdpRtcpFbAttributeList::Feedback along too.
+  bool mRembFbSet;
+  bool mFECFbSet;
+  bool mTransportCCFbSet;
+
+  int mULPFECPayloadType;
+  int mREDPayloadType;
+  int mREDRTXPayloadType;
+  int mRTXPayloadType;
+
+  uint32_t mTias;
+  EncodingConstraints mEncodingConstraints;
+  struct Encoding {
+    std::string rid;
+    EncodingConstraints constraints;
+    bool active = true;
+    // TODO(bug 1744116): Use = default here
+    bool operator==(const Encoding& aOther) const {
+      return rid == aOther.rid && constraints == aOther.constraints &&
+             active == aOther.active;
+    }
+  };
+  std::vector<Encoding> mEncodings;
+  std::string mSpropParameterSets;
+  uint8_t mProfile;
+  uint8_t mConstraints;
+  uint8_t mLevel;
+  uint8_t mPacketizationMode;
+  // TODO: add external negotiated SPS/PPS
+
+  // TODO(bug 1744116): Use = default here
+  bool operator==(const VideoCodecConfig& aRhs) const {
+    return mType == aRhs.mType && mName == aRhs.mName &&
+           mAckFbTypes == aRhs.mAckFbTypes &&
+           mNackFbTypes == aRhs.mNackFbTypes &&
+           mCcmFbTypes == aRhs.mCcmFbTypes && mRembFbSet == aRhs.mRembFbSet &&
+           mFECFbSet == aRhs.mFECFbSet &&
+           mTransportCCFbSet == aRhs.mTransportCCFbSet &&
+           mULPFECPayloadType == aRhs.mULPFECPayloadType &&
+           mREDPayloadType == aRhs.mREDPayloadType &&
+           mREDRTXPayloadType == aRhs.mREDRTXPayloadType &&
+           mRTXPayloadType == aRhs.mRTXPayloadType && mTias == aRhs.mTias &&
+           mEncodingConstraints == aRhs.mEncodingConstraints &&
+           mEncodings == aRhs.mEncodings &&
+           mSpropParameterSets == aRhs.mSpropParameterSets &&
+           mProfile == aRhs.mProfile && mConstraints == aRhs.mConstraints &&
+           mLevel == aRhs.mLevel &&
+           mPacketizationMode == aRhs.mPacketizationMode;
+  }
+
+  VideoCodecConfig(int type, std::string name,
+                   const EncodingConstraints& constraints,
+                   const struct VideoCodecConfigH264* h264 = nullptr)
+      : mType(type),
+        mName(name),
+        mRembFbSet(false),
+        mFECFbSet(false),
+        mTransportCCFbSet(false),
+        mULPFECPayloadType(-1),
+        mREDPayloadType(-1),
+        mREDRTXPayloadType(-1),
+        mRTXPayloadType(-1),
+        mTias(0),
+        mEncodingConstraints(constraints),
+        mProfile(0x42),
+        mConstraints(0xE0),
+        mLevel(0x0C),
+        mPacketizationMode(1) {
+    if (h264) {
+      mProfile = (h264->profile_level_id & 0x00FF0000) >> 16;
+      mConstraints = (h264->profile_level_id & 0x0000FF00) >> 8;
+      mLevel = (h264->profile_level_id & 0x000000FF);
+      mPacketizationMode = h264->packetization_mode;
+      mSpropParameterSets = h264->sprop_parameter_sets;
+    }
+  }
+
+  bool ResolutionEquals(const VideoCodecConfig& aConfig) const {
+    if (mEncodings.size() != aConfig.mEncodings.size()) {
+      return false;
+    }
+    for (size_t i = 0; i < mEncodings.size(); ++i) {
+      if (!mEncodings[i].constraints.ResolutionEquals(
+              aConfig.mEncodings[i].constraints)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  // Nothing seems to use this right now. Do we intend to support this
+  // someday?
+  bool RtcpFbAckIsSet(const std::string& type) const {
+    for (auto i = mAckFbTypes.begin(); i != mAckFbTypes.end(); ++i) {
+      if (*i == type) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool RtcpFbNackIsSet(const std::string& type) const {
+    for (auto i = mNackFbTypes.begin(); i != mNackFbTypes.end(); ++i) {
+      if (*i == type) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool RtcpFbCcmIsSet(const std::string& type) const {
+    for (auto i = mCcmFbTypes.begin(); i != mCcmFbTypes.end(); ++i) {
+      if (*i == type) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  bool RtcpFbRembIsSet() const { return mRembFbSet; }
+
+  bool RtcpFbFECIsSet() const { return mFECFbSet; }
+
+  bool RtcpFbTransportCCIsSet() const { return mTransportCCFbSet; }
+
+  bool RtxPayloadTypeIsSet() const { return mRTXPayloadType != -1; }
+};
+}  // namespace mozilla
+#endif