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

Move PacedSender ownership to RtpTransportControllerSend.

Browse Source 
BUG=webrtc:8089
R=nisse@webrtc.org, terelius@webrtc.org

Review-Url: https://codereview.webrtc.org/3000773002 .
Cr-Commit-Position: refs/heads/master@{#19451}
This commit is contained in:
Stefan Holmer
2017-08-22 16:16:44 +02:00
parent ee42d19b70
commit 5c8942aee1
15 changed files with 121 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
webrtc/audio/audio_send_stream_unittest.cc
View File

@ -22,7 +22,7 @@
#include "webrtc/modules/audio_processing/include/mock_audio_processing.h"
#include "webrtc/modules/congestion_controller/include/mock/mock_congestion_observer.h"
#include "webrtc/modules/congestion_controller/include/send_side_congestion_controller.h"
#include "webrtc/modules/pacing/paced_sender.h"
#include "webrtc/modules/pacing/mock/mock_paced_sender.h"
#include "webrtc/modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
#include "webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
#include "webrtc/rtc_base/ptr_util.h"
@ -139,8 +139,8 @@ struct ConfigHelper {
&simulated_clock_,
nullptr /* observer */,
&event_log_,
&packet_router_)),
fake_transport_(&packet_router_, send_side_cc_.get()),
&pacer_)),
fake_transport_(&packet_router_, &pacer_, send_side_cc_.get()),
bitrate_allocator_(&limit_observer_),
worker_queue_("ConfigHelper_worker_queue"),
audio_encoder_(nullptr) {
@ -335,6 +335,7 @@ struct ConfigHelper {
AudioProcessing::AudioProcessingStatistics audio_processing_stats_;
SimulatedClock simulated_clock_;
PacketRouter packet_router_;
testing::NiceMock<MockPacedSender> pacer_;
std::unique_ptr<SendSideCongestionController> send_side_cc_;
FakeRtpTransportControllerSend fake_transport_;
MockRtcEventLog event_log_;

10
webrtc/call/call.cc
View File

@ -30,7 +30,6 @@
#include "webrtc/logging/rtc_event_log/rtc_event_log.h"
#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
#include "webrtc/modules/congestion_controller/include/receive_side_congestion_controller.h"
#include "webrtc/modules/pacing/paced_sender.h"
#include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
@ -438,8 +437,7 @@ Call::Call(const Call::Config& config,
// We have to attach the pacer to the pacer thread before starting the
// module process thread to avoid a race accessing the process thread
// both from the process thread and the pacer thread.
pacer_thread_->RegisterModule(transport_send_->send_side_cc()->pacer(),
RTC_FROM_HERE);
pacer_thread_->RegisterModule(transport_send_->pacer(), RTC_FROM_HERE);
pacer_thread_->RegisterModule(
receive_side_cc_.GetRemoteBitrateEstimator(true), RTC_FROM_HERE);
pacer_thread_->Start();
@ -466,7 +464,7 @@ Call::~Call() {
// the pacer thread is stopped.
module_process_thread_->DeRegisterModule(transport_send_->send_side_cc());
pacer_thread_->Stop();
pacer_thread_->DeRegisterModule(transport_send_->send_side_cc()->pacer());
pacer_thread_->DeRegisterModule(transport_send_->pacer());
pacer_thread_->DeRegisterModule(
receive_side_cc_.GetRemoteBitrateEstimator(true));
module_process_thread_->DeRegisterModule(&receive_side_cc_);
@ -1198,8 +1196,8 @@ void Call::OnNetworkChanged(uint32_t target_bitrate_bps,
void Call::OnAllocationLimitsChanged(uint32_t min_send_bitrate_bps,
uint32_t max_padding_bitrate_bps) {
transport_send_->send_side_cc()->SetAllocatedSendBitrateLimits(
min_send_bitrate_bps, max_padding_bitrate_bps);
transport_send_->SetAllocatedSendBitrateLimits(min_send_bitrate_bps,
max_padding_bitrate_bps);
rtc::CritScope lock(&bitrate_crit_);
min_allocated_send_bitrate_bps_ = min_send_bitrate_bps;
configured_max_padding_bitrate_bps_ = max_padding_bitrate_bps;

6
webrtc/call/call_unittest.cc
View File

@ -21,6 +21,7 @@
#include "webrtc/modules/audio_device/include/mock_audio_device.h"
#include "webrtc/modules/audio_mixer/audio_mixer_impl.h"
#include "webrtc/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h"
#include "webrtc/modules/pacing/mock/mock_paced_sender.h"
#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
#include "webrtc/rtc_base/ptr_util.h"
#include "webrtc/test/fake_encoder.h"
@ -324,12 +325,12 @@ struct CallBitrateHelper {
CallBitrateHelper() : CallBitrateHelper(Call::Config::BitrateConfig()) {}
explicit CallBitrateHelper(const Call::Config::BitrateConfig& bitrate_config)
: mock_cc_(Clock::GetRealTimeClock(), &event_log_, &packet_router_) {
: mock_cc_(Clock::GetRealTimeClock(), &event_log_, &pacer_) {
Call::Config config(&event_log_);
config.bitrate_config = bitrate_config;
call_.reset(
Call::Create(config, rtc::MakeUnique<FakeRtpTransportControllerSend>(
&packet_router_, &mock_cc_)));
&packet_router_, &pacer_, &mock_cc_)));
}
webrtc::Call* operator->() { return call_.get(); }
@ -340,6 +341,7 @@ struct CallBitrateHelper {
private:
webrtc::RtcEventLogNullImpl event_log_;
PacketRouter packet_router_;
testing::NiceMock<MockPacedSender> pacer_;
testing::NiceMock<test::MockSendSideCongestionController> mock_cc_;
std::unique_ptr<Call> call_;
};

13
webrtc/call/fake_rtp_transport_controller_send.h
View File

@ -23,8 +23,11 @@ class FakeRtpTransportControllerSend
public:
explicit FakeRtpTransportControllerSend(
PacketRouter* packet_router,
PacedSender* paced_sender,
SendSideCongestionController* send_side_cc)
: packet_router_(packet_router), send_side_cc_(send_side_cc) {
: packet_router_(packet_router),
paced_sender_(paced_sender),
send_side_cc_(send_side_cc) {
RTC_DCHECK(send_side_cc);
}
@ -38,18 +41,24 @@ class FakeRtpTransportControllerSend
return send_side_cc_;
}
RtpPacketSender* packet_sender() override { return send_side_cc_->pacer(); }
PacedSender* pacer() override { return paced_sender_; }
RtpPacketSender* packet_sender() override { return paced_sender_; }
const RtpKeepAliveConfig& keepalive_config() const override {
return keepalive_;
}
void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
int max_padding_bitrate_bps) override {}
void set_keepalive_config(const RtpKeepAliveConfig& keepalive_config) {
keepalive_ = keepalive_config;
}
private:
PacketRouter* packet_router_;
PacedSender* paced_sender_;
SendSideCongestionController* send_side_cc_;
RtpKeepAliveConfig keepalive_;
};

16
webrtc/call/rtp_transport_controller_send.cc
View File

@ -15,13 +15,17 @@ namespace webrtc {
RtpTransportControllerSend::RtpTransportControllerSend(
Clock* clock,
webrtc::RtcEventLog* event_log)
: send_side_cc_(clock, nullptr /* observer */, event_log, &packet_router_) {
}
: pacer_(clock, &packet_router_, event_log),
send_side_cc_(clock, nullptr /* observer */, event_log, &pacer_) {}
PacketRouter* RtpTransportControllerSend::packet_router() {
return &packet_router_;
}
PacedSender* RtpTransportControllerSend::pacer() {
return &pacer_;
}
SendSideCongestionController* RtpTransportControllerSend::send_side_cc() {
return &send_side_cc_;
}
@ -32,13 +36,19 @@ RtpTransportControllerSend::transport_feedback_observer() {
}
RtpPacketSender* RtpTransportControllerSend::packet_sender() {
return send_side_cc_.pacer();
return &pacer_;
}
const RtpKeepAliveConfig& RtpTransportControllerSend::keepalive_config() const {
return keepalive_;
}
void RtpTransportControllerSend::SetAllocatedSendBitrateLimits(
int min_send_bitrate_bps,
int max_padding_bitrate_bps) {
pacer_.SetSendBitrateLimits(min_send_bitrate_bps, max_padding_bitrate_bps);
}
void RtpTransportControllerSend::SetKeepAliveConfig(
const RtpKeepAliveConfig& config) {
keepalive_ = config;

9
webrtc/call/rtp_transport_controller_send.h
View File

@ -29,15 +29,24 @@ class RtpTransportControllerSend : public RtpTransportControllerSendInterface {
// Implements RtpTransportControllerSendInterface
PacketRouter* packet_router() override;
// TODO(holmer): Temporarily exposed, should be removed and the
// appropriate methods should be added to this class instead.
// 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;
void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
int max_padding_bitrate_bps) override;
void SetKeepAliveConfig(const RtpKeepAliveConfig& config);
private:
PacketRouter packet_router_;
PacedSender pacer_;
SendSideCongestionController send_side_cc_;
RtpKeepAliveConfig keepalive_;

14
webrtc/call/rtp_transport_controller_send_interface.h
View File

@ -13,6 +13,7 @@
namespace webrtc {
class PacedSender;
class PacketRouter;
class RtpPacketSender;
struct RtpKeepAliveConfig;
@ -46,12 +47,25 @@ class RtpTransportControllerSendInterface {
public:
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;
virtual const RtpKeepAliveConfig& keepalive_config() const = 0;
// SetAllocatedSendBitrateLimits sets bitrates limits imposed by send codec
// settings.
// |min_send_bitrate_bps| is the total minimum send bitrate required by all
// sending streams. This is the minimum bitrate the PacedSender will use.
// Note that SendSideCongestionController::OnNetworkChanged can still be
// called with a lower bitrate estimate. |max_padding_bitrate_bps| is the max
// bitrate the send streams request for padding. This can be higher than the
// current network estimate and tells the PacedSender how much it should max
// pad unless there is real packets to send.
virtual void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
int max_padding_bitrate_bps) = 0;
};
} // namespace webrtc

4
webrtc/modules/congestion_controller/include/mock/mock_send_side_congestion_controller.h
View File

@ -21,11 +21,11 @@ class MockSendSideCongestionController : public SendSideCongestionController {
public:
MockSendSideCongestionController(const Clock* clock,
RtcEventLog* event_log,
PacketRouter* packet_router)
PacedSender* paced_sender)
: SendSideCongestionController(clock,
nullptr /* observer */,
event_log,
packet_router) {}
paced_sender) {}
MOCK_METHOD3(SetBweBitrates,
void(int min_bitrate_bps,

30
webrtc/modules/congestion_controller/include/send_side_congestion_controller.h
View File

@ -58,16 +58,17 @@ class SendSideCongestionController : public CallStatsObserver,
protected:
virtual ~Observer() {}
};
// TODO(holmer): Delete after fixing upstream projects.
RTC_DEPRECATED SendSideCongestionController(const Clock* clock,
Observer* observer,
RtcEventLog* event_log,
PacketRouter* packet_router);
// TODO(nisse): Consider deleting the |observer| argument to constructors
// once CongestionController is deleted.
SendSideCongestionController(const Clock* clock,
Observer* observer,
RtcEventLog* event_log,
PacketRouter* packet_router);
SendSideCongestionController(const Clock* clock,
Observer* observer,
RtcEventLog* event_log,
std::unique_ptr<PacedSender> pacer);
PacedSender* pacer);
~SendSideCongestionController() override;
void RegisterPacketFeedbackObserver(PacketFeedbackObserver* observer);
@ -91,26 +92,12 @@ class SendSideCongestionController : public CallStatsObserver,
virtual BitrateController* GetBitrateController() const;
virtual int64_t GetPacerQueuingDelayMs() const;
virtual int64_t GetFirstPacketTimeMs() const;
// TODO(nisse): Delete this accessor function. The pacer should be
// internal to the congestion controller.
virtual PacedSender* pacer();
virtual TransportFeedbackObserver* GetTransportFeedbackObserver();
RateLimiter* GetRetransmissionRateLimiter();
void EnablePeriodicAlrProbing(bool enable);
// SetAllocatedSendBitrateLimits sets bitrates limits imposed by send codec
// settings.
// |min_send_bitrate_bps| is the total minimum send bitrate required by all
// sending streams. This is the minimum bitrate the PacedSender will use.
// Note that SendSideCongestionController::OnNetworkChanged can still be
// called with a lower bitrate estimate. |max_padding_bitrate_bps| is the max
// bitrate the send streams request for padding. This can be higher than the
// current network estimate and tells the PacedSender how much it should max
// pad unless there is real packets to send.
void SetAllocatedSendBitrateLimits(int min_send_bitrate_bps,
int max_padding_bitrate_bps);
virtual void OnSentPacket(const rtc::SentPacket& sent_packet);
// Implements CallStatsObserver.
@ -141,7 +128,8 @@ class SendSideCongestionController : public CallStatsObserver,
rtc::CriticalSection observer_lock_;
Observer* observer_ GUARDED_BY(observer_lock_);
RtcEventLog* const event_log_;
const std::unique_ptr<PacedSender> pacer_;
std::unique_ptr<PacedSender> owned_pacer_;
PacedSender* pacer_;
const std::unique_ptr<BitrateController> bitrate_controller_;
std::unique_ptr<AcknowledgedBitrateEstimator> acknowledged_bitrate_estimator_;
const std::unique_ptr<ProbeController> probe_controller_;

55
webrtc/modules/congestion_controller/send_side_congestion_controller.cc
View File

@ -98,27 +98,54 @@ SendSideCongestionController::SendSideCongestionController(
Observer* observer,
RtcEventLog* event_log,
PacketRouter* packet_router)
: SendSideCongestionController(
clock,
observer,
event_log,
std::unique_ptr<PacedSender>(
new PacedSender(clock, packet_router, event_log))) {}
: clock_(clock),
observer_(observer),
event_log_(event_log),
owned_pacer_(
rtc::MakeUnique<PacedSender>(clock, packet_router, event_log)),
pacer_(owned_pacer_.get()),
bitrate_controller_(
BitrateController::CreateBitrateController(clock_, event_log)),
acknowledged_bitrate_estimator_(
rtc::MakeUnique<AcknowledgedBitrateEstimator>()),
probe_controller_(new ProbeController(pacer_, clock_)),
retransmission_rate_limiter_(
new RateLimiter(clock, kRetransmitWindowSizeMs)),
transport_feedback_adapter_(clock_),
last_reported_bitrate_bps_(0),
last_reported_fraction_loss_(0),
last_reported_rtt_(0),
network_state_(kNetworkUp),
pause_pacer_(false),
pacer_paused_(false),
min_bitrate_bps_(congestion_controller::GetMinBitrateBps()),
delay_based_bwe_(new DelayBasedBwe(event_log_, clock_)),
in_cwnd_experiment_(CwndExperimentEnabled()),
accepted_queue_ms_(kDefaultAcceptedQueueMs),
was_in_alr_(0) {
delay_based_bwe_->SetMinBitrate(min_bitrate_bps_);
if (in_cwnd_experiment_ &&
!ReadCwndExperimentParameter(&accepted_queue_ms_)) {
LOG(LS_WARNING) << "Failed to parse parameters for CwndExperiment "
"from field trial string. Experiment disabled.";
in_cwnd_experiment_ = false;
}
}
SendSideCongestionController::SendSideCongestionController(
const Clock* clock,
Observer* observer,
RtcEventLog* event_log,
std::unique_ptr<PacedSender> pacer)
PacedSender* pacer)
: clock_(clock),
observer_(observer),
event_log_(event_log),
pacer_(std::move(pacer)),
pacer_(pacer),
bitrate_controller_(
BitrateController::CreateBitrateController(clock_, event_log)),
acknowledged_bitrate_estimator_(
rtc::MakeUnique<AcknowledgedBitrateEstimator>()),
probe_controller_(new ProbeController(pacer_.get(), clock_)),
probe_controller_(new ProbeController(pacer_, clock_)),
retransmission_rate_limiter_(
new RateLimiter(clock, kRetransmitWindowSizeMs)),
transport_feedback_adapter_(clock_),
@ -229,12 +256,6 @@ void SendSideCongestionController::EnablePeriodicAlrProbing(bool enable) {
probe_controller_->EnablePeriodicAlrProbing(enable);
}
void SendSideCongestionController::SetAllocatedSendBitrateLimits(
int min_send_bitrate_bps,
int max_padding_bitrate_bps) {
pacer_->SetSendBitrateLimits(min_send_bitrate_bps, max_padding_bitrate_bps);
}
int64_t SendSideCongestionController::GetPacerQueuingDelayMs() const {
return IsNetworkDown() ? 0 : pacer_->QueueInMs();
}
@ -243,10 +264,6 @@ int64_t SendSideCongestionController::GetFirstPacketTimeMs() const {
return pacer_->FirstSentPacketTimeMs();
}
PacedSender* SendSideCongestionController::pacer() {
return pacer_.get();
}
TransportFeedbackObserver*
SendSideCongestionController::GetTransportFeedbackObserver() {
return this;

18
webrtc/modules/congestion_controller/send_side_congestion_controller_unittest.cc
View File

@ -54,10 +54,9 @@ class SendSideCongestionControllerTest : public ::testing::Test {
~SendSideCongestionControllerTest() override {}
void SetUp() override {
pacer_ = new NiceMock<MockPacedSender>();
std::unique_ptr<PacedSender> pacer(pacer_); // Passes ownership.
pacer_.reset(new NiceMock<MockPacedSender>());
controller_.reset(new SendSideCongestionController(
&clock_, &observer_, &event_log_, std::move(pacer)));
&clock_, &observer_, &event_log_, pacer_.get()));
bandwidth_observer_.reset(
controller_->GetBitrateController()->CreateRtcpBandwidthObserver());
@ -73,9 +72,9 @@ class SendSideCongestionControllerTest : public ::testing::Test {
// Custom setup - use an observer that tracks the target bitrate, without
// prescribing on which iterations it must change (like a mock would).
void TargetBitrateTrackingSetup() {
std::unique_ptr<PacedSender> pacer(new NiceMock<MockPacedSender>());
pacer_.reset(new NiceMock<MockPacedSender>());
controller_.reset(new SendSideCongestionController(
&clock_, &target_bitrate_observer_, &event_log_, std::move(pacer)));
&clock_, &target_bitrate_observer_, &event_log_, pacer_.get()));
controller_->SetBweBitrates(0, kInitialBitrateBps, 5 * kInitialBitrateBps);
}
@ -138,9 +137,10 @@ class SendSideCongestionControllerTest : public ::testing::Test {
SimulatedClock clock_;
StrictMock<MockCongestionObserver> observer_;
TargetBitrateObserver target_bitrate_observer_;
NiceMock<MockPacedSender>* pacer_;
NiceMock<MockRtcEventLog> event_log_;
std::unique_ptr<RtcpBandwidthObserver> bandwidth_observer_;
PacketRouter packet_router_;
std::unique_ptr<NiceMock<MockPacedSender>> pacer_;
std::unique_ptr<SendSideCongestionController> controller_;
rtc::Optional<uint32_t> target_bitrate_bps_;
@ -216,7 +216,7 @@ TEST_F(SendSideCongestionControllerTest, SignalNetworkState) {
TEST_F(SendSideCongestionControllerTest, OnNetworkRouteChanged) {
int new_bitrate = 200000;
testing::Mock::VerifyAndClearExpectations(pacer_);
testing::Mock::VerifyAndClearExpectations(pacer_.get());
EXPECT_CALL(observer_, OnNetworkChanged(new_bitrate, _, _, _));
EXPECT_CALL(*pacer_, SetEstimatedBitrate(new_bitrate));
rtc::NetworkRoute route;
@ -236,7 +236,7 @@ TEST_F(SendSideCongestionControllerTest, OnNetworkRouteChanged) {
TEST_F(SendSideCongestionControllerTest, OldFeedback) {
int new_bitrate = 200000;
testing::Mock::VerifyAndClearExpectations(pacer_);
testing::Mock::VerifyAndClearExpectations(pacer_.get());
EXPECT_CALL(observer_, OnNetworkChanged(new_bitrate, _, _, _));
EXPECT_CALL(*pacer_, SetEstimatedBitrate(new_bitrate));
@ -334,7 +334,7 @@ TEST_F(SendSideCongestionControllerTest, GetProbingInterval) {
}
TEST_F(SendSideCongestionControllerTest, ProbeOnRouteChange) {
testing::Mock::VerifyAndClearExpectations(pacer_);
testing::Mock::VerifyAndClearExpectations(pacer_.get());
EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 6));
EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 12));
EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps * 2, _, _, _));

1
webrtc/modules/pacing/mock/mock_paced_sender.h
View File

@ -36,6 +36,7 @@ class MockPacedSender : public PacedSender {
MOCK_CONST_METHOD0(ExpectedQueueTimeMs, int64_t());
MOCK_CONST_METHOD0(GetApplicationLimitedRegionStartTime,
rtc::Optional<int64_t>());
MOCK_METHOD0(Process, void());
};
} // namespace webrtc

1
webrtc/rtc_tools/DEPS
View File

@ -9,6 +9,7 @@ include_rules = [
"+webrtc/modules/audio_processing",
"+webrtc/modules/bitrate_controller",
"+webrtc/modules/congestion_controller",
"+webrtc/modules/pacing",
"+webrtc/modules/rtp_rtcp",
"+webrtc/system_wrappers",
"+webrtc/p2p",

4
webrtc/rtc_tools/event_log_visualizer/analyzer.cc
View File

@ -1126,8 +1126,8 @@ void EventLogAnalyzer::CreateBweSimulationGraph(Plot* plot) {
BitrateObserver observer;
RtcEventLogNullImpl null_event_log;
PacketRouter packet_router;
SendSideCongestionController cc(&clock, &observer, &null_event_log,
&packet_router);
PacedSender pacer(&clock, &packet_router, &null_event_log);
SendSideCongestionController cc(&clock, &observer, &null_event_log, &pacer);
// TODO(holmer): Log the call config and use that here instead.
static const uint32_t kDefaultStartBitrateBps = 300000;
cc.SetBweBitrates(0, kDefaultStartBitrateBps, -1);

6
webrtc/video/video_send_stream.cc
View File

@ -715,10 +715,8 @@ VideoSendStreamImpl::VideoSendStreamImpl(
}
if (alr_settings) {
transport->send_side_cc()->EnablePeriodicAlrProbing(true);
transport->send_side_cc()->pacer()->SetPacingFactor(
alr_settings->pacing_factor);
transport->send_side_cc()->pacer()->SetQueueTimeLimit(
alr_settings->max_paced_queue_time);
transport->pacer()->SetPacingFactor(alr_settings->pacing_factor);
transport->pacer()->SetQueueTimeLimit(alr_settings->max_paced_queue_time);
}
if (config_->periodic_alr_bandwidth_probing) {