zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete SetRtcpXrRrtrStatus, make it a construction-time setting

Browse Source 
Bug: None
Change-Id: If2c42af6038c2ce1dc4289b949a0a3a279bae1b9
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/195337
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Åsa Persson <asapersson@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#32754}
This commit is contained in:
Niels Möller
2020-12-02 14:25:03 +01:00
committed by Commit Bot
parent 091617dda8
commit be810cba19
16 changed files with 67 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
View File

@ -149,7 +149,6 @@ class MockRtpRtcpInterface : public RtpRtcpInterface {
GetLatestReportBlockData,
(),
(const, override));
MOCK_METHOD(void, SetRtcpXrRrtrStatus, (bool enable), (override));
MOCK_METHOD(void,
SetRemb,
(int64_t bitrate, std::vector<uint32_t> ssrcs),

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

@ -174,7 +174,7 @@ RTCPReceiver::RTCPReceiver(const RtpRtcpInterface::Configuration& config,
// TODO(bugs.webrtc.org/10774): Remove fallback.
remote_ssrc_(0),
remote_sender_rtp_time_(0),
xr_rrtr_status_(false),
xr_rrtr_status_(config.non_sender_rtt_measurement),
xr_rr_rtt_ms_(0),
oldest_tmmbr_info_ms_(0),
stats_callback_(config.rtcp_statistics_callback),
@ -256,11 +256,6 @@ int32_t RTCPReceiver::RTT(uint32_t remote_ssrc,
return 0;
}
void RTCPReceiver::SetRtcpXrRrtrStatus(bool enable) {
MutexLock lock(&rtcp_receiver_lock_);
xr_rrtr_status_ = enable;
}
bool RTCPReceiver::GetAndResetXrRrRtt(int64_t* rtt_ms) {
RTC_DCHECK(rtt_ms);
MutexLock lock(&rtcp_receiver_lock_);

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

@ -86,7 +86,6 @@ class RTCPReceiver final {
int64_t* min_rtt_ms,
int64_t* max_rtt_ms) const;
void SetRtcpXrRrtrStatus(bool enable);
bool GetAndResetXrRrRtt(int64_t* rtt_ms);
// Called once per second on the worker thread to do rtt calculations.
@ -252,7 +251,7 @@ class RTCPReceiver final {
received_rrtrs_ssrc_it_ RTC_GUARDED_BY(rtcp_receiver_lock_);
// Estimated rtt, zero when there is no valid estimate.
bool xr_rrtr_status_ RTC_GUARDED_BY(rtcp_receiver_lock_);
const bool xr_rrtr_status_;
int64_t xr_rr_rtt_ms_;
int64_t oldest_tmmbr_info_ms_ RTC_GUARDED_BY(rtcp_receiver_lock_);

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

@ -838,11 +838,11 @@ TEST(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
TEST(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
auto config = DefaultConfiguration(&mocks);
// Allow calculate rtt using dlrr/rrtr, simulating media receiver side.
receiver.SetRtcpXrRrtrStatus(true);
config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
rtcp::ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
@ -856,12 +856,13 @@ TEST(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
auto config = DefaultConfiguration(&mocks);
config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
const uint32_t kLastRR = 0x12345;
const uint32_t kDelay = 0x23456;
receiver.SetRtcpXrRrtrStatus(true);
int64_t rtt_ms = 0;
EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms));
@ -880,12 +881,13 @@ TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
auto config = DefaultConfiguration(&mocks);
config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
const uint32_t kLastRR = 0x12345;
const uint32_t kDelay = 0x56789;
receiver.SetRtcpXrRrtrStatus(true);
rtcp::ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
@ -905,11 +907,11 @@ TEST(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
auto config = DefaultConfiguration(&mocks);
config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
receiver.SetRtcpXrRrtrStatus(true);
rtcp::Rrtr rrtr;
rtcp::ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
@ -927,11 +929,11 @@ TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
auto config = DefaultConfiguration(&mocks);
config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
receiver.SetRtcpXrRrtrStatus(true);
rtcp::Rrtr rrtr;
rtcp::ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);
@ -955,25 +957,26 @@ TEST(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
TEST(RtcpReceiverTest, TestExtendedReportsRrRttInitiallyFalse) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
auto config = DefaultConfiguration(&mocks);
config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
receiver.SetRtcpXrRrtrStatus(true);
int64_t rtt_ms;
EXPECT_FALSE(receiver.GetAndResetXrRrRtt(&rtt_ms));
}
TEST(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
auto config = DefaultConfiguration(&mocks);
config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
Random rand(0x0123456789abcdef);
const int64_t kRttMs = rand.Rand(1, 9 * 3600 * 1000);
const uint32_t kDelayNtp = rand.Rand(0, 0x7fffffff);
const int64_t kDelayMs = CompactNtpRttToMs(kDelayNtp);
receiver.SetRtcpXrRrtrStatus(true);
NtpTime now = TimeMicrosToNtp(mocks.clock.TimeInMicroseconds());
uint32_t sent_ntp = CompactNtp(now);
mocks.clock.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
@ -991,7 +994,9 @@ TEST(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
TEST(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) {
ReceiverMocks mocks;
RTCPReceiver receiver(DefaultConfiguration(&mocks), &mocks.rtp_rtcp_impl);
auto config = DefaultConfiguration(&mocks);
config.non_sender_rtt_measurement = true;
RTCPReceiver receiver(config, &mocks.rtp_rtcp_impl);
receiver.SetRemoteSSRC(kSenderSsrc);
Random rand(0x0123456789abcdef);
@ -1001,7 +1006,6 @@ TEST(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) {
NtpTime now = TimeMicrosToNtp(mocks.clock.TimeInMicroseconds());
uint32_t sent_ntp = CompactNtp(now);
mocks.clock.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
receiver.SetRtcpXrRrtrStatus(true);
rtcp::ExtendedReports xr;
xr.SetSenderSsrc(kSenderSsrc);

13
modules/rtp_rtcp/source/rtcp_sender.cc
View File

@ -173,7 +173,8 @@ RTCPSender::RTCPSender(const RtpRtcpInterface::Configuration& config)
packet_oh_send_(0),
max_packet_size_(IP_PACKET_SIZE - 28), // IPv4 + UDP by default.
xr_send_receiver_reference_time_enabled_(false),
xr_send_receiver_reference_time_enabled_(
config.non_sender_rtt_measurement),
packet_type_counter_observer_(config.rtcp_packet_type_counter_observer),
send_video_bitrate_allocation_(false),
last_payload_type_(-1) {
@ -896,16 +897,6 @@ void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
csrcs_ = csrcs;
}
void RTCPSender::SendRtcpXrReceiverReferenceTime(bool enable) {
MutexLock lock(&mutex_rtcp_sender_);
xr_send_receiver_reference_time_enabled_ = enable;
}
bool RTCPSender::RtcpXrReceiverReferenceTime() const {
MutexLock lock(&mutex_rtcp_sender_);
return xr_send_receiver_reference_time_enabled_;
}
void RTCPSender::SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) {
MutexLock lock(&mutex_rtcp_sender_);
tmmbn_to_send_ = std::move(bounding_set);

9
modules/rtp_rtcp/source/rtcp_sender.h
View File

@ -142,12 +142,6 @@ class RTCPSender final {
void SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set)
RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
void SendRtcpXrReceiverReferenceTime(bool enable)
RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
bool RtcpXrReceiverReferenceTime() const
RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
void SetCsrcs(const std::vector<uint32_t>& csrcs)
RTC_LOCKS_EXCLUDED(mutex_rtcp_sender_);
@ -267,8 +261,7 @@ class RTCPSender final {
size_t max_packet_size_ RTC_GUARDED_BY(mutex_rtcp_sender_);
// True if sending of XR Receiver reference time report is enabled.
bool xr_send_receiver_reference_time_enabled_
RTC_GUARDED_BY(mutex_rtcp_sender_);
const bool xr_send_receiver_reference_time_enabled_;
RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
RtcpPacketTypeCounter packet_type_counter_ RTC_GUARDED_BY(mutex_rtcp_sender_);

15
modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -523,10 +523,11 @@ TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) {
}
TEST_F(RtcpSenderTest, SendXrWithRrtr) {
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
RtpRtcpInterface::Configuration config = GetDefaultConfig();
config.non_sender_rtt_measurement = true;
auto rtcp_sender = CreateRtcpSender(config);
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), false));
rtcp_sender->SendRtcpXrReceiverReferenceTime(true);
NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(1, parser()->xr()->num_packets());
@ -537,19 +538,21 @@ TEST_F(RtcpSenderTest, SendXrWithRrtr) {
}
TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) {
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
RtpRtcpInterface::Configuration config = GetDefaultConfig();
config.non_sender_rtt_measurement = true;
auto rtcp_sender = CreateRtcpSender(config);
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), true));
rtcp_sender->SendRtcpXrReceiverReferenceTime(true);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(0, parser()->xr()->num_packets());
}
TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) {
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
RtpRtcpInterface::Configuration config = GetDefaultConfig();
config.non_sender_rtt_measurement = false;
auto rtcp_sender = CreateRtcpSender(config);
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), false));
rtcp_sender->SendRtcpXrReceiverReferenceTime(false);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(0, parser()->xr()->num_packets());
}

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

@ -536,15 +536,6 @@ int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(
return -1;
}
void ModuleRtpRtcpImpl::SetRtcpXrRrtrStatus(bool enable) {
rtcp_receiver_.SetRtcpXrRrtrStatus(enable);
rtcp_sender_.SendRtcpXrReceiverReferenceTime(enable);
}
bool ModuleRtpRtcpImpl::RtcpXrRrtrStatus() const {
return rtcp_sender_.RtcpXrReceiverReferenceTime();
}
// TODO(asapersson): Replace this method with the one below.
int32_t ModuleRtpRtcpImpl::DataCountersRTP(size_t* bytes_sent,
uint32_t* packets_sent) const {

3
modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@ -247,9 +247,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
const uint8_t* data,
uint16_t length) override;
// (XR) Receiver reference time report.
void SetRtcpXrRrtrStatus(bool enable) override;
// Video part.
int32_t SendLossNotification(uint16_t last_decoded_seq_num,
uint16_t last_received_seq_num,

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

@ -479,15 +479,6 @@ int32_t ModuleRtpRtcpImpl2::SendRTCP(RTCPPacketType packet_type) {
return rtcp_sender_.SendRTCP(GetFeedbackState(), packet_type);
}
void ModuleRtpRtcpImpl2::SetRtcpXrRrtrStatus(bool enable) {
rtcp_receiver_.SetRtcpXrRrtrStatus(enable);
rtcp_sender_.SendRtcpXrReceiverReferenceTime(enable);
}
bool ModuleRtpRtcpImpl2::RtcpXrRrtrStatus() const {
return rtcp_sender_.RtcpXrReceiverReferenceTime();
}
void ModuleRtpRtcpImpl2::GetSendStreamDataCounters(
StreamDataCounters* rtp_counters,
StreamDataCounters* rtx_counters) const {

6
modules/rtp_rtcp/source/rtp_rtcp_impl2.h
View File

@ -234,9 +234,6 @@ class ModuleRtpRtcpImpl2 final : public RtpRtcpInterface,
void SendCombinedRtcpPacket(
std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) override;
// (XR) Receiver reference time report.
void SetRtcpXrRrtrStatus(bool enable) override;
// Video part.
int32_t SendLossNotification(uint16_t last_decoded_seq_num,
uint16_t last_received_seq_num,
@ -291,9 +288,6 @@ class ModuleRtpRtcpImpl2 final : public RtpRtcpInterface,
// Returns true if the module is configured to store packets.
bool StorePackets() const;
// Returns current Receiver Reference Time Report (RTTR) status.
bool RtcpXrRrtrStatus() const;
TaskQueueBase* const worker_queue_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker process_thread_checker_;

3
modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
View File

@ -160,6 +160,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver {
config.rtcp_report_interval_ms = rtcp_report_interval_ms_;
config.local_media_ssrc = is_sender_ ? kSenderSsrc : kReceiverSsrc;
config.need_rtp_packet_infos = true;
config.non_sender_rtt_measurement = true;
impl_.reset(new ModuleRtpRtcpImpl2(config));
impl_->SetRemoteSSRC(is_sender_ ? kReceiverSsrc : kSenderSsrc);
@ -321,8 +322,6 @@ TEST_F(RtpRtcpImpl2Test, Rtt) {
}
TEST_F(RtpRtcpImpl2Test, RttForReceiverOnly) {
receiver_.impl_->SetRtcpXrRrtrStatus(true);
// Receiver module should send a Receiver time reference report (RTRR).
EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));

3
modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -155,6 +155,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver {
config.rtcp_report_interval_ms = rtcp_report_interval_ms_;
config.local_media_ssrc = is_sender_ ? kSenderSsrc : kReceiverSsrc;
config.need_rtp_packet_infos = true;
config.non_sender_rtt_measurement = true;
impl_.reset(new ModuleRtpRtcpImpl(config));
impl_->SetRemoteSSRC(is_sender_ ? kReceiverSsrc : kSenderSsrc);
@ -309,8 +310,6 @@ TEST_F(RtpRtcpImplTest, Rtt) {
}
TEST_F(RtpRtcpImplTest, RttForReceiverOnly) {
receiver_.impl_->SetRtcpXrRrtrStatus(true);
// Receiver module should send a Receiver time reference report (RTRR).
EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpReport));

7
modules/rtp_rtcp/source/rtp_rtcp_interface.h
View File

@ -144,6 +144,10 @@ class RtpRtcpInterface : public RtcpFeedbackSenderInterface {
// overhead.
bool enable_rtx_padding_prioritization = true;
// Estimate RTT as non-sender as described in
// https://tools.ietf.org/html/rfc3611#section-4.4 and #section-4.5
bool non_sender_rtt_measurement = false;
private:
RTC_DISALLOW_COPY_AND_ASSIGN(Configuration);
};
@ -369,9 +373,6 @@ class RtpRtcpInterface : public RtcpFeedbackSenderInterface {
// that pair.
virtual std::vector<ReportBlockData> GetLatestReportBlockData() const = 0;
// (XR) Sets Receiver Reference Time Report (RTTR) status.
virtual void SetRtcpXrRrtrStatus(bool enable) = 0;
// (REMB) Receiver Estimated Max Bitrate.
// Schedules sending REMB on next and following sender/receiver reports.
void SetRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs) override = 0;

21
video/rtp_video_stream_receiver.cc
View File

@ -84,6 +84,7 @@ std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
RtcpRttStats* rtt_stats,
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
RtcpCnameCallback* rtcp_cname_callback,
bool non_sender_rtt_measurement,
uint32_t local_ssrc) {
RtpRtcpInterface::Configuration configuration;
configuration.clock = clock;
@ -96,6 +97,7 @@ std::unique_ptr<RtpRtcp> CreateRtpRtcpModule(
rtcp_packet_type_counter_observer;
configuration.rtcp_cname_callback = rtcp_cname_callback;
configuration.local_media_ssrc = local_ssrc;
configuration.non_sender_rtt_measurement = non_sender_rtt_measurement;
std::unique_ptr<RtpRtcp> rtp_rtcp = RtpRtcp::DEPRECATED_Create(configuration);
rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound);
@ -255,13 +257,15 @@ RtpVideoStreamReceiver::RtpVideoStreamReceiver(
config->rtp.extensions)),
receiving_(false),
last_packet_log_ms_(-1),
rtp_rtcp_(CreateRtpRtcpModule(clock,
rtp_receive_statistics_,
transport,
rtt_stats,
rtcp_packet_type_counter_observer,
rtcp_cname_callback,
config_.rtp.local_ssrc)),
rtp_rtcp_(CreateRtpRtcpModule(
clock,
rtp_receive_statistics_,
transport,
rtt_stats,
rtcp_packet_type_counter_observer,
rtcp_cname_callback,
config_.rtp.rtcp_xr.receiver_reference_time_report,
config_.rtp.local_ssrc)),
complete_frame_callback_(complete_frame_callback),
keyframe_request_sender_(keyframe_request_sender),
// TODO(bugs.webrtc.org/10336): Let |rtcp_feedback_buffer_| communicate
@ -299,9 +303,6 @@ RtpVideoStreamReceiver::RtpVideoStreamReceiver(
rtp_receive_statistics_->SetMaxReorderingThreshold(
config_.rtp.rtx_ssrc, max_reordering_threshold);
}
if (config_.rtp.rtcp_xr.receiver_reference_time_report)
rtp_rtcp_->SetRtcpXrRrtrStatus(true);
ParseFieldTrial(
{&forced_playout_delay_max_ms_, &forced_playout_delay_min_ms_},
field_trial::FindFullName("WebRTC-ForcePlayoutDelay"));

20
video/rtp_video_stream_receiver2.cc
View File

@ -83,6 +83,7 @@ std::unique_ptr<ModuleRtpRtcpImpl2> CreateRtpRtcpModule(
RtcpRttStats* rtt_stats,
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
RtcpCnameCallback* rtcp_cname_callback,
bool non_sender_rtt_measurement,
uint32_t local_ssrc) {
RtpRtcpInterface::Configuration configuration;
configuration.clock = clock;
@ -95,6 +96,7 @@ std::unique_ptr<ModuleRtpRtcpImpl2> CreateRtpRtcpModule(
rtcp_packet_type_counter_observer;
configuration.rtcp_cname_callback = rtcp_cname_callback;
configuration.local_media_ssrc = local_ssrc;
configuration.non_sender_rtt_measurement = non_sender_rtt_measurement;
std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp =
ModuleRtpRtcpImpl2::Create(configuration);
@ -228,13 +230,15 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2(
config->rtp.extensions)),
receiving_(false),
last_packet_log_ms_(-1),
rtp_rtcp_(CreateRtpRtcpModule(clock,
rtp_receive_statistics_,
transport,
rtt_stats,
rtcp_packet_type_counter_observer,
rtcp_cname_callback,
config_.rtp.local_ssrc)),
rtp_rtcp_(CreateRtpRtcpModule(
clock,
rtp_receive_statistics_,
transport,
rtt_stats,
rtcp_packet_type_counter_observer,
rtcp_cname_callback,
config_.rtp.rtcp_xr.receiver_reference_time_report,
config_.rtp.local_ssrc)),
complete_frame_callback_(complete_frame_callback),
keyframe_request_sender_(keyframe_request_sender),
// TODO(bugs.webrtc.org/10336): Let |rtcp_feedback_buffer_| communicate
@ -277,8 +281,6 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2(
rtp_receive_statistics_->SetMaxReorderingThreshold(
config_.rtp.rtx_ssrc, max_reordering_threshold);
}
if (config_.rtp.rtcp_xr.receiver_reference_time_report)
rtp_rtcp_->SetRtcpXrRrtrStatus(true);
ParseFieldTrial(
{&forced_playout_delay_max_ms_, &forced_playout_delay_min_ms_},