Turn off error resilience for vp8 for no temporal layers if nack is enabled.

webrtc/modules/video_coding/video_codec_initializer.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
 #include "webrtc/modules/video_coding/include/video_codec_initializer.h"
 
 #include "webrtc/base/basictypes.h"
+#include "webrtc/base/logging.h"
 #include "webrtc/common_video/include/video_bitrate_allocator.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/video_coding/codecs/vp8/screenshare_layers.h"
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/utility/simulcast_rate_allocator.h"
 #include "webrtc/modules/video_coding/utility/default_video_bitrate_allocator.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 bool VideoCodecInitializer::SetupCodec(
     const VideoEncoderConfig& config,
     const VideoSendStream::Config::EncoderSettings settings,
     const std::vector<VideoStream>& streams,
+    bool nack_enabled,
     VideoCodec* codec,
     std::unique_ptr<VideoBitrateAllocator>* bitrate_allocator) {
-  *codec = VideoEncoderConfigToVideoCodec(
-      config, streams, settings.payload_name, settings.payload_type);
+  *codec =
+      VideoEncoderConfigToVideoCodec(config, streams, settings.payload_name,
+                                     settings.payload_type, nack_enabled);
 
   std::unique_ptr<TemporalLayersFactory> tl_factory;
   switch (codec->codecType) {
     case kVideoCodecVP8: {
       if (!codec->VP8()->tl_factory) {
         if (codec->mode == kScreensharing &&
             codec->numberOfSimulcastStreams == 1 &&
             codec->VP8()->numberOfTemporalLayers == 2) {
           // Conference mode temporal layering for screen content.
           tl_factory.reset(new ScreenshareTemporalLayersFactory());
@@ skipping 33 matching lines @@
   }
 
   return rate_allocator;
 }
 
 // TODO(sprang): Split this up and separate the codec specific parts.
 VideoCodec VideoCodecInitializer::VideoEncoderConfigToVideoCodec(
     const VideoEncoderConfig& config,
     const std::vector<VideoStream>& streams,
     const std::string& payload_name,
-    int payload_type) {
+    int payload_type,
+    bool nack_enabled) {
   static const int kEncoderMinBitrateKbps = 30;
   RTC_DCHECK(!streams.empty());
   RTC_DCHECK_GE(config.min_transmit_bitrate_bps, 0);
 
   VideoCodec video_codec;
   memset(&video_codec, 0, sizeof(video_codec));
   video_codec.codecType = PayloadNameToCodecType(payload_name)
                               .value_or(VideoCodecType::kVideoCodecGeneric);
 
   switch (config.content_type) {
@@ skipping 12 matching lines @@
 
   if (config.encoder_specific_settings)
     config.encoder_specific_settings->FillEncoderSpecificSettings(&video_codec);
 
   switch (video_codec.codecType) {
     case kVideoCodecVP8: {
       if (!config.encoder_specific_settings)
         *video_codec.VP8() = VideoEncoder::GetDefaultVp8Settings();
       video_codec.VP8()->numberOfTemporalLayers = static_cast<unsigned char>(
           streams.back().temporal_layer_thresholds_bps.size() + 1);
+      bool temporal_layers_configured = false;
+      for (const VideoStream& stream : streams) {
+        if (stream.temporal_layer_thresholds_bps.size() > 0)
+          temporal_layers_configured = true;
+      }
+      if (nack_enabled && !temporal_layers_configured) {
+        LOG(LS_INFO) << "No temporal layers and nack enabled -> resilience off";
+        video_codec.VP8()->resilience = kResilienceOff;
+      }
       break;
     }
     case kVideoCodecVP9: {
       if (!config.encoder_specific_settings)
         *video_codec.VP9() = VideoEncoder::GetDefaultVp9Settings();
       if (video_codec.mode == kScreensharing &&
           config.encoder_specific_settings) {
         video_codec.VP9()->flexibleMode = true;
         // For now VP9 screensharing use 1 temporal and 2 spatial layers.
         RTC_DCHECK_EQ(1, video_codec.VP9()->numberOfTemporalLayers);
@@ skipping 75 matching lines @@
   }
   if (video_codec.maxBitrate < kEncoderMinBitrateKbps)
     video_codec.maxBitrate = kEncoderMinBitrateKbps;
 
   RTC_DCHECK_GT(streams[0].max_framerate, 0);
   video_codec.maxFramerate = streams[0].max_framerate;
   return video_codec;
 }
 
 }  // namespace webrtc