blob: ffc8cf3777862e9f290f3d3daf410f236519a763 [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>
pbos@webrtc.org03c817e2014-07-07 10:20:35 +000018
Mirko Bonadei92ea95e2017-09-15 06:47:31 +020019#include "modules/include/module_common_types.h"
20#include "modules/pacing/alr_detector.h"
21#include "modules/pacing/bitrate_prober.h"
22#include "modules/pacing/interval_budget.h"
23#include "modules/utility/include/process_thread.h"
24#include "rtc_base/checks.h"
25#include "rtc_base/logging.h"
26#include "system_wrappers/include/clock.h"
27#include "system_wrappers/include/field_trial.h"
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000028
29namespace {
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000030// Time limit in milliseconds between packet bursts.
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +000031const int64_t kMinPacketLimitMs = 5;
stefan9e117c5e12017-08-16 08:16:25 -070032const int64_t kPausedPacketIntervalMs = 500;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000033
34// Upper cap on process interval, in case process has not been called in a long
35// time.
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +000036const int64_t kMaxIntervalTimeMs = 30;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000037
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000038} // namespace
39
40namespace webrtc {
pwestin@webrtc.org52aa0192013-04-25 17:35:56 +000041
sprang0a43fef2015-11-20 09:00:37 -080042const int64_t PacedSender::kMaxQueueLengthMs = 2000;
stefan@webrtc.org88e0dda2014-07-04 09:20:42 +000043const float PacedSender::kDefaultPaceMultiplier = 2.5f;
44
philipelc3b3f7a2017-03-29 01:23:13 -070045PacedSender::PacedSender(const Clock* clock,
46 PacketSender* packet_sender,
47 RtcEventLog* event_log)
stefan@webrtc.org88e0dda2014-07-04 09:20:42 +000048 : clock_(clock),
perkjec81bcd2016-05-11 06:01:13 -070049 packet_sender_(packet_sender),
isheriff31687812016-10-04 08:43:09 -070050 alr_detector_(new AlrDetector()),
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000051 paused_(false),
tschumim82c55932017-07-11 06:56:04 -070052 media_budget_(new IntervalBudget(0)),
53 padding_budget_(new IntervalBudget(0)),
philipelc3b3f7a2017-03-29 01:23:13 -070054 prober_(new BitrateProber(event_log)),
philipelb61927c2017-02-28 07:05:23 -080055 probing_send_failure_(false),
perkjec81bcd2016-05-11 06:01:13 -070056 estimated_bitrate_bps_(0),
57 min_send_bitrate_kbps_(0u),
perkj71ee44c2016-06-15 00:47:53 -070058 max_padding_bitrate_kbps_(0u),
perkjec81bcd2016-05-11 06:01:13 -070059 pacing_bitrate_kbps_(0),
stefan@webrtc.org89fd1e82014-07-15 16:40:38 +000060 time_last_update_us_(clock->TimeInMicroseconds()),
asaperssonfc5e81c2017-04-19 23:28:53 -070061 first_sent_packet_ms_(-1),
philipel9981bd92017-09-26 17:16:06 +020062 packets_(new PacketQueue(clock)),
sprang89c4a7e2017-06-30 13:27:40 -070063 packet_counter_(0),
64 pacing_factor_(kDefaultPaceMultiplier),
Alex Naresta5fbc232017-10-18 18:31:07 +020065 queue_time_limit(kMaxQueueLengthMs),
66 account_for_audio_(false) {
isheriff31687812016-10-04 08:43:09 -070067 UpdateBudgetWithElapsedTime(kMinPacketLimitMs);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000068}
69
stefan@webrtc.org89fd1e82014-07-15 16:40:38 +000070PacedSender::~PacedSender() {}
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +000071
philipelfd58b612017-01-04 07:05:25 -080072void PacedSender::CreateProbeCluster(int bitrate_bps) {
kthelgason6bfe49c2017-03-30 01:14:41 -070073 rtc::CritScope cs(&critsect_);
Stefan Holmer0e3213a2017-02-08 15:19:05 +010074 prober_->CreateProbeCluster(bitrate_bps, clock_->TimeInMilliseconds());
philipeleb680ea2016-08-17 11:11:59 +020075}
76
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000077void PacedSender::Pause() {
tommi919dce22017-03-15 07:45:36 -070078 {
kthelgason6bfe49c2017-03-30 01:14:41 -070079 rtc::CritScope cs(&critsect_);
stefan9e117c5e12017-08-16 08:16:25 -070080 if (!paused_)
81 LOG(LS_INFO) << "PacedSender paused.";
tommi919dce22017-03-15 07:45:36 -070082 paused_ = true;
sprangddcfb9f2017-08-16 05:38:49 -070083 packets_->SetPauseState(true, clock_->TimeInMilliseconds());
tommi919dce22017-03-15 07:45:36 -070084 }
85 // Tell the process thread to call our TimeUntilNextProcess() method to get
86 // a new (longer) estimate for when to call Process().
87 if (process_thread_)
88 process_thread_->WakeUp(this);
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +000089}
90
91void PacedSender::Resume() {
tommi919dce22017-03-15 07:45:36 -070092 {
kthelgason6bfe49c2017-03-30 01:14:41 -070093 rtc::CritScope cs(&critsect_);
stefan9e117c5e12017-08-16 08:16:25 -070094 if (paused_)
95 LOG(LS_INFO) << "PacedSender resumed.";
tommi919dce22017-03-15 07:45:36 -070096 paused_ = false;
sprangddcfb9f2017-08-16 05:38:49 -070097 packets_->SetPauseState(false, clock_->TimeInMilliseconds());
tommi919dce22017-03-15 07:45:36 -070098 }
99 // Tell the process thread to call our TimeUntilNextProcess() method to
100 // refresh the estimate for when to call Process().
101 if (process_thread_)
102 process_thread_->WakeUp(this);
pwestin@webrtc.orgdb418562013-03-22 23:39:29 +0000103}
104
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000105void PacedSender::SetProbingEnabled(bool enabled) {
kthelgason6bfe49c2017-03-30 01:14:41 -0700106 rtc::CritScope cs(&critsect_);
Elad Alon44b1fa42017-10-17 14:17:54 +0200107 RTC_CHECK_EQ(0, packet_counter_);
Irfan Sheriff6e11efa2016-08-02 12:57:37 -0700108 prober_->SetEnabled(enabled);
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000109}
110
perkjec81bcd2016-05-11 06:01:13 -0700111void PacedSender::SetEstimatedBitrate(uint32_t bitrate_bps) {
terelius8b70faf2016-08-01 09:47:31 -0700112 if (bitrate_bps == 0)
113 LOG(LS_ERROR) << "PacedSender is not designed to handle 0 bitrate.";
kthelgason6bfe49c2017-03-30 01:14:41 -0700114 rtc::CritScope cs(&critsect_);
perkjec81bcd2016-05-11 06:01:13 -0700115 estimated_bitrate_bps_ = bitrate_bps;
perkj71ee44c2016-06-15 00:47:53 -0700116 padding_budget_->set_target_rate_kbps(
117 std::min(estimated_bitrate_bps_ / 1000, max_padding_bitrate_kbps_));
perkjec81bcd2016-05-11 06:01:13 -0700118 pacing_bitrate_kbps_ =
119 std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
sprang89c4a7e2017-06-30 13:27:40 -0700120 pacing_factor_;
isheriff31687812016-10-04 08:43:09 -0700121 alr_detector_->SetEstimatedBitrate(bitrate_bps);
perkjec81bcd2016-05-11 06:01:13 -0700122}
123
perkj71ee44c2016-06-15 00:47:53 -0700124void PacedSender::SetSendBitrateLimits(int min_send_bitrate_bps,
125 int padding_bitrate) {
kthelgason6bfe49c2017-03-30 01:14:41 -0700126 rtc::CritScope cs(&critsect_);
perkj71ee44c2016-06-15 00:47:53 -0700127 min_send_bitrate_kbps_ = min_send_bitrate_bps / 1000;
perkjec81bcd2016-05-11 06:01:13 -0700128 pacing_bitrate_kbps_ =
129 std::max(min_send_bitrate_kbps_, estimated_bitrate_bps_ / 1000) *
sprang89c4a7e2017-06-30 13:27:40 -0700130 pacing_factor_;
perkj71ee44c2016-06-15 00:47:53 -0700131 max_padding_bitrate_kbps_ = padding_bitrate / 1000;
132 padding_budget_->set_target_rate_kbps(
133 std::min(estimated_bitrate_bps_ / 1000, max_padding_bitrate_kbps_));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000134}
135
Peter Boströme23e7372015-10-08 11:44:14 +0200136void PacedSender::InsertPacket(RtpPacketSender::Priority priority,
137 uint32_t ssrc,
138 uint16_t sequence_number,
139 int64_t capture_time_ms,
140 size_t bytes,
141 bool retransmission) {
kthelgason6bfe49c2017-03-30 01:14:41 -0700142 rtc::CritScope cs(&critsect_);
perkjec81bcd2016-05-11 06:01:13 -0700143 RTC_DCHECK(estimated_bitrate_bps_ > 0)
144 << "SetEstimatedBitrate must be called before InsertPacket.";
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000145
Erik Språngad113e52015-11-26 16:26:12 +0100146 int64_t now_ms = clock_->TimeInMilliseconds();
philipel4a1ec1e2016-08-15 11:51:06 -0700147 prober_->OnIncomingPacket(bytes);
Peter Boström0453ef82016-02-16 16:23:08 +0100148
sprang0a43fef2015-11-20 09:00:37 -0800149 if (capture_time_ms < 0)
Erik Språngad113e52015-11-26 16:26:12 +0100150 capture_time_ms = now_ms;
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000151
philipel9981bd92017-09-26 17:16:06 +0200152 packets_->Push(PacketQueue::Packet(priority, ssrc, sequence_number,
153 capture_time_ms, now_ms, bytes,
154 retransmission, packet_counter_++));
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000155}
156
Alex Naresta5fbc232017-10-18 18:31:07 +0200157void PacedSender::SetAccountForAudioPackets(bool account_for_audio) {
158 rtc::CritScope cs(&critsect_);
159 account_for_audio_ = account_for_audio;
160}
161
pkasting@chromium.org2656bf82014-11-17 22:21:14 +0000162int64_t PacedSender::ExpectedQueueTimeMs() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700163 rtc::CritScope cs(&critsect_);
kwibergaf476c72016-11-28 15:21:39 -0800164 RTC_DCHECK_GT(pacing_bitrate_kbps_, 0);
perkjec81bcd2016-05-11 06:01:13 -0700165 return static_cast<int64_t>(packets_->SizeInBytes() * 8 /
166 pacing_bitrate_kbps_);
stefan@webrtc.orgbfacda62013-03-27 16:36:01 +0000167}
168
sergeyu80ed35e2016-11-28 13:11:13 -0800169rtc::Optional<int64_t> PacedSender::GetApplicationLimitedRegionStartTime()
170 const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700171 rtc::CritScope cs(&critsect_);
sergeyu80ed35e2016-11-28 13:11:13 -0800172 return alr_detector_->GetApplicationLimitedRegionStartTime();
Irfan Sheriff1eb12932016-10-18 17:04:25 -0700173}
174
stefan@webrtc.org82462aa2014-10-23 11:57:05 +0000175size_t PacedSender::QueueSizePackets() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700176 rtc::CritScope cs(&critsect_);
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000177 return packets_->SizeInPackets();
178}
179
asaperssonfc5e81c2017-04-19 23:28:53 -0700180int64_t PacedSender::FirstSentPacketTimeMs() const {
181 rtc::CritScope cs(&critsect_);
182 return first_sent_packet_ms_;
183}
184
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000185int64_t PacedSender::QueueInMs() const {
kthelgason6bfe49c2017-03-30 01:14:41 -0700186 rtc::CritScope cs(&critsect_);
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000187
sprang0a43fef2015-11-20 09:00:37 -0800188 int64_t oldest_packet = packets_->OldestEnqueueTimeMs();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000189 if (oldest_packet == 0)
190 return 0;
191
192 return clock_->TimeInMilliseconds() - oldest_packet;
stefan@webrtc.org82462aa2014-10-23 11:57:05 +0000193}
194
Erik Språngad113e52015-11-26 16:26:12 +0100195int64_t PacedSender::AverageQueueTimeMs() {
kthelgason6bfe49c2017-03-30 01:14:41 -0700196 rtc::CritScope cs(&critsect_);
Erik Språngad113e52015-11-26 16:26:12 +0100197 packets_->UpdateQueueTime(clock_->TimeInMilliseconds());
198 return packets_->AverageQueueTimeMs();
199}
200
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000201int64_t PacedSender::TimeUntilNextProcess() {
kthelgason6bfe49c2017-03-30 01:14:41 -0700202 rtc::CritScope cs(&critsect_);
stefan9e117c5e12017-08-16 08:16:25 -0700203 int64_t elapsed_time_us = clock_->TimeInMicroseconds() - time_last_update_us_;
204 int64_t elapsed_time_ms = (elapsed_time_us + 500) / 1000;
205 // When paused we wake up every 500 ms to send a padding packet to ensure
206 // we won't get stuck in the paused state due to no feedback being received.
tommi919dce22017-03-15 07:45:36 -0700207 if (paused_)
stefan9e117c5e12017-08-16 08:16:25 -0700208 return std::max<int64_t>(kPausedPacketIntervalMs - elapsed_time_ms, 0);
tommi919dce22017-03-15 07:45:36 -0700209
stefan@webrtc.org82462aa2014-10-23 11:57:05 +0000210 if (prober_->IsProbing()) {
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000211 int64_t ret = prober_->TimeUntilNextProbe(clock_->TimeInMilliseconds());
philipelb61927c2017-02-28 07:05:23 -0800212 if (ret > 0 || (ret == 0 && !probing_send_failure_))
stefan@webrtc.orge9f0f592015-02-16 15:47:51 +0000213 return ret;
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000214 }
pkasting@chromium.org0b1534c2014-12-15 22:09:40 +0000215 return std::max<int64_t>(kMinPacketLimitMs - elapsed_time_ms, 0);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000216}
217
pbosa26ac922016-02-25 04:50:01 -0800218void PacedSender::Process() {
stefan@webrtc.org89fd1e82014-07-15 16:40:38 +0000219 int64_t now_us = clock_->TimeInMicroseconds();
kthelgason6bfe49c2017-03-30 01:14:41 -0700220 rtc::CritScope cs(&critsect_);
tschumim5afa3f22017-08-18 03:38:49 -0700221 int64_t elapsed_time_ms = std::min(
222 kMaxIntervalTimeMs, (now_us - time_last_update_us_ + 500) / 1000);
perkjec81bcd2016-05-11 06:01:13 -0700223 int target_bitrate_kbps = pacing_bitrate_kbps_;
stefan9e117c5e12017-08-16 08:16:25 -0700224
225 if (paused_) {
226 PacedPacketInfo pacing_info;
227 time_last_update_us_ = now_us;
228 // We can not send padding unless a normal packet has first been sent. If we
229 // do, timestamps get messed up.
230 if (packet_counter_ == 0)
231 return;
232 size_t bytes_sent = SendPadding(1, pacing_info);
tschumim5afa3f22017-08-18 03:38:49 -0700233 alr_detector_->OnBytesSent(bytes_sent, elapsed_time_ms);
stefan9e117c5e12017-08-16 08:16:25 -0700234 return;
235 }
236
237 if (elapsed_time_ms > 0) {
sprang0a43fef2015-11-20 09:00:37 -0800238 size_t queue_size_bytes = packets_->SizeInBytes();
239 if (queue_size_bytes > 0) {
240 // Assuming equal size packets and input/output rate, the average packet
241 // has avg_time_left_ms left to get queue_size_bytes out of the queue, if
242 // time constraint shall be met. Determine bitrate needed for that.
Erik Språngad113e52015-11-26 16:26:12 +0100243 packets_->UpdateQueueTime(clock_->TimeInMilliseconds());
sprang0a43fef2015-11-20 09:00:37 -0800244 int64_t avg_time_left_ms = std::max<int64_t>(
sprang89c4a7e2017-06-30 13:27:40 -0700245 1, queue_time_limit - packets_->AverageQueueTimeMs());
sprang0a43fef2015-11-20 09:00:37 -0800246 int min_bitrate_needed_kbps =
247 static_cast<int>(queue_size_bytes * 8 / avg_time_left_ms);
248 if (min_bitrate_needed_kbps > target_bitrate_kbps)
249 target_bitrate_kbps = min_bitrate_needed_kbps;
250 }
251
252 media_budget_->set_target_rate_kbps(target_bitrate_kbps);
isheriff31687812016-10-04 08:43:09 -0700253 UpdateBudgetWithElapsedTime(elapsed_time_ms);
stefan@webrtc.org80865fd2013-08-09 11:31:23 +0000254 }
philipela1ed0b32016-06-01 06:31:17 -0700255
stefan9e117c5e12017-08-16 08:16:25 -0700256 time_last_update_us_ = now_us;
257
philipel1a93cde2016-06-03 01:41:45 -0700258 bool is_probing = prober_->IsProbing();
philipelc7bf32a2017-02-17 03:59:43 -0800259 PacedPacketInfo pacing_info;
isheriffcc5903e2016-10-04 08:29:38 -0700260 size_t bytes_sent = 0;
261 size_t recommended_probe_size = 0;
262 if (is_probing) {
philipelc7bf32a2017-02-17 03:59:43 -0800263 pacing_info = prober_->CurrentCluster();
isheriffcc5903e2016-10-04 08:29:38 -0700264 recommended_probe_size = prober_->RecommendedMinProbeSize();
265 }
Peter Boströme23e7372015-10-08 11:44:14 +0200266 while (!packets_->Empty()) {
Peter Boströme23e7372015-10-08 11:44:14 +0200267 // Since we need to release the lock in order to send, we first pop the
268 // element from the priority queue but keep it in storage, so that we can
269 // reinsert it if send fails.
philipel9981bd92017-09-26 17:16:06 +0200270 const PacketQueue::Packet& packet = packets_->BeginPop();
Stefan Holmerb86d4e42015-12-07 10:26:18 +0100271
philipelc7bf32a2017-02-17 03:59:43 -0800272 if (SendPacket(packet, pacing_info)) {
Peter Boströme23e7372015-10-08 11:44:14 +0200273 // Send succeeded, remove it from the queue.
asaperssonfc5e81c2017-04-19 23:28:53 -0700274 if (first_sent_packet_ms_ == -1)
275 first_sent_packet_ms_ = clock_->TimeInMilliseconds();
isheriffcc5903e2016-10-04 08:29:38 -0700276 bytes_sent += packet.bytes;
Peter Boströme23e7372015-10-08 11:44:14 +0200277 packets_->FinalizePop(packet);
isheriffcc5903e2016-10-04 08:29:38 -0700278 if (is_probing && bytes_sent > recommended_probe_size)
279 break;
Peter Boströme23e7372015-10-08 11:44:14 +0200280 } else {
281 // Send failed, put it back into the queue.
282 packets_->CancelPop(packet);
isheriffcc5903e2016-10-04 08:29:38 -0700283 break;
Peter Boströme23e7372015-10-08 11:44:14 +0200284 }
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000285 }
Peter Boströme23e7372015-10-08 11:44:14 +0200286
stefan9e117c5e12017-08-16 08:16:25 -0700287 if (packets_->Empty()) {
isheriffcc5903e2016-10-04 08:29:38 -0700288 // We can not send padding unless a normal packet has first been sent. If we
289 // do, timestamps get messed up.
290 if (packet_counter_ > 0) {
291 int padding_needed =
292 static_cast<int>(is_probing ? (recommended_probe_size - bytes_sent)
293 : padding_budget_->bytes_remaining());
isheriffcc5903e2016-10-04 08:29:38 -0700294 if (padding_needed > 0)
philipelc7bf32a2017-02-17 03:59:43 -0800295 bytes_sent += SendPadding(padding_needed, pacing_info);
isheriffcc5903e2016-10-04 08:29:38 -0700296 }
perkj71ee44c2016-06-15 00:47:53 -0700297 }
philipelb61927c2017-02-28 07:05:23 -0800298 if (is_probing) {
299 probing_send_failure_ = bytes_sent == 0;
300 if (!probing_send_failure_)
301 prober_->ProbeSent(clock_->TimeInMilliseconds(), bytes_sent);
302 }
tschumim82c55932017-07-11 06:56:04 -0700303 alr_detector_->OnBytesSent(bytes_sent, elapsed_time_ms);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000304}
305
tommi919dce22017-03-15 07:45:36 -0700306void PacedSender::ProcessThreadAttached(ProcessThread* process_thread) {
307 LOG(LS_INFO) << "ProcessThreadAttached 0x" << std::hex << process_thread;
308 process_thread_ = process_thread;
309}
310
philipel9981bd92017-09-26 17:16:06 +0200311bool PacedSender::SendPacket(const PacketQueue::Packet& packet,
philipelc7bf32a2017-02-17 03:59:43 -0800312 const PacedPacketInfo& pacing_info) {
stefan9e117c5e12017-08-16 08:16:25 -0700313 RTC_DCHECK(!paused_);
stefan099110c2017-02-01 03:57:42 -0800314 if (media_budget_->bytes_remaining() == 0 &&
philipelc7bf32a2017-02-17 03:59:43 -0800315 pacing_info.probe_cluster_id == PacedPacketInfo::kNotAProbe) {
stefan099110c2017-02-01 03:57:42 -0800316 return false;
terelius8b70faf2016-08-01 09:47:31 -0700317 }
philipelc7bf32a2017-02-17 03:59:43 -0800318
kthelgason6bfe49c2017-03-30 01:14:41 -0700319 critsect_.Leave();
perkjec81bcd2016-05-11 06:01:13 -0700320 const bool success = packet_sender_->TimeToSendPacket(
321 packet.ssrc, packet.sequence_number, packet.capture_time_ms,
philipelc7bf32a2017-02-17 03:59:43 -0800322 packet.retransmission, pacing_info);
kthelgason6bfe49c2017-03-30 01:14:41 -0700323 critsect_.Enter();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000324
Peter Boström7ecc1632016-03-02 14:22:25 +0100325 if (success) {
Alex Naresta5fbc232017-10-18 18:31:07 +0200326 if (packet.priority != kHighPriority || account_for_audio_) {
Peter Boström7ecc1632016-03-02 14:22:25 +0100327 // Update media bytes sent.
eladalon32040ef2017-08-02 06:29:00 -0700328 // TODO(eladalon): TimeToSendPacket() can also return |true| in some
329 // situations where nothing actually ended up being sent to the network,
330 // and we probably don't want to update the budget in such cases.
331 // https://bugs.chromium.org/p/webrtc/issues/detail?id=8052
isheriff31687812016-10-04 08:43:09 -0700332 UpdateBudgetWithBytesSent(packet.bytes);
Peter Boström7ecc1632016-03-02 14:22:25 +0100333 }
stefan@webrtc.org19a40ff2013-11-27 14:16:20 +0000334 }
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000335
336 return success;
337}
338
philipelc7bf32a2017-02-17 03:59:43 -0800339size_t PacedSender::SendPadding(size_t padding_needed,
340 const PacedPacketInfo& pacing_info) {
stefan9e117c5e12017-08-16 08:16:25 -0700341 RTC_DCHECK_GT(packet_counter_, 0);
kthelgason6bfe49c2017-03-30 01:14:41 -0700342 critsect_.Leave();
philipela1ed0b32016-06-01 06:31:17 -0700343 size_t bytes_sent =
philipelc7bf32a2017-02-17 03:59:43 -0800344 packet_sender_->TimeToSendPadding(padding_needed, pacing_info);
kthelgason6bfe49c2017-03-30 01:14:41 -0700345 critsect_.Enter();
sprang@webrtc.orgdcebf2d2014-11-04 16:27:16 +0000346
Stefan Holmer01b48882015-05-05 10:21:24 +0200347 if (bytes_sent > 0) {
isheriff31687812016-10-04 08:43:09 -0700348 UpdateBudgetWithBytesSent(bytes_sent);
Stefan Holmer01b48882015-05-05 10:21:24 +0200349 }
isheriffcc5903e2016-10-04 08:29:38 -0700350 return bytes_sent;
stefan@webrtc.org19a40ff2013-11-27 14:16:20 +0000351}
352
isheriff31687812016-10-04 08:43:09 -0700353void PacedSender::UpdateBudgetWithElapsedTime(int64_t delta_time_ms) {
stefan@webrtc.orgc3cc3752013-06-04 09:36:56 +0000354 media_budget_->IncreaseBudget(delta_time_ms);
355 padding_budget_->IncreaseBudget(delta_time_ms);
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000356}
isheriff31687812016-10-04 08:43:09 -0700357
358void PacedSender::UpdateBudgetWithBytesSent(size_t bytes_sent) {
359 media_budget_->UseBudget(bytes_sent);
360 padding_budget_->UseBudget(bytes_sent);
361}
sprang89c4a7e2017-06-30 13:27:40 -0700362
363void PacedSender::SetPacingFactor(float pacing_factor) {
364 rtc::CritScope cs(&critsect_);
365 pacing_factor_ = pacing_factor;
Erik Språng5fc130b2017-10-04 09:42:53 +0200366 // Make sure new padding factor is applied immediately, otherwise we need to
367 // wait for the send bitrate estimate to be updated before this takes effect.
368 SetEstimatedBitrate(estimated_bitrate_bps_);
sprang89c4a7e2017-06-30 13:27:40 -0700369}
370
371void PacedSender::SetQueueTimeLimit(int limit_ms) {
372 rtc::CritScope cs(&critsect_);
373 queue_time_limit = limit_ms;
374}
375
pwestin@webrtc.orgb5180172012-11-09 20:56:23 +0000376} // namespace webrtc