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

Removing access to send side cc in rtp controller.

Browse Source 
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 <srte@webrtc.org>
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22044}
This commit is contained in:
Sebastian Jansson
2018-02-15 16:51:41 +01:00
committed by Commit Bot
parent 06ad105631
commit e4be6dad65
17 changed files with 266 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
audio/BUILD.gn
View File

@ -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",

15
audio/audio_send_stream.cc
View File

@ -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);
}

42
call/call.cc
View File

@ -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<unsigned int> 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<int>& 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,

63
call/fake_rtp_transport_controller_send.h
View File

@ -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_;

70
call/rtp_transport_controller_send.cc
View File

@ -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

26
call/rtp_transport_controller_send.h
View File

@ -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_;

42
call/rtp_transport_controller_send_interface.h
View File

@ -10,14 +10,25 @@
#ifndef CALL_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_
#define CALL_RTP_TRANSPORT_CONTROLLER_SEND_INTERFACE_H_
#include <stddef.h>
#include <stdint.h>
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

1
modules/congestion_controller/BUILD.gn
View File

@ -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",

4
modules/congestion_controller/include/mock/mock_congestion_observer.h
View File

@ -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,

34
modules/congestion_controller/include/network_changed_observer.h Normal file
View File

@ -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 <stdint.h>
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_

17
modules/congestion_controller/include/send_side_congestion_controller.h
View File

@ -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,

2
modules/congestion_controller/send_side_congestion_controller_unittest.cc
View File

@ -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) {}

2
modules/congestion_controller/transport_feedback_adapter.h
View File

@ -49,7 +49,7 @@ class TransportFeedbackAdapter {
std::vector<PacketFeedback> GetTransportFeedbackVector() const;
rtc::Optional<int64_t> 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);

2
rtc_base/networkroute.h
View File

@ -11,6 +11,8 @@
#ifndef RTC_BASE_NETWORKROUTE_H_
#define RTC_BASE_NETWORKROUTE_H_
#include <stdint.h>
// 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

2
rtc_tools/event_log_visualizer/analyzer.cc
View File

@ -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) {}

1
video/BUILD.gn
View File

@ -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",

18
video/video_send_stream.cc
View File

@ -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,