前言

peerconnection收到sdp封装后的message后，将其解析。
1、发送消息
void PeerConnectionClient::SendToPeer(int peer_id, const std::string& message)
image.png
2、接收消息
void PeerConnectionClient::OnMessageFromPeer(int peer_id, const std::string& message)
image.png

PeerConnectionClient::OnMessageFromPeer

  1. void PeerConnectionClient::OnMessageFromPeer(int peer_id,
  2.                                              const std::string& message) {
  3.   if (message.length() == (sizeof(kByeMessage) - 1) &&
  4.       message.compare(kByeMessage) == 0) {
  5.     callback_->OnPeerDisconnected(peer_id);
  6.   } else {
  7.     callback_->OnMessageFromPeer(peer_id, message);
  8.   }
  9. }

里面调用的OnMessageFromPeer是 Conductor::OnMessageFromPeer

Conductor::OnMessageFromPeer

  1. void Conductor::OnMessageFromPeer(int peer_id, const std::string& message) {
  2.   RTC_DCHECK(peer_id_ == peer_id || peer_id_ == -1);
  3.   RTC_DCHECK(!message.empty());
  5.   if (!peer_connection_.get()) {
  6.     RTC_DCHECK(peer_id_ == -1);
  7.     peer_id_ = peer_id;
  9.     if (!InitializePeerConnection()) {
  10.       RTC_LOG(LS_ERROR) << "Failed to initialize our PeerConnection instance";
  11.       client_->SignOut();
  12.       return;
  13.     }
  14.   } else if (peer_id != peer_id_) {
  15.     RTC_DCHECK(peer_id_ != -1);
  16.     RTC_LOG(WARNING)
  17.         << "Received a message from unknown peer while already in a "
  18.            "conversation with a different peer.";
  19.     return;
  20.   }
  23.   // json解析接收到的对端消息
  24.   Json::Reader reader;
  25.   Json::Value jmessage;
  26.   if (!reader.parse(message, jmessage)) {
  27.     RTC_LOG(WARNING) << "Received unknown message. " << message;
  28.     return;
  29.   }
  30.   std::string type_str;
  31.   std::string json_object;
  33.   // 获取信令类型，type_str为answer或者offer,
  34.   // 如果是本端发起通信，第一次会收到answer类型，后面收到的就是空类型
  35.   rtc::GetStringFromJsonObject(jmessage, kSessionDescriptionTypeName,
  36.                                &type_str);
  38.   if (!type_str.empty()) { // 类型不为空
  39.     if (type_str == "offer-loopback") { 
  40.       // This is a loopback call.
  41.       // Recreate the peerconnection with DTLS disabled.
  42.       if (!ReinitializePeerConnectionForLoopback()) {
  43.         RTC_LOG(LS_ERROR) << "Failed to initialize our PeerConnection instance";
  44.         DeletePeerConnection();
  45.         client_->SignOut();
  46.       }
  47.       return;
  48.     }
  49.     // 获取sdp类型
  50.     absl::optional<webrtc::SdpType> type_maybe =
  51.         webrtc::SdpTypeFromString(type_str);
  52.     if (!type_maybe) {
  53.       RTC_LOG(LS_ERROR) << "Unknown SDP type: " << type_str;
  54.       return;
  55.     }
  56.     webrtc::SdpType type = *type_maybe;
  57.     // 从json中解析出一个个的文本sdp消息
  58.     std::string sdp;
  59.     if (!rtc::GetStringFromJsonObject(jmessage, kSessionDescriptionSdpName,
  60.                                       &sdp)) {
  61.       RTC_LOG(WARNING) << "Can't parse received session description message.";
  62.       return;
  63.     }
  65.     // 创建SessionDescriptionInterface对象保存sdp
  66.     webrtc::SdpParseError error;
  67.     std::unique_ptr<webrtc::SessionDescriptionInterface> session_description =
  68.         webrtc::CreateSessionDescription(type, sdp, &error);
  69.     if (!session_description) {
  70.       RTC_LOG(WARNING) << "Can't parse received session description message. "
  71.                           "SdpParseError was: "
  72.                        << error.description;
  73.       return;
  74.     }
  75.     RTC_LOG(INFO) << " Received session description :" << message;
  77.     // 设置远端的消息保存到内存
  78.     peer_connection_->SetRemoteDescription(
  79.         DummySetSessionDescriptionObserver::Create(),
  80.         session_description.release());
  82.     // 如果是offer消息，则代表是对端发起通信，需要发给对端answer
  83.     if (type == webrtc::SdpType::kOffer) { 
  84.       peer_connection_->CreateAnswer(
  85.           this, webrtc::PeerConnectionInterface::RTCOfferAnswerOptions());
  86.     }
  88.   } else { 
  89.     std::string sdp_mid;
  90.     int sdp_mlineindex = 0;
  92.     // 获取sdp信息
  93.     std::string sdp;
  94.     if (!rtc::GetStringFromJsonObject(jmessage, kCandidateSdpMidName,
  95.                                       &sdp_mid) ||
  96.         !rtc::GetIntFromJsonObject(jmessage, kCandidateSdpMlineIndexName,
  97.                                    &sdp_mlineindex) ||
  98.         !rtc::GetStringFromJsonObject(jmessage, kCandidateSdpName, &sdp)) {
  99.       RTC_LOG(WARNING) << "Can't parse received message.";
  100.       return;
  101.     }
  103.     // 根据sdp，创建candidate
  104.     webrtc::SdpParseError error;
  105.     std::unique_ptr<webrtc::IceCandidateInterface> candidate(
  106.         webrtc::CreateIceCandidate(sdp_mid, sdp_mlineindex, sdp, &error));
  107.     if (!candidate.get()) {
  108.       RTC_LOG(WARNING) << "Can't parse received candidate message. "
  109.                           "SdpParseError was: "
  110.                        << error.description;
  111.       return;
  112.     }
  114.     // 添加AddIceCandidate
  115.     if (!peer_connection_->AddIceCandidate(candidate.get())) {
  116.       RTC_LOG(WARNING) << "Failed to apply the received candidate";
  117.       return;
  118.     }
  119.     RTC_LOG(INFO) << " Received candidate :" << message;
  120.   }
  121. }

image.png
image.png
取出type_str和sdp后，创建session_description，
std::unique_ptr session_description =
webrtc::CreateSessionDescription(type, sdp, &error);

webrtc::CreateSessionDescription

  1. std::unique_ptr<SessionDescriptionInterface> CreateSessionDescription(
  2.     SdpType type,
  3.     const std::string& sdp,
  4.     SdpParseError* error_out) {
  5.   auto jsep_desc = std::make_unique<JsepSessionDescription>(type);
  6.   if (type != SdpType::kRollback) {
  7.     if (!SdpDeserialize(sdp, jsep_desc.get(), error_out)) {
  8.       return nullptr;
  9.     }
  10.   }
  11.   return std::move(jsep_desc);
  12. }

里面主要是调用了SdpDeserialize，反序列化解析sdp文本出来。跟之前的序列化SdpSerialize函数相对应。

SdpDeserialize

  1. bool SdpDeserialize(const std::string& message,
  2.                     JsepSessionDescription* jdesc,
  3.                     SdpParseError* error) {
  4.   std::string session_id;
  5.   std::string session_version;
  6.   TransportDescription session_td("", "");
  7.   RtpHeaderExtensions session_extmaps;
  8.   rtc::SocketAddress session_connection_addr;
  9.   auto desc = std::make_unique<cricket::SessionDescription>();
  10.   size_t current_pos = 0;
  12.   // Session Description
  13.   if (!ParseSessionDescription(message, &current_pos, &session_id,
  14.                                &session_version, &session_td, &session_extmaps,
  15.                                &session_connection_addr, desc.get(), error)) {
  16.     return false;
  17.   }
  19.   // Media Description
  20.   std::vector<std::unique_ptr<JsepIceCandidate>> candidates;
  21.   if (!ParseMediaDescription(message, session_td, session_extmaps, &current_pos,
  22.                              session_connection_addr, desc.get(), &candidates,
  23.                              error)) {
  24.     return false;
  25.   }
  27.   jdesc->Initialize(std::move(desc), session_id, session_version);
  29.   for (const auto& candidate : candidates) {
  30.     jdesc->AddCandidate(candidate.get());
  31.   }
  32.   return true;
  33. }

重点看媒体会话描述ParseMediaDescription

ParseMediaDescription

  1. bool ParseMediaDescription(***){
  2. ***
  3.   // Zero or more media descriptions
  4.   // RFC 4566
  5.   // m=<media> <port> <proto> <fmt> 获取每一行
  6.   while (GetLineWithType(message, pos, &line, kLineTypeMedia)) {
  7.     ++mline_index;
  9.      // 按照空格来分割，将分割后的内容保存到fields
  10.     std::vector<std::string> fields;
  11.     rtc::split(line.substr(kLinePrefixLength), kSdpDelimiterSpaceChar, &fields);
  13.     const size_t expected_min_fields = 4;
  14.     if (fields.size() < expected_min_fields) {
  15.       return ParseFailedExpectMinFieldNum(line, expected_min_fields, error);
  16.     }
  17.     bool port_rejected = false;
  18.     // RFC 3264
  19.     // To reject an offered stream, the port number in the corresponding stream
  20.     // in the answer MUST be set to zero.
  21.     if (fields[1] == kMediaPortRejected) {
  22.       port_rejected = true;
  23.     }
  25.     int port = 0;
  26.     if (!rtc::FromString<int>(fields[1], &port) || !IsValidPort(port)) {
  27.       return ParseFailed(line, "The port number is invalid", error);
  28.     }
  29.     const std::string& protocol = fields[2];
  31.     // <fmt> 获取payload_types
  32.     std::vector<int> payload_types;
  33.     if (cricket::IsRtpProtocol(protocol)) {
  34.       for (size_t j = 3; j < fields.size(); ++j) {
  35.         int pl = 0;
  36.         if (!GetPayloadTypeFromString(line, fields[j], &pl, error)) {
  37.           return false;
  38.         }
  39.         payload_types.push_back(pl);
  40.       }
  41.     }
  43.       // 构建临时的TransportDescription
  44.     // Make a temporary TransportDescription based on |session_td|.
  45.     // Some of this gets overwritten by ParseContent.
  46.     TransportDescription transport(
  47.         session_td.transport_options, session_td.ice_ufrag, session_td.ice_pwd,
  48.         session_td.ice_mode, session_td.connection_role,
  49.         session_td.identity_fingerprint.get());
  51.       //媒体信息解析
  52.     std::unique_ptr<MediaContentDescription> content;
  53.     std::string content_name;
  54.     bool bundle_only = false;
  55.     int section_msid_signaling = 0;
  56.     const std::string& media_type = fields[0];
  57.     if ((media_type == kMediaTypeVideo || media_type == kMediaTypeAudio) &&
  58.         !cricket::IsRtpProtocol(protocol)) {
  59.       return ParseFailed(line, "Unsupported protocol for media type", error);
  60.     }
  61.     if (media_type == kMediaTypeVideo) { 视频
  62.       content = ParseContentDescription<VideoContentDescription>(
  63.           message, cricket::MEDIA_TYPE_VIDEO, mline_index, protocol,
  64.           payload_types, pos, &content_name, &bundle_only,
  65.           &section_msid_signaling, &transport, candidates, error);
  66.     } else if (media_type == kMediaTypeAudio) {
  67.       content = ParseContentDescription<AudioContentDescription>(
  68.           message, cricket::MEDIA_TYPE_AUDIO, mline_index, protocol,
  69.           payload_types, pos, &content_name, &bundle_only,
  70.           &section_msid_signaling, &transport, candidates, error);
  71.     } else if (media_type == kMediaTypeData) { 媒体类型数据
  72.       if (cricket::IsDtlsSctp(protocol)) {
  73.     ***
  74.         }
  75.         if (!ParseContent(message, cricket::MEDIA_TYPE_DATA, mline_index,
  76.                           protocol, payload_types, pos, &content_name,
  77.                           &bundle_only, &section_msid_signaling,
  78.                           data_desc.get(), &transport, candidates, error)) {
  79.           return false;
  80.         }
  81.       **
  82.       } else if (cricket::IsRtpProtocol(protocol)) {
  83.         // RTP
  84.         std::unique_ptr<RtpDataContentDescription> data_desc =
  85.             ParseContentDescription<RtpDataContentDescription>***
  86.       } else {
  87.         return ParseFailed(line, "Unsupported protocol for media type", error);
  88.       }
  89.     } else {
  90.       RTC_LOG(LS_WARNING) << "Unsupported media type: " << line;
  91.       auto unsupported_desc =
  92.           std::make_unique<UnsupportedContentDescription>(media_type);
  93.       if (!ParseContent(message, cricket::MEDIA_TYPE_UNSUPPORTED, mline_index,
  94.                         protocol, payload_types, pos, &content_name,
  95.                         &bundle_only, &section_msid_signaling,
  96.                         unsupported_desc.get(), &transport, candidates,
  97.                         error)) {
  98.         return false;
  99.       }
  100.     ***
  102.     bool content_rejected = false;
  103.     // A port of 0 is not interpreted as a rejected m= section when it's
  104.     // used along with a=bundle-only.
  105.     if (bundle_only) {
  106.       if (!port_rejected) {
  107.         // Usage of bundle-only with a nonzero port is unspecified. So just
  108.         // ignore bundle-only if we see this.
  109.         bundle_only = false;
  110.         RTC_LOG(LS_WARNING)
  111.             << "a=bundle-only attribute observed with a nonzero "
  112.                "port; this usage is unspecified so the attribute is being "
  113.                "ignored.";
  114.       }
  115.     } else {
  116.       // If not using bundle-only, interpret port 0 in the normal way; the m=
  117.       // section is being rejected.
  118.       content_rejected = port_rejected;
  119.     }
  121.   ***
  122.       for (size_t i = 0; i < session_extmaps.size(); ++i) {
  123.         content->AddRtpHeaderExtension(session_extmaps[i]);
  124.       }
  125.     } else if (content->as_sctp()) {
  126.       // Do nothing, it's OK
  127.     } else {
  128.       RTC_LOG(LS_WARNING) << "Parse failed with unknown protocol " << protocol;
  129.       return false;
  130.     }
  132.     // Use the session level connection address if the media level addresses are
  133.     // not specified.
  134.     rtc::SocketAddress address;
  135.     address = content->connection_address().IsNil()
  136.                   ? session_connection_addr
  137.                   : content->connection_address();
  138.     address.SetPort(port);
  139.     content->set_connection_address(address);
  141.     desc->AddContent(content_name,
  142.                      cricket::IsDtlsSctp(protocol) ? MediaProtocolType::kSctp
  143.                                                    : MediaProtocolType::kRtp,
  144.                      content_rejected, bundle_only, std::move(content));
  145.     // Create TransportInfo with the media level "ice-pwd" and "ice-ufrag".
  146.     desc->AddTransportInfo(TransportInfo(content_name, transport));
  147.   }
  149.   desc->set_msid_signaling(msid_signaling);
  150. **
  151.   return true;
  152. }

image.png
查看payload_types
image.png
后面以media_type == kMediaTypeAudio为例子，看音频类型的解析content
content = ParseContentDescription(
message, cricket::MEDIA_TYPE_AUDIO, mline_index, protocol,
payload_types, pos, &content_name, &bundle_only,
&section_msid_signaling, &transport, candidates, error);

ParseContentDescription

  1. template <class C>
  2. static std::unique_ptr<C> ParseContentDescription(
  3.     const std::string& message,
  4.     const cricket::MediaType media_type,
  5.     int mline_index,
  6.     const std::string& protocol,
  7.     const std::vector<int>& payload_types,
  8.     size_t* pos,
  9.     std::string* content_name,
  10.     bool* bundle_only,
  11.     int* msid_signaling,
  12.     TransportDescription* transport,
  13.     std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
  14.     webrtc::SdpParseError* error) {
  15.   auto media_desc = std::make_unique<C>();
  16.   media_desc->set_extmap_allow_mixed_enum(MediaContentDescription::kNo);
  17.   if (!ParseContent(message, media_type, mline_index, protocol, payload_types,
  18.                     pos, content_name, bundle_only, msid_signaling,
  19.                     media_desc.get(), transport, candidates, error)) {
  20.     return nullptr;
  21.   }
  22.   // Sort the codecs according to the m-line fmt list.
  23.   std::unordered_map<int, int> payload_type_preferences;
  24.   // "size + 1" so that the lowest preference payload type has a preference of
  25.   // 1, which is greater than the default (0) for payload types not in the fmt
  26.   // list.
  27.   int preference = static_cast<int>(payload_types.size() + 1);
  28.   for (int pt : payload_types) {
  29.     payload_type_preferences[pt] = preference--;
  30.   }
  31.   std::vector<typename C::CodecType> codecs = media_desc->codecs();
  32.   absl::c_sort(
  33.       codecs, [&payload_type_preferences](const typename C::CodecType& a,
  34.                                           const typename C::CodecType& b) {
  35.         return payload_type_preferences[a.id] > payload_type_preferences[b.id];
  36.       });
  37.   media_desc->set_codecs(codecs);
  38.   return media_desc;
  39. }

ParseContent

  1. bool ParseContent(const std::string& message,
  2.                   const cricket::MediaType media_type,
  3.                   int mline_index,
  4.                   const std::string& protocol,
  5.                   const std::vector<int>& payload_types,
  6.                   size_t* pos,
  7.                   std::string* content_name,
  8.                   bool* bundle_only,
  9.                   int* msid_signaling,
  10.                   MediaContentDescription* media_desc,
  11.                   TransportDescription* transport,
  12.                   std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
  13.                   SdpParseError* error) {
  14.   RTC_DCHECK(media_desc != NULL);
  15.   RTC_DCHECK(content_name != NULL);
  16.   RTC_DCHECK(transport != NULL);
  18.   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
  19.     MaybeCreateStaticPayloadAudioCodecs(payload_types, media_desc->as_audio());
  20.   }
  22.   // The media level "ice-ufrag" and "ice-pwd".
  23.   // The candidates before update the media level "ice-pwd" and "ice-ufrag".
  24.   Candidates candidates_orig;
  25.   std::string line;
  26.   std::string mline_id;
  27.   // Tracks created out of the ssrc attributes.
  28.   StreamParamsVec tracks;
  29.   SsrcInfoVec ssrc_infos;
  30.   SsrcGroupVec ssrc_groups;
  31.   std::string maxptime_as_string;
  32.   std::string ptime_as_string;
  33.   std::vector<std::string> stream_ids;
  34.   std::string track_id;
  35.   SdpSerializer deserializer;
  36.   std::vector<RidDescription> rids;
  37.   SimulcastDescription simulcast;
  39.   // Loop until the next m line
  40.     // 循环直到下一个m行
  41.   while (!IsLineType(message, kLineTypeMedia, *pos)) {
  42.       ***
  44.   }
  47.   // Remove duplicate or inconsistent rids.
  48.   RemoveInvalidRidDescriptions(payload_types, &rids);
  50.   // If simulcast is specifed, split the rids into send and receive.
  51.   // Rids that do not appear in simulcast attribute will be removed.
  52.   // If it is not specified, we assume that all rids are for send layers.
  53.   std::vector<RidDescription> send_rids;
  54.   std::vector<RidDescription> receive_rids;
  55.   if (!simulcast.empty()) {
  56.     // Verify that the rids in simulcast match rids in sdp.
  57.     RemoveInvalidRidsFromSimulcast(rids, &simulcast);
  59.     // Use simulcast description to figure out Send / Receive RIDs.
  60.     std::map<std::string, RidDescription> rid_map;
  61.     for (const RidDescription& rid : rids) {
  62.       rid_map[rid.rid] = rid;
  63.     }
  65.     for (const auto& layer : simulcast.send_layers().GetAllLayers()) {
  66.       auto iter = rid_map.find(layer.rid);
  67.       RTC_DCHECK(iter != rid_map.end());
  68.       send_rids.push_back(iter->second);
  69.     }
  71.     for (const auto& layer : simulcast.receive_layers().GetAllLayers()) {
  72.       auto iter = rid_map.find(layer.rid);
  73.       RTC_DCHECK(iter != rid_map.end());
  74.       receive_rids.push_back(iter->second);
  75.     }
  77.     media_desc->set_simulcast_description(simulcast);
  78.   } else {
  79.     send_rids = rids;
  80.   }
  82.   media_desc->set_receive_rids(receive_rids);
  84.   // Create tracks from the |ssrc_infos|.
  85.   // If the stream_id/track_id for all SSRCS are identical, one StreamParams
  86.   // will be created in CreateTracksFromSsrcInfos, containing all the SSRCs from
  87.   // the m= section.
  88.   if (!ssrc_infos.empty()) {
  89.     CreateTracksFromSsrcInfos(ssrc_infos, stream_ids, track_id, &tracks,
  90.                               *msid_signaling);
  91.   } else if (media_type != cricket::MEDIA_TYPE_DATA &&
  92.              (*msid_signaling & cricket::kMsidSignalingMediaSection)) {
  93.     // If the stream_ids/track_id was signaled but SSRCs were unsignaled we
  94.     // still create a track. This isn't done for data media types because
  95.     // StreamParams aren't used for SCTP streams, and RTP data channels don't
  96.     // support unsignaled SSRCs.
  97.     CreateTrackWithNoSsrcs(stream_ids, track_id, send_rids, &tracks);
  98.   }
  100.   // Add the ssrc group to the track.
  101.   for (const SsrcGroup& ssrc_group : ssrc_groups) {
  102.     if (ssrc_group.ssrcs.empty()) {
  103.       continue;
  104.     }
  105.     uint32_t ssrc = ssrc_group.ssrcs.front();
  106.     for (StreamParams& track : tracks) {
  107.       if (track.has_ssrc(ssrc)) {
  108.         track.ssrc_groups.push_back(ssrc_group);
  109.       }
  110.     }
  111.   }
  113.   // Add the new tracks to the |media_desc|.
  114.   for (StreamParams& track : tracks) {
  115.     media_desc->AddStream(track);
  116.   }
  118.   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
  119.     AudioContentDescription* audio_desc = media_desc->as_audio();
  120.     UpdateFromWildcardCodecs(audio_desc);
  122.     // Verify audio codec ensures that no audio codec has been populated with
  123.     // only fmtp.
  124.     if (!VerifyAudioCodecs(audio_desc)) {
  125.       return ParseFailed("Failed to parse audio codecs correctly.", error);
  126.     }
  127.     AddAudioAttribute(kCodecParamMaxPTime, maxptime_as_string, audio_desc);
  128.     AddAudioAttribute(kCodecParamPTime, ptime_as_string, audio_desc);
  129.   }
  131.   if (media_type == cricket::MEDIA_TYPE_VIDEO) {
  132.     VideoContentDescription* video_desc = media_desc->as_video();
  133.     UpdateFromWildcardCodecs(video_desc);
  134.     // Verify video codec ensures that no video codec has been populated with
  135.     // only rtcp-fb.
  136.     if (!VerifyVideoCodecs(video_desc)) {
  137.       return ParseFailed("Failed to parse video codecs correctly.", error);
  138.     }
  139.   }
  141.   // RFC 5245
  142.   // Update the candidates with the media level "ice-pwd" and "ice-ufrag".
  143.   for (Candidate& candidate : candidates_orig) {
  144.     RTC_DCHECK(candidate.username().empty() ||
  145.                candidate.username() == transport->ice_ufrag);
  146.     candidate.set_username(transport->ice_ufrag);
  147.     RTC_DCHECK(candidate.password().empty());
  148.     candidate.set_password(transport->ice_pwd);
  149.     candidates->push_back(
  150.         std::make_unique<JsepIceCandidate>(mline_id, mline_index, candidate));
  151.   }
  153.   return true;