前言

image.png

image.png

代码分析

Conductor::OnSuccess

  1. void Conductor::OnSuccess(webrtc::SessionDescriptionInterface* desc) {
  2.   peer_connection_->SetLocalDescription(
  3.       DummySetSessionDescriptionObserver::Create(), desc);
  5.   std::string sdp;
  6.   desc->ToString(&sdp);
  7.     ***
  8.  }

JsepSessionDescription::ToString

  1. bool JsepSessionDescription::ToString(std::string* out) const {
  2.   if (!description_ || !out) {
  3.     return false;
  4.   }
  5.   *out = SdpSerialize(*this);
  6.   return !out->empty();
  7. }

SdpSerialize

  1. std::string SdpSerialize(const JsepSessionDescription& jdesc) {
  2.   const cricket::SessionDescription* desc = jdesc.description();
  3.   if (!desc) {
  4.     return "";
  5.   }
  7.   std::string message;
  9.   // Session Description.
  10.   AddLine(kSessionVersion, &message);
  11.   // Session Origin
  12.   // RFC 4566
  13.   // o=<username> <sess-id> <sess-version> <nettype> <addrtype>
  14.   // <unicast-address>
  15.   rtc::StringBuilder os;
  16.   InitLine(kLineTypeOrigin, kSessionOriginUsername, &os);
  17.   const std::string& session_id =
  18.       jdesc.session_id().empty() ? kSessionOriginSessionId : jdesc.session_id();
  19.   const std::string& session_version = jdesc.session_version().empty()
  20.                                            ? kSessionOriginSessionVersion
  21.                                            : jdesc.session_version();
  22.   os << " " << session_id << " " << session_version << " "
  23.      << kSessionOriginNettype << " " << kSessionOriginAddrtype << " "
  24.      << kSessionOriginAddress;
  25.   AddLine(os.str(), &message);
  26.   AddLine(kSessionName, &message);
  28.   // Time Description.
  29.   AddLine(kTimeDescription, &message);
  31.   // Group
  32.   if (desc->HasGroup(cricket::GROUP_TYPE_BUNDLE)) {
  33.     std::string group_line = kAttrGroup;
  34.     const cricket::ContentGroup* group =
  35.         desc->GetGroupByName(cricket::GROUP_TYPE_BUNDLE);
  36.     RTC_DCHECK(group != NULL);
  37.     for (const std::string& content_name : group->content_names()) {
  38.       group_line.append(" ");
  39.       group_line.append(content_name);
  40.     }
  41.     AddLine(group_line, &message);
  42.   }
  44.   // Mixed one- and two-byte header extension.
  45.   if (desc->extmap_allow_mixed()) {
  46.     InitAttrLine(kAttributeExtmapAllowMixed, &os);
  47.     AddLine(os.str(), &message);
  48.   }
  50.   // MediaStream semantics
  51.   InitAttrLine(kAttributeMsidSemantics, &os);
  52.   os << kSdpDelimiterColon << " " << kMediaStreamSemantic;
  54.   std::set<std::string> media_stream_ids;
  55.   const ContentInfo* audio_content = GetFirstAudioContent(desc);
  56.   if (audio_content)
  57.     GetMediaStreamIds(audio_content, &media_stream_ids);
  59.   const ContentInfo* video_content = GetFirstVideoContent(desc);
  60.   if (video_content)
  61.     GetMediaStreamIds(video_content, &media_stream_ids);
  63.   for (const std::string& id : media_stream_ids) {
  64.     os << " " << id;
  65.   }
  66.   AddLine(os.str(), &message);
  68.   // a=ice-lite
  69.   //
  70.   // TODO(deadbeef): It's weird that we need to iterate TransportInfos for
  71.   // this, when it's a session-level attribute. It really should be moved to a
  72.   // session-level structure like SessionDescription.
  73.   for (const cricket::TransportInfo& transport : desc->transport_infos()) {
  74.     if (transport.description.ice_mode == cricket::ICEMODE_LITE) {
  75.       InitAttrLine(kAttributeIceLite, &os);
  76.       AddLine(os.str(), &message);
  77.       break;
  78.     }
  79.   }
  81.   // Preserve the order of the media contents.
  82.     // 重点***
  83.   int mline_index = -1;
  84.   for (const ContentInfo& content : desc->contents()) {
  85.     std::vector<Candidate> candidates;
  86.     GetCandidatesByMindex(jdesc, ++mline_index, &candidates);
  87.       // 构建每一个媒体行和解释
  88.     BuildMediaDescription(&content, desc->GetTransportInfoByName(content.name),
  89.                           content.media_description()->type(), candidates,
  90.                           desc->msid_signaling(), &message);
  91.   }
  92.   return message;
  93. }

AddLine的作用是将信息添加到message中，可以算是sdp文本中的一行。
InitLine 一行信息的初始化

BuildMediaDescription

  1. void BuildMediaDescription(const ContentInfo* content_info,
  2.                            const TransportInfo* transport_info,
  3.                            const cricket::MediaType media_type,
  4.                            const std::vector<Candidate>& candidates,
  5.                            int msid_signaling,
  6.                            std::string* message) {
  7.   RTC_DCHECK(message != NULL);
  8.   if (content_info == NULL || message == NULL) {
  9.     return;
  10.   }
  11.     // 创建一个buffer，最后将这个buffer输出到message中。
  12.   rtc::StringBuilder os;
  14.    // 取出media_desc，然后下面根据类型来做相应的处理
  15.   const MediaContentDescription* media_desc = content_info->media_description();
  16.   RTC_DCHECK(media_desc);
  18.   // RFC 4566
  19.   // m=<media> <port> <proto> <fmt>
  20.   // fmt is a list of payload type numbers that MAY be used in the session.
  21.   std::string type;
  22.   std::string fmt;
  23.   if (media_type == cricket::MEDIA_TYPE_VIDEO) { //视频类型
  24.     type = kMediaTypeVideo;
  25.     const VideoContentDescription* video_desc = media_desc->as_video();
  26.     for (const cricket::VideoCodec& codec : video_desc->codecs()) {
  27.       fmt.append(" ");
  28.       fmt.append(rtc::ToString(codec.id));
  29.     }
  30.   } else if (media_type == cricket::MEDIA_TYPE_AUDIO) { // 音频类型
  31.     type = kMediaTypeAudio;
  32.     const AudioContentDescription* audio_desc = media_desc->as_audio();
  33.     for (const cricket::AudioCodec& codec : audio_desc->codecs()) {
  34.       fmt.append(" ");
  35.       fmt.append(rtc::ToString(codec.id));
  36.     }
  37.   } else if (media_type == cricket::MEDIA_TYPE_DATA) { // 数据类型
  38.     type = kMediaTypeData;
  39.     const cricket::SctpDataContentDescription* sctp_data_desc =
  40.         media_desc->as_sctp();
  41.     if (sctp_data_desc) {
  42.       fmt.append(" ");
  44.       if (sctp_data_desc->use_sctpmap()) {
  45.         fmt.append(rtc::ToString(sctp_data_desc->port()));
  46.       } else {
  47.         fmt.append(kDefaultSctpmapProtocol);
  48.       }
  49.     } else {
  50.       const RtpDataContentDescription* rtp_data_desc =
  51.           media_desc->as_rtp_data();
  52.       for (const cricket::RtpDataCodec& codec : rtp_data_desc->codecs()) {
  53.         fmt.append(" ");
  54.         fmt.append(rtc::ToString(codec.id));
  55.       }
  56.     }
  57.   } else if (media_type == cricket::MEDIA_TYPE_UNSUPPORTED) { // 不支持的类型
  58.     const UnsupportedContentDescription* unsupported_desc =
  59.         media_desc->as_unsupported();
  60.     type = unsupported_desc->media_type();
  61.   } else {
  62.     RTC_NOTREACHED();
  63.   }
  64.   // The fmt must never be empty. If no codecs are found, set the fmt attribute
  65.   // to 0.
  66.   if (fmt.empty()) {
  67.     fmt = " 0";
  68.   }
  70.   // The port number in the m line will be updated later when associated with
  71.   // the candidates.
  72.   //
  73.   // A port value of 0 indicates that the m= section is rejected.
  74.   // RFC 3264
  75.   // To reject an offered stream, the port number in the corresponding stream in
  76.   // the answer MUST be set to zero.
  77.   //
  78.   // However, the BUNDLE draft adds a new meaning to port zero, when used along
  79.   // with a=bundle-only.
  80.   std::string port = kDummyPort; //定义端口，默认为9
  81.   if (content_info->rejected || content_info->bundle_only) {
  82.     port = kMediaPortRejected;
  83.   } else if (!media_desc->connection_address().IsNil()) {
  84.     port = rtc::ToString(media_desc->connection_address().port());
  85.   }
  87.     // 获取指纹对象
  88.   rtc::SSLFingerprint* fp =
  89.       (transport_info) ? transport_info->description.identity_fingerprint.get()
  90.                        : NULL;
  92.   // Add the m and c lines.
  93.     // 添加m行和c行
  94.   InitLine(kLineTypeMedia, type, &os);
  95.   os << " " << port << " " << media_desc->protocol() << fmt;
  96.   AddLine(os.str(), message);
  98.   InitLine(kLineTypeConnection, kConnectionNettype, &os);
  99.   if (media_desc->connection_address().IsNil()) {
  100.     os << " " << kConnectionIpv4Addrtype << " " << kDummyAddress;
  101.   } else if (media_desc->connection_address().family() == AF_INET) {
  102.     os << " " << kConnectionIpv4Addrtype << " "
  103.        << media_desc->connection_address().ipaddr().ToString();
  104.   } else if (media_desc->connection_address().family() == AF_INET6) {
  105.     os << " " << kConnectionIpv6Addrtype << " "
  106.        << media_desc->connection_address().ipaddr().ToString();
  107.   } else {
  108.     os << " " << kConnectionIpv4Addrtype << " " << kDummyAddress;
  109.   }
  110.   AddLine(os.str(), message);
  112.     // 添加带宽的行内容
  113.   // RFC 4566
  114.   // b=AS:<bandwidth> or
  115.   // b=TIAS:<bandwidth>
  116.   int bandwidth = media_desc->bandwidth();
  117.   std::string bandwidth_type = media_desc->bandwidth_type();
  118.   if (bandwidth_type == kApplicationSpecificBandwidth && bandwidth >= 1000) {
  119.     InitLine(kLineTypeSessionBandwidth, bandwidth_type, &os);
  120.     bandwidth /= 1000;
  121.     os << kSdpDelimiterColon << bandwidth;
  122.     AddLine(os.str(), message);
  123.   } else if (bandwidth_type == kTransportSpecificBandwidth && bandwidth > 0) {
  124.     InitLine(kLineTypeSessionBandwidth, bandwidth_type, &os);
  125.     os << kSdpDelimiterColon << bandwidth;
  126.     AddLine(os.str(), message);
  127.   }
  129.   // Add the a=bundle-only line.
  130.   if (content_info->bundle_only) {
  131.     InitAttrLine(kAttributeBundleOnly, &os);
  132.     AddLine(os.str(), message);
  133.   }
  135.   // Add the a=rtcp line.
  136.   if (cricket::IsRtpProtocol(media_desc->protocol())) {
  137.     std::string rtcp_line = GetRtcpLine(candidates);
  138.     if (!rtcp_line.empty()) {
  139.       AddLine(rtcp_line, message);
  140.     }
  141.   }
  143.     // 老的方式，现在已经不使用了。用的是读取配置方式
  144.   // Build the a=candidate lines. We don't include ufrag and pwd in the
  145.   // candidates in the SDP to avoid redundancy.
  146.   BuildCandidate(candidates, false, message);
  148.   // Use the transport_info to build the media level ice-ufrag and ice-pwd.
  149.   if (transport_info) {
  150.     // RFC 5245
  151.     // ice-pwd-att           = "ice-pwd" ":" password
  152.     // ice-ufrag-att         = "ice-ufrag" ":" ufrag
  153.     // ice-ufrag
  154.     if (!transport_info->description.ice_ufrag.empty()) {
  155.       InitAttrLine(kAttributeIceUfrag, &os);
  156.       os << kSdpDelimiterColon << transport_info->description.ice_ufrag;
  157.       AddLine(os.str(), message);
  158.     }
  159.     // ice-pwd
  160.     if (!transport_info->description.ice_pwd.empty()) {
  161.       InitAttrLine(kAttributeIcePwd, &os);
  162.       os << kSdpDelimiterColon << transport_info->description.ice_pwd;
  163.       AddLine(os.str(), message);
  164.     }
  166.     // draft-petithuguenin-mmusic-ice-attributes-level-03
  167.     BuildIceOptions(transport_info->description.transport_options, message);
  169.     // RFC 4572
  170.     // fingerprint-attribute  =
  171.     //   "fingerprint" ":" hash-func SP fingerprint
  172.     if (fp) {
  173.       // Insert the fingerprint attribute.
  174.       InitAttrLine(kAttributeFingerprint, &os);
  175.       os << kSdpDelimiterColon << fp->algorithm << kSdpDelimiterSpace
  176.          << fp->GetRfc4572Fingerprint();
  177.       AddLine(os.str(), message);
  179.       // Inserting setup attribute.
  180.       if (transport_info->description.connection_role !=
  181.           cricket::CONNECTIONROLE_NONE) {
  182.         // Making sure we are not using "passive" mode.
  183.         cricket::ConnectionRole role =
  184.             transport_info->description.connection_role;
  185.         std::string dtls_role_str;
  186.         const bool success =
  187.             cricket::ConnectionRoleToString(role, &dtls_role_str);
  188.         RTC_DCHECK(success);
  189.         InitAttrLine(kAttributeSetup, &os);
  190.         os << kSdpDelimiterColon << dtls_role_str;
  191.         AddLine(os.str(), message);
  192.       }
  193.     }
  194.   }
  196.   // RFC 3388
  197.   // mid-attribute      = "a=mid:" identification-tag
  198.   // identification-tag = token
  199.   // Use the content name as the mid identification-tag.
  200.   InitAttrLine(kAttributeMid, &os);
  201.   os << kSdpDelimiterColon << content_info->name;
  202.   AddLine(os.str(), message);
  204.   if (cricket::IsDtlsSctp(media_desc->protocol())) {
  205.     const cricket::SctpDataContentDescription* data_desc =
  206.         media_desc->as_sctp();
  207.     BuildSctpContentAttributes(message, data_desc);
  208.   } else if (cricket::IsRtpProtocol(media_desc->protocol())) {
  209.     BuildRtpContentAttributes(media_desc, media_type, msid_signaling, message);
  210.   }
  211. }

BuildSctpContentAttributes
BuildRtpContentAttributes

BuildRtpContentAttributes

  1. void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
  2.                                const cricket::MediaType media_type,
  3.                                int msid_signaling,
  4.                                std::string* message) {
  5.   SdpSerializer serializer;
  6.   rtc::StringBuilder os;
  7.   // RFC 8285
  8.   // a=extmap-allow-mixed
  9.   // The attribute MUST be either on session level or media level. We support
  10.   // responding on both levels, however, we don't respond on media level if it's
  11.   // set on session level.
  12.   if (media_desc->extmap_allow_mixed_enum() ==
  13.       MediaContentDescription::kMedia) {
  14.     InitAttrLine(kAttributeExtmapAllowMixed, &os);
  15.     AddLine(os.str(), message);
  16.   }
  17.   // RFC 8285
  18.   // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
  19.   // The definitions MUST be either all session level or all media level. This
  20.   // implementation uses all media level.
  21.   for (size_t i = 0; i < media_desc->rtp_header_extensions().size(); ++i) {
  22.     const RtpExtension& extension = media_desc->rtp_header_extensions()[i];
  23.     InitAttrLine(kAttributeExtmap, &os);
  24.     os << kSdpDelimiterColon << extension.id;
  25.     if (extension.encrypt) {
  26.       os << kSdpDelimiterSpace << RtpExtension::kEncryptHeaderExtensionsUri;
  27.     }
  28.     os << kSdpDelimiterSpace << extension.uri;
  29.     AddLine(os.str(), message);
  30.   }
  32.   // RFC 3264
  33.   // a=sendrecv || a=sendonly || a=sendrecv || a=inactive
  34.   switch (media_desc->direction()) {
  35.     // Special case that for sdp purposes should be treated same as inactive.
  36.     case RtpTransceiverDirection::kStopped:
  37.     case RtpTransceiverDirection::kInactive:
  38.       InitAttrLine(kAttributeInactive, &os);
  39.       break;
  40.     case RtpTransceiverDirection::kSendOnly:
  41.       InitAttrLine(kAttributeSendOnly, &os);
  42.       break;
  43.     case RtpTransceiverDirection::kRecvOnly:
  44.       InitAttrLine(kAttributeRecvOnly, &os);
  45.       break;
  46.     case RtpTransceiverDirection::kSendRecv:
  47.       InitAttrLine(kAttributeSendRecv, &os);
  48.       break;
  49.     default:
  50.       RTC_NOTREACHED();
  51.       InitAttrLine(kAttributeSendRecv, &os);
  52.       break;
  53.   }
  54.     // 默认是sendrecv方式
  55.   AddLine(os.str(), message);
  57.   // Specified in https://datatracker.ietf.org/doc/draft-ietf-mmusic-msid/16/
  58.   // a=msid:<msid-id> <msid-appdata>
  59.   // The msid-id is a 1*64 token char representing the media stream id, and the
  60.   // msid-appdata is a 1*64 token char representing the track id. There is a
  61.   // line for every media stream, with a special msid-id value of "-"
  62.   // representing no streams. The value of "msid-appdata" MUST be identical for
  63.   // all lines.
  64.   if (msid_signaling & cricket::kMsidSignalingMediaSection) {
  65.     const StreamParamsVec& streams = media_desc->streams();
  66.     if (streams.size() == 1u) {
  67.       const StreamParams& track = streams[0];
  68.       std::vector<std::string> stream_ids = track.stream_ids();
  69.       if (stream_ids.empty()) {
  70.         stream_ids.push_back(kNoStreamMsid);
  71.       }
  72.       for (const std::string& stream_id : stream_ids) {
  73.         InitAttrLine(kAttributeMsid, &os);
  74.         os << kSdpDelimiterColon << stream_id << kSdpDelimiterSpace << track.id;
  75.         AddLine(os.str(), message);
  76.       }
  77.     } else if (streams.size() > 1u) {
  78.       RTC_LOG(LS_WARNING)
  79.           << "Trying to serialize Unified Plan SDP with more than "
  80.              "one track in a media section. Omitting 'a=msid'.";
  81.     }
  82.   }
  84.   // RFC 5761
  85.   // a=rtcp-mux
  86.   if (media_desc->rtcp_mux()) {
  87.     InitAttrLine(kAttributeRtcpMux, &os);
  88.     AddLine(os.str(), message);
  89.   }
  91.   // RFC 5506
  92.   // a=rtcp-rsize
  93.   if (media_desc->rtcp_reduced_size()) {
  94.     InitAttrLine(kAttributeRtcpReducedSize, &os);
  95.     AddLine(os.str(), message);
  96.   }
  98.   if (media_desc->conference_mode()) {
  99.     InitAttrLine(kAttributeXGoogleFlag, &os);
  100.     os << kSdpDelimiterColon << kValueConference;
  101.     AddLine(os.str(), message);
  102.   }
  104.   if (media_desc->remote_estimate()) {
  105.     InitAttrLine(kAttributeRtcpRemoteEstimate, &os);
  106.     AddLine(os.str(), message);
  107.   }
  109.   // RFC 4568
  110.   // a=crypto:<tag> <crypto-suite> <key-params> [<session-params>]
  111.   for (const CryptoParams& crypto_params : media_desc->cryptos()) {
  112.     InitAttrLine(kAttributeCrypto, &os);
  113.     os << kSdpDelimiterColon << crypto_params.tag << " "
  114.        << crypto_params.cipher_suite << " " << crypto_params.key_params;
  115.     if (!crypto_params.session_params.empty()) {
  116.       os << " " << crypto_params.session_params;
  117.     }
  118.     AddLine(os.str(), message);
  119.   }
  121.   // RFC 4566
  122.   // a=rtpmap:<payload type> <encoding name>/<clock rate>
  123.   // [/<encodingparameters>]
  124.   BuildRtpMap(media_desc, media_type, message);
  126.   for (const StreamParams& track : media_desc->streams()) {
  127.     // Build the ssrc-group lines.
  128.     for (const SsrcGroup& ssrc_group : track.ssrc_groups) {
  129.       // RFC 5576
  130.       // a=ssrc-group:<semantics> <ssrc-id> ...
  131.       if (ssrc_group.ssrcs.empty()) {
  132.         continue;
  133.       }
  134.       InitAttrLine(kAttributeSsrcGroup, &os);
  135.       os << kSdpDelimiterColon << ssrc_group.semantics;
  136.       for (uint32_t ssrc : ssrc_group.ssrcs) {
  137.         os << kSdpDelimiterSpace << rtc::ToString(ssrc);
  138.       }
  139.       AddLine(os.str(), message);
  140.     }
  141.     // Build the ssrc lines for each ssrc.
  142.     for (uint32_t ssrc : track.ssrcs) {
  143.       // RFC 5576
  144.       // a=ssrc:<ssrc-id> cname:<value>
  145.       AddSsrcLine(ssrc, kSsrcAttributeCname, track.cname, message);
  147.       if (msid_signaling & cricket::kMsidSignalingSsrcAttribute) {
  148.         // draft-alvestrand-mmusic-msid-00
  149.         // a=ssrc:<ssrc-id> msid:identifier [appdata]
  150.         // The appdata consists of the "id" attribute of a MediaStreamTrack,
  151.         // which corresponds to the "id" attribute of StreamParams.
  152.         // Since a=ssrc msid signaling is used in Plan B SDP semantics, and
  153.         // multiple stream ids are not supported for Plan B, we are only adding
  154.         // a line for the first media stream id here.
  155.         const std::string& track_stream_id = track.first_stream_id();
  156.         // We use a special msid-id value of "-" to represent no streams,
  157.         // for Unified Plan compatibility. Plan B will always have a
  158.         // track_stream_id.
  159.         const std::string& stream_id =
  160.             track_stream_id.empty() ? kNoStreamMsid : track_stream_id;
  161.         InitAttrLine(kAttributeSsrc, &os);
  162.         os << kSdpDelimiterColon << ssrc << kSdpDelimiterSpace
  163.            << kSsrcAttributeMsid << kSdpDelimiterColon << stream_id
  164.            << kSdpDelimiterSpace << track.id;
  165.         AddLine(os.str(), message);
  167.         // TODO(ronghuawu): Remove below code which is for backward
  168.         // compatibility.
  169.         // draft-alvestrand-rtcweb-mid-01
  170.         // a=ssrc:<ssrc-id> mslabel:<value>
  171.         // The label isn't yet defined.
  172.         // a=ssrc:<ssrc-id> label:<value>
  173.         AddSsrcLine(ssrc, kSsrcAttributeMslabel, stream_id, message);
  174.         AddSsrcLine(ssrc, kSSrcAttributeLabel, track.id, message);
  175.       }
  176.     }
  178.     // Build the rid lines for each layer of the track
  179.     for (const RidDescription& rid_description : track.rids()) {
  180.       InitAttrLine(kAttributeRid, &os);
  181.       os << kSdpDelimiterColon
  182.          << serializer.SerializeRidDescription(rid_description);
  183.       AddLine(os.str(), message);
  184.     }
  185.   }
  187.   for (const RidDescription& rid_description : media_desc->receive_rids()) {
  188.     InitAttrLine(kAttributeRid, &os);
  189.     os << kSdpDelimiterColon
  190.        << serializer.SerializeRidDescription(rid_description);
  191.     AddLine(os.str(), message);
  192.   }
  194.   // Simulcast (a=simulcast)
  195.   // https://tools.ietf.org/html/draft-ietf-mmusic-sdp-simulcast-13#section-5.1
  196.   if (media_desc->HasSimulcast()) {
  197.     const auto& simulcast = media_desc->simulcast_description();
  198.     InitAttrLine(kAttributeSimulcast, &os);
  199.     os << kSdpDelimiterColon
  200.        << serializer.SerializeSimulcastDescription(simulcast);
  201.     AddLine(os.str(), message);
  202.   }
  203. }

image.png
默认是sendrecv。