Adding upstream version 115.7.0esr.upstream/115.7.0esr

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

1 files changed, 182 insertions, 0 deletions

diff --git a/third_party/libwebrtc/pc/used_ids.h b/third_party/libwebrtc/pc/used_ids.h
new file mode 100644
index 0000000000..1236a786df
--- /dev/null
+++ b/third_party/libwebrtc/pc/used_ids.h
@@ -0,0 +1,182 @@
+/*
+ *  Copyright 2019 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#ifndef PC_USED_IDS_H_
+#define PC_USED_IDS_H_
+
+#include <set>
+#include <vector>
+
+#include "api/rtp_parameters.h"
+#include "media/base/codec.h"
+#include "rtc_base/checks.h"
+#include "rtc_base/logging.h"
+
+namespace cricket {
+template <typename IdStruct>
+class UsedIds {
+ public:
+  UsedIds(int min_allowed_id, int max_allowed_id)
+      : min_allowed_id_(min_allowed_id),
+        max_allowed_id_(max_allowed_id),
+        next_id_(max_allowed_id) {}
+  virtual ~UsedIds() {}
+
+  // Loops through all Id in `ids` and changes its id if it is
+  // already in use by another IdStruct. Call this methods with all Id
+  // in a session description to make sure no duplicate ids exists.
+  // Note that typename Id must be a type of IdStruct.
+  template <typename Id>
+  void FindAndSetIdUsed(std::vector<Id>* ids) {
+    for (const Id& id : *ids) {
+      FindAndSetIdUsed(&id);
+    }
+  }
+
+  // Finds and sets an unused id if the `idstruct` id is already in use.
+  void FindAndSetIdUsed(IdStruct* idstruct) {
+    const int original_id = idstruct->id;
+    int new_id = idstruct->id;
+
+    if (original_id > max_allowed_id_ || original_id < min_allowed_id_) {
+      // If the original id is not in range - this is an id that can't be
+      // dynamically changed.
+      return;
+    }
+
+    if (IsIdUsed(original_id)) {
+      new_id = FindUnusedId();
+      // Duplicate id found. Reassign from the original id to the new.
+      idstruct->id = new_id;
+    }
+    SetIdUsed(new_id);
+  }
+
+ protected:
+  virtual bool IsIdUsed(int new_id) {
+    return id_set_.find(new_id) != id_set_.end();
+  }
+  const int min_allowed_id_;
+  const int max_allowed_id_;
+
+ private:
+  // Returns the first unused id in reverse order.
+  // This hopefully reduces the risk of more collisions. We want to change the
+  // default ids as little as possible. This function is virtual and can be
+  // overriden if the search for unused IDs should follow a specific pattern.
+  virtual int FindUnusedId() {
+    while (IsIdUsed(next_id_) && next_id_ >= min_allowed_id_) {
+      --next_id_;
+    }
+    RTC_DCHECK(next_id_ >= min_allowed_id_);
+    return next_id_;
+  }
+
+  void SetIdUsed(int new_id) {
+    RTC_DCHECK(new_id >= min_allowed_id_);
+    RTC_DCHECK(new_id <= max_allowed_id_);
+    RTC_DCHECK(!IsIdUsed(new_id));
+    id_set_.insert(new_id);
+  }
+  int next_id_;
+  std::set<int> id_set_;
+};
+
+// Helper class used for finding duplicate RTP payload types among audio, video
+// and data codecs. When bundle is used the payload types may not collide.
+class UsedPayloadTypes : public UsedIds<Codec> {
+ public:
+  UsedPayloadTypes()
+      : UsedIds<Codec>(kFirstDynamicPayloadTypeLowerRange,
+                       kLastDynamicPayloadTypeUpperRange) {}
+
+ protected:
+  bool IsIdUsed(int new_id) override {
+    // Range marked for RTCP avoidance is "used".
+    if (new_id > kLastDynamicPayloadTypeLowerRange &&
+        new_id < kFirstDynamicPayloadTypeUpperRange)
+      return true;
+    return UsedIds<Codec>::IsIdUsed(new_id);
+  }
+
+ private:
+  static const int kFirstDynamicPayloadTypeLowerRange = 35;
+  static const int kLastDynamicPayloadTypeLowerRange = 63;
+
+  static const int kFirstDynamicPayloadTypeUpperRange = 96;
+  static const int kLastDynamicPayloadTypeUpperRange = 127;
+};
+
+// Helper class used for finding duplicate RTP Header extension ids among
+// audio and video extensions.
+class UsedRtpHeaderExtensionIds : public UsedIds<webrtc::RtpExtension> {
+ public:
+  enum class IdDomain {
+    // Only allocate IDs that fit in one-byte header extensions.
+    kOneByteOnly,
+    // Prefer to allocate one-byte header extension IDs, but overflow to
+    // two-byte if none are left.
+    kTwoByteAllowed,
+  };
+
+  explicit UsedRtpHeaderExtensionIds(IdDomain id_domain)
+      : UsedIds<webrtc::RtpExtension>(
+            webrtc::RtpExtension::kMinId,
+            id_domain == IdDomain::kTwoByteAllowed
+                ? webrtc::RtpExtension::kMaxId
+                : webrtc::RtpExtension::kOneByteHeaderExtensionMaxId),
+        id_domain_(id_domain),
+        next_extension_id_(webrtc::RtpExtension::kOneByteHeaderExtensionMaxId) {
+  }
+
+ private:
+  // Returns the first unused id in reverse order from the max id of one byte
+  // header extensions. This hopefully reduce the risk of more collisions. We
+  // want to change the default ids as little as possible. If no unused id is
+  // found and two byte header extensions are enabled (i.e.,
+  // `extmap_allow_mixed_` is true), search for unused ids from 15 to 255.
+  int FindUnusedId() override {
+    if (next_extension_id_ <=
+        webrtc::RtpExtension::kOneByteHeaderExtensionMaxId) {
+      // First search in reverse order from the max id of one byte header
+      // extensions.
+      while (IsIdUsed(next_extension_id_) &&
+             next_extension_id_ >= min_allowed_id_) {
+        --next_extension_id_;
+      }
+    }
+
+    if (id_domain_ == IdDomain::kTwoByteAllowed) {
+      if (next_extension_id_ < min_allowed_id_) {
+        // We have searched among all one-byte IDs without finding an unused ID,
+        // continue at the first two-byte ID.
+        next_extension_id_ =
+            webrtc::RtpExtension::kOneByteHeaderExtensionMaxId + 1;
+      }
+
+      if (next_extension_id_ >
+          webrtc::RtpExtension::kOneByteHeaderExtensionMaxId) {
+        while (IsIdUsed(next_extension_id_) &&
+               next_extension_id_ <= max_allowed_id_) {
+          ++next_extension_id_;
+        }
+      }
+    }
+    RTC_DCHECK(next_extension_id_ >= min_allowed_id_);
+    RTC_DCHECK(next_extension_id_ <= max_allowed_id_);
+    return next_extension_id_;
+  }
+
+  const IdDomain id_domain_;
+  int next_extension_id_;
+};
+
+}  // namespace cricket
+
+#endif  // PC_USED_IDS_H_