Don't send FEC for H.264 with NACK enabled.

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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 89 matching lines @@
   ss << ", render_delay_ms: " << render_delay_ms;
   ss << ", target_delay_ms: " << target_delay_ms;
   ss << ", suspend_below_min_bitrate: " << (suspend_below_min_bitrate ? "on"
                                                                       : "off");
   ss << '}';
   return ss.str();
 }
 
 namespace {
 
+VideoCodecType PayloadNameToCodecType(const std::string& payload_name) {
+  if (payload_name == "VP8")
+    return kVideoCodecVP8;
+  if (payload_name == "VP9")
+    return kVideoCodecVP9;
+  if (payload_name == "H264")
+    return kVideoCodecH264;
+  return kVideoCodecGeneric;
+}
+
+bool PayloadTypeSupportsSkippingFecPackets(const std::string& payload_name) {
+  switch (PayloadNameToCodecType(payload_name)) {
+    case kVideoCodecVP8:
+    case kVideoCodecVP9:
+      return true;
+    case kVideoCodecH264:
+    case kVideoCodecGeneric:
+      return false;
+    case kVideoCodecI420:
+    case kVideoCodecRED:
+    case kVideoCodecULPFEC:
+    case kVideoCodecUnknown:
+      RTC_NOTREACHED();
+      return false;
+  }
+  RTC_NOTREACHED();
+  return false;
+}
+
 CpuOveruseOptions GetCpuOveruseOptions(bool full_overuse_time) {
   CpuOveruseOptions options;
   if (full_overuse_time) {
     options.low_encode_usage_threshold_percent = 100;
     options.high_encode_usage_threshold_percent = 120;
   }
   return options;
 }
 }  // namespace
 
@@ skipping 88 matching lines @@
       RTC_NOTREACHED() << "Registering unsupported RTP extension.";
     }
   }
 
   RtpRtcp* rtp_module = vie_channel_.rtp_rtcp();
   remb_->AddRembSender(rtp_module);
   rtp_module->SetREMBStatus(true);
 
   // Enable NACK, FEC or both.
   const bool enable_protection_nack = config_.rtp.nack.rtp_history_ms > 0;
-  const bool enable_protection_fec = config_.rtp.fec.red_payload_type != -1;
+  bool enable_protection_fec = config_.rtp.fec.red_payload_type != -1;
+  // Payload types without picture ID cannot determine that a stream is complete
+  // without retransmitting FEC, so using FEC + NACK for H.264 (for instance) is
+  // a waste of bandwidth since FEC packets still have to be transmitted. Note
+  // that this is not the case with FLEXFEC.
+  if (enable_protection_nack &&
+      !PayloadTypeSupportsSkippingFecPackets(
+          config_.encoder_settings.payload_name)) {
+    LOG(LS_WARNING) << "Transmitting payload type without picture ID using"
+                       "NACK+FEC is a waste of bandwidth since FEC packets "
+                       "also have to be retransmitted. Disabling FEC.";
+    enable_protection_fec = false;
+  }
   // TODO(changbin): Should set RTX for RED mapping in RTP sender in future.
   vie_channel_.SetProtectionMode(enable_protection_nack, enable_protection_fec,
                                   config_.rtp.fec.red_payload_type,
                                   config_.rtp.fec.ulpfec_payload_type);
   vie_encoder_.SetProtectionMethod(enable_protection_nack,
                                     enable_protection_fec);
 
   ConfigureSsrcs();
 
   vie_channel_.SetRTCPCName(config_.rtp.c_name.c_str());
@@ skipping 88 matching lines @@
 bool VideoSendStream::ReconfigureVideoEncoder(
     const VideoEncoderConfig& config) {
   TRACE_EVENT0("webrtc", "VideoSendStream::(Re)configureVideoEncoder");
   LOG(LS_INFO) << "(Re)configureVideoEncoder: " << config.ToString();
   const std::vector<VideoStream>& streams = config.streams;
   RTC_DCHECK(!streams.empty());
   RTC_DCHECK_GE(config_.rtp.ssrcs.size(), streams.size());
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
-  if (config_.encoder_settings.payload_name == "VP8") {
-    video_codec.codecType = kVideoCodecVP8;
-  } else if (config_.encoder_settings.payload_name == "VP9") {
-    video_codec.codecType = kVideoCodecVP9;
-  } else if (config_.encoder_settings.payload_name == "H264") {
-    video_codec.codecType = kVideoCodecH264;
-  } else {
-    video_codec.codecType = kVideoCodecGeneric;
-  }
+  video_codec.codecType =
+      PayloadNameToCodecType(config_.encoder_settings.payload_name);
 
   switch (config.content_type) {
     case VideoEncoderConfig::ContentType::kRealtimeVideo:
       video_codec.mode = kRealtimeVideo;
       break;
     case VideoEncoderConfig::ContentType::kScreen:
       video_codec.mode = kScreensharing;
       if (config.streams.size() == 1 &&
           config.streams[0].temporal_layer_thresholds_bps.size() == 1) {
         video_codec.targetBitrate =
@@ skipping 252 matching lines @@
   used_ssrcs.resize(static_cast<size_t>(video_codec.numberOfSimulcastStreams));
   vie_encoder_.SetSsrcs(used_ssrcs);
 
   // Restart the media flow
   vie_encoder_.Restart();
 
   return true;
 }
 }  // namespace internal
 }  // namespace webrtc