Refactor NACK bitrate allocation

webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.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 96 matching lines @@
   MockRtpPacketSender() {}
   virtual ~MockRtpPacketSender() {}
 
   MOCK_METHOD6(InsertPacket,
                void(Priority priority,
                     uint32_t ssrc,
                     uint16_t sequence_number,
                     int64_t capture_time_ms,
                     size_t bytes,
                     bool retransmission));
+
+  MOCK_METHOD1(AllocateRetransmissionBitrate, bool(size_t bytes));
+  MOCK_METHOD0(CurrentRetransmissionBitrate, int(void));
 };
 
 class MockTransportSequenceNumberAllocator
     : public TransportSequenceNumberAllocator {
  public:
   MOCK_METHOD0(AllocateSequenceNumber, uint16_t());
 };
 
 class MockSendPacketObserver : public SendPacketObserver {
  public:
@@ skipping 677 matching lines @@
   ASSERT_NE(-1, rtp_length_int);
   size_t rtp_length = static_cast<size_t>(rtp_length_int);
 
   // Packet should be stored in a send bucket.
   EXPECT_EQ(0, rtp_sender_->SendToNetwork(packet_, 0, rtp_length,
                                           capture_time_ms, kAllowRetransmission,
                                           RtpPacketSender::kNormalPriority));
 
   EXPECT_EQ(0, transport_.packets_sent_);
 
+  EXPECT_CALL(mock_paced_sender_, AllocateRetransmissionBitrate(rtp_length))
+      .WillOnce(testing::Return(true));
   EXPECT_CALL(mock_paced_sender_, InsertPacket(RtpPacketSender::kNormalPriority,
                                                _, kSeqNum, _, _, _));
 
   const int kStoredTimeInMs = 100;
   fake_clock_.AdvanceTimeMilliseconds(kStoredTimeInMs);
 
   EXPECT_EQ(rtp_length_int, rtp_sender_->ReSendPacket(kSeqNum));
   EXPECT_EQ(0, transport_.packets_sent_);
 
   rtp_sender_->TimeToSendPacket(kSeqNum, capture_time_ms, false,
@@ skipping 382 matching lines @@
   EXPECT_EQ(ssrc, callback.ssrc_);
   EXPECT_EQ(1, callback.frame_counts_.key_frames);
   EXPECT_EQ(1, callback.frame_counts_.delta_frames);
 
   rtp_sender_.reset();
 }
 
 TEST_F(RtpSenderTest, BitrateCallbacks) {
   class TestCallback : public BitrateStatisticsObserver {
    public:
-    TestCallback() : BitrateStatisticsObserver(), num_calls_(0), ssrc_(0) {}
+    TestCallback()
+        : BitrateStatisticsObserver(),
+          num_calls_(0),
+          ssrc_(0),
+          total_bitrate_(0),
+          retransmit_bitrate_(0) {}
     virtual ~TestCallback() {}
 
-    void Notify(const BitrateStatistics& total_stats,
-                const BitrateStatistics& retransmit_stats,
+    void Notify(uint32_t total_bitrate,
+                uint32_t retransmit_bitrate,
                 uint32_t ssrc) override {
       ++num_calls_;
       ssrc_ = ssrc;
-      total_stats_ = total_stats;
-      retransmit_stats_ = retransmit_stats;
+      total_bitrate_ = total_bitrate;
+      retransmit_bitrate_ = retransmit_bitrate;
     }
 
     uint32_t num_calls_;
     uint32_t ssrc_;
-    BitrateStatistics total_stats_;
-    BitrateStatistics retransmit_stats_;
+    uint32_t total_bitrate_;
+    uint32_t retransmit_bitrate_;
   } callback;
   rtp_sender_.reset(new RTPSender(false, &fake_clock_, &transport_, nullptr,
                                   nullptr, nullptr, &callback, nullptr, nullptr,
                                   nullptr, nullptr));
 
-  // Simulate kNumPackets sent with kPacketInterval ms intervals.
-  const uint32_t kNumPackets = 15;
+  // Simulate kNumPackets sent with kPacketInterval ms intervals, with the
+  // number of packets selected so that we fill (but don't overflow) the one
+  // second averaging window.
+  const uint32_t kWindowSizeMs = 1000;
   const uint32_t kPacketInterval = 20;
+  const uint32_t kNumPackets =
+      (kWindowSizeMs - kPacketInterval) / kPacketInterval;
   // Overhead = 12 bytes RTP header + 1 byte generic header.
   const uint32_t kPacketOverhead = 13;
 
   char payload_name[RTP_PAYLOAD_NAME_SIZE] = "GENERIC";
   const uint8_t payload_type = 127;
   ASSERT_EQ(0, rtp_sender_->RegisterPayload(payload_name, payload_type, 90000,
                                             0, 1500));
   uint8_t payload[] = {47, 11, 32, 93, 89};
   rtp_sender_->SetStorePacketsStatus(true, 1);
   uint32_t ssrc = rtp_sender_->SSRC();
 
   // Initial process call so we get a new time window.
   rtp_sender_->ProcessBitrate();
-  uint64_t start_time = fake_clock_.CurrentNtpInMilliseconds();
 
   // Send a few frames.
   for (uint32_t i = 0; i < kNumPackets; ++i) {
     ASSERT_EQ(0,
               rtp_sender_->SendOutgoingData(kVideoFrameKey, payload_type, 1234,
                                             4321, payload, sizeof(payload), 0));
     fake_clock_.AdvanceTimeMilliseconds(kPacketInterval);
   }
 
   rtp_sender_->ProcessBitrate();
 
-  const uint32_t expected_packet_rate = 1000 / kPacketInterval;
-
   // We get one call for every stats updated, thus two calls since both the
   // stream stats and the retransmit stats are updated once.
   EXPECT_EQ(2u, callback.num_calls_);
   EXPECT_EQ(ssrc, callback.ssrc_);
-  EXPECT_EQ(start_time + (kNumPackets * kPacketInterval),
-            callback.total_stats_.timestamp_ms);
-  EXPECT_EQ(expected_packet_rate, callback.total_stats_.packet_rate);
-  EXPECT_EQ((kPacketOverhead + sizeof(payload)) * 8 * expected_packet_rate,
-            callback.total_stats_.bitrate_bps);
+  const uint32_t kTotalPacketSize = kPacketOverhead + sizeof(payload);
+  // Bitrate measured over delta between last and first timestamp, plus one.
+  const uint32_t kExpectedWindowMs = kNumPackets * kPacketInterval + 1;
+  const uint32_t kExpectedBitsAccumulated = kTotalPacketSize * kNumPackets * 8;
+  const uint32_t KexpectedRateBps =
+      (kExpectedBitsAccumulated * 1000 + (kExpectedWindowMs / 2)) /
+      kExpectedWindowMs;
+  EXPECT_EQ(KexpectedRateBps, callback.total_bitrate_);
 
   rtp_sender_.reset();
 }
 
 class RtpSenderAudioTest : public RtpSenderTest {
  protected:
   RtpSenderAudioTest() {}
 
   void SetUp() override {
     payload_ = kAudioPayload;
@@ skipping 317 matching lines @@
       reinterpret_cast<uint8_t*>(transport_.sent_packets_[0]->data()),
       transport_.sent_packets_[0]->size(), true, &map, kSeqNum, hdr.rotation);
 
   // Verify that this packet does have CVO byte.
   VerifyCVOPacket(
       reinterpret_cast<uint8_t*>(transport_.sent_packets_[1]->data()),
       transport_.sent_packets_[1]->size(), true, &map, kSeqNum + 1,
       hdr.rotation);
 }
 }  // namespace webrtc