Adding upstream version 115.8.0esr.upstream/115.8.0esr

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

1 files changed, 253 insertions, 0 deletions

diff --git a/dom/media/webrtc/sdp/RsdparsaSdpMediaSection.cpp b/dom/media/webrtc/sdp/RsdparsaSdpMediaSection.cpp
new file mode 100644
index 0000000000..25084db2ad
--- /dev/null
+++ b/dom/media/webrtc/sdp/RsdparsaSdpMediaSection.cpp
@@ -0,0 +1,253 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "sdp/SdpMediaSection.h"
+#include "sdp/RsdparsaSdpMediaSection.h"
+
+#include "sdp/RsdparsaSdpGlue.h"
+#include "sdp/RsdparsaSdpInc.h"
+
+#include <ostream>
+
+#ifdef CRLF
+#  undef CRLF
+#endif
+#define CRLF "\r\n"
+
+namespace mozilla {
+
+RsdparsaSdpMediaSection::RsdparsaSdpMediaSection(
+    size_t level, RsdparsaSessionHandle session,
+    const RustMediaSection* const section,
+    const RsdparsaSdpAttributeList* sessionLevel)
+    : SdpMediaSection(level), mSession(std::move(session)), mSection(section) {
+  switch (sdp_rust_get_media_type(section)) {
+    case RustSdpMediaValue::kRustAudio:
+      mMediaType = kAudio;
+      break;
+    case RustSdpMediaValue::kRustVideo:
+      mMediaType = kVideo;
+      break;
+    case RustSdpMediaValue::kRustApplication:
+      mMediaType = kApplication;
+      break;
+  }
+
+  RsdparsaSessionHandle attributeSession(sdp_new_reference(mSession.get()));
+  mAttributeList.reset(new RsdparsaSdpAttributeList(std::move(attributeSession),
+                                                    section, sessionLevel));
+
+  LoadFormats();
+  LoadConnection();
+}
+
+unsigned int RsdparsaSdpMediaSection::GetPort() const {
+  return sdp_get_media_port(mSection);
+}
+
+void RsdparsaSdpMediaSection::SetPort(unsigned int port) {
+  sdp_set_media_port(mSection, port);
+}
+
+unsigned int RsdparsaSdpMediaSection::GetPortCount() const {
+  return sdp_get_media_port_count(mSection);
+}
+
+SdpMediaSection::Protocol RsdparsaSdpMediaSection::GetProtocol() const {
+  switch (sdp_get_media_protocol(mSection)) {
+    case RustSdpProtocolValue::kRustRtpSavpf:
+      return kRtpSavpf;
+    case RustSdpProtocolValue::kRustUdpTlsRtpSavp:
+      return kUdpTlsRtpSavp;
+    case RustSdpProtocolValue::kRustTcpDtlsRtpSavp:
+      return kTcpDtlsRtpSavp;
+    case RustSdpProtocolValue::kRustUdpTlsRtpSavpf:
+      return kUdpTlsRtpSavpf;
+    case RustSdpProtocolValue::kRustTcpDtlsRtpSavpf:
+      return kTcpDtlsRtpSavpf;
+    case RustSdpProtocolValue::kRustDtlsSctp:
+      return kDtlsSctp;
+    case RustSdpProtocolValue::kRustUdpDtlsSctp:
+      return kUdpDtlsSctp;
+    case RustSdpProtocolValue::kRustTcpDtlsSctp:
+      return kTcpDtlsSctp;
+    case RustSdpProtocolValue::kRustRtpAvp:
+      return kRtpAvp;
+    case RustSdpProtocolValue::kRustRtpAvpf:
+      return kRtpAvpf;
+    case RustSdpProtocolValue::kRustRtpSavp:
+      return kRtpSavp;
+  }
+  MOZ_CRASH("invalid media protocol");
+}
+
+const SdpConnection& RsdparsaSdpMediaSection::GetConnection() const {
+  MOZ_ASSERT(mConnection);
+  return *mConnection;
+}
+
+SdpConnection& RsdparsaSdpMediaSection::GetConnection() {
+  MOZ_ASSERT(mConnection);
+  return *mConnection;
+}
+
+uint32_t RsdparsaSdpMediaSection::GetBandwidth(const std::string& type) const {
+  return sdp_get_media_bandwidth(mSection, type.c_str());
+}
+
+const std::vector<std::string>& RsdparsaSdpMediaSection::GetFormats() const {
+  return mFormats;
+}
+
+const SdpAttributeList& RsdparsaSdpMediaSection::GetAttributeList() const {
+  return *mAttributeList;
+}
+
+SdpAttributeList& RsdparsaSdpMediaSection::GetAttributeList() {
+  return *mAttributeList;
+}
+
+SdpDirectionAttribute RsdparsaSdpMediaSection::GetDirectionAttribute() const {
+  return SdpDirectionAttribute(mAttributeList->GetDirection());
+}
+
+void RsdparsaSdpMediaSection::AddCodec(const std::string& pt,
+                                       const std::string& name,
+                                       uint32_t clockrate, uint16_t channels) {
+  StringView rustName{name.c_str(), name.size()};
+
+  // call the rust interface
+  auto nr = sdp_media_add_codec(mSection, std::stoul(pt), rustName, clockrate,
+                                channels);
+
+  if (NS_SUCCEEDED(nr)) {
+    // If the rust call was successful, adjust the shadow C++ structures
+    mFormats.push_back(pt);
+
+    // Add a rtpmap in mAttributeList
+    SdpRtpmapAttributeList* rtpmap = new SdpRtpmapAttributeList();
+    if (mAttributeList->HasAttribute(SdpAttribute::kRtpmapAttribute)) {
+      const SdpRtpmapAttributeList& old = mAttributeList->GetRtpmap();
+      for (auto it = old.mRtpmaps.begin(); it != old.mRtpmaps.end(); ++it) {
+        rtpmap->mRtpmaps.push_back(*it);
+      }
+    }
+
+    SdpRtpmapAttributeList::CodecType codec =
+        SdpRtpmapAttributeList::kOtherCodec;
+    if (name == "opus") {
+      codec = SdpRtpmapAttributeList::kOpus;
+    } else if (name == "VP8") {
+      codec = SdpRtpmapAttributeList::kVP8;
+    } else if (name == "VP9") {
+      codec = SdpRtpmapAttributeList::kVP9;
+    } else if (name == "H264") {
+      codec = SdpRtpmapAttributeList::kH264;
+    }
+
+    rtpmap->PushEntry(pt, codec, name, clockrate, channels);
+    mAttributeList->SetAttribute(rtpmap);
+  }
+}
+
+void RsdparsaSdpMediaSection::ClearCodecs() {
+  // Clear the codecs in rust
+  sdp_media_clear_codecs(mSection);
+
+  mFormats.clear();
+  mAttributeList->RemoveAttribute(SdpAttribute::kRtpmapAttribute);
+  mAttributeList->RemoveAttribute(SdpAttribute::kFmtpAttribute);
+  mAttributeList->RemoveAttribute(SdpAttribute::kSctpmapAttribute);
+  mAttributeList->RemoveAttribute(SdpAttribute::kRtcpFbAttribute);
+}
+
+void RsdparsaSdpMediaSection::AddDataChannel(const std::string& name,
+                                             uint16_t port, uint16_t streams,
+                                             uint32_t message_size) {
+  StringView rustName{name.c_str(), name.size()};
+  auto nr = sdp_media_add_datachannel(mSection, rustName, port, streams,
+                                      message_size);
+  if (NS_SUCCEEDED(nr)) {
+    // Update the formats
+    mFormats.clear();
+    LoadFormats();
+
+    // Update the attribute list
+    RsdparsaSessionHandle sessHandle(sdp_new_reference(mSession.get()));
+    auto sessAttributes = mAttributeList->mSessionAttributes;
+    mAttributeList.reset(new RsdparsaSdpAttributeList(
+        std::move(sessHandle), mSection, sessAttributes));
+  }
+}
+
+void RsdparsaSdpMediaSection::Serialize(std::ostream& os) const {
+  os << "m=" << mMediaType << " " << GetPort();
+  if (GetPortCount()) {
+    os << "/" << GetPortCount();
+  }
+  os << " " << GetProtocol();
+  for (auto i = mFormats.begin(); i != mFormats.end(); ++i) {
+    os << " " << (*i);
+  }
+  os << CRLF;
+
+  // We dont do i=
+
+  if (mConnection) {
+    os << *mConnection;
+  }
+
+  BandwidthVec* bwVec = sdp_get_media_bandwidth_vec(mSection);
+  char* bwString = sdp_serialize_bandwidth(bwVec);
+  if (bwString) {
+    os << bwString;
+    sdp_free_string(bwString);
+  }
+
+  // We dont do k= because they're evil
+
+  os << *mAttributeList;
+}
+
+void RsdparsaSdpMediaSection::LoadFormats() {
+  RustSdpFormatType formatType = sdp_get_format_type(mSection);
+  if (formatType == RustSdpFormatType::kRustIntegers) {
+    U32Vec* vec = sdp_get_format_u32_vec(mSection);
+    size_t len = u32_vec_len(vec);
+    for (size_t i = 0; i < len; i++) {
+      uint32_t val;
+      u32_vec_get(vec, i, &val);
+      mFormats.push_back(std::to_string(val));
+    }
+  } else {
+    StringVec* vec = sdp_get_format_string_vec(mSection);
+    mFormats = convertStringVec(vec);
+  }
+}
+
+UniquePtr<SdpConnection> convertRustConnection(RustSdpConnection conn) {
+  auto address = convertExplicitlyTypedAddress(&conn.addr);
+  return MakeUnique<SdpConnection>(address.first, address.second, conn.ttl,
+                                   conn.amount);
+}
+
+void RsdparsaSdpMediaSection::LoadConnection() {
+  RustSdpConnection conn;
+  nsresult nr;
+  if (sdp_media_has_connection(mSection)) {
+    nr = sdp_get_media_connection(mSection, &conn);
+    if (NS_SUCCEEDED(nr)) {
+      mConnection = convertRustConnection(conn);
+    }
+  } else if (sdp_session_has_connection(mSession.get())) {
+    nr = sdp_get_session_connection(mSession.get(), &conn);
+    if (NS_SUCCEEDED(nr)) {
+      mConnection = convertRustConnection(conn);
+    }
+  }
+}
+
+}  // namespace mozilla