Move logic for calculating needed bitrate overhead used by NACK and FEC to VideoSender.

webrtc/modules/video_coding/protection_bitrate_calculator_unittest.cc

Index: webrtc/modules/video_coding/protection_bitrate_calculator_unittest.cc
diff --git a/webrtc/modules/video_coding/media_optimization_unittest.cc b/webrtc/modules/video_coding/protection_bitrate_calculator_unittest.cc
similarity index 23%
copy from webrtc/modules/video_coding/media_optimization_unittest.cc
copy to webrtc/modules/video_coding/protection_bitrate_calculator_unittest.cc
index e6a1bcccd96572f58681c222a2f93a0602d3cc63..667dd6a359f3d888f93d44145575658fd5a792ea 100644
--- a/webrtc/modules/video_coding/media_optimization_unittest.cc
+++ b/webrtc/modules/video_coding/protection_bitrate_calculator_unittest.cc
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
+ *  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
@@ -9,146 +9,81 @@
  */
 
 #include "testing/gtest/include/gtest/gtest.h"
-#include "webrtc/modules/video_coding/media_optimization.h"
+#include "webrtc/modules/video_coding/protection_bitrate_calculator.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
-namespace media_optimization {
 
-class TestMediaOptimization : public ::testing::Test {
+static const int kCodecBitrateBps = 100000;
+
+class ProtectionBitrateCalculatorTest : public ::testing::Test {
  protected:
   enum {
     kSampleRate = 90000  // RTP timestamps per second.
   };
 
-  // Note: simulated clock starts at 1 seconds, since parts of webrtc use 0 as
-  // a special case (e.g. frame rate in media optimization).
-  TestMediaOptimization()
-      : clock_(1000),
-        media_opt_(&clock_),
-        frame_time_ms_(33),
-        next_timestamp_(0) {}
-
-  // This method mimics what happens in VideoSender::AddVideoFrame.
-  void AddFrameAndAdvanceTime(uint32_t bitrate_bps, bool expect_frame_drop) {
-    bool frame_dropped = media_opt_.DropFrame();
-    EXPECT_EQ(expect_frame_drop, frame_dropped);
-    if (!frame_dropped) {
-      size_t bytes_per_frame = bitrate_bps * frame_time_ms_ / (8 * 1000);
-      EncodedImage encoded_image;
-      encoded_image._length = bytes_per_frame;
-      encoded_image._timeStamp = next_timestamp_;
-      encoded_image._frameType = kVideoFrameKey;
-      ASSERT_EQ(VCM_OK, media_opt_.UpdateWithEncodedData(encoded_image));
-    }
-    next_timestamp_ += frame_time_ms_ * kSampleRate / 1000;
-    clock_.AdvanceTimeMilliseconds(frame_time_ms_);
-  }
-
-  SimulatedClock clock_;
-  MediaOptimization media_opt_;
-  int frame_time_ms_;
-  uint32_t next_timestamp_;
-};
-
-TEST_F(TestMediaOptimization, VerifyMuting) {
-  // Enable video suspension with these limits.
-  // Suspend the video when the rate is below 50 kbps and resume when it gets
-  // above 50 + 10 kbps again.
-  const uint32_t kThresholdBps = 50000;
-  const uint32_t kWindowBps = 10000;
-  media_opt_.SuspendBelowMinBitrate(kThresholdBps, kWindowBps);
-
-  // The video should not be suspended from the start.
-  EXPECT_FALSE(media_opt_.IsVideoSuspended());
-
-  uint32_t target_bitrate_kbps = 100;
-  media_opt_.SetTargetRates(target_bitrate_kbps * 1000,
-                            0,    // Lossrate.
-                            100,  // RTT in ms.
-                            nullptr);
-  media_opt_.EnableFrameDropper(true);
-  for (int time = 0; time < 2000; time += frame_time_ms_) {
-    ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, false));
-  }
-
-  // Set the target rate below the limit for muting.
-  media_opt_.SetTargetRates(kThresholdBps - 1000,
-                            0,    // Lossrate.
-                            100,  // RTT in ms.
-                            nullptr);
-  // Expect the muter to engage immediately and stay muted.
-  // Test during 2 seconds.
-  for (int time = 0; time < 2000; time += frame_time_ms_) {
-    EXPECT_TRUE(media_opt_.IsVideoSuspended());
-    ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, true));
-  }
-
-  // Set the target above the limit for muting, but not above the
-  // limit + window.
-  media_opt_.SetTargetRates(kThresholdBps + 1000,
-                            0,    // Lossrate.
-                            100,  // RTT in ms.
-                            nullptr);
-  // Expect the muter to stay muted.
-  // Test during 2 seconds.
-  for (int time = 0; time < 2000; time += frame_time_ms_) {
-    EXPECT_TRUE(media_opt_.IsVideoSuspended());
-    ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, true));
-  }
-
-  // Set the target above limit + window.
-  media_opt_.SetTargetRates(kThresholdBps + kWindowBps + 1000,
-                            0,    // Lossrate.
-                            100,  // RTT in ms.
-                            nullptr);
-  // Expect the muter to disengage immediately.
-  // Test during 2 seconds.
-  for (int time = 0; time < 2000; time += frame_time_ms_) {
-    EXPECT_FALSE(media_opt_.IsVideoSuspended());
-    ASSERT_NO_FATAL_FAILURE(
-        AddFrameAndAdvanceTime((kThresholdBps + kWindowBps) / 1000, false));
-  }
-}
-
-TEST_F(TestMediaOptimization, ProtectsUsingFecBitrateAboveCodecMax) {
-  static const int kCodecBitrateBps = 100000;
-  static const int kMaxBitrateBps = 130000;
-
   class ProtectionCallback : public VCMProtectionCallback {
+   public:
     int ProtectionRequest(const FecProtectionParams* delta_params,
                           const FecProtectionParams* key_params,
                           uint32_t* sent_video_rate_bps,
                           uint32_t* sent_nack_rate_bps,
                           uint32_t* sent_fec_rate_bps) override {
       *sent_video_rate_bps = kCodecBitrateBps;
-      *sent_nack_rate_bps = 0;
+      *sent_nack_rate_bps = nack_rate_bps_;
       *sent_fec_rate_bps = fec_rate_bps_;
       return 0;
     }
 
-   public:
-    uint32_t fec_rate_bps_;
-  } protection_callback;
+    uint32_t fec_rate_bps_ = 0;
+    uint32_t nack_rate_bps_ = 0;
+  };
 
-  media_opt_.SetProtectionMethod(kFec);
-  media_opt_.SetEncodingData(kVideoCodecVP8, kCodecBitrateBps, kCodecBitrateBps,
-                             640, 480, 30, 1, 1000);
+  // Note: simulated clock starts at 1 seconds, since parts of webrtc use 0 as
+  // a special case (e.g. frame rate in media optimization).
+  ProtectionBitrateCalculatorTest()
+      : clock_(1000), media_opt_(&clock_, &protection_callback_) {}
+
+  SimulatedClock clock_;
+  ProtectionCallback protection_callback_;
+  ProtectionBitrateCalculator media_opt_;
+};
+
+TEST_F(ProtectionBitrateCalculatorTest, ProtectsUsingFecBitrate) {
+  static const uint32_t kMaxBitrateBps = 130000;
+
+  media_opt_.SetProtectionMethod(true /*enable_fec*/, false /* enable_nack */);
+  media_opt_.SetEncodingData(kCodecBitrateBps, 640, 480, 30, 1, 1000);
 
-  // Using 10% of codec bitrate for FEC, should still be able to use all of it.
-  protection_callback.fec_rate_bps_ = kCodecBitrateBps / 10;
-  uint32_t target_bitrate = media_opt_.SetTargetRates(
-      kMaxBitrateBps, 0, 0, &protection_callback);
+  // Using 10% of codec bitrate for FEC.
+  protection_callback_.fec_rate_bps_ = kCodecBitrateBps / 10;
+  uint32_t target_bitrate = media_opt_.SetTargetRates(kMaxBitrateBps, 30, 0, 0);
 
-  EXPECT_EQ(kCodecBitrateBps, static_cast<int>(target_bitrate));
+  EXPECT_GT(target_bitrate, 0u);
+  EXPECT_GT(kMaxBitrateBps, target_bitrate);
 
   // Using as much for codec bitrate as fec rate, new target rate should share
   // both equally, but only be half of max (since that ceiling should be hit).
-  protection_callback.fec_rate_bps_ = kCodecBitrateBps;
-  target_bitrate = media_opt_.SetTargetRates(kMaxBitrateBps, 128, 100,
-                                             &protection_callback);
-  EXPECT_EQ(kMaxBitrateBps / 2, static_cast<int>(target_bitrate));
+  protection_callback_.fec_rate_bps_ = kCodecBitrateBps;
+  target_bitrate = media_opt_.SetTargetRates(kMaxBitrateBps, 30, 128, 100);
+  EXPECT_EQ(kMaxBitrateBps / 2, target_bitrate);
+}
+
+TEST_F(ProtectionBitrateCalculatorTest, ProtectsUsingNackBitrate) {
+  static const uint32_t kMaxBitrateBps = 130000;
+
+  media_opt_.SetProtectionMethod(false /*enable_fec*/, true /* enable_nack */);
+  media_opt_.SetEncodingData(kCodecBitrateBps, 640, 480, 30, 1, 1000);
+
+  uint32_t target_bitrate = media_opt_.SetTargetRates(kMaxBitrateBps, 30, 0, 0);
+
+  EXPECT_EQ(kMaxBitrateBps, target_bitrate);
+
+  // Using as much for codec bitrate as nack rate, new target rate should share
+  // both equally, but only be half of max (since that ceiling should be hit).
+  protection_callback_.nack_rate_bps_ = kMaxBitrateBps;
+  target_bitrate = media_opt_.SetTargetRates(kMaxBitrateBps, 30, 128, 100);
+  EXPECT_EQ(kMaxBitrateBps / 2, target_bitrate);
 }
 
-}  // namespace media_optimization
 }  // namespace webrtc