From bba9dec4d57d8f2b7a3b67a61e63cc33667a2b54 Mon Sep 17 00:00:00 2001 From: stefan Date: Mon, 1 Feb 2016 04:39:55 -0800 Subject: [PATCH] Use separate rtp module lists for send and receive in PacketRouter. This makes it possible to handle send and receive streams with the same SSRC, which is currently the case in some peer connection tests. Also moves sending transport feedback to the pacer thread. BUG=webrtc:5263 Review URL: https://codereview.webrtc.org/1628683002 Cr-Commit-Position: refs/heads/master@{#11443} --- webrtc/audio/audio_receive_stream.cc | 6 +- webrtc/audio/audio_receive_stream_unittest.cc | 7 +- webrtc/audio/audio_send_stream.cc | 4 +- webrtc/audio/audio_send_stream_unittest.cc | 5 +- webrtc/call/congestion_controller.cc | 4 +- webrtc/modules/pacing/packet_router.cc | 74 +++++++++++++------ webrtc/modules/pacing/packet_router.h | 12 +-- .../modules/pacing/packet_router_unittest.cc | 32 ++++++-- webrtc/test/mock_voe_channel_proxy.h | 7 +- webrtc/video/vie_channel.cc | 8 +- webrtc/voice_engine/channel.cc | 73 ++++++++++-------- webrtc/voice_engine/channel.h | 10 ++- webrtc/voice_engine/channel_proxy.cc | 15 +++- webrtc/voice_engine/channel_proxy.h | 5 +- 14 files changed, 171 insertions(+), 91 deletions(-) diff --git a/webrtc/audio/audio_receive_stream.cc b/webrtc/audio/audio_receive_stream.cc index ebe271367b..b7311266ef 100644 --- a/webrtc/audio/audio_receive_stream.cc +++ b/webrtc/audio/audio_receive_stream.cc @@ -117,8 +117,8 @@ AudioReceiveStream::AudioReceiveStream( } } // Configure bandwidth estimation. - channel_proxy_->SetCongestionControlObjects( - nullptr, nullptr, congestion_controller->packet_router()); + channel_proxy_->RegisterReceiverCongestionControlObjects( + congestion_controller->packet_router()); if (config.combined_audio_video_bwe) { if (UseSendSideBwe(config)) { remote_bitrate_estimator_ = @@ -134,7 +134,7 @@ AudioReceiveStream::AudioReceiveStream( AudioReceiveStream::~AudioReceiveStream() { RTC_DCHECK(thread_checker_.CalledOnValidThread()); LOG(LS_INFO) << "~AudioReceiveStream: " << config_.ToString(); - channel_proxy_->SetCongestionControlObjects(nullptr, nullptr, nullptr); + channel_proxy_->ResetCongestionControlObjects(); if (remote_bitrate_estimator_) { remote_bitrate_estimator_->RemoveStream(config_.rtp.remote_ssrc); } diff --git a/webrtc/audio/audio_receive_stream_unittest.cc b/webrtc/audio/audio_receive_stream_unittest.cc index b241bed6b5..fd88fc83df 100644 --- a/webrtc/audio/audio_receive_stream_unittest.cc +++ b/webrtc/audio/audio_receive_stream_unittest.cc @@ -94,13 +94,12 @@ struct ConfigHelper { EXPECT_CALL(*channel_proxy_, EnableReceiveTransportSequenceNumber( kTransportSequenceNumberId)) .Times(1); - EXPECT_CALL(*channel_proxy_, SetCongestionControlObjects( - nullptr, nullptr, &packet_router_)) + EXPECT_CALL(*channel_proxy_, + RegisterReceiverCongestionControlObjects(&packet_router_)) .Times(1); EXPECT_CALL(congestion_controller_, packet_router()) .WillOnce(Return(&packet_router_)); - EXPECT_CALL(*channel_proxy_, - SetCongestionControlObjects(nullptr, nullptr, nullptr)) + EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects()) .Times(1); return channel_proxy_; })); diff --git a/webrtc/audio/audio_send_stream.cc b/webrtc/audio/audio_send_stream.cc index 35a65521dd..62121c63a5 100644 --- a/webrtc/audio/audio_send_stream.cc +++ b/webrtc/audio/audio_send_stream.cc @@ -68,7 +68,7 @@ AudioSendStream::AudioSendStream( VoiceEngineImpl* voe_impl = static_cast(voice_engine()); channel_proxy_ = voe_impl->GetChannelProxy(config_.voe_channel_id); - channel_proxy_->SetCongestionControlObjects( + channel_proxy_->RegisterSenderCongestionControlObjects( congestion_controller->pacer(), congestion_controller->GetTransportFeedbackObserver(), congestion_controller->packet_router()); @@ -92,7 +92,7 @@ AudioSendStream::AudioSendStream( AudioSendStream::~AudioSendStream() { RTC_DCHECK(thread_checker_.CalledOnValidThread()); LOG(LS_INFO) << "~AudioSendStream: " << config_.ToString(); - channel_proxy_->SetCongestionControlObjects(nullptr, nullptr, nullptr); + channel_proxy_->ResetCongestionControlObjects(); } void AudioSendStream::Start() { diff --git a/webrtc/audio/audio_send_stream_unittest.cc b/webrtc/audio/audio_send_stream_unittest.cc index 466c1571ac..a01ef025d3 100644 --- a/webrtc/audio/audio_send_stream_unittest.cc +++ b/webrtc/audio/audio_send_stream_unittest.cc @@ -83,13 +83,12 @@ struct ConfigHelper { kTransportSequenceNumberId)) .Times(1); EXPECT_CALL(*channel_proxy_, - SetCongestionControlObjects( + RegisterSenderCongestionControlObjects( congestion_controller_.pacer(), congestion_controller_.GetTransportFeedbackObserver(), congestion_controller_.packet_router())) .Times(1); - EXPECT_CALL(*channel_proxy_, - SetCongestionControlObjects(nullptr, nullptr, nullptr)) + EXPECT_CALL(*channel_proxy_, ResetCongestionControlObjects()) .Times(1); return channel_proxy_; })); diff --git a/webrtc/call/congestion_controller.cc b/webrtc/call/congestion_controller.cc index 0267d79fca..e548a96999 100644 --- a/webrtc/call/congestion_controller.cc +++ b/webrtc/call/congestion_controller.cc @@ -171,9 +171,9 @@ CongestionController::CongestionController(ProcessThread* process_thread, call_stats_->RegisterStatsObserver(remote_bitrate_estimator_.get()); pacer_thread_->RegisterModule(pacer_.get()); + pacer_thread_->RegisterModule(remote_estimator_proxy_.get()); pacer_thread_->Start(); - process_thread->RegisterModule(remote_estimator_proxy_.get()); process_thread->RegisterModule(remote_bitrate_estimator_.get()); process_thread->RegisterModule(bitrate_controller_.get()); } @@ -181,9 +181,9 @@ CongestionController::CongestionController(ProcessThread* process_thread, CongestionController::~CongestionController() { pacer_thread_->Stop(); pacer_thread_->DeRegisterModule(pacer_.get()); + pacer_thread_->DeRegisterModule(remote_estimator_proxy_.get()); process_thread_->DeRegisterModule(bitrate_controller_.get()); process_thread_->DeRegisterModule(remote_bitrate_estimator_.get()); - process_thread_->DeRegisterModule(remote_estimator_proxy_.get()); call_stats_->DeregisterStatsObserver(remote_bitrate_estimator_.get()); if (transport_feedback_adapter_.get()) call_stats_->DeregisterStatsObserver(transport_feedback_adapter_.get()); diff --git a/webrtc/modules/pacing/packet_router.cc b/webrtc/modules/pacing/packet_router.cc index 5fd350834a..e98ab0c2b0 100644 --- a/webrtc/modules/pacing/packet_router.cc +++ b/webrtc/modules/pacing/packet_router.cc @@ -18,33 +18,64 @@ namespace webrtc { +namespace { +void AddModule(RtpRtcp* rtp_module, std::list* rtp_modules) { + RTC_DCHECK(std::find(rtp_modules->begin(), rtp_modules->end(), rtp_module) == + rtp_modules->end()); + rtp_modules->push_back(rtp_module); +} + +void RemoveModule(RtpRtcp* rtp_module, std::list* rtp_modules) { + RTC_DCHECK(std::find(rtp_modules->begin(), rtp_modules->end(), rtp_module) != + rtp_modules->end()); + rtp_modules->remove(rtp_module); +} + +bool SendFeedback(rtcp::TransportFeedback* packet, + std::list* rtp_modules) { + for (auto* rtp_module : *rtp_modules) { + packet->WithPacketSenderSsrc(rtp_module->SSRC()); + if (rtp_module->SendFeedbackPacket(*packet)) + return true; + } + return false; +} +} + PacketRouter::PacketRouter() : transport_seq_(0) { + pacer_thread_checker_.DetachFromThread(); } PacketRouter::~PacketRouter() { - RTC_DCHECK(rtp_modules_.empty()); + RTC_DCHECK(send_rtp_modules_.empty()); + RTC_DCHECK(recv_rtp_modules_.empty()); } -void PacketRouter::AddRtpModule(RtpRtcp* rtp_module) { - rtc::CritScope cs(&modules_lock_); - RTC_DCHECK(std::find(rtp_modules_.begin(), rtp_modules_.end(), rtp_module) == - rtp_modules_.end()); - rtp_modules_.push_back(rtp_module); +void PacketRouter::AddRtpModule(RtpRtcp* rtp_module, bool sender) { + rtc::CritScope cs(&modules_crit_); + if (sender) { + AddModule(rtp_module, &send_rtp_modules_); + } else { + AddModule(rtp_module, &recv_rtp_modules_); + } } -void PacketRouter::RemoveRtpModule(RtpRtcp* rtp_module) { - rtc::CritScope cs(&modules_lock_); - auto it = std::find(rtp_modules_.begin(), rtp_modules_.end(), rtp_module); - RTC_DCHECK(it != rtp_modules_.end()); - rtp_modules_.erase(it); +void PacketRouter::RemoveRtpModule(RtpRtcp* rtp_module, bool sender) { + rtc::CritScope cs(&modules_crit_); + if (sender) { + RemoveModule(rtp_module, &send_rtp_modules_); + } else { + RemoveModule(rtp_module, &recv_rtp_modules_); + } } bool PacketRouter::TimeToSendPacket(uint32_t ssrc, uint16_t sequence_number, int64_t capture_timestamp, bool retransmission) { - rtc::CritScope cs(&modules_lock_); - for (auto* rtp_module : rtp_modules_) { + RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread()); + rtc::CritScope cs(&modules_crit_); + for (auto* rtp_module : send_rtp_modules_) { if (rtp_module->SendingMedia() && ssrc == rtp_module->SSRC()) { return rtp_module->TimeToSendPacket(ssrc, sequence_number, capture_timestamp, retransmission); @@ -54,9 +85,10 @@ bool PacketRouter::TimeToSendPacket(uint32_t ssrc, } size_t PacketRouter::TimeToSendPadding(size_t bytes_to_send) { + RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread()); size_t total_bytes_sent = 0; - rtc::CritScope cs(&modules_lock_); - for (RtpRtcp* module : rtp_modules_) { + rtc::CritScope cs(&modules_crit_); + for (RtpRtcp* module : send_rtp_modules_) { if (module->SendingMedia()) { size_t bytes_sent = module->TimeToSendPadding(bytes_to_send - total_bytes_sent); @@ -91,12 +123,12 @@ uint16_t PacketRouter::AllocateSequenceNumber() { } bool PacketRouter::SendFeedback(rtcp::TransportFeedback* packet) { - rtc::CritScope cs(&modules_lock_); - for (auto* rtp_module : rtp_modules_) { - packet->WithPacketSenderSsrc(rtp_module->SSRC()); - if (rtp_module->SendFeedbackPacket(*packet)) - return true; - } + RTC_DCHECK(pacer_thread_checker_.CalledOnValidThread()); + rtc::CritScope cs(&modules_crit_); + if (::webrtc::SendFeedback(packet, &recv_rtp_modules_)) + return true; + if (::webrtc::SendFeedback(packet, &send_rtp_modules_)) + return true; return false; } diff --git a/webrtc/modules/pacing/packet_router.h b/webrtc/modules/pacing/packet_router.h index edef1aa9b3..dd58faf4ea 100644 --- a/webrtc/modules/pacing/packet_router.h +++ b/webrtc/modules/pacing/packet_router.h @@ -17,6 +17,7 @@ #include "webrtc/base/criticalsection.h" #include "webrtc/base/scoped_ptr.h" #include "webrtc/base/thread_annotations.h" +#include "webrtc/base/thread_checker.h" #include "webrtc/common_types.h" #include "webrtc/modules/pacing/paced_sender.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" @@ -36,8 +37,8 @@ class PacketRouter : public PacedSender::Callback, PacketRouter(); virtual ~PacketRouter(); - void AddRtpModule(RtpRtcp* rtp_module); - void RemoveRtpModule(RtpRtcp* rtp_module); + void AddRtpModule(RtpRtcp* rtp_module, bool sender); + void RemoveRtpModule(RtpRtcp* rtp_module, bool sender); // Implements PacedSender::Callback. bool TimeToSendPacket(uint32_t ssrc, @@ -54,9 +55,10 @@ class PacketRouter : public PacedSender::Callback, virtual bool SendFeedback(rtcp::TransportFeedback* packet); private: - rtc::CriticalSection modules_lock_; - // Map from ssrc to sending rtp module. - std::list rtp_modules_ GUARDED_BY(modules_lock_); + rtc::ThreadChecker pacer_thread_checker_; + rtc::CriticalSection modules_crit_; + std::list send_rtp_modules_ GUARDED_BY(modules_crit_); + std::list recv_rtp_modules_ GUARDED_BY(modules_crit_); volatile int transport_seq_; diff --git a/webrtc/modules/pacing/packet_router_unittest.cc b/webrtc/modules/pacing/packet_router_unittest.cc index 31acf44b9b..e5e05896c2 100644 --- a/webrtc/modules/pacing/packet_router_unittest.cc +++ b/webrtc/modules/pacing/packet_router_unittest.cc @@ -16,6 +16,7 @@ #include "webrtc/modules/pacing/packet_router.h" #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h" #include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h" +#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" #include "webrtc/base/scoped_ptr.h" using ::testing::_; @@ -35,8 +36,8 @@ class PacketRouterTest : public ::testing::Test { TEST_F(PacketRouterTest, TimeToSendPacket) { MockRtpRtcp rtp_1; MockRtpRtcp rtp_2; - packet_router_->AddRtpModule(&rtp_1); - packet_router_->AddRtpModule(&rtp_2); + packet_router_->AddRtpModule(&rtp_1, true); + packet_router_->AddRtpModule(&rtp_2, true); const uint16_t kSsrc1 = 1234; uint16_t sequence_number = 17; @@ -88,7 +89,7 @@ TEST_F(PacketRouterTest, TimeToSendPacket) { EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1 + kSsrc2, sequence_number, timestamp, retransmission)); - packet_router_->RemoveRtpModule(&rtp_1); + packet_router_->RemoveRtpModule(&rtp_1, true); // rtp_1 has been removed, try sending a packet on that ssrc and make sure // it is dropped as expected by not expecting any calls to rtp_1. @@ -98,7 +99,7 @@ TEST_F(PacketRouterTest, TimeToSendPacket) { EXPECT_TRUE(packet_router_->TimeToSendPacket(kSsrc1, sequence_number, timestamp, retransmission)); - packet_router_->RemoveRtpModule(&rtp_2); + packet_router_->RemoveRtpModule(&rtp_2, true); } TEST_F(PacketRouterTest, TimeToSendPadding) { @@ -109,8 +110,8 @@ TEST_F(PacketRouterTest, TimeToSendPadding) { EXPECT_CALL(rtp_1, SSRC()).WillRepeatedly(Return(kSsrc1)); MockRtpRtcp rtp_2; EXPECT_CALL(rtp_2, SSRC()).WillRepeatedly(Return(kSsrc2)); - packet_router_->AddRtpModule(&rtp_1); - packet_router_->AddRtpModule(&rtp_2); + packet_router_->AddRtpModule(&rtp_1, true); + packet_router_->AddRtpModule(&rtp_2, true); // Default configuration, sending padding on all modules sending media, // ordered by SSRC. @@ -146,7 +147,7 @@ TEST_F(PacketRouterTest, TimeToSendPadding) { EXPECT_CALL(rtp_2, TimeToSendPadding(_)).Times(0); EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes)); - packet_router_->RemoveRtpModule(&rtp_1); + packet_router_->RemoveRtpModule(&rtp_1, true); // rtp_1 has been removed, try sending padding and make sure rtp_1 isn't asked // to send by not expecting any calls. Instead verify rtp_2 is called. @@ -154,7 +155,7 @@ TEST_F(PacketRouterTest, TimeToSendPadding) { EXPECT_CALL(rtp_2, TimeToSendPadding(requested_padding_bytes)).Times(1); EXPECT_EQ(0u, packet_router_->TimeToSendPadding(requested_padding_bytes)); - packet_router_->RemoveRtpModule(&rtp_2); + packet_router_->RemoveRtpModule(&rtp_2, true); } TEST_F(PacketRouterTest, AllocateSequenceNumbers) { @@ -169,4 +170,19 @@ TEST_F(PacketRouterTest, AllocateSequenceNumbers) { EXPECT_EQ(static_cast(expected_unwrapped_seq & 0xFFFF), seq); } } + +TEST_F(PacketRouterTest, SendFeedback) { + MockRtpRtcp rtp_1; + MockRtpRtcp rtp_2; + packet_router_->AddRtpModule(&rtp_1, false); + packet_router_->AddRtpModule(&rtp_2, true); + + rtcp::TransportFeedback feedback; + EXPECT_CALL(rtp_1, SendFeedbackPacket(_)).Times(1); + packet_router_->SendFeedback(&feedback); + packet_router_->RemoveRtpModule(&rtp_1, false); + EXPECT_CALL(rtp_2, SendFeedbackPacket(_)).Times(1); + packet_router_->SendFeedback(&feedback); + packet_router_->RemoveRtpModule(&rtp_2, true); +} } // namespace webrtc diff --git a/webrtc/test/mock_voe_channel_proxy.h b/webrtc/test/mock_voe_channel_proxy.h index a0ec4b2405..f5c87334cc 100644 --- a/webrtc/test/mock_voe_channel_proxy.h +++ b/webrtc/test/mock_voe_channel_proxy.h @@ -29,10 +29,13 @@ class MockVoEChannelProxy : public voe::ChannelProxy { MOCK_METHOD2(SetReceiveAudioLevelIndicationStatus, void(bool enable, int id)); MOCK_METHOD1(EnableSendTransportSequenceNumber, void(int id)); MOCK_METHOD1(EnableReceiveTransportSequenceNumber, void(int id)); - MOCK_METHOD3(SetCongestionControlObjects, + MOCK_METHOD3(RegisterSenderCongestionControlObjects, void(RtpPacketSender* rtp_packet_sender, TransportFeedbackObserver* transport_feedback_observer, - PacketRouter* seq_num_allocator)); + PacketRouter* packet_router)); + MOCK_METHOD1(RegisterReceiverCongestionControlObjects, + void(PacketRouter* packet_router)); + MOCK_METHOD0(ResetCongestionControlObjects, void()); MOCK_CONST_METHOD0(GetRTCPStatistics, CallStatistics()); MOCK_CONST_METHOD0(GetRemoteRTCPReportBlocks, std::vector()); MOCK_CONST_METHOD0(GetNetworkStatistics, NetworkStatistics()); diff --git a/webrtc/video/vie_channel.cc b/webrtc/video/vie_channel.cc index b1b0f0c4b8..7c13a7c3df 100644 --- a/webrtc/video/vie_channel.cc +++ b/webrtc/video/vie_channel.cc @@ -150,7 +150,7 @@ int32_t ViEChannel::Init() { for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) rtp_rtcp->SetStorePacketsStatus(true, nack_history_size_sender_); } - packet_router_->AddRtpModule(rtp_rtcp_modules_[0]); + packet_router_->AddRtpModule(rtp_rtcp_modules_[0], sender_); if (sender_) { std::list send_rtp_modules(1, rtp_rtcp_modules_[0]); send_payload_router_->SetSendingRtpModules(send_rtp_modules); @@ -179,7 +179,7 @@ ViEChannel::~ViEChannel() { module_process_thread_->DeRegisterModule(&vie_sync_); send_payload_router_->SetSendingRtpModules(std::list()); for (size_t i = 0; i < num_active_rtp_rtcp_modules_; ++i) - packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); + packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_); for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { module_process_thread_->DeRegisterModule(rtp_rtcp); delete rtp_rtcp; @@ -400,12 +400,12 @@ int32_t ViEChannel::SetSendCodec(const VideoCodec& video_codec, // Deregister previously registered modules. for (size_t i = num_active_modules; i < num_prev_active_modules; ++i) { module_process_thread_->DeRegisterModule(rtp_rtcp_modules_[i]); - packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i]); + packet_router_->RemoveRtpModule(rtp_rtcp_modules_[i], sender_); } // Register new active modules. for (size_t i = num_prev_active_modules; i < num_active_modules; ++i) { module_process_thread_->RegisterModule(rtp_rtcp_modules_[i]); - packet_router_->AddRtpModule(rtp_rtcp_modules_[i]); + packet_router_->AddRtpModule(rtp_rtcp_modules_[i], sender_); } return 0; } diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc index d5f10bfdf8..148ef81d78 100644 --- a/webrtc/voice_engine/channel.cc +++ b/webrtc/voice_engine/channel.cc @@ -124,6 +124,12 @@ class RtpPacketSenderProxy : public RtpPacketSender { rtp_packet_sender_ = rtp_packet_sender; } + bool HasPacketSender() const { + RTC_DCHECK(thread_checker_.CalledOnValidThread()); + rtc::CritScope lock(&crit_); + return rtp_packet_sender_ != nullptr; + } + // Implements RtpPacketSender. void InsertPacket(Priority priority, uint32_t ssrc, @@ -813,12 +819,9 @@ Channel::Channel(int32_t channelId, network_predictor_(new NetworkPredictor(Clock::GetRealTimeClock())), associate_send_channel_(ChannelOwner(nullptr)), pacing_enabled_(config.Get().enabled), - feedback_observer_proxy_(pacing_enabled_ ? new TransportFeedbackProxy() - : nullptr), - seq_num_allocator_proxy_( - pacing_enabled_ ? new TransportSequenceNumberProxy() : nullptr), - rtp_packet_sender_proxy_(pacing_enabled_ ? new RtpPacketSenderProxy() - : nullptr) { + feedback_observer_proxy_(new TransportFeedbackProxy()), + seq_num_allocator_proxy_(new TransportSequenceNumberProxy()), + rtp_packet_sender_proxy_(new RtpPacketSenderProxy()) { WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, _channelId), "Channel::Channel() - ctor"); AudioCodingModule::Config acm_config; @@ -843,10 +846,12 @@ Channel::Channel(int32_t channelId, configuration.audio_messages = this; configuration.receive_statistics = rtp_receive_statistics_.get(); configuration.bandwidth_callback = rtcp_observer_.get(); - configuration.paced_sender = rtp_packet_sender_proxy_.get(); - configuration.transport_sequence_number_allocator = - seq_num_allocator_proxy_.get(); - configuration.transport_feedback_callback = feedback_observer_proxy_.get(); + if (pacing_enabled_) { + configuration.paced_sender = rtp_packet_sender_proxy_.get(); + configuration.transport_sequence_number_allocator = + seq_num_allocator_proxy_.get(); + configuration.transport_feedback_callback = feedback_observer_proxy_.get(); + } configuration.event_log = event_log; _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration)); @@ -2582,32 +2587,40 @@ void Channel::EnableReceiveTransportSequenceNumber(int id) { RTC_DCHECK(ret); } -void Channel::SetCongestionControlObjects( +void Channel::RegisterSenderCongestionControlObjects( RtpPacketSender* rtp_packet_sender, TransportFeedbackObserver* transport_feedback_observer, PacketRouter* packet_router) { - RTC_DCHECK(packet_router != nullptr || packet_router_ != nullptr); - if (transport_feedback_observer) { - RTC_DCHECK(feedback_observer_proxy_.get()); - feedback_observer_proxy_->SetTransportFeedbackObserver( - transport_feedback_observer); - } - if (rtp_packet_sender) { - RTC_DCHECK(rtp_packet_sender_proxy_.get()); - rtp_packet_sender_proxy_->SetPacketSender(rtp_packet_sender); - } - if (seq_num_allocator_proxy_.get()) { - seq_num_allocator_proxy_->SetSequenceNumberAllocator(packet_router); - } - _rtpRtcpModule->SetStorePacketsStatus(rtp_packet_sender != nullptr, 600); - if (packet_router != nullptr) { - packet_router->AddRtpModule(_rtpRtcpModule.get()); - } else { - packet_router_->RemoveRtpModule(_rtpRtcpModule.get()); - } + RTC_DCHECK(rtp_packet_sender); + RTC_DCHECK(transport_feedback_observer); + RTC_DCHECK(packet_router && !packet_router_); + feedback_observer_proxy_->SetTransportFeedbackObserver( + transport_feedback_observer); + seq_num_allocator_proxy_->SetSequenceNumberAllocator(packet_router); + rtp_packet_sender_proxy_->SetPacketSender(rtp_packet_sender); + _rtpRtcpModule->SetStorePacketsStatus(true, 600); + packet_router->AddRtpModule(_rtpRtcpModule.get(), true); packet_router_ = packet_router; } +void Channel::RegisterReceiverCongestionControlObjects( + PacketRouter* packet_router) { + RTC_DCHECK(packet_router && !packet_router_); + packet_router->AddRtpModule(_rtpRtcpModule.get(), false); + packet_router_ = packet_router; +} + +void Channel::ResetCongestionControlObjects() { + RTC_DCHECK(packet_router_); + _rtpRtcpModule->SetStorePacketsStatus(false, 600); + feedback_observer_proxy_->SetTransportFeedbackObserver(nullptr); + seq_num_allocator_proxy_->SetSequenceNumberAllocator(nullptr); + const bool sender = rtp_packet_sender_proxy_->HasPacketSender(); + packet_router_->RemoveRtpModule(_rtpRtcpModule.get(), sender); + packet_router_ = nullptr; + rtp_packet_sender_proxy_->SetPacketSender(nullptr); +} + void Channel::SetRTCPStatus(bool enable) { WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId), "Channel::SetRTCPStatus()"); diff --git a/webrtc/voice_engine/channel.h b/webrtc/voice_engine/channel.h index 14bfc2bba0..889214b0aa 100644 --- a/webrtc/voice_engine/channel.h +++ b/webrtc/voice_engine/channel.h @@ -339,10 +339,12 @@ class Channel void EnableSendTransportSequenceNumber(int id); void EnableReceiveTransportSequenceNumber(int id); - void SetCongestionControlObjects( - RtpPacketSender* rtp_packet_sender, - TransportFeedbackObserver* transport_feedback_observer, - PacketRouter* packet_router); + void RegisterSenderCongestionControlObjects( + RtpPacketSender* rtp_packet_sender, + TransportFeedbackObserver* transport_feedback_observer, + PacketRouter* packet_router); + void RegisterReceiverCongestionControlObjects(PacketRouter* packet_router); + void ResetCongestionControlObjects(); void SetRTCPStatus(bool enable); int GetRTCPStatus(bool& enabled); diff --git a/webrtc/voice_engine/channel_proxy.cc b/webrtc/voice_engine/channel_proxy.cc index 15a21512fb..1e2281aef4 100644 --- a/webrtc/voice_engine/channel_proxy.cc +++ b/webrtc/voice_engine/channel_proxy.cc @@ -79,15 +79,26 @@ void ChannelProxy::EnableReceiveTransportSequenceNumber(int id) { channel()->EnableReceiveTransportSequenceNumber(id); } -void ChannelProxy::SetCongestionControlObjects( +void ChannelProxy::RegisterSenderCongestionControlObjects( RtpPacketSender* rtp_packet_sender, TransportFeedbackObserver* transport_feedback_observer, PacketRouter* packet_router) { RTC_DCHECK(thread_checker_.CalledOnValidThread()); - channel()->SetCongestionControlObjects( + channel()->RegisterSenderCongestionControlObjects( rtp_packet_sender, transport_feedback_observer, packet_router); } +void ChannelProxy::RegisterReceiverCongestionControlObjects( + PacketRouter* packet_router) { + RTC_DCHECK(thread_checker_.CalledOnValidThread()); + channel()->RegisterReceiverCongestionControlObjects(packet_router); +} + +void ChannelProxy::ResetCongestionControlObjects() { + RTC_DCHECK(thread_checker_.CalledOnValidThread()); + channel()->ResetCongestionControlObjects(); +} + CallStatistics ChannelProxy::GetRTCPStatistics() const { RTC_DCHECK(thread_checker_.CalledOnValidThread()); CallStatistics stats = {0}; diff --git a/webrtc/voice_engine/channel_proxy.h b/webrtc/voice_engine/channel_proxy.h index 9a931600f4..9d6839c8de 100644 --- a/webrtc/voice_engine/channel_proxy.h +++ b/webrtc/voice_engine/channel_proxy.h @@ -51,10 +51,13 @@ class ChannelProxy { virtual void SetReceiveAudioLevelIndicationStatus(bool enable, int id); virtual void EnableSendTransportSequenceNumber(int id); virtual void EnableReceiveTransportSequenceNumber(int id); - virtual void SetCongestionControlObjects( + virtual void RegisterSenderCongestionControlObjects( RtpPacketSender* rtp_packet_sender, TransportFeedbackObserver* transport_feedback_observer, PacketRouter* packet_router); + virtual void RegisterReceiverCongestionControlObjects( + PacketRouter* packet_router); + virtual void ResetCongestionControlObjects(); virtual CallStatistics GetRTCPStatistics() const; virtual std::vector GetRemoteRTCPReportBlocks() const;