• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h"
11 
12 #include <algorithm>
13 #include <limits>
14 #include <utility>
15 
16 namespace webrtc {
17 
18 const size_t kMtu = 1200;
19 const unsigned int kAcceptedBitrateErrorBps = 50000;
20 
21 namespace testing {
22 
OnReceiveBitrateChanged(const std::vector<unsigned int> & ssrcs,unsigned int bitrate)23 void TestBitrateObserver::OnReceiveBitrateChanged(
24     const std::vector<unsigned int>& ssrcs,
25     unsigned int bitrate) {
26   latest_bitrate_ = bitrate;
27   updated_ = true;
28 }
29 
RtpStream(int fps,int bitrate_bps,unsigned int ssrc,unsigned int frequency,uint32_t timestamp_offset,int64_t rtcp_receive_time)30 RtpStream::RtpStream(int fps,
31                      int bitrate_bps,
32                      unsigned int ssrc,
33                      unsigned int frequency,
34                      uint32_t timestamp_offset,
35                      int64_t rtcp_receive_time)
36     : fps_(fps),
37       bitrate_bps_(bitrate_bps),
38       ssrc_(ssrc),
39       frequency_(frequency),
40       next_rtp_time_(0),
41       next_rtcp_time_(rtcp_receive_time),
42       rtp_timestamp_offset_(timestamp_offset),
43       kNtpFracPerMs(4.294967296E6) {
44   assert(fps_ > 0);
45 }
46 
set_rtp_timestamp_offset(uint32_t offset)47 void RtpStream::set_rtp_timestamp_offset(uint32_t offset) {
48   rtp_timestamp_offset_ = offset;
49 }
50 
51 // Generates a new frame for this stream. If called too soon after the
52 // previous frame, no frame will be generated. The frame is split into
53 // packets.
GenerateFrame(int64_t time_now_us,PacketList * packets)54 int64_t RtpStream::GenerateFrame(int64_t time_now_us, PacketList* packets) {
55   if (time_now_us < next_rtp_time_) {
56     return next_rtp_time_;
57   }
58   assert(packets != NULL);
59   size_t bits_per_frame = (bitrate_bps_ + fps_ / 2) / fps_;
60   size_t n_packets =
61       std::max<size_t>((bits_per_frame + 4 * kMtu) / (8 * kMtu), 1u);
62   size_t packet_size = (bits_per_frame + 4 * n_packets) / (8 * n_packets);
63   for (size_t i = 0; i < n_packets; ++i) {
64     RtpPacket* packet = new RtpPacket;
65     packet->send_time = time_now_us + kSendSideOffsetUs;
66     packet->size = packet_size;
67     packet->rtp_timestamp = rtp_timestamp_offset_ + static_cast<uint32_t>(
68         ((frequency_ / 1000) * packet->send_time + 500) / 1000);
69     packet->ssrc = ssrc_;
70     packets->push_back(packet);
71   }
72   next_rtp_time_ = time_now_us + (1000000 + fps_ / 2) / fps_;
73   return next_rtp_time_;
74 }
75 
76 // The send-side time when the next frame can be generated.
next_rtp_time() const77 double RtpStream::next_rtp_time() const {
78   return next_rtp_time_;
79 }
80 
81 // Generates an RTCP packet.
Rtcp(int64_t time_now_us)82 RtpStream::RtcpPacket* RtpStream::Rtcp(int64_t time_now_us) {
83   if (time_now_us < next_rtcp_time_) {
84     return NULL;
85   }
86   RtcpPacket* rtcp = new RtcpPacket;
87   int64_t send_time_us = time_now_us + kSendSideOffsetUs;
88   rtcp->timestamp = rtp_timestamp_offset_ + static_cast<uint32_t>(
89       ((frequency_ / 1000) * send_time_us + 500) / 1000);
90   rtcp->ntp_secs = send_time_us / 1000000;
91   rtcp->ntp_frac = static_cast<int64_t>((send_time_us % 1000000) *
92       kNtpFracPerMs);
93   rtcp->ssrc = ssrc_;
94   next_rtcp_time_ = time_now_us + kRtcpIntervalUs;
95   return rtcp;
96 }
97 
set_bitrate_bps(int bitrate_bps)98 void RtpStream::set_bitrate_bps(int bitrate_bps) {
99   ASSERT_GE(bitrate_bps, 0);
100   bitrate_bps_ = bitrate_bps;
101 }
102 
bitrate_bps() const103 int RtpStream::bitrate_bps() const {
104   return bitrate_bps_;
105 }
106 
ssrc() const107 unsigned int RtpStream::ssrc() const {
108   return ssrc_;
109 }
110 
Compare(const std::pair<unsigned int,RtpStream * > & left,const std::pair<unsigned int,RtpStream * > & right)111 bool RtpStream::Compare(const std::pair<unsigned int, RtpStream*>& left,
112                         const std::pair<unsigned int, RtpStream*>& right) {
113   return left.second->next_rtp_time_ < right.second->next_rtp_time_;
114 }
115 
StreamGenerator(int capacity,double time_now)116 StreamGenerator::StreamGenerator(int capacity, double time_now)
117     : capacity_(capacity),
118       prev_arrival_time_us_(time_now) {}
119 
~StreamGenerator()120 StreamGenerator::~StreamGenerator() {
121   for (StreamMap::iterator it = streams_.begin(); it != streams_.end();
122       ++it) {
123     delete it->second;
124   }
125   streams_.clear();
126 }
127 
128 // Add a new stream.
AddStream(RtpStream * stream)129 void StreamGenerator::AddStream(RtpStream* stream) {
130   streams_[stream->ssrc()] = stream;
131 }
132 
133 // Set the link capacity.
set_capacity_bps(int capacity_bps)134 void StreamGenerator::set_capacity_bps(int capacity_bps) {
135   ASSERT_GT(capacity_bps, 0);
136   capacity_ = capacity_bps;
137 }
138 
139 // Divides |bitrate_bps| among all streams. The allocated bitrate per stream
140 // is decided by the current allocation ratios.
SetBitrateBps(int bitrate_bps)141 void StreamGenerator::SetBitrateBps(int bitrate_bps) {
142   ASSERT_GE(streams_.size(), 0u);
143   int total_bitrate_before = 0;
144   for (StreamMap::iterator it = streams_.begin(); it != streams_.end(); ++it) {
145     total_bitrate_before += it->second->bitrate_bps();
146   }
147   int64_t bitrate_before = 0;
148   int total_bitrate_after = 0;
149   for (StreamMap::iterator it = streams_.begin(); it != streams_.end(); ++it) {
150     bitrate_before += it->second->bitrate_bps();
151     int64_t bitrate_after = (bitrate_before * bitrate_bps +
152         total_bitrate_before / 2) / total_bitrate_before;
153     it->second->set_bitrate_bps(bitrate_after - total_bitrate_after);
154     total_bitrate_after += it->second->bitrate_bps();
155   }
156   ASSERT_EQ(bitrate_before, total_bitrate_before);
157   EXPECT_EQ(total_bitrate_after, bitrate_bps);
158 }
159 
160 // Set the RTP timestamp offset for the stream identified by |ssrc|.
set_rtp_timestamp_offset(unsigned int ssrc,uint32_t offset)161 void StreamGenerator::set_rtp_timestamp_offset(unsigned int ssrc,
162                                                uint32_t offset) {
163   streams_[ssrc]->set_rtp_timestamp_offset(offset);
164 }
165 
166 // TODO(holmer): Break out the channel simulation part from this class to make
167 // it possible to simulate different types of channels.
GenerateFrame(RtpStream::PacketList * packets,int64_t time_now_us)168 int64_t StreamGenerator::GenerateFrame(RtpStream::PacketList* packets,
169                                        int64_t time_now_us) {
170   assert(packets != NULL);
171   assert(packets->empty());
172   assert(capacity_ > 0);
173   StreamMap::iterator it = std::min_element(streams_.begin(), streams_.end(),
174                                             RtpStream::Compare);
175   (*it).second->GenerateFrame(time_now_us, packets);
176   int i = 0;
177   for (RtpStream::PacketList::iterator packet_it = packets->begin();
178       packet_it != packets->end(); ++packet_it) {
179     int capacity_bpus = capacity_ / 1000;
180     int64_t required_network_time_us =
181         (8 * 1000 * (*packet_it)->size + capacity_bpus / 2) / capacity_bpus;
182     prev_arrival_time_us_ = std::max(time_now_us + required_network_time_us,
183         prev_arrival_time_us_ + required_network_time_us);
184     (*packet_it)->arrival_time = prev_arrival_time_us_;
185     ++i;
186   }
187   it = std::min_element(streams_.begin(), streams_.end(), RtpStream::Compare);
188   return (*it).second->next_rtp_time();
189 }
190 }  // namespace testing
191 
RemoteBitrateEstimatorTest()192 RemoteBitrateEstimatorTest::RemoteBitrateEstimatorTest()
193     : clock_(0),
194       bitrate_observer_(new testing::TestBitrateObserver),
195       stream_generator_(new testing::StreamGenerator(
196           1e6,  // Capacity.
197           clock_.TimeInMicroseconds())) {}
198 
~RemoteBitrateEstimatorTest()199 RemoteBitrateEstimatorTest::~RemoteBitrateEstimatorTest() {}
200 
AddDefaultStream()201 void RemoteBitrateEstimatorTest::AddDefaultStream() {
202   stream_generator_->AddStream(new testing::RtpStream(
203     30,          // Frames per second.
204     3e5,         // Bitrate.
205     1,           // SSRC.
206     90000,       // RTP frequency.
207     0xFFFFF000,  // Timestamp offset.
208     0));         // RTCP receive time.
209 }
210 
AbsSendTime(int64_t t,int64_t denom)211 uint32_t RemoteBitrateEstimatorTest::AbsSendTime(int64_t t, int64_t denom) {
212   return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful;
213 }
214 
AddAbsSendTime(uint32_t t1,uint32_t t2)215 uint32_t RemoteBitrateEstimatorTest::AddAbsSendTime(uint32_t t1, uint32_t t2) {
216   return (t1 + t2) & 0x00fffffful;
217 }
218 
219 const unsigned int RemoteBitrateEstimatorTest::kDefaultSsrc = 1;
220 
IncomingPacket(uint32_t ssrc,size_t payload_size,int64_t arrival_time,uint32_t rtp_timestamp,uint32_t absolute_send_time,bool was_paced)221 void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc,
222                                                 size_t payload_size,
223                                                 int64_t arrival_time,
224                                                 uint32_t rtp_timestamp,
225                                                 uint32_t absolute_send_time,
226                                                 bool was_paced) {
227   RTPHeader header;
228   memset(&header, 0, sizeof(header));
229   header.ssrc = ssrc;
230   header.timestamp = rtp_timestamp;
231   header.extension.hasAbsoluteSendTime = true;
232   header.extension.absoluteSendTime = absolute_send_time;
233   bitrate_estimator_->IncomingPacket(arrival_time + kArrivalTimeClockOffsetMs,
234                                      payload_size, header, was_paced);
235 }
236 
237 // Generates a frame of packets belonging to a stream at a given bitrate and
238 // with a given ssrc. The stream is pushed through a very simple simulated
239 // network, and is then given to the receive-side bandwidth estimator.
240 // Returns true if an over-use was seen, false otherwise.
241 // The StreamGenerator::updated() should be used to check for any changes in
242 // target bitrate after the call to this function.
GenerateAndProcessFrame(unsigned int ssrc,unsigned int bitrate_bps)243 bool RemoteBitrateEstimatorTest::GenerateAndProcessFrame(unsigned int ssrc,
244     unsigned int bitrate_bps) {
245   stream_generator_->SetBitrateBps(bitrate_bps);
246   testing::RtpStream::PacketList packets;
247   int64_t next_time_us = stream_generator_->GenerateFrame(
248       &packets, clock_.TimeInMicroseconds());
249   bool overuse = false;
250   while (!packets.empty()) {
251     testing::RtpStream::RtpPacket* packet = packets.front();
252     bitrate_observer_->Reset();
253     // The simulated clock should match the time of packet->arrival_time
254     // since both are used in IncomingPacket().
255     clock_.AdvanceTimeMicroseconds(packet->arrival_time -
256                                    clock_.TimeInMicroseconds());
257     IncomingPacket(packet->ssrc, packet->size,
258                    (packet->arrival_time + 500) / 1000, packet->rtp_timestamp,
259                    AbsSendTime(packet->send_time, 1000000), true);
260     if (bitrate_observer_->updated()) {
261       // Verify that new estimates only are triggered by an overuse and a
262       // rate decrease.
263       overuse = true;
264       EXPECT_LE(bitrate_observer_->latest_bitrate(), bitrate_bps);
265     }
266     delete packet;
267     packets.pop_front();
268   }
269   bitrate_estimator_->Process();
270   clock_.AdvanceTimeMicroseconds(next_time_us - clock_.TimeInMicroseconds());
271   return overuse;
272 }
273 
274 // Run the bandwidth estimator with a stream of |number_of_frames| frames, or
275 // until it reaches |target_bitrate|.
276 // Can for instance be used to run the estimator for some time to get it
277 // into a steady state.
SteadyStateRun(unsigned int ssrc,int max_number_of_frames,unsigned int start_bitrate,unsigned int min_bitrate,unsigned int max_bitrate,unsigned int target_bitrate)278 unsigned int RemoteBitrateEstimatorTest::SteadyStateRun(
279     unsigned int ssrc,
280     int max_number_of_frames,
281     unsigned int start_bitrate,
282     unsigned int min_bitrate,
283     unsigned int max_bitrate,
284     unsigned int target_bitrate) {
285   unsigned int bitrate_bps = start_bitrate;
286   bool bitrate_update_seen = false;
287   // Produce |number_of_frames| frames and give them to the estimator.
288   for (int i = 0; i < max_number_of_frames; ++i) {
289     bool overuse = GenerateAndProcessFrame(ssrc, bitrate_bps);
290     if (overuse) {
291       EXPECT_LT(bitrate_observer_->latest_bitrate(), max_bitrate);
292       EXPECT_GT(bitrate_observer_->latest_bitrate(), min_bitrate);
293       bitrate_bps = bitrate_observer_->latest_bitrate();
294       bitrate_update_seen = true;
295     } else if (bitrate_observer_->updated()) {
296       bitrate_bps = bitrate_observer_->latest_bitrate();
297       bitrate_observer_->Reset();
298     }
299     if (bitrate_update_seen && bitrate_bps > target_bitrate) {
300       break;
301     }
302   }
303   EXPECT_TRUE(bitrate_update_seen);
304   return bitrate_bps;
305 }
306 
InitialBehaviorTestHelper(unsigned int expected_converge_bitrate)307 void RemoteBitrateEstimatorTest::InitialBehaviorTestHelper(
308     unsigned int expected_converge_bitrate) {
309   const int kFramerate = 50;  // 50 fps to avoid rounding errors.
310   const int kFrameIntervalMs = 1000 / kFramerate;
311   const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate);
312   unsigned int bitrate_bps = 0;
313   uint32_t timestamp = 0;
314   uint32_t absolute_send_time = 0;
315   std::vector<unsigned int> ssrcs;
316   EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
317   EXPECT_EQ(0u, ssrcs.size());
318   clock_.AdvanceTimeMilliseconds(1000);
319   bitrate_estimator_->Process();
320   EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
321   EXPECT_FALSE(bitrate_observer_->updated());
322   bitrate_observer_->Reset();
323   clock_.AdvanceTimeMilliseconds(1000);
324   // Inserting a packet. Still no valid estimate. We need to wait 5 seconds.
325   IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
326                  absolute_send_time, true);
327   bitrate_estimator_->Process();
328   EXPECT_FALSE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
329   EXPECT_EQ(0u, ssrcs.size());
330   EXPECT_FALSE(bitrate_observer_->updated());
331   bitrate_observer_->Reset();
332   // Inserting packets for 5 seconds to get a valid estimate.
333   for (int i = 0; i < 5 * kFramerate + 1; ++i) {
334     IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
335                    absolute_send_time, true);
336     clock_.AdvanceTimeMilliseconds(1000 / kFramerate);
337     timestamp += 90 * kFrameIntervalMs;
338     absolute_send_time = AddAbsSendTime(absolute_send_time,
339                                         kFrameIntervalAbsSendTime);
340   }
341   bitrate_estimator_->Process();
342   EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
343   ASSERT_EQ(1u, ssrcs.size());
344   EXPECT_EQ(kDefaultSsrc, ssrcs.front());
345   EXPECT_NEAR(expected_converge_bitrate, bitrate_bps, kAcceptedBitrateErrorBps);
346   EXPECT_TRUE(bitrate_observer_->updated());
347   bitrate_observer_->Reset();
348   EXPECT_EQ(bitrate_observer_->latest_bitrate(), bitrate_bps);
349   bitrate_estimator_->RemoveStream(kDefaultSsrc);
350   EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_bps));
351   ASSERT_EQ(0u, ssrcs.size());
352   EXPECT_EQ(0u, bitrate_bps);
353 }
354 
RateIncreaseReorderingTestHelper(uint32_t expected_bitrate_bps)355 void RemoteBitrateEstimatorTest::RateIncreaseReorderingTestHelper(
356     uint32_t expected_bitrate_bps) {
357   const int kFramerate = 50;  // 50 fps to avoid rounding errors.
358   const int kFrameIntervalMs = 1000 / kFramerate;
359   const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate);
360   uint32_t timestamp = 0;
361   uint32_t absolute_send_time = 0;
362   IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
363                  absolute_send_time, true);
364   bitrate_estimator_->Process();
365   EXPECT_FALSE(bitrate_observer_->updated());  // No valid estimate.
366   // Inserting packets for one second to get a valid estimate.
367   for (int i = 0; i < 5 * kFramerate + 1; ++i) {
368     IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp,
369                    absolute_send_time, true);
370     clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
371     timestamp += 90 * kFrameIntervalMs;
372     absolute_send_time = AddAbsSendTime(absolute_send_time,
373                                         kFrameIntervalAbsSendTime);
374   }
375   bitrate_estimator_->Process();
376   EXPECT_TRUE(bitrate_observer_->updated());
377   EXPECT_NEAR(expected_bitrate_bps,
378               bitrate_observer_->latest_bitrate(),
379               kAcceptedBitrateErrorBps);
380   for (int i = 0; i < 10; ++i) {
381     clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs);
382     timestamp += 2 * 90 * kFrameIntervalMs;
383     absolute_send_time = AddAbsSendTime(absolute_send_time,
384                                         2 * kFrameIntervalAbsSendTime);
385     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
386                    absolute_send_time, true);
387     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(),
388                    timestamp - 90 * kFrameIntervalMs,
389                    AddAbsSendTime(absolute_send_time,
390                                   -static_cast<int>(kFrameIntervalAbsSendTime)),
391                    true);
392   }
393   bitrate_estimator_->Process();
394   EXPECT_TRUE(bitrate_observer_->updated());
395   EXPECT_NEAR(expected_bitrate_bps,
396               bitrate_observer_->latest_bitrate(),
397               kAcceptedBitrateErrorBps);
398 }
399 
400 // Make sure we initially increase the bitrate as expected.
RateIncreaseRtpTimestampsTestHelper(int expected_iterations)401 void RemoteBitrateEstimatorTest::RateIncreaseRtpTimestampsTestHelper(
402     int expected_iterations) {
403   // This threshold corresponds approximately to increasing linearly with
404   // bitrate(i) = 1.04 * bitrate(i-1) + 1000
405   // until bitrate(i) > 500000, with bitrate(1) ~= 30000.
406   unsigned int bitrate_bps = 30000;
407   int iterations = 0;
408   AddDefaultStream();
409   // Feed the estimator with a stream of packets and verify that it reaches
410   // 500 kbps at the expected time.
411   while (bitrate_bps < 5e5) {
412     bool overuse = GenerateAndProcessFrame(kDefaultSsrc, bitrate_bps);
413     if (overuse) {
414       EXPECT_GT(bitrate_observer_->latest_bitrate(), bitrate_bps);
415       bitrate_bps = bitrate_observer_->latest_bitrate();
416       bitrate_observer_->Reset();
417     } else if (bitrate_observer_->updated()) {
418       bitrate_bps = bitrate_observer_->latest_bitrate();
419       bitrate_observer_->Reset();
420     }
421     ++iterations;
422     ASSERT_LE(iterations, expected_iterations);
423   }
424   ASSERT_EQ(expected_iterations, iterations);
425 }
426 
CapacityDropTestHelper(int number_of_streams,bool wrap_time_stamp,unsigned int expected_bitrate_drop_delta)427 void RemoteBitrateEstimatorTest::CapacityDropTestHelper(
428     int number_of_streams,
429     bool wrap_time_stamp,
430     unsigned int expected_bitrate_drop_delta) {
431   const int kFramerate = 30;
432   const int kStartBitrate = 900e3;
433   const int kMinExpectedBitrate = 800e3;
434   const int kMaxExpectedBitrate = 1100e3;
435   const unsigned int kInitialCapacityBps = 1000e3;
436   const unsigned int kReducedCapacityBps = 500e3;
437 
438   int steady_state_time = 0;
439   if (number_of_streams <= 1) {
440     steady_state_time = 10;
441     AddDefaultStream();
442   } else {
443     steady_state_time = 10 * number_of_streams;
444     int bitrate_sum = 0;
445     int kBitrateDenom = number_of_streams * (number_of_streams - 1);
446     for (int i = 0; i < number_of_streams; i++) {
447       // First stream gets half available bitrate, while the rest share the
448       // remaining half i.e.: 1/2 = Sum[n/(N*(N-1))] for n=1..N-1 (rounded up)
449       int bitrate = kStartBitrate / 2;
450       if (i > 0) {
451         bitrate = (kStartBitrate * i + kBitrateDenom / 2) / kBitrateDenom;
452       }
453       stream_generator_->AddStream(new testing::RtpStream(
454           kFramerate,                     // Frames per second.
455           bitrate,                        // Bitrate.
456           kDefaultSsrc + i,               // SSRC.
457           90000,                          // RTP frequency.
458           0xFFFFF000 ^ (~0 << (32 - i)),  // Timestamp offset.
459           0));                            // RTCP receive time.
460       bitrate_sum += bitrate;
461     }
462     ASSERT_EQ(bitrate_sum, kStartBitrate);
463   }
464   if (wrap_time_stamp) {
465     stream_generator_->set_rtp_timestamp_offset(kDefaultSsrc,
466         std::numeric_limits<uint32_t>::max() - steady_state_time * 90000);
467   }
468 
469   // Run in steady state to make the estimator converge.
470   stream_generator_->set_capacity_bps(kInitialCapacityBps);
471   unsigned int bitrate_bps = SteadyStateRun(kDefaultSsrc,
472                                             steady_state_time * kFramerate,
473                                             kStartBitrate,
474                                             kMinExpectedBitrate,
475                                             kMaxExpectedBitrate,
476                                             kInitialCapacityBps);
477   EXPECT_NEAR(kInitialCapacityBps, bitrate_bps, 110000u);
478   bitrate_observer_->Reset();
479 
480   // Reduce the capacity and verify the decrease time.
481   stream_generator_->set_capacity_bps(kReducedCapacityBps);
482   int64_t overuse_start_time = clock_.TimeInMilliseconds();
483   int64_t bitrate_drop_time = -1;
484   for (int i = 0; i < 100 * number_of_streams; ++i) {
485     GenerateAndProcessFrame(kDefaultSsrc, bitrate_bps);
486     // Check for either increase or decrease.
487     if (bitrate_observer_->updated()) {
488       if (bitrate_drop_time == -1 &&
489           bitrate_observer_->latest_bitrate() <= kReducedCapacityBps) {
490         bitrate_drop_time = clock_.TimeInMilliseconds();
491       }
492       bitrate_bps = bitrate_observer_->latest_bitrate();
493       bitrate_observer_->Reset();
494     }
495   }
496 
497   EXPECT_NEAR(expected_bitrate_drop_delta,
498               bitrate_drop_time - overuse_start_time, 33);
499 
500   // Remove stream one by one.
501   unsigned int latest_bps = 0;
502   std::vector<unsigned int> ssrcs;
503   for (int i = 0; i < number_of_streams; i++) {
504     EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &latest_bps));
505     EXPECT_EQ(number_of_streams - i, static_cast<int>(ssrcs.size()));
506     EXPECT_EQ(bitrate_bps, latest_bps);
507     for (int j = i; j < number_of_streams; j++) {
508       EXPECT_EQ(kDefaultSsrc + j, ssrcs[j - i]);
509     }
510     bitrate_estimator_->RemoveStream(kDefaultSsrc + i);
511   }
512   EXPECT_TRUE(bitrate_estimator_->LatestEstimate(&ssrcs, &latest_bps));
513   EXPECT_EQ(0u, ssrcs.size());
514   EXPECT_EQ(0u, latest_bps);
515 }
516 
TestTimestampGroupingTestHelper()517 void RemoteBitrateEstimatorTest::TestTimestampGroupingTestHelper() {
518   const int kFramerate = 50;  // 50 fps to avoid rounding errors.
519   const int kFrameIntervalMs = 1000 / kFramerate;
520   const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate);
521   uint32_t timestamp = 0;
522   // Initialize absolute_send_time (24 bits) so that it will definitely wrap
523   // during the test.
524   uint32_t absolute_send_time = AddAbsSendTime(
525       (1 << 24), -static_cast<int>(50 * kFrameIntervalAbsSendTime));
526   // Initial set of frames to increase the bitrate. 6 seconds to have enough
527   // time for the first estimate to be generated and for Process() to be called.
528   for (int i = 0; i <= 6 * kFramerate; ++i) {
529     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
530                    absolute_send_time, true);
531     bitrate_estimator_->Process();
532     clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
533     timestamp += 90 * kFrameIntervalMs;
534     absolute_send_time = AddAbsSendTime(absolute_send_time,
535                                         kFrameIntervalAbsSendTime);
536   }
537   EXPECT_TRUE(bitrate_observer_->updated());
538   EXPECT_GE(bitrate_observer_->latest_bitrate(), 400000u);
539 
540   // Insert batches of frames which were sent very close in time. Also simulate
541   // capacity over-use to see that we back off correctly.
542   const int kTimestampGroupLength = 15;
543   const uint32_t kTimestampGroupLengthAbsSendTime =
544       AbsSendTime(kTimestampGroupLength, 90000);
545   const uint32_t kSingleRtpTickAbsSendTime = AbsSendTime(1, 90000);
546   for (int i = 0; i < 100; ++i) {
547     for (int j = 0; j < kTimestampGroupLength; ++j) {
548       // Insert |kTimestampGroupLength| frames with just 1 timestamp ticks in
549       // between. Should be treated as part of the same group by the estimator.
550       IncomingPacket(kDefaultSsrc, 100, clock_.TimeInMilliseconds(), timestamp,
551                      absolute_send_time, true);
552       clock_.AdvanceTimeMilliseconds(kFrameIntervalMs / kTimestampGroupLength);
553       timestamp += 1;
554       absolute_send_time = AddAbsSendTime(absolute_send_time,
555                                           kSingleRtpTickAbsSendTime);
556     }
557     // Increase time until next batch to simulate over-use.
558     clock_.AdvanceTimeMilliseconds(10);
559     timestamp += 90 * kFrameIntervalMs - kTimestampGroupLength;
560     absolute_send_time = AddAbsSendTime(
561         absolute_send_time,
562         AddAbsSendTime(kFrameIntervalAbsSendTime,
563                        -static_cast<int>(kTimestampGroupLengthAbsSendTime)));
564     bitrate_estimator_->Process();
565   }
566   EXPECT_TRUE(bitrate_observer_->updated());
567   // Should have reduced the estimate.
568   EXPECT_LT(bitrate_observer_->latest_bitrate(), 400000u);
569 }
570 
TestGetStatsHelper()571 void RemoteBitrateEstimatorTest::TestGetStatsHelper() {
572   const int kFramerate = 100;
573   const int kFrameIntervalMs = 1000 / kFramerate;
574   const int kBurstThresholdMs = 5;
575   const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate);
576   uint32_t timestamp = 0;
577   // Initialize absolute_send_time (24 bits) so that it will definitely wrap
578   // during the test.
579   uint32_t absolute_send_time =
580       AddAbsSendTime((1 << 24),
581       -(50 * static_cast<int>(kFrameIntervalAbsSendTime)));
582 
583   // Inject propagation_time_delta of kFrameIntervalMs.
584   for (size_t i = 0; i < 3; ++i) {
585     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
586                    absolute_send_time, true);
587     timestamp += kFrameIntervalMs;
588     // Insert a kFrameIntervalMs propagation_time_delta.
589     clock_.AdvanceTimeMilliseconds(kFrameIntervalMs * 2);
590     absolute_send_time = AddAbsSendTime(absolute_send_time,
591                                         kFrameIntervalAbsSendTime);
592   }
593   ReceiveBandwidthEstimatorStats stats;
594   EXPECT_TRUE(bitrate_estimator_->GetStats(&stats));
595   EXPECT_EQ(1U, stats.recent_propagation_time_delta_ms.size());
596   EXPECT_EQ(kFrameIntervalMs, stats.recent_propagation_time_delta_ms[0]);
597   EXPECT_EQ(1U, stats.recent_arrival_time_ms.size());
598   EXPECT_EQ(kFrameIntervalMs, stats.total_propagation_time_delta_ms);
599 
600   // Inject negative propagation_time_deltas. The total propagation_time_delta
601   // should be adjusted to 0.
602   for (size_t i = 0; i < 3; ++i) {
603     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
604                    absolute_send_time, true);
605     timestamp += 10 * kFrameIntervalMs;
606     clock_.AdvanceTimeMilliseconds(kBurstThresholdMs + 1);
607     absolute_send_time = AddAbsSendTime(absolute_send_time,
608                                         10 * kFrameIntervalAbsSendTime);
609   }
610   EXPECT_TRUE(bitrate_estimator_->GetStats(&stats));
611   EXPECT_EQ(0, stats.total_propagation_time_delta_ms);
612 
613   // Send more than 1000 frames and make sure the stats queues stays within
614   // limits.
615   for (size_t i = 0; i < 1001; ++i) {
616     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
617                    absolute_send_time, true);
618     timestamp += kFrameIntervalMs;
619     absolute_send_time = AddAbsSendTime(absolute_send_time,
620                                         kFrameIntervalAbsSendTime);
621   }
622   EXPECT_TRUE(bitrate_estimator_->GetStats(&stats));
623   EXPECT_LE(stats.recent_propagation_time_delta_ms.size(), 1000U);
624   EXPECT_LE(stats.recent_arrival_time_ms.size(), 1000U);
625 
626   // Move the clock over the 1000ms limit.
627   clock_.AdvanceTimeMilliseconds(2000);
628   EXPECT_TRUE(bitrate_estimator_->GetStats(&stats));
629   EXPECT_EQ(0U, stats.recent_propagation_time_delta_ms.size());
630 }
631 
TestWrappingHelper(int silence_time_s)632 void RemoteBitrateEstimatorTest::TestWrappingHelper(
633     int silence_time_s) {
634   const int kFramerate = 100;
635   const int kFrameIntervalMs = 1000 / kFramerate;
636   const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate);
637   uint32_t absolute_send_time = 0;
638   uint32_t timestamp = 0;
639 
640   for (size_t i = 0; i < 3000; ++i) {
641     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
642                    absolute_send_time, true);
643     timestamp += kFrameIntervalMs;
644     clock_.AdvanceTimeMilliseconds(kFrameIntervalMs);
645     absolute_send_time = AddAbsSendTime(absolute_send_time,
646                                         kFrameIntervalAbsSendTime);
647     bitrate_estimator_->Process();
648   }
649   unsigned int bitrate_before = 0;
650   std::vector<unsigned int> ssrcs;
651   bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_before);
652 
653   clock_.AdvanceTimeMilliseconds(silence_time_s * 1000);
654   absolute_send_time = AddAbsSendTime(absolute_send_time,
655                                       AbsSendTime(silence_time_s, 1));
656   bitrate_estimator_->Process();
657   for (size_t i = 0; i < 100; ++i) {
658     IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp,
659                    absolute_send_time, true);
660     timestamp += kFrameIntervalMs;
661     clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs);
662     absolute_send_time = AddAbsSendTime(absolute_send_time,
663                                         kFrameIntervalAbsSendTime);
664     bitrate_estimator_->Process();
665   }
666   unsigned int bitrate_after = 0;
667   bitrate_estimator_->LatestEstimate(&ssrcs, &bitrate_after);
668   EXPECT_LT(bitrate_after, bitrate_before);
669 }
670 }  // namespace webrtc
671