Line data Source code
1 : /*
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 :
11 : #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
12 :
13 : #include <algorithm>
14 : #include <memory>
15 : #include <vector>
16 :
17 : #include "webrtc/base/checks.h"
18 : #include "webrtc/base/logging.h"
19 : #include "webrtc/base/rate_limiter.h"
20 : #include "webrtc/base/socket.h"
21 : #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
22 : #include "webrtc/modules/congestion_controller/probe_controller.h"
23 : #include "webrtc/modules/remote_bitrate_estimator/include/bwe_defines.h"
24 : #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"
26 : #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
27 :
28 : namespace webrtc {
29 : namespace {
30 :
31 : static const uint32_t kTimeOffsetSwitchThreshold = 30;
32 : static const int64_t kRetransmitWindowSizeMs = 500;
33 :
34 : // Makes sure that the bitrate and the min, max values are in valid range.
35 0 : static void ClampBitrates(int* bitrate_bps,
36 : int* min_bitrate_bps,
37 : int* max_bitrate_bps) {
38 : // TODO(holmer): We should make sure the default bitrates are set to 10 kbps,
39 : // and that we don't try to set the min bitrate to 0 from any applications.
40 : // The congestion controller should allow a min bitrate of 0.
41 0 : if (*min_bitrate_bps < congestion_controller::GetMinBitrateBps())
42 0 : *min_bitrate_bps = congestion_controller::GetMinBitrateBps();
43 0 : if (*max_bitrate_bps > 0)
44 0 : *max_bitrate_bps = std::max(*min_bitrate_bps, *max_bitrate_bps);
45 0 : if (*bitrate_bps > 0)
46 0 : *bitrate_bps = std::max(*min_bitrate_bps, *bitrate_bps);
47 0 : }
48 :
49 : class WrappingBitrateEstimator : public RemoteBitrateEstimator {
50 : public:
51 0 : WrappingBitrateEstimator(RemoteBitrateObserver* observer, Clock* clock)
52 0 : : observer_(observer),
53 : clock_(clock),
54 : crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
55 0 : rbe_(new RemoteBitrateEstimatorSingleStream(observer_, clock_)),
56 : using_absolute_send_time_(false),
57 : packets_since_absolute_send_time_(0),
58 0 : min_bitrate_bps_(congestion_controller::GetMinBitrateBps()) {}
59 :
60 0 : virtual ~WrappingBitrateEstimator() {}
61 :
62 0 : void IncomingPacket(int64_t arrival_time_ms,
63 : size_t payload_size,
64 : const RTPHeader& header) override {
65 0 : CriticalSectionScoped cs(crit_sect_.get());
66 0 : PickEstimatorFromHeader(header);
67 0 : rbe_->IncomingPacket(arrival_time_ms, payload_size, header);
68 0 : }
69 :
70 0 : void Process() override {
71 0 : CriticalSectionScoped cs(crit_sect_.get());
72 0 : rbe_->Process();
73 0 : }
74 :
75 0 : int64_t TimeUntilNextProcess() override {
76 0 : CriticalSectionScoped cs(crit_sect_.get());
77 0 : return rbe_->TimeUntilNextProcess();
78 : }
79 :
80 0 : void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override {
81 0 : CriticalSectionScoped cs(crit_sect_.get());
82 0 : rbe_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
83 0 : }
84 :
85 0 : void RemoveStream(unsigned int ssrc) override {
86 0 : CriticalSectionScoped cs(crit_sect_.get());
87 0 : rbe_->RemoveStream(ssrc);
88 0 : }
89 :
90 0 : bool LatestEstimate(std::vector<unsigned int>* ssrcs,
91 : unsigned int* bitrate_bps) const override {
92 0 : CriticalSectionScoped cs(crit_sect_.get());
93 0 : return rbe_->LatestEstimate(ssrcs, bitrate_bps);
94 : }
95 :
96 0 : void SetMinBitrate(int min_bitrate_bps) override {
97 0 : CriticalSectionScoped cs(crit_sect_.get());
98 0 : rbe_->SetMinBitrate(min_bitrate_bps);
99 0 : min_bitrate_bps_ = min_bitrate_bps;
100 0 : }
101 :
102 : private:
103 0 : void PickEstimatorFromHeader(const RTPHeader& header)
104 : EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) {
105 0 : if (header.extension.hasAbsoluteSendTime) {
106 : // If we see AST in header, switch RBE strategy immediately.
107 0 : if (!using_absolute_send_time_) {
108 0 : LOG(LS_INFO) <<
109 0 : "WrappingBitrateEstimator: Switching to absolute send time RBE.";
110 0 : using_absolute_send_time_ = true;
111 0 : PickEstimator();
112 : }
113 0 : packets_since_absolute_send_time_ = 0;
114 : } else {
115 : // When we don't see AST, wait for a few packets before going back to TOF.
116 0 : if (using_absolute_send_time_) {
117 0 : ++packets_since_absolute_send_time_;
118 0 : if (packets_since_absolute_send_time_ >= kTimeOffsetSwitchThreshold) {
119 0 : LOG(LS_INFO) << "WrappingBitrateEstimator: Switching to transmission "
120 0 : << "time offset RBE.";
121 0 : using_absolute_send_time_ = false;
122 0 : PickEstimator();
123 : }
124 : }
125 : }
126 0 : }
127 :
128 : // Instantiate RBE for Time Offset or Absolute Send Time extensions.
129 0 : void PickEstimator() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) {
130 0 : if (using_absolute_send_time_) {
131 0 : rbe_.reset(new RemoteBitrateEstimatorAbsSendTime(observer_, clock_));
132 : } else {
133 0 : rbe_.reset(new RemoteBitrateEstimatorSingleStream(observer_, clock_));
134 : }
135 0 : rbe_->SetMinBitrate(min_bitrate_bps_);
136 0 : }
137 :
138 : RemoteBitrateObserver* observer_;
139 : Clock* const clock_;
140 : std::unique_ptr<CriticalSectionWrapper> crit_sect_;
141 : std::unique_ptr<RemoteBitrateEstimator> rbe_;
142 : bool using_absolute_send_time_;
143 : uint32_t packets_since_absolute_send_time_;
144 : int min_bitrate_bps_;
145 :
146 : RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator);
147 : };
148 :
149 : } // namespace
150 :
151 0 : CongestionController::CongestionController(
152 : Clock* clock,
153 : Observer* observer,
154 : RemoteBitrateObserver* remote_bitrate_observer,
155 : RtcEventLog* event_log,
156 0 : PacketRouter* packet_router)
157 : : CongestionController(
158 : clock,
159 : observer,
160 : remote_bitrate_observer,
161 : event_log,
162 : packet_router,
163 0 : std::unique_ptr<PacedSender>(new PacedSender(clock, packet_router))) {
164 0 : }
165 :
166 0 : CongestionController::CongestionController(
167 : Clock* clock,
168 : Observer* observer,
169 : RemoteBitrateObserver* remote_bitrate_observer,
170 : RtcEventLog* event_log,
171 : PacketRouter* packet_router,
172 0 : std::unique_ptr<PacedSender> pacer)
173 : : clock_(clock),
174 : observer_(observer),
175 : packet_router_(packet_router),
176 0 : pacer_(std::move(pacer)),
177 : remote_bitrate_estimator_(
178 0 : new WrappingBitrateEstimator(remote_bitrate_observer, clock_)),
179 : // Constructed last as this object calls the provided callback on
180 : // construction.
181 : bitrate_controller_(
182 0 : BitrateController::CreateBitrateController(clock_, event_log)),
183 0 : probe_controller_(new ProbeController(pacer_.get(), clock_)),
184 : retransmission_rate_limiter_(
185 0 : new RateLimiter(clock, kRetransmitWindowSizeMs)),
186 0 : remote_estimator_proxy_(clock_, packet_router_),
187 0 : transport_feedback_adapter_(clock_, bitrate_controller_.get()),
188 0 : min_bitrate_bps_(congestion_controller::GetMinBitrateBps()),
189 : max_bitrate_bps_(0),
190 : last_reported_bitrate_bps_(0),
191 : last_reported_fraction_loss_(0),
192 : last_reported_rtt_(0),
193 0 : network_state_(kNetworkUp) {
194 0 : transport_feedback_adapter_.InitBwe();
195 0 : transport_feedback_adapter_.SetMinBitrate(min_bitrate_bps_);
196 0 : }
197 :
198 0 : CongestionController::~CongestionController() {}
199 :
200 0 : void CongestionController::OnReceivedPacket(int64_t arrival_time_ms,
201 : size_t payload_size,
202 : const RTPHeader& header) {
203 : // Send-side BWE.
204 0 : if (header.extension.hasTransportSequenceNumber) {
205 0 : remote_estimator_proxy_.IncomingPacket(arrival_time_ms, payload_size,
206 0 : header);
207 0 : return;
208 : }
209 :
210 : // Receive-side BWE.
211 0 : if (remote_bitrate_estimator_) {
212 0 : remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
213 0 : header);
214 : }
215 : }
216 :
217 0 : void CongestionController::SetBweBitrates(int min_bitrate_bps,
218 : int start_bitrate_bps,
219 : int max_bitrate_bps) {
220 0 : ClampBitrates(&start_bitrate_bps, &min_bitrate_bps, &max_bitrate_bps);
221 0 : bitrate_controller_->SetBitrates(start_bitrate_bps,
222 : min_bitrate_bps,
223 0 : max_bitrate_bps);
224 :
225 0 : probe_controller_->SetBitrates(min_bitrate_bps, start_bitrate_bps,
226 0 : max_bitrate_bps);
227 0 : max_bitrate_bps_ = max_bitrate_bps;
228 :
229 0 : if (remote_bitrate_estimator_)
230 0 : remote_bitrate_estimator_->SetMinBitrate(min_bitrate_bps);
231 0 : min_bitrate_bps_ = min_bitrate_bps;
232 0 : transport_feedback_adapter_.SetMinBitrate(min_bitrate_bps_);
233 0 : MaybeTriggerOnNetworkChanged();
234 0 : }
235 :
236 0 : void CongestionController::ResetBweAndBitrates(int bitrate_bps,
237 : int min_bitrate_bps,
238 : int max_bitrate_bps) {
239 0 : ClampBitrates(&bitrate_bps, &min_bitrate_bps, &max_bitrate_bps);
240 : // TODO(honghaiz): Recreate this object once the bitrate controller is
241 : // no longer exposed outside CongestionController.
242 0 : bitrate_controller_->ResetBitrates(bitrate_bps, min_bitrate_bps,
243 0 : max_bitrate_bps);
244 0 : min_bitrate_bps_ = min_bitrate_bps;
245 0 : max_bitrate_bps_ = max_bitrate_bps;
246 : // TODO(honghaiz): Recreate this object once the remote bitrate estimator is
247 : // no longer exposed outside CongestionController.
248 0 : if (remote_bitrate_estimator_)
249 0 : remote_bitrate_estimator_->SetMinBitrate(min_bitrate_bps);
250 :
251 0 : transport_feedback_adapter_.InitBwe();
252 0 : transport_feedback_adapter_.SetMinBitrate(min_bitrate_bps);
253 : // TODO(holmer): Trigger a new probe once mid-call probing is implemented.
254 0 : MaybeTriggerOnNetworkChanged();
255 0 : }
256 :
257 0 : BitrateController* CongestionController::GetBitrateController() const {
258 0 : return bitrate_controller_.get();
259 : }
260 :
261 0 : RemoteBitrateEstimator* CongestionController::GetRemoteBitrateEstimator(
262 : bool send_side_bwe) {
263 0 : if (send_side_bwe) {
264 0 : return &remote_estimator_proxy_;
265 : } else {
266 0 : return remote_bitrate_estimator_.get();
267 : }
268 : }
269 :
270 : TransportFeedbackObserver*
271 0 : CongestionController::GetTransportFeedbackObserver() {
272 0 : return &transport_feedback_adapter_;
273 : }
274 :
275 0 : RateLimiter* CongestionController::GetRetransmissionRateLimiter() {
276 0 : return retransmission_rate_limiter_.get();
277 : }
278 :
279 0 : void CongestionController::EnablePeriodicAlrProbing(bool enable) {
280 0 : probe_controller_->EnablePeriodicAlrProbing(enable);
281 0 : }
282 :
283 0 : void CongestionController::SetAllocatedSendBitrateLimits(
284 : int min_send_bitrate_bps,
285 : int max_padding_bitrate_bps) {
286 0 : pacer_->SetSendBitrateLimits(min_send_bitrate_bps, max_padding_bitrate_bps);
287 0 : }
288 :
289 0 : int64_t CongestionController::GetPacerQueuingDelayMs() const {
290 0 : return IsNetworkDown() ? 0 : pacer_->QueueInMs();
291 : }
292 :
293 0 : void CongestionController::SignalNetworkState(NetworkState state) {
294 0 : LOG(LS_INFO) << "SignalNetworkState "
295 0 : << (state == kNetworkUp ? "Up" : "Down");
296 0 : if (state == kNetworkUp) {
297 0 : pacer_->Resume();
298 : } else {
299 0 : pacer_->Pause();
300 : }
301 : {
302 0 : rtc::CritScope cs(&critsect_);
303 0 : network_state_ = state;
304 : }
305 0 : probe_controller_->OnNetworkStateChanged(state);
306 0 : MaybeTriggerOnNetworkChanged();
307 0 : }
308 :
309 0 : void CongestionController::SetTransportOverhead(
310 : size_t transport_overhead_bytes_per_packet) {
311 0 : transport_feedback_adapter_.SetTransportOverhead(
312 0 : transport_overhead_bytes_per_packet);
313 0 : }
314 :
315 0 : void CongestionController::OnSentPacket(const rtc::SentPacket& sent_packet) {
316 : // We're not interested in packets without an id, which may be stun packets,
317 : // etc, sent on the same transport.
318 0 : if (sent_packet.packet_id == -1)
319 0 : return;
320 0 : transport_feedback_adapter_.OnSentPacket(sent_packet.packet_id,
321 0 : sent_packet.send_time_ms);
322 : }
323 :
324 0 : void CongestionController::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) {
325 0 : remote_bitrate_estimator_->OnRttUpdate(avg_rtt_ms, max_rtt_ms);
326 0 : transport_feedback_adapter_.OnRttUpdate(avg_rtt_ms, max_rtt_ms);
327 0 : }
328 :
329 0 : int64_t CongestionController::TimeUntilNextProcess() {
330 0 : return std::min(bitrate_controller_->TimeUntilNextProcess(),
331 0 : remote_bitrate_estimator_->TimeUntilNextProcess());
332 : }
333 :
334 0 : void CongestionController::Process() {
335 0 : bitrate_controller_->Process();
336 0 : remote_bitrate_estimator_->Process();
337 0 : probe_controller_->Process();
338 0 : MaybeTriggerOnNetworkChanged();
339 0 : }
340 :
341 0 : void CongestionController::MaybeTriggerOnNetworkChanged() {
342 : // TODO(perkj): |observer_| can be nullptr if the ctor that accepts a
343 : // BitrateObserver is used. Remove this check once the ctor is removed.
344 0 : if (!observer_)
345 0 : return;
346 :
347 : uint32_t bitrate_bps;
348 : uint8_t fraction_loss;
349 : int64_t rtt;
350 0 : bool estimate_changed = bitrate_controller_->GetNetworkParameters(
351 0 : &bitrate_bps, &fraction_loss, &rtt);
352 0 : if (estimate_changed) {
353 0 : pacer_->SetEstimatedBitrate(bitrate_bps);
354 0 : probe_controller_->SetEstimatedBitrate(bitrate_bps);
355 0 : retransmission_rate_limiter_->SetMaxRate(bitrate_bps);
356 : }
357 :
358 0 : bitrate_bps = IsNetworkDown() || IsSendQueueFull() ? 0 : bitrate_bps;
359 :
360 0 : if (HasNetworkParametersToReportChanged(bitrate_bps, fraction_loss, rtt)) {
361 0 : observer_->OnNetworkChanged(
362 : bitrate_bps, fraction_loss, rtt,
363 0 : transport_feedback_adapter_.GetProbingIntervalMs());
364 0 : remote_estimator_proxy_.OnBitrateChanged(bitrate_bps);
365 : }
366 : }
367 :
368 0 : bool CongestionController::HasNetworkParametersToReportChanged(
369 : uint32_t bitrate_bps,
370 : uint8_t fraction_loss,
371 : int64_t rtt) {
372 0 : rtc::CritScope cs(&critsect_);
373 : bool changed =
374 0 : last_reported_bitrate_bps_ != bitrate_bps ||
375 0 : (bitrate_bps > 0 && (last_reported_fraction_loss_ != fraction_loss ||
376 0 : last_reported_rtt_ != rtt));
377 0 : if (changed && (last_reported_bitrate_bps_ == 0 || bitrate_bps == 0)) {
378 0 : LOG(LS_INFO) << "Bitrate estimate state changed, BWE: " << bitrate_bps
379 0 : << " bps.";
380 : }
381 0 : last_reported_bitrate_bps_ = bitrate_bps;
382 0 : last_reported_fraction_loss_ = fraction_loss;
383 0 : last_reported_rtt_ = rtt;
384 0 : return changed;
385 : }
386 :
387 0 : bool CongestionController::IsSendQueueFull() const {
388 0 : return pacer_->ExpectedQueueTimeMs() > PacedSender::kMaxQueueLengthMs;
389 : }
390 :
391 0 : bool CongestionController::IsNetworkDown() const {
392 0 : rtc::CritScope cs(&critsect_);
393 0 : return network_state_ == kNetworkDown;
394 : }
395 :
396 : } // namespace webrtc
|
