blob: a022e5642ddcd5277cb3dc7506d0da1cef1eb302 [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"
Steve Anton5a1de872018-12-18 19:25:5527#include "absl/memory/memory.h"
Niels Möller039743e2018-10-23 08:07:2528#include "absl/strings/match.h"
Patrik Höglunde2d6a062017-10-05 12:53:3329#include "api/candidate.h"
Steve Anton10542f22019-01-11 17:11:0030#include "api/crypto_params.h"
31#include "api/jsep_ice_candidate.h"
32#include "api/jsep_session_description.h"
33#include "api/media_types.h"
isheriff6f8d6862016-05-26 18:24:5534// for RtpExtension
Steve Anton10542f22019-01-11 17:11:0035#include "api/rtp_parameters.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3136#include "media/base/codec.h"
Steve Anton10542f22019-01-11 17:11:0037#include "media/base/media_constants.h"
38#include "media/base/rtp_utils.h"
39#include "media/sctp/sctp_transport_internal.h"
40#include "p2p/base/p2p_constants.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3141#include "p2p/base/port.h"
Steve Anton10542f22019-01-11 17:11:0042#include "pc/media_session.h"
43#include "pc/sdp_serializer.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3144#include "rtc_base/arraysize.h"
45#include "rtc_base/checks.h"
46#include "rtc_base/logging.h"
Steve Anton10542f22019-01-11 17:11:0047#include "rtc_base/message_digest.h"
Niels Möller198cf002019-05-10 10:29:1348#include "rtc_base/string_utils.h"
Jonas Olssonec9e4922018-09-05 07:53:4949#include "rtc_base/strings/string_builder.h"
Piotr (Peter) Slatala13e570f2019-02-27 19:34:2650#include "rtc_base/third_party/base64/base64.h"
henrike@webrtc.org28e20752013-07-10 00:45:3651
52using cricket::AudioContentDescription;
53using cricket::Candidate;
54using cricket::Candidates;
henrike@webrtc.org28e20752013-07-10 00:45:3655using cricket::ContentInfo;
56using cricket::CryptoParams;
Harald Alvestrand141c0ad2019-05-05 19:00:0057using cricket::ICE_CANDIDATE_COMPONENT_RTCP;
Harald Alvestrand37f2b432019-05-09 07:19:5458using cricket::ICE_CANDIDATE_COMPONENT_RTP;
59using cricket::kCodecParamAssociatedPayloadType;
60using cricket::kCodecParamMaxAverageBitrate;
henrike@webrtc.org28e20752013-07-10 00:45:3661using cricket::kCodecParamMaxBitrate;
Harald Alvestrand37f2b432019-05-09 07:19:5462using cricket::kCodecParamMaxPlaybackRate;
henrike@webrtc.org28e20752013-07-10 00:45:3663using cricket::kCodecParamMaxPTime;
64using cricket::kCodecParamMaxQuantization;
65using cricket::kCodecParamMinBitrate;
66using cricket::kCodecParamMinPTime;
67using cricket::kCodecParamPTime;
Harald Alvestrand37f2b432019-05-09 07:19:5468using cricket::kCodecParamSctpProtocol;
69using cricket::kCodecParamSctpStreams;
henrike@webrtc.org28e20752013-07-10 00:45:3670using cricket::kCodecParamSPropStereo;
buildbot@webrtc.orged97bb02014-05-07 11:15:2071using cricket::kCodecParamStartBitrate;
henrike@webrtc.org28e20752013-07-10 00:45:3672using cricket::kCodecParamStereo;
Harald Alvestrand141c0ad2019-05-05 19:00:0073using cricket::kCodecParamUseDtx;
Harald Alvestrand37f2b432019-05-09 07:19:5474using cricket::kCodecParamUseInbandFec;
henrike@webrtc.org28e20752013-07-10 00:45:3675using cricket::MediaContentDescription;
Harald Alvestrand141c0ad2019-05-05 19:00:0076using cricket::MediaProtocolType;
Harald Alvestrand37f2b432019-05-09 07:19:5477using cricket::MediaType;
Harald Alvestrand141c0ad2019-05-05 19:00:0078using cricket::RidDescription;
Harald Alvestrand5fc28b12019-05-13 11:36:1679using cricket::RtpDataContentDescription;
Harald Alvestrand37f2b432019-05-09 07:19:5480using cricket::RtpHeaderExtensions;
Harald Alvestrand5fc28b12019-05-13 11:36:1681using cricket::SctpDataContentDescription;
Amit Hilbucha2012042018-12-03 19:35:0582using cricket::SimulcastDescription;
Amit Hilbuchc57d5732018-12-11 23:30:1183using cricket::SimulcastLayer;
84using cricket::SimulcastLayerList;
henrike@webrtc.org28e20752013-07-10 00:45:3685using cricket::SsrcGroup;
86using cricket::StreamParams;
87using cricket::StreamParamsVec;
88using cricket::TransportDescription;
89using cricket::TransportInfo;
90using cricket::VideoContentDescription;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:5291using rtc::SocketAddress;
henrike@webrtc.org28e20752013-07-10 00:45:3692
henrike@webrtc.org28e20752013-07-10 00:45:3693namespace cricket {
94class SessionDescription;
95}
96
deadbeef90f1e1e2017-02-10 20:35:0597// TODO(deadbeef): Switch to using anonymous namespace rather than declaring
98// everything "static".
henrike@webrtc.org28e20752013-07-10 00:45:3699namespace webrtc {
100
101// Line type
102// RFC 4566
103// An SDP session description consists of a number of lines of text of
104// the form:
105// <type>=<value>
106// where <type> MUST be exactly one case-significant character.
deadbeef9d3584c2016-02-17 01:54:10107static const int kLinePrefixLength = 2; // Length of <type>=
henrike@webrtc.org28e20752013-07-10 00:45:36108static const char kLineTypeVersion = 'v';
109static const char kLineTypeOrigin = 'o';
110static const char kLineTypeSessionName = 's';
111static const char kLineTypeSessionInfo = 'i';
112static const char kLineTypeSessionUri = 'u';
113static const char kLineTypeSessionEmail = 'e';
114static const char kLineTypeSessionPhone = 'p';
115static const char kLineTypeSessionBandwidth = 'b';
116static const char kLineTypeTiming = 't';
117static const char kLineTypeRepeatTimes = 'r';
118static const char kLineTypeTimeZone = 'z';
119static const char kLineTypeEncryptionKey = 'k';
120static const char kLineTypeMedia = 'm';
121static const char kLineTypeConnection = 'c';
122static const char kLineTypeAttributes = 'a';
123
124// Attributes
125static const char kAttributeGroup[] = "group";
126static const char kAttributeMid[] = "mid";
deadbeef9d3584c2016-02-17 01:54:10127static const char kAttributeMsid[] = "msid";
deadbeef25ed4352016-12-13 02:37:36128static const char kAttributeBundleOnly[] = "bundle-only";
henrike@webrtc.org28e20752013-07-10 00:45:36129static const char kAttributeRtcpMux[] = "rtcp-mux";
deadbeef13871492015-12-09 20:37:51130static const char kAttributeRtcpReducedSize[] = "rtcp-rsize";
henrike@webrtc.org28e20752013-07-10 00:45:36131static const char kAttributeSsrc[] = "ssrc";
132static const char kSsrcAttributeCname[] = "cname";
Johannes Kron0854eb62018-10-10 20:33:20133static const char kAttributeExtmapAllowMixed[] = "extmap-allow-mixed";
henrike@webrtc.org28e20752013-07-10 00:45:36134static const char kAttributeExtmap[] = "extmap";
135// draft-alvestrand-mmusic-msid-01
136// a=msid-semantic: WMS
Seth Hampson5b4f0752018-04-02 23:31:36137// This is a legacy field supported only for Plan B semantics.
henrike@webrtc.org28e20752013-07-10 00:45:36138static const char kAttributeMsidSemantics[] = "msid-semantic";
139static const char kMediaStreamSemantic[] = "WMS";
140static const char kSsrcAttributeMsid[] = "msid";
141static const char kDefaultMsid[] = "default";
Seth Hampson5b4f0752018-04-02 23:31:36142static const char kNoStreamMsid[] = "-";
henrike@webrtc.org28e20752013-07-10 00:45:36143static const char kSsrcAttributeMslabel[] = "mslabel";
144static const char kSSrcAttributeLabel[] = "label";
145static const char kAttributeSsrcGroup[] = "ssrc-group";
146static const char kAttributeCrypto[] = "crypto";
147static const char kAttributeCandidate[] = "candidate";
148static const char kAttributeCandidateTyp[] = "typ";
149static const char kAttributeCandidateRaddr[] = "raddr";
150static const char kAttributeCandidateRport[] = "rport";
honghaiza54a0802015-12-17 02:37:23151static const char kAttributeCandidateUfrag[] = "ufrag";
152static const char kAttributeCandidatePwd[] = "pwd";
henrike@webrtc.org28e20752013-07-10 00:45:36153static const char kAttributeCandidateGeneration[] = "generation";
honghaiza0c44ea2016-03-23 23:07:48154static const char kAttributeCandidateNetworkId[] = "network-id";
honghaize1a0c942016-02-16 22:54:56155static const char kAttributeCandidateNetworkCost[] = "network-cost";
henrike@webrtc.org28e20752013-07-10 00:45:36156static const char kAttributeFingerprint[] = "fingerprint";
sergeyu@chromium.org0be6aa02013-08-23 23:21:25157static const char kAttributeSetup[] = "setup";
henrike@webrtc.org28e20752013-07-10 00:45:36158static const char kAttributeFmtp[] = "fmtp";
159static const char kAttributeRtpmap[] = "rtpmap";
wu@webrtc.org78187522013-10-07 23:32:02160static const char kAttributeSctpmap[] = "sctpmap";
henrike@webrtc.org28e20752013-07-10 00:45:36161static const char kAttributeRtcp[] = "rtcp";
162static const char kAttributeIceUfrag[] = "ice-ufrag";
163static const char kAttributeIcePwd[] = "ice-pwd";
164static const char kAttributeIceLite[] = "ice-lite";
165static const char kAttributeIceOption[] = "ice-options";
166static const char kAttributeSendOnly[] = "sendonly";
167static const char kAttributeRecvOnly[] = "recvonly";
168static const char kAttributeRtcpFb[] = "rtcp-fb";
169static const char kAttributeSendRecv[] = "sendrecv";
170static const char kAttributeInactive[] = "inactive";
Harald Alvestrand48cce4d2019-04-11 08:41:24171// draft-ietf-mmusic-sctp-sdp-26
172// a=sctp-port, a=max-message-size
jiayl@webrtc.orgddb85ab2014-09-05 16:31:56173static const char kAttributeSctpPort[] = "sctp-port";
Harald Alvestrand48cce4d2019-04-11 08:41:24174static const char kAttributeMaxMessageSize[] = "max-message-size";
Harald Alvestrandfbb45bd2019-05-15 06:07:47175static const int kDefaultSctpMaxMessageSize = 65536;
Amit Hilbucha2012042018-12-03 19:35:05176// draft-ietf-mmusic-sdp-simulcast-13
177// a=simulcast
178static const char kAttributeSimulcast[] = "simulcast";
Amit Hilbuchc57d5732018-12-11 23:30:11179// draft-ietf-mmusic-rid-15
180// a=rid
181static const char kAttributeRid[] = "rid";
Mirta Dvornicic479a3c02019-06-04 13:38:50182static const char kAttributePacketization[] = "packetization";
henrike@webrtc.org28e20752013-07-10 00:45:36183
184// Experimental flags
185static const char kAttributeXGoogleFlag[] = "x-google-flag";
186static const char kValueConference[] = "conference";
henrike@webrtc.org28e20752013-07-10 00:45:36187
188// Candidate
189static const char kCandidateHost[] = "host";
190static const char kCandidateSrflx[] = "srflx";
Honghai Zhang7fb69db2016-03-14 18:59:18191static const char kCandidatePrflx[] = "prflx";
henrike@webrtc.org28e20752013-07-10 00:45:36192static const char kCandidateRelay[] = "relay";
mallinath@webrtc.org2d60c5e2014-08-08 22:29:20193static const char kTcpCandidateType[] = "tcptype";
henrike@webrtc.org28e20752013-07-10 00:45:36194
Jonas Olssonec9e4922018-09-05 07:53:49195// rtc::StringBuilder doesn't have a << overload for chars, while rtc::split and
196// rtc::tokenize_first both take a char delimiter. To handle both cases these
197// constants come in pairs of a chars and length-one strings.
198static const char kSdpDelimiterEqual[] = "=";
199static const char kSdpDelimiterEqualChar = '=';
200static const char kSdpDelimiterSpace[] = " ";
201static const char kSdpDelimiterSpaceChar = ' ';
202static const char kSdpDelimiterColon[] = ":";
203static const char kSdpDelimiterColonChar = ':';
204static const char kSdpDelimiterSemicolon[] = ";";
205static const char kSdpDelimiterSemicolonChar = ';';
206static const char kSdpDelimiterSlashChar = '/';
207static const char kNewLine[] = "\n";
208static const char kNewLineChar = '\n';
209static const char kReturnChar = '\r';
henrike@webrtc.org28e20752013-07-10 00:45:36210static const char kLineBreak[] = "\r\n";
211
Steve Anton36b29d12017-10-30 16:57:42212// TODO(deadbeef): Generate the Session and Time description
henrike@webrtc.org28e20752013-07-10 00:45:36213// instead of hardcoding.
214static const char kSessionVersion[] = "v=0";
215// RFC 4566
216static const char kSessionOriginUsername[] = "-";
217static const char kSessionOriginSessionId[] = "0";
218static const char kSessionOriginSessionVersion[] = "0";
219static const char kSessionOriginNettype[] = "IN";
220static const char kSessionOriginAddrtype[] = "IP4";
221static const char kSessionOriginAddress[] = "127.0.0.1";
222static const char kSessionName[] = "s=-";
223static const char kTimeDescription[] = "t=0 0";
224static const char kAttrGroup[] = "a=group:BUNDLE";
225static const char kConnectionNettype[] = "IN";
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22226static const char kConnectionIpv4Addrtype[] = "IP4";
227static const char kConnectionIpv6Addrtype[] = "IP6";
henrike@webrtc.org28e20752013-07-10 00:45:36228static const char kMediaTypeVideo[] = "video";
229static const char kMediaTypeAudio[] = "audio";
230static const char kMediaTypeData[] = "application";
231static const char kMediaPortRejected[] = "0";
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22232// draft-ietf-mmusic-trickle-ice-01
233// When no candidates have been gathered, set the connection
234// address to IP6 ::.
perkj@webrtc.orgd105cc82014-11-07 11:22:06235// TODO(perkj): FF can not parse IP6 ::. See http://crbug/430333
236// Use IPV4 per default.
237static const char kDummyAddress[] = "0.0.0.0";
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22238static const char kDummyPort[] = "9";
henrike@webrtc.org28e20752013-07-10 00:45:36239// RFC 3556
240static const char kApplicationSpecificMaximum[] = "AS";
241
wu@webrtc.org78187522013-10-07 23:32:02242static const char kDefaultSctpmapProtocol[] = "webrtc-datachannel";
henrike@webrtc.org28e20752013-07-10 00:45:36243
Piotr (Peter) Slatala13e570f2019-02-27 19:34:26244// This is a non-standardized media transport settings.
245// This setting is going to be set in the offer. There may be one or more
246// a=x-mt: settings, and they are in the priority order (the most preferred on
247// top). x-mt setting format depends on the media transport, and is generated by
248// |MediaTransportInterface::GetTransportParametersOffer|.
249static const char kMediaTransportSettingLine[] = "x-mt";
250
Bjorn A Mellemc85ebbe2019-06-07 17:28:06251// This is a non-standardized setting for plugin transports.
252static const char kOpaqueTransportParametersLine[] = "x-opaque";
253
pkasting@chromium.orgd3245462015-02-23 21:28:22254// RTP payload type is in the 0-127 range. Use -1 to indicate "all" payload
255// types.
256const int kWildcardPayloadType = -1;
257
henrike@webrtc.org28e20752013-07-10 00:45:36258struct SsrcInfo {
Peter Boström0c4e06b2015-10-07 10:23:21259 uint32_t ssrc_id;
henrike@webrtc.org28e20752013-07-10 00:45:36260 std::string cname;
deadbeef9d3584c2016-02-17 01:54:10261 std::string stream_id;
262 std::string track_id;
henrike@webrtc.org28e20752013-07-10 00:45:36263
264 // For backward compatibility.
265 // TODO(ronghuawu): Remove below 2 fields once all the clients support msid.
266 std::string label;
267 std::string mslabel;
268};
269typedef std::vector<SsrcInfo> SsrcInfoVec;
270typedef std::vector<SsrcGroup> SsrcGroupVec;
271
henrike@webrtc.org28e20752013-07-10 00:45:36272template <class T>
273static void AddFmtpLine(const T& codec, std::string* message);
274static void BuildMediaDescription(const ContentInfo* content_info,
275 const TransportInfo* transport_info,
Patrik Höglundb6b29e02018-06-21 14:58:01276 const cricket::MediaType media_type,
wu@webrtc.org4c3e9912014-07-16 21:03:13277 const std::vector<Candidate>& candidates,
Steve Antone831b8c2018-02-01 20:22:16278 int msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:36279 std::string* message);
deadbeef9d3584c2016-02-17 01:54:10280static void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
Patrik Höglundb6b29e02018-06-21 14:58:01281 const cricket::MediaType media_type,
Steve Antone831b8c2018-02-01 20:22:16282 int msid_signaling,
deadbeef9d3584c2016-02-17 01:54:10283 std::string* message);
henrike@webrtc.org28e20752013-07-10 00:45:36284static void BuildRtpMap(const MediaContentDescription* media_desc,
Patrik Höglundb6b29e02018-06-21 14:58:01285 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:36286 std::string* message);
287static void BuildCandidate(const std::vector<Candidate>& candidates,
honghaiza54a0802015-12-17 02:37:23288 bool include_ufrag,
henrike@webrtc.org28e20752013-07-10 00:45:36289 std::string* message);
290static void BuildIceOptions(const std::vector<std::string>& transport_options,
291 std::string* message);
zhihuang38989e52017-03-21 18:04:53292static bool ParseSessionDescription(const std::string& message,
293 size_t* pos,
henrike@webrtc.org28e20752013-07-10 00:45:36294 std::string* session_id,
295 std::string* session_version,
henrike@webrtc.org28e20752013-07-10 00:45:36296 TransportDescription* session_td,
297 RtpHeaderExtensions* session_extmaps,
zhihuang38989e52017-03-21 18:04:53298 rtc::SocketAddress* connection_addr,
henrike@webrtc.org28e20752013-07-10 00:45:36299 cricket::SessionDescription* desc,
300 SdpParseError* error);
301static bool ParseGroupAttribute(const std::string& line,
302 cricket::SessionDescription* desc,
303 SdpParseError* error);
304static bool ParseMediaDescription(
305 const std::string& message,
306 const TransportDescription& session_td,
307 const RtpHeaderExtensions& session_extmaps,
zhihuang38989e52017-03-21 18:04:53308 size_t* pos,
309 const rtc::SocketAddress& session_connection_addr,
310 cricket::SessionDescription* desc,
Steve Anton5a1de872018-12-18 19:25:55311 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
henrike@webrtc.org28e20752013-07-10 00:45:36312 SdpParseError* error);
Steve Anton5a1de872018-12-18 19:25:55313static bool ParseContent(
314 const std::string& message,
315 const cricket::MediaType media_type,
316 int mline_index,
317 const std::string& protocol,
318 const std::vector<int>& payload_types,
319 size_t* pos,
320 std::string* content_name,
321 bool* bundle_only,
322 int* msid_signaling,
323 MediaContentDescription* media_desc,
324 TransportDescription* transport,
325 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
326 SdpParseError* error);
henrike@webrtc.org28e20752013-07-10 00:45:36327static bool ParseSsrcAttribute(const std::string& line,
328 SsrcInfoVec* ssrc_infos,
Steve Antone831b8c2018-02-01 20:22:16329 int* msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:36330 SdpParseError* error);
331static bool ParseSsrcGroupAttribute(const std::string& line,
332 SsrcGroupVec* ssrc_groups,
333 SdpParseError* error);
334static bool ParseCryptoAttribute(const std::string& line,
335 MediaContentDescription* media_desc,
336 SdpParseError* error);
337static bool ParseRtpmapAttribute(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:01338 const cricket::MediaType media_type,
deadbeef67cf2c12016-04-13 17:07:16339 const std::vector<int>& payload_types,
henrike@webrtc.org28e20752013-07-10 00:45:36340 MediaContentDescription* media_desc,
341 SdpParseError* error);
342static bool ParseFmtpAttributes(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:01343 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:36344 MediaContentDescription* media_desc,
345 SdpParseError* error);
Yves Gerey665174f2018-06-19 13:03:05346static bool ParseFmtpParam(const std::string& line,
347 std::string* parameter,
348 std::string* value,
349 SdpParseError* error);
Mirta Dvornicic479a3c02019-06-04 13:38:50350static bool ParsePacketizationAttribute(const std::string& line,
351 const cricket::MediaType media_type,
352 MediaContentDescription* media_desc,
353 SdpParseError* error);
henrike@webrtc.org28e20752013-07-10 00:45:36354static bool ParseRtcpFbAttribute(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:01355 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:36356 MediaContentDescription* media_desc,
357 SdpParseError* error);
358static bool ParseIceOptions(const std::string& line,
359 std::vector<std::string>* transport_options,
360 SdpParseError* error);
361static bool ParseExtmap(const std::string& line,
isheriff6f8d6862016-05-26 18:24:55362 RtpExtension* extmap,
henrike@webrtc.org28e20752013-07-10 00:45:36363 SdpParseError* error);
Steve Anton4905edb2018-10-16 02:27:44364static bool ParseFingerprintAttribute(
365 const std::string& line,
366 std::unique_ptr<rtc::SSLFingerprint>* fingerprint,
367 SdpParseError* error);
sergeyu@chromium.org0be6aa02013-08-23 23:21:25368static bool ParseDtlsSetup(const std::string& line,
369 cricket::ConnectionRole* role,
370 SdpParseError* error);
deadbeef9d3584c2016-02-17 01:54:10371static bool ParseMsidAttribute(const std::string& line,
Seth Hampson5b4f0752018-04-02 23:31:36372 std::vector<std::string>* stream_ids,
deadbeef9d3584c2016-02-17 01:54:10373 std::string* track_id,
374 SdpParseError* error);
henrike@webrtc.org28e20752013-07-10 00:45:36375
Amit Hilbuchc57d5732018-12-11 23:30:11376static void RemoveInvalidRidDescriptions(const std::vector<int>& payload_types,
377 std::vector<RidDescription>* rids);
378
379static SimulcastLayerList RemoveRidsFromSimulcastLayerList(
380 const std::set<std::string>& to_remove,
381 const SimulcastLayerList& layers);
382
383static void RemoveInvalidRidsFromSimulcast(
384 const std::vector<RidDescription>& rids,
385 SimulcastDescription* simulcast);
386
henrike@webrtc.org28e20752013-07-10 00:45:36387// Helper functions
388
389// Below ParseFailed*** functions output the line that caused the parsing
390// failure and the detailed reason (|description|) of the failure to |error|.
391// The functions always return false so that they can be used directly in the
392// following way when error happens:
393// "return ParseFailed***(...);"
394
395// The line starting at |line_start| of |message| is the failing line.
396// The reason for the failure should be provided in the |description|.
397// An example of a description could be "unknown character".
398static bool ParseFailed(const std::string& message,
399 size_t line_start,
400 const std::string& description,
401 SdpParseError* error) {
402 // Get the first line of |message| from |line_start|.
sergeyu@chromium.org5bc25c42013-12-05 00:24:06403 std::string first_line;
henrike@webrtc.org28e20752013-07-10 00:45:36404 size_t line_end = message.find(kNewLine, line_start);
405 if (line_end != std::string::npos) {
Jonas Olssonec9e4922018-09-05 07:53:49406 if (line_end > 0 && (message.at(line_end - 1) == kReturnChar)) {
henrike@webrtc.org28e20752013-07-10 00:45:36407 --line_end;
408 }
409 first_line = message.substr(line_start, (line_end - line_start));
sergeyu@chromium.org5bc25c42013-12-05 00:24:06410 } else {
411 first_line = message.substr(line_start);
henrike@webrtc.org28e20752013-07-10 00:45:36412 }
413
414 if (error) {
415 error->line = first_line;
416 error->description = description;
417 }
Mirko Bonadei675513b2017-11-09 10:09:25418 RTC_LOG(LS_ERROR) << "Failed to parse: \"" << first_line
419 << "\". Reason: " << description;
henrike@webrtc.org28e20752013-07-10 00:45:36420 return false;
421}
422
423// |line| is the failing line. The reason for the failure should be
424// provided in the |description|.
425static bool ParseFailed(const std::string& line,
426 const std::string& description,
427 SdpParseError* error) {
428 return ParseFailed(line, 0, description, error);
429}
430
431// Parses failure where the failing SDP line isn't know or there are multiple
432// failing lines.
Yves Gerey665174f2018-06-19 13:03:05433static bool ParseFailed(const std::string& description, SdpParseError* error) {
henrike@webrtc.org28e20752013-07-10 00:45:36434 return ParseFailed("", description, error);
435}
436
437// |line| is the failing line. The failure is due to the fact that |line|
438// doesn't have |expected_fields| fields.
439static bool ParseFailedExpectFieldNum(const std::string& line,
440 int expected_fields,
441 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:49442 rtc::StringBuilder description;
henrike@webrtc.org28e20752013-07-10 00:45:36443 description << "Expects " << expected_fields << " fields.";
444 return ParseFailed(line, description.str(), error);
445}
446
447// |line| is the failing line. The failure is due to the fact that |line| has
448// less than |expected_min_fields| fields.
449static bool ParseFailedExpectMinFieldNum(const std::string& line,
450 int expected_min_fields,
451 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:49452 rtc::StringBuilder description;
henrike@webrtc.org28e20752013-07-10 00:45:36453 description << "Expects at least " << expected_min_fields << " fields.";
454 return ParseFailed(line, description.str(), error);
455}
456
457// |line| is the failing line. The failure is due to the fact that it failed to
458// get the value of |attribute|.
459static bool ParseFailedGetValue(const std::string& line,
460 const std::string& attribute,
461 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:49462 rtc::StringBuilder description;
henrike@webrtc.org28e20752013-07-10 00:45:36463 description << "Failed to get the value of attribute: " << attribute;
464 return ParseFailed(line, description.str(), error);
465}
466
467// The line starting at |line_start| of |message| is the failing line. The
468// failure is due to the line type (e.g. the "m" part of the "m-line")
469// not matching what is expected. The expected line type should be
470// provided as |line_type|.
471static bool ParseFailedExpectLine(const std::string& message,
472 size_t line_start,
473 const char line_type,
474 const std::string& line_value,
475 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:49476 rtc::StringBuilder description;
477 description << "Expect line: " << std::string(1, line_type) << "="
478 << line_value;
henrike@webrtc.org28e20752013-07-10 00:45:36479 return ParseFailed(message, line_start, description.str(), error);
480}
481
482static bool AddLine(const std::string& line, std::string* message) {
483 if (!message)
484 return false;
485
486 message->append(line);
487 message->append(kLineBreak);
488 return true;
489}
490
491static bool GetLine(const std::string& message,
492 size_t* pos,
493 std::string* line) {
494 size_t line_begin = *pos;
495 size_t line_end = message.find(kNewLine, line_begin);
496 if (line_end == std::string::npos) {
497 return false;
498 }
499 // Update the new start position
500 *pos = line_end + 1;
Jonas Olssonec9e4922018-09-05 07:53:49501 if (line_end > 0 && (message.at(line_end - 1) == kReturnChar)) {
henrike@webrtc.org28e20752013-07-10 00:45:36502 --line_end;
503 }
504 *line = message.substr(line_begin, (line_end - line_begin));
505 const char* cline = line->c_str();
506 // RFC 4566
507 // An SDP session description consists of a number of lines of text of
508 // the form:
509 // <type>=<value>
510 // where <type> MUST be exactly one case-significant character and
511 // <value> is structured text whose format depends on <type>.
512 // Whitespace MUST NOT be used on either side of the "=" sign.
Taylor Brandstetter93a7b242018-04-16 17:45:24513 //
514 // However, an exception to the whitespace rule is made for "s=", since
515 // RFC4566 also says:
516 //
517 // If a session has no meaningful name, the value "s= " SHOULD be used
518 // (i.e., a single space as the session name).
519 if (line->length() < 3 || !islower(cline[0]) ||
Jonas Olssonec9e4922018-09-05 07:53:49520 cline[1] != kSdpDelimiterEqualChar ||
521 (cline[0] != kLineTypeSessionName &&
522 cline[2] == kSdpDelimiterSpaceChar)) {
henrike@webrtc.org28e20752013-07-10 00:45:36523 *pos = line_begin;
524 return false;
525 }
526 return true;
527}
528
529// Init |os| to "|type|=|value|".
530static void InitLine(const char type,
531 const std::string& value,
Jonas Olssonec9e4922018-09-05 07:53:49532 rtc::StringBuilder* os) {
533 os->Clear();
534 *os << std::string(1, type) << kSdpDelimiterEqual << value;
henrike@webrtc.org28e20752013-07-10 00:45:36535}
536
537// Init |os| to "a=|attribute|".
Jonas Olssonec9e4922018-09-05 07:53:49538static void InitAttrLine(const std::string& attribute, rtc::StringBuilder* os) {
henrike@webrtc.org28e20752013-07-10 00:45:36539 InitLine(kLineTypeAttributes, attribute, os);
540}
541
Piotr (Peter) Slatalab1ae10b2019-03-01 19:14:05542// Writes an x-mt SDP attribute line based on the media transport settings.
543static void AddMediaTransportLine(
544 const cricket::SessionDescription::MediaTransportSetting& setting,
545 std::string* message) {
546 rtc::StringBuilder os;
547 InitAttrLine(kMediaTransportSettingLine, &os);
548 os << kSdpDelimiterColon << setting.transport_name << kSdpDelimiterColon
549 << rtc::Base64::Encode(setting.transport_setting);
550 AddLine(os.str(), message);
551}
552
Bjorn A Mellemc85ebbe2019-06-07 17:28:06553// Adds an x-otp SDP attribute line based on opaque transport parameters.
554static void AddOpaqueTransportLine(
555 const cricket::OpaqueTransportParameters params,
556 std::string* message) {
557 rtc::StringBuilder os;
558 InitAttrLine(kOpaqueTransportParametersLine, &os);
559 os << kSdpDelimiterColon << params.protocol << kSdpDelimiterColon
560 << rtc::Base64::Encode(params.parameters);
561 AddLine(os.str(), message);
562}
563
henrike@webrtc.org28e20752013-07-10 00:45:36564// Writes a SDP attribute line based on |attribute| and |value| to |message|.
Yves Gerey665174f2018-06-19 13:03:05565static void AddAttributeLine(const std::string& attribute,
566 int value,
henrike@webrtc.org28e20752013-07-10 00:45:36567 std::string* message) {
Jonas Olssonec9e4922018-09-05 07:53:49568 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:36569 InitAttrLine(attribute, &os);
570 os << kSdpDelimiterColon << value;
571 AddLine(os.str(), message);
572}
573
henrike@webrtc.org28e20752013-07-10 00:45:36574static bool IsLineType(const std::string& message,
575 const char type,
576 size_t line_start) {
577 if (message.size() < line_start + kLinePrefixLength) {
578 return false;
579 }
580 const char* cmessage = message.c_str();
581 return (cmessage[line_start] == type &&
Jonas Olssonec9e4922018-09-05 07:53:49582 cmessage[line_start + 1] == kSdpDelimiterEqualChar);
henrike@webrtc.org28e20752013-07-10 00:45:36583}
584
Yves Gerey665174f2018-06-19 13:03:05585static bool IsLineType(const std::string& line, const char type) {
henrike@webrtc.org28e20752013-07-10 00:45:36586 return IsLineType(line, type, 0);
587}
588
Yves Gerey665174f2018-06-19 13:03:05589static bool GetLineWithType(const std::string& message,
590 size_t* pos,
591 std::string* line,
592 const char type) {
henrike@webrtc.org28e20752013-07-10 00:45:36593 if (!IsLineType(message, type, *pos)) {
594 return false;
595 }
596
597 if (!GetLine(message, pos, line))
598 return false;
599
600 return true;
601}
602
603static bool HasAttribute(const std::string& line,
604 const std::string& attribute) {
Johannes Kron211856b2018-09-06 10:12:28605 if (line.compare(kLinePrefixLength, attribute.size(), attribute) == 0) {
606 // Make sure that the match is not only a partial match. If length of
607 // strings doesn't match, the next character of the line must be ':' or ' '.
608 // This function is also used for media descriptions (e.g., "m=audio 9..."),
609 // hence the need to also allow space in the end.
610 RTC_CHECK_LE(kLinePrefixLength + attribute.size(), line.size());
611 if ((kLinePrefixLength + attribute.size()) == line.size() ||
612 line[kLinePrefixLength + attribute.size()] == kSdpDelimiterColonChar ||
613 line[kLinePrefixLength + attribute.size()] == kSdpDelimiterSpaceChar) {
614 return true;
615 }
616 }
617 return false;
henrike@webrtc.org28e20752013-07-10 00:45:36618}
619
Peter Boström0c4e06b2015-10-07 10:23:21620static bool AddSsrcLine(uint32_t ssrc_id,
621 const std::string& attribute,
622 const std::string& value,
623 std::string* message) {
henrike@webrtc.org28e20752013-07-10 00:45:36624 // RFC 5576
625 // a=ssrc:<ssrc-id> <attribute>:<value>
Jonas Olssonec9e4922018-09-05 07:53:49626 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:36627 InitAttrLine(kAttributeSsrc, &os);
Yves Gerey665174f2018-06-19 13:03:05628 os << kSdpDelimiterColon << ssrc_id << kSdpDelimiterSpace << attribute
629 << kSdpDelimiterColon << value;
henrike@webrtc.org28e20752013-07-10 00:45:36630 return AddLine(os.str(), message);
631}
632
henrike@webrtc.org28e20752013-07-10 00:45:36633// Get value only from <attribute>:<value>.
Yves Gerey665174f2018-06-19 13:03:05634static bool GetValue(const std::string& message,
635 const std::string& attribute,
636 std::string* value,
637 SdpParseError* error) {
henrike@webrtc.org28e20752013-07-10 00:45:36638 std::string leftpart;
Jonas Olssonec9e4922018-09-05 07:53:49639 if (!rtc::tokenize_first(message, kSdpDelimiterColonChar, &leftpart, value)) {
henrike@webrtc.org28e20752013-07-10 00:45:36640 return ParseFailedGetValue(message, attribute, error);
641 }
642 // The left part should end with the expected attribute.
643 if (leftpart.length() < attribute.length() ||
644 leftpart.compare(leftpart.length() - attribute.length(),
645 attribute.length(), attribute) != 0) {
646 return ParseFailedGetValue(message, attribute, error);
647 }
648 return true;
649}
650
651static bool CaseInsensitiveFind(std::string str1, std::string str2) {
Steve Anton64b626b2019-01-29 01:25:26652 absl::c_transform(str1, str1.begin(), ::tolower);
653 absl::c_transform(str2, str2.begin(), ::tolower);
henrike@webrtc.org28e20752013-07-10 00:45:36654 return str1.find(str2) != std::string::npos;
655}
656
wu@webrtc.org5e760e72014-04-02 23:19:09657template <class T>
658static bool GetValueFromString(const std::string& line,
659 const std::string& s,
660 T* t,
661 SdpParseError* error) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52662 if (!rtc::FromString(s, t)) {
Jonas Olssonec9e4922018-09-05 07:53:49663 rtc::StringBuilder description;
wu@webrtc.org5e760e72014-04-02 23:19:09664 description << "Invalid value: " << s << ".";
665 return ParseFailed(line, description.str(), error);
666 }
667 return true;
668}
669
pkasting@chromium.orge9facf82015-02-17 20:36:28670static bool GetPayloadTypeFromString(const std::string& line,
671 const std::string& s,
672 int* payload_type,
673 SdpParseError* error) {
674 return GetValueFromString(line, s, payload_type, error) &&
Yves Gerey665174f2018-06-19 13:03:05675 cricket::IsValidRtpPayloadType(*payload_type);
pkasting@chromium.orge9facf82015-02-17 20:36:28676}
677
Seth Hampson5897a6e2018-04-03 18:16:33678// Creates a StreamParams track in the case when no SSRC lines are signaled.
679// This is a track that does not contain SSRCs and only contains
680// stream_ids/track_id if it's signaled with a=msid lines.
681void CreateTrackWithNoSsrcs(const std::vector<std::string>& msid_stream_ids,
682 const std::string& msid_track_id,
Amit Hilbuchc57d5732018-12-11 23:30:11683 const std::vector<RidDescription>& rids,
Seth Hampson5897a6e2018-04-03 18:16:33684 StreamParamsVec* tracks) {
685 StreamParams track;
Amit Hilbuch6df49d82019-04-15 22:47:21686 if (msid_track_id.empty() && rids.empty()) {
Seth Hampson5897a6e2018-04-03 18:16:33687 // We only create an unsignaled track if a=msid lines were signaled.
Amit Hilbuch6df49d82019-04-15 22:47:21688 RTC_LOG(LS_INFO) << "MSID not signaled, skipping creation of StreamParams";
Seth Hampson5897a6e2018-04-03 18:16:33689 return;
690 }
691 track.set_stream_ids(msid_stream_ids);
692 track.id = msid_track_id;
Amit Hilbuchc57d5732018-12-11 23:30:11693 track.set_rids(rids);
Seth Hampson5897a6e2018-04-03 18:16:33694 tracks->push_back(track);
695}
696
697// Creates the StreamParams tracks, for the case when SSRC lines are signaled.
698// |msid_stream_ids| and |msid_track_id| represent the stream/track ID from the
Taylor Brandstetter5de6b752016-03-10 01:02:30699// "a=msid" attribute, if it exists. They are empty if the attribute does not
Seth Hampson5897a6e2018-04-03 18:16:33700// exist. We prioritize getting stream_ids/track_ids signaled in a=msid lines.
henrike@webrtc.org28e20752013-07-10 00:45:36701void CreateTracksFromSsrcInfos(const SsrcInfoVec& ssrc_infos,
Seth Hampson5b4f0752018-04-02 23:31:36702 const std::vector<std::string>& msid_stream_ids,
Taylor Brandstetter5de6b752016-03-10 01:02:30703 const std::string& msid_track_id,
Seth Hampson5b4f0752018-04-02 23:31:36704 StreamParamsVec* tracks,
705 int msid_signaling) {
nisseede5da42017-01-12 13:15:36706 RTC_DCHECK(tracks != NULL);
Steve Anton4daf66e2018-09-07 21:55:53707 for (const SsrcInfo& ssrc_info : ssrc_infos) {
708 if (ssrc_info.cname.empty()) {
henrike@webrtc.org28e20752013-07-10 00:45:36709 continue;
710 }
711
Seth Hampson5b4f0752018-04-02 23:31:36712 std::vector<std::string> stream_ids;
henrike@webrtc.org28e20752013-07-10 00:45:36713 std::string track_id;
Seth Hampson5b4f0752018-04-02 23:31:36714 if (msid_signaling & cricket::kMsidSignalingMediaSection) {
715 // This is the case with Unified Plan SDP msid signaling.
716 stream_ids = msid_stream_ids;
Tomas Gunnarsson191bf5c2018-03-30 10:44:43717 track_id = msid_track_id;
Seth Hampson5b4f0752018-04-02 23:31:36718 } else if (msid_signaling & cricket::kMsidSignalingSsrcAttribute) {
719 // This is the case with Plan B SDP msid signaling.
Steve Anton4daf66e2018-09-07 21:55:53720 stream_ids.push_back(ssrc_info.stream_id);
721 track_id = ssrc_info.track_id;
722 } else if (!ssrc_info.mslabel.empty()) {
Seth Hampson5b4f0752018-04-02 23:31:36723 // Since there's no a=msid or a=ssrc msid signaling, this is a sdp from
724 // an older version of client that doesn't support msid.
725 // In that case, we use the mslabel and label to construct the track.
Steve Anton4daf66e2018-09-07 21:55:53726 stream_ids.push_back(ssrc_info.mslabel);
727 track_id = ssrc_info.label;
Seth Hampson5b4f0752018-04-02 23:31:36728 } else {
729 // Since no media streams isn't supported with older SDP signaling, we
730 // use a default a stream id.
731 stream_ids.push_back(kDefaultMsid);
henrike@webrtc.org28e20752013-07-10 00:45:36732 }
Seth Hampson5b4f0752018-04-02 23:31:36733 // If a track ID wasn't populated from the SSRC attributes OR the
Taylor Brandstetter5de6b752016-03-10 01:02:30734 // msid attribute, use default/random values.
Taylor Brandstetter5de6b752016-03-10 01:02:30735 if (track_id.empty()) {
736 // TODO(ronghuawu): What should we do if the track id doesn't appear?
737 // Create random string (which will be used as track label later)?
738 track_id = rtc::CreateRandomString(8);
henrike@webrtc.org28e20752013-07-10 00:45:36739 }
740
Steve Anton64b626b2019-01-29 01:25:26741 auto track_it = absl::c_find_if(
742 *tracks,
Steve Anton4daf66e2018-09-07 21:55:53743 [track_id](const StreamParams& track) { return track.id == track_id; });
744 if (track_it == tracks->end()) {
henrike@webrtc.org28e20752013-07-10 00:45:36745 // If we don't find an existing track, create a new one.
746 tracks->push_back(StreamParams());
Steve Anton4daf66e2018-09-07 21:55:53747 track_it = tracks->end() - 1;
henrike@webrtc.org28e20752013-07-10 00:45:36748 }
Steve Anton4daf66e2018-09-07 21:55:53749 StreamParams& track = *track_it;
750 track.add_ssrc(ssrc_info.ssrc_id);
751 track.cname = ssrc_info.cname;
752 track.set_stream_ids(stream_ids);
753 track.id = track_id;
henrike@webrtc.org28e20752013-07-10 00:45:36754 }
755}
756
Seth Hampson845e8782018-03-02 19:34:10757void GetMediaStreamIds(const ContentInfo* content,
758 std::set<std::string>* labels) {
Steve Antonb1c1de12017-12-21 23:14:30759 for (const StreamParams& stream_params :
760 content->media_description()->streams()) {
Seth Hampson845e8782018-03-02 19:34:10761 for (const std::string& stream_id : stream_params.stream_ids()) {
762 labels->insert(stream_id);
Steve Anton5a26a3a2018-02-28 19:38:47763 }
henrike@webrtc.org28e20752013-07-10 00:45:36764 }
765}
766
767// RFC 5245
768// It is RECOMMENDED that default candidates be chosen based on the
769// likelihood of those candidates to work with the peer that is being
770// contacted. It is RECOMMENDED that relayed > reflexive > host.
771static const int kPreferenceUnknown = 0;
772static const int kPreferenceHost = 1;
773static const int kPreferenceReflexive = 2;
774static const int kPreferenceRelayed = 3;
775
776static int GetCandidatePreferenceFromType(const std::string& type) {
777 int preference = kPreferenceUnknown;
778 if (type == cricket::LOCAL_PORT_TYPE) {
779 preference = kPreferenceHost;
780 } else if (type == cricket::STUN_PORT_TYPE) {
781 preference = kPreferenceReflexive;
782 } else if (type == cricket::RELAY_PORT_TYPE) {
783 preference = kPreferenceRelayed;
784 } else {
nissec80e7412017-01-11 13:56:46785 RTC_NOTREACHED();
henrike@webrtc.org28e20752013-07-10 00:45:36786 }
787 return preference;
788}
789
guoweis@webrtc.org57ac2c82015-02-06 00:45:13790// Get ip and port of the default destination from the |candidates| with the
791// given value of |component_id|. The default candidate should be the one most
792// likely to work, typically IPv4 relay.
henrike@webrtc.org28e20752013-07-10 00:45:36793// RFC 5245
794// The value of |component_id| currently supported are 1 (RTP) and 2 (RTCP).
Steve Anton36b29d12017-10-30 16:57:42795// TODO(deadbeef): Decide the default destination in webrtcsession and
henrike@webrtc.org28e20752013-07-10 00:45:36796// pass it down via SessionDescription.
Yves Gerey665174f2018-06-19 13:03:05797static void GetDefaultDestination(const std::vector<Candidate>& candidates,
798 int component_id,
799 std::string* port,
800 std::string* ip,
801 std::string* addr_type) {
perkj@webrtc.orgd105cc82014-11-07 11:22:06802 *addr_type = kConnectionIpv4Addrtype;
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22803 *port = kDummyPort;
804 *ip = kDummyAddress;
henrike@webrtc.org28e20752013-07-10 00:45:36805 int current_preference = kPreferenceUnknown;
guoweis@webrtc.org57ac2c82015-02-06 00:45:13806 int current_family = AF_UNSPEC;
Steve Anton4daf66e2018-09-07 21:55:53807 for (const Candidate& candidate : candidates) {
808 if (candidate.component() != component_id) {
henrike@webrtc.org28e20752013-07-10 00:45:36809 continue;
810 }
guoweis@webrtc.org57ac2c82015-02-06 00:45:13811 // Default destination should be UDP only.
Steve Anton4daf66e2018-09-07 21:55:53812 if (candidate.protocol() != cricket::UDP_PROTOCOL_NAME) {
henrike@webrtc.org28e20752013-07-10 00:45:36813 continue;
814 }
Steve Anton4daf66e2018-09-07 21:55:53815 const int preference = GetCandidatePreferenceFromType(candidate.type());
816 const int family = candidate.address().ipaddr().family();
guoweis@webrtc.org57ac2c82015-02-06 00:45:13817 // See if this candidate is more preferable then the current one if it's the
818 // same family. Or if the current family is IPv4 already so we could safely
819 // ignore all IPv6 ones. WebRTC bug 4269.
820 // http://code.google.com/p/webrtc/issues/detail?id=4269
821 if ((preference <= current_preference && current_family == family) ||
822 (current_family == AF_INET && family == AF_INET6)) {
823 continue;
824 }
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22825 if (family == AF_INET) {
826 addr_type->assign(kConnectionIpv4Addrtype);
827 } else if (family == AF_INET6) {
828 addr_type->assign(kConnectionIpv6Addrtype);
829 }
guoweis@webrtc.org57ac2c82015-02-06 00:45:13830 current_preference = preference;
831 current_family = family;
Steve Anton4daf66e2018-09-07 21:55:53832 *port = candidate.address().PortAsString();
833 *ip = candidate.address().ipaddr().ToString();
henrike@webrtc.org28e20752013-07-10 00:45:36834 }
henrike@webrtc.org28e20752013-07-10 00:45:36835}
836
wu@webrtc.org4c3e9912014-07-16 21:03:13837// Gets "a=rtcp" line if found default RTCP candidate from |candidates|.
838static std::string GetRtcpLine(const std::vector<Candidate>& candidates) {
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22839 std::string rtcp_line, rtcp_port, rtcp_ip, addr_type;
Yves Gerey665174f2018-06-19 13:03:05840 GetDefaultDestination(candidates, ICE_CANDIDATE_COMPONENT_RTCP, &rtcp_port,
841 &rtcp_ip, &addr_type);
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22842 // Found default RTCP candidate.
843 // RFC 5245
844 // If the agent is utilizing RTCP, it MUST encode the RTCP candidate
845 // using the a=rtcp attribute as defined in RFC 3605.
henrike@webrtc.org28e20752013-07-10 00:45:36846
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22847 // RFC 3605
848 // rtcp-attribute = "a=rtcp:" port [nettype space addrtype space
849 // connection-address] CRLF
Jonas Olssonec9e4922018-09-05 07:53:49850 rtc::StringBuilder os;
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22851 InitAttrLine(kAttributeRtcp, &os);
Yves Gerey665174f2018-06-19 13:03:05852 os << kSdpDelimiterColon << rtcp_port << " " << kConnectionNettype << " "
853 << addr_type << " " << rtcp_ip;
pthatcher@webrtc.orgc9d6d142014-10-23 23:37:22854 rtcp_line = os.str();
wu@webrtc.org4c3e9912014-07-16 21:03:13855 return rtcp_line;
henrike@webrtc.org28e20752013-07-10 00:45:36856}
857
858// Get candidates according to the mline index from SessionDescriptionInterface.
859static void GetCandidatesByMindex(const SessionDescriptionInterface& desci,
860 int mline_index,
861 std::vector<Candidate>* candidates) {
862 if (!candidates) {
863 return;
864 }
865 const IceCandidateCollection* cc = desci.candidates(mline_index);
866 for (size_t i = 0; i < cc->count(); ++i) {
867 const IceCandidateInterface* candidate = cc->at(i);
868 candidates->push_back(candidate->candidate());
869 }
870}
871
deadbeef90f1e1e2017-02-10 20:35:05872static bool IsValidPort(int port) {
873 return port >= 0 && port <= 65535;
874}
875
Steve Antone831b8c2018-02-01 20:22:16876std::string SdpSerialize(const JsepSessionDescription& jdesc) {
henrike@webrtc.org28e20752013-07-10 00:45:36877 const cricket::SessionDescription* desc = jdesc.description();
878 if (!desc) {
879 return "";
880 }
881
882 std::string message;
883
884 // Session Description.
885 AddLine(kSessionVersion, &message);
886 // Session Origin
887 // RFC 4566
888 // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
889 // <unicast-address>
Jonas Olssonec9e4922018-09-05 07:53:49890 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:36891 InitLine(kLineTypeOrigin, kSessionOriginUsername, &os);
Yves Gerey665174f2018-06-19 13:03:05892 const std::string& session_id =
893 jdesc.session_id().empty() ? kSessionOriginSessionId : jdesc.session_id();
894 const std::string& session_version = jdesc.session_version().empty()
895 ? kSessionOriginSessionVersion
896 : jdesc.session_version();
henrike@webrtc.org28e20752013-07-10 00:45:36897 os << " " << session_id << " " << session_version << " "
898 << kSessionOriginNettype << " " << kSessionOriginAddrtype << " "
899 << kSessionOriginAddress;
900 AddLine(os.str(), &message);
901 AddLine(kSessionName, &message);
902
903 // Time Description.
904 AddLine(kTimeDescription, &message);
905
Piotr (Peter) Slatalab1ae10b2019-03-01 19:14:05906 for (const cricket::SessionDescription::MediaTransportSetting& settings :
907 desc->MediaTransportSettings()) {
908 AddMediaTransportLine(settings, &message);
909 }
910
henrike@webrtc.org28e20752013-07-10 00:45:36911 // Group
912 if (desc->HasGroup(cricket::GROUP_TYPE_BUNDLE)) {
913 std::string group_line = kAttrGroup;
914 const cricket::ContentGroup* group =
915 desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
nisseede5da42017-01-12 13:15:36916 RTC_DCHECK(group != NULL);
Steve Anton4daf66e2018-09-07 21:55:53917 for (const std::string& content_name : group->content_names()) {
henrike@webrtc.org28e20752013-07-10 00:45:36918 group_line.append(" ");
Steve Anton4daf66e2018-09-07 21:55:53919 group_line.append(content_name);
henrike@webrtc.org28e20752013-07-10 00:45:36920 }
921 AddLine(group_line, &message);
922 }
923
Johannes Kron0854eb62018-10-10 20:33:20924 // Mixed one- and two-byte header extension.
Johannes Kron9581bc42018-10-23 08:17:39925 if (desc->extmap_allow_mixed()) {
Johannes Kron0854eb62018-10-10 20:33:20926 InitAttrLine(kAttributeExtmapAllowMixed, &os);
927 AddLine(os.str(), &message);
928 }
929
henrike@webrtc.org28e20752013-07-10 00:45:36930 // MediaStream semantics
931 InitAttrLine(kAttributeMsidSemantics, &os);
932 os << kSdpDelimiterColon << " " << kMediaStreamSemantic;
wu@webrtc.org4c3e9912014-07-16 21:03:13933
Seth Hampson845e8782018-03-02 19:34:10934 std::set<std::string> media_stream_ids;
henrike@webrtc.org28e20752013-07-10 00:45:36935 const ContentInfo* audio_content = GetFirstAudioContent(desc);
936 if (audio_content)
Seth Hampson845e8782018-03-02 19:34:10937 GetMediaStreamIds(audio_content, &media_stream_ids);
wu@webrtc.org4c3e9912014-07-16 21:03:13938
henrike@webrtc.org28e20752013-07-10 00:45:36939 const ContentInfo* video_content = GetFirstVideoContent(desc);
940 if (video_content)
Seth Hampson845e8782018-03-02 19:34:10941 GetMediaStreamIds(video_content, &media_stream_ids);
wu@webrtc.org4c3e9912014-07-16 21:03:13942
Steve Anton4daf66e2018-09-07 21:55:53943 for (const std::string& id : media_stream_ids) {
944 os << " " << id;
henrike@webrtc.org28e20752013-07-10 00:45:36945 }
946 AddLine(os.str(), &message);
947
Taylor Brandstetter2f65ec52018-05-24 18:37:28948 // a=ice-lite
949 //
950 // TODO(deadbeef): It's weird that we need to iterate TransportInfos for
951 // this, when it's a session-level attribute. It really should be moved to a
952 // session-level structure like SessionDescription.
953 for (const cricket::TransportInfo& transport : desc->transport_infos()) {
954 if (transport.description.ice_mode == cricket::ICEMODE_LITE) {
955 InitAttrLine(kAttributeIceLite, &os);
956 AddLine(os.str(), &message);
957 break;
958 }
959 }
960
wu@webrtc.org4c3e9912014-07-16 21:03:13961 // Preserve the order of the media contents.
962 int mline_index = -1;
Steve Anton4daf66e2018-09-07 21:55:53963 for (const ContentInfo& content : desc->contents()) {
wu@webrtc.org4c3e9912014-07-16 21:03:13964 std::vector<Candidate> candidates;
965 GetCandidatesByMindex(jdesc, ++mline_index, &candidates);
Steve Anton4daf66e2018-09-07 21:55:53966 BuildMediaDescription(&content, desc->GetTransportInfoByName(content.name),
967 content.media_description()->type(), candidates,
968 desc->msid_signaling(), &message);
henrike@webrtc.org28e20752013-07-10 00:45:36969 }
henrike@webrtc.org28e20752013-07-10 00:45:36970 return message;
971}
972
973// Serializes the passed in IceCandidateInterface to a SDP string.
974// candidate - The candidate to be serialized.
Honghai Zhang7fb69db2016-03-14 18:59:18975std::string SdpSerializeCandidate(const IceCandidateInterface& candidate) {
976 return SdpSerializeCandidate(candidate.candidate());
977}
978
979// Serializes a cricket Candidate.
980std::string SdpSerializeCandidate(const cricket::Candidate& candidate) {
henrike@webrtc.org28e20752013-07-10 00:45:36981 std::string message;
Honghai Zhang7fb69db2016-03-14 18:59:18982 std::vector<cricket::Candidate> candidates(1, candidate);
honghaiza54a0802015-12-17 02:37:23983 BuildCandidate(candidates, true, &message);
wu@webrtc.orgec9f5fb2014-06-24 17:05:10984 // From WebRTC draft section 4.8.1.1 candidate-attribute will be
985 // just candidate:<candidate> not a=candidate:<blah>CRLF
nisseede5da42017-01-12 13:15:36986 RTC_DCHECK(message.find("a=") == 0);
wu@webrtc.orgec9f5fb2014-06-24 17:05:10987 message.erase(0, 2);
nisseede5da42017-01-12 13:15:36988 RTC_DCHECK(message.find(kLineBreak) == message.size() - 2);
wu@webrtc.orgec9f5fb2014-06-24 17:05:10989 message.resize(message.size() - 2);
henrike@webrtc.org28e20752013-07-10 00:45:36990 return message;
991}
992
993bool SdpDeserialize(const std::string& message,
994 JsepSessionDescription* jdesc,
995 SdpParseError* error) {
996 std::string session_id;
997 std::string session_version;
Peter Thatcher7cbd1882015-09-18 01:54:52998 TransportDescription session_td("", "");
henrike@webrtc.org28e20752013-07-10 00:45:36999 RtpHeaderExtensions session_extmaps;
zhihuang38989e52017-03-21 18:04:531000 rtc::SocketAddress session_connection_addr;
Steve Anton5a1de872018-12-18 19:25:551001 auto desc = absl::make_unique<cricket::SessionDescription>();
henrike@webrtc.org28e20752013-07-10 00:45:361002 size_t current_pos = 0;
henrike@webrtc.org28e20752013-07-10 00:45:361003
1004 // Session Description
1005 if (!ParseSessionDescription(message, &current_pos, &session_id,
deadbeefc80741f2015-10-22 20:14:451006 &session_version, &session_td, &session_extmaps,
Steve Anton5a1de872018-12-18 19:25:551007 &session_connection_addr, desc.get(), error)) {
henrike@webrtc.org28e20752013-07-10 00:45:361008 return false;
1009 }
1010
1011 // Media Description
Steve Anton5a1de872018-12-18 19:25:551012 std::vector<std::unique_ptr<JsepIceCandidate>> candidates;
deadbeefc80741f2015-10-22 20:14:451013 if (!ParseMediaDescription(message, session_td, session_extmaps, &current_pos,
Steve Anton5a1de872018-12-18 19:25:551014 session_connection_addr, desc.get(), &candidates,
zhihuang38989e52017-03-21 18:04:531015 error)) {
henrike@webrtc.org28e20752013-07-10 00:45:361016 return false;
1017 }
1018
Harald Alvestrand4d7160e2019-04-12 05:01:291019 jdesc->Initialize(std::move(desc), session_id, session_version);
henrike@webrtc.org28e20752013-07-10 00:45:361020
Steve Anton5a1de872018-12-18 19:25:551021 for (const auto& candidate : candidates) {
1022 jdesc->AddCandidate(candidate.get());
henrike@webrtc.org28e20752013-07-10 00:45:361023 }
1024 return true;
1025}
1026
1027bool SdpDeserializeCandidate(const std::string& message,
1028 JsepIceCandidate* jcandidate,
1029 SdpParseError* error) {
nisseede5da42017-01-12 13:15:361030 RTC_DCHECK(jcandidate != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:361031 Candidate candidate;
1032 if (!ParseCandidate(message, &candidate, error, true)) {
1033 return false;
1034 }
1035 jcandidate->SetCandidate(candidate);
1036 return true;
1037}
1038
Honghai Zhang7fb69db2016-03-14 18:59:181039bool SdpDeserializeCandidate(const std::string& transport_name,
1040 const std::string& message,
1041 cricket::Candidate* candidate,
1042 SdpParseError* error) {
nisseede5da42017-01-12 13:15:361043 RTC_DCHECK(candidate != nullptr);
Honghai Zhang7fb69db2016-03-14 18:59:181044 if (!ParseCandidate(message, candidate, error, true)) {
1045 return false;
1046 }
1047 candidate->set_transport_name(transport_name);
1048 return true;
1049}
1050
Yves Gerey665174f2018-06-19 13:03:051051bool ParseCandidate(const std::string& message,
1052 Candidate* candidate,
1053 SdpParseError* error,
1054 bool is_raw) {
nisseede5da42017-01-12 13:15:361055 RTC_DCHECK(candidate != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:361056
1057 // Get the first line from |message|.
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151058 std::string first_line = message;
1059 size_t pos = 0;
1060 GetLine(message, &pos, &first_line);
henrike@webrtc.org28e20752013-07-10 00:45:361061
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151062 // Makes sure |message| contains only one line.
1063 if (message.size() > first_line.size()) {
1064 std::string left, right;
Jonas Olssonec9e4922018-09-05 07:53:491065 if (rtc::tokenize_first(message, kNewLineChar, &left, &right) &&
Donald Curtis0e07f922015-05-15 16:21:231066 !right.empty()) {
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151067 return ParseFailed(message, 0, "Expect one line only", error);
1068 }
1069 }
1070
1071 // From WebRTC draft section 4.8.1.1 candidate-attribute should be
1072 // candidate:<candidate> when trickled, but we still support
1073 // a=candidate:<blah>CRLF for backward compatibility and for parsing a line
1074 // from the SDP.
1075 if (IsLineType(first_line, kLineTypeAttributes)) {
1076 first_line = first_line.substr(kLinePrefixLength);
1077 }
1078
1079 std::string attribute_candidate;
1080 std::string candidate_value;
1081
1082 // |first_line| must be in the form of "candidate:<value>".
Jonas Olssonec9e4922018-09-05 07:53:491083 if (!rtc::tokenize_first(first_line, kSdpDelimiterColonChar,
1084 &attribute_candidate, &candidate_value) ||
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151085 attribute_candidate != kAttributeCandidate) {
henrike@webrtc.org28e20752013-07-10 00:45:361086 if (is_raw) {
Jonas Olssonec9e4922018-09-05 07:53:491087 rtc::StringBuilder description;
Yves Gerey665174f2018-06-19 13:03:051088 description << "Expect line: " << kAttributeCandidate << ":"
1089 << "<candidate-str>";
henrike@webrtc.org28e20752013-07-10 00:45:361090 return ParseFailed(first_line, 0, description.str(), error);
1091 } else {
1092 return ParseFailedExpectLine(first_line, 0, kLineTypeAttributes,
1093 kAttributeCandidate, error);
1094 }
1095 }
1096
1097 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:491098 rtc::split(candidate_value, kSdpDelimiterSpaceChar, &fields);
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151099
henrike@webrtc.org28e20752013-07-10 00:45:361100 // RFC 5245
1101 // a=candidate:<foundation> <component-id> <transport> <priority>
1102 // <connection-address> <port> typ <candidate-types>
1103 // [raddr <connection-address>] [rport <port>]
1104 // *(SP extension-att-name SP extension-att-value)
1105 const size_t expected_min_fields = 8;
1106 if (fields.size() < expected_min_fields ||
1107 (fields[6] != kAttributeCandidateTyp)) {
1108 return ParseFailedExpectMinFieldNum(first_line, expected_min_fields, error);
1109 }
jbauch083b73f2015-07-16 09:46:321110 const std::string& foundation = fields[0];
jiayl@webrtc.org7ec3f9f2014-08-08 23:09:151111
wu@webrtc.org5e760e72014-04-02 23:19:091112 int component_id = 0;
1113 if (!GetValueFromString(first_line, fields[1], &component_id, error)) {
1114 return false;
1115 }
jbauch083b73f2015-07-16 09:46:321116 const std::string& transport = fields[2];
Peter Boström0c4e06b2015-10-07 10:23:211117 uint32_t priority = 0;
wu@webrtc.org5e760e72014-04-02 23:19:091118 if (!GetValueFromString(first_line, fields[3], &priority, error)) {
1119 return false;
1120 }
jbauch083b73f2015-07-16 09:46:321121 const std::string& connection_address = fields[4];
wu@webrtc.org5e760e72014-04-02 23:19:091122 int port = 0;
1123 if (!GetValueFromString(first_line, fields[5], &port, error)) {
1124 return false;
1125 }
deadbeef90f1e1e2017-02-10 20:35:051126 if (!IsValidPort(port)) {
1127 return ParseFailed(first_line, "Invalid port number.", error);
1128 }
henrike@webrtc.org28e20752013-07-10 00:45:361129 SocketAddress address(connection_address, port);
1130
1131 cricket::ProtocolType protocol;
hnslb68cc752016-12-13 18:33:411132 if (!StringToProto(transport.c_str(), &protocol)) {
henrike@webrtc.org28e20752013-07-10 00:45:361133 return ParseFailed(first_line, "Unsupported transport type.", error);
1134 }
hnslb68cc752016-12-13 18:33:411135 switch (protocol) {
1136 case cricket::PROTO_UDP:
1137 case cricket::PROTO_TCP:
1138 case cricket::PROTO_SSLTCP:
1139 // Supported protocol.
1140 break;
1141 default:
1142 return ParseFailed(first_line, "Unsupported transport type.", error);
1143 }
henrike@webrtc.org28e20752013-07-10 00:45:361144
1145 std::string candidate_type;
jbauch083b73f2015-07-16 09:46:321146 const std::string& type = fields[7];
henrike@webrtc.org28e20752013-07-10 00:45:361147 if (type == kCandidateHost) {
1148 candidate_type = cricket::LOCAL_PORT_TYPE;
1149 } else if (type == kCandidateSrflx) {
1150 candidate_type = cricket::STUN_PORT_TYPE;
1151 } else if (type == kCandidateRelay) {
1152 candidate_type = cricket::RELAY_PORT_TYPE;
Honghai Zhang7fb69db2016-03-14 18:59:181153 } else if (type == kCandidatePrflx) {
1154 candidate_type = cricket::PRFLX_PORT_TYPE;
henrike@webrtc.org28e20752013-07-10 00:45:361155 } else {
1156 return ParseFailed(first_line, "Unsupported candidate type.", error);
1157 }
1158
1159 size_t current_position = expected_min_fields;
1160 SocketAddress related_address;
1161 // The 2 optional fields for related address
1162 // [raddr <connection-address>] [rport <port>]
1163 if (fields.size() >= (current_position + 2) &&
1164 fields[current_position] == kAttributeCandidateRaddr) {
1165 related_address.SetIP(fields[++current_position]);
1166 ++current_position;
1167 }
1168 if (fields.size() >= (current_position + 2) &&
1169 fields[current_position] == kAttributeCandidateRport) {
wu@webrtc.org5e760e72014-04-02 23:19:091170 int port = 0;
Yves Gerey665174f2018-06-19 13:03:051171 if (!GetValueFromString(first_line, fields[++current_position], &port,
1172 error)) {
wu@webrtc.org5e760e72014-04-02 23:19:091173 return false;
1174 }
deadbeef90f1e1e2017-02-10 20:35:051175 if (!IsValidPort(port)) {
1176 return ParseFailed(first_line, "Invalid port number.", error);
1177 }
wu@webrtc.org5e760e72014-04-02 23:19:091178 related_address.SetPort(port);
henrike@webrtc.org28e20752013-07-10 00:45:361179 ++current_position;
1180 }
1181
mallinath@webrtc.org2d60c5e2014-08-08 22:29:201182 // If this is a TCP candidate, it has additional extension as defined in
1183 // RFC 6544.
1184 std::string tcptype;
1185 if (fields.size() >= (current_position + 2) &&
1186 fields[current_position] == kTcpCandidateType) {
1187 tcptype = fields[++current_position];
1188 ++current_position;
1189
1190 if (tcptype != cricket::TCPTYPE_ACTIVE_STR &&
1191 tcptype != cricket::TCPTYPE_PASSIVE_STR &&
1192 tcptype != cricket::TCPTYPE_SIMOPEN_STR) {
1193 return ParseFailed(first_line, "Invalid TCP candidate type.", error);
1194 }
1195
1196 if (protocol != cricket::PROTO_TCP) {
1197 return ParseFailed(first_line, "Invalid non-TCP candidate", error);
1198 }
1199 }
1200
henrike@webrtc.org28e20752013-07-10 00:45:361201 // Extension
honghaiza54a0802015-12-17 02:37:231202 // Though non-standard, we support the ICE ufrag and pwd being signaled on
1203 // the candidate to avoid issues with confusing which generation a candidate
1204 // belongs to when trickling multiple generations at the same time.
henrike@webrtc.org28e20752013-07-10 00:45:361205 std::string username;
1206 std::string password;
Peter Boström0c4e06b2015-10-07 10:23:211207 uint32_t generation = 0;
honghaiza0c44ea2016-03-23 23:07:481208 uint16_t network_id = 0;
1209 uint16_t network_cost = 0;
henrike@webrtc.org28e20752013-07-10 00:45:361210 for (size_t i = current_position; i + 1 < fields.size(); ++i) {
1211 // RFC 5245
1212 // *(SP extension-att-name SP extension-att-value)
1213 if (fields[i] == kAttributeCandidateGeneration) {
wu@webrtc.org5e760e72014-04-02 23:19:091214 if (!GetValueFromString(first_line, fields[++i], &generation, error)) {
1215 return false;
1216 }
honghaiza54a0802015-12-17 02:37:231217 } else if (fields[i] == kAttributeCandidateUfrag) {
henrike@webrtc.org28e20752013-07-10 00:45:361218 username = fields[++i];
honghaiza54a0802015-12-17 02:37:231219 } else if (fields[i] == kAttributeCandidatePwd) {
henrike@webrtc.org28e20752013-07-10 00:45:361220 password = fields[++i];
honghaiza0c44ea2016-03-23 23:07:481221 } else if (fields[i] == kAttributeCandidateNetworkId) {
1222 if (!GetValueFromString(first_line, fields[++i], &network_id, error)) {
1223 return false;
1224 }
honghaize1a0c942016-02-16 22:54:561225 } else if (fields[i] == kAttributeCandidateNetworkCost) {
1226 if (!GetValueFromString(first_line, fields[++i], &network_cost, error)) {
1227 return false;
1228 }
Honghai Zhang351d77b2016-05-20 22:08:291229 network_cost = std::min(network_cost, rtc::kNetworkCostMax);
henrike@webrtc.org28e20752013-07-10 00:45:361230 } else {
1231 // Skip the unknown extension.
1232 ++i;
1233 }
1234 }
1235
guoweis@webrtc.org61c12472015-01-15 06:53:071236 *candidate = Candidate(component_id, cricket::ProtoToString(protocol),
guoweis@webrtc.org950c5182014-12-16 23:01:311237 address, priority, username, password, candidate_type,
honghaiza0c44ea2016-03-23 23:07:481238 generation, foundation, network_id, network_cost);
henrike@webrtc.org28e20752013-07-10 00:45:361239 candidate->set_related_address(related_address);
mallinath@webrtc.org2d60c5e2014-08-08 22:29:201240 candidate->set_tcptype(tcptype);
henrike@webrtc.org28e20752013-07-10 00:45:361241 return true;
1242}
1243
1244bool ParseIceOptions(const std::string& line,
1245 std::vector<std::string>* transport_options,
1246 SdpParseError* error) {
1247 std::string ice_options;
1248 if (!GetValue(line, kAttributeIceOption, &ice_options, error)) {
1249 return false;
1250 }
1251 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:491252 rtc::split(ice_options, kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:361253 for (size_t i = 0; i < fields.size(); ++i) {
1254 transport_options->push_back(fields[i]);
1255 }
1256 return true;
1257}
1258
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561259bool ParseSctpPort(const std::string& line,
1260 int* sctp_port,
1261 SdpParseError* error) {
Harald Alvestrand48cce4d2019-04-11 08:41:241262 // draft-ietf-mmusic-sctp-sdp-26
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561263 // a=sctp-port
1264 std::vector<std::string> fields;
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561265 const size_t expected_min_fields = 2;
Jonas Olssonec9e4922018-09-05 07:53:491266 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterColonChar, &fields);
lally69f57602015-10-08 17:15:041267 if (fields.size() < expected_min_fields) {
1268 fields.resize(0);
Jonas Olssonec9e4922018-09-05 07:53:491269 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
lally69f57602015-10-08 17:15:041270 }
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561271 if (fields.size() < expected_min_fields) {
1272 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
1273 }
1274 if (!rtc::FromString(fields[1], sctp_port)) {
lally69f57602015-10-08 17:15:041275 return ParseFailed(line, "Invalid sctp port value.", error);
jiayl@webrtc.orgddb85ab2014-09-05 16:31:561276 }
1277 return true;
1278}
1279
Harald Alvestrand48cce4d2019-04-11 08:41:241280bool ParseSctpMaxMessageSize(const std::string& line,
1281 int* max_message_size,
1282 SdpParseError* error) {
1283 // draft-ietf-mmusic-sctp-sdp-26
1284 // a=max-message-size:199999
1285 std::vector<std::string> fields;
1286 const size_t expected_min_fields = 2;
1287 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterColonChar, &fields);
1288 if (fields.size() < expected_min_fields) {
1289 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
1290 }
1291 if (!rtc::FromString(fields[1], max_message_size)) {
1292 return ParseFailed(line, "Invalid SCTP max message size.", error);
1293 }
1294 return true;
1295}
1296
isheriff6f8d6862016-05-26 18:24:551297bool ParseExtmap(const std::string& line,
1298 RtpExtension* extmap,
henrike@webrtc.org28e20752013-07-10 00:45:361299 SdpParseError* error) {
1300 // RFC 5285
1301 // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
1302 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:491303 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:361304 const size_t expected_min_fields = 2;
1305 if (fields.size() < expected_min_fields) {
1306 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
1307 }
1308 std::string uri = fields[1];
1309
1310 std::string value_direction;
1311 if (!GetValue(fields[0], kAttributeExtmap, &value_direction, error)) {
1312 return false;
1313 }
1314 std::vector<std::string> sub_fields;
Jonas Olssonec9e4922018-09-05 07:53:491315 rtc::split(value_direction, kSdpDelimiterSlashChar, &sub_fields);
wu@webrtc.org5e760e72014-04-02 23:19:091316 int value = 0;
1317 if (!GetValueFromString(line, sub_fields[0], &value, error)) {
1318 return false;
1319 }
henrike@webrtc.org28e20752013-07-10 00:45:361320
jbauch5869f502017-06-29 19:31:361321 bool encrypted = false;
1322 if (uri == RtpExtension::kEncryptHeaderExtensionsUri) {
1323 // RFC 6904
Steve Anton36b29d12017-10-30 16:57:421324 // a=extmap:<value["/"<direction>] urn:ietf:params:rtp-hdrext:encrypt <URI>
1325 // <extensionattributes>
jbauch5869f502017-06-29 19:31:361326 const size_t expected_min_fields_encrypted = expected_min_fields + 1;
1327 if (fields.size() < expected_min_fields_encrypted) {
1328 return ParseFailedExpectMinFieldNum(line, expected_min_fields_encrypted,
Yves Gerey665174f2018-06-19 13:03:051329 error);
jbauch5869f502017-06-29 19:31:361330 }
1331
1332 encrypted = true;
1333 uri = fields[2];
1334 if (uri == RtpExtension::kEncryptHeaderExtensionsUri) {
1335 return ParseFailed(line, "Recursive encrypted header.", error);
1336 }
1337 }
1338
1339 *extmap = RtpExtension(uri, value, encrypted);
henrike@webrtc.org28e20752013-07-10 00:45:361340 return true;
1341}
1342
Harald Alvestrandfbb45bd2019-05-15 06:07:471343static void BuildSctpContentAttributes(
1344 std::string* message,
1345 const cricket::SctpDataContentDescription* data_desc) {
1346 rtc::StringBuilder os;
1347 if (data_desc->use_sctpmap()) {
1348 // draft-ietf-mmusic-sctp-sdp-04
1349 // a=sctpmap:sctpmap-number protocol [streams]
1350 rtc::StringBuilder os;
1351 InitAttrLine(kAttributeSctpmap, &os);
1352 os << kSdpDelimiterColon << data_desc->port() << kSdpDelimiterSpace
1353 << kDefaultSctpmapProtocol << kSdpDelimiterSpace
1354 << cricket::kMaxSctpStreams;
1355 AddLine(os.str(), message);
1356 } else {
1357 // draft-ietf-mmusic-sctp-sdp-23
1358 // a=sctp-port:<port>
1359 InitAttrLine(kAttributeSctpPort, &os);
1360 os << kSdpDelimiterColon << data_desc->port();
1361 AddLine(os.str(), message);
1362 if (data_desc->max_message_size() != kDefaultSctpMaxMessageSize) {
1363 InitAttrLine(kAttributeMaxMessageSize, &os);
1364 os << kSdpDelimiterColon << data_desc->max_message_size();
1365 AddLine(os.str(), message);
1366 }
1367 }
1368}
1369
henrike@webrtc.org28e20752013-07-10 00:45:361370void BuildMediaDescription(const ContentInfo* content_info,
1371 const TransportInfo* transport_info,
Patrik Höglundb6b29e02018-06-21 14:58:011372 const cricket::MediaType media_type,
wu@webrtc.org4c3e9912014-07-16 21:03:131373 const std::vector<Candidate>& candidates,
Steve Antone831b8c2018-02-01 20:22:161374 int msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:361375 std::string* message) {
nisseede5da42017-01-12 13:15:361376 RTC_DCHECK(message != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:361377 if (content_info == NULL || message == NULL) {
1378 return;
1379 }
Jonas Olssonec9e4922018-09-05 07:53:491380 rtc::StringBuilder os;
Steve Antonb1c1de12017-12-21 23:14:301381 const MediaContentDescription* media_desc = content_info->media_description();
1382 RTC_DCHECK(media_desc);
henrike@webrtc.org28e20752013-07-10 00:45:361383
henrike@webrtc.org28e20752013-07-10 00:45:361384 // RFC 4566
1385 // m=<media> <port> <proto> <fmt>
1386 // fmt is a list of payload type numbers that MAY be used in the session.
1387 const char* type = NULL;
1388 if (media_type == cricket::MEDIA_TYPE_AUDIO)
1389 type = kMediaTypeAudio;
1390 else if (media_type == cricket::MEDIA_TYPE_VIDEO)
1391 type = kMediaTypeVideo;
1392 else if (media_type == cricket::MEDIA_TYPE_DATA)
1393 type = kMediaTypeData;
1394 else
nissec80e7412017-01-11 13:56:461395 RTC_NOTREACHED();
henrike@webrtc.org28e20752013-07-10 00:45:361396
1397 std::string fmt;
1398 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
Steve Antonb1c1de12017-12-21 23:14:301399 const VideoContentDescription* video_desc = media_desc->as_video();
Steve Anton4daf66e2018-09-07 21:55:531400 for (const cricket::VideoCodec& codec : video_desc->codecs()) {
henrike@webrtc.org28e20752013-07-10 00:45:361401 fmt.append(" ");
Steve Anton4daf66e2018-09-07 21:55:531402 fmt.append(rtc::ToString(codec.id));
henrike@webrtc.org28e20752013-07-10 00:45:361403 }
1404 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
Steve Antonb1c1de12017-12-21 23:14:301405 const AudioContentDescription* audio_desc = media_desc->as_audio();
Steve Anton4daf66e2018-09-07 21:55:531406 for (const cricket::AudioCodec& codec : audio_desc->codecs()) {
henrike@webrtc.org28e20752013-07-10 00:45:361407 fmt.append(" ");
Steve Anton4daf66e2018-09-07 21:55:531408 fmt.append(rtc::ToString(codec.id));
henrike@webrtc.org28e20752013-07-10 00:45:361409 }
1410 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
Harald Alvestrand5fc28b12019-05-13 11:36:161411 const cricket::SctpDataContentDescription* sctp_data_desc =
1412 media_desc->as_sctp();
1413 if (sctp_data_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:361414 fmt.append(" ");
jiayl@webrtc.org9c16c392014-05-01 18:30:301415
Harald Alvestrand5fc28b12019-05-13 11:36:161416 if (sctp_data_desc->use_sctpmap()) {
1417 fmt.append(rtc::ToString(sctp_data_desc->port()));
zstein4b2e0822017-02-18 03:48:381418 } else {
1419 fmt.append(kDefaultSctpmapProtocol);
1420 }
henrike@webrtc.org28e20752013-07-10 00:45:361421 } else {
Harald Alvestrand5fc28b12019-05-13 11:36:161422 const RtpDataContentDescription* rtp_data_desc =
1423 media_desc->as_rtp_data();
1424 for (const cricket::RtpDataCodec& codec : rtp_data_desc->codecs()) {
henrike@webrtc.org28e20752013-07-10 00:45:361425 fmt.append(" ");
Steve Anton4daf66e2018-09-07 21:55:531426 fmt.append(rtc::ToString(codec.id));
henrike@webrtc.org28e20752013-07-10 00:45:361427 }
1428 }
1429 }
1430 // The fmt must never be empty. If no codecs are found, set the fmt attribute
1431 // to 0.
1432 if (fmt.empty()) {
1433 fmt = " 0";
1434 }
1435
deadbeef25ed4352016-12-13 02:37:361436 // The port number in the m line will be updated later when associated with
henrike@webrtc.org28e20752013-07-10 00:45:361437 // the candidates.
deadbeef25ed4352016-12-13 02:37:361438 //
1439 // A port value of 0 indicates that the m= section is rejected.
henrike@webrtc.org28e20752013-07-10 00:45:361440 // RFC 3264
1441 // To reject an offered stream, the port number in the corresponding stream in
1442 // the answer MUST be set to zero.
deadbeef25ed4352016-12-13 02:37:361443 //
1444 // However, the BUNDLE draft adds a new meaning to port zero, when used along
1445 // with a=bundle-only.
zhihuang38989e52017-03-21 18:04:531446 std::string port = kDummyPort;
1447 if (content_info->rejected || content_info->bundle_only) {
1448 port = kMediaPortRejected;
1449 } else if (!media_desc->connection_address().IsNil()) {
1450 port = rtc::ToString(media_desc->connection_address().port());
1451 }
henrike@webrtc.org28e20752013-07-10 00:45:361452
Yves Gerey665174f2018-06-19 13:03:051453 rtc::SSLFingerprint* fp =
1454 (transport_info) ? transport_info->description.identity_fingerprint.get()
1455 : NULL;
henrike@webrtc.org28e20752013-07-10 00:45:361456
wu@webrtc.org4c3e9912014-07-16 21:03:131457 // Add the m and c lines.
henrike@webrtc.org28e20752013-07-10 00:45:361458 InitLine(kLineTypeMedia, type, &os);
1459 os << " " << port << " " << media_desc->protocol() << fmt;
zhihuang38989e52017-03-21 18:04:531460 AddLine(os.str(), message);
1461
1462 InitLine(kLineTypeConnection, kConnectionNettype, &os);
1463 if (media_desc->connection_address().IsNil()) {
1464 os << " " << kConnectionIpv4Addrtype << " " << kDummyAddress;
1465 } else if (media_desc->connection_address().family() == AF_INET) {
1466 os << " " << kConnectionIpv4Addrtype << " "
1467 << media_desc->connection_address().ipaddr().ToString();
Qingsi Wang56991422019-02-08 20:53:061468 } else if (media_desc->connection_address().family() == AF_INET6) {
zhihuang38989e52017-03-21 18:04:531469 os << " " << kConnectionIpv6Addrtype << " "
1470 << media_desc->connection_address().ipaddr().ToString();
Qingsi Wang56991422019-02-08 20:53:061471 } else {
1472 os << " " << kConnectionIpv4Addrtype << " " << kDummyAddress;
zhihuang38989e52017-03-21 18:04:531473 }
1474 AddLine(os.str(), message);
wu@webrtc.org4c3e9912014-07-16 21:03:131475
1476 // RFC 4566
1477 // b=AS:<bandwidth>
Peter Thatcherc0c3a862015-06-24 22:31:251478 if (media_desc->bandwidth() >= 1000) {
wu@webrtc.org4c3e9912014-07-16 21:03:131479 InitLine(kLineTypeSessionBandwidth, kApplicationSpecificMaximum, &os);
1480 os << kSdpDelimiterColon << (media_desc->bandwidth() / 1000);
1481 AddLine(os.str(), message);
1482 }
1483
deadbeef25ed4352016-12-13 02:37:361484 // Add the a=bundle-only line.
1485 if (content_info->bundle_only) {
1486 InitAttrLine(kAttributeBundleOnly, &os);
1487 AddLine(os.str(), message);
1488 }
1489
wu@webrtc.org4c3e9912014-07-16 21:03:131490 // Add the a=rtcp line.
Harald Alvestrand5fc28b12019-05-13 11:36:161491 if (cricket::IsRtpProtocol(media_desc->protocol())) {
wu@webrtc.org4c3e9912014-07-16 21:03:131492 std::string rtcp_line = GetRtcpLine(candidates);
1493 if (!rtcp_line.empty()) {
1494 AddLine(rtcp_line, message);
1495 }
1496 }
1497
honghaiza54a0802015-12-17 02:37:231498 // Build the a=candidate lines. We don't include ufrag and pwd in the
1499 // candidates in the SDP to avoid redundancy.
1500 BuildCandidate(candidates, false, message);
henrike@webrtc.org28e20752013-07-10 00:45:361501
1502 // Use the transport_info to build the media level ice-ufrag and ice-pwd.
1503 if (transport_info) {
1504 // RFC 5245
1505 // ice-pwd-att = "ice-pwd" ":" password
1506 // ice-ufrag-att = "ice-ufrag" ":" ufrag
1507 // ice-ufrag
deadbeef3f7219b2015-12-28 23:17:141508 if (!transport_info->description.ice_ufrag.empty()) {
1509 InitAttrLine(kAttributeIceUfrag, &os);
1510 os << kSdpDelimiterColon << transport_info->description.ice_ufrag;
1511 AddLine(os.str(), message);
1512 }
henrike@webrtc.org28e20752013-07-10 00:45:361513 // ice-pwd
deadbeef3f7219b2015-12-28 23:17:141514 if (!transport_info->description.ice_pwd.empty()) {
1515 InitAttrLine(kAttributeIcePwd, &os);
1516 os << kSdpDelimiterColon << transport_info->description.ice_pwd;
1517 AddLine(os.str(), message);
1518 }
henrike@webrtc.org28e20752013-07-10 00:45:361519
1520 // draft-petithuguenin-mmusic-ice-attributes-level-03
1521 BuildIceOptions(transport_info->description.transport_options, message);
1522
1523 // RFC 4572
1524 // fingerprint-attribute =
1525 // "fingerprint" ":" hash-func SP fingerprint
1526 if (fp) {
1527 // Insert the fingerprint attribute.
1528 InitAttrLine(kAttributeFingerprint, &os);
Yves Gerey665174f2018-06-19 13:03:051529 os << kSdpDelimiterColon << fp->algorithm << kSdpDelimiterSpace
henrike@webrtc.org28e20752013-07-10 00:45:361530 << fp->GetRfc4572Fingerprint();
henrike@webrtc.org28e20752013-07-10 00:45:361531 AddLine(os.str(), message);
sergeyu@chromium.org0be6aa02013-08-23 23:21:251532
1533 // Inserting setup attribute.
1534 if (transport_info->description.connection_role !=
Yves Gerey665174f2018-06-19 13:03:051535 cricket::CONNECTIONROLE_NONE) {
sergeyu@chromium.org0be6aa02013-08-23 23:21:251536 // Making sure we are not using "passive" mode.
1537 cricket::ConnectionRole role =
1538 transport_info->description.connection_role;
mallinath@webrtc.org19f27e62013-10-13 17:18:271539 std::string dtls_role_str;
nissec16fa5e2017-02-07 15:18:431540 const bool success =
1541 cricket::ConnectionRoleToString(role, &dtls_role_str);
1542 RTC_DCHECK(success);
sergeyu@chromium.org0be6aa02013-08-23 23:21:251543 InitAttrLine(kAttributeSetup, &os);
sergeyu@chromium.org0be6aa02013-08-23 23:21:251544 os << kSdpDelimiterColon << dtls_role_str;
1545 AddLine(os.str(), message);
1546 }
henrike@webrtc.org28e20752013-07-10 00:45:361547 }
Bjorn A Mellemc85ebbe2019-06-07 17:28:061548
1549 if (transport_info->description.opaque_parameters) {
1550 AddOpaqueTransportLine(*transport_info->description.opaque_parameters,
1551 message);
1552 }
henrike@webrtc.org28e20752013-07-10 00:45:361553 }
1554
1555 // RFC 3388
1556 // mid-attribute = "a=mid:" identification-tag
1557 // identification-tag = token
1558 // Use the content name as the mid identification-tag.
1559 InitAttrLine(kAttributeMid, &os);
1560 os << kSdpDelimiterColon << content_info->name;
1561 AddLine(os.str(), message);
1562
Harald Alvestrand5fc28b12019-05-13 11:36:161563 if (cricket::IsDtlsSctp(media_desc->protocol())) {
1564 const cricket::SctpDataContentDescription* data_desc =
1565 media_desc->as_sctp();
Harald Alvestrandfbb45bd2019-05-15 06:07:471566 BuildSctpContentAttributes(message, data_desc);
Harald Alvestrand5fc28b12019-05-13 11:36:161567 } else if (cricket::IsRtpProtocol(media_desc->protocol())) {
Steve Antone831b8c2018-02-01 20:22:161568 BuildRtpContentAttributes(media_desc, media_type, msid_signaling, message);
henrike@webrtc.org28e20752013-07-10 00:45:361569 }
1570}
1571
deadbeef9d3584c2016-02-17 01:54:101572void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
Patrik Höglundb6b29e02018-06-21 14:58:011573 const cricket::MediaType media_type,
Steve Antone831b8c2018-02-01 20:22:161574 int msid_signaling,
deadbeef9d3584c2016-02-17 01:54:101575 std::string* message) {
Amit Hilbuchc57d5732018-12-11 23:30:111576 SdpSerializer serializer;
Jonas Olssonec9e4922018-09-05 07:53:491577 rtc::StringBuilder os;
Johannes Kron0854eb62018-10-10 20:33:201578 // RFC 8285
1579 // a=extmap-allow-mixed
1580 // The attribute MUST be either on session level or media level. We support
1581 // responding on both levels, however, we don't respond on media level if it's
1582 // set on session level.
Johannes Kron9581bc42018-10-23 08:17:391583 if (media_desc->extmap_allow_mixed_enum() ==
Johannes Kron0854eb62018-10-10 20:33:201584 MediaContentDescription::kMedia) {
1585 InitAttrLine(kAttributeExtmapAllowMixed, &os);
1586 AddLine(os.str(), message);
1587 }
1588 // RFC 8285
henrike@webrtc.org28e20752013-07-10 00:45:361589 // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
1590 // The definitions MUST be either all session level or all media level. This
1591 // implementation uses all media level.
1592 for (size_t i = 0; i < media_desc->rtp_header_extensions().size(); ++i) {
jbauch5869f502017-06-29 19:31:361593 const RtpExtension& extension = media_desc->rtp_header_extensions()[i];
henrike@webrtc.org28e20752013-07-10 00:45:361594 InitAttrLine(kAttributeExtmap, &os);
jbauch5869f502017-06-29 19:31:361595 os << kSdpDelimiterColon << extension.id;
1596 if (extension.encrypt) {
1597 os << kSdpDelimiterSpace << RtpExtension::kEncryptHeaderExtensionsUri;
1598 }
1599 os << kSdpDelimiterSpace << extension.uri;
henrike@webrtc.org28e20752013-07-10 00:45:361600 AddLine(os.str(), message);
1601 }
1602
1603 // RFC 3264
1604 // a=sendrecv || a=sendonly || a=sendrecv || a=inactive
deadbeefc80741f2015-10-22 20:14:451605 switch (media_desc->direction()) {
Steve Anton4e70a722017-11-28 22:57:101606 case RtpTransceiverDirection::kInactive:
henrike@webrtc.org28e20752013-07-10 00:45:361607 InitAttrLine(kAttributeInactive, &os);
1608 break;
Steve Anton4e70a722017-11-28 22:57:101609 case RtpTransceiverDirection::kSendOnly:
henrike@webrtc.org28e20752013-07-10 00:45:361610 InitAttrLine(kAttributeSendOnly, &os);
1611 break;
Steve Anton4e70a722017-11-28 22:57:101612 case RtpTransceiverDirection::kRecvOnly:
henrike@webrtc.org28e20752013-07-10 00:45:361613 InitAttrLine(kAttributeRecvOnly, &os);
1614 break;
Steve Anton4e70a722017-11-28 22:57:101615 case RtpTransceiverDirection::kSendRecv:
henrike@webrtc.org28e20752013-07-10 00:45:361616 default:
1617 InitAttrLine(kAttributeSendRecv, &os);
1618 break;
1619 }
1620 AddLine(os.str(), message);
1621
Seth Hampson5b4f0752018-04-02 23:31:361622 // Specified in https://datatracker.ietf.org/doc/draft-ietf-mmusic-msid/16/
1623 // a=msid:<msid-id> <msid-appdata>
1624 // The msid-id is a 1*64 token char representing the media stream id, and the
1625 // msid-appdata is a 1*64 token char representing the track id. There is a
1626 // line for every media stream, with a special msid-id value of "-"
1627 // representing no streams. The value of "msid-appdata" MUST be identical for
1628 // all lines.
Steve Antone831b8c2018-02-01 20:22:161629 if (msid_signaling & cricket::kMsidSignalingMediaSection) {
1630 const StreamParamsVec& streams = media_desc->streams();
1631 if (streams.size() == 1u) {
1632 const StreamParams& track = streams[0];
Seth Hampson5b4f0752018-04-02 23:31:361633 std::vector<std::string> stream_ids = track.stream_ids();
1634 if (stream_ids.empty()) {
1635 stream_ids.push_back(kNoStreamMsid);
1636 }
1637 for (const std::string& stream_id : stream_ids) {
1638 InitAttrLine(kAttributeMsid, &os);
1639 os << kSdpDelimiterColon << stream_id << kSdpDelimiterSpace << track.id;
1640 AddLine(os.str(), message);
1641 }
Steve Antone831b8c2018-02-01 20:22:161642 } else if (streams.size() > 1u) {
1643 RTC_LOG(LS_WARNING)
1644 << "Trying to serialize Unified Plan SDP with more than "
Jonas Olsson45cc8902018-02-13 09:37:071645 "one track in a media section. Omitting 'a=msid'.";
deadbeef9d3584c2016-02-17 01:54:101646 }
1647 }
1648
henrike@webrtc.org28e20752013-07-10 00:45:361649 // RFC 5761
1650 // a=rtcp-mux
1651 if (media_desc->rtcp_mux()) {
1652 InitAttrLine(kAttributeRtcpMux, &os);
1653 AddLine(os.str(), message);
1654 }
1655
deadbeef13871492015-12-09 20:37:511656 // RFC 5506
1657 // a=rtcp-rsize
1658 if (media_desc->rtcp_reduced_size()) {
1659 InitAttrLine(kAttributeRtcpReducedSize, &os);
1660 AddLine(os.str(), message);
1661 }
1662
deadbeefd45aea82017-09-16 08:24:291663 if (media_desc->conference_mode()) {
1664 InitAttrLine(kAttributeXGoogleFlag, &os);
1665 os << kSdpDelimiterColon << kValueConference;
1666 AddLine(os.str(), message);
1667 }
1668
henrike@webrtc.org28e20752013-07-10 00:45:361669 // RFC 4568
1670 // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
Steve Anton4daf66e2018-09-07 21:55:531671 for (const CryptoParams& crypto_params : media_desc->cryptos()) {
henrike@webrtc.org28e20752013-07-10 00:45:361672 InitAttrLine(kAttributeCrypto, &os);
Steve Anton4daf66e2018-09-07 21:55:531673 os << kSdpDelimiterColon << crypto_params.tag << " "
1674 << crypto_params.cipher_suite << " " << crypto_params.key_params;
1675 if (!crypto_params.session_params.empty()) {
1676 os << " " << crypto_params.session_params;
henrike@webrtc.org28e20752013-07-10 00:45:361677 }
1678 AddLine(os.str(), message);
1679 }
1680
1681 // RFC 4566
1682 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1683 // [/<encodingparameters>]
1684 BuildRtpMap(media_desc, media_type, message);
1685
Steve Anton4daf66e2018-09-07 21:55:531686 for (const StreamParams& track : media_desc->streams()) {
henrike@webrtc.org28e20752013-07-10 00:45:361687 // Build the ssrc-group lines.
Steve Anton4daf66e2018-09-07 21:55:531688 for (const SsrcGroup& ssrc_group : track.ssrc_groups) {
henrike@webrtc.org28e20752013-07-10 00:45:361689 // RFC 5576
1690 // a=ssrc-group:<semantics> <ssrc-id> ...
Steve Anton4daf66e2018-09-07 21:55:531691 if (ssrc_group.ssrcs.empty()) {
henrike@webrtc.org28e20752013-07-10 00:45:361692 continue;
1693 }
henrike@webrtc.org28e20752013-07-10 00:45:361694 InitAttrLine(kAttributeSsrcGroup, &os);
Steve Anton4daf66e2018-09-07 21:55:531695 os << kSdpDelimiterColon << ssrc_group.semantics;
1696 for (uint32_t ssrc : ssrc_group.ssrcs) {
1697 os << kSdpDelimiterSpace << rtc::ToString(ssrc);
henrike@webrtc.org28e20752013-07-10 00:45:361698 }
1699 AddLine(os.str(), message);
1700 }
1701 // Build the ssrc lines for each ssrc.
Steve Anton4daf66e2018-09-07 21:55:531702 for (uint32_t ssrc : track.ssrcs) {
henrike@webrtc.org28e20752013-07-10 00:45:361703 // RFC 5576
1704 // a=ssrc:<ssrc-id> cname:<value>
Steve Anton4daf66e2018-09-07 21:55:531705 AddSsrcLine(ssrc, kSsrcAttributeCname, track.cname, message);
henrike@webrtc.org28e20752013-07-10 00:45:361706
Steve Antone831b8c2018-02-01 20:22:161707 if (msid_signaling & cricket::kMsidSignalingSsrcAttribute) {
1708 // draft-alvestrand-mmusic-msid-00
1709 // a=ssrc:<ssrc-id> msid:identifier [appdata]
1710 // The appdata consists of the "id" attribute of a MediaStreamTrack,
1711 // which corresponds to the "id" attribute of StreamParams.
Seth Hampson5b4f0752018-04-02 23:31:361712 // Since a=ssrc msid signaling is used in Plan B SDP semantics, and
1713 // multiple stream ids are not supported for Plan B, we are only adding
1714 // a line for the first media stream id here.
Seth Hampson7fa6ee62018-10-17 17:25:281715 const std::string& track_stream_id = track.first_stream_id();
1716 // We use a special msid-id value of "-" to represent no streams,
1717 // for Unified Plan compatibility. Plan B will always have a
1718 // track_stream_id.
1719 const std::string& stream_id =
1720 track_stream_id.empty() ? kNoStreamMsid : track_stream_id;
Steve Antone831b8c2018-02-01 20:22:161721 InitAttrLine(kAttributeSsrc, &os);
1722 os << kSdpDelimiterColon << ssrc << kSdpDelimiterSpace
1723 << kSsrcAttributeMsid << kSdpDelimiterColon << stream_id
Steve Anton4daf66e2018-09-07 21:55:531724 << kSdpDelimiterSpace << track.id;
Steve Antone831b8c2018-02-01 20:22:161725 AddLine(os.str(), message);
henrike@webrtc.org28e20752013-07-10 00:45:361726
Steve Antone831b8c2018-02-01 20:22:161727 // TODO(ronghuawu): Remove below code which is for backward
1728 // compatibility.
1729 // draft-alvestrand-rtcweb-mid-01
1730 // a=ssrc:<ssrc-id> mslabel:<value>
1731 // The label isn't yet defined.
1732 // a=ssrc:<ssrc-id> label:<value>
Seth Hampson5b4f0752018-04-02 23:31:361733 AddSsrcLine(ssrc, kSsrcAttributeMslabel, stream_id, message);
Steve Anton4daf66e2018-09-07 21:55:531734 AddSsrcLine(ssrc, kSSrcAttributeLabel, track.id, message);
Steve Antone831b8c2018-02-01 20:22:161735 }
henrike@webrtc.org28e20752013-07-10 00:45:361736 }
Amit Hilbuchc57d5732018-12-11 23:30:111737
1738 // Build the rid lines for each layer of the track
1739 for (const RidDescription& rid_description : track.rids()) {
1740 InitAttrLine(kAttributeRid, &os);
1741 os << kSdpDelimiterColon
1742 << serializer.SerializeRidDescription(rid_description);
1743 AddLine(os.str(), message);
1744 }
1745 }
1746
Florent Castellib60141b2019-07-03 10:47:541747 for (const RidDescription& rid_description : media_desc->receive_rids()) {
1748 InitAttrLine(kAttributeRid, &os);
1749 os << kSdpDelimiterColon
1750 << serializer.SerializeRidDescription(rid_description);
1751 AddLine(os.str(), message);
1752 }
1753
Amit Hilbucha2012042018-12-03 19:35:051754 // Simulcast (a=simulcast)
1755 // https://tools.ietf.org/html/draft-ietf-mmusic-sdp-simulcast-13#section-5.1
Amit Hilbuchc57d5732018-12-11 23:30:111756 if (media_desc->HasSimulcast()) {
1757 const auto& simulcast = media_desc->simulcast_description();
Amit Hilbucha2012042018-12-03 19:35:051758 InitAttrLine(kAttributeSimulcast, &os);
Amit Hilbucha2012042018-12-03 19:35:051759 os << kSdpDelimiterColon
1760 << serializer.SerializeSimulcastDescription(simulcast);
1761 AddLine(os.str(), message);
1762 }
henrike@webrtc.org28e20752013-07-10 00:45:361763}
1764
Jonas Olssonec9e4922018-09-05 07:53:491765void WriteFmtpHeader(int payload_type, rtc::StringBuilder* os) {
henrike@webrtc.org28e20752013-07-10 00:45:361766 // fmtp header: a=fmtp:|payload_type| <parameters>
1767 // Add a=fmtp
1768 InitAttrLine(kAttributeFmtp, os);
1769 // Add :|payload_type|
1770 *os << kSdpDelimiterColon << payload_type;
1771}
1772
Mirta Dvornicic479a3c02019-06-04 13:38:501773void WritePacketizationHeader(int payload_type, rtc::StringBuilder* os) {
1774 // packetization header: a=packetization:|payload_type| <packetization_format>
1775 // Add a=packetization
1776 InitAttrLine(kAttributePacketization, os);
1777 // Add :|payload_type|
1778 *os << kSdpDelimiterColon << payload_type;
1779}
1780
Jonas Olssonec9e4922018-09-05 07:53:491781void WriteRtcpFbHeader(int payload_type, rtc::StringBuilder* os) {
henrike@webrtc.org28e20752013-07-10 00:45:361782 // rtcp-fb header: a=rtcp-fb:|payload_type|
1783 // <parameters>/<ccm <ccm_parameters>>
1784 // Add a=rtcp-fb
1785 InitAttrLine(kAttributeRtcpFb, os);
1786 // Add :
1787 *os << kSdpDelimiterColon;
1788 if (payload_type == kWildcardPayloadType) {
1789 *os << "*";
1790 } else {
1791 *os << payload_type;
1792 }
1793}
1794
1795void WriteFmtpParameter(const std::string& parameter_name,
1796 const std::string& parameter_value,
Jonas Olssonec9e4922018-09-05 07:53:491797 rtc::StringBuilder* os) {
henrike@webrtc.org28e20752013-07-10 00:45:361798 // fmtp parameters: |parameter_name|=|parameter_value|
1799 *os << parameter_name << kSdpDelimiterEqual << parameter_value;
1800}
1801
1802void WriteFmtpParameters(const cricket::CodecParameterMap& parameters,
Jonas Olssonec9e4922018-09-05 07:53:491803 rtc::StringBuilder* os) {
Steve Anton4daf66e2018-09-07 21:55:531804 bool first = true;
1805 for (const auto& entry : parameters) {
1806 const std::string& key = entry.first;
1807 const std::string& value = entry.second;
hta62a216e2016-04-15 18:02:141808 // Parameters are a semicolon-separated list, no spaces.
1809 // The list is separated from the header by a space.
Steve Anton4daf66e2018-09-07 21:55:531810 if (first) {
hta62a216e2016-04-15 18:02:141811 *os << kSdpDelimiterSpace;
Steve Anton4daf66e2018-09-07 21:55:531812 first = false;
hta62a216e2016-04-15 18:02:141813 } else {
henrike@webrtc.org28e20752013-07-10 00:45:361814 *os << kSdpDelimiterSemicolon;
1815 }
Steve Anton4daf66e2018-09-07 21:55:531816 WriteFmtpParameter(key, value, os);
henrike@webrtc.org28e20752013-07-10 00:45:361817 }
1818}
1819
1820bool IsFmtpParam(const std::string& name) {
ossuaa4b0772017-01-30 15:41:181821 // RFC 4855, section 3 specifies the mapping of media format parameters to SDP
1822 // parameters. Only ptime, maxptime, channels and rate are placed outside of
1823 // the fmtp line. In WebRTC, channels and rate are already handled separately
1824 // and thus not included in the CodecParameterMap.
1825 return name != kCodecParamPTime && name != kCodecParamMaxPTime;
henrike@webrtc.org28e20752013-07-10 00:45:361826}
1827
1828// Retreives fmtp parameters from |params|, which may contain other parameters
1829// as well, and puts them in |fmtp_parameters|.
1830void GetFmtpParams(const cricket::CodecParameterMap& params,
1831 cricket::CodecParameterMap* fmtp_parameters) {
Steve Anton4daf66e2018-09-07 21:55:531832 for (const auto& entry : params) {
1833 const std::string& key = entry.first;
1834 const std::string& value = entry.second;
1835 if (IsFmtpParam(key)) {
1836 (*fmtp_parameters)[key] = value;
henrike@webrtc.org28e20752013-07-10 00:45:361837 }
1838 }
1839}
1840
1841template <class T>
1842void AddFmtpLine(const T& codec, std::string* message) {
1843 cricket::CodecParameterMap fmtp_parameters;
1844 GetFmtpParams(codec.params, &fmtp_parameters);
1845 if (fmtp_parameters.empty()) {
1846 // No need to add an fmtp if it will have no (optional) parameters.
1847 return;
1848 }
Jonas Olssonec9e4922018-09-05 07:53:491849 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:361850 WriteFmtpHeader(codec.id, &os);
1851 WriteFmtpParameters(fmtp_parameters, &os);
1852 AddLine(os.str(), message);
1853 return;
1854}
1855
1856template <class T>
Mirta Dvornicic479a3c02019-06-04 13:38:501857void AddPacketizationLine(const T& codec, std::string* message) {
1858 if (!codec.packetization) {
1859 return;
1860 }
1861 rtc::StringBuilder os;
1862 WritePacketizationHeader(codec.id, &os);
1863 os << " " << *codec.packetization;
1864 AddLine(os.str(), message);
1865}
1866
1867template <class T>
henrike@webrtc.org28e20752013-07-10 00:45:361868void AddRtcpFbLines(const T& codec, std::string* message) {
Steve Anton4daf66e2018-09-07 21:55:531869 for (const cricket::FeedbackParam& param : codec.feedback_params.params()) {
Jonas Olssonec9e4922018-09-05 07:53:491870 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:361871 WriteRtcpFbHeader(codec.id, &os);
Steve Anton4daf66e2018-09-07 21:55:531872 os << " " << param.id();
1873 if (!param.param().empty()) {
1874 os << " " << param.param();
henrike@webrtc.org28e20752013-07-10 00:45:361875 }
1876 AddLine(os.str(), message);
1877 }
1878}
1879
1880bool GetMinValue(const std::vector<int>& values, int* value) {
1881 if (values.empty()) {
1882 return false;
1883 }
Steve Anton64b626b2019-01-29 01:25:261884 auto it = absl::c_min_element(values);
1885 *value = *it;
henrike@webrtc.org28e20752013-07-10 00:45:361886 return true;
1887}
1888
1889bool GetParameter(const std::string& name,
Yves Gerey665174f2018-06-19 13:03:051890 const cricket::CodecParameterMap& params,
1891 int* value) {
1892 std::map<std::string, std::string>::const_iterator found = params.find(name);
henrike@webrtc.org28e20752013-07-10 00:45:361893 if (found == params.end()) {
1894 return false;
1895 }
buildbot@webrtc.orgd4e598d2014-07-29 17:36:521896 if (!rtc::FromString(found->second, value)) {
wu@webrtc.org5e760e72014-04-02 23:19:091897 return false;
1898 }
henrike@webrtc.org28e20752013-07-10 00:45:361899 return true;
1900}
1901
1902void BuildRtpMap(const MediaContentDescription* media_desc,
Patrik Höglundb6b29e02018-06-21 14:58:011903 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:361904 std::string* message) {
nisseede5da42017-01-12 13:15:361905 RTC_DCHECK(message != NULL);
1906 RTC_DCHECK(media_desc != NULL);
Jonas Olssonec9e4922018-09-05 07:53:491907 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:361908 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
Steve Anton4daf66e2018-09-07 21:55:531909 for (const cricket::VideoCodec& codec : media_desc->as_video()->codecs()) {
henrike@webrtc.org28e20752013-07-10 00:45:361910 // RFC 4566
1911 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1912 // [/<encodingparameters>]
Steve Anton4daf66e2018-09-07 21:55:531913 if (codec.id != kWildcardPayloadType) {
henrike@webrtc.org28e20752013-07-10 00:45:361914 InitAttrLine(kAttributeRtpmap, &os);
Steve Anton4daf66e2018-09-07 21:55:531915 os << kSdpDelimiterColon << codec.id << " " << codec.name << "/"
deadbeefe814a0d2017-02-26 02:15:091916 << cricket::kVideoCodecClockrate;
henrike@webrtc.org28e20752013-07-10 00:45:361917 AddLine(os.str(), message);
1918 }
Mirta Dvornicic479a3c02019-06-04 13:38:501919 AddPacketizationLine(codec, message);
Steve Anton4daf66e2018-09-07 21:55:531920 AddRtcpFbLines(codec, message);
1921 AddFmtpLine(codec, message);
henrike@webrtc.org28e20752013-07-10 00:45:361922 }
1923 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
henrike@webrtc.org28e20752013-07-10 00:45:361924 std::vector<int> ptimes;
1925 std::vector<int> maxptimes;
1926 int max_minptime = 0;
Steve Anton4daf66e2018-09-07 21:55:531927 for (const cricket::AudioCodec& codec : media_desc->as_audio()->codecs()) {
1928 RTC_DCHECK(!codec.name.empty());
henrike@webrtc.org28e20752013-07-10 00:45:361929 // RFC 4566
1930 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1931 // [/<encodingparameters>]
1932 InitAttrLine(kAttributeRtpmap, &os);
Steve Anton4daf66e2018-09-07 21:55:531933 os << kSdpDelimiterColon << codec.id << " ";
1934 os << codec.name << "/" << codec.clockrate;
1935 if (codec.channels != 1) {
1936 os << "/" << codec.channels;
henrike@webrtc.org28e20752013-07-10 00:45:361937 }
1938 AddLine(os.str(), message);
Steve Anton4daf66e2018-09-07 21:55:531939 AddRtcpFbLines(codec, message);
1940 AddFmtpLine(codec, message);
henrike@webrtc.org28e20752013-07-10 00:45:361941 int minptime = 0;
Steve Anton4daf66e2018-09-07 21:55:531942 if (GetParameter(kCodecParamMinPTime, codec.params, &minptime)) {
henrike@webrtc.org28e20752013-07-10 00:45:361943 max_minptime = std::max(minptime, max_minptime);
1944 }
1945 int ptime;
Steve Anton4daf66e2018-09-07 21:55:531946 if (GetParameter(kCodecParamPTime, codec.params, &ptime)) {
henrike@webrtc.org28e20752013-07-10 00:45:361947 ptimes.push_back(ptime);
1948 }
1949 int maxptime;
Steve Anton4daf66e2018-09-07 21:55:531950 if (GetParameter(kCodecParamMaxPTime, codec.params, &maxptime)) {
henrike@webrtc.org28e20752013-07-10 00:45:361951 maxptimes.push_back(maxptime);
1952 }
1953 }
1954 // Populate the maxptime attribute with the smallest maxptime of all codecs
1955 // under the same m-line.
1956 int min_maxptime = INT_MAX;
1957 if (GetMinValue(maxptimes, &min_maxptime)) {
1958 AddAttributeLine(kCodecParamMaxPTime, min_maxptime, message);
1959 }
nisseede5da42017-01-12 13:15:361960 RTC_DCHECK(min_maxptime > max_minptime);
henrike@webrtc.org28e20752013-07-10 00:45:361961 // Populate the ptime attribute with the smallest ptime or the largest
1962 // minptime, whichever is the largest, for all codecs under the same m-line.
1963 int ptime = INT_MAX;
1964 if (GetMinValue(ptimes, &ptime)) {
1965 ptime = std::min(ptime, min_maxptime);
1966 ptime = std::max(ptime, max_minptime);
1967 AddAttributeLine(kCodecParamPTime, ptime, message);
1968 }
1969 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
Harald Alvestrand5fc28b12019-05-13 11:36:161970 if (media_desc->as_rtp_data()) {
1971 for (const cricket::RtpDataCodec& codec :
1972 media_desc->as_rtp_data()->codecs()) {
1973 // RFC 4566
1974 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1975 // [/<encodingparameters>]
1976 InitAttrLine(kAttributeRtpmap, &os);
1977 os << kSdpDelimiterColon << codec.id << " " << codec.name << "/"
1978 << codec.clockrate;
1979 AddLine(os.str(), message);
1980 }
henrike@webrtc.org28e20752013-07-10 00:45:361981 }
1982 }
1983}
1984
1985void BuildCandidate(const std::vector<Candidate>& candidates,
honghaiza54a0802015-12-17 02:37:231986 bool include_ufrag,
henrike@webrtc.org28e20752013-07-10 00:45:361987 std::string* message) {
Jonas Olssonec9e4922018-09-05 07:53:491988 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:361989
Steve Anton4daf66e2018-09-07 21:55:531990 for (const Candidate& candidate : candidates) {
henrike@webrtc.org28e20752013-07-10 00:45:361991 // RFC 5245
1992 // a=candidate:<foundation> <component-id> <transport> <priority>
1993 // <connection-address> <port> typ <candidate-types>
1994 // [raddr <connection-address>] [rport <port>]
1995 // *(SP extension-att-name SP extension-att-value)
1996 std::string type;
1997 // Map the cricket candidate type to "host" / "srflx" / "prflx" / "relay"
Steve Anton4daf66e2018-09-07 21:55:531998 if (candidate.type() == cricket::LOCAL_PORT_TYPE) {
henrike@webrtc.org28e20752013-07-10 00:45:361999 type = kCandidateHost;
Steve Anton4daf66e2018-09-07 21:55:532000 } else if (candidate.type() == cricket::STUN_PORT_TYPE) {
henrike@webrtc.org28e20752013-07-10 00:45:362001 type = kCandidateSrflx;
Steve Anton4daf66e2018-09-07 21:55:532002 } else if (candidate.type() == cricket::RELAY_PORT_TYPE) {
henrike@webrtc.org28e20752013-07-10 00:45:362003 type = kCandidateRelay;
Steve Anton4daf66e2018-09-07 21:55:532004 } else if (candidate.type() == cricket::PRFLX_PORT_TYPE) {
Honghai Zhang7fb69db2016-03-14 18:59:182005 type = kCandidatePrflx;
2006 // Peer reflexive candidate may be signaled for being removed.
henrike@webrtc.org28e20752013-07-10 00:45:362007 } else {
nissec80e7412017-01-11 13:56:462008 RTC_NOTREACHED();
Peter Thatcher019087f2015-04-28 16:06:262009 // Never write out candidates if we don't know the type.
2010 continue;
henrike@webrtc.org28e20752013-07-10 00:45:362011 }
2012
2013 InitAttrLine(kAttributeCandidate, &os);
Steve Anton4daf66e2018-09-07 21:55:532014 os << kSdpDelimiterColon << candidate.foundation() << " "
2015 << candidate.component() << " " << candidate.protocol() << " "
2016 << candidate.priority() << " "
2017 << (candidate.address().ipaddr().IsNil()
2018 ? candidate.address().hostname()
2019 : candidate.address().ipaddr().ToString())
2020 << " " << candidate.address().PortAsString() << " "
2021 << kAttributeCandidateTyp << " " << type << " ";
henrike@webrtc.org28e20752013-07-10 00:45:362022
2023 // Related address
Steve Anton4daf66e2018-09-07 21:55:532024 if (!candidate.related_address().IsNil()) {
henrike@webrtc.org28e20752013-07-10 00:45:362025 os << kAttributeCandidateRaddr << " "
Steve Anton4daf66e2018-09-07 21:55:532026 << candidate.related_address().ipaddr().ToString() << " "
henrike@webrtc.org28e20752013-07-10 00:45:362027 << kAttributeCandidateRport << " "
Steve Anton4daf66e2018-09-07 21:55:532028 << candidate.related_address().PortAsString() << " ";
henrike@webrtc.org28e20752013-07-10 00:45:362029 }
2030
Steve Anton4daf66e2018-09-07 21:55:532031 if (candidate.protocol() == cricket::TCP_PROTOCOL_NAME) {
2032 os << kTcpCandidateType << " " << candidate.tcptype() << " ";
mallinath@webrtc.org2d60c5e2014-08-08 22:29:202033 }
2034
henrike@webrtc.org28e20752013-07-10 00:45:362035 // Extensions
Steve Anton4daf66e2018-09-07 21:55:532036 os << kAttributeCandidateGeneration << " " << candidate.generation();
2037 if (include_ufrag && !candidate.username().empty()) {
2038 os << " " << kAttributeCandidateUfrag << " " << candidate.username();
honghaiza54a0802015-12-17 02:37:232039 }
Steve Anton4daf66e2018-09-07 21:55:532040 if (candidate.network_id() > 0) {
2041 os << " " << kAttributeCandidateNetworkId << " "
2042 << candidate.network_id();
honghaiza0c44ea2016-03-23 23:07:482043 }
Steve Anton4daf66e2018-09-07 21:55:532044 if (candidate.network_cost() > 0) {
2045 os << " " << kAttributeCandidateNetworkCost << " "
2046 << candidate.network_cost();
honghaize1a0c942016-02-16 22:54:562047 }
henrike@webrtc.org28e20752013-07-10 00:45:362048
2049 AddLine(os.str(), message);
2050 }
2051}
2052
2053void BuildIceOptions(const std::vector<std::string>& transport_options,
2054 std::string* message) {
2055 if (!transport_options.empty()) {
Jonas Olssonec9e4922018-09-05 07:53:492056 rtc::StringBuilder os;
henrike@webrtc.org28e20752013-07-10 00:45:362057 InitAttrLine(kAttributeIceOption, &os);
2058 os << kSdpDelimiterColon << transport_options[0];
2059 for (size_t i = 1; i < transport_options.size(); ++i) {
2060 os << kSdpDelimiterSpace << transport_options[i];
2061 }
2062 AddLine(os.str(), message);
2063 }
2064}
2065
zhihuang38989e52017-03-21 18:04:532066bool ParseConnectionData(const std::string& line,
2067 rtc::SocketAddress* addr,
2068 SdpParseError* error) {
2069 // Parse the line from left to right.
2070 std::string token;
2071 std::string rightpart;
2072 // RFC 4566
2073 // c=<nettype> <addrtype> <connection-address>
2074 // Skip the "c="
Jonas Olssonec9e4922018-09-05 07:53:492075 if (!rtc::tokenize_first(line, kSdpDelimiterEqualChar, &token, &rightpart)) {
zhihuang38989e52017-03-21 18:04:532076 return ParseFailed(line, "Failed to parse the network type.", error);
2077 }
2078
2079 // Extract and verify the <nettype>
Jonas Olssonec9e4922018-09-05 07:53:492080 if (!rtc::tokenize_first(rightpart, kSdpDelimiterSpaceChar, &token,
2081 &rightpart) ||
zhihuang38989e52017-03-21 18:04:532082 token != kConnectionNettype) {
2083 return ParseFailed(line,
2084 "Failed to parse the connection data. The network type "
2085 "is not currently supported.",
2086 error);
2087 }
2088
2089 // Extract the "<addrtype>" and "<connection-address>".
Jonas Olssonec9e4922018-09-05 07:53:492090 if (!rtc::tokenize_first(rightpart, kSdpDelimiterSpaceChar, &token,
2091 &rightpart)) {
zhihuang38989e52017-03-21 18:04:532092 return ParseFailed(line, "Failed to parse the address type.", error);
2093 }
2094
2095 // The rightpart part should be the IP address without the slash which is used
2096 // for multicast.
2097 if (rightpart.find('/') != std::string::npos) {
2098 return ParseFailed(line,
2099 "Failed to parse the connection data. Multicast is not "
2100 "currently supported.",
2101 error);
2102 }
2103 addr->SetIP(rightpart);
2104
2105 // Verify that the addrtype matches the type of the parsed address.
2106 if ((addr->family() == AF_INET && token != "IP4") ||
2107 (addr->family() == AF_INET6 && token != "IP6")) {
2108 addr->Clear();
2109 return ParseFailed(
2110 line,
2111 "Failed to parse the connection data. The address type is mismatching.",
2112 error);
2113 }
2114 return true;
2115}
2116
Piotr (Peter) Slatala13e570f2019-02-27 19:34:262117bool ParseMediaTransportLine(const std::string& line,
2118 std::string* transport_name,
2119 std::string* transport_setting,
2120 SdpParseError* error) {
2121 std::string value;
2122 if (!GetValue(line, kMediaTransportSettingLine, &value, error)) {
2123 return false;
2124 }
2125 std::string media_transport_settings_base64;
2126 if (!rtc::tokenize_first(value, kSdpDelimiterColonChar, transport_name,
2127 &media_transport_settings_base64)) {
2128 return ParseFailedGetValue(line, kMediaTransportSettingLine, error);
2129 }
2130 if (!rtc::Base64::Decode(media_transport_settings_base64,
2131 rtc::Base64::DO_STRICT, transport_setting,
2132 nullptr)) {
2133 return ParseFailedGetValue(line, kMediaTransportSettingLine, error);
2134 }
2135
2136 return true;
2137}
2138
Bjorn A Mellemc85ebbe2019-06-07 17:28:062139bool ParseOpaqueTransportLine(const std::string& line,
2140 std::string* protocol,
2141 std::string* transport_parameters,
2142 SdpParseError* error) {
2143 std::string value;
2144 if (!GetValue(line, kOpaqueTransportParametersLine, &value, error)) {
2145 return false;
2146 }
2147 std::string tmp_parameters;
2148 if (!rtc::tokenize_first(value, kSdpDelimiterColonChar, protocol,
2149 &tmp_parameters)) {
2150 return ParseFailedGetValue(line, kOpaqueTransportParametersLine, error);
2151 }
2152 if (!rtc::Base64::Decode(tmp_parameters, rtc::Base64::DO_STRICT,
2153 transport_parameters, nullptr)) {
2154 return ParseFailedGetValue(line, kOpaqueTransportParametersLine, error);
2155 }
2156 return true;
2157}
2158
zhihuang38989e52017-03-21 18:04:532159bool ParseSessionDescription(const std::string& message,
2160 size_t* pos,
henrike@webrtc.org28e20752013-07-10 00:45:362161 std::string* session_id,
2162 std::string* session_version,
henrike@webrtc.org28e20752013-07-10 00:45:362163 TransportDescription* session_td,
2164 RtpHeaderExtensions* session_extmaps,
zhihuang38989e52017-03-21 18:04:532165 rtc::SocketAddress* connection_addr,
henrike@webrtc.org28e20752013-07-10 00:45:362166 cricket::SessionDescription* desc,
2167 SdpParseError* error) {
2168 std::string line;
2169
deadbeefc80741f2015-10-22 20:14:452170 desc->set_msid_supported(false);
Johannes Kron9581bc42018-10-23 08:17:392171 desc->set_extmap_allow_mixed(false);
henrike@webrtc.org28e20752013-07-10 00:45:362172 // RFC 4566
2173 // v= (protocol version)
2174 if (!GetLineWithType(message, pos, &line, kLineTypeVersion)) {
Yves Gerey665174f2018-06-19 13:03:052175 return ParseFailedExpectLine(message, *pos, kLineTypeVersion, std::string(),
2176 error);
henrike@webrtc.org28e20752013-07-10 00:45:362177 }
2178 // RFC 4566
2179 // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
2180 // <unicast-address>
2181 if (!GetLineWithType(message, pos, &line, kLineTypeOrigin)) {
Yves Gerey665174f2018-06-19 13:03:052182 return ParseFailedExpectLine(message, *pos, kLineTypeOrigin, std::string(),
2183 error);
henrike@webrtc.org28e20752013-07-10 00:45:362184 }
2185 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492186 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:362187 const size_t expected_fields = 6;
2188 if (fields.size() != expected_fields) {
2189 return ParseFailedExpectFieldNum(line, expected_fields, error);
2190 }
2191 *session_id = fields[1];
2192 *session_version = fields[2];
2193
2194 // RFC 4566
2195 // s= (session name)
2196 if (!GetLineWithType(message, pos, &line, kLineTypeSessionName)) {
2197 return ParseFailedExpectLine(message, *pos, kLineTypeSessionName,
2198 std::string(), error);
2199 }
2200
Danil Chapovalov66cadcc2018-06-19 14:47:432201 // absl::optional lines
henrike@webrtc.org28e20752013-07-10 00:45:362202 // Those are the optional lines, so shouldn't return false if not present.
2203 // RFC 4566
2204 // i=* (session information)
2205 GetLineWithType(message, pos, &line, kLineTypeSessionInfo);
2206
2207 // RFC 4566
2208 // u=* (URI of description)
2209 GetLineWithType(message, pos, &line, kLineTypeSessionUri);
2210
2211 // RFC 4566
2212 // e=* (email address)
2213 GetLineWithType(message, pos, &line, kLineTypeSessionEmail);
2214
2215 // RFC 4566
2216 // p=* (phone number)
2217 GetLineWithType(message, pos, &line, kLineTypeSessionPhone);
2218
2219 // RFC 4566
2220 // c=* (connection information -- not required if included in
2221 // all media)
zhihuang38989e52017-03-21 18:04:532222 if (GetLineWithType(message, pos, &line, kLineTypeConnection)) {
2223 if (!ParseConnectionData(line, connection_addr, error)) {
2224 return false;
2225 }
2226 }
henrike@webrtc.org28e20752013-07-10 00:45:362227
2228 // RFC 4566
2229 // b=* (zero or more bandwidth information lines)
2230 while (GetLineWithType(message, pos, &line, kLineTypeSessionBandwidth)) {
2231 // By pass zero or more b lines.
2232 }
2233
2234 // RFC 4566
2235 // One or more time descriptions ("t=" and "r=" lines; see below)
2236 // t= (time the session is active)
2237 // r=* (zero or more repeat times)
2238 // Ensure there's at least one time description
2239 if (!GetLineWithType(message, pos, &line, kLineTypeTiming)) {
2240 return ParseFailedExpectLine(message, *pos, kLineTypeTiming, std::string(),
2241 error);
2242 }
2243
2244 while (GetLineWithType(message, pos, &line, kLineTypeRepeatTimes)) {
2245 // By pass zero or more r lines.
2246 }
2247
2248 // Go through the rest of the time descriptions
2249 while (GetLineWithType(message, pos, &line, kLineTypeTiming)) {
2250 while (GetLineWithType(message, pos, &line, kLineTypeRepeatTimes)) {
2251 // By pass zero or more r lines.
2252 }
2253 }
2254
2255 // RFC 4566
2256 // z=* (time zone adjustments)
2257 GetLineWithType(message, pos, &line, kLineTypeTimeZone);
2258
2259 // RFC 4566
2260 // k=* (encryption key)
2261 GetLineWithType(message, pos, &line, kLineTypeEncryptionKey);
2262
2263 // RFC 4566
2264 // a=* (zero or more session attribute lines)
2265 while (GetLineWithType(message, pos, &line, kLineTypeAttributes)) {
2266 if (HasAttribute(line, kAttributeGroup)) {
2267 if (!ParseGroupAttribute(line, desc, error)) {
2268 return false;
2269 }
2270 } else if (HasAttribute(line, kAttributeIceUfrag)) {
Yves Gerey665174f2018-06-19 13:03:052271 if (!GetValue(line, kAttributeIceUfrag, &(session_td->ice_ufrag),
2272 error)) {
henrike@webrtc.org28e20752013-07-10 00:45:362273 return false;
2274 }
2275 } else if (HasAttribute(line, kAttributeIcePwd)) {
2276 if (!GetValue(line, kAttributeIcePwd, &(session_td->ice_pwd), error)) {
2277 return false;
2278 }
2279 } else if (HasAttribute(line, kAttributeIceLite)) {
2280 session_td->ice_mode = cricket::ICEMODE_LITE;
2281 } else if (HasAttribute(line, kAttributeIceOption)) {
2282 if (!ParseIceOptions(line, &(session_td->transport_options), error)) {
2283 return false;
2284 }
2285 } else if (HasAttribute(line, kAttributeFingerprint)) {
2286 if (session_td->identity_fingerprint.get()) {
2287 return ParseFailed(
2288 line,
2289 "Can't have multiple fingerprint attributes at the same level.",
2290 error);
2291 }
Steve Anton4905edb2018-10-16 02:27:442292 std::unique_ptr<rtc::SSLFingerprint> fingerprint;
henrike@webrtc.org28e20752013-07-10 00:45:362293 if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
2294 return false;
2295 }
Steve Anton4905edb2018-10-16 02:27:442296 session_td->identity_fingerprint = std::move(fingerprint);
sergeyu@chromium.org0be6aa02013-08-23 23:21:252297 } else if (HasAttribute(line, kAttributeSetup)) {
2298 if (!ParseDtlsSetup(line, &(session_td->connection_role), error)) {
2299 return false;
2300 }
henrike@webrtc.org28e20752013-07-10 00:45:362301 } else if (HasAttribute(line, kAttributeMsidSemantics)) {
2302 std::string semantics;
2303 if (!GetValue(line, kAttributeMsidSemantics, &semantics, error)) {
2304 return false;
2305 }
deadbeefc80741f2015-10-22 20:14:452306 desc->set_msid_supported(
2307 CaseInsensitiveFind(semantics, kMediaStreamSemantic));
Johannes Kron0854eb62018-10-10 20:33:202308 } else if (HasAttribute(line, kAttributeExtmapAllowMixed)) {
Johannes Kron9581bc42018-10-23 08:17:392309 desc->set_extmap_allow_mixed(true);
henrike@webrtc.org28e20752013-07-10 00:45:362310 } else if (HasAttribute(line, kAttributeExtmap)) {
isheriff6f8d6862016-05-26 18:24:552311 RtpExtension extmap;
henrike@webrtc.org28e20752013-07-10 00:45:362312 if (!ParseExtmap(line, &extmap, error)) {
2313 return false;
2314 }
2315 session_extmaps->push_back(extmap);
Piotr (Peter) Slatala13e570f2019-02-27 19:34:262316 } else if (HasAttribute(line, kMediaTransportSettingLine)) {
2317 std::string transport_name;
2318 std::string transport_setting;
2319 if (!ParseMediaTransportLine(line, &transport_name, &transport_setting,
2320 error)) {
2321 return false;
2322 }
2323
2324 for (const auto& setting : desc->MediaTransportSettings()) {
2325 if (setting.transport_name == transport_name) {
2326 // Ignore repeated transport names rather than failing to parse so
2327 // that in the future the same transport could have multiple configs.
2328 RTC_LOG(INFO) << "x-mt line with repeated transport, transport_name="
2329 << transport_name;
2330 return true;
2331 }
2332 }
2333 desc->AddMediaTransportSetting(transport_name, transport_setting);
henrike@webrtc.org28e20752013-07-10 00:45:362334 }
2335 }
2336
2337 return true;
2338}
2339
2340bool ParseGroupAttribute(const std::string& line,
2341 cricket::SessionDescription* desc,
2342 SdpParseError* error) {
nisseede5da42017-01-12 13:15:362343 RTC_DCHECK(desc != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:362344
2345 // RFC 5888 and draft-holmberg-mmusic-sdp-bundle-negotiation-00
2346 // a=group:BUNDLE video voice
2347 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492348 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:362349 std::string semantics;
2350 if (!GetValue(fields[0], kAttributeGroup, &semantics, error)) {
2351 return false;
2352 }
2353 cricket::ContentGroup group(semantics);
2354 for (size_t i = 1; i < fields.size(); ++i) {
2355 group.AddContentName(fields[i]);
2356 }
2357 desc->AddGroup(group);
2358 return true;
2359}
2360
Steve Anton4905edb2018-10-16 02:27:442361static bool ParseFingerprintAttribute(
2362 const std::string& line,
2363 std::unique_ptr<rtc::SSLFingerprint>* fingerprint,
2364 SdpParseError* error) {
henrike@webrtc.org28e20752013-07-10 00:45:362365 if (!IsLineType(line, kLineTypeAttributes) ||
2366 !HasAttribute(line, kAttributeFingerprint)) {
2367 return ParseFailedExpectLine(line, 0, kLineTypeAttributes,
2368 kAttributeFingerprint, error);
2369 }
2370
2371 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492372 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:362373 const size_t expected_fields = 2;
2374 if (fields.size() != expected_fields) {
2375 return ParseFailedExpectFieldNum(line, expected_fields, error);
2376 }
2377
2378 // The first field here is "fingerprint:<hash>.
2379 std::string algorithm;
2380 if (!GetValue(fields[0], kAttributeFingerprint, &algorithm, error)) {
2381 return false;
2382 }
2383
2384 // Downcase the algorithm. Note that we don't need to downcase the
2385 // fingerprint because hex_decode can handle upper-case.
Steve Anton64b626b2019-01-29 01:25:262386 absl::c_transform(algorithm, algorithm.begin(), ::tolower);
henrike@webrtc.org28e20752013-07-10 00:45:362387
2388 // The second field is the digest value. De-hexify it.
Steve Anton4905edb2018-10-16 02:27:442389 *fingerprint =
2390 rtc::SSLFingerprint::CreateUniqueFromRfc4572(algorithm, fields[1]);
henrike@webrtc.org28e20752013-07-10 00:45:362391 if (!*fingerprint) {
Yves Gerey665174f2018-06-19 13:03:052392 return ParseFailed(line, "Failed to create fingerprint from the digest.",
henrike@webrtc.org28e20752013-07-10 00:45:362393 error);
2394 }
2395
2396 return true;
2397}
2398
sergeyu@chromium.org0be6aa02013-08-23 23:21:252399static bool ParseDtlsSetup(const std::string& line,
2400 cricket::ConnectionRole* role,
2401 SdpParseError* error) {
2402 // setup-attr = "a=setup:" role
2403 // role = "active" / "passive" / "actpass" / "holdconn"
2404 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492405 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterColonChar, &fields);
sergeyu@chromium.org0be6aa02013-08-23 23:21:252406 const size_t expected_fields = 2;
2407 if (fields.size() != expected_fields) {
2408 return ParseFailedExpectFieldNum(line, expected_fields, error);
2409 }
2410 std::string role_str = fields[1];
2411 if (!cricket::StringToConnectionRole(role_str, role)) {
2412 return ParseFailed(line, "Invalid attribute value.", error);
2413 }
2414 return true;
2415}
2416
deadbeef9d3584c2016-02-17 01:54:102417static bool ParseMsidAttribute(const std::string& line,
Seth Hampson5b4f0752018-04-02 23:31:362418 std::vector<std::string>* stream_ids,
deadbeef9d3584c2016-02-17 01:54:102419 std::string* track_id,
2420 SdpParseError* error) {
Seth Hampson5b4f0752018-04-02 23:31:362421 // https://datatracker.ietf.org/doc/draft-ietf-mmusic-msid/16/
deadbeef9d3584c2016-02-17 01:54:102422 // a=msid:<stream id> <track id>
2423 // msid-value = msid-id [ SP msid-appdata ]
2424 // msid-id = 1*64token-char ; see RFC 4566
2425 // msid-appdata = 1*64token-char ; see RFC 4566
2426 std::string field1;
Seth Hampson5b4f0752018-04-02 23:31:362427 std::string new_stream_id;
2428 std::string new_track_id;
Jonas Olssonec9e4922018-09-05 07:53:492429 if (!rtc::tokenize_first(line.substr(kLinePrefixLength),
2430 kSdpDelimiterSpaceChar, &field1, &new_track_id)) {
deadbeef9d3584c2016-02-17 01:54:102431 const size_t expected_fields = 2;
2432 return ParseFailedExpectFieldNum(line, expected_fields, error);
2433 }
2434
Seth Hampson5b4f0752018-04-02 23:31:362435 if (new_track_id.empty()) {
deadbeefa4549d62017-02-11 01:26:222436 return ParseFailed(line, "Missing track ID in msid attribute.", error);
2437 }
Seth Hampson5b4f0752018-04-02 23:31:362438 // All track ids should be the same within an m section in a Unified Plan SDP.
2439 if (!track_id->empty() && new_track_id.compare(*track_id) != 0) {
2440 return ParseFailed(
2441 line, "Two different track IDs in msid attribute in one m= section",
2442 error);
2443 }
2444 *track_id = new_track_id;
deadbeefa4549d62017-02-11 01:26:222445
deadbeef9d3584c2016-02-17 01:54:102446 // msid:<msid-id>
Seth Hampson5b4f0752018-04-02 23:31:362447 if (!GetValue(field1, kAttributeMsid, &new_stream_id, error)) {
deadbeef9d3584c2016-02-17 01:54:102448 return false;
2449 }
Seth Hampson5b4f0752018-04-02 23:31:362450 if (new_stream_id.empty()) {
deadbeefa4549d62017-02-11 01:26:222451 return ParseFailed(line, "Missing stream ID in msid attribute.", error);
2452 }
Seth Hampson5b4f0752018-04-02 23:31:362453 // The special value "-" indicates "no MediaStream".
2454 if (new_stream_id.compare(kNoStreamMsid) != 0) {
2455 stream_ids->push_back(new_stream_id);
2456 }
deadbeef9d3584c2016-02-17 01:54:102457 return true;
2458}
2459
Amit Hilbuchc57d5732018-12-11 23:30:112460static void RemoveInvalidRidDescriptions(const std::vector<int>& payload_types,
2461 std::vector<RidDescription>* rids) {
2462 RTC_DCHECK(rids);
2463 std::set<std::string> to_remove;
2464 std::set<std::string> unique_rids;
2465
2466 // Check the rids to see which ones should be removed.
2467 for (RidDescription& rid : *rids) {
2468 // In the case of a duplicate, the entire "a=rid" line, and all "a=rid"
2469 // lines with rid-ids that duplicate this line, are discarded and MUST NOT
2470 // be included in the SDP Answer.
2471 auto pair = unique_rids.insert(rid.rid);
2472 // Insert will "fail" if element already exists.
2473 if (!pair.second) {
2474 to_remove.insert(rid.rid);
2475 continue;
2476 }
2477
2478 // If the "a=rid" line contains a "pt=", the list of payload types
2479 // is verified against the list of valid payload types for the media
2480 // section (that is, those listed on the "m=" line). Any PT missing
2481 // from the "m=" line is discarded from the set of values in the
2482 // "pt=". If no values are left in the "pt=" parameter after this
2483 // processing, then the "a=rid" line is discarded.
2484 if (rid.payload_types.empty()) {
2485 // If formats were not specified, rid should not be removed.
2486 continue;
2487 }
2488
2489 // Note: Spec does not mention how to handle duplicate formats.
2490 // Media section does not handle duplicates either.
2491 std::set<int> removed_formats;
2492 for (int payload_type : rid.payload_types) {
Steve Anton64b626b2019-01-29 01:25:262493 if (!absl::c_linear_search(payload_types, payload_type)) {
Amit Hilbuchc57d5732018-12-11 23:30:112494 removed_formats.insert(payload_type);
2495 }
2496 }
2497
2498 rid.payload_types.erase(
2499 std::remove_if(rid.payload_types.begin(), rid.payload_types.end(),
2500 [&removed_formats](int format) {
2501 return removed_formats.count(format) > 0;
2502 }),
2503 rid.payload_types.end());
2504
2505 // If all formats were removed then remove the rid alogether.
2506 if (rid.payload_types.empty()) {
2507 to_remove.insert(rid.rid);
2508 }
2509 }
2510
2511 // Remove every rid description that appears in the to_remove list.
2512 if (!to_remove.empty()) {
2513 rids->erase(std::remove_if(rids->begin(), rids->end(),
2514 [&to_remove](const RidDescription& rid) {
2515 return to_remove.count(rid.rid) > 0;
2516 }),
2517 rids->end());
2518 }
2519}
2520
2521// Create a new list (because SimulcastLayerList is immutable) without any
2522// layers that have a rid in the to_remove list.
2523// If a group of alternatives is empty after removing layers, the group should
2524// be removed altogether.
2525static SimulcastLayerList RemoveRidsFromSimulcastLayerList(
2526 const std::set<std::string>& to_remove,
2527 const SimulcastLayerList& layers) {
2528 SimulcastLayerList result;
2529 for (const std::vector<SimulcastLayer>& vector : layers) {
2530 std::vector<SimulcastLayer> new_layers;
2531 for (const SimulcastLayer& layer : vector) {
2532 if (to_remove.find(layer.rid) == to_remove.end()) {
2533 new_layers.push_back(layer);
2534 }
2535 }
2536 // If all layers were removed, do not add an entry.
2537 if (!new_layers.empty()) {
2538 result.AddLayerWithAlternatives(new_layers);
2539 }
2540 }
2541
2542 return result;
2543}
2544
2545// Will remove Simulcast Layers if:
2546// 1. They appear in both send and receive directions.
2547// 2. They do not appear in the list of |valid_rids|.
2548static void RemoveInvalidRidsFromSimulcast(
2549 const std::vector<RidDescription>& valid_rids,
2550 SimulcastDescription* simulcast) {
2551 RTC_DCHECK(simulcast);
2552 std::set<std::string> to_remove;
2553 std::vector<SimulcastLayer> all_send_layers =
2554 simulcast->send_layers().GetAllLayers();
2555 std::vector<SimulcastLayer> all_receive_layers =
2556 simulcast->receive_layers().GetAllLayers();
2557
2558 // If a rid appears in both send and receive directions, remove it from both.
2559 // This algorithm runs in O(n^2) time, but for small n (as is the case with
2560 // simulcast layers) it should still perform well.
2561 for (const SimulcastLayer& send_layer : all_send_layers) {
Steve Anton64b626b2019-01-29 01:25:262562 if (absl::c_any_of(all_receive_layers,
2563 [&send_layer](const SimulcastLayer& layer) {
2564 return layer.rid == send_layer.rid;
2565 })) {
Amit Hilbuchc57d5732018-12-11 23:30:112566 to_remove.insert(send_layer.rid);
2567 }
2568 }
2569
2570 // Add any rid that is not in the valid list to the remove set.
2571 for (const SimulcastLayer& send_layer : all_send_layers) {
Steve Anton64b626b2019-01-29 01:25:262572 if (absl::c_none_of(valid_rids, [&send_layer](const RidDescription& rid) {
Florent Castellic4421972019-07-02 18:27:422573 return send_layer.rid == rid.rid &&
2574 rid.direction == cricket::RidDirection::kSend;
Steve Anton64b626b2019-01-29 01:25:262575 })) {
Amit Hilbuchc57d5732018-12-11 23:30:112576 to_remove.insert(send_layer.rid);
2577 }
2578 }
2579
2580 // Add any rid that is not in the valid list to the remove set.
2581 for (const SimulcastLayer& receive_layer : all_receive_layers) {
Florent Castellic4421972019-07-02 18:27:422582 if (absl::c_none_of(
2583 valid_rids, [&receive_layer](const RidDescription& rid) {
2584 return receive_layer.rid == rid.rid &&
2585 rid.direction == cricket::RidDirection::kReceive;
2586 })) {
Amit Hilbuchc57d5732018-12-11 23:30:112587 to_remove.insert(receive_layer.rid);
2588 }
2589 }
2590
2591 simulcast->send_layers() =
2592 RemoveRidsFromSimulcastLayerList(to_remove, simulcast->send_layers());
2593 simulcast->receive_layers() =
2594 RemoveRidsFromSimulcastLayerList(to_remove, simulcast->receive_layers());
2595}
2596
henrike@webrtc.org28e20752013-07-10 00:45:362597// RFC 3551
2598// PT encoding media type clock rate channels
2599// name (Hz)
2600// 0 PCMU A 8,000 1
2601// 1 reserved A
2602// 2 reserved A
2603// 3 GSM A 8,000 1
2604// 4 G723 A 8,000 1
2605// 5 DVI4 A 8,000 1
2606// 6 DVI4 A 16,000 1
2607// 7 LPC A 8,000 1
2608// 8 PCMA A 8,000 1
2609// 9 G722 A 8,000 1
2610// 10 L16 A 44,100 2
2611// 11 L16 A 44,100 1
2612// 12 QCELP A 8,000 1
2613// 13 CN A 8,000 1
2614// 14 MPA A 90,000 (see text)
2615// 15 G728 A 8,000 1
2616// 16 DVI4 A 11,025 1
2617// 17 DVI4 A 22,050 1
2618// 18 G729 A 8,000 1
2619struct StaticPayloadAudioCodec {
2620 const char* name;
2621 int clockrate;
Peter Kasting69558702016-01-13 00:26:352622 size_t channels;
henrike@webrtc.org28e20752013-07-10 00:45:362623};
2624static const StaticPayloadAudioCodec kStaticPayloadAudioCodecs[] = {
Yves Gerey665174f2018-06-19 13:03:052625 {"PCMU", 8000, 1}, {"reserved", 0, 0}, {"reserved", 0, 0},
2626 {"GSM", 8000, 1}, {"G723", 8000, 1}, {"DVI4", 8000, 1},
2627 {"DVI4", 16000, 1}, {"LPC", 8000, 1}, {"PCMA", 8000, 1},
2628 {"G722", 8000, 1}, {"L16", 44100, 2}, {"L16", 44100, 1},
2629 {"QCELP", 8000, 1}, {"CN", 8000, 1}, {"MPA", 90000, 1},
2630 {"G728", 8000, 1}, {"DVI4", 11025, 1}, {"DVI4", 22050, 1},
2631 {"G729", 8000, 1},
henrike@webrtc.org28e20752013-07-10 00:45:362632};
2633
Yves Gerey665174f2018-06-19 13:03:052634void MaybeCreateStaticPayloadAudioCodecs(const std::vector<int>& fmts,
2635 AudioContentDescription* media_desc) {
henrike@webrtc.org28e20752013-07-10 00:45:362636 if (!media_desc) {
2637 return;
2638 }
deadbeef67cf2c12016-04-13 17:07:162639 RTC_DCHECK(media_desc->codecs().empty());
solenberg9fa49752016-10-08 20:02:442640 for (int payload_type : fmts) {
Yves Gerey665174f2018-06-19 13:03:052641 if (!media_desc->HasCodec(payload_type) && payload_type >= 0 &&
kjellander3e33bfe2016-06-20 14:04:092642 static_cast<uint32_t>(payload_type) <
2643 arraysize(kStaticPayloadAudioCodecs)) {
henrike@webrtc.org28e20752013-07-10 00:45:362644 std::string encoding_name = kStaticPayloadAudioCodecs[payload_type].name;
2645 int clock_rate = kStaticPayloadAudioCodecs[payload_type].clockrate;
Peter Kasting69558702016-01-13 00:26:352646 size_t channels = kStaticPayloadAudioCodecs[payload_type].channels;
henrike@webrtc.org28e20752013-07-10 00:45:362647 media_desc->AddCodec(cricket::AudioCodec(payload_type, encoding_name,
deadbeef67cf2c12016-04-13 17:07:162648 clock_rate, 0, channels));
henrike@webrtc.org28e20752013-07-10 00:45:362649 }
henrike@webrtc.org28e20752013-07-10 00:45:362650 }
2651}
2652
2653template <class C>
Steve Anton5a1de872018-12-18 19:25:552654static std::unique_ptr<C> ParseContentDescription(
2655 const std::string& message,
2656 const cricket::MediaType media_type,
2657 int mline_index,
2658 const std::string& protocol,
2659 const std::vector<int>& payload_types,
2660 size_t* pos,
2661 std::string* content_name,
2662 bool* bundle_only,
2663 int* msid_signaling,
2664 TransportDescription* transport,
2665 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
2666 webrtc::SdpParseError* error) {
2667 auto media_desc = absl::make_unique<C>();
deadbeef67cf2c12016-04-13 17:07:162668 if (!ParseContent(message, media_type, mline_index, protocol, payload_types,
Steve Anton5a1de872018-12-18 19:25:552669 pos, content_name, bundle_only, msid_signaling,
2670 media_desc.get(), transport, candidates, error)) {
zhihuang38989e52017-03-21 18:04:532671 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:362672 }
2673 // Sort the codecs according to the m-line fmt list.
deadbeef67cf2c12016-04-13 17:07:162674 std::unordered_map<int, int> payload_type_preferences;
2675 // "size + 1" so that the lowest preference payload type has a preference of
2676 // 1, which is greater than the default (0) for payload types not in the fmt
2677 // list.
2678 int preference = static_cast<int>(payload_types.size() + 1);
2679 for (int pt : payload_types) {
2680 payload_type_preferences[pt] = preference--;
2681 }
2682 std::vector<typename C::CodecType> codecs = media_desc->codecs();
Steve Anton64b626b2019-01-29 01:25:262683 absl::c_sort(
2684 codecs, [&payload_type_preferences](const typename C::CodecType& a,
2685 const typename C::CodecType& b) {
2686 return payload_type_preferences[a.id] > payload_type_preferences[b.id];
2687 });
deadbeef67cf2c12016-04-13 17:07:162688 media_desc->set_codecs(codecs);
henrike@webrtc.org28e20752013-07-10 00:45:362689 return media_desc;
2690}
2691
Steve Anton5a1de872018-12-18 19:25:552692bool ParseMediaDescription(
2693 const std::string& message,
2694 const TransportDescription& session_td,
2695 const RtpHeaderExtensions& session_extmaps,
2696 size_t* pos,
2697 const rtc::SocketAddress& session_connection_addr,
2698 cricket::SessionDescription* desc,
2699 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
2700 SdpParseError* error) {
nisseede5da42017-01-12 13:15:362701 RTC_DCHECK(desc != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:362702 std::string line;
2703 int mline_index = -1;
Steve Antone831b8c2018-02-01 20:22:162704 int msid_signaling = 0;
henrike@webrtc.org28e20752013-07-10 00:45:362705
2706 // Zero or more media descriptions
2707 // RFC 4566
2708 // m=<media> <port> <proto> <fmt>
2709 while (GetLineWithType(message, pos, &line, kLineTypeMedia)) {
2710 ++mline_index;
2711
2712 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:492713 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
zstein4b2e0822017-02-18 03:48:382714
henrike@webrtc.org28e20752013-07-10 00:45:362715 const size_t expected_min_fields = 4;
2716 if (fields.size() < expected_min_fields) {
2717 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
2718 }
deadbeef25ed4352016-12-13 02:37:362719 bool port_rejected = false;
henrike@webrtc.org28e20752013-07-10 00:45:362720 // RFC 3264
2721 // To reject an offered stream, the port number in the corresponding stream
2722 // in the answer MUST be set to zero.
2723 if (fields[1] == kMediaPortRejected) {
deadbeef25ed4352016-12-13 02:37:362724 port_rejected = true;
henrike@webrtc.org28e20752013-07-10 00:45:362725 }
2726
zhihuang38989e52017-03-21 18:04:532727 int port = 0;
2728 if (!rtc::FromString<int>(fields[1], &port) || !IsValidPort(port)) {
2729 return ParseFailed(line, "The port number is invalid", error);
2730 }
henrike@webrtc.org28e20752013-07-10 00:45:362731 std::string protocol = fields[2];
henrike@webrtc.org28e20752013-07-10 00:45:362732
2733 // <fmt>
deadbeef67cf2c12016-04-13 17:07:162734 std::vector<int> payload_types;
Harald Alvestrand5fc28b12019-05-13 11:36:162735 if (cricket::IsRtpProtocol(protocol)) {
Yves Gerey665174f2018-06-19 13:03:052736 for (size_t j = 3; j < fields.size(); ++j) {
jiayl@webrtc.orgddb85ab2014-09-05 16:31:562737 // TODO(wu): Remove when below bug is fixed.
2738 // https://bugzilla.mozilla.org/show_bug.cgi?id=996329
pbosbb36fdf2015-07-09 14:48:142739 if (fields[j].empty() && j == fields.size() - 1) {
jiayl@webrtc.orgddb85ab2014-09-05 16:31:562740 continue;
2741 }
wu@webrtc.org36eda7c2014-04-15 20:37:302742
jiayl@webrtc.orgddb85ab2014-09-05 16:31:562743 int pl = 0;
pkasting@chromium.orge9facf82015-02-17 20:36:282744 if (!GetPayloadTypeFromString(line, fields[j], &pl, error)) {
jiayl@webrtc.orgddb85ab2014-09-05 16:31:562745 return false;
2746 }
deadbeef67cf2c12016-04-13 17:07:162747 payload_types.push_back(pl);
wu@webrtc.org5e760e72014-04-02 23:19:092748 }
henrike@webrtc.org28e20752013-07-10 00:45:362749 }
2750
2751 // Make a temporary TransportDescription based on |session_td|.
2752 // Some of this gets overwritten by ParseContent.
deadbeef46eed762016-01-28 21:24:372753 TransportDescription transport(
2754 session_td.transport_options, session_td.ice_ufrag, session_td.ice_pwd,
2755 session_td.ice_mode, session_td.connection_role,
2756 session_td.identity_fingerprint.get());
henrike@webrtc.org28e20752013-07-10 00:45:362757
kwibergd1fe2812016-04-27 13:47:292758 std::unique_ptr<MediaContentDescription> content;
henrike@webrtc.org28e20752013-07-10 00:45:362759 std::string content_name;
deadbeef25ed4352016-12-13 02:37:362760 bool bundle_only = false;
Steve Antone831b8c2018-02-01 20:22:162761 int section_msid_signaling = 0;
henrike@webrtc.org28e20752013-07-10 00:45:362762 if (HasAttribute(line, kMediaTypeVideo)) {
Steve Anton5a1de872018-12-18 19:25:552763 content = ParseContentDescription<VideoContentDescription>(
deadbeef67cf2c12016-04-13 17:07:162764 message, cricket::MEDIA_TYPE_VIDEO, mline_index, protocol,
Steve Antone831b8c2018-02-01 20:22:162765 payload_types, pos, &content_name, &bundle_only,
Steve Anton5a1de872018-12-18 19:25:552766 &section_msid_signaling, &transport, candidates, error);
henrike@webrtc.org28e20752013-07-10 00:45:362767 } else if (HasAttribute(line, kMediaTypeAudio)) {
Steve Anton5a1de872018-12-18 19:25:552768 content = ParseContentDescription<AudioContentDescription>(
deadbeef67cf2c12016-04-13 17:07:162769 message, cricket::MEDIA_TYPE_AUDIO, mline_index, protocol,
Steve Antone831b8c2018-02-01 20:22:162770 payload_types, pos, &content_name, &bundle_only,
Steve Anton5a1de872018-12-18 19:25:552771 &section_msid_signaling, &transport, candidates, error);
henrike@webrtc.org28e20752013-07-10 00:45:362772 } else if (HasAttribute(line, kMediaTypeData)) {
Harald Alvestrand5fc28b12019-05-13 11:36:162773 if (cricket::IsDtlsSctp(protocol)) {
2774 // The draft-03 format is:
2775 // m=application <port> DTLS/SCTP <sctp-port>...
2776 // use_sctpmap should be false.
2777 // The draft-26 format is:
2778 // m=application <port> UDP/DTLS/SCTP webrtc-datachannel
2779 // use_sctpmap should be false.
2780 auto data_desc = absl::make_unique<SctpDataContentDescription>();
Harald Alvestrandfbb45bd2019-05-15 06:07:472781 // Default max message size is 64K
2782 // according to draft-ietf-mmusic-sctp-sdp-26
2783 data_desc->set_max_message_size(kDefaultSctpMaxMessageSize);
zstein4b2e0822017-02-18 03:48:382784 int p;
2785 if (rtc::FromString(fields[3], &p)) {
Harald Alvestrand5fc28b12019-05-13 11:36:162786 data_desc->set_port(p);
zstein4b2e0822017-02-18 03:48:382787 } else if (fields[3] == kDefaultSctpmapProtocol) {
2788 data_desc->set_use_sctpmap(false);
2789 }
Harald Alvestrand5fc28b12019-05-13 11:36:162790 if (!ParseContent(message, cricket::MEDIA_TYPE_DATA, mline_index,
2791 protocol, payload_types, pos, &content_name,
2792 &bundle_only, &section_msid_signaling,
2793 data_desc.get(), &transport, candidates, error)) {
2794 return false;
2795 }
2796 data_desc->set_protocol(protocol);
2797 content = std::move(data_desc);
2798 } else {
2799 // RTP
2800 std::unique_ptr<RtpDataContentDescription> data_desc =
2801 ParseContentDescription<RtpDataContentDescription>(
2802 message, cricket::MEDIA_TYPE_DATA, mline_index, protocol,
2803 payload_types, pos, &content_name, &bundle_only,
2804 &section_msid_signaling, &transport, candidates, error);
2805 content = std::move(data_desc);
wu@webrtc.org78187522013-10-07 23:32:022806 }
henrike@webrtc.org28e20752013-07-10 00:45:362807 } else {
Mirko Bonadei675513b2017-11-09 10:09:252808 RTC_LOG(LS_WARNING) << "Unsupported media type: " << line;
henrike@webrtc.org28e20752013-07-10 00:45:362809 continue;
2810 }
2811 if (!content.get()) {
2812 // ParseContentDescription returns NULL if failed.
2813 return false;
2814 }
2815
Steve Antone831b8c2018-02-01 20:22:162816 msid_signaling |= section_msid_signaling;
2817
deadbeef25ed4352016-12-13 02:37:362818 bool content_rejected = false;
deadbeef12771a12017-01-03 21:53:472819 // A port of 0 is not interpreted as a rejected m= section when it's
2820 // used along with a=bundle-only.
deadbeef25ed4352016-12-13 02:37:362821 if (bundle_only) {
deadbeef25ed4352016-12-13 02:37:362822 if (!port_rejected) {
deadbeef12771a12017-01-03 21:53:472823 // Usage of bundle-only with a nonzero port is unspecified. So just
2824 // ignore bundle-only if we see this.
2825 bundle_only = false;
Mirko Bonadei675513b2017-11-09 10:09:252826 RTC_LOG(LS_WARNING)
deadbeef12771a12017-01-03 21:53:472827 << "a=bundle-only attribute observed with a nonzero "
Jonas Olsson45cc8902018-02-13 09:37:072828 "port; this usage is unspecified so the attribute is being "
2829 "ignored.";
deadbeef25ed4352016-12-13 02:37:362830 }
2831 } else {
2832 // If not using bundle-only, interpret port 0 in the normal way; the m=
2833 // section is being rejected.
2834 content_rejected = port_rejected;
2835 }
2836
Harald Alvestrand5fc28b12019-05-13 11:36:162837 if (cricket::IsRtpProtocol(protocol) && !content->as_sctp()) {
2838 content->set_protocol(protocol);
henrike@webrtc.org28e20752013-07-10 00:45:362839 // Set the extmap.
2840 if (!session_extmaps.empty() &&
2841 !content->rtp_header_extensions().empty()) {
2842 return ParseFailed("",
2843 "The a=extmap MUST be either all session level or "
2844 "all media level.",
2845 error);
2846 }
2847 for (size_t i = 0; i < session_extmaps.size(); ++i) {
2848 content->AddRtpHeaderExtension(session_extmaps[i]);
2849 }
Harald Alvestrand5fc28b12019-05-13 11:36:162850 } else if (content->as_sctp()) {
2851 // Do nothing, it's OK
2852 } else {
2853 RTC_LOG(LS_WARNING) << "Parse failed with unknown protocol " << protocol;
2854 return false;
henrike@webrtc.org28e20752013-07-10 00:45:362855 }
zhihuang38989e52017-03-21 18:04:532856
2857 // Use the session level connection address if the media level addresses are
2858 // not specified.
2859 rtc::SocketAddress address;
2860 address = content->connection_address().IsNil()
2861 ? session_connection_addr
2862 : content->connection_address();
2863 address.SetPort(port);
2864 content->set_connection_address(address);
2865
henrike@webrtc.org28e20752013-07-10 00:45:362866 desc->AddContent(content_name,
Harald Alvestrand5fc28b12019-05-13 11:36:162867 cricket::IsDtlsSctp(protocol) ? MediaProtocolType::kSctp
2868 : MediaProtocolType::kRtp,
Harald Alvestrand1716d392019-06-03 18:35:452869 content_rejected, bundle_only, std::move(content));
henrike@webrtc.org28e20752013-07-10 00:45:362870 // Create TransportInfo with the media level "ice-pwd" and "ice-ufrag".
Steve Anton06817cd2018-12-18 23:55:302871 desc->AddTransportInfo(TransportInfo(content_name, transport));
henrike@webrtc.org28e20752013-07-10 00:45:362872 }
wu@webrtc.orgcecfd182013-10-30 05:18:122873
Steve Antone831b8c2018-02-01 20:22:162874 desc->set_msid_signaling(msid_signaling);
2875
wu@webrtc.orgcecfd182013-10-30 05:18:122876 size_t end_of_message = message.size();
2877 if (mline_index == -1 && *pos != end_of_message) {
2878 ParseFailed(message, *pos, "Expects m line.", error);
2879 return false;
2880 }
henrike@webrtc.org28e20752013-07-10 00:45:362881 return true;
2882}
2883
2884bool VerifyCodec(const cricket::Codec& codec) {
2885 // Codec has not been populated correctly unless the name has been set. This
2886 // can happen if an SDP has an fmtp or rtcp-fb with a payload type but doesn't
2887 // have a corresponding "rtpmap" line.
htab39db842016-12-08 09:50:482888 return !codec.name.empty();
henrike@webrtc.org28e20752013-07-10 00:45:362889}
2890
2891bool VerifyAudioCodecs(const AudioContentDescription* audio_desc) {
Steve Anton64b626b2019-01-29 01:25:262892 return absl::c_all_of(audio_desc->codecs(), &VerifyCodec);
henrike@webrtc.org28e20752013-07-10 00:45:362893}
2894
2895bool VerifyVideoCodecs(const VideoContentDescription* video_desc) {
Steve Anton64b626b2019-01-29 01:25:262896 return absl::c_all_of(video_desc->codecs(), &VerifyCodec);
henrike@webrtc.org28e20752013-07-10 00:45:362897}
2898
2899void AddParameters(const cricket::CodecParameterMap& parameters,
2900 cricket::Codec* codec) {
Steve Anton4daf66e2018-09-07 21:55:532901 for (const auto& entry : parameters) {
2902 const std::string& key = entry.first;
2903 const std::string& value = entry.second;
2904 codec->SetParam(key, value);
henrike@webrtc.org28e20752013-07-10 00:45:362905 }
2906}
2907
2908void AddFeedbackParameter(const cricket::FeedbackParam& feedback_param,
2909 cricket::Codec* codec) {
2910 codec->AddFeedbackParam(feedback_param);
2911}
2912
2913void AddFeedbackParameters(const cricket::FeedbackParams& feedback_params,
2914 cricket::Codec* codec) {
Steve Anton4daf66e2018-09-07 21:55:532915 for (const cricket::FeedbackParam& param : feedback_params.params()) {
2916 codec->AddFeedbackParam(param);
henrike@webrtc.org28e20752013-07-10 00:45:362917 }
2918}
2919
2920// Gets the current codec setting associated with |payload_type|. If there
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342921// is no Codec associated with that payload type it returns an empty codec
henrike@webrtc.org28e20752013-07-10 00:45:362922// with that payload type.
2923template <class T>
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342924T GetCodecWithPayloadType(const std::vector<T>& codecs, int payload_type) {
magjedb05fa242016-11-11 12:00:162925 const T* codec = FindCodecById(codecs, payload_type);
2926 if (codec)
2927 return *codec;
2928 // Return empty codec with |payload_type|.
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342929 T ret_val;
magjedb05fa242016-11-11 12:00:162930 ret_val.id = payload_type;
henrike@webrtc.org28e20752013-07-10 00:45:362931 return ret_val;
2932}
2933
2934// Updates or creates a new codec entry in the audio description.
2935template <class T, class U>
2936void AddOrReplaceCodec(MediaContentDescription* content_desc, const U& codec) {
2937 T* desc = static_cast<T*>(content_desc);
2938 std::vector<U> codecs = desc->codecs();
2939 bool found = false;
Steve Anton4daf66e2018-09-07 21:55:532940 for (U& existing_codec : codecs) {
2941 if (codec.id == existing_codec.id) {
2942 // Overwrite existing codec with the new codec.
2943 existing_codec = codec;
henrike@webrtc.org28e20752013-07-10 00:45:362944 found = true;
2945 break;
2946 }
2947 }
2948 if (!found) {
2949 desc->AddCodec(codec);
2950 return;
2951 }
2952 desc->set_codecs(codecs);
2953}
2954
2955// Adds or updates existing codec corresponding to |payload_type| according
2956// to |parameters|.
2957template <class T, class U>
Yves Gerey665174f2018-06-19 13:03:052958void UpdateCodec(MediaContentDescription* content_desc,
2959 int payload_type,
henrike@webrtc.org28e20752013-07-10 00:45:362960 const cricket::CodecParameterMap& parameters) {
2961 // Codec might already have been populated (from rtpmap).
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342962 U new_codec = GetCodecWithPayloadType(static_cast<T*>(content_desc)->codecs(),
2963 payload_type);
henrike@webrtc.org28e20752013-07-10 00:45:362964 AddParameters(parameters, &new_codec);
2965 AddOrReplaceCodec<T, U>(content_desc, new_codec);
2966}
2967
2968// Adds or updates existing codec corresponding to |payload_type| according
2969// to |feedback_param|.
2970template <class T, class U>
Yves Gerey665174f2018-06-19 13:03:052971void UpdateCodec(MediaContentDescription* content_desc,
2972 int payload_type,
henrike@webrtc.org28e20752013-07-10 00:45:362973 const cricket::FeedbackParam& feedback_param) {
2974 // Codec might already have been populated (from rtpmap).
changbin.shao@webrtc.org2d25b442015-03-16 04:14:342975 U new_codec = GetCodecWithPayloadType(static_cast<T*>(content_desc)->codecs(),
2976 payload_type);
henrike@webrtc.org28e20752013-07-10 00:45:362977 AddFeedbackParameter(feedback_param, &new_codec);
2978 AddOrReplaceCodec<T, U>(content_desc, new_codec);
2979}
2980
Mirta Dvornicic479a3c02019-06-04 13:38:502981// Adds or updates existing video codec corresponding to |payload_type|
2982// according to |packetization|.
2983void UpdateVideoCodecPacketization(VideoContentDescription* video_desc,
2984 int payload_type,
2985 const std::string& packetization) {
2986 if (packetization != cricket::kPacketizationParamRaw) {
2987 // Ignore unsupported packetization attribute.
2988 return;
2989 }
2990
2991 // Codec might already have been populated (from rtpmap).
2992 cricket::VideoCodec codec =
2993 GetCodecWithPayloadType(video_desc->codecs(), payload_type);
2994 codec.packetization = packetization;
2995 AddOrReplaceCodec<VideoContentDescription, cricket::VideoCodec>(video_desc,
2996 codec);
2997}
2998
jlmiller@webrtc.orga744a282015-02-18 21:37:462999template <class T>
3000bool PopWildcardCodec(std::vector<T>* codecs, T* wildcard_codec) {
3001 for (auto iter = codecs->begin(); iter != codecs->end(); ++iter) {
henrike@webrtc.org28e20752013-07-10 00:45:363002 if (iter->id == kWildcardPayloadType) {
3003 *wildcard_codec = *iter;
3004 codecs->erase(iter);
3005 return true;
3006 }
3007 }
3008 return false;
3009}
3010
Yves Gerey665174f2018-06-19 13:03:053011template <class T>
jlmiller@webrtc.orga744a282015-02-18 21:37:463012void UpdateFromWildcardCodecs(cricket::MediaContentDescriptionImpl<T>* desc) {
3013 auto codecs = desc->codecs();
3014 T wildcard_codec;
henrike@webrtc.org28e20752013-07-10 00:45:363015 if (!PopWildcardCodec(&codecs, &wildcard_codec)) {
3016 return;
3017 }
jlmiller@webrtc.orga744a282015-02-18 21:37:463018 for (auto& codec : codecs) {
henrike@webrtc.org28e20752013-07-10 00:45:363019 AddFeedbackParameters(wildcard_codec.feedback_params, &codec);
3020 }
jlmiller@webrtc.orga744a282015-02-18 21:37:463021 desc->set_codecs(codecs);
henrike@webrtc.org28e20752013-07-10 00:45:363022}
3023
Yves Gerey665174f2018-06-19 13:03:053024void AddAudioAttribute(const std::string& name,
3025 const std::string& value,
henrike@webrtc.org28e20752013-07-10 00:45:363026 AudioContentDescription* audio_desc) {
3027 if (value.empty()) {
3028 return;
3029 }
3030 std::vector<cricket::AudioCodec> codecs = audio_desc->codecs();
Steve Anton4daf66e2018-09-07 21:55:533031 for (cricket::AudioCodec& codec : codecs) {
3032 codec.params[name] = value;
henrike@webrtc.org28e20752013-07-10 00:45:363033 }
3034 audio_desc->set_codecs(codecs);
3035}
3036
3037bool ParseContent(const std::string& message,
Patrik Höglundb6b29e02018-06-21 14:58:013038 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:363039 int mline_index,
3040 const std::string& protocol,
deadbeef67cf2c12016-04-13 17:07:163041 const std::vector<int>& payload_types,
henrike@webrtc.org28e20752013-07-10 00:45:363042 size_t* pos,
3043 std::string* content_name,
deadbeef25ed4352016-12-13 02:37:363044 bool* bundle_only,
Steve Antone831b8c2018-02-01 20:22:163045 int* msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:363046 MediaContentDescription* media_desc,
3047 TransportDescription* transport,
Steve Anton5a1de872018-12-18 19:25:553048 std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
henrike@webrtc.org28e20752013-07-10 00:45:363049 SdpParseError* error) {
nisseede5da42017-01-12 13:15:363050 RTC_DCHECK(media_desc != NULL);
3051 RTC_DCHECK(content_name != NULL);
3052 RTC_DCHECK(transport != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:363053
henrike@webrtc.org704bf9e2014-02-27 17:52:043054 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
Steve Antonb1c1de12017-12-21 23:14:303055 MaybeCreateStaticPayloadAudioCodecs(payload_types, media_desc->as_audio());
henrike@webrtc.org704bf9e2014-02-27 17:52:043056 }
3057
henrike@webrtc.org28e20752013-07-10 00:45:363058 // The media level "ice-ufrag" and "ice-pwd".
3059 // The candidates before update the media level "ice-pwd" and "ice-ufrag".
3060 Candidates candidates_orig;
3061 std::string line;
3062 std::string mline_id;
3063 // Tracks created out of the ssrc attributes.
3064 StreamParamsVec tracks;
3065 SsrcInfoVec ssrc_infos;
3066 SsrcGroupVec ssrc_groups;
3067 std::string maxptime_as_string;
3068 std::string ptime_as_string;
Seth Hampson5b4f0752018-04-02 23:31:363069 std::vector<std::string> stream_ids;
deadbeef9d3584c2016-02-17 01:54:103070 std::string track_id;
Amit Hilbuchc57d5732018-12-11 23:30:113071 SdpSerializer deserializer;
3072 std::vector<RidDescription> rids;
Amit Hilbucha2012042018-12-03 19:35:053073 SimulcastDescription simulcast;
henrike@webrtc.org28e20752013-07-10 00:45:363074
henrike@webrtc.org28e20752013-07-10 00:45:363075 // Loop until the next m line
3076 while (!IsLineType(message, kLineTypeMedia, *pos)) {
3077 if (!GetLine(message, pos, &line)) {
3078 if (*pos >= message.size()) {
3079 break; // Done parsing
3080 } else {
sergeyu@chromium.org5bc25c42013-12-05 00:24:063081 return ParseFailed(message, *pos, "Invalid SDP line.", error);
henrike@webrtc.org28e20752013-07-10 00:45:363082 }
3083 }
3084
henrike@webrtc.org28e20752013-07-10 00:45:363085 // RFC 4566
3086 // b=* (zero or more bandwidth information lines)
3087 if (IsLineType(line, kLineTypeSessionBandwidth)) {
3088 std::string bandwidth;
3089 if (HasAttribute(line, kApplicationSpecificMaximum)) {
3090 if (!GetValue(line, kApplicationSpecificMaximum, &bandwidth, error)) {
3091 return false;
3092 } else {
wu@webrtc.org5e760e72014-04-02 23:19:093093 int b = 0;
3094 if (!GetValueFromString(line, bandwidth, &b, error)) {
3095 return false;
3096 }
deadbeef3e8016e2017-08-04 00:49:303097 // TODO(deadbeef): Historically, applications may be setting a value
3098 // of -1 to mean "unset any previously set bandwidth limit", even
3099 // though ommitting the "b=AS" entirely will do just that. Once we've
3100 // transitioned applications to doing the right thing, it would be
3101 // better to treat this as a hard error instead of just ignoring it.
3102 if (b == -1) {
Mirko Bonadei675513b2017-11-09 10:09:253103 RTC_LOG(LS_WARNING)
3104 << "Ignoring \"b=AS:-1\"; will be treated as \"no "
3105 "bandwidth limit\".";
deadbeef3e8016e2017-08-04 00:49:303106 continue;
3107 }
deadbeefbc88c6b2017-08-02 18:26:343108 if (b < 0) {
3109 return ParseFailed(line, "b=AS value can't be negative.", error);
3110 }
Peter Thatcherc0c3a862015-06-24 22:31:253111 // We should never use more than the default bandwidth for RTP-based
3112 // data channels. Don't allow SDP to set the bandwidth, because
3113 // that would give JS the opportunity to "break the Internet".
3114 // See: https://code.google.com/p/chromium/issues/detail?id=280726
Harald Alvestrand5fc28b12019-05-13 11:36:163115 if (media_type == cricket::MEDIA_TYPE_DATA &&
3116 cricket::IsRtpProtocol(protocol) &&
Peter Thatcherc0c3a862015-06-24 22:31:253117 b > cricket::kDataMaxBandwidth / 1000) {
Jonas Olssonec9e4922018-09-05 07:53:493118 rtc::StringBuilder description;
Peter Thatcherc0c3a862015-06-24 22:31:253119 description << "RTP-based data channels may not send more than "
3120 << cricket::kDataMaxBandwidth / 1000 << "kbps.";
3121 return ParseFailed(line, description.str(), error);
3122 }
deadbeefb2362572016-12-14 00:37:063123 // Prevent integer overflow.
3124 b = std::min(b, INT_MAX / 1000);
wu@webrtc.org5e760e72014-04-02 23:19:093125 media_desc->set_bandwidth(b * 1000);
henrike@webrtc.org28e20752013-07-10 00:45:363126 }
3127 }
3128 continue;
3129 }
3130
zhihuang38989e52017-03-21 18:04:533131 // Parse the media level connection data.
3132 if (IsLineType(line, kLineTypeConnection)) {
3133 rtc::SocketAddress addr;
3134 if (!ParseConnectionData(line, &addr, error)) {
3135 return false;
3136 }
3137 media_desc->set_connection_address(addr);
3138 continue;
3139 }
3140
henrike@webrtc.org28e20752013-07-10 00:45:363141 if (!IsLineType(line, kLineTypeAttributes)) {
Steve Anton36b29d12017-10-30 16:57:423142 // TODO(deadbeef): Handle other lines if needed.
Mirko Bonadei675513b2017-11-09 10:09:253143 RTC_LOG(LS_INFO) << "Ignored line: " << line;
henrike@webrtc.org28e20752013-07-10 00:45:363144 continue;
3145 }
3146
3147 // Handle attributes common to SCTP and RTP.
3148 if (HasAttribute(line, kAttributeMid)) {
3149 // RFC 3388
3150 // mid-attribute = "a=mid:" identification-tag
3151 // identification-tag = token
3152 // Use the mid identification-tag as the content name.
3153 if (!GetValue(line, kAttributeMid, &mline_id, error)) {
3154 return false;
3155 }
3156 *content_name = mline_id;
deadbeef25ed4352016-12-13 02:37:363157 } else if (HasAttribute(line, kAttributeBundleOnly)) {
3158 *bundle_only = true;
henrike@webrtc.org28e20752013-07-10 00:45:363159 } else if (HasAttribute(line, kAttributeCandidate)) {
3160 Candidate candidate;
3161 if (!ParseCandidate(line, &candidate, error, false)) {
3162 return false;
3163 }
deadbeef7bcdb692017-01-20 20:43:583164 // ParseCandidate will parse non-standard ufrag and password attributes,
3165 // since it's used for candidate trickling, but we only want to process
3166 // the "a=ice-ufrag"/"a=ice-pwd" values in a session description, so
3167 // strip them off at this point.
3168 candidate.set_username(std::string());
3169 candidate.set_password(std::string());
henrike@webrtc.org28e20752013-07-10 00:45:363170 candidates_orig.push_back(candidate);
3171 } else if (HasAttribute(line, kAttributeIceUfrag)) {
3172 if (!GetValue(line, kAttributeIceUfrag, &transport->ice_ufrag, error)) {
3173 return false;
3174 }
3175 } else if (HasAttribute(line, kAttributeIcePwd)) {
3176 if (!GetValue(line, kAttributeIcePwd, &transport->ice_pwd, error)) {
3177 return false;
3178 }
3179 } else if (HasAttribute(line, kAttributeIceOption)) {
3180 if (!ParseIceOptions(line, &transport->transport_options, error)) {
3181 return false;
3182 }
Bjorn A Mellemc85ebbe2019-06-07 17:28:063183 } else if (HasAttribute(line, kOpaqueTransportParametersLine)) {
3184 transport->opaque_parameters = cricket::OpaqueTransportParameters();
3185 if (!ParseOpaqueTransportLine(
3186 line, &transport->opaque_parameters->protocol,
3187 &transport->opaque_parameters->parameters, error)) {
3188 return false;
3189 }
henrike@webrtc.org28e20752013-07-10 00:45:363190 } else if (HasAttribute(line, kAttributeFmtp)) {
3191 if (!ParseFmtpAttributes(line, media_type, media_desc, error)) {
3192 return false;
3193 }
3194 } else if (HasAttribute(line, kAttributeFingerprint)) {
Steve Anton4905edb2018-10-16 02:27:443195 std::unique_ptr<rtc::SSLFingerprint> fingerprint;
henrike@webrtc.org28e20752013-07-10 00:45:363196 if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
3197 return false;
3198 }
Steve Anton4905edb2018-10-16 02:27:443199 transport->identity_fingerprint = std::move(fingerprint);
sergeyu@chromium.org0be6aa02013-08-23 23:21:253200 } else if (HasAttribute(line, kAttributeSetup)) {
3201 if (!ParseDtlsSetup(line, &(transport->connection_role), error)) {
3202 return false;
3203 }
Harald Alvestrand5fc28b12019-05-13 11:36:163204 } else if (cricket::IsDtlsSctp(protocol) &&
3205 HasAttribute(line, kAttributeSctpPort)) {
deadbeef7e146cb2016-09-28 17:04:343206 if (media_type != cricket::MEDIA_TYPE_DATA) {
3207 return ParseFailed(
3208 line, "sctp-port attribute found in non-data media description.",
3209 error);
3210 }
Harald Alvestrand5fc28b12019-05-13 11:36:163211 if (media_desc->as_sctp()->use_sctpmap()) {
3212 return ParseFailed(
3213 line, "sctp-port attribute can't be used with sctpmap.", error);
3214 }
jiayl@webrtc.orgddb85ab2014-09-05 16:31:563215 int sctp_port;
3216 if (!ParseSctpPort(line, &sctp_port, error)) {
3217 return false;
3218 }
Harald Alvestrand5fc28b12019-05-13 11:36:163219 media_desc->as_sctp()->set_port(sctp_port);
3220 } else if (cricket::IsDtlsSctp(protocol) &&
Harald Alvestrand48cce4d2019-04-11 08:41:243221 HasAttribute(line, kAttributeMaxMessageSize)) {
3222 if (media_type != cricket::MEDIA_TYPE_DATA) {
3223 return ParseFailed(
3224 line,
3225 "max-message-size attribute found in non-data media description.",
3226 error);
3227 }
3228 int max_message_size;
3229 if (!ParseSctpMaxMessageSize(line, &max_message_size, error)) {
3230 return false;
3231 }
Harald Alvestrand5fc28b12019-05-13 11:36:163232 media_desc->as_sctp()->set_max_message_size(max_message_size);
3233 } else if (cricket::IsRtpProtocol(protocol)) {
henrike@webrtc.org28e20752013-07-10 00:45:363234 //
3235 // RTP specific attrubtes
3236 //
3237 if (HasAttribute(line, kAttributeRtcpMux)) {
3238 media_desc->set_rtcp_mux(true);
deadbeef13871492015-12-09 20:37:513239 } else if (HasAttribute(line, kAttributeRtcpReducedSize)) {
3240 media_desc->set_rtcp_reduced_size(true);
henrike@webrtc.org28e20752013-07-10 00:45:363241 } else if (HasAttribute(line, kAttributeSsrcGroup)) {
3242 if (!ParseSsrcGroupAttribute(line, &ssrc_groups, error)) {
3243 return false;
3244 }
3245 } else if (HasAttribute(line, kAttributeSsrc)) {
Steve Antone831b8c2018-02-01 20:22:163246 if (!ParseSsrcAttribute(line, &ssrc_infos, msid_signaling, error)) {
henrike@webrtc.org28e20752013-07-10 00:45:363247 return false;
3248 }
3249 } else if (HasAttribute(line, kAttributeCrypto)) {
3250 if (!ParseCryptoAttribute(line, media_desc, error)) {
3251 return false;
3252 }
3253 } else if (HasAttribute(line, kAttributeRtpmap)) {
deadbeef67cf2c12016-04-13 17:07:163254 if (!ParseRtpmapAttribute(line, media_type, payload_types, media_desc,
3255 error)) {
henrike@webrtc.org28e20752013-07-10 00:45:363256 return false;
3257 }
3258 } else if (HasAttribute(line, kCodecParamMaxPTime)) {
3259 if (!GetValue(line, kCodecParamMaxPTime, &maxptime_as_string, error)) {
3260 return false;
3261 }
Mirta Dvornicic479a3c02019-06-04 13:38:503262 } else if (HasAttribute(line, kAttributePacketization)) {
3263 if (!ParsePacketizationAttribute(line, media_type, media_desc, error)) {
3264 return false;
3265 }
henrike@webrtc.org28e20752013-07-10 00:45:363266 } else if (HasAttribute(line, kAttributeRtcpFb)) {
3267 if (!ParseRtcpFbAttribute(line, media_type, media_desc, error)) {
3268 return false;
3269 }
3270 } else if (HasAttribute(line, kCodecParamPTime)) {
3271 if (!GetValue(line, kCodecParamPTime, &ptime_as_string, error)) {
3272 return false;
3273 }
3274 } else if (HasAttribute(line, kAttributeSendOnly)) {
Steve Anton4e70a722017-11-28 22:57:103275 media_desc->set_direction(RtpTransceiverDirection::kSendOnly);
henrike@webrtc.org28e20752013-07-10 00:45:363276 } else if (HasAttribute(line, kAttributeRecvOnly)) {
Steve Anton4e70a722017-11-28 22:57:103277 media_desc->set_direction(RtpTransceiverDirection::kRecvOnly);
henrike@webrtc.org28e20752013-07-10 00:45:363278 } else if (HasAttribute(line, kAttributeInactive)) {
Steve Anton4e70a722017-11-28 22:57:103279 media_desc->set_direction(RtpTransceiverDirection::kInactive);
henrike@webrtc.org28e20752013-07-10 00:45:363280 } else if (HasAttribute(line, kAttributeSendRecv)) {
Steve Anton4e70a722017-11-28 22:57:103281 media_desc->set_direction(RtpTransceiverDirection::kSendRecv);
Johannes Kron0854eb62018-10-10 20:33:203282 } else if (HasAttribute(line, kAttributeExtmapAllowMixed)) {
Johannes Kron9581bc42018-10-23 08:17:393283 media_desc->set_extmap_allow_mixed_enum(
Johannes Kron0854eb62018-10-10 20:33:203284 MediaContentDescription::kMedia);
henrike@webrtc.org28e20752013-07-10 00:45:363285 } else if (HasAttribute(line, kAttributeExtmap)) {
isheriff6f8d6862016-05-26 18:24:553286 RtpExtension extmap;
henrike@webrtc.org28e20752013-07-10 00:45:363287 if (!ParseExtmap(line, &extmap, error)) {
3288 return false;
3289 }
3290 media_desc->AddRtpHeaderExtension(extmap);
3291 } else if (HasAttribute(line, kAttributeXGoogleFlag)) {
3292 // Experimental attribute. Conference mode activates more aggressive
3293 // AEC and NS settings.
Steve Anton36b29d12017-10-30 16:57:423294 // TODO(deadbeef): expose API to set these directly.
henrike@webrtc.org28e20752013-07-10 00:45:363295 std::string flag_value;
3296 if (!GetValue(line, kAttributeXGoogleFlag, &flag_value, error)) {
3297 return false;
3298 }
3299 if (flag_value.compare(kValueConference) == 0)
3300 media_desc->set_conference_mode(true);
deadbeef9d3584c2016-02-17 01:54:103301 } else if (HasAttribute(line, kAttributeMsid)) {
Seth Hampson5b4f0752018-04-02 23:31:363302 if (!ParseMsidAttribute(line, &stream_ids, &track_id, error)) {
deadbeef9d3584c2016-02-17 01:54:103303 return false;
3304 }
Steve Antone831b8c2018-02-01 20:22:163305 *msid_signaling |= cricket::kMsidSignalingMediaSection;
Amit Hilbuchc57d5732018-12-11 23:30:113306 } else if (HasAttribute(line, kAttributeRid)) {
3307 const size_t kRidPrefixLength =
3308 kLinePrefixLength + arraysize(kAttributeRid);
3309 if (line.size() <= kRidPrefixLength) {
3310 RTC_LOG(LS_INFO) << "Ignoring empty RID attribute: " << line;
3311 continue;
3312 }
3313 RTCErrorOr<RidDescription> error_or_rid_description =
3314 deserializer.DeserializeRidDescription(
3315 line.substr(kRidPrefixLength));
3316
3317 // Malformed a=rid lines are discarded.
3318 if (!error_or_rid_description.ok()) {
3319 RTC_LOG(LS_INFO) << "Ignoring malformed RID line: '" << line
3320 << "'. Error: "
3321 << error_or_rid_description.error().message();
3322 continue;
3323 }
3324
3325 rids.push_back(error_or_rid_description.MoveValue());
Amit Hilbucha2012042018-12-03 19:35:053326 } else if (HasAttribute(line, kAttributeSimulcast)) {
3327 const size_t kSimulcastPrefixLength =
3328 kLinePrefixLength + arraysize(kAttributeSimulcast);
3329 if (line.size() <= kSimulcastPrefixLength) {
3330 return ParseFailed(line, "Simulcast attribute is empty.", error);
3331 }
3332
3333 if (!simulcast.empty()) {
3334 return ParseFailed(line, "Multiple Simulcast attributes specified.",
3335 error);
3336 }
3337
Amit Hilbucha2012042018-12-03 19:35:053338 RTCErrorOr<SimulcastDescription> error_or_simulcast =
3339 deserializer.DeserializeSimulcastDescription(
3340 line.substr(kSimulcastPrefixLength));
3341 if (!error_or_simulcast.ok()) {
3342 return ParseFailed(line,
3343 std::string("Malformed simulcast line: ") +
3344 error_or_simulcast.error().message(),
3345 error);
3346 }
3347
3348 simulcast = error_or_simulcast.value();
3349 } else {
3350 // Unrecognized attribute in RTP protocol.
3351 RTC_LOG(LS_INFO) << "Ignored line: " << line;
3352 continue;
henrike@webrtc.org28e20752013-07-10 00:45:363353 }
3354 } else {
3355 // Only parse lines that we are interested of.
Mirko Bonadei675513b2017-11-09 10:09:253356 RTC_LOG(LS_INFO) << "Ignored line: " << line;
henrike@webrtc.org28e20752013-07-10 00:45:363357 continue;
3358 }
3359 }
3360
Amit Hilbuchc57d5732018-12-11 23:30:113361 // Remove duplicate or inconsistent rids.
3362 RemoveInvalidRidDescriptions(payload_types, &rids);
3363
3364 // If simulcast is specifed, split the rids into send and receive.
3365 // Rids that do not appear in simulcast attribute will be removed.
3366 // If it is not specified, we assume that all rids are for send layers.
Amit Hilbuchb7446ed2019-01-28 20:25:253367 std::vector<RidDescription> send_rids;
Florent Castellib60141b2019-07-03 10:47:543368 std::vector<RidDescription> receive_rids;
Amit Hilbuchc57d5732018-12-11 23:30:113369 if (!simulcast.empty()) {
3370 // Verify that the rids in simulcast match rids in sdp.
3371 RemoveInvalidRidsFromSimulcast(rids, &simulcast);
3372
3373 // Use simulcast description to figure out Send / Receive RIDs.
3374 std::map<std::string, RidDescription> rid_map;
3375 for (const RidDescription& rid : rids) {
3376 rid_map[rid.rid] = rid;
3377 }
3378
3379 for (const auto& layer : simulcast.send_layers().GetAllLayers()) {
3380 auto iter = rid_map.find(layer.rid);
3381 RTC_DCHECK(iter != rid_map.end());
3382 send_rids.push_back(iter->second);
3383 }
3384
Florent Castellib60141b2019-07-03 10:47:543385 for (const auto& layer : simulcast.receive_layers().GetAllLayers()) {
3386 auto iter = rid_map.find(layer.rid);
3387 RTC_DCHECK(iter != rid_map.end());
3388 receive_rids.push_back(iter->second);
3389 }
3390
Amit Hilbuchc57d5732018-12-11 23:30:113391 media_desc->set_simulcast_description(simulcast);
3392 } else {
3393 send_rids = rids;
3394 }
3395
Florent Castellib60141b2019-07-03 10:47:543396 media_desc->set_receive_rids(receive_rids);
3397
henrike@webrtc.org28e20752013-07-10 00:45:363398 // Create tracks from the |ssrc_infos|.
Taylor Brandstetter5de6b752016-03-10 01:02:303399 // If the stream_id/track_id for all SSRCS are identical, one StreamParams
3400 // will be created in CreateTracksFromSsrcInfos, containing all the SSRCs from
3401 // the m= section.
Seth Hampson5897a6e2018-04-03 18:16:333402 if (!ssrc_infos.empty()) {
3403 CreateTracksFromSsrcInfos(ssrc_infos, stream_ids, track_id, &tracks,
3404 *msid_signaling);
3405 } else if (media_type != cricket::MEDIA_TYPE_DATA &&
3406 (*msid_signaling & cricket::kMsidSignalingMediaSection)) {
3407 // If the stream_ids/track_id was signaled but SSRCs were unsignaled we
3408 // still create a track. This isn't done for data media types because
3409 // StreamParams aren't used for SCTP streams, and RTP data channels don't
3410 // support unsignaled SSRCs.
Amit Hilbuchc57d5732018-12-11 23:30:113411 CreateTrackWithNoSsrcs(stream_ids, track_id, send_rids, &tracks);
3412 }
3413
henrike@webrtc.org28e20752013-07-10 00:45:363414 // Add the ssrc group to the track.
Steve Anton4daf66e2018-09-07 21:55:533415 for (const SsrcGroup& ssrc_group : ssrc_groups) {
3416 if (ssrc_group.ssrcs.empty()) {
henrike@webrtc.org28e20752013-07-10 00:45:363417 continue;
3418 }
Steve Anton4daf66e2018-09-07 21:55:533419 uint32_t ssrc = ssrc_group.ssrcs.front();
3420 for (StreamParams& track : tracks) {
3421 if (track.has_ssrc(ssrc)) {
3422 track.ssrc_groups.push_back(ssrc_group);
henrike@webrtc.org28e20752013-07-10 00:45:363423 }
3424 }
3425 }
3426
3427 // Add the new tracks to the |media_desc|.
deadbeef9d3584c2016-02-17 01:54:103428 for (StreamParams& track : tracks) {
3429 media_desc->AddStream(track);
henrike@webrtc.org28e20752013-07-10 00:45:363430 }
3431
3432 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
Steve Antonb1c1de12017-12-21 23:14:303433 AudioContentDescription* audio_desc = media_desc->as_audio();
jlmiller@webrtc.orga744a282015-02-18 21:37:463434 UpdateFromWildcardCodecs(audio_desc);
3435
henrike@webrtc.org28e20752013-07-10 00:45:363436 // Verify audio codec ensures that no audio codec has been populated with
3437 // only fmtp.
3438 if (!VerifyAudioCodecs(audio_desc)) {
3439 return ParseFailed("Failed to parse audio codecs correctly.", error);
3440 }
3441 AddAudioAttribute(kCodecParamMaxPTime, maxptime_as_string, audio_desc);
3442 AddAudioAttribute(kCodecParamPTime, ptime_as_string, audio_desc);
3443 }
3444
3445 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
Steve Antonb1c1de12017-12-21 23:14:303446 VideoContentDescription* video_desc = media_desc->as_video();
jlmiller@webrtc.orga744a282015-02-18 21:37:463447 UpdateFromWildcardCodecs(video_desc);
3448 // Verify video codec ensures that no video codec has been populated with
3449 // only rtcp-fb.
3450 if (!VerifyVideoCodecs(video_desc)) {
3451 return ParseFailed("Failed to parse video codecs correctly.", error);
3452 }
henrike@webrtc.org28e20752013-07-10 00:45:363453 }
3454
3455 // RFC 5245
3456 // Update the candidates with the media level "ice-pwd" and "ice-ufrag".
Steve Anton4daf66e2018-09-07 21:55:533457 for (Candidate& candidate : candidates_orig) {
3458 RTC_DCHECK(candidate.username().empty() ||
3459 candidate.username() == transport->ice_ufrag);
3460 candidate.set_username(transport->ice_ufrag);
3461 RTC_DCHECK(candidate.password().empty());
3462 candidate.set_password(transport->ice_pwd);
3463 candidates->push_back(
Steve Anton5a1de872018-12-18 19:25:553464 absl::make_unique<JsepIceCandidate>(mline_id, mline_index, candidate));
henrike@webrtc.org28e20752013-07-10 00:45:363465 }
Amit Hilbucha2012042018-12-03 19:35:053466
henrike@webrtc.org28e20752013-07-10 00:45:363467 return true;
3468}
3469
Steve Antone831b8c2018-02-01 20:22:163470bool ParseSsrcAttribute(const std::string& line,
3471 SsrcInfoVec* ssrc_infos,
3472 int* msid_signaling,
henrike@webrtc.org28e20752013-07-10 00:45:363473 SdpParseError* error) {
nisseede5da42017-01-12 13:15:363474 RTC_DCHECK(ssrc_infos != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:363475 // RFC 5576
3476 // a=ssrc:<ssrc-id> <attribute>
3477 // a=ssrc:<ssrc-id> <attribute>:<value>
3478 std::string field1, field2;
Jonas Olssonec9e4922018-09-05 07:53:493479 if (!rtc::tokenize_first(line.substr(kLinePrefixLength),
3480 kSdpDelimiterSpaceChar, &field1, &field2)) {
henrike@webrtc.org28e20752013-07-10 00:45:363481 const size_t expected_fields = 2;
3482 return ParseFailedExpectFieldNum(line, expected_fields, error);
3483 }
3484
3485 // ssrc:<ssrc-id>
3486 std::string ssrc_id_s;
3487 if (!GetValue(field1, kAttributeSsrc, &ssrc_id_s, error)) {
3488 return false;
3489 }
Peter Boström0c4e06b2015-10-07 10:23:213490 uint32_t ssrc_id = 0;
wu@webrtc.org5e760e72014-04-02 23:19:093491 if (!GetValueFromString(line, ssrc_id_s, &ssrc_id, error)) {
3492 return false;
3493 }
henrike@webrtc.org28e20752013-07-10 00:45:363494
3495 std::string attribute;
3496 std::string value;
Jonas Olssonec9e4922018-09-05 07:53:493497 if (!rtc::tokenize_first(field2, kSdpDelimiterColonChar, &attribute,
3498 &value)) {
3499 rtc::StringBuilder description;
henrike@webrtc.org28e20752013-07-10 00:45:363500 description << "Failed to get the ssrc attribute value from " << field2
3501 << ". Expected format <attribute>:<value>.";
3502 return ParseFailed(line, description.str(), error);
3503 }
3504
3505 // Check if there's already an item for this |ssrc_id|. Create a new one if
3506 // there isn't.
Steve Anton64b626b2019-01-29 01:25:263507 auto ssrc_info_it =
3508 absl::c_find_if(*ssrc_infos, [ssrc_id](const SsrcInfo& ssrc_info) {
3509 return ssrc_info.ssrc_id == ssrc_id;
3510 });
Steve Anton4daf66e2018-09-07 21:55:533511 if (ssrc_info_it == ssrc_infos->end()) {
henrike@webrtc.org28e20752013-07-10 00:45:363512 SsrcInfo info;
3513 info.ssrc_id = ssrc_id;
3514 ssrc_infos->push_back(info);
Steve Anton4daf66e2018-09-07 21:55:533515 ssrc_info_it = ssrc_infos->end() - 1;
henrike@webrtc.org28e20752013-07-10 00:45:363516 }
Steve Anton4daf66e2018-09-07 21:55:533517 SsrcInfo& ssrc_info = *ssrc_info_it;
henrike@webrtc.org28e20752013-07-10 00:45:363518
3519 // Store the info to the |ssrc_info|.
3520 if (attribute == kSsrcAttributeCname) {
3521 // RFC 5576
3522 // cname:<value>
Steve Anton4daf66e2018-09-07 21:55:533523 ssrc_info.cname = value;
henrike@webrtc.org28e20752013-07-10 00:45:363524 } else if (attribute == kSsrcAttributeMsid) {
3525 // draft-alvestrand-mmusic-msid-00
Seth Hampson5b4f0752018-04-02 23:31:363526 // msid:identifier [appdata]
henrike@webrtc.org28e20752013-07-10 00:45:363527 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493528 rtc::split(value, kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:363529 if (fields.size() < 1 || fields.size() > 2) {
Yves Gerey665174f2018-06-19 13:03:053530 return ParseFailed(
3531 line, "Expected format \"msid:<identifier>[ <appdata>]\".", error);
henrike@webrtc.org28e20752013-07-10 00:45:363532 }
Steve Anton4daf66e2018-09-07 21:55:533533 ssrc_info.stream_id = fields[0];
henrike@webrtc.org28e20752013-07-10 00:45:363534 if (fields.size() == 2) {
Steve Anton4daf66e2018-09-07 21:55:533535 ssrc_info.track_id = fields[1];
henrike@webrtc.org28e20752013-07-10 00:45:363536 }
Steve Antone831b8c2018-02-01 20:22:163537 *msid_signaling |= cricket::kMsidSignalingSsrcAttribute;
henrike@webrtc.org28e20752013-07-10 00:45:363538 } else if (attribute == kSsrcAttributeMslabel) {
3539 // draft-alvestrand-rtcweb-mid-01
3540 // mslabel:<value>
Steve Anton4daf66e2018-09-07 21:55:533541 ssrc_info.mslabel = value;
henrike@webrtc.org28e20752013-07-10 00:45:363542 } else if (attribute == kSSrcAttributeLabel) {
3543 // The label isn't defined.
3544 // label:<value>
Steve Anton4daf66e2018-09-07 21:55:533545 ssrc_info.label = value;
henrike@webrtc.org28e20752013-07-10 00:45:363546 }
3547 return true;
3548}
3549
3550bool ParseSsrcGroupAttribute(const std::string& line,
3551 SsrcGroupVec* ssrc_groups,
3552 SdpParseError* error) {
nisseede5da42017-01-12 13:15:363553 RTC_DCHECK(ssrc_groups != NULL);
henrike@webrtc.org28e20752013-07-10 00:45:363554 // RFC 5576
3555 // a=ssrc-group:<semantics> <ssrc-id> ...
3556 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493557 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:363558 const size_t expected_min_fields = 2;
3559 if (fields.size() < expected_min_fields) {
3560 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
3561 }
3562 std::string semantics;
3563 if (!GetValue(fields[0], kAttributeSsrcGroup, &semantics, error)) {
3564 return false;
3565 }
Peter Boström0c4e06b2015-10-07 10:23:213566 std::vector<uint32_t> ssrcs;
henrike@webrtc.org28e20752013-07-10 00:45:363567 for (size_t i = 1; i < fields.size(); ++i) {
Peter Boström0c4e06b2015-10-07 10:23:213568 uint32_t ssrc = 0;
wu@webrtc.org5e760e72014-04-02 23:19:093569 if (!GetValueFromString(line, fields[i], &ssrc, error)) {
3570 return false;
3571 }
henrike@webrtc.org28e20752013-07-10 00:45:363572 ssrcs.push_back(ssrc);
3573 }
3574 ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
3575 return true;
3576}
3577
3578bool ParseCryptoAttribute(const std::string& line,
3579 MediaContentDescription* media_desc,
3580 SdpParseError* error) {
3581 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493582 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:363583 // RFC 4568
3584 // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
3585 const size_t expected_min_fields = 3;
3586 if (fields.size() < expected_min_fields) {
3587 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
3588 }
3589 std::string tag_value;
3590 if (!GetValue(fields[0], kAttributeCrypto, &tag_value, error)) {
3591 return false;
3592 }
wu@webrtc.org5e760e72014-04-02 23:19:093593 int tag = 0;
3594 if (!GetValueFromString(line, tag_value, &tag, error)) {
3595 return false;
3596 }
jbauch083b73f2015-07-16 09:46:323597 const std::string& crypto_suite = fields[1];
3598 const std::string& key_params = fields[2];
henrike@webrtc.org28e20752013-07-10 00:45:363599 std::string session_params;
3600 if (fields.size() > 3) {
3601 session_params = fields[3];
3602 }
Yves Gerey665174f2018-06-19 13:03:053603 media_desc->AddCrypto(
3604 CryptoParams(tag, crypto_suite, key_params, session_params));
henrike@webrtc.org28e20752013-07-10 00:45:363605 return true;
3606}
3607
3608// Updates or creates a new codec entry in the audio description with according
deadbeef67cf2c12016-04-13 17:07:163609// to |name|, |clockrate|, |bitrate|, and |channels|.
3610void UpdateCodec(int payload_type,
3611 const std::string& name,
3612 int clockrate,
3613 int bitrate,
3614 size_t channels,
henrike@webrtc.org28e20752013-07-10 00:45:363615 AudioContentDescription* audio_desc) {
3616 // Codec may already be populated with (only) optional parameters
3617 // (from an fmtp).
changbin.shao@webrtc.org2d25b442015-03-16 04:14:343618 cricket::AudioCodec codec =
3619 GetCodecWithPayloadType(audio_desc->codecs(), payload_type);
henrike@webrtc.org28e20752013-07-10 00:45:363620 codec.name = name;
3621 codec.clockrate = clockrate;
3622 codec.bitrate = bitrate;
3623 codec.channels = channels;
henrike@webrtc.org28e20752013-07-10 00:45:363624 AddOrReplaceCodec<AudioContentDescription, cricket::AudioCodec>(audio_desc,
3625 codec);
3626}
3627
3628// Updates or creates a new codec entry in the video description according to
deadbeef67cf2c12016-04-13 17:07:163629// |name|, |width|, |height|, and |framerate|.
3630void UpdateCodec(int payload_type,
3631 const std::string& name,
henrike@webrtc.org28e20752013-07-10 00:45:363632 VideoContentDescription* video_desc) {
3633 // Codec may already be populated with (only) optional parameters
3634 // (from an fmtp).
changbin.shao@webrtc.org2d25b442015-03-16 04:14:343635 cricket::VideoCodec codec =
3636 GetCodecWithPayloadType(video_desc->codecs(), payload_type);
henrike@webrtc.org28e20752013-07-10 00:45:363637 codec.name = name;
henrike@webrtc.org28e20752013-07-10 00:45:363638 AddOrReplaceCodec<VideoContentDescription, cricket::VideoCodec>(video_desc,
3639 codec);
3640}
3641
3642bool ParseRtpmapAttribute(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:013643 const cricket::MediaType media_type,
deadbeef67cf2c12016-04-13 17:07:163644 const std::vector<int>& payload_types,
henrike@webrtc.org28e20752013-07-10 00:45:363645 MediaContentDescription* media_desc,
3646 SdpParseError* error) {
3647 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493648 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
henrike@webrtc.org28e20752013-07-10 00:45:363649 // RFC 4566
3650 // a=rtpmap:<payload type> <encoding name>/<clock rate>[/<encodingparameters>]
3651 const size_t expected_min_fields = 2;
3652 if (fields.size() < expected_min_fields) {
3653 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
3654 }
3655 std::string payload_type_value;
3656 if (!GetValue(fields[0], kAttributeRtpmap, &payload_type_value, error)) {
3657 return false;
3658 }
wu@webrtc.org5e760e72014-04-02 23:19:093659 int payload_type = 0;
pkasting@chromium.orge9facf82015-02-17 20:36:283660 if (!GetPayloadTypeFromString(line, payload_type_value, &payload_type,
3661 error)) {
wu@webrtc.org5e760e72014-04-02 23:19:093662 return false;
3663 }
henrike@webrtc.org28e20752013-07-10 00:45:363664
Steve Anton64b626b2019-01-29 01:25:263665 if (!absl::c_linear_search(payload_types, payload_type)) {
Mirko Bonadei675513b2017-11-09 10:09:253666 RTC_LOG(LS_WARNING) << "Ignore rtpmap line that did not appear in the "
Jonas Olsson45cc8902018-02-13 09:37:073667 "<fmt> of the m-line: "
3668 << line;
henrike@webrtc.org28e20752013-07-10 00:45:363669 return true;
3670 }
jbauch083b73f2015-07-16 09:46:323671 const std::string& encoder = fields[1];
henrike@webrtc.org28e20752013-07-10 00:45:363672 std::vector<std::string> codec_params;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:523673 rtc::split(encoder, '/', &codec_params);
henrike@webrtc.org28e20752013-07-10 00:45:363674 // <encoding name>/<clock rate>[/<encodingparameters>]
3675 // 2 mandatory fields
3676 if (codec_params.size() < 2 || codec_params.size() > 3) {
3677 return ParseFailed(line,
3678 "Expected format \"<encoding name>/<clock rate>"
3679 "[/<encodingparameters>]\".",
3680 error);
3681 }
jbauch083b73f2015-07-16 09:46:323682 const std::string& encoding_name = codec_params[0];
wu@webrtc.org5e760e72014-04-02 23:19:093683 int clock_rate = 0;
3684 if (!GetValueFromString(line, codec_params[1], &clock_rate, error)) {
3685 return false;
3686 }
henrike@webrtc.org28e20752013-07-10 00:45:363687 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
Steve Antonb1c1de12017-12-21 23:14:303688 VideoContentDescription* video_desc = media_desc->as_video();
Yves Gerey665174f2018-06-19 13:03:053689 UpdateCodec(payload_type, encoding_name, video_desc);
henrike@webrtc.org28e20752013-07-10 00:45:363690 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
3691 // RFC 4566
3692 // For audio streams, <encoding parameters> indicates the number
3693 // of audio channels. This parameter is OPTIONAL and may be
3694 // omitted if the number of channels is one, provided that no
3695 // additional parameters are needed.
Peter Kasting69558702016-01-13 00:26:353696 size_t channels = 1;
henrike@webrtc.org28e20752013-07-10 00:45:363697 if (codec_params.size() == 3) {
wu@webrtc.org5e760e72014-04-02 23:19:093698 if (!GetValueFromString(line, codec_params[2], &channels, error)) {
3699 return false;
3700 }
henrike@webrtc.org28e20752013-07-10 00:45:363701 }
Steve Antonb1c1de12017-12-21 23:14:303702 AudioContentDescription* audio_desc = media_desc->as_audio();
ossue1405ad2017-01-23 16:55:483703 UpdateCodec(payload_type, encoding_name, clock_rate, 0, channels,
deadbeef67cf2c12016-04-13 17:07:163704 audio_desc);
henrike@webrtc.org28e20752013-07-10 00:45:363705 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
Harald Alvestrand5fc28b12019-05-13 11:36:163706 RtpDataContentDescription* data_desc = media_desc->as_rtp_data();
3707 if (data_desc) {
3708 data_desc->AddCodec(cricket::RtpDataCodec(payload_type, encoding_name));
3709 }
henrike@webrtc.org28e20752013-07-10 00:45:363710 }
3711 return true;
3712}
3713
Yves Gerey665174f2018-06-19 13:03:053714bool ParseFmtpParam(const std::string& line,
3715 std::string* parameter,
3716 std::string* value,
3717 SdpParseError* error) {
Jonas Olssonec9e4922018-09-05 07:53:493718 if (!rtc::tokenize_first(line, kSdpDelimiterEqualChar, parameter, value)) {
henrike@webrtc.org28e20752013-07-10 00:45:363719 ParseFailed(line, "Unable to parse fmtp parameter. \'=\' missing.", error);
3720 return false;
3721 }
3722 // a=fmtp:<payload_type> <param1>=<value1>; <param2>=<value2>; ...
henrike@webrtc.org28e20752013-07-10 00:45:363723 return true;
3724}
3725
Yves Gerey665174f2018-06-19 13:03:053726bool ParseFmtpAttributes(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:013727 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:363728 MediaContentDescription* media_desc,
3729 SdpParseError* error) {
3730 if (media_type != cricket::MEDIA_TYPE_AUDIO &&
3731 media_type != cricket::MEDIA_TYPE_VIDEO) {
3732 return true;
3733 }
Donald Curtis0e07f922015-05-15 16:21:233734
3735 std::string line_payload;
3736 std::string line_params;
henrike@webrtc.org28e20752013-07-10 00:45:363737
3738 // RFC 5576
3739 // a=fmtp:<format> <format specific parameters>
3740 // At least two fields, whereas the second one is any of the optional
3741 // parameters.
Jonas Olssonec9e4922018-09-05 07:53:493742 if (!rtc::tokenize_first(line.substr(kLinePrefixLength),
3743 kSdpDelimiterSpaceChar, &line_payload,
3744 &line_params)) {
henrike@webrtc.org28e20752013-07-10 00:45:363745 ParseFailedExpectMinFieldNum(line, 2, error);
3746 return false;
3747 }
3748
Donald Curtis0e07f922015-05-15 16:21:233749 // Parse out the payload information.
pkasting@chromium.orgd3245462015-02-23 21:28:223750 std::string payload_type_str;
Donald Curtis0e07f922015-05-15 16:21:233751 if (!GetValue(line_payload, kAttributeFmtp, &payload_type_str, error)) {
henrike@webrtc.org28e20752013-07-10 00:45:363752 return false;
3753 }
3754
Donald Curtis0e07f922015-05-15 16:21:233755 int payload_type = 0;
Donald Curtis144d0182015-05-15 20:14:243756 if (!GetPayloadTypeFromString(line_payload, payload_type_str, &payload_type,
3757 error)) {
Donald Curtis0e07f922015-05-15 16:21:233758 return false;
3759 }
3760
3761 // Parse out format specific parameters.
3762 std::vector<std::string> fields;
Jonas Olssonec9e4922018-09-05 07:53:493763 rtc::split(line_params, kSdpDelimiterSemicolonChar, &fields);
Donald Curtis0e07f922015-05-15 16:21:233764
henrike@webrtc.org28e20752013-07-10 00:45:363765 cricket::CodecParameterMap codec_params;
Donald Curtis144d0182015-05-15 20:14:243766 for (auto& iter : fields) {
Donald Curtis0e07f922015-05-15 16:21:233767 if (iter.find(kSdpDelimiterEqual) == std::string::npos) {
henrike@webrtc.org28e20752013-07-10 00:45:363768 // Only fmtps with equals are currently supported. Other fmtp types
3769 // should be ignored. Unknown fmtps do not constitute an error.
3770 continue;
3771 }
Donald Curtis0e07f922015-05-15 16:21:233772
3773 std::string name;
3774 std::string value;
3775 if (!ParseFmtpParam(rtc::string_trim(iter), &name, &value, error)) {
henrike@webrtc.org28e20752013-07-10 00:45:363776 return false;
3777 }
3778 codec_params[name] = value;
3779 }
3780
henrike@webrtc.org28e20752013-07-10 00:45:363781 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
3782 UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
pkasting@chromium.orgd3245462015-02-23 21:28:223783 media_desc, payload_type, codec_params);
henrike@webrtc.org28e20752013-07-10 00:45:363784 } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
3785 UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
pkasting@chromium.orgd3245462015-02-23 21:28:223786 media_desc, payload_type, codec_params);
henrike@webrtc.org28e20752013-07-10 00:45:363787 }
3788 return true;
3789}
3790
Mirta Dvornicic479a3c02019-06-04 13:38:503791bool ParsePacketizationAttribute(const std::string& line,
3792 const cricket::MediaType media_type,
3793 MediaContentDescription* media_desc,
3794 SdpParseError* error) {
3795 if (media_type != cricket::MEDIA_TYPE_VIDEO) {
3796 return true;
3797 }
3798 std::vector<std::string> packetization_fields;
3799 rtc::split(line.c_str(), kSdpDelimiterSpaceChar, &packetization_fields);
3800 if (packetization_fields.size() < 2) {
3801 return ParseFailedGetValue(line, kAttributePacketization, error);
3802 }
3803 std::string payload_type_string;
3804 if (!GetValue(packetization_fields[0], kAttributePacketization,
3805 &payload_type_string, error)) {
3806 return false;
3807 }
3808 int payload_type;
3809 if (!GetPayloadTypeFromString(line, payload_type_string, &payload_type,
3810 error)) {
3811 return false;
3812 }
3813 std::string packetization = packetization_fields[1];
3814 UpdateVideoCodecPacketization(media_desc->as_video(), payload_type,
3815 packetization);
3816 return true;
3817}
3818
Yves Gerey665174f2018-06-19 13:03:053819bool ParseRtcpFbAttribute(const std::string& line,
Patrik Höglundb6b29e02018-06-21 14:58:013820 const cricket::MediaType media_type,
henrike@webrtc.org28e20752013-07-10 00:45:363821 MediaContentDescription* media_desc,
3822 SdpParseError* error) {
3823 if (media_type != cricket::MEDIA_TYPE_AUDIO &&
3824 media_type != cricket::MEDIA_TYPE_VIDEO) {
3825 return true;
3826 }
3827 std::vector<std::string> rtcp_fb_fields;
Jonas Olssonec9e4922018-09-05 07:53:493828 rtc::split(line.c_str(), kSdpDelimiterSpaceChar, &rtcp_fb_fields);
henrike@webrtc.org28e20752013-07-10 00:45:363829 if (rtcp_fb_fields.size() < 2) {
3830 return ParseFailedGetValue(line, kAttributeRtcpFb, error);
3831 }
3832 std::string payload_type_string;
3833 if (!GetValue(rtcp_fb_fields[0], kAttributeRtcpFb, &payload_type_string,
3834 error)) {
3835 return false;
3836 }
wu@webrtc.org5e760e72014-04-02 23:19:093837 int payload_type = kWildcardPayloadType;
3838 if (payload_type_string != "*") {
pkasting@chromium.orge9facf82015-02-17 20:36:283839 if (!GetPayloadTypeFromString(line, payload_type_string, &payload_type,
3840 error)) {
wu@webrtc.org5e760e72014-04-02 23:19:093841 return false;
3842 }
3843 }
henrike@webrtc.org28e20752013-07-10 00:45:363844 std::string id = rtcp_fb_fields[1];
3845 std::string param = "";
3846 for (std::vector<std::string>::iterator iter = rtcp_fb_fields.begin() + 2;
3847 iter != rtcp_fb_fields.end(); ++iter) {
3848 param.append(*iter);
3849 }
3850 const cricket::FeedbackParam feedback_param(id, param);
3851
3852 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
pkasting@chromium.orgd3245462015-02-23 21:28:223853 UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
3854 media_desc, payload_type, feedback_param);
henrike@webrtc.org28e20752013-07-10 00:45:363855 } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
pkasting@chromium.orgd3245462015-02-23 21:28:223856 UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
3857 media_desc, payload_type, feedback_param);
henrike@webrtc.org28e20752013-07-10 00:45:363858 }
3859 return true;
3860}
3861
3862} // namespace webrtc