summaryrefslogtreecommitdiffstats
path: root/third_party/libwebrtc/api/rtp_parameters.cc
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/libwebrtc/api/rtp_parameters.cc')
-rw-r--r--third_party/libwebrtc/api/rtp_parameters.cc295
1 files changed, 295 insertions, 0 deletions
diff --git a/third_party/libwebrtc/api/rtp_parameters.cc b/third_party/libwebrtc/api/rtp_parameters.cc
new file mode 100644
index 0000000000..c1d12e5d8d
--- /dev/null
+++ b/third_party/libwebrtc/api/rtp_parameters.cc
@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2017 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.
+ */
+#include "api/rtp_parameters.h"
+
+#include <algorithm>
+#include <string>
+#include <tuple>
+#include <utility>
+
+#include "api/array_view.h"
+#include "rtc_base/strings/string_builder.h"
+
+namespace webrtc {
+
+const char* DegradationPreferenceToString(
+ DegradationPreference degradation_preference) {
+ switch (degradation_preference) {
+ case DegradationPreference::DISABLED:
+ return "disabled";
+ case DegradationPreference::MAINTAIN_FRAMERATE:
+ return "maintain-framerate";
+ case DegradationPreference::MAINTAIN_RESOLUTION:
+ return "maintain-resolution";
+ case DegradationPreference::BALANCED:
+ return "balanced";
+ }
+ RTC_CHECK_NOTREACHED();
+}
+
+const double kDefaultBitratePriority = 1.0;
+
+RtcpFeedback::RtcpFeedback() = default;
+RtcpFeedback::RtcpFeedback(RtcpFeedbackType type) : type(type) {}
+RtcpFeedback::RtcpFeedback(RtcpFeedbackType type,
+ RtcpFeedbackMessageType message_type)
+ : type(type), message_type(message_type) {}
+RtcpFeedback::RtcpFeedback(const RtcpFeedback& rhs) = default;
+RtcpFeedback::~RtcpFeedback() = default;
+
+RtpCodecCapability::RtpCodecCapability() = default;
+RtpCodecCapability::~RtpCodecCapability() = default;
+
+RtpHeaderExtensionCapability::RtpHeaderExtensionCapability() = default;
+RtpHeaderExtensionCapability::RtpHeaderExtensionCapability(
+ absl::string_view uri)
+ : uri(uri) {}
+RtpHeaderExtensionCapability::RtpHeaderExtensionCapability(
+ absl::string_view uri,
+ int preferred_id)
+ : uri(uri), preferred_id(preferred_id) {}
+RtpHeaderExtensionCapability::RtpHeaderExtensionCapability(
+ absl::string_view uri,
+ int preferred_id,
+ RtpTransceiverDirection direction)
+ : uri(uri), preferred_id(preferred_id), direction(direction) {}
+RtpHeaderExtensionCapability::~RtpHeaderExtensionCapability() = default;
+
+RtpExtension::RtpExtension() = default;
+RtpExtension::RtpExtension(absl::string_view uri, int id) : uri(uri), id(id) {}
+RtpExtension::RtpExtension(absl::string_view uri, int id, bool encrypt)
+ : uri(uri), id(id), encrypt(encrypt) {}
+RtpExtension::~RtpExtension() = default;
+
+RtpFecParameters::RtpFecParameters() = default;
+RtpFecParameters::RtpFecParameters(FecMechanism mechanism)
+ : mechanism(mechanism) {}
+RtpFecParameters::RtpFecParameters(FecMechanism mechanism, uint32_t ssrc)
+ : ssrc(ssrc), mechanism(mechanism) {}
+RtpFecParameters::RtpFecParameters(const RtpFecParameters& rhs) = default;
+RtpFecParameters::~RtpFecParameters() = default;
+
+RtpRtxParameters::RtpRtxParameters() = default;
+RtpRtxParameters::RtpRtxParameters(uint32_t ssrc) : ssrc(ssrc) {}
+RtpRtxParameters::RtpRtxParameters(const RtpRtxParameters& rhs) = default;
+RtpRtxParameters::~RtpRtxParameters() = default;
+
+RtpEncodingParameters::RtpEncodingParameters() = default;
+RtpEncodingParameters::RtpEncodingParameters(const RtpEncodingParameters& rhs) =
+ default;
+RtpEncodingParameters::~RtpEncodingParameters() = default;
+
+RtpCodecParameters::RtpCodecParameters() = default;
+RtpCodecParameters::RtpCodecParameters(const RtpCodecParameters& rhs) = default;
+RtpCodecParameters::~RtpCodecParameters() = default;
+
+RtpCapabilities::RtpCapabilities() = default;
+RtpCapabilities::~RtpCapabilities() = default;
+
+RtcpParameters::RtcpParameters() = default;
+RtcpParameters::RtcpParameters(const RtcpParameters& rhs) = default;
+RtcpParameters::~RtcpParameters() = default;
+
+RtpParameters::RtpParameters() = default;
+RtpParameters::RtpParameters(const RtpParameters& rhs) = default;
+RtpParameters::~RtpParameters() = default;
+
+std::string RtpExtension::ToString() const {
+ char buf[256];
+ rtc::SimpleStringBuilder sb(buf);
+ sb << "{uri: " << uri;
+ sb << ", id: " << id;
+ if (encrypt) {
+ sb << ", encrypt";
+ }
+ sb << '}';
+ return sb.str();
+}
+
+constexpr char RtpExtension::kEncryptHeaderExtensionsUri[];
+constexpr char RtpExtension::kAudioLevelUri[];
+constexpr char RtpExtension::kTimestampOffsetUri[];
+constexpr char RtpExtension::kAbsSendTimeUri[];
+constexpr char RtpExtension::kAbsoluteCaptureTimeUri[];
+constexpr char RtpExtension::kVideoRotationUri[];
+constexpr char RtpExtension::kVideoContentTypeUri[];
+constexpr char RtpExtension::kVideoTimingUri[];
+constexpr char RtpExtension::kGenericFrameDescriptorUri00[];
+constexpr char RtpExtension::kDependencyDescriptorUri[];
+constexpr char RtpExtension::kVideoLayersAllocationUri[];
+constexpr char RtpExtension::kTransportSequenceNumberUri[];
+constexpr char RtpExtension::kTransportSequenceNumberV2Uri[];
+constexpr char RtpExtension::kPlayoutDelayUri[];
+constexpr char RtpExtension::kColorSpaceUri[];
+constexpr char RtpExtension::kMidUri[];
+constexpr char RtpExtension::kRidUri[];
+constexpr char RtpExtension::kRepairedRidUri[];
+constexpr char RtpExtension::kVideoFrameTrackingIdUri[];
+constexpr char RtpExtension::kCsrcAudioLevelsUri[];
+
+constexpr int RtpExtension::kMinId;
+constexpr int RtpExtension::kMaxId;
+constexpr int RtpExtension::kMaxValueSize;
+constexpr int RtpExtension::kOneByteHeaderExtensionMaxId;
+constexpr int RtpExtension::kOneByteHeaderExtensionMaxValueSize;
+
+bool RtpExtension::IsSupportedForAudio(absl::string_view uri) {
+ return uri == webrtc::RtpExtension::kAudioLevelUri ||
+ uri == webrtc::RtpExtension::kAbsSendTimeUri ||
+ uri == webrtc::RtpExtension::kAbsoluteCaptureTimeUri ||
+ uri == webrtc::RtpExtension::kTransportSequenceNumberUri ||
+ uri == webrtc::RtpExtension::kTransportSequenceNumberV2Uri ||
+ uri == webrtc::RtpExtension::kMidUri ||
+ uri == webrtc::RtpExtension::kRidUri ||
+ uri == webrtc::RtpExtension::kRepairedRidUri ||
+ uri == webrtc::RtpExtension::kCsrcAudioLevelsUri;
+}
+
+bool RtpExtension::IsSupportedForVideo(absl::string_view uri) {
+ return uri == webrtc::RtpExtension::kTimestampOffsetUri ||
+ uri == webrtc::RtpExtension::kAbsSendTimeUri ||
+ uri == webrtc::RtpExtension::kAbsoluteCaptureTimeUri ||
+ uri == webrtc::RtpExtension::kVideoRotationUri ||
+ uri == webrtc::RtpExtension::kTransportSequenceNumberUri ||
+ uri == webrtc::RtpExtension::kTransportSequenceNumberV2Uri ||
+ uri == webrtc::RtpExtension::kPlayoutDelayUri ||
+ uri == webrtc::RtpExtension::kVideoContentTypeUri ||
+ uri == webrtc::RtpExtension::kVideoTimingUri ||
+ uri == webrtc::RtpExtension::kMidUri ||
+ uri == webrtc::RtpExtension::kGenericFrameDescriptorUri00 ||
+ uri == webrtc::RtpExtension::kDependencyDescriptorUri ||
+ uri == webrtc::RtpExtension::kColorSpaceUri ||
+ uri == webrtc::RtpExtension::kRidUri ||
+ uri == webrtc::RtpExtension::kRepairedRidUri ||
+ uri == webrtc::RtpExtension::kVideoLayersAllocationUri ||
+ uri == webrtc::RtpExtension::kVideoFrameTrackingIdUri;
+}
+
+bool RtpExtension::IsEncryptionSupported(absl::string_view uri) {
+ return
+#if defined(ENABLE_EXTERNAL_AUTH)
+ // TODO(jbauch): Figure out a way to always allow "kAbsSendTimeUri"
+ // here and filter out later if external auth is really used in
+ // srtpfilter. External auth is used by Chromium and replaces the
+ // extension header value of "kAbsSendTimeUri", so it must not be
+ // encrypted (which can't be done by Chromium).
+ uri != webrtc::RtpExtension::kAbsSendTimeUri &&
+#endif
+ uri != webrtc::RtpExtension::kEncryptHeaderExtensionsUri;
+}
+
+// Returns whether a header extension with the given URI exists.
+// Note: This does not differentiate between encrypted and non-encrypted
+// extensions, so use with care!
+static bool HeaderExtensionWithUriExists(
+ const std::vector<RtpExtension>& extensions,
+ absl::string_view uri) {
+ for (const auto& extension : extensions) {
+ if (extension.uri == uri) {
+ return true;
+ }
+ }
+ return false;
+}
+
+const RtpExtension* RtpExtension::FindHeaderExtensionByUri(
+ const std::vector<RtpExtension>& extensions,
+ absl::string_view uri,
+ Filter filter) {
+ const webrtc::RtpExtension* fallback_extension = nullptr;
+ for (const auto& extension : extensions) {
+ if (extension.uri != uri) {
+ continue;
+ }
+
+ switch (filter) {
+ case kDiscardEncryptedExtension:
+ // We only accept an unencrypted extension.
+ if (!extension.encrypt) {
+ return &extension;
+ }
+ break;
+
+ case kPreferEncryptedExtension:
+ // We prefer an encrypted extension but we can fall back to an
+ // unencrypted extension.
+ if (extension.encrypt) {
+ return &extension;
+ } else {
+ fallback_extension = &extension;
+ }
+ break;
+
+ case kRequireEncryptedExtension:
+ // We only accept an encrypted extension.
+ if (extension.encrypt) {
+ return &extension;
+ }
+ break;
+ }
+ }
+
+ // Returning fallback extension (if any)
+ return fallback_extension;
+}
+
+const RtpExtension* RtpExtension::FindHeaderExtensionByUriAndEncryption(
+ const std::vector<RtpExtension>& extensions,
+ absl::string_view uri,
+ bool encrypt) {
+ for (const auto& extension : extensions) {
+ if (extension.uri == uri && extension.encrypt == encrypt) {
+ return &extension;
+ }
+ }
+ return nullptr;
+}
+
+const std::vector<RtpExtension> RtpExtension::DeduplicateHeaderExtensions(
+ const std::vector<RtpExtension>& extensions,
+ Filter filter) {
+ std::vector<RtpExtension> filtered;
+
+ // If we do not discard encrypted extensions, add them first
+ if (filter != kDiscardEncryptedExtension) {
+ for (const auto& extension : extensions) {
+ if (!extension.encrypt) {
+ continue;
+ }
+ if (!HeaderExtensionWithUriExists(filtered, extension.uri)) {
+ filtered.push_back(extension);
+ }
+ }
+ }
+
+ // If we do not require encrypted extensions, add missing, non-encrypted
+ // extensions.
+ if (filter != kRequireEncryptedExtension) {
+ for (const auto& extension : extensions) {
+ if (extension.encrypt) {
+ continue;
+ }
+ if (!HeaderExtensionWithUriExists(filtered, extension.uri)) {
+ filtered.push_back(extension);
+ }
+ }
+ }
+
+ // Sort the returned vector to make comparisons of header extensions reliable.
+ // In order of priority, we sort by uri first, then encrypt and id last.
+ std::sort(filtered.begin(), filtered.end(),
+ [](const RtpExtension& a, const RtpExtension& b) {
+ return std::tie(a.uri, a.encrypt, a.id) <
+ std::tie(b.uri, b.encrypt, b.id);
+ });
+
+ return filtered;
+}
+} // namespace webrtc
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-01 22:57:14 +0000