blob: ef01eca80df32df94420c1ac85bb39ebb903c0e5 [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:361/*
kjellanderb24317b2016-02-10 15:54:432 * Copyright 2011 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:363 *
kjellanderb24317b2016-02-10 15:54:434 * 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.
henrike@webrtc.org28e20752013-07-10 00:45:369 */
10
Steve Anton10542f22019-01-11 17:11:0011#include "pc/webrtc_sdp.h"
henrike@webrtc.org28e20752013-07-10 00:45:3612
kjellandera96e2d72016-02-05 07:52:2813#include <ctype.h>
henrike@webrtc.org28e20752013-07-10 00:45:3614#include <limits.h>
15#include <stdio.h>
kwibergd1fe2812016-04-27 13:47:2916
henrike@webrtc.org28e20752013-07-10 00:45:3617#include <algorithm>
Steve Anton36b29d12017-10-30 16:57:4218#include <map>
kwibergd1fe2812016-04-27 13:47:2919#include <memory>
Steve Anton36b29d12017-10-30 16:57:4220#include <set>
henrike@webrtc.org28e20752013-07-10 00:45:3621#include <string>
deadbeef67cf2c12016-04-13 17:07:1622#include <unordered_map>
Steve Anton4905edb2018-10-16 02:27:4423#include <utility>
henrike@webrtc.org28e20752013-07-10 00:45:3624#include <vector>
25
Steve Anton64b626b2019-01-29 01:25:2626#include "absl/algorithm/container.h"
Niels Möller039743e2018-10-23 08:07:2527#include "absl/strings/match.h"
Patrik Höglunde2d6a062017-10-05 12:53:3328#include "api/candidate.h"
Steve Anton10542f22019-01-11 17:11:0029#include "api/crypto_params.h"
30#include "api/jsep_ice_candidate.h"
31#include "api/jsep_session_description.h"
32#include "api/media_types.h"
isheriff6f8d6862016-05-26 18:24:5533// for RtpExtension
Steve Anton10542f22019-01-11 17:11:0034#include "api/rtp_parameters.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3135#include "media/base/codec.h"
Steve Anton10542f22019-01-11 17:11:0036#include "media/base/media_constants.h"
37#include "media/base/rtp_utils.h"
38#include "media/sctp/sctp_transport_internal.h"
39#include "p2p/base/p2p_constants.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3140#include "p2p/base/port.h"
Steve Anton10542f22019-01-11 17:11:0041#include "pc/media_session.h"
42#include "pc/sdp_serializer.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3143#include "rtc_base/arraysize.h"
44#include "rtc_base/checks.h"
45#include "rtc_base/logging.h"
Steve Anton10542f22019-01-11 17:11:0046#include "rtc_base/message_digest.h"
Niels Möller198cf002019-05-10 10:29:1347#include "rtc_base/string_utils.h"
Jonas Olssonec9e4922018-09-05 07:53:4948#include "rtc_base/strings/string_builder.h"
Piotr (Peter) Slatala13e570f2019-02-27 19:34:2649#include "rtc_base/third_party/base64/base64.h"
henrike@webrtc.org28e20752013-07-10 00:45:3650
51using cricket::AudioContentDescription;
52using cricket::Candidate;
53using cricket::Candidates;
henrike@webrtc.org28e20752013-07-10 00:45:3654using cricket::ContentInfo;
55using cricket::CryptoParams;
Harald Alvestrand141c0ad2019-05-05 19:00:0056using cricket::ICE_CANDIDATE_COMPONENT_RTCP;
Harald Alvestrand37f2b432019-05-09 07:19:5457using cricket::ICE_CANDIDATE_COMPONENT_RTP;
henrike@webrtc.org28e20752013-07-10 00:45:3658using cricket::kCodecParamMaxPTime;
henrike@webrtc.org28e20752013-07-10 00:45:3659using cricket::kCodecParamMinPTime;
60using cricket::kCodecParamPTime;
henrike@webrtc.org28e20752013-07-10 00:45:3661using cricket::MediaContentDescription;
Harald Alvestrand141c0ad2019-05-05 19:00:0062using cricket::MediaProtocolType;
Harald Alvestrand37f2b432019-05-09 07:19:5463using cricket::MediaType;
Harald Alvestrand141c0ad2019-05-05 19:00:0064using cricket::RidDescription;
Harald Alvestrand5fc28b12019-05-13 11:36:1665using cricket::RtpDataContentDescription;
Harald Alvestrand37f2b432019-05-09 07:19:5466using cricket::RtpHeaderExtensions;
Harald Alvestrand5fc28b12019-05-13 11:36:1667using cricket::SctpDataContentDescription;
Amit Hilbucha2012042018-12-03 19:35:0568using cricket::SimulcastDescription;
Amit Hilbuchc57d5732018-12-11 23:30:1169using cricket::SimulcastLayer;
70using cricket::SimulcastLayerList;
henrike@webrtc.org28e20752013-07-10 00:45:3671using cricket::SsrcGroup;
72using cricket::StreamParams;
73using cricket::StreamParamsVec;
74using cricket::TransportDescription;
75using cricket::TransportInfo;
76using cricket::VideoContentDescription;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:5277using rtc::SocketAddress;
henrike@webrtc.org28e20752013-07-10 00:45:3678
henrike@webrtc.org28e20752013-07-10 00:45:3679namespace cricket {
80class SessionDescription;
81}
82
deadbeef90f1e1e2017-02-10 20:35:0583// TODO(deadbeef): Switch to using anonymous namespace rather than declaring
84// everything "static".
henrike@webrtc.org28e20752013-07-10 00:45:3685namespace webrtc {
86
87// Line type
88// RFC 4566
89// An SDP session description consists of a number of lines of text of
90// the form:
91// <type>=<value>
92// where <type> MUST be exactly one case-significant character.
deadbeef9d3584c2016-02-17 01:54:1093static const int kLinePrefixLength = 2; // Length of <type>=
henrike@webrtc.org28e20752013-07-10 00:45:3694static const char kLineTypeVersion = 'v';
95static const char kLineTypeOrigin = 'o';
96static const char kLineTypeSessionName = 's';
97static const char kLineTypeSessionInfo = 'i';
98static const char kLineTypeSessionUri = 'u';
99static const char kLineTypeSessionEmail = 'e';
100static const char kLineTypeSessionPhone = 'p';
101static const char kLineTypeSessionBandwidth = 'b';
102static const char kLineTypeTiming = 't';
103static const char kLineTypeRepeatTimes = 'r';
104static const char kLineTypeTimeZone = 'z';
105static const char kLineTypeEncryptionKey = 'k';
106static const char kLineTypeMedia = 'm';
107static const char kLineTypeConnection = 'c';
108static const char kLineTypeAttributes = 'a';
109
110// Attributes
111static const char kAttributeGroup[] = "group";
112static const char kAttributeMid[] = "mid";
deadbeef9d3584c2016-02-17 01:54:10113static const char kAttributeMsid[] = "msid";
deadbeef25ed4352016-12-13 02:37:36114static const char kAttributeBundleOnly[] = "bundle-only";
henrike@webrtc.org28e20752013-07-10 00:45:36115static const char kAttributeRtcpMux[] = "rtcp-mux";
deadbeef13871492015-12-09 20:37:51116static const char kAttributeRtcpReducedSize[] = "rtcp-rsize";
henrike@webrtc.org28e20752013-07-10 00:45:36117static const char kAttributeSsrc[] = "ssrc";
118static const char kSsrcAttributeCname[] = "cname";
Johannes Kron0854eb62018-10-10 20:33:20119static const char kAttributeExtmapAllowMixed[] = "extmap-allow-mixed";
henrike@webrtc.org28e20752013-07-10 00:45:36120static const char kAttributeExtmap[] = "extmap";
121// draft-alvestrand-mmusic-msid-01
122// a=msid-semantic: WMS
Seth Hampson5b4f0752018-04-02 23:31:36123// This is a legacy field supported only for Plan B semantics.
henrike@webrtc.org28e20752013-07-10 00:45:36124static const char kAttributeMsidSemantics[] = "msid-semantic";
125static const char kMediaStreamSemantic[] = "WMS";
126static const char kSsrcAttributeMsid[] = "msid";
127static const char kDefaultMsid[] = "default";
Seth Hampson5b4f0752018-04-02 23:31:36128static const char kNoStreamMsid[] = "-";
Artem Titovf0a34f22020-03-16 17:52:04129static const char kSsrcAttributeMslabel[] = "mslabel";
130static const char kSSrcAttributeLabel[] = "label";
henrike@webrtc.org28e20752013-07-10 00:45:36131static const char kAttributeSsrcGroup[] = "ssrc-group";
132static const char kAttributeCrypto[] = "crypto";
133static const char kAttributeCandidate[] = "candidate";
134static const char kAttributeCandidateTyp[] = "typ";
135static const char kAttributeCandidateRaddr[] = "raddr";
136static const char kAttributeCandidateRport[] = "rport";
honghaiza54a0802015-12-17 02:37:23137static const char kAttributeCandidateUfrag[] = "ufrag";
138static const char kAttributeCandidatePwd[] = "pwd";
henrike@webrtc.org28e20752013-07-10 00:45:36139static const char kAttributeCandidateGeneration[] = "generation";
honghaiza0c44ea2016-03-23 23:07:48140static const char kAttributeCandidateNetworkId[] = "network-id";
honghaize1a0c942016-02-16 22:54:56141static const char kAttributeCandidateNetworkCost[] = "network-cost";
henrike@webrtc.org28e20752013-07-10 00:45:36142static const char kAttributeFingerprint[] = "fingerprint";
sergeyu@chromium.org0be6aa02013-08-23 23:21:25143static const char kAttributeSetup[] = "setup";
henrike@webrtc.org28e20752013-07-10 00:45:36144static const char kAttributeFmtp[] = "fmtp";
145static const char kAttributeRtpmap[] = "rtpmap";
wu@webrtc.org78187522013-10-07 23:32:02146static const char kAttributeSctpmap[] = "sctpmap";
henrike@webrtc.org28e20752013-07-10 00:45:36147static const char kAttributeRtcp[] = "rtcp";
148static const char kAttributeIceUfrag[] = "ice-ufrag";
149static const char kAttributeIcePwd[] = "ice-pwd";
150static const char kAttributeIceLite[] = "ice-lite";
151static const char kAttributeIceOption[] = "ice-options";
152static const char kAttributeSendOnly[] = "sendonly";
153static const char kAttributeRecvOnly[] = "recvonly";
154static const char kAttributeRtcpFb[] = "rtcp-fb";
155static const char kAttributeSendRecv[] = "sendrecv";
156static const char kAttributeInactive[] = "inactive";
Harald Alvestrand48cce4d2019-04-11 08:41:24157// draft-ietf-mmusic-sctp-sdp-26
158// a=sctp-port, a=max-message-size
jiayl@webrtc.orgddb85ab2014-09-05 16:31:56159static const char kAttributeSctpPort[] = "sctp-port";
Harald Alvestrand48cce4d2019-04-11 08:41:24160static const char kAttributeMaxMessageSize[] = "max-message-size";
Harald Alvestrandfbb45bd2019-05-15 06:07:47161static const int kDefaultSctpMaxMessageSize = 65536;
Amit Hilbucha2012042018-12-03 19:35:05162// draft-ietf-mmusic-sdp-simulcast-13
163// a=simulcast
164static const char kAttributeSimulcast[] = "simulcast";
Amit Hilbuchc57d5732018-12-11 23:30:11165// draft-ietf-mmusic-rid-15
166// a=rid
167static const char kAttributeRid[] = "rid";
Mirta Dvornicic479a3c02019-06-04 13:38:50168static const char kAttributePacketization[] = "packetization";
henrike@webrtc.org28e20752013-07-10 00:45:36169
170// Experimental flags
171static const char kAttributeXGoogleFlag[] = "x-google-flag";
172static const char kValueConference[] = "conference";
henrike@webrtc.org28e20752013-07-10 00:45:36173
Sebastian Janssone1795f42019-07-24 09:38:03174static const char kAttributeRtcpRemoteEstimate[] = "remote-net-estimate";
175
henrike@webrtc.org28e20752013-07-10 00:45:36176// Candidate
177static const char kCandidateHost[] = "host";
178static const char kCandidateSrflx[] = "srflx";
Honghai Zhang7fb69db2016-03-14 18:59:18179static const char kCandidatePrflx[] = "prflx";
henrike@webrtc.org28e20752013-07-10 00:45:36180static const char kCandidateRelay[] = "relay";
mallinath@webrtc.org2d60c5e2014-08-08 22:29:20181static const char kTcpCandidateType[] = "tcptype";
henrike@webrtc.org28e20752013-07-10 00:45:36182
Jonas Olssonec9e4922018-09-05 07:53:49183// rtc::StringBuilder doesn't have a << overload for chars, while rtc::split and
184// rtc::tokenize_first both take a char delimiter. To handle both cases these
185// constants come in pairs of a chars and length-one strings.
186static const char kSdpDelimiterEqual[] = "=";
187static const char kSdpDelimiterEqualChar = '=';
188static const char kSdpDelimiterSpace[] = " ";
189static const char kSdpDelimiterSpaceChar = ' ';
190static const char kSdpDelimiterColon[] = ":";
191static const char kSdpDelimiterColonChar = ':';
192static const char kSdpDelimiterSemicolon[] = ";";
193static const char kSdpDelimiterSemicolonChar = ';';
194static const char kSdpDelimiterSlashChar = '/';
195static const char kNewLine[] = "\n";
196static const char kNewLineChar = '\n';
197static const char kReturnChar = '\r';
henrike@webrtc.org28e20752013-07-10 00:45:36198static const char kLineBreak[] = "\r\n";
199
Steve Anton36b29d12017-10-30 16:57:42200// TODO(deadbeef): Generate the Session and Time description
henrike@webrtc.org28e20752013-07-10 00:45:36201// instead of hardcoding.
202static const char kSessionVersion[] = "v=0";
203// RFC 4566
204static const char kSessionOriginUsername[] = "-";
205static const char kSessionOriginSessionId[] = "0";
206static const char kSessionOriginSessionVersion[] = "0";
207static const char kSessionOriginNettype[] = "IN";
208static const char kSessionOriginAddrtype[] = "IP4";
209static const char kSessionOriginAddress[] = "127.0.0.1";
210static const char kSessionName[] = "s=-";
211static const char kTimeDescription[] = "t=0 0";
212static const char kAttrGroup[] = "a=group:BUNDLE";
213static const char kConnectionNettype[] = "IN";
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22214static const char kConnectionIpv4Addrtype[] = "IP4";
215static const char kConnectionIpv6Addrtype[] = "IP6";
henrike@webrtc.org28e20752013-07-10 00:45:36216static const char kMediaTypeVideo[] = "video";
217static const char kMediaTypeAudio[] = "audio";
218static const char kMediaTypeData[] = "application";
219static const char kMediaPortRejected[] = "0";
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22220// draft-ietf-mmusic-trickle-ice-01
221// When no candidates have been gathered, set the connection
222// address to IP6 ::.
perkj@webrtc.orgd105cc82014-11-07 11:22:06223// TODO(perkj): FF can not parse IP6 ::. See http://crbug/430333
224// Use IPV4 per default.
225static const char kDummyAddress[] = "0.0.0.0";
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22226static const char kDummyPort[] = "9";
henrike@webrtc.org28e20752013-07-10 00:45:36227// RFC 3556
228static const char kApplicationSpecificMaximum[] = "AS";
229
wu@webrtc.org78187522013-10-07 23:32:02230static const char kDefaultSctpmapProtocol[] = "webrtc-datachannel";
henrike@webrtc.org28e20752013-07-10 00:45:36231
pkasting@chromium.orgd3245462015-02-23 21:28:22232// RTP payload type is in the 0-127 range. Use -1 to indicate "all" payload
233// types.
234const int kWildcardPayloadType = -1;
235
henrike@webrtc.org28e20752013-07-10 00:45:36236struct SsrcInfo {
Peter Boström0c4e06b2015-10-07 10:23:21237 uint32_t ssrc_id;
henrike@webrtc.org28e20752013-07-10 00:45:36238 std::string cname;
deadbeef9d3584c2016-02-17 01:54:10239 std::string stream_id;
240 std::string track_id;
Artem Titovf0a34f22020-03-16 17:52:04241
242 // For backward compatibility.
243 // TODO(ronghuawu): Remove below 2 fields once all the clients support msid.
244 std::string label;
245 std::string mslabel;
henrike@webrtc.org28e20752013-07-10 00:45:36246};
247typedef std::vector<SsrcInfo> SsrcInfoVec;
248typedef std::vector<SsrcGroup> SsrcGroupVec;
249
henrike@webrtc.org28e20752013-07-10 00:45:36250template <class T>
251static void AddFmtpLine(const T& codec, std::string* message);
252static void BuildMediaDescription(const ContentInfo* content_info,
253 const TransportInfo* transport_info,
Patrik Höglundb6b29e02018-06-21 14:58:01254 const cricket::MediaType media_type,
wu@webrtc.org4c3e9912014-07-16 21:03:13255 const std::vector<Candidate>& candidates,
Steve Antone831b8c2018-02-01 20:22:16256 int msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:36257 std::string* message);
deadbeef9d3584c2016-02-17 01:54:10258static void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
Patrik Höglundb6b29e02018-06-21 14:58:01259 const cricket::MediaType media_type,
Steve Antone831b8c2018-02-01 20:22:16260 int msid_signaling,
deadbeef9d3584c2016-02-17 01:54:10261 std::string* message);
henrike@webrtc.org28e20752013-07-10 00:45:36262static void BuildRtpMap(const MediaContentDescription* media_desc,
Patrik Höglundb6b29e02018-06-21 14:58:01263 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:36264 std::string* message);
265static void BuildCandidate(const std::vector<Candidate>& candidates,
honghaiza54a0802015-12-17 02:37:23266 bool include_ufrag,
henrike@webrtc.org28e20752013-07-10 00:45:36267 std::string* message);
268static void BuildIceOptions(const std::vector<std::string>& transport_options,
269 std::string* message);
zhihuang38989e52017-03-21 18:04:53270static bool ParseSessionDescription(const std::string& message,
271 size_t* pos,
henrike@webrtc.org28e20752013-07-10 00:45:36272 std::string* session_id,
273 std::string* session_version,
henrike@webrtc.org28e20752013-07-10 00:45:36274 TransportDescription* session_td,
275 RtpHeaderExtensions* session_extmaps,
zhihuang38989e52017-03-21 18:04:53276 rtc::SocketAddress* connection_addr,
henrike@webrtc.org28e20752013-07-10 00:45:36277 cricket::SessionDescription* desc,
278 SdpParseError* error);
279static bool ParseGroupAttribute(const std::string& line,
280 cricket::SessionDescription* desc,
281 SdpParseError* error);
282static bool ParseMediaDescription(
283 const std::string& message,
284 const TransportDescription& session_td,
285 const RtpHeaderExtensions& session_extmaps,
zhihuang38989e52017-03-21 18:04:53286 size_t* pos,
287 const rtc::SocketAddress& session_connection_addr,
288 cricket::SessionDescription* desc,
Steve Anton5a1de872018-12-18 19:25:55289 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
henrike@webrtc.org28e20752013-07-10 00:45:36290 SdpParseError* error);
Steve Anton5a1de872018-12-18 19:25:55291static bool ParseContent(
292 const std::string& message,
293 const cricket::MediaType media_type,
294 int mline_index,
295 const std::string& protocol,
296 const std::vector<int>& payload_types,
297 size_t* pos,
298 std::string* content_name,
299 bool* bundle_only,
300 int* msid_signaling,
301 MediaContentDescription* media_desc,
302 TransportDescription* transport,
303 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
304 SdpParseError* error);
henrike@webrtc.org28e20752013-07-10 00:45:36305static bool ParseSsrcAttribute(const std::string& line,
306 SsrcInfoVec* ssrc_infos,
Steve Antone831b8c2018-02-01 20:22:16307 int* msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:36308 SdpParseError* error);
309static bool ParseSsrcGroupAttribute(const std::string& line,
310 SsrcGroupVec* ssrc_groups,
311 SdpParseError* error);
312static bool ParseCryptoAttribute(const std::string& line,
313 MediaContentDescription* media_desc,
314 SdpParseError* error);
315static bool ParseRtpmapAttribute(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:01316 const cricket::MediaType media_type,
deadbeef67cf2c12016-04-13 17:07:16317 const std::vector<int>& payload_types,
henrike@webrtc.org28e20752013-07-10 00:45:36318 MediaContentDescription* media_desc,
319 SdpParseError* error);
320static bool ParseFmtpAttributes(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:01321 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:36322 MediaContentDescription* media_desc,
323 SdpParseError* error);
Yves Gerey665174f2018-06-19 13:03:05324static bool ParseFmtpParam(const std::string& line,
325 std::string* parameter,
326 std::string* value,
327 SdpParseError* error);
Mirta Dvornicic479a3c02019-06-04 13:38:50328static bool ParsePacketizationAttribute(const std::string& line,
329 const cricket::MediaType media_type,
330 MediaContentDescription* media_desc,
331 SdpParseError* error);
henrike@webrtc.org28e20752013-07-10 00:45:36332static bool ParseRtcpFbAttribute(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:01333 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:36334 MediaContentDescription* media_desc,
335 SdpParseError* error);
336static bool ParseIceOptions(const std::string& line,
337 std::vector<std::string>* transport_options,
338 SdpParseError* error);
339static bool ParseExtmap(const std::string& line,
isheriff6f8d6862016-05-26 18:24:55340 RtpExtension* extmap,
henrike@webrtc.org28e20752013-07-10 00:45:36341 SdpParseError* error);
Steve Anton4905edb2018-10-16 02:27:44342static bool ParseFingerprintAttribute(
343 const std::string& line,
344 std::unique_ptr<rtc::SSLFingerprint>* fingerprint,
345 SdpParseError* error);
sergeyu@chromium.org0be6aa02013-08-23 23:21:25346static bool ParseDtlsSetup(const std::string& line,
347 cricket::ConnectionRole* role,
348 SdpParseError* error);
deadbeef9d3584c2016-02-17 01:54:10349static bool ParseMsidAttribute(const std::string& line,
Seth Hampson5b4f0752018-04-02 23:31:36350 std::vector<std::string>* stream_ids,
deadbeef9d3584c2016-02-17 01:54:10351 std::string* track_id,
352 SdpParseError* error);
henrike@webrtc.org28e20752013-07-10 00:45:36353
Amit Hilbuchc57d5732018-12-11 23:30:11354static void RemoveInvalidRidDescriptions(const std::vector<int>& payload_types,
355 std::vector<RidDescription>* rids);
356
357static SimulcastLayerList RemoveRidsFromSimulcastLayerList(
358 const std::set<std::string>& to_remove,
359 const SimulcastLayerList& layers);
360
361static void RemoveInvalidRidsFromSimulcast(
362 const std::vector<RidDescription>& rids,
363 SimulcastDescription* simulcast);
364
henrike@webrtc.org28e20752013-07-10 00:45:36365// Helper functions
366
367// Below ParseFailed*** functions output the line that caused the parsing
368// failure and the detailed reason (|description|) of the failure to |error|.
369// The functions always return false so that they can be used directly in the
370// following way when error happens:
371// "return ParseFailed***(...);"
372
373// The line starting at |line_start| of |message| is the failing line.
374// The reason for the failure should be provided in the |description|.
375// An example of a description could be "unknown character".
376static bool ParseFailed(const std::string& message,
377 size_t line_start,
378 const std::string& description,
379 SdpParseError* error) {
380 // Get the first line of |message| from |line_start|.
sergeyu@chromium.org5bc25c42013-12-05 00:24:06381 std::string first_line;
henrike@webrtc.org28e20752013-07-10 00:45:36382 size_t line_end = message.find(kNewLine, line_start);
383 if (line_end != std::string::npos) {
Jonas Olssonec9e4922018-09-05 07:53:49384 if (line_end > 0 && (message.at(line_end - 1) == kReturnChar)) {
henrike@webrtc.org28e20752013-07-10 00:45:36385 --line_end;
386 }
387 first_line = message.substr(line_start, (line_end - line_start));
sergeyu@chromium.org5bc25c42013-12-05 00:24:06388 } else {
389 first_line = message.substr(line_start);
henrike@webrtc.org28e20752013-07-10 00:45:36390 }
391
392 if (error) {
393 error->line = first_line;
394 error->description = description;
395 }
Mirko Bonadei675513b2017-11-09 10:09:25396 RTC_LOG(LS_ERROR) << "Failed to parse: \"" << first_line
397 << "\". Reason: " << description;
henrike@webrtc.org28e20752013-07-10 00:45:36398 return false;
399}
400
401// |line| is the failing line. The reason for the failure should be
402// provided in the |description|.
403static bool ParseFailed(const std::string& line,
404 const std::string& description,
405 SdpParseError* error) {
406 return ParseFailed(line, 0, description, error);
407}
408
409// Parses failure where the failing SDP line isn't know or there are multiple
410// failing lines.
Yves Gerey665174f2018-06-19 13:03:05411static bool ParseFailed(const std::string& description, SdpParseError* error) {
henrike@webrtc.org28e20752013-07-10 00:45:36412 return ParseFailed("", description, error);
413}
414
415// |line| is the failing line. The failure is due to the fact that |line|
416// doesn't have |expected_fields| fields.
417static bool ParseFailedExpectFieldNum(const std::string& line,
418 int expected_fields,
419 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:49420 rtc::StringBuilder description;
henrike@webrtc.org28e20752013-07-10 00:45:36421 description << "Expects " << expected_fields << " fields.";
422 return ParseFailed(line, description.str(), error);
423}
424
425// |line| is the failing line. The failure is due to the fact that |line| has
426// less than |expected_min_fields| fields.
427static bool ParseFailedExpectMinFieldNum(const std::string& line,
428 int expected_min_fields,
429 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:49430 rtc::StringBuilder description;
henrike@webrtc.org28e20752013-07-10 00:45:36431 description << "Expects at least " << expected_min_fields << " fields.";
432 return ParseFailed(line, description.str(), error);
433}
434
435// |line| is the failing line. The failure is due to the fact that it failed to
436// get the value of |attribute|.
437static bool ParseFailedGetValue(const std::string& line,
438 const std::string& attribute,
439 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:49440 rtc::StringBuilder description;
henrike@webrtc.org28e20752013-07-10 00:45:36441 description << "Failed to get the value of attribute: " << attribute;
442 return ParseFailed(line, description.str(), error);
443}
444
445// The line starting at |line_start| of |message| is the failing line. The
446// failure is due to the line type (e.g. the "m" part of the "m-line")
447// not matching what is expected. The expected line type should be
448// provided as |line_type|.
449static bool ParseFailedExpectLine(const std::string& message,
450 size_t line_start,
451 const char line_type,
452 const std::string& line_value,
453 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:49454 rtc::StringBuilder description;
455 description << "Expect line: " << std::string(1, line_type) << "="
456 << line_value;
henrike@webrtc.org28e20752013-07-10 00:45:36457 return ParseFailed(message, line_start, description.str(), error);
458}
459
460static bool AddLine(const std::string& line, std::string* message) {
461 if (!message)
462 return false;
463
464 message->append(line);
465 message->append(kLineBreak);
466 return true;
467}
468
469static bool GetLine(const std::string& message,
470 size_t* pos,
471 std::string* line) {
472 size_t line_begin = *pos;
473 size_t line_end = message.find(kNewLine, line_begin);
474 if (line_end == std::string::npos) {
475 return false;
476 }
477 // Update the new start position
478 *pos = line_end + 1;
Jonas Olssonec9e4922018-09-05 07:53:49479 if (line_end > 0 && (message.at(line_end - 1) == kReturnChar)) {
henrike@webrtc.org28e20752013-07-10 00:45:36480 --line_end;
481 }
482 *line = message.substr(line_begin, (line_end - line_begin));
483 const char* cline = line->c_str();
484 // RFC 4566
485 // An SDP session description consists of a number of lines of text of
486 // the form:
487 // <type>=<value>
488 // where <type> MUST be exactly one case-significant character and
489 // <value> is structured text whose format depends on <type>.
490 // Whitespace MUST NOT be used on either side of the "=" sign.
Taylor Brandstetter93a7b242018-04-16 17:45:24491 //
492 // However, an exception to the whitespace rule is made for "s=", since
493 // RFC4566 also says:
494 //
495 // If a session has no meaningful name, the value "s= " SHOULD be used
496 // (i.e., a single space as the session name).
497 if (line->length() < 3 || !islower(cline[0]) ||
Jonas Olssonec9e4922018-09-05 07:53:49498 cline[1] != kSdpDelimiterEqualChar ||
499 (cline[0] != kLineTypeSessionName &&
500 cline[2] == kSdpDelimiterSpaceChar)) {
henrike@webrtc.org28e20752013-07-10 00:45:36501 *pos = line_begin;
502 return false;
503 }
504 return true;
505}
506
507// Init |os| to "|type|=|value|".
508static void InitLine(const char type,
509 const std::string& value,
Jonas Olssonec9e4922018-09-05 07:53:49510 rtc::StringBuilder* os) {
511 os->Clear();
512 *os << std::string(1, type) << kSdpDelimiterEqual << value;
henrike@webrtc.org28e20752013-07-10 00:45:36513}
514
515// Init |os| to "a=|attribute|".
Jonas Olssonec9e4922018-09-05 07:53:49516static void InitAttrLine(const std::string& attribute, rtc::StringBuilder* os) {
henrike@webrtc.org28e20752013-07-10 00:45:36517 InitLine(kLineTypeAttributes, attribute, os);
518}
519
520// Writes a SDP attribute line based on |attribute| and |value| to |message|.
Yves Gerey665174f2018-06-19 13:03:05521static void AddAttributeLine(const std::string& attribute,
522 int value,
henrike@webrtc.org28e20752013-07-10 00:45:36523 std::string* message) {
Jonas Olssonec9e4922018-09-05 07:53:49524 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:36525 InitAttrLine(attribute, &os);
526 os << kSdpDelimiterColon << value;
527 AddLine(os.str(), message);
528}
529
henrike@webrtc.org28e20752013-07-10 00:45:36530static bool IsLineType(const std::string& message,
531 const char type,
532 size_t line_start) {
533 if (message.size() < line_start + kLinePrefixLength) {
534 return false;
535 }
536 const char* cmessage = message.c_str();
537 return (cmessage[line_start] == type &&
Jonas Olssonec9e4922018-09-05 07:53:49538 cmessage[line_start + 1] == kSdpDelimiterEqualChar);
henrike@webrtc.org28e20752013-07-10 00:45:36539}
540
Yves Gerey665174f2018-06-19 13:03:05541static bool IsLineType(const std::string& line, const char type) {
henrike@webrtc.org28e20752013-07-10 00:45:36542 return IsLineType(line, type, 0);
543}
544
Yves Gerey665174f2018-06-19 13:03:05545static bool GetLineWithType(const std::string& message,
546 size_t* pos,
547 std::string* line,
548 const char type) {
henrike@webrtc.org28e20752013-07-10 00:45:36549 if (!IsLineType(message, type, *pos)) {
550 return false;
551 }
552
553 if (!GetLine(message, pos, line))
554 return false;
555
556 return true;
557}
558
559static bool HasAttribute(const std::string& line,
560 const std::string& attribute) {
Johannes Kron211856b2018-09-06 10:12:28561 if (line.compare(kLinePrefixLength, attribute.size(), attribute) == 0) {
562 // Make sure that the match is not only a partial match. If length of
563 // strings doesn't match, the next character of the line must be ':' or ' '.
564 // This function is also used for media descriptions (e.g., "m=audio 9..."),
565 // hence the need to also allow space in the end.
566 RTC_CHECK_LE(kLinePrefixLength + attribute.size(), line.size());
567 if ((kLinePrefixLength + attribute.size()) == line.size() ||
568 line[kLinePrefixLength + attribute.size()] == kSdpDelimiterColonChar ||
569 line[kLinePrefixLength + attribute.size()] == kSdpDelimiterSpaceChar) {
570 return true;
571 }
572 }
573 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36574}
575
Peter Boström0c4e06b2015-10-07 10:23:21576static bool AddSsrcLine(uint32_t ssrc_id,
577 const std::string& attribute,
578 const std::string& value,
579 std::string* message) {
henrike@webrtc.org28e20752013-07-10 00:45:36580 // RFC 5576
581 // a=ssrc:<ssrc-id> <attribute>:<value>
Jonas Olssonec9e4922018-09-05 07:53:49582 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:36583 InitAttrLine(kAttributeSsrc, &os);
Yves Gerey665174f2018-06-19 13:03:05584 os << kSdpDelimiterColon << ssrc_id << kSdpDelimiterSpace << attribute
585 << kSdpDelimiterColon << value;
henrike@webrtc.org28e20752013-07-10 00:45:36586 return AddLine(os.str(), message);
587}
588
henrike@webrtc.org28e20752013-07-10 00:45:36589// Get value only from <attribute>:<value>.
Yves Gerey665174f2018-06-19 13:03:05590static bool GetValue(const std::string& message,
591 const std::string& attribute,
592 std::string* value,
593 SdpParseError* error) {
henrike@webrtc.org28e20752013-07-10 00:45:36594 std::string leftpart;
Jonas Olssonec9e4922018-09-05 07:53:49595 if (!rtc::tokenize_first(message, kSdpDelimiterColonChar, &leftpart, value)) {
henrike@webrtc.org28e20752013-07-10 00:45:36596 return ParseFailedGetValue(message, attribute, error);
597 }
598 // The left part should end with the expected attribute.
599 if (leftpart.length() < attribute.length() ||
600 leftpart.compare(leftpart.length() - attribute.length(),
601 attribute.length(), attribute) != 0) {
602 return ParseFailedGetValue(message, attribute, error);
603 }
604 return true;
605}
606
607static bool CaseInsensitiveFind(std::string str1, std::string str2) {
Steve Anton64b626b2019-01-29 01:25:26608 absl::c_transform(str1, str1.begin(), ::tolower);
609 absl::c_transform(str2, str2.begin(), ::tolower);
henrike@webrtc.org28e20752013-07-10 00:45:36610 return str1.find(str2) != std::string::npos;
611}
612
wu@webrtc.org5e760e72014-04-02 23:19:09613template <class T>
614static bool GetValueFromString(const std::string& line,
615 const std::string& s,
616 T* t,
617 SdpParseError* error) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52618 if (!rtc::FromString(s, t)) {
Jonas Olssonec9e4922018-09-05 07:53:49619 rtc::StringBuilder description;
wu@webrtc.org5e760e72014-04-02 23:19:09620 description << "Invalid value: " << s << ".";
621 return ParseFailed(line, description.str(), error);
622 }
623 return true;
624}
625
pkasting@chromium.orge9facf82015-02-17 20:36:28626static bool GetPayloadTypeFromString(const std::string& line,
627 const std::string& s,
628 int* payload_type,
629 SdpParseError* error) {
630 return GetValueFromString(line, s, payload_type, error) &&
Yves Gerey665174f2018-06-19 13:03:05631 cricket::IsValidRtpPayloadType(*payload_type);
pkasting@chromium.orge9facf82015-02-17 20:36:28632}
633
Seth Hampson5897a6e2018-04-03 18:16:33634// Creates a StreamParams track in the case when no SSRC lines are signaled.
635// This is a track that does not contain SSRCs and only contains
636// stream_ids/track_id if it's signaled with a=msid lines.
637void CreateTrackWithNoSsrcs(const std::vector<std::string>& msid_stream_ids,
638 const std::string& msid_track_id,
Amit Hilbuchc57d5732018-12-11 23:30:11639 const std::vector<RidDescription>& rids,
Seth Hampson5897a6e2018-04-03 18:16:33640 StreamParamsVec* tracks) {
641 StreamParams track;
Amit Hilbuch6df49d82019-04-15 22:47:21642 if (msid_track_id.empty() && rids.empty()) {
Seth Hampson5897a6e2018-04-03 18:16:33643 // We only create an unsignaled track if a=msid lines were signaled.
Amit Hilbuch6df49d82019-04-15 22:47:21644 RTC_LOG(LS_INFO) << "MSID not signaled, skipping creation of StreamParams";
Seth Hampson5897a6e2018-04-03 18:16:33645 return;
646 }
647 track.set_stream_ids(msid_stream_ids);
648 track.id = msid_track_id;
Amit Hilbuchc57d5732018-12-11 23:30:11649 track.set_rids(rids);
Seth Hampson5897a6e2018-04-03 18:16:33650 tracks->push_back(track);
651}
652
653// Creates the StreamParams tracks, for the case when SSRC lines are signaled.
654// |msid_stream_ids| and |msid_track_id| represent the stream/track ID from the
Taylor Brandstetter5de6b752016-03-10 01:02:30655// "a=msid" attribute, if it exists. They are empty if the attribute does not
Seth Hampson5897a6e2018-04-03 18:16:33656// exist. We prioritize getting stream_ids/track_ids signaled in a=msid lines.
henrike@webrtc.org28e20752013-07-10 00:45:36657void CreateTracksFromSsrcInfos(const SsrcInfoVec& ssrc_infos,
Seth Hampson5b4f0752018-04-02 23:31:36658 const std::vector<std::string>& msid_stream_ids,
Taylor Brandstetter5de6b752016-03-10 01:02:30659 const std::string& msid_track_id,
Seth Hampson5b4f0752018-04-02 23:31:36660 StreamParamsVec* tracks,
661 int msid_signaling) {
nisseede5da42017-01-12 13:15:36662 RTC_DCHECK(tracks != NULL);
Steve Anton4daf66e2018-09-07 21:55:53663 for (const SsrcInfo& ssrc_info : ssrc_infos) {
Taylor Brandstetter4256df02020-02-18 22:05:07664 // According to https://tools.ietf.org/html/rfc5576#section-6.1, the CNAME
665 // attribute is mandatory, but we relax that restriction.
Steve Anton4daf66e2018-09-07 21:55:53666 if (ssrc_info.cname.empty()) {
Taylor Brandstetter4256df02020-02-18 22:05:07667 RTC_LOG(LS_WARNING) << "CNAME attribute missing for SSRC "
668 << ssrc_info.ssrc_id;
henrike@webrtc.org28e20752013-07-10 00:45:36669 }
Seth Hampson5b4f0752018-04-02 23:31:36670 std::vector<std::string> stream_ids;
henrike@webrtc.org28e20752013-07-10 00:45:36671 std::string track_id;
Seth Hampson5b4f0752018-04-02 23:31:36672 if (msid_signaling & cricket::kMsidSignalingMediaSection) {
673 // This is the case with Unified Plan SDP msid signaling.
674 stream_ids = msid_stream_ids;
Tomas Gunnarsson191bf5c2018-03-30 10:44:43675 track_id = msid_track_id;
Seth Hampson5b4f0752018-04-02 23:31:36676 } else if (msid_signaling & cricket::kMsidSignalingSsrcAttribute) {
677 // This is the case with Plan B SDP msid signaling.
Steve Anton4daf66e2018-09-07 21:55:53678 stream_ids.push_back(ssrc_info.stream_id);
679 track_id = ssrc_info.track_id;
Artem Titovf0a34f22020-03-16 17:52:04680 } else if (!ssrc_info.mslabel.empty()) {
681 // Since there's no a=msid or a=ssrc msid signaling, this is a sdp from
682 // an older version of client that doesn't support msid.
683 // In that case, we use the mslabel and label to construct the track.
684 stream_ids.push_back(ssrc_info.mslabel);
685 track_id = ssrc_info.label;
Seth Hampson5b4f0752018-04-02 23:31:36686 } else {
687 // Since no media streams isn't supported with older SDP signaling, we
688 // use a default a stream id.
689 stream_ids.push_back(kDefaultMsid);
henrike@webrtc.org28e20752013-07-10 00:45:36690 }
Seth Hampson5b4f0752018-04-02 23:31:36691 // If a track ID wasn't populated from the SSRC attributes OR the
Taylor Brandstetter5de6b752016-03-10 01:02:30692 // msid attribute, use default/random values.
Taylor Brandstetter5de6b752016-03-10 01:02:30693 if (track_id.empty()) {
694 // TODO(ronghuawu): What should we do if the track id doesn't appear?
695 // Create random string (which will be used as track label later)?
696 track_id = rtc::CreateRandomString(8);
henrike@webrtc.org28e20752013-07-10 00:45:36697 }
698
Steve Anton64b626b2019-01-29 01:25:26699 auto track_it = absl::c_find_if(
700 *tracks,
Steve Anton4daf66e2018-09-07 21:55:53701 [track_id](const StreamParams& track) { return track.id == track_id; });
702 if (track_it == tracks->end()) {
henrike@webrtc.org28e20752013-07-10 00:45:36703 // If we don't find an existing track, create a new one.
704 tracks->push_back(StreamParams());
Steve Anton4daf66e2018-09-07 21:55:53705 track_it = tracks->end() - 1;
henrike@webrtc.org28e20752013-07-10 00:45:36706 }
Steve Anton4daf66e2018-09-07 21:55:53707 StreamParams& track = *track_it;
708 track.add_ssrc(ssrc_info.ssrc_id);
709 track.cname = ssrc_info.cname;
710 track.set_stream_ids(stream_ids);
711 track.id = track_id;
henrike@webrtc.org28e20752013-07-10 00:45:36712 }
713}
714
Seth Hampson845e8782018-03-02 19:34:10715void GetMediaStreamIds(const ContentInfo* content,
716 std::set<std::string>* labels) {
Steve Antonb1c1de12017-12-21 23:14:30717 for (const StreamParams& stream_params :
718 content->media_description()->streams()) {
Seth Hampson845e8782018-03-02 19:34:10719 for (const std::string& stream_id : stream_params.stream_ids()) {
720 labels->insert(stream_id);
Steve Anton5a26a3a2018-02-28 19:38:47721 }
henrike@webrtc.org28e20752013-07-10 00:45:36722 }
723}
724
725// RFC 5245
726// It is RECOMMENDED that default candidates be chosen based on the
727// likelihood of those candidates to work with the peer that is being
728// contacted. It is RECOMMENDED that relayed > reflexive > host.
729static const int kPreferenceUnknown = 0;
730static const int kPreferenceHost = 1;
731static const int kPreferenceReflexive = 2;
732static const int kPreferenceRelayed = 3;
733
734static int GetCandidatePreferenceFromType(const std::string& type) {
735 int preference = kPreferenceUnknown;
736 if (type == cricket::LOCAL_PORT_TYPE) {
737 preference = kPreferenceHost;
738 } else if (type == cricket::STUN_PORT_TYPE) {
739 preference = kPreferenceReflexive;
740 } else if (type == cricket::RELAY_PORT_TYPE) {
741 preference = kPreferenceRelayed;
742 } else {
nissec80e7412017-01-11 13:56:46743 RTC_NOTREACHED();
henrike@webrtc.org28e20752013-07-10 00:45:36744 }
745 return preference;
746}
747
guoweis@webrtc.org57ac2c82015-02-06 00:45:13748// Get ip and port of the default destination from the |candidates| with the
749// given value of |component_id|. The default candidate should be the one most
750// likely to work, typically IPv4 relay.
henrike@webrtc.org28e20752013-07-10 00:45:36751// RFC 5245
752// The value of |component_id| currently supported are 1 (RTP) and 2 (RTCP).
Steve Anton36b29d12017-10-30 16:57:42753// TODO(deadbeef): Decide the default destination in webrtcsession and
henrike@webrtc.org28e20752013-07-10 00:45:36754// pass it down via SessionDescription.
Yves Gerey665174f2018-06-19 13:03:05755static void GetDefaultDestination(const std::vector<Candidate>& candidates,
756 int component_id,
757 std::string* port,
758 std::string* ip,
759 std::string* addr_type) {
perkj@webrtc.orgd105cc82014-11-07 11:22:06760 *addr_type = kConnectionIpv4Addrtype;
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22761 *port = kDummyPort;
762 *ip = kDummyAddress;
henrike@webrtc.org28e20752013-07-10 00:45:36763 int current_preference = kPreferenceUnknown;
guoweis@webrtc.org57ac2c82015-02-06 00:45:13764 int current_family = AF_UNSPEC;
Steve Anton4daf66e2018-09-07 21:55:53765 for (const Candidate& candidate : candidates) {
766 if (candidate.component() != component_id) {
henrike@webrtc.org28e20752013-07-10 00:45:36767 continue;
768 }
guoweis@webrtc.org57ac2c82015-02-06 00:45:13769 // Default destination should be UDP only.
Steve Anton4daf66e2018-09-07 21:55:53770 if (candidate.protocol() != cricket::UDP_PROTOCOL_NAME) {
henrike@webrtc.org28e20752013-07-10 00:45:36771 continue;
772 }
Steve Anton4daf66e2018-09-07 21:55:53773 const int preference = GetCandidatePreferenceFromType(candidate.type());
774 const int family = candidate.address().ipaddr().family();
guoweis@webrtc.org57ac2c82015-02-06 00:45:13775 // See if this candidate is more preferable then the current one if it's the
776 // same family. Or if the current family is IPv4 already so we could safely
777 // ignore all IPv6 ones. WebRTC bug 4269.
778 // http://code.google.com/p/webrtc/issues/detail?id=4269
779 if ((preference <= current_preference && current_family == family) ||
780 (current_family == AF_INET && family == AF_INET6)) {
781 continue;
782 }
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22783 if (family == AF_INET) {
784 addr_type->assign(kConnectionIpv4Addrtype);
785 } else if (family == AF_INET6) {
786 addr_type->assign(kConnectionIpv6Addrtype);
787 }
guoweis@webrtc.org57ac2c82015-02-06 00:45:13788 current_preference = preference;
789 current_family = family;
Steve Anton4daf66e2018-09-07 21:55:53790 *port = candidate.address().PortAsString();
791 *ip = candidate.address().ipaddr().ToString();
henrike@webrtc.org28e20752013-07-10 00:45:36792 }
henrike@webrtc.org28e20752013-07-10 00:45:36793}
794
wu@webrtc.org4c3e9912014-07-16 21:03:13795// Gets "a=rtcp" line if found default RTCP candidate from |candidates|.
796static std::string GetRtcpLine(const std::vector<Candidate>& candidates) {
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22797 std::string rtcp_line, rtcp_port, rtcp_ip, addr_type;
Yves Gerey665174f2018-06-19 13:03:05798 GetDefaultDestination(candidates, ICE_CANDIDATE_COMPONENT_RTCP, &rtcp_port,
799 &rtcp_ip, &addr_type);
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22800 // Found default RTCP candidate.
801 // RFC 5245
802 // If the agent is utilizing RTCP, it MUST encode the RTCP candidate
803 // using the a=rtcp attribute as defined in RFC 3605.
henrike@webrtc.org28e20752013-07-10 00:45:36804
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22805 // RFC 3605
806 // rtcp-attribute = "a=rtcp:" port [nettype space addrtype space
807 // connection-address] CRLF
Jonas Olssonec9e4922018-09-05 07:53:49808 rtc::StringBuilder os;
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22809 InitAttrLine(kAttributeRtcp, &os);
Yves Gerey665174f2018-06-19 13:03:05810 os << kSdpDelimiterColon << rtcp_port << " " << kConnectionNettype << " "
811 << addr_type << " " << rtcp_ip;
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22812 rtcp_line = os.str();
wu@webrtc.org4c3e9912014-07-16 21:03:13813 return rtcp_line;
henrike@webrtc.org28e20752013-07-10 00:45:36814}
815
816// Get candidates according to the mline index from SessionDescriptionInterface.
817static void GetCandidatesByMindex(const SessionDescriptionInterface& desci,
818 int mline_index,
819 std::vector<Candidate>* candidates) {
820 if (!candidates) {
821 return;
822 }
823 const IceCandidateCollection* cc = desci.candidates(mline_index);
824 for (size_t i = 0; i < cc->count(); ++i) {
825 const IceCandidateInterface* candidate = cc->at(i);
826 candidates->push_back(candidate->candidate());
827 }
828}
829
deadbeef90f1e1e2017-02-10 20:35:05830static bool IsValidPort(int port) {
831 return port >= 0 && port <= 65535;
832}
833
Steve Antone831b8c2018-02-01 20:22:16834std::string SdpSerialize(const JsepSessionDescription& jdesc) {
henrike@webrtc.org28e20752013-07-10 00:45:36835 const cricket::SessionDescription* desc = jdesc.description();
836 if (!desc) {
837 return "";
838 }
839
840 std::string message;
841
842 // Session Description.
843 AddLine(kSessionVersion, &message);
844 // Session Origin
845 // RFC 4566
846 // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
847 // <unicast-address>
Jonas Olssonec9e4922018-09-05 07:53:49848 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:36849 InitLine(kLineTypeOrigin, kSessionOriginUsername, &os);
Yves Gerey665174f2018-06-19 13:03:05850 const std::string& session_id =
851 jdesc.session_id().empty() ? kSessionOriginSessionId : jdesc.session_id();
852 const std::string& session_version = jdesc.session_version().empty()
853 ? kSessionOriginSessionVersion
854 : jdesc.session_version();
henrike@webrtc.org28e20752013-07-10 00:45:36855 os << " " << session_id << " " << session_version << " "
856 << kSessionOriginNettype << " " << kSessionOriginAddrtype << " "
857 << kSessionOriginAddress;
858 AddLine(os.str(), &message);
859 AddLine(kSessionName, &message);
860
861 // Time Description.
862 AddLine(kTimeDescription, &message);
863
864 // Group
865 if (desc->HasGroup(cricket::GROUP_TYPE_BUNDLE)) {
866 std::string group_line = kAttrGroup;
867 const cricket::ContentGroup* group =
868 desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
nisseede5da42017-01-12 13:15:36869 RTC_DCHECK(group != NULL);
Steve Anton4daf66e2018-09-07 21:55:53870 for (const std::string& content_name : group->content_names()) {
henrike@webrtc.org28e20752013-07-10 00:45:36871 group_line.append(" ");
Steve Anton4daf66e2018-09-07 21:55:53872 group_line.append(content_name);
henrike@webrtc.org28e20752013-07-10 00:45:36873 }
874 AddLine(group_line, &message);
875 }
876
Johannes Kron0854eb62018-10-10 20:33:20877 // Mixed one- and two-byte header extension.
Johannes Kron9581bc42018-10-23 08:17:39878 if (desc->extmap_allow_mixed()) {
Johannes Kron0854eb62018-10-10 20:33:20879 InitAttrLine(kAttributeExtmapAllowMixed, &os);
880 AddLine(os.str(), &message);
881 }
882
henrike@webrtc.org28e20752013-07-10 00:45:36883 // MediaStream semantics
884 InitAttrLine(kAttributeMsidSemantics, &os);
885 os << kSdpDelimiterColon << " " << kMediaStreamSemantic;
wu@webrtc.org4c3e9912014-07-16 21:03:13886
Seth Hampson845e8782018-03-02 19:34:10887 std::set<std::string> media_stream_ids;
henrike@webrtc.org28e20752013-07-10 00:45:36888 const ContentInfo* audio_content = GetFirstAudioContent(desc);
889 if (audio_content)
Seth Hampson845e8782018-03-02 19:34:10890 GetMediaStreamIds(audio_content, &media_stream_ids);
wu@webrtc.org4c3e9912014-07-16 21:03:13891
henrike@webrtc.org28e20752013-07-10 00:45:36892 const ContentInfo* video_content = GetFirstVideoContent(desc);
893 if (video_content)
Seth Hampson845e8782018-03-02 19:34:10894 GetMediaStreamIds(video_content, &media_stream_ids);
wu@webrtc.org4c3e9912014-07-16 21:03:13895
Steve Anton4daf66e2018-09-07 21:55:53896 for (const std::string& id : media_stream_ids) {
897 os << " " << id;
henrike@webrtc.org28e20752013-07-10 00:45:36898 }
899 AddLine(os.str(), &message);
900
Taylor Brandstetter2f65ec52018-05-24 18:37:28901 // a=ice-lite
902 //
903 // TODO(deadbeef): It's weird that we need to iterate TransportInfos for
904 // this, when it's a session-level attribute. It really should be moved to a
905 // session-level structure like SessionDescription.
906 for (const cricket::TransportInfo& transport : desc->transport_infos()) {
907 if (transport.description.ice_mode == cricket::ICEMODE_LITE) {
908 InitAttrLine(kAttributeIceLite, &os);
909 AddLine(os.str(), &message);
910 break;
911 }
912 }
913
wu@webrtc.org4c3e9912014-07-16 21:03:13914 // Preserve the order of the media contents.
915 int mline_index = -1;
Steve Anton4daf66e2018-09-07 21:55:53916 for (const ContentInfo& content : desc->contents()) {
wu@webrtc.org4c3e9912014-07-16 21:03:13917 std::vector<Candidate> candidates;
918 GetCandidatesByMindex(jdesc, ++mline_index, &candidates);
Steve Anton4daf66e2018-09-07 21:55:53919 BuildMediaDescription(&content, desc->GetTransportInfoByName(content.name),
920 content.media_description()->type(), candidates,
921 desc->msid_signaling(), &message);
henrike@webrtc.org28e20752013-07-10 00:45:36922 }
henrike@webrtc.org28e20752013-07-10 00:45:36923 return message;
924}
925
926// Serializes the passed in IceCandidateInterface to a SDP string.
927// candidate - The candidate to be serialized.
Honghai Zhang7fb69db2016-03-14 18:59:18928std::string SdpSerializeCandidate(const IceCandidateInterface& candidate) {
929 return SdpSerializeCandidate(candidate.candidate());
930}
931
932// Serializes a cricket Candidate.
933std::string SdpSerializeCandidate(const cricket::Candidate& candidate) {
henrike@webrtc.org28e20752013-07-10 00:45:36934 std::string message;
Honghai Zhang7fb69db2016-03-14 18:59:18935 std::vector<cricket::Candidate> candidates(1, candidate);
honghaiza54a0802015-12-17 02:37:23936 BuildCandidate(candidates, true, &message);
wu@webrtc.orgec9f5fb2014-06-24 17:05:10937 // From WebRTC draft section 4.8.1.1 candidate-attribute will be
938 // just candidate:<candidate> not a=candidate:<blah>CRLF
nisseede5da42017-01-12 13:15:36939 RTC_DCHECK(message.find("a=") == 0);
wu@webrtc.orgec9f5fb2014-06-24 17:05:10940 message.erase(0, 2);
nisseede5da42017-01-12 13:15:36941 RTC_DCHECK(message.find(kLineBreak) == message.size() - 2);
wu@webrtc.orgec9f5fb2014-06-24 17:05:10942 message.resize(message.size() - 2);
henrike@webrtc.org28e20752013-07-10 00:45:36943 return message;
944}
945
946bool SdpDeserialize(const std::string& message,
947 JsepSessionDescription* jdesc,
948 SdpParseError* error) {
949 std::string session_id;
950 std::string session_version;
Peter Thatcher7cbd1882015-09-18 01:54:52951 TransportDescription session_td("", "");
henrike@webrtc.org28e20752013-07-10 00:45:36952 RtpHeaderExtensions session_extmaps;
zhihuang38989e52017-03-21 18:04:53953 rtc::SocketAddress session_connection_addr;
Mirko Bonadei317a1f02019-09-17 15:06:18954 auto desc = std::make_unique<cricket::SessionDescription>();
henrike@webrtc.org28e20752013-07-10 00:45:36955 size_t current_pos = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36956
957 // Session Description
958 if (!ParseSessionDescription(message, &current_pos, &session_id,
deadbeefc80741f2015-10-22 20:14:45959 &session_version, &session_td, &session_extmaps,
Steve Anton5a1de872018-12-18 19:25:55960 &session_connection_addr, desc.get(), error)) {
henrike@webrtc.org28e20752013-07-10 00:45:36961 return false;
962 }
963
964 // Media Description
Steve Anton5a1de872018-12-18 19:25:55965 std::vector<std::unique_ptr<JsepIceCandidate>> candidates;
deadbeefc80741f2015-10-22 20:14:45966 if (!ParseMediaDescription(message, session_td, session_extmaps, &current_pos,
Steve Anton5a1de872018-12-18 19:25:55967 session_connection_addr, desc.get(), &candidates,
zhihuang38989e52017-03-21 18:04:53968 error)) {
henrike@webrtc.org28e20752013-07-10 00:45:36969 return false;
970 }
971
Harald Alvestrand4d7160e2019-04-12 05:01:29972 jdesc->Initialize(std::move(desc), session_id, session_version);
henrike@webrtc.org28e20752013-07-10 00:45:36973
Steve Anton5a1de872018-12-18 19:25:55974 for (const auto& candidate : candidates) {
975 jdesc->AddCandidate(candidate.get());
henrike@webrtc.org28e20752013-07-10 00:45:36976 }
977 return true;
978}
979
980bool SdpDeserializeCandidate(const std::string& message,
981 JsepIceCandidate* jcandidate,
982 SdpParseError* error) {
nisseede5da42017-01-12 13:15:36983 RTC_DCHECK(jcandidate != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36984 Candidate candidate;
985 if (!ParseCandidate(message, &candidate, error, true)) {
986 return false;
987 }
988 jcandidate->SetCandidate(candidate);
989 return true;
990}
991
Honghai Zhang7fb69db2016-03-14 18:59:18992bool SdpDeserializeCandidate(const std::string& transport_name,
993 const std::string& message,
994 cricket::Candidate* candidate,
995 SdpParseError* error) {
nisseede5da42017-01-12 13:15:36996 RTC_DCHECK(candidate != nullptr);
Honghai Zhang7fb69db2016-03-14 18:59:18997 if (!ParseCandidate(message, candidate, error, true)) {
998 return false;
999 }
1000 candidate->set_transport_name(transport_name);
1001 return true;
1002}
1003
Yves Gerey665174f2018-06-19 13:03:051004bool ParseCandidate(const std::string& message,
1005 Candidate* candidate,
1006 SdpParseError* error,
1007 bool is_raw) {
nisseede5da42017-01-12 13:15:361008 RTC_DCHECK(candidate != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:361009
1010 // Get the first line from |message|.
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151011 std::string first_line = message;
1012 size_t pos = 0;
1013 GetLine(message, &pos, &first_line);
henrike@webrtc.org28e20752013-07-10 00:45:361014
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151015 // Makes sure |message| contains only one line.
1016 if (message.size() > first_line.size()) {
1017 std::string left, right;
Jonas Olssonec9e4922018-09-05 07:53:491018 if (rtc::tokenize_first(message, kNewLineChar, &left, &right) &&
Donald Curtis0e07f922015-05-15 16:21:231019 !right.empty()) {
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151020 return ParseFailed(message, 0, "Expect one line only", error);
1021 }
1022 }
1023
1024 // From WebRTC draft section 4.8.1.1 candidate-attribute should be
1025 // candidate:<candidate> when trickled, but we still support
1026 // a=candidate:<blah>CRLF for backward compatibility and for parsing a line
1027 // from the SDP.
1028 if (IsLineType(first_line, kLineTypeAttributes)) {
1029 first_line = first_line.substr(kLinePrefixLength);
1030 }
1031
1032 std::string attribute_candidate;
1033 std::string candidate_value;
1034
1035 // |first_line| must be in the form of "candidate:<value>".
Jonas Olssonec9e4922018-09-05 07:53:491036 if (!rtc::tokenize_first(first_line, kSdpDelimiterColonChar,
1037 &attribute_candidate, &candidate_value) ||
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151038 attribute_candidate != kAttributeCandidate) {
henrike@webrtc.org28e20752013-07-10 00:45:361039 if (is_raw) {
Jonas Olssonec9e4922018-09-05 07:53:491040 rtc::StringBuilder description;
Jonas Olssonb2b20312020-01-14 11:11:311041 description << "Expect line: " << kAttributeCandidate
1042 << ":"
1043 "<candidate-str>";
henrike@webrtc.org28e20752013-07-10 00:45:361044 return ParseFailed(first_line, 0, description.str(), error);
1045 } else {
1046 return ParseFailedExpectLine(first_line, 0, kLineTypeAttributes,
1047 kAttributeCandidate, error);
1048 }
1049 }
1050
1051 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:491052 rtc::split(candidate_value, kSdpDelimiterSpaceChar, &fields);
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151053
henrike@webrtc.org28e20752013-07-10 00:45:361054 // RFC 5245
1055 // a=candidate:<foundation> <component-id> <transport> <priority>
1056 // <connection-address> <port> typ <candidate-types>
1057 // [raddr <connection-address>] [rport <port>]
1058 // *(SP extension-att-name SP extension-att-value)
1059 const size_t expected_min_fields = 8;
1060 if (fields.size() < expected_min_fields ||
1061 (fields[6] != kAttributeCandidateTyp)) {
1062 return ParseFailedExpectMinFieldNum(first_line, expected_min_fields, error);
1063 }
jbauch083b73f2015-07-16 09:46:321064 const std::string& foundation = fields[0];
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151065
wu@webrtc.org5e760e72014-04-02 23:19:091066 int component_id = 0;
1067 if (!GetValueFromString(first_line, fields[1], &component_id, error)) {
1068 return false;
1069 }
jbauch083b73f2015-07-16 09:46:321070 const std::string& transport = fields[2];
Peter Boström0c4e06b2015-10-07 10:23:211071 uint32_t priority = 0;
wu@webrtc.org5e760e72014-04-02 23:19:091072 if (!GetValueFromString(first_line, fields[3], &priority, error)) {
1073 return false;
1074 }
jbauch083b73f2015-07-16 09:46:321075 const std::string& connection_address = fields[4];
wu@webrtc.org5e760e72014-04-02 23:19:091076 int port = 0;
1077 if (!GetValueFromString(first_line, fields[5], &port, error)) {
1078 return false;
1079 }
deadbeef90f1e1e2017-02-10 20:35:051080 if (!IsValidPort(port)) {
1081 return ParseFailed(first_line, "Invalid port number.", error);
1082 }
henrike@webrtc.org28e20752013-07-10 00:45:361083 SocketAddress address(connection_address, port);
1084
1085 cricket::ProtocolType protocol;
hnslb68cc752016-12-13 18:33:411086 if (!StringToProto(transport.c_str(), &protocol)) {
henrike@webrtc.org28e20752013-07-10 00:45:361087 return ParseFailed(first_line, "Unsupported transport type.", error);
1088 }
Taylor Brandstetter8206bc02020-04-02 19:36:381089 bool tcp_protocol = false;
hnslb68cc752016-12-13 18:33:411090 switch (protocol) {
Taylor Brandstetter8206bc02020-04-02 19:36:381091 // Supported protocols.
hnslb68cc752016-12-13 18:33:411092 case cricket::PROTO_UDP:
Taylor Brandstetter8206bc02020-04-02 19:36:381093 break;
hnslb68cc752016-12-13 18:33:411094 case cricket::PROTO_TCP:
1095 case cricket::PROTO_SSLTCP:
Taylor Brandstetter8206bc02020-04-02 19:36:381096 tcp_protocol = true;
hnslb68cc752016-12-13 18:33:411097 break;
1098 default:
1099 return ParseFailed(first_line, "Unsupported transport type.", error);
1100 }
henrike@webrtc.org28e20752013-07-10 00:45:361101
1102 std::string candidate_type;
jbauch083b73f2015-07-16 09:46:321103 const std::string& type = fields[7];
henrike@webrtc.org28e20752013-07-10 00:45:361104 if (type == kCandidateHost) {
1105 candidate_type = cricket::LOCAL_PORT_TYPE;
1106 } else if (type == kCandidateSrflx) {
1107 candidate_type = cricket::STUN_PORT_TYPE;
1108 } else if (type == kCandidateRelay) {
1109 candidate_type = cricket::RELAY_PORT_TYPE;
Honghai Zhang7fb69db2016-03-14 18:59:181110 } else if (type == kCandidatePrflx) {
1111 candidate_type = cricket::PRFLX_PORT_TYPE;
henrike@webrtc.org28e20752013-07-10 00:45:361112 } else {
1113 return ParseFailed(first_line, "Unsupported candidate type.", error);
1114 }
1115
1116 size_t current_position = expected_min_fields;
1117 SocketAddress related_address;
1118 // The 2 optional fields for related address
1119 // [raddr <connection-address>] [rport <port>]
1120 if (fields.size() >= (current_position + 2) &&
1121 fields[current_position] == kAttributeCandidateRaddr) {
1122 related_address.SetIP(fields[++current_position]);
1123 ++current_position;
1124 }
1125 if (fields.size() >= (current_position + 2) &&
1126 fields[current_position] == kAttributeCandidateRport) {
wu@webrtc.org5e760e72014-04-02 23:19:091127 int port = 0;
Yves Gerey665174f2018-06-19 13:03:051128 if (!GetValueFromString(first_line, fields[++current_position], &port,
1129 error)) {
wu@webrtc.org5e760e72014-04-02 23:19:091130 return false;
1131 }
deadbeef90f1e1e2017-02-10 20:35:051132 if (!IsValidPort(port)) {
1133 return ParseFailed(first_line, "Invalid port number.", error);
1134 }
wu@webrtc.org5e760e72014-04-02 23:19:091135 related_address.SetPort(port);
henrike@webrtc.org28e20752013-07-10 00:45:361136 ++current_position;
1137 }
1138
mallinath@webrtc.org2d60c5e2014-08-08 22:29:201139 // If this is a TCP candidate, it has additional extension as defined in
1140 // RFC 6544.
1141 std::string tcptype;
1142 if (fields.size() >= (current_position + 2) &&
1143 fields[current_position] == kTcpCandidateType) {
1144 tcptype = fields[++current_position];
1145 ++current_position;
1146
1147 if (tcptype != cricket::TCPTYPE_ACTIVE_STR &&
1148 tcptype != cricket::TCPTYPE_PASSIVE_STR &&
1149 tcptype != cricket::TCPTYPE_SIMOPEN_STR) {
1150 return ParseFailed(first_line, "Invalid TCP candidate type.", error);
1151 }
1152
Taylor Brandstetter8206bc02020-04-02 19:36:381153 if (!tcp_protocol) {
mallinath@webrtc.org2d60c5e2014-08-08 22:29:201154 return ParseFailed(first_line, "Invalid non-TCP candidate", error);
1155 }
Taylor Brandstetter8206bc02020-04-02 19:36:381156 } else if (tcp_protocol) {
1157 // We allow the tcptype to be missing, for backwards compatibility,
1158 // treating it as a passive candidate.
1159 // TODO(bugs.webrtc.org/11466): Treat a missing tcptype as an error?
1160 tcptype = cricket::TCPTYPE_PASSIVE_STR;
mallinath@webrtc.org2d60c5e2014-08-08 22:29:201161 }
1162
henrike@webrtc.org28e20752013-07-10 00:45:361163 // Extension
honghaiza54a0802015-12-17 02:37:231164 // Though non-standard, we support the ICE ufrag and pwd being signaled on
1165 // the candidate to avoid issues with confusing which generation a candidate
1166 // belongs to when trickling multiple generations at the same time.
henrike@webrtc.org28e20752013-07-10 00:45:361167 std::string username;
1168 std::string password;
Peter Boström0c4e06b2015-10-07 10:23:211169 uint32_t generation = 0;
honghaiza0c44ea2016-03-23 23:07:481170 uint16_t network_id = 0;
1171 uint16_t network_cost = 0;
henrike@webrtc.org28e20752013-07-10 00:45:361172 for (size_t i = current_position; i + 1 < fields.size(); ++i) {
1173 // RFC 5245
1174 // *(SP extension-att-name SP extension-att-value)
1175 if (fields[i] == kAttributeCandidateGeneration) {
wu@webrtc.org5e760e72014-04-02 23:19:091176 if (!GetValueFromString(first_line, fields[++i], &generation, error)) {
1177 return false;
1178 }
honghaiza54a0802015-12-17 02:37:231179 } else if (fields[i] == kAttributeCandidateUfrag) {
henrike@webrtc.org28e20752013-07-10 00:45:361180 username = fields[++i];
honghaiza54a0802015-12-17 02:37:231181 } else if (fields[i] == kAttributeCandidatePwd) {
henrike@webrtc.org28e20752013-07-10 00:45:361182 password = fields[++i];
honghaiza0c44ea2016-03-23 23:07:481183 } else if (fields[i] == kAttributeCandidateNetworkId) {
1184 if (!GetValueFromString(first_line, fields[++i], &network_id, error)) {
1185 return false;
1186 }
honghaize1a0c942016-02-16 22:54:561187 } else if (fields[i] == kAttributeCandidateNetworkCost) {
1188 if (!GetValueFromString(first_line, fields[++i], &network_cost, error)) {
1189 return false;
1190 }
Honghai Zhang351d77b2016-05-20 22:08:291191 network_cost = std::min(network_cost, rtc::kNetworkCostMax);
henrike@webrtc.org28e20752013-07-10 00:45:361192 } else {
1193 // Skip the unknown extension.
1194 ++i;
1195 }
1196 }
1197
guoweis@webrtc.org61c12472015-01-15 06:53:071198 *candidate = Candidate(component_id, cricket::ProtoToString(protocol),
guoweis@webrtc.org950c5182014-12-16 23:01:311199 address, priority, username, password, candidate_type,
honghaiza0c44ea2016-03-23 23:07:481200 generation, foundation, network_id, network_cost);
henrike@webrtc.org28e20752013-07-10 00:45:361201 candidate->set_related_address(related_address);
mallinath@webrtc.org2d60c5e2014-08-08 22:29:201202 candidate->set_tcptype(tcptype);
henrike@webrtc.org28e20752013-07-10 00:45:361203 return true;
1204}
1205
1206bool ParseIceOptions(const std::string& line,
1207 std::vector<std::string>* transport_options,
1208 SdpParseError* error) {
1209 std::string ice_options;
1210 if (!GetValue(line, kAttributeIceOption, &ice_options, error)) {
1211 return false;
1212 }
1213 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:491214 rtc::split(ice_options, kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:361215 for (size_t i = 0; i < fields.size(); ++i) {
1216 transport_options->push_back(fields[i]);
1217 }
1218 return true;
1219}
1220
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561221bool ParseSctpPort(const std::string& line,
1222 int* sctp_port,
1223 SdpParseError* error) {
Harald Alvestrand48cce4d2019-04-11 08:41:241224 // draft-ietf-mmusic-sctp-sdp-26
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561225 // a=sctp-port
1226 std::vector<std::string> fields;
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561227 const size_t expected_min_fields = 2;
Jonas Olssonec9e4922018-09-05 07:53:491228 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterColonChar, &fields);
lally69f57602015-10-08 17:15:041229 if (fields.size() < expected_min_fields) {
1230 fields.resize(0);
Jonas Olssonec9e4922018-09-05 07:53:491231 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
lally69f57602015-10-08 17:15:041232 }
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561233 if (fields.size() < expected_min_fields) {
1234 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
1235 }
1236 if (!rtc::FromString(fields[1], sctp_port)) {
lally69f57602015-10-08 17:15:041237 return ParseFailed(line, "Invalid sctp port value.", error);
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561238 }
1239 return true;
1240}
1241
Harald Alvestrand48cce4d2019-04-11 08:41:241242bool ParseSctpMaxMessageSize(const std::string& line,
1243 int* max_message_size,
1244 SdpParseError* error) {
1245 // draft-ietf-mmusic-sctp-sdp-26
1246 // a=max-message-size:199999
1247 std::vector<std::string> fields;
1248 const size_t expected_min_fields = 2;
1249 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterColonChar, &fields);
1250 if (fields.size() < expected_min_fields) {
1251 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
1252 }
1253 if (!rtc::FromString(fields[1], max_message_size)) {
1254 return ParseFailed(line, "Invalid SCTP max message size.", error);
1255 }
1256 return true;
1257}
1258
isheriff6f8d6862016-05-26 18:24:551259bool ParseExtmap(const std::string& line,
1260 RtpExtension* extmap,
henrike@webrtc.org28e20752013-07-10 00:45:361261 SdpParseError* error) {
1262 // RFC 5285
1263 // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
1264 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:491265 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:361266 const size_t expected_min_fields = 2;
1267 if (fields.size() < expected_min_fields) {
1268 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
1269 }
1270 std::string uri = fields[1];
1271
1272 std::string value_direction;
1273 if (!GetValue(fields[0], kAttributeExtmap, &value_direction, error)) {
1274 return false;
1275 }
1276 std::vector<std::string> sub_fields;
Jonas Olssonec9e4922018-09-05 07:53:491277 rtc::split(value_direction, kSdpDelimiterSlashChar, &sub_fields);
wu@webrtc.org5e760e72014-04-02 23:19:091278 int value = 0;
1279 if (!GetValueFromString(line, sub_fields[0], &value, error)) {
1280 return false;
1281 }
henrike@webrtc.org28e20752013-07-10 00:45:361282
jbauch5869f502017-06-29 19:31:361283 bool encrypted = false;
1284 if (uri == RtpExtension::kEncryptHeaderExtensionsUri) {
1285 // RFC 6904
Steve Anton36b29d12017-10-30 16:57:421286 // a=extmap:<value["/"<direction>] urn:ietf:params:rtp-hdrext:encrypt <URI>
1287 // <extensionattributes>
jbauch5869f502017-06-29 19:31:361288 const size_t expected_min_fields_encrypted = expected_min_fields + 1;
1289 if (fields.size() < expected_min_fields_encrypted) {
1290 return ParseFailedExpectMinFieldNum(line, expected_min_fields_encrypted,
Yves Gerey665174f2018-06-19 13:03:051291 error);
jbauch5869f502017-06-29 19:31:361292 }
1293
1294 encrypted = true;
1295 uri = fields[2];
1296 if (uri == RtpExtension::kEncryptHeaderExtensionsUri) {
1297 return ParseFailed(line, "Recursive encrypted header.", error);
1298 }
1299 }
1300
1301 *extmap = RtpExtension(uri, value, encrypted);
henrike@webrtc.org28e20752013-07-10 00:45:361302 return true;
1303}
1304
Harald Alvestrandfbb45bd2019-05-15 06:07:471305static void BuildSctpContentAttributes(
1306 std::string* message,
1307 const cricket::SctpDataContentDescription* data_desc) {
1308 rtc::StringBuilder os;
1309 if (data_desc->use_sctpmap()) {
1310 // draft-ietf-mmusic-sctp-sdp-04
1311 // a=sctpmap:sctpmap-number protocol [streams]
1312 rtc::StringBuilder os;
1313 InitAttrLine(kAttributeSctpmap, &os);
1314 os << kSdpDelimiterColon << data_desc->port() << kSdpDelimiterSpace
1315 << kDefaultSctpmapProtocol << kSdpDelimiterSpace
1316 << cricket::kMaxSctpStreams;
1317 AddLine(os.str(), message);
1318 } else {
1319 // draft-ietf-mmusic-sctp-sdp-23
1320 // a=sctp-port:<port>
1321 InitAttrLine(kAttributeSctpPort, &os);
1322 os << kSdpDelimiterColon << data_desc->port();
1323 AddLine(os.str(), message);
1324 if (data_desc->max_message_size() != kDefaultSctpMaxMessageSize) {
1325 InitAttrLine(kAttributeMaxMessageSize, &os);
1326 os << kSdpDelimiterColon << data_desc->max_message_size();
1327 AddLine(os.str(), message);
1328 }
1329 }
1330}
1331
henrike@webrtc.org28e20752013-07-10 00:45:361332void BuildMediaDescription(const ContentInfo* content_info,
1333 const TransportInfo* transport_info,
Patrik Höglundb6b29e02018-06-21 14:58:011334 const cricket::MediaType media_type,
wu@webrtc.org4c3e9912014-07-16 21:03:131335 const std::vector<Candidate>& candidates,
Steve Antone831b8c2018-02-01 20:22:161336 int msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:361337 std::string* message) {
nisseede5da42017-01-12 13:15:361338 RTC_DCHECK(message != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:361339 if (content_info == NULL || message == NULL) {
1340 return;
1341 }
Jonas Olssonec9e4922018-09-05 07:53:491342 rtc::StringBuilder os;
Steve Antonb1c1de12017-12-21 23:14:301343 const MediaContentDescription* media_desc = content_info->media_description();
1344 RTC_DCHECK(media_desc);
henrike@webrtc.org28e20752013-07-10 00:45:361345
henrike@webrtc.org28e20752013-07-10 00:45:361346 // RFC 4566
1347 // m=<media> <port> <proto> <fmt>
1348 // fmt is a list of payload type numbers that MAY be used in the session.
1349 const char* type = NULL;
1350 if (media_type == cricket::MEDIA_TYPE_AUDIO)
1351 type = kMediaTypeAudio;
1352 else if (media_type == cricket::MEDIA_TYPE_VIDEO)
1353 type = kMediaTypeVideo;
1354 else if (media_type == cricket::MEDIA_TYPE_DATA)
1355 type = kMediaTypeData;
1356 else
nissec80e7412017-01-11 13:56:461357 RTC_NOTREACHED();
henrike@webrtc.org28e20752013-07-10 00:45:361358
1359 std::string fmt;
1360 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
Steve Antonb1c1de12017-12-21 23:14:301361 const VideoContentDescription* video_desc = media_desc->as_video();
Steve Anton4daf66e2018-09-07 21:55:531362 for (const cricket::VideoCodec& codec : video_desc->codecs()) {
henrike@webrtc.org28e20752013-07-10 00:45:361363 fmt.append(" ");
Steve Anton4daf66e2018-09-07 21:55:531364 fmt.append(rtc::ToString(codec.id));
henrike@webrtc.org28e20752013-07-10 00:45:361365 }
1366 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
Steve Antonb1c1de12017-12-21 23:14:301367 const AudioContentDescription* audio_desc = media_desc->as_audio();
Steve Anton4daf66e2018-09-07 21:55:531368 for (const cricket::AudioCodec& codec : audio_desc->codecs()) {
henrike@webrtc.org28e20752013-07-10 00:45:361369 fmt.append(" ");
Steve Anton4daf66e2018-09-07 21:55:531370 fmt.append(rtc::ToString(codec.id));
henrike@webrtc.org28e20752013-07-10 00:45:361371 }
1372 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
Harald Alvestrand5fc28b12019-05-13 11:36:161373 const cricket::SctpDataContentDescription* sctp_data_desc =
1374 media_desc->as_sctp();
1375 if (sctp_data_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:361376 fmt.append(" ");
jiayl@webrtc.org9c16c392014-05-01 18:30:301377
Harald Alvestrand5fc28b12019-05-13 11:36:161378 if (sctp_data_desc->use_sctpmap()) {
1379 fmt.append(rtc::ToString(sctp_data_desc->port()));
zstein4b2e0822017-02-18 03:48:381380 } else {
1381 fmt.append(kDefaultSctpmapProtocol);
1382 }
henrike@webrtc.org28e20752013-07-10 00:45:361383 } else {
Harald Alvestrand5fc28b12019-05-13 11:36:161384 const RtpDataContentDescription* rtp_data_desc =
1385 media_desc->as_rtp_data();
1386 for (const cricket::RtpDataCodec& codec : rtp_data_desc->codecs()) {
henrike@webrtc.org28e20752013-07-10 00:45:361387 fmt.append(" ");
Steve Anton4daf66e2018-09-07 21:55:531388 fmt.append(rtc::ToString(codec.id));
henrike@webrtc.org28e20752013-07-10 00:45:361389 }
1390 }
1391 }
1392 // The fmt must never be empty. If no codecs are found, set the fmt attribute
1393 // to 0.
1394 if (fmt.empty()) {
1395 fmt = " 0";
1396 }
1397
deadbeef25ed4352016-12-13 02:37:361398 // The port number in the m line will be updated later when associated with
henrike@webrtc.org28e20752013-07-10 00:45:361399 // the candidates.
deadbeef25ed4352016-12-13 02:37:361400 //
1401 // A port value of 0 indicates that the m= section is rejected.
henrike@webrtc.org28e20752013-07-10 00:45:361402 // RFC 3264
1403 // To reject an offered stream, the port number in the corresponding stream in
1404 // the answer MUST be set to zero.
deadbeef25ed4352016-12-13 02:37:361405 //
1406 // However, the BUNDLE draft adds a new meaning to port zero, when used along
1407 // with a=bundle-only.
zhihuang38989e52017-03-21 18:04:531408 std::string port = kDummyPort;
1409 if (content_info->rejected || content_info->bundle_only) {
1410 port = kMediaPortRejected;
1411 } else if (!media_desc->connection_address().IsNil()) {
1412 port = rtc::ToString(media_desc->connection_address().port());
1413 }
henrike@webrtc.org28e20752013-07-10 00:45:361414
Yves Gerey665174f2018-06-19 13:03:051415 rtc::SSLFingerprint* fp =
1416 (transport_info) ? transport_info->description.identity_fingerprint.get()
1417 : NULL;
henrike@webrtc.org28e20752013-07-10 00:45:361418
wu@webrtc.org4c3e9912014-07-16 21:03:131419 // Add the m and c lines.
henrike@webrtc.org28e20752013-07-10 00:45:361420 InitLine(kLineTypeMedia, type, &os);
1421 os << " " << port << " " << media_desc->protocol() << fmt;
zhihuang38989e52017-03-21 18:04:531422 AddLine(os.str(), message);
1423
1424 InitLine(kLineTypeConnection, kConnectionNettype, &os);
1425 if (media_desc->connection_address().IsNil()) {
1426 os << " " << kConnectionIpv4Addrtype << " " << kDummyAddress;
1427 } else if (media_desc->connection_address().family() == AF_INET) {
1428 os << " " << kConnectionIpv4Addrtype << " "
1429 << media_desc->connection_address().ipaddr().ToString();
Qingsi Wang56991422019-02-08 20:53:061430 } else if (media_desc->connection_address().family() == AF_INET6) {
zhihuang38989e52017-03-21 18:04:531431 os << " " << kConnectionIpv6Addrtype << " "
1432 << media_desc->connection_address().ipaddr().ToString();
Qingsi Wang56991422019-02-08 20:53:061433 } else {
1434 os << " " << kConnectionIpv4Addrtype << " " << kDummyAddress;
zhihuang38989e52017-03-21 18:04:531435 }
1436 AddLine(os.str(), message);
wu@webrtc.org4c3e9912014-07-16 21:03:131437
1438 // RFC 4566
1439 // b=AS:<bandwidth>
Peter Thatcherc0c3a862015-06-24 22:31:251440 if (media_desc->bandwidth() >= 1000) {
wu@webrtc.org4c3e9912014-07-16 21:03:131441 InitLine(kLineTypeSessionBandwidth, kApplicationSpecificMaximum, &os);
1442 os << kSdpDelimiterColon << (media_desc->bandwidth() / 1000);
1443 AddLine(os.str(), message);
1444 }
1445
deadbeef25ed4352016-12-13 02:37:361446 // Add the a=bundle-only line.
1447 if (content_info->bundle_only) {
1448 InitAttrLine(kAttributeBundleOnly, &os);
1449 AddLine(os.str(), message);
1450 }
1451
wu@webrtc.org4c3e9912014-07-16 21:03:131452 // Add the a=rtcp line.
Harald Alvestrand5fc28b12019-05-13 11:36:161453 if (cricket::IsRtpProtocol(media_desc->protocol())) {
wu@webrtc.org4c3e9912014-07-16 21:03:131454 std::string rtcp_line = GetRtcpLine(candidates);
1455 if (!rtcp_line.empty()) {
1456 AddLine(rtcp_line, message);
1457 }
1458 }
1459
honghaiza54a0802015-12-17 02:37:231460 // Build the a=candidate lines. We don't include ufrag and pwd in the
1461 // candidates in the SDP to avoid redundancy.
1462 BuildCandidate(candidates, false, message);
henrike@webrtc.org28e20752013-07-10 00:45:361463
1464 // Use the transport_info to build the media level ice-ufrag and ice-pwd.
1465 if (transport_info) {
1466 // RFC 5245
1467 // ice-pwd-att = "ice-pwd" ":" password
1468 // ice-ufrag-att = "ice-ufrag" ":" ufrag
1469 // ice-ufrag
deadbeef3f7219b2015-12-28 23:17:141470 if (!transport_info->description.ice_ufrag.empty()) {
1471 InitAttrLine(kAttributeIceUfrag, &os);
1472 os << kSdpDelimiterColon << transport_info->description.ice_ufrag;
1473 AddLine(os.str(), message);
1474 }
henrike@webrtc.org28e20752013-07-10 00:45:361475 // ice-pwd
deadbeef3f7219b2015-12-28 23:17:141476 if (!transport_info->description.ice_pwd.empty()) {
1477 InitAttrLine(kAttributeIcePwd, &os);
1478 os << kSdpDelimiterColon << transport_info->description.ice_pwd;
1479 AddLine(os.str(), message);
1480 }
henrike@webrtc.org28e20752013-07-10 00:45:361481
1482 // draft-petithuguenin-mmusic-ice-attributes-level-03
1483 BuildIceOptions(transport_info->description.transport_options, message);
1484
1485 // RFC 4572
1486 // fingerprint-attribute =
1487 // "fingerprint" ":" hash-func SP fingerprint
1488 if (fp) {
1489 // Insert the fingerprint attribute.
1490 InitAttrLine(kAttributeFingerprint, &os);
Yves Gerey665174f2018-06-19 13:03:051491 os << kSdpDelimiterColon << fp->algorithm << kSdpDelimiterSpace
henrike@webrtc.org28e20752013-07-10 00:45:361492 << fp->GetRfc4572Fingerprint();
henrike@webrtc.org28e20752013-07-10 00:45:361493 AddLine(os.str(), message);
sergeyu@chromium.org0be6aa02013-08-23 23:21:251494
1495 // Inserting setup attribute.
1496 if (transport_info->description.connection_role !=
Yves Gerey665174f2018-06-19 13:03:051497 cricket::CONNECTIONROLE_NONE) {
sergeyu@chromium.org0be6aa02013-08-23 23:21:251498 // Making sure we are not using "passive" mode.
1499 cricket::ConnectionRole role =
1500 transport_info->description.connection_role;
mallinath@webrtc.org19f27e62013-10-13 17:18:271501 std::string dtls_role_str;
nissec16fa5e2017-02-07 15:18:431502 const bool success =
1503 cricket::ConnectionRoleToString(role, &dtls_role_str);
1504 RTC_DCHECK(success);
sergeyu@chromium.org0be6aa02013-08-23 23:21:251505 InitAttrLine(kAttributeSetup, &os);
sergeyu@chromium.org0be6aa02013-08-23 23:21:251506 os << kSdpDelimiterColon << dtls_role_str;
1507 AddLine(os.str(), message);
1508 }
henrike@webrtc.org28e20752013-07-10 00:45:361509 }
1510 }
1511
1512 // RFC 3388
1513 // mid-attribute = "a=mid:" identification-tag
1514 // identification-tag = token
1515 // Use the content name as the mid identification-tag.
1516 InitAttrLine(kAttributeMid, &os);
1517 os << kSdpDelimiterColon << content_info->name;
1518 AddLine(os.str(), message);
1519
Harald Alvestrand5fc28b12019-05-13 11:36:161520 if (cricket::IsDtlsSctp(media_desc->protocol())) {
1521 const cricket::SctpDataContentDescription* data_desc =
1522 media_desc->as_sctp();
Harald Alvestrandfbb45bd2019-05-15 06:07:471523 BuildSctpContentAttributes(message, data_desc);
Harald Alvestrand5fc28b12019-05-13 11:36:161524 } else if (cricket::IsRtpProtocol(media_desc->protocol())) {
Steve Antone831b8c2018-02-01 20:22:161525 BuildRtpContentAttributes(media_desc, media_type, msid_signaling, message);
henrike@webrtc.org28e20752013-07-10 00:45:361526 }
1527}
1528
deadbeef9d3584c2016-02-17 01:54:101529void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
Patrik Höglundb6b29e02018-06-21 14:58:011530 const cricket::MediaType media_type,
Steve Antone831b8c2018-02-01 20:22:161531 int msid_signaling,
deadbeef9d3584c2016-02-17 01:54:101532 std::string* message) {
Amit Hilbuchc57d5732018-12-11 23:30:111533 SdpSerializer serializer;
Jonas Olssonec9e4922018-09-05 07:53:491534 rtc::StringBuilder os;
Johannes Kron0854eb62018-10-10 20:33:201535 // RFC 8285
1536 // a=extmap-allow-mixed
1537 // The attribute MUST be either on session level or media level. We support
1538 // responding on both levels, however, we don't respond on media level if it's
1539 // set on session level.
Johannes Kron9581bc42018-10-23 08:17:391540 if (media_desc->extmap_allow_mixed_enum() ==
Johannes Kron0854eb62018-10-10 20:33:201541 MediaContentDescription::kMedia) {
1542 InitAttrLine(kAttributeExtmapAllowMixed, &os);
1543 AddLine(os.str(), message);
1544 }
1545 // RFC 8285
henrike@webrtc.org28e20752013-07-10 00:45:361546 // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
1547 // The definitions MUST be either all session level or all media level. This
1548 // implementation uses all media level.
1549 for (size_t i = 0; i < media_desc->rtp_header_extensions().size(); ++i) {
jbauch5869f502017-06-29 19:31:361550 const RtpExtension& extension = media_desc->rtp_header_extensions()[i];
henrike@webrtc.org28e20752013-07-10 00:45:361551 InitAttrLine(kAttributeExtmap, &os);
jbauch5869f502017-06-29 19:31:361552 os << kSdpDelimiterColon << extension.id;
1553 if (extension.encrypt) {
1554 os << kSdpDelimiterSpace << RtpExtension::kEncryptHeaderExtensionsUri;
1555 }
1556 os << kSdpDelimiterSpace << extension.uri;
henrike@webrtc.org28e20752013-07-10 00:45:361557 AddLine(os.str(), message);
1558 }
1559
1560 // RFC 3264
1561 // a=sendrecv || a=sendonly || a=sendrecv || a=inactive
deadbeefc80741f2015-10-22 20:14:451562 switch (media_desc->direction()) {
Steve Anton4e70a722017-11-28 22:57:101563 case RtpTransceiverDirection::kInactive:
henrike@webrtc.org28e20752013-07-10 00:45:361564 InitAttrLine(kAttributeInactive, &os);
1565 break;
Steve Anton4e70a722017-11-28 22:57:101566 case RtpTransceiverDirection::kSendOnly:
henrike@webrtc.org28e20752013-07-10 00:45:361567 InitAttrLine(kAttributeSendOnly, &os);
1568 break;
Steve Anton4e70a722017-11-28 22:57:101569 case RtpTransceiverDirection::kRecvOnly:
henrike@webrtc.org28e20752013-07-10 00:45:361570 InitAttrLine(kAttributeRecvOnly, &os);
1571 break;
Steve Anton4e70a722017-11-28 22:57:101572 case RtpTransceiverDirection::kSendRecv:
Markus Handell45c104b2020-03-11 09:51:131573 InitAttrLine(kAttributeSendRecv, &os);
1574 break;
1575 case RtpTransceiverDirection::kStopped:
henrike@webrtc.org28e20752013-07-10 00:45:361576 default:
Markus Handell45c104b2020-03-11 09:51:131577 // kStopped shouldn't be used in signalling.
1578 RTC_NOTREACHED();
henrike@webrtc.org28e20752013-07-10 00:45:361579 InitAttrLine(kAttributeSendRecv, &os);
1580 break;
1581 }
1582 AddLine(os.str(), message);
1583
Seth Hampson5b4f0752018-04-02 23:31:361584 // Specified in https://datatracker.ietf.org/doc/draft-ietf-mmusic-msid/16/
1585 // a=msid:<msid-id> <msid-appdata>
1586 // The msid-id is a 1*64 token char representing the media stream id, and the
1587 // msid-appdata is a 1*64 token char representing the track id. There is a
1588 // line for every media stream, with a special msid-id value of "-"
1589 // representing no streams. The value of "msid-appdata" MUST be identical for
1590 // all lines.
Steve Antone831b8c2018-02-01 20:22:161591 if (msid_signaling & cricket::kMsidSignalingMediaSection) {
1592 const StreamParamsVec& streams = media_desc->streams();
1593 if (streams.size() == 1u) {
1594 const StreamParams& track = streams[0];
Seth Hampson5b4f0752018-04-02 23:31:361595 std::vector<std::string> stream_ids = track.stream_ids();
1596 if (stream_ids.empty()) {
1597 stream_ids.push_back(kNoStreamMsid);
1598 }
1599 for (const std::string& stream_id : stream_ids) {
1600 InitAttrLine(kAttributeMsid, &os);
1601 os << kSdpDelimiterColon << stream_id << kSdpDelimiterSpace << track.id;
1602 AddLine(os.str(), message);
1603 }
Steve Antone831b8c2018-02-01 20:22:161604 } else if (streams.size() > 1u) {
1605 RTC_LOG(LS_WARNING)
1606 << "Trying to serialize Unified Plan SDP with more than "
Jonas Olsson45cc8902018-02-13 09:37:071607 "one track in a media section. Omitting 'a=msid'.";
deadbeef9d3584c2016-02-17 01:54:101608 }
1609 }
1610
henrike@webrtc.org28e20752013-07-10 00:45:361611 // RFC 5761
1612 // a=rtcp-mux
1613 if (media_desc->rtcp_mux()) {
1614 InitAttrLine(kAttributeRtcpMux, &os);
1615 AddLine(os.str(), message);
1616 }
1617
deadbeef13871492015-12-09 20:37:511618 // RFC 5506
1619 // a=rtcp-rsize
1620 if (media_desc->rtcp_reduced_size()) {
1621 InitAttrLine(kAttributeRtcpReducedSize, &os);
1622 AddLine(os.str(), message);
1623 }
1624
deadbeefd45aea82017-09-16 08:24:291625 if (media_desc->conference_mode()) {
1626 InitAttrLine(kAttributeXGoogleFlag, &os);
1627 os << kSdpDelimiterColon << kValueConference;
1628 AddLine(os.str(), message);
1629 }
1630
Sebastian Janssone1795f42019-07-24 09:38:031631 if (media_desc->remote_estimate()) {
1632 InitAttrLine(kAttributeRtcpRemoteEstimate, &os);
1633 AddLine(os.str(), message);
1634 }
1635
henrike@webrtc.org28e20752013-07-10 00:45:361636 // RFC 4568
1637 // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
Steve Anton4daf66e2018-09-07 21:55:531638 for (const CryptoParams& crypto_params : media_desc->cryptos()) {
henrike@webrtc.org28e20752013-07-10 00:45:361639 InitAttrLine(kAttributeCrypto, &os);
Steve Anton4daf66e2018-09-07 21:55:531640 os << kSdpDelimiterColon << crypto_params.tag << " "
1641 << crypto_params.cipher_suite << " " << crypto_params.key_params;
1642 if (!crypto_params.session_params.empty()) {
1643 os << " " << crypto_params.session_params;
henrike@webrtc.org28e20752013-07-10 00:45:361644 }
1645 AddLine(os.str(), message);
1646 }
1647
1648 // RFC 4566
1649 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1650 // [/<encodingparameters>]
1651 BuildRtpMap(media_desc, media_type, message);
1652
Steve Anton4daf66e2018-09-07 21:55:531653 for (const StreamParams& track : media_desc->streams()) {
henrike@webrtc.org28e20752013-07-10 00:45:361654 // Build the ssrc-group lines.
Steve Anton4daf66e2018-09-07 21:55:531655 for (const SsrcGroup& ssrc_group : track.ssrc_groups) {
henrike@webrtc.org28e20752013-07-10 00:45:361656 // RFC 5576
1657 // a=ssrc-group:<semantics> <ssrc-id> ...
Steve Anton4daf66e2018-09-07 21:55:531658 if (ssrc_group.ssrcs.empty()) {
henrike@webrtc.org28e20752013-07-10 00:45:361659 continue;
1660 }
henrike@webrtc.org28e20752013-07-10 00:45:361661 InitAttrLine(kAttributeSsrcGroup, &os);
Steve Anton4daf66e2018-09-07 21:55:531662 os << kSdpDelimiterColon << ssrc_group.semantics;
1663 for (uint32_t ssrc : ssrc_group.ssrcs) {
1664 os << kSdpDelimiterSpace << rtc::ToString(ssrc);
henrike@webrtc.org28e20752013-07-10 00:45:361665 }
1666 AddLine(os.str(), message);
1667 }
1668 // Build the ssrc lines for each ssrc.
Steve Anton4daf66e2018-09-07 21:55:531669 for (uint32_t ssrc : track.ssrcs) {
henrike@webrtc.org28e20752013-07-10 00:45:361670 // RFC 5576
1671 // a=ssrc:<ssrc-id> cname:<value>
Steve Anton4daf66e2018-09-07 21:55:531672 AddSsrcLine(ssrc, kSsrcAttributeCname, track.cname, message);
henrike@webrtc.org28e20752013-07-10 00:45:361673
Steve Antone831b8c2018-02-01 20:22:161674 if (msid_signaling & cricket::kMsidSignalingSsrcAttribute) {
1675 // draft-alvestrand-mmusic-msid-00
1676 // a=ssrc:<ssrc-id> msid:identifier [appdata]
1677 // The appdata consists of the "id" attribute of a MediaStreamTrack,
1678 // which corresponds to the "id" attribute of StreamParams.
Seth Hampson5b4f0752018-04-02 23:31:361679 // Since a=ssrc msid signaling is used in Plan B SDP semantics, and
1680 // multiple stream ids are not supported for Plan B, we are only adding
1681 // a line for the first media stream id here.
Seth Hampson7fa6ee62018-10-17 17:25:281682 const std::string& track_stream_id = track.first_stream_id();
1683 // We use a special msid-id value of "-" to represent no streams,
1684 // for Unified Plan compatibility. Plan B will always have a
1685 // track_stream_id.
1686 const std::string& stream_id =
1687 track_stream_id.empty() ? kNoStreamMsid : track_stream_id;
Steve Antone831b8c2018-02-01 20:22:161688 InitAttrLine(kAttributeSsrc, &os);
1689 os << kSdpDelimiterColon << ssrc << kSdpDelimiterSpace
1690 << kSsrcAttributeMsid << kSdpDelimiterColon << stream_id
Steve Anton4daf66e2018-09-07 21:55:531691 << kSdpDelimiterSpace << track.id;
Steve Antone831b8c2018-02-01 20:22:161692 AddLine(os.str(), message);
Artem Titovf0a34f22020-03-16 17:52:041693
1694 // TODO(ronghuawu): Remove below code which is for backward
1695 // compatibility.
1696 // draft-alvestrand-rtcweb-mid-01
1697 // a=ssrc:<ssrc-id> mslabel:<value>
1698 // The label isn't yet defined.
1699 // a=ssrc:<ssrc-id> label:<value>
1700 AddSsrcLine(ssrc, kSsrcAttributeMslabel, stream_id, message);
1701 AddSsrcLine(ssrc, kSSrcAttributeLabel, track.id, message);
Steve Antone831b8c2018-02-01 20:22:161702 }
henrike@webrtc.org28e20752013-07-10 00:45:361703 }
Amit Hilbuchc57d5732018-12-11 23:30:111704
1705 // Build the rid lines for each layer of the track
1706 for (const RidDescription& rid_description : track.rids()) {
1707 InitAttrLine(kAttributeRid, &os);
1708 os << kSdpDelimiterColon
1709 << serializer.SerializeRidDescription(rid_description);
1710 AddLine(os.str(), message);
1711 }
1712 }
1713
Florent Castellib60141b2019-07-03 10:47:541714 for (const RidDescription& rid_description : media_desc->receive_rids()) {
1715 InitAttrLine(kAttributeRid, &os);
1716 os << kSdpDelimiterColon
1717 << serializer.SerializeRidDescription(rid_description);
1718 AddLine(os.str(), message);
1719 }
1720
Amit Hilbucha2012042018-12-03 19:35:051721 // Simulcast (a=simulcast)
1722 // https://tools.ietf.org/html/draft-ietf-mmusic-sdp-simulcast-13#section-5.1
Amit Hilbuchc57d5732018-12-11 23:30:111723 if (media_desc->HasSimulcast()) {
1724 const auto& simulcast = media_desc->simulcast_description();
Amit Hilbucha2012042018-12-03 19:35:051725 InitAttrLine(kAttributeSimulcast, &os);
Amit Hilbucha2012042018-12-03 19:35:051726 os << kSdpDelimiterColon
1727 << serializer.SerializeSimulcastDescription(simulcast);
1728 AddLine(os.str(), message);
1729 }
henrike@webrtc.org28e20752013-07-10 00:45:361730}
1731
Jonas Olssonec9e4922018-09-05 07:53:491732void WriteFmtpHeader(int payload_type, rtc::StringBuilder* os) {
henrike@webrtc.org28e20752013-07-10 00:45:361733 // fmtp header: a=fmtp:|payload_type| <parameters>
1734 // Add a=fmtp
1735 InitAttrLine(kAttributeFmtp, os);
1736 // Add :|payload_type|
1737 *os << kSdpDelimiterColon << payload_type;
1738}
1739
Mirta Dvornicic479a3c02019-06-04 13:38:501740void WritePacketizationHeader(int payload_type, rtc::StringBuilder* os) {
1741 // packetization header: a=packetization:|payload_type| <packetization_format>
1742 // Add a=packetization
1743 InitAttrLine(kAttributePacketization, os);
1744 // Add :|payload_type|
1745 *os << kSdpDelimiterColon << payload_type;
1746}
1747
Jonas Olssonec9e4922018-09-05 07:53:491748void WriteRtcpFbHeader(int payload_type, rtc::StringBuilder* os) {
henrike@webrtc.org28e20752013-07-10 00:45:361749 // rtcp-fb header: a=rtcp-fb:|payload_type|
1750 // <parameters>/<ccm <ccm_parameters>>
1751 // Add a=rtcp-fb
1752 InitAttrLine(kAttributeRtcpFb, os);
1753 // Add :
1754 *os << kSdpDelimiterColon;
1755 if (payload_type == kWildcardPayloadType) {
1756 *os << "*";
1757 } else {
1758 *os << payload_type;
1759 }
1760}
1761
1762void WriteFmtpParameter(const std::string& parameter_name,
1763 const std::string& parameter_value,
Jonas Olssonec9e4922018-09-05 07:53:491764 rtc::StringBuilder* os) {
henrike@webrtc.org28e20752013-07-10 00:45:361765 // fmtp parameters: |parameter_name|=|parameter_value|
1766 *os << parameter_name << kSdpDelimiterEqual << parameter_value;
1767}
1768
henrike@webrtc.org28e20752013-07-10 00:45:361769bool IsFmtpParam(const std::string& name) {
ossuaa4b0772017-01-30 15:41:181770 // RFC 4855, section 3 specifies the mapping of media format parameters to SDP
1771 // parameters. Only ptime, maxptime, channels and rate are placed outside of
1772 // the fmtp line. In WebRTC, channels and rate are already handled separately
1773 // and thus not included in the CodecParameterMap.
1774 return name != kCodecParamPTime && name != kCodecParamMaxPTime;
henrike@webrtc.org28e20752013-07-10 00:45:361775}
1776
Johannes Kron72d69152020-02-10 13:05:551777bool WriteFmtpParameters(const cricket::CodecParameterMap& parameters,
1778 rtc::StringBuilder* os) {
1779 bool empty = true;
1780 const char* delimiter = ""; // No delimiter before first parameter.
1781 for (const auto& entry : parameters) {
Steve Anton4daf66e2018-09-07 21:55:531782 const std::string& key = entry.first;
1783 const std::string& value = entry.second;
Johannes Kron72d69152020-02-10 13:05:551784
Steve Anton4daf66e2018-09-07 21:55:531785 if (IsFmtpParam(key)) {
Johannes Kron72d69152020-02-10 13:05:551786 *os << delimiter;
1787 // A semicolon before each subsequent parameter.
1788 delimiter = kSdpDelimiterSemicolon;
1789 WriteFmtpParameter(key, value, os);
1790 empty = false;
henrike@webrtc.org28e20752013-07-10 00:45:361791 }
1792 }
Johannes Kron72d69152020-02-10 13:05:551793
1794 return !empty;
henrike@webrtc.org28e20752013-07-10 00:45:361795}
1796
1797template <class T>
1798void AddFmtpLine(const T& codec, std::string* message) {
Jonas Olssonec9e4922018-09-05 07:53:491799 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:361800 WriteFmtpHeader(codec.id, &os);
Johannes Kron72d69152020-02-10 13:05:551801 os << kSdpDelimiterSpace;
1802 // Create FMTP line and check that it's nonempty.
1803 if (WriteFmtpParameters(codec.params, &os)) {
1804 AddLine(os.str(), message);
1805 }
henrike@webrtc.org28e20752013-07-10 00:45:361806 return;
1807}
1808
1809template <class T>
Mirta Dvornicic479a3c02019-06-04 13:38:501810void AddPacketizationLine(const T& codec, std::string* message) {
1811 if (!codec.packetization) {
1812 return;
1813 }
1814 rtc::StringBuilder os;
1815 WritePacketizationHeader(codec.id, &os);
1816 os << " " << *codec.packetization;
1817 AddLine(os.str(), message);
1818}
1819
1820template <class T>
henrike@webrtc.org28e20752013-07-10 00:45:361821void AddRtcpFbLines(const T& codec, std::string* message) {
Steve Anton4daf66e2018-09-07 21:55:531822 for (const cricket::FeedbackParam& param : codec.feedback_params.params()) {
Jonas Olssonec9e4922018-09-05 07:53:491823 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:361824 WriteRtcpFbHeader(codec.id, &os);
Steve Anton4daf66e2018-09-07 21:55:531825 os << " " << param.id();
1826 if (!param.param().empty()) {
1827 os << " " << param.param();
henrike@webrtc.org28e20752013-07-10 00:45:361828 }
1829 AddLine(os.str(), message);
1830 }
1831}
1832
1833bool GetMinValue(const std::vector<int>& values, int* value) {
1834 if (values.empty()) {
1835 return false;
1836 }
Steve Anton64b626b2019-01-29 01:25:261837 auto it = absl::c_min_element(values);
1838 *value = *it;
henrike@webrtc.org28e20752013-07-10 00:45:361839 return true;
1840}
1841
1842bool GetParameter(const std::string& name,
Yves Gerey665174f2018-06-19 13:03:051843 const cricket::CodecParameterMap& params,
1844 int* value) {
1845 std::map<std::string, std::string>::const_iterator found = params.find(name);
henrike@webrtc.org28e20752013-07-10 00:45:361846 if (found == params.end()) {
1847 return false;
1848 }
buildbot@webrtc.orgd4e598d2014-07-29 17:36:521849 if (!rtc::FromString(found->second, value)) {
wu@webrtc.org5e760e72014-04-02 23:19:091850 return false;
1851 }
henrike@webrtc.org28e20752013-07-10 00:45:361852 return true;
1853}
1854
1855void BuildRtpMap(const MediaContentDescription* media_desc,
Patrik Höglundb6b29e02018-06-21 14:58:011856 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:361857 std::string* message) {
nisseede5da42017-01-12 13:15:361858 RTC_DCHECK(message != NULL);
1859 RTC_DCHECK(media_desc != NULL);
Jonas Olssonec9e4922018-09-05 07:53:491860 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:361861 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
Steve Anton4daf66e2018-09-07 21:55:531862 for (const cricket::VideoCodec& codec : media_desc->as_video()->codecs()) {
henrike@webrtc.org28e20752013-07-10 00:45:361863 // RFC 4566
1864 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1865 // [/<encodingparameters>]
Steve Anton4daf66e2018-09-07 21:55:531866 if (codec.id != kWildcardPayloadType) {
henrike@webrtc.org28e20752013-07-10 00:45:361867 InitAttrLine(kAttributeRtpmap, &os);
Steve Anton4daf66e2018-09-07 21:55:531868 os << kSdpDelimiterColon << codec.id << " " << codec.name << "/"
deadbeefe814a0d2017-02-26 02:15:091869 << cricket::kVideoCodecClockrate;
henrike@webrtc.org28e20752013-07-10 00:45:361870 AddLine(os.str(), message);
1871 }
Mirta Dvornicic479a3c02019-06-04 13:38:501872 AddPacketizationLine(codec, message);
Steve Anton4daf66e2018-09-07 21:55:531873 AddRtcpFbLines(codec, message);
1874 AddFmtpLine(codec, message);
henrike@webrtc.org28e20752013-07-10 00:45:361875 }
1876 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
henrike@webrtc.org28e20752013-07-10 00:45:361877 std::vector<int> ptimes;
1878 std::vector<int> maxptimes;
1879 int max_minptime = 0;
Steve Anton4daf66e2018-09-07 21:55:531880 for (const cricket::AudioCodec& codec : media_desc->as_audio()->codecs()) {
1881 RTC_DCHECK(!codec.name.empty());
henrike@webrtc.org28e20752013-07-10 00:45:361882 // RFC 4566
1883 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1884 // [/<encodingparameters>]
1885 InitAttrLine(kAttributeRtpmap, &os);
Steve Anton4daf66e2018-09-07 21:55:531886 os << kSdpDelimiterColon << codec.id << " ";
1887 os << codec.name << "/" << codec.clockrate;
1888 if (codec.channels != 1) {
1889 os << "/" << codec.channels;
henrike@webrtc.org28e20752013-07-10 00:45:361890 }
1891 AddLine(os.str(), message);
Steve Anton4daf66e2018-09-07 21:55:531892 AddRtcpFbLines(codec, message);
1893 AddFmtpLine(codec, message);
henrike@webrtc.org28e20752013-07-10 00:45:361894 int minptime = 0;
Steve Anton4daf66e2018-09-07 21:55:531895 if (GetParameter(kCodecParamMinPTime, codec.params, &minptime)) {
henrike@webrtc.org28e20752013-07-10 00:45:361896 max_minptime = std::max(minptime, max_minptime);
1897 }
1898 int ptime;
Steve Anton4daf66e2018-09-07 21:55:531899 if (GetParameter(kCodecParamPTime, codec.params, &ptime)) {
henrike@webrtc.org28e20752013-07-10 00:45:361900 ptimes.push_back(ptime);
1901 }
1902 int maxptime;
Steve Anton4daf66e2018-09-07 21:55:531903 if (GetParameter(kCodecParamMaxPTime, codec.params, &maxptime)) {
henrike@webrtc.org28e20752013-07-10 00:45:361904 maxptimes.push_back(maxptime);
1905 }
1906 }
1907 // Populate the maxptime attribute with the smallest maxptime of all codecs
1908 // under the same m-line.
1909 int min_maxptime = INT_MAX;
1910 if (GetMinValue(maxptimes, &min_maxptime)) {
1911 AddAttributeLine(kCodecParamMaxPTime, min_maxptime, message);
1912 }
nisseede5da42017-01-12 13:15:361913 RTC_DCHECK(min_maxptime > max_minptime);
henrike@webrtc.org28e20752013-07-10 00:45:361914 // Populate the ptime attribute with the smallest ptime or the largest
1915 // minptime, whichever is the largest, for all codecs under the same m-line.
1916 int ptime = INT_MAX;
1917 if (GetMinValue(ptimes, &ptime)) {
1918 ptime = std::min(ptime, min_maxptime);
1919 ptime = std::max(ptime, max_minptime);
1920 AddAttributeLine(kCodecParamPTime, ptime, message);
1921 }
1922 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
Harald Alvestrand5fc28b12019-05-13 11:36:161923 if (media_desc->as_rtp_data()) {
1924 for (const cricket::RtpDataCodec& codec :
1925 media_desc->as_rtp_data()->codecs()) {
1926 // RFC 4566
1927 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1928 // [/<encodingparameters>]
1929 InitAttrLine(kAttributeRtpmap, &os);
1930 os << kSdpDelimiterColon << codec.id << " " << codec.name << "/"
1931 << codec.clockrate;
1932 AddLine(os.str(), message);
1933 }
henrike@webrtc.org28e20752013-07-10 00:45:361934 }
1935 }
1936}
1937
1938void BuildCandidate(const std::vector<Candidate>& candidates,
honghaiza54a0802015-12-17 02:37:231939 bool include_ufrag,
henrike@webrtc.org28e20752013-07-10 00:45:361940 std::string* message) {
Jonas Olssonec9e4922018-09-05 07:53:491941 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:361942
Steve Anton4daf66e2018-09-07 21:55:531943 for (const Candidate& candidate : candidates) {
henrike@webrtc.org28e20752013-07-10 00:45:361944 // RFC 5245
1945 // a=candidate:<foundation> <component-id> <transport> <priority>
1946 // <connection-address> <port> typ <candidate-types>
1947 // [raddr <connection-address>] [rport <port>]
1948 // *(SP extension-att-name SP extension-att-value)
1949 std::string type;
1950 // Map the cricket candidate type to "host" / "srflx" / "prflx" / "relay"
Steve Anton4daf66e2018-09-07 21:55:531951 if (candidate.type() == cricket::LOCAL_PORT_TYPE) {
henrike@webrtc.org28e20752013-07-10 00:45:361952 type = kCandidateHost;
Steve Anton4daf66e2018-09-07 21:55:531953 } else if (candidate.type() == cricket::STUN_PORT_TYPE) {
henrike@webrtc.org28e20752013-07-10 00:45:361954 type = kCandidateSrflx;
Steve Anton4daf66e2018-09-07 21:55:531955 } else if (candidate.type() == cricket::RELAY_PORT_TYPE) {
henrike@webrtc.org28e20752013-07-10 00:45:361956 type = kCandidateRelay;
Steve Anton4daf66e2018-09-07 21:55:531957 } else if (candidate.type() == cricket::PRFLX_PORT_TYPE) {
Honghai Zhang7fb69db2016-03-14 18:59:181958 type = kCandidatePrflx;
1959 // Peer reflexive candidate may be signaled for being removed.
henrike@webrtc.org28e20752013-07-10 00:45:361960 } else {
nissec80e7412017-01-11 13:56:461961 RTC_NOTREACHED();
Peter Thatcher019087f2015-04-28 16:06:261962 // Never write out candidates if we don't know the type.
1963 continue;
henrike@webrtc.org28e20752013-07-10 00:45:361964 }
1965
1966 InitAttrLine(kAttributeCandidate, &os);
Steve Anton4daf66e2018-09-07 21:55:531967 os << kSdpDelimiterColon << candidate.foundation() << " "
1968 << candidate.component() << " " << candidate.protocol() << " "
1969 << candidate.priority() << " "
1970 << (candidate.address().ipaddr().IsNil()
1971 ? candidate.address().hostname()
1972 : candidate.address().ipaddr().ToString())
1973 << " " << candidate.address().PortAsString() << " "
1974 << kAttributeCandidateTyp << " " << type << " ";
henrike@webrtc.org28e20752013-07-10 00:45:361975
1976 // Related address
Steve Anton4daf66e2018-09-07 21:55:531977 if (!candidate.related_address().IsNil()) {
henrike@webrtc.org28e20752013-07-10 00:45:361978 os << kAttributeCandidateRaddr << " "
Steve Anton4daf66e2018-09-07 21:55:531979 << candidate.related_address().ipaddr().ToString() << " "
henrike@webrtc.org28e20752013-07-10 00:45:361980 << kAttributeCandidateRport << " "
Steve Anton4daf66e2018-09-07 21:55:531981 << candidate.related_address().PortAsString() << " ";
henrike@webrtc.org28e20752013-07-10 00:45:361982 }
1983
Taylor Brandstetter8206bc02020-04-02 19:36:381984 // Note that we allow the tcptype to be missing, for backwards
1985 // compatibility; the implementation treats this as a passive candidate.
1986 // TODO(bugs.webrtc.org/11466): Treat a missing tcptype as an error?
1987 if (candidate.protocol() == cricket::TCP_PROTOCOL_NAME &&
1988 !candidate.tcptype().empty()) {
Steve Anton4daf66e2018-09-07 21:55:531989 os << kTcpCandidateType << " " << candidate.tcptype() << " ";
mallinath@webrtc.org2d60c5e2014-08-08 22:29:201990 }
1991
henrike@webrtc.org28e20752013-07-10 00:45:361992 // Extensions
Steve Anton4daf66e2018-09-07 21:55:531993 os << kAttributeCandidateGeneration << " " << candidate.generation();
1994 if (include_ufrag && !candidate.username().empty()) {
1995 os << " " << kAttributeCandidateUfrag << " " << candidate.username();
honghaiza54a0802015-12-17 02:37:231996 }
Steve Anton4daf66e2018-09-07 21:55:531997 if (candidate.network_id() > 0) {
1998 os << " " << kAttributeCandidateNetworkId << " "
1999 << candidate.network_id();
honghaiza0c44ea2016-03-23 23:07:482000 }
Steve Anton4daf66e2018-09-07 21:55:532001 if (candidate.network_cost() > 0) {
2002 os << " " << kAttributeCandidateNetworkCost << " "
2003 << candidate.network_cost();
honghaize1a0c942016-02-16 22:54:562004 }
henrike@webrtc.org28e20752013-07-10 00:45:362005
2006 AddLine(os.str(), message);
2007 }
2008}
2009
2010void BuildIceOptions(const std::vector<std::string>& transport_options,
2011 std::string* message) {
2012 if (!transport_options.empty()) {
Jonas Olssonec9e4922018-09-05 07:53:492013 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:362014 InitAttrLine(kAttributeIceOption, &os);
2015 os << kSdpDelimiterColon << transport_options[0];
2016 for (size_t i = 1; i < transport_options.size(); ++i) {
2017 os << kSdpDelimiterSpace << transport_options[i];
2018 }
2019 AddLine(os.str(), message);
2020 }
2021}
2022
zhihuang38989e52017-03-21 18:04:532023bool ParseConnectionData(const std::string& line,
2024 rtc::SocketAddress* addr,
2025 SdpParseError* error) {
2026 // Parse the line from left to right.
2027 std::string token;
2028 std::string rightpart;
2029 // RFC 4566
2030 // c=<nettype> <addrtype> <connection-address>
2031 // Skip the "c="
Jonas Olssonec9e4922018-09-05 07:53:492032 if (!rtc::tokenize_first(line, kSdpDelimiterEqualChar, &token, &rightpart)) {
zhihuang38989e52017-03-21 18:04:532033 return ParseFailed(line, "Failed to parse the network type.", error);
2034 }
2035
2036 // Extract and verify the <nettype>
Jonas Olssonec9e4922018-09-05 07:53:492037 if (!rtc::tokenize_first(rightpart, kSdpDelimiterSpaceChar, &token,
2038 &rightpart) ||
zhihuang38989e52017-03-21 18:04:532039 token != kConnectionNettype) {
2040 return ParseFailed(line,
2041 "Failed to parse the connection data. The network type "
2042 "is not currently supported.",
2043 error);
2044 }
2045
2046 // Extract the "<addrtype>" and "<connection-address>".
Jonas Olssonec9e4922018-09-05 07:53:492047 if (!rtc::tokenize_first(rightpart, kSdpDelimiterSpaceChar, &token,
2048 &rightpart)) {
zhihuang38989e52017-03-21 18:04:532049 return ParseFailed(line, "Failed to parse the address type.", error);
2050 }
2051
2052 // The rightpart part should be the IP address without the slash which is used
2053 // for multicast.
2054 if (rightpart.find('/') != std::string::npos) {
2055 return ParseFailed(line,
2056 "Failed to parse the connection data. Multicast is not "
2057 "currently supported.",
2058 error);
2059 }
2060 addr->SetIP(rightpart);
2061
2062 // Verify that the addrtype matches the type of the parsed address.
2063 if ((addr->family() == AF_INET && token != "IP4") ||
2064 (addr->family() == AF_INET6 && token != "IP6")) {
2065 addr->Clear();
2066 return ParseFailed(
2067 line,
2068 "Failed to parse the connection data. The address type is mismatching.",
2069 error);
2070 }
2071 return true;
2072}
2073
2074bool ParseSessionDescription(const std::string& message,
2075 size_t* pos,
henrike@webrtc.org28e20752013-07-10 00:45:362076 std::string* session_id,
2077 std::string* session_version,
henrike@webrtc.org28e20752013-07-10 00:45:362078 TransportDescription* session_td,
2079 RtpHeaderExtensions* session_extmaps,
zhihuang38989e52017-03-21 18:04:532080 rtc::SocketAddress* connection_addr,
henrike@webrtc.org28e20752013-07-10 00:45:362081 cricket::SessionDescription* desc,
2082 SdpParseError* error) {
2083 std::string line;
2084
deadbeefc80741f2015-10-22 20:14:452085 desc->set_msid_supported(false);
Johannes Kron9581bc42018-10-23 08:17:392086 desc->set_extmap_allow_mixed(false);
henrike@webrtc.org28e20752013-07-10 00:45:362087 // RFC 4566
2088 // v= (protocol version)
2089 if (!GetLineWithType(message, pos, &line, kLineTypeVersion)) {
Yves Gerey665174f2018-06-19 13:03:052090 return ParseFailedExpectLine(message, *pos, kLineTypeVersion, std::string(),
2091 error);
henrike@webrtc.org28e20752013-07-10 00:45:362092 }
2093 // RFC 4566
2094 // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
2095 // <unicast-address>
2096 if (!GetLineWithType(message, pos, &line, kLineTypeOrigin)) {
Yves Gerey665174f2018-06-19 13:03:052097 return ParseFailedExpectLine(message, *pos, kLineTypeOrigin, std::string(),
2098 error);
henrike@webrtc.org28e20752013-07-10 00:45:362099 }
2100 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492101 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:362102 const size_t expected_fields = 6;
2103 if (fields.size() != expected_fields) {
2104 return ParseFailedExpectFieldNum(line, expected_fields, error);
2105 }
2106 *session_id = fields[1];
2107 *session_version = fields[2];
2108
2109 // RFC 4566
2110 // s= (session name)
2111 if (!GetLineWithType(message, pos, &line, kLineTypeSessionName)) {
2112 return ParseFailedExpectLine(message, *pos, kLineTypeSessionName,
2113 std::string(), error);
2114 }
2115
Danil Chapovalov66cadcc2018-06-19 14:47:432116 // absl::optional lines
henrike@webrtc.org28e20752013-07-10 00:45:362117 // Those are the optional lines, so shouldn't return false if not present.
2118 // RFC 4566
2119 // i=* (session information)
2120 GetLineWithType(message, pos, &line, kLineTypeSessionInfo);
2121
2122 // RFC 4566
2123 // u=* (URI of description)
2124 GetLineWithType(message, pos, &line, kLineTypeSessionUri);
2125
2126 // RFC 4566
2127 // e=* (email address)
2128 GetLineWithType(message, pos, &line, kLineTypeSessionEmail);
2129
2130 // RFC 4566
2131 // p=* (phone number)
2132 GetLineWithType(message, pos, &line, kLineTypeSessionPhone);
2133
2134 // RFC 4566
2135 // c=* (connection information -- not required if included in
2136 // all media)
zhihuang38989e52017-03-21 18:04:532137 if (GetLineWithType(message, pos, &line, kLineTypeConnection)) {
2138 if (!ParseConnectionData(line, connection_addr, error)) {
2139 return false;
2140 }
2141 }
henrike@webrtc.org28e20752013-07-10 00:45:362142
2143 // RFC 4566
2144 // b=* (zero or more bandwidth information lines)
2145 while (GetLineWithType(message, pos, &line, kLineTypeSessionBandwidth)) {
2146 // By pass zero or more b lines.
2147 }
2148
2149 // RFC 4566
2150 // One or more time descriptions ("t=" and "r=" lines; see below)
2151 // t= (time the session is active)
2152 // r=* (zero or more repeat times)
2153 // Ensure there's at least one time description
2154 if (!GetLineWithType(message, pos, &line, kLineTypeTiming)) {
2155 return ParseFailedExpectLine(message, *pos, kLineTypeTiming, std::string(),
2156 error);
2157 }
2158
2159 while (GetLineWithType(message, pos, &line, kLineTypeRepeatTimes)) {
2160 // By pass zero or more r lines.
2161 }
2162
2163 // Go through the rest of the time descriptions
2164 while (GetLineWithType(message, pos, &line, kLineTypeTiming)) {
2165 while (GetLineWithType(message, pos, &line, kLineTypeRepeatTimes)) {
2166 // By pass zero or more r lines.
2167 }
2168 }
2169
2170 // RFC 4566
2171 // z=* (time zone adjustments)
2172 GetLineWithType(message, pos, &line, kLineTypeTimeZone);
2173
2174 // RFC 4566
2175 // k=* (encryption key)
2176 GetLineWithType(message, pos, &line, kLineTypeEncryptionKey);
2177
2178 // RFC 4566
2179 // a=* (zero or more session attribute lines)
2180 while (GetLineWithType(message, pos, &line, kLineTypeAttributes)) {
2181 if (HasAttribute(line, kAttributeGroup)) {
2182 if (!ParseGroupAttribute(line, desc, error)) {
2183 return false;
2184 }
2185 } else if (HasAttribute(line, kAttributeIceUfrag)) {
Yves Gerey665174f2018-06-19 13:03:052186 if (!GetValue(line, kAttributeIceUfrag, &(session_td->ice_ufrag),
2187 error)) {
henrike@webrtc.org28e20752013-07-10 00:45:362188 return false;
2189 }
2190 } else if (HasAttribute(line, kAttributeIcePwd)) {
2191 if (!GetValue(line, kAttributeIcePwd, &(session_td->ice_pwd), error)) {
2192 return false;
2193 }
2194 } else if (HasAttribute(line, kAttributeIceLite)) {
2195 session_td->ice_mode = cricket::ICEMODE_LITE;
2196 } else if (HasAttribute(line, kAttributeIceOption)) {
2197 if (!ParseIceOptions(line, &(session_td->transport_options), error)) {
2198 return false;
2199 }
2200 } else if (HasAttribute(line, kAttributeFingerprint)) {
2201 if (session_td->identity_fingerprint.get()) {
2202 return ParseFailed(
2203 line,
2204 "Can't have multiple fingerprint attributes at the same level.",
2205 error);
2206 }
Steve Anton4905edb2018-10-16 02:27:442207 std::unique_ptr<rtc::SSLFingerprint> fingerprint;
henrike@webrtc.org28e20752013-07-10 00:45:362208 if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
2209 return false;
2210 }
Steve Anton4905edb2018-10-16 02:27:442211 session_td->identity_fingerprint = std::move(fingerprint);
sergeyu@chromium.org0be6aa02013-08-23 23:21:252212 } else if (HasAttribute(line, kAttributeSetup)) {
2213 if (!ParseDtlsSetup(line, &(session_td->connection_role), error)) {
2214 return false;
2215 }
henrike@webrtc.org28e20752013-07-10 00:45:362216 } else if (HasAttribute(line, kAttributeMsidSemantics)) {
2217 std::string semantics;
2218 if (!GetValue(line, kAttributeMsidSemantics, &semantics, error)) {
2219 return false;
2220 }
deadbeefc80741f2015-10-22 20:14:452221 desc->set_msid_supported(
2222 CaseInsensitiveFind(semantics, kMediaStreamSemantic));
Johannes Kron0854eb62018-10-10 20:33:202223 } else if (HasAttribute(line, kAttributeExtmapAllowMixed)) {
Johannes Kron9581bc42018-10-23 08:17:392224 desc->set_extmap_allow_mixed(true);
henrike@webrtc.org28e20752013-07-10 00:45:362225 } else if (HasAttribute(line, kAttributeExtmap)) {
isheriff6f8d6862016-05-26 18:24:552226 RtpExtension extmap;
henrike@webrtc.org28e20752013-07-10 00:45:362227 if (!ParseExtmap(line, &extmap, error)) {
2228 return false;
2229 }
2230 session_extmaps->push_back(extmap);
2231 }
2232 }
2233
2234 return true;
2235}
2236
2237bool ParseGroupAttribute(const std::string& line,
2238 cricket::SessionDescription* desc,
2239 SdpParseError* error) {
nisseede5da42017-01-12 13:15:362240 RTC_DCHECK(desc != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:362241
2242 // RFC 5888 and draft-holmberg-mmusic-sdp-bundle-negotiation-00
2243 // a=group:BUNDLE video voice
2244 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492245 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:362246 std::string semantics;
2247 if (!GetValue(fields[0], kAttributeGroup, &semantics, error)) {
2248 return false;
2249 }
2250 cricket::ContentGroup group(semantics);
2251 for (size_t i = 1; i < fields.size(); ++i) {
2252 group.AddContentName(fields[i]);
2253 }
2254 desc->AddGroup(group);
2255 return true;
2256}
2257
Steve Anton4905edb2018-10-16 02:27:442258static bool ParseFingerprintAttribute(
2259 const std::string& line,
2260 std::unique_ptr<rtc::SSLFingerprint>* fingerprint,
2261 SdpParseError* error) {
henrike@webrtc.org28e20752013-07-10 00:45:362262 if (!IsLineType(line, kLineTypeAttributes) ||
2263 !HasAttribute(line, kAttributeFingerprint)) {
2264 return ParseFailedExpectLine(line, 0, kLineTypeAttributes,
2265 kAttributeFingerprint, error);
2266 }
2267
2268 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492269 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:362270 const size_t expected_fields = 2;
2271 if (fields.size() != expected_fields) {
2272 return ParseFailedExpectFieldNum(line, expected_fields, error);
2273 }
2274
2275 // The first field here is "fingerprint:<hash>.
2276 std::string algorithm;
2277 if (!GetValue(fields[0], kAttributeFingerprint, &algorithm, error)) {
2278 return false;
2279 }
2280
2281 // Downcase the algorithm. Note that we don't need to downcase the
2282 // fingerprint because hex_decode can handle upper-case.
Steve Anton64b626b2019-01-29 01:25:262283 absl::c_transform(algorithm, algorithm.begin(), ::tolower);
henrike@webrtc.org28e20752013-07-10 00:45:362284
2285 // The second field is the digest value. De-hexify it.
Steve Anton4905edb2018-10-16 02:27:442286 *fingerprint =
2287 rtc::SSLFingerprint::CreateUniqueFromRfc4572(algorithm, fields[1]);
henrike@webrtc.org28e20752013-07-10 00:45:362288 if (!*fingerprint) {
Yves Gerey665174f2018-06-19 13:03:052289 return ParseFailed(line, "Failed to create fingerprint from the digest.",
henrike@webrtc.org28e20752013-07-10 00:45:362290 error);
2291 }
2292
2293 return true;
2294}
2295
sergeyu@chromium.org0be6aa02013-08-23 23:21:252296static bool ParseDtlsSetup(const std::string& line,
2297 cricket::ConnectionRole* role,
2298 SdpParseError* error) {
2299 // setup-attr = "a=setup:" role
2300 // role = "active" / "passive" / "actpass" / "holdconn"
2301 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492302 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterColonChar, &fields);
sergeyu@chromium.org0be6aa02013-08-23 23:21:252303 const size_t expected_fields = 2;
2304 if (fields.size() != expected_fields) {
2305 return ParseFailedExpectFieldNum(line, expected_fields, error);
2306 }
2307 std::string role_str = fields[1];
2308 if (!cricket::StringToConnectionRole(role_str, role)) {
2309 return ParseFailed(line, "Invalid attribute value.", error);
2310 }
2311 return true;
2312}
2313
deadbeef9d3584c2016-02-17 01:54:102314static bool ParseMsidAttribute(const std::string& line,
Seth Hampson5b4f0752018-04-02 23:31:362315 std::vector<std::string>* stream_ids,
deadbeef9d3584c2016-02-17 01:54:102316 std::string* track_id,
2317 SdpParseError* error) {
Seth Hampson5b4f0752018-04-02 23:31:362318 // https://datatracker.ietf.org/doc/draft-ietf-mmusic-msid/16/
deadbeef9d3584c2016-02-17 01:54:102319 // a=msid:<stream id> <track id>
2320 // msid-value = msid-id [ SP msid-appdata ]
2321 // msid-id = 1*64token-char ; see RFC 4566
2322 // msid-appdata = 1*64token-char ; see RFC 4566
2323 std::string field1;
Seth Hampson5b4f0752018-04-02 23:31:362324 std::string new_stream_id;
2325 std::string new_track_id;
Jonas Olssonec9e4922018-09-05 07:53:492326 if (!rtc::tokenize_first(line.substr(kLinePrefixLength),
2327 kSdpDelimiterSpaceChar, &field1, &new_track_id)) {
deadbeef9d3584c2016-02-17 01:54:102328 const size_t expected_fields = 2;
2329 return ParseFailedExpectFieldNum(line, expected_fields, error);
2330 }
2331
Seth Hampson5b4f0752018-04-02 23:31:362332 if (new_track_id.empty()) {
deadbeefa4549d62017-02-11 01:26:222333 return ParseFailed(line, "Missing track ID in msid attribute.", error);
2334 }
Seth Hampson5b4f0752018-04-02 23:31:362335 // All track ids should be the same within an m section in a Unified Plan SDP.
2336 if (!track_id->empty() && new_track_id.compare(*track_id) != 0) {
2337 return ParseFailed(
2338 line, "Two different track IDs in msid attribute in one m= section",
2339 error);
2340 }
2341 *track_id = new_track_id;
deadbeefa4549d62017-02-11 01:26:222342
deadbeef9d3584c2016-02-17 01:54:102343 // msid:<msid-id>
Seth Hampson5b4f0752018-04-02 23:31:362344 if (!GetValue(field1, kAttributeMsid, &new_stream_id, error)) {
deadbeef9d3584c2016-02-17 01:54:102345 return false;
2346 }
Seth Hampson5b4f0752018-04-02 23:31:362347 if (new_stream_id.empty()) {
deadbeefa4549d62017-02-11 01:26:222348 return ParseFailed(line, "Missing stream ID in msid attribute.", error);
2349 }
Seth Hampson5b4f0752018-04-02 23:31:362350 // The special value "-" indicates "no MediaStream".
2351 if (new_stream_id.compare(kNoStreamMsid) != 0) {
2352 stream_ids->push_back(new_stream_id);
2353 }
deadbeef9d3584c2016-02-17 01:54:102354 return true;
2355}
2356
Amit Hilbuchc57d5732018-12-11 23:30:112357static void RemoveInvalidRidDescriptions(const std::vector<int>& payload_types,
2358 std::vector<RidDescription>* rids) {
2359 RTC_DCHECK(rids);
2360 std::set<std::string> to_remove;
2361 std::set<std::string> unique_rids;
2362
2363 // Check the rids to see which ones should be removed.
2364 for (RidDescription& rid : *rids) {
2365 // In the case of a duplicate, the entire "a=rid" line, and all "a=rid"
2366 // lines with rid-ids that duplicate this line, are discarded and MUST NOT
2367 // be included in the SDP Answer.
2368 auto pair = unique_rids.insert(rid.rid);
2369 // Insert will "fail" if element already exists.
2370 if (!pair.second) {
2371 to_remove.insert(rid.rid);
2372 continue;
2373 }
2374
2375 // If the "a=rid" line contains a "pt=", the list of payload types
2376 // is verified against the list of valid payload types for the media
2377 // section (that is, those listed on the "m=" line). Any PT missing
2378 // from the "m=" line is discarded from the set of values in the
2379 // "pt=". If no values are left in the "pt=" parameter after this
2380 // processing, then the "a=rid" line is discarded.
2381 if (rid.payload_types.empty()) {
2382 // If formats were not specified, rid should not be removed.
2383 continue;
2384 }
2385
2386 // Note: Spec does not mention how to handle duplicate formats.
2387 // Media section does not handle duplicates either.
2388 std::set<int> removed_formats;
2389 for (int payload_type : rid.payload_types) {
Steve Anton64b626b2019-01-29 01:25:262390 if (!absl::c_linear_search(payload_types, payload_type)) {
Amit Hilbuchc57d5732018-12-11 23:30:112391 removed_formats.insert(payload_type);
2392 }
2393 }
2394
2395 rid.payload_types.erase(
2396 std::remove_if(rid.payload_types.begin(), rid.payload_types.end(),
2397 [&removed_formats](int format) {
2398 return removed_formats.count(format) > 0;
2399 }),
2400 rid.payload_types.end());
2401
2402 // If all formats were removed then remove the rid alogether.
2403 if (rid.payload_types.empty()) {
2404 to_remove.insert(rid.rid);
2405 }
2406 }
2407
2408 // Remove every rid description that appears in the to_remove list.
2409 if (!to_remove.empty()) {
2410 rids->erase(std::remove_if(rids->begin(), rids->end(),
2411 [&to_remove](const RidDescription& rid) {
2412 return to_remove.count(rid.rid) > 0;
2413 }),
2414 rids->end());
2415 }
2416}
2417
2418// Create a new list (because SimulcastLayerList is immutable) without any
2419// layers that have a rid in the to_remove list.
2420// If a group of alternatives is empty after removing layers, the group should
2421// be removed altogether.
2422static SimulcastLayerList RemoveRidsFromSimulcastLayerList(
2423 const std::set<std::string>& to_remove,
2424 const SimulcastLayerList& layers) {
2425 SimulcastLayerList result;
2426 for (const std::vector<SimulcastLayer>& vector : layers) {
2427 std::vector<SimulcastLayer> new_layers;
2428 for (const SimulcastLayer& layer : vector) {
2429 if (to_remove.find(layer.rid) == to_remove.end()) {
2430 new_layers.push_back(layer);
2431 }
2432 }
2433 // If all layers were removed, do not add an entry.
2434 if (!new_layers.empty()) {
2435 result.AddLayerWithAlternatives(new_layers);
2436 }
2437 }
2438
2439 return result;
2440}
2441
2442// Will remove Simulcast Layers if:
2443// 1. They appear in both send and receive directions.
2444// 2. They do not appear in the list of |valid_rids|.
2445static void RemoveInvalidRidsFromSimulcast(
2446 const std::vector<RidDescription>& valid_rids,
2447 SimulcastDescription* simulcast) {
2448 RTC_DCHECK(simulcast);
2449 std::set<std::string> to_remove;
2450 std::vector<SimulcastLayer> all_send_layers =
2451 simulcast->send_layers().GetAllLayers();
2452 std::vector<SimulcastLayer> all_receive_layers =
2453 simulcast->receive_layers().GetAllLayers();
2454
2455 // If a rid appears in both send and receive directions, remove it from both.
2456 // This algorithm runs in O(n^2) time, but for small n (as is the case with
2457 // simulcast layers) it should still perform well.
2458 for (const SimulcastLayer& send_layer : all_send_layers) {
Steve Anton64b626b2019-01-29 01:25:262459 if (absl::c_any_of(all_receive_layers,
2460 [&send_layer](const SimulcastLayer& layer) {
2461 return layer.rid == send_layer.rid;
2462 })) {
Amit Hilbuchc57d5732018-12-11 23:30:112463 to_remove.insert(send_layer.rid);
2464 }
2465 }
2466
2467 // Add any rid that is not in the valid list to the remove set.
2468 for (const SimulcastLayer& send_layer : all_send_layers) {
Steve Anton64b626b2019-01-29 01:25:262469 if (absl::c_none_of(valid_rids, [&send_layer](const RidDescription& rid) {
Florent Castellic4421972019-07-02 18:27:422470 return send_layer.rid == rid.rid &&
2471 rid.direction == cricket::RidDirection::kSend;
Steve Anton64b626b2019-01-29 01:25:262472 })) {
Amit Hilbuchc57d5732018-12-11 23:30:112473 to_remove.insert(send_layer.rid);
2474 }
2475 }
2476
2477 // Add any rid that is not in the valid list to the remove set.
2478 for (const SimulcastLayer& receive_layer : all_receive_layers) {
Florent Castellic4421972019-07-02 18:27:422479 if (absl::c_none_of(
2480 valid_rids, [&receive_layer](const RidDescription& rid) {
2481 return receive_layer.rid == rid.rid &&
2482 rid.direction == cricket::RidDirection::kReceive;
2483 })) {
Amit Hilbuchc57d5732018-12-11 23:30:112484 to_remove.insert(receive_layer.rid);
2485 }
2486 }
2487
2488 simulcast->send_layers() =
2489 RemoveRidsFromSimulcastLayerList(to_remove, simulcast->send_layers());
2490 simulcast->receive_layers() =
2491 RemoveRidsFromSimulcastLayerList(to_remove, simulcast->receive_layers());
2492}
2493
henrike@webrtc.org28e20752013-07-10 00:45:362494// RFC 3551
2495// PT encoding media type clock rate channels
2496// name (Hz)
2497// 0 PCMU A 8,000 1
2498// 1 reserved A
2499// 2 reserved A
2500// 3 GSM A 8,000 1
2501// 4 G723 A 8,000 1
2502// 5 DVI4 A 8,000 1
2503// 6 DVI4 A 16,000 1
2504// 7 LPC A 8,000 1
2505// 8 PCMA A 8,000 1
2506// 9 G722 A 8,000 1
2507// 10 L16 A 44,100 2
2508// 11 L16 A 44,100 1
2509// 12 QCELP A 8,000 1
2510// 13 CN A 8,000 1
2511// 14 MPA A 90,000 (see text)
2512// 15 G728 A 8,000 1
2513// 16 DVI4 A 11,025 1
2514// 17 DVI4 A 22,050 1
2515// 18 G729 A 8,000 1
2516struct StaticPayloadAudioCodec {
2517 const char* name;
2518 int clockrate;
Peter Kasting69558702016-01-13 00:26:352519 size_t channels;
henrike@webrtc.org28e20752013-07-10 00:45:362520};
2521static const StaticPayloadAudioCodec kStaticPayloadAudioCodecs[] = {
Yves Gerey665174f2018-06-19 13:03:052522 {"PCMU", 8000, 1}, {"reserved", 0, 0}, {"reserved", 0, 0},
2523 {"GSM", 8000, 1}, {"G723", 8000, 1}, {"DVI4", 8000, 1},
2524 {"DVI4", 16000, 1}, {"LPC", 8000, 1}, {"PCMA", 8000, 1},
2525 {"G722", 8000, 1}, {"L16", 44100, 2}, {"L16", 44100, 1},
2526 {"QCELP", 8000, 1}, {"CN", 8000, 1}, {"MPA", 90000, 1},
2527 {"G728", 8000, 1}, {"DVI4", 11025, 1}, {"DVI4", 22050, 1},
2528 {"G729", 8000, 1},
henrike@webrtc.org28e20752013-07-10 00:45:362529};
2530
Yves Gerey665174f2018-06-19 13:03:052531void MaybeCreateStaticPayloadAudioCodecs(const std::vector<int>& fmts,
2532 AudioContentDescription* media_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:362533 if (!media_desc) {
2534 return;
2535 }
deadbeef67cf2c12016-04-13 17:07:162536 RTC_DCHECK(media_desc->codecs().empty());
solenberg9fa49752016-10-08 20:02:442537 for (int payload_type : fmts) {
Yves Gerey665174f2018-06-19 13:03:052538 if (!media_desc->HasCodec(payload_type) && payload_type >= 0 &&
kjellander3e33bfe2016-06-20 14:04:092539 static_cast<uint32_t>(payload_type) <
2540 arraysize(kStaticPayloadAudioCodecs)) {
henrike@webrtc.org28e20752013-07-10 00:45:362541 std::string encoding_name = kStaticPayloadAudioCodecs[payload_type].name;
2542 int clock_rate = kStaticPayloadAudioCodecs[payload_type].clockrate;
Peter Kasting69558702016-01-13 00:26:352543 size_t channels = kStaticPayloadAudioCodecs[payload_type].channels;
henrike@webrtc.org28e20752013-07-10 00:45:362544 media_desc->AddCodec(cricket::AudioCodec(payload_type, encoding_name,
deadbeef67cf2c12016-04-13 17:07:162545 clock_rate, 0, channels));
henrike@webrtc.org28e20752013-07-10 00:45:362546 }
henrike@webrtc.org28e20752013-07-10 00:45:362547 }
2548}
2549
2550template <class C>
Steve Anton5a1de872018-12-18 19:25:552551static std::unique_ptr<C> ParseContentDescription(
2552 const std::string& message,
2553 const cricket::MediaType media_type,
2554 int mline_index,
2555 const std::string& protocol,
2556 const std::vector<int>& payload_types,
2557 size_t* pos,
2558 std::string* content_name,
2559 bool* bundle_only,
2560 int* msid_signaling,
2561 TransportDescription* transport,
2562 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
2563 webrtc::SdpParseError* error) {
Mirko Bonadei317a1f02019-09-17 15:06:182564 auto media_desc = std::make_unique<C>();
deadbeef67cf2c12016-04-13 17:07:162565 if (!ParseContent(message, media_type, mline_index, protocol, payload_types,
Steve Anton5a1de872018-12-18 19:25:552566 pos, content_name, bundle_only, msid_signaling,
2567 media_desc.get(), transport, candidates, error)) {
zhihuang38989e52017-03-21 18:04:532568 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:362569 }
2570 // Sort the codecs according to the m-line fmt list.
deadbeef67cf2c12016-04-13 17:07:162571 std::unordered_map<int, int> payload_type_preferences;
2572 // "size + 1" so that the lowest preference payload type has a preference of
2573 // 1, which is greater than the default (0) for payload types not in the fmt
2574 // list.
2575 int preference = static_cast<int>(payload_types.size() + 1);
2576 for (int pt : payload_types) {
2577 payload_type_preferences[pt] = preference--;
2578 }
2579 std::vector<typename C::CodecType> codecs = media_desc->codecs();
Steve Anton64b626b2019-01-29 01:25:262580 absl::c_sort(
2581 codecs, [&payload_type_preferences](const typename C::CodecType& a,
2582 const typename C::CodecType& b) {
2583 return payload_type_preferences[a.id] > payload_type_preferences[b.id];
2584 });
deadbeef67cf2c12016-04-13 17:07:162585 media_desc->set_codecs(codecs);
henrike@webrtc.org28e20752013-07-10 00:45:362586 return media_desc;
2587}
2588
Steve Anton5a1de872018-12-18 19:25:552589bool ParseMediaDescription(
2590 const std::string& message,
2591 const TransportDescription& session_td,
2592 const RtpHeaderExtensions& session_extmaps,
2593 size_t* pos,
2594 const rtc::SocketAddress& session_connection_addr,
2595 cricket::SessionDescription* desc,
2596 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
2597 SdpParseError* error) {
nisseede5da42017-01-12 13:15:362598 RTC_DCHECK(desc != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:362599 std::string line;
2600 int mline_index = -1;
Steve Antone831b8c2018-02-01 20:22:162601 int msid_signaling = 0;
henrike@webrtc.org28e20752013-07-10 00:45:362602
2603 // Zero or more media descriptions
2604 // RFC 4566
2605 // m=<media> <port> <proto> <fmt>
2606 while (GetLineWithType(message, pos, &line, kLineTypeMedia)) {
2607 ++mline_index;
2608
2609 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492610 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
zstein4b2e0822017-02-18 03:48:382611
henrike@webrtc.org28e20752013-07-10 00:45:362612 const size_t expected_min_fields = 4;
2613 if (fields.size() < expected_min_fields) {
2614 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
2615 }
deadbeef25ed4352016-12-13 02:37:362616 bool port_rejected = false;
henrike@webrtc.org28e20752013-07-10 00:45:362617 // RFC 3264
2618 // To reject an offered stream, the port number in the corresponding stream
2619 // in the answer MUST be set to zero.
2620 if (fields[1] == kMediaPortRejected) {
deadbeef25ed4352016-12-13 02:37:362621 port_rejected = true;
henrike@webrtc.org28e20752013-07-10 00:45:362622 }
2623
zhihuang38989e52017-03-21 18:04:532624 int port = 0;
2625 if (!rtc::FromString<int>(fields[1], &port) || !IsValidPort(port)) {
2626 return ParseFailed(line, "The port number is invalid", error);
2627 }
Philipp Hancke6fb70042020-06-29 10:32:082628 const std::string& protocol = fields[2];
henrike@webrtc.org28e20752013-07-10 00:45:362629
2630 // <fmt>
deadbeef67cf2c12016-04-13 17:07:162631 std::vector<int> payload_types;
Harald Alvestrand5fc28b12019-05-13 11:36:162632 if (cricket::IsRtpProtocol(protocol)) {
Yves Gerey665174f2018-06-19 13:03:052633 for (size_t j = 3; j < fields.size(); ++j) {
jiayl@webrtc.orgddb85ab2014-09-05 16:31:562634 // TODO(wu): Remove when below bug is fixed.
2635 // https://bugzilla.mozilla.org/show_bug.cgi?id=996329
pbosbb36fdf2015-07-09 14:48:142636 if (fields[j].empty() && j == fields.size() - 1) {
jiayl@webrtc.orgddb85ab2014-09-05 16:31:562637 continue;
2638 }
wu@webrtc.org36eda7c2014-04-15 20:37:302639
jiayl@webrtc.orgddb85ab2014-09-05 16:31:562640 int pl = 0;
pkasting@chromium.orge9facf82015-02-17 20:36:282641 if (!GetPayloadTypeFromString(line, fields[j], &pl, error)) {
jiayl@webrtc.orgddb85ab2014-09-05 16:31:562642 return false;
2643 }
deadbeef67cf2c12016-04-13 17:07:162644 payload_types.push_back(pl);
wu@webrtc.org5e760e72014-04-02 23:19:092645 }
henrike@webrtc.org28e20752013-07-10 00:45:362646 }
2647
2648 // Make a temporary TransportDescription based on |session_td|.
2649 // Some of this gets overwritten by ParseContent.
deadbeef46eed762016-01-28 21:24:372650 TransportDescription transport(
2651 session_td.transport_options, session_td.ice_ufrag, session_td.ice_pwd,
2652 session_td.ice_mode, session_td.connection_role,
2653 session_td.identity_fingerprint.get());
henrike@webrtc.org28e20752013-07-10 00:45:362654
kwibergd1fe2812016-04-27 13:47:292655 std::unique_ptr<MediaContentDescription> content;
henrike@webrtc.org28e20752013-07-10 00:45:362656 std::string content_name;
deadbeef25ed4352016-12-13 02:37:362657 bool bundle_only = false;
Steve Antone831b8c2018-02-01 20:22:162658 int section_msid_signaling = 0;
Philipp Hancke6fb70042020-06-29 10:32:082659 const std::string& media_type = fields[0];
2660 if (media_type == kMediaTypeVideo) {
Steve Anton5a1de872018-12-18 19:25:552661 content = ParseContentDescription<VideoContentDescription>(
deadbeef67cf2c12016-04-13 17:07:162662 message, cricket::MEDIA_TYPE_VIDEO, mline_index, protocol,
Steve Antone831b8c2018-02-01 20:22:162663 payload_types, pos, &content_name, &bundle_only,
Steve Anton5a1de872018-12-18 19:25:552664 &section_msid_signaling, &transport, candidates, error);
Philipp Hancke6fb70042020-06-29 10:32:082665 } else if (media_type == kMediaTypeAudio) {
Steve Anton5a1de872018-12-18 19:25:552666 content = ParseContentDescription<AudioContentDescription>(
deadbeef67cf2c12016-04-13 17:07:162667 message, cricket::MEDIA_TYPE_AUDIO, mline_index, protocol,
Steve Antone831b8c2018-02-01 20:22:162668 payload_types, pos, &content_name, &bundle_only,
Steve Anton5a1de872018-12-18 19:25:552669 &section_msid_signaling, &transport, candidates, error);
Philipp Hancke6fb70042020-06-29 10:32:082670 } else if (media_type == kMediaTypeData) {
Harald Alvestrand5fc28b12019-05-13 11:36:162671 if (cricket::IsDtlsSctp(protocol)) {
2672 // The draft-03 format is:
2673 // m=application <port> DTLS/SCTP <sctp-port>...
2674 // use_sctpmap should be false.
2675 // The draft-26 format is:
2676 // m=application <port> UDP/DTLS/SCTP webrtc-datachannel
2677 // use_sctpmap should be false.
Mirko Bonadei317a1f02019-09-17 15:06:182678 auto data_desc = std::make_unique<SctpDataContentDescription>();
Harald Alvestrandfbb45bd2019-05-15 06:07:472679 // Default max message size is 64K
2680 // according to draft-ietf-mmusic-sctp-sdp-26
2681 data_desc->set_max_message_size(kDefaultSctpMaxMessageSize);
zstein4b2e0822017-02-18 03:48:382682 int p;
2683 if (rtc::FromString(fields[3], &p)) {
Harald Alvestrand5fc28b12019-05-13 11:36:162684 data_desc->set_port(p);
zstein4b2e0822017-02-18 03:48:382685 } else if (fields[3] == kDefaultSctpmapProtocol) {
2686 data_desc->set_use_sctpmap(false);
2687 }
Harald Alvestrand5fc28b12019-05-13 11:36:162688 if (!ParseContent(message, cricket::MEDIA_TYPE_DATA, mline_index,
2689 protocol, payload_types, pos, &content_name,
2690 &bundle_only, &section_msid_signaling,
2691 data_desc.get(), &transport, candidates, error)) {
2692 return false;
2693 }
2694 data_desc->set_protocol(protocol);
2695 content = std::move(data_desc);
2696 } else {
2697 // RTP
2698 std::unique_ptr<RtpDataContentDescription> data_desc =
2699 ParseContentDescription<RtpDataContentDescription>(
2700 message, cricket::MEDIA_TYPE_DATA, mline_index, protocol,
2701 payload_types, pos, &content_name, &bundle_only,
2702 &section_msid_signaling, &transport, candidates, error);
2703 content = std::move(data_desc);
wu@webrtc.org78187522013-10-07 23:32:022704 }
henrike@webrtc.org28e20752013-07-10 00:45:362705 } else {
Mirko Bonadei675513b2017-11-09 10:09:252706 RTC_LOG(LS_WARNING) << "Unsupported media type: " << line;
henrike@webrtc.org28e20752013-07-10 00:45:362707 continue;
2708 }
2709 if (!content.get()) {
2710 // ParseContentDescription returns NULL if failed.
2711 return false;
2712 }
2713
Steve Antone831b8c2018-02-01 20:22:162714 msid_signaling |= section_msid_signaling;
2715
deadbeef25ed4352016-12-13 02:37:362716 bool content_rejected = false;
deadbeef12771a12017-01-03 21:53:472717 // A port of 0 is not interpreted as a rejected m= section when it's
2718 // used along with a=bundle-only.
deadbeef25ed4352016-12-13 02:37:362719 if (bundle_only) {
deadbeef25ed4352016-12-13 02:37:362720 if (!port_rejected) {
deadbeef12771a12017-01-03 21:53:472721 // Usage of bundle-only with a nonzero port is unspecified. So just
2722 // ignore bundle-only if we see this.
2723 bundle_only = false;
Mirko Bonadei675513b2017-11-09 10:09:252724 RTC_LOG(LS_WARNING)
deadbeef12771a12017-01-03 21:53:472725 << "a=bundle-only attribute observed with a nonzero "
Jonas Olsson45cc8902018-02-13 09:37:072726 "port; this usage is unspecified so the attribute is being "
2727 "ignored.";
deadbeef25ed4352016-12-13 02:37:362728 }
2729 } else {
2730 // If not using bundle-only, interpret port 0 in the normal way; the m=
2731 // section is being rejected.
2732 content_rejected = port_rejected;
2733 }
2734
Harald Alvestrand5fc28b12019-05-13 11:36:162735 if (cricket::IsRtpProtocol(protocol) && !content->as_sctp()) {
2736 content->set_protocol(protocol);
henrike@webrtc.org28e20752013-07-10 00:45:362737 // Set the extmap.
2738 if (!session_extmaps.empty() &&
2739 !content->rtp_header_extensions().empty()) {
2740 return ParseFailed("",
2741 "The a=extmap MUST be either all session level or "
2742 "all media level.",
2743 error);
2744 }
2745 for (size_t i = 0; i < session_extmaps.size(); ++i) {
2746 content->AddRtpHeaderExtension(session_extmaps[i]);
2747 }
Harald Alvestrand5fc28b12019-05-13 11:36:162748 } else if (content->as_sctp()) {
2749 // Do nothing, it's OK
2750 } else {
2751 RTC_LOG(LS_WARNING) << "Parse failed with unknown protocol " << protocol;
2752 return false;
henrike@webrtc.org28e20752013-07-10 00:45:362753 }
zhihuang38989e52017-03-21 18:04:532754
2755 // Use the session level connection address if the media level addresses are
2756 // not specified.
2757 rtc::SocketAddress address;
2758 address = content->connection_address().IsNil()
2759 ? session_connection_addr
2760 : content->connection_address();
2761 address.SetPort(port);
2762 content->set_connection_address(address);
2763
henrike@webrtc.org28e20752013-07-10 00:45:362764 desc->AddContent(content_name,
Harald Alvestrand5fc28b12019-05-13 11:36:162765 cricket::IsDtlsSctp(protocol) ? MediaProtocolType::kSctp
2766 : MediaProtocolType::kRtp,
Harald Alvestrand1716d392019-06-03 18:35:452767 content_rejected, bundle_only, std::move(content));
henrike@webrtc.org28e20752013-07-10 00:45:362768 // Create TransportInfo with the media level "ice-pwd" and "ice-ufrag".
Steve Anton06817cd2018-12-18 23:55:302769 desc->AddTransportInfo(TransportInfo(content_name, transport));
henrike@webrtc.org28e20752013-07-10 00:45:362770 }
wu@webrtc.orgcecfd182013-10-30 05:18:122771
Steve Antone831b8c2018-02-01 20:22:162772 desc->set_msid_signaling(msid_signaling);
2773
wu@webrtc.orgcecfd182013-10-30 05:18:122774 size_t end_of_message = message.size();
2775 if (mline_index == -1 && *pos != end_of_message) {
2776 ParseFailed(message, *pos, "Expects m line.", error);
2777 return false;
2778 }
henrike@webrtc.org28e20752013-07-10 00:45:362779 return true;
2780}
2781
2782bool VerifyCodec(const cricket::Codec& codec) {
2783 // Codec has not been populated correctly unless the name has been set. This
2784 // can happen if an SDP has an fmtp or rtcp-fb with a payload type but doesn't
2785 // have a corresponding "rtpmap" line.
htab39db842016-12-08 09:50:482786 return !codec.name.empty();
henrike@webrtc.org28e20752013-07-10 00:45:362787}
2788
2789bool VerifyAudioCodecs(const AudioContentDescription* audio_desc) {
Steve Anton64b626b2019-01-29 01:25:262790 return absl::c_all_of(audio_desc->codecs(), &VerifyCodec);
henrike@webrtc.org28e20752013-07-10 00:45:362791}
2792
2793bool VerifyVideoCodecs(const VideoContentDescription* video_desc) {
Steve Anton64b626b2019-01-29 01:25:262794 return absl::c_all_of(video_desc->codecs(), &VerifyCodec);
henrike@webrtc.org28e20752013-07-10 00:45:362795}
2796
2797void AddParameters(const cricket::CodecParameterMap& parameters,
2798 cricket::Codec* codec) {
Steve Anton4daf66e2018-09-07 21:55:532799 for (const auto& entry : parameters) {
2800 const std::string& key = entry.first;
2801 const std::string& value = entry.second;
2802 codec->SetParam(key, value);
henrike@webrtc.org28e20752013-07-10 00:45:362803 }
2804}
2805
2806void AddFeedbackParameter(const cricket::FeedbackParam& feedback_param,
2807 cricket::Codec* codec) {
2808 codec->AddFeedbackParam(feedback_param);
2809}
2810
2811void AddFeedbackParameters(const cricket::FeedbackParams& feedback_params,
2812 cricket::Codec* codec) {
Steve Anton4daf66e2018-09-07 21:55:532813 for (const cricket::FeedbackParam& param : feedback_params.params()) {
2814 codec->AddFeedbackParam(param);
henrike@webrtc.org28e20752013-07-10 00:45:362815 }
2816}
2817
2818// Gets the current codec setting associated with |payload_type|. If there
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342819// is no Codec associated with that payload type it returns an empty codec
henrike@webrtc.org28e20752013-07-10 00:45:362820// with that payload type.
2821template <class T>
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342822T GetCodecWithPayloadType(const std::vector<T>& codecs, int payload_type) {
magjedb05fa242016-11-11 12:00:162823 const T* codec = FindCodecById(codecs, payload_type);
2824 if (codec)
2825 return *codec;
2826 // Return empty codec with |payload_type|.
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342827 T ret_val;
magjedb05fa242016-11-11 12:00:162828 ret_val.id = payload_type;
henrike@webrtc.org28e20752013-07-10 00:45:362829 return ret_val;
2830}
2831
2832// Updates or creates a new codec entry in the audio description.
2833template <class T, class U>
2834void AddOrReplaceCodec(MediaContentDescription* content_desc, const U& codec) {
2835 T* desc = static_cast<T*>(content_desc);
2836 std::vector<U> codecs = desc->codecs();
2837 bool found = false;
Steve Anton4daf66e2018-09-07 21:55:532838 for (U& existing_codec : codecs) {
2839 if (codec.id == existing_codec.id) {
2840 // Overwrite existing codec with the new codec.
2841 existing_codec = codec;
henrike@webrtc.org28e20752013-07-10 00:45:362842 found = true;
2843 break;
2844 }
2845 }
2846 if (!found) {
2847 desc->AddCodec(codec);
2848 return;
2849 }
2850 desc->set_codecs(codecs);
2851}
2852
2853// Adds or updates existing codec corresponding to |payload_type| according
2854// to |parameters|.
2855template <class T, class U>
Yves Gerey665174f2018-06-19 13:03:052856void UpdateCodec(MediaContentDescription* content_desc,
2857 int payload_type,
henrike@webrtc.org28e20752013-07-10 00:45:362858 const cricket::CodecParameterMap& parameters) {
2859 // Codec might already have been populated (from rtpmap).
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342860 U new_codec = GetCodecWithPayloadType(static_cast<T*>(content_desc)->codecs(),
2861 payload_type);
henrike@webrtc.org28e20752013-07-10 00:45:362862 AddParameters(parameters, &new_codec);
2863 AddOrReplaceCodec<T, U>(content_desc, new_codec);
2864}
2865
2866// Adds or updates existing codec corresponding to |payload_type| according
2867// to |feedback_param|.
2868template <class T, class U>
Yves Gerey665174f2018-06-19 13:03:052869void UpdateCodec(MediaContentDescription* content_desc,
2870 int payload_type,
henrike@webrtc.org28e20752013-07-10 00:45:362871 const cricket::FeedbackParam& feedback_param) {
2872 // Codec might already have been populated (from rtpmap).
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342873 U new_codec = GetCodecWithPayloadType(static_cast<T*>(content_desc)->codecs(),
2874 payload_type);
henrike@webrtc.org28e20752013-07-10 00:45:362875 AddFeedbackParameter(feedback_param, &new_codec);
2876 AddOrReplaceCodec<T, U>(content_desc, new_codec);
2877}
2878
Mirta Dvornicic479a3c02019-06-04 13:38:502879// Adds or updates existing video codec corresponding to |payload_type|
2880// according to |packetization|.
2881void UpdateVideoCodecPacketization(VideoContentDescription* video_desc,
2882 int payload_type,
2883 const std::string& packetization) {
2884 if (packetization != cricket::kPacketizationParamRaw) {
2885 // Ignore unsupported packetization attribute.
2886 return;
2887 }
2888
2889 // Codec might already have been populated (from rtpmap).
2890 cricket::VideoCodec codec =
2891 GetCodecWithPayloadType(video_desc->codecs(), payload_type);
2892 codec.packetization = packetization;
2893 AddOrReplaceCodec<VideoContentDescription, cricket::VideoCodec>(video_desc,
2894 codec);
2895}
2896
jlmiller@webrtc.orga744a282015-02-18 21:37:462897template <class T>
2898bool PopWildcardCodec(std::vector<T>* codecs, T* wildcard_codec) {
2899 for (auto iter = codecs->begin(); iter != codecs->end(); ++iter) {
henrike@webrtc.org28e20752013-07-10 00:45:362900 if (iter->id == kWildcardPayloadType) {
2901 *wildcard_codec = *iter;
2902 codecs->erase(iter);
2903 return true;
2904 }
2905 }
2906 return false;
2907}
2908
Yves Gerey665174f2018-06-19 13:03:052909template <class T>
jlmiller@webrtc.orga744a282015-02-18 21:37:462910void UpdateFromWildcardCodecs(cricket::MediaContentDescriptionImpl<T>* desc) {
2911 auto codecs = desc->codecs();
2912 T wildcard_codec;
henrike@webrtc.org28e20752013-07-10 00:45:362913 if (!PopWildcardCodec(&codecs, &wildcard_codec)) {
2914 return;
2915 }
jlmiller@webrtc.orga744a282015-02-18 21:37:462916 for (auto& codec : codecs) {
henrike@webrtc.org28e20752013-07-10 00:45:362917 AddFeedbackParameters(wildcard_codec.feedback_params, &codec);
2918 }
jlmiller@webrtc.orga744a282015-02-18 21:37:462919 desc->set_codecs(codecs);
henrike@webrtc.org28e20752013-07-10 00:45:362920}
2921
Yves Gerey665174f2018-06-19 13:03:052922void AddAudioAttribute(const std::string& name,
2923 const std::string& value,
henrike@webrtc.org28e20752013-07-10 00:45:362924 AudioContentDescription* audio_desc) {
2925 if (value.empty()) {
2926 return;
2927 }
2928 std::vector<cricket::AudioCodec> codecs = audio_desc->codecs();
Steve Anton4daf66e2018-09-07 21:55:532929 for (cricket::AudioCodec& codec : codecs) {
2930 codec.params[name] = value;
henrike@webrtc.org28e20752013-07-10 00:45:362931 }
2932 audio_desc->set_codecs(codecs);
2933}
2934
2935bool ParseContent(const std::string& message,
Patrik Höglundb6b29e02018-06-21 14:58:012936 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:362937 int mline_index,
2938 const std::string& protocol,
deadbeef67cf2c12016-04-13 17:07:162939 const std::vector<int>& payload_types,
henrike@webrtc.org28e20752013-07-10 00:45:362940 size_t* pos,
2941 std::string* content_name,
deadbeef25ed4352016-12-13 02:37:362942 bool* bundle_only,
Steve Antone831b8c2018-02-01 20:22:162943 int* msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:362944 MediaContentDescription* media_desc,
2945 TransportDescription* transport,
Steve Anton5a1de872018-12-18 19:25:552946 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
henrike@webrtc.org28e20752013-07-10 00:45:362947 SdpParseError* error) {
nisseede5da42017-01-12 13:15:362948 RTC_DCHECK(media_desc != NULL);
2949 RTC_DCHECK(content_name != NULL);
2950 RTC_DCHECK(transport != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:362951
henrike@webrtc.org704bf9e2014-02-27 17:52:042952 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
Steve Antonb1c1de12017-12-21 23:14:302953 MaybeCreateStaticPayloadAudioCodecs(payload_types, media_desc->as_audio());
henrike@webrtc.org704bf9e2014-02-27 17:52:042954 }
2955
henrike@webrtc.org28e20752013-07-10 00:45:362956 // The media level "ice-ufrag" and "ice-pwd".
2957 // The candidates before update the media level "ice-pwd" and "ice-ufrag".
2958 Candidates candidates_orig;
2959 std::string line;
2960 std::string mline_id;
2961 // Tracks created out of the ssrc attributes.
2962 StreamParamsVec tracks;
2963 SsrcInfoVec ssrc_infos;
2964 SsrcGroupVec ssrc_groups;
2965 std::string maxptime_as_string;
2966 std::string ptime_as_string;
Seth Hampson5b4f0752018-04-02 23:31:362967 std::vector<std::string> stream_ids;
deadbeef9d3584c2016-02-17 01:54:102968 std::string track_id;
Amit Hilbuchc57d5732018-12-11 23:30:112969 SdpSerializer deserializer;
2970 std::vector<RidDescription> rids;
Amit Hilbucha2012042018-12-03 19:35:052971 SimulcastDescription simulcast;
henrike@webrtc.org28e20752013-07-10 00:45:362972
henrike@webrtc.org28e20752013-07-10 00:45:362973 // Loop until the next m line
2974 while (!IsLineType(message, kLineTypeMedia, *pos)) {
2975 if (!GetLine(message, pos, &line)) {
2976 if (*pos >= message.size()) {
2977 break; // Done parsing
2978 } else {
sergeyu@chromium.org5bc25c42013-12-05 00:24:062979 return ParseFailed(message, *pos, "Invalid SDP line.", error);
henrike@webrtc.org28e20752013-07-10 00:45:362980 }
2981 }
2982
henrike@webrtc.org28e20752013-07-10 00:45:362983 // RFC 4566
2984 // b=* (zero or more bandwidth information lines)
2985 if (IsLineType(line, kLineTypeSessionBandwidth)) {
2986 std::string bandwidth;
2987 if (HasAttribute(line, kApplicationSpecificMaximum)) {
2988 if (!GetValue(line, kApplicationSpecificMaximum, &bandwidth, error)) {
2989 return false;
2990 } else {
wu@webrtc.org5e760e72014-04-02 23:19:092991 int b = 0;
2992 if (!GetValueFromString(line, bandwidth, &b, error)) {
2993 return false;
2994 }
deadbeef3e8016e2017-08-04 00:49:302995 // TODO(deadbeef): Historically, applications may be setting a value
2996 // of -1 to mean "unset any previously set bandwidth limit", even
2997 // though ommitting the "b=AS" entirely will do just that. Once we've
2998 // transitioned applications to doing the right thing, it would be
2999 // better to treat this as a hard error instead of just ignoring it.
3000 if (b == -1) {
Mirko Bonadei675513b2017-11-09 10:09:253001 RTC_LOG(LS_WARNING)
3002 << "Ignoring \"b=AS:-1\"; will be treated as \"no "
3003 "bandwidth limit\".";
deadbeef3e8016e2017-08-04 00:49:303004 continue;
3005 }
deadbeefbc88c6b2017-08-02 18:26:343006 if (b < 0) {
3007 return ParseFailed(line, "b=AS value can't be negative.", error);
3008 }
Peter Thatcherc0c3a862015-06-24 22:31:253009 // We should never use more than the default bandwidth for RTP-based
3010 // data channels. Don't allow SDP to set the bandwidth, because
3011 // that would give JS the opportunity to "break the Internet".
3012 // See: https://code.google.com/p/chromium/issues/detail?id=280726
Harald Alvestrand5fc28b12019-05-13 11:36:163013 if (media_type == cricket::MEDIA_TYPE_DATA &&
3014 cricket::IsRtpProtocol(protocol) &&
Peter Thatcherc0c3a862015-06-24 22:31:253015 b > cricket::kDataMaxBandwidth / 1000) {
Jonas Olssonec9e4922018-09-05 07:53:493016 rtc::StringBuilder description;
Peter Thatcherc0c3a862015-06-24 22:31:253017 description << "RTP-based data channels may not send more than "
3018 << cricket::kDataMaxBandwidth / 1000 << "kbps.";
3019 return ParseFailed(line, description.str(), error);
3020 }
deadbeefb2362572016-12-14 00:37:063021 // Prevent integer overflow.
3022 b = std::min(b, INT_MAX / 1000);
wu@webrtc.org5e760e72014-04-02 23:19:093023 media_desc->set_bandwidth(b * 1000);
henrike@webrtc.org28e20752013-07-10 00:45:363024 }
3025 }
3026 continue;
3027 }
3028
zhihuang38989e52017-03-21 18:04:533029 // Parse the media level connection data.
3030 if (IsLineType(line, kLineTypeConnection)) {
3031 rtc::SocketAddress addr;
3032 if (!ParseConnectionData(line, &addr, error)) {
3033 return false;
3034 }
3035 media_desc->set_connection_address(addr);
3036 continue;
3037 }
3038
henrike@webrtc.org28e20752013-07-10 00:45:363039 if (!IsLineType(line, kLineTypeAttributes)) {
Steve Anton36b29d12017-10-30 16:57:423040 // TODO(deadbeef): Handle other lines if needed.
Mirko Bonadei675513b2017-11-09 10:09:253041 RTC_LOG(LS_INFO) << "Ignored line: " << line;
henrike@webrtc.org28e20752013-07-10 00:45:363042 continue;
3043 }
3044
3045 // Handle attributes common to SCTP and RTP.
3046 if (HasAttribute(line, kAttributeMid)) {
3047 // RFC 3388
3048 // mid-attribute = "a=mid:" identification-tag
3049 // identification-tag = token
3050 // Use the mid identification-tag as the content name.
3051 if (!GetValue(line, kAttributeMid, &mline_id, error)) {
3052 return false;
3053 }
3054 *content_name = mline_id;
deadbeef25ed4352016-12-13 02:37:363055 } else if (HasAttribute(line, kAttributeBundleOnly)) {
3056 *bundle_only = true;
henrike@webrtc.org28e20752013-07-10 00:45:363057 } else if (HasAttribute(line, kAttributeCandidate)) {
3058 Candidate candidate;
3059 if (!ParseCandidate(line, &candidate, error, false)) {
3060 return false;
3061 }
deadbeef7bcdb692017-01-20 20:43:583062 // ParseCandidate will parse non-standard ufrag and password attributes,
3063 // since it's used for candidate trickling, but we only want to process
3064 // the "a=ice-ufrag"/"a=ice-pwd" values in a session description, so
3065 // strip them off at this point.
3066 candidate.set_username(std::string());
3067 candidate.set_password(std::string());
henrike@webrtc.org28e20752013-07-10 00:45:363068 candidates_orig.push_back(candidate);
3069 } else if (HasAttribute(line, kAttributeIceUfrag)) {
3070 if (!GetValue(line, kAttributeIceUfrag, &transport->ice_ufrag, error)) {
3071 return false;
3072 }
3073 } else if (HasAttribute(line, kAttributeIcePwd)) {
3074 if (!GetValue(line, kAttributeIcePwd, &transport->ice_pwd, error)) {
3075 return false;
3076 }
3077 } else if (HasAttribute(line, kAttributeIceOption)) {
3078 if (!ParseIceOptions(line, &transport->transport_options, error)) {
3079 return false;
3080 }
3081 } else if (HasAttribute(line, kAttributeFmtp)) {
3082 if (!ParseFmtpAttributes(line, media_type, media_desc, error)) {
3083 return false;
3084 }
3085 } else if (HasAttribute(line, kAttributeFingerprint)) {
Steve Anton4905edb2018-10-16 02:27:443086 std::unique_ptr<rtc::SSLFingerprint> fingerprint;
henrike@webrtc.org28e20752013-07-10 00:45:363087 if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
3088 return false;
3089 }
Steve Anton4905edb2018-10-16 02:27:443090 transport->identity_fingerprint = std::move(fingerprint);
sergeyu@chromium.org0be6aa02013-08-23 23:21:253091 } else if (HasAttribute(line, kAttributeSetup)) {
3092 if (!ParseDtlsSetup(line, &(transport->connection_role), error)) {
3093 return false;
3094 }
Harald Alvestrand5fc28b12019-05-13 11:36:163095 } else if (cricket::IsDtlsSctp(protocol) &&
3096 HasAttribute(line, kAttributeSctpPort)) {
deadbeef7e146cb2016-09-28 17:04:343097 if (media_type != cricket::MEDIA_TYPE_DATA) {
3098 return ParseFailed(
3099 line, "sctp-port attribute found in non-data media description.",
3100 error);
3101 }
Harald Alvestrand5fc28b12019-05-13 11:36:163102 if (media_desc->as_sctp()->use_sctpmap()) {
3103 return ParseFailed(
3104 line, "sctp-port attribute can't be used with sctpmap.", error);
3105 }
jiayl@webrtc.orgddb85ab2014-09-05 16:31:563106 int sctp_port;
3107 if (!ParseSctpPort(line, &sctp_port, error)) {
3108 return false;
3109 }
Harald Alvestrand5fc28b12019-05-13 11:36:163110 media_desc->as_sctp()->set_port(sctp_port);
3111 } else if (cricket::IsDtlsSctp(protocol) &&
Harald Alvestrand48cce4d2019-04-11 08:41:243112 HasAttribute(line, kAttributeMaxMessageSize)) {
3113 if (media_type != cricket::MEDIA_TYPE_DATA) {
3114 return ParseFailed(
3115 line,
3116 "max-message-size attribute found in non-data media description.",
3117 error);
3118 }
3119 int max_message_size;
3120 if (!ParseSctpMaxMessageSize(line, &max_message_size, error)) {
3121 return false;
3122 }
Harald Alvestrand5fc28b12019-05-13 11:36:163123 media_desc->as_sctp()->set_max_message_size(max_message_size);
3124 } else if (cricket::IsRtpProtocol(protocol)) {
henrike@webrtc.org28e20752013-07-10 00:45:363125 //
3126 // RTP specific attrubtes
3127 //
3128 if (HasAttribute(line, kAttributeRtcpMux)) {
3129 media_desc->set_rtcp_mux(true);
deadbeef13871492015-12-09 20:37:513130 } else if (HasAttribute(line, kAttributeRtcpReducedSize)) {
3131 media_desc->set_rtcp_reduced_size(true);
Sebastian Janssone1795f42019-07-24 09:38:033132 } else if (HasAttribute(line, kAttributeRtcpRemoteEstimate)) {
3133 media_desc->set_remote_estimate(true);
henrike@webrtc.org28e20752013-07-10 00:45:363134 } else if (HasAttribute(line, kAttributeSsrcGroup)) {
3135 if (!ParseSsrcGroupAttribute(line, &ssrc_groups, error)) {
3136 return false;
3137 }
3138 } else if (HasAttribute(line, kAttributeSsrc)) {
Steve Antone831b8c2018-02-01 20:22:163139 if (!ParseSsrcAttribute(line, &ssrc_infos, msid_signaling, error)) {
henrike@webrtc.org28e20752013-07-10 00:45:363140 return false;
3141 }
3142 } else if (HasAttribute(line, kAttributeCrypto)) {
3143 if (!ParseCryptoAttribute(line, media_desc, error)) {
3144 return false;
3145 }
3146 } else if (HasAttribute(line, kAttributeRtpmap)) {
deadbeef67cf2c12016-04-13 17:07:163147 if (!ParseRtpmapAttribute(line, media_type, payload_types, media_desc,
3148 error)) {
henrike@webrtc.org28e20752013-07-10 00:45:363149 return false;
3150 }
3151 } else if (HasAttribute(line, kCodecParamMaxPTime)) {
3152 if (!GetValue(line, kCodecParamMaxPTime, &maxptime_as_string, error)) {
3153 return false;
3154 }
Mirta Dvornicic479a3c02019-06-04 13:38:503155 } else if (HasAttribute(line, kAttributePacketization)) {
3156 if (!ParsePacketizationAttribute(line, media_type, media_desc, error)) {
3157 return false;
3158 }
henrike@webrtc.org28e20752013-07-10 00:45:363159 } else if (HasAttribute(line, kAttributeRtcpFb)) {
3160 if (!ParseRtcpFbAttribute(line, media_type, media_desc, error)) {
3161 return false;
3162 }
3163 } else if (HasAttribute(line, kCodecParamPTime)) {
3164 if (!GetValue(line, kCodecParamPTime, &ptime_as_string, error)) {
3165 return false;
3166 }
3167 } else if (HasAttribute(line, kAttributeSendOnly)) {
Steve Anton4e70a722017-11-28 22:57:103168 media_desc->set_direction(RtpTransceiverDirection::kSendOnly);
henrike@webrtc.org28e20752013-07-10 00:45:363169 } else if (HasAttribute(line, kAttributeRecvOnly)) {
Steve Anton4e70a722017-11-28 22:57:103170 media_desc->set_direction(RtpTransceiverDirection::kRecvOnly);
henrike@webrtc.org28e20752013-07-10 00:45:363171 } else if (HasAttribute(line, kAttributeInactive)) {
Steve Anton4e70a722017-11-28 22:57:103172 media_desc->set_direction(RtpTransceiverDirection::kInactive);
henrike@webrtc.org28e20752013-07-10 00:45:363173 } else if (HasAttribute(line, kAttributeSendRecv)) {
Steve Anton4e70a722017-11-28 22:57:103174 media_desc->set_direction(RtpTransceiverDirection::kSendRecv);
Johannes Kron0854eb62018-10-10 20:33:203175 } else if (HasAttribute(line, kAttributeExtmapAllowMixed)) {
Johannes Kron9581bc42018-10-23 08:17:393176 media_desc->set_extmap_allow_mixed_enum(
Johannes Kron0854eb62018-10-10 20:33:203177 MediaContentDescription::kMedia);
henrike@webrtc.org28e20752013-07-10 00:45:363178 } else if (HasAttribute(line, kAttributeExtmap)) {
isheriff6f8d6862016-05-26 18:24:553179 RtpExtension extmap;
henrike@webrtc.org28e20752013-07-10 00:45:363180 if (!ParseExtmap(line, &extmap, error)) {
3181 return false;
3182 }
3183 media_desc->AddRtpHeaderExtension(extmap);
3184 } else if (HasAttribute(line, kAttributeXGoogleFlag)) {
3185 // Experimental attribute. Conference mode activates more aggressive
3186 // AEC and NS settings.
Steve Anton36b29d12017-10-30 16:57:423187 // TODO(deadbeef): expose API to set these directly.
henrike@webrtc.org28e20752013-07-10 00:45:363188 std::string flag_value;
3189 if (!GetValue(line, kAttributeXGoogleFlag, &flag_value, error)) {
3190 return false;
3191 }
3192 if (flag_value.compare(kValueConference) == 0)
3193 media_desc->set_conference_mode(true);
deadbeef9d3584c2016-02-17 01:54:103194 } else if (HasAttribute(line, kAttributeMsid)) {
Seth Hampson5b4f0752018-04-02 23:31:363195 if (!ParseMsidAttribute(line, &stream_ids, &track_id, error)) {
deadbeef9d3584c2016-02-17 01:54:103196 return false;
3197 }
Steve Antone831b8c2018-02-01 20:22:163198 *msid_signaling |= cricket::kMsidSignalingMediaSection;
Amit Hilbuchc57d5732018-12-11 23:30:113199 } else if (HasAttribute(line, kAttributeRid)) {
3200 const size_t kRidPrefixLength =
3201 kLinePrefixLength + arraysize(kAttributeRid);
3202 if (line.size() <= kRidPrefixLength) {
3203 RTC_LOG(LS_INFO) << "Ignoring empty RID attribute: " << line;
3204 continue;
3205 }
3206 RTCErrorOr<RidDescription> error_or_rid_description =
3207 deserializer.DeserializeRidDescription(
3208 line.substr(kRidPrefixLength));
3209
3210 // Malformed a=rid lines are discarded.
3211 if (!error_or_rid_description.ok()) {
3212 RTC_LOG(LS_INFO) << "Ignoring malformed RID line: '" << line
3213 << "'. Error: "
3214 << error_or_rid_description.error().message();
3215 continue;
3216 }
3217
3218 rids.push_back(error_or_rid_description.MoveValue());
Amit Hilbucha2012042018-12-03 19:35:053219 } else if (HasAttribute(line, kAttributeSimulcast)) {
3220 const size_t kSimulcastPrefixLength =
3221 kLinePrefixLength + arraysize(kAttributeSimulcast);
3222 if (line.size() <= kSimulcastPrefixLength) {
3223 return ParseFailed(line, "Simulcast attribute is empty.", error);
3224 }
3225
3226 if (!simulcast.empty()) {
3227 return ParseFailed(line, "Multiple Simulcast attributes specified.",
3228 error);
3229 }
3230
Amit Hilbucha2012042018-12-03 19:35:053231 RTCErrorOr<SimulcastDescription> error_or_simulcast =
3232 deserializer.DeserializeSimulcastDescription(
3233 line.substr(kSimulcastPrefixLength));
3234 if (!error_or_simulcast.ok()) {
3235 return ParseFailed(line,
3236 std::string("Malformed simulcast line: ") +
3237 error_or_simulcast.error().message(),
3238 error);
3239 }
3240
3241 simulcast = error_or_simulcast.value();
3242 } else {
3243 // Unrecognized attribute in RTP protocol.
3244 RTC_LOG(LS_INFO) << "Ignored line: " << line;
3245 continue;
henrike@webrtc.org28e20752013-07-10 00:45:363246 }
3247 } else {
3248 // Only parse lines that we are interested of.
Mirko Bonadei675513b2017-11-09 10:09:253249 RTC_LOG(LS_INFO) << "Ignored line: " << line;
henrike@webrtc.org28e20752013-07-10 00:45:363250 continue;
3251 }
3252 }
3253
Amit Hilbuchc57d5732018-12-11 23:30:113254 // Remove duplicate or inconsistent rids.
3255 RemoveInvalidRidDescriptions(payload_types, &rids);
3256
3257 // If simulcast is specifed, split the rids into send and receive.
3258 // Rids that do not appear in simulcast attribute will be removed.
3259 // If it is not specified, we assume that all rids are for send layers.
Amit Hilbuchb7446ed2019-01-28 20:25:253260 std::vector<RidDescription> send_rids;
Florent Castellib60141b2019-07-03 10:47:543261 std::vector<RidDescription> receive_rids;
Amit Hilbuchc57d5732018-12-11 23:30:113262 if (!simulcast.empty()) {
3263 // Verify that the rids in simulcast match rids in sdp.
3264 RemoveInvalidRidsFromSimulcast(rids, &simulcast);
3265
3266 // Use simulcast description to figure out Send / Receive RIDs.
3267 std::map<std::string, RidDescription> rid_map;
3268 for (const RidDescription& rid : rids) {
3269 rid_map[rid.rid] = rid;
3270 }
3271
3272 for (const auto& layer : simulcast.send_layers().GetAllLayers()) {
3273 auto iter = rid_map.find(layer.rid);
3274 RTC_DCHECK(iter != rid_map.end());
3275 send_rids.push_back(iter->second);
3276 }
3277
Florent Castellib60141b2019-07-03 10:47:543278 for (const auto& layer : simulcast.receive_layers().GetAllLayers()) {
3279 auto iter = rid_map.find(layer.rid);
3280 RTC_DCHECK(iter != rid_map.end());
3281 receive_rids.push_back(iter->second);
3282 }
3283
Amit Hilbuchc57d5732018-12-11 23:30:113284 media_desc->set_simulcast_description(simulcast);
3285 } else {
3286 send_rids = rids;
3287 }
3288
Florent Castellib60141b2019-07-03 10:47:543289 media_desc->set_receive_rids(receive_rids);
3290
henrike@webrtc.org28e20752013-07-10 00:45:363291 // Create tracks from the |ssrc_infos|.
Taylor Brandstetter5de6b752016-03-10 01:02:303292 // If the stream_id/track_id for all SSRCS are identical, one StreamParams
3293 // will be created in CreateTracksFromSsrcInfos, containing all the SSRCs from
3294 // the m= section.
Seth Hampson5897a6e2018-04-03 18:16:333295 if (!ssrc_infos.empty()) {
3296 CreateTracksFromSsrcInfos(ssrc_infos, stream_ids, track_id, &tracks,
3297 *msid_signaling);
3298 } else if (media_type != cricket::MEDIA_TYPE_DATA &&
3299 (*msid_signaling & cricket::kMsidSignalingMediaSection)) {
3300 // If the stream_ids/track_id was signaled but SSRCs were unsignaled we
3301 // still create a track. This isn't done for data media types because
3302 // StreamParams aren't used for SCTP streams, and RTP data channels don't
3303 // support unsignaled SSRCs.
Amit Hilbuchc57d5732018-12-11 23:30:113304 CreateTrackWithNoSsrcs(stream_ids, track_id, send_rids, &tracks);
3305 }
3306
henrike@webrtc.org28e20752013-07-10 00:45:363307 // Add the ssrc group to the track.
Steve Anton4daf66e2018-09-07 21:55:533308 for (const SsrcGroup& ssrc_group : ssrc_groups) {
3309 if (ssrc_group.ssrcs.empty()) {
henrike@webrtc.org28e20752013-07-10 00:45:363310 continue;
3311 }
Steve Anton4daf66e2018-09-07 21:55:533312 uint32_t ssrc = ssrc_group.ssrcs.front();
3313 for (StreamParams& track : tracks) {
3314 if (track.has_ssrc(ssrc)) {
3315 track.ssrc_groups.push_back(ssrc_group);
henrike@webrtc.org28e20752013-07-10 00:45:363316 }
3317 }
3318 }
3319
3320 // Add the new tracks to the |media_desc|.
deadbeef9d3584c2016-02-17 01:54:103321 for (StreamParams& track : tracks) {
3322 media_desc->AddStream(track);
henrike@webrtc.org28e20752013-07-10 00:45:363323 }
3324
3325 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
Steve Antonb1c1de12017-12-21 23:14:303326 AudioContentDescription* audio_desc = media_desc->as_audio();
jlmiller@webrtc.orga744a282015-02-18 21:37:463327 UpdateFromWildcardCodecs(audio_desc);
3328
henrike@webrtc.org28e20752013-07-10 00:45:363329 // Verify audio codec ensures that no audio codec has been populated with
3330 // only fmtp.
3331 if (!VerifyAudioCodecs(audio_desc)) {
3332 return ParseFailed("Failed to parse audio codecs correctly.", error);
3333 }
3334 AddAudioAttribute(kCodecParamMaxPTime, maxptime_as_string, audio_desc);
3335 AddAudioAttribute(kCodecParamPTime, ptime_as_string, audio_desc);
3336 }
3337
3338 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
Steve Antonb1c1de12017-12-21 23:14:303339 VideoContentDescription* video_desc = media_desc->as_video();
jlmiller@webrtc.orga744a282015-02-18 21:37:463340 UpdateFromWildcardCodecs(video_desc);
3341 // Verify video codec ensures that no video codec has been populated with
3342 // only rtcp-fb.
3343 if (!VerifyVideoCodecs(video_desc)) {
3344 return ParseFailed("Failed to parse video codecs correctly.", error);
3345 }
henrike@webrtc.org28e20752013-07-10 00:45:363346 }
3347
3348 // RFC 5245
3349 // Update the candidates with the media level "ice-pwd" and "ice-ufrag".
Steve Anton4daf66e2018-09-07 21:55:533350 for (Candidate& candidate : candidates_orig) {
3351 RTC_DCHECK(candidate.username().empty() ||
3352 candidate.username() == transport->ice_ufrag);
3353 candidate.set_username(transport->ice_ufrag);
3354 RTC_DCHECK(candidate.password().empty());
3355 candidate.set_password(transport->ice_pwd);
3356 candidates->push_back(
Mirko Bonadei317a1f02019-09-17 15:06:183357 std::make_unique<JsepIceCandidate>(mline_id, mline_index, candidate));
henrike@webrtc.org28e20752013-07-10 00:45:363358 }
Amit Hilbucha2012042018-12-03 19:35:053359
henrike@webrtc.org28e20752013-07-10 00:45:363360 return true;
3361}
3362
Steve Antone831b8c2018-02-01 20:22:163363bool ParseSsrcAttribute(const std::string& line,
3364 SsrcInfoVec* ssrc_infos,
3365 int* msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:363366 SdpParseError* error) {
nisseede5da42017-01-12 13:15:363367 RTC_DCHECK(ssrc_infos != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:363368 // RFC 5576
3369 // a=ssrc:<ssrc-id> <attribute>
3370 // a=ssrc:<ssrc-id> <attribute>:<value>
3371 std::string field1, field2;
Jonas Olssonec9e4922018-09-05 07:53:493372 if (!rtc::tokenize_first(line.substr(kLinePrefixLength),
3373 kSdpDelimiterSpaceChar, &field1, &field2)) {
henrike@webrtc.org28e20752013-07-10 00:45:363374 const size_t expected_fields = 2;
3375 return ParseFailedExpectFieldNum(line, expected_fields, error);
3376 }
3377
3378 // ssrc:<ssrc-id>
3379 std::string ssrc_id_s;
3380 if (!GetValue(field1, kAttributeSsrc, &ssrc_id_s, error)) {
3381 return false;
3382 }
Peter Boström0c4e06b2015-10-07 10:23:213383 uint32_t ssrc_id = 0;
wu@webrtc.org5e760e72014-04-02 23:19:093384 if (!GetValueFromString(line, ssrc_id_s, &ssrc_id, error)) {
3385 return false;
3386 }
henrike@webrtc.org28e20752013-07-10 00:45:363387
3388 std::string attribute;
3389 std::string value;
Jonas Olssonec9e4922018-09-05 07:53:493390 if (!rtc::tokenize_first(field2, kSdpDelimiterColonChar, &attribute,
3391 &value)) {
3392 rtc::StringBuilder description;
henrike@webrtc.org28e20752013-07-10 00:45:363393 description << "Failed to get the ssrc attribute value from " << field2
3394 << ". Expected format <attribute>:<value>.";
3395 return ParseFailed(line, description.str(), error);
3396 }
3397
3398 // Check if there's already an item for this |ssrc_id|. Create a new one if
3399 // there isn't.
Steve Anton64b626b2019-01-29 01:25:263400 auto ssrc_info_it =
3401 absl::c_find_if(*ssrc_infos, [ssrc_id](const SsrcInfo& ssrc_info) {
3402 return ssrc_info.ssrc_id == ssrc_id;
3403 });
Steve Anton4daf66e2018-09-07 21:55:533404 if (ssrc_info_it == ssrc_infos->end()) {
henrike@webrtc.org28e20752013-07-10 00:45:363405 SsrcInfo info;
3406 info.ssrc_id = ssrc_id;
3407 ssrc_infos->push_back(info);
Steve Anton4daf66e2018-09-07 21:55:533408 ssrc_info_it = ssrc_infos->end() - 1;
henrike@webrtc.org28e20752013-07-10 00:45:363409 }
Steve Anton4daf66e2018-09-07 21:55:533410 SsrcInfo& ssrc_info = *ssrc_info_it;
henrike@webrtc.org28e20752013-07-10 00:45:363411
3412 // Store the info to the |ssrc_info|.
3413 if (attribute == kSsrcAttributeCname) {
3414 // RFC 5576
3415 // cname:<value>
Steve Anton4daf66e2018-09-07 21:55:533416 ssrc_info.cname = value;
henrike@webrtc.org28e20752013-07-10 00:45:363417 } else if (attribute == kSsrcAttributeMsid) {
3418 // draft-alvestrand-mmusic-msid-00
Seth Hampson5b4f0752018-04-02 23:31:363419 // msid:identifier [appdata]
henrike@webrtc.org28e20752013-07-10 00:45:363420 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493421 rtc::split(value, kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:363422 if (fields.size() < 1 || fields.size() > 2) {
Yves Gerey665174f2018-06-19 13:03:053423 return ParseFailed(
3424 line, "Expected format \"msid:<identifier>[ <appdata>]\".", error);
henrike@webrtc.org28e20752013-07-10 00:45:363425 }
Steve Anton4daf66e2018-09-07 21:55:533426 ssrc_info.stream_id = fields[0];
henrike@webrtc.org28e20752013-07-10 00:45:363427 if (fields.size() == 2) {
Steve Anton4daf66e2018-09-07 21:55:533428 ssrc_info.track_id = fields[1];
henrike@webrtc.org28e20752013-07-10 00:45:363429 }
Steve Antone831b8c2018-02-01 20:22:163430 *msid_signaling |= cricket::kMsidSignalingSsrcAttribute;
Artem Titovf0a34f22020-03-16 17:52:043431 } else if (attribute == kSsrcAttributeMslabel) {
3432 // draft-alvestrand-rtcweb-mid-01
3433 // mslabel:<value>
3434 ssrc_info.mslabel = value;
3435 } else if (attribute == kSSrcAttributeLabel) {
3436 // The label isn't defined.
3437 // label:<value>
3438 ssrc_info.label = value;
henrike@webrtc.org28e20752013-07-10 00:45:363439 }
3440 return true;
3441}
3442
3443bool ParseSsrcGroupAttribute(const std::string& line,
3444 SsrcGroupVec* ssrc_groups,
3445 SdpParseError* error) {
nisseede5da42017-01-12 13:15:363446 RTC_DCHECK(ssrc_groups != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:363447 // RFC 5576
3448 // a=ssrc-group:<semantics> <ssrc-id> ...
3449 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493450 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:363451 const size_t expected_min_fields = 2;
3452 if (fields.size() < expected_min_fields) {
3453 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
3454 }
3455 std::string semantics;
3456 if (!GetValue(fields[0], kAttributeSsrcGroup, &semantics, error)) {
3457 return false;
3458 }
Peter Boström0c4e06b2015-10-07 10:23:213459 std::vector<uint32_t> ssrcs;
henrike@webrtc.org28e20752013-07-10 00:45:363460 for (size_t i = 1; i < fields.size(); ++i) {
Peter Boström0c4e06b2015-10-07 10:23:213461 uint32_t ssrc = 0;
wu@webrtc.org5e760e72014-04-02 23:19:093462 if (!GetValueFromString(line, fields[i], &ssrc, error)) {
3463 return false;
3464 }
henrike@webrtc.org28e20752013-07-10 00:45:363465 ssrcs.push_back(ssrc);
3466 }
3467 ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
3468 return true;
3469}
3470
3471bool ParseCryptoAttribute(const std::string& line,
3472 MediaContentDescription* media_desc,
3473 SdpParseError* error) {
3474 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493475 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:363476 // RFC 4568
3477 // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
3478 const size_t expected_min_fields = 3;
3479 if (fields.size() < expected_min_fields) {
3480 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
3481 }
3482 std::string tag_value;
3483 if (!GetValue(fields[0], kAttributeCrypto, &tag_value, error)) {
3484 return false;
3485 }
wu@webrtc.org5e760e72014-04-02 23:19:093486 int tag = 0;
3487 if (!GetValueFromString(line, tag_value, &tag, error)) {
3488 return false;
3489 }
jbauch083b73f2015-07-16 09:46:323490 const std::string& crypto_suite = fields[1];
3491 const std::string& key_params = fields[2];
henrike@webrtc.org28e20752013-07-10 00:45:363492 std::string session_params;
3493 if (fields.size() > 3) {
3494 session_params = fields[3];
3495 }
Yves Gerey665174f2018-06-19 13:03:053496 media_desc->AddCrypto(
3497 CryptoParams(tag, crypto_suite, key_params, session_params));
henrike@webrtc.org28e20752013-07-10 00:45:363498 return true;
3499}
3500
3501// Updates or creates a new codec entry in the audio description with according
deadbeef67cf2c12016-04-13 17:07:163502// to |name|, |clockrate|, |bitrate|, and |channels|.
3503void UpdateCodec(int payload_type,
3504 const std::string& name,
3505 int clockrate,
3506 int bitrate,
3507 size_t channels,
henrike@webrtc.org28e20752013-07-10 00:45:363508 AudioContentDescription* audio_desc) {
3509 // Codec may already be populated with (only) optional parameters
3510 // (from an fmtp).
changbin.shao@webrtc.org2d25b442015-03-16 04:14:343511 cricket::AudioCodec codec =
3512 GetCodecWithPayloadType(audio_desc->codecs(), payload_type);
henrike@webrtc.org28e20752013-07-10 00:45:363513 codec.name = name;
3514 codec.clockrate = clockrate;
3515 codec.bitrate = bitrate;
3516 codec.channels = channels;
henrike@webrtc.org28e20752013-07-10 00:45:363517 AddOrReplaceCodec<AudioContentDescription, cricket::AudioCodec>(audio_desc,
3518 codec);
3519}
3520
3521// Updates or creates a new codec entry in the video description according to
deadbeef67cf2c12016-04-13 17:07:163522// |name|, |width|, |height|, and |framerate|.
3523void UpdateCodec(int payload_type,
3524 const std::string& name,
henrike@webrtc.org28e20752013-07-10 00:45:363525 VideoContentDescription* video_desc) {
3526 // Codec may already be populated with (only) optional parameters
3527 // (from an fmtp).
changbin.shao@webrtc.org2d25b442015-03-16 04:14:343528 cricket::VideoCodec codec =
3529 GetCodecWithPayloadType(video_desc->codecs(), payload_type);
henrike@webrtc.org28e20752013-07-10 00:45:363530 codec.name = name;
henrike@webrtc.org28e20752013-07-10 00:45:363531 AddOrReplaceCodec<VideoContentDescription, cricket::VideoCodec>(video_desc,
3532 codec);
3533}
3534
3535bool ParseRtpmapAttribute(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:013536 const cricket::MediaType media_type,
deadbeef67cf2c12016-04-13 17:07:163537 const std::vector<int>& payload_types,
henrike@webrtc.org28e20752013-07-10 00:45:363538 MediaContentDescription* media_desc,
3539 SdpParseError* error) {
3540 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493541 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:363542 // RFC 4566
3543 // a=rtpmap:<payload type> <encoding name>/<clock rate>[/<encodingparameters>]
3544 const size_t expected_min_fields = 2;
3545 if (fields.size() < expected_min_fields) {
3546 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
3547 }
3548 std::string payload_type_value;
3549 if (!GetValue(fields[0], kAttributeRtpmap, &payload_type_value, error)) {
3550 return false;
3551 }
wu@webrtc.org5e760e72014-04-02 23:19:093552 int payload_type = 0;
pkasting@chromium.orge9facf82015-02-17 20:36:283553 if (!GetPayloadTypeFromString(line, payload_type_value, &payload_type,
3554 error)) {
wu@webrtc.org5e760e72014-04-02 23:19:093555 return false;
3556 }
henrike@webrtc.org28e20752013-07-10 00:45:363557
Steve Anton64b626b2019-01-29 01:25:263558 if (!absl::c_linear_search(payload_types, payload_type)) {
Mirko Bonadei675513b2017-11-09 10:09:253559 RTC_LOG(LS_WARNING) << "Ignore rtpmap line that did not appear in the "
Jonas Olsson45cc8902018-02-13 09:37:073560 "<fmt> of the m-line: "
3561 << line;
henrike@webrtc.org28e20752013-07-10 00:45:363562 return true;
3563 }
jbauch083b73f2015-07-16 09:46:323564 const std::string& encoder = fields[1];
henrike@webrtc.org28e20752013-07-10 00:45:363565 std::vector<std::string> codec_params;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:523566 rtc::split(encoder, '/', &codec_params);
henrike@webrtc.org28e20752013-07-10 00:45:363567 // <encoding name>/<clock rate>[/<encodingparameters>]
3568 // 2 mandatory fields
3569 if (codec_params.size() < 2 || codec_params.size() > 3) {
3570 return ParseFailed(line,
3571 "Expected format \"<encoding name>/<clock rate>"
3572 "[/<encodingparameters>]\".",
3573 error);
3574 }
jbauch083b73f2015-07-16 09:46:323575 const std::string& encoding_name = codec_params[0];
wu@webrtc.org5e760e72014-04-02 23:19:093576 int clock_rate = 0;
3577 if (!GetValueFromString(line, codec_params[1], &clock_rate, error)) {
3578 return false;
3579 }
henrike@webrtc.org28e20752013-07-10 00:45:363580 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
Steve Antonb1c1de12017-12-21 23:14:303581 VideoContentDescription* video_desc = media_desc->as_video();
Yves Gerey665174f2018-06-19 13:03:053582 UpdateCodec(payload_type, encoding_name, video_desc);
henrike@webrtc.org28e20752013-07-10 00:45:363583 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
3584 // RFC 4566
3585 // For audio streams, <encoding parameters> indicates the number
3586 // of audio channels. This parameter is OPTIONAL and may be
3587 // omitted if the number of channels is one, provided that no
3588 // additional parameters are needed.
Peter Kasting69558702016-01-13 00:26:353589 size_t channels = 1;
henrike@webrtc.org28e20752013-07-10 00:45:363590 if (codec_params.size() == 3) {
wu@webrtc.org5e760e72014-04-02 23:19:093591 if (!GetValueFromString(line, codec_params[2], &channels, error)) {
3592 return false;
3593 }
henrike@webrtc.org28e20752013-07-10 00:45:363594 }
Steve Antonb1c1de12017-12-21 23:14:303595 AudioContentDescription* audio_desc = media_desc->as_audio();
ossue1405ad2017-01-23 16:55:483596 UpdateCodec(payload_type, encoding_name, clock_rate, 0, channels,
deadbeef67cf2c12016-04-13 17:07:163597 audio_desc);
henrike@webrtc.org28e20752013-07-10 00:45:363598 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
Harald Alvestrand5fc28b12019-05-13 11:36:163599 RtpDataContentDescription* data_desc = media_desc->as_rtp_data();
3600 if (data_desc) {
3601 data_desc->AddCodec(cricket::RtpDataCodec(payload_type, encoding_name));
3602 }
henrike@webrtc.org28e20752013-07-10 00:45:363603 }
3604 return true;
3605}
3606
Yves Gerey665174f2018-06-19 13:03:053607bool ParseFmtpParam(const std::string& line,
3608 std::string* parameter,
3609 std::string* value,
3610 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:493611 if (!rtc::tokenize_first(line, kSdpDelimiterEqualChar, parameter, value)) {
henrike@webrtc.org28e20752013-07-10 00:45:363612 ParseFailed(line, "Unable to parse fmtp parameter. \'=\' missing.", error);
3613 return false;
3614 }
3615 // a=fmtp:<payload_type> <param1>=<value1>; <param2>=<value2>; ...
henrike@webrtc.org28e20752013-07-10 00:45:363616 return true;
3617}
3618
Yves Gerey665174f2018-06-19 13:03:053619bool ParseFmtpAttributes(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:013620 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:363621 MediaContentDescription* media_desc,
3622 SdpParseError* error) {
3623 if (media_type != cricket::MEDIA_TYPE_AUDIO &&
3624 media_type != cricket::MEDIA_TYPE_VIDEO) {
3625 return true;
3626 }
Donald Curtis0e07f922015-05-15 16:21:233627
3628 std::string line_payload;
3629 std::string line_params;
henrike@webrtc.org28e20752013-07-10 00:45:363630
3631 // RFC 5576
3632 // a=fmtp:<format> <format specific parameters>
3633 // At least two fields, whereas the second one is any of the optional
3634 // parameters.
Jonas Olssonec9e4922018-09-05 07:53:493635 if (!rtc::tokenize_first(line.substr(kLinePrefixLength),
3636 kSdpDelimiterSpaceChar, &line_payload,
3637 &line_params)) {
henrike@webrtc.org28e20752013-07-10 00:45:363638 ParseFailedExpectMinFieldNum(line, 2, error);
3639 return false;
3640 }
3641
Donald Curtis0e07f922015-05-15 16:21:233642 // Parse out the payload information.
pkasting@chromium.orgd3245462015-02-23 21:28:223643 std::string payload_type_str;
Donald Curtis0e07f922015-05-15 16:21:233644 if (!GetValue(line_payload, kAttributeFmtp, &payload_type_str, error)) {
henrike@webrtc.org28e20752013-07-10 00:45:363645 return false;
3646 }
3647
Donald Curtis0e07f922015-05-15 16:21:233648 int payload_type = 0;
Donald Curtis144d0182015-05-15 20:14:243649 if (!GetPayloadTypeFromString(line_payload, payload_type_str, &payload_type,
3650 error)) {
Donald Curtis0e07f922015-05-15 16:21:233651 return false;
3652 }
3653
3654 // Parse out format specific parameters.
3655 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493656 rtc::split(line_params, kSdpDelimiterSemicolonChar, &fields);
Donald Curtis0e07f922015-05-15 16:21:233657
henrike@webrtc.org28e20752013-07-10 00:45:363658 cricket::CodecParameterMap codec_params;
Donald Curtis144d0182015-05-15 20:14:243659 for (auto& iter : fields) {
Donald Curtis0e07f922015-05-15 16:21:233660 if (iter.find(kSdpDelimiterEqual) == std::string::npos) {
henrike@webrtc.org28e20752013-07-10 00:45:363661 // Only fmtps with equals are currently supported. Other fmtp types
3662 // should be ignored. Unknown fmtps do not constitute an error.
3663 continue;
3664 }
Donald Curtis0e07f922015-05-15 16:21:233665
3666 std::string name;
3667 std::string value;
3668 if (!ParseFmtpParam(rtc::string_trim(iter), &name, &value, error)) {
henrike@webrtc.org28e20752013-07-10 00:45:363669 return false;
3670 }
3671 codec_params[name] = value;
3672 }
3673
henrike@webrtc.org28e20752013-07-10 00:45:363674 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
3675 UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
pkasting@chromium.orgd3245462015-02-23 21:28:223676 media_desc, payload_type, codec_params);
henrike@webrtc.org28e20752013-07-10 00:45:363677 } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
3678 UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
pkasting@chromium.orgd3245462015-02-23 21:28:223679 media_desc, payload_type, codec_params);
henrike@webrtc.org28e20752013-07-10 00:45:363680 }
3681 return true;
3682}
3683
Mirta Dvornicic479a3c02019-06-04 13:38:503684bool ParsePacketizationAttribute(const std::string& line,
3685 const cricket::MediaType media_type,
3686 MediaContentDescription* media_desc,
3687 SdpParseError* error) {
3688 if (media_type != cricket::MEDIA_TYPE_VIDEO) {
3689 return true;
3690 }
3691 std::vector<std::string> packetization_fields;
3692 rtc::split(line.c_str(), kSdpDelimiterSpaceChar, &packetization_fields);
3693 if (packetization_fields.size() < 2) {
3694 return ParseFailedGetValue(line, kAttributePacketization, error);
3695 }
3696 std::string payload_type_string;
3697 if (!GetValue(packetization_fields[0], kAttributePacketization,
3698 &payload_type_string, error)) {
3699 return false;
3700 }
3701 int payload_type;
3702 if (!GetPayloadTypeFromString(line, payload_type_string, &payload_type,
3703 error)) {
3704 return false;
3705 }
3706 std::string packetization = packetization_fields[1];
3707 UpdateVideoCodecPacketization(media_desc->as_video(), payload_type,
3708 packetization);
3709 return true;
3710}
3711
Yves Gerey665174f2018-06-19 13:03:053712bool ParseRtcpFbAttribute(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:013713 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:363714 MediaContentDescription* media_desc,
3715 SdpParseError* error) {
3716 if (media_type != cricket::MEDIA_TYPE_AUDIO &&
3717 media_type != cricket::MEDIA_TYPE_VIDEO) {
3718 return true;
3719 }
3720 std::vector<std::string> rtcp_fb_fields;
Jonas Olssonec9e4922018-09-05 07:53:493721 rtc::split(line.c_str(), kSdpDelimiterSpaceChar, &rtcp_fb_fields);
henrike@webrtc.org28e20752013-07-10 00:45:363722 if (rtcp_fb_fields.size() < 2) {
3723 return ParseFailedGetValue(line, kAttributeRtcpFb, error);
3724 }
3725 std::string payload_type_string;
3726 if (!GetValue(rtcp_fb_fields[0], kAttributeRtcpFb, &payload_type_string,
3727 error)) {
3728 return false;
3729 }
wu@webrtc.org5e760e72014-04-02 23:19:093730 int payload_type = kWildcardPayloadType;
3731 if (payload_type_string != "*") {
pkasting@chromium.orge9facf82015-02-17 20:36:283732 if (!GetPayloadTypeFromString(line, payload_type_string, &payload_type,
3733 error)) {
wu@webrtc.org5e760e72014-04-02 23:19:093734 return false;
3735 }
3736 }
henrike@webrtc.org28e20752013-07-10 00:45:363737 std::string id = rtcp_fb_fields[1];
3738 std::string param = "";
3739 for (std::vector<std::string>::iterator iter = rtcp_fb_fields.begin() + 2;
3740 iter != rtcp_fb_fields.end(); ++iter) {
3741 param.append(*iter);
3742 }
3743 const cricket::FeedbackParam feedback_param(id, param);
3744
3745 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
pkasting@chromium.orgd3245462015-02-23 21:28:223746 UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
3747 media_desc, payload_type, feedback_param);
henrike@webrtc.org28e20752013-07-10 00:45:363748 } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
pkasting@chromium.orgd3245462015-02-23 21:28:223749 UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
3750 media_desc, payload_type, feedback_param);
henrike@webrtc.org28e20752013-07-10 00:45:363751 }
3752 return true;
3753}
3754
3755} // namespace webrtc