From 3587b8302a8a45c4f80c612a9fc661833a143daa Mon Sep 17 00:00:00 2001 From: Jiawei Ou Date: Wed, 31 Jan 2018 22:08:26 -0800 Subject: [PATCH] Make RTCP report interval configurable Bug: webrtc:8789 Change-Id: I79c9132123c946b030ed79c647b4329e81d6e6ae Reviewed-on: https://webrtc-review.googlesource.com/43201 Reviewed-by: Stefan Holmer Commit-Queue: Stefan Holmer Cr-Commit-Position: refs/heads/master@{#21837} --- call/video_send_stream.cc | 13 ++++ call/video_send_stream.h | 12 ++++ modules/rtp_rtcp/include/rtp_rtcp.h | 1 + modules/rtp_rtcp/include/rtp_rtcp_defines.h | 9 +++ modules/rtp_rtcp/source/rtcp_receiver.cc | 8 +-- modules/rtp_rtcp/source/rtcp_sender.cc | 42 +++++++++---- modules/rtp_rtcp/source/rtcp_sender.h | 8 ++- .../rtp_rtcp/source/rtcp_sender_unittest.cc | 15 +++-- modules/rtp_rtcp/source/rtp_rtcp_config.h | 2 - modules/rtp_rtcp/source/rtp_rtcp_impl.cc | 7 ++- .../rtp_rtcp/source/rtp_rtcp_impl_unittest.cc | 62 +++++++++++++++++++ video/video_send_stream.cc | 7 ++- video/video_send_stream_tests.cc | 7 ++- 13 files changed, 160 insertions(+), 33 deletions(-) diff --git a/call/video_send_stream.cc b/call/video_send_stream.cc index 4f8c059ee4..bf840d3ce7 100644 --- a/call/video_send_stream.cc +++ b/call/video_send_stream.cc @@ -71,6 +71,7 @@ std::string VideoSendStream::Config::ToString() const { std::stringstream ss; ss << "{encoder_settings: " << encoder_settings.ToString(); ss << ", rtp: " << rtp.ToString(); + ss << ", rtcp: " << rtcp.ToString(); ss << ", pre_encode_callback: " << (pre_encode_callback ? "(VideoSinkInterface)" : "nullptr"); ss << ", post_encode_callback: " @@ -159,4 +160,16 @@ std::string VideoSendStream::Config::Rtp::Rtx::ToString() const { return ss.str(); } +VideoSendStream::Config::Rtcp::Rtcp() = default; +VideoSendStream::Config::Rtcp::Rtcp(const Rtcp&) = default; +VideoSendStream::Config::Rtcp::~Rtcp() = default; + +std::string VideoSendStream::Config::Rtcp::ToString() const { + std::stringstream ss; + ss << "{video_report_interval_ms: " << video_report_interval_ms; + ss << ", audio_report_interval_ms: " << audio_report_interval_ms; + ss << '}'; + return ss.str(); +} + } // namespace webrtc diff --git a/call/video_send_stream.h b/call/video_send_stream.h index cb831760d1..ff9c477f78 100644 --- a/call/video_send_stream.h +++ b/call/video_send_stream.h @@ -201,6 +201,18 @@ class VideoSendStream { std::string c_name; } rtp; + struct Rtcp { + Rtcp(); + Rtcp(const Rtcp&); + ~Rtcp(); + std::string ToString() const; + + // Time interval between RTCP report for video + int64_t video_report_interval_ms = 1000; + // Time interval between RTCP report for audio + int64_t audio_report_interval_ms = 5000; + } rtcp; + // Transport for outgoing packets. Transport* send_transport = nullptr; diff --git a/modules/rtp_rtcp/include/rtp_rtcp.h b/modules/rtp_rtcp/include/rtp_rtcp.h index 7e85cb6983..be77006394 100644 --- a/modules/rtp_rtcp/include/rtp_rtcp.h +++ b/modules/rtp_rtcp/include/rtp_rtcp.h @@ -94,6 +94,7 @@ class RtpRtcp : public Module, public RtcpFeedbackSenderInterface { RateLimiter* retransmission_rate_limiter = nullptr; OverheadObserver* overhead_observer = nullptr; RtpKeepAliveConfig keepalive_config; + RtcpIntervalConfig rtcp_interval_config; private: RTC_DISALLOW_COPY_AND_ASSIGN(Configuration); diff --git a/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/modules/rtp_rtcp/include/rtp_rtcp_defines.h index 61b1577d7d..d6730e063e 100644 --- a/modules/rtp_rtcp/include/rtp_rtcp_defines.h +++ b/modules/rtp_rtcp/include/rtp_rtcp_defines.h @@ -41,6 +41,15 @@ const int kBogusRtpRateForAudioRtcp = 8000; // Minimum RTP header size in bytes. const uint8_t kRtpHeaderSize = 12; +struct RtcpIntervalConfig final { + RtcpIntervalConfig() = default; + RtcpIntervalConfig(int64_t video_interval_ms, int64_t audio_interval_ms) + : video_interval_ms(video_interval_ms), + audio_interval_ms(audio_interval_ms) {} + int64_t video_interval_ms = 1000; + int64_t audio_interval_ms = 5000; +}; + struct AudioPayload { SdpAudioFormat format; uint32_t rate; diff --git a/modules/rtp_rtcp/source/rtcp_receiver.cc b/modules/rtp_rtcp/source/rtcp_receiver.cc index 91c88e2ca7..bd8e81b6b8 100644 --- a/modules/rtp_rtcp/source/rtcp_receiver.cc +++ b/modules/rtp_rtcp/source/rtcp_receiver.cc @@ -52,6 +52,8 @@ using rtcp::ReportBlock; // The number of RTCP time intervals needed to trigger a timeout. const int kRrTimeoutIntervals = 3; +const int64_t kTmmbrTimeoutIntervalMs = 5 * 5000; + const int64_t kMaxWarningLogIntervalMs = 10000; const int64_t kRtcpMinFrameLengthMs = 17; @@ -567,8 +569,7 @@ bool RTCPReceiver::UpdateTmmbrTimers() { rtc::CritScope lock(&rtcp_receiver_lock_); int64_t now_ms = clock_->TimeInMilliseconds(); - // Use audio define since we don't know what interval the remote peer use. - int64_t timeout_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS; + int64_t timeout_ms = now_ms - kTmmbrTimeoutIntervalMs; if (oldest_tmmbr_info_ms_ >= timeout_ms) return false; @@ -1032,8 +1033,7 @@ std::vector RTCPReceiver::TmmbrReceived() { std::vector candidates; int64_t now_ms = clock_->TimeInMilliseconds(); - // Use audio define since we don't know what interval the remote peer use. - int64_t timeout_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS; + int64_t timeout_ms = now_ms - kTmmbrTimeoutIntervalMs; for (auto& kv : tmmbr_infos_) { for (auto it = kv.second.tmmbr.begin(); it != kv.second.tmmbr.end();) { diff --git a/modules/rtp_rtcp/source/rtcp_sender.cc b/modules/rtp_rtcp/source/rtcp_sender.cc index bd1a5d4b62..d45a86f8c5 100644 --- a/modules/rtp_rtcp/source/rtcp_sender.cc +++ b/modules/rtp_rtcp/source/rtcp_sender.cc @@ -37,6 +37,7 @@ #include "rtc_base/checks.h" #include "rtc_base/constructormagic.h" #include "rtc_base/logging.h" +#include "rtc_base/numerics/safe_conversions.h" #include "rtc_base/ptr_util.h" #include "rtc_base/trace_event.h" @@ -139,13 +140,15 @@ RTCPSender::RTCPSender( ReceiveStatisticsProvider* receive_statistics, RtcpPacketTypeCounterObserver* packet_type_counter_observer, RtcEventLog* event_log, - Transport* outgoing_transport) + Transport* outgoing_transport, + RtcpIntervalConfig interval_config) : audio_(audio), clock_(clock), random_(clock_->TimeInMicroseconds()), method_(RtcpMode::kOff), event_log_(event_log), transport_(outgoing_transport), + interval_config_(interval_config), using_nack_(false), sending_(false), next_time_to_send_rtcp_(0), @@ -199,9 +202,9 @@ void RTCPSender::SetRTCPStatus(RtcpMode new_method) { if (method_ == RtcpMode::kOff && new_method != RtcpMode::kOff) { // When switching on, reschedule the next packet - next_time_to_send_rtcp_ = - clock_->TimeInMilliseconds() + - (audio_ ? RTCP_INTERVAL_AUDIO_MS / 2 : RTCP_INTERVAL_VIDEO_MS / 2); + int64_t interval_ms = audio_ ? interval_config_.audio_interval_ms + : interval_config_.video_interval_ms; + next_time_to_send_rtcp_ = clock_->TimeInMilliseconds() + (interval_ms / 2); } method_ = new_method; } @@ -343,11 +346,11 @@ int32_t RTCPSender::RemoveMixedCNAME(uint32_t SSRC) { bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const { /* - For audio we use a fix 5 sec interval + For audio we use a configurable interval (default: 5 seconds) - For video we use 1 sec interval fo a BW smaller than 360 kbit/s, - technicaly we break the max 5% RTCP BW for video below 10 kbit/s but - that should be extremely rare + For video we use a configurable interval (default: 1 second) for a BW + smaller than 360 kbit/s, technicaly we break the max 5% RTCP BW for + video below 10 kbit/s but that should be extremely rare From RFC 3550 @@ -361,8 +364,8 @@ bool RTCPSender::TimeToSendRTCPReport(bool sendKeyframeBeforeRTP) const { is smaller than 5 seconds for bandwidths greater than 72 kb/s. If the participant has not yet sent an RTCP packet (the variable - initial is true), the constant Tmin is set to 2.5 seconds, else it - is set to 5 seconds. + initial is true), the constant Tmin is set to half of the configured + interval. The interval between RTCP packets is varied randomly over the range [0.5,1.5] times the calculated interval to avoid unintended @@ -793,7 +796,8 @@ void RTCPSender::PrepareReport(const FeedbackState& feedback_state) { } // generate next time to send an RTCP report - uint32_t minIntervalMs = RTCP_INTERVAL_AUDIO_MS; + uint32_t minIntervalMs = + rtc::dchecked_cast(interval_config_.audio_interval_ms); if (!audio_) { if (sending_) { @@ -802,9 +806,13 @@ void RTCPSender::PrepareReport(const FeedbackState& feedback_state) { if (send_bitrate_kbit != 0) minIntervalMs = 360000 / send_bitrate_kbit; } - if (minIntervalMs > RTCP_INTERVAL_VIDEO_MS) - minIntervalMs = RTCP_INTERVAL_VIDEO_MS; + if (minIntervalMs > + rtc::dchecked_cast(interval_config_.video_interval_ms)) { + minIntervalMs = + rtc::dchecked_cast(interval_config_.video_interval_ms); + } } + // The interval between RTCP packets is varied randomly over the // range [1/2,3/2] times the calculated interval. uint32_t timeToNext = @@ -962,4 +970,12 @@ bool RTCPSender::SendFeedbackPacket(const rtcp::TransportFeedback& packet) { return packet.Build(max_packet_size, callback) && !send_failure; } +int64_t RTCPSender::RtcpAudioReportInverval() const { + return interval_config_.audio_interval_ms; +} + +int64_t RTCPSender::RtcpVideoReportInverval() const { + return interval_config_.video_interval_ms; +} + } // namespace webrtc diff --git a/modules/rtp_rtcp/source/rtcp_sender.h b/modules/rtp_rtcp/source/rtcp_sender.h index e56f66ce62..134a6fb2e9 100644 --- a/modules/rtp_rtcp/source/rtcp_sender.h +++ b/modules/rtp_rtcp/source/rtcp_sender.h @@ -80,7 +80,8 @@ class RTCPSender { ReceiveStatisticsProvider* receive_statistics, RtcpPacketTypeCounterObserver* packet_type_counter_observer, RtcEventLog* event_log, - Transport* outgoing_transport); + Transport* outgoing_transport, + RtcpIntervalConfig interval_config); virtual ~RTCPSender(); RtcpMode Status() const; @@ -148,6 +149,9 @@ class RTCPSender { void SetVideoBitrateAllocation(const BitrateAllocation& bitrate); bool SendFeedbackPacket(const rtcp::TransportFeedback& packet); + int64_t RtcpAudioReportInverval() const; + int64_t RtcpVideoReportInverval() const; + private: class RtcpContext; @@ -194,6 +198,8 @@ class RTCPSender { RtcEventLog* const event_log_; Transport* const transport_; + const RtcpIntervalConfig interval_config_; + rtc::CriticalSection critical_section_rtcp_sender_; bool using_nack_ RTC_GUARDED_BY(critical_section_rtcp_sender_); bool sending_ RTC_GUARDED_BY(critical_section_rtcp_sender_); diff --git a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc index 4549c674d8..1aaef1d5c6 100644 --- a/modules/rtp_rtcp/source/rtcp_sender_unittest.cc +++ b/modules/rtp_rtcp/source/rtcp_sender_unittest.cc @@ -239,7 +239,8 @@ class RtcpSenderTest : public ::testing::Test { rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl(configuration)); rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), - nullptr, nullptr, &test_transport_)); + nullptr, nullptr, &test_transport_, + configuration.rtcp_interval_config)); rtcp_sender_->SetSSRC(kSenderSsrc); rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp); @@ -309,7 +310,8 @@ TEST_F(RtcpSenderTest, SendSr) { TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) { rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), - nullptr, nullptr, &test_transport_)); + nullptr, nullptr, &test_transport_, + RtcpIntervalConfig{})); rtcp_sender_->SetSSRC(kSenderSsrc); rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); @@ -327,7 +329,8 @@ TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) { TEST_F(RtcpSenderTest, DoNotSendCompundBeforeRtp) { rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), - nullptr, nullptr, &test_transport_)); + nullptr, nullptr, &test_transport_, + RtcpIntervalConfig{})); rtcp_sender_->SetSSRC(kSenderSsrc); rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound); @@ -654,7 +657,8 @@ TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) { TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) { RtcpPacketTypeCounterObserverImpl observer; rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), - &observer, nullptr, &test_transport_)); + &observer, nullptr, &test_transport_, + RtcpIntervalConfig{})); rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize); EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli)); @@ -775,7 +779,8 @@ TEST_F(RtcpSenderTest, ByeMustBeLast) { // Re-configure rtcp_sender_ with mock_transport_ rtcp_sender_.reset(new RTCPSender(false, &clock_, receive_statistics_.get(), - nullptr, nullptr, &mock_transport)); + nullptr, nullptr, &mock_transport, + RtcpIntervalConfig{})); rtcp_sender_->SetSSRC(kSenderSsrc); rtcp_sender_->SetRemoteSSRC(kRemoteSsrc); rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp); diff --git a/modules/rtp_rtcp/source/rtp_rtcp_config.h b/modules/rtp_rtcp/source/rtp_rtcp_config.h index 09deef35cd..a24bcdff62 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_config.h +++ b/modules/rtp_rtcp/source/rtp_rtcp_config.h @@ -19,8 +19,6 @@ enum { kSendSideNackListSizeSanity = 20000 }; enum { kDefaultMaxReorderingThreshold = 50 }; // In sequence numbers. enum { kRtcpMaxNackFields = 253 }; -enum { RTCP_INTERVAL_VIDEO_MS = 1000 }; -enum { RTCP_INTERVAL_AUDIO_MS = 5000 }; enum { RTCP_SEND_BEFORE_KEY_FRAME_MS = 100 }; enum { RTCP_MAX_REPORT_BLOCKS = 31 }; // RFC 3550 page 37 enum { diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc index 629bf8a430..27bf5b47a1 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_impl.cc +++ b/modules/rtp_rtcp/source/rtp_rtcp_impl.cc @@ -84,7 +84,8 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration) configuration.receive_statistics, configuration.rtcp_packet_type_counter_observer, configuration.event_log, - configuration.outgoing_transport), + configuration.outgoing_transport, + configuration.rtcp_interval_config), rtcp_receiver_(configuration.clock, configuration.receiver_only, configuration.rtcp_packet_type_counter_observer, @@ -884,9 +885,9 @@ std::vector ModuleRtpRtcpImpl::BoundingSet(bool* tmmbr_owner) { int64_t ModuleRtpRtcpImpl::RtcpReportInterval() { if (audio_) - return RTCP_INTERVAL_AUDIO_MS; + return rtcp_sender_.RtcpAudioReportInverval(); else - return RTCP_INTERVAL_VIDEO_MS; + return rtcp_sender_.RtcpVideoReportInverval(); } void ModuleRtpRtcpImpl::SetRtcpReceiverSsrcs(uint32_t main_ssrc) { diff --git a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc index ad3ec0bbed..022e1ccd3c 100644 --- a/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc +++ b/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc @@ -57,6 +57,7 @@ class SendTransport : public Transport, clock_(nullptr), delay_ms_(0), rtp_packets_sent_(0), + rtcp_packets_sent_(0), keepalive_payload_type_(0), num_keepalive_sent_(0) {} @@ -89,6 +90,7 @@ class SendTransport : public Transport, } EXPECT_TRUE(receiver_); receiver_->IncomingRtcpPacket(data, len); + ++rtcp_packets_sent_; return true; } int32_t OnReceivedPayloadData(const uint8_t* payload_data, @@ -100,10 +102,12 @@ class SendTransport : public Transport, keepalive_payload_type_ = payload_type; } size_t NumKeepaliveSent() { return num_keepalive_sent_; } + size_t NumRtcpSent() { return rtcp_packets_sent_; } ModuleRtpRtcpImpl* receiver_; SimulatedClock* clock_; int64_t delay_ms_; int rtp_packets_sent_; + size_t rtcp_packets_sent_; RTPHeader last_rtp_header_; std::vector last_nack_list_; uint8_t keepalive_payload_type_; @@ -130,6 +134,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver { uint32_t remote_ssrc_; RateLimiter retransmission_rate_limiter_; RtpKeepAliveConfig keepalive_config_; + RtcpIntervalConfig rtcp_interval_config_; void SetRemoteSsrc(uint32_t ssrc) { remote_ssrc_ = ssrc; @@ -166,6 +171,10 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver { CreateModuleImpl(); transport_.SetKeepalivePayloadType(config.payload_type); } + void SetRtcpIntervalConfigAndReset(const RtcpIntervalConfig& config) { + rtcp_interval_config_ = config; + CreateModuleImpl(); + } private: void CreateModuleImpl() { @@ -178,6 +187,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver { config.rtt_stats = &rtt_stats_; config.retransmission_rate_limiter = &retransmission_rate_limiter_; config.keepalive_config = keepalive_config_; + config.rtcp_interval_config = rtcp_interval_config_; impl_.reset(new ModuleRtpRtcpImpl(config)); impl_->SetRTCPStatus(RtcpMode::kCompound); @@ -643,4 +653,56 @@ TEST_F(RtpRtcpImplTest, SendsKeepaliveAfterTimout) { sender_.impl_->Process(); EXPECT_EQ(3U, sender_.transport_.NumKeepaliveSent()); } + +TEST_F(RtpRtcpImplTest, ConfigurableRtcpReportInterval) { + const int kVideoReportInterval = 3000; + + RtcpIntervalConfig config; + config.video_interval_ms = kVideoReportInterval; + + // Recreate sender impl with new configuration, and redo setup. + sender_.SetRtcpIntervalConfigAndReset(config); + SetUp(); + + SendFrame(&sender_, kBaseLayerTid); + + // Initial state + sender_.impl_->Process(); + EXPECT_EQ(sender_.RtcpSent().first_packet_time_ms, -1); + EXPECT_EQ(0u, sender_.transport_.NumRtcpSent()); + + // Move ahead to the last ms before a rtcp is expected, no action. + clock_.AdvanceTimeMilliseconds(kVideoReportInterval / 2 - 1); + sender_.impl_->Process(); + EXPECT_EQ(sender_.RtcpSent().first_packet_time_ms, -1); + EXPECT_EQ(sender_.transport_.NumRtcpSent(), 0u); + + // Move ahead to the first rtcp. Send RTCP. + clock_.AdvanceTimeMilliseconds(1); + sender_.impl_->Process(); + EXPECT_GT(sender_.RtcpSent().first_packet_time_ms, -1); + EXPECT_EQ(sender_.transport_.NumRtcpSent(), 1u); + + SendFrame(&sender_, kBaseLayerTid); + + // Move ahead to the last possible second before second rtcp is expected. + clock_.AdvanceTimeMilliseconds(kVideoReportInterval * 1 / 2 - 1); + sender_.impl_->Process(); + EXPECT_EQ(sender_.transport_.NumRtcpSent(), 1u); + + // Move ahead into the range of second rtcp, the second rtcp may be sent. + clock_.AdvanceTimeMilliseconds(1); + sender_.impl_->Process(); + EXPECT_GE(sender_.transport_.NumRtcpSent(), 1u); + + clock_.AdvanceTimeMilliseconds(kVideoReportInterval / 2); + sender_.impl_->Process(); + EXPECT_GE(sender_.transport_.NumRtcpSent(), 1u); + + // Move out the range of second rtcp, the second rtcp must have been sent. + clock_.AdvanceTimeMilliseconds(kVideoReportInterval / 2); + sender_.impl_->Process(); + EXPECT_EQ(sender_.transport_.NumRtcpSent(), 2u); +} + } // namespace webrtc diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc index 3db592da8c..800cca24e9 100644 --- a/video/video_send_stream.cc +++ b/video/video_send_stream.cc @@ -63,7 +63,8 @@ std::vector CreateRtpRtcpModules( RateLimiter* retransmission_rate_limiter, OverheadObserver* overhead_observer, size_t num_modules, - RtpKeepAliveConfig keepalive_config) { + RtpKeepAliveConfig keepalive_config, + RtcpIntervalConfig rtc_interval_config) { RTC_DCHECK_GT(num_modules, 0); RtpRtcp::Configuration configuration; configuration.audio = false; @@ -763,7 +764,9 @@ VideoSendStreamImpl::VideoSendStreamImpl( transport->send_side_cc()->GetRetransmissionRateLimiter(), this, config_->rtp.ssrcs.size(), - transport->keepalive_config())), + transport->keepalive_config(), + RtcpIntervalConfig{config_->rtcp.video_report_interval_ms, + config_->rtcp.audio_report_interval_ms})), payload_router_(rtp_rtcp_modules_, config_->rtp.ssrcs, config_->encoder_settings.payload_type, diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc index e2f4908286..d5226bfedb 100644 --- a/video/video_send_stream_tests.cc +++ b/video/video_send_stream_tests.cc @@ -798,7 +798,8 @@ void VideoSendStreamTest::TestNackRetransmission( uint16_t nack_sequence_number = header.sequenceNumber - 1; nacked_sequence_number_ = nack_sequence_number; RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), nullptr, - nullptr, nullptr, transport_adapter_.get()); + nullptr, nullptr, transport_adapter_.get(), + RtcpIntervalConfig{}); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]); @@ -990,7 +991,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format, static_cast((255 * kLossPercent) / 100)); // Loss percent. RTCPSender rtcp_sender(false, Clock::GetRealTimeClock(), &lossy_receive_stats, nullptr, nullptr, - transport_adapter_.get()); + transport_adapter_.get(), RtcpIntervalConfig{}); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]); @@ -1247,7 +1248,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) { FakeReceiveStatistics receive_stats(kVideoSendSsrcs[0], last_sequence_number_, rtp_count_, 0); RTCPSender rtcp_sender(false, clock_, &receive_stats, nullptr, nullptr, - transport_adapter_.get()); + transport_adapter_.get(), RtcpIntervalConfig{}); rtcp_sender.SetRTCPStatus(RtcpMode::kReducedSize); rtcp_sender.SetRemoteSSRC(kVideoSendSsrcs[0]);