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

webrtc/video/vie_encoder_unittest.cc

Index: webrtc/video/vie_encoder_unittest.cc
diff --git a/webrtc/video/vie_encoder_unittest.cc b/webrtc/video/vie_encoder_unittest.cc
index 895109773f16a0837742c6730e2523143f3d1afb..b632edf9003f111998e836039015089813791430 100644
--- a/webrtc/video/vie_encoder_unittest.cc
+++ b/webrtc/video/vie_encoder_unittest.cc
@@ -23,6 +23,9 @@
 namespace webrtc {
 
 namespace {
+const size_t kMaxPayloadLength = 1440;
+const int kTargetBitrateBps = 100000;
+
 class TestBuffer : public webrtc::I420Buffer {
  public:
   TestBuffer(rtc::Event* event, int width, int height)
@@ -67,6 +70,29 @@ class ViEEncoderUnderTest : public ViEEncoder {
   }
 };
 
+class VideoStreamFactory
+    : public VideoEncoderConfig::VideoStreamFactoryInterface {
+ public:
+  explicit VideoStreamFactory(size_t num_temporal_layers)
+      : num_temporal_layers_(num_temporal_layers) {
+    EXPECT_GT(num_temporal_layers, 0u);
+  }
+
+ private:
+  std::vector<VideoStream> CreateEncoderStreams(
+      int width,
+      int height,
+      const VideoEncoderConfig& encoder_config) override {
+    std::vector<VideoStream> streams =
+        test::CreateVideoStreams(width, height, encoder_config);
+    for (size_t i = 0; i < streams.size(); ++i) {
+      streams[i].temporal_layer_thresholds_bps.resize(num_temporal_layers_ - 1);
+    }
+    return streams;
+  }
+  const size_t num_temporal_layers_;
+};
+
 }  // namespace
 
 class ViEEncoderTest : public ::testing::Test {
@@ -93,13 +119,35 @@ class ViEEncoderTest : public ::testing::Test {
 
     VideoEncoderConfig video_encoder_config;
     test::FillEncoderConfiguration(1, &video_encoder_config);
+    ConfigureEncoder(std::move(video_encoder_config), true /* nack_enabled */);
+  }
+
+  void ConfigureEncoder(VideoEncoderConfig video_encoder_config,
+                        bool nack_enabled) {
+    if (vie_encoder_)
+      vie_encoder_->Stop();
     vie_encoder_.reset(new ViEEncoderUnderTest(
         stats_proxy_.get(), video_send_config_.encoder_settings));
     vie_encoder_->SetSink(&sink_, false /* rotation_applied */);
     vie_encoder_->SetSource(&video_source_,
                             VideoSendStream::DegradationPreference::kBalanced);
     vie_encoder_->SetStartBitrate(10000);
-    vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), 1440);
+    vie_encoder_->ConfigureEncoder(std::move(video_encoder_config),
+                                   kMaxPayloadLength, nack_enabled);
+  }
+
+  void ResetEncoder(const std::string& payload_name,
+                    size_t num_streams,
+                    size_t num_temporal_layers,
+                    bool nack_enabled) {
+    video_send_config_.encoder_settings.payload_name = payload_name;
+
+    VideoEncoderConfig video_encoder_config;
+    video_encoder_config.number_of_streams = num_streams;
+    video_encoder_config.max_bitrate_bps = 1000000;
+    video_encoder_config.video_stream_factory =
+        new rtc::RefCountedObject<VideoStreamFactory>(num_temporal_layers);
+    ConfigureEncoder(std::move(video_encoder_config), nack_enabled);
   }
 
   VideoFrame CreateFrame(int64_t ntp_ts, rtc::Event* destruction_event) const {
@@ -245,7 +293,6 @@ class ViEEncoderTest : public ::testing::Test {
 };
 
 TEST_F(ViEEncoderTest, EncodeOneFrame) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
   rtc::Event frame_destroyed_event(false, false);
   video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
@@ -260,7 +307,6 @@ TEST_F(ViEEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) {
   video_source_.IncomingCapturedFrame(CreateFrame(1, &frame_destroyed_event));
   EXPECT_TRUE(frame_destroyed_event.Wait(kDefaultTimeoutMs));
 
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
@@ -269,7 +315,6 @@ TEST_F(ViEEncoderTest, DropsFramesBeforeFirstOnBitrateUpdated) {
 }
 
 TEST_F(ViEEncoderTest, DropsFramesWhenRateSetToZero) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   sink_.WaitForEncodedFrame(1);
@@ -285,7 +330,6 @@ TEST_F(ViEEncoderTest, DropsFramesWhenRateSetToZero) {
 }
 
 TEST_F(ViEEncoderTest, DropsFramesWithSameOrOldNtpTimestamp) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
   sink_.WaitForEncodedFrame(1);
@@ -299,7 +343,6 @@ TEST_F(ViEEncoderTest, DropsFramesWithSameOrOldNtpTimestamp) {
 }
 
 TEST_F(ViEEncoderTest, DropsFrameAfterStop) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
@@ -313,7 +356,6 @@ TEST_F(ViEEncoderTest, DropsFrameAfterStop) {
 }
 
 TEST_F(ViEEncoderTest, DropsPendingFramesOnSlowEncode) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   fake_encoder_.BlockNextEncode();
@@ -330,7 +372,6 @@ TEST_F(ViEEncoderTest, DropsPendingFramesOnSlowEncode) {
 }
 
 TEST_F(ViEEncoderTest, ConfigureEncoderTriggersOnEncoderConfigurationChanged) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
   EXPECT_EQ(0, sink_.number_of_reconfigurations());
 
@@ -344,7 +385,8 @@ TEST_F(ViEEncoderTest, ConfigureEncoderTriggersOnEncoderConfigurationChanged) {
   VideoEncoderConfig video_encoder_config;
   test::FillEncoderConfiguration(1, &video_encoder_config);
   video_encoder_config.min_transmit_bitrate_bps = 9999;
-  vie_encoder_->ConfigureEncoder(std::move(video_encoder_config), 1440);
+  vie_encoder_->ConfigureEncoder(std::move(video_encoder_config),
+                                 kMaxPayloadLength, true /* nack_enabled */);
 
   // Capture a frame and wait for it to synchronize with the encoder thread.
   video_source_.IncomingCapturedFrame(CreateFrame(2, nullptr));
@@ -356,7 +398,6 @@ TEST_F(ViEEncoderTest, ConfigureEncoderTriggersOnEncoderConfigurationChanged) {
 }
 
 TEST_F(ViEEncoderTest, FrameResolutionChangeReconfigureEncoder) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   // Capture a frame and wait for it to synchronize with the encoder thread.
@@ -380,6 +421,86 @@ TEST_F(ViEEncoderTest, FrameResolutionChangeReconfigureEncoder) {
   vie_encoder_->Stop();
 }
 
+TEST_F(ViEEncoderTest, Vp8ResilienceIsOffFor1SL1TLWithNackEnabled) {
+  const bool kNackEnabled = true;
+  const size_t kNumStreams = 1;
+  const size_t kNumTl = 1;
+  ResetEncoder("VP8", kNumStreams, kNumTl, kNackEnabled);
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  // Capture a frame and wait for it to synchronize with the encoder thread.
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
+  sink_.WaitForEncodedFrame(1);
+  // The encoder have been configured once when the first frame is received.
+  EXPECT_EQ(1, sink_.number_of_reconfigurations());
+  EXPECT_EQ(kVideoCodecVP8, fake_encoder_.codec_config().codecType);
+  EXPECT_EQ(kNumStreams, fake_encoder_.codec_config().numberOfSimulcastStreams);
+  EXPECT_EQ(kNumTl, fake_encoder_.codec_config().VP8()->numberOfTemporalLayers);
+  // Resilience is off for single stream and no temporal layers with nack on.
+  EXPECT_FALSE(fake_encoder_.codec_config().VP8()->resilience);
+  vie_encoder_->Stop();
+}
+
+TEST_F(ViEEncoderTest, Vp8ResilienceIsOnFor1SL1TLWithNackDisabled) {
+  const bool kNackEnabled = false;
+  const size_t kNumStreams = 1;
+  const size_t kNumTl = 1;
+  ResetEncoder("VP8", kNumStreams, kNumTl, kNackEnabled);
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  // Capture a frame and wait for it to synchronize with the encoder thread.
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
+  sink_.WaitForEncodedFrame(1);
+  // The encoder have been configured once when the first frame is received.
+  EXPECT_EQ(1, sink_.number_of_reconfigurations());
+  EXPECT_EQ(kVideoCodecVP8, fake_encoder_.codec_config().codecType);
+  EXPECT_EQ(kNumStreams, fake_encoder_.codec_config().numberOfSimulcastStreams);
+  EXPECT_EQ(kNumTl, fake_encoder_.codec_config().VP8()->numberOfTemporalLayers);
+  // Resilience is on for single stream and no temporal layers with nack off.
+  EXPECT_TRUE(fake_encoder_.codec_config().VP8()->resilience);
+  vie_encoder_->Stop();
+}
+
+TEST_F(ViEEncoderTest, Vp8ResilienceIsOnFor2SL1TlWithNackEnabled) {
+  const bool kNackEnabled = true;
+  const size_t kNumStreams = 2;
+  const size_t kNumTl = 1;
+  ResetEncoder("VP8", kNumStreams, kNumTl, kNackEnabled);
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  // Capture a frame and wait for it to synchronize with the encoder thread.
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
+  sink_.WaitForEncodedFrame(1);
+  // The encoder have been configured once when the first frame is received.
+  EXPECT_EQ(1, sink_.number_of_reconfigurations());
+  EXPECT_EQ(kVideoCodecVP8, fake_encoder_.codec_config().codecType);
+  EXPECT_EQ(kNumStreams, fake_encoder_.codec_config().numberOfSimulcastStreams);
+  EXPECT_EQ(kNumTl, fake_encoder_.codec_config().VP8()->numberOfTemporalLayers);
+  // Resilience is on if not single stream.
+  EXPECT_TRUE(fake_encoder_.codec_config().VP8()->resilience);
+  vie_encoder_->Stop();
+}
+
+TEST_F(ViEEncoderTest, Vp8ResilienceIsOnFor1SL2TlWithNackEnabled) {
+  const bool kNackEnabled = true;
+  const size_t kNumStreams = 1;
+  const size_t kNumTl = 2;
+  ResetEncoder("VP8", kNumStreams, kNumTl, kNackEnabled);
+  vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
+
+  // Capture a frame and wait for it to synchronize with the encoder thread.
+  video_source_.IncomingCapturedFrame(CreateFrame(1, nullptr));
+  sink_.WaitForEncodedFrame(1);
+  // The encoder have been configured once when the first frame is received.
+  EXPECT_EQ(1, sink_.number_of_reconfigurations());
+  EXPECT_EQ(kVideoCodecVP8, fake_encoder_.codec_config().codecType);
+  EXPECT_EQ(kNumStreams, fake_encoder_.codec_config().numberOfSimulcastStreams);
+  EXPECT_EQ(kNumTl, fake_encoder_.codec_config().VP8()->numberOfTemporalLayers);
+  // Resilience is on for temporal layers.
+  EXPECT_TRUE(fake_encoder_.codec_config().VP8()->resilience);
+  vie_encoder_->Stop();
+}
+
 TEST_F(ViEEncoderTest, SwitchSourceDeregisterEncoderAsSink) {
   EXPECT_TRUE(video_source_.has_sinks());
   test::FrameForwarder new_video_source;
@@ -399,7 +520,6 @@ TEST_F(ViEEncoderTest, SinkWantsRotationApplied) {
 }
 
 TEST_F(ViEEncoderTest, SinkWantsFromOveruseDetector) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   EXPECT_FALSE(video_source_.sink_wants().max_pixel_count);
@@ -449,7 +569,6 @@ TEST_F(ViEEncoderTest, SinkWantsFromOveruseDetector) {
 
 TEST_F(ViEEncoderTest,
        ResolutionSinkWantsResetOnSetSourceWithDisabledResolutionScaling) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   EXPECT_FALSE(video_source_.sink_wants().max_pixel_count);
@@ -496,7 +615,6 @@ TEST_F(ViEEncoderTest,
 }
 
 TEST_F(ViEEncoderTest, StatsTracksAdaptationStats) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   int frame_width = 1280;
@@ -533,7 +651,6 @@ TEST_F(ViEEncoderTest, StatsTracksAdaptationStats) {
 }
 
 TEST_F(ViEEncoderTest, StatsTracksAdaptationStatsWhenSwitchingSource) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   // Trigger CPU overuse.
@@ -595,7 +712,6 @@ TEST_F(ViEEncoderTest, StatsTracksAdaptationStatsWhenSwitchingSource) {
 }
 
 TEST_F(ViEEncoderTest, UMACpuLimitedResolutionInPercent) {
-  const int kTargetBitrateBps = 100000;
   vie_encoder_->OnBitrateUpdated(kTargetBitrateBps, 0, 0);
 
   int frame_width = 640;