mflodman@webrtc.org | 9ec883e | 2012-03-05 17:12:41 | [diff] [blame] | 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 | |
Stefan Holmer | 80e1207 | 2016-02-23 12:30:42 | [diff] [blame] | 11 | #include "webrtc/modules/congestion_controller/include/congestion_controller.h" |
mflodman@webrtc.org | 9ec883e | 2012-03-05 17:12:41 | [diff] [blame] | 12 | |
Stefan Holmer | 62a5ccd | 2016-02-16 16:07:21 | [diff] [blame] | 13 | #include <algorithm> |
Stefan Holmer | 58c664c | 2016-02-08 13:31:30 | [diff] [blame] | 14 | #include <vector> |
| 15 | |
stefan@webrtc.org | a50e6f0 | 2015-03-09 10:06:40 | [diff] [blame] | 16 | #include "webrtc/base/checks.h" |
Peter Boström | 7c704b8 | 2015-12-04 15:13:05 | [diff] [blame] | 17 | #include "webrtc/base/logging.h" |
Stefan Holmer | 58c664c | 2016-02-08 13:31:30 | [diff] [blame] | 18 | #include "webrtc/base/socket.h" |
pbos@webrtc.org | 38344ed | 2014-09-24 06:05:00 | [diff] [blame] | 19 | #include "webrtc/base/thread_annotations.h" |
mflodman | 0e7e259 | 2015-11-13 05:02:42 | [diff] [blame] | 20 | #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h" |
Henrik Kjellander | 0b9e29c | 2015-11-16 10:12:24 | [diff] [blame] | 21 | #include "webrtc/modules/pacing/paced_sender.h" |
sprang | 867fb52 | 2015-08-03 11:38:41 | [diff] [blame] | 22 | #include "webrtc/modules/remote_bitrate_estimator/include/send_time_history.h" |
Erik Språng | 468e62a | 2015-07-06 08:50:47 | [diff] [blame] | 23 | #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_abs_send_time.h" |
| 24 | #include "webrtc/modules/remote_bitrate_estimator/remote_bitrate_estimator_single_stream.h" |
Henrik Kjellander | ff761fb | 2015-11-04 07:31:52 | [diff] [blame] | 25 | #include "webrtc/modules/utility/include/process_thread.h" |
Henrik Kjellander | 98f5351 | 2015-10-28 17:17:40 | [diff] [blame] | 26 | #include "webrtc/system_wrappers/include/critical_section_wrapper.h" |
Peter Boström | 7623ce4 | 2015-12-09 11:13:30 | [diff] [blame] | 27 | #include "webrtc/video/payload_router.h" |
mflodman@webrtc.org | 9ec883e | 2012-03-05 17:12:41 | [diff] [blame] | 28 | |
| 29 | namespace webrtc { |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 30 | namespace { |
| 31 | |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 32 | static const uint32_t kTimeOffsetSwitchThreshold = 30; |
| 33 | |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 34 | class WrappingBitrateEstimator : public RemoteBitrateEstimator { |
| 35 | public: |
pbos | ef35f06 | 2015-07-27 15:37:06 | [diff] [blame] | 36 | WrappingBitrateEstimator(RemoteBitrateObserver* observer, Clock* clock) |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 37 | : observer_(observer), |
| 38 | clock_(clock), |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 39 | crit_sect_(CriticalSectionWrapper::CreateCriticalSection()), |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 40 | rbe_(new RemoteBitrateEstimatorSingleStream(observer_, clock_)), |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 41 | using_absolute_send_time_(false), |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 42 | packets_since_absolute_send_time_(0), |
| 43 | min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps) {} |
andresp@webrtc.org | 1295dc6 | 2014-07-02 13:23:19 | [diff] [blame] | 44 | |
| 45 | virtual ~WrappingBitrateEstimator() {} |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 46 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 | [diff] [blame] | 47 | void IncomingPacket(int64_t arrival_time_ms, |
| 48 | size_t payload_size, |
Stefan Holmer | ff4ea93 | 2015-06-18 14:01:33 | [diff] [blame] | 49 | const RTPHeader& header, |
| 50 | bool was_paced) override { |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 51 | CriticalSectionScoped cs(crit_sect_.get()); |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 52 | PickEstimatorFromHeader(header); |
Stefan Holmer | ff4ea93 | 2015-06-18 14:01:33 | [diff] [blame] | 53 | rbe_->IncomingPacket(arrival_time_ms, payload_size, header, was_paced); |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 54 | } |
| 55 | |
torbjorng | da33a8a | 2016-02-25 12:34:03 | [diff] [blame^] | 56 | int32_t Process() override { |
andresp@webrtc.org | 1295dc6 | 2014-07-02 13:23:19 | [diff] [blame] | 57 | CriticalSectionScoped cs(crit_sect_.get()); |
torbjorng | da33a8a | 2016-02-25 12:34:03 | [diff] [blame^] | 58 | return rbe_->Process(); |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 59 | } |
| 60 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 | [diff] [blame] | 61 | int64_t TimeUntilNextProcess() override { |
andresp@webrtc.org | 1295dc6 | 2014-07-02 13:23:19 | [diff] [blame] | 62 | CriticalSectionScoped cs(crit_sect_.get()); |
| 63 | return rbe_->TimeUntilNextProcess(); |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 64 | } |
| 65 | |
stefan | 2328a94 | 2015-08-07 11:27:51 | [diff] [blame] | 66 | void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override { |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 67 | CriticalSectionScoped cs(crit_sect_.get()); |
stefan | 2328a94 | 2015-08-07 11:27:51 | [diff] [blame] | 68 | rbe_->OnRttUpdate(avg_rtt_ms, max_rtt_ms); |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 69 | } |
| 70 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 | [diff] [blame] | 71 | void RemoveStream(unsigned int ssrc) override { |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 72 | CriticalSectionScoped cs(crit_sect_.get()); |
| 73 | rbe_->RemoveStream(ssrc); |
| 74 | } |
| 75 | |
kjellander@webrtc.org | 14665ff | 2015-03-04 12:58:35 | [diff] [blame] | 76 | bool LatestEstimate(std::vector<unsigned int>* ssrcs, |
| 77 | unsigned int* bitrate_bps) const override { |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 78 | CriticalSectionScoped cs(crit_sect_.get()); |
| 79 | return rbe_->LatestEstimate(ssrcs, bitrate_bps); |
| 80 | } |
| 81 | |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 82 | void SetMinBitrate(int min_bitrate_bps) { |
| 83 | CriticalSectionScoped cs(crit_sect_.get()); |
| 84 | rbe_->SetMinBitrate(min_bitrate_bps); |
| 85 | min_bitrate_bps_ = min_bitrate_bps; |
| 86 | } |
| 87 | |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 88 | private: |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 89 | void PickEstimatorFromHeader(const RTPHeader& header) |
| 90 | EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) { |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 91 | if (header.extension.hasAbsoluteSendTime) { |
| 92 | // If we see AST in header, switch RBE strategy immediately. |
| 93 | if (!using_absolute_send_time_) { |
mflodman@webrtc.org | 5574dac | 2014-04-07 10:56:31 | [diff] [blame] | 94 | LOG(LS_INFO) << |
| 95 | "WrappingBitrateEstimator: Switching to absolute send time RBE."; |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 96 | using_absolute_send_time_ = true; |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 97 | PickEstimator(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 98 | } |
| 99 | packets_since_absolute_send_time_ = 0; |
| 100 | } else { |
| 101 | // When we don't see AST, wait for a few packets before going back to TOF. |
| 102 | if (using_absolute_send_time_) { |
| 103 | ++packets_since_absolute_send_time_; |
| 104 | if (packets_since_absolute_send_time_ >= kTimeOffsetSwitchThreshold) { |
mflodman@webrtc.org | 5574dac | 2014-04-07 10:56:31 | [diff] [blame] | 105 | LOG(LS_INFO) << "WrappingBitrateEstimator: Switching to transmission " |
| 106 | << "time offset RBE."; |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 107 | using_absolute_send_time_ = false; |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 108 | PickEstimator(); |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 109 | } |
| 110 | } |
| 111 | } |
| 112 | } |
| 113 | |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 114 | // Instantiate RBE for Time Offset or Absolute Send Time extensions. |
| 115 | void PickEstimator() EXCLUSIVE_LOCKS_REQUIRED(crit_sect_.get()) { |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 116 | if (using_absolute_send_time_) { |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 117 | rbe_.reset(new RemoteBitrateEstimatorAbsSendTime(observer_, clock_)); |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 118 | } else { |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 119 | rbe_.reset(new RemoteBitrateEstimatorSingleStream(observer_, clock_)); |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 120 | } |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 121 | rbe_->SetMinBitrate(min_bitrate_bps_); |
stefan@webrtc.org | a16147c | 2014-03-25 10:37:31 | [diff] [blame] | 122 | } |
| 123 | |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 124 | RemoteBitrateObserver* observer_; |
Stefan Holmer | 58c664c | 2016-02-08 13:31:30 | [diff] [blame] | 125 | Clock* const clock_; |
kwiberg@webrtc.org | 00b8f6b | 2015-02-26 14:34:55 | [diff] [blame] | 126 | rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_; |
kwiberg@webrtc.org | 00b8f6b | 2015-02-26 14:34:55 | [diff] [blame] | 127 | rtc::scoped_ptr<RemoteBitrateEstimator> rbe_; |
pbos@webrtc.org | 5ab7567 | 2013-12-16 12:24:44 | [diff] [blame] | 128 | bool using_absolute_send_time_; |
| 129 | uint32_t packets_since_absolute_send_time_; |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 130 | int min_bitrate_bps_; |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 131 | |
henrikg | 3c089d7 | 2015-09-16 12:37:44 | [diff] [blame] | 132 | RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(WrappingBitrateEstimator); |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 133 | }; |
sprang | 867fb52 | 2015-08-03 11:38:41 | [diff] [blame] | 134 | |
solenberg@webrtc.org | a6db54d | 2013-05-27 16:02:56 | [diff] [blame] | 135 | } // namespace |
mflodman@webrtc.org | 9ec883e | 2012-03-05 17:12:41 | [diff] [blame] | 136 | |
Stefan Holmer | 58c664c | 2016-02-08 13:31:30 | [diff] [blame] | 137 | CongestionController::CongestionController( |
| 138 | Clock* clock, |
Stefan Holmer | 58c664c | 2016-02-08 13:31:30 | [diff] [blame] | 139 | BitrateObserver* bitrate_observer, |
| 140 | RemoteBitrateObserver* remote_bitrate_observer) |
| 141 | : clock_(clock), |
Stefan Holmer | 58c664c | 2016-02-08 13:31:30 | [diff] [blame] | 142 | pacer_(new PacedSender(clock_, |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 143 | &packet_router_, |
| 144 | BitrateController::kDefaultStartBitrateKbps, |
| 145 | PacedSender::kDefaultPaceMultiplier * |
| 146 | BitrateController::kDefaultStartBitrateKbps, |
| 147 | 0)), |
Erik Språng | 6b8d355 | 2015-09-24 13:06:57 | [diff] [blame] | 148 | remote_bitrate_estimator_( |
Stefan Holmer | 58c664c | 2016-02-08 13:31:30 | [diff] [blame] | 149 | new WrappingBitrateEstimator(remote_bitrate_observer, clock_)), |
Stefan Holmer | e590416 | 2015-03-26 10:11:06 | [diff] [blame] | 150 | // Constructed last as this object calls the provided callback on |
| 151 | // construction. |
| 152 | bitrate_controller_( |
Stefan Holmer | 58c664c | 2016-02-08 13:31:30 | [diff] [blame] | 153 | BitrateController::CreateBitrateController(clock_, bitrate_observer)), |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 154 | remote_estimator_proxy_(clock_, &packet_router_), |
| 155 | transport_feedback_adapter_(bitrate_controller_.get(), clock_), |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 156 | min_bitrate_bps_(RemoteBitrateEstimator::kDefaultMinBitrateBps) { |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 157 | transport_feedback_adapter_.SetBitrateEstimator( |
| 158 | new RemoteBitrateEstimatorAbsSendTime(&transport_feedback_adapter_, |
| 159 | clock_)); |
| 160 | transport_feedback_adapter_.GetBitrateEstimator()->SetMinBitrate( |
| 161 | min_bitrate_bps_); |
pwestin@webrtc.org | 49888ce | 2012-04-27 05:25:53 | [diff] [blame] | 162 | } |
mflodman@webrtc.org | 9ec883e | 2012-03-05 17:12:41 | [diff] [blame] | 163 | |
mflodman | 0c478b3 | 2015-10-21 13:52:16 | [diff] [blame] | 164 | CongestionController::~CongestionController() { |
stefan@webrtc.org | a50e6f0 | 2015-03-09 10:06:40 | [diff] [blame] | 165 | } |
| 166 | |
stefan@webrtc.org | a50e6f0 | 2015-03-09 10:06:40 | [diff] [blame] | 167 | |
mflodman | 0c478b3 | 2015-10-21 13:52:16 | [diff] [blame] | 168 | void CongestionController::SetBweBitrates(int min_bitrate_bps, |
| 169 | int start_bitrate_bps, |
| 170 | int max_bitrate_bps) { |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 171 | RTC_DCHECK(config_thread_checker_.CalledOnValidThread()); |
Stefan Holmer | 62a5ccd | 2016-02-16 16:07:21 | [diff] [blame] | 172 | // TODO(holmer): We should make sure the default bitrates are set to 10 kbps, |
| 173 | // and that we don't try to set the min bitrate to 0 from any applications. |
| 174 | // The congestion controller should allow a min bitrate of 0. |
| 175 | const int kMinBitrateBps = 10000; |
| 176 | if (min_bitrate_bps < kMinBitrateBps) |
| 177 | min_bitrate_bps = kMinBitrateBps; |
| 178 | if (max_bitrate_bps > 0) |
| 179 | max_bitrate_bps = std::max(min_bitrate_bps, max_bitrate_bps); |
| 180 | if (start_bitrate_bps > 0) { |
| 181 | start_bitrate_bps = std::max(min_bitrate_bps, start_bitrate_bps); |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 182 | bitrate_controller_->SetStartBitrate(start_bitrate_bps); |
Stefan Holmer | 62a5ccd | 2016-02-16 16:07:21 | [diff] [blame] | 183 | } |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 184 | bitrate_controller_->SetMinMaxBitrate(min_bitrate_bps, max_bitrate_bps); |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 185 | if (remote_bitrate_estimator_) |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 186 | remote_bitrate_estimator_->SetMinBitrate(min_bitrate_bps); |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 187 | min_bitrate_bps_ = min_bitrate_bps; |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 188 | transport_feedback_adapter_.GetBitrateEstimator()->SetMinBitrate( |
| 189 | min_bitrate_bps_); |
stefan | 4fbd145 | 2015-09-28 10:57:14 | [diff] [blame] | 190 | } |
| 191 | |
mflodman | 0c478b3 | 2015-10-21 13:52:16 | [diff] [blame] | 192 | BitrateController* CongestionController::GetBitrateController() const { |
bjornv@webrtc.org | cb89c6f | 2012-06-05 12:25:35 | [diff] [blame] | 193 | return bitrate_controller_.get(); |
stefan@webrtc.org | f728814 | 2012-06-05 10:44:00 | [diff] [blame] | 194 | } |
| 195 | |
mflodman | 0c478b3 | 2015-10-21 13:52:16 | [diff] [blame] | 196 | RemoteBitrateEstimator* CongestionController::GetRemoteBitrateEstimator( |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 197 | bool send_side_bwe) { |
| 198 | if (send_side_bwe) { |
| 199 | return &remote_estimator_proxy_; |
| 200 | } else { |
mflodman | a20de20 | 2015-10-19 05:08:19 | [diff] [blame] | 201 | return remote_bitrate_estimator_.get(); |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 202 | } |
stefan@webrtc.org | 9354cc9 | 2012-06-07 08:10:14 | [diff] [blame] | 203 | } |
| 204 | |
mflodman | 0c478b3 | 2015-10-21 13:52:16 | [diff] [blame] | 205 | TransportFeedbackObserver* |
| 206 | CongestionController::GetTransportFeedbackObserver() { |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 207 | RTC_DCHECK(config_thread_checker_.CalledOnValidThread()); |
| 208 | return &transport_feedback_adapter_; |
mflodman | 949c2f0 | 2015-10-16 09:31:11 | [diff] [blame] | 209 | } |
| 210 | |
mflodman | 0e7e259 | 2015-11-13 05:02:42 | [diff] [blame] | 211 | void CongestionController::UpdatePacerBitrate(int bitrate_kbps, |
| 212 | int max_bitrate_kbps, |
| 213 | int min_bitrate_kbps) { |
| 214 | pacer_->UpdateBitrate(bitrate_kbps, max_bitrate_kbps, min_bitrate_kbps); |
| 215 | } |
| 216 | |
mflodman | 0c478b3 | 2015-10-21 13:52:16 | [diff] [blame] | 217 | int64_t CongestionController::GetPacerQueuingDelayMs() const { |
Stefan Holmer | e590416 | 2015-03-26 10:11:06 | [diff] [blame] | 218 | return pacer_->QueueInMs(); |
| 219 | } |
| 220 | |
mflodman | 0c478b3 | 2015-10-21 13:52:16 | [diff] [blame] | 221 | void CongestionController::SignalNetworkState(NetworkState state) { |
stefan | 457a61d | 2015-10-14 10:12:59 | [diff] [blame] | 222 | if (state == kNetworkUp) { |
| 223 | pacer_->Resume(); |
| 224 | } else { |
| 225 | pacer_->Pause(); |
| 226 | } |
| 227 | } |
| 228 | |
mflodman | 0c478b3 | 2015-10-21 13:52:16 | [diff] [blame] | 229 | void CongestionController::OnSentPacket(const rtc::SentPacket& sent_packet) { |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 230 | transport_feedback_adapter_.OnSentPacket(sent_packet.packet_id, |
| 231 | sent_packet.send_time_ms); |
stefan | c1aeaf0 | 2015-10-15 14:26:07 | [diff] [blame] | 232 | } |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 233 | |
| 234 | void CongestionController::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { |
| 235 | remote_bitrate_estimator_->OnRttUpdate(avg_rtt_ms, max_rtt_ms); |
| 236 | transport_feedback_adapter_.OnRttUpdate(avg_rtt_ms, max_rtt_ms); |
| 237 | } |
| 238 | |
| 239 | int64_t CongestionController::TimeUntilNextProcess() { |
| 240 | return std::min(bitrate_controller_->TimeUntilNextProcess(), |
| 241 | remote_bitrate_estimator_->TimeUntilNextProcess()); |
| 242 | } |
| 243 | |
torbjorng | da33a8a | 2016-02-25 12:34:03 | [diff] [blame^] | 244 | int32_t CongestionController::Process() { |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 245 | bitrate_controller_->Process(); |
| 246 | remote_bitrate_estimator_->Process(); |
torbjorng | da33a8a | 2016-02-25 12:34:03 | [diff] [blame^] | 247 | return 0; |
Stefan Holmer | 789ba92 | 2016-02-17 14:52:17 | [diff] [blame] | 248 | } |
| 249 | |
mflodman@webrtc.org | 9ec883e | 2012-03-05 17:12:41 | [diff] [blame] | 250 | } // namespace webrtc |