Add TransportFeedbackPacketLossTracker.

This CL is to calculate packet loss metrics from TransportFeedback. The outcome of this will be passed down to audio encoder.

BUG=webrtc:6904

Review-Url: https://codereview.webrtc.org/2579613003
Cr-Commit-Position: refs/heads/master@{#16217}

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",
+  ]
+}

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 <algorithm>
+
+#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<const uint8_t> data)
+      : data_(data), ended_(false), data_idx_(0) {}
+
+  void GetNextTransportFeedback(rtcp::TransportFeedback* feedback) {
+    uint16_t base_seq_num = 0;
+    if (!ReadData<uint16_t>(&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<uint16_t>(&num_statuses))
+      return;
+    num_statuses = std::max<uint16_t>(num_statuses, 1);
+
+    uint16_t seq_num = base_seq_num;
+    while (true) {
+      uint8_t status_byte = 0;
+      if (!ReadData<uint8_t>(&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 <typename T>
+  bool ReadData(T* value) {
+    RTC_DCHECK(!ended_);
+    if (data_idx_ + sizeof(T) > data_.size()) {
+      ended_ = true;
+      return false;
+    }
+    *value = ByteReader<T>::ReadBigEndian(&data_[data_idx_]);
+    data_idx_ += sizeof(T);
+    return true;
+  }
+
+  const rtc::ArrayView<const uint8_t> 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<size_t>(
+      kSeqNumHalf,
+      std::max<uint16_t>(1, ByteReader<uint16_t>::ReadBigEndian(data)));
+  data += sizeof(uint16_t);
+  const size_t window_size_2 = std::min<size_t>(
+      kSeqNumHalf,
+      std::max<uint16_t>(1, ByteReader<uint16_t>::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<const uint8_t>(data, size));
+  while (!feedback_generator.ended()) {
+    rtcp::TransportFeedback feedback;
+    feedback_generator.GetNextTransportFeedback(&feedback);
+    tracker.OnReceivedTransportFeedback(feedback);
+    tracker.Validate();
+  }
+}
+
+}  // namespace webrtc

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",

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 <limits>
+#include <utility>
+
+#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<float>(num_lost_packets_) / total;
+  *consecutive_packet_loss_rate =
+      static_cast<float>(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<uint16_t>(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<uint16_t>(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<uint16_t>(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<uint16_t>(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<uint16_t>(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

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 <map>
+
+#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<uint16_t, bool> 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_

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 <limits>
+#include <memory>
+#include <vector>
+
+#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<bool>& 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<TransportFeedback> 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