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 23 void TestBitrateObserver::OnReceiveBitrateChanged( 24 const std::vector<unsigned int>& ssrcs, 25 unsigned int bitrate) { 26 latest_bitrate_ = bitrate; 27 updated_ = true; 28 } 29 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 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. 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. 77 double RtpStream::next_rtp_time() const { 78 return next_rtp_time_; 79 } 80 81 // Generates an RTCP packet. 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 98 void RtpStream::set_bitrate_bps(int bitrate_bps) { 99 ASSERT_GE(bitrate_bps, 0); 100 bitrate_bps_ = bitrate_bps; 101 } 102 103 int RtpStream::bitrate_bps() const { 104 return bitrate_bps_; 105 } 106 107 unsigned int RtpStream::ssrc() const { 108 return ssrc_; 109 } 110 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 116 StreamGenerator::StreamGenerator(int capacity, double time_now) 117 : capacity_(capacity), 118 prev_arrival_time_us_(time_now) {} 119 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. 129 void StreamGenerator::AddStream(RtpStream* stream) { 130 streams_[stream->ssrc()] = stream; 131 } 132 133 // Set the link capacity. 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. 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|. 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. 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 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 199 RemoteBitrateEstimatorTest::~RemoteBitrateEstimatorTest() {} 200 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 211 uint32_t RemoteBitrateEstimatorTest::AbsSendTime(int64_t t, int64_t denom) { 212 return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful; 213 } 214 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 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. 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. 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 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 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. 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 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 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 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 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
