Fix issue where the first audio packets significantly impacts initial BWE negatively.

webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.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.
  */
 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h"
@@ skipping 302 matching lines @@
   uint32_t absolute_send_time = 0;
   std::vector<unsigned int> ssrcs;
   EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
   EXPECT_EQ(0u, ssrcs.size());
   clock_.AdvanceTimeMilliseconds(1000);
   bitrate_estimator_->Process();
   EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
   EXPECT_FALSE(bitrate_observer_->updated());
   bitrate_observer_->Reset();
   clock_.AdvanceTimeMilliseconds(1000);
-  // Inserting a packet. Still no valid estimate. We need to wait 1 second.
+  // Inserting a packet. Still no valid estimate. We need to wait 5 seconds.
   IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
                  absolute_send_time, true);
   bitrate_estimator_->Process();
   EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
   EXPECT_EQ(0u, ssrcs.size());
   EXPECT_FALSE(bitrate_observer_->updated());
   bitrate_observer_->Reset();
-  // Inserting packets for one second to get a valid estimate.
-  for (int i = 0; i < kFramerate; ++i) {
+  // Inserting packets for 5 seconds to get a valid estimate.
+  for (int i = 0; i < 5 * kFramerate + 1; ++i) {
     IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
                    absolute_send_time, true);
     clock_.AdvanceTimeMilliseconds(1000 / kFramerate);
     timestamp += 90 * kFrameIntervalMs;
     absolute_send_time = AddAbsSendTime(absolute_send_time,
                                         kFrameIntervalAbsSendTime);
   }
   bitrate_estimator_->Process();
   EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
   ASSERT_EQ(1u, ssrcs.size());
@@ skipping 13 matching lines @@
   const int kFramerate = 50;  // 50 fps to avoid rounding errors.
   const int kFrameIntervalMs = 1000 / kFramerate;
   const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate);
   uint32_t timestamp = 0;
   uint32_t absolute_send_time = 0;
   IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
                  absolute_send_time, true);
   bitrate_estimator_->Process();
   EXPECT_FALSE(bitrate_observer_->updated());  // No valid estimate.
   // Inserting packets for one second to get a valid estimate.
-  for (int i = 0; i < kFramerate; ++i) {
+  for (int i = 0; i < 5 * kFramerate + 1; ++i) {
     IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
                    absolute_send_time, true);
     clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
     timestamp += 90 * kFrameIntervalMs;
     absolute_send_time = AddAbsSendTime(absolute_send_time,
                                         kFrameIntervalAbsSendTime);
   }
   bitrate_estimator_->Process();
   EXPECT_TRUE(bitrate_observer_->updated());
   EXPECT_NEAR(expected_bitrate_bps,
@@ skipping 55 matching lines @@
   const int kMinExpectedBitrate = 800e3;
   const int kMaxExpectedBitrate = 1100e3;
   const unsigned int kInitialCapacityBps = 1000e3;
   const unsigned int kReducedCapacityBps = 500e3;
 
   int steady_state_time = 0;
   if (number_of_streams <= 1) {
     steady_state_time = 10;
     AddDefaultStream();
   } else {
-    steady_state_time = 8 * number_of_streams;
+    steady_state_time = 10 * number_of_streams;
     int bitrate_sum = 0;
     int kBitrateDenom = number_of_streams * (number_of_streams - 1);
     for (int i = 0; i < number_of_streams; i++) {
       // First stream gets half available bitrate, while the rest share the
       // remaining half i.e.: 1/2 = Sum[n/(N*(N-1))] for n=1..N-1 (rounded up)
       int bitrate = kStartBitrate / 2;
       if (i > 0) {
         bitrate = (kStartBitrate * i + kBitrateDenom / 2) / kBitrateDenom;
       }
       stream_generator_->AddStream(new testing::RtpStream(
@@ skipping 33 matching lines @@
     if (bitrate_observer_->updated()) {
       if (bitrate_drop_time == -1 &&
           bitrate_observer_->latest_bitrate() <= kReducedCapacityBps) {
         bitrate_drop_time = clock_.TimeInMilliseconds();
       }
       bitrate_bps = bitrate_observer_->latest_bitrate();
       bitrate_observer_->Reset();
     }
   }
 
-  EXPECT_EQ(expected_bitrate_drop_delta,
-            bitrate_drop_time - overuse_start_time);
+  EXPECT_NEAR(expected_bitrate_drop_delta,
+              bitrate_drop_time - overuse_start_time, 33);
 
   // Remove stream one by one.
   unsigned int latest_bps = 0;
   std::vector<unsigned int> ssrcs;
   for (int i = 0; i < number_of_streams; i++) {
     EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &latest_bps));
     EXPECT_EQ(number_of_streams - i, static_cast<int>(ssrcs.size()));
     EXPECT_EQ(bitrate_bps, latest_bps);
     for (int j = i; j < number_of_streams; j++) {
       EXPECT_EQ(kDefaultSsrc + j, ssrcs[j - i]);
     }
     bitrate_estimator_->RemoveStream(kDefaultSsrc + i);
   }
   EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &latest_bps));
   EXPECT_EQ(0u, ssrcs.size());
   EXPECT_EQ(0u, latest_bps);
 }
 
-void RemoteBitrateEstimatorTest::TestTimestampGroupingTestHelper(
-    uint32_t bitrate_bps) {
+void RemoteBitrateEstimatorTest::TestTimestampGroupingTestHelper() {
   const int kFramerate = 50;  // 50 fps to avoid rounding errors.
   const int kFrameIntervalMs = 1000 / kFramerate;
   const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate);
   uint32_t timestamp = 0;
   // Initialize absolute_send_time (24 bits) so that it will definitely wrap
   // during the test.
   uint32_t absolute_send_time =
       AddAbsSendTime((1 << 24), -int(50 * kFrameIntervalAbsSendTime));
-  // Initial set of frames to increase the bitrate.
-  for (int i = 0; i <= 100; ++i) {
+  // Initial set of frames to increase the bitrate. 6 seconds to have enough
+  // time for the first estimate to be generated and for Process() to be called.
+  for (int i = 0; i <= 6 * kFramerate; ++i) {
     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
                    absolute_send_time, true);
     bitrate_estimator_->Process();
     clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
     timestamp += 90 * kFrameIntervalMs;
     absolute_send_time = AddAbsSendTime(absolute_send_time,
                                         kFrameIntervalAbsSendTime);
   }
   EXPECT_TRUE(bitrate_observer_->updated());
-  EXPECT_NEAR(470000u, bitrate_observer_->latest_bitrate(), 10000u);
+  EXPECT_GE(bitrate_observer_->latest_bitrate(), 400000u);
 
   // Insert batches of frames which were sent very close in time. Also simulate
   // capacity over-use to see that we back off correctly.
   const int kTimestampGroupLength = 15;
   const uint32_t kTimestampGroupLengthAbsSendTime =
       AbsSendTime(kTimestampGroupLength, 90000);
   const uint32_t kSingleRtpTickAbsSendTime = AbsSendTime(1, 90000);
   for (int i = 0; i < 100; ++i) {
     for (int j = 0; j < kTimestampGroupLength; ++j) {
       // Insert |kTimestampGroupLength| frames with just 1 timestamp ticks in
       // between. Should be treated as part of the same group by the estimator.
       IncomingPacket(kDefaultSsrc, 100, clock_.TimeInMilliseconds(), timestamp,
                      absolute_send_time, true);
       clock_.AdvanceTimeMilliseconds(kFrameIntervalMs / kTimestampGroupLength);
       timestamp += 1;
       absolute_send_time = AddAbsSendTime(absolute_send_time,
                                           kSingleRtpTickAbsSendTime);
     }
     // Increase time until next batch to simulate over-use.
     clock_.AdvanceTimeMilliseconds(10);
     timestamp += 90 * kFrameIntervalMs - kTimestampGroupLength;
     absolute_send_time = AddAbsSendTime(absolute_send_time, AddAbsSendTime(
         kFrameIntervalAbsSendTime, -int(kTimestampGroupLengthAbsSendTime)));
     bitrate_estimator_->Process();
   }
   EXPECT_TRUE(bitrate_observer_->updated());
   // Should have reduced the estimate.
-  EXPECT_EQ(bitrate_bps, bitrate_observer_->latest_bitrate());
+  EXPECT_LT(bitrate_observer_->latest_bitrate(), 400000u);
 }
 
 void RemoteBitrateEstimatorTest::TestGetStatsHelper() {
   const int kFramerate = 100;
   const int kFrameIntervalMs = 1000 / kFramerate;
   const int kBurstThresholdMs = 5;
   const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate);
   uint32_t timestamp = 0;
   // Initialize absolute_send_time (24 bits) so that it will definitely wrap
   // during the test.
@@ skipping 82 matching lines @@
     clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs);
     absolute_send_time = AddAbsSendTime(absolute_send_time,
                                         kFrameIntervalAbsSendTime);
     bitrate_estimator_->Process();
   }
   unsigned int bitrate_after = 0;
   bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_after);
   EXPECT_LT(bitrate_after, bitrate_before);
 }
 }  // namespace webrtc