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

webrtc/video/vie_encoder.cc

Index: webrtc/video/vie_encoder.cc
diff --git a/webrtc/video/vie_encoder.cc b/webrtc/video/vie_encoder.cc
index 7cc799a644058291dd577927b47af91e6cf5c85c..7506909b803636f55c25941dbe1a49b065a51b15 100644
--- a/webrtc/video/vie_encoder.cc
+++ b/webrtc/video/vie_encoder.cc
@@ -45,7 +45,8 @@ 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);
@@ -78,6 +79,12 @@ VideoCodec VideoEncoderConfigToVideoCodec(
       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.

@@ -192,21 +199,24 @@ 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 {
@@ -385,6 +395,7 @@ ViEEncoder::ViEEncoder(uint32_t number_of_cores,
       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),
@@ -482,19 +493,22 @@ void ViEEncoder::SetStartBitrate(int 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;
 
@@ -519,7 +533,8 @@ void ViEEncoder::ReconfigureEncoder() {
           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);