1 /*
2 * libjingle
3 * Copyright 2011, Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "talk/app/webrtc/webrtcsdp.h"
29
30 #include <limits.h>
31 #include <stdio.h>
32 #include <algorithm>
33 #include <string>
34 #include <vector>
35
36 #include "talk/app/webrtc/jsepicecandidate.h"
37 #include "talk/app/webrtc/jsepsessiondescription.h"
38 #include "talk/media/base/codec.h"
39 #include "talk/media/base/constants.h"
40 #include "talk/media/base/cryptoparams.h"
41 #include "talk/media/sctp/sctpdataengine.h"
42 #include "talk/p2p/base/candidate.h"
43 #include "talk/p2p/base/constants.h"
44 #include "talk/p2p/base/port.h"
45 #include "talk/session/media/mediasession.h"
46 #include "talk/session/media/mediasessionclient.h"
47 #include "webrtc/base/common.h"
48 #include "webrtc/base/logging.h"
49 #include "webrtc/base/messagedigest.h"
50 #include "webrtc/base/stringutils.h"
51
52 using cricket::AudioContentDescription;
53 using cricket::Candidate;
54 using cricket::Candidates;
55 using cricket::ContentDescription;
56 using cricket::ContentInfo;
57 using cricket::CryptoParams;
58 using cricket::DataContentDescription;
59 using cricket::ICE_CANDIDATE_COMPONENT_RTP;
60 using cricket::ICE_CANDIDATE_COMPONENT_RTCP;
61 using cricket::kCodecParamMaxBitrate;
62 using cricket::kCodecParamMaxPTime;
63 using cricket::kCodecParamMaxQuantization;
64 using cricket::kCodecParamMinBitrate;
65 using cricket::kCodecParamMinPTime;
66 using cricket::kCodecParamPTime;
67 using cricket::kCodecParamSPropStereo;
68 using cricket::kCodecParamStartBitrate;
69 using cricket::kCodecParamStereo;
70 using cricket::kCodecParamUseInbandFec;
71 using cricket::kCodecParamSctpProtocol;
72 using cricket::kCodecParamSctpStreams;
73 using cricket::kCodecParamMaxAverageBitrate;
74 using cricket::kCodecParamMaxPlaybackRate;
75 using cricket::kCodecParamAssociatedPayloadType;
76 using cricket::kWildcardPayloadType;
77 using cricket::MediaContentDescription;
78 using cricket::MediaType;
79 using cricket::NS_JINGLE_ICE_UDP;
80 using cricket::RtpHeaderExtension;
81 using cricket::SsrcGroup;
82 using cricket::StreamParams;
83 using cricket::StreamParamsVec;
84 using cricket::TransportDescription;
85 using cricket::TransportInfo;
86 using cricket::VideoContentDescription;
87 using rtc::SocketAddress;
88
89 typedef std::vector<RtpHeaderExtension> RtpHeaderExtensions;
90
91 namespace cricket {
92 class SessionDescription;
93 }
94
95 namespace webrtc {
96
97 // Line type
98 // RFC 4566
99 // An SDP session description consists of a number of lines of text of
100 // the form:
101 // <type>=<value>
102 // where <type> MUST be exactly one case-significant character.
103 static const int kLinePrefixLength = 2; // Lenght of <type>=
104 static const char kLineTypeVersion = 'v';
105 static const char kLineTypeOrigin = 'o';
106 static const char kLineTypeSessionName = 's';
107 static const char kLineTypeSessionInfo = 'i';
108 static const char kLineTypeSessionUri = 'u';
109 static const char kLineTypeSessionEmail = 'e';
110 static const char kLineTypeSessionPhone = 'p';
111 static const char kLineTypeSessionBandwidth = 'b';
112 static const char kLineTypeTiming = 't';
113 static const char kLineTypeRepeatTimes = 'r';
114 static const char kLineTypeTimeZone = 'z';
115 static const char kLineTypeEncryptionKey = 'k';
116 static const char kLineTypeMedia = 'm';
117 static const char kLineTypeConnection = 'c';
118 static const char kLineTypeAttributes = 'a';
119
120 // Attributes
121 static const char kAttributeGroup[] = "group";
122 static const char kAttributeMid[] = "mid";
123 static const char kAttributeRtcpMux[] = "rtcp-mux";
124 static const char kAttributeSsrc[] = "ssrc";
125 static const char kSsrcAttributeCname[] = "cname";
126 static const char kAttributeExtmap[] = "extmap";
127 // draft-alvestrand-mmusic-msid-01
128 // a=msid-semantic: WMS
129 static const char kAttributeMsidSemantics[] = "msid-semantic";
130 static const char kMediaStreamSemantic[] = "WMS";
131 static const char kSsrcAttributeMsid[] = "msid";
132 static const char kDefaultMsid[] = "default";
133 static const char kSsrcAttributeMslabel[] = "mslabel";
134 static const char kSSrcAttributeLabel[] = "label";
135 static const char kAttributeSsrcGroup[] = "ssrc-group";
136 static const char kAttributeCrypto[] = "crypto";
137 static const char kAttributeCandidate[] = "candidate";
138 static const char kAttributeCandidateTyp[] = "typ";
139 static const char kAttributeCandidateRaddr[] = "raddr";
140 static const char kAttributeCandidateRport[] = "rport";
141 static const char kAttributeCandidateUsername[] = "username";
142 static const char kAttributeCandidatePassword[] = "password";
143 static const char kAttributeCandidateGeneration[] = "generation";
144 static const char kAttributeFingerprint[] = "fingerprint";
145 static const char kAttributeSetup[] = "setup";
146 static const char kAttributeFmtp[] = "fmtp";
147 static const char kAttributeRtpmap[] = "rtpmap";
148 static const char kAttributeSctpmap[] = "sctpmap";
149 static const char kAttributeRtcp[] = "rtcp";
150 static const char kAttributeIceUfrag[] = "ice-ufrag";
151 static const char kAttributeIcePwd[] = "ice-pwd";
152 static const char kAttributeIceLite[] = "ice-lite";
153 static const char kAttributeIceOption[] = "ice-options";
154 static const char kAttributeSendOnly[] = "sendonly";
155 static const char kAttributeRecvOnly[] = "recvonly";
156 static const char kAttributeRtcpFb[] = "rtcp-fb";
157 static const char kAttributeSendRecv[] = "sendrecv";
158 static const char kAttributeInactive[] = "inactive";
159 // draft-ietf-mmusic-sctp-sdp-07
160 // a=sctp-port
161 static const char kAttributeSctpPort[] = "sctp-port";
162
163 // Experimental flags
164 static const char kAttributeXGoogleFlag[] = "x-google-flag";
165 static const char kValueConference[] = "conference";
166 static const char kAttributeXGoogleBufferLatency[] =
167 "x-google-buffer-latency";
168
169 // Candidate
170 static const char kCandidateHost[] = "host";
171 static const char kCandidateSrflx[] = "srflx";
172 // TODO: How to map the prflx with circket candidate type
173 // static const char kCandidatePrflx[] = "prflx";
174 static const char kCandidateRelay[] = "relay";
175 static const char kTcpCandidateType[] = "tcptype";
176
177 static const char kSdpDelimiterEqual = '=';
178 static const char kSdpDelimiterSpace = ' ';
179 static const char kSdpDelimiterColon = ':';
180 static const char kSdpDelimiterSemicolon = ';';
181 static const char kSdpDelimiterSlash = '/';
182 static const char kNewLine = '\n';
183 static const char kReturn = '\r';
184 static const char kLineBreak[] = "\r\n";
185
186 // TODO: Generate the Session and Time description
187 // instead of hardcoding.
188 static const char kSessionVersion[] = "v=0";
189 // RFC 4566
190 static const char kSessionOriginUsername[] = "-";
191 static const char kSessionOriginSessionId[] = "0";
192 static const char kSessionOriginSessionVersion[] = "0";
193 static const char kSessionOriginNettype[] = "IN";
194 static const char kSessionOriginAddrtype[] = "IP4";
195 static const char kSessionOriginAddress[] = "127.0.0.1";
196 static const char kSessionName[] = "s=-";
197 static const char kTimeDescription[] = "t=0 0";
198 static const char kAttrGroup[] = "a=group:BUNDLE";
199 static const char kConnectionNettype[] = "IN";
200 static const char kConnectionAddrtype[] = "IP4";
201 static const char kMediaTypeVideo[] = "video";
202 static const char kMediaTypeAudio[] = "audio";
203 static const char kMediaTypeData[] = "application";
204 static const char kMediaPortRejected[] = "0";
205 static const char kDefaultAddress[] = "0.0.0.0";
206 static const char kDefaultPort[] = "1";
207 // RFC 3556
208 static const char kApplicationSpecificMaximum[] = "AS";
209
210 static const int kDefaultVideoClockrate = 90000;
211
212 // ISAC special-case.
213 static const char kIsacCodecName[] = "ISAC"; // From webrtcvoiceengine.cc
214 static const int kIsacWbDefaultRate = 32000; // From acm_common_defs.h
215 static const int kIsacSwbDefaultRate = 56000; // From acm_common_defs.h
216
217 static const char kDefaultSctpmapProtocol[] = "webrtc-datachannel";
218
219 struct SsrcInfo {
SsrcInfowebrtc::SsrcInfo220 SsrcInfo()
221 : msid_identifier(kDefaultMsid),
222 // TODO(ronghuawu): What should we do if the appdata doesn't appear?
223 // Create random string (which will be used as track label later)?
224 msid_appdata(rtc::CreateRandomString(8)) {
225 }
226 uint32 ssrc_id;
227 std::string cname;
228 std::string msid_identifier;
229 std::string msid_appdata;
230
231 // For backward compatibility.
232 // TODO(ronghuawu): Remove below 2 fields once all the clients support msid.
233 std::string label;
234 std::string mslabel;
235 };
236 typedef std::vector<SsrcInfo> SsrcInfoVec;
237 typedef std::vector<SsrcGroup> SsrcGroupVec;
238
239 template <class T>
240 static void AddFmtpLine(const T& codec, std::string* message);
241 static void BuildMediaDescription(const ContentInfo* content_info,
242 const TransportInfo* transport_info,
243 const MediaType media_type,
244 const std::vector<Candidate>& candidates,
245 std::string* message);
246 static void BuildSctpContentAttributes(std::string* message, int sctp_port);
247 static void BuildRtpContentAttributes(
248 const MediaContentDescription* media_desc,
249 const MediaType media_type,
250 std::string* message);
251 static void BuildRtpMap(const MediaContentDescription* media_desc,
252 const MediaType media_type,
253 std::string* message);
254 static void BuildCandidate(const std::vector<Candidate>& candidates,
255 std::string* message);
256 static void BuildIceOptions(const std::vector<std::string>& transport_options,
257 std::string* message);
258
259 static bool ParseSessionDescription(const std::string& message, size_t* pos,
260 std::string* session_id,
261 std::string* session_version,
262 bool* supports_msid,
263 TransportDescription* session_td,
264 RtpHeaderExtensions* session_extmaps,
265 cricket::SessionDescription* desc,
266 SdpParseError* error);
267 static bool ParseGroupAttribute(const std::string& line,
268 cricket::SessionDescription* desc,
269 SdpParseError* error);
270 static bool ParseMediaDescription(
271 const std::string& message,
272 const TransportDescription& session_td,
273 const RtpHeaderExtensions& session_extmaps,
274 bool supports_msid,
275 size_t* pos, cricket::SessionDescription* desc,
276 std::vector<JsepIceCandidate*>* candidates,
277 SdpParseError* error);
278 static bool ParseContent(const std::string& message,
279 const MediaType media_type,
280 int mline_index,
281 const std::string& protocol,
282 const std::vector<int>& codec_preference,
283 size_t* pos,
284 std::string* content_name,
285 MediaContentDescription* media_desc,
286 TransportDescription* transport,
287 std::vector<JsepIceCandidate*>* candidates,
288 SdpParseError* error);
289 static bool ParseSsrcAttribute(const std::string& line,
290 SsrcInfoVec* ssrc_infos,
291 SdpParseError* error);
292 static bool ParseSsrcGroupAttribute(const std::string& line,
293 SsrcGroupVec* ssrc_groups,
294 SdpParseError* error);
295 static bool ParseCryptoAttribute(const std::string& line,
296 MediaContentDescription* media_desc,
297 SdpParseError* error);
298 static bool ParseRtpmapAttribute(const std::string& line,
299 const MediaType media_type,
300 const std::vector<int>& codec_preference,
301 MediaContentDescription* media_desc,
302 SdpParseError* error);
303 static bool ParseFmtpAttributes(const std::string& line,
304 const MediaType media_type,
305 MediaContentDescription* media_desc,
306 SdpParseError* error);
307 static bool ParseFmtpParam(const std::string& line, std::string* parameter,
308 std::string* value, SdpParseError* error);
309 static bool ParseCandidate(const std::string& message, Candidate* candidate,
310 SdpParseError* error, bool is_raw);
311 static bool ParseRtcpFbAttribute(const std::string& line,
312 const MediaType media_type,
313 MediaContentDescription* media_desc,
314 SdpParseError* error);
315 static bool ParseIceOptions(const std::string& line,
316 std::vector<std::string>* transport_options,
317 SdpParseError* error);
318 static bool ParseExtmap(const std::string& line,
319 RtpHeaderExtension* extmap,
320 SdpParseError* error);
321 static bool ParseFingerprintAttribute(const std::string& line,
322 rtc::SSLFingerprint** fingerprint,
323 SdpParseError* error);
324 static bool ParseDtlsSetup(const std::string& line,
325 cricket::ConnectionRole* role,
326 SdpParseError* error);
327
328 // Helper functions
329
330 // Below ParseFailed*** functions output the line that caused the parsing
331 // failure and the detailed reason (|description|) of the failure to |error|.
332 // The functions always return false so that they can be used directly in the
333 // following way when error happens:
334 // "return ParseFailed***(...);"
335
336 // The line starting at |line_start| of |message| is the failing line.
337 // The reason for the failure should be provided in the |description|.
338 // An example of a description could be "unknown character".
ParseFailed(const std::string & message,size_t line_start,const std::string & description,SdpParseError * error)339 static bool ParseFailed(const std::string& message,
340 size_t line_start,
341 const std::string& description,
342 SdpParseError* error) {
343 // Get the first line of |message| from |line_start|.
344 std::string first_line;
345 size_t line_end = message.find(kNewLine, line_start);
346 if (line_end != std::string::npos) {
347 if (line_end > 0 && (message.at(line_end - 1) == kReturn)) {
348 --line_end;
349 }
350 first_line = message.substr(line_start, (line_end - line_start));
351 } else {
352 first_line = message.substr(line_start);
353 }
354
355 if (error) {
356 error->line = first_line;
357 error->description = description;
358 }
359 LOG(LS_ERROR) << "Failed to parse: \"" << first_line
360 << "\". Reason: " << description;
361 return false;
362 }
363
364 // |line| is the failing line. The reason for the failure should be
365 // provided in the |description|.
ParseFailed(const std::string & line,const std::string & description,SdpParseError * error)366 static bool ParseFailed(const std::string& line,
367 const std::string& description,
368 SdpParseError* error) {
369 return ParseFailed(line, 0, description, error);
370 }
371
372 // Parses failure where the failing SDP line isn't know or there are multiple
373 // failing lines.
ParseFailed(const std::string & description,SdpParseError * error)374 static bool ParseFailed(const std::string& description,
375 SdpParseError* error) {
376 return ParseFailed("", description, error);
377 }
378
379 // |line| is the failing line. The failure is due to the fact that |line|
380 // doesn't have |expected_fields| fields.
ParseFailedExpectFieldNum(const std::string & line,int expected_fields,SdpParseError * error)381 static bool ParseFailedExpectFieldNum(const std::string& line,
382 int expected_fields,
383 SdpParseError* error) {
384 std::ostringstream description;
385 description << "Expects " << expected_fields << " fields.";
386 return ParseFailed(line, description.str(), error);
387 }
388
389 // |line| is the failing line. The failure is due to the fact that |line| has
390 // less than |expected_min_fields| fields.
ParseFailedExpectMinFieldNum(const std::string & line,int expected_min_fields,SdpParseError * error)391 static bool ParseFailedExpectMinFieldNum(const std::string& line,
392 int expected_min_fields,
393 SdpParseError* error) {
394 std::ostringstream description;
395 description << "Expects at least " << expected_min_fields << " fields.";
396 return ParseFailed(line, description.str(), error);
397 }
398
399 // |line| is the failing line. The failure is due to the fact that it failed to
400 // get the value of |attribute|.
ParseFailedGetValue(const std::string & line,const std::string & attribute,SdpParseError * error)401 static bool ParseFailedGetValue(const std::string& line,
402 const std::string& attribute,
403 SdpParseError* error) {
404 std::ostringstream description;
405 description << "Failed to get the value of attribute: " << attribute;
406 return ParseFailed(line, description.str(), error);
407 }
408
409 // The line starting at |line_start| of |message| is the failing line. The
410 // failure is due to the line type (e.g. the "m" part of the "m-line")
411 // not matching what is expected. The expected line type should be
412 // provided as |line_type|.
ParseFailedExpectLine(const std::string & message,size_t line_start,const char line_type,const std::string & line_value,SdpParseError * error)413 static bool ParseFailedExpectLine(const std::string& message,
414 size_t line_start,
415 const char line_type,
416 const std::string& line_value,
417 SdpParseError* error) {
418 std::ostringstream description;
419 description << "Expect line: " << line_type << "=" << line_value;
420 return ParseFailed(message, line_start, description.str(), error);
421 }
422
AddLine(const std::string & line,std::string * message)423 static bool AddLine(const std::string& line, std::string* message) {
424 if (!message)
425 return false;
426
427 message->append(line);
428 message->append(kLineBreak);
429 return true;
430 }
431
GetLine(const std::string & message,size_t * pos,std::string * line)432 static bool GetLine(const std::string& message,
433 size_t* pos,
434 std::string* line) {
435 size_t line_begin = *pos;
436 size_t line_end = message.find(kNewLine, line_begin);
437 if (line_end == std::string::npos) {
438 return false;
439 }
440 // Update the new start position
441 *pos = line_end + 1;
442 if (line_end > 0 && (message.at(line_end - 1) == kReturn)) {
443 --line_end;
444 }
445 *line = message.substr(line_begin, (line_end - line_begin));
446 const char* cline = line->c_str();
447 // RFC 4566
448 // An SDP session description consists of a number of lines of text of
449 // the form:
450 // <type>=<value>
451 // where <type> MUST be exactly one case-significant character and
452 // <value> is structured text whose format depends on <type>.
453 // Whitespace MUST NOT be used on either side of the "=" sign.
454 if (cline[0] == kSdpDelimiterSpace ||
455 cline[1] != kSdpDelimiterEqual ||
456 cline[2] == kSdpDelimiterSpace) {
457 *pos = line_begin;
458 return false;
459 }
460 return true;
461 }
462
463 // Init |os| to "|type|=|value|".
InitLine(const char type,const std::string & value,std::ostringstream * os)464 static void InitLine(const char type,
465 const std::string& value,
466 std::ostringstream* os) {
467 os->str("");
468 *os << type << kSdpDelimiterEqual << value;
469 }
470
471 // Init |os| to "a=|attribute|".
InitAttrLine(const std::string & attribute,std::ostringstream * os)472 static void InitAttrLine(const std::string& attribute, std::ostringstream* os) {
473 InitLine(kLineTypeAttributes, attribute, os);
474 }
475
476 // Writes a SDP attribute line based on |attribute| and |value| to |message|.
AddAttributeLine(const std::string & attribute,int value,std::string * message)477 static void AddAttributeLine(const std::string& attribute, int value,
478 std::string* message) {
479 std::ostringstream os;
480 InitAttrLine(attribute, &os);
481 os << kSdpDelimiterColon << value;
482 AddLine(os.str(), message);
483 }
484
IsLineType(const std::string & message,const char type,size_t line_start)485 static bool IsLineType(const std::string& message,
486 const char type,
487 size_t line_start) {
488 if (message.size() < line_start + kLinePrefixLength) {
489 return false;
490 }
491 const char* cmessage = message.c_str();
492 return (cmessage[line_start] == type &&
493 cmessage[line_start + 1] == kSdpDelimiterEqual);
494 }
495
IsLineType(const std::string & line,const char type)496 static bool IsLineType(const std::string& line,
497 const char type) {
498 return IsLineType(line, type, 0);
499 }
500
GetLineWithType(const std::string & message,size_t * pos,std::string * line,const char type)501 static bool GetLineWithType(const std::string& message, size_t* pos,
502 std::string* line, const char type) {
503 if (!IsLineType(message, type, *pos)) {
504 return false;
505 }
506
507 if (!GetLine(message, pos, line))
508 return false;
509
510 return true;
511 }
512
HasAttribute(const std::string & line,const std::string & attribute)513 static bool HasAttribute(const std::string& line,
514 const std::string& attribute) {
515 return (line.compare(kLinePrefixLength, attribute.size(), attribute) == 0);
516 }
517
AddSsrcLine(uint32 ssrc_id,const std::string & attribute,const std::string & value,std::string * message)518 static bool AddSsrcLine(uint32 ssrc_id, const std::string& attribute,
519 const std::string& value, std::string* message) {
520 // RFC 5576
521 // a=ssrc:<ssrc-id> <attribute>:<value>
522 std::ostringstream os;
523 InitAttrLine(kAttributeSsrc, &os);
524 os << kSdpDelimiterColon << ssrc_id << kSdpDelimiterSpace
525 << attribute << kSdpDelimiterColon << value;
526 return AddLine(os.str(), message);
527 }
528
529 // Split the message into two parts by the first delimiter.
SplitByDelimiter(const std::string & message,const char delimiter,std::string * field1,std::string * field2)530 static bool SplitByDelimiter(const std::string& message,
531 const char delimiter,
532 std::string* field1,
533 std::string* field2) {
534 // Find the first delimiter
535 size_t pos = message.find(delimiter);
536 if (pos == std::string::npos) {
537 return false;
538 }
539 *field1 = message.substr(0, pos);
540 // The rest is the value.
541 *field2 = message.substr(pos + 1);
542 return true;
543 }
544
545 // Get value only from <attribute>:<value>.
GetValue(const std::string & message,const std::string & attribute,std::string * value,SdpParseError * error)546 static bool GetValue(const std::string& message, const std::string& attribute,
547 std::string* value, SdpParseError* error) {
548 std::string leftpart;
549 if (!SplitByDelimiter(message, kSdpDelimiterColon, &leftpart, value)) {
550 return ParseFailedGetValue(message, attribute, error);
551 }
552 // The left part should end with the expected attribute.
553 if (leftpart.length() < attribute.length() ||
554 leftpart.compare(leftpart.length() - attribute.length(),
555 attribute.length(), attribute) != 0) {
556 return ParseFailedGetValue(message, attribute, error);
557 }
558 return true;
559 }
560
CaseInsensitiveFind(std::string str1,std::string str2)561 static bool CaseInsensitiveFind(std::string str1, std::string str2) {
562 std::transform(str1.begin(), str1.end(), str1.begin(),
563 ::tolower);
564 std::transform(str2.begin(), str2.end(), str2.begin(),
565 ::tolower);
566 return str1.find(str2) != std::string::npos;
567 }
568
569 template <class T>
GetValueFromString(const std::string & line,const std::string & s,T * t,SdpParseError * error)570 static bool GetValueFromString(const std::string& line,
571 const std::string& s,
572 T* t,
573 SdpParseError* error) {
574 if (!rtc::FromString(s, t)) {
575 std::ostringstream description;
576 description << "Invalid value: " << s << ".";
577 return ParseFailed(line, description.str(), error);
578 }
579 return true;
580 }
581
CreateTracksFromSsrcInfos(const SsrcInfoVec & ssrc_infos,StreamParamsVec * tracks)582 void CreateTracksFromSsrcInfos(const SsrcInfoVec& ssrc_infos,
583 StreamParamsVec* tracks) {
584 ASSERT(tracks != NULL);
585 for (SsrcInfoVec::const_iterator ssrc_info = ssrc_infos.begin();
586 ssrc_info != ssrc_infos.end(); ++ssrc_info) {
587 if (ssrc_info->cname.empty()) {
588 continue;
589 }
590
591 std::string sync_label;
592 std::string track_id;
593 if (ssrc_info->msid_identifier == kDefaultMsid &&
594 !ssrc_info->mslabel.empty()) {
595 // If there's no msid and there's mslabel, we consider this is a sdp from
596 // a older version of client that doesn't support msid.
597 // In that case, we use the mslabel and label to construct the track.
598 sync_label = ssrc_info->mslabel;
599 track_id = ssrc_info->label;
600 } else {
601 sync_label = ssrc_info->msid_identifier;
602 // The appdata consists of the "id" attribute of a MediaStreamTrack, which
603 // is corresponding to the "id" attribute of StreamParams.
604 track_id = ssrc_info->msid_appdata;
605 }
606 if (sync_label.empty() || track_id.empty()) {
607 ASSERT(false);
608 continue;
609 }
610
611 StreamParamsVec::iterator track = tracks->begin();
612 for (; track != tracks->end(); ++track) {
613 if (track->id == track_id) {
614 break;
615 }
616 }
617 if (track == tracks->end()) {
618 // If we don't find an existing track, create a new one.
619 tracks->push_back(StreamParams());
620 track = tracks->end() - 1;
621 }
622 track->add_ssrc(ssrc_info->ssrc_id);
623 track->cname = ssrc_info->cname;
624 track->sync_label = sync_label;
625 track->id = track_id;
626 }
627 }
628
GetMediaStreamLabels(const ContentInfo * content,std::set<std::string> * labels)629 void GetMediaStreamLabels(const ContentInfo* content,
630 std::set<std::string>* labels) {
631 const MediaContentDescription* media_desc =
632 static_cast<const MediaContentDescription*>(
633 content->description);
634 const cricket::StreamParamsVec& streams = media_desc->streams();
635 for (cricket::StreamParamsVec::const_iterator it = streams.begin();
636 it != streams.end(); ++it) {
637 labels->insert(it->sync_label);
638 }
639 }
640
641 // RFC 5245
642 // It is RECOMMENDED that default candidates be chosen based on the
643 // likelihood of those candidates to work with the peer that is being
644 // contacted. It is RECOMMENDED that relayed > reflexive > host.
645 static const int kPreferenceUnknown = 0;
646 static const int kPreferenceHost = 1;
647 static const int kPreferenceReflexive = 2;
648 static const int kPreferenceRelayed = 3;
649
GetCandidatePreferenceFromType(const std::string & type)650 static int GetCandidatePreferenceFromType(const std::string& type) {
651 int preference = kPreferenceUnknown;
652 if (type == cricket::LOCAL_PORT_TYPE) {
653 preference = kPreferenceHost;
654 } else if (type == cricket::STUN_PORT_TYPE) {
655 preference = kPreferenceReflexive;
656 } else if (type == cricket::RELAY_PORT_TYPE) {
657 preference = kPreferenceRelayed;
658 } else {
659 ASSERT(false);
660 }
661 return preference;
662 }
663
664 // Get ip and port of the default destination from the |candidates| with
665 // the given value of |component_id|.
666 // RFC 5245
667 // The value of |component_id| currently supported are 1 (RTP) and 2 (RTCP).
668 // TODO: Decide the default destination in webrtcsession and
669 // pass it down via SessionDescription.
GetDefaultDestination(const std::vector<Candidate> & candidates,int component_id,std::string * port,std::string * ip)670 static bool GetDefaultDestination(const std::vector<Candidate>& candidates,
671 int component_id, std::string* port, std::string* ip) {
672 *port = kDefaultPort;
673 *ip = kDefaultAddress;
674 int current_preference = kPreferenceUnknown;
675 for (std::vector<Candidate>::const_iterator it = candidates.begin();
676 it != candidates.end(); ++it) {
677 if (it->component() != component_id) {
678 continue;
679 }
680 const int preference = GetCandidatePreferenceFromType(it->type());
681 // See if this candidate is more preferable then the current one.
682 if (preference <= current_preference) {
683 continue;
684 }
685 current_preference = preference;
686 *port = it->address().PortAsString();
687 *ip = it->address().ipaddr().ToString();
688 }
689 return true;
690 }
691
692 // Update |mline|'s default destination and append a c line after it.
UpdateMediaDefaultDestination(const std::vector<Candidate> & candidates,const std::string mline,std::string * message)693 static void UpdateMediaDefaultDestination(
694 const std::vector<Candidate>& candidates,
695 const std::string mline,
696 std::string* message) {
697 std::string new_lines;
698 AddLine(mline, &new_lines);
699 // RFC 4566
700 // m=<media> <port> <proto> <fmt> ...
701 std::vector<std::string> fields;
702 rtc::split(mline, kSdpDelimiterSpace, &fields);
703 if (fields.size() < 3) {
704 return;
705 }
706
707 std::ostringstream os;
708 std::string rtp_port, rtp_ip;
709 if (GetDefaultDestination(candidates, ICE_CANDIDATE_COMPONENT_RTP,
710 &rtp_port, &rtp_ip)) {
711 // Found default RTP candidate.
712 // RFC 5245
713 // The default candidates are added to the SDP as the default
714 // destination for media. For streams based on RTP, this is done by
715 // placing the IP address and port of the RTP candidate into the c and m
716 // lines, respectively.
717
718 // Update the port in the m line.
719 // If this is a m-line with port equal to 0, we don't change it.
720 if (fields[1] != kMediaPortRejected) {
721 new_lines.replace(fields[0].size() + 1,
722 fields[1].size(),
723 rtp_port);
724 }
725 // Add the c line.
726 // RFC 4566
727 // c=<nettype> <addrtype> <connection-address>
728 InitLine(kLineTypeConnection, kConnectionNettype, &os);
729 os << " " << kConnectionAddrtype << " " << rtp_ip;
730 AddLine(os.str(), &new_lines);
731 }
732 message->append(new_lines);
733 }
734
735 // Gets "a=rtcp" line if found default RTCP candidate from |candidates|.
GetRtcpLine(const std::vector<Candidate> & candidates)736 static std::string GetRtcpLine(const std::vector<Candidate>& candidates) {
737 std::string rtcp_line, rtcp_port, rtcp_ip;
738 if (GetDefaultDestination(candidates, ICE_CANDIDATE_COMPONENT_RTCP,
739 &rtcp_port, &rtcp_ip)) {
740 // Found default RTCP candidate.
741 // RFC 5245
742 // If the agent is utilizing RTCP, it MUST encode the RTCP candidate
743 // using the a=rtcp attribute as defined in RFC 3605.
744
745 // RFC 3605
746 // rtcp-attribute = "a=rtcp:" port [nettype space addrtype space
747 // connection-address] CRLF
748 std::ostringstream os;
749 InitAttrLine(kAttributeRtcp, &os);
750 os << kSdpDelimiterColon
751 << rtcp_port << " "
752 << kConnectionNettype << " "
753 << kConnectionAddrtype << " "
754 << rtcp_ip;
755 rtcp_line = os.str();
756 }
757 return rtcp_line;
758 }
759
760 // Get candidates according to the mline index from SessionDescriptionInterface.
GetCandidatesByMindex(const SessionDescriptionInterface & desci,int mline_index,std::vector<Candidate> * candidates)761 static void GetCandidatesByMindex(const SessionDescriptionInterface& desci,
762 int mline_index,
763 std::vector<Candidate>* candidates) {
764 if (!candidates) {
765 return;
766 }
767 const IceCandidateCollection* cc = desci.candidates(mline_index);
768 for (size_t i = 0; i < cc->count(); ++i) {
769 const IceCandidateInterface* candidate = cc->at(i);
770 candidates->push_back(candidate->candidate());
771 }
772 }
773
SdpSerialize(const JsepSessionDescription & jdesc)774 std::string SdpSerialize(const JsepSessionDescription& jdesc) {
775 const cricket::SessionDescription* desc = jdesc.description();
776 if (!desc) {
777 return "";
778 }
779
780 std::string message;
781
782 // Session Description.
783 AddLine(kSessionVersion, &message);
784 // Session Origin
785 // RFC 4566
786 // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
787 // <unicast-address>
788 std::ostringstream os;
789 InitLine(kLineTypeOrigin, kSessionOriginUsername, &os);
790 const std::string session_id = jdesc.session_id().empty() ?
791 kSessionOriginSessionId : jdesc.session_id();
792 const std::string session_version = jdesc.session_version().empty() ?
793 kSessionOriginSessionVersion : jdesc.session_version();
794 os << " " << session_id << " " << session_version << " "
795 << kSessionOriginNettype << " " << kSessionOriginAddrtype << " "
796 << kSessionOriginAddress;
797 AddLine(os.str(), &message);
798 AddLine(kSessionName, &message);
799
800 // Time Description.
801 AddLine(kTimeDescription, &message);
802
803 // Group
804 if (desc->HasGroup(cricket::GROUP_TYPE_BUNDLE)) {
805 std::string group_line = kAttrGroup;
806 const cricket::ContentGroup* group =
807 desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
808 ASSERT(group != NULL);
809 const cricket::ContentNames& content_names = group->content_names();
810 for (cricket::ContentNames::const_iterator it = content_names.begin();
811 it != content_names.end(); ++it) {
812 group_line.append(" ");
813 group_line.append(*it);
814 }
815 AddLine(group_line, &message);
816 }
817
818 // MediaStream semantics
819 InitAttrLine(kAttributeMsidSemantics, &os);
820 os << kSdpDelimiterColon << " " << kMediaStreamSemantic;
821
822 std::set<std::string> media_stream_labels;
823 const ContentInfo* audio_content = GetFirstAudioContent(desc);
824 if (audio_content)
825 GetMediaStreamLabels(audio_content, &media_stream_labels);
826
827 const ContentInfo* video_content = GetFirstVideoContent(desc);
828 if (video_content)
829 GetMediaStreamLabels(video_content, &media_stream_labels);
830
831 for (std::set<std::string>::const_iterator it =
832 media_stream_labels.begin(); it != media_stream_labels.end(); ++it) {
833 os << " " << *it;
834 }
835 AddLine(os.str(), &message);
836
837 // Preserve the order of the media contents.
838 int mline_index = -1;
839 for (cricket::ContentInfos::const_iterator it = desc->contents().begin();
840 it != desc->contents().end(); ++it) {
841 const MediaContentDescription* mdesc =
842 static_cast<const MediaContentDescription*>(it->description);
843 std::vector<Candidate> candidates;
844 GetCandidatesByMindex(jdesc, ++mline_index, &candidates);
845 BuildMediaDescription(&*it,
846 desc->GetTransportInfoByName(it->name),
847 mdesc->type(),
848 candidates,
849 &message);
850 }
851 return message;
852 }
853
854 // Serializes the passed in IceCandidateInterface to a SDP string.
855 // candidate - The candidate to be serialized.
SdpSerializeCandidate(const IceCandidateInterface & candidate)856 std::string SdpSerializeCandidate(
857 const IceCandidateInterface& candidate) {
858 std::string message;
859 std::vector<cricket::Candidate> candidates;
860 candidates.push_back(candidate.candidate());
861 BuildCandidate(candidates, &message);
862 // From WebRTC draft section 4.8.1.1 candidate-attribute will be
863 // just candidate:<candidate> not a=candidate:<blah>CRLF
864 ASSERT(message.find("a=") == 0);
865 message.erase(0, 2);
866 ASSERT(message.find(kLineBreak) == message.size() - 2);
867 message.resize(message.size() - 2);
868 return message;
869 }
870
SdpDeserialize(const std::string & message,JsepSessionDescription * jdesc,SdpParseError * error)871 bool SdpDeserialize(const std::string& message,
872 JsepSessionDescription* jdesc,
873 SdpParseError* error) {
874 std::string session_id;
875 std::string session_version;
876 TransportDescription session_td(NS_JINGLE_ICE_UDP,
877 std::string(), std::string());
878 RtpHeaderExtensions session_extmaps;
879 cricket::SessionDescription* desc = new cricket::SessionDescription();
880 std::vector<JsepIceCandidate*> candidates;
881 size_t current_pos = 0;
882 bool supports_msid = false;
883
884 // Session Description
885 if (!ParseSessionDescription(message, ¤t_pos, &session_id,
886 &session_version, &supports_msid, &session_td,
887 &session_extmaps, desc, error)) {
888 delete desc;
889 return false;
890 }
891
892 // Media Description
893 if (!ParseMediaDescription(message, session_td, session_extmaps,
894 supports_msid, ¤t_pos, desc, &candidates,
895 error)) {
896 delete desc;
897 for (std::vector<JsepIceCandidate*>::const_iterator
898 it = candidates.begin(); it != candidates.end(); ++it) {
899 delete *it;
900 }
901 return false;
902 }
903
904 jdesc->Initialize(desc, session_id, session_version);
905
906 for (std::vector<JsepIceCandidate*>::const_iterator
907 it = candidates.begin(); it != candidates.end(); ++it) {
908 jdesc->AddCandidate(*it);
909 delete *it;
910 }
911 return true;
912 }
913
SdpDeserializeCandidate(const std::string & message,JsepIceCandidate * jcandidate,SdpParseError * error)914 bool SdpDeserializeCandidate(const std::string& message,
915 JsepIceCandidate* jcandidate,
916 SdpParseError* error) {
917 ASSERT(jcandidate != NULL);
918 Candidate candidate;
919 if (!ParseCandidate(message, &candidate, error, true)) {
920 return false;
921 }
922 jcandidate->SetCandidate(candidate);
923 return true;
924 }
925
ParseCandidate(const std::string & message,Candidate * candidate,SdpParseError * error,bool is_raw)926 bool ParseCandidate(const std::string& message, Candidate* candidate,
927 SdpParseError* error, bool is_raw) {
928 ASSERT(candidate != NULL);
929
930 // Get the first line from |message|.
931 std::string first_line = message;
932 size_t pos = 0;
933 GetLine(message, &pos, &first_line);
934
935 // Makes sure |message| contains only one line.
936 if (message.size() > first_line.size()) {
937 std::string left, right;
938 if (SplitByDelimiter(message, kNewLine, &left, &right) && !right.empty()) {
939 return ParseFailed(message, 0, "Expect one line only", error);
940 }
941 }
942
943 // From WebRTC draft section 4.8.1.1 candidate-attribute should be
944 // candidate:<candidate> when trickled, but we still support
945 // a=candidate:<blah>CRLF for backward compatibility and for parsing a line
946 // from the SDP.
947 if (IsLineType(first_line, kLineTypeAttributes)) {
948 first_line = first_line.substr(kLinePrefixLength);
949 }
950
951 std::string attribute_candidate;
952 std::string candidate_value;
953
954 // |first_line| must be in the form of "candidate:<value>".
955 if (!SplitByDelimiter(first_line, kSdpDelimiterColon,
956 &attribute_candidate, &candidate_value) ||
957 attribute_candidate != kAttributeCandidate) {
958 if (is_raw) {
959 std::ostringstream description;
960 description << "Expect line: " << kAttributeCandidate
961 << ":" << "<candidate-str>";
962 return ParseFailed(first_line, 0, description.str(), error);
963 } else {
964 return ParseFailedExpectLine(first_line, 0, kLineTypeAttributes,
965 kAttributeCandidate, error);
966 }
967 }
968
969 std::vector<std::string> fields;
970 rtc::split(candidate_value, kSdpDelimiterSpace, &fields);
971
972 // RFC 5245
973 // a=candidate:<foundation> <component-id> <transport> <priority>
974 // <connection-address> <port> typ <candidate-types>
975 // [raddr <connection-address>] [rport <port>]
976 // *(SP extension-att-name SP extension-att-value)
977 const size_t expected_min_fields = 8;
978 if (fields.size() < expected_min_fields ||
979 (fields[6] != kAttributeCandidateTyp)) {
980 return ParseFailedExpectMinFieldNum(first_line, expected_min_fields, error);
981 }
982 std::string foundation = fields[0];
983
984 int component_id = 0;
985 if (!GetValueFromString(first_line, fields[1], &component_id, error)) {
986 return false;
987 }
988 const std::string transport = fields[2];
989 uint32 priority = 0;
990 if (!GetValueFromString(first_line, fields[3], &priority, error)) {
991 return false;
992 }
993 const std::string connection_address = fields[4];
994 int port = 0;
995 if (!GetValueFromString(first_line, fields[5], &port, error)) {
996 return false;
997 }
998 SocketAddress address(connection_address, port);
999
1000 cricket::ProtocolType protocol;
1001 if (!StringToProto(transport.c_str(), &protocol)) {
1002 return ParseFailed(first_line, "Unsupported transport type.", error);
1003 }
1004
1005 std::string candidate_type;
1006 const std::string type = fields[7];
1007 if (type == kCandidateHost) {
1008 candidate_type = cricket::LOCAL_PORT_TYPE;
1009 } else if (type == kCandidateSrflx) {
1010 candidate_type = cricket::STUN_PORT_TYPE;
1011 } else if (type == kCandidateRelay) {
1012 candidate_type = cricket::RELAY_PORT_TYPE;
1013 } else {
1014 return ParseFailed(first_line, "Unsupported candidate type.", error);
1015 }
1016
1017 size_t current_position = expected_min_fields;
1018 SocketAddress related_address;
1019 // The 2 optional fields for related address
1020 // [raddr <connection-address>] [rport <port>]
1021 if (fields.size() >= (current_position + 2) &&
1022 fields[current_position] == kAttributeCandidateRaddr) {
1023 related_address.SetIP(fields[++current_position]);
1024 ++current_position;
1025 }
1026 if (fields.size() >= (current_position + 2) &&
1027 fields[current_position] == kAttributeCandidateRport) {
1028 int port = 0;
1029 if (!GetValueFromString(
1030 first_line, fields[++current_position], &port, error)) {
1031 return false;
1032 }
1033 related_address.SetPort(port);
1034 ++current_position;
1035 }
1036
1037 // If this is a TCP candidate, it has additional extension as defined in
1038 // RFC 6544.
1039 std::string tcptype;
1040 if (fields.size() >= (current_position + 2) &&
1041 fields[current_position] == kTcpCandidateType) {
1042 tcptype = fields[++current_position];
1043 ++current_position;
1044
1045 if (tcptype != cricket::TCPTYPE_ACTIVE_STR &&
1046 tcptype != cricket::TCPTYPE_PASSIVE_STR &&
1047 tcptype != cricket::TCPTYPE_SIMOPEN_STR) {
1048 return ParseFailed(first_line, "Invalid TCP candidate type.", error);
1049 }
1050
1051 if (protocol != cricket::PROTO_TCP) {
1052 return ParseFailed(first_line, "Invalid non-TCP candidate", error);
1053 }
1054 }
1055
1056 // Extension
1057 // Empty string as the candidate username and password.
1058 // Will be updated later with the ice-ufrag and ice-pwd.
1059 // TODO: Remove the username/password extension, which is currently
1060 // kept for backwards compatibility.
1061 std::string username;
1062 std::string password;
1063 uint32 generation = 0;
1064 for (size_t i = current_position; i + 1 < fields.size(); ++i) {
1065 // RFC 5245
1066 // *(SP extension-att-name SP extension-att-value)
1067 if (fields[i] == kAttributeCandidateGeneration) {
1068 if (!GetValueFromString(first_line, fields[++i], &generation, error)) {
1069 return false;
1070 }
1071 } else if (fields[i] == kAttributeCandidateUsername) {
1072 username = fields[++i];
1073 } else if (fields[i] == kAttributeCandidatePassword) {
1074 password = fields[++i];
1075 } else {
1076 // Skip the unknown extension.
1077 ++i;
1078 }
1079 }
1080
1081 // Empty string as the candidate id and network name.
1082 const std::string id;
1083 const std::string network_name;
1084 *candidate = Candidate(id, component_id, cricket::ProtoToString(protocol),
1085 address, priority, username, password, candidate_type, network_name,
1086 generation, foundation);
1087 candidate->set_related_address(related_address);
1088 candidate->set_tcptype(tcptype);
1089 return true;
1090 }
1091
ParseIceOptions(const std::string & line,std::vector<std::string> * transport_options,SdpParseError * error)1092 bool ParseIceOptions(const std::string& line,
1093 std::vector<std::string>* transport_options,
1094 SdpParseError* error) {
1095 std::string ice_options;
1096 if (!GetValue(line, kAttributeIceOption, &ice_options, error)) {
1097 return false;
1098 }
1099 std::vector<std::string> fields;
1100 rtc::split(ice_options, kSdpDelimiterSpace, &fields);
1101 for (size_t i = 0; i < fields.size(); ++i) {
1102 transport_options->push_back(fields[i]);
1103 }
1104 return true;
1105 }
1106
ParseSctpPort(const std::string & line,int * sctp_port,SdpParseError * error)1107 bool ParseSctpPort(const std::string& line,
1108 int* sctp_port,
1109 SdpParseError* error) {
1110 // draft-ietf-mmusic-sctp-sdp-07
1111 // a=sctp-port
1112 std::vector<std::string> fields;
1113 rtc::split(line.substr(kLinePrefixLength),
1114 kSdpDelimiterSpace, &fields);
1115 const size_t expected_min_fields = 2;
1116 if (fields.size() < expected_min_fields) {
1117 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
1118 }
1119 if (!rtc::FromString(fields[1], sctp_port)) {
1120 return ParseFailed(line,
1121 "Invalid sctp port value.",
1122 error);
1123 }
1124 return true;
1125 }
1126
ParseExtmap(const std::string & line,RtpHeaderExtension * extmap,SdpParseError * error)1127 bool ParseExtmap(const std::string& line, RtpHeaderExtension* extmap,
1128 SdpParseError* error) {
1129 // RFC 5285
1130 // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
1131 std::vector<std::string> fields;
1132 rtc::split(line.substr(kLinePrefixLength),
1133 kSdpDelimiterSpace, &fields);
1134 const size_t expected_min_fields = 2;
1135 if (fields.size() < expected_min_fields) {
1136 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
1137 }
1138 std::string uri = fields[1];
1139
1140 std::string value_direction;
1141 if (!GetValue(fields[0], kAttributeExtmap, &value_direction, error)) {
1142 return false;
1143 }
1144 std::vector<std::string> sub_fields;
1145 rtc::split(value_direction, kSdpDelimiterSlash, &sub_fields);
1146 int value = 0;
1147 if (!GetValueFromString(line, sub_fields[0], &value, error)) {
1148 return false;
1149 }
1150
1151 *extmap = RtpHeaderExtension(uri, value);
1152 return true;
1153 }
1154
BuildMediaDescription(const ContentInfo * content_info,const TransportInfo * transport_info,const MediaType media_type,const std::vector<Candidate> & candidates,std::string * message)1155 void BuildMediaDescription(const ContentInfo* content_info,
1156 const TransportInfo* transport_info,
1157 const MediaType media_type,
1158 const std::vector<Candidate>& candidates,
1159 std::string* message) {
1160 ASSERT(message != NULL);
1161 if (content_info == NULL || message == NULL) {
1162 return;
1163 }
1164 // TODO: Rethink if we should use sprintfn instead of stringstream.
1165 // According to the style guide, streams should only be used for logging.
1166 // http://google-styleguide.googlecode.com/svn/
1167 // trunk/cppguide.xml?showone=Streams#Streams
1168 std::ostringstream os;
1169 const MediaContentDescription* media_desc =
1170 static_cast<const MediaContentDescription*>(
1171 content_info->description);
1172 ASSERT(media_desc != NULL);
1173
1174 bool is_sctp = (media_desc->protocol() == cricket::kMediaProtocolDtlsSctp);
1175 int sctp_port = cricket::kSctpDefaultPort;
1176
1177 // RFC 4566
1178 // m=<media> <port> <proto> <fmt>
1179 // fmt is a list of payload type numbers that MAY be used in the session.
1180 const char* type = NULL;
1181 if (media_type == cricket::MEDIA_TYPE_AUDIO)
1182 type = kMediaTypeAudio;
1183 else if (media_type == cricket::MEDIA_TYPE_VIDEO)
1184 type = kMediaTypeVideo;
1185 else if (media_type == cricket::MEDIA_TYPE_DATA)
1186 type = kMediaTypeData;
1187 else
1188 ASSERT(false);
1189
1190 std::string fmt;
1191 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
1192 const VideoContentDescription* video_desc =
1193 static_cast<const VideoContentDescription*>(media_desc);
1194 for (std::vector<cricket::VideoCodec>::const_iterator it =
1195 video_desc->codecs().begin();
1196 it != video_desc->codecs().end(); ++it) {
1197 fmt.append(" ");
1198 fmt.append(rtc::ToString<int>(it->id));
1199 }
1200 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
1201 const AudioContentDescription* audio_desc =
1202 static_cast<const AudioContentDescription*>(media_desc);
1203 for (std::vector<cricket::AudioCodec>::const_iterator it =
1204 audio_desc->codecs().begin();
1205 it != audio_desc->codecs().end(); ++it) {
1206 fmt.append(" ");
1207 fmt.append(rtc::ToString<int>(it->id));
1208 }
1209 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
1210 const DataContentDescription* data_desc =
1211 static_cast<const DataContentDescription*>(media_desc);
1212 if (is_sctp) {
1213 fmt.append(" ");
1214
1215 for (std::vector<cricket::DataCodec>::const_iterator it =
1216 data_desc->codecs().begin();
1217 it != data_desc->codecs().end(); ++it) {
1218 if (it->id == cricket::kGoogleSctpDataCodecId &&
1219 it->GetParam(cricket::kCodecParamPort, &sctp_port)) {
1220 break;
1221 }
1222 }
1223
1224 fmt.append(rtc::ToString<int>(sctp_port));
1225 } else {
1226 for (std::vector<cricket::DataCodec>::const_iterator it =
1227 data_desc->codecs().begin();
1228 it != data_desc->codecs().end(); ++it) {
1229 fmt.append(" ");
1230 fmt.append(rtc::ToString<int>(it->id));
1231 }
1232 }
1233 }
1234 // The fmt must never be empty. If no codecs are found, set the fmt attribute
1235 // to 0.
1236 if (fmt.empty()) {
1237 fmt = " 0";
1238 }
1239
1240 // The port number in the m line will be updated later when associate with
1241 // the candidates.
1242 // RFC 3264
1243 // To reject an offered stream, the port number in the corresponding stream in
1244 // the answer MUST be set to zero.
1245 const std::string port = content_info->rejected ?
1246 kMediaPortRejected : kDefaultPort;
1247
1248 rtc::SSLFingerprint* fp = (transport_info) ?
1249 transport_info->description.identity_fingerprint.get() : NULL;
1250
1251 // Add the m and c lines.
1252 InitLine(kLineTypeMedia, type, &os);
1253 os << " " << port << " " << media_desc->protocol() << fmt;
1254 std::string mline = os.str();
1255 UpdateMediaDefaultDestination(candidates, mline, message);
1256
1257 // RFC 4566
1258 // b=AS:<bandwidth>
1259 // We should always use the default bandwidth for RTP-based data
1260 // channels. Don't allow SDP to set the bandwidth, because that
1261 // would give JS the opportunity to "break the Internet".
1262 // TODO(pthatcher): But we need to temporarily allow the SDP to control
1263 // this for backwards-compatibility. Once we don't need that any
1264 // more, remove this.
1265 bool support_dc_sdp_bandwidth_temporarily = true;
1266 if (media_desc->bandwidth() >= 1000 &&
1267 (media_type != cricket::MEDIA_TYPE_DATA ||
1268 support_dc_sdp_bandwidth_temporarily)) {
1269 InitLine(kLineTypeSessionBandwidth, kApplicationSpecificMaximum, &os);
1270 os << kSdpDelimiterColon << (media_desc->bandwidth() / 1000);
1271 AddLine(os.str(), message);
1272 }
1273
1274 // Add the a=rtcp line.
1275 bool is_rtp =
1276 media_desc->protocol().empty() ||
1277 rtc::starts_with(media_desc->protocol().data(),
1278 cricket::kMediaProtocolRtpPrefix);
1279 if (is_rtp) {
1280 std::string rtcp_line = GetRtcpLine(candidates);
1281 if (!rtcp_line.empty()) {
1282 AddLine(rtcp_line, message);
1283 }
1284 }
1285
1286 // Build the a=candidate lines.
1287 BuildCandidate(candidates, message);
1288
1289 // Use the transport_info to build the media level ice-ufrag and ice-pwd.
1290 if (transport_info) {
1291 // RFC 5245
1292 // ice-pwd-att = "ice-pwd" ":" password
1293 // ice-ufrag-att = "ice-ufrag" ":" ufrag
1294 // ice-ufrag
1295 InitAttrLine(kAttributeIceUfrag, &os);
1296 os << kSdpDelimiterColon << transport_info->description.ice_ufrag;
1297 AddLine(os.str(), message);
1298 // ice-pwd
1299 InitAttrLine(kAttributeIcePwd, &os);
1300 os << kSdpDelimiterColon << transport_info->description.ice_pwd;
1301 AddLine(os.str(), message);
1302
1303 // draft-petithuguenin-mmusic-ice-attributes-level-03
1304 BuildIceOptions(transport_info->description.transport_options, message);
1305
1306 // RFC 4572
1307 // fingerprint-attribute =
1308 // "fingerprint" ":" hash-func SP fingerprint
1309 if (fp) {
1310 // Insert the fingerprint attribute.
1311 InitAttrLine(kAttributeFingerprint, &os);
1312 os << kSdpDelimiterColon
1313 << fp->algorithm << kSdpDelimiterSpace
1314 << fp->GetRfc4572Fingerprint();
1315 AddLine(os.str(), message);
1316
1317 // Inserting setup attribute.
1318 if (transport_info->description.connection_role !=
1319 cricket::CONNECTIONROLE_NONE) {
1320 // Making sure we are not using "passive" mode.
1321 cricket::ConnectionRole role =
1322 transport_info->description.connection_role;
1323 std::string dtls_role_str;
1324 VERIFY(cricket::ConnectionRoleToString(role, &dtls_role_str));
1325 InitAttrLine(kAttributeSetup, &os);
1326 os << kSdpDelimiterColon << dtls_role_str;
1327 AddLine(os.str(), message);
1328 }
1329 }
1330 }
1331
1332 // RFC 3388
1333 // mid-attribute = "a=mid:" identification-tag
1334 // identification-tag = token
1335 // Use the content name as the mid identification-tag.
1336 InitAttrLine(kAttributeMid, &os);
1337 os << kSdpDelimiterColon << content_info->name;
1338 AddLine(os.str(), message);
1339
1340 if (is_sctp) {
1341 BuildSctpContentAttributes(message, sctp_port);
1342 } else {
1343 BuildRtpContentAttributes(media_desc, media_type, message);
1344 }
1345 }
1346
BuildSctpContentAttributes(std::string * message,int sctp_port)1347 void BuildSctpContentAttributes(std::string* message, int sctp_port) {
1348 // draft-ietf-mmusic-sctp-sdp-04
1349 // a=sctpmap:sctpmap-number protocol [streams]
1350 std::ostringstream os;
1351 InitAttrLine(kAttributeSctpmap, &os);
1352 os << kSdpDelimiterColon << sctp_port << kSdpDelimiterSpace
1353 << kDefaultSctpmapProtocol << kSdpDelimiterSpace
1354 << (cricket::kMaxSctpSid + 1);
1355 AddLine(os.str(), message);
1356 }
1357
BuildRtpContentAttributes(const MediaContentDescription * media_desc,const MediaType media_type,std::string * message)1358 void BuildRtpContentAttributes(
1359 const MediaContentDescription* media_desc,
1360 const MediaType media_type,
1361 std::string* message) {
1362 std::ostringstream os;
1363 // RFC 5285
1364 // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
1365 // The definitions MUST be either all session level or all media level. This
1366 // implementation uses all media level.
1367 for (size_t i = 0; i < media_desc->rtp_header_extensions().size(); ++i) {
1368 InitAttrLine(kAttributeExtmap, &os);
1369 os << kSdpDelimiterColon << media_desc->rtp_header_extensions()[i].id
1370 << kSdpDelimiterSpace << media_desc->rtp_header_extensions()[i].uri;
1371 AddLine(os.str(), message);
1372 }
1373
1374 // RFC 3264
1375 // a=sendrecv || a=sendonly || a=sendrecv || a=inactive
1376
1377 cricket::MediaContentDirection direction = media_desc->direction();
1378 if (media_desc->streams().empty() && direction == cricket::MD_SENDRECV) {
1379 direction = cricket::MD_RECVONLY;
1380 }
1381
1382 switch (direction) {
1383 case cricket::MD_INACTIVE:
1384 InitAttrLine(kAttributeInactive, &os);
1385 break;
1386 case cricket::MD_SENDONLY:
1387 InitAttrLine(kAttributeSendOnly, &os);
1388 break;
1389 case cricket::MD_RECVONLY:
1390 InitAttrLine(kAttributeRecvOnly, &os);
1391 break;
1392 case cricket::MD_SENDRECV:
1393 default:
1394 InitAttrLine(kAttributeSendRecv, &os);
1395 break;
1396 }
1397 AddLine(os.str(), message);
1398
1399 // RFC 5761
1400 // a=rtcp-mux
1401 if (media_desc->rtcp_mux()) {
1402 InitAttrLine(kAttributeRtcpMux, &os);
1403 AddLine(os.str(), message);
1404 }
1405
1406 // RFC 4568
1407 // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
1408 for (std::vector<CryptoParams>::const_iterator it =
1409 media_desc->cryptos().begin();
1410 it != media_desc->cryptos().end(); ++it) {
1411 InitAttrLine(kAttributeCrypto, &os);
1412 os << kSdpDelimiterColon << it->tag << " " << it->cipher_suite << " "
1413 << it->key_params;
1414 if (!it->session_params.empty()) {
1415 os << " " << it->session_params;
1416 }
1417 AddLine(os.str(), message);
1418 }
1419
1420 // RFC 4566
1421 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1422 // [/<encodingparameters>]
1423 BuildRtpMap(media_desc, media_type, message);
1424
1425 // Specify latency for buffered mode.
1426 // a=x-google-buffer-latency:<value>
1427 if (media_desc->buffered_mode_latency() != cricket::kBufferedModeDisabled) {
1428 std::ostringstream os;
1429 InitAttrLine(kAttributeXGoogleBufferLatency, &os);
1430 os << kSdpDelimiterColon << media_desc->buffered_mode_latency();
1431 AddLine(os.str(), message);
1432 }
1433
1434 for (StreamParamsVec::const_iterator track = media_desc->streams().begin();
1435 track != media_desc->streams().end(); ++track) {
1436 // Require that the track belongs to a media stream,
1437 // ie the sync_label is set. This extra check is necessary since the
1438 // MediaContentDescription always contains a streamparam with an ssrc even
1439 // if no track or media stream have been created.
1440 if (track->sync_label.empty()) continue;
1441
1442 // Build the ssrc-group lines.
1443 for (size_t i = 0; i < track->ssrc_groups.size(); ++i) {
1444 // RFC 5576
1445 // a=ssrc-group:<semantics> <ssrc-id> ...
1446 if (track->ssrc_groups[i].ssrcs.empty()) {
1447 continue;
1448 }
1449 std::ostringstream os;
1450 InitAttrLine(kAttributeSsrcGroup, &os);
1451 os << kSdpDelimiterColon << track->ssrc_groups[i].semantics;
1452 std::vector<uint32>::const_iterator ssrc =
1453 track->ssrc_groups[i].ssrcs.begin();
1454 for (; ssrc != track->ssrc_groups[i].ssrcs.end(); ++ssrc) {
1455 os << kSdpDelimiterSpace << rtc::ToString<uint32>(*ssrc);
1456 }
1457 AddLine(os.str(), message);
1458 }
1459 // Build the ssrc lines for each ssrc.
1460 for (size_t i = 0; i < track->ssrcs.size(); ++i) {
1461 uint32 ssrc = track->ssrcs[i];
1462 // RFC 5576
1463 // a=ssrc:<ssrc-id> cname:<value>
1464 AddSsrcLine(ssrc, kSsrcAttributeCname,
1465 track->cname, message);
1466
1467 // draft-alvestrand-mmusic-msid-00
1468 // a=ssrc:<ssrc-id> msid:identifier [appdata]
1469 // The appdata consists of the "id" attribute of a MediaStreamTrack, which
1470 // is corresponding to the "name" attribute of StreamParams.
1471 std::string appdata = track->id;
1472 std::ostringstream os;
1473 InitAttrLine(kAttributeSsrc, &os);
1474 os << kSdpDelimiterColon << ssrc << kSdpDelimiterSpace
1475 << kSsrcAttributeMsid << kSdpDelimiterColon << track->sync_label
1476 << kSdpDelimiterSpace << appdata;
1477 AddLine(os.str(), message);
1478
1479 // TODO(ronghuawu): Remove below code which is for backward compatibility.
1480 // draft-alvestrand-rtcweb-mid-01
1481 // a=ssrc:<ssrc-id> mslabel:<value>
1482 // The label isn't yet defined.
1483 // a=ssrc:<ssrc-id> label:<value>
1484 AddSsrcLine(ssrc, kSsrcAttributeMslabel, track->sync_label, message);
1485 AddSsrcLine(ssrc, kSSrcAttributeLabel, track->id, message);
1486 }
1487 }
1488 }
1489
WriteFmtpHeader(int payload_type,std::ostringstream * os)1490 void WriteFmtpHeader(int payload_type, std::ostringstream* os) {
1491 // fmtp header: a=fmtp:|payload_type| <parameters>
1492 // Add a=fmtp
1493 InitAttrLine(kAttributeFmtp, os);
1494 // Add :|payload_type|
1495 *os << kSdpDelimiterColon << payload_type;
1496 }
1497
WriteRtcpFbHeader(int payload_type,std::ostringstream * os)1498 void WriteRtcpFbHeader(int payload_type, std::ostringstream* os) {
1499 // rtcp-fb header: a=rtcp-fb:|payload_type|
1500 // <parameters>/<ccm <ccm_parameters>>
1501 // Add a=rtcp-fb
1502 InitAttrLine(kAttributeRtcpFb, os);
1503 // Add :
1504 *os << kSdpDelimiterColon;
1505 if (payload_type == kWildcardPayloadType) {
1506 *os << "*";
1507 } else {
1508 *os << payload_type;
1509 }
1510 }
1511
WriteFmtpParameter(const std::string & parameter_name,const std::string & parameter_value,std::ostringstream * os)1512 void WriteFmtpParameter(const std::string& parameter_name,
1513 const std::string& parameter_value,
1514 std::ostringstream* os) {
1515 // fmtp parameters: |parameter_name|=|parameter_value|
1516 *os << parameter_name << kSdpDelimiterEqual << parameter_value;
1517 }
1518
WriteFmtpParameters(const cricket::CodecParameterMap & parameters,std::ostringstream * os)1519 void WriteFmtpParameters(const cricket::CodecParameterMap& parameters,
1520 std::ostringstream* os) {
1521 for (cricket::CodecParameterMap::const_iterator fmtp = parameters.begin();
1522 fmtp != parameters.end(); ++fmtp) {
1523 // Each new parameter, except the first one starts with ";" and " ".
1524 if (fmtp != parameters.begin()) {
1525 *os << kSdpDelimiterSemicolon;
1526 }
1527 *os << kSdpDelimiterSpace;
1528 WriteFmtpParameter(fmtp->first, fmtp->second, os);
1529 }
1530 }
1531
IsFmtpParam(const std::string & name)1532 bool IsFmtpParam(const std::string& name) {
1533 const char* kFmtpParams[] = {
1534 kCodecParamMinPTime, kCodecParamSPropStereo,
1535 kCodecParamStereo, kCodecParamUseInbandFec, kCodecParamStartBitrate,
1536 kCodecParamMaxBitrate, kCodecParamMinBitrate, kCodecParamMaxQuantization,
1537 kCodecParamSctpProtocol, kCodecParamSctpStreams,
1538 kCodecParamMaxAverageBitrate, kCodecParamMaxPlaybackRate,
1539 kCodecParamAssociatedPayloadType
1540 };
1541 for (size_t i = 0; i < ARRAY_SIZE(kFmtpParams); ++i) {
1542 if (_stricmp(name.c_str(), kFmtpParams[i]) == 0) {
1543 return true;
1544 }
1545 }
1546 return false;
1547 }
1548
1549 // Retreives fmtp parameters from |params|, which may contain other parameters
1550 // as well, and puts them in |fmtp_parameters|.
GetFmtpParams(const cricket::CodecParameterMap & params,cricket::CodecParameterMap * fmtp_parameters)1551 void GetFmtpParams(const cricket::CodecParameterMap& params,
1552 cricket::CodecParameterMap* fmtp_parameters) {
1553 for (cricket::CodecParameterMap::const_iterator iter = params.begin();
1554 iter != params.end(); ++iter) {
1555 if (IsFmtpParam(iter->first)) {
1556 (*fmtp_parameters)[iter->first] = iter->second;
1557 }
1558 }
1559 }
1560
1561 template <class T>
AddFmtpLine(const T & codec,std::string * message)1562 void AddFmtpLine(const T& codec, std::string* message) {
1563 cricket::CodecParameterMap fmtp_parameters;
1564 GetFmtpParams(codec.params, &fmtp_parameters);
1565 if (fmtp_parameters.empty()) {
1566 // No need to add an fmtp if it will have no (optional) parameters.
1567 return;
1568 }
1569 std::ostringstream os;
1570 WriteFmtpHeader(codec.id, &os);
1571 WriteFmtpParameters(fmtp_parameters, &os);
1572 AddLine(os.str(), message);
1573 return;
1574 }
1575
1576 template <class T>
AddRtcpFbLines(const T & codec,std::string * message)1577 void AddRtcpFbLines(const T& codec, std::string* message) {
1578 for (std::vector<cricket::FeedbackParam>::const_iterator iter =
1579 codec.feedback_params.params().begin();
1580 iter != codec.feedback_params.params().end(); ++iter) {
1581 std::ostringstream os;
1582 WriteRtcpFbHeader(codec.id, &os);
1583 os << " " << iter->id();
1584 if (!iter->param().empty()) {
1585 os << " " << iter->param();
1586 }
1587 AddLine(os.str(), message);
1588 }
1589 }
1590
AddSctpDataCodec(DataContentDescription * media_desc,int sctp_port)1591 bool AddSctpDataCodec(DataContentDescription* media_desc,
1592 int sctp_port) {
1593 if (media_desc->HasCodec(cricket::kGoogleSctpDataCodecId)) {
1594 return ParseFailed("",
1595 "Can't have multiple sctp port attributes.",
1596 NULL);
1597 }
1598 // Add the SCTP Port number as a pseudo-codec "port" parameter
1599 cricket::DataCodec codec_port(
1600 cricket::kGoogleSctpDataCodecId, cricket::kGoogleSctpDataCodecName,
1601 0);
1602 codec_port.SetParam(cricket::kCodecParamPort, sctp_port);
1603 LOG(INFO) << "AddSctpDataCodec: Got SCTP Port Number "
1604 << sctp_port;
1605 media_desc->AddCodec(codec_port);
1606 return true;
1607 }
1608
GetMinValue(const std::vector<int> & values,int * value)1609 bool GetMinValue(const std::vector<int>& values, int* value) {
1610 if (values.empty()) {
1611 return false;
1612 }
1613 std::vector<int>::const_iterator found =
1614 std::min_element(values.begin(), values.end());
1615 *value = *found;
1616 return true;
1617 }
1618
GetParameter(const std::string & name,const cricket::CodecParameterMap & params,int * value)1619 bool GetParameter(const std::string& name,
1620 const cricket::CodecParameterMap& params, int* value) {
1621 std::map<std::string, std::string>::const_iterator found =
1622 params.find(name);
1623 if (found == params.end()) {
1624 return false;
1625 }
1626 if (!rtc::FromString(found->second, value)) {
1627 return false;
1628 }
1629 return true;
1630 }
1631
BuildRtpMap(const MediaContentDescription * media_desc,const MediaType media_type,std::string * message)1632 void BuildRtpMap(const MediaContentDescription* media_desc,
1633 const MediaType media_type,
1634 std::string* message) {
1635 ASSERT(message != NULL);
1636 ASSERT(media_desc != NULL);
1637 std::ostringstream os;
1638 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
1639 const VideoContentDescription* video_desc =
1640 static_cast<const VideoContentDescription*>(media_desc);
1641 for (std::vector<cricket::VideoCodec>::const_iterator it =
1642 video_desc->codecs().begin();
1643 it != video_desc->codecs().end(); ++it) {
1644 // RFC 4566
1645 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1646 // [/<encodingparameters>]
1647 if (it->id != kWildcardPayloadType) {
1648 InitAttrLine(kAttributeRtpmap, &os);
1649 os << kSdpDelimiterColon << it->id << " " << it->name
1650 << "/" << kDefaultVideoClockrate;
1651 AddLine(os.str(), message);
1652 }
1653 AddRtcpFbLines(*it, message);
1654 AddFmtpLine(*it, message);
1655 }
1656 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
1657 const AudioContentDescription* audio_desc =
1658 static_cast<const AudioContentDescription*>(media_desc);
1659 std::vector<int> ptimes;
1660 std::vector<int> maxptimes;
1661 int max_minptime = 0;
1662 for (std::vector<cricket::AudioCodec>::const_iterator it =
1663 audio_desc->codecs().begin();
1664 it != audio_desc->codecs().end(); ++it) {
1665 ASSERT(!it->name.empty());
1666 // RFC 4566
1667 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1668 // [/<encodingparameters>]
1669 InitAttrLine(kAttributeRtpmap, &os);
1670 os << kSdpDelimiterColon << it->id << " ";
1671 os << it->name << "/" << it->clockrate;
1672 if (it->channels != 1) {
1673 os << "/" << it->channels;
1674 }
1675 AddLine(os.str(), message);
1676 AddRtcpFbLines(*it, message);
1677 AddFmtpLine(*it, message);
1678 int minptime = 0;
1679 if (GetParameter(kCodecParamMinPTime, it->params, &minptime)) {
1680 max_minptime = std::max(minptime, max_minptime);
1681 }
1682 int ptime;
1683 if (GetParameter(kCodecParamPTime, it->params, &ptime)) {
1684 ptimes.push_back(ptime);
1685 }
1686 int maxptime;
1687 if (GetParameter(kCodecParamMaxPTime, it->params, &maxptime)) {
1688 maxptimes.push_back(maxptime);
1689 }
1690 }
1691 // Populate the maxptime attribute with the smallest maxptime of all codecs
1692 // under the same m-line.
1693 int min_maxptime = INT_MAX;
1694 if (GetMinValue(maxptimes, &min_maxptime)) {
1695 AddAttributeLine(kCodecParamMaxPTime, min_maxptime, message);
1696 }
1697 ASSERT(min_maxptime > max_minptime);
1698 // Populate the ptime attribute with the smallest ptime or the largest
1699 // minptime, whichever is the largest, for all codecs under the same m-line.
1700 int ptime = INT_MAX;
1701 if (GetMinValue(ptimes, &ptime)) {
1702 ptime = std::min(ptime, min_maxptime);
1703 ptime = std::max(ptime, max_minptime);
1704 AddAttributeLine(kCodecParamPTime, ptime, message);
1705 }
1706 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
1707 const DataContentDescription* data_desc =
1708 static_cast<const DataContentDescription*>(media_desc);
1709 for (std::vector<cricket::DataCodec>::const_iterator it =
1710 data_desc->codecs().begin();
1711 it != data_desc->codecs().end(); ++it) {
1712 // RFC 4566
1713 // a=rtpmap:<payload type> <encoding name>/<clock rate>
1714 // [/<encodingparameters>]
1715 InitAttrLine(kAttributeRtpmap, &os);
1716 os << kSdpDelimiterColon << it->id << " "
1717 << it->name << "/" << it->clockrate;
1718 AddLine(os.str(), message);
1719 }
1720 }
1721 }
1722
BuildCandidate(const std::vector<Candidate> & candidates,std::string * message)1723 void BuildCandidate(const std::vector<Candidate>& candidates,
1724 std::string* message) {
1725 std::ostringstream os;
1726
1727 for (std::vector<Candidate>::const_iterator it = candidates.begin();
1728 it != candidates.end(); ++it) {
1729 // RFC 5245
1730 // a=candidate:<foundation> <component-id> <transport> <priority>
1731 // <connection-address> <port> typ <candidate-types>
1732 // [raddr <connection-address>] [rport <port>]
1733 // *(SP extension-att-name SP extension-att-value)
1734 std::string type;
1735 // Map the cricket candidate type to "host" / "srflx" / "prflx" / "relay"
1736 if (it->type() == cricket::LOCAL_PORT_TYPE) {
1737 type = kCandidateHost;
1738 } else if (it->type() == cricket::STUN_PORT_TYPE) {
1739 type = kCandidateSrflx;
1740 } else if (it->type() == cricket::RELAY_PORT_TYPE) {
1741 type = kCandidateRelay;
1742 } else {
1743 ASSERT(false);
1744 }
1745
1746 InitAttrLine(kAttributeCandidate, &os);
1747 os << kSdpDelimiterColon
1748 << it->foundation() << " "
1749 << it->component() << " "
1750 << it->protocol() << " "
1751 << it->priority() << " "
1752 << it->address().ipaddr().ToString() << " "
1753 << it->address().PortAsString() << " "
1754 << kAttributeCandidateTyp << " "
1755 << type << " ";
1756
1757 // Related address
1758 if (!it->related_address().IsNil()) {
1759 os << kAttributeCandidateRaddr << " "
1760 << it->related_address().ipaddr().ToString() << " "
1761 << kAttributeCandidateRport << " "
1762 << it->related_address().PortAsString() << " ";
1763 }
1764
1765 if (it->protocol() == cricket::TCP_PROTOCOL_NAME) {
1766 os << kTcpCandidateType << " " << it->tcptype() << " ";
1767 }
1768
1769 // Extensions
1770 os << kAttributeCandidateGeneration << " " << it->generation();
1771
1772 AddLine(os.str(), message);
1773 }
1774 }
1775
BuildIceOptions(const std::vector<std::string> & transport_options,std::string * message)1776 void BuildIceOptions(const std::vector<std::string>& transport_options,
1777 std::string* message) {
1778 if (!transport_options.empty()) {
1779 std::ostringstream os;
1780 InitAttrLine(kAttributeIceOption, &os);
1781 os << kSdpDelimiterColon << transport_options[0];
1782 for (size_t i = 1; i < transport_options.size(); ++i) {
1783 os << kSdpDelimiterSpace << transport_options[i];
1784 }
1785 AddLine(os.str(), message);
1786 }
1787 }
1788
ParseSessionDescription(const std::string & message,size_t * pos,std::string * session_id,std::string * session_version,bool * supports_msid,TransportDescription * session_td,RtpHeaderExtensions * session_extmaps,cricket::SessionDescription * desc,SdpParseError * error)1789 bool ParseSessionDescription(const std::string& message, size_t* pos,
1790 std::string* session_id,
1791 std::string* session_version,
1792 bool* supports_msid,
1793 TransportDescription* session_td,
1794 RtpHeaderExtensions* session_extmaps,
1795 cricket::SessionDescription* desc,
1796 SdpParseError* error) {
1797 std::string line;
1798
1799 // RFC 4566
1800 // v= (protocol version)
1801 if (!GetLineWithType(message, pos, &line, kLineTypeVersion)) {
1802 return ParseFailedExpectLine(message, *pos, kLineTypeVersion,
1803 std::string(), error);
1804 }
1805 // RFC 4566
1806 // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
1807 // <unicast-address>
1808 if (!GetLineWithType(message, pos, &line, kLineTypeOrigin)) {
1809 return ParseFailedExpectLine(message, *pos, kLineTypeOrigin,
1810 std::string(), error);
1811 }
1812 std::vector<std::string> fields;
1813 rtc::split(line.substr(kLinePrefixLength),
1814 kSdpDelimiterSpace, &fields);
1815 const size_t expected_fields = 6;
1816 if (fields.size() != expected_fields) {
1817 return ParseFailedExpectFieldNum(line, expected_fields, error);
1818 }
1819 *session_id = fields[1];
1820 *session_version = fields[2];
1821
1822 // RFC 4566
1823 // s= (session name)
1824 if (!GetLineWithType(message, pos, &line, kLineTypeSessionName)) {
1825 return ParseFailedExpectLine(message, *pos, kLineTypeSessionName,
1826 std::string(), error);
1827 }
1828
1829 // Optional lines
1830 // Those are the optional lines, so shouldn't return false if not present.
1831 // RFC 4566
1832 // i=* (session information)
1833 GetLineWithType(message, pos, &line, kLineTypeSessionInfo);
1834
1835 // RFC 4566
1836 // u=* (URI of description)
1837 GetLineWithType(message, pos, &line, kLineTypeSessionUri);
1838
1839 // RFC 4566
1840 // e=* (email address)
1841 GetLineWithType(message, pos, &line, kLineTypeSessionEmail);
1842
1843 // RFC 4566
1844 // p=* (phone number)
1845 GetLineWithType(message, pos, &line, kLineTypeSessionPhone);
1846
1847 // RFC 4566
1848 // c=* (connection information -- not required if included in
1849 // all media)
1850 GetLineWithType(message, pos, &line, kLineTypeConnection);
1851
1852 // RFC 4566
1853 // b=* (zero or more bandwidth information lines)
1854 while (GetLineWithType(message, pos, &line, kLineTypeSessionBandwidth)) {
1855 // By pass zero or more b lines.
1856 }
1857
1858 // RFC 4566
1859 // One or more time descriptions ("t=" and "r=" lines; see below)
1860 // t= (time the session is active)
1861 // r=* (zero or more repeat times)
1862 // Ensure there's at least one time description
1863 if (!GetLineWithType(message, pos, &line, kLineTypeTiming)) {
1864 return ParseFailedExpectLine(message, *pos, kLineTypeTiming, std::string(),
1865 error);
1866 }
1867
1868 while (GetLineWithType(message, pos, &line, kLineTypeRepeatTimes)) {
1869 // By pass zero or more r lines.
1870 }
1871
1872 // Go through the rest of the time descriptions
1873 while (GetLineWithType(message, pos, &line, kLineTypeTiming)) {
1874 while (GetLineWithType(message, pos, &line, kLineTypeRepeatTimes)) {
1875 // By pass zero or more r lines.
1876 }
1877 }
1878
1879 // RFC 4566
1880 // z=* (time zone adjustments)
1881 GetLineWithType(message, pos, &line, kLineTypeTimeZone);
1882
1883 // RFC 4566
1884 // k=* (encryption key)
1885 GetLineWithType(message, pos, &line, kLineTypeEncryptionKey);
1886
1887 // RFC 4566
1888 // a=* (zero or more session attribute lines)
1889 while (GetLineWithType(message, pos, &line, kLineTypeAttributes)) {
1890 if (HasAttribute(line, kAttributeGroup)) {
1891 if (!ParseGroupAttribute(line, desc, error)) {
1892 return false;
1893 }
1894 } else if (HasAttribute(line, kAttributeIceUfrag)) {
1895 if (!GetValue(line, kAttributeIceUfrag,
1896 &(session_td->ice_ufrag), error)) {
1897 return false;
1898 }
1899 } else if (HasAttribute(line, kAttributeIcePwd)) {
1900 if (!GetValue(line, kAttributeIcePwd, &(session_td->ice_pwd), error)) {
1901 return false;
1902 }
1903 } else if (HasAttribute(line, kAttributeIceLite)) {
1904 session_td->ice_mode = cricket::ICEMODE_LITE;
1905 } else if (HasAttribute(line, kAttributeIceOption)) {
1906 if (!ParseIceOptions(line, &(session_td->transport_options), error)) {
1907 return false;
1908 }
1909 } else if (HasAttribute(line, kAttributeFingerprint)) {
1910 if (session_td->identity_fingerprint.get()) {
1911 return ParseFailed(
1912 line,
1913 "Can't have multiple fingerprint attributes at the same level.",
1914 error);
1915 }
1916 rtc::SSLFingerprint* fingerprint = NULL;
1917 if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
1918 return false;
1919 }
1920 session_td->identity_fingerprint.reset(fingerprint);
1921 } else if (HasAttribute(line, kAttributeSetup)) {
1922 if (!ParseDtlsSetup(line, &(session_td->connection_role), error)) {
1923 return false;
1924 }
1925 } else if (HasAttribute(line, kAttributeMsidSemantics)) {
1926 std::string semantics;
1927 if (!GetValue(line, kAttributeMsidSemantics, &semantics, error)) {
1928 return false;
1929 }
1930 *supports_msid = CaseInsensitiveFind(semantics, kMediaStreamSemantic);
1931 } else if (HasAttribute(line, kAttributeExtmap)) {
1932 RtpHeaderExtension extmap;
1933 if (!ParseExtmap(line, &extmap, error)) {
1934 return false;
1935 }
1936 session_extmaps->push_back(extmap);
1937 }
1938 }
1939
1940 return true;
1941 }
1942
ParseGroupAttribute(const std::string & line,cricket::SessionDescription * desc,SdpParseError * error)1943 bool ParseGroupAttribute(const std::string& line,
1944 cricket::SessionDescription* desc,
1945 SdpParseError* error) {
1946 ASSERT(desc != NULL);
1947
1948 // RFC 5888 and draft-holmberg-mmusic-sdp-bundle-negotiation-00
1949 // a=group:BUNDLE video voice
1950 std::vector<std::string> fields;
1951 rtc::split(line.substr(kLinePrefixLength),
1952 kSdpDelimiterSpace, &fields);
1953 std::string semantics;
1954 if (!GetValue(fields[0], kAttributeGroup, &semantics, error)) {
1955 return false;
1956 }
1957 cricket::ContentGroup group(semantics);
1958 for (size_t i = 1; i < fields.size(); ++i) {
1959 group.AddContentName(fields[i]);
1960 }
1961 desc->AddGroup(group);
1962 return true;
1963 }
1964
ParseFingerprintAttribute(const std::string & line,rtc::SSLFingerprint ** fingerprint,SdpParseError * error)1965 static bool ParseFingerprintAttribute(const std::string& line,
1966 rtc::SSLFingerprint** fingerprint,
1967 SdpParseError* error) {
1968 if (!IsLineType(line, kLineTypeAttributes) ||
1969 !HasAttribute(line, kAttributeFingerprint)) {
1970 return ParseFailedExpectLine(line, 0, kLineTypeAttributes,
1971 kAttributeFingerprint, error);
1972 }
1973
1974 std::vector<std::string> fields;
1975 rtc::split(line.substr(kLinePrefixLength),
1976 kSdpDelimiterSpace, &fields);
1977 const size_t expected_fields = 2;
1978 if (fields.size() != expected_fields) {
1979 return ParseFailedExpectFieldNum(line, expected_fields, error);
1980 }
1981
1982 // The first field here is "fingerprint:<hash>.
1983 std::string algorithm;
1984 if (!GetValue(fields[0], kAttributeFingerprint, &algorithm, error)) {
1985 return false;
1986 }
1987
1988 // Downcase the algorithm. Note that we don't need to downcase the
1989 // fingerprint because hex_decode can handle upper-case.
1990 std::transform(algorithm.begin(), algorithm.end(), algorithm.begin(),
1991 ::tolower);
1992
1993 // The second field is the digest value. De-hexify it.
1994 *fingerprint = rtc::SSLFingerprint::CreateFromRfc4572(
1995 algorithm, fields[1]);
1996 if (!*fingerprint) {
1997 return ParseFailed(line,
1998 "Failed to create fingerprint from the digest.",
1999 error);
2000 }
2001
2002 return true;
2003 }
2004
ParseDtlsSetup(const std::string & line,cricket::ConnectionRole * role,SdpParseError * error)2005 static bool ParseDtlsSetup(const std::string& line,
2006 cricket::ConnectionRole* role,
2007 SdpParseError* error) {
2008 // setup-attr = "a=setup:" role
2009 // role = "active" / "passive" / "actpass" / "holdconn"
2010 std::vector<std::string> fields;
2011 rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterColon, &fields);
2012 const size_t expected_fields = 2;
2013 if (fields.size() != expected_fields) {
2014 return ParseFailedExpectFieldNum(line, expected_fields, error);
2015 }
2016 std::string role_str = fields[1];
2017 if (!cricket::StringToConnectionRole(role_str, role)) {
2018 return ParseFailed(line, "Invalid attribute value.", error);
2019 }
2020 return true;
2021 }
2022
2023 // RFC 3551
2024 // PT encoding media type clock rate channels
2025 // name (Hz)
2026 // 0 PCMU A 8,000 1
2027 // 1 reserved A
2028 // 2 reserved A
2029 // 3 GSM A 8,000 1
2030 // 4 G723 A 8,000 1
2031 // 5 DVI4 A 8,000 1
2032 // 6 DVI4 A 16,000 1
2033 // 7 LPC A 8,000 1
2034 // 8 PCMA A 8,000 1
2035 // 9 G722 A 8,000 1
2036 // 10 L16 A 44,100 2
2037 // 11 L16 A 44,100 1
2038 // 12 QCELP A 8,000 1
2039 // 13 CN A 8,000 1
2040 // 14 MPA A 90,000 (see text)
2041 // 15 G728 A 8,000 1
2042 // 16 DVI4 A 11,025 1
2043 // 17 DVI4 A 22,050 1
2044 // 18 G729 A 8,000 1
2045 struct StaticPayloadAudioCodec {
2046 const char* name;
2047 int clockrate;
2048 int channels;
2049 };
2050 static const StaticPayloadAudioCodec kStaticPayloadAudioCodecs[] = {
2051 { "PCMU", 8000, 1 },
2052 { "reserved", 0, 0 },
2053 { "reserved", 0, 0 },
2054 { "GSM", 8000, 1 },
2055 { "G723", 8000, 1 },
2056 { "DVI4", 8000, 1 },
2057 { "DVI4", 16000, 1 },
2058 { "LPC", 8000, 1 },
2059 { "PCMA", 8000, 1 },
2060 { "G722", 8000, 1 },
2061 { "L16", 44100, 2 },
2062 { "L16", 44100, 1 },
2063 { "QCELP", 8000, 1 },
2064 { "CN", 8000, 1 },
2065 { "MPA", 90000, 1 },
2066 { "G728", 8000, 1 },
2067 { "DVI4", 11025, 1 },
2068 { "DVI4", 22050, 1 },
2069 { "G729", 8000, 1 },
2070 };
2071
MaybeCreateStaticPayloadAudioCodecs(const std::vector<int> & fmts,AudioContentDescription * media_desc)2072 void MaybeCreateStaticPayloadAudioCodecs(
2073 const std::vector<int>& fmts, AudioContentDescription* media_desc) {
2074 if (!media_desc) {
2075 return;
2076 }
2077 int preference = static_cast<int>(fmts.size());
2078 std::vector<int>::const_iterator it = fmts.begin();
2079 bool add_new_codec = false;
2080 for (; it != fmts.end(); ++it) {
2081 int payload_type = *it;
2082 if (!media_desc->HasCodec(payload_type) &&
2083 payload_type >= 0 &&
2084 payload_type < ARRAY_SIZE(kStaticPayloadAudioCodecs)) {
2085 std::string encoding_name = kStaticPayloadAudioCodecs[payload_type].name;
2086 int clock_rate = kStaticPayloadAudioCodecs[payload_type].clockrate;
2087 int channels = kStaticPayloadAudioCodecs[payload_type].channels;
2088 media_desc->AddCodec(cricket::AudioCodec(payload_type, encoding_name,
2089 clock_rate, 0, channels,
2090 preference));
2091 add_new_codec = true;
2092 }
2093 --preference;
2094 }
2095 if (add_new_codec) {
2096 media_desc->SortCodecs();
2097 }
2098 }
2099
2100 template <class C>
ParseContentDescription(const std::string & message,const MediaType media_type,int mline_index,const std::string & protocol,const std::vector<int> & codec_preference,size_t * pos,std::string * content_name,TransportDescription * transport,std::vector<JsepIceCandidate * > * candidates,webrtc::SdpParseError * error)2101 static C* ParseContentDescription(const std::string& message,
2102 const MediaType media_type,
2103 int mline_index,
2104 const std::string& protocol,
2105 const std::vector<int>& codec_preference,
2106 size_t* pos,
2107 std::string* content_name,
2108 TransportDescription* transport,
2109 std::vector<JsepIceCandidate*>* candidates,
2110 webrtc::SdpParseError* error) {
2111 C* media_desc = new C();
2112 switch (media_type) {
2113 case cricket::MEDIA_TYPE_AUDIO:
2114 *content_name = cricket::CN_AUDIO;
2115 break;
2116 case cricket::MEDIA_TYPE_VIDEO:
2117 *content_name = cricket::CN_VIDEO;
2118 break;
2119 case cricket::MEDIA_TYPE_DATA:
2120 *content_name = cricket::CN_DATA;
2121 break;
2122 default:
2123 ASSERT(false);
2124 break;
2125 }
2126 if (!ParseContent(message, media_type, mline_index, protocol,
2127 codec_preference, pos, content_name,
2128 media_desc, transport, candidates, error)) {
2129 delete media_desc;
2130 return NULL;
2131 }
2132 // Sort the codecs according to the m-line fmt list.
2133 media_desc->SortCodecs();
2134 return media_desc;
2135 }
2136
ParseMediaDescription(const std::string & message,const TransportDescription & session_td,const RtpHeaderExtensions & session_extmaps,bool supports_msid,size_t * pos,cricket::SessionDescription * desc,std::vector<JsepIceCandidate * > * candidates,SdpParseError * error)2137 bool ParseMediaDescription(const std::string& message,
2138 const TransportDescription& session_td,
2139 const RtpHeaderExtensions& session_extmaps,
2140 bool supports_msid,
2141 size_t* pos,
2142 cricket::SessionDescription* desc,
2143 std::vector<JsepIceCandidate*>* candidates,
2144 SdpParseError* error) {
2145 ASSERT(desc != NULL);
2146 std::string line;
2147 int mline_index = -1;
2148
2149 // Zero or more media descriptions
2150 // RFC 4566
2151 // m=<media> <port> <proto> <fmt>
2152 while (GetLineWithType(message, pos, &line, kLineTypeMedia)) {
2153 ++mline_index;
2154
2155 std::vector<std::string> fields;
2156 rtc::split(line.substr(kLinePrefixLength),
2157 kSdpDelimiterSpace, &fields);
2158 const size_t expected_min_fields = 4;
2159 if (fields.size() < expected_min_fields) {
2160 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
2161 }
2162 bool rejected = false;
2163 // RFC 3264
2164 // To reject an offered stream, the port number in the corresponding stream
2165 // in the answer MUST be set to zero.
2166 if (fields[1] == kMediaPortRejected) {
2167 rejected = true;
2168 }
2169
2170 std::string protocol = fields[2];
2171 bool is_sctp = (protocol == cricket::kMediaProtocolDtlsSctp);
2172
2173 // <fmt>
2174 std::vector<int> codec_preference;
2175 if (!is_sctp) {
2176 for (size_t j = 3 ; j < fields.size(); ++j) {
2177 // TODO(wu): Remove when below bug is fixed.
2178 // https://bugzilla.mozilla.org/show_bug.cgi?id=996329
2179 if (fields[j] == "" && j == fields.size() - 1) {
2180 continue;
2181 }
2182
2183 int pl = 0;
2184 if (!GetValueFromString(line, fields[j], &pl, error)) {
2185 return false;
2186 }
2187 codec_preference.push_back(pl);
2188 }
2189 }
2190
2191 // Make a temporary TransportDescription based on |session_td|.
2192 // Some of this gets overwritten by ParseContent.
2193 TransportDescription transport(NS_JINGLE_ICE_UDP,
2194 session_td.transport_options,
2195 session_td.ice_ufrag,
2196 session_td.ice_pwd,
2197 session_td.ice_mode,
2198 session_td.connection_role,
2199 session_td.identity_fingerprint.get(),
2200 Candidates());
2201
2202 rtc::scoped_ptr<MediaContentDescription> content;
2203 std::string content_name;
2204 if (HasAttribute(line, kMediaTypeVideo)) {
2205 content.reset(ParseContentDescription<VideoContentDescription>(
2206 message, cricket::MEDIA_TYPE_VIDEO, mline_index, protocol,
2207 codec_preference, pos, &content_name,
2208 &transport, candidates, error));
2209 } else if (HasAttribute(line, kMediaTypeAudio)) {
2210 content.reset(ParseContentDescription<AudioContentDescription>(
2211 message, cricket::MEDIA_TYPE_AUDIO, mline_index, protocol,
2212 codec_preference, pos, &content_name,
2213 &transport, candidates, error));
2214 } else if (HasAttribute(line, kMediaTypeData)) {
2215 DataContentDescription* data_desc =
2216 ParseContentDescription<DataContentDescription>(
2217 message, cricket::MEDIA_TYPE_DATA, mline_index, protocol,
2218 codec_preference, pos, &content_name,
2219 &transport, candidates, error);
2220 content.reset(data_desc);
2221
2222 int p;
2223 if (data_desc && protocol == cricket::kMediaProtocolDtlsSctp &&
2224 rtc::FromString(fields[3], &p)) {
2225 if (!AddSctpDataCodec(data_desc, p))
2226 return false;
2227 }
2228
2229 // We should always use the default bandwidth for RTP-based data
2230 // channels. Don't allow SDP to set the bandwidth, because that
2231 // would give JS the opportunity to "break the Internet".
2232 // TODO(pthatcher): But we need to temporarily allow the SDP to control
2233 // this for backwards-compatibility. Once we don't need that any
2234 // more, remove this.
2235 bool support_dc_sdp_bandwidth_temporarily = true;
2236 if (content.get() && !support_dc_sdp_bandwidth_temporarily) {
2237 content->set_bandwidth(cricket::kAutoBandwidth);
2238 }
2239 } else {
2240 LOG(LS_WARNING) << "Unsupported media type: " << line;
2241 continue;
2242 }
2243 if (!content.get()) {
2244 // ParseContentDescription returns NULL if failed.
2245 return false;
2246 }
2247
2248 if (!is_sctp) {
2249 // Make sure to set the media direction correctly. If the direction is not
2250 // MD_RECVONLY or Inactive and no streams are parsed,
2251 // a default MediaStream will be created to prepare for receiving media.
2252 if (supports_msid && content->streams().empty() &&
2253 content->direction() == cricket::MD_SENDRECV) {
2254 content->set_direction(cricket::MD_RECVONLY);
2255 }
2256
2257 // Set the extmap.
2258 if (!session_extmaps.empty() &&
2259 !content->rtp_header_extensions().empty()) {
2260 return ParseFailed("",
2261 "The a=extmap MUST be either all session level or "
2262 "all media level.",
2263 error);
2264 }
2265 for (size_t i = 0; i < session_extmaps.size(); ++i) {
2266 content->AddRtpHeaderExtension(session_extmaps[i]);
2267 }
2268 }
2269 content->set_protocol(protocol);
2270 desc->AddContent(content_name,
2271 is_sctp ? cricket::NS_JINGLE_DRAFT_SCTP :
2272 cricket::NS_JINGLE_RTP,
2273 rejected,
2274 content.release());
2275 // Create TransportInfo with the media level "ice-pwd" and "ice-ufrag".
2276 TransportInfo transport_info(content_name, transport);
2277
2278 if (!desc->AddTransportInfo(transport_info)) {
2279 std::ostringstream description;
2280 description << "Failed to AddTransportInfo with content name: "
2281 << content_name;
2282 return ParseFailed("", description.str(), error);
2283 }
2284 }
2285
2286 size_t end_of_message = message.size();
2287 if (mline_index == -1 && *pos != end_of_message) {
2288 ParseFailed(message, *pos, "Expects m line.", error);
2289 return false;
2290 }
2291 return true;
2292 }
2293
VerifyCodec(const cricket::Codec & codec)2294 bool VerifyCodec(const cricket::Codec& codec) {
2295 // Codec has not been populated correctly unless the name has been set. This
2296 // can happen if an SDP has an fmtp or rtcp-fb with a payload type but doesn't
2297 // have a corresponding "rtpmap" line.
2298 cricket::Codec default_codec;
2299 return default_codec.name != codec.name;
2300 }
2301
VerifyAudioCodecs(const AudioContentDescription * audio_desc)2302 bool VerifyAudioCodecs(const AudioContentDescription* audio_desc) {
2303 const std::vector<cricket::AudioCodec>& codecs = audio_desc->codecs();
2304 for (std::vector<cricket::AudioCodec>::const_iterator iter = codecs.begin();
2305 iter != codecs.end(); ++iter) {
2306 if (!VerifyCodec(*iter)) {
2307 return false;
2308 }
2309 }
2310 return true;
2311 }
2312
VerifyVideoCodecs(const VideoContentDescription * video_desc)2313 bool VerifyVideoCodecs(const VideoContentDescription* video_desc) {
2314 const std::vector<cricket::VideoCodec>& codecs = video_desc->codecs();
2315 for (std::vector<cricket::VideoCodec>::const_iterator iter = codecs.begin();
2316 iter != codecs.end(); ++iter) {
2317 if (!VerifyCodec(*iter)) {
2318 return false;
2319 }
2320 }
2321 return true;
2322 }
2323
AddParameters(const cricket::CodecParameterMap & parameters,cricket::Codec * codec)2324 void AddParameters(const cricket::CodecParameterMap& parameters,
2325 cricket::Codec* codec) {
2326 for (cricket::CodecParameterMap::const_iterator iter =
2327 parameters.begin(); iter != parameters.end(); ++iter) {
2328 codec->SetParam(iter->first, iter->second);
2329 }
2330 }
2331
AddFeedbackParameter(const cricket::FeedbackParam & feedback_param,cricket::Codec * codec)2332 void AddFeedbackParameter(const cricket::FeedbackParam& feedback_param,
2333 cricket::Codec* codec) {
2334 codec->AddFeedbackParam(feedback_param);
2335 }
2336
AddFeedbackParameters(const cricket::FeedbackParams & feedback_params,cricket::Codec * codec)2337 void AddFeedbackParameters(const cricket::FeedbackParams& feedback_params,
2338 cricket::Codec* codec) {
2339 for (std::vector<cricket::FeedbackParam>::const_iterator iter =
2340 feedback_params.params().begin();
2341 iter != feedback_params.params().end(); ++iter) {
2342 codec->AddFeedbackParam(*iter);
2343 }
2344 }
2345
2346 // Gets the current codec setting associated with |payload_type|. If there
2347 // is no AudioCodec associated with that payload type it returns an empty codec
2348 // with that payload type.
2349 template <class T>
GetCodec(const std::vector<T> & codecs,int payload_type)2350 T GetCodec(const std::vector<T>& codecs, int payload_type) {
2351 for (typename std::vector<T>::const_iterator codec = codecs.begin();
2352 codec != codecs.end(); ++codec) {
2353 if (codec->id == payload_type) {
2354 return *codec;
2355 }
2356 }
2357 T ret_val = T();
2358 ret_val.id = payload_type;
2359 return ret_val;
2360 }
2361
2362 // Updates or creates a new codec entry in the audio description.
2363 template <class T, class U>
AddOrReplaceCodec(MediaContentDescription * content_desc,const U & codec)2364 void AddOrReplaceCodec(MediaContentDescription* content_desc, const U& codec) {
2365 T* desc = static_cast<T*>(content_desc);
2366 std::vector<U> codecs = desc->codecs();
2367 bool found = false;
2368
2369 typename std::vector<U>::iterator iter;
2370 for (iter = codecs.begin(); iter != codecs.end(); ++iter) {
2371 if (iter->id == codec.id) {
2372 *iter = codec;
2373 found = true;
2374 break;
2375 }
2376 }
2377 if (!found) {
2378 desc->AddCodec(codec);
2379 return;
2380 }
2381 desc->set_codecs(codecs);
2382 }
2383
2384 // Adds or updates existing codec corresponding to |payload_type| according
2385 // to |parameters|.
2386 template <class T, class U>
UpdateCodec(MediaContentDescription * content_desc,int payload_type,const cricket::CodecParameterMap & parameters)2387 void UpdateCodec(MediaContentDescription* content_desc, int payload_type,
2388 const cricket::CodecParameterMap& parameters) {
2389 // Codec might already have been populated (from rtpmap).
2390 U new_codec = GetCodec(static_cast<T*>(content_desc)->codecs(), payload_type);
2391 AddParameters(parameters, &new_codec);
2392 AddOrReplaceCodec<T, U>(content_desc, new_codec);
2393 }
2394
2395 // Adds or updates existing codec corresponding to |payload_type| according
2396 // to |feedback_param|.
2397 template <class T, class U>
UpdateCodec(MediaContentDescription * content_desc,int payload_type,const cricket::FeedbackParam & feedback_param)2398 void UpdateCodec(MediaContentDescription* content_desc, int payload_type,
2399 const cricket::FeedbackParam& feedback_param) {
2400 // Codec might already have been populated (from rtpmap).
2401 U new_codec = GetCodec(static_cast<T*>(content_desc)->codecs(), payload_type);
2402 AddFeedbackParameter(feedback_param, &new_codec);
2403 AddOrReplaceCodec<T, U>(content_desc, new_codec);
2404 }
2405
PopWildcardCodec(std::vector<cricket::VideoCodec> * codecs,cricket::VideoCodec * wildcard_codec)2406 bool PopWildcardCodec(std::vector<cricket::VideoCodec>* codecs,
2407 cricket::VideoCodec* wildcard_codec) {
2408 for (std::vector<cricket::VideoCodec>::iterator iter = codecs->begin();
2409 iter != codecs->end(); ++iter) {
2410 if (iter->id == kWildcardPayloadType) {
2411 *wildcard_codec = *iter;
2412 codecs->erase(iter);
2413 return true;
2414 }
2415 }
2416 return false;
2417 }
2418
UpdateFromWildcardVideoCodecs(VideoContentDescription * video_desc)2419 void UpdateFromWildcardVideoCodecs(VideoContentDescription* video_desc) {
2420 std::vector<cricket::VideoCodec> codecs = video_desc->codecs();
2421 cricket::VideoCodec wildcard_codec;
2422 if (!PopWildcardCodec(&codecs, &wildcard_codec)) {
2423 return;
2424 }
2425 for (std::vector<cricket::VideoCodec>::iterator iter = codecs.begin();
2426 iter != codecs.end(); ++iter) {
2427 cricket::VideoCodec& codec = *iter;
2428 AddFeedbackParameters(wildcard_codec.feedback_params, &codec);
2429 }
2430 video_desc->set_codecs(codecs);
2431 }
2432
AddAudioAttribute(const std::string & name,const std::string & value,AudioContentDescription * audio_desc)2433 void AddAudioAttribute(const std::string& name, const std::string& value,
2434 AudioContentDescription* audio_desc) {
2435 if (value.empty()) {
2436 return;
2437 }
2438 std::vector<cricket::AudioCodec> codecs = audio_desc->codecs();
2439 for (std::vector<cricket::AudioCodec>::iterator iter = codecs.begin();
2440 iter != codecs.end(); ++iter) {
2441 iter->params[name] = value;
2442 }
2443 audio_desc->set_codecs(codecs);
2444 }
2445
ParseContent(const std::string & message,const MediaType media_type,int mline_index,const std::string & protocol,const std::vector<int> & codec_preference,size_t * pos,std::string * content_name,MediaContentDescription * media_desc,TransportDescription * transport,std::vector<JsepIceCandidate * > * candidates,SdpParseError * error)2446 bool ParseContent(const std::string& message,
2447 const MediaType media_type,
2448 int mline_index,
2449 const std::string& protocol,
2450 const std::vector<int>& codec_preference,
2451 size_t* pos,
2452 std::string* content_name,
2453 MediaContentDescription* media_desc,
2454 TransportDescription* transport,
2455 std::vector<JsepIceCandidate*>* candidates,
2456 SdpParseError* error) {
2457 ASSERT(media_desc != NULL);
2458 ASSERT(content_name != NULL);
2459 ASSERT(transport != NULL);
2460
2461 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
2462 MaybeCreateStaticPayloadAudioCodecs(
2463 codec_preference, static_cast<AudioContentDescription*>(media_desc));
2464 }
2465
2466 // The media level "ice-ufrag" and "ice-pwd".
2467 // The candidates before update the media level "ice-pwd" and "ice-ufrag".
2468 Candidates candidates_orig;
2469 std::string line;
2470 std::string mline_id;
2471 // Tracks created out of the ssrc attributes.
2472 StreamParamsVec tracks;
2473 SsrcInfoVec ssrc_infos;
2474 SsrcGroupVec ssrc_groups;
2475 std::string maxptime_as_string;
2476 std::string ptime_as_string;
2477
2478 bool is_rtp =
2479 protocol.empty() ||
2480 rtc::starts_with(protocol.data(),
2481 cricket::kMediaProtocolRtpPrefix);
2482
2483 // Loop until the next m line
2484 while (!IsLineType(message, kLineTypeMedia, *pos)) {
2485 if (!GetLine(message, pos, &line)) {
2486 if (*pos >= message.size()) {
2487 break; // Done parsing
2488 } else {
2489 return ParseFailed(message, *pos, "Invalid SDP line.", error);
2490 }
2491 }
2492
2493 // RFC 4566
2494 // b=* (zero or more bandwidth information lines)
2495 if (IsLineType(line, kLineTypeSessionBandwidth)) {
2496 std::string bandwidth;
2497 if (HasAttribute(line, kApplicationSpecificMaximum)) {
2498 if (!GetValue(line, kApplicationSpecificMaximum, &bandwidth, error)) {
2499 return false;
2500 } else {
2501 int b = 0;
2502 if (!GetValueFromString(line, bandwidth, &b, error)) {
2503 return false;
2504 }
2505 media_desc->set_bandwidth(b * 1000);
2506 }
2507 }
2508 continue;
2509 }
2510
2511 if (!IsLineType(line, kLineTypeAttributes)) {
2512 // TODO: Handle other lines if needed.
2513 LOG(LS_INFO) << "Ignored line: " << line;
2514 continue;
2515 }
2516
2517 // Handle attributes common to SCTP and RTP.
2518 if (HasAttribute(line, kAttributeMid)) {
2519 // RFC 3388
2520 // mid-attribute = "a=mid:" identification-tag
2521 // identification-tag = token
2522 // Use the mid identification-tag as the content name.
2523 if (!GetValue(line, kAttributeMid, &mline_id, error)) {
2524 return false;
2525 }
2526 *content_name = mline_id;
2527 } else if (HasAttribute(line, kAttributeCandidate)) {
2528 Candidate candidate;
2529 if (!ParseCandidate(line, &candidate, error, false)) {
2530 return false;
2531 }
2532 candidates_orig.push_back(candidate);
2533 } else if (HasAttribute(line, kAttributeIceUfrag)) {
2534 if (!GetValue(line, kAttributeIceUfrag, &transport->ice_ufrag, error)) {
2535 return false;
2536 }
2537 } else if (HasAttribute(line, kAttributeIcePwd)) {
2538 if (!GetValue(line, kAttributeIcePwd, &transport->ice_pwd, error)) {
2539 return false;
2540 }
2541 } else if (HasAttribute(line, kAttributeIceOption)) {
2542 if (!ParseIceOptions(line, &transport->transport_options, error)) {
2543 return false;
2544 }
2545 } else if (HasAttribute(line, kAttributeFmtp)) {
2546 if (!ParseFmtpAttributes(line, media_type, media_desc, error)) {
2547 return false;
2548 }
2549 } else if (HasAttribute(line, kAttributeFingerprint)) {
2550 rtc::SSLFingerprint* fingerprint = NULL;
2551
2552 if (!ParseFingerprintAttribute(line, &fingerprint, error)) {
2553 return false;
2554 }
2555 transport->identity_fingerprint.reset(fingerprint);
2556 } else if (HasAttribute(line, kAttributeSetup)) {
2557 if (!ParseDtlsSetup(line, &(transport->connection_role), error)) {
2558 return false;
2559 }
2560 } else if (HasAttribute(line, kAttributeSctpPort)) {
2561 int sctp_port;
2562 if (!ParseSctpPort(line, &sctp_port, error)) {
2563 return false;
2564 }
2565 if (!AddSctpDataCodec(static_cast<DataContentDescription*>(media_desc),
2566 sctp_port)) {
2567 return false;
2568 }
2569 } else if (is_rtp) {
2570 //
2571 // RTP specific attrubtes
2572 //
2573 if (HasAttribute(line, kAttributeRtcpMux)) {
2574 media_desc->set_rtcp_mux(true);
2575 } else if (HasAttribute(line, kAttributeSsrcGroup)) {
2576 if (!ParseSsrcGroupAttribute(line, &ssrc_groups, error)) {
2577 return false;
2578 }
2579 } else if (HasAttribute(line, kAttributeSsrc)) {
2580 if (!ParseSsrcAttribute(line, &ssrc_infos, error)) {
2581 return false;
2582 }
2583 } else if (HasAttribute(line, kAttributeCrypto)) {
2584 if (!ParseCryptoAttribute(line, media_desc, error)) {
2585 return false;
2586 }
2587 } else if (HasAttribute(line, kAttributeRtpmap)) {
2588 if (!ParseRtpmapAttribute(line, media_type, codec_preference,
2589 media_desc, error)) {
2590 return false;
2591 }
2592 } else if (HasAttribute(line, kCodecParamMaxPTime)) {
2593 if (!GetValue(line, kCodecParamMaxPTime, &maxptime_as_string, error)) {
2594 return false;
2595 }
2596 } else if (HasAttribute(line, kAttributeRtcpFb)) {
2597 if (!ParseRtcpFbAttribute(line, media_type, media_desc, error)) {
2598 return false;
2599 }
2600 } else if (HasAttribute(line, kCodecParamPTime)) {
2601 if (!GetValue(line, kCodecParamPTime, &ptime_as_string, error)) {
2602 return false;
2603 }
2604 } else if (HasAttribute(line, kAttributeSendOnly)) {
2605 media_desc->set_direction(cricket::MD_SENDONLY);
2606 } else if (HasAttribute(line, kAttributeRecvOnly)) {
2607 media_desc->set_direction(cricket::MD_RECVONLY);
2608 } else if (HasAttribute(line, kAttributeInactive)) {
2609 media_desc->set_direction(cricket::MD_INACTIVE);
2610 } else if (HasAttribute(line, kAttributeSendRecv)) {
2611 media_desc->set_direction(cricket::MD_SENDRECV);
2612 } else if (HasAttribute(line, kAttributeExtmap)) {
2613 RtpHeaderExtension extmap;
2614 if (!ParseExtmap(line, &extmap, error)) {
2615 return false;
2616 }
2617 media_desc->AddRtpHeaderExtension(extmap);
2618 } else if (HasAttribute(line, kAttributeXGoogleFlag)) {
2619 // Experimental attribute. Conference mode activates more aggressive
2620 // AEC and NS settings.
2621 // TODO: expose API to set these directly.
2622 std::string flag_value;
2623 if (!GetValue(line, kAttributeXGoogleFlag, &flag_value, error)) {
2624 return false;
2625 }
2626 if (flag_value.compare(kValueConference) == 0)
2627 media_desc->set_conference_mode(true);
2628 } else if (HasAttribute(line, kAttributeXGoogleBufferLatency)) {
2629 // Experimental attribute.
2630 // TODO: expose API to set this directly.
2631 std::string flag_value;
2632 if (!GetValue(line, kAttributeXGoogleBufferLatency, &flag_value,
2633 error)) {
2634 return false;
2635 }
2636 int buffer_latency = 0;
2637 if (!GetValueFromString(line, flag_value, &buffer_latency, error)) {
2638 return false;
2639 }
2640 if (buffer_latency < 0) {
2641 return ParseFailed(line, "Buffer latency less than 0.", error);
2642 }
2643 media_desc->set_buffered_mode_latency(buffer_latency);
2644 }
2645 } else {
2646 // Only parse lines that we are interested of.
2647 LOG(LS_INFO) << "Ignored line: " << line;
2648 continue;
2649 }
2650 }
2651
2652 // Create tracks from the |ssrc_infos|.
2653 CreateTracksFromSsrcInfos(ssrc_infos, &tracks);
2654
2655 // Add the ssrc group to the track.
2656 for (SsrcGroupVec::iterator ssrc_group = ssrc_groups.begin();
2657 ssrc_group != ssrc_groups.end(); ++ssrc_group) {
2658 if (ssrc_group->ssrcs.empty()) {
2659 continue;
2660 }
2661 uint32 ssrc = ssrc_group->ssrcs.front();
2662 for (StreamParamsVec::iterator track = tracks.begin();
2663 track != tracks.end(); ++track) {
2664 if (track->has_ssrc(ssrc)) {
2665 track->ssrc_groups.push_back(*ssrc_group);
2666 }
2667 }
2668 }
2669
2670 // Add the new tracks to the |media_desc|.
2671 for (StreamParamsVec::iterator track = tracks.begin();
2672 track != tracks.end(); ++track) {
2673 media_desc->AddStream(*track);
2674 }
2675
2676 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
2677 AudioContentDescription* audio_desc =
2678 static_cast<AudioContentDescription*>(media_desc);
2679 // Verify audio codec ensures that no audio codec has been populated with
2680 // only fmtp.
2681 if (!VerifyAudioCodecs(audio_desc)) {
2682 return ParseFailed("Failed to parse audio codecs correctly.", error);
2683 }
2684 AddAudioAttribute(kCodecParamMaxPTime, maxptime_as_string, audio_desc);
2685 AddAudioAttribute(kCodecParamPTime, ptime_as_string, audio_desc);
2686 }
2687
2688 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
2689 VideoContentDescription* video_desc =
2690 static_cast<VideoContentDescription*>(media_desc);
2691 UpdateFromWildcardVideoCodecs(video_desc);
2692 // Verify video codec ensures that no video codec has been populated with
2693 // only rtcp-fb.
2694 if (!VerifyVideoCodecs(video_desc)) {
2695 return ParseFailed("Failed to parse video codecs correctly.", error);
2696 }
2697 }
2698
2699 // RFC 5245
2700 // Update the candidates with the media level "ice-pwd" and "ice-ufrag".
2701 for (Candidates::iterator it = candidates_orig.begin();
2702 it != candidates_orig.end(); ++it) {
2703 ASSERT((*it).username().empty());
2704 (*it).set_username(transport->ice_ufrag);
2705 ASSERT((*it).password().empty());
2706 (*it).set_password(transport->ice_pwd);
2707 candidates->push_back(
2708 new JsepIceCandidate(mline_id, mline_index, *it));
2709 }
2710 return true;
2711 }
2712
ParseSsrcAttribute(const std::string & line,SsrcInfoVec * ssrc_infos,SdpParseError * error)2713 bool ParseSsrcAttribute(const std::string& line, SsrcInfoVec* ssrc_infos,
2714 SdpParseError* error) {
2715 ASSERT(ssrc_infos != NULL);
2716 // RFC 5576
2717 // a=ssrc:<ssrc-id> <attribute>
2718 // a=ssrc:<ssrc-id> <attribute>:<value>
2719 std::string field1, field2;
2720 if (!SplitByDelimiter(line.substr(kLinePrefixLength),
2721 kSdpDelimiterSpace,
2722 &field1,
2723 &field2)) {
2724 const size_t expected_fields = 2;
2725 return ParseFailedExpectFieldNum(line, expected_fields, error);
2726 }
2727
2728 // ssrc:<ssrc-id>
2729 std::string ssrc_id_s;
2730 if (!GetValue(field1, kAttributeSsrc, &ssrc_id_s, error)) {
2731 return false;
2732 }
2733 uint32 ssrc_id = 0;
2734 if (!GetValueFromString(line, ssrc_id_s, &ssrc_id, error)) {
2735 return false;
2736 }
2737
2738 std::string attribute;
2739 std::string value;
2740 if (!SplitByDelimiter(field2, kSdpDelimiterColon,
2741 &attribute, &value)) {
2742 std::ostringstream description;
2743 description << "Failed to get the ssrc attribute value from " << field2
2744 << ". Expected format <attribute>:<value>.";
2745 return ParseFailed(line, description.str(), error);
2746 }
2747
2748 // Check if there's already an item for this |ssrc_id|. Create a new one if
2749 // there isn't.
2750 SsrcInfoVec::iterator ssrc_info = ssrc_infos->begin();
2751 for (; ssrc_info != ssrc_infos->end(); ++ssrc_info) {
2752 if (ssrc_info->ssrc_id == ssrc_id) {
2753 break;
2754 }
2755 }
2756 if (ssrc_info == ssrc_infos->end()) {
2757 SsrcInfo info;
2758 info.ssrc_id = ssrc_id;
2759 ssrc_infos->push_back(info);
2760 ssrc_info = ssrc_infos->end() - 1;
2761 }
2762
2763 // Store the info to the |ssrc_info|.
2764 if (attribute == kSsrcAttributeCname) {
2765 // RFC 5576
2766 // cname:<value>
2767 ssrc_info->cname = value;
2768 } else if (attribute == kSsrcAttributeMsid) {
2769 // draft-alvestrand-mmusic-msid-00
2770 // "msid:" identifier [ " " appdata ]
2771 std::vector<std::string> fields;
2772 rtc::split(value, kSdpDelimiterSpace, &fields);
2773 if (fields.size() < 1 || fields.size() > 2) {
2774 return ParseFailed(line,
2775 "Expected format \"msid:<identifier>[ <appdata>]\".",
2776 error);
2777 }
2778 ssrc_info->msid_identifier = fields[0];
2779 if (fields.size() == 2) {
2780 ssrc_info->msid_appdata = fields[1];
2781 }
2782 } else if (attribute == kSsrcAttributeMslabel) {
2783 // draft-alvestrand-rtcweb-mid-01
2784 // mslabel:<value>
2785 ssrc_info->mslabel = value;
2786 } else if (attribute == kSSrcAttributeLabel) {
2787 // The label isn't defined.
2788 // label:<value>
2789 ssrc_info->label = value;
2790 }
2791 return true;
2792 }
2793
ParseSsrcGroupAttribute(const std::string & line,SsrcGroupVec * ssrc_groups,SdpParseError * error)2794 bool ParseSsrcGroupAttribute(const std::string& line,
2795 SsrcGroupVec* ssrc_groups,
2796 SdpParseError* error) {
2797 ASSERT(ssrc_groups != NULL);
2798 // RFC 5576
2799 // a=ssrc-group:<semantics> <ssrc-id> ...
2800 std::vector<std::string> fields;
2801 rtc::split(line.substr(kLinePrefixLength),
2802 kSdpDelimiterSpace, &fields);
2803 const size_t expected_min_fields = 2;
2804 if (fields.size() < expected_min_fields) {
2805 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
2806 }
2807 std::string semantics;
2808 if (!GetValue(fields[0], kAttributeSsrcGroup, &semantics, error)) {
2809 return false;
2810 }
2811 std::vector<uint32> ssrcs;
2812 for (size_t i = 1; i < fields.size(); ++i) {
2813 uint32 ssrc = 0;
2814 if (!GetValueFromString(line, fields[i], &ssrc, error)) {
2815 return false;
2816 }
2817 ssrcs.push_back(ssrc);
2818 }
2819 ssrc_groups->push_back(SsrcGroup(semantics, ssrcs));
2820 return true;
2821 }
2822
ParseCryptoAttribute(const std::string & line,MediaContentDescription * media_desc,SdpParseError * error)2823 bool ParseCryptoAttribute(const std::string& line,
2824 MediaContentDescription* media_desc,
2825 SdpParseError* error) {
2826 std::vector<std::string> fields;
2827 rtc::split(line.substr(kLinePrefixLength),
2828 kSdpDelimiterSpace, &fields);
2829 // RFC 4568
2830 // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
2831 const size_t expected_min_fields = 3;
2832 if (fields.size() < expected_min_fields) {
2833 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
2834 }
2835 std::string tag_value;
2836 if (!GetValue(fields[0], kAttributeCrypto, &tag_value, error)) {
2837 return false;
2838 }
2839 int tag = 0;
2840 if (!GetValueFromString(line, tag_value, &tag, error)) {
2841 return false;
2842 }
2843 const std::string crypto_suite = fields[1];
2844 const std::string key_params = fields[2];
2845 std::string session_params;
2846 if (fields.size() > 3) {
2847 session_params = fields[3];
2848 }
2849 media_desc->AddCrypto(CryptoParams(tag, crypto_suite, key_params,
2850 session_params));
2851 return true;
2852 }
2853
2854 // Updates or creates a new codec entry in the audio description with according
2855 // to |name|, |clockrate|, |bitrate|, |channels| and |preference|.
UpdateCodec(int payload_type,const std::string & name,int clockrate,int bitrate,int channels,int preference,AudioContentDescription * audio_desc)2856 void UpdateCodec(int payload_type, const std::string& name, int clockrate,
2857 int bitrate, int channels, int preference,
2858 AudioContentDescription* audio_desc) {
2859 // Codec may already be populated with (only) optional parameters
2860 // (from an fmtp).
2861 cricket::AudioCodec codec = GetCodec(audio_desc->codecs(), payload_type);
2862 codec.name = name;
2863 codec.clockrate = clockrate;
2864 codec.bitrate = bitrate;
2865 codec.channels = channels;
2866 codec.preference = preference;
2867 AddOrReplaceCodec<AudioContentDescription, cricket::AudioCodec>(audio_desc,
2868 codec);
2869 }
2870
2871 // Updates or creates a new codec entry in the video description according to
2872 // |name|, |width|, |height|, |framerate| and |preference|.
UpdateCodec(int payload_type,const std::string & name,int width,int height,int framerate,int preference,VideoContentDescription * video_desc)2873 void UpdateCodec(int payload_type, const std::string& name, int width,
2874 int height, int framerate, int preference,
2875 VideoContentDescription* video_desc) {
2876 // Codec may already be populated with (only) optional parameters
2877 // (from an fmtp).
2878 cricket::VideoCodec codec = GetCodec(video_desc->codecs(), payload_type);
2879 codec.name = name;
2880 codec.width = width;
2881 codec.height = height;
2882 codec.framerate = framerate;
2883 codec.preference = preference;
2884 AddOrReplaceCodec<VideoContentDescription, cricket::VideoCodec>(video_desc,
2885 codec);
2886 }
2887
ParseRtpmapAttribute(const std::string & line,const MediaType media_type,const std::vector<int> & codec_preference,MediaContentDescription * media_desc,SdpParseError * error)2888 bool ParseRtpmapAttribute(const std::string& line,
2889 const MediaType media_type,
2890 const std::vector<int>& codec_preference,
2891 MediaContentDescription* media_desc,
2892 SdpParseError* error) {
2893 std::vector<std::string> fields;
2894 rtc::split(line.substr(kLinePrefixLength),
2895 kSdpDelimiterSpace, &fields);
2896 // RFC 4566
2897 // a=rtpmap:<payload type> <encoding name>/<clock rate>[/<encodingparameters>]
2898 const size_t expected_min_fields = 2;
2899 if (fields.size() < expected_min_fields) {
2900 return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
2901 }
2902 std::string payload_type_value;
2903 if (!GetValue(fields[0], kAttributeRtpmap, &payload_type_value, error)) {
2904 return false;
2905 }
2906 int payload_type = 0;
2907 if (!GetValueFromString(line, payload_type_value, &payload_type, error)) {
2908 return false;
2909 }
2910
2911 // Set the preference order depending on the order of the pl type in the
2912 // <fmt> of the m-line.
2913 const int preference = codec_preference.end() -
2914 std::find(codec_preference.begin(), codec_preference.end(),
2915 payload_type);
2916 if (preference == 0) {
2917 LOG(LS_WARNING) << "Ignore rtpmap line that did not appear in the "
2918 << "<fmt> of the m-line: " << line;
2919 return true;
2920 }
2921 const std::string encoder = fields[1];
2922 std::vector<std::string> codec_params;
2923 rtc::split(encoder, '/', &codec_params);
2924 // <encoding name>/<clock rate>[/<encodingparameters>]
2925 // 2 mandatory fields
2926 if (codec_params.size() < 2 || codec_params.size() > 3) {
2927 return ParseFailed(line,
2928 "Expected format \"<encoding name>/<clock rate>"
2929 "[/<encodingparameters>]\".",
2930 error);
2931 }
2932 const std::string encoding_name = codec_params[0];
2933 int clock_rate = 0;
2934 if (!GetValueFromString(line, codec_params[1], &clock_rate, error)) {
2935 return false;
2936 }
2937 if (media_type == cricket::MEDIA_TYPE_VIDEO) {
2938 VideoContentDescription* video_desc =
2939 static_cast<VideoContentDescription*>(media_desc);
2940 // TODO: We will send resolution in SDP. For now use
2941 // JsepSessionDescription::kMaxVideoCodecWidth and kMaxVideoCodecHeight.
2942 UpdateCodec(payload_type, encoding_name,
2943 JsepSessionDescription::kMaxVideoCodecWidth,
2944 JsepSessionDescription::kMaxVideoCodecHeight,
2945 JsepSessionDescription::kDefaultVideoCodecFramerate,
2946 preference, video_desc);
2947 } else if (media_type == cricket::MEDIA_TYPE_AUDIO) {
2948 // RFC 4566
2949 // For audio streams, <encoding parameters> indicates the number
2950 // of audio channels. This parameter is OPTIONAL and may be
2951 // omitted if the number of channels is one, provided that no
2952 // additional parameters are needed.
2953 int channels = 1;
2954 if (codec_params.size() == 3) {
2955 if (!GetValueFromString(line, codec_params[2], &channels, error)) {
2956 return false;
2957 }
2958 }
2959 int bitrate = 0;
2960 // The default behavior for ISAC (bitrate == 0) in webrtcvoiceengine.cc
2961 // (specifically FindWebRtcCodec) is bandwidth-adaptive variable bitrate.
2962 // The bandwidth adaptation doesn't always work well, so this code
2963 // sets a fixed target bitrate instead.
2964 if (_stricmp(encoding_name.c_str(), kIsacCodecName) == 0) {
2965 if (clock_rate <= 16000) {
2966 bitrate = kIsacWbDefaultRate;
2967 } else {
2968 bitrate = kIsacSwbDefaultRate;
2969 }
2970 }
2971 AudioContentDescription* audio_desc =
2972 static_cast<AudioContentDescription*>(media_desc);
2973 UpdateCodec(payload_type, encoding_name, clock_rate, bitrate, channels,
2974 preference, audio_desc);
2975 } else if (media_type == cricket::MEDIA_TYPE_DATA) {
2976 DataContentDescription* data_desc =
2977 static_cast<DataContentDescription*>(media_desc);
2978 data_desc->AddCodec(cricket::DataCodec(payload_type, encoding_name,
2979 preference));
2980 }
2981 return true;
2982 }
2983
PruneRight(const char delimiter,std::string * message)2984 void PruneRight(const char delimiter, std::string* message) {
2985 size_t trailing = message->find(delimiter);
2986 if (trailing != std::string::npos) {
2987 *message = message->substr(0, trailing);
2988 }
2989 }
2990
ParseFmtpParam(const std::string & line,std::string * parameter,std::string * value,SdpParseError * error)2991 bool ParseFmtpParam(const std::string& line, std::string* parameter,
2992 std::string* value, SdpParseError* error) {
2993 if (!SplitByDelimiter(line, kSdpDelimiterEqual, parameter, value)) {
2994 ParseFailed(line, "Unable to parse fmtp parameter. \'=\' missing.", error);
2995 return false;
2996 }
2997 // a=fmtp:<payload_type> <param1>=<value1>; <param2>=<value2>; ...
2998 // When parsing the values the trailing ";" gets picked up. Remove them.
2999 PruneRight(kSdpDelimiterSemicolon, value);
3000 return true;
3001 }
3002
ParseFmtpAttributes(const std::string & line,const MediaType media_type,MediaContentDescription * media_desc,SdpParseError * error)3003 bool ParseFmtpAttributes(const std::string& line, const MediaType media_type,
3004 MediaContentDescription* media_desc,
3005 SdpParseError* error) {
3006 if (media_type != cricket::MEDIA_TYPE_AUDIO &&
3007 media_type != cricket::MEDIA_TYPE_VIDEO) {
3008 return true;
3009 }
3010 std::vector<std::string> fields;
3011 rtc::split(line.substr(kLinePrefixLength),
3012 kSdpDelimiterSpace, &fields);
3013
3014 // RFC 5576
3015 // a=fmtp:<format> <format specific parameters>
3016 // At least two fields, whereas the second one is any of the optional
3017 // parameters.
3018 if (fields.size() < 2) {
3019 ParseFailedExpectMinFieldNum(line, 2, error);
3020 return false;
3021 }
3022
3023 std::string payload_type;
3024 if (!GetValue(fields[0], kAttributeFmtp, &payload_type, error)) {
3025 return false;
3026 }
3027
3028 cricket::CodecParameterMap codec_params;
3029 for (std::vector<std::string>::const_iterator iter = fields.begin() + 1;
3030 iter != fields.end(); ++iter) {
3031 std::string name;
3032 std::string value;
3033 if (iter->find(kSdpDelimiterEqual) == std::string::npos) {
3034 // Only fmtps with equals are currently supported. Other fmtp types
3035 // should be ignored. Unknown fmtps do not constitute an error.
3036 continue;
3037 }
3038 if (!ParseFmtpParam(*iter, &name, &value, error)) {
3039 return false;
3040 }
3041 codec_params[name] = value;
3042 }
3043
3044 int int_payload_type = 0;
3045 if (!GetValueFromString(line, payload_type, &int_payload_type, error)) {
3046 return false;
3047 }
3048 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
3049 UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
3050 media_desc, int_payload_type, codec_params);
3051 } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
3052 UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
3053 media_desc, int_payload_type, codec_params);
3054 }
3055 return true;
3056 }
3057
ParseRtcpFbAttribute(const std::string & line,const MediaType media_type,MediaContentDescription * media_desc,SdpParseError * error)3058 bool ParseRtcpFbAttribute(const std::string& line, const MediaType media_type,
3059 MediaContentDescription* media_desc,
3060 SdpParseError* error) {
3061 if (media_type != cricket::MEDIA_TYPE_AUDIO &&
3062 media_type != cricket::MEDIA_TYPE_VIDEO) {
3063 return true;
3064 }
3065 std::vector<std::string> rtcp_fb_fields;
3066 rtc::split(line.c_str(), kSdpDelimiterSpace, &rtcp_fb_fields);
3067 if (rtcp_fb_fields.size() < 2) {
3068 return ParseFailedGetValue(line, kAttributeRtcpFb, error);
3069 }
3070 std::string payload_type_string;
3071 if (!GetValue(rtcp_fb_fields[0], kAttributeRtcpFb, &payload_type_string,
3072 error)) {
3073 return false;
3074 }
3075 int payload_type = kWildcardPayloadType;
3076 if (payload_type_string != "*") {
3077 if (!GetValueFromString(line, payload_type_string, &payload_type, error)) {
3078 return false;
3079 }
3080 }
3081 std::string id = rtcp_fb_fields[1];
3082 std::string param = "";
3083 for (std::vector<std::string>::iterator iter = rtcp_fb_fields.begin() + 2;
3084 iter != rtcp_fb_fields.end(); ++iter) {
3085 param.append(*iter);
3086 }
3087 const cricket::FeedbackParam feedback_param(id, param);
3088
3089 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
3090 UpdateCodec<AudioContentDescription, cricket::AudioCodec>(media_desc,
3091 payload_type,
3092 feedback_param);
3093 } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
3094 UpdateCodec<VideoContentDescription, cricket::VideoCodec>(media_desc,
3095 payload_type,
3096 feedback_param);
3097 }
3098 return true;
3099 }
3100
3101 } // namespace webrtc
3102