blob: 3e36f14740204840b0d73d0fd5e6e26f40f8fb00 [file] [log] [blame]
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +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
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020011#include "modules/pacing/paced_sender.h"
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000012
jbauchd2a22962016-02-08 23:18:25 -080013#include <algorithm>
Sebastian Jansson916ae082018-10-26 13:10:23 +020014#include <utility>
pbos@webrtc.org03c817e2014-07-07 10:20:35 +000015
Karl Wiberg918f50c2018-07-05 11:40:33 +020016#include "absl/memory/memory.h"
Yves Gerey988cc082018-10-23 12:03:01 +020017#include "logging/rtc_event_log/rtc_event_log.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020018#include "modules/pacing/bitrate_prober.h"
19#include "modules/pacing/interval_budget.h"
20#include "modules/utility/include/process_thread.h"
21#include "rtc_base/checks.h"
22#include "rtc_base/logging.h"
23#include "system_wrappers/include/clock.h"
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000024
Per Kjellander7ef34f82019-02-22 13:09:32 +010025namespace webrtc {
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000026namespace {
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000027// Time limit in milliseconds between packet bursts.
Christoffer Rodbroe2e00002018-12-20 15:46:03 +010028const int64_t kDefaultMinPacketLimitMs = 5;
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +010029const int64_t kCongestedPacketIntervalMs = 500;
30const int64_t kPausedProcessIntervalMs = kCongestedPacketIntervalMs;
Sebastian Janssone5d8c572018-02-28 08:53:06 +010031const int64_t kMaxElapsedTimeMs = 2000;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000032
33// Upper cap on process interval, in case process has not been called in a long
34// time.
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +000035const int64_t kMaxIntervalTimeMs = 30;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000036
Per Kjellander7ef34f82019-02-22 13:09:32 +010037bool IsDisabled(const WebRtcKeyValueConfig& field_trials,
38 absl::string_view key) {
39 return field_trials.Lookup(key).find("Disabled") == 0;
40}
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000041
Per Kjellander7ef34f82019-02-22 13:09:32 +010042bool IsEnabled(const WebRtcKeyValueConfig& field_trials,
43 absl::string_view key) {
44 return field_trials.Lookup(key).find("Enabled") == 0;
45}
46
47} // namespace
sprang0a43fef2015-11-20 09:00:37 -080048const int64_t PacedSender::kMaxQueueLengthMs = 2000;
Sebastian Janssonea86bb72018-02-14 16:53:38 +000049const float PacedSender::kDefaultPaceMultiplier = 2.5f;
stefan@webrtc.org88e0dda2014-07-04 09:20:42 +000050
Sebastian Janssonaa01f272019-01-30 11:28:59 +010051PacedSender::PacedSender(Clock* clock,
Erik Språnge7942432019-06-12 13:30:02 +020052 PacketRouter* packet_router,
Per Kjellander7ef34f82019-02-22 13:09:32 +010053 RtcEventLog* event_log,
54 const WebRtcKeyValueConfig* field_trials)
stefan@webrtc.org88e0dda2014-07-04 09:20:42 +000055 : clock_(clock),
Erik Språnge7942432019-06-12 13:30:02 +020056 packet_router_(packet_router),
Per Kjellander5b698732019-04-15 12:36:33 +020057 fallback_field_trials_(
58 !field_trials ? absl::make_unique<FieldTrialBasedConfig>() : nullptr),
59 field_trials_(field_trials ? field_trials : fallback_field_trials_.get()),
Per Kjellander5b698732019-04-15 12:36:33 +020060 drain_large_queues_(
61 !IsDisabled(*field_trials_, "WebRTC-Pacer-DrainQueue")),
Sebastian Janssonc235a8d2018-06-15 14:46:11 +020062 send_padding_if_silent_(
Per Kjellander5b698732019-04-15 12:36:33 +020063 IsEnabled(*field_trials_, "WebRTC-Pacer-PadInSilence")),
64 pace_audio_(!IsDisabled(*field_trials_, "WebRTC-Pacer-BlockAudio")),
Christoffer Rodbroe2e00002018-12-20 15:46:03 +010065 min_packet_limit_ms_("", kDefaultMinPacketLimitMs),
Erik Språng96816752018-09-04 18:40:19 +020066 last_timestamp_ms_(clock_->TimeInMilliseconds()),
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000067 paused_(false),
Sebastian Jansson03914462018-10-11 20:22:03 +020068 media_budget_(0),
69 padding_budget_(0),
Per Kjellander5b698732019-04-15 12:36:33 +020070 prober_(*field_trials_),
philipelb61927c2017-02-28 07:05:23 -080071 probing_send_failure_(false),
perkjec81bcd2016-05-11 06:01:13 -070072 pacing_bitrate_kbps_(0),
Sebastian Janssona1630f82018-02-21 13:39:26 +010073 time_last_process_us_(clock->TimeInMicroseconds()),
74 last_send_time_us_(clock->TimeInMicroseconds()),
asaperssonfc5e81c2017-04-19 23:28:53 -070075 first_sent_packet_ms_(-1),
Sebastian Jansson2560e2e2018-10-11 20:17:22 +020076 packets_(clock->TimeInMicroseconds()),
sprang89c4a7e2017-06-30 13:27:40 -070077 packet_counter_(0),
Alex Narest78609d52017-10-20 10:37:47 +020078 queue_time_limit(kMaxQueueLengthMs),
79 account_for_audio_(false) {
Christoffer Rodbroe2e00002018-12-20 15:46:03 +010080 if (!drain_large_queues_) {
Sebastian Jansson0601d682018-06-25 19:23:05 +020081 RTC_LOG(LS_WARNING) << "Pacer queues will not be drained,"
82 "pushback experiment must be enabled.";
Christoffer Rodbroe2e00002018-12-20 15:46:03 +010083 }
84 ParseFieldTrial({&min_packet_limit_ms_},
Per Kjellander5b698732019-04-15 12:36:33 +020085 field_trials_->Lookup("WebRTC-Pacer-MinPacketLimitMs"));
Christoffer Rodbroe2e00002018-12-20 15:46:03 +010086 UpdateBudgetWithElapsedTime(min_packet_limit_ms_);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000087}
88
stefan@webrtc.org89fd1e82014-07-15 16:40:38 +000089PacedSender::~PacedSender() {}
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000090
Piotr (Peter) Slatalac39f4622019-02-15 07:38:04 -080091void PacedSender::CreateProbeCluster(int bitrate_bps, int cluster_id) {
kthelgason6bfe49c2017-03-30 01:14:41 -070092 rtc::CritScope cs(&critsect_);
Piotr (Peter) Slatalac39f4622019-02-15 07:38:04 -080093 prober_.CreateProbeCluster(bitrate_bps, TimeMilliseconds(), cluster_id);
philipeleb680ea2016-08-17 11:11:59 +020094}
95
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000096void PacedSender::Pause() {
tommi919dce22017-03-15 07:45:36 -070097 {
kthelgason6bfe49c2017-03-30 01:14:41 -070098 rtc::CritScope cs(&critsect_);
stefan9e117c5e12017-08-16 08:16:25 -070099 if (!paused_)
Mirko Bonadei675513b2017-11-09 11:09:25 +0100100 RTC_LOG(LS_INFO) << "PacedSender paused.";
tommi919dce22017-03-15 07:45:36 -0700101 paused_ = true;
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200102 packets_.SetPauseState(true, TimeMilliseconds());
tommi919dce22017-03-15 07:45:36 -0700103 }
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100104 rtc::CritScope cs(&process_thread_lock_);
tommi919dce22017-03-15 07:45:36 -0700105 // Tell the process thread to call our TimeUntilNextProcess() method to get
106 // a new (longer) estimate for when to call Process().
107 if (process_thread_)
108 process_thread_->WakeUp(this);
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000109}
110
111void PacedSender::Resume() {
tommi919dce22017-03-15 07:45:36 -0700112 {
kthelgason6bfe49c2017-03-30 01:14:41 -0700113 rtc::CritScope cs(&critsect_);
stefan9e117c5e12017-08-16 08:16:25 -0700114 if (paused_)
Mirko Bonadei675513b2017-11-09 11:09:25 +0100115 RTC_LOG(LS_INFO) << "PacedSender resumed.";
tommi919dce22017-03-15 07:45:36 -0700116 paused_ = false;
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200117 packets_.SetPauseState(false, TimeMilliseconds());
tommi919dce22017-03-15 07:45:36 -0700118 }
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100119 rtc::CritScope cs(&process_thread_lock_);
tommi919dce22017-03-15 07:45:36 -0700120 // Tell the process thread to call our TimeUntilNextProcess() method to
121 // refresh the estimate for when to call Process().
122 if (process_thread_)
123 process_thread_->WakeUp(this);
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000124}
125
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100126void PacedSender::SetCongestionWindow(int64_t congestion_window_bytes) {
127 rtc::CritScope cs(&critsect_);
128 congestion_window_bytes_ = congestion_window_bytes;
129}
130
131void PacedSender::UpdateOutstandingData(int64_t outstanding_bytes) {
132 rtc::CritScope cs(&critsect_);
133 outstanding_bytes_ = outstanding_bytes;
134}
135
136bool PacedSender::Congested() const {
137 if (congestion_window_bytes_ == kNoCongestionWindow)
138 return false;
139 return outstanding_bytes_ >= congestion_window_bytes_;
140}
141
Erik Språng96816752018-09-04 18:40:19 +0200142int64_t PacedSender::TimeMilliseconds() const {
143 int64_t time_ms = clock_->TimeInMilliseconds();
144 if (time_ms < last_timestamp_ms_) {
145 RTC_LOG(LS_WARNING)
146 << "Non-monotonic clock behavior observed. Previous timestamp: "
147 << last_timestamp_ms_ << ", new timestamp: " << time_ms;
148 RTC_DCHECK_GE(time_ms, last_timestamp_ms_);
149 time_ms = last_timestamp_ms_;
150 }
151 last_timestamp_ms_ = time_ms;
152 return time_ms;
153}
154
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000155void PacedSender::SetProbingEnabled(bool enabled) {
kthelgason6bfe49c2017-03-30 01:14:41 -0700156 rtc::CritScope cs(&critsect_);
Elad Alon44b1fa42017-10-17 14:17:54 +0200157 RTC_CHECK_EQ(0, packet_counter_);
Sebastian Jansson03914462018-10-11 20:22:03 +0200158 prober_.SetEnabled(enabled);
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000159}
160
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100161void PacedSender::SetPacingRates(uint32_t pacing_rate_bps,
162 uint32_t padding_rate_bps) {
163 rtc::CritScope cs(&critsect_);
164 RTC_DCHECK(pacing_rate_bps > 0);
165 pacing_bitrate_kbps_ = pacing_rate_bps / 1000;
Sebastian Jansson03914462018-10-11 20:22:03 +0200166 padding_budget_.set_target_rate_kbps(padding_rate_bps / 1000);
Evan Shrubsolefee13e82019-02-26 15:25:52 +0100167
168 RTC_LOG(LS_VERBOSE) << "bwe:pacer_updated pacing_kbps="
169 << pacing_bitrate_kbps_
170 << " padding_budget_kbps=" << padding_rate_bps / 1000;
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100171}
172
Peter Boströme23e7372015-10-08 11:44:14 +0200173void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
174 uint32_t ssrc,
175 uint16_t sequence_number,
176 int64_t capture_time_ms,
177 size_t bytes,
178 bool retransmission) {
kthelgason6bfe49c2017-03-30 01:14:41 -0700179 rtc::CritScope cs(&critsect_);
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100180 RTC_DCHECK(pacing_bitrate_kbps_ > 0)
181 << "SetPacingRate must be called before InsertPacket.";
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000182
Erik Språng96816752018-09-04 18:40:19 +0200183 int64_t now_ms = TimeMilliseconds();
Sebastian Jansson03914462018-10-11 20:22:03 +0200184 prober_.OnIncomingPacket(bytes);
Peter Boström0453ef82016-02-16 16:23:08 +0100185
sprang0a43fef2015-11-20 09:00:37 -0800186 if (capture_time_ms < 0)
Erik Språngad113e52015-11-26 16:26:12 +0100187 capture_time_ms = now_ms;
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000188
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200189 packets_.Push(RoundRobinPacketQueue::Packet(
Yves Gerey665174f2018-06-19 15:03:05 +0200190 priority, ssrc, sequence_number, capture_time_ms, now_ms, bytes,
191 retransmission, packet_counter_++));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000192}
193
Alex Narest78609d52017-10-20 10:37:47 +0200194void PacedSender::SetAccountForAudioPackets(bool account_for_audio) {
195 rtc::CritScope cs(&critsect_);
196 account_for_audio_ = account_for_audio;
197}
198
pkasting@chromium.org2656bf82014-11-17 22:21:14 +0000199int64_t PacedSender::ExpectedQueueTimeMs() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700200 rtc::CritScope cs(&critsect_);
kwibergaf476c72016-11-28 15:21:39 -0800201 RTC_DCHECK_GT(pacing_bitrate_kbps_, 0);
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200202 return static_cast<int64_t>(packets_.SizeInBytes() * 8 /
perkjec81bcd2016-05-11 06:01:13 -0700203 pacing_bitrate_kbps_);
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000204}
205
stefan@webrtc.org82462aa2014-10-23 11:57:05 +0000206size_t PacedSender::QueueSizePackets() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700207 rtc::CritScope cs(&critsect_);
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200208 return packets_.SizeInPackets();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000209}
210
Christoffer Rodbroc610e262019-01-08 10:49:19 +0100211int64_t PacedSender::QueueSizeBytes() const {
212 rtc::CritScope cs(&critsect_);
213 return packets_.SizeInBytes();
214}
215
asaperssonfc5e81c2017-04-19 23:28:53 -0700216int64_t PacedSender::FirstSentPacketTimeMs() const {
217 rtc::CritScope cs(&critsect_);
218 return first_sent_packet_ms_;
219}
220
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000221int64_t PacedSender::QueueInMs() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700222 rtc::CritScope cs(&critsect_);
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000223
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200224 int64_t oldest_packet = packets_.OldestEnqueueTimeMs();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000225 if (oldest_packet == 0)
226 return 0;
227
Erik Språng96816752018-09-04 18:40:19 +0200228 return TimeMilliseconds() - oldest_packet;
stefan@webrtc.org82462aa2014-10-23 11:57:05 +0000229}
230
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000231int64_t PacedSender::TimeUntilNextProcess() {
kthelgason6bfe49c2017-03-30 01:14:41 -0700232 rtc::CritScope cs(&critsect_);
Sebastian Janssona1630f82018-02-21 13:39:26 +0100233 int64_t elapsed_time_us =
234 clock_->TimeInMicroseconds() - time_last_process_us_;
stefan9e117c5e12017-08-16 08:16:25 -0700235 int64_t elapsed_time_ms = (elapsed_time_us + 500) / 1000;
236 // When paused we wake up every 500 ms to send a padding packet to ensure
237 // we won't get stuck in the paused state due to no feedback being received.
tommi919dce22017-03-15 07:45:36 -0700238 if (paused_)
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100239 return std::max<int64_t>(kPausedProcessIntervalMs - elapsed_time_ms, 0);
tommi919dce22017-03-15 07:45:36 -0700240
Sebastian Jansson03914462018-10-11 20:22:03 +0200241 if (prober_.IsProbing()) {
242 int64_t ret = prober_.TimeUntilNextProbe(TimeMilliseconds());
philipelb61927c2017-02-28 07:05:23 -0800243 if (ret > 0 || (ret == 0 && !probing_send_failure_))
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000244 return ret;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000245 }
Christoffer Rodbroe2e00002018-12-20 15:46:03 +0100246 return std::max<int64_t>(min_packet_limit_ms_ - elapsed_time_ms, 0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000247}
248
Sebastian Jansson916ae082018-10-26 13:10:23 +0200249int64_t PacedSender::UpdateTimeAndGetElapsedMs(int64_t now_us) {
Sebastian Janssonb544f6c2018-06-04 19:02:41 +0200250 int64_t elapsed_time_ms = (now_us - time_last_process_us_ + 500) / 1000;
Sebastian Janssona1630f82018-02-21 13:39:26 +0100251 time_last_process_us_ = now_us;
Sebastian Janssone5d8c572018-02-28 08:53:06 +0100252 if (elapsed_time_ms > kMaxElapsedTimeMs) {
253 RTC_LOG(LS_WARNING) << "Elapsed time (" << elapsed_time_ms
254 << " ms) longer than expected, limiting to "
255 << kMaxElapsedTimeMs << " ms";
256 elapsed_time_ms = kMaxElapsedTimeMs;
257 }
Sebastian Jansson916ae082018-10-26 13:10:23 +0200258 return elapsed_time_ms;
259}
260
261bool PacedSender::ShouldSendKeepalive(int64_t now_us) const {
Sebastian Janssonc235a8d2018-06-15 14:46:11 +0200262 if (send_padding_if_silent_ || paused_ || Congested()) {
263 // We send a padding packet every 500 ms to ensure we won't get stuck in
264 // congested state due to no feedback being received.
Sebastian Janssonb544f6c2018-06-04 19:02:41 +0200265 int64_t elapsed_since_last_send_us = now_us - last_send_time_us_;
266 if (elapsed_since_last_send_us >= kCongestedPacketIntervalMs * 1000) {
Sebastian Jansson682c6492018-04-12 13:08:22 +0200267 // We can not send padding unless a normal packet has first been sent. If
268 // we do, timestamps get messed up.
269 if (packet_counter_ > 0) {
Sebastian Jansson916ae082018-10-26 13:10:23 +0200270 return true;
Sebastian Jansson682c6492018-04-12 13:08:22 +0200271 }
Sebastian Janssona1630f82018-02-21 13:39:26 +0100272 }
stefan9e117c5e12017-08-16 08:16:25 -0700273 }
Sebastian Jansson916ae082018-10-26 13:10:23 +0200274 return false;
275}
276
277void PacedSender::Process() {
278 rtc::CritScope cs(&critsect_);
279 int64_t now_us = clock_->TimeInMicroseconds();
280 int64_t elapsed_time_ms = UpdateTimeAndGetElapsedMs(now_us);
281 if (ShouldSendKeepalive(now_us)) {
282 critsect_.Leave();
Erik Språnge7942432019-06-12 13:30:02 +0200283 size_t bytes_sent = packet_router_->TimeToSendPadding(1, PacedPacketInfo());
Sebastian Jansson916ae082018-10-26 13:10:23 +0200284 critsect_.Enter();
285 OnPaddingSent(bytes_sent);
Sebastian Jansson916ae082018-10-26 13:10:23 +0200286 }
287
Sebastian Janssonc235a8d2018-06-15 14:46:11 +0200288 if (paused_)
289 return;
stefan9e117c5e12017-08-16 08:16:25 -0700290
291 if (elapsed_time_ms > 0) {
Sebastian Janssonc235a8d2018-06-15 14:46:11 +0200292 int target_bitrate_kbps = pacing_bitrate_kbps_;
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200293 size_t queue_size_bytes = packets_.SizeInBytes();
sprang0a43fef2015-11-20 09:00:37 -0800294 if (queue_size_bytes > 0) {
295 // Assuming equal size packets and input/output rate, the average packet
296 // has avg_time_left_ms left to get queue_size_bytes out of the queue, if
297 // time constraint shall be met. Determine bitrate needed for that.
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200298 packets_.UpdateQueueTime(TimeMilliseconds());
Sebastian Jansson0601d682018-06-25 19:23:05 +0200299 if (drain_large_queues_) {
300 int64_t avg_time_left_ms = std::max<int64_t>(
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200301 1, queue_time_limit - packets_.AverageQueueTimeMs());
Sebastian Jansson0601d682018-06-25 19:23:05 +0200302 int min_bitrate_needed_kbps =
303 static_cast<int>(queue_size_bytes * 8 / avg_time_left_ms);
Evan Shrubsolefee13e82019-02-26 15:25:52 +0100304 if (min_bitrate_needed_kbps > target_bitrate_kbps) {
Sebastian Jansson0601d682018-06-25 19:23:05 +0200305 target_bitrate_kbps = min_bitrate_needed_kbps;
Evan Shrubsolefee13e82019-02-26 15:25:52 +0100306 RTC_LOG(LS_VERBOSE) << "bwe:large_pacing_queue pacing_rate_kbps="
307 << target_bitrate_kbps;
308 }
Sebastian Jansson0601d682018-06-25 19:23:05 +0200309 }
sprang0a43fef2015-11-20 09:00:37 -0800310 }
311
Sebastian Jansson03914462018-10-11 20:22:03 +0200312 media_budget_.set_target_rate_kbps(target_bitrate_kbps);
isheriff31687812016-10-04 08:43:09 -0700313 UpdateBudgetWithElapsedTime(elapsed_time_ms);
stefan@webrtc.org80865fd2013-08-09 11:31:23 +0000314 }
philipela1ed0b32016-06-01 06:31:17 -0700315
Sebastian Jansson03914462018-10-11 20:22:03 +0200316 bool is_probing = prober_.IsProbing();
philipelc7bf32a2017-02-17 03:59:43 -0800317 PacedPacketInfo pacing_info;
isheriffcc5903e2016-10-04 08:29:38 -0700318 size_t bytes_sent = 0;
319 size_t recommended_probe_size = 0;
320 if (is_probing) {
Sebastian Jansson03914462018-10-11 20:22:03 +0200321 pacing_info = prober_.CurrentCluster();
322 recommended_probe_size = prober_.RecommendedMinProbeSize();
isheriffcc5903e2016-10-04 08:29:38 -0700323 }
Sebastian Jansson916ae082018-10-26 13:10:23 +0200324 // The paused state is checked in the loop since it leaves the critical
325 // section allowing the paused state to be changed from other code.
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200326 while (!packets_.Empty() && !paused_) {
Sebastian Jansson916ae082018-10-26 13:10:23 +0200327 const auto* packet = GetPendingPacket(pacing_info);
328 if (packet == nullptr)
329 break;
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100330
Sebastian Jansson916ae082018-10-26 13:10:23 +0200331 critsect_.Leave();
Erik Språnge7942432019-06-12 13:30:02 +0200332 RtpPacketSendResult success = packet_router_->TimeToSendPacket(
Sebastian Jansson916ae082018-10-26 13:10:23 +0200333 packet->ssrc, packet->sequence_number, packet->capture_time_ms,
334 packet->retransmission, pacing_info);
335 critsect_.Enter();
Erik Språngd2879622019-05-10 08:29:01 -0700336 if (success == RtpPacketSendResult::kSuccess ||
337 success == RtpPacketSendResult::kPacketNotFound) {
338 // Packet sent or invalid packet, remove it from queue.
339 // TODO(webrtc:8052): Don't consume media budget on kInvalid.
Sebastian Jansson916ae082018-10-26 13:10:23 +0200340 bytes_sent += packet->bytes;
Sebastian Janssona1630f82018-02-21 13:39:26 +0100341 // Send succeeded, remove it from the queue.
Mirko Bonadei05cf6be2019-01-31 21:38:12 +0100342 OnPacketSent(packet);
isheriffcc5903e2016-10-04 08:29:38 -0700343 if (is_probing && bytes_sent > recommended_probe_size)
344 break;
Peter Boströme23e7372015-10-08 11:44:14 +0200345 } else {
346 // Send failed, put it back into the queue.
Sebastian Jansson916ae082018-10-26 13:10:23 +0200347 packets_.CancelPop(*packet);
isheriffcc5903e2016-10-04 08:29:38 -0700348 break;
Peter Boströme23e7372015-10-08 11:44:14 +0200349 }
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000350 }
Peter Boströme23e7372015-10-08 11:44:14 +0200351
Sebastian Jansson60570dc2018-09-13 17:11:06 +0200352 if (packets_.Empty() && !Congested()) {
isheriffcc5903e2016-10-04 08:29:38 -0700353 // We can not send padding unless a normal packet has first been sent. If we
354 // do, timestamps get messed up.
355 if (packet_counter_ > 0) {
356 int padding_needed =
357 static_cast<int>(is_probing ? (recommended_probe_size - bytes_sent)
Sebastian Jansson03914462018-10-11 20:22:03 +0200358 : padding_budget_.bytes_remaining());
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100359 if (padding_needed > 0) {
Sebastian Jansson916ae082018-10-26 13:10:23 +0200360 critsect_.Leave();
361 size_t padding_sent =
Erik Språnge7942432019-06-12 13:30:02 +0200362 packet_router_->TimeToSendPadding(padding_needed, pacing_info);
Sebastian Jansson916ae082018-10-26 13:10:23 +0200363 critsect_.Enter();
364 bytes_sent += padding_sent;
365 OnPaddingSent(padding_sent);
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100366 }
isheriffcc5903e2016-10-04 08:29:38 -0700367 }
perkj71ee44c2016-06-15 00:47:53 -0700368 }
philipelb61927c2017-02-28 07:05:23 -0800369 if (is_probing) {
370 probing_send_failure_ = bytes_sent == 0;
371 if (!probing_send_failure_)
Sebastian Jansson03914462018-10-11 20:22:03 +0200372 prober_.ProbeSent(TimeMilliseconds(), bytes_sent);
philipelb61927c2017-02-28 07:05:23 -0800373 }
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000374}
375
tommi919dce22017-03-15 07:45:36 -0700376void PacedSender::ProcessThreadAttached(ProcessThread* process_thread) {
Karl Wiberg43432732018-05-23 11:13:31 +0200377 RTC_LOG(LS_INFO) << "ProcessThreadAttached 0x" << process_thread;
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100378 rtc::CritScope cs(&process_thread_lock_);
tommi919dce22017-03-15 07:45:36 -0700379 process_thread_ = process_thread;
380}
381
Sebastian Jansson916ae082018-10-26 13:10:23 +0200382const RoundRobinPacketQueue::Packet* PacedSender::GetPendingPacket(
383 const PacedPacketInfo& pacing_info) {
384 // Since we need to release the lock in order to send, we first pop the
385 // element from the priority queue but keep it in storage, so that we can
386 // reinsert it if send fails.
387 const RoundRobinPacketQueue::Packet* packet = &packets_.BeginPop();
388 bool audio_packet = packet->priority == kHighPriority;
Sebastian Jansson470a5ea2019-01-23 12:37:49 +0100389 bool apply_pacing = !audio_packet || pace_audio_;
Sebastian Jansson03914462018-10-11 20:22:03 +0200390 if (apply_pacing && (Congested() || (media_budget_.bytes_remaining() == 0 &&
Sebastian Janssonce4829a2018-06-15 14:47:35 +0200391 pacing_info.probe_cluster_id ==
392 PacedPacketInfo::kNotAProbe))) {
Sebastian Jansson916ae082018-10-26 13:10:23 +0200393 packets_.CancelPop(*packet);
394 return nullptr;
terelius8b70faf2016-08-01 09:47:31 -0700395 }
Sebastian Jansson916ae082018-10-26 13:10:23 +0200396 return packet;
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000397}
398
Sebastian Jansson916ae082018-10-26 13:10:23 +0200399void PacedSender::OnPacketSent(const RoundRobinPacketQueue::Packet* packet) {
400 if (first_sent_packet_ms_ == -1)
401 first_sent_packet_ms_ = TimeMilliseconds();
402 bool audio_packet = packet->priority == kHighPriority;
403 if (!audio_packet || account_for_audio_) {
404 // Update media bytes sent.
Sebastian Jansson916ae082018-10-26 13:10:23 +0200405 UpdateBudgetWithBytesSent(packet->bytes);
406 last_send_time_us_ = clock_->TimeInMicroseconds();
407 }
408 // Send succeeded, remove it from the queue.
409 packets_.FinalizePop(*packet);
410}
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000411
Sebastian Jansson916ae082018-10-26 13:10:23 +0200412void PacedSender::OnPaddingSent(size_t bytes_sent) {
Stefan Holmer01b48882015-05-05 10:21:24 +0200413 if (bytes_sent > 0) {
isheriff31687812016-10-04 08:43:09 -0700414 UpdateBudgetWithBytesSent(bytes_sent);
Stefan Holmer01b48882015-05-05 10:21:24 +0200415 }
Sebastian Janssonc235a8d2018-06-15 14:46:11 +0200416 last_send_time_us_ = clock_->TimeInMicroseconds();
stefan@webrtc.org19a40ff2013-11-27 14:16:20 +0000417}
418
isheriff31687812016-10-04 08:43:09 -0700419void PacedSender::UpdateBudgetWithElapsedTime(int64_t delta_time_ms) {
Sebastian Janssona1630f82018-02-21 13:39:26 +0100420 delta_time_ms = std::min(kMaxIntervalTimeMs, delta_time_ms);
Sebastian Jansson03914462018-10-11 20:22:03 +0200421 media_budget_.IncreaseBudget(delta_time_ms);
422 padding_budget_.IncreaseBudget(delta_time_ms);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000423}
isheriff31687812016-10-04 08:43:09 -0700424
425void PacedSender::UpdateBudgetWithBytesSent(size_t bytes_sent) {
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100426 outstanding_bytes_ += bytes_sent;
Sebastian Jansson03914462018-10-11 20:22:03 +0200427 media_budget_.UseBudget(bytes_sent);
428 padding_budget_.UseBudget(bytes_sent);
isheriff31687812016-10-04 08:43:09 -0700429}
sprang89c4a7e2017-06-30 13:27:40 -0700430
sprang89c4a7e2017-06-30 13:27:40 -0700431void PacedSender::SetQueueTimeLimit(int limit_ms) {
432 rtc::CritScope cs(&critsect_);
433 queue_time_limit = limit_ms;
434}
435
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000436} // namespace webrtc