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