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

webrtc/video/vie_encoder.cc

 /*
  *  Copyright (c) 2012 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 27 matching lines @@
     return kVideoCodecVP9;
   if (payload_name == "H264")
     return kVideoCodecH264;
   return kVideoCodecGeneric;
 }
 
 VideoCodec 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);
 
   switch (config.content_type) {
     case VideoEncoderConfig::ContentType::kRealtimeVideo:
@@ 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.codecSpecific.VP8 = VideoEncoder::GetDefaultVp8Settings();
       video_codec.codecSpecific.VP8.numberOfTemporalLayers =
           static_cast<unsigned char>(
               streams.back().temporal_layer_thresholds_bps.size() + 1);
+      // Turn error resilience off for single stream and no temporal layers when
+      // nack is enabled.
+      if (nack_enabled && streams.size() == 1 &&

[stefan-webrtc, 2016/11/15 08:48:47]

Why only for single stream?

[marpan, 2016/11/15 17:38:23]

No need for single stream condition, can also be used for
simulcast/stream.size() > 1.

[åsapersson, 2016/11/17 15:30:50]

Removed single stream check.

[åsapersson, 2016/11/17 15:30:50]

Done.

+          video_codec.codecSpecific.VP8.numberOfTemporalLayers == 1) {
+        video_codec.codecSpecific.VP8.resilience = kResilienceOff;
+      }
       break;
     }
     case kVideoCodecVP9: {

[marpan, 2016/11/15 17:38:23]

Same can also be done with VP9 (for #spatial_layers=1, #temporal_layers=1),
maybe that will done in separate CL?

[åsapersson, 2016/11/17 15:30:50]

Will do the same for VP9 in a separate CL.

       if (!config.encoder_specific_settings)
         video_codec.codecSpecific.VP9 = VideoEncoder::GetDefaultVp9Settings();
       if (video_codec.mode == kScreensharing &&
           config.encoder_specific_settings) {
         video_codec.codecSpecific.VP9.flexibleMode = true;
         // For now VP9 screensharing use 1 temporal and 2 spatial layers.
         RTC_DCHECK_EQ(1, video_codec.codecSpecific.VP9.numberOfTemporalLayers);
         RTC_DCHECK_EQ(2, video_codec.codecSpecific.VP9.numberOfSpatialLayers);
       }
       video_codec.codecSpecific.VP9.numberOfTemporalLayers =
@@ skipping 91 matching lines @@
   }
   return options;
 }
 
 }  //  namespace
 
 class ViEEncoder::ConfigureEncoderTask : public rtc::QueuedTask {
  public:
   ConfigureEncoderTask(ViEEncoder* vie_encoder,
                        VideoEncoderConfig config,
-                       size_t max_data_payload_length)
+                       size_t max_data_payload_length,
+                       bool nack_enabled)
       : vie_encoder_(vie_encoder),
         config_(std::move(config)),
-        max_data_payload_length_(max_data_payload_length) {}
+        max_data_payload_length_(max_data_payload_length),
+        nack_enabled_(nack_enabled) {}
 
  private:
   bool Run() override {
-    vie_encoder_->ConfigureEncoderOnTaskQueue(std::move(config_),
-                                              max_data_payload_length_);
+    vie_encoder_->ConfigureEncoderOnTaskQueue(
+        std::move(config_), max_data_payload_length_, nack_enabled_);
     return true;
   }
 
   ViEEncoder* const vie_encoder_;
   VideoEncoderConfig config_;
   size_t max_data_payload_length_;
+  bool nack_enabled_;
 };
 
 class ViEEncoder::EncodeTask : public rtc::QueuedTask {
  public:
   EncodeTask(const VideoFrame& frame,
              ViEEncoder* vie_encoder,
              int64_t time_when_posted_in_ms,
              bool log_stats)
       : vie_encoder_(vie_encoder),
         time_when_posted_ms_(time_when_posted_in_ms),
@@ skipping 158 matching lines @@
                         GetCpuOveruseOptions(settings.full_overuse_time),
                         this,
                         encoder_timing,
                         stats_proxy),
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),
       module_process_thread_(nullptr),
       pending_encoder_reconfiguration_(false),
       encoder_start_bitrate_bps_(0),
       max_data_payload_length_(0),
+      nack_enabled_(false),
       last_observed_bitrate_bps_(0),
       encoder_paused_and_dropped_frame_(false),
       has_received_sli_(false),
       picture_id_sli_(0),
       has_received_rpsi_(false),
       picture_id_rpsi_(0),
       clock_(Clock::GetRealTimeClock()),
       degradation_preference_(
           VideoSendStream::DegradationPreference::kBalanced),
       cpu_restricted_counter_(0),
@@ skipping 77 matching lines @@
 }
 
 void ViEEncoder::SetStartBitrate(int start_bitrate_bps) {
   encoder_queue_.PostTask([this, start_bitrate_bps] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     encoder_start_bitrate_bps_ = start_bitrate_bps;
   });
 }
 
 void ViEEncoder::ConfigureEncoder(VideoEncoderConfig config,
-                                  size_t max_data_payload_length) {
+                                  size_t max_data_payload_length,
+                                  bool nack_enabled) {
   encoder_queue_.PostTask(
       std::unique_ptr<rtc::QueuedTask>(new ConfigureEncoderTask(
-          this, std::move(config), max_data_payload_length)));
+          this, std::move(config), max_data_payload_length, nack_enabled)));
 }
 
 void ViEEncoder::ConfigureEncoderOnTaskQueue(VideoEncoderConfig config,
-                                             size_t max_data_payload_length) {
+                                             size_t max_data_payload_length,
+                                             bool nack_enabled) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   RTC_DCHECK(sink_);
   LOG(LS_INFO) << "ConfigureEncoder requested.";
 
   max_data_payload_length_ = max_data_payload_length;
+  nack_enabled_ = nack_enabled;
   encoder_config_ = std::move(config);
   pending_encoder_reconfiguration_ = true;
 
   // Reconfigure the encoder now if the encoder has an internal source or
   // if the frame resolution is known. Otherwise, the reconfiguration is
   // deferred until the next frame to minimize the number of reconfigurations.
   // The codec configuration depends on incoming video frame size.
   if (last_frame_info_) {
     ReconfigureEncoder();
   } else if (settings_.internal_source) {
     last_frame_info_ = rtc::Optional<VideoFrameInfo>(
         VideoFrameInfo(176, 144, kVideoRotation_0, false));
     ReconfigureEncoder();
   }
 }
 
 void ViEEncoder::ReconfigureEncoder() {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   RTC_DCHECK(pending_encoder_reconfiguration_);
   std::vector<VideoStream> streams =
       encoder_config_.video_stream_factory->CreateEncoderStreams(
           last_frame_info_->width, last_frame_info_->height, encoder_config_);
 
   VideoCodec codec = VideoEncoderConfigToVideoCodec(
-      encoder_config_, streams, settings_.payload_name, settings_.payload_type);
+      encoder_config_, streams, settings_.payload_name, settings_.payload_type,
+      nack_enabled_);
 
   codec.startBitrate =
       std::max(encoder_start_bitrate_bps_ / 1000, codec.minBitrate);
   codec.startBitrate = std::min(codec.startBitrate, codec.maxBitrate);
   codec.expect_encode_from_texture = last_frame_info_->is_texture;
 
   bool success = video_sender_.RegisterSendCodec(
                      &codec, number_of_cores_,
                      static_cast<uint32_t>(max_data_payload_length_)) == VCM_OK;
   if (!success) {
@@ skipping 291 matching lines @@
       current_pixel_count > *max_pixel_count_step_up_) {
     max_pixel_count_ = rtc::Optional<int>();
     max_pixel_count_step_up_ = rtc::Optional<int>(current_pixel_count);
     --cpu_restricted_counter_;
     stats_proxy_->OnCpuRestrictedResolutionChanged(cpu_restricted_counter_ > 0);
     source_proxy_->RequestHigherResolutionThan(current_pixel_count);
   }
 }
 
 }  // namespace webrtc