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 { 220 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". 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|. 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. 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. 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. 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|. 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|. 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 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 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|". 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|". 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|. 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 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 496 static bool IsLineType(const std::string& line, 497 const char type) { 498 return IsLineType(line, type, 0); 499 } 500 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 513 static bool HasAttribute(const std::string& line, 514 const std::string& attribute) { 515 return (line.compare(kLinePrefixLength, attribute.size(), attribute) == 0); 516 } 517 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. 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>. 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 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> 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 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 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 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. 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. 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|. 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. 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 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. 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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|. 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> 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> 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 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 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 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 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 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 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 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 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 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 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 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> 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 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 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 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 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 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 2332 void AddFeedbackParameter(const cricket::FeedbackParam& feedback_param, 2333 cricket::Codec* codec) { 2334 codec->AddFeedbackParam(feedback_param); 2335 } 2336 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> 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> 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> 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> 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 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 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 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 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 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 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 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|. 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|. 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 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 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 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 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 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
