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

Removing interface to access pacer via SSCC.

Browse Source 
SSCC was accessing the pacer just to report values back to
RtpTransportControllerSend which already owns the pacer.
This CL moves those access methods.

To make RtpTransportControllerSend simpler, Call is made
responsible to keep track of network status used only as a
condition for report the pacer queuing delay.

Bug: webrtc:8415
Change-Id: I306bc9fcd3d8dcc7a637d51f2629ececebd48cad
Reviewed-on: https://webrtc-review.googlesource.com/60483
Reviewed-by: Stefan Holmer <stefan@webrtc.org>
Reviewed-by: Niels Moller <nisse@webrtc.org>
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#22331}
This commit is contained in:
Sebastian Jansson 2018-03-07 18:49:55 +01:00 committed by Commit Bot
parent d90a7e8424
commit a06e919b9f
7 changed files with 24 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
call/call.cc
View File

@ -268,6 +268,8 @@ class Call : public webrtc::Call,
NetworkState audio_network_state_;
NetworkState video_network_state_;
rtc::CriticalSection aggregate_network_up_crit_;
bool aggregate_network_up_ RTC_GUARDED_BY(aggregate_network_up_crit_);
std::unique_ptr<RWLockWrapper> receive_crit_;
// Audio, Video, and FlexFEC receive streams are owned by the client that
@ -413,6 +415,7 @@ Call::Call(const Call::Config& config,
config_(config),
audio_network_state_(kNetworkDown),
video_network_state_(kNetworkDown),
aggregate_network_up_(false),
receive_crit_(RWLockWrapper::CreateRWLock()),
send_crit_(RWLockWrapper::CreateRWLock()),
event_log_(config.event_log),
@ -909,7 +912,14 @@ Call::Stats Call::GetStats() const {
&ssrcs, &recv_bandwidth);
stats.send_bandwidth_bps = send_bandwidth;
stats.recv_bandwidth_bps = recv_bandwidth;
stats.pacer_delay_ms = transport_send_->GetPacerQueuingDelayMs();
// TODO(srte): It is unclear if we only want to report queues if network is
// available.
{
rtc::CritScope cs(&aggregate_network_up_crit_);
stats.pacer_delay_ms =
aggregate_network_up_ ? transport_send_->GetPacerQueuingDelayMs() : 0;
}
stats.rtt_ms = call_stats_->rtcp_rtt_stats()->LastProcessedRtt();
{
rtc::CritScope cs(&bitrate_crit_);
@ -1016,16 +1026,17 @@ void Call::UpdateAggregateNetworkState() {
have_video = true;
}
NetworkState aggregate_state = kNetworkDown;
if ((have_video && video_network_state_ == kNetworkUp) ||
(have_audio && audio_network_state_ == kNetworkUp)) {
aggregate_state = kNetworkUp;
}
bool aggregate_network_up =
((have_video && video_network_state_ == kNetworkUp) ||
(have_audio && audio_network_state_ == kNetworkUp));
RTC_LOG(LS_INFO) << "UpdateAggregateNetworkState: aggregate_state="
<< (aggregate_state == kNetworkUp ? "up" : "down");
transport_send_->OnNetworkAvailability(aggregate_state == kNetworkUp);
<< (aggregate_network_up ? "up" : "down");
{
rtc::CritScope cs(&aggregate_network_up_crit_);
aggregate_network_up_ = aggregate_network_up;
}
transport_send_->OnNetworkAvailability(aggregate_network_up);
}
void Call::OnSentPacket(const rtc::SentPacket& sent_packet) {

4
call/rtp_transport_controller_send.cc
View File

@ -145,10 +145,10 @@ bool RtpTransportControllerSend::AvailableBandwidth(uint32_t* bandwidth) const {
return send_side_cc_->AvailableBandwidth(bandwidth);
}
int64_t RtpTransportControllerSend::GetPacerQueuingDelayMs() const {
return send_side_cc_->GetPacerQueuingDelayMs();
return pacer_.QueueInMs();
}
int64_t RtpTransportControllerSend::GetFirstPacketTimeMs() const {
return send_side_cc_->GetFirstPacketTimeMs();
return pacer_.FirstSentPacketTimeMs();
}
void RtpTransportControllerSend::EnablePeriodicAlrProbing(bool enable) {
send_side_cc_->EnablePeriodicAlrProbing(enable);

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

@ -88,8 +88,8 @@ class SendSideCongestionController
RTC_DEPRECATED RtcpBandwidthObserver* GetBandwidthObserver() const;
bool AvailableBandwidth(uint32_t* bandwidth) const override;
int64_t GetPacerQueuingDelayMs() const override;
int64_t GetFirstPacketTimeMs() const override;
virtual int64_t GetPacerQueuingDelayMs() const;
virtual int64_t GetFirstPacketTimeMs() const;
TransportFeedbackObserver* GetTransportFeedbackObserver() override;

2
modules/congestion_controller/include/send_side_congestion_controller_interface.h
View File

@ -59,8 +59,6 @@ class SendSideCongestionControllerInterface : public CallStatsObserver,
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 TransportFeedbackObserver* GetTransportFeedbackObserver() = 0;
virtual void EnablePeriodicAlrProbing(bool enable) = 0;
virtual void OnSentPacket(const rtc::SentPacket& sent_packet) = 0;

2
modules/congestion_controller/rtp/include/send_side_congestion_controller.h
View File

@ -95,8 +95,6 @@ class SendSideCongestionController
RtcpBandwidthObserver* GetBandwidthObserver() override;
bool AvailableBandwidth(uint32_t* bandwidth) const override;
int64_t GetPacerQueuingDelayMs() const override;
int64_t GetFirstPacketTimeMs() const override;
TransportFeedbackObserver* GetTransportFeedbackObserver() override;

11
modules/congestion_controller/rtp/send_side_congestion_controller.cc
View File

@ -398,17 +398,6 @@ void SendSideCongestionController::UpdateStreamsConfig() {
controller_->OnStreamsConfig(streams_config_);
}
int64_t SendSideCongestionController::GetPacerQueuingDelayMs() const {
// TODO(srte): This should be made less synchronous. Now it grabs a lock in
// the pacer just for stats usage. Some kind of push interface might make
// sense.
return network_available_ ? pacer_->QueueInMs() : 0;
}
int64_t SendSideCongestionController::GetFirstPacketTimeMs() const {
return pacer_->FirstSentPacketTimeMs();
}
TransportFeedbackObserver*
SendSideCongestionController::GetTransportFeedbackObserver() {
return this;

16
modules/congestion_controller/rtp/send_side_congestion_controller_unittest.cc
View File

@ -331,22 +331,6 @@ TEST_F(SendSideCongestionControllerTest,
controller_->Process();
}
TEST_F(SendSideCongestionControllerTest, GetPacerQueuingDelayMs) {
EXPECT_CALL(observer_, OnNetworkChanged(_, _, _, _)).Times(AtLeast(1));
const int64_t kQueueTimeMs = 123;
EXPECT_CALL(*pacer_, QueueInMs()).WillRepeatedly(Return(kQueueTimeMs));
EXPECT_EQ(kQueueTimeMs, controller_->GetPacerQueuingDelayMs());
// Expect zero pacer delay when network is down.
controller_->SignalNetworkState(kNetworkDown);
EXPECT_EQ(0, controller_->GetPacerQueuingDelayMs());
// Network is up, pacer delay should be reported.
controller_->SignalNetworkState(kNetworkUp);
EXPECT_EQ(kQueueTimeMs, controller_->GetPacerQueuingDelayMs());
}
TEST_F(SendSideCongestionControllerTest, GetProbingInterval) {
clock_.AdvanceTimeMilliseconds(25);
controller_->Process();