diff --git a/webrtc/test/fuzzers/BUILD.gn b/webrtc/test/fuzzers/BUILD.gn index 1cb12d5a10..ea2352a82c 100644 --- a/webrtc/test/fuzzers/BUILD.gn +++ b/webrtc/test/fuzzers/BUILD.gn @@ -301,3 +301,13 @@ webrtc_fuzzer_test("pseudotcp_parser_fuzzer") { "../../p2p:rtc_p2p", ] } + +webrtc_fuzzer_test("transport_feedback_packet_loss_tracker_fuzzer") { + sources = [ + "transport_feedback_packet_loss_tracker_fuzzer.cc", + ] + deps = [ + "../../modules/rtp_rtcp", + "../../voice_engine", + ] +} diff --git a/webrtc/test/fuzzers/transport_feedback_packet_loss_tracker_fuzzer.cc b/webrtc/test/fuzzers/transport_feedback_packet_loss_tracker_fuzzer.cc new file mode 100644 index 0000000000..837ae883f6 --- /dev/null +++ b/webrtc/test/fuzzers/transport_feedback_packet_loss_tracker_fuzzer.cc @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2017 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 + +#include "webrtc/base/array_view.h" +#include "webrtc/modules/rtp_rtcp/source/byte_io.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" +#include "webrtc/voice_engine/transport_feedback_packet_loss_tracker.h" + +namespace webrtc { + +namespace { + +class TransportFeedbackGenerator { + public: + explicit TransportFeedbackGenerator(rtc::ArrayView data) + : data_(data), ended_(false), data_idx_(0) {} + + void GetNextTransportFeedback(rtcp::TransportFeedback* feedback) { + uint16_t base_seq_num = 0; + if (!ReadData(&base_seq_num)) { + return; + } + + const int64_t kBaseTimeUs = 1234; // Irrelevant to this test. + feedback->SetBase(base_seq_num, kBaseTimeUs); + + uint16_t num_statuses = 0; + if (!ReadData(&num_statuses)) + return; + num_statuses = std::max(num_statuses, 1); + + uint16_t seq_num = base_seq_num; + while (true) { + uint8_t status_byte = 0; + if (!ReadData(&status_byte)) + return; + // Each status byte contains 8 statuses. + for (size_t j = 0; j < 8; ++j) { + if (status_byte & 0x01) { + feedback->AddReceivedPacket(seq_num, kBaseTimeUs); + } + seq_num++; + if (seq_num >= base_seq_num + num_statuses) { + feedback->AddReceivedPacket(seq_num, kBaseTimeUs); + return; + } + status_byte >>= 1; + } + } + } + + bool ended() const { return ended_; } + + private: + template + bool ReadData(T* value) { + RTC_DCHECK(!ended_); + if (data_idx_ + sizeof(T) > data_.size()) { + ended_ = true; + return false; + } + *value = ByteReader::ReadBigEndian(&data_[data_idx_]); + data_idx_ += sizeof(T); + return true; + } + + const rtc::ArrayView data_; + bool ended_; + size_t data_idx_; +}; + +} // namespace + +void FuzzOneInput(const uint8_t* data, size_t size) { + if (size < sizeof(uint32_t)) { + return; + } + constexpr size_t kSeqNumHalf = 0x8000u; + const size_t window_size_1 = std::min( + kSeqNumHalf, + std::max(1, ByteReader::ReadBigEndian(data))); + data += sizeof(uint16_t); + const size_t window_size_2 = std::min( + kSeqNumHalf, + std::max(1, ByteReader::ReadBigEndian(data))); + data += sizeof(uint16_t); + size -= 2 * sizeof(uint16_t); + + TransportFeedbackPacketLossTracker tracker( + std::min(window_size_1, window_size_2), + std::max(window_size_1, window_size_2)); + TransportFeedbackGenerator feedback_generator( + rtc::ArrayView(data, size)); + while (!feedback_generator.ended()) { + rtcp::TransportFeedback feedback; + feedback_generator.GetNextTransportFeedback(&feedback); + tracker.OnReceivedTransportFeedback(feedback); + tracker.Validate(); + } +} + +} // namespace webrtc diff --git a/webrtc/voice_engine/BUILD.gn b/webrtc/voice_engine/BUILD.gn index 0591999def..c29e646e18 100644 --- a/webrtc/voice_engine/BUILD.gn +++ b/webrtc/voice_engine/BUILD.gn @@ -96,6 +96,8 @@ rtc_static_library("voice_engine") { "statistics.h", "transmit_mixer.cc", "transmit_mixer.h", + "transport_feedback_packet_loss_tracker.cc", + "transport_feedback_packet_loss_tracker.h", "utility.cc", "utility.h", "voe_audio_processing_impl.cc", @@ -276,6 +278,7 @@ if (rtc_include_tests) { "test/channel_transport/udp_socket_wrapper_unittest.cc", "test/channel_transport/udp_transport_unittest.cc", "transmit_mixer_unittest.cc", + "transport_feedback_packet_loss_tracker_unittest.cc", "utility_unittest.cc", "voe_audio_processing_unittest.cc", "voe_base_unittest.cc", diff --git a/webrtc/voice_engine/transport_feedback_packet_loss_tracker.cc b/webrtc/voice_engine/transport_feedback_packet_loss_tracker.cc new file mode 100644 index 0000000000..becf964609 --- /dev/null +++ b/webrtc/voice_engine/transport_feedback_packet_loss_tracker.cc @@ -0,0 +1,277 @@ +/* + * Copyright (c) 2017 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 "webrtc/voice_engine/transport_feedback_packet_loss_tracker.h" + +#include +#include + +#include "webrtc/base/checks.h" +#include "webrtc/base/mod_ops.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" + +namespace { +constexpr uint16_t kSeqNumHalf = 0x8000u; +constexpr uint16_t kSeqNumQuarter = kSeqNumHalf / 2; +constexpr size_t kMaxConsecutiveOldReports = 4; +} // namespace + +namespace webrtc { + +TransportFeedbackPacketLossTracker::TransportFeedbackPacketLossTracker( + size_t min_window_size, + size_t max_window_size) + : min_window_size_(min_window_size), + max_window_size_(max_window_size), + ref_packet_status_(packet_status_window_.begin()) { + RTC_DCHECK_GT(min_window_size, 0); + RTC_DCHECK_GE(max_window_size_, min_window_size_); + RTC_DCHECK_LE(max_window_size_, kSeqNumHalf); + Reset(); +} + +void TransportFeedbackPacketLossTracker::Reset() { + num_received_packets_ = 0; + num_lost_packets_ = 0; + num_consecutive_losses_ = 0; + num_consecutive_old_reports_ = 0; + packet_status_window_.clear(); + ref_packet_status_ = packet_status_window_.begin(); +} + +uint16_t TransportFeedbackPacketLossTracker::ReferenceSequenceNumber() const { + RTC_DCHECK(!packet_status_window_.empty()); + return ref_packet_status_->first; +} + +bool TransportFeedbackPacketLossTracker::IsOldSequenceNumber( + uint16_t seq_num) const { + if (packet_status_window_.empty()) { + return false; + } + const uint16_t diff = ForwardDiff(ReferenceSequenceNumber(), seq_num); + return diff >= 3 * kSeqNumQuarter; +} + +void TransportFeedbackPacketLossTracker::OnReceivedTransportFeedback( + const rtcp::TransportFeedback& feedback) { + const auto& fb_vector = feedback.GetStatusVector(); + const uint16_t base_seq_num = feedback.GetBaseSequence(); + + if (IsOldSequenceNumber(base_seq_num)) { + ++num_consecutive_old_reports_; + if (num_consecutive_old_reports_ <= kMaxConsecutiveOldReports) { + // If the number consecutive old reports have not exceed a threshold, we + // consider this packet as a late arrival. We could consider adding it to + // |packet_status_window_|, but in current implementation, we simply + // ignore it. + return; + } + // If we see several consecutive older reports, we assume that we've not + // received reports for an exceedingly long time, and do a reset. + Reset(); + RTC_DCHECK(!IsOldSequenceNumber(base_seq_num)); + } else { + num_consecutive_old_reports_ = 0; + } + + uint16_t seq_num = base_seq_num; + for (size_t i = 0; i < fb_vector.size(); ++i, ++seq_num) { + // Remove the oldest feedbacks so that the distance between the oldest and + // the packet to be added does not exceed or equal to half of total sequence + // numbers. + while (!packet_status_window_.empty() && + ForwardDiff(ReferenceSequenceNumber(), seq_num) >= kSeqNumHalf) { + RemoveOldestPacketStatus(); + } + + const bool received = + fb_vector[i] != + webrtc::rtcp::TransportFeedback::StatusSymbol::kNotReceived; + InsertPacketStatus(seq_num, received); + + while (packet_status_window_.size() > max_window_size_) { + // Make sure that the window holds at most |max_window_size_| items. + RemoveOldestPacketStatus(); + } + } +} + +bool TransportFeedbackPacketLossTracker::GetPacketLossRates( + float* packet_loss_rate, + float* consecutive_packet_loss_rate) const { + const size_t total = num_lost_packets_ + num_received_packets_; + if (total < min_window_size_) + return false; + *packet_loss_rate = static_cast(num_lost_packets_) / total; + *consecutive_packet_loss_rate = + static_cast(num_consecutive_losses_) / total; + return true; +} + +void TransportFeedbackPacketLossTracker::InsertPacketStatus(uint16_t seq_num, + bool received) { + const auto& ret = + packet_status_window_.insert(std::make_pair(seq_num, received)); + if (!ret.second) { + if (!ret.first->second && received) { + // If older status said that the packet was lost but newer one says it + // is received, we take the newer one. + UndoPacketStatus(ret.first); + ret.first->second = received; + } else { + // If the value is unchanged or if older status said that the packet was + // received but the newer one says it is lost, we ignore it. + return; + } + } + ApplyPacketStatus(ret.first); + if (packet_status_window_.size() == 1) + ref_packet_status_ = ret.first; +} + +void TransportFeedbackPacketLossTracker::RemoveOldestPacketStatus() { + UndoPacketStatus(ref_packet_status_); + const auto it = ref_packet_status_; + ref_packet_status_ = NextPacketStatus(it); + packet_status_window_.erase(it); +} + +void TransportFeedbackPacketLossTracker::ApplyPacketStatus( + PacketStatusIterator it) { + RTC_DCHECK(it != packet_status_window_.end()); + if (it->second) { + ++num_received_packets_; + } else { + ++num_lost_packets_; + const auto& next = NextPacketStatus(it); + if (next != packet_status_window_.end() && + next->first == static_cast(it->first + 1) && !next->second) { + // Feedback shows that the next packet has been lost. Since this + // packet is lost, we increase the consecutive loss counter. + ++num_consecutive_losses_; + } + if (it != ref_packet_status_) { + const auto& pre = PreviousPacketStatus(it); + if (pre->first == static_cast(it->first - 1) && !pre->second) { + // Feedback shows that the previous packet has been lost. Since this + // packet is lost, we increase the consecutive loss counter. + ++num_consecutive_losses_; + } + } + } +} + +void TransportFeedbackPacketLossTracker::UndoPacketStatus( + PacketStatusIterator it) { + RTC_DCHECK(it != packet_status_window_.end()); + if (it->second) { + RTC_DCHECK_GT(num_received_packets_, 0); + --num_received_packets_; + } else { + RTC_DCHECK_GT(num_lost_packets_, 0); + --num_lost_packets_; + const auto& next = NextPacketStatus(it); + if (next != packet_status_window_.end() && + next->first == static_cast(it->first + 1) && !next->second) { + RTC_DCHECK_GT(num_consecutive_losses_, 0); + --num_consecutive_losses_; + } + if (it != ref_packet_status_) { + const auto& pre = PreviousPacketStatus(it); + if (pre->first == static_cast(it->first - 1) && !pre->second) { + RTC_DCHECK_GT(num_consecutive_losses_, 0); + --num_consecutive_losses_; + } + } + } +} + +TransportFeedbackPacketLossTracker::PacketStatusIterator +TransportFeedbackPacketLossTracker::PreviousPacketStatus( + PacketStatusIterator it) { + RTC_DCHECK(it != ref_packet_status_); + if (it == packet_status_window_.end()) { + // This is to make PreviousPacketStatus(packet_status_window_.end()) point + // to the last element. + it = ref_packet_status_; + } + + if (it == packet_status_window_.begin()) { + // Due to the circular nature of sequence numbers, we let the iterator + // go to the end. + it = packet_status_window_.end(); + } + return --it; +} + +TransportFeedbackPacketLossTracker::PacketStatusIterator +TransportFeedbackPacketLossTracker::NextPacketStatus(PacketStatusIterator it) { + RTC_DCHECK(it != packet_status_window_.end()); + ++it; + if (it == packet_status_window_.end()) { + // Due to the circular nature of sequence numbers, we let the iterator + // goes back to the beginning. + it = packet_status_window_.begin(); + } + if (it == ref_packet_status_) { + // This is to make the NextPacketStatus of the last element to return the + // beyond-the-end iterator. + it = packet_status_window_.end(); + } + return it; +} + +// TODO(minyue): This method checks the states of this class do not misbehave. +// The method is used both in unit tests and a fuzzer test. The fuzzer test +// is present to help finding potential errors. Once the fuzzer test shows no +// error after long period, we can remove the fuzzer test, and move this method +// to unit test. +void TransportFeedbackPacketLossTracker::Validate() const { // Testing only! + RTC_CHECK_LE(packet_status_window_.size(), max_window_size_); + RTC_CHECK_GE(num_lost_packets_, num_consecutive_losses_); + RTC_CHECK_EQ(packet_status_window_.size(), + num_lost_packets_ + num_received_packets_); + + size_t received_packets = 0; + size_t lost_packets = 0; + size_t consecutive_losses = 0; + + if (!packet_status_window_.empty()) { + PacketStatusIterator it = ref_packet_status_; + bool pre_lost = false; + uint16_t pre_seq_num = it->first - 1; + do { + if (it->second) { + ++received_packets; + } else { + ++lost_packets; + if (pre_lost && pre_seq_num == static_cast(it->first - 1)) + ++consecutive_losses; + } + + RTC_CHECK_LT(ForwardDiff(ReferenceSequenceNumber(), it->first), + kSeqNumHalf); + + pre_lost = !it->second; + pre_seq_num = it->first; + + ++it; + if (it == packet_status_window_.end()) + it = packet_status_window_.begin(); + } while (it != ref_packet_status_); + } + + RTC_CHECK_EQ(num_received_packets_, received_packets); + RTC_CHECK_EQ(num_lost_packets_, lost_packets); + RTC_CHECK_EQ(num_consecutive_losses_, consecutive_losses); +} + +} // namespace webrtc diff --git a/webrtc/voice_engine/transport_feedback_packet_loss_tracker.h b/webrtc/voice_engine/transport_feedback_packet_loss_tracker.h new file mode 100644 index 0000000000..e5626eb9b2 --- /dev/null +++ b/webrtc/voice_engine/transport_feedback_packet_loss_tracker.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2017 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. + */ + +#ifndef WEBRTC_VOICE_ENGINE_TRANSPORT_FEEDBACK_PACKET_LOSS_TRACKER_H_ +#define WEBRTC_VOICE_ENGINE_TRANSPORT_FEEDBACK_PACKET_LOSS_TRACKER_H_ + +#include + +#include "webrtc/base/optional.h" +#include "webrtc/modules/include/module_common_types.h" + +namespace webrtc { + +namespace rtcp { +class TransportFeedback; +} + +class TransportFeedbackPacketLossTracker final { + public: + // Up to |max_window_size| latest packet statuses wil be used for calculating + // the packet loss metrics. When less than |min_window_size| samples are + // available for making a reliable estimation, GetPacketLossRates() will + // return false to indicate packet loss metrics are not ready. + TransportFeedbackPacketLossTracker(size_t min_window_size, + size_t max_window_size); + + void OnReceivedTransportFeedback(const rtcp::TransportFeedback& feedback); + + // Returns true if packet loss rate and packet loss episode duration are ready + // and assigns respective values to |*packet_loss_rate| and + // |*consecutive_packet_loss_rate|. Continuous packet loss rate is defined as + // the probability of losing two adjacent packets. + bool GetPacketLossRates(float* packet_loss_rate, + float* consecutive_packet_loss_rate) const; + + // Verifies that the internal states are correct. Only used for tests. + void Validate() const; + + private: + // PacketStatus is a map from sequence number to its reception status. The + // status is true if the corresponding packet is received, and false if it is + // lost. Unknown statuses are not present in the map. + typedef std::map PacketStatus; + typedef PacketStatus::const_iterator PacketStatusIterator; + + void Reset(); + // ReferenceSequenceNumber() provides a sequence number that defines the + // order of packet reception info stored in |packet_status_window_|. In + // particular, given any sequence number |x|, + // (2^16 + x - ref_seq_num_) % 2^16 defines its actual position in + // |packet_status_window_|. + uint16_t ReferenceSequenceNumber() const; + bool IsOldSequenceNumber(uint16_t seq_num) const; + void InsertPacketStatus(uint16_t seq_num, bool received); + void RemoveOldestPacketStatus(); + void ApplyPacketStatus(PacketStatusIterator it); + void UndoPacketStatus(PacketStatusIterator it); + PacketStatusIterator PreviousPacketStatus(PacketStatusIterator it); + PacketStatusIterator NextPacketStatus(PacketStatusIterator it); + + const size_t min_window_size_; + const size_t max_window_size_; + + PacketStatus packet_status_window_; + // |ref_packet_status_| points to the oldest item in |packet_status_window_|. + PacketStatusIterator ref_packet_status_; + + size_t num_received_packets_; + size_t num_lost_packets_; + size_t num_consecutive_losses_; + size_t num_consecutive_old_reports_; +}; + +} // namespace webrtc + +#endif // WEBRTC_VOICE_ENGINE_TRANSPORT_FEEDBACK_PACKET_LOSS_TRACKER_H_ diff --git a/webrtc/voice_engine/transport_feedback_packet_loss_tracker_unittest.cc b/webrtc/voice_engine/transport_feedback_packet_loss_tracker_unittest.cc new file mode 100644 index 0000000000..f639923b8c --- /dev/null +++ b/webrtc/voice_engine/transport_feedback_packet_loss_tracker_unittest.cc @@ -0,0 +1,700 @@ +/* + * Copyright (c) 2017 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 +#include +#include + +#include "webrtc/base/checks.h" +#include "webrtc/base/mod_ops.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" +#include "webrtc/test/gmock.h" +#include "webrtc/test/gtest.h" +#include "webrtc/voice_engine/transport_feedback_packet_loss_tracker.h" + +using webrtc::rtcp::TransportFeedback; +using testing::Return; +using testing::StrictMock; + +namespace webrtc { + +namespace { + +constexpr size_t kMaxConsecutiveOldReports = 4; + +// All tests are run multiple times with various baseline sequence number, +// to weed out potential bugs with wrap-around handling. +constexpr uint16_t kBases[] = {0x0000, 0x3456, 0xc032, 0xfffe}; + +void AddTransportFeedbackAndValidate( + TransportFeedbackPacketLossTracker* tracker, + uint16_t base_sequence_num, + const std::vector& reception_status_vec) { + const int64_t kBaseTimeUs = 1234; // Irrelevant to this test. + TransportFeedback test_feedback; + test_feedback.SetBase(base_sequence_num, kBaseTimeUs); + uint16_t sequence_num = base_sequence_num; + for (bool status : reception_status_vec) { + if (status) + test_feedback.AddReceivedPacket(sequence_num, kBaseTimeUs); + ++sequence_num; + } + tracker->OnReceivedTransportFeedback(test_feedback); + tracker->Validate(); +} + +} // namespace + +// Sanity check on an empty window. +TEST(TransportFeedbackPacketLossTrackerTest, EmptyWindow) { + std::unique_ptr feedback; + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + + TransportFeedbackPacketLossTracker tracker(5, 10); + + // PLR and CPLR reported as unknown before reception of first feedback. + EXPECT_FALSE(tracker.GetPacketLossRates(&plr, &cplr)); +} + +// Sanity check on partially filled window. +TEST(TransportFeedbackPacketLossTrackerTest, PartiallyFilledWindow) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 10); + + // PLR and CPLR reported as unknown before minimum window size reached. + // Expected window contents: [] -> [1001]. + AddTransportFeedbackAndValidate(&tracker, base, {true, false, false, true}); + EXPECT_FALSE(tracker.GetPacketLossRates(&plr, &cplr)); + } +} + +// Sanity check on minimum filled window. +TEST(TransportFeedbackPacketLossTrackerTest, MinimumFilledWindow) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 10); + + // PLR and CPLR correctly calculated after minimum window size reached. + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 5.0f); + EXPECT_EQ(cplr, 1.0f / 5.0f); + } +} + +// Additional reports update PLR and CPLR. +TEST(TransportFeedbackPacketLossTrackerTest, ExtendWindow) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + + // Expected window contents: [10011] -> [10011-10101]. + AddTransportFeedbackAndValidate(&tracker, base + 5, + {true, false, true, false, true}); + + // Expected window contents: [10011-10101] -> [10011-10101-10001]. + AddTransportFeedbackAndValidate(&tracker, base + 10, + {true, false, false, false, true}); + + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 7.0f / 15.0f); + EXPECT_EQ(cplr, 3.0f / 15.0f); + } +} + +TEST(TransportFeedbackPacketLossTrackerTest, AllReceived) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 10); + + // PLR and CPLR correctly calculated after minimum window size reached. + // Expected window contents: [] -> [11111]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, true, true, true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 0.0f); + EXPECT_EQ(cplr, 0.0f); + } +} + +// Repeated reports are ignored. +TEST(TransportFeedbackPacketLossTrackerTest, ReportRepetition) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 10); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + + // Repeat entire previous feedback + // Expected window contents: [10011] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 5.0f); + EXPECT_EQ(cplr, 1.0f / 5.0f); + } +} + +// Report overlap. +TEST(TransportFeedbackPacketLossTrackerTest, ReportOverlap) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 10); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + + // Expected window contents: [10011] -> [10011-01]. + AddTransportFeedbackAndValidate(&tracker, base + 3, + {true, true, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 3.0f / 7.0f); + EXPECT_EQ(cplr, 1.0f / 7.0f); + } +} + +// Report conflict. +TEST(TransportFeedbackPacketLossTrackerTest, ReportConflict) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 10); + + // Expected window contents: [] -> [01001]. + AddTransportFeedbackAndValidate(&tracker, base, + {false, true, false, false, true}); + + // Expected window contents: [01001] -> [11101]. + // While false->true will be applied, true -> false will be ignored. + AddTransportFeedbackAndValidate(&tracker, base, {true, false, true}); + + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 1.0f / 5.0f); + EXPECT_EQ(cplr, 0.0f / 5.0f); + } +} + +// Skipped packets treated as unknown (not lost). +TEST(TransportFeedbackPacketLossTrackerTest, SkippedPackets) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 10); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + + // Expected window contents: [10011] -> [10011-101]. + AddTransportFeedbackAndValidate(&tracker, base + 100, {true, false, true}); + + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 3.0f / 8.0f); + EXPECT_EQ(cplr, 1.0f / 8.0f); + } +} + +// The window retain information up to the configured max-window-size, but +// starts discarding after that. +TEST(TransportFeedbackPacketLossTrackerTest, MaxWindowSize) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(10, 10); + + // Expected window contents: [] -> [10101-00001]. + AddTransportFeedbackAndValidate( + &tracker, base, + {true, false, true, false, true, false, false, false, false, true}); + + // Up to max-window-size retained. + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 6.0f / 10.0f); + EXPECT_EQ(cplr, 3.0f / 10.0f); + + // Expected window contents: [10101-00001] -> [00001-10111]. + AddTransportFeedbackAndValidate(&tracker, base + 10, + {true, false, true, true, true}); + + // After max-window-size, older entries discarded to accommodate newer ones. + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 5.0f / 10.0f); + EXPECT_EQ(cplr, 3.0f / 10.0f); + } +} + +// Inserting into the middle of a full window works correctly. +TEST(TransportFeedbackPacketLossTrackerTest, InsertIntoMiddle) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(10, 10); + + // Expected window contents: [] -> [10101]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, true, false, true}); + + // Expected window contents: [10101] -> [10101-10001]. + AddTransportFeedbackAndValidate(&tracker, base + 100, + {true, false, false, false, true}); + + // Setup sanity + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 5.0f / 10.0f); + EXPECT_EQ(cplr, 2.0f / 10.0f); + + // Insert into the middle of this full window - it discards the older data. + // Expected window contents: [10101-10001] -> [11111-10001]. + AddTransportFeedbackAndValidate(&tracker, base + 50, + {true, true, true, true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 3.0f / 10.0f); + EXPECT_EQ(cplr, 2.0f / 10.0f); + } +} + +// Test the behavior of TransportFeedbackPacketLossTracker when there is a gap +// of more than 0x4000 in sequence number, i.e., 1/4 of total sequence numbers. +// Since the sequence number is used in a circular manner, i.e., after 0xffff, +// the sequence number wraps back to 0x0000, we refer to 1/4 of total sequence +// numbers as a quadrant. In this test, e.g., three transport feedbacks are +// added, whereas the 2nd and 3rd lie in the second quadrant w.r.t. the 1st +// feedback. +TEST(TransportFeedbackPacketLossTrackerTest, SecondQuadrant) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + + // Window *does* get updated with inputs from quadrant #2. + // Expected window contents: [10011] -> [10011-1]. + AddTransportFeedbackAndValidate(&tracker, base + 0x4321, {true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 6.0f); + EXPECT_EQ(cplr, 1.0f / 6.0f); + + // Correct recognition of quadrant #2: up to, but not including, base + + // 0x8000 + // Expected window contents: [10011-1] -> [10011-11]. + AddTransportFeedbackAndValidate(&tracker, base + 0x7fff, {true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 7.0f); + EXPECT_EQ(cplr, 1.0f / 7.0f); + } +} + +// Insertion into the third quadrant moves the base of the window. +TEST(TransportFeedbackPacketLossTrackerTest, ThirdQuadrantMovesBase) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Seed the test. + // Expected window contents: [] -> [10011-01]. + AddTransportFeedbackAndValidate( + &tracker, base, {true, false, false, true, true, false, true}); + + // Quadrant #3 begins at base + 0x8000. It triggers moving the window so + // that + // at least one (oldest) report shifts out of window. + // Expected window contents: [10011-01] -> [10110-01]. + AddTransportFeedbackAndValidate(&tracker, base + 0x8000, + {true, false, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 3.0f / 7.0f); + EXPECT_EQ(cplr, 1.0f / 7.0f); + + // The base can move more than once, because the minimum quadrant-1 packets + // were dropped out of the window, and some remain. + AddTransportFeedbackAndValidate(&tracker, base + 0x8000 + 4, {true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 7.0f); + EXPECT_EQ(cplr, 1.0f / 7.0f); + } +} + +// After the base has moved due to insertion into the third quadrant, it is +// still possible to insert into the middle of the window and obtain the correct +// PLR and CPLR. Insertion into the middle before the max window size has been +// achieved does not cause older packets to be dropped. +TEST(TransportFeedbackPacketLossTrackerTest, InsertIntoMiddleAfterBaseMove) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Seed the test. + // Expected window contents: [] -> [10011-01]. + AddTransportFeedbackAndValidate( + &tracker, base, {true, false, false, true, true, false, true}); + + // Expected window contents: [10011-01] -> [10110-01]. + AddTransportFeedbackAndValidate(&tracker, base + 0x8000, + {true, false, false, true}); + + // Inserting into the middle still works after the base has shifted. + // Expected window contents: [10110-01] -> [10110-01011-001]. + AddTransportFeedbackAndValidate(&tracker, base + 0x5000, + {true, false, false, true, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 6.0f / 13.0f); + EXPECT_EQ(cplr, 2.0f / 13.0f); + + // The base can keep moving after inserting into the middle. + // Expected window contents: [10110-01011-001] -> [11001-01100-111]. + AddTransportFeedbackAndValidate(&tracker, base + 0x8000 + 4, {true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 5.0f / 13.0f); + EXPECT_EQ(cplr, 2.0f / 13.0f); + } +} + +// After moving the base of the window, the max window size is still observed. +TEST(TransportFeedbackPacketLossTrackerTest, ThirdQuadrantObservesMaxWindow) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(10, 15); + + // Expected window contents: [] -> [10011-10101]. + AddTransportFeedbackAndValidate( + &tracker, base, + {true, false, false, true, true, true, false, true, false, true}); + + // Expected window contents: [10011-10101] -> [11101-01101]. + AddTransportFeedbackAndValidate(&tracker, base + 0x8000, + {true, false, true}); + + // Push into middle until max window is reached. + // Expected window contents: [11101-01101] -> [11101-01100-01101]. + AddTransportFeedbackAndValidate(&tracker, base + 0x4000, + {true, false, false, false, true}); + + // Setup sanity + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 6.0f / 15.0f); + EXPECT_EQ(cplr, 2.0f / 15.0f); + + // Pushing new packets into the middle would discard older packets. + // Expected window contents: [11101-01100-01101] -> [01011-00011-01101]. + AddTransportFeedbackAndValidate(&tracker, base + 0x4000 + 5, + {true, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 7.0f / 15.0f); + EXPECT_EQ(cplr, 2.0f / 15.0f); + } +} + +// A new feedback in quadrant #3 might shift enough old feedbacks out of window, +// that we'd go back to an unknown PLR and CPLR. +TEST(TransportFeedbackPacketLossTrackerTest, QuadrantThreeMovedBaseMinWindow) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011-10101]. + AddTransportFeedbackAndValidate( + &tracker, base, + {true, false, false, true, true, true, false, true, false, true}); + EXPECT_TRUE( + tracker.GetPacketLossRates(&plr, &cplr)); // Min window reached. + + // A new feedback in quadrant #3 might shift enough old feedbacks out of + // window, that we'd go back to an unknown PLR and CPLR. This *doesn't* + // necessarily mean all of the old ones were discarded, though. + // Expected window contents: [10011-10101] -> [0111]. + AddTransportFeedbackAndValidate(&tracker, base + 0x8006, {true, true}); + EXPECT_FALSE(tracker.GetPacketLossRates(&plr, &cplr)); + + // Inserting in the middle shows that though some of the elements were + // ejected, some were retained. + // Expected window contents: [] -> [01101-11]. + AddTransportFeedbackAndValidate(&tracker, base + 0x4000, + {true, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 7.0f); + EXPECT_EQ(cplr, 0.0f / 7.0f); + } +} + +// Quadrant four reports ignored for up to kMaxConsecutiveOldReports times. +TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourInitiallyIgnored) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + + // Feedbacks in quadrant #4 are discarded (up to kMaxConsecutiveOldReports + // consecutive reports). + // Expected window contents: [10011] -> [10011]. + for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) { + AddTransportFeedbackAndValidate(&tracker, base + 0xc000, {true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 5.0f); + EXPECT_EQ(cplr, 1.0f / 5.0f); + } + } +} + +// Receiving a packet from quadrant #1 resets the counter for quadrant #4. +TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourCounterResetByQ1) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + + // Feedbacks in quadrant #4 are discarded (up to kMaxConsecutiveOldReports + // consecutive reports). + // Expected window contents: [10011] -> [10011]. + for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) { + AddTransportFeedbackAndValidate(&tracker, base + 0xc000, {true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 5.0f); + EXPECT_EQ(cplr, 1.0f / 5.0f); + } + + // If we receive a feedback in quadrant #1, the above counter is reset. + // Expected window contents: [10011] -> [10011-1]. + AddTransportFeedbackAndValidate(&tracker, base + 0x000f, {true}); + for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) { + // Note: though the feedback message reports three packets, it only gets + // counted once. + AddTransportFeedbackAndValidate(&tracker, base + 0xc000, + {true, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 6.0f); + EXPECT_EQ(cplr, 1.0f / 6.0f); + } + } +} + +// Receiving a packet from quadrant #2 resets the counter for quadrant #4. +TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourCounterResetByQ2) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + + // Feedbacks in quadrant #4 are discarded (up to kMaxConsecutiveOldReports + // consecutive reports). + // Expected window contents: [10011] -> [10011]. + for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) { + AddTransportFeedbackAndValidate(&tracker, base + 0xc000, {true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 5.0f); + EXPECT_EQ(cplr, 1.0f / 5.0f); + } + + // If we receive a feedback in quadrant #1, the above counter is reset. + // Expected window contents: [10011] -> [10011-1]. + AddTransportFeedbackAndValidate(&tracker, base + 0x400f, {true}); + for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) { + // Note: though the feedback message reports three packets, it only gets + // counted once. + AddTransportFeedbackAndValidate(&tracker, base + 0xc000, + {true, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 6.0f); + EXPECT_EQ(cplr, 1.0f / 6.0f); + } + } +} + +// Receiving a packet from quadrant #3 resets the counter for quadrant #4. +TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourCounterResetByQ3) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011-10001]. + AddTransportFeedbackAndValidate( + &tracker, base, + {true, false, false, true, true, true, false, false, false, true}); + + // Feedbacks in quadrant #4 are discarded (up to kMaxConsecutiveOldReports + // consecutive reports). + // Expected window contents: [10011-10001] -> [10011-10001]. + for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) { + AddTransportFeedbackAndValidate(&tracker, base + 0xc000, {true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 5.0f / 10.0f); + EXPECT_EQ(cplr, 3.0f / 10.0f); + } + + // If we receive a feedback in quadrant #1, the above counter is reset. + // Expected window contents: [10011-10001] -> [11100-01111]. + AddTransportFeedbackAndValidate(&tracker, base + 0x8000, + {true, true, true}); + for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) { + // Note: though the feedback message reports three packets, it only gets + // counted once. + AddTransportFeedbackAndValidate(&tracker, base + 0xc000 + 10, + {true, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 3.0f / 10.0f); + EXPECT_EQ(cplr, 2.0f / 10.0f); + } + } +} + +// Quadrant four reports ignored for up to kMaxConsecutiveOldReports times. +// After that, the window is reset. +TEST(TransportFeedbackPacketLossTrackerTest, QuadrantFourReset) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011-10001]. + AddTransportFeedbackAndValidate( + &tracker, base, + {true, false, false, true, true, true, false, false, false, true}); + + // The first kMaxConsecutiveOldReports quadrant #4 reports are ignored. + // It doesn't matter that they consist of multiple packets - each report + // is only counted once. + for (size_t i = 0; i < kMaxConsecutiveOldReports; i++) { + // Expected window contents: [10011-10001] -> [10011-10001]. + AddTransportFeedbackAndValidate(&tracker, base + 0xc000, + {true, true, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 5.0f / 10.0f); + EXPECT_EQ(cplr, 3.0f / 10.0f); + } + + // One additional feedback in quadrant #4 brings us over + // kMaxConsecutiveOldReports consecutive "old" reports, resetting the + // window. + // Note: The report doesn't have to be the same as the previous ones. + // Expected window contents: [10011-10001] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base + 0xc000, + {true, false, false, true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + + // The new window is not completely empty - it's been seeded with the + // packets reported in the feedback that has triggered the reset. + EXPECT_EQ(plr, 2.0f / 5.0f); + EXPECT_EQ(cplr, 1.0f / 5.0f); + } +} + +// Feedbacks spanning multiple quadrant are treated correctly (Q1-Q2). +TEST(TransportFeedbackPacketLossTrackerTest, MultiQuadrantQ1Q2) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base, + {true, false, false, true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + + // A feedback with entries in both quadrant #1 and #2 gets both counted: + // Expected window contents: [10011] -> [10011-11]. + AddTransportFeedbackAndValidate(&tracker, base + 0x3fff, {true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 7.0f); + EXPECT_EQ(cplr, 1.0f / 7.0f); + } +} + +// Feedbacks spanning multiple quadrant are treated correctly (Q2-Q3). +TEST(TransportFeedbackPacketLossTrackerTest, MultiQuadrantQ2Q3) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011-00001]. + AddTransportFeedbackAndValidate( + &tracker, base, + {true, false, false, true, true, false, false, false, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 6.0f / 10.0f); + EXPECT_EQ(cplr, 4.0f / 10.0f); + + // A feedback with entries in both quadrant #2 and #3 gets both counted, + // but only those from #3 trigger throwing out old entries from quadrant #1: + // Expected window contents: [10011-00001] -> [01100-00110-01]. + AddTransportFeedbackAndValidate(&tracker, base + 0x7ffe, + {true, false, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 7.0f / 12.0f); + EXPECT_EQ(cplr, 4.0f / 12.0f); + } +} + +// Feedbacks spanning multiple quadrant are treated correctly (Q2-Q3). +TEST(TransportFeedbackPacketLossTrackerTest, MultiQuadrantQ3Q4) { + for (uint16_t base : kBases) { + float plr = 0.0f; // Packet-loss-rate + float cplr = 0.0f; // Consecutive-packet-loss-rate + + TransportFeedbackPacketLossTracker tracker(5, 20); + + // Expected window contents: [] -> [10011-00001]. + AddTransportFeedbackAndValidate( + &tracker, base, + {true, false, false, true, true, false, false, false, false, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 6.0f / 10.0f); + EXPECT_EQ(cplr, 4.0f / 10.0f); + + // A feedback with entries in both quadrant #3 and #4 would have the entries + // from quadrant #3 shift enough quadrant #1 entries out of window, that + // by the time the #4 packets are examined, the moving baseline has made + // them into quadrant #3 packets. + // Expected window contents: [10011-00001] -> [10011]. + AddTransportFeedbackAndValidate(&tracker, base + 0xbfff, + {true, false, false, true, true}); + EXPECT_TRUE(tracker.GetPacketLossRates(&plr, &cplr)); + EXPECT_EQ(plr, 2.0f / 5.0f); + EXPECT_EQ(cplr, 1.0f / 5.0f); + } +} + +} // namespace webrtc