Delete deprecated NackModule
Bug: None
Change-Id: Ie9dfe6c0051a172efa4a7768eac0bd0ddba669bd
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/266367
Commit-Queue: Philip Eliasson <philipel@webrtc.org>
Auto-Submit: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#37301}
diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index d0e6c37..942b4eb 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -1091,7 +1091,6 @@
"histogram_unittest.cc",
"jitter_buffer_unittest.cc",
"loss_notification_controller_unittest.cc",
- "nack_module_unittest.cc",
"nack_requester_unittest.cc",
"packet_buffer_unittest.cc",
"receiver_unittest.cc",
@@ -1209,7 +1208,6 @@
"../rtp_rtcp:rtp_rtcp_format",
"../rtp_rtcp:rtp_video_header",
"codecs/av1:video_coding_codecs_av1_tests",
- "deprecated:nack_module",
"svc:scalability_structure_tests",
"svc:svc_rate_allocator_tests",
"timing:jitter_estimator",
diff --git a/modules/video_coding/deprecated/BUILD.gn b/modules/video_coding/deprecated/BUILD.gn
deleted file mode 100644
index 0155fc4..0000000
--- a/modules/video_coding/deprecated/BUILD.gn
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright (c) 2020 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.
-
-import("../../../webrtc.gni")
-
-rtc_library("nack_module") {
- sources = [
- "nack_module.cc",
- "nack_module.h",
- ]
-
- deps = [
- "..:nack_requester",
- "../..:module_api",
- "../../../api:field_trials_view",
- "../../../api/units:time_delta",
- "../../../api/units:timestamp",
- "../../../rtc_base:checks",
- "../../../rtc_base:criticalsection",
- "../../../rtc_base:logging",
- "../../../rtc_base:macromagic",
- "../../../rtc_base:rtc_numerics",
- "../../../rtc_base/experiments:field_trial_parser",
- "../../../rtc_base/synchronization:mutex",
- "../../../system_wrappers",
- "../../utility",
- ]
- absl_deps = [ "//third_party/abseil-cpp/absl/base:core_headers" ]
-}
diff --git a/modules/video_coding/deprecated/nack_module.cc b/modules/video_coding/deprecated/nack_module.cc
deleted file mode 100644
index 0768bc4..0000000
--- a/modules/video_coding/deprecated/nack_module.cc
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
- * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "modules/video_coding/deprecated/nack_module.h"
-
-#include <algorithm>
-#include <limits>
-
-#include "api/units/timestamp.h"
-#include "modules/utility/include/process_thread.h"
-#include "rtc_base/checks.h"
-#include "rtc_base/experiments/field_trial_parser.h"
-#include "rtc_base/logging.h"
-
-namespace webrtc {
-
-namespace {
-const int kMaxPacketAge = 10000;
-const int kMaxNackPackets = 1000;
-const int kDefaultRttMs = 100;
-const int kMaxNackRetries = 10;
-const int kProcessFrequency = 50;
-const int kProcessIntervalMs = 1000 / kProcessFrequency;
-const int kMaxReorderedPackets = 128;
-const int kNumReorderingBuckets = 10;
-const int kDefaultSendNackDelayMs = 0;
-
-int64_t GetSendNackDelay(const FieldTrialsView& field_trials) {
- int64_t delay_ms = strtol(
- field_trials.Lookup("WebRTC-SendNackDelayMs").c_str(), nullptr, 10);
- if (delay_ms > 0 && delay_ms <= 20) {
- RTC_LOG(LS_INFO) << "SendNackDelay is set to " << delay_ms;
- return delay_ms;
- }
- return kDefaultSendNackDelayMs;
-}
-} // namespace
-
-DEPRECATED_NackModule::NackInfo::NackInfo()
- : seq_num(0), send_at_seq_num(0), sent_at_time(-1), retries(0) {}
-
-DEPRECATED_NackModule::NackInfo::NackInfo(uint16_t seq_num,
- uint16_t send_at_seq_num,
- int64_t created_at_time)
- : seq_num(seq_num),
- send_at_seq_num(send_at_seq_num),
- created_at_time(created_at_time),
- sent_at_time(-1),
- retries(0) {}
-
-DEPRECATED_NackModule::BackoffSettings::BackoffSettings(TimeDelta min_retry,
- TimeDelta max_rtt,
- double base)
- : min_retry_interval(min_retry), max_rtt(max_rtt), base(base) {}
-
-absl::optional<DEPRECATED_NackModule::BackoffSettings>
-DEPRECATED_NackModule::BackoffSettings::ParseFromFieldTrials(
- const FieldTrialsView& field_trials) {
- // Matches magic number in RTPSender::OnReceivedNack().
- const TimeDelta kDefaultMinRetryInterval = TimeDelta::Millis(5);
- // Upper bound on link-delay considered for exponential backoff.
- // Selected so that cumulative delay with 1.25 base and 10 retries ends up
- // below 3s, since above that there will be a FIR generated instead.
- const TimeDelta kDefaultMaxRtt = TimeDelta::Millis(160);
- // Default base for exponential backoff, adds 25% RTT delay for each retry.
- const double kDefaultBase = 1.25;
-
- FieldTrialParameter<bool> enabled("enabled", false);
- FieldTrialParameter<TimeDelta> min_retry("min_retry",
- kDefaultMinRetryInterval);
- FieldTrialParameter<TimeDelta> max_rtt("max_rtt", kDefaultMaxRtt);
- FieldTrialParameter<double> base("base", kDefaultBase);
- ParseFieldTrial({&enabled, &min_retry, &max_rtt, &base},
- field_trials.Lookup("WebRTC-ExponentialNackBackoff"));
-
- if (enabled) {
- return DEPRECATED_NackModule::BackoffSettings(min_retry.Get(),
- max_rtt.Get(), base.Get());
- }
- return absl::nullopt;
-}
-
-DEPRECATED_NackModule::DEPRECATED_NackModule(
- Clock* clock,
- NackSender* nack_sender,
- KeyFrameRequestSender* keyframe_request_sender,
- const FieldTrialsView& field_trials)
- : clock_(clock),
- nack_sender_(nack_sender),
- keyframe_request_sender_(keyframe_request_sender),
- reordering_histogram_(kNumReorderingBuckets, kMaxReorderedPackets),
- initialized_(false),
- rtt_ms_(kDefaultRttMs),
- newest_seq_num_(0),
- next_process_time_ms_(-1),
- send_nack_delay_ms_(GetSendNackDelay(field_trials)),
- backoff_settings_(BackoffSettings::ParseFromFieldTrials(field_trials)) {
- RTC_DCHECK(clock_);
- RTC_DCHECK(nack_sender_);
- RTC_DCHECK(keyframe_request_sender_);
-}
-
-int DEPRECATED_NackModule::OnReceivedPacket(uint16_t seq_num,
- bool is_keyframe) {
- return OnReceivedPacket(seq_num, is_keyframe, false);
-}
-
-int DEPRECATED_NackModule::OnReceivedPacket(uint16_t seq_num,
- bool is_keyframe,
- bool is_recovered) {
- MutexLock lock(&mutex_);
- // TODO(philipel): When the packet includes information whether it is
- // retransmitted or not, use that value instead. For
- // now set it to true, which will cause the reordering
- // statistics to never be updated.
- bool is_retransmitted = true;
-
- if (!initialized_) {
- newest_seq_num_ = seq_num;
- if (is_keyframe)
- keyframe_list_.insert(seq_num);
- initialized_ = true;
- return 0;
- }
-
- // Since the `newest_seq_num_` is a packet we have actually received we know
- // that packet has never been Nacked.
- if (seq_num == newest_seq_num_)
- return 0;
-
- if (AheadOf(newest_seq_num_, seq_num)) {
- // An out of order packet has been received.
- auto nack_list_it = nack_list_.find(seq_num);
- int nacks_sent_for_packet = 0;
- if (nack_list_it != nack_list_.end()) {
- nacks_sent_for_packet = nack_list_it->second.retries;
- nack_list_.erase(nack_list_it);
- }
- if (!is_retransmitted)
- UpdateReorderingStatistics(seq_num);
- return nacks_sent_for_packet;
- }
-
- // Keep track of new keyframes.
- if (is_keyframe)
- keyframe_list_.insert(seq_num);
-
- // And remove old ones so we don't accumulate keyframes.
- auto it = keyframe_list_.lower_bound(seq_num - kMaxPacketAge);
- if (it != keyframe_list_.begin())
- keyframe_list_.erase(keyframe_list_.begin(), it);
-
- if (is_recovered) {
- recovered_list_.insert(seq_num);
-
- // Remove old ones so we don't accumulate recovered packets.
- auto it = recovered_list_.lower_bound(seq_num - kMaxPacketAge);
- if (it != recovered_list_.begin())
- recovered_list_.erase(recovered_list_.begin(), it);
-
- // Do not send nack for packets recovered by FEC or RTX.
- return 0;
- }
-
- AddPacketsToNack(newest_seq_num_ + 1, seq_num);
- newest_seq_num_ = seq_num;
-
- // Are there any nacks that are waiting for this seq_num.
- std::vector<uint16_t> nack_batch = GetNackBatch(kSeqNumOnly);
- if (!nack_batch.empty()) {
- // This batch of NACKs is triggered externally; the initiator can
- // batch them with other feedback messages.
- nack_sender_->SendNack(nack_batch, /*buffering_allowed=*/true);
- }
-
- return 0;
-}
-
-void DEPRECATED_NackModule::ClearUpTo(uint16_t seq_num) {
- MutexLock lock(&mutex_);
- nack_list_.erase(nack_list_.begin(), nack_list_.lower_bound(seq_num));
- keyframe_list_.erase(keyframe_list_.begin(),
- keyframe_list_.lower_bound(seq_num));
- recovered_list_.erase(recovered_list_.begin(),
- recovered_list_.lower_bound(seq_num));
-}
-
-void DEPRECATED_NackModule::UpdateRtt(int64_t rtt_ms) {
- MutexLock lock(&mutex_);
- rtt_ms_ = rtt_ms;
-}
-
-void DEPRECATED_NackModule::Clear() {
- MutexLock lock(&mutex_);
- nack_list_.clear();
- keyframe_list_.clear();
- recovered_list_.clear();
-}
-
-int64_t DEPRECATED_NackModule::TimeUntilNextProcess() {
- return std::max<int64_t>(next_process_time_ms_ - clock_->TimeInMilliseconds(),
- 0);
-}
-
-void DEPRECATED_NackModule::Process() {
- if (nack_sender_) {
- std::vector<uint16_t> nack_batch;
- {
- MutexLock lock(&mutex_);
- nack_batch = GetNackBatch(kTimeOnly);
- }
-
- if (!nack_batch.empty()) {
- // This batch of NACKs is triggered externally; there is no external
- // initiator who can batch them with other feedback messages.
- nack_sender_->SendNack(nack_batch, /*buffering_allowed=*/false);
- }
- }
-
- // Update the next_process_time_ms_ in intervals to achieve
- // the targeted frequency over time. Also add multiple intervals
- // in case of a skip in time as to not make uneccessary
- // calls to Process in order to catch up.
- int64_t now_ms = clock_->TimeInMilliseconds();
- if (next_process_time_ms_ == -1) {
- next_process_time_ms_ = now_ms + kProcessIntervalMs;
- } else {
- next_process_time_ms_ = next_process_time_ms_ + kProcessIntervalMs +
- (now_ms - next_process_time_ms_) /
- kProcessIntervalMs * kProcessIntervalMs;
- }
-}
-
-bool DEPRECATED_NackModule::RemovePacketsUntilKeyFrame() {
- while (!keyframe_list_.empty()) {
- auto it = nack_list_.lower_bound(*keyframe_list_.begin());
-
- if (it != nack_list_.begin()) {
- // We have found a keyframe that actually is newer than at least one
- // packet in the nack list.
- nack_list_.erase(nack_list_.begin(), it);
- return true;
- }
-
- // If this keyframe is so old it does not remove any packets from the list,
- // remove it from the list of keyframes and try the next keyframe.
- keyframe_list_.erase(keyframe_list_.begin());
- }
- return false;
-}
-
-void DEPRECATED_NackModule::AddPacketsToNack(uint16_t seq_num_start,
- uint16_t seq_num_end) {
- // Remove old packets.
- auto it = nack_list_.lower_bound(seq_num_end - kMaxPacketAge);
- nack_list_.erase(nack_list_.begin(), it);
-
- // If the nack list is too large, remove packets from the nack list until
- // the latest first packet of a keyframe. If the list is still too large,
- // clear it and request a keyframe.
- uint16_t num_new_nacks = ForwardDiff(seq_num_start, seq_num_end);
- if (nack_list_.size() + num_new_nacks > kMaxNackPackets) {
- while (RemovePacketsUntilKeyFrame() &&
- nack_list_.size() + num_new_nacks > kMaxNackPackets) {
- }
-
- if (nack_list_.size() + num_new_nacks > kMaxNackPackets) {
- nack_list_.clear();
- RTC_LOG(LS_WARNING) << "NACK list full, clearing NACK"
- " list and requesting keyframe.";
- keyframe_request_sender_->RequestKeyFrame();
- return;
- }
- }
-
- for (uint16_t seq_num = seq_num_start; seq_num != seq_num_end; ++seq_num) {
- // Do not send nack for packets that are already recovered by FEC or RTX
- if (recovered_list_.find(seq_num) != recovered_list_.end())
- continue;
- NackInfo nack_info(seq_num, seq_num + WaitNumberOfPackets(0.5),
- clock_->TimeInMilliseconds());
- RTC_DCHECK(nack_list_.find(seq_num) == nack_list_.end());
- nack_list_[seq_num] = nack_info;
- }
-}
-
-std::vector<uint16_t> DEPRECATED_NackModule::GetNackBatch(
- NackFilterOptions options) {
- bool consider_seq_num = options != kTimeOnly;
- bool consider_timestamp = options != kSeqNumOnly;
- Timestamp now = clock_->CurrentTime();
- std::vector<uint16_t> nack_batch;
- auto it = nack_list_.begin();
- while (it != nack_list_.end()) {
- TimeDelta resend_delay = TimeDelta::Millis(rtt_ms_);
- if (backoff_settings_) {
- resend_delay =
- std::max(resend_delay, backoff_settings_->min_retry_interval);
- if (it->second.retries > 1) {
- TimeDelta exponential_backoff =
- std::min(TimeDelta::Millis(rtt_ms_), backoff_settings_->max_rtt) *
- std::pow(backoff_settings_->base, it->second.retries - 1);
- resend_delay = std::max(resend_delay, exponential_backoff);
- }
- }
-
- bool delay_timed_out =
- now.ms() - it->second.created_at_time >= send_nack_delay_ms_;
- bool nack_on_rtt_passed =
- now.ms() - it->second.sent_at_time >= resend_delay.ms();
- bool nack_on_seq_num_passed =
- it->second.sent_at_time == -1 &&
- AheadOrAt(newest_seq_num_, it->second.send_at_seq_num);
- if (delay_timed_out && ((consider_seq_num && nack_on_seq_num_passed) ||
- (consider_timestamp && nack_on_rtt_passed))) {
- nack_batch.emplace_back(it->second.seq_num);
- ++it->second.retries;
- it->second.sent_at_time = now.ms();
- if (it->second.retries >= kMaxNackRetries) {
- RTC_LOG(LS_WARNING) << "Sequence number " << it->second.seq_num
- << " removed from NACK list due to max retries.";
- it = nack_list_.erase(it);
- } else {
- ++it;
- }
- continue;
- }
- ++it;
- }
- return nack_batch;
-}
-
-void DEPRECATED_NackModule::UpdateReorderingStatistics(uint16_t seq_num) {
- RTC_DCHECK(AheadOf(newest_seq_num_, seq_num));
- uint16_t diff = ReverseDiff(newest_seq_num_, seq_num);
- reordering_histogram_.Add(diff);
-}
-
-int DEPRECATED_NackModule::WaitNumberOfPackets(float probability) const {
- if (reordering_histogram_.NumValues() == 0)
- return 0;
- return reordering_histogram_.InverseCdf(probability);
-}
-
-} // namespace webrtc
diff --git a/modules/video_coding/deprecated/nack_module.h b/modules/video_coding/deprecated/nack_module.h
deleted file mode 100644
index 3b49bd1..0000000
--- a/modules/video_coding/deprecated/nack_module.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2016 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 MODULES_VIDEO_CODING_DEPRECATED_NACK_MODULE_H_
-#define MODULES_VIDEO_CODING_DEPRECATED_NACK_MODULE_H_
-
-#include <stdint.h>
-
-#include <map>
-#include <set>
-#include <vector>
-
-#include "absl/base/attributes.h"
-#include "api/field_trials_view.h"
-#include "api/units/time_delta.h"
-#include "modules/include/module.h"
-#include "modules/include/module_common_types.h"
-#include "modules/video_coding/histogram.h"
-#include "rtc_base/numerics/sequence_number_util.h"
-#include "rtc_base/synchronization/mutex.h"
-#include "rtc_base/thread_annotations.h"
-#include "system_wrappers/include/clock.h"
-
-namespace webrtc {
-
-class DEPRECATED_NackModule : public Module {
- public:
- DEPRECATED_NackModule(Clock* clock,
- NackSender* nack_sender,
- KeyFrameRequestSender* keyframe_request_sender,
- const FieldTrialsView& field_trials);
-
- int OnReceivedPacket(uint16_t seq_num, bool is_keyframe);
- int OnReceivedPacket(uint16_t seq_num, bool is_keyframe, bool is_recovered);
-
- void ClearUpTo(uint16_t seq_num);
- void UpdateRtt(int64_t rtt_ms);
- void Clear();
-
- // Module implementation
- int64_t TimeUntilNextProcess() override;
- void Process() override;
-
- private:
- // Which fields to consider when deciding which packet to nack in
- // GetNackBatch.
- enum NackFilterOptions { kSeqNumOnly, kTimeOnly, kSeqNumAndTime };
-
- // This class holds the sequence number of the packet that is in the nack list
- // as well as the meta data about when it should be nacked and how many times
- // we have tried to nack this packet.
- struct NackInfo {
- NackInfo();
- NackInfo(uint16_t seq_num,
- uint16_t send_at_seq_num,
- int64_t created_at_time);
-
- uint16_t seq_num;
- uint16_t send_at_seq_num;
- int64_t created_at_time;
- int64_t sent_at_time;
- int retries;
- };
-
- struct BackoffSettings {
- BackoffSettings(TimeDelta min_retry, TimeDelta max_rtt, double base);
- static absl::optional<BackoffSettings> ParseFromFieldTrials(
- const FieldTrialsView& field_trials);
-
- // Min time between nacks.
- const TimeDelta min_retry_interval;
- // Upper bound on link-delay considered for exponential backoff.
- const TimeDelta max_rtt;
- // Base for the exponential backoff.
- const double base;
- };
-
- void AddPacketsToNack(uint16_t seq_num_start, uint16_t seq_num_end)
- RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
- // Removes packets from the nack list until the next keyframe. Returns true
- // if packets were removed.
- bool RemovePacketsUntilKeyFrame() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
- std::vector<uint16_t> GetNackBatch(NackFilterOptions options)
- RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
- // Update the reordering distribution.
- void UpdateReorderingStatistics(uint16_t seq_num)
- RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
- // Returns how many packets we have to wait in order to receive the packet
- // with probability `probabilty` or higher.
- int WaitNumberOfPackets(float probability) const
- RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-
- Mutex mutex_;
- Clock* const clock_;
- NackSender* const nack_sender_;
- KeyFrameRequestSender* const keyframe_request_sender_;
-
- // TODO(philipel): Some of the variables below are consistently used on a
- // known thread (e.g. see `initialized_`). Those probably do not need
- // synchronized access.
- std::map<uint16_t, NackInfo, DescendingSeqNumComp<uint16_t>> nack_list_
- RTC_GUARDED_BY(mutex_);
- std::set<uint16_t, DescendingSeqNumComp<uint16_t>> keyframe_list_
- RTC_GUARDED_BY(mutex_);
- std::set<uint16_t, DescendingSeqNumComp<uint16_t>> recovered_list_
- RTC_GUARDED_BY(mutex_);
- video_coding::Histogram reordering_histogram_ RTC_GUARDED_BY(mutex_);
- bool initialized_ RTC_GUARDED_BY(mutex_);
- int64_t rtt_ms_ RTC_GUARDED_BY(mutex_);
- uint16_t newest_seq_num_ RTC_GUARDED_BY(mutex_);
-
- // Only touched on the process thread.
- int64_t next_process_time_ms_;
-
- // Adds a delay before send nack on packet received.
- const int64_t send_nack_delay_ms_;
-
- const absl::optional<BackoffSettings> backoff_settings_;
-};
-
-using NackModule ABSL_DEPRECATED("") = DEPRECATED_NackModule;
-
-} // namespace webrtc
-
-#endif // MODULES_VIDEO_CODING_DEPRECATED_NACK_MODULE_H_
diff --git a/modules/video_coding/nack_module_unittest.cc b/modules/video_coding/nack_module_unittest.cc
deleted file mode 100644
index 704f2cd..0000000
--- a/modules/video_coding/nack_module_unittest.cc
+++ /dev/null
@@ -1,371 +0,0 @@
-/*
- * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
- *
- * Use of this source code is governed by a BSD-style license
- * that can be found in the LICENSE file in the root of the source
- * tree. An additional intellectual property rights grant can be found
- * in the file PATENTS. All contributing project authors may
- * be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "modules/video_coding/deprecated/nack_module.h"
-
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include <memory>
-
-#include "system_wrappers/include/clock.h"
-#include "test/gtest.h"
-#include "test/scoped_key_value_config.h"
-
-namespace webrtc {
-class TestNackModule : public ::testing::TestWithParam<bool>,
- public NackSender,
- public KeyFrameRequestSender {
- protected:
- TestNackModule()
- : clock_(new SimulatedClock(0)),
- field_trial_(GetParam()
- ? "WebRTC-ExponentialNackBackoff/enabled:true/"
- : "WebRTC-ExponentialNackBackoff/enabled:false/"),
- nack_module_(clock_.get(), this, this, field_trial_),
- keyframes_requested_(0) {}
-
- void SetUp() override { nack_module_.UpdateRtt(kDefaultRttMs); }
-
- void SendNack(const std::vector<uint16_t>& sequence_numbers,
- bool buffering_allowed) override {
- sent_nacks_.insert(sent_nacks_.end(), sequence_numbers.begin(),
- sequence_numbers.end());
- }
-
- void RequestKeyFrame() override { ++keyframes_requested_; }
-
- static constexpr int64_t kDefaultRttMs = 20;
- std::unique_ptr<SimulatedClock> clock_;
- test::ScopedKeyValueConfig field_trial_;
- DEPRECATED_NackModule nack_module_;
- std::vector<uint16_t> sent_nacks_;
- int keyframes_requested_;
-};
-
-TEST_P(TestNackModule, NackOnePacket) {
- nack_module_.OnReceivedPacket(1, false, false);
- nack_module_.OnReceivedPacket(3, false, false);
- EXPECT_EQ(1u, sent_nacks_.size());
- EXPECT_EQ(2, sent_nacks_[0]);
-}
-
-TEST_P(TestNackModule, WrappingSeqNum) {
- nack_module_.OnReceivedPacket(0xfffe, false, false);
- nack_module_.OnReceivedPacket(1, false, false);
- EXPECT_EQ(2u, sent_nacks_.size());
- EXPECT_EQ(0xffff, sent_nacks_[0]);
- EXPECT_EQ(0, sent_nacks_[1]);
-}
-
-TEST_P(TestNackModule, WrappingSeqNumClearToKeyframe) {
- nack_module_.OnReceivedPacket(0xfffe, false, false);
- nack_module_.OnReceivedPacket(1, false, false);
- EXPECT_EQ(2u, sent_nacks_.size());
- EXPECT_EQ(0xffff, sent_nacks_[0]);
- EXPECT_EQ(0, sent_nacks_[1]);
-
- sent_nacks_.clear();
- nack_module_.OnReceivedPacket(2, true, false);
- EXPECT_EQ(0u, sent_nacks_.size());
-
- nack_module_.OnReceivedPacket(501, true, false);
- EXPECT_EQ(498u, sent_nacks_.size());
- for (int seq_num = 3; seq_num < 501; ++seq_num)
- EXPECT_EQ(seq_num, sent_nacks_[seq_num - 3]);
-
- sent_nacks_.clear();
- nack_module_.OnReceivedPacket(1001, false, false);
- EXPECT_EQ(499u, sent_nacks_.size());
- for (int seq_num = 502; seq_num < 1001; ++seq_num)
- EXPECT_EQ(seq_num, sent_nacks_[seq_num - 502]);
-
- sent_nacks_.clear();
- clock_->AdvanceTimeMilliseconds(100);
- nack_module_.Process();
- EXPECT_EQ(999u, sent_nacks_.size());
- EXPECT_EQ(0xffff, sent_nacks_[0]);
- EXPECT_EQ(0, sent_nacks_[1]);
- for (int seq_num = 3; seq_num < 501; ++seq_num)
- EXPECT_EQ(seq_num, sent_nacks_[seq_num - 1]);
- for (int seq_num = 502; seq_num < 1001; ++seq_num)
- EXPECT_EQ(seq_num, sent_nacks_[seq_num - 2]);
-
- // Adding packet 1004 will cause the nack list to reach it's max limit.
- // It will then clear all nacks up to the next keyframe (seq num 2),
- // thus removing 0xffff and 0 from the nack list.
- sent_nacks_.clear();
- nack_module_.OnReceivedPacket(1004, false, false);
- EXPECT_EQ(2u, sent_nacks_.size());
- EXPECT_EQ(1002, sent_nacks_[0]);
- EXPECT_EQ(1003, sent_nacks_[1]);
-
- sent_nacks_.clear();
- clock_->AdvanceTimeMilliseconds(100);
- nack_module_.Process();
- EXPECT_EQ(999u, sent_nacks_.size());
- for (int seq_num = 3; seq_num < 501; ++seq_num)
- EXPECT_EQ(seq_num, sent_nacks_[seq_num - 3]);
- for (int seq_num = 502; seq_num < 1001; ++seq_num)
- EXPECT_EQ(seq_num, sent_nacks_[seq_num - 4]);
-
- // Adding packet 1007 will cause the nack module to overflow again, thus
- // clearing everything up to 501 which is the next keyframe.
- nack_module_.OnReceivedPacket(1007, false, false);
- sent_nacks_.clear();
- clock_->AdvanceTimeMilliseconds(100);
- nack_module_.Process();
- EXPECT_EQ(503u, sent_nacks_.size());
- for (int seq_num = 502; seq_num < 1001; ++seq_num)
- EXPECT_EQ(seq_num, sent_nacks_[seq_num - 502]);
- EXPECT_EQ(1005, sent_nacks_[501]);
- EXPECT_EQ(1006, sent_nacks_[502]);
-}
-
-TEST_P(TestNackModule, DontBurstOnTimeSkip) {
- nack_module_.Process();
- clock_->AdvanceTimeMilliseconds(20);
- EXPECT_EQ(0, nack_module_.TimeUntilNextProcess());
- nack_module_.Process();
-
- clock_->AdvanceTimeMilliseconds(100);
- EXPECT_EQ(0, nack_module_.TimeUntilNextProcess());
- nack_module_.Process();
- EXPECT_EQ(20, nack_module_.TimeUntilNextProcess());
-
- clock_->AdvanceTimeMilliseconds(19);
- EXPECT_EQ(1, nack_module_.TimeUntilNextProcess());
- clock_->AdvanceTimeMilliseconds(2);
- nack_module_.Process();
- EXPECT_EQ(19, nack_module_.TimeUntilNextProcess());
-
- clock_->AdvanceTimeMilliseconds(19);
- EXPECT_EQ(0, nack_module_.TimeUntilNextProcess());
- nack_module_.Process();
-
- clock_->AdvanceTimeMilliseconds(21);
- EXPECT_EQ(0, nack_module_.TimeUntilNextProcess());
- nack_module_.Process();
- EXPECT_EQ(19, nack_module_.TimeUntilNextProcess());
-}
-
-TEST_P(TestNackModule, ResendNack) {
- nack_module_.OnReceivedPacket(1, false, false);
- nack_module_.OnReceivedPacket(3, false, false);
- size_t expected_nacks_sent = 1;
- EXPECT_EQ(expected_nacks_sent, sent_nacks_.size());
- EXPECT_EQ(2, sent_nacks_[0]);
-
- if (GetParam()) {
- // Retry has to wait at least 5ms by default.
- nack_module_.UpdateRtt(1);
- clock_->AdvanceTimeMilliseconds(4);
- nack_module_.Process(); // Too early.
- EXPECT_EQ(expected_nacks_sent, sent_nacks_.size());
-
- clock_->AdvanceTimeMilliseconds(1);
- nack_module_.Process(); // Now allowed.
- EXPECT_EQ(++expected_nacks_sent, sent_nacks_.size());
- } else {
- nack_module_.UpdateRtt(1);
- clock_->AdvanceTimeMilliseconds(1);
- nack_module_.Process(); // Fast retransmit allowed.
- EXPECT_EQ(++expected_nacks_sent, sent_nacks_.size());
- }
-
- // N:th try has to wait b^(N-1) * rtt by default.
- const double b = GetParam() ? 1.25 : 1.0;
- for (int i = 2; i < 10; ++i) {
- // Change RTT, above the 40ms max for exponential backoff.
- TimeDelta rtt = TimeDelta::Millis(160); // + (i * 10 - 40)
- nack_module_.UpdateRtt(rtt.ms());
-
- // RTT gets capped at 160ms in backoff calculations.
- TimeDelta expected_backoff_delay =
- std::pow(b, i - 1) * std::min(rtt, TimeDelta::Millis(160));
-
- // Move to one millisecond before next allowed NACK.
- clock_->AdvanceTimeMilliseconds(expected_backoff_delay.ms() - 1);
- nack_module_.Process();
- EXPECT_EQ(expected_nacks_sent, sent_nacks_.size());
-
- // Move to one millisecond after next allowed NACK.
- // After rather than on to avoid rounding errors.
- clock_->AdvanceTimeMilliseconds(2);
- nack_module_.Process(); // Now allowed.
- EXPECT_EQ(++expected_nacks_sent, sent_nacks_.size());
- }
-
- // Giving up after 10 tries.
- clock_->AdvanceTimeMilliseconds(3000);
- nack_module_.Process();
- EXPECT_EQ(expected_nacks_sent, sent_nacks_.size());
-}
-
-TEST_P(TestNackModule, ResendPacketMaxRetries) {
- nack_module_.OnReceivedPacket(1, false, false);
- nack_module_.OnReceivedPacket(3, false, false);
- EXPECT_EQ(1u, sent_nacks_.size());
- EXPECT_EQ(2, sent_nacks_[0]);
-
- int backoff_factor = 1;
- for (size_t retries = 1; retries < 10; ++retries) {
- // Exponential backoff, so that we don't reject NACK because of time.
- clock_->AdvanceTimeMilliseconds(backoff_factor * kDefaultRttMs);
- backoff_factor *= 2;
- nack_module_.Process();
- EXPECT_EQ(retries + 1, sent_nacks_.size());
- }
-
- clock_->AdvanceTimeMilliseconds(backoff_factor * kDefaultRttMs);
- nack_module_.Process();
- EXPECT_EQ(10u, sent_nacks_.size());
-}
-
-TEST_P(TestNackModule, TooLargeNackList) {
- nack_module_.OnReceivedPacket(0, false, false);
- nack_module_.OnReceivedPacket(1001, false, false);
- EXPECT_EQ(1000u, sent_nacks_.size());
- EXPECT_EQ(0, keyframes_requested_);
- nack_module_.OnReceivedPacket(1003, false, false);
- EXPECT_EQ(1000u, sent_nacks_.size());
- EXPECT_EQ(1, keyframes_requested_);
- nack_module_.OnReceivedPacket(1004, false, false);
- EXPECT_EQ(1000u, sent_nacks_.size());
- EXPECT_EQ(1, keyframes_requested_);
-}
-
-TEST_P(TestNackModule, TooLargeNackListWithKeyFrame) {
- nack_module_.OnReceivedPacket(0, false, false);
- nack_module_.OnReceivedPacket(1, true, false);
- nack_module_.OnReceivedPacket(1001, false, false);
- EXPECT_EQ(999u, sent_nacks_.size());
- EXPECT_EQ(0, keyframes_requested_);
- nack_module_.OnReceivedPacket(1003, false, false);
- EXPECT_EQ(1000u, sent_nacks_.size());
- EXPECT_EQ(0, keyframes_requested_);
- nack_module_.OnReceivedPacket(1005, false, false);
- EXPECT_EQ(1000u, sent_nacks_.size());
- EXPECT_EQ(1, keyframes_requested_);
-}
-
-TEST_P(TestNackModule, ClearUpTo) {
- nack_module_.OnReceivedPacket(0, false, false);
- nack_module_.OnReceivedPacket(100, false, false);
- EXPECT_EQ(99u, sent_nacks_.size());
-
- sent_nacks_.clear();
- clock_->AdvanceTimeMilliseconds(100);
- nack_module_.ClearUpTo(50);
- nack_module_.Process();
- EXPECT_EQ(50u, sent_nacks_.size());
- EXPECT_EQ(50, sent_nacks_[0]);
-}
-
-TEST_P(TestNackModule, ClearUpToWrap) {
- nack_module_.OnReceivedPacket(0xfff0, false, false);
- nack_module_.OnReceivedPacket(0xf, false, false);
- EXPECT_EQ(30u, sent_nacks_.size());
-
- sent_nacks_.clear();
- clock_->AdvanceTimeMilliseconds(100);
- nack_module_.ClearUpTo(0);
- nack_module_.Process();
- EXPECT_EQ(15u, sent_nacks_.size());
- EXPECT_EQ(0, sent_nacks_[0]);
-}
-
-TEST_P(TestNackModule, PacketNackCount) {
- EXPECT_EQ(0, nack_module_.OnReceivedPacket(0, false, false));
- EXPECT_EQ(0, nack_module_.OnReceivedPacket(2, false, false));
- EXPECT_EQ(1, nack_module_.OnReceivedPacket(1, false, false));
-
- sent_nacks_.clear();
- nack_module_.UpdateRtt(100);
- EXPECT_EQ(0, nack_module_.OnReceivedPacket(5, false, false));
- clock_->AdvanceTimeMilliseconds(100);
- nack_module_.Process();
- clock_->AdvanceTimeMilliseconds(125);
- nack_module_.Process();
- EXPECT_EQ(3, nack_module_.OnReceivedPacket(3, false, false));
- EXPECT_EQ(3, nack_module_.OnReceivedPacket(4, false, false));
- EXPECT_EQ(0, nack_module_.OnReceivedPacket(4, false, false));
-}
-
-TEST_P(TestNackModule, NackListFullAndNoOverlapWithKeyframes) {
- const int kMaxNackPackets = 1000;
- const unsigned int kFirstGap = kMaxNackPackets - 20;
- const unsigned int kSecondGap = 200;
- uint16_t seq_num = 0;
- nack_module_.OnReceivedPacket(seq_num++, true, false);
- seq_num += kFirstGap;
- nack_module_.OnReceivedPacket(seq_num++, true, false);
- EXPECT_EQ(kFirstGap, sent_nacks_.size());
- sent_nacks_.clear();
- seq_num += kSecondGap;
- nack_module_.OnReceivedPacket(seq_num, true, false);
- EXPECT_EQ(kSecondGap, sent_nacks_.size());
-}
-
-TEST_P(TestNackModule, HandleFecRecoveredPacket) {
- nack_module_.OnReceivedPacket(1, false, false);
- nack_module_.OnReceivedPacket(4, false, true);
- EXPECT_EQ(0u, sent_nacks_.size());
- nack_module_.OnReceivedPacket(5, false, false);
- EXPECT_EQ(2u, sent_nacks_.size());
-}
-
-TEST_P(TestNackModule, SendNackWithoutDelay) {
- nack_module_.OnReceivedPacket(0, false, false);
- nack_module_.OnReceivedPacket(100, false, false);
- EXPECT_EQ(99u, sent_nacks_.size());
-}
-
-INSTANTIATE_TEST_SUITE_P(WithAndWithoutBackoff,
- TestNackModule,
- ::testing::Values(true, false));
-
-class TestNackModuleWithFieldTrial : public ::testing::Test,
- public NackSender,
- public KeyFrameRequestSender {
- protected:
- TestNackModuleWithFieldTrial()
- : nack_delay_field_trial_("WebRTC-SendNackDelayMs/10/"),
- clock_(new SimulatedClock(0)),
- nack_module_(clock_.get(), this, this, nack_delay_field_trial_),
- keyframes_requested_(0) {}
-
- void SendNack(const std::vector<uint16_t>& sequence_numbers,
- bool buffering_allowed) override {
- sent_nacks_.insert(sent_nacks_.end(), sequence_numbers.begin(),
- sequence_numbers.end());
- }
-
- void RequestKeyFrame() override { ++keyframes_requested_; }
-
- test::ScopedKeyValueConfig nack_delay_field_trial_;
- std::unique_ptr<SimulatedClock> clock_;
- DEPRECATED_NackModule nack_module_;
- std::vector<uint16_t> sent_nacks_;
- int keyframes_requested_;
-};
-
-TEST_F(TestNackModuleWithFieldTrial, SendNackWithDelay) {
- nack_module_.OnReceivedPacket(0, false, false);
- nack_module_.OnReceivedPacket(100, false, false);
- EXPECT_EQ(0u, sent_nacks_.size());
- clock_->AdvanceTimeMilliseconds(10);
- nack_module_.OnReceivedPacket(106, false, false);
- EXPECT_EQ(99u, sent_nacks_.size());
- clock_->AdvanceTimeMilliseconds(10);
- nack_module_.OnReceivedPacket(109, false, false);
- EXPECT_EQ(104u, sent_nacks_.size());
-}
-} // namespace webrtc
