admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved bitrate configuration to rtp controller

Browse Source 
Since rtp transport controller send owns the congestion controller it
also should own the bitrate configuration logic, this way it can
initialize the send side congestion controller with the bitrate
configuration.

Bug: webrtc:8415
Change-Id: Ifaa16139ca477cb1c80bf4aa24f17652af997553
Reviewed-on: https://webrtc-review.googlesource.com/54303
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22127}
This commit is contained in:
Sebastian Jansson 2018-02-21 13:01:55 +01:00 committed by Commit Bot
parent a425184a04
commit 97f61ea684
8 changed files with 101 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
audio/audio_send_stream_unittest.cc
View File

@ -126,7 +126,7 @@ struct ConfigHelper {
: stream_config_(nullptr),
audio_processing_(new rtc::RefCountedObject<MockAudioProcessing>()),
simulated_clock_(123456),
rtp_transport_(&simulated_clock_, &event_log_),
rtp_transport_(&simulated_clock_, &event_log_, BitrateConstraints()),
bitrate_allocator_(&limit_observer_),
worker_queue_("ConfigHelper_worker_queue"),
audio_encoder_(nullptr) {

2
call/BUILD.gn
View File

@ -92,6 +92,7 @@ rtc_source_set("rtp_sender") {
"rtp_transport_controller_send.h",
]
deps = [
":bitrate_configurator",
":rtp_interfaces",
"..:webrtc_common",
"../modules/congestion_controller",
@ -147,7 +148,6 @@ rtc_static_library("call") {
deps = [
":bitrate_allocator",
":bitrate_configurator",
":call_interfaces",
":rtp_interfaces",
":rtp_receiver",

60
call/call.cc
View File

@ -24,7 +24,6 @@
#include "call/bitrate_allocator.h"
#include "call/call.h"
#include "call/flexfec_receive_stream_impl.h"
#include "call/rtp_bitrate_configurator.h"
#include "call/rtp_stream_receiver_controller.h"
#include "call/rtp_transport_controller_send.h"
#include "logging/rtc_event_log/events/rtc_event_audio_receive_stream_config.h"
@ -369,7 +368,6 @@ class Call : public webrtc::Call,
// and deleted before any other members.
rtc::TaskQueue worker_queue_;
RtpBitrateConfigurator bitrate_configurator_;
RTC_DISALLOW_COPY_AND_ASSIGN(Call);
};
} // namespace internal
@ -387,9 +385,10 @@ std::string Call::Stats::ToString(int64_t time_ms) const {
}
Call* Call::Create(const Call::Config& config) {
return new internal::Call(config,
rtc::MakeUnique<RtpTransportControllerSend>(
Clock::GetRealTimeClock(), config.event_log));
return new internal::Call(
config,
rtc::MakeUnique<RtpTransportControllerSend>(
Clock::GetRealTimeClock(), config.event_log, config.bitrate_config));
}
Call* Call::Create(
@ -435,16 +434,11 @@ Call::Call(const Call::Config& config,
receive_side_cc_(clock_, transport_send->packet_router()),
video_send_delay_stats_(new SendDelayStats(clock_)),
start_ms_(clock_->TimeInMilliseconds()),
worker_queue_("call_worker_queue"),
bitrate_configurator_(config.bitrate_config) {
worker_queue_("call_worker_queue") {
RTC_DCHECK(config.event_log != nullptr);
transport_send->RegisterNetworkObserver(this);
transport_send_ = std::move(transport_send);
transport_send_->OnNetworkAvailability(false);
transport_send_->SetBweBitrates(
bitrate_configurator_.GetConfig().min_bitrate_bps,
bitrate_configurator_.GetConfig().start_bitrate_bps,
bitrate_configurator_.GetConfig().max_bitrate_bps);
call_stats_->RegisterStatsObserver(&receive_side_cc_);
call_stats_->RegisterStatsObserver(transport_send_->GetCallStatsObserver());
@ -941,29 +935,13 @@ Call::Stats Call::GetStats() const {
void Call::SetBitrateConfig(const BitrateConstraints& bitrate_config) {
TRACE_EVENT0("webrtc", "Call::SetBitrateConfig");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
rtc::Optional<BitrateConstraints> config =
bitrate_configurator_.UpdateWithSdpParameters(bitrate_config);
if (config.has_value()) {
transport_send_->SetBweBitrates(config->min_bitrate_bps,
config->start_bitrate_bps,
config->max_bitrate_bps);
} else {
RTC_LOG(LS_VERBOSE) << "WebRTC.Call.SetBitrateConfig: "
<< "nothing to update";
}
transport_send_->SetSdpBitrateParameters(bitrate_config);
}
void Call::SetBitrateConfigMask(const BitrateConstraintsMask& bitrate_mask) {
rtc::Optional<BitrateConstraints> config =
bitrate_configurator_.UpdateWithClientPreferences(bitrate_mask);
if (config.has_value()) {
transport_send_->SetBweBitrates(config->min_bitrate_bps,
config->start_bitrate_bps,
config->max_bitrate_bps);
} else {
RTC_LOG(LS_VERBOSE) << "WebRTC.Call.SetBitrateConfigMask: "
<< "nothing to update";
}
void Call::SetBitrateConfigMask(const webrtc::BitrateConstraintsMask& mask) {
TRACE_EVENT0("webrtc", "Call::SetBitrateConfigMask");
RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_);
transport_send_->SetClientBitratePreferences(mask);
}
void Call::SetBitrateAllocationStrategy(
@ -1067,21 +1045,7 @@ void Call::OnNetworkRouteChanged(const std::string& transport_name,
}
if (kv->second != network_route) {
kv->second = network_route;
BitrateConstraints bitrate_config = bitrate_configurator_.GetConfig();
RTC_LOG(LS_INFO) << "Network route changed on transport " << transport_name
<< ": new local network id "
<< network_route.local_network_id
<< " new remote network id "
<< network_route.remote_network_id
<< " Reset bitrates to min: "
<< bitrate_config.min_bitrate_bps
<< " bps, start: " << bitrate_config.start_bitrate_bps
<< " bps, max: " << bitrate_config.max_bitrate_bps
<< " bps.";
RTC_DCHECK_GT(bitrate_config.start_bitrate_bps, 0);
transport_send_->OnNetworkRouteChanged(
network_route, bitrate_config.start_bitrate_bps,
bitrate_config.min_bitrate_bps, bitrate_config.max_bitrate_bps);
transport_send_->OnNetworkRouteChanged(transport_name, network_route);
}
}

71
call/rtp_transport_controller_send.cc
View File

@ -9,14 +9,23 @@
*/
#include "call/rtp_transport_controller_send.h"
#include "rtc_base/logging.h"
namespace webrtc {
RtpTransportControllerSend::RtpTransportControllerSend(
Clock* clock,
webrtc::RtcEventLog* event_log)
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_(clock, nullptr /* observer */, event_log, &pacer_),
bitrate_configurator_(bitrate_config) {
send_side_cc_.SignalNetworkState(kNetworkDown);
send_side_cc_.SetBweBitrates(bitrate_config.min_bitrate_bps,
bitrate_config.start_bitrate_bps,
bitrate_config.max_bitrate_bps);
}
RtpTransportControllerSend::~RtpTransportControllerSend() = default;
PacketRouter* RtpTransportControllerSend::packet_router() {
return &packet_router_;
@ -76,19 +85,24 @@ 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);
const std::string& transport_name,
const rtc::NetworkRoute& network_route) {
BitrateConstraints bitrate_config = bitrate_configurator_.GetConfig();
RTC_LOG(LS_INFO) << "Network route changed on transport " << transport_name
<< ": new local network id "
<< network_route.local_network_id
<< " new remote network id "
<< network_route.remote_network_id
<< " Reset bitrates to min: "
<< bitrate_config.min_bitrate_bps
<< " bps, start: " << bitrate_config.start_bitrate_bps
<< " bps, max: " << bitrate_config.max_bitrate_bps
<< " bps.";
RTC_DCHECK_GT(bitrate_config.start_bitrate_bps, 0);
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
@ -121,4 +135,33 @@ void RtpTransportControllerSend::OnSentPacket(
send_side_cc_.OnSentPacket(sent_packet);
}
void RtpTransportControllerSend::SetSdpBitrateParameters(
const BitrateConstraints& constraints) {
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);
} else {
RTC_LOG(LS_VERBOSE)
<< "WebRTC.RtpTransportControllerSend.SetBitrateConfig: "
<< "nothing to update";
}
}
void RtpTransportControllerSend::SetClientBitratePreferences(
const BitrateConstraintsMask& preferences) {
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);
} else {
RTC_LOG(LS_VERBOSE)
<< "WebRTC.RtpTransportControllerSend.SetBitrateConfigMask: "
<< "nothing to update";
}
}
} // namespace webrtc

23
call/rtp_transport_controller_send.h
View File

@ -11,6 +11,9 @@
#ifndef CALL_RTP_TRANSPORT_CONTROLLER_SEND_H_
#define CALL_RTP_TRANSPORT_CONTROLLER_SEND_H_
#include <string>
#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"
@ -26,8 +29,10 @@ class RtcEventLog;
// per transport, sharing the same congestion controller.
class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
public:
RtpTransportControllerSend(Clock* clock, webrtc::RtcEventLog* event_log);
RtpTransportControllerSend(Clock* clock,
RtcEventLog* event_log,
const BitrateConstraints& bitrate_config);
~RtpTransportControllerSend() override;
// Implements RtpTransportControllerSendInterface
PacketRouter* packet_router() override;
@ -50,13 +55,8 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
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 OnNetworkRouteChanged(const std::string& transport_name,
const rtc::NetworkRoute& network_route) override;
void OnNetworkAvailability(bool network_available) override;
void SetTransportOverhead(
size_t transport_overhead_bytes_per_packet) override;
@ -68,11 +68,16 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
void EnablePeriodicAlrProbing(bool enable) override;
void OnSentPacket(const rtc::SentPacket& sent_packet) override;
void SetSdpBitrateParameters(const BitrateConstraints& constraints) override;
void SetClientBitratePreferences(
const BitrateConstraintsMask& preferences) override;
private:
PacketRouter packet_router_;
PacedSender pacer_;
SendSideCongestionController send_side_cc_;
RtpKeepAliveConfig keepalive_;
RtpBitrateConfigurator bitrate_configurator_;
RTC_DISALLOW_COPY_AND_ASSIGN(RtpTransportControllerSend);
};

20
call/rtp_transport_controller_send_interface.h
View File

@ -13,6 +13,11 @@
#include <stddef.h>
#include <stdint.h>
#include <string>
#include "api/optional.h"
#include "call/bitrate_constraints.h"
namespace rtc {
struct SentPacket;
struct NetworkRoute;
@ -88,13 +93,9 @@ class RtpTransportControllerSendInterface {
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 OnNetworkRouteChanged(
const std::string& transport_name,
const rtc::NetworkRoute& network_route) = 0;
virtual void OnNetworkAvailability(bool network_available) = 0;
virtual void SetTransportOverhead(
size_t transport_overhead_bytes_per_packet) = 0;
@ -105,6 +106,11 @@ class RtpTransportControllerSendInterface {
virtual RateLimiter* GetRetransmissionRateLimiter() = 0;
virtual void EnablePeriodicAlrProbing(bool enable) = 0;
virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;
virtual void SetSdpBitrateParameters(
const BitrateConstraints& constraints) = 0;
virtual void SetClientBitratePreferences(
const BitrateConstraintsMask& preferences) = 0;
};
} // namespace webrtc

4
ortc/rtptransportcontrolleradapter.cc
View File

@ -651,8 +651,8 @@ void RtpTransportControllerAdapter::Init_w() {
call_config.bitrate_config.start_bitrate_bps = kStartBandwidthBps;
call_config.bitrate_config.max_bitrate_bps = kMaxBandwidthBps;
call_send_rtp_transport_controller_ =
new RtpTransportControllerSend(Clock::GetRealTimeClock(), event_log_);
call_send_rtp_transport_controller_ = new RtpTransportControllerSend(
Clock::GetRealTimeClock(), event_log_, call_config.bitrate_config);
call_.reset(webrtc::Call::Create(
call_config, std::unique_ptr<RtpTransportControllerSendInterface>(
call_send_rtp_transport_controller_)));

2
test/call_test.cc
View File

@ -172,7 +172,7 @@ void CallTest::CreateCalls(const Call::Config& sender_config,
void CallTest::CreateSenderCall(const Call::Config& config) {
sender_call_transport_controller_ = new RtpTransportControllerSend(
Clock::GetRealTimeClock(), config.event_log);
Clock::GetRealTimeClock(), config.event_log, config.bitrate_config);
sender_call_.reset(
Call::Create(config, std::unique_ptr<RtpTransportControllerSend>(