1 /*
2 * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10 #include "api/rtp_parameters.h"
11
12 #include <algorithm>
13 #include <string>
14 #include <tuple>
15 #include <utility>
16
17 #include "api/array_view.h"
18 #include "rtc_base/strings/string_builder.h"
19
20 namespace webrtc {
21
DegradationPreferenceToString(DegradationPreference degradation_preference)22 const char* DegradationPreferenceToString(
23 DegradationPreference degradation_preference) {
24 switch (degradation_preference) {
25 case DegradationPreference::DISABLED:
26 return "disabled";
27 case DegradationPreference::MAINTAIN_FRAMERATE:
28 return "maintain-framerate";
29 case DegradationPreference::MAINTAIN_RESOLUTION:
30 return "maintain-resolution";
31 case DegradationPreference::BALANCED:
32 return "balanced";
33 }
34 RTC_CHECK_NOTREACHED();
35 }
36
37 const double kDefaultBitratePriority = 1.0;
38
39 RtcpFeedback::RtcpFeedback() = default;
RtcpFeedback(RtcpFeedbackType type)40 RtcpFeedback::RtcpFeedback(RtcpFeedbackType type) : type(type) {}
RtcpFeedback(RtcpFeedbackType type,RtcpFeedbackMessageType message_type)41 RtcpFeedback::RtcpFeedback(RtcpFeedbackType type,
42 RtcpFeedbackMessageType message_type)
43 : type(type), message_type(message_type) {}
44 RtcpFeedback::RtcpFeedback(const RtcpFeedback& rhs) = default;
45 RtcpFeedback::~RtcpFeedback() = default;
46
47 RtpCodecCapability::RtpCodecCapability() = default;
48 RtpCodecCapability::~RtpCodecCapability() = default;
49
50 RtpHeaderExtensionCapability::RtpHeaderExtensionCapability() = default;
RtpHeaderExtensionCapability(absl::string_view uri)51 RtpHeaderExtensionCapability::RtpHeaderExtensionCapability(
52 absl::string_view uri)
53 : uri(uri) {}
RtpHeaderExtensionCapability(absl::string_view uri,int preferred_id)54 RtpHeaderExtensionCapability::RtpHeaderExtensionCapability(
55 absl::string_view uri,
56 int preferred_id)
57 : uri(uri), preferred_id(preferred_id) {}
RtpHeaderExtensionCapability(absl::string_view uri,int preferred_id,RtpTransceiverDirection direction)58 RtpHeaderExtensionCapability::RtpHeaderExtensionCapability(
59 absl::string_view uri,
60 int preferred_id,
61 RtpTransceiverDirection direction)
62 : uri(uri), preferred_id(preferred_id), direction(direction) {}
63 RtpHeaderExtensionCapability::~RtpHeaderExtensionCapability() = default;
64
65 RtpExtension::RtpExtension() = default;
RtpExtension(absl::string_view uri,int id)66 RtpExtension::RtpExtension(absl::string_view uri, int id) : uri(uri), id(id) {}
RtpExtension(absl::string_view uri,int id,bool encrypt)67 RtpExtension::RtpExtension(absl::string_view uri, int id, bool encrypt)
68 : uri(uri), id(id), encrypt(encrypt) {}
69 RtpExtension::~RtpExtension() = default;
70
71 RtpFecParameters::RtpFecParameters() = default;
RtpFecParameters(FecMechanism mechanism)72 RtpFecParameters::RtpFecParameters(FecMechanism mechanism)
73 : mechanism(mechanism) {}
RtpFecParameters(FecMechanism mechanism,uint32_t ssrc)74 RtpFecParameters::RtpFecParameters(FecMechanism mechanism, uint32_t ssrc)
75 : ssrc(ssrc), mechanism(mechanism) {}
76 RtpFecParameters::RtpFecParameters(const RtpFecParameters& rhs) = default;
77 RtpFecParameters::~RtpFecParameters() = default;
78
79 RtpRtxParameters::RtpRtxParameters() = default;
RtpRtxParameters(uint32_t ssrc)80 RtpRtxParameters::RtpRtxParameters(uint32_t ssrc) : ssrc(ssrc) {}
81 RtpRtxParameters::RtpRtxParameters(const RtpRtxParameters& rhs) = default;
82 RtpRtxParameters::~RtpRtxParameters() = default;
83
84 RtpEncodingParameters::RtpEncodingParameters() = default;
85 RtpEncodingParameters::RtpEncodingParameters(const RtpEncodingParameters& rhs) =
86 default;
87 RtpEncodingParameters::~RtpEncodingParameters() = default;
88
89 RtpCodecParameters::RtpCodecParameters() = default;
90 RtpCodecParameters::RtpCodecParameters(const RtpCodecParameters& rhs) = default;
91 RtpCodecParameters::~RtpCodecParameters() = default;
92
93 RtpCapabilities::RtpCapabilities() = default;
94 RtpCapabilities::~RtpCapabilities() = default;
95
96 RtcpParameters::RtcpParameters() = default;
97 RtcpParameters::RtcpParameters(const RtcpParameters& rhs) = default;
98 RtcpParameters::~RtcpParameters() = default;
99
100 RtpParameters::RtpParameters() = default;
101 RtpParameters::RtpParameters(const RtpParameters& rhs) = default;
102 RtpParameters::~RtpParameters() = default;
103
ToString() const104 std::string RtpExtension::ToString() const {
105 char buf[256];
106 rtc::SimpleStringBuilder sb(buf);
107 sb << "{uri: " << uri;
108 sb << ", id: " << id;
109 if (encrypt) {
110 sb << ", encrypt";
111 }
112 sb << '}';
113 return sb.str();
114 }
115
116 constexpr char RtpExtension::kEncryptHeaderExtensionsUri[];
117 constexpr char RtpExtension::kAudioLevelUri[];
118 constexpr char RtpExtension::kTimestampOffsetUri[];
119 constexpr char RtpExtension::kAbsSendTimeUri[];
120 constexpr char RtpExtension::kAbsoluteCaptureTimeUri[];
121 constexpr char RtpExtension::kVideoRotationUri[];
122 constexpr char RtpExtension::kVideoContentTypeUri[];
123 constexpr char RtpExtension::kVideoTimingUri[];
124 constexpr char RtpExtension::kGenericFrameDescriptorUri00[];
125 constexpr char RtpExtension::kDependencyDescriptorUri[];
126 constexpr char RtpExtension::kVideoLayersAllocationUri[];
127 constexpr char RtpExtension::kTransportSequenceNumberUri[];
128 constexpr char RtpExtension::kTransportSequenceNumberV2Uri[];
129 constexpr char RtpExtension::kPlayoutDelayUri[];
130 constexpr char RtpExtension::kColorSpaceUri[];
131 constexpr char RtpExtension::kMidUri[];
132 constexpr char RtpExtension::kRidUri[];
133 constexpr char RtpExtension::kRepairedRidUri[];
134 constexpr char RtpExtension::kVideoFrameTrackingIdUri[];
135 constexpr char RtpExtension::kCsrcAudioLevelsUri[];
136
137 constexpr int RtpExtension::kMinId;
138 constexpr int RtpExtension::kMaxId;
139 constexpr int RtpExtension::kMaxValueSize;
140 constexpr int RtpExtension::kOneByteHeaderExtensionMaxId;
141 constexpr int RtpExtension::kOneByteHeaderExtensionMaxValueSize;
142
IsSupportedForAudio(absl::string_view uri)143 bool RtpExtension::IsSupportedForAudio(absl::string_view uri) {
144 return uri == webrtc::RtpExtension::kAudioLevelUri ||
145 uri == webrtc::RtpExtension::kAbsSendTimeUri ||
146 uri == webrtc::RtpExtension::kAbsoluteCaptureTimeUri ||
147 uri == webrtc::RtpExtension::kTransportSequenceNumberUri ||
148 uri == webrtc::RtpExtension::kTransportSequenceNumberV2Uri ||
149 uri == webrtc::RtpExtension::kMidUri ||
150 uri == webrtc::RtpExtension::kRidUri ||
151 uri == webrtc::RtpExtension::kRepairedRidUri;
152 }
153
IsSupportedForVideo(absl::string_view uri)154 bool RtpExtension::IsSupportedForVideo(absl::string_view uri) {
155 return uri == webrtc::RtpExtension::kTimestampOffsetUri ||
156 uri == webrtc::RtpExtension::kAbsSendTimeUri ||
157 uri == webrtc::RtpExtension::kAbsoluteCaptureTimeUri ||
158 uri == webrtc::RtpExtension::kVideoRotationUri ||
159 uri == webrtc::RtpExtension::kTransportSequenceNumberUri ||
160 uri == webrtc::RtpExtension::kTransportSequenceNumberV2Uri ||
161 uri == webrtc::RtpExtension::kPlayoutDelayUri ||
162 uri == webrtc::RtpExtension::kVideoContentTypeUri ||
163 uri == webrtc::RtpExtension::kVideoTimingUri ||
164 uri == webrtc::RtpExtension::kMidUri ||
165 uri == webrtc::RtpExtension::kGenericFrameDescriptorUri00 ||
166 uri == webrtc::RtpExtension::kDependencyDescriptorUri ||
167 uri == webrtc::RtpExtension::kColorSpaceUri ||
168 uri == webrtc::RtpExtension::kRidUri ||
169 uri == webrtc::RtpExtension::kRepairedRidUri ||
170 uri == webrtc::RtpExtension::kVideoLayersAllocationUri ||
171 uri == webrtc::RtpExtension::kVideoFrameTrackingIdUri;
172 }
173
IsEncryptionSupported(absl::string_view uri)174 bool RtpExtension::IsEncryptionSupported(absl::string_view uri) {
175 return
176 #if defined(ENABLE_EXTERNAL_AUTH)
177 // TODO(jbauch): Figure out a way to always allow "kAbsSendTimeUri"
178 // here and filter out later if external auth is really used in
179 // srtpfilter. External auth is used by Chromium and replaces the
180 // extension header value of "kAbsSendTimeUri", so it must not be
181 // encrypted (which can't be done by Chromium).
182 uri != webrtc::RtpExtension::kAbsSendTimeUri &&
183 #endif
184 uri != webrtc::RtpExtension::kEncryptHeaderExtensionsUri;
185 }
186
187 // Returns whether a header extension with the given URI exists.
188 // Note: This does not differentiate between encrypted and non-encrypted
189 // extensions, so use with care!
HeaderExtensionWithUriExists(const std::vector<RtpExtension> & extensions,absl::string_view uri)190 static bool HeaderExtensionWithUriExists(
191 const std::vector<RtpExtension>& extensions,
192 absl::string_view uri) {
193 for (const auto& extension : extensions) {
194 if (extension.uri == uri) {
195 return true;
196 }
197 }
198 return false;
199 }
200
FindHeaderExtensionByUri(const std::vector<RtpExtension> & extensions,absl::string_view uri,Filter filter)201 const RtpExtension* RtpExtension::FindHeaderExtensionByUri(
202 const std::vector<RtpExtension>& extensions,
203 absl::string_view uri,
204 Filter filter) {
205 const webrtc::RtpExtension* fallback_extension = nullptr;
206 for (const auto& extension : extensions) {
207 if (extension.uri != uri) {
208 continue;
209 }
210
211 switch (filter) {
212 case kDiscardEncryptedExtension:
213 // We only accept an unencrypted extension.
214 if (!extension.encrypt) {
215 return &extension;
216 }
217 break;
218
219 case kPreferEncryptedExtension:
220 // We prefer an encrypted extension but we can fall back to an
221 // unencrypted extension.
222 if (extension.encrypt) {
223 return &extension;
224 } else {
225 fallback_extension = &extension;
226 }
227 break;
228
229 case kRequireEncryptedExtension:
230 // We only accept an encrypted extension.
231 if (extension.encrypt) {
232 return &extension;
233 }
234 break;
235 }
236 }
237
238 // Returning fallback extension (if any)
239 return fallback_extension;
240 }
241
FindHeaderExtensionByUriAndEncryption(const std::vector<RtpExtension> & extensions,absl::string_view uri,bool encrypt)242 const RtpExtension* RtpExtension::FindHeaderExtensionByUriAndEncryption(
243 const std::vector<RtpExtension>& extensions,
244 absl::string_view uri,
245 bool encrypt) {
246 for (const auto& extension : extensions) {
247 if (extension.uri == uri && extension.encrypt == encrypt) {
248 return &extension;
249 }
250 }
251 return nullptr;
252 }
253
DeduplicateHeaderExtensions(const std::vector<RtpExtension> & extensions,Filter filter)254 const std::vector<RtpExtension> RtpExtension::DeduplicateHeaderExtensions(
255 const std::vector<RtpExtension>& extensions,
256 Filter filter) {
257 std::vector<RtpExtension> filtered;
258
259 // If we do not discard encrypted extensions, add them first
260 if (filter != kDiscardEncryptedExtension) {
261 for (const auto& extension : extensions) {
262 if (!extension.encrypt) {
263 continue;
264 }
265 if (!HeaderExtensionWithUriExists(filtered, extension.uri)) {
266 filtered.push_back(extension);
267 }
268 }
269 }
270
271 // If we do not require encrypted extensions, add missing, non-encrypted
272 // extensions.
273 if (filter != kRequireEncryptedExtension) {
274 for (const auto& extension : extensions) {
275 if (extension.encrypt) {
276 continue;
277 }
278 if (!HeaderExtensionWithUriExists(filtered, extension.uri)) {
279 filtered.push_back(extension);
280 }
281 }
282 }
283
284 // Sort the returned vector to make comparisons of header extensions reliable.
285 // In order of priority, we sort by uri first, then encrypt and id last.
286 std::sort(filtered.begin(), filtered.end(),
287 [](const RtpExtension& a, const RtpExtension& b) {
288 return std::tie(a.uri, a.encrypt, a.id) <
289 std::tie(b.uri, b.encrypt, b.id);
290 });
291
292 return filtered;
293 }
294 } // namespace webrtc
295