mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 13:50:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

NackModule2: Rename to NackRequester.

Browse source 
The alternative new name proposed, NackTracker, is already in
use in audio_coding.

Fixed: webrtc:11594
Change-Id: I6a05fafc05fa7ddb18ea4f64886a135e5ef59f7e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/226744
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Markus Handell <handellm@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34539}
This commit is contained in:
Markus Handell 2021-07-22 15:09:39 +02:00 committed by WebRTC LUCI CQ
parent d7aa87501f
commit 06a2bf09a4
9 changed files with 111 additions and 114 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
modules/video_coding/BUILD.gn
View file

@ -71,12 +71,12 @@ rtc_library("frame_dependencies_calculator") {
]
}
rtc_library("nack_module") {
rtc_library("nack_requester") {
sources = [
"histogram.cc",
"histogram.h",
"nack_module2.cc",
"nack_module2.h",
"nack_requester.cc",
"nack_requester.h",
]
deps = [
@ -965,8 +965,8 @@ if (rtc_include_tests) {
"jitter_buffer_unittest.cc",
"jitter_estimator_tests.cc",
"loss_notification_controller_unittest.cc",
"nack_module2_unittest.cc",
"nack_module_unittest.cc",
"nack_requester_unittest.cc",
"packet_buffer_unittest.cc",
"receiver_unittest.cc",
"rtp_frame_reference_finder_unittest.cc",
@ -1002,7 +1002,7 @@ if (rtc_include_tests) {
":codec_globals_headers",
":encoded_frame",
":frame_dependencies_calculator",
":nack_module",
":nack_requester",
":simulcast_test_fixture_impl",
":video_codec_interface",
":video_codecs_test_framework",

2
modules/video_coding/deprecated/BUILD.gn
View file

@ -15,7 +15,7 @@ rtc_library("nack_module") {
]
deps = [
"..:nack_module",
"..:nack_requester",
"../..:module_api",
"../../../api/units:time_delta",
"../../../api/units:timestamp",

46
modules/video_coding/nack_module2.cc → modules/video_coding/nack_requester.cc
View file

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/video_coding/nack_module2.h"
#include "modules/video_coding/nack_requester.h"
#include <algorithm>
#include <limits>
@ -52,7 +52,7 @@ NackPeriodicProcessor::NackPeriodicProcessor(TimeDelta update_interval)
NackPeriodicProcessor::~NackPeriodicProcessor() {}
void NackPeriodicProcessor::RegisterNackModule(NackModuleBase* module) {
void NackPeriodicProcessor::RegisterNackModule(NackRequesterBase* module) {
RTC_DCHECK_RUN_ON(&sequence_);
modules_.push_back(module);
if (modules_.size() != 1)
@ -65,7 +65,7 @@ void NackPeriodicProcessor::RegisterNackModule(NackModuleBase* module) {
});
}
void NackPeriodicProcessor::UnregisterNackModule(NackModuleBase* module) {
void NackPeriodicProcessor::UnregisterNackModule(NackRequesterBase* module) {
RTC_DCHECK_RUN_ON(&sequence_);
auto it = std::find(modules_.begin(), modules_.end(), module);
RTC_DCHECK(it != modules_.end());
@ -76,12 +76,12 @@ void NackPeriodicProcessor::UnregisterNackModule(NackModuleBase* module) {
// RTC_RUN_ON(sequence_)
void NackPeriodicProcessor::ProcessNackModules() {
for (NackModuleBase* module : modules_)
for (NackRequesterBase* module : modules_)
module->ProcessNacks();
}
ScopedNackPeriodicProcessorRegistration::
ScopedNackPeriodicProcessorRegistration(NackModuleBase* module,
ScopedNackPeriodicProcessorRegistration(NackRequesterBase* module,
NackPeriodicProcessor* processor)
: module_(module), processor_(processor) {
processor_->RegisterNackModule(module_);
@ -92,10 +92,10 @@ ScopedNackPeriodicProcessorRegistration::
processor_->UnregisterNackModule(module_);
}
NackModule2::NackInfo::NackInfo()
NackRequester::NackInfo::NackInfo()
: seq_num(0), send_at_seq_num(0), sent_at_time(-1), retries(0) {}
NackModule2::NackInfo::NackInfo(uint16_t seq_num,
NackRequester::NackInfo::NackInfo(uint16_t seq_num,
uint16_t send_at_seq_num,
int64_t created_at_time)
: seq_num(seq_num),
@ -104,13 +104,13 @@ NackModule2::NackInfo::NackInfo(uint16_t seq_num,
sent_at_time(-1),
retries(0) {}
NackModule2::BackoffSettings::BackoffSettings(TimeDelta min_retry,
NackRequester::BackoffSettings::BackoffSettings(TimeDelta min_retry,
TimeDelta max_rtt,
double base)
: min_retry_interval(min_retry), max_rtt(max_rtt), base(base) {}
absl::optional<NackModule2::BackoffSettings>
NackModule2::BackoffSettings::ParseFromFieldTrials() {
absl::optional<NackRequester::BackoffSettings>
NackRequester::BackoffSettings::ParseFromFieldTrials() {
// Matches magic number in RTPSender::OnReceivedNack().
const TimeDelta kDefaultMinRetryInterval = TimeDelta::Millis(5);
// Upper bound on link-delay considered for exponential backoff.
@ -129,13 +129,13 @@ NackModule2::BackoffSettings::ParseFromFieldTrials() {
field_trial::FindFullName("WebRTC-ExponentialNackBackoff"));
if (enabled) {
return NackModule2::BackoffSettings(min_retry.Get(), max_rtt.Get(),
return NackRequester::BackoffSettings(min_retry.Get(), max_rtt.Get(),
base.Get());
}
return absl::nullopt;
}
NackModule2::NackModule2(TaskQueueBase* current_queue,
NackRequester::NackRequester(TaskQueueBase* current_queue,
NackPeriodicProcessor* periodic_processor,
Clock* clock,
NackSender* nack_sender,
@ -158,11 +158,11 @@ NackModule2::NackModule2(TaskQueueBase* current_queue,
RTC_DCHECK(worker_thread_->IsCurrent());
}
NackModule2::~NackModule2() {
NackRequester::~NackRequester() {
RTC_DCHECK_RUN_ON(worker_thread_);
}
void NackModule2::ProcessNacks() {
void NackRequester::ProcessNacks() {
RTC_DCHECK_RUN_ON(worker_thread_);
std::vector<uint16_t> nack_batch = GetNackBatch(kTimeOnly);
if (!nack_batch.empty()) {
@ -172,12 +172,12 @@ void NackModule2::ProcessNacks() {
}
}
int NackModule2::OnReceivedPacket(uint16_t seq_num, bool is_keyframe) {
int NackRequester::OnReceivedPacket(uint16_t seq_num, bool is_keyframe) {
RTC_DCHECK_RUN_ON(worker_thread_);
return OnReceivedPacket(seq_num, is_keyframe, false);
}
int NackModule2::OnReceivedPacket(uint16_t seq_num,
int NackRequester::OnReceivedPacket(uint16_t seq_num,
bool is_keyframe,
bool is_recovered) {
RTC_DCHECK_RUN_ON(worker_thread_);
@ -248,7 +248,7 @@ int NackModule2::OnReceivedPacket(uint16_t seq_num,
return 0;
}
void NackModule2::ClearUpTo(uint16_t seq_num) {
void NackRequester::ClearUpTo(uint16_t seq_num) {
// Called via RtpVideoStreamReceiver2::FrameContinuous on the network thread.
worker_thread_->PostTask(ToQueuedTask(task_safety_, [seq_num, this]() {
RTC_DCHECK_RUN_ON(worker_thread_);
@ -260,12 +260,12 @@ void NackModule2::ClearUpTo(uint16_t seq_num) {
}));
}
void NackModule2::UpdateRtt(int64_t rtt_ms) {
void NackRequester::UpdateRtt(int64_t rtt_ms) {
RTC_DCHECK_RUN_ON(worker_thread_);
rtt_ms_ = rtt_ms;
}
bool NackModule2::RemovePacketsUntilKeyFrame() {
bool NackRequester::RemovePacketsUntilKeyFrame() {
// Called on worker_thread_.
while (!keyframe_list_.empty()) {
auto it = nack_list_.lower_bound(*keyframe_list_.begin());
@ -284,7 +284,7 @@ bool NackModule2::RemovePacketsUntilKeyFrame() {
return false;
}
void NackModule2::AddPacketsToNack(uint16_t seq_num_start,
void NackRequester::AddPacketsToNack(uint16_t seq_num_start,
uint16_t seq_num_end) {
// Called on worker_thread_.
// Remove old packets.
@ -320,7 +320,7 @@ void NackModule2::AddPacketsToNack(uint16_t seq_num_start,
}
}
std::vector<uint16_t> NackModule2::GetNackBatch(NackFilterOptions options) {
std::vector<uint16_t> NackRequester::GetNackBatch(NackFilterOptions options) {
// Called on worker_thread_.
bool consider_seq_num = options != kTimeOnly;
@ -367,14 +367,14 @@ std::vector<uint16_t> NackModule2::GetNackBatch(NackFilterOptions options) {
return nack_batch;
}
void NackModule2::UpdateReorderingStatistics(uint16_t seq_num) {
void NackRequester::UpdateReorderingStatistics(uint16_t seq_num) {
// Running on worker_thread_.
RTC_DCHECK(AheadOf(newest_seq_num_, seq_num));
uint16_t diff = ReverseDiff(newest_seq_num_, seq_num);
reordering_histogram_.Add(diff);
}
int NackModule2::WaitNumberOfPackets(float probability) const {
int NackRequester::WaitNumberOfPackets(float probability) const {
// Called on worker_thread_;
if (reordering_histogram_.NumValues() == 0)
return 0;

29
modules/video_coding/nack_module2.h → modules/video_coding/nack_requester.h
View file

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef MODULES_VIDEO_CODING_NACK_MODULE2_H_
#define MODULES_VIDEO_CODING_NACK_MODULE2_H_
#ifndef MODULES_VIDEO_CODING_NACK_REQUESTER_H_
#define MODULES_VIDEO_CODING_NACK_REQUESTER_H_
#include <stdint.h>
@ -30,9 +30,9 @@
namespace webrtc {
class NackModuleBase {
class NackRequesterBase {
public:
virtual ~NackModuleBase() = default;
virtual ~NackRequesterBase() = default;
virtual void ProcessNacks() = 0;
};
@ -41,40 +41,37 @@ class NackPeriodicProcessor {
static constexpr TimeDelta kUpdateInterval = TimeDelta::Millis(20);
explicit NackPeriodicProcessor(TimeDelta update_interval = kUpdateInterval);
~NackPeriodicProcessor();
void RegisterNackModule(NackModuleBase* module);
void UnregisterNackModule(NackModuleBase* module);
void RegisterNackModule(NackRequesterBase* module);
void UnregisterNackModule(NackRequesterBase* module);
private:
void ProcessNackModules() RTC_RUN_ON(sequence_);
const TimeDelta update_interval_;
RepeatingTaskHandle repeating_task_ RTC_GUARDED_BY(sequence_);
std::vector<NackModuleBase*> modules_ RTC_GUARDED_BY(sequence_);
std::vector<NackRequesterBase*> modules_ RTC_GUARDED_BY(sequence_);
RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_;
};
class ScopedNackPeriodicProcessorRegistration {
public:
ScopedNackPeriodicProcessorRegistration(NackModuleBase* module,
ScopedNackPeriodicProcessorRegistration(NackRequesterBase* module,
NackPeriodicProcessor* processor);
~ScopedNackPeriodicProcessorRegistration();
private:
NackModuleBase* const module_;
NackRequesterBase* const module_;
NackPeriodicProcessor* const processor_;
};
// TODO(bugs.webrtc.org/11594): This class no longer implements the Module
// interface and therefore "NackModule" may not be a descriptive name anymore.
// Consider renaming to e.g. NackTracker or NackRequester.
class NackModule2 final : public NackModuleBase {
class NackRequester final : public NackRequesterBase {
public:
NackModule2(TaskQueueBase* current_queue,
NackRequester(TaskQueueBase* current_queue,
NackPeriodicProcessor* periodic_processor,
Clock* clock,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender);
~NackModule2();
~NackRequester();
void ProcessNacks() override;
@ -168,4 +165,4 @@ class NackModule2 final : public NackModuleBase {
} // namespace webrtc
#endif // MODULES_VIDEO_CODING_NACK_MODULE2_H_
#endif // MODULES_VIDEO_CODING_NACK_REQUESTER_H_

78
modules/video_coding/nack_module2_unittest.cc → modules/video_coding/nack_requester_unittest.cc
View file

@ -8,7 +8,7 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/video_coding/nack_module2.h"
#include "modules/video_coding/nack_requester.h"
#include <algorithm>
#include <cstdint>
@ -24,11 +24,11 @@ namespace webrtc {
// TODO(bugs.webrtc.org/11594): Use the use the GlobalSimulatedTimeController
// instead of RunLoop. At the moment we mix use of the Clock and the underlying
// implementation of RunLoop, which is realtime.
class TestNackModule2 : public ::testing::TestWithParam<bool>,
class TestNackRequester : public ::testing::TestWithParam<bool>,
public NackSender,
public KeyFrameRequestSender {
protected:
TestNackModule2()
TestNackRequester()
: clock_(new SimulatedClock(0)),
field_trial_(GetParam()
? "WebRTC-ExponentialNackBackoff/enabled:true/"
@ -79,14 +79,14 @@ class TestNackModule2 : public ::testing::TestWithParam<bool>,
return true;
}
NackModule2& CreateNackModule(
NackRequester& CreateNackModule(
TimeDelta interval = NackPeriodicProcessor::kUpdateInterval) {
RTC_DCHECK(!nack_module_.get());
nack_periodic_processor_ =
std::make_unique<NackPeriodicProcessor>(interval);
nack_module_ = std::make_unique<NackModule2>(TaskQueueBase::Current(),
nack_periodic_processor_.get(),
clock_.get(), this, this);
nack_module_ = std::make_unique<NackRequester>(
TaskQueueBase::Current(), nack_periodic_processor_.get(), clock_.get(),
this, this);
nack_module_->UpdateRtt(kDefaultRttMs);
return *nack_module_.get();
}
@ -96,23 +96,23 @@ class TestNackModule2 : public ::testing::TestWithParam<bool>,
std::unique_ptr<SimulatedClock> clock_;
test::ScopedFieldTrials field_trial_;
std::unique_ptr<NackPeriodicProcessor> nack_periodic_processor_;
std::unique_ptr<NackModule2> nack_module_;
std::unique_ptr<NackRequester> nack_module_;
std::vector<uint16_t> sent_nacks_;
int keyframes_requested_;
bool waiting_for_send_nack_ = false;
bool timed_out_ = false;
};
TEST_P(TestNackModule2, NackOnePacket) {
NackModule2& nack_module = CreateNackModule();
TEST_P(TestNackRequester, NackOnePacket) {
NackRequester& nack_module = CreateNackModule();
nack_module.OnReceivedPacket(1, false, false);
nack_module.OnReceivedPacket(3, false, false);
ASSERT_EQ(1u, sent_nacks_.size());
EXPECT_EQ(2, sent_nacks_[0]);
}
TEST_P(TestNackModule2, WrappingSeqNum) {
NackModule2& nack_module = CreateNackModule();
TEST_P(TestNackRequester, WrappingSeqNum) {
NackRequester& nack_module = CreateNackModule();
nack_module.OnReceivedPacket(0xfffe, false, false);
nack_module.OnReceivedPacket(1, false, false);
ASSERT_EQ(2u, sent_nacks_.size());
@ -120,8 +120,8 @@ TEST_P(TestNackModule2, WrappingSeqNum) {
EXPECT_EQ(0, sent_nacks_[1]);
}
TEST_P(TestNackModule2, WrappingSeqNumClearToKeyframe) {
NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(10));
TEST_P(TestNackRequester, WrappingSeqNumClearToKeyframe) {
NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(10));
nack_module.OnReceivedPacket(0xfffe, false, false);
nack_module.OnReceivedPacket(1, false, false);
ASSERT_EQ(2u, sent_nacks_.size());
@ -185,8 +185,8 @@ TEST_P(TestNackModule2, WrappingSeqNumClearToKeyframe) {
EXPECT_EQ(1006, sent_nacks_[502]);
}
TEST_P(TestNackModule2, ResendNack) {
NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(1));
TEST_P(TestNackRequester, ResendNack) {
NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(1));
nack_module.OnReceivedPacket(1, false, false);
nack_module.OnReceivedPacket(3, false, false);
size_t expected_nacks_sent = 1;
@ -239,8 +239,8 @@ TEST_P(TestNackModule2, ResendNack) {
EXPECT_EQ(expected_nacks_sent, sent_nacks_.size());
}
TEST_P(TestNackModule2, ResendPacketMaxRetries) {
NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(1));
TEST_P(TestNackRequester, ResendPacketMaxRetries) {
NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(1));
nack_module.OnReceivedPacket(1, false, false);
nack_module.OnReceivedPacket(3, false, false);
ASSERT_EQ(1u, sent_nacks_.size());
@ -260,8 +260,8 @@ TEST_P(TestNackModule2, ResendPacketMaxRetries) {
EXPECT_EQ(10u, sent_nacks_.size());
}
TEST_P(TestNackModule2, TooLargeNackList) {
NackModule2& nack_module = CreateNackModule();
TEST_P(TestNackRequester, TooLargeNackList) {
NackRequester& nack_module = CreateNackModule();
nack_module.OnReceivedPacket(0, false, false);
nack_module.OnReceivedPacket(1001, false, false);
EXPECT_EQ(1000u, sent_nacks_.size());
@ -274,8 +274,8 @@ TEST_P(TestNackModule2, TooLargeNackList) {
EXPECT_EQ(1, keyframes_requested_);
}
TEST_P(TestNackModule2, TooLargeNackListWithKeyFrame) {
NackModule2& nack_module = CreateNackModule();
TEST_P(TestNackRequester, TooLargeNackListWithKeyFrame) {
NackRequester& nack_module = CreateNackModule();
nack_module.OnReceivedPacket(0, false, false);
nack_module.OnReceivedPacket(1, true, false);
nack_module.OnReceivedPacket(1001, false, false);
@ -289,8 +289,8 @@ TEST_P(TestNackModule2, TooLargeNackListWithKeyFrame) {
EXPECT_EQ(1, keyframes_requested_);
}
TEST_P(TestNackModule2, ClearUpTo) {
NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(1));
TEST_P(TestNackRequester, ClearUpTo) {
NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(1));
nack_module.OnReceivedPacket(0, false, false);
nack_module.OnReceivedPacket(100, false, false);
EXPECT_EQ(99u, sent_nacks_.size());
@ -303,8 +303,8 @@ TEST_P(TestNackModule2, ClearUpTo) {
EXPECT_EQ(50, sent_nacks_[0]);
}
TEST_P(TestNackModule2, ClearUpToWrap) {
NackModule2& nack_module = CreateNackModule();
TEST_P(TestNackRequester, ClearUpToWrap) {
NackRequester& nack_module = CreateNackModule();
nack_module.OnReceivedPacket(0xfff0, false, false);
nack_module.OnReceivedPacket(0xf, false, false);
EXPECT_EQ(30u, sent_nacks_.size());
@ -317,8 +317,8 @@ TEST_P(TestNackModule2, ClearUpToWrap) {
EXPECT_EQ(0, sent_nacks_[0]);
}
TEST_P(TestNackModule2, PacketNackCount) {
NackModule2& nack_module = CreateNackModule(TimeDelta::Millis(1));
TEST_P(TestNackRequester, PacketNackCount) {
NackRequester& nack_module = CreateNackModule(TimeDelta::Millis(1));
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));
@ -340,8 +340,8 @@ TEST_P(TestNackModule2, PacketNackCount) {
EXPECT_EQ(0, nack_module.OnReceivedPacket(4, false, false));
}
TEST_P(TestNackModule2, NackListFullAndNoOverlapWithKeyframes) {
NackModule2& nack_module = CreateNackModule();
TEST_P(TestNackRequester, NackListFullAndNoOverlapWithKeyframes) {
NackRequester& nack_module = CreateNackModule();
const int kMaxNackPackets = 1000;
const unsigned int kFirstGap = kMaxNackPackets - 20;
const unsigned int kSecondGap = 200;
@ -356,8 +356,8 @@ TEST_P(TestNackModule2, NackListFullAndNoOverlapWithKeyframes) {
EXPECT_EQ(kSecondGap, sent_nacks_.size());
}
TEST_P(TestNackModule2, HandleFecRecoveredPacket) {
NackModule2& nack_module = CreateNackModule();
TEST_P(TestNackRequester, HandleFecRecoveredPacket) {
NackRequester& nack_module = CreateNackModule();
nack_module.OnReceivedPacket(1, false, false);
nack_module.OnReceivedPacket(4, false, true);
EXPECT_EQ(0u, sent_nacks_.size());
@ -365,22 +365,22 @@ TEST_P(TestNackModule2, HandleFecRecoveredPacket) {
EXPECT_EQ(2u, sent_nacks_.size());
}
TEST_P(TestNackModule2, SendNackWithoutDelay) {
NackModule2& nack_module = CreateNackModule();
TEST_P(TestNackRequester, SendNackWithoutDelay) {
NackRequester& nack_module = CreateNackModule();
nack_module.OnReceivedPacket(0, false, false);
nack_module.OnReceivedPacket(100, false, false);
EXPECT_EQ(99u, sent_nacks_.size());
}
INSTANTIATE_TEST_SUITE_P(WithAndWithoutBackoff,
TestNackModule2,
TestNackRequester,
::testing::Values(true, false));
class TestNackModule2WithFieldTrial : public ::testing::Test,
class TestNackRequesterWithFieldTrial : public ::testing::Test,
public NackSender,
public KeyFrameRequestSender {
protected:
TestNackModule2WithFieldTrial()
TestNackRequesterWithFieldTrial()
: nack_delay_field_trial_("WebRTC-SendNackDelayMs/10/"),
clock_(new SimulatedClock(0)),
nack_module_(TaskQueueBase::Current(),
@ -401,12 +401,12 @@ class TestNackModule2WithFieldTrial : public ::testing::Test,
test::ScopedFieldTrials nack_delay_field_trial_;
std::unique_ptr<SimulatedClock> clock_;
NackPeriodicProcessor nack_periodic_processor_;
NackModule2 nack_module_;
NackRequester nack_module_;
std::vector<uint16_t> sent_nacks_;
int keyframes_requested_;
};
TEST_F(TestNackModule2WithFieldTrial, SendNackWithDelay) {
TEST_F(TestNackRequesterWithFieldTrial, SendNackWithDelay) {
nack_module_.OnReceivedPacket(0, false, false);
nack_module_.OnReceivedPacket(100, false, false);
EXPECT_EQ(0u, sent_nacks_.size());

2
video/BUILD.gn
View file

@ -95,7 +95,7 @@ rtc_library("video") {
"../modules/utility",
"../modules/video_coding",
"../modules/video_coding:codec_globals_headers",
"../modules/video_coding:nack_module",
"../modules/video_coding:nack_requester",
"../modules/video_coding:video_codec_interface",
"../modules/video_coding:video_coding_utility",
"../modules/video_processing",

6
video/rtp_video_stream_receiver2.cc
View file

@ -39,7 +39,7 @@
#include "modules/video_coding/frame_object.h"
#include "modules/video_coding/h264_sprop_parameter_sets.h"
#include "modules/video_coding/h264_sps_pps_tracker.h"
#include "modules/video_coding/nack_module2.h"
#include "modules/video_coding/nack_requester.h"
#include "modules/video_coding/packet_buffer.h"
#include "rtc_base/checks.h"
#include "rtc_base/location.h"
@ -103,7 +103,7 @@ std::unique_ptr<ModuleRtpRtcpImpl2> CreateRtpRtcpModule(
return rtp_rtcp;
}
std::unique_ptr<NackModule2> MaybeConstructNackModule(
std::unique_ptr<NackRequester> MaybeConstructNackModule(
TaskQueueBase* current_queue,
NackPeriodicProcessor* nack_periodic_processor,
const VideoReceiveStream::Config& config,
@ -114,7 +114,7 @@ std::unique_ptr<NackModule2> MaybeConstructNackModule(
return nullptr;
// TODO(bugs.webrtc.org/12420): pass rtp_history_ms to the nack module.
return std::make_unique<NackModule2>(current_queue, nack_periodic_processor,
return std::make_unique<NackRequester>(current_queue, nack_periodic_processor,
clock, nack_sender,
keyframe_request_sender);
}

6
video/rtp_video_stream_receiver2.h
View file

@ -39,7 +39,7 @@
#include "modules/rtp_rtcp/source/video_rtp_depacketizer.h"
#include "modules/video_coding/h264_sps_pps_tracker.h"
#include "modules/video_coding/loss_notification_controller.h"
#include "modules/video_coding/nack_module2.h"
#include "modules/video_coding/nack_requester.h"
#include "modules/video_coding/packet_buffer.h"
#include "modules/video_coding/rtp_frame_reference_finder.h"
#include "modules/video_coding/unique_timestamp_counter.h"
@ -53,7 +53,7 @@
namespace webrtc {
class NackModule2;
class NackRequester;
class PacketRouter;
class ReceiveStatistics;
class RtcpRttStats;
@ -316,7 +316,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
KeyFrameRequestSender* const keyframe_request_sender_;
RtcpFeedbackBuffer rtcp_feedback_buffer_;
const std::unique_ptr<NackModule2> nack_module_;
const std::unique_ptr<NackRequester> nack_module_;
std::unique_ptr<LossNotificationController> loss_notification_controller_;
video_coding::PacketBuffer packet_buffer_

2
video/video_receive_stream2.h
View file

@ -25,7 +25,7 @@
#include "modules/rtp_rtcp/include/flexfec_receiver.h"
#include "modules/rtp_rtcp/source/source_tracker.h"
#include "modules/video_coding/frame_buffer2.h"
#include "modules/video_coding/nack_module2.h"
#include "modules/video_coding/nack_requester.h"
#include "modules/video_coding/video_receiver2.h"
#include "rtc_base/system/no_unique_address.h"
#include "rtc_base/task_queue.h"