blob: afec7d0094ef8d3ca21f7190cd15a9dec7edecba [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>
pbos@webrtc.org03c817e2014-07-07 10:20:35 +000014#include <map>
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +000015#include <queue>
pbos@webrtc.org03c817e2014-07-07 10:20:35 +000016#include <set>
jbauchd2a22962016-02-08 23:18:25 -080017#include <vector>
Niels Möller9d4af012017-10-31 09:54:50 +010018#include <utility>
pbos@webrtc.org03c817e2014-07-07 10:20:35 +000019
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020020#include "modules/include/module_common_types.h"
Sebastian Janssonea86bb72018-02-14 16:53:38 +000021#include "modules/pacing/alr_detector.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020022#include "modules/pacing/bitrate_prober.h"
23#include "modules/pacing/interval_budget.h"
Sebastian Janssonb5374962018-02-07 13:26:38 +010024#include "modules/pacing/round_robin_packet_queue.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020025#include "modules/utility/include/process_thread.h"
26#include "rtc_base/checks.h"
27#include "rtc_base/logging.h"
Niels Möller712048c2017-10-18 13:08:22 +020028#include "rtc_base/ptr_util.h"
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020029#include "system_wrappers/include/clock.h"
30#include "system_wrappers/include/field_trial.h"
Ilya Nikolaevskiy2ffe3e82018-01-17 19:57:24 +000031#include "system_wrappers/include/runtime_enabled_features.h"
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000032
33namespace {
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000034// Time limit in milliseconds between packet bursts.
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +000035const int64_t kMinPacketLimitMs = 5;
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +010036const int64_t kCongestedPacketIntervalMs = 500;
37const int64_t kPausedProcessIntervalMs = kCongestedPacketIntervalMs;
Sebastian Janssone5d8c572018-02-28 08:53:06 +010038const int64_t kMaxElapsedTimeMs = 2000;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000039
40// Upper cap on process interval, in case process has not been called in a long
41// time.
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +000042const int64_t kMaxIntervalTimeMs = 30;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000043
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000044} // namespace
45
46namespace webrtc {
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +000047
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
philipelc3b3f7a2017-03-29 01:23:13 -070051PacedSender::PacedSender(const Clock* clock,
52 PacketSender* packet_sender,
Sebastian Janssonb5374962018-02-07 13:26:38 +010053 RtcEventLog* event_log)
54 : PacedSender(clock,
55 packet_sender,
56 event_log,
Ilya Nikolaevskiy94065692018-03-02 12:32:05 +010057 rtc::MakeUnique<RoundRobinPacketQueue>(clock)) {}
Niels Möller9d4af012017-10-31 09:54:50 +010058
59PacedSender::PacedSender(const Clock* clock,
60 PacketSender* packet_sender,
61 RtcEventLog* event_log,
Sebastian Janssonb5374962018-02-07 13:26:38 +010062 std::unique_ptr<PacketQueueInterface> packets)
stefan@webrtc.org88e0dda2014-07-04 09:20:42 +000063 : clock_(clock),
perkjec81bcd2016-05-11 06:01:13 -070064 packet_sender_(packet_sender),
Sebastian Janssonea86bb72018-02-14 16:53:38 +000065 alr_detector_(rtc::MakeUnique<AlrDetector>(event_log)),
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000066 paused_(false),
Niels Möller712048c2017-10-18 13:08:22 +020067 media_budget_(rtc::MakeUnique<IntervalBudget>(0)),
68 padding_budget_(rtc::MakeUnique<IntervalBudget>(0)),
69 prober_(rtc::MakeUnique<BitrateProber>(event_log)),
philipelb61927c2017-02-28 07:05:23 -080070 probing_send_failure_(false),
Sebastian Janssonea86bb72018-02-14 16:53:38 +000071 estimated_bitrate_bps_(0),
72 min_send_bitrate_kbps_(0u),
73 max_padding_bitrate_kbps_(0u),
perkjec81bcd2016-05-11 06:01:13 -070074 pacing_bitrate_kbps_(0),
Sebastian Janssona1630f82018-02-21 13:39:26 +010075 time_last_process_us_(clock->TimeInMicroseconds()),
76 last_send_time_us_(clock->TimeInMicroseconds()),
asaperssonfc5e81c2017-04-19 23:28:53 -070077 first_sent_packet_ms_(-1),
Niels Möller9d4af012017-10-31 09:54:50 +010078 packets_(std::move(packets)),
sprang89c4a7e2017-06-30 13:27:40 -070079 packet_counter_(0),
Sebastian Janssonea86bb72018-02-14 16:53:38 +000080 pacing_factor_(kDefaultPaceMultiplier),
Alex Narest78609d52017-10-20 10:37:47 +020081 queue_time_limit(kMaxQueueLengthMs),
82 account_for_audio_(false) {
isheriff31687812016-10-04 08:43:09 -070083 UpdateBudgetWithElapsedTime(kMinPacketLimitMs);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000084}
85
stefan@webrtc.org89fd1e82014-07-15 16:40:38 +000086PacedSender::~PacedSender() {}
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000087
philipelfd58b612017-01-04 07:05:25 -080088void PacedSender::CreateProbeCluster(int bitrate_bps) {
kthelgason6bfe49c2017-03-30 01:14:41 -070089 rtc::CritScope cs(&critsect_);
Stefan Holmer0e3213a2017-02-08 15:19:05 +010090 prober_->CreateProbeCluster(bitrate_bps, clock_->TimeInMilliseconds());
philipeleb680ea2016-08-17 11:11:59 +020091}
92
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000093void PacedSender::Pause() {
tommi919dce22017-03-15 07:45:36 -070094 {
kthelgason6bfe49c2017-03-30 01:14:41 -070095 rtc::CritScope cs(&critsect_);
stefan9e117c5e12017-08-16 08:16:25 -070096 if (!paused_)
Mirko Bonadei675513b2017-11-09 11:09:25 +010097 RTC_LOG(LS_INFO) << "PacedSender paused.";
tommi919dce22017-03-15 07:45:36 -070098 paused_ = true;
sprangddcfb9f2017-08-16 05:38:49 -070099 packets_->SetPauseState(true, clock_->TimeInMilliseconds());
tommi919dce22017-03-15 07:45:36 -0700100 }
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100101 rtc::CritScope cs(&process_thread_lock_);
tommi919dce22017-03-15 07:45:36 -0700102 // Tell the process thread to call our TimeUntilNextProcess() method to get
103 // a new (longer) estimate for when to call Process().
104 if (process_thread_)
105 process_thread_->WakeUp(this);
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000106}
107
108void PacedSender::Resume() {
tommi919dce22017-03-15 07:45:36 -0700109 {
kthelgason6bfe49c2017-03-30 01:14:41 -0700110 rtc::CritScope cs(&critsect_);
stefan9e117c5e12017-08-16 08:16:25 -0700111 if (paused_)
Mirko Bonadei675513b2017-11-09 11:09:25 +0100112 RTC_LOG(LS_INFO) << "PacedSender resumed.";
tommi919dce22017-03-15 07:45:36 -0700113 paused_ = false;
sprangddcfb9f2017-08-16 05:38:49 -0700114 packets_->SetPauseState(false, clock_->TimeInMilliseconds());
tommi919dce22017-03-15 07:45:36 -0700115 }
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100116 rtc::CritScope cs(&process_thread_lock_);
tommi919dce22017-03-15 07:45:36 -0700117 // Tell the process thread to call our TimeUntilNextProcess() method to
118 // refresh the estimate for when to call Process().
119 if (process_thread_)
120 process_thread_->WakeUp(this);
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000121}
122
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100123void PacedSender::SetCongestionWindow(int64_t congestion_window_bytes) {
124 rtc::CritScope cs(&critsect_);
125 congestion_window_bytes_ = congestion_window_bytes;
126}
127
128void PacedSender::UpdateOutstandingData(int64_t outstanding_bytes) {
129 rtc::CritScope cs(&critsect_);
130 outstanding_bytes_ = outstanding_bytes;
131}
132
133bool PacedSender::Congested() const {
134 if (congestion_window_bytes_ == kNoCongestionWindow)
135 return false;
136 return outstanding_bytes_ >= congestion_window_bytes_;
137}
138
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000139void PacedSender::SetProbingEnabled(bool enabled) {
kthelgason6bfe49c2017-03-30 01:14:41 -0700140 rtc::CritScope cs(&critsect_);
Elad Alon44b1fa42017-10-17 14:17:54 +0200141 RTC_CHECK_EQ(0, packet_counter_);
Irfan Sheriff6e11efa2016-08-02 12:57:37 -0700142 prober_->SetEnabled(enabled);
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000143}
144
Sebastian Janssonea86bb72018-02-14 16:53:38 +0000145void PacedSender::SetEstimatedBitrate(uint32_t bitrate_bps) {
146 if (bitrate_bps == 0)
147 RTC_LOG(LS_ERROR) << "PacedSender is not designed to handle 0 bitrate.";
kthelgason6bfe49c2017-03-30 01:14:41 -0700148 rtc::CritScope cs(&critsect_);
Sebastian Janssonea86bb72018-02-14 16:53:38 +0000149 estimated_bitrate_bps_ = bitrate_bps;
150 padding_budget_->set_target_rate_kbps(
151 std::min(estimated_bitrate_bps_ / 1000, max_padding_bitrate_kbps_));
152 pacing_bitrate_kbps_ =
153 std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
154 pacing_factor_;
155 alr_detector_->SetEstimatedBitrate(bitrate_bps);
156}
157
158void PacedSender::SetSendBitrateLimits(int min_send_bitrate_bps,
159 int padding_bitrate) {
160 rtc::CritScope cs(&critsect_);
161 min_send_bitrate_kbps_ = min_send_bitrate_bps / 1000;
162 pacing_bitrate_kbps_ =
163 std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
164 pacing_factor_;
165 max_padding_bitrate_kbps_ = padding_bitrate / 1000;
166 padding_budget_->set_target_rate_kbps(
167 std::min(estimated_bitrate_bps_ / 1000, max_padding_bitrate_kbps_));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000168}
169
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100170void PacedSender::SetPacingRates(uint32_t pacing_rate_bps,
171 uint32_t padding_rate_bps) {
172 rtc::CritScope cs(&critsect_);
173 RTC_DCHECK(pacing_rate_bps > 0);
174 pacing_bitrate_kbps_ = pacing_rate_bps / 1000;
175 padding_budget_->set_target_rate_kbps(padding_rate_bps / 1000);
176}
177
Peter Boströme23e7372015-10-08 11:44:14 +0200178void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
179 uint32_t ssrc,
180 uint16_t sequence_number,
181 int64_t capture_time_ms,
182 size_t bytes,
183 bool retransmission) {
kthelgason6bfe49c2017-03-30 01:14:41 -0700184 rtc::CritScope cs(&critsect_);
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100185 RTC_DCHECK(pacing_bitrate_kbps_ > 0)
186 << "SetPacingRate must be called before InsertPacket.";
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000187
Erik Språngad113e52015-11-26 16:26:12 +0100188 int64_t now_ms = clock_->TimeInMilliseconds();
philipel4a1ec1e2016-08-15 11:51:06 -0700189 prober_->OnIncomingPacket(bytes);
Peter Boström0453ef82016-02-16 16:23:08 +0100190
sprang0a43fef2015-11-20 09:00:37 -0800191 if (capture_time_ms < 0)
Erik Språngad113e52015-11-26 16:26:12 +0100192 capture_time_ms = now_ms;
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000193
Ilya Nikolaevskiy94065692018-03-02 12:32:05 +0100194 packets_->Push(PacketQueueInterface::Packet(priority, ssrc, sequence_number,
philipel9981bd92017-09-26 17:16:06 +0200195 capture_time_ms, now_ms, bytes,
196 retransmission, packet_counter_++));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000197}
198
Alex Narest78609d52017-10-20 10:37:47 +0200199void PacedSender::SetAccountForAudioPackets(bool account_for_audio) {
200 rtc::CritScope cs(&critsect_);
201 account_for_audio_ = account_for_audio;
202}
203
pkasting@chromium.org2656bf82014-11-17 22:21:14 +0000204int64_t PacedSender::ExpectedQueueTimeMs() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700205 rtc::CritScope cs(&critsect_);
kwibergaf476c72016-11-28 15:21:39 -0800206 RTC_DCHECK_GT(pacing_bitrate_kbps_, 0);
perkjec81bcd2016-05-11 06:01:13 -0700207 return static_cast<int64_t>(packets_->SizeInBytes() * 8 /
208 pacing_bitrate_kbps_);
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000209}
210
Sebastian Janssonea86bb72018-02-14 16:53:38 +0000211rtc::Optional<int64_t> PacedSender::GetApplicationLimitedRegionStartTime()
212 const {
213 rtc::CritScope cs(&critsect_);
214 return alr_detector_->GetApplicationLimitedRegionStartTime();
215}
216
stefan@webrtc.org82462aa2014-10-23 11:57:05 +0000217size_t PacedSender::QueueSizePackets() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700218 rtc::CritScope cs(&critsect_);
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000219 return packets_->SizeInPackets();
220}
221
asaperssonfc5e81c2017-04-19 23:28:53 -0700222int64_t PacedSender::FirstSentPacketTimeMs() const {
223 rtc::CritScope cs(&critsect_);
224 return first_sent_packet_ms_;
225}
226
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000227int64_t PacedSender::QueueInMs() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700228 rtc::CritScope cs(&critsect_);
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000229
sprang0a43fef2015-11-20 09:00:37 -0800230 int64_t oldest_packet = packets_->OldestEnqueueTimeMs();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000231 if (oldest_packet == 0)
232 return 0;
233
234 return clock_->TimeInMilliseconds() - oldest_packet;
stefan@webrtc.org82462aa2014-10-23 11:57:05 +0000235}
236
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000237int64_t PacedSender::TimeUntilNextProcess() {
kthelgason6bfe49c2017-03-30 01:14:41 -0700238 rtc::CritScope cs(&critsect_);
Sebastian Janssona1630f82018-02-21 13:39:26 +0100239 int64_t elapsed_time_us =
240 clock_->TimeInMicroseconds() - time_last_process_us_;
stefan9e117c5e12017-08-16 08:16:25 -0700241 int64_t elapsed_time_ms = (elapsed_time_us + 500) / 1000;
242 // When paused we wake up every 500 ms to send a padding packet to ensure
243 // we won't get stuck in the paused state due to no feedback being received.
tommi919dce22017-03-15 07:45:36 -0700244 if (paused_)
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100245 return std::max<int64_t>(kPausedProcessIntervalMs - elapsed_time_ms, 0);
tommi919dce22017-03-15 07:45:36 -0700246
stefan@webrtc.org82462aa2014-10-23 11:57:05 +0000247 if (prober_->IsProbing()) {
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000248 int64_t ret = prober_->TimeUntilNextProbe(clock_->TimeInMilliseconds());
philipelb61927c2017-02-28 07:05:23 -0800249 if (ret > 0 || (ret == 0 && !probing_send_failure_))
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000250 return ret;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000251 }
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000252 return std::max<int64_t>(kMinPacketLimitMs - elapsed_time_ms, 0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000253}
254
pbosa26ac922016-02-25 04:50:01 -0800255void PacedSender::Process() {
stefan@webrtc.org89fd1e82014-07-15 16:40:38 +0000256 int64_t now_us = clock_->TimeInMicroseconds();
kthelgason6bfe49c2017-03-30 01:14:41 -0700257 rtc::CritScope cs(&critsect_);
Sebastian Janssona1630f82018-02-21 13:39:26 +0100258 time_last_process_us_ = now_us;
259 int64_t elapsed_time_ms = (now_us - last_send_time_us_ + 500) / 1000;
Sebastian Janssone5d8c572018-02-28 08:53:06 +0100260 if (elapsed_time_ms > kMaxElapsedTimeMs) {
261 RTC_LOG(LS_WARNING) << "Elapsed time (" << elapsed_time_ms
262 << " ms) longer than expected, limiting to "
263 << kMaxElapsedTimeMs << " ms";
264 elapsed_time_ms = kMaxElapsedTimeMs;
265 }
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100266 // When congested we send a padding packet every 500 ms to ensure we won't get
267 // stuck in the congested state due to no feedback being received.
268 // TODO(srte): Stop sending packet in paused state when pause is no longer
269 // used for congestion windows.
270 if (paused_ || Congested()) {
stefan9e117c5e12017-08-16 08:16:25 -0700271 // We can not send padding unless a normal packet has first been sent. If we
272 // do, timestamps get messed up.
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100273 if (elapsed_time_ms >= kCongestedPacketIntervalMs && packet_counter_ > 0) {
Sebastian Janssona1630f82018-02-21 13:39:26 +0100274 PacedPacketInfo pacing_info;
275 size_t bytes_sent = SendPadding(1, pacing_info);
276 alr_detector_->OnBytesSent(bytes_sent, elapsed_time_ms);
277 last_send_time_us_ = clock_->TimeInMicroseconds();
278 }
stefan9e117c5e12017-08-16 08:16:25 -0700279 return;
280 }
281
Sebastian Janssona1630f82018-02-21 13:39:26 +0100282 int target_bitrate_kbps = pacing_bitrate_kbps_;
stefan9e117c5e12017-08-16 08:16:25 -0700283 if (elapsed_time_ms > 0) {
sprang0a43fef2015-11-20 09:00:37 -0800284 size_t queue_size_bytes = packets_->SizeInBytes();
285 if (queue_size_bytes > 0) {
286 // Assuming equal size packets and input/output rate, the average packet
287 // has avg_time_left_ms left to get queue_size_bytes out of the queue, if
288 // time constraint shall be met. Determine bitrate needed for that.
Erik Språngad113e52015-11-26 16:26:12 +0100289 packets_->UpdateQueueTime(clock_->TimeInMilliseconds());
sprang0a43fef2015-11-20 09:00:37 -0800290 int64_t avg_time_left_ms = std::max<int64_t>(
sprang89c4a7e2017-06-30 13:27:40 -0700291 1, queue_time_limit - packets_->AverageQueueTimeMs());
sprang0a43fef2015-11-20 09:00:37 -0800292 int min_bitrate_needed_kbps =
293 static_cast<int>(queue_size_bytes * 8 / avg_time_left_ms);
294 if (min_bitrate_needed_kbps > target_bitrate_kbps)
295 target_bitrate_kbps = min_bitrate_needed_kbps;
296 }
297
298 media_budget_->set_target_rate_kbps(target_bitrate_kbps);
isheriff31687812016-10-04 08:43:09 -0700299 UpdateBudgetWithElapsedTime(elapsed_time_ms);
stefan@webrtc.org80865fd2013-08-09 11:31:23 +0000300 }
philipela1ed0b32016-06-01 06:31:17 -0700301
Sebastian Janssona1630f82018-02-21 13:39:26 +0100302 last_send_time_us_ = clock_->TimeInMicroseconds();
stefan9e117c5e12017-08-16 08:16:25 -0700303
philipel1a93cde2016-06-03 01:41:45 -0700304 bool is_probing = prober_->IsProbing();
philipelc7bf32a2017-02-17 03:59:43 -0800305 PacedPacketInfo pacing_info;
isheriffcc5903e2016-10-04 08:29:38 -0700306 size_t bytes_sent = 0;
307 size_t recommended_probe_size = 0;
308 if (is_probing) {
philipelc7bf32a2017-02-17 03:59:43 -0800309 pacing_info = prober_->CurrentCluster();
isheriffcc5903e2016-10-04 08:29:38 -0700310 recommended_probe_size = prober_->RecommendedMinProbeSize();
311 }
Sebastian Janssona1630f82018-02-21 13:39:26 +0100312 // The paused state is checked in the loop since SendPacket leaves the
313 // critical section allowing the paused state to be changed from other code.
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100314 while (!packets_->Empty() && !paused_ && !Congested()) {
Peter Boströme23e7372015-10-08 11:44:14 +0200315 // Since we need to release the lock in order to send, we first pop the
316 // element from the priority queue but keep it in storage, so that we can
317 // reinsert it if send fails.
Ilya Nikolaevskiy94065692018-03-02 12:32:05 +0100318 const PacketQueueInterface::Packet& packet = packets_->BeginPop();
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100319
philipelc7bf32a2017-02-17 03:59:43 -0800320 if (SendPacket(packet, pacing_info)) {
Danil Chapovalov516036f2018-02-14 10:21:27 +0000321 bytes_sent += packet.bytes;
Sebastian Janssona1630f82018-02-21 13:39:26 +0100322 // Send succeeded, remove it from the queue.
Peter Boströme23e7372015-10-08 11:44:14 +0200323 packets_->FinalizePop(packet);
isheriffcc5903e2016-10-04 08:29:38 -0700324 if (is_probing && bytes_sent > recommended_probe_size)
325 break;
Peter Boströme23e7372015-10-08 11:44:14 +0200326 } else {
327 // Send failed, put it back into the queue.
328 packets_->CancelPop(packet);
isheriffcc5903e2016-10-04 08:29:38 -0700329 break;
Peter Boströme23e7372015-10-08 11:44:14 +0200330 }
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000331 }
Peter Boströme23e7372015-10-08 11:44:14 +0200332
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100333 if (packets_->Empty() && !Congested()) {
isheriffcc5903e2016-10-04 08:29:38 -0700334 // We can not send padding unless a normal packet has first been sent. If we
335 // do, timestamps get messed up.
336 if (packet_counter_ > 0) {
337 int padding_needed =
338 static_cast<int>(is_probing ? (recommended_probe_size - bytes_sent)
339 : padding_budget_->bytes_remaining());
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100340 if (padding_needed > 0) {
philipelc7bf32a2017-02-17 03:59:43 -0800341 bytes_sent += SendPadding(padding_needed, pacing_info);
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100342 }
isheriffcc5903e2016-10-04 08:29:38 -0700343 }
perkj71ee44c2016-06-15 00:47:53 -0700344 }
philipelb61927c2017-02-28 07:05:23 -0800345 if (is_probing) {
346 probing_send_failure_ = bytes_sent == 0;
347 if (!probing_send_failure_)
348 prober_->ProbeSent(clock_->TimeInMilliseconds(), bytes_sent);
349 }
Sebastian Janssonea86bb72018-02-14 16:53:38 +0000350 alr_detector_->OnBytesSent(bytes_sent, elapsed_time_ms);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000351}
352
tommi919dce22017-03-15 07:45:36 -0700353void PacedSender::ProcessThreadAttached(ProcessThread* process_thread) {
Mirko Bonadei675513b2017-11-09 11:09:25 +0100354 RTC_LOG(LS_INFO) << "ProcessThreadAttached 0x" << std::hex << process_thread;
Sebastian Jansson439f0bc2018-02-20 10:46:39 +0100355 rtc::CritScope cs(&process_thread_lock_);
tommi919dce22017-03-15 07:45:36 -0700356 process_thread_ = process_thread;
357}
358
Ilya Nikolaevskiy94065692018-03-02 12:32:05 +0100359bool PacedSender::SendPacket(const PacketQueueInterface::Packet& packet,
philipelc7bf32a2017-02-17 03:59:43 -0800360 const PacedPacketInfo& pacing_info) {
stefan9e117c5e12017-08-16 08:16:25 -0700361 RTC_DCHECK(!paused_);
stefan099110c2017-02-01 03:57:42 -0800362 if (media_budget_->bytes_remaining() == 0 &&
philipelc7bf32a2017-02-17 03:59:43 -0800363 pacing_info.probe_cluster_id == PacedPacketInfo::kNotAProbe) {
stefan099110c2017-02-01 03:57:42 -0800364 return false;
terelius8b70faf2016-08-01 09:47:31 -0700365 }
philipelc7bf32a2017-02-17 03:59:43 -0800366
kthelgason6bfe49c2017-03-30 01:14:41 -0700367 critsect_.Leave();
perkjec81bcd2016-05-11 06:01:13 -0700368 const bool success = packet_sender_->TimeToSendPacket(
369 packet.ssrc, packet.sequence_number, packet.capture_time_ms,
philipelc7bf32a2017-02-17 03:59:43 -0800370 packet.retransmission, pacing_info);
kthelgason6bfe49c2017-03-30 01:14:41 -0700371 critsect_.Enter();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000372
Peter Boström7ecc1632016-03-02 14:22:25 +0100373 if (success) {
Sebastian Janssona1630f82018-02-21 13:39:26 +0100374 if (first_sent_packet_ms_ == -1)
375 first_sent_packet_ms_ = clock_->TimeInMilliseconds();
Alex Narest78609d52017-10-20 10:37:47 +0200376 if (packet.priority != kHighPriority || account_for_audio_) {
Peter Boström7ecc1632016-03-02 14:22:25 +0100377 // Update media bytes sent.
eladalon32040ef2017-08-02 06:29:00 -0700378 // TODO(eladalon): TimeToSendPacket() can also return |true| in some
379 // situations where nothing actually ended up being sent to the network,
380 // and we probably don't want to update the budget in such cases.
381 // https://bugs.chromium.org/p/webrtc/issues/detail?id=8052
isheriff31687812016-10-04 08:43:09 -0700382 UpdateBudgetWithBytesSent(packet.bytes);
Peter Boström7ecc1632016-03-02 14:22:25 +0100383 }
stefan@webrtc.org19a40ff2013-11-27 14:16:20 +0000384 }
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000385
386 return success;
387}
388
philipelc7bf32a2017-02-17 03:59:43 -0800389size_t PacedSender::SendPadding(size_t padding_needed,
390 const PacedPacketInfo& pacing_info) {
stefan9e117c5e12017-08-16 08:16:25 -0700391 RTC_DCHECK_GT(packet_counter_, 0);
kthelgason6bfe49c2017-03-30 01:14:41 -0700392 critsect_.Leave();
philipela1ed0b32016-06-01 06:31:17 -0700393 size_t bytes_sent =
philipelc7bf32a2017-02-17 03:59:43 -0800394 packet_sender_->TimeToSendPadding(padding_needed, pacing_info);
kthelgason6bfe49c2017-03-30 01:14:41 -0700395 critsect_.Enter();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000396
Stefan Holmer01b48882015-05-05 10:21:24 +0200397 if (bytes_sent > 0) {
isheriff31687812016-10-04 08:43:09 -0700398 UpdateBudgetWithBytesSent(bytes_sent);
Stefan Holmer01b48882015-05-05 10:21:24 +0200399 }
isheriffcc5903e2016-10-04 08:29:38 -0700400 return bytes_sent;
stefan@webrtc.org19a40ff2013-11-27 14:16:20 +0000401}
402
isheriff31687812016-10-04 08:43:09 -0700403void PacedSender::UpdateBudgetWithElapsedTime(int64_t delta_time_ms) {
Sebastian Janssona1630f82018-02-21 13:39:26 +0100404 delta_time_ms = std::min(kMaxIntervalTimeMs, delta_time_ms);
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000405 media_budget_->IncreaseBudget(delta_time_ms);
406 padding_budget_->IncreaseBudget(delta_time_ms);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000407}
isheriff31687812016-10-04 08:43:09 -0700408
409void PacedSender::UpdateBudgetWithBytesSent(size_t bytes_sent) {
Sebastian Jansson45d9c1d2018-03-09 12:48:01 +0100410 outstanding_bytes_ += bytes_sent;
isheriff31687812016-10-04 08:43:09 -0700411 media_budget_->UseBudget(bytes_sent);
412 padding_budget_->UseBudget(bytes_sent);
413}
sprang89c4a7e2017-06-30 13:27:40 -0700414
Sebastian Janssonea86bb72018-02-14 16:53:38 +0000415void PacedSender::SetPacingFactor(float pacing_factor) {
416 rtc::CritScope cs(&critsect_);
417 pacing_factor_ = pacing_factor;
418 // Make sure new padding factor is applied immediately, otherwise we need to
419 // wait for the send bitrate estimate to be updated before this takes effect.
420 SetEstimatedBitrate(estimated_bitrate_bps_);
421}
422
sprang89c4a7e2017-06-30 13:27:40 -0700423void PacedSender::SetQueueTimeLimit(int limit_ms) {
424 rtc::CritScope cs(&critsect_);
425 queue_time_limit = limit_ms;
426}
427
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000428} // namespace webrtc