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

Using pointer to SSCC in transport controller send.

Browse Source 
Using unique_ptr of send side congestion controller (SSCC in
RtpTransportControllerSend. This prepares for a later CL where
the implementation of SSCC will be toggled by an experiment.

Bug: webrtc:8415
Change-Id: I52501d470efc96a62d0bd5c35ad361d43bceb9f9
Reviewed-on: https://webrtc-review.googlesource.com/58901
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22241}
This commit is contained in:
Sebastian Jansson
2018-02-28 16:48:26 +01:00
committed by Commit Bot
parent 8acd5f8334
commit 10211e9b05
2 changed files with 37 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
call/rtp_transport_controller_send.cc
View File

@ -10,8 +10,10 @@
#include <utility>
#include "call/rtp_transport_controller_send.h"
#include "modules/congestion_controller/include/send_side_congestion_controller.h"
#include "rtc_base/location.h"
#include "rtc_base/logging.h"
#include "rtc_base/ptr_util.h"
namespace webrtc {
@ -20,22 +22,26 @@ RtpTransportControllerSend::RtpTransportControllerSend(
webrtc::RtcEventLog* event_log,
const BitrateConstraints& bitrate_config)
: pacer_(clock, &packet_router_, event_log),
send_side_cc_(clock, nullptr /* observer */, event_log, &pacer_),
send_side_cc_(
rtc::MakeUnique<SendSideCongestionController>(clock,
nullptr /* observer */,
event_log,
&pacer_)),
bitrate_configurator_(bitrate_config),
process_thread_(ProcessThread::Create("SendControllerThread")) {
send_side_cc_.SignalNetworkState(kNetworkDown);
send_side_cc_.SetBweBitrates(bitrate_config.min_bitrate_bps,
bitrate_config.start_bitrate_bps,
bitrate_config.max_bitrate_bps);
send_side_cc_->SignalNetworkState(kNetworkDown);
send_side_cc_->SetBweBitrates(bitrate_config.min_bitrate_bps,
bitrate_config.start_bitrate_bps,
bitrate_config.max_bitrate_bps);
process_thread_->RegisterModule(&pacer_, RTC_FROM_HERE);
process_thread_->RegisterModule(&send_side_cc_, RTC_FROM_HERE);
process_thread_->RegisterModule(send_side_cc_.get(), RTC_FROM_HERE);
process_thread_->Start();
}
RtpTransportControllerSend::~RtpTransportControllerSend() {
process_thread_->Stop();
process_thread_->DeRegisterModule(&send_side_cc_);
process_thread_->DeRegisterModule(send_side_cc_.get());
process_thread_->DeRegisterModule(&pacer_);
}
@ -45,7 +51,7 @@ PacketRouter* RtpTransportControllerSend::packet_router() {
TransportFeedbackObserver*
RtpTransportControllerSend::transport_feedback_observer() {
return &send_side_cc_;
return send_side_cc_.get();
}
RtpPacketSender* RtpTransportControllerSend::packet_sender() {
@ -73,23 +79,23 @@ void RtpTransportControllerSend::SetQueueTimeLimit(int limit_ms) {
pacer_.SetQueueTimeLimit(limit_ms);
}
CallStatsObserver* RtpTransportControllerSend::GetCallStatsObserver() {
return &send_side_cc_;
return send_side_cc_.get();
}
void RtpTransportControllerSend::RegisterPacketFeedbackObserver(
PacketFeedbackObserver* observer) {
send_side_cc_.RegisterPacketFeedbackObserver(observer);
send_side_cc_->RegisterPacketFeedbackObserver(observer);
}
void RtpTransportControllerSend::DeRegisterPacketFeedbackObserver(
PacketFeedbackObserver* observer) {
send_side_cc_.DeRegisterPacketFeedbackObserver(observer);
send_side_cc_->DeRegisterPacketFeedbackObserver(observer);
}
void RtpTransportControllerSend::RegisterNetworkObserver(
NetworkChangedObserver* observer) {
send_side_cc_.RegisterNetworkObserver(observer);
send_side_cc_->RegisterNetworkObserver(observer);
}
void RtpTransportControllerSend::DeRegisterNetworkObserver(
NetworkChangedObserver* observer) {
send_side_cc_.DeRegisterNetworkObserver(observer);
send_side_cc_->DeRegisterNetworkObserver(observer);
}
void RtpTransportControllerSend::OnNetworkRouteChanged(
const std::string& transport_name,
@ -125,36 +131,36 @@ void RtpTransportControllerSend::OnNetworkRouteChanged(
<< " bps, max: " << bitrate_config.max_bitrate_bps
<< " bps.";
RTC_DCHECK_GT(bitrate_config.start_bitrate_bps, 0);
send_side_cc_.OnNetworkRouteChanged(
send_side_cc_->OnNetworkRouteChanged(
network_route, bitrate_config.start_bitrate_bps,
bitrate_config.min_bitrate_bps, bitrate_config.max_bitrate_bps);
}
}
void RtpTransportControllerSend::OnNetworkAvailability(bool network_available) {
send_side_cc_.SignalNetworkState(network_available ? kNetworkUp
: kNetworkDown);
send_side_cc_->SignalNetworkState(network_available ? kNetworkUp
: kNetworkDown);
}
RtcpBandwidthObserver* RtpTransportControllerSend::GetBandwidthObserver() {
return send_side_cc_.GetBandwidthObserver();
return send_side_cc_->GetBandwidthObserver();
}
bool RtpTransportControllerSend::AvailableBandwidth(uint32_t* bandwidth) const {
return send_side_cc_.AvailableBandwidth(bandwidth);
return send_side_cc_->AvailableBandwidth(bandwidth);
}
int64_t RtpTransportControllerSend::GetPacerQueuingDelayMs() const {
return send_side_cc_.GetPacerQueuingDelayMs();
return send_side_cc_->GetPacerQueuingDelayMs();
}
int64_t RtpTransportControllerSend::GetFirstPacketTimeMs() const {
return send_side_cc_.GetFirstPacketTimeMs();
return send_side_cc_->GetFirstPacketTimeMs();
}
RateLimiter* RtpTransportControllerSend::GetRetransmissionRateLimiter() {
return send_side_cc_.GetRetransmissionRateLimiter();
return send_side_cc_->GetRetransmissionRateLimiter();
}
void RtpTransportControllerSend::EnablePeriodicAlrProbing(bool enable) {
send_side_cc_.EnablePeriodicAlrProbing(enable);
send_side_cc_->EnablePeriodicAlrProbing(enable);
}
void RtpTransportControllerSend::OnSentPacket(
const rtc::SentPacket& sent_packet) {
send_side_cc_.OnSentPacket(sent_packet);
send_side_cc_->OnSentPacket(sent_packet);
}
void RtpTransportControllerSend::SetSdpBitrateParameters(
@ -162,9 +168,9 @@ void RtpTransportControllerSend::SetSdpBitrateParameters(
rtc::Optional<BitrateConstraints> updated =
bitrate_configurator_.UpdateWithSdpParameters(constraints);
if (updated.has_value()) {
send_side_cc_.SetBweBitrates(updated->min_bitrate_bps,
updated->start_bitrate_bps,
updated->max_bitrate_bps);
send_side_cc_->SetBweBitrates(updated->min_bitrate_bps,
updated->start_bitrate_bps,
updated->max_bitrate_bps);
} else {
RTC_LOG(LS_VERBOSE)
<< "WebRTC.RtpTransportControllerSend.SetSdpBitrateParameters: "
@ -177,9 +183,9 @@ void RtpTransportControllerSend::SetClientBitratePreferences(
rtc::Optional<BitrateConstraints> updated =
bitrate_configurator_.UpdateWithClientPreferences(preferences);
if (updated.has_value()) {
send_side_cc_.SetBweBitrates(updated->min_bitrate_bps,
updated->start_bitrate_bps,
updated->max_bitrate_bps);
send_side_cc_->SetBweBitrates(updated->min_bitrate_bps,
updated->start_bitrate_bps,
updated->max_bitrate_bps);
} else {
RTC_LOG(LS_VERBOSE)
<< "WebRTC.RtpTransportControllerSend.SetClientBitratePreferences: "

4
call/rtp_transport_controller_send.h
View File

@ -18,7 +18,7 @@
#include "call/rtp_bitrate_configurator.h"
#include "call/rtp_transport_controller_send_interface.h"
#include "common_types.h" // NOLINT(build/include)
#include "modules/congestion_controller/include/send_side_congestion_controller.h"
#include "modules/congestion_controller/include/send_side_congestion_controller_interface.h"
#include "modules/pacing/packet_router.h"
#include "modules/utility/include/process_thread.h"
#include "rtc_base/constructormagic.h"
@ -75,7 +75,7 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
private:
PacketRouter packet_router_;
PacedSender pacer_;
SendSideCongestionController send_side_cc_;
const std::unique_ptr<SendSideCongestionControllerInterface> send_side_cc_;
RtpKeepAliveConfig keepalive_;
RtpBitrateConfigurator bitrate_configurator_;
std::map<std::string, rtc::NetworkRoute> network_routes_;