Let MediaSession generate a FlexFEC SSRC when FlexFEC is active.

webrtc/pc/mediasession.cc

 /*
  *  Copyright 2004 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 428 matching lines @@
     GenerateSsrcs(*current_streams, num_ssrcs, &ssrcs);
     if (include_rtx_streams) {
       content_description->AddLegacyStream(ssrcs[0], ssrcs[1]);
       content_description->set_multistream(true);
     } else {
       content_description->AddLegacyStream(ssrcs[0]);
     }
     return true;
   }
 
+  const bool include_flexfec_stream =
+      ContainsFlexfecCodec(content_description->codecs());
+
   MediaSessionOptions::Streams::const_iterator stream_it;
   for (stream_it = streams.begin();
        stream_it != streams.end(); ++stream_it) {
     if (stream_it->type != media_type)
       continue;  // Wrong media type.
 
     const StreamParams* param =
         GetStreamByIds(*current_streams, "", stream_it->id);
     // groupid is empty for StreamParams generated using
     // MediaSessionDescriptionFactory.
@@ skipping 15 matching lines @@
       if (include_rtx_streams) {
         // Generate an RTX ssrc for every ssrc in the group.
         std::vector<uint32_t> rtx_ssrcs;
         GenerateSsrcs(*current_streams, static_cast<int>(ssrcs.size()),
                       &rtx_ssrcs);
         for (size_t i = 0; i < ssrcs.size(); ++i) {
           stream_param.AddFidSsrc(ssrcs[i], rtx_ssrcs[i]);
         }
         content_description->set_multistream(true);
       }
+      // Generate extra ssrc for include_flexfec_stream case.
+      if (include_flexfec_stream) {
+        // TODO(brandtr): Update when we support multistream protection.
+        if (ssrcs.size() == 1) {
+          std::vector<uint32_t> flexfec_ssrcs;
+          GenerateSsrcs(*current_streams, 1, &flexfec_ssrcs);
+          stream_param.AddFecFrSsrc(ssrcs[0], flexfec_ssrcs[0]);
+          content_description->set_multistream(true);
+        } else if (!ssrcs.empty()) {
+          LOG(LS_WARNING)
+              << "Our FlexFEC implementation only supports protecting "
+              << "a single media streams. This session has multiple "
+              << "media streams however, so no FlexFEC SSRC will be generated.";
+        }
+      }
       stream_param.cname = options.rtcp_cname;
       stream_param.sync_label = stream_it->sync_label;
       content_description->AddStream(stream_param);
 
       // Store the new StreamParams in current_streams.
       // This is necessary so that we can use the CNAME for other media types.
       current_streams->push_back(stream_param);
     } else {
       content_description->AddStream(*param);
     }
@@ skipping 171 matching lines @@
         return false;
       }
       media_desc->set_cryptos(common_cryptos);
     }
   }
   return true;
 }
 
 template <class C>
 static bool ContainsRtxCodec(const std::vector<C>& codecs) {
-  typename std::vector<C>::const_iterator it;
-  for (it = codecs.begin(); it != codecs.end(); ++it) {
-    if (IsRtxCodec(*it)) {
+  for (const auto& codec : codecs) {
+    if (IsRtxCodec(codec)) {
       return true;
     }
   }
   return false;
 }
 
 template <class C>
 static bool IsRtxCodec(const C& codec) {
   return stricmp(codec.name.c_str(), kRtxCodecName) == 0;
 }
 
+template <class C>
+static bool ContainsFlexfecCodec(const std::vector<C>& codecs) {
+  for (const auto& codec : codecs) {
+    if (IsFlexfecCodec(codec)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+template <class C>
+static bool IsFlexfecCodec(const C& codec) {
+  return stricmp(codec.name.c_str(), kFlexfecCodecName) == 0;
+}
+
 static TransportOptions GetTransportOptions(const MediaSessionOptions& options,
                                             const std::string& content_name) {
   TransportOptions transport_options;
   auto it = options.transport_options.find(content_name);
   if (it != options.transport_options.end()) {
     transport_options = it->second;
   }
   transport_options.enable_ice_renomination = options.enable_ice_renomination;
   return transport_options;
 }
@@ skipping 1459 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 DataContentDescription* GetFirstDataContentDescription(
     SessionDescription* sdesc) {
   return static_cast<DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket