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