blob: ab3a90c2ecc6ee42efedf7086e971f8fbd5edef5 [file] [log] [blame]
mflodman@webrtc.org9ec883e2012-03-05 17:12:41 +00001/*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
Stefan Holmer80e12072016-02-23 13:30:42 +010011#include "webrtc/modules/congestion_controller/include/congestion_controller.h"
mflodman@webrtc.org9ec883e2012-03-05 17:12:41 +000012
Stefan Holmer62a5ccd2016-02-16 17:07:21 +010013#include <algorithm>
kwiberg22feaa32016-03-17 09:17:43 -070014#include <memory>
Stefan Holmer58c664c2016-02-08 14:31:30 +010015#include <vector>
16
stefan@webrtc.orga50e6f02015-03-09 10:06:40 +000017#include "webrtc/base/checks.h"
kwiberg4485ffb2016-04-26 08:14:39 -070018#include "webrtc/base/constructormagic.h"
Peter Boström7c704b82015-12-04 16:13:05 +010019#include "webrtc/base/logging.h"
Stefan Holmer58c664c2016-02-08 14:31:30 +010020#include "webrtc/base/socket.h"
pbos@webrtc.org38344ed2014-09-24 06:05:00 +000021#include "webrtc/base/thread_annotations.h"
mflodman0e7e2592015-11-12 21:02:42 -080022#include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
sprang867fb522015-08-03 04:38:41 -070023#include "webrtc/modules/remote_bitrate_estimator/include/send_time_history.h"
Erik Språng468e62a2015-07-06 10:50:47 +020024#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h"
25#include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h"
Henrik Kjellanderff761fb2015-11-04 08:31:52 +010026#include "webrtc/modules/utility/include/process_thread.h"
Henrik Kjellander98f53512015-10-28 18:17:40 +010027#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
Peter Boström7623ce42015-12-09 12:13:30 +010028#include "webrtc/video/payload_router.h"
mflodman@webrtc.org9ec883e2012-03-05 17:12:41 +000029
30namespace webrtc {
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000031namespace {
32
pbos@webrtc.org5ab75672013-12-16 12:24:44 +000033static const uint32_t kTimeOffsetSwitchThreshold = 30;
34
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000035class WrappingBitrateEstimator : public RemoteBitrateEstimator {
36 public:
pbosef35f062015-07-27 08:37:06 -070037 WrappingBitrateEstimator(RemoteBitrateObserver* observer, Clock* clock)
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000038 : observer_(observer),
39 clock_(clock),
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000040 crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
stefan4fbd1452015-09-28 03:57:14 -070041 rbe_(new RemoteBitrateEstimatorSingleStream(observer_, clock_)),
pbos@webrtc.org5ab75672013-12-16 12:24:44 +000042 using_absolute_send_time_(false),
stefan4fbd1452015-09-28 03:57:14 -070043 packets_since_absolute_send_time_(0),
44 min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps) {}
andresp@webrtc.org1295dc62014-07-02 13:23:19 +000045
46 virtual ~WrappingBitrateEstimator() {}
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000047
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000048 void IncomingPacket(int64_t arrival_time_ms,
49 size_t payload_size,
Stefan Holmerff4ea932015-06-18 16:01:33 +020050 const RTPHeader& header,
51 bool was_paced) override {
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000052 CriticalSectionScoped cs(crit_sect_.get());
stefan@webrtc.orga16147c2014-03-25 10:37:31 +000053 PickEstimatorFromHeader(header);
Stefan Holmerff4ea932015-06-18 16:01:33 +020054 rbe_->IncomingPacket(arrival_time_ms, payload_size, header, was_paced);
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000055 }
56
pbosa26ac922016-02-25 04:50:01 -080057 void Process() override {
andresp@webrtc.org1295dc62014-07-02 13:23:19 +000058 CriticalSectionScoped cs(crit_sect_.get());
pbosa26ac922016-02-25 04:50:01 -080059 rbe_->Process();
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000060 }
61
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000062 int64_t TimeUntilNextProcess() override {
andresp@webrtc.org1295dc62014-07-02 13:23:19 +000063 CriticalSectionScoped cs(crit_sect_.get());
64 return rbe_->TimeUntilNextProcess();
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000065 }
66
stefan2328a942015-08-07 04:27:51 -070067 void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override {
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000068 CriticalSectionScoped cs(crit_sect_.get());
stefan2328a942015-08-07 04:27:51 -070069 rbe_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000070 }
71
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000072 void RemoveStream(unsigned int ssrc) override {
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000073 CriticalSectionScoped cs(crit_sect_.get());
74 rbe_->RemoveStream(ssrc);
75 }
76
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +000077 bool LatestEstimate(std::vector<unsigned int>* ssrcs,
78 unsigned int* bitrate_bps) const override {
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000079 CriticalSectionScoped cs(crit_sect_.get());
80 return rbe_->LatestEstimate(ssrcs, bitrate_bps);
81 }
82
nisseef8b61e2016-04-29 06:09:15 -070083 void SetMinBitrate(int min_bitrate_bps) override {
stefan4fbd1452015-09-28 03:57:14 -070084 CriticalSectionScoped cs(crit_sect_.get());
85 rbe_->SetMinBitrate(min_bitrate_bps);
86 min_bitrate_bps_ = min_bitrate_bps;
87 }
88
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +000089 private:
stefan@webrtc.orga16147c2014-03-25 10:37:31 +000090 void PickEstimatorFromHeader(const RTPHeader& header)
91 EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) {
pbos@webrtc.org5ab75672013-12-16 12:24:44 +000092 if (header.extension.hasAbsoluteSendTime) {
93 // If we see AST in header, switch RBE strategy immediately.
94 if (!using_absolute_send_time_) {
mflodman@webrtc.org5574dac2014-04-07 10:56:31 +000095 LOG(LS_INFO) <<
96 "WrappingBitrateEstimator: Switching to absolute send time RBE.";
pbos@webrtc.org5ab75672013-12-16 12:24:44 +000097 using_absolute_send_time_ = true;
stefan@webrtc.orga16147c2014-03-25 10:37:31 +000098 PickEstimator();
pbos@webrtc.org5ab75672013-12-16 12:24:44 +000099 }
100 packets_since_absolute_send_time_ = 0;
101 } else {
102 // When we don't see AST, wait for a few packets before going back to TOF.
103 if (using_absolute_send_time_) {
104 ++packets_since_absolute_send_time_;
105 if (packets_since_absolute_send_time_ >= kTimeOffsetSwitchThreshold) {
mflodman@webrtc.org5574dac2014-04-07 10:56:31 +0000106 LOG(LS_INFO) << "WrappingBitrateEstimator: Switching to transmission "
107 << "time offset RBE.";
pbos@webrtc.org5ab75672013-12-16 12:24:44 +0000108 using_absolute_send_time_ = false;
stefan@webrtc.orga16147c2014-03-25 10:37:31 +0000109 PickEstimator();
pbos@webrtc.org5ab75672013-12-16 12:24:44 +0000110 }
111 }
112 }
113 }
114
stefan@webrtc.orga16147c2014-03-25 10:37:31 +0000115 // Instantiate RBE for Time Offset or Absolute Send Time extensions.
116 void PickEstimator() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) {
stefan@webrtc.orga16147c2014-03-25 10:37:31 +0000117 if (using_absolute_send_time_) {
stefan1112b2b2016-04-14 08:08:15 -0700118 rbe_.reset(new RemoteBitrateEstimatorAbsSendTime(observer_));
stefan@webrtc.orga16147c2014-03-25 10:37:31 +0000119 } else {
stefan4fbd1452015-09-28 03:57:14 -0700120 rbe_.reset(new RemoteBitrateEstimatorSingleStream(observer_, clock_));
stefan@webrtc.orga16147c2014-03-25 10:37:31 +0000121 }
stefan4fbd1452015-09-28 03:57:14 -0700122 rbe_->SetMinBitrate(min_bitrate_bps_);
stefan@webrtc.orga16147c2014-03-25 10:37:31 +0000123 }
124
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +0000125 RemoteBitrateObserver* observer_;
Stefan Holmer58c664c2016-02-08 14:31:30 +0100126 Clock* const clock_;
kwiberg22feaa32016-03-17 09:17:43 -0700127 std::unique_ptr<CriticalSectionWrapper> crit_sect_;
128 std::unique_ptr<RemoteBitrateEstimator> rbe_;
pbos@webrtc.org5ab75672013-12-16 12:24:44 +0000129 bool using_absolute_send_time_;
130 uint32_t packets_since_absolute_send_time_;
stefan4fbd1452015-09-28 03:57:14 -0700131 int min_bitrate_bps_;
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +0000132
henrikg3c089d72015-09-16 05:37:44 -0700133 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator);
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +0000134};
sprang867fb522015-08-03 04:38:41 -0700135
solenberg@webrtc.orga6db54d2013-05-27 16:02:56 +0000136} // namespace
mflodman@webrtc.org9ec883e2012-03-05 17:12:41 +0000137
Stefan Holmer58c664c2016-02-08 14:31:30 +0100138CongestionController::CongestionController(
139 Clock* clock,
perkj825eb582016-05-04 01:08:05 -0700140 BitrateObserver* bitrate_observer,
Stefan Holmer58c664c2016-02-08 14:31:30 +0100141 RemoteBitrateObserver* remote_bitrate_observer)
142 : clock_(clock),
perkjec81bcd2016-05-11 06:01:13 -0700143 observer_(nullptr),
144 packet_router_(new PacketRouter()),
Stefan Holmer58c664c2016-02-08 14:31:30 +0100145 pacer_(new PacedSender(clock_,
perkjec81bcd2016-05-11 06:01:13 -0700146 packet_router_.get())),
147 remote_bitrate_estimator_(
148 new WrappingBitrateEstimator(remote_bitrate_observer, clock_)),
149 bitrate_controller_(
150 BitrateController::CreateBitrateController(clock_, bitrate_observer)),
151 remote_estimator_proxy_(clock_, packet_router_.get()),
152 transport_feedback_adapter_(bitrate_controller_.get(), clock_),
153 min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps),
perkj50b5c3b2016-05-12 04:53:47 -0700154 last_reported_bitrate_bps_(0),
155 last_reported_fraction_loss_(0),
156 last_reported_rtt_(0),
157 network_state_(kNetworkUp) {
perkjec81bcd2016-05-11 06:01:13 -0700158 Init();
159}
160
161CongestionController::CongestionController(
162 Clock* clock,
163 Observer* observer,
164 RemoteBitrateObserver* remote_bitrate_observer)
165 : clock_(clock),
166 observer_(observer),
167 packet_router_(new PacketRouter()),
168 pacer_(new PacedSender(clock_,
169 packet_router_.get())),
170 remote_bitrate_estimator_(
171 new WrappingBitrateEstimator(remote_bitrate_observer, clock_)),
172 bitrate_controller_(BitrateController::CreateBitrateController(clock_)),
173 remote_estimator_proxy_(clock_, packet_router_.get()),
174 transport_feedback_adapter_(bitrate_controller_.get(), clock_),
175 min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps),
perkj50b5c3b2016-05-12 04:53:47 -0700176 last_reported_bitrate_bps_(0),
177 last_reported_fraction_loss_(0),
178 last_reported_rtt_(0),
179 network_state_(kNetworkUp) {
perkjec81bcd2016-05-11 06:01:13 -0700180 Init();
181}
182
183CongestionController::CongestionController(
184 Clock* clock,
185 Observer* observer,
186 RemoteBitrateObserver* remote_bitrate_observer,
187 std::unique_ptr<PacketRouter> packet_router,
188 std::unique_ptr<PacedSender> pacer)
189 : clock_(clock),
190 observer_(observer),
191 packet_router_(std::move(packet_router)),
192 pacer_(std::move(pacer)),
Erik Språng6b8d3552015-09-24 15:06:57 +0200193 remote_bitrate_estimator_(
Stefan Holmer58c664c2016-02-08 14:31:30 +0100194 new WrappingBitrateEstimator(remote_bitrate_observer, clock_)),
Stefan Holmere5904162015-03-26 11:11:06 +0100195 // Constructed last as this object calls the provided callback on
196 // construction.
perkjec81bcd2016-05-11 06:01:13 -0700197 bitrate_controller_(BitrateController::CreateBitrateController(clock_)),
198 remote_estimator_proxy_(clock_, packet_router_.get()),
Stefan Holmer789ba922016-02-17 15:52:17 +0100199 transport_feedback_adapter_(bitrate_controller_.get(), clock_),
perkjec81bcd2016-05-11 06:01:13 -0700200 min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps),
perkj50b5c3b2016-05-12 04:53:47 -0700201 last_reported_bitrate_bps_(0),
202 last_reported_fraction_loss_(0),
203 last_reported_rtt_(0),
204 network_state_(kNetworkUp) {
perkjec81bcd2016-05-11 06:01:13 -0700205 Init();
206}
207
208CongestionController::~CongestionController() {}
209
210void CongestionController::Init() {
Stefan Holmer789ba922016-02-17 15:52:17 +0100211 transport_feedback_adapter_.SetBitrateEstimator(
stefan1112b2b2016-04-14 08:08:15 -0700212 new RemoteBitrateEstimatorAbsSendTime(&transport_feedback_adapter_));
Stefan Holmer789ba922016-02-17 15:52:17 +0100213 transport_feedback_adapter_.GetBitrateEstimator()->SetMinBitrate(
214 min_bitrate_bps_);
perkje30c2722016-05-09 04:57:11 -0700215}
216
stefan@webrtc.orga50e6f02015-03-09 10:06:40 +0000217
mflodman0c478b32015-10-21 15:52:16 +0200218void CongestionController::SetBweBitrates(int min_bitrate_bps,
219 int start_bitrate_bps,
220 int max_bitrate_bps) {
Stefan Holmer62a5ccd2016-02-16 17:07:21 +0100221 // TODO(holmer): We should make sure the default bitrates are set to 10 kbps,
222 // and that we don't try to set the min bitrate to 0 from any applications.
223 // The congestion controller should allow a min bitrate of 0.
224 const int kMinBitrateBps = 10000;
225 if (min_bitrate_bps < kMinBitrateBps)
226 min_bitrate_bps = kMinBitrateBps;
227 if (max_bitrate_bps > 0)
228 max_bitrate_bps = std::max(min_bitrate_bps, max_bitrate_bps);
philipelc6957c72016-04-28 15:52:49 +0200229 if (start_bitrate_bps > 0)
Stefan Holmer62a5ccd2016-02-16 17:07:21 +0100230 start_bitrate_bps = std::max(min_bitrate_bps, start_bitrate_bps);
philipelc6957c72016-04-28 15:52:49 +0200231
232 bitrate_controller_->SetBitrates(start_bitrate_bps,
233 min_bitrate_bps,
234 max_bitrate_bps);
235
Stefan Holmer789ba922016-02-17 15:52:17 +0100236 if (remote_bitrate_estimator_)
stefan4fbd1452015-09-28 03:57:14 -0700237 remote_bitrate_estimator_->SetMinBitrate(min_bitrate_bps);
stefan4fbd1452015-09-28 03:57:14 -0700238 min_bitrate_bps_ = min_bitrate_bps;
Stefan Holmer789ba922016-02-17 15:52:17 +0100239 transport_feedback_adapter_.GetBitrateEstimator()->SetMinBitrate(
240 min_bitrate_bps_);
perkjec81bcd2016-05-11 06:01:13 -0700241 MaybeTriggerOnNetworkChanged();
stefan4fbd1452015-09-28 03:57:14 -0700242}
243
mflodman0c478b32015-10-21 15:52:16 +0200244BitrateController* CongestionController::GetBitrateController() const {
bjornv@webrtc.orgcb89c6f2012-06-05 12:25:35 +0000245 return bitrate_controller_.get();
stefan@webrtc.orgf7288142012-06-05 10:44:00 +0000246}
247
mflodman0c478b32015-10-21 15:52:16 +0200248RemoteBitrateEstimator* CongestionController::GetRemoteBitrateEstimator(
Stefan Holmer789ba922016-02-17 15:52:17 +0100249 bool send_side_bwe) {
250 if (send_side_bwe) {
251 return &remote_estimator_proxy_;
252 } else {
mflodmana20de202015-10-18 22:08:19 -0700253 return remote_bitrate_estimator_.get();
Stefan Holmer789ba922016-02-17 15:52:17 +0100254 }
stefan@webrtc.org9354cc92012-06-07 08:10:14 +0000255}
256
mflodman0c478b32015-10-21 15:52:16 +0200257TransportFeedbackObserver*
258CongestionController::GetTransportFeedbackObserver() {
Stefan Holmer789ba922016-02-17 15:52:17 +0100259 return &transport_feedback_adapter_;
mflodman949c2f02015-10-16 02:31:11 -0700260}
261
perkjec81bcd2016-05-11 06:01:13 -0700262void CongestionController::SetAllocatedSendBitrate(int allocated_bitrate_bps,
263 int padding_bitrate_bps) {
264 pacer_->SetAllocatedSendBitrate(allocated_bitrate_bps, padding_bitrate_bps);
mflodman0e7e2592015-11-12 21:02:42 -0800265}
266
mflodman0c478b32015-10-21 15:52:16 +0200267int64_t CongestionController::GetPacerQueuingDelayMs() const {
Stefan Holmere5904162015-03-26 11:11:06 +0100268 return pacer_->QueueInMs();
269}
270
mflodman0c478b32015-10-21 15:52:16 +0200271void CongestionController::SignalNetworkState(NetworkState state) {
stefan457a61d2015-10-14 03:12:59 -0700272 if (state == kNetworkUp) {
273 pacer_->Resume();
274 } else {
275 pacer_->Pause();
276 }
perkj50b5c3b2016-05-12 04:53:47 -0700277 {
278 rtc::CritScope cs(&critsect_);
279 network_state_ = state;
280 }
281 MaybeTriggerOnNetworkChanged();
stefan457a61d2015-10-14 03:12:59 -0700282}
283
mflodman0c478b32015-10-21 15:52:16 +0200284void CongestionController::OnSentPacket(const rtc::SentPacket& sent_packet) {
Stefan Holmer789ba922016-02-17 15:52:17 +0100285 transport_feedback_adapter_.OnSentPacket(sent_packet.packet_id,
286 sent_packet.send_time_ms);
stefanc1aeaf02015-10-15 07:26:07 -0700287}
Stefan Holmer789ba922016-02-17 15:52:17 +0100288
289void CongestionController::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
290 remote_bitrate_estimator_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
291 transport_feedback_adapter_.OnRttUpdate(avg_rtt_ms, max_rtt_ms);
292}
293
294int64_t CongestionController::TimeUntilNextProcess() {
295 return std::min(bitrate_controller_->TimeUntilNextProcess(),
296 remote_bitrate_estimator_->TimeUntilNextProcess());
297}
298
pbosa26ac922016-02-25 04:50:01 -0800299void CongestionController::Process() {
Stefan Holmer789ba922016-02-17 15:52:17 +0100300 bitrate_controller_->Process();
301 remote_bitrate_estimator_->Process();
perkjec81bcd2016-05-11 06:01:13 -0700302 MaybeTriggerOnNetworkChanged();
303}
304
305void CongestionController::MaybeTriggerOnNetworkChanged() {
306 // TODO(perkj): |observer_| can be nullptr if the ctor that accepts a
307 // BitrateObserver is used. Remove this check once the ctor is removed.
308 if (!observer_)
309 return;
310
311 uint32_t bitrate_bps;
312 uint8_t fraction_loss;
313 int64_t rtt;
perkj50b5c3b2016-05-12 04:53:47 -0700314 bool estimate_changed = bitrate_controller_->GetNetworkParameters(
perkjec81bcd2016-05-11 06:01:13 -0700315 &bitrate_bps, &fraction_loss, &rtt);
perkj50b5c3b2016-05-12 04:53:47 -0700316 if (estimate_changed)
perkjec81bcd2016-05-11 06:01:13 -0700317 pacer_->SetEstimatedBitrate(bitrate_bps);
perkj50b5c3b2016-05-12 04:53:47 -0700318
319 bitrate_bps = IsNetworkDown() || IsSendQueueFull() ? 0 : bitrate_bps;
320
321 if (HasNetworkParametersToReportChanged(bitrate_bps, fraction_loss, rtt)) {
perkjec81bcd2016-05-11 06:01:13 -0700322 observer_->OnNetworkChanged(bitrate_bps, fraction_loss, rtt);
323 }
324}
325
perkj50b5c3b2016-05-12 04:53:47 -0700326bool CongestionController::HasNetworkParametersToReportChanged(
327 uint32_t bitrate_bps,
328 uint8_t fraction_loss,
329 int64_t rtt) {
perkjec81bcd2016-05-11 06:01:13 -0700330 rtc::CritScope cs(&critsect_);
perkj50b5c3b2016-05-12 04:53:47 -0700331 bool changed =
332 last_reported_bitrate_bps_ != bitrate_bps ||
333 (bitrate_bps > 0 && (last_reported_fraction_loss_ != fraction_loss ||
334 last_reported_rtt_ != rtt));
335 last_reported_bitrate_bps_ = bitrate_bps;
336 last_reported_fraction_loss_ = fraction_loss;
337 last_reported_rtt_ = rtt;
338 return changed;
339}
340
341bool CongestionController::IsSendQueueFull() const {
342 return pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs;
343}
344
345bool CongestionController::IsNetworkDown() const {
346 rtc::CritScope cs(&critsect_);
347 return network_state_ == kNetworkDown;
Stefan Holmer789ba922016-02-17 15:52:17 +0100348}
349
mflodman@webrtc.org9ec883e2012-03-05 17:12:41 +0000350} // namespace webrtc