Implementing unified plan encoding of msid.

talk/app/webrtc/webrtcsdp.cc

 /*
  * libjingle
  * Copyright 2011 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 83 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 111 matching lines @@
 };
 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 438 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'.";

[Taylor Brandstetter, 2016/02/12 02:20:10]

You may ask "why not throw an exception/return a warning here?", but this could
happen if you theoretically deserialize a Plan B description, then try to
serialize it as unified plan.

[pthatcher1, 2016/02/12 03:54:35]

Should we at least serialize the first media description, then?

[Taylor Brandstetter, 2016/02/12 20:44:57]

We do.

+    } else {
+      auto track = media_desc->streams().begin();
+      std::string appdata = track->id;

[pthatcher1, 2016/02/12 03:54:34]

1.  Why is this "appdata" instead of track_id?
2.  Why are you copying it?  Why not just use track->id below?
3.  Why not do "const std::string& stream_id = track->sync_label" to make it
more readable?

[Taylor Brandstetter, 2016/02/12 20:44:57]

1. That's what the code below does for the SSRC line. I assumed there was a
reason.
2. Same as above.
3. Same as above.

I cleaned it up in both places.

+      std::ostringstream os;
+      InitAttrLine(kAttributeMsid, &os);
+      os << kSdpDelimiterColon << track->sync_label << kSdpDelimiterSpace
+         << appdata;
+      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 48 matching lines @@
     // 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.
+      // The appdata consists of the "id" attribute of a MediaStreamTrack,
+      // which corresponds to the "id" attribute of StreamParams.
       std::string appdata = track->id;
       std::ostringstream os;
       InitAttrLine(kAttributeSsrc, &os);
       os << kSdpDelimiterColon << ssrc << kSdpDelimiterSpace
          << kSsrcAttributeMsid << kSdpDelimiterColon << track->sync_label
          << kSdpDelimiterSpace << appdata;
       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) {
+  // msid-value = msid-id [ SP msid-appdata ]
+  // msid-id = 1*64token-char ; see RFC 4566
+  // msid-appdata = 1*64token-char  ; see RFC 4566

[pthatcher1, 2016/02/12 03:54:34]

The parsing code and the serializing code don't seem to have the same comment. 
I think the other one was more clear.

[Taylor Brandstetter, 2016/02/12 20:44:56]

Again, was just copying the way it was done elsewhere. I included the other
comment, but kept this one, since it's how the attribute is actually defined in
the spec.

+  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 msid_identifier/msid_appdata will cause only one StreamParams
+  // to be created, containing all the SSRCs from the m= section.
+  if (!stream_id.empty() && !track_id.empty()) {
+    for (SsrcInfo& ssrc_info : ssrc_infos) {
+      ssrc_info.msid_identifier = stream_id;
+      ssrc_info.msid_appdata = track_id;

[pthatcher1, 2016/02/12 03:54:34]

Can we rename ssrc_info.msid_identifier and .msid_appdata to .stream_id and
.track_id?  It seems like it would make a lot more sense.

[Taylor Brandstetter, 2016/02/12 20:44:56]

Done.

+    }

[pthatcher1, 2016/02/12 03:54:35]

Do we need to merge all of the ssrc_infos into one big ssrc_info or does
CreateTracksFromSsrcInfos take care of that?  If it does, can you put a comment
here explaining so?

[Taylor Brandstetter, 2016/02/12 20:44:56]

Yes, CreateTracksFromSsrcInfos does that. I meant for the comment above to
convey that, but I made it more clear.

+  }
+
   // 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 409 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