Implementing unified plan encoding of msid.

webrtc/api/webrtcsdp.cc

 /*
  *  Copyright 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 66 matching lines @@
 }
 
 namespace webrtc {
 
 // Line type
 // RFC 4566
 // An SDP session description consists of a number of lines of text of
 // the form:
 // <type>=<value>
 // where <type> MUST be exactly one case-significant character.
-static const int kLinePrefixLength = 2;  // Lenght of <type>=
+static const int kLinePrefixLength = 2;  // Length of <type>=
 static const char kLineTypeVersion = 'v';
 static const char kLineTypeOrigin = 'o';
 static const char kLineTypeSessionName = 's';
 static const char kLineTypeSessionInfo = 'i';
 static const char kLineTypeSessionUri = 'u';
 static const char kLineTypeSessionEmail = 'e';
 static const char kLineTypeSessionPhone = 'p';
 static const char kLineTypeSessionBandwidth = 'b';
 static const char kLineTypeTiming = 't';
 static const char kLineTypeRepeatTimes = 'r';
 static const char kLineTypeTimeZone = 'z';
 static const char kLineTypeEncryptionKey = 'k';
 static const char kLineTypeMedia = 'm';
 static const char kLineTypeConnection = 'c';
 static const char kLineTypeAttributes = 'a';
 
 // Attributes
 static const char kAttributeGroup[] = "group";
 static const char kAttributeMid[] = "mid";
+static const char kAttributeMsid[] = "msid";
 static const char kAttributeRtcpMux[] = "rtcp-mux";
 static const char kAttributeRtcpReducedSize[] = "rtcp-rsize";
 static const char kAttributeSsrc[] = "ssrc";
 static const char kSsrcAttributeCname[] = "cname";
 static const char kAttributeExtmap[] = "extmap";
 // draft-alvestrand-mmusic-msid-01
 // a=msid-semantic: WMS
 static const char kAttributeMsidSemantics[] = "msid-semantic";
 static const char kMediaStreamSemantic[] = "WMS";
 static const char kSsrcAttributeMsid[] = "msid";
@@ skipping 87 matching lines @@
 static const int kIsacSwbDefaultRate = 56000;  // From acm_common_defs.h
 
 static const char kDefaultSctpmapProtocol[] = "webrtc-datachannel";
 
 // RTP payload type is in the 0-127 range. Use -1 to indicate "all" payload
 // types.
 const int kWildcardPayloadType = -1;
 
 struct SsrcInfo {
   SsrcInfo()
-      : msid_identifier(kDefaultMsid),
-        // TODO(ronghuawu): What should we do if the appdata doesn't appear?
+      : stream_id(kDefaultMsid),
+        // TODO(ronghuawu): What should we do if the track id doesn't appear?
         // Create random string (which will be used as track label later)?
-        msid_appdata(rtc::CreateRandomString(8)) {
-  }
+        track_id(rtc::CreateRandomString(8)) {}
   uint32_t ssrc_id;
   std::string cname;
-  std::string msid_identifier;
-  std::string msid_appdata;
+  std::string stream_id;
+  std::string track_id;
 
   // For backward compatibility.
   // TODO(ronghuawu): Remove below 2 fields once all the clients support msid.
   std::string label;
   std::string mslabel;
 };
 typedef std::vector<SsrcInfo> SsrcInfoVec;
 typedef std::vector<SsrcGroup> SsrcGroupVec;
 
 template <class T>
 static void AddFmtpLine(const T& codec, std::string* message);
 static void BuildMediaDescription(const ContentInfo* content_info,
                                   const TransportInfo* transport_info,
                                   const MediaType media_type,
                                   const std::vector<Candidate>& candidates,
+                                  bool unified_plan_sdp,
                                   std::string* message);
 static void BuildSctpContentAttributes(std::string* message, int sctp_port);
-static void BuildRtpContentAttributes(
-    const MediaContentDescription* media_desc,
-    const MediaType media_type,
-    std::string* message);
+static void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
+                                      const MediaType media_type,
+                                      bool unified_plan_sdp,
+                                      std::string* message);
 static void BuildRtpMap(const MediaContentDescription* media_desc,
                         const MediaType media_type,
                         std::string* message);
 static void BuildCandidate(const std::vector<Candidate>& candidates,
                            bool include_ufrag,
                            std::string* message);
 static void BuildIceOptions(const std::vector<std::string>& transport_options,
                             std::string* message);
 static bool IsRtp(const std::string& protocol);
 static bool IsDtlsSctp(const std::string& protocol);
@@ skipping 56 matching lines @@
                             SdpParseError* error);
 static bool ParseExtmap(const std::string& line,
                         RtpHeaderExtension* extmap,
                         SdpParseError* error);
 static bool ParseFingerprintAttribute(const std::string& line,
                                       rtc::SSLFingerprint** fingerprint,
                                       SdpParseError* error);
 static bool ParseDtlsSetup(const std::string& line,
                            cricket::ConnectionRole* role,
                            SdpParseError* error);
+static bool ParseMsidAttribute(const std::string& line,
+                               std::string* stream_id,
+                               std::string* track_id,
+                               SdpParseError* error);
 
 // Helper functions
 
 // Below ParseFailed*** functions output the line that caused the parsing
 // failure and the detailed reason (|description|) of the failure to |error|.
 // The functions always return false so that they can be used directly in the
 // following way when error happens:
 // "return ParseFailed***(...);"
 
 // The line starting at |line_start| of |message| is the failing line.
@@ skipping 241 matching lines @@
                                StreamParamsVec* tracks) {
   ASSERT(tracks != NULL);
   for (SsrcInfoVec::const_iterator ssrc_info = ssrc_infos.begin();
        ssrc_info != ssrc_infos.end(); ++ssrc_info) {
     if (ssrc_info->cname.empty()) {
       continue;
     }
 
     std::string sync_label;
     std::string track_id;
-    if (ssrc_info->msid_identifier == kDefaultMsid &&
-        !ssrc_info->mslabel.empty()) {
+    if (ssrc_info->stream_id == kDefaultMsid && !ssrc_info->mslabel.empty()) {
       // If there's no msid and there's mslabel, we consider this is a sdp from
       // a older version of client that doesn't support msid.
       // In that case, we use the mslabel and label to construct the track.
       sync_label = ssrc_info->mslabel;
       track_id = ssrc_info->label;
     } else {
-      sync_label = ssrc_info->msid_identifier;
-      // The appdata consists of the "id" attribute of a MediaStreamTrack, which
-      // is corresponding to the "id" attribute of StreamParams.
-      track_id = ssrc_info->msid_appdata;
+      sync_label = ssrc_info->stream_id;
+      track_id = ssrc_info->track_id;
     }
     if (sync_label.empty() || track_id.empty()) {
       ASSERT(false);
       continue;
     }
 
     StreamParamsVec::iterator track = tracks->begin();
     for (; track != tracks->end(); ++track) {
       if (track->id == track_id) {
         break;
@@ skipping 165 matching lines @@
   if (!candidates) {
     return;
   }
   const IceCandidateCollection* cc = desci.candidates(mline_index);
   for (size_t i = 0; i < cc->count(); ++i) {
     const IceCandidateInterface* candidate = cc->at(i);
     candidates->push_back(candidate->candidate());
   }
 }
 
-std::string SdpSerialize(const JsepSessionDescription& jdesc) {
+std::string SdpSerialize(const JsepSessionDescription& jdesc,
+                         bool unified_plan_sdp) {
   const cricket::SessionDescription* desc = jdesc.description();
   if (!desc) {
     return "";
   }
 
   std::string message;
 
   // Session Description.
   AddLine(kSessionVersion, &message);
   // Session Origin
@@ skipping 50 matching lines @@
   AddLine(os.str(), &message);
 
   // Preserve the order of the media contents.
   int mline_index = -1;
   for (cricket::ContentInfos::const_iterator it = desc->contents().begin();
        it != desc->contents().end(); ++it) {
     const MediaContentDescription* mdesc =
       static_cast<const MediaContentDescription*>(it->description);
     std::vector<Candidate> candidates;
     GetCandidatesByMindex(jdesc, ++mline_index, &candidates);
-    BuildMediaDescription(&*it,
-                          desc->GetTransportInfoByName(it->name),
-                          mdesc->type(),
-                          candidates,
+    BuildMediaDescription(&*it, desc->GetTransportInfoByName(it->name),
+                          mdesc->type(), candidates, unified_plan_sdp,
                           &message);
   }
   return message;
 }
 
 // Serializes the passed in IceCandidateInterface to a SDP string.
 // candidate - The candidate to be serialized.
 std::string SdpSerializeCandidate(
     const IceCandidateInterface& candidate) {
   std::string message;
@@ skipping 285 matching lines @@
   }
 
   *extmap = RtpHeaderExtension(uri, value);
   return true;
 }
 
 void BuildMediaDescription(const ContentInfo* content_info,
                            const TransportInfo* transport_info,
                            const MediaType media_type,
                            const std::vector<Candidate>& candidates,
+                           bool unified_plan_sdp,
                            std::string* message) {
   ASSERT(message != NULL);
   if (content_info == NULL || message == NULL) {
     return;
   }
   // TODO: Rethink if we should use sprintfn instead of stringstream.
   // According to the style guide, streams should only be used for logging.
   // http://google-styleguide.googlecode.com/svn/
   // trunk/cppguide.xml?showone=Streams#Streams
   std::ostringstream os;
@@ skipping 155 matching lines @@
   // mid-attribute      = "a=mid:" identification-tag
   // identification-tag = token
   // Use the content name as the mid identification-tag.
   InitAttrLine(kAttributeMid, &os);
   os << kSdpDelimiterColon << content_info->name;
   AddLine(os.str(), message);
 
   if (IsDtlsSctp(media_desc->protocol())) {
     BuildSctpContentAttributes(message, sctp_port);
   } else if (IsRtp(media_desc->protocol())) {
-    BuildRtpContentAttributes(media_desc, media_type, message);
+    BuildRtpContentAttributes(media_desc, media_type, unified_plan_sdp,
+                              message);
   }
 }
 
 void BuildSctpContentAttributes(std::string* message, int sctp_port) {
   // draft-ietf-mmusic-sctp-sdp-04
   // a=sctpmap:sctpmap-number  protocol  [streams]
   // TODO(lally): switch this over to mmusic-sctp-sdp-12 (or later), with
   // 'a=sctp-port:'
   std::ostringstream os;
   InitAttrLine(kAttributeSctpmap, &os);
   os << kSdpDelimiterColon << sctp_port << kSdpDelimiterSpace
      << kDefaultSctpmapProtocol << kSdpDelimiterSpace
      << (cricket::kMaxSctpSid + 1);
   AddLine(os.str(), message);
 }
 
-void BuildRtpContentAttributes(
-    const MediaContentDescription* media_desc,
-    const MediaType media_type,
-    std::string* message) {
+// If unified_plan_sdp is true, will use "a=msid".
+void BuildRtpContentAttributes(const MediaContentDescription* media_desc,
+                               const MediaType media_type,
+                               bool unified_plan_sdp,
+                               std::string* message) {
   std::ostringstream os;
   // RFC 5285
   // a=extmap:<value>["/"<direction>] <URI> <extensionattributes>
   // The definitions MUST be either all session level or all media level. This
   // implementation uses all media level.
   for (size_t i = 0; i < media_desc->rtp_header_extensions().size(); ++i) {
     InitAttrLine(kAttributeExtmap, &os);
     os << kSdpDelimiterColon << media_desc->rtp_header_extensions()[i].id
        << kSdpDelimiterSpace << media_desc->rtp_header_extensions()[i].uri;
     AddLine(os.str(), message);
@@ skipping 11 matching lines @@
     case cricket::MD_RECVONLY:
       InitAttrLine(kAttributeRecvOnly, &os);
       break;
     case cricket::MD_SENDRECV:
     default:
       InitAttrLine(kAttributeSendRecv, &os);
       break;
   }
   AddLine(os.str(), message);
 
+  // draft-ietf-mmusic-msid-11
+  // a=msid:<stream id> <track id>
+  if (unified_plan_sdp && !media_desc->streams().empty()) {
+    if (media_desc->streams().size() > 1u) {
+      LOG(LS_WARNING) << "Trying to serialize unified plan SDP with more than "
+                      << "one track in a media section. Omitting 'a=msid'.";
+    } else {
+      auto track = media_desc->streams().begin();
+      const std::string& stream_id = track->sync_label;
+      std::ostringstream os;

[brucedawson, 2016/02/19 19:23:39]

Unnecessarily duplicated variable, also variable shadowing.

+      InitAttrLine(kAttributeMsid, &os);
+      os << kSdpDelimiterColon << stream_id << kSdpDelimiterSpace << track->id;
+      AddLine(os.str(), message);
+    }
+  }
+
   // RFC 5761
   // a=rtcp-mux
   if (media_desc->rtcp_mux()) {
     InitAttrLine(kAttributeRtcpMux, &os);
     AddLine(os.str(), message);
   }
 
   // RFC 5506
   // a=rtcp-rsize
   if (media_desc->rtcp_reduced_size()) {
@@ skipping 28 matching lines @@
     // if no track or media stream have been created.
     if (track->sync_label.empty()) continue;
 
     // Build the ssrc-group lines.
     for (size_t i = 0; i < track->ssrc_groups.size(); ++i) {
       // RFC 5576
       // a=ssrc-group:<semantics> <ssrc-id> ...
       if (track->ssrc_groups[i].ssrcs.empty()) {
         continue;
       }
       std::ostringstream os;

[brucedawson, 2016/02/19 19:23:39]

Ditto (but not from this CL).

       InitAttrLine(kAttributeSsrcGroup, &os);
       os << kSdpDelimiterColon << track->ssrc_groups[i].semantics;
       std::vector<uint32_t>::const_iterator ssrc =
           track->ssrc_groups[i].ssrcs.begin();
       for (; ssrc != track->ssrc_groups[i].ssrcs.end(); ++ssrc) {
         os << kSdpDelimiterSpace << rtc::ToString<uint32_t>(*ssrc);
       }
       AddLine(os.str(), message);
     }
     // Build the ssrc lines for each ssrc.
     for (size_t i = 0; i < track->ssrcs.size(); ++i) {
       uint32_t ssrc = track->ssrcs[i];
       // RFC 5576
       // a=ssrc:<ssrc-id> cname:<value>
       AddSsrcLine(ssrc, kSsrcAttributeCname,
                   track->cname, message);
 
       // draft-alvestrand-mmusic-msid-00
       // a=ssrc:<ssrc-id> msid:identifier [appdata]
-      // The appdata consists of the "id" attribute of a MediaStreamTrack, which
-      // is corresponding to the "name" attribute of StreamParams.
-      std::string appdata = track->id;
+      // The appdata consists of the "id" attribute of a MediaStreamTrack,
+      // which corresponds to the "id" attribute of StreamParams.
+      const std::string& stream_id = track->sync_label;
       std::ostringstream os;

[brucedawson, 2016/02/19 19:23:39]

Ditto (but not from this CL).

       InitAttrLine(kAttributeSsrc, &os);
       os << kSdpDelimiterColon << ssrc << kSdpDelimiterSpace
-         << kSsrcAttributeMsid << kSdpDelimiterColon << track->sync_label
-         << kSdpDelimiterSpace << appdata;
+         << kSsrcAttributeMsid << kSdpDelimiterColon << stream_id
+         << kSdpDelimiterSpace << track->id;
       AddLine(os.str(), message);
 
-      // TODO(ronghuawu): Remove below code which is for backward compatibility.
+      // TODO(ronghuawu): Remove below code which is for backward
+      // compatibility.
       // draft-alvestrand-rtcweb-mid-01
       // a=ssrc:<ssrc-id> mslabel:<value>
       // The label isn't yet defined.
       // a=ssrc:<ssrc-id> label:<value>
       AddSsrcLine(ssrc, kSsrcAttributeMslabel, track->sync_label, message);
       AddSsrcLine(ssrc, kSSrcAttributeLabel, track->id, message);
     }
   }
 }
 
@@ skipping 541 matching lines @@
   if (fields.size() != expected_fields) {
     return ParseFailedExpectFieldNum(line, expected_fields, error);
   }
   std::string role_str = fields[1];
   if (!cricket::StringToConnectionRole(role_str, role)) {
     return ParseFailed(line, "Invalid attribute value.", error);
   }
   return true;
 }
 
+static bool ParseMsidAttribute(const std::string& line,
+                               std::string* stream_id,
+                               std::string* track_id,
+                               SdpParseError* error) {
+  // draft-ietf-mmusic-msid-11
+  // a=msid:<stream id> <track id>
+  // msid-value = msid-id [ SP msid-appdata ]
+  // msid-id = 1*64token-char ; see RFC 4566
+  // msid-appdata = 1*64token-char  ; see RFC 4566
+  std::string field1;
+  if (!rtc::tokenize_first(line.substr(kLinePrefixLength), kSdpDelimiterSpace,
+                           &field1, track_id)) {
+    const size_t expected_fields = 2;
+    return ParseFailedExpectFieldNum(line, expected_fields, error);
+  }
+
+  // msid:<msid-id>
+  if (!GetValue(field1, kAttributeMsid, stream_id, error)) {
+    return false;
+  }
+  return true;
+}
+
 // RFC 3551
 //  PT   encoding    media type  clock rate   channels
 //                      name                    (Hz)
 //  0    PCMU        A            8,000       1
 //  1    reserved    A
 //  2    reserved    A
 //  3    GSM         A            8,000       1
 //  4    G723        A            8,000       1
 //  5    DVI4        A            8,000       1
 //  6    DVI4        A           16,000       1
@@ skipping 404 matching lines @@
   // The candidates before update the media level "ice-pwd" and "ice-ufrag".
   Candidates candidates_orig;
   std::string line;
   std::string mline_id;
   // Tracks created out of the ssrc attributes.
   StreamParamsVec tracks;
   SsrcInfoVec ssrc_infos;
   SsrcGroupVec ssrc_groups;
   std::string maxptime_as_string;
   std::string ptime_as_string;
+  std::string stream_id;
+  std::string track_id;
 
   // Loop until the next m line
   while (!IsLineType(message, kLineTypeMedia, *pos)) {
     if (!GetLine(message, pos, &line)) {
       if (*pos >= message.size()) {
         break;  // Done parsing
       } else {
         return ParseFailed(message, *pos, "Invalid SDP line.", error);
       }
     }
@@ skipping 139 matching lines @@
       } else if (HasAttribute(line, kAttributeXGoogleFlag)) {
         // Experimental attribute.  Conference mode activates more aggressive
         // AEC and NS settings.
         // TODO: expose API to set these directly.
         std::string flag_value;
         if (!GetValue(line, kAttributeXGoogleFlag, &flag_value, error)) {
           return false;
         }
         if (flag_value.compare(kValueConference) == 0)
           media_desc->set_conference_mode(true);
+      } else if (HasAttribute(line, kAttributeMsid)) {
+        if (!ParseMsidAttribute(line, &stream_id, &track_id, error)) {
+          return false;
+        }
       }
     } else {
       // Only parse lines that we are interested of.
       LOG(LS_INFO) << "Ignored line: " << line;
       continue;
     }
   }
 
+  // Found an msid attribute.
+  // Setting the stream_id/track_id will cause only one StreamParams
+  // to be created in CreateTracksFromSsrcInfos, containing all the SSRCs from
+  // the m= section.
+  if (!stream_id.empty() && !track_id.empty()) {
+    for (SsrcInfo& ssrc_info : ssrc_infos) {
+      ssrc_info.stream_id = stream_id;
+      ssrc_info.track_id = track_id;
+    }
+  }
+
   // Create tracks from the |ssrc_infos|.
   CreateTracksFromSsrcInfos(ssrc_infos, &tracks);
 
   // Add the ssrc group to the track.
   for (SsrcGroupVec::iterator ssrc_group = ssrc_groups.begin();
        ssrc_group != ssrc_groups.end(); ++ssrc_group) {
     if (ssrc_group->ssrcs.empty()) {
       continue;
     }
     uint32_t ssrc = ssrc_group->ssrcs.front();
     for (StreamParamsVec::iterator track = tracks.begin();
          track != tracks.end(); ++track) {
       if (track->has_ssrc(ssrc)) {
         track->ssrc_groups.push_back(*ssrc_group);
       }
     }
   }
 
   // Add the new tracks to the |media_desc|.
-  for (StreamParamsVec::iterator track = tracks.begin();
-       track != tracks.end(); ++track) {
-    media_desc->AddStream(*track);
+  for (StreamParams& track : tracks) {
+    media_desc->AddStream(track);
   }
 
   if (media_type == cricket::MEDIA_TYPE_AUDIO) {
     AudioContentDescription* audio_desc =
         static_cast<AudioContentDescription*>(media_desc);
     UpdateFromWildcardCodecs(audio_desc);
 
     // Verify audio codec ensures that no audio codec has been populated with
     // only fmtp.
     if (!VerifyAudioCodecs(audio_desc)) {
@@ skipping 84 matching lines @@
   } else if (attribute == kSsrcAttributeMsid) {
     // draft-alvestrand-mmusic-msid-00
     // "msid:" identifier [ " " appdata ]
     std::vector<std::string> fields;
     rtc::split(value, kSdpDelimiterSpace, &fields);
     if (fields.size() < 1 || fields.size() > 2) {
       return ParseFailed(line,
                          "Expected format \"msid:<identifier>[ <appdata>]\".",
                          error);
     }
-    ssrc_info->msid_identifier = fields[0];
+    ssrc_info->stream_id = fields[0];
     if (fields.size() == 2) {
-      ssrc_info->msid_appdata = fields[1];
+      ssrc_info->track_id = fields[1];
     }
   } else if (attribute == kSsrcAttributeMslabel) {
     // draft-alvestrand-rtcweb-mid-01
     // mslabel:<value>
     ssrc_info->mslabel = value;
   } else if (attribute == kSSrcAttributeLabel) {
     // The label isn't defined.
     // label:<value>
     ssrc_info->label = value;
   }
@@ skipping 302 matching lines @@
     UpdateCodec<AudioContentDescription, cricket::AudioCodec>(
         media_desc, payload_type, feedback_param);
   } else if (media_type == cricket::MEDIA_TYPE_VIDEO) {
     UpdateCodec<VideoContentDescription, cricket::VideoCodec>(
         media_desc, payload_type, feedback_param);
   }
   return true;
 }
 
 }  // namespace webrtc