diff options
Diffstat (limited to 'third_party/libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc')
| -rw-r--r-- | third_party/libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc | 600 |
1 files changed, 600 insertions, 0 deletions
diff --git a/third_party/libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc b/third_party/libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc new file mode 100644 index 0000000000..f8652b455e --- /dev/null +++ b/third_party/libwebrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.cc @@ -0,0 +1,600 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ +#include "modules/remote_bitrate_estimator/remote_bitrate_estimator_unittest_helper.h" + +#include <algorithm> +#include <limits> +#include <utility> + +#include "modules/rtp_rtcp/include/rtp_header_extension_map.h" +#include "modules/rtp_rtcp/source/rtp_header_extensions.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" +#include "rtc_base/checks.h" + +namespace webrtc { + +const size_t kMtu = 1200; +const uint32_t kAcceptedBitrateErrorBps = 50000; + +// Number of packets needed before we have a valid estimate. +const int kNumInitialPackets = 2; + +namespace testing { + +void TestBitrateObserver::OnReceiveBitrateChanged( + const std::vector<uint32_t>& ssrcs, + uint32_t bitrate) { + latest_bitrate_ = bitrate; + updated_ = true; +} + +RtpStream::RtpStream(int fps, + int bitrate_bps, + uint32_t ssrc, + uint32_t frequency, + uint32_t timestamp_offset, + int64_t rtcp_receive_time) + : fps_(fps), + bitrate_bps_(bitrate_bps), + ssrc_(ssrc), + frequency_(frequency), + next_rtp_time_(0), + next_rtcp_time_(rtcp_receive_time), + rtp_timestamp_offset_(timestamp_offset), + kNtpFracPerMs(4.294967296E6) { + RTC_DCHECK_GT(fps_, 0); +} + +void RtpStream::set_rtp_timestamp_offset(uint32_t offset) { + rtp_timestamp_offset_ = offset; +} + +// Generates a new frame for this stream. If called too soon after the +// previous frame, no frame will be generated. The frame is split into +// packets. +int64_t RtpStream::GenerateFrame(int64_t time_now_us, PacketList* packets) { + if (time_now_us < next_rtp_time_) { + return next_rtp_time_; + } + RTC_DCHECK(packets); + size_t bits_per_frame = (bitrate_bps_ + fps_ / 2) / fps_; + size_t n_packets = + std::max<size_t>((bits_per_frame + 4 * kMtu) / (8 * kMtu), 1u); + size_t packet_size = (bits_per_frame + 4 * n_packets) / (8 * n_packets); + for (size_t i = 0; i < n_packets; ++i) { + RtpPacket* packet = new RtpPacket; + packet->send_time = time_now_us + kSendSideOffsetUs; + packet->size = packet_size; + packet->rtp_timestamp = + rtp_timestamp_offset_ + + static_cast<uint32_t>(((frequency_ / 1000) * packet->send_time + 500) / + 1000); + packet->ssrc = ssrc_; + packets->push_back(packet); + } + next_rtp_time_ = time_now_us + (1000000 + fps_ / 2) / fps_; + return next_rtp_time_; +} + +// The send-side time when the next frame can be generated. +int64_t RtpStream::next_rtp_time() const { + return next_rtp_time_; +} + +// Generates an RTCP packet. +RtpStream::RtcpPacket* RtpStream::Rtcp(int64_t time_now_us) { + if (time_now_us < next_rtcp_time_) { + return NULL; + } + RtcpPacket* rtcp = new RtcpPacket; + int64_t send_time_us = time_now_us + kSendSideOffsetUs; + rtcp->timestamp = + rtp_timestamp_offset_ + + static_cast<uint32_t>(((frequency_ / 1000) * send_time_us + 500) / 1000); + rtcp->ntp_secs = send_time_us / 1000000; + rtcp->ntp_frac = + static_cast<int64_t>((send_time_us % 1000000) * kNtpFracPerMs); + rtcp->ssrc = ssrc_; + next_rtcp_time_ = time_now_us + kRtcpIntervalUs; + return rtcp; +} + +void RtpStream::set_bitrate_bps(int bitrate_bps) { + ASSERT_GE(bitrate_bps, 0); + bitrate_bps_ = bitrate_bps; +} + +int RtpStream::bitrate_bps() const { + return bitrate_bps_; +} + +uint32_t RtpStream::ssrc() const { + return ssrc_; +} + +bool RtpStream::Compare(const std::pair<uint32_t, RtpStream*>& left, + const std::pair<uint32_t, RtpStream*>& right) { + return left.second->next_rtp_time_ < right.second->next_rtp_time_; +} + +StreamGenerator::StreamGenerator(int capacity, int64_t time_now) + : capacity_(capacity), prev_arrival_time_us_(time_now) {} + +StreamGenerator::~StreamGenerator() { + for (StreamMap::iterator it = streams_.begin(); it != streams_.end(); ++it) { + delete it->second; + } + streams_.clear(); +} + +// Add a new stream. +void StreamGenerator::AddStream(RtpStream* stream) { + streams_[stream->ssrc()] = stream; +} + +// Set the link capacity. +void StreamGenerator::set_capacity_bps(int capacity_bps) { + ASSERT_GT(capacity_bps, 0); + capacity_ = capacity_bps; +} + +// Divides `bitrate_bps` among all streams. The allocated bitrate per stream +// is decided by the current allocation ratios. +void StreamGenerator::SetBitrateBps(int bitrate_bps) { + ASSERT_GE(streams_.size(), 0u); + int total_bitrate_before = 0; + for (StreamMap::iterator it = streams_.begin(); it != streams_.end(); ++it) { + total_bitrate_before += it->second->bitrate_bps(); + } + int64_t bitrate_before = 0; + int total_bitrate_after = 0; + for (StreamMap::iterator it = streams_.begin(); it != streams_.end(); ++it) { + bitrate_before += it->second->bitrate_bps(); + int64_t bitrate_after = + (bitrate_before * bitrate_bps + total_bitrate_before / 2) / + total_bitrate_before; + it->second->set_bitrate_bps(bitrate_after - total_bitrate_after); + total_bitrate_after += it->second->bitrate_bps(); + } + ASSERT_EQ(bitrate_before, total_bitrate_before); + EXPECT_EQ(total_bitrate_after, bitrate_bps); +} + +// Set the RTP timestamp offset for the stream identified by `ssrc`. +void StreamGenerator::set_rtp_timestamp_offset(uint32_t ssrc, uint32_t offset) { + streams_[ssrc]->set_rtp_timestamp_offset(offset); +} + +// TODO(holmer): Break out the channel simulation part from this class to make +// it possible to simulate different types of channels. +int64_t StreamGenerator::GenerateFrame(RtpStream::PacketList* packets, + int64_t time_now_us) { + RTC_DCHECK(packets); + RTC_DCHECK(packets->empty()); + RTC_DCHECK_GT(capacity_, 0); + StreamMap::iterator it = + std::min_element(streams_.begin(), streams_.end(), RtpStream::Compare); + (*it).second->GenerateFrame(time_now_us, packets); + for (RtpStream::PacketList::iterator packet_it = packets->begin(); + packet_it != packets->end(); ++packet_it) { + int capacity_bpus = capacity_ / 1000; + int64_t required_network_time_us = + (8 * 1000 * (*packet_it)->size + capacity_bpus / 2) / capacity_bpus; + prev_arrival_time_us_ = + std::max(time_now_us + required_network_time_us, + prev_arrival_time_us_ + required_network_time_us); + (*packet_it)->arrival_time = prev_arrival_time_us_; + } + it = std::min_element(streams_.begin(), streams_.end(), RtpStream::Compare); + return std::max((*it).second->next_rtp_time(), time_now_us); +} +} // namespace testing + +RemoteBitrateEstimatorTest::RemoteBitrateEstimatorTest() + : clock_(100000000), + bitrate_observer_(new testing::TestBitrateObserver), + stream_generator_( + new testing::StreamGenerator(1e6, // Capacity. + clock_.TimeInMicroseconds())), + arrival_time_offset_ms_(0) {} + +RemoteBitrateEstimatorTest::~RemoteBitrateEstimatorTest() {} + +void RemoteBitrateEstimatorTest::AddDefaultStream() { + stream_generator_->AddStream( + new testing::RtpStream(30, // Frames per second. + 3e5, // Bitrate. + 1, // SSRC. + 90000, // RTP frequency. + 0xFFFFF000, // Timestamp offset. + 0)); // RTCP receive time. +} + +uint32_t RemoteBitrateEstimatorTest::AbsSendTime(int64_t t, int64_t denom) { + return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful; +} + +uint32_t RemoteBitrateEstimatorTest::AddAbsSendTime(uint32_t t1, uint32_t t2) { + return (t1 + t2) & 0x00fffffful; +} + +const uint32_t RemoteBitrateEstimatorTest::kDefaultSsrc = 1; + +void RemoteBitrateEstimatorTest::IncomingPacket(uint32_t ssrc, + size_t payload_size, + int64_t arrival_time, + uint32_t rtp_timestamp, + uint32_t absolute_send_time) { + RtpHeaderExtensionMap extensions; + extensions.Register<AbsoluteSendTime>(1); + RtpPacketReceived rtp_packet(&extensions); + rtp_packet.SetSsrc(ssrc); + rtp_packet.SetTimestamp(rtp_timestamp); + rtp_packet.SetExtension<AbsoluteSendTime>(absolute_send_time); + rtp_packet.SetPayloadSize(payload_size); + rtp_packet.set_arrival_time( + Timestamp::Millis(arrival_time + arrival_time_offset_ms_)); + + bitrate_estimator_->IncomingPacket(rtp_packet); +} + +// Generates a frame of packets belonging to a stream at a given bitrate and +// with a given ssrc. The stream is pushed through a very simple simulated +// network, and is then given to the receive-side bandwidth estimator. +// Returns true if an over-use was seen, false otherwise. +// The StreamGenerator::updated() should be used to check for any changes in +// target bitrate after the call to this function. +bool RemoteBitrateEstimatorTest::GenerateAndProcessFrame(uint32_t ssrc, + uint32_t bitrate_bps) { + RTC_DCHECK_GT(bitrate_bps, 0); + stream_generator_->SetBitrateBps(bitrate_bps); + testing::RtpStream::PacketList packets; + int64_t next_time_us = + stream_generator_->GenerateFrame(&packets, clock_.TimeInMicroseconds()); + bool overuse = false; + while (!packets.empty()) { + testing::RtpStream::RtpPacket* packet = packets.front(); + bitrate_observer_->Reset(); + // The simulated clock should match the time of packet->arrival_time + // since both are used in IncomingPacket(). + clock_.AdvanceTimeMicroseconds(packet->arrival_time - + clock_.TimeInMicroseconds()); + IncomingPacket(packet->ssrc, packet->size, + (packet->arrival_time + 500) / 1000, packet->rtp_timestamp, + AbsSendTime(packet->send_time, 1000000)); + if (bitrate_observer_->updated()) { + if (bitrate_observer_->latest_bitrate() < bitrate_bps) + overuse = true; + } + delete packet; + packets.pop_front(); + } + bitrate_estimator_->Process(); + clock_.AdvanceTimeMicroseconds(next_time_us - clock_.TimeInMicroseconds()); + return overuse; +} + +// Run the bandwidth estimator with a stream of `number_of_frames` frames, or +// until it reaches `target_bitrate`. +// Can for instance be used to run the estimator for some time to get it +// into a steady state. +uint32_t RemoteBitrateEstimatorTest::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) { + uint32_t bitrate_bps = start_bitrate; + bool bitrate_update_seen = false; + // Produce `number_of_frames` frames and give them to the estimator. + for (int i = 0; i < max_number_of_frames; ++i) { + bool overuse = GenerateAndProcessFrame(ssrc, bitrate_bps); + if (overuse) { + EXPECT_LT(bitrate_observer_->latest_bitrate(), max_bitrate); + EXPECT_GT(bitrate_observer_->latest_bitrate(), min_bitrate); + bitrate_bps = bitrate_observer_->latest_bitrate(); + bitrate_update_seen = true; + } else if (bitrate_observer_->updated()) { + bitrate_bps = bitrate_observer_->latest_bitrate(); + bitrate_observer_->Reset(); + } + if (bitrate_update_seen && bitrate_bps > target_bitrate) { + break; + } + } + EXPECT_TRUE(bitrate_update_seen); + return bitrate_bps; +} + +void RemoteBitrateEstimatorTest::InitialBehaviorTestHelper( + uint32_t expected_converge_bitrate) { + const int kFramerate = 50; // 50 fps to avoid rounding errors. + const int kFrameIntervalMs = 1000 / kFramerate; + const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate); + uint32_t timestamp = 0; + uint32_t absolute_send_time = 0; + EXPECT_EQ(bitrate_estimator_->LatestEstimate(), DataRate::Zero()); + clock_.AdvanceTimeMilliseconds(1000); + bitrate_estimator_->Process(); + EXPECT_EQ(bitrate_estimator_->LatestEstimate(), DataRate::Zero()); + EXPECT_FALSE(bitrate_observer_->updated()); + bitrate_observer_->Reset(); + clock_.AdvanceTimeMilliseconds(1000); + // Inserting packets for 5 seconds to get a valid estimate. + for (int i = 0; i < 5 * kFramerate + 1 + kNumInitialPackets; ++i) { + if (i == kNumInitialPackets) { + bitrate_estimator_->Process(); + EXPECT_EQ(bitrate_estimator_->LatestEstimate(), DataRate::Zero()); + EXPECT_FALSE(bitrate_observer_->updated()); + bitrate_observer_->Reset(); + } + + IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp, + absolute_send_time); + clock_.AdvanceTimeMilliseconds(1000 / kFramerate); + timestamp += 90 * kFrameIntervalMs; + absolute_send_time = + AddAbsSendTime(absolute_send_time, kFrameIntervalAbsSendTime); + } + bitrate_estimator_->Process(); + uint32_t bitrate_bps = bitrate_estimator_->LatestEstimate().bps<uint32_t>(); + EXPECT_NEAR(expected_converge_bitrate, bitrate_bps, kAcceptedBitrateErrorBps); + EXPECT_TRUE(bitrate_observer_->updated()); + bitrate_observer_->Reset(); + EXPECT_EQ(bitrate_observer_->latest_bitrate(), bitrate_bps); + bitrate_estimator_->RemoveStream(kDefaultSsrc); + EXPECT_EQ(bitrate_estimator_->LatestEstimate(), DataRate::Zero()); +} + +void RemoteBitrateEstimatorTest::RateIncreaseReorderingTestHelper( + uint32_t expected_bitrate_bps) { + const int kFramerate = 50; // 50 fps to avoid rounding errors. + const int kFrameIntervalMs = 1000 / kFramerate; + const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate); + uint32_t timestamp = 0; + uint32_t absolute_send_time = 0; + // Inserting packets for five seconds to get a valid estimate. + for (int i = 0; i < 5 * kFramerate + 1 + kNumInitialPackets; ++i) { + // TODO(sprang): Remove this hack once the single stream estimator is gone, + // as it doesn't do anything in Process(). + if (i == kNumInitialPackets) { + // Process after we have enough frames to get a valid input rate estimate. + bitrate_estimator_->Process(); + EXPECT_FALSE(bitrate_observer_->updated()); // No valid estimate. + } + + IncomingPacket(kDefaultSsrc, kMtu, clock_.TimeInMilliseconds(), timestamp, + absolute_send_time); + clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); + timestamp += 90 * kFrameIntervalMs; + absolute_send_time = + AddAbsSendTime(absolute_send_time, kFrameIntervalAbsSendTime); + } + bitrate_estimator_->Process(); + EXPECT_TRUE(bitrate_observer_->updated()); + EXPECT_NEAR(expected_bitrate_bps, bitrate_observer_->latest_bitrate(), + kAcceptedBitrateErrorBps); + for (int i = 0; i < 10; ++i) { + clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs); + timestamp += 2 * 90 * kFrameIntervalMs; + absolute_send_time = + AddAbsSendTime(absolute_send_time, 2 * kFrameIntervalAbsSendTime); + IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, + absolute_send_time); + IncomingPacket( + kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), + timestamp - 90 * kFrameIntervalMs, + AddAbsSendTime(absolute_send_time, + -static_cast<int>(kFrameIntervalAbsSendTime))); + } + bitrate_estimator_->Process(); + EXPECT_TRUE(bitrate_observer_->updated()); + EXPECT_NEAR(expected_bitrate_bps, bitrate_observer_->latest_bitrate(), + kAcceptedBitrateErrorBps); +} + +// Make sure we initially increase the bitrate as expected. +void RemoteBitrateEstimatorTest::RateIncreaseRtpTimestampsTestHelper( + int expected_iterations) { + // This threshold corresponds approximately to increasing linearly with + // bitrate(i) = 1.04 * bitrate(i-1) + 1000 + // until bitrate(i) > 500000, with bitrate(1) ~= 30000. + uint32_t bitrate_bps = 30000; + int iterations = 0; + AddDefaultStream(); + // Feed the estimator with a stream of packets and verify that it reaches + // 500 kbps at the expected time. + while (bitrate_bps < 5e5) { + bool overuse = GenerateAndProcessFrame(kDefaultSsrc, bitrate_bps); + if (overuse) { + EXPECT_GT(bitrate_observer_->latest_bitrate(), bitrate_bps); + bitrate_bps = bitrate_observer_->latest_bitrate(); + bitrate_observer_->Reset(); + } else if (bitrate_observer_->updated()) { + bitrate_bps = bitrate_observer_->latest_bitrate(); + bitrate_observer_->Reset(); + } + ++iterations; + ASSERT_LE(iterations, expected_iterations); + } + ASSERT_EQ(expected_iterations, iterations); +} + +void RemoteBitrateEstimatorTest::CapacityDropTestHelper( + int number_of_streams, + bool wrap_time_stamp, + uint32_t expected_bitrate_drop_delta, + int64_t receiver_clock_offset_change_ms) { + const int kFramerate = 30; + const int kStartBitrate = 900e3; + const int kMinExpectedBitrate = 800e3; + const int kMaxExpectedBitrate = 1100e3; + const uint32_t kInitialCapacityBps = 1000e3; + const uint32_t kReducedCapacityBps = 500e3; + + int steady_state_time = 0; + if (number_of_streams <= 1) { + steady_state_time = 10; + AddDefaultStream(); + } else { + steady_state_time = 10 * number_of_streams; + int bitrate_sum = 0; + int kBitrateDenom = number_of_streams * (number_of_streams - 1); + for (int i = 0; i < number_of_streams; i++) { + // First stream gets half available bitrate, while the rest share the + // remaining half i.e.: 1/2 = Sum[n/(N*(N-1))] for n=1..N-1 (rounded up) + int bitrate = kStartBitrate / 2; + if (i > 0) { + bitrate = (kStartBitrate * i + kBitrateDenom / 2) / kBitrateDenom; + } + uint32_t mask = ~0ull << (32 - i); + stream_generator_->AddStream( + new testing::RtpStream(kFramerate, // Frames per second. + bitrate, // Bitrate. + kDefaultSsrc + i, // SSRC. + 90000, // RTP frequency. + 0xFFFFF000u ^ mask, // Timestamp offset. + 0)); // RTCP receive time. + bitrate_sum += bitrate; + } + ASSERT_EQ(bitrate_sum, kStartBitrate); + } + if (wrap_time_stamp) { + stream_generator_->set_rtp_timestamp_offset( + kDefaultSsrc, + std::numeric_limits<uint32_t>::max() - steady_state_time * 90000); + } + + // Run in steady state to make the estimator converge. + stream_generator_->set_capacity_bps(kInitialCapacityBps); + uint32_t bitrate_bps = SteadyStateRun( + kDefaultSsrc, steady_state_time * kFramerate, kStartBitrate, + kMinExpectedBitrate, kMaxExpectedBitrate, kInitialCapacityBps); + EXPECT_GE(bitrate_bps, 0.85 * kInitialCapacityBps); + EXPECT_LE(bitrate_bps, 1.05 * kInitialCapacityBps); + bitrate_observer_->Reset(); + + // Add an offset to make sure the BWE can handle it. + arrival_time_offset_ms_ += receiver_clock_offset_change_ms; + + // Reduce the capacity and verify the decrease time. + stream_generator_->set_capacity_bps(kReducedCapacityBps); + int64_t overuse_start_time = clock_.TimeInMilliseconds(); + int64_t bitrate_drop_time = -1; + for (int i = 0; i < 100 * number_of_streams; ++i) { + GenerateAndProcessFrame(kDefaultSsrc, bitrate_bps); + if (bitrate_drop_time == -1 && + bitrate_observer_->latest_bitrate() <= kReducedCapacityBps) { + bitrate_drop_time = clock_.TimeInMilliseconds(); + } + if (bitrate_observer_->updated()) + bitrate_bps = bitrate_observer_->latest_bitrate(); + } + + EXPECT_NEAR(expected_bitrate_drop_delta, + bitrate_drop_time - overuse_start_time, 33); + + // Remove stream one by one. + for (int i = 0; i < number_of_streams; i++) { + EXPECT_EQ(bitrate_estimator_->LatestEstimate().bps(), bitrate_bps); + bitrate_estimator_->RemoveStream(kDefaultSsrc + i); + } + EXPECT_EQ(bitrate_estimator_->LatestEstimate(), DataRate::Zero()); +} + +void RemoteBitrateEstimatorTest::TestTimestampGroupingTestHelper() { + const int kFramerate = 50; // 50 fps to avoid rounding errors. + const int kFrameIntervalMs = 1000 / kFramerate; + const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate); + uint32_t timestamp = 0; + // Initialize absolute_send_time (24 bits) so that it will definitely wrap + // during the test. + uint32_t absolute_send_time = AddAbsSendTime( + (1 << 24), -static_cast<int>(50 * kFrameIntervalAbsSendTime)); + // Initial set of frames to increase the bitrate. 6 seconds to have enough + // time for the first estimate to be generated and for Process() to be called. + for (int i = 0; i <= 6 * kFramerate; ++i) { + IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, + absolute_send_time); + bitrate_estimator_->Process(); + clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); + timestamp += 90 * kFrameIntervalMs; + absolute_send_time = + AddAbsSendTime(absolute_send_time, kFrameIntervalAbsSendTime); + } + EXPECT_TRUE(bitrate_observer_->updated()); + EXPECT_GE(bitrate_observer_->latest_bitrate(), 400000u); + + // Insert batches of frames which were sent very close in time. Also simulate + // capacity over-use to see that we back off correctly. + const int kTimestampGroupLength = 15; + const uint32_t kTimestampGroupLengthAbsSendTime = + AbsSendTime(kTimestampGroupLength, 90000); + const uint32_t kSingleRtpTickAbsSendTime = AbsSendTime(1, 90000); + for (int i = 0; i < 100; ++i) { + for (int j = 0; j < kTimestampGroupLength; ++j) { + // Insert `kTimestampGroupLength` frames with just 1 timestamp ticks in + // between. Should be treated as part of the same group by the estimator. + IncomingPacket(kDefaultSsrc, 100, clock_.TimeInMilliseconds(), timestamp, + absolute_send_time); + clock_.AdvanceTimeMilliseconds(kFrameIntervalMs / kTimestampGroupLength); + timestamp += 1; + absolute_send_time = + AddAbsSendTime(absolute_send_time, kSingleRtpTickAbsSendTime); + } + // Increase time until next batch to simulate over-use. + clock_.AdvanceTimeMilliseconds(10); + timestamp += 90 * kFrameIntervalMs - kTimestampGroupLength; + absolute_send_time = AddAbsSendTime( + absolute_send_time, + AddAbsSendTime(kFrameIntervalAbsSendTime, + -static_cast<int>(kTimestampGroupLengthAbsSendTime))); + bitrate_estimator_->Process(); + } + EXPECT_TRUE(bitrate_observer_->updated()); + // Should have reduced the estimate. + EXPECT_LT(bitrate_observer_->latest_bitrate(), 400000u); +} + +void RemoteBitrateEstimatorTest::TestWrappingHelper(int silence_time_s) { + const int kFramerate = 100; + const int kFrameIntervalMs = 1000 / kFramerate; + const uint32_t kFrameIntervalAbsSendTime = AbsSendTime(1, kFramerate); + uint32_t absolute_send_time = 0; + uint32_t timestamp = 0; + + for (size_t i = 0; i < 3000; ++i) { + IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, + absolute_send_time); + timestamp += kFrameIntervalMs; + clock_.AdvanceTimeMilliseconds(kFrameIntervalMs); + absolute_send_time = + AddAbsSendTime(absolute_send_time, kFrameIntervalAbsSendTime); + bitrate_estimator_->Process(); + } + DataRate bitrate_before = bitrate_estimator_->LatestEstimate(); + + clock_.AdvanceTimeMilliseconds(silence_time_s * 1000); + absolute_send_time = + AddAbsSendTime(absolute_send_time, AbsSendTime(silence_time_s, 1)); + bitrate_estimator_->Process(); + for (size_t i = 0; i < 21; ++i) { + IncomingPacket(kDefaultSsrc, 1000, clock_.TimeInMilliseconds(), timestamp, + absolute_send_time); + timestamp += kFrameIntervalMs; + clock_.AdvanceTimeMilliseconds(2 * kFrameIntervalMs); + absolute_send_time = + AddAbsSendTime(absolute_send_time, kFrameIntervalAbsSendTime); + bitrate_estimator_->Process(); + } + DataRate bitrate_after = bitrate_estimator_->LatestEstimate(); + EXPECT_LT(bitrate_after, bitrate_before); +} +} // namespace webrtc |