From e4be6dad656a36165534b520e4888eb1717dced3 Mon Sep 17 00:00:00 2001 From: Sebastian Jansson Date: Thu, 15 Feb 2018 16:51:41 +0100 Subject: [PATCH] Removing access to send side cc in rtp controller. This CL removes direct access to SendSideCongestionController (SSCC) via the RtpTransportControllerSend interface and replaces all usages with calls on RtpTransportControllerSend which will in turn calls SSCC. This prepares for later refactor of RtpTransportControllerSend. Bug: webrtc:8415 Change-Id: I68363a3ab0203b95579f747402a1e7f58a5eeeb5 Reviewed-on: https://webrtc-review.googlesource.com/53860 Commit-Queue: Sebastian Jansson Reviewed-by: Stefan Holmer Cr-Commit-Position: refs/heads/master@{#22044} --- audio/BUILD.gn | 1 - audio/audio_send_stream.cc | 15 ++-- call/call.cc | 42 ++++++----- call/fake_rtp_transport_controller_send.h | 63 +++++++++++++++-- call/rtp_transport_controller_send.cc | 70 +++++++++++++++++-- call/rtp_transport_controller_send.h | 26 ++++++- .../rtp_transport_controller_send_interface.h | 42 ++++++++++- modules/congestion_controller/BUILD.gn | 1 + .../include/mock/mock_congestion_observer.h | 4 +- .../include/network_changed_observer.h | 34 +++++++++ .../include/send_side_congestion_controller.h | 17 +---- ...end_side_congestion_controller_unittest.cc | 2 +- .../transport_feedback_adapter.h | 2 +- rtc_base/networkroute.h | 2 + rtc_tools/event_log_visualizer/analyzer.cc | 2 +- video/BUILD.gn | 1 - video/video_send_stream.cc | 18 +++-- 17 files changed, 266 insertions(+), 76 deletions(-) create mode 100644 modules/congestion_controller/include/network_changed_observer.h diff --git a/audio/BUILD.gn b/audio/BUILD.gn index f6a30bac8f..5b5c723c4f 100644 --- a/audio/BUILD.gn +++ b/audio/BUILD.gn @@ -69,7 +69,6 @@ rtc_static_library("audio") { "../modules/audio_device", "../modules/audio_processing", "../modules/bitrate_controller:bitrate_controller", - "../modules/congestion_controller:congestion_controller", "../modules/pacing:pacing", "../modules/remote_bitrate_estimator:remote_bitrate_estimator", "../modules/rtp_rtcp", diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc index 0a5fc58581..5de079bb18 100644 --- a/audio/audio_send_stream.cc +++ b/audio/audio_send_stream.cc @@ -19,8 +19,6 @@ #include "audio/conversion.h" #include "call/rtp_transport_controller_send_interface.h" #include "modules/audio_coding/codecs/cng/audio_encoder_cng.h" -#include "modules/bitrate_controller/include/bitrate_controller.h" -#include "modules/congestion_controller/include/send_side_congestion_controller.h" #include "modules/pacing/paced_sender.h" #include "rtc_base/checks.h" #include "rtc_base/event.h" @@ -138,7 +136,6 @@ AudioSendStream::AudioSendStream( RTC_DCHECK(channel_proxy_); RTC_DCHECK(bitrate_allocator_); RTC_DCHECK(transport); - RTC_DCHECK(transport->send_side_cc()); RTC_DCHECK(overall_call_lifetime_); channel_proxy_->SetRtcEventLog(event_log_); @@ -152,14 +149,14 @@ AudioSendStream::AudioSendStream( pacer_thread_checker_.DetachFromThread(); // Signal congestion controller this object is ready for OnPacket* callbacks. - transport_->send_side_cc()->RegisterPacketFeedbackObserver(this); + transport_->RegisterPacketFeedbackObserver(this); } AudioSendStream::~AudioSendStream() { RTC_DCHECK(worker_thread_checker_.CalledOnValidThread()); RTC_LOG(LS_INFO) << "~AudioSendStream: " << config_.rtp.ssrc; RTC_DCHECK(!sending_); - transport_->send_side_cc()->DeRegisterPacketFeedbackObserver(this); + transport_->DeRegisterPacketFeedbackObserver(this); channel_proxy_->RegisterTransport(nullptr); channel_proxy_->ResetSenderCongestionControlObjects(); channel_proxy_->SetRtcEventLog(nullptr); @@ -257,9 +254,8 @@ void AudioSendStream::ConfigureStream( // Probing in application limited region is only used in combination with // send side congestion control, wich depends on feedback packets which // requires transport sequence numbers to be enabled. - stream->transport_->send_side_cc()->EnablePeriodicAlrProbing(true); - bandwidth_observer = - stream->transport_->send_side_cc()->GetBandwidthObserver(); + stream->transport_->EnablePeriodicAlrProbing(true); + bandwidth_observer = stream->transport_->GetBandwidthObserver(); } channel_proxy->RegisterSenderCongestionControlObjects(stream->transport_, @@ -455,8 +451,7 @@ void AudioSendStream::OnPacketFeedbackVector( void AudioSendStream::SetTransportOverhead(int transport_overhead_per_packet) { RTC_DCHECK(worker_thread_checker_.CalledOnValidThread()); - transport_->send_side_cc()->SetTransportOverhead( - transport_overhead_per_packet); + transport_->SetTransportOverhead(transport_overhead_per_packet); channel_proxy_->SetTransportOverhead(transport_overhead_per_packet); } diff --git a/call/call.cc b/call/call.cc index e19051d177..338a135900 100644 --- a/call/call.cc +++ b/call/call.cc @@ -35,6 +35,7 @@ #include "logging/rtc_event_log/rtc_event_log.h" #include "logging/rtc_event_log/rtc_stream_config.h" #include "modules/bitrate_controller/include/bitrate_controller.h" +#include "modules/congestion_controller/include/network_changed_observer.h" #include "modules/congestion_controller/include/receive_side_congestion_controller.h" #include "modules/rtp_rtcp/include/flexfec_receiver.h" #include "modules/rtp_rtcp/include/rtp_header_extension_map.h" @@ -163,7 +164,7 @@ namespace internal { class Call : public webrtc::Call, public PacketReceiver, public RecoveredPacketReceiver, - public SendSideCongestionController::Observer, + public NetworkChangedObserver, public BitrateAllocator::LimitObserver { public: Call(const Call::Config& config, @@ -451,15 +452,14 @@ Call::Call(const Call::Config& config, RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps, config.bitrate_config.start_bitrate_bps); } - transport_send->send_side_cc()->RegisterNetworkObserver(this); + transport_send->RegisterNetworkObserver(this); transport_send_ = std::move(transport_send); - transport_send_->send_side_cc()->SignalNetworkState(kNetworkDown); - transport_send_->send_side_cc()->SetBweBitrates( - config_.bitrate_config.min_bitrate_bps, - config_.bitrate_config.start_bitrate_bps, - config_.bitrate_config.max_bitrate_bps); + transport_send_->OnNetworkAvailability(false); + transport_send_->SetBweBitrates(config_.bitrate_config.min_bitrate_bps, + config_.bitrate_config.start_bitrate_bps, + config_.bitrate_config.max_bitrate_bps); call_stats_->RegisterStatsObserver(&receive_side_cc_); - call_stats_->RegisterStatsObserver(transport_send_->send_side_cc()); + call_stats_->RegisterStatsObserver(transport_send_->GetCallStatsObserver()); // We have to attach the pacer to the pacer thread before starting the // module process thread to avoid a race accessing the process thread @@ -471,7 +471,7 @@ Call::Call(const Call::Config& config, module_process_thread_->RegisterModule(call_stats_.get(), RTC_FROM_HERE); module_process_thread_->RegisterModule(&receive_side_cc_, RTC_FROM_HERE); - module_process_thread_->RegisterModule(transport_send_->send_side_cc(), + module_process_thread_->RegisterModule(transport_send_->GetModule(), RTC_FROM_HERE); module_process_thread_->Start(); } @@ -489,7 +489,7 @@ Call::~Call() { // the pacer thread being stopped to avoid a race when accessing the // pacer thread object on the module process thread at the same time as // the pacer thread is stopped. - module_process_thread_->DeRegisterModule(transport_send_->send_side_cc()); + module_process_thread_->DeRegisterModule(transport_send_->GetModule()); pacer_thread_->Stop(); pacer_thread_->DeRegisterModule(transport_send_->pacer()); pacer_thread_->DeRegisterModule( @@ -498,10 +498,9 @@ Call::~Call() { module_process_thread_->DeRegisterModule(call_stats_.get()); module_process_thread_->Stop(); call_stats_->DeregisterStatsObserver(&receive_side_cc_); - call_stats_->DeregisterStatsObserver(transport_send_->send_side_cc()); + call_stats_->DeregisterStatsObserver(transport_send_->GetCallStatsObserver()); - int64_t first_sent_packet_ms = - transport_send_->send_side_cc()->GetFirstPacketTimeMs(); + int64_t first_sent_packet_ms = transport_send_->GetFirstPacketTimeMs(); // Only update histograms after process threads have been shut down, so that // they won't try to concurrently update stats. { @@ -930,15 +929,14 @@ Call::Stats Call::GetStats() const { Stats stats; // Fetch available send/receive bitrates. uint32_t send_bandwidth = 0; - transport_send_->send_side_cc()->AvailableBandwidth(&send_bandwidth); + transport_send_->AvailableBandwidth(&send_bandwidth); std::vector ssrcs; uint32_t recv_bandwidth = 0; receive_side_cc_.GetRemoteBitrateEstimator(false)->LatestEstimate( &ssrcs, &recv_bandwidth); stats.send_bandwidth_bps = send_bandwidth; stats.recv_bandwidth_bps = recv_bandwidth; - stats.pacer_delay_ms = - transport_send_->send_side_cc()->GetPacerQueuingDelayMs(); + stats.pacer_delay_ms = transport_send_->GetPacerQueuingDelayMs(); stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt(); { rtc::CritScope cs(&bitrate_crit_); @@ -1019,9 +1017,9 @@ void Call::UpdateCurrentBitrateConfig(const rtc::Optional& new_start) { << "calling SetBweBitrates with args (" << updated.min_bitrate_bps << ", " << updated.start_bitrate_bps << ", " << updated.max_bitrate_bps << ")"; - transport_send_->send_side_cc()->SetBweBitrates(updated.min_bitrate_bps, - updated.start_bitrate_bps, - updated.max_bitrate_bps); + transport_send_->SetBweBitrates(updated.min_bitrate_bps, + updated.start_bitrate_bps, + updated.max_bitrate_bps); if (!new_start) { updated.start_bitrate_bps = config_.bitrate_config.start_bitrate_bps; } @@ -1138,7 +1136,7 @@ void Call::OnNetworkRouteChanged(const std::string& transport_name, << " bps, max: " << config_.bitrate_config.start_bitrate_bps << " bps."; RTC_DCHECK_GT(config_.bitrate_config.start_bitrate_bps, 0); - transport_send_->send_side_cc()->OnNetworkRouteChanged( + transport_send_->OnNetworkRouteChanged( network_route, config_.bitrate_config.start_bitrate_bps, config_.bitrate_config.min_bitrate_bps, config_.bitrate_config.max_bitrate_bps); @@ -1174,13 +1172,13 @@ void Call::UpdateAggregateNetworkState() { RTC_LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state=" << (aggregate_state == kNetworkUp ? "up" : "down"); - transport_send_->send_side_cc()->SignalNetworkState(aggregate_state); + transport_send_->OnNetworkAvailability(aggregate_state == kNetworkUp); } void Call::OnSentPacket(const rtc::SentPacket& sent_packet) { video_send_delay_stats_->OnSentPacket(sent_packet.packet_id, clock_->TimeInMilliseconds()); - transport_send_->send_side_cc()->OnSentPacket(sent_packet); + transport_send_->OnSentPacket(sent_packet); } void Call::OnNetworkChanged(uint32_t target_bitrate_bps, diff --git a/call/fake_rtp_transport_controller_send.h b/call/fake_rtp_transport_controller_send.h index dda2e5f645..b797a352bd 100644 --- a/call/fake_rtp_transport_controller_send.h +++ b/call/fake_rtp_transport_controller_send.h @@ -33,10 +33,6 @@ class FakeRtpTransportControllerSend PacketRouter* packet_router() override { return packet_router_; } - SendSideCongestionController* send_side_cc() override { - return send_side_cc_; - } - TransportFeedbackObserver* transport_feedback_observer() override { return send_side_cc_; } @@ -56,6 +52,65 @@ class FakeRtpTransportControllerSend keepalive_ = keepalive_config; } + Module* GetModule() override { return send_side_cc_; } + CallStatsObserver* GetCallStatsObserver() override { return send_side_cc_; } + void RegisterPacketFeedbackObserver( + PacketFeedbackObserver* observer) override { + send_side_cc_->RegisterPacketFeedbackObserver(observer); + } + void DeRegisterPacketFeedbackObserver( + PacketFeedbackObserver* observer) override { + send_side_cc_->DeRegisterPacketFeedbackObserver(observer); + } + void RegisterNetworkObserver(NetworkChangedObserver* observer) override { + send_side_cc_->RegisterNetworkObserver(observer); + } + void DeRegisterNetworkObserver(NetworkChangedObserver* observer) override { + send_side_cc_->RegisterNetworkObserver(observer); + } + void SetBweBitrates(int min_bitrate_bps, + int start_bitrate_bps, + int max_bitrate_bps) override { + send_side_cc_->SetBweBitrates(min_bitrate_bps, start_bitrate_bps, + max_bitrate_bps); + } + void OnNetworkRouteChanged(const rtc::NetworkRoute& network_route, + int start_bitrate_bps, + int min_bitrate_bps, + int max_bitrate_bps) override { + send_side_cc_->OnNetworkRouteChanged(network_route, start_bitrate_bps, + min_bitrate_bps, max_bitrate_bps); + } + void OnNetworkAvailability(bool network_available) override { + send_side_cc_->SignalNetworkState(network_available ? kNetworkUp + : kNetworkDown); + } + void SetTransportOverhead( + size_t transport_overhead_bytes_per_packet) override { + send_side_cc_->SetTransportOverhead(transport_overhead_bytes_per_packet); + } + RtcpBandwidthObserver* GetBandwidthObserver() override { + return send_side_cc_->GetBandwidthObserver(); + } + bool AvailableBandwidth(uint32_t* bandwidth) const override { + return send_side_cc_->AvailableBandwidth(bandwidth); + } + int64_t GetPacerQueuingDelayMs() const override { + return send_side_cc_->GetPacerQueuingDelayMs(); + } + int64_t GetFirstPacketTimeMs() const override { + return send_side_cc_->GetFirstPacketTimeMs(); + } + RateLimiter* GetRetransmissionRateLimiter() override { + return send_side_cc_->GetRetransmissionRateLimiter(); + } + void EnablePeriodicAlrProbing(bool enable) override { + send_side_cc_->EnablePeriodicAlrProbing(enable); + } + void OnSentPacket(const rtc::SentPacket& sent_packet) override { + send_side_cc_->OnSentPacket(sent_packet); + } + private: PacketRouter* packet_router_; PacedSender* paced_sender_; diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc index 090c261e4e..f203c4e6f8 100644 --- a/call/rtp_transport_controller_send.cc +++ b/call/rtp_transport_controller_send.cc @@ -26,10 +26,6 @@ PacedSender* RtpTransportControllerSend::pacer() { return &pacer_; } -SendSideCongestionController* RtpTransportControllerSend::send_side_cc() { - return &send_side_cc_; -} - TransportFeedbackObserver* RtpTransportControllerSend::transport_feedback_observer() { return &send_side_cc_; @@ -53,5 +49,71 @@ void RtpTransportControllerSend::SetKeepAliveConfig( const RtpKeepAliveConfig& config) { keepalive_ = config; } +Module* RtpTransportControllerSend::GetModule() { + return &send_side_cc_; +} +CallStatsObserver* RtpTransportControllerSend::GetCallStatsObserver() { + return &send_side_cc_; +} +void RtpTransportControllerSend::RegisterPacketFeedbackObserver( + PacketFeedbackObserver* observer) { + send_side_cc_.RegisterPacketFeedbackObserver(observer); +} +void RtpTransportControllerSend::DeRegisterPacketFeedbackObserver( + PacketFeedbackObserver* observer) { + send_side_cc_.DeRegisterPacketFeedbackObserver(observer); +} +void RtpTransportControllerSend::RegisterNetworkObserver( + NetworkChangedObserver* observer) { + send_side_cc_.RegisterNetworkObserver(observer); +} +void RtpTransportControllerSend::DeRegisterNetworkObserver( + NetworkChangedObserver* observer) { + send_side_cc_.DeRegisterNetworkObserver(observer); +} +void RtpTransportControllerSend::SetBweBitrates(int min_bitrate_bps, + int start_bitrate_bps, + int max_bitrate_bps) { + send_side_cc_.SetBweBitrates(min_bitrate_bps, start_bitrate_bps, + max_bitrate_bps); +} +void RtpTransportControllerSend::OnNetworkRouteChanged( + const rtc::NetworkRoute& network_route, + int start_bitrate_bps, + int min_bitrate_bps, + int max_bitrate_bps) { + send_side_cc_.OnNetworkRouteChanged(network_route, start_bitrate_bps, + min_bitrate_bps, max_bitrate_bps); +} +void RtpTransportControllerSend::OnNetworkAvailability(bool network_available) { + send_side_cc_.SignalNetworkState(network_available ? kNetworkUp + : kNetworkDown); +} +void RtpTransportControllerSend::SetTransportOverhead( + size_t transport_overhead_bytes_per_packet) { + send_side_cc_.SetTransportOverhead(transport_overhead_bytes_per_packet); +} +RtcpBandwidthObserver* RtpTransportControllerSend::GetBandwidthObserver() { + return send_side_cc_.GetBandwidthObserver(); +} +bool RtpTransportControllerSend::AvailableBandwidth(uint32_t* bandwidth) const { + return send_side_cc_.AvailableBandwidth(bandwidth); +} +int64_t RtpTransportControllerSend::GetPacerQueuingDelayMs() const { + return send_side_cc_.GetPacerQueuingDelayMs(); +} +int64_t RtpTransportControllerSend::GetFirstPacketTimeMs() const { + return send_side_cc_.GetFirstPacketTimeMs(); +} +RateLimiter* RtpTransportControllerSend::GetRetransmissionRateLimiter() { + return send_side_cc_.GetRetransmissionRateLimiter(); +} +void RtpTransportControllerSend::EnablePeriodicAlrProbing(bool enable) { + send_side_cc_.EnablePeriodicAlrProbing(enable); +} +void RtpTransportControllerSend::OnSentPacket( + const rtc::SentPacket& sent_packet) { + send_side_cc_.OnSentPacket(sent_packet); +} } // namespace webrtc diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h index 45d6db0fee..2ae4ce6d39 100644 --- a/call/rtp_transport_controller_send.h +++ b/call/rtp_transport_controller_send.h @@ -35,7 +35,6 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface { // In addition the PacedSender should be driven by this class, either // by owning the process thread, or later by using a task queue. PacedSender* pacer() override; - SendSideCongestionController* send_side_cc() override; TransportFeedbackObserver* transport_feedback_observer() override; RtpPacketSender* packet_sender() override; const RtpKeepAliveConfig& keepalive_config() const override; @@ -44,6 +43,31 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface { int max_padding_bitrate_bps) override; void SetKeepAliveConfig(const RtpKeepAliveConfig& config); + Module* GetModule() override; + CallStatsObserver* GetCallStatsObserver() override; + void RegisterPacketFeedbackObserver( + PacketFeedbackObserver* observer) override; + void DeRegisterPacketFeedbackObserver( + PacketFeedbackObserver* observer) override; + void RegisterNetworkObserver(NetworkChangedObserver* observer) override; + void DeRegisterNetworkObserver(NetworkChangedObserver* observer) override; + void SetBweBitrates(int min_bitrate_bps, + int start_bitrate_bps, + int max_bitrate_bps) override; + void OnNetworkRouteChanged(const rtc::NetworkRoute& network_route, + int start_bitrate_bps, + int min_bitrate_bps, + int max_bitrate_bps) override; + void OnNetworkAvailability(bool network_available) override; + void SetTransportOverhead( + size_t transport_overhead_bytes_per_packet) override; + RtcpBandwidthObserver* GetBandwidthObserver() override; + bool AvailableBandwidth(uint32_t* bandwidth) const override; + int64_t GetPacerQueuingDelayMs() const override; + int64_t GetFirstPacketTimeMs() const override; + RateLimiter* GetRetransmissionRateLimiter() override; + void EnablePeriodicAlrProbing(bool enable) override; + void OnSentPacket(const rtc::SentPacket& sent_packet) override; private: PacketRouter packet_router_; diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h index 7b0dbefd14..d8f58db0e8 100644 --- a/call/rtp_transport_controller_send_interface.h +++ b/call/rtp_transport_controller_send_interface.h @@ -10,14 +10,25 @@ #ifndef CALL_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_ #define CALL_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_ +#include +#include +namespace rtc { +struct SentPacket; +struct NetworkRoute; +} // namespace rtc namespace webrtc { +class CallStatsObserver; +class NetworkChangedObserver; +class Module; class PacedSender; +class PacketFeedbackObserver; class PacketRouter; +class RateLimiter; +class RtcpBandwidthObserver; class RtpPacketSender; struct RtpKeepAliveConfig; -class SendSideCongestionController; class TransportFeedbackObserver; // An RtpTransportController should own everything related to the RTP @@ -48,8 +59,6 @@ class RtpTransportControllerSendInterface { virtual ~RtpTransportControllerSendInterface() {} virtual PacketRouter* packet_router() = 0; virtual PacedSender* pacer() = 0; - // Currently returning the same pointer, but with different types. - virtual SendSideCongestionController* send_side_cc() = 0; virtual TransportFeedbackObserver* transport_feedback_observer() = 0; virtual RtpPacketSender* packet_sender() = 0; @@ -66,6 +75,33 @@ class RtpTransportControllerSendInterface { // pad unless there is real packets to send. virtual void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps, int max_padding_bitrate_bps) = 0; + + virtual Module* GetModule() = 0; + virtual CallStatsObserver* GetCallStatsObserver() = 0; + + virtual void RegisterPacketFeedbackObserver( + PacketFeedbackObserver* observer) = 0; + virtual void DeRegisterPacketFeedbackObserver( + PacketFeedbackObserver* observer) = 0; + virtual void RegisterNetworkObserver(NetworkChangedObserver* observer) = 0; + virtual void DeRegisterNetworkObserver(NetworkChangedObserver* observer) = 0; + virtual void SetBweBitrates(int min_bitrate_bps, + int start_bitrate_bps, + int max_bitrate_bps) = 0; + virtual void OnNetworkRouteChanged(const rtc::NetworkRoute& network_route, + int start_bitrate_bps, + int min_bitrate_bps, + int max_bitrate_bps) = 0; + virtual void OnNetworkAvailability(bool network_available) = 0; + virtual void SetTransportOverhead( + size_t transport_overhead_bytes_per_packet) = 0; + virtual RtcpBandwidthObserver* GetBandwidthObserver() = 0; + virtual bool AvailableBandwidth(uint32_t* bandwidth) const = 0; + virtual int64_t GetPacerQueuingDelayMs() const = 0; + virtual int64_t GetFirstPacketTimeMs() const = 0; + virtual RateLimiter* GetRetransmissionRateLimiter() = 0; + virtual void EnablePeriodicAlrProbing(bool enable) = 0; + virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0; }; } // namespace webrtc diff --git a/modules/congestion_controller/BUILD.gn b/modules/congestion_controller/BUILD.gn index 23f5333dd9..6709c858de 100644 --- a/modules/congestion_controller/BUILD.gn +++ b/modules/congestion_controller/BUILD.gn @@ -20,6 +20,7 @@ rtc_static_library("congestion_controller") { visibility = [ "*" ] configs += [ ":bwe_test_logging" ] sources = [ + "include/network_changed_observer.h", "include/receive_side_congestion_controller.h", "include/send_side_congestion_controller.h", "probe_controller.cc", diff --git a/modules/congestion_controller/include/mock/mock_congestion_observer.h b/modules/congestion_controller/include/mock/mock_congestion_observer.h index c6883d976b..d9c24a23ca 100644 --- a/modules/congestion_controller/include/mock/mock_congestion_observer.h +++ b/modules/congestion_controller/include/mock/mock_congestion_observer.h @@ -11,13 +11,13 @@ #ifndef MODULES_CONGESTION_CONTROLLER_INCLUDE_MOCK_MOCK_CONGESTION_OBSERVER_H_ #define MODULES_CONGESTION_CONTROLLER_INCLUDE_MOCK_MOCK_CONGESTION_OBSERVER_H_ -#include "modules/congestion_controller/include/send_side_congestion_controller.h" +#include "modules/congestion_controller/include/network_changed_observer.h" #include "test/gmock.h" namespace webrtc { namespace test { -class MockCongestionObserver : public SendSideCongestionController::Observer { +class MockCongestionObserver : public NetworkChangedObserver { public: MOCK_METHOD4(OnNetworkChanged, void(uint32_t bitrate_bps, diff --git a/modules/congestion_controller/include/network_changed_observer.h b/modules/congestion_controller/include/network_changed_observer.h new file mode 100644 index 0000000000..bb95a3d703 --- /dev/null +++ b/modules/congestion_controller/include/network_changed_observer.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_ +#define MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_ + +#include + +namespace webrtc { + +// Observer class for bitrate changes announced due to change in bandwidth +// estimate or due to that the send pacer is full. Fraction loss and rtt is +// also part of this callback to allow the observer to optimize its settings +// for different types of network environments. The bitrate does not include +// packet headers and is measured in bits per second. +class NetworkChangedObserver { + public: + virtual void OnNetworkChanged(uint32_t bitrate_bps, + uint8_t fraction_loss, // 0 - 255. + int64_t rtt_ms, + int64_t probing_interval_ms) = 0; + + protected: + virtual ~NetworkChangedObserver() {} +}; +} // namespace webrtc +#endif // MODULES_CONGESTION_CONTROLLER_INCLUDE_NETWORK_CHANGED_OBSERVER_H_ diff --git a/modules/congestion_controller/include/send_side_congestion_controller.h b/modules/congestion_controller/include/send_side_congestion_controller.h index 2707cc340d..d08c05dd83 100644 --- a/modules/congestion_controller/include/send_side_congestion_controller.h +++ b/modules/congestion_controller/include/send_side_congestion_controller.h @@ -16,6 +16,7 @@ #include "common_types.h" // NOLINT(build/include) #include "modules/congestion_controller/delay_based_bwe.h" +#include "modules/congestion_controller/include/network_changed_observer.h" #include "modules/congestion_controller/transport_feedback_adapter.h" #include "modules/include/module.h" #include "modules/include/module_common_types.h" @@ -42,21 +43,7 @@ class SendSideCongestionController : public CallStatsObserver, public Module, public TransportFeedbackObserver { public: - // Observer class for bitrate changes announced due to change in bandwidth - // estimate or due to that the send pacer is full. Fraction loss and rtt is - // also part of this callback to allow the observer to optimize its settings - // for different types of network environments. The bitrate does not include - // packet headers and is measured in bits per second. - class Observer { - public: - virtual void OnNetworkChanged(uint32_t bitrate_bps, - uint8_t fraction_loss, // 0 - 255. - int64_t rtt_ms, - int64_t probing_interval_ms) = 0; - - protected: - virtual ~Observer() {} - }; + using Observer = NetworkChangedObserver; SendSideCongestionController(const Clock* clock, Observer* observer, RtcEventLog* event_log, diff --git a/modules/congestion_controller/send_side_congestion_controller_unittest.cc b/modules/congestion_controller/send_side_congestion_controller_unittest.cc index 67d2c402c4..cc672071d2 100644 --- a/modules/congestion_controller/send_side_congestion_controller_unittest.cc +++ b/modules/congestion_controller/send_side_congestion_controller_unittest.cc @@ -85,7 +85,7 @@ class SendSideCongestionControllerTest : public ::testing::Test { // Allows us to track the target bitrate, without prescribing the exact // iterations when this would hapen, like a mock would. - class TargetBitrateObserver : public SendSideCongestionController::Observer { + class TargetBitrateObserver : public NetworkChangedObserver { public: explicit TargetBitrateObserver(SendSideCongestionControllerTest* owner) : owner_(owner) {} diff --git a/modules/congestion_controller/transport_feedback_adapter.h b/modules/congestion_controller/transport_feedback_adapter.h index 2e9bf7ced2..dfd926414e 100644 --- a/modules/congestion_controller/transport_feedback_adapter.h +++ b/modules/congestion_controller/transport_feedback_adapter.h @@ -49,7 +49,7 @@ class TransportFeedbackAdapter { std::vector GetTransportFeedbackVector() const; rtc::Optional GetMinFeedbackLoopRtt() const; - void SetTransportOverhead(int transport_overhead_bytes_per_packet); + void SetTransportOverhead(size_t transport_overhead_bytes_per_packet); void SetNetworkIds(uint16_t local_id, uint16_t remote_id); diff --git a/rtc_base/networkroute.h b/rtc_base/networkroute.h index 07cba6324c..5800ef8484 100644 --- a/rtc_base/networkroute.h +++ b/rtc_base/networkroute.h @@ -11,6 +11,8 @@ #ifndef RTC_BASE_NETWORKROUTE_H_ #define RTC_BASE_NETWORKROUTE_H_ +#include + // TODO(honghaiz): Make a directory that describes the interfaces and structs // the media code can rely on and the network code can implement, and both can // depend on that, but not depend on each other. Then, move this file to that diff --git a/rtc_tools/event_log_visualizer/analyzer.cc b/rtc_tools/event_log_visualizer/analyzer.cc index c32c676b38..0249ec4cc5 100644 --- a/rtc_tools/event_log_visualizer/analyzer.cc +++ b/rtc_tools/event_log_visualizer/analyzer.cc @@ -671,7 +671,7 @@ EventLogAnalyzer::EventLogAnalyzer(const ParsedRtcEventLog& log) << " (LOG_START, LOG_END) segments in log."; } -class BitrateObserver : public SendSideCongestionController::Observer, +class BitrateObserver : public NetworkChangedObserver, public RemoteBitrateObserver { public: BitrateObserver() : last_bitrate_bps_(0), bitrate_updated_(false) {} diff --git a/video/BUILD.gn b/video/BUILD.gn index 0a7b331f63..52c8af29ae 100644 --- a/video/BUILD.gn +++ b/video/BUILD.gn @@ -81,7 +81,6 @@ rtc_static_library("video") { "../logging:rtc_event_log_api", "../modules:module_api", "../modules/bitrate_controller", - "../modules/congestion_controller", "../modules/pacing", "../modules/remote_bitrate_estimator", "../modules/rtp_rtcp", diff --git a/video/video_send_stream.cc b/video/video_send_stream.cc index 3d59bc25b9..f49f5a001c 100644 --- a/video/video_send_stream.cc +++ b/video/video_send_stream.cc @@ -22,7 +22,6 @@ #include "common_types.h" // NOLINT(build/include) #include "common_video/include/video_bitrate_allocator.h" #include "modules/bitrate_controller/include/bitrate_controller.h" -#include "modules/congestion_controller/include/send_side_congestion_controller.h" #include "modules/pacing/packet_router.h" #include "modules/rtp_rtcp/include/rtp_rtcp.h" #include "modules/rtp_rtcp/source/rtp_sender.h" @@ -790,7 +789,7 @@ VideoSendStreamImpl::VideoSendStreamImpl( encoder_feedback_(Clock::GetRealTimeClock(), config_->rtp.ssrcs, video_stream_encoder), - bandwidth_observer_(transport->send_side_cc()->GetBandwidthObserver()), + bandwidth_observer_(transport->GetBandwidthObserver()), rtp_rtcp_modules_(CreateRtpRtcpModules( config_->send_transport, &encoder_feedback_, @@ -801,7 +800,7 @@ VideoSendStreamImpl::VideoSendStreamImpl( stats_proxy_, send_delay_stats, event_log, - transport->send_side_cc()->GetRetransmissionRateLimiter(), + transport->GetRetransmissionRateLimiter(), this, config_->rtp.ssrcs.size(), transport->keepalive_config(), @@ -822,7 +821,7 @@ VideoSendStreamImpl::VideoSendStreamImpl( RTC_DCHECK(!config_->rtp.ssrcs.empty()); RTC_DCHECK(call_stats_); RTC_DCHECK(transport_); - RTC_DCHECK(transport_->send_side_cc()); + RTC_DCHECK(transport_); RTC_DCHECK_GT(encoder_max_bitrate_bps_, 0); RTC_CHECK(AlrExperimentSettings::MaxOneFieldTrialEnabled()); @@ -838,7 +837,7 @@ VideoSendStreamImpl::VideoSendStreamImpl( AlrExperimentSettings::kStrictPacingAndProbingExperimentName); } if (alr_settings) { - transport->send_side_cc()->EnablePeriodicAlrProbing(true); + transport->EnablePeriodicAlrProbing(true); transport->pacer()->SetPacingFactor(alr_settings->pacing_factor); configured_pacing_factor_ = alr_settings->pacing_factor; transport->pacer()->SetQueueTimeLimit(alr_settings->max_paced_queue_time); @@ -846,7 +845,7 @@ VideoSendStreamImpl::VideoSendStreamImpl( } if (config_->periodic_alr_bandwidth_probing) { - transport->send_side_cc()->EnablePeriodicAlrProbing(true); + transport->EnablePeriodicAlrProbing(true); } // RTP/RTCP initialization. @@ -890,7 +889,7 @@ VideoSendStreamImpl::VideoSendStreamImpl( fec_controller_->SetProtectionCallback(this); // Signal congestion controller this object is ready for OnPacket* callbacks. if (fec_controller_->UseLossVectorMask()) { - transport_->send_side_cc()->RegisterPacketFeedbackObserver(this); + transport_->RegisterPacketFeedbackObserver(this); } RTC_DCHECK(config_->encoder_settings.encoder); @@ -936,7 +935,7 @@ VideoSendStreamImpl::~VideoSendStreamImpl() { << "VideoSendStreamImpl::Stop not called"; RTC_LOG(LS_INFO) << "~VideoSendStreamInternal: " << config_->ToString(); if (fec_controller_->UseLossVectorMask()) { - transport_->send_side_cc()->DeRegisterPacketFeedbackObserver(this); + transport_->DeRegisterPacketFeedbackObserver(this); } for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) { transport_->packet_router()->RemoveSendRtpModule(rtp_rtcp); @@ -1424,8 +1423,7 @@ void VideoSendStreamImpl::SetTransportOverhead( transport_overhead_bytes_per_packet_ = transport_overhead_bytes_per_packet; - transport_->send_side_cc()->SetTransportOverhead( - transport_overhead_bytes_per_packet_); + transport_->SetTransportOverhead(transport_overhead_bytes_per_packet_); size_t rtp_packet_size = std::min(config_->rtp.max_packet_size,