admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Pass Environment into RtcpReceiver

Browse Source 
to avoid relying on the global field trials.

Bug: webrtc:362762208
Change-Id: I94e96f0a3f16cfd64f7deb4deb4aaa924ac1bba8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/361865
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#42982}
This commit is contained in:
Danil Chapovalov 2024-09-06 15:26:14 +00:00 committed by WebRTC LUCI CQ
parent 3652dd30db
commit 02113a2169
8 changed files with 181 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
modules/rtp_rtcp/BUILD.gn
View File

@ -295,7 +295,6 @@ rtc_library("rtp_rtcp") {
"../../api/rtc_event_log", "../../api/rtc_event_log",
"../../api/task_queue", "../../api/task_queue",
"../../api/task_queue:pending_task_safety_flag", "../../api/task_queue:pending_task_safety_flag",
"../../api/transport:field_trial_based_config",
"../../api/transport:network_control", "../../api/transport:network_control",
"../../api/transport/rtp:dependency_descriptor", "../../api/transport/rtp:dependency_descriptor",
"../../api/transport/rtp:rtp_source", "../../api/transport/rtp:rtp_source",
@ -728,7 +727,6 @@ if (rtc_include_tests) {
"../../test:mock_transport", "../../test:mock_transport",
"../../test:rtp_test_utils", "../../test:rtp_test_utils",
"../../test:run_loop", "../../test:run_loop",
"../../test:scoped_key_value_config",
"../../test:test_support", "../../test:test_support",
"../../test/time_controller:time_controller", "../../test/time_controller:time_controller",
"../video_coding:codec_globals_headers", "../video_coding:codec_globals_headers",

56
modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -26,8 +26,9 @@
#include "absl/algorithm/container.h" #include "absl/algorithm/container.h"
#include "absl/base/attributes.h" #include "absl/base/attributes.h"
#include "api/array_view.h" #include "api/array_view.h"
#include "api/environment/environment.h"
#include "api/field_trials_view.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/transport/field_trial_based_config.h"
#include "api/transport/network_types.h" #include "api/transport/network_types.h"
#include "api/units/data_rate.h" #include "api/units/data_rate.h"
#include "api/units/time_delta.h" #include "api/units/time_delta.h"
@ -157,11 +158,12 @@ struct RTCPReceiver::PacketInformation {
std::unique_ptr<rtcp::LossNotification> loss_notification; std::unique_ptr<rtcp::LossNotification> loss_notification;
}; };
RTCPReceiver::RTCPReceiver(const RtpRtcpInterface::Configuration& config, RTCPReceiver::RTCPReceiver(const Environment& env,
const RtpRtcpInterface::Configuration& config,
ModuleRtpRtcpImpl2* owner) ModuleRtpRtcpImpl2* owner)
: clock_(config.clock), : env_(env),
receiver_only_(config.receiver_only), receiver_only_(config.receiver_only),
enable_congestion_controller_feedback_(FieldTrialBasedConfig().IsEnabled( enable_congestion_controller_feedback_(env_.field_trials().IsEnabled(
"WebRTC-RFC8888CongestionControlFeedback")), "WebRTC-RFC8888CongestionControlFeedback")),
rtp_rtcp_(owner), rtp_rtcp_(owner),
registered_ssrcs_(false, config), registered_ssrcs_(false, config),
@ -182,15 +184,16 @@ RTCPReceiver::RTCPReceiver(const RtpRtcpInterface::Configuration& config,
report_block_data_observer_(config.report_block_data_observer), report_block_data_observer_(config.report_block_data_observer),
packet_type_counter_observer_(config.rtcp_packet_type_counter_observer), packet_type_counter_observer_(config.rtcp_packet_type_counter_observer),
num_skipped_packets_(0), num_skipped_packets_(0),
last_skipped_packets_warning_(clock_->CurrentTime()) { last_skipped_packets_warning_(env_.clock().CurrentTime()) {
RTC_DCHECK(owner); RTC_DCHECK(owner);
} }
RTCPReceiver::RTCPReceiver(const RtpRtcpInterface::Configuration& config, RTCPReceiver::RTCPReceiver(const Environment& env,
const RtpRtcpInterface::Configuration& config,
ModuleRtpRtcp* owner) ModuleRtpRtcp* owner)
: clock_(config.clock), : env_(env),
receiver_only_(config.receiver_only), receiver_only_(config.receiver_only),
enable_congestion_controller_feedback_(FieldTrialBasedConfig().IsEnabled( enable_congestion_controller_feedback_(env_.field_trials().IsEnabled(
"WebRTC-RFC8888CongestionControlFeedback")), "WebRTC-RFC8888CongestionControlFeedback")),
rtp_rtcp_(owner), rtp_rtcp_(owner),
registered_ssrcs_(true, config), registered_ssrcs_(true, config),
@ -211,7 +214,7 @@ RTCPReceiver::RTCPReceiver(const RtpRtcpInterface::Configuration& config,
report_block_data_observer_(config.report_block_data_observer), report_block_data_observer_(config.report_block_data_observer),
packet_type_counter_observer_(config.rtcp_packet_type_counter_observer), packet_type_counter_observer_(config.rtcp_packet_type_counter_observer),
num_skipped_packets_(0), num_skipped_packets_(0),
last_skipped_packets_warning_(clock_->CurrentTime()) { last_skipped_packets_warning_(env_.clock().CurrentTime()) {
RTC_DCHECK(owner); RTC_DCHECK(owner);
// Dear reader - if you're here because of this log statement and are // Dear reader - if you're here because of this log statement and are
// wondering what this is about, chances are that you are using an instance // wondering what this is about, chances are that you are using an instance
@ -337,7 +340,7 @@ std::optional<TimeDelta> RTCPReceiver::OnPeriodicRttUpdate(Timestamp newer_than,
} }
// Check for expired timers and if so, log and reset. // Check for expired timers and if so, log and reset.
Timestamp now = clock_->CurrentTime(); Timestamp now = env_.clock().CurrentTime();
if (RtcpRrTimeoutLocked(now)) { if (RtcpRrTimeoutLocked(now)) {
RTC_LOG_F(LS_WARNING) << "Timeout: No RTCP RR received."; RTC_LOG_F(LS_WARNING) << "Timeout: No RTCP RR received.";
} else if (RtcpRrSequenceNumberTimeoutLocked(now)) { } else if (RtcpRrSequenceNumberTimeoutLocked(now)) {
@ -371,7 +374,7 @@ RTCPReceiver::ConsumeReceivedXrReferenceTimeInfo() {
std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis; std::vector<rtcp::ReceiveTimeInfo> last_xr_rtis;
last_xr_rtis.reserve(last_xr_rtis_size); last_xr_rtis.reserve(last_xr_rtis_size);
const uint32_t now_ntp = CompactNtp(clock_->CurrentNtpTime()); const uint32_t now_ntp = CompactNtp(env_.clock().CurrentNtpTime());
for (size_t i = 0; i < last_xr_rtis_size; ++i) { for (size_t i = 0; i < last_xr_rtis_size; ++i) {
RrtrInformation& rrtr = received_rrtrs_.front(); RrtrInformation& rrtr = received_rrtrs_.front();
@ -497,7 +500,7 @@ bool RTCPReceiver::ParseCompoundPacket(rtc::ArrayView<const uint8_t> packet,
} }
if (num_skipped_packets_ > 0) { if (num_skipped_packets_ > 0) {
const Timestamp now = clock_->CurrentTime(); const Timestamp now = env_.clock().CurrentTime();
if (now - last_skipped_packets_warning_ >= kMaxWarningLogInterval) { if (now - last_skipped_packets_warning_ >= kMaxWarningLogInterval) {
last_skipped_packets_warning_ = now; last_skipped_packets_warning_ = now;
RTC_LOG(LS_WARNING) RTC_LOG(LS_WARNING)
@ -550,7 +553,7 @@ bool RTCPReceiver::HandleSenderReport(const CommonHeader& rtcp_block,
remote_sender_.last_remote_timestamp = sender_report.ntp(); remote_sender_.last_remote_timestamp = sender_report.ntp();
remote_sender_.last_remote_rtp_timestamp = sender_report.rtp_timestamp(); remote_sender_.last_remote_rtp_timestamp = sender_report.rtp_timestamp();
remote_sender_.last_arrival_timestamp = clock_->CurrentNtpTime(); remote_sender_.last_arrival_timestamp = env_.clock().CurrentNtpTime();
remote_sender_.packets_sent = sender_report.sender_packet_count(); remote_sender_.packets_sent = sender_report.sender_packet_count();
remote_sender_.bytes_sent = sender_report.sender_octet_count(); remote_sender_.bytes_sent = sender_report.sender_octet_count();
remote_sender_.reports_count++; remote_sender_.reports_count++;
@ -605,7 +608,7 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
if (!registered_ssrcs_.contains(report_block.source_ssrc())) if (!registered_ssrcs_.contains(report_block.source_ssrc()))
return; return;
Timestamp now = clock_->CurrentTime(); Timestamp now = env_.clock().CurrentTime();
last_received_rb_ = now; last_received_rb_ = now;
ReportBlockData* report_block_data = ReportBlockData* report_block_data =
@ -616,7 +619,7 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block,
// the last RR was sent from the remote side. // the last RR was sent from the remote side.
last_increased_sequence_number_ = last_received_rb_; last_increased_sequence_number_ = last_received_rb_;
} }
NtpTime now_ntp = clock_->ConvertTimestampToNtpTime(now); NtpTime now_ntp = env_.clock().ConvertTimestampToNtpTime(now);
// Number of seconds since 1900 January 1 00:00 GMT (see // Number of seconds since 1900 January 1 00:00 GMT (see
// https://tools.ietf.org/html/rfc868). // https://tools.ietf.org/html/rfc868).
report_block_data->SetReportBlock( report_block_data->SetReportBlock(
@ -653,14 +656,14 @@ RTCPReceiver::TmmbrInformation* RTCPReceiver::FindOrCreateTmmbrInfo(
// Create or find receive information. // Create or find receive information.
TmmbrInformation* tmmbr_info = &tmmbr_infos_[remote_ssrc]; TmmbrInformation* tmmbr_info = &tmmbr_infos_[remote_ssrc];
// Update that this remote is alive. // Update that this remote is alive.
tmmbr_info->last_time_received = clock_->CurrentTime(); tmmbr_info->last_time_received = env_.clock().CurrentTime();
return tmmbr_info; return tmmbr_info;
} }
void RTCPReceiver::UpdateTmmbrRemoteIsAlive(uint32_t remote_ssrc) { void RTCPReceiver::UpdateTmmbrRemoteIsAlive(uint32_t remote_ssrc) {
auto tmmbr_it = tmmbr_infos_.find(remote_ssrc); auto tmmbr_it = tmmbr_infos_.find(remote_ssrc);
if (tmmbr_it != tmmbr_infos_.end()) if (tmmbr_it != tmmbr_infos_.end())
tmmbr_it->second.last_time_received = clock_->CurrentTime(); tmmbr_it->second.last_time_received = env_.clock().CurrentTime();
} }
RTCPReceiver::TmmbrInformation* RTCPReceiver::GetTmmbrInformation( RTCPReceiver::TmmbrInformation* RTCPReceiver::GetTmmbrInformation(
@ -677,18 +680,18 @@ RTCPReceiver::TmmbrInformation* RTCPReceiver::GetTmmbrInformation(
// the worker thread and thus no locking is needed. // the worker thread and thus no locking is needed.
bool RTCPReceiver::RtcpRrTimeout() { bool RTCPReceiver::RtcpRrTimeout() {
MutexLock lock(&rtcp_receiver_lock_); MutexLock lock(&rtcp_receiver_lock_);
return RtcpRrTimeoutLocked(clock_->CurrentTime()); return RtcpRrTimeoutLocked(env_.clock().CurrentTime());
} }
bool RTCPReceiver::RtcpRrSequenceNumberTimeout() { bool RTCPReceiver::RtcpRrSequenceNumberTimeout() {
MutexLock lock(&rtcp_receiver_lock_); MutexLock lock(&rtcp_receiver_lock_);
return RtcpRrSequenceNumberTimeoutLocked(clock_->CurrentTime()); return RtcpRrSequenceNumberTimeoutLocked(env_.clock().CurrentTime());
} }
bool RTCPReceiver::UpdateTmmbrTimers() { bool RTCPReceiver::UpdateTmmbrTimers() {
MutexLock lock(&rtcp_receiver_lock_); MutexLock lock(&rtcp_receiver_lock_);
Timestamp timeout = clock_->CurrentTime() - kTmmbrTimeoutInterval; Timestamp timeout = env_.clock().CurrentTime() - kTmmbrTimeoutInterval;
if (oldest_tmmbr_info_ >= timeout) if (oldest_tmmbr_info_ >= timeout)
return false; return false;
@ -846,7 +849,8 @@ bool RTCPReceiver::HandleXr(const CommonHeader& rtcp_block,
void RTCPReceiver::HandleXrReceiveReferenceTime(uint32_t sender_ssrc, void RTCPReceiver::HandleXrReceiveReferenceTime(uint32_t sender_ssrc,
const rtcp::Rrtr& rrtr) { const rtcp::Rrtr& rrtr) {
uint32_t received_remote_mid_ntp_time = CompactNtp(rrtr.ntp()); uint32_t received_remote_mid_ntp_time = CompactNtp(rrtr.ntp());
uint32_t local_receive_mid_ntp_time = CompactNtp(clock_->CurrentNtpTime()); uint32_t local_receive_mid_ntp_time =
CompactNtp(env_.clock().CurrentNtpTime());
auto it = received_rrtrs_ssrc_it_.find(sender_ssrc); auto it = received_rrtrs_ssrc_it_.find(sender_ssrc);
if (it != received_rrtrs_ssrc_it_.end()) { if (it != received_rrtrs_ssrc_it_.end()) {
@ -886,7 +890,7 @@ void RTCPReceiver::HandleXrDlrrReportBlock(uint32_t sender_ssrc,
} }
uint32_t delay_ntp = rti.delay_since_last_rr; uint32_t delay_ntp = rti.delay_since_last_rr;
uint32_t now_ntp = CompactNtp(clock_->CurrentNtpTime()); uint32_t now_ntp = CompactNtp(env_.clock().CurrentNtpTime());
uint32_t rtt_ntp = now_ntp - delay_ntp - send_time_ntp; uint32_t rtt_ntp = now_ntp - delay_ntp - send_time_ntp;
TimeDelta rtt = CompactNtpRttToTimeDelta(rtt_ntp); TimeDelta rtt = CompactNtpRttToTimeDelta(rtt_ntp);
@ -1029,7 +1033,7 @@ bool RTCPReceiver::HandleFir(const CommonHeader& rtcp_block,
if (fir.requests().empty()) if (fir.requests().empty())
return true; return true;
const Timestamp now = clock_->CurrentTime(); const Timestamp now = env_.clock().CurrentTime();
for (const rtcp::Fir::Request& fir_request : fir.requests()) { for (const rtcp::Fir::Request& fir_request : fir.requests()) {
// Is it our sender that is requested to generate a new keyframe. // Is it our sender that is requested to generate a new keyframe.
if (local_media_ssrc() != fir_request.ssrc) if (local_media_ssrc() != fir_request.ssrc)
@ -1100,7 +1104,7 @@ void RTCPReceiver::NotifyTmmbrUpdated() {
uint64_t bitrate_bps = TMMBRHelp::CalcMinBitrateBps(bounding); uint64_t bitrate_bps = TMMBRHelp::CalcMinBitrateBps(bounding);
if (bitrate_bps < std::numeric_limits<int64_t>::max()) { if (bitrate_bps < std::numeric_limits<int64_t>::max()) {
network_link_rtcp_observer_->OnReceiverEstimatedMaxBitrate( network_link_rtcp_observer_->OnReceiverEstimatedMaxBitrate(
clock_->CurrentTime(), DataRate::BitsPerSec(bitrate_bps)); env_.clock().CurrentTime(), DataRate::BitsPerSec(bitrate_bps));
} }
} }
@ -1162,7 +1166,7 @@ void RTCPReceiver::TriggerCallbacksFromRtcpPacket(
} }
if (network_link_rtcp_observer_) { if (network_link_rtcp_observer_) {
Timestamp now = clock_->CurrentTime(); Timestamp now = env_.clock().CurrentTime();
if (packet_information.packet_type_flags & kRtcpRemb) { if (packet_information.packet_type_flags & kRtcpRemb) {
network_link_rtcp_observer_->OnReceiverEstimatedMaxBitrate( network_link_rtcp_observer_->OnReceiverEstimatedMaxBitrate(
now, DataRate::BitsPerSec( now, DataRate::BitsPerSec(
@ -1218,7 +1222,7 @@ std::vector<rtcp::TmmbItem> RTCPReceiver::TmmbrReceived() {
MutexLock lock(&rtcp_receiver_lock_); MutexLock lock(&rtcp_receiver_lock_);
std::vector<rtcp::TmmbItem> candidates; std::vector<rtcp::TmmbItem> candidates;
Timestamp now = clock_->CurrentTime(); Timestamp now = env_.clock().CurrentTime();
for (auto& kv : tmmbr_infos_) { for (auto& kv : tmmbr_infos_) {
for (auto it = kv.second.tmmbr.begin(); it != kv.second.tmmbr.end();) { for (auto it = kv.second.tmmbr.begin(); it != kv.second.tmmbr.end();) {

10
modules/rtp_rtcp/source/rtcp_receiver.h
View File

@ -20,6 +20,7 @@
#include "absl/container/inlined_vector.h" #include "absl/container/inlined_vector.h"
#include "api/array_view.h" #include "api/array_view.h"
#include "api/environment/environment.h"
#include "api/sequence_checker.h" #include "api/sequence_checker.h"
#include "api/units/time_delta.h" #include "api/units/time_delta.h"
#include "api/units/timestamp.h" #include "api/units/timestamp.h"
@ -36,7 +37,6 @@
#include "rtc_base/synchronization/mutex.h" #include "rtc_base/synchronization/mutex.h"
#include "rtc_base/system/no_unique_address.h" #include "rtc_base/system/no_unique_address.h"
#include "rtc_base/thread_annotations.h" #include "rtc_base/thread_annotations.h"
#include "system_wrappers/include/clock.h"
namespace webrtc { namespace webrtc {
@ -95,10 +95,12 @@ class RTCPReceiver final {
int round_trip_time_measurements_ = 0; int round_trip_time_measurements_ = 0;
}; };
RTCPReceiver(const RtpRtcpInterface::Configuration& config, RTCPReceiver(const Environment& env,
const RtpRtcpInterface::Configuration& config,
ModuleRtpRtcp* owner); ModuleRtpRtcp* owner);
RTCPReceiver(const RtpRtcpInterface::Configuration& config, RTCPReceiver(const Environment& env,
const RtpRtcpInterface::Configuration& config,
ModuleRtpRtcpImpl2* owner); ModuleRtpRtcpImpl2* owner);
~RTCPReceiver(); ~RTCPReceiver();
@ -356,7 +358,7 @@ class RTCPReceiver final {
bool RtcpRrSequenceNumberTimeoutLocked(Timestamp now) bool RtcpRrSequenceNumberTimeoutLocked(Timestamp now)
RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_); RTC_EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
Clock* const clock_; const Environment env_;
const bool receiver_only_; const bool receiver_only_;
const bool enable_congestion_controller_feedback_; const bool enable_congestion_controller_feedback_;
ModuleRtpRtcp* const rtp_rtcp_; ModuleRtpRtcp* const rtp_rtcp_;

262
modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
View File

@ -10,24 +10,35 @@
#include "modules/rtp_rtcp/source/rtcp_receiver.h" #include "modules/rtp_rtcp/source/rtcp_receiver.h"
#include <cstddef>
#include <cstdint>
#include <memory> #include <memory>
#include <optional>
#include <set> #include <set>
#include <string>
#include <utility> #include <utility>
#include <vector>
#include "absl/strings/string_view.h"
#include "api/array_view.h" #include "api/array_view.h"
#include "api/environment/environment_factory.h"
#include "api/units/data_rate.h"
#include "api/units/time_delta.h" #include "api/units/time_delta.h"
#include "api/units/timestamp.h" #include "api/units/timestamp.h"
#include "api/video/video_bitrate_allocation.h" #include "api/video/video_bitrate_allocation.h"
#include "api/video/video_bitrate_allocator.h" #include "api/video/video_bitrate_allocator.h"
#include "api/video/video_codec_constants.h"
#include "modules/rtp_rtcp/include/report_block_data.h" #include "modules/rtp_rtcp/include/report_block_data.h"
#include "modules/rtp_rtcp/include/rtcp_statistics.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/mocks/mock_network_link_rtcp_observer.h" #include "modules/rtp_rtcp/mocks/mock_network_link_rtcp_observer.h"
#include "modules/rtp_rtcp/source/byte_io.h" #include "modules/rtp_rtcp/source/byte_io.h"
#include "modules/rtp_rtcp/source/ntp_time_util.h" #include "modules/rtp_rtcp/source/ntp_time_util.h"
#include "modules/rtp_rtcp/source/rtcp_packet.h"
#include "modules/rtp_rtcp/source/rtcp_packet/app.h" #include "modules/rtp_rtcp/source/rtcp_packet/app.h"
#include "modules/rtp_rtcp/source/rtcp_packet/bye.h" #include "modules/rtp_rtcp/source/rtcp_packet/bye.h"
#include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h" #include "modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
#include "modules/rtp_rtcp/source/rtcp_packet/congestion_control_feedback.h" #include "modules/rtp_rtcp/source/rtcp_packet/congestion_control_feedback.h"
#include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
#include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h" #include "modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
#include "modules/rtp_rtcp/source/rtcp_packet/fir.h" #include "modules/rtp_rtcp/source/rtcp_packet/fir.h"
#include "modules/rtp_rtcp/source/rtcp_packet/nack.h" #include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
@ -35,17 +46,21 @@
#include "modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h" #include "modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
#include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" #include "modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
#include "modules/rtp_rtcp/source/rtcp_packet/remb.h" #include "modules/rtp_rtcp/source/rtcp_packet/remb.h"
#include "modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
#include "modules/rtp_rtcp/source/rtcp_packet/sdes.h" #include "modules/rtp_rtcp/source/rtcp_packet/sdes.h"
#include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h" #include "modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
#include "modules/rtp_rtcp/source/rtcp_packet/tmmbr.h" #include "modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
#include "rtc_base/arraysize.h" #include "rtc_base/arraysize.h"
#include "rtc_base/fake_clock.h" #include "rtc_base/buffer.h"
#include "rtc_base/random.h" #include "rtc_base/random.h"
#include "rtc_base/time_utils.h"
#include "system_wrappers/include/clock.h"
#include "system_wrappers/include/ntp_time.h" #include "system_wrappers/include/ntp_time.h"
#include "test/explicit_key_value_config.h"
#include "test/gmock.h" #include "test/gmock.h"
#include "test/gtest.h" #include "test/gtest.h"
#include "test/scoped_key_value_config.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -66,7 +81,7 @@ using ::testing::SizeIs;
using ::testing::StrEq; using ::testing::StrEq;
using ::testing::StrictMock; using ::testing::StrictMock;
using ::testing::UnorderedElementsAre; using ::testing::UnorderedElementsAre;
using ::webrtc::test::ScopedKeyValueConfig; using ::webrtc::test::ExplicitKeyValueConfig;
class MockRtcpPacketTypeCounterObserver : public RtcpPacketTypeCounterObserver { class MockRtcpPacketTypeCounterObserver : public RtcpPacketTypeCounterObserver {
public: public:
@ -143,9 +158,8 @@ constexpr TimeDelta kEpsilon = TimeDelta::Millis(1);
} // namespace } // namespace
struct ReceiverMocks { struct ReceiverMocks {
ReceiverMocks() : clock(1335900000) {} SimulatedClock clock{1335900000};
std::string field_trials;
SimulatedClock clock;
// Callbacks to packet_type_counter_observer are frequent but most of the time // Callbacks to packet_type_counter_observer are frequent but most of the time
// are not interesting. // are not interesting.
NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer; NiceMock<MockRtcpPacketTypeCounterObserver> packet_type_counter_observer;
@ -154,28 +168,30 @@ struct ReceiverMocks {
StrictMock<MockVideoBitrateAllocationObserver> bitrate_allocation_observer; StrictMock<MockVideoBitrateAllocationObserver> bitrate_allocation_observer;
StrictMock<MockModuleRtpRtcp> rtp_rtcp_impl; StrictMock<MockModuleRtpRtcp> rtp_rtcp_impl;
NiceMock<MockNetworkLinkRtcpObserver> network_link_rtcp_observer; NiceMock<MockNetworkLinkRtcpObserver> network_link_rtcp_observer;
RtpRtcpInterface::Configuration config = {
.receiver_only = false,
.intra_frame_callback = &intra_frame_observer,
.rtcp_loss_notification_observer = &rtcp_loss_notification_observer,
.network_link_rtcp_observer = &network_link_rtcp_observer,
.bitrate_allocation_observer = &bitrate_allocation_observer,
.rtcp_packet_type_counter_observer = &packet_type_counter_observer,
.rtcp_report_interval_ms = kRtcpIntervalMs,
.local_media_ssrc = kReceiverMainSsrc,
.rtx_send_ssrc = kReceiverExtraSsrc};
}; };
RtpRtcpInterface::Configuration DefaultConfiguration(ReceiverMocks* mocks) { RTCPReceiver Create(ReceiverMocks& mocks) {
RtpRtcpInterface::Configuration config; return RTCPReceiver(
config.clock = &mocks->clock; CreateEnvironment(
config.receiver_only = false; &mocks.clock,
config.rtcp_packet_type_counter_observer = std::make_unique<test::ExplicitKeyValueConfig>(mocks.field_trials)),
&mocks->packet_type_counter_observer; mocks.config, &mocks.rtp_rtcp_impl);
config.network_link_rtcp_observer = &mocks->network_link_rtcp_observer;
config.intra_frame_callback = &mocks->intra_frame_observer;
config.rtcp_loss_notification_observer =
&mocks->rtcp_loss_notification_observer;
config.bitrate_allocation_observer = &mocks->bitrate_allocation_observer;
config.rtcp_report_interval_ms = kRtcpIntervalMs;
config.local_media_ssrc = kReceiverMainSsrc;
config.rtx_send_ssrc = kReceiverExtraSsrc;
return config;
} }
TEST(RtcpReceiverTest, BrokenPacketIsIgnored) { TEST(RtcpReceiverTest, BrokenPacketIsIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
const uint8_t bad_packet[] = {0, 0, 0, 0}; const uint8_t bad_packet[] = {0, 0, 0, 0};
EXPECT_CALL(mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated) EXPECT_CALL(mocks.packet_type_counter_observer, RtcpPacketTypesCounterUpdated)
@ -185,7 +201,7 @@ TEST(RtcpReceiverTest, BrokenPacketIsIgnored) {
TEST(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) { TEST(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
// Too short feedback packet. // Too short feedback packet.
const uint8_t bad_packet[] = {0x81, rtcp::Rtpfb::kPacketType, 0, 0}; const uint8_t bad_packet[] = {0x81, rtcp::Rtpfb::kPacketType, 0, 0};
@ -197,7 +213,7 @@ TEST(RtcpReceiverTest, InvalidFeedbackPacketIsIgnored) {
TEST(RtcpReceiverTest, InjectSrPacket) { TEST(RtcpReceiverTest, InjectSrPacket) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
EXPECT_FALSE(receiver.GetSenderReportStats()); EXPECT_FALSE(receiver.GetSenderReportStats());
@ -213,7 +229,7 @@ TEST(RtcpReceiverTest, InjectSrPacket) {
TEST(RtcpReceiverTest, InjectSrPacketFromUnknownSender) { TEST(RtcpReceiverTest, InjectSrPacketFromUnknownSender) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::SenderReport sr; rtcp::SenderReport sr;
@ -230,7 +246,7 @@ TEST(RtcpReceiverTest, InjectSrPacketFromUnknownSender) {
TEST(RtcpReceiverTest, InjectSrPacketCalculatesRTT) { TEST(RtcpReceiverTest, InjectSrPacketCalculatesRTT) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const TimeDelta kRtt = TimeDelta::Millis(123); const TimeDelta kRtt = TimeDelta::Millis(123);
@ -259,7 +275,7 @@ TEST(RtcpReceiverTest, InjectSrPacketCalculatesRTT) {
TEST(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOneMs) { TEST(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOneMs) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const TimeDelta kRtt = TimeDelta::Millis(-13); const TimeDelta kRtt = TimeDelta::Millis(-13);
@ -289,7 +305,7 @@ TEST(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOneMs) {
TEST(RtcpReceiverTest, TwoReportBlocksWithLastOneWithoutLastSrCalculatesRtt) { TEST(RtcpReceiverTest, TwoReportBlocksWithLastOneWithoutLastSrCalculatesRtt) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const TimeDelta kRtt = TimeDelta::Millis(125); const TimeDelta kRtt = TimeDelta::Millis(125);
@ -317,7 +333,7 @@ TEST(RtcpReceiverTest, TwoReportBlocksWithLastOneWithoutLastSrCalculatesRtt) {
TEST(RtcpReceiverTest, InjectRrPacket) { TEST(RtcpReceiverTest, InjectRrPacket) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ReceiverReport rr; rtcp::ReceiverReport rr;
@ -331,7 +347,7 @@ TEST(RtcpReceiverTest, InjectRrPacket) {
TEST(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) { TEST(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ReportBlock rb; rtcp::ReportBlock rb;
@ -350,7 +366,7 @@ TEST(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
TEST(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) { TEST(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
Timestamp now = mocks.clock.CurrentTime(); Timestamp now = mocks.clock.CurrentTime();
@ -371,7 +387,7 @@ TEST(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
TEST(RtcpReceiverTest, InjectSrPacketWithOneReportBlock) { TEST(RtcpReceiverTest, InjectSrPacketWithOneReportBlock) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
Timestamp now = mocks.clock.CurrentTime(); Timestamp now = mocks.clock.CurrentTime();
@ -395,7 +411,7 @@ TEST(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
const uint32_t kCumLost[] = {13, 555}; const uint32_t kCumLost[] = {13, 555};
const uint8_t kFracLost[] = {20, 11}; const uint8_t kFracLost[] = {20, 11};
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
Timestamp now = mocks.clock.CurrentTime(); Timestamp now = mocks.clock.CurrentTime();
@ -473,7 +489,7 @@ TEST(RtcpReceiverTest,
const int32_t kCumLost[] = {13, 555}; const int32_t kCumLost[] = {13, 555};
const uint8_t kFracLost[] = {20, 11}; const uint8_t kFracLost[] = {20, 11};
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ReportBlock rb1; rtcp::ReportBlock rb1;
@ -525,7 +541,7 @@ TEST(RtcpReceiverTest,
TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnReportBlocks) { TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnReportBlocks) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ReportBlock rb1; rtcp::ReportBlock rb1;
@ -559,9 +575,8 @@ TEST(RtcpReceiverTest, GetRtt) {
const uint32_t kSentCompactNtp = 0x1234; const uint32_t kSentCompactNtp = 0x1234;
const uint32_t kDelayCompactNtp = 0x222; const uint32_t kDelayCompactNtp = 0x222;
ReceiverMocks mocks; ReceiverMocks mocks;
RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks); mocks.config.network_link_rtcp_observer = &mocks.network_link_rtcp_observer;
config.network_link_rtcp_observer = &mocks.network_link_rtcp_observer; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
// No report block received. // No report block received.
@ -591,7 +606,7 @@ TEST(RtcpReceiverTest, GetRtt) {
// App packets are ignored. // App packets are ignored.
TEST(RtcpReceiverTest, InjectApp) { TEST(RtcpReceiverTest, InjectApp) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::App app; rtcp::App app;
@ -606,9 +621,8 @@ TEST(RtcpReceiverTest, InjectApp) {
TEST(RtcpReceiverTest, InjectSdesWithOneChunk) { TEST(RtcpReceiverTest, InjectSdesWithOneChunk) {
ReceiverMocks mocks; ReceiverMocks mocks;
MockCnameCallbackImpl callback; MockCnameCallbackImpl callback;
RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks); mocks.config.rtcp_cname_callback = &callback;
config.rtcp_cname_callback = &callback; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const char kCname[] = "alice@host"; const char kCname[] = "alice@host";
@ -621,7 +635,7 @@ TEST(RtcpReceiverTest, InjectSdesWithOneChunk) {
TEST(RtcpReceiverTest, InjectByePacketRemovesReportBlocks) { TEST(RtcpReceiverTest, InjectByePacketRemovesReportBlocks) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ReportBlock rb1; rtcp::ReportBlock rb1;
@ -655,7 +669,7 @@ TEST(RtcpReceiverTest, InjectByePacketRemovesReportBlocks) {
TEST(RtcpReceiverTest, InjectByePacketRemovesReferenceTimeInfo) { TEST(RtcpReceiverTest, InjectByePacketRemovesReferenceTimeInfo) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ExtendedReports xr; rtcp::ExtendedReports xr;
@ -674,7 +688,7 @@ TEST(RtcpReceiverTest, InjectByePacketRemovesReferenceTimeInfo) {
TEST(RtcpReceiverTest, InjectPliPacket) { TEST(RtcpReceiverTest, InjectPliPacket) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::Pli pli; rtcp::Pli pli;
@ -691,7 +705,7 @@ TEST(RtcpReceiverTest, InjectPliPacket) {
TEST(RtcpReceiverTest, PliPacketNotToUsIgnored) { TEST(RtcpReceiverTest, PliPacketNotToUsIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::Pli pli; rtcp::Pli pli;
@ -707,7 +721,7 @@ TEST(RtcpReceiverTest, PliPacketNotToUsIgnored) {
TEST(RtcpReceiverTest, InjectFirPacket) { TEST(RtcpReceiverTest, InjectFirPacket) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::Fir fir; rtcp::Fir fir;
@ -724,7 +738,7 @@ TEST(RtcpReceiverTest, InjectFirPacket) {
TEST(RtcpReceiverTest, FirPacketNotToUsIgnored) { TEST(RtcpReceiverTest, FirPacketNotToUsIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::Fir fir; rtcp::Fir fir;
@ -736,7 +750,7 @@ TEST(RtcpReceiverTest, FirPacketNotToUsIgnored) {
TEST(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) { TEST(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ExtendedReports xr; rtcp::ExtendedReports xr;
@ -747,7 +761,7 @@ TEST(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
TEST(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) { TEST(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const NtpTime kNtp(0x10203, 0x40506); const NtpTime kNtp(0x10203, 0x40506);
@ -772,10 +786,9 @@ TEST(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
TEST(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) { TEST(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks);
// Allow calculate rtt using dlrr/rrtr, simulating media receiver side. // Allow calculate rtt using dlrr/rrtr, simulating media receiver side.
config.non_sender_rtt_measurement = true; mocks.config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ExtendedReports xr; rtcp::ExtendedReports xr;
@ -794,9 +807,8 @@ TEST(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) { TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint32_t kLastRR = 0x12345; const uint32_t kLastRR = 0x12345;
@ -822,9 +834,8 @@ TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) { TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint32_t kLastRR = 0x12345; const uint32_t kLastRR = 0x12345;
@ -851,9 +862,8 @@ TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) { TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::Rrtr rrtr; rtcp::Rrtr rrtr;
@ -872,9 +882,8 @@ TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) { TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::Rrtr rrtr; rtcp::Rrtr rrtr;
@ -904,9 +913,8 @@ TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
TEST(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) { TEST(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
EXPECT_FALSE(receiver.GetAndResetXrRrRtt()); EXPECT_FALSE(receiver.GetAndResetXrRrRtt());
@ -919,9 +927,8 @@ TEST(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) {
TEST(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) { TEST(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
Random rand(0x0123456789abcdef); Random rand(0x0123456789abcdef);
@ -951,9 +958,8 @@ TEST(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
// the config struct. // the config struct.
TEST(RtcpReceiverTest, SetterEnablesReceiverRtt) { TEST(RtcpReceiverTest, SetterEnablesReceiverRtt) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = false;
config.non_sender_rtt_measurement = false; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
receiver.SetNonSenderRttMeasurement(true); receiver.SetNonSenderRttMeasurement(true);
@ -984,9 +990,8 @@ TEST(RtcpReceiverTest, SetterEnablesReceiverRtt) {
// the config struct. // the config struct.
TEST(RtcpReceiverTest, DoesntCalculateRttOnReceivedDlrr) { TEST(RtcpReceiverTest, DoesntCalculateRttOnReceivedDlrr) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
receiver.SetNonSenderRttMeasurement(false); receiver.SetNonSenderRttMeasurement(false);
@ -1015,9 +1020,8 @@ TEST(RtcpReceiverTest, DoesntCalculateRttOnReceivedDlrr) {
TEST(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOneMillisecond) { TEST(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOneMillisecond) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
Random rand(0x0123456789abcdef); Random rand(0x0123456789abcdef);
@ -1046,9 +1050,8 @@ TEST(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOneMillisecond) {
// Test receiver RTT stats with multiple measurements. // Test receiver RTT stats with multiple measurements.
TEST(RtcpReceiverTest, ReceiverRttWithMultipleMeasurements) { TEST(RtcpReceiverTest, ReceiverRttWithMultipleMeasurements) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
Random rand(0x0123456789abcdef); Random rand(0x0123456789abcdef);
@ -1101,9 +1104,8 @@ TEST(RtcpReceiverTest, ReceiverRttWithMultipleMeasurements) {
// https://www.w3.org/TR/webrtc-stats/#dom-rtcremoteoutboundrtpstreamstats-roundtriptime. // https://www.w3.org/TR/webrtc-stats/#dom-rtcremoteoutboundrtpstreamstats-roundtriptime.
TEST(RtcpReceiverTest, ReceiverRttResetOnSrWithoutXr) { TEST(RtcpReceiverTest, ReceiverRttResetOnSrWithoutXr) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
Random rand(0x0123456789abcdef); Random rand(0x0123456789abcdef);
@ -1145,9 +1147,8 @@ TEST(RtcpReceiverTest, ReceiverRttResetOnSrWithoutXr) {
// https://www.w3.org/TR/webrtc-stats/#dom-rtcremoteoutboundrtpstreamstats-roundtriptime. // https://www.w3.org/TR/webrtc-stats/#dom-rtcremoteoutboundrtpstreamstats-roundtriptime.
TEST(RtcpReceiverTest, ReceiverRttResetOnDlrrWithZeroTimestamp) { TEST(RtcpReceiverTest, ReceiverRttResetOnDlrrWithZeroTimestamp) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = true;
config.non_sender_rtt_measurement = true; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
Random rand(0x0123456789abcdef); Random rand(0x0123456789abcdef);
@ -1184,9 +1185,8 @@ TEST(RtcpReceiverTest, ReceiverRttResetOnDlrrWithZeroTimestamp) {
// Check that the receiver RTT works correctly when the remote SSRC changes. // Check that the receiver RTT works correctly when the remote SSRC changes.
TEST(RtcpReceiverTest, ReceiverRttWithMultipleRemoteSsrcs) { TEST(RtcpReceiverTest, ReceiverRttWithMultipleRemoteSsrcs) {
ReceiverMocks mocks; ReceiverMocks mocks;
auto config = DefaultConfiguration(&mocks); mocks.config.non_sender_rtt_measurement = false;
config.non_sender_rtt_measurement = false; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
receiver.SetNonSenderRttMeasurement(true); receiver.SetNonSenderRttMeasurement(true);
@ -1238,7 +1238,7 @@ TEST(RtcpReceiverTest, ReceiverRttWithMultipleRemoteSsrcs) {
TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfoInitiallyEmpty) { TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfoInitiallyEmpty) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
EXPECT_THAT(receiver.ConsumeReceivedXrReferenceTimeInfo(), IsEmpty()); EXPECT_THAT(receiver.ConsumeReceivedXrReferenceTimeInfo(), IsEmpty());
@ -1246,7 +1246,7 @@ TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfoInitiallyEmpty) {
TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfo) { TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfo) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const NtpTime kNtp(0x10203, 0x40506); const NtpTime kNtp(0x10203, 0x40506);
@ -1273,7 +1273,7 @@ TEST(RtcpReceiverTest, ConsumeReceivedXrReferenceTimeInfo) {
TEST(RtcpReceiverTest, TEST(RtcpReceiverTest,
ReceivedRrtrFromSameSsrcUpdatesReceivedReferenceTimeInfo) { ReceivedRrtrFromSameSsrcUpdatesReceivedReferenceTimeInfo) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const NtpTime kNtp1(0x10203, 0x40506); const NtpTime kNtp1(0x10203, 0x40506);
@ -1303,7 +1303,7 @@ TEST(RtcpReceiverTest,
TEST(RtcpReceiverTest, StoresLastReceivedRrtrPerSsrc) { TEST(RtcpReceiverTest, StoresLastReceivedRrtrPerSsrc) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const size_t kNumBufferedReports = 1; const size_t kNumBufferedReports = 1;
@ -1335,7 +1335,7 @@ TEST(RtcpReceiverTest, StoresLastReceivedRrtrPerSsrc) {
TEST(RtcpReceiverTest, ReceiveReportTimeout) { TEST(RtcpReceiverTest, ReceiveReportTimeout) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint16_t kSequenceNumber = 1234; const uint16_t kSequenceNumber = 1234;
@ -1407,7 +1407,7 @@ TEST(RtcpReceiverTest, ReceiveReportTimeout) {
TEST(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) { TEST(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
EXPECT_THAT(receiver.TmmbrReceived(), IsEmpty()); EXPECT_THAT(receiver.TmmbrReceived(), IsEmpty());
@ -1415,7 +1415,7 @@ TEST(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
TEST(RtcpReceiverTest, TmmbrPacketAccepted) { TEST(RtcpReceiverTest, TmmbrPacketAccepted) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const DataRate kBitrate = DataRate::BitsPerSec(30'000); const DataRate kBitrate = DataRate::BitsPerSec(30'000);
@ -1443,7 +1443,7 @@ TEST(RtcpReceiverTest, TmmbrPacketAccepted) {
TEST(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) { TEST(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint32_t kBitrateBps = 30000; const uint32_t kBitrateBps = 30000;
@ -1467,7 +1467,7 @@ TEST(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
TEST(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) { TEST(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
auto tmmbr = std::make_unique<rtcp::Tmmbr>(); auto tmmbr = std::make_unique<rtcp::Tmmbr>();
@ -1489,7 +1489,7 @@ TEST(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
TEST(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) { TEST(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
// Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2. // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2.
@ -1531,9 +1531,8 @@ TEST(RtcpReceiverTest,
VerifyBlockAndTimestampObtainedFromReportBlockDataObserver) { VerifyBlockAndTimestampObtainedFromReportBlockDataObserver) {
ReceiverMocks mocks; ReceiverMocks mocks;
MockReportBlockDataObserverImpl observer; MockReportBlockDataObserverImpl observer;
RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks); mocks.config.report_block_data_observer = &observer;
config.report_block_data_observer = &observer; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint8_t kFractionLoss = 3; const uint8_t kFractionLoss = 3;
@ -1574,9 +1573,8 @@ TEST(RtcpReceiverTest,
TEST(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) { TEST(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) {
ReceiverMocks mocks; ReceiverMocks mocks;
MockReportBlockDataObserverImpl observer; MockReportBlockDataObserverImpl observer;
RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks); mocks.config.report_block_data_observer = &observer;
config.report_block_data_observer = &observer; RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
// To avoid issues with rounding due to different way to represent time units, // To avoid issues with rounding due to different way to represent time units,
@ -1620,7 +1618,7 @@ TEST(RtcpReceiverTest, VerifyRttObtainedFromReportBlockDataObserver) {
TEST(RtcpReceiverTest, GetReportBlockDataAfterOneReportBlock) { TEST(RtcpReceiverTest, GetReportBlockDataAfterOneReportBlock) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint16_t kSequenceNumber = 1234; const uint16_t kSequenceNumber = 1234;
@ -1644,7 +1642,7 @@ TEST(RtcpReceiverTest, GetReportBlockDataAfterOneReportBlock) {
TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) { TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint16_t kSequenceNumber1 = 1234; const uint16_t kSequenceNumber1 = 1234;
@ -1682,7 +1680,7 @@ TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfSameSsrc) {
TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfDifferentSsrcs) { TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfDifferentSsrcs) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint16_t kSequenceNumber1 = 1234; const uint16_t kSequenceNumber1 = 1234;
@ -1722,12 +1720,11 @@ TEST(RtcpReceiverTest, GetReportBlockDataAfterTwoReportBlocksOfDifferentSsrcs) {
TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnTransportFeedback) { TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnTransportFeedback) {
ReceiverMocks mocks; ReceiverMocks mocks;
RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks); RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::TransportFeedback packet; rtcp::TransportFeedback packet;
packet.SetMediaSsrc(config.local_media_ssrc); packet.SetMediaSsrc(mocks.config.local_media_ssrc);
packet.SetSenderSsrc(kSenderSsrc); packet.SetSenderSsrc(kSenderSsrc);
packet.SetBase(123, Timestamp::Millis(1)); packet.SetBase(123, Timestamp::Millis(1));
packet.AddReceivedPacket(123, Timestamp::Millis(1)); packet.AddReceivedPacket(123, Timestamp::Millis(1));
@ -1744,11 +1741,9 @@ TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnTransportFeedback) {
} }
TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnCongestionControlFeedback) { TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnCongestionControlFeedback) {
ScopedKeyValueConfig trials(
"WebRTC-RFC8888CongestionControlFeedback/Enabled/");
ReceiverMocks mocks; ReceiverMocks mocks;
RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks); mocks.field_trials = "WebRTC-RFC8888CongestionControlFeedback/Enabled/";
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::CongestionControlFeedback packet({{ rtcp::CongestionControlFeedback packet({{
@ -1767,11 +1762,9 @@ TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnCongestionControlFeedback) {
} }
TEST(RtcpReceiverTest, HandlesInvalidCongestionControlFeedback) { TEST(RtcpReceiverTest, HandlesInvalidCongestionControlFeedback) {
ScopedKeyValueConfig trials(
"WebRTC-RFC8888CongestionControlFeedback/Enabled/");
ReceiverMocks mocks; ReceiverMocks mocks;
RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks); mocks.field_trials = "WebRTC-RFC8888CongestionControlFeedback/Enabled/";
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::CongestionControlFeedback packet({{ rtcp::CongestionControlFeedback packet({{
@ -1794,12 +1787,11 @@ TEST(RtcpReceiverTest, HandlesInvalidCongestionControlFeedback) {
TEST(RtcpReceiverTest, TEST(RtcpReceiverTest,
NotifiesNetworkLinkObserverOnTransportFeedbackOnRtxSsrc) { NotifiesNetworkLinkObserverOnTransportFeedbackOnRtxSsrc) {
ReceiverMocks mocks; ReceiverMocks mocks;
RtpRtcpInterface::Configuration config = DefaultConfiguration(&mocks); RTCPReceiver receiver = Create(mocks);
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::TransportFeedback packet; rtcp::TransportFeedback packet;
packet.SetMediaSsrc(*config.rtx_send_ssrc); packet.SetMediaSsrc(*mocks.config.rtx_send_ssrc);
packet.SetSenderSsrc(kSenderSsrc); packet.SetSenderSsrc(kSenderSsrc);
packet.SetBase(1, Timestamp::Millis(1)); packet.SetBase(1, Timestamp::Millis(1));
packet.AddReceivedPacket(1, Timestamp::Millis(1)); packet.AddReceivedPacket(1, Timestamp::Millis(1));
@ -1811,7 +1803,7 @@ TEST(RtcpReceiverTest,
TEST(RtcpReceiverTest, TEST(RtcpReceiverTest,
DoesNotNotifyNetworkLinkObserverOnTransportFeedbackForUnregistedSsrc) { DoesNotNotifyNetworkLinkObserverOnTransportFeedbackForUnregistedSsrc) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::TransportFeedback packet; rtcp::TransportFeedback packet;
@ -1826,7 +1818,7 @@ TEST(RtcpReceiverTest,
TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnRemb) { TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnRemb) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::Remb remb; rtcp::Remb remb;
@ -1841,7 +1833,7 @@ TEST(RtcpReceiverTest, NotifiesNetworkLinkObserverOnRemb) {
TEST(RtcpReceiverTest, HandlesInvalidTransportFeedback) { TEST(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
// Send a compound packet with a TransportFeedback followed by something else. // Send a compound packet with a TransportFeedback followed by something else.
@ -1875,7 +1867,7 @@ TEST(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
TEST(RtcpReceiverTest, Nack) { TEST(RtcpReceiverTest, Nack) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint16_t kNackList1[] = {1, 2, 3, 5}; const uint16_t kNackList1[] = {1, 2, 3, 5};
@ -1930,7 +1922,7 @@ TEST(RtcpReceiverTest, Nack) {
TEST(RtcpReceiverTest, NackNotForUsIgnored) { TEST(RtcpReceiverTest, NackNotForUsIgnored) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
const uint16_t kNackList1[] = {1, 2, 3, 5}; const uint16_t kNackList1[] = {1, 2, 3, 5};
@ -1949,7 +1941,7 @@ TEST(RtcpReceiverTest, NackNotForUsIgnored) {
TEST(RtcpReceiverTest, ForceSenderReport) { TEST(RtcpReceiverTest, ForceSenderReport) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::RapidResyncRequest rr; rtcp::RapidResyncRequest rr;
@ -1962,7 +1954,7 @@ TEST(RtcpReceiverTest, ForceSenderReport) {
TEST(RtcpReceiverTest, ReceivesTargetBitrate) { TEST(RtcpReceiverTest, ReceivesTargetBitrate) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
VideoBitrateAllocation expected_allocation; VideoBitrateAllocation expected_allocation;
@ -1996,7 +1988,7 @@ TEST(RtcpReceiverTest, ReceivesTargetBitrate) {
TEST(RtcpReceiverTest, HandlesIncorrectTargetBitrate) { TEST(RtcpReceiverTest, HandlesIncorrectTargetBitrate) {
ReceiverMocks mocks; ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
VideoBitrateAllocation expected_allocation; VideoBitrateAllocation expected_allocation;
@ -2019,7 +2011,7 @@ TEST(RtcpReceiverTest, HandlesIncorrectTargetBitrate) {
TEST(RtcpReceiverTest, ChangeLocalMediaSsrc) { TEST(RtcpReceiverTest, ChangeLocalMediaSsrc) {
ReceiverMocks mocks; ReceiverMocks mocks;
// Construct a receiver with `kReceiverMainSsrc` (default) local media ssrc. // Construct a receiver with `kReceiverMainSsrc` (default) local media ssrc.
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl); RTCPReceiver receiver = Create(mocks);
receiver.SetRemoteSSRC(kSenderSsrc); receiver.SetRemoteSSRC(kSenderSsrc);
constexpr uint32_t kSecondarySsrc = kReceiverMainSsrc + 1; constexpr uint32_t kSecondarySsrc = kReceiverMainSsrc + 1;

2
modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -90,7 +90,7 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Environment& env,
: env_(env), : env_(env),
rtcp_sender_( rtcp_sender_(
RTCPSender::Configuration::FromRtpRtcpConfiguration(configuration)), RTCPSender::Configuration::FromRtpRtcpConfiguration(configuration)),
rtcp_receiver_(configuration, this), rtcp_receiver_(env_, configuration, this),
last_bitrate_process_time_(env_.clock().TimeInMilliseconds()), last_bitrate_process_time_(env_.clock().TimeInMilliseconds()),
last_rtt_process_time_(env_.clock().TimeInMilliseconds()), last_rtt_process_time_(env_.clock().TimeInMilliseconds()),
packet_overhead_(28), // IPV4 UDP. packet_overhead_(28), // IPV4 UDP.

2
modules/rtp_rtcp/source/rtp_rtcp_impl2.cc
View File

@ -116,7 +116,7 @@ ModuleRtpRtcpImpl2::ModuleRtpRtcpImpl2(TagConfigurationIncludesEnvironment,
[this](TimeDelta duration) { [this](TimeDelta duration) {
ScheduleRtcpSendEvaluation(duration); ScheduleRtcpSendEvaluation(duration);
})), })),
rtcp_receiver_(configuration, this), rtcp_receiver_(env_, configuration, this),
packet_overhead_(28), // IPV4 UDP. packet_overhead_(28), // IPV4 UDP.
nack_last_time_sent_full_ms_(0), nack_last_time_sent_full_ms_(0),
nack_last_seq_number_sent_(0), nack_last_seq_number_sent_(0),

5
test/fuzzers/BUILD.gn
View File

@ -224,11 +224,14 @@ webrtc_fuzzer_test("rtp_video_frame_assembler_fuzzer") {
webrtc_fuzzer_test("rtcp_receiver_fuzzer") { webrtc_fuzzer_test("rtcp_receiver_fuzzer") {
sources = [ "rtcp_receiver_fuzzer.cc" ] sources = [ "rtcp_receiver_fuzzer.cc" ]
deps = [ deps = [
"../../api:array_view",
"../../api/environment",
"../../api/environment:environment_factory",
"../../modules/rtp_rtcp", "../../modules/rtp_rtcp",
"../../modules/rtp_rtcp:rtp_rtcp_format", "../../modules/rtp_rtcp:rtp_rtcp_format",
"../../rtc_base:checks", "../../rtc_base:checks",
"../../system_wrappers", "../../system_wrappers",
"../../system_wrappers:field_trial", "../../test:explicit_key_value_config",
] ]
seed_corpus = "corpora/rtcp-corpus" seed_corpus = "corpora/rtcp-corpus"
} }

16
test/fuzzers/rtcp_receiver_fuzzer.cc
View File

@ -7,11 +7,19 @@
* in the file PATENTS. All contributing project authors may * in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include <cstddef>
#include <cstdint>
#include <vector>
#include "api/array_view.h"
#include "api/environment/environment_factory.h"
#include "modules/rtp_rtcp/include/report_block_data.h"
#include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h" #include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
#include "modules/rtp_rtcp/source/rtcp_receiver.h" #include "modules/rtp_rtcp/source/rtcp_receiver.h"
#include "modules/rtp_rtcp/source/rtp_rtcp_interface.h" #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
#include "system_wrappers/include/clock.h" #include "system_wrappers/include/clock.h"
#include "system_wrappers/include/field_trial.h" #include "test/explicit_key_value_config.h"
namespace webrtc { namespace webrtc {
namespace { namespace {
@ -37,17 +45,17 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
if (size > kMaxInputLenBytes) { if (size > kMaxInputLenBytes) {
return; return;
} }
field_trial::InitFieldTrialsFromString( test::ExplicitKeyValueConfig field_trials(
"WebRTC-RFC8888CongestionControlFeedback/Enabled/"); "WebRTC-RFC8888CongestionControlFeedback/Enabled/");
NullModuleRtpRtcp rtp_rtcp_module; NullModuleRtpRtcp rtp_rtcp_module;
SimulatedClock clock(1234); SimulatedClock clock(1234);
RtpRtcpInterface::Configuration config; RtpRtcpInterface::Configuration config;
config.clock = &clock;
config.rtcp_report_interval_ms = kRtcpIntervalMs; config.rtcp_report_interval_ms = kRtcpIntervalMs;
config.local_media_ssrc = 1; config.local_media_ssrc = 1;
RTCPReceiver receiver(config, &rtp_rtcp_module); RTCPReceiver receiver(CreateEnvironment(&clock, &field_trials), config,
&rtp_rtcp_module);
receiver.IncomingPacket(rtc::MakeArrayView(data, size)); receiver.IncomingPacket(rtc::MakeArrayView(data, size));
} }