OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 201 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
212 const float PacedSender::kDefaultPaceMultiplier = 2.5f; | 212 const float PacedSender::kDefaultPaceMultiplier = 2.5f; |
213 | 213 |
214 PacedSender::PacedSender(Clock* clock, | 214 PacedSender::PacedSender(Clock* clock, |
215 Callback* callback, | 215 Callback* callback, |
216 int bitrate_kbps, | 216 int bitrate_kbps, |
217 int max_bitrate_kbps, | 217 int max_bitrate_kbps, |
218 int min_bitrate_kbps) | 218 int min_bitrate_kbps) |
219 : clock_(clock), | 219 : clock_(clock), |
220 callback_(callback), | 220 callback_(callback), |
221 critsect_(CriticalSectionWrapper::CreateCriticalSection()), | 221 critsect_(CriticalSectionWrapper::CreateCriticalSection()), |
222 enabled_(true), | |
223 paused_(false), | 222 paused_(false), |
224 probing_enabled_(true), | 223 probing_enabled_(true), |
225 media_budget_(new paced_sender::IntervalBudget(max_bitrate_kbps)), | 224 media_budget_(new paced_sender::IntervalBudget(max_bitrate_kbps)), |
226 padding_budget_(new paced_sender::IntervalBudget(min_bitrate_kbps)), | 225 padding_budget_(new paced_sender::IntervalBudget(min_bitrate_kbps)), |
227 prober_(new BitrateProber()), | 226 prober_(new BitrateProber()), |
228 bitrate_bps_(1000 * bitrate_kbps), | 227 bitrate_bps_(1000 * bitrate_kbps), |
229 time_last_update_us_(clock->TimeInMicroseconds()), | 228 time_last_update_us_(clock->TimeInMicroseconds()), |
230 packets_(new paced_sender::PacketQueue()), | 229 packets_(new paced_sender::PacketQueue()), |
231 packet_counter_(0) { | 230 packet_counter_(0) { |
232 UpdateBytesPerInterval(kMinPacketLimitMs); | 231 UpdateBytesPerInterval(kMinPacketLimitMs); |
233 } | 232 } |
234 | 233 |
235 PacedSender::~PacedSender() {} | 234 PacedSender::~PacedSender() {} |
236 | 235 |
237 void PacedSender::Pause() { | 236 void PacedSender::Pause() { |
238 CriticalSectionScoped cs(critsect_.get()); | 237 CriticalSectionScoped cs(critsect_.get()); |
239 paused_ = true; | 238 paused_ = true; |
240 } | 239 } |
241 | 240 |
242 void PacedSender::Resume() { | 241 void PacedSender::Resume() { |
243 CriticalSectionScoped cs(critsect_.get()); | 242 CriticalSectionScoped cs(critsect_.get()); |
244 paused_ = false; | 243 paused_ = false; |
245 } | 244 } |
246 | 245 |
247 void PacedSender::SetProbingEnabled(bool enabled) { | 246 void PacedSender::SetProbingEnabled(bool enabled) { |
248 assert(packet_counter_ == 0); | 247 assert(packet_counter_ == 0); |
249 probing_enabled_ = enabled; | 248 probing_enabled_ = enabled; |
250 } | 249 } |
251 | 250 |
252 void PacedSender::SetStatus(bool enable) { | |
253 CriticalSectionScoped cs(critsect_.get()); | |
254 enabled_ = enable; | |
255 } | |
256 | |
257 bool PacedSender::Enabled() const { | |
258 CriticalSectionScoped cs(critsect_.get()); | |
259 return enabled_; | |
260 } | |
261 | |
262 void PacedSender::UpdateBitrate(int bitrate_kbps, | 251 void PacedSender::UpdateBitrate(int bitrate_kbps, |
263 int max_bitrate_kbps, | 252 int max_bitrate_kbps, |
264 int min_bitrate_kbps) { | 253 int min_bitrate_kbps) { |
265 CriticalSectionScoped cs(critsect_.get()); | 254 CriticalSectionScoped cs(critsect_.get()); |
266 media_budget_->set_target_rate_kbps(max_bitrate_kbps); | 255 media_budget_->set_target_rate_kbps(max_bitrate_kbps); |
267 padding_budget_->set_target_rate_kbps(min_bitrate_kbps); | 256 padding_budget_->set_target_rate_kbps(min_bitrate_kbps); |
268 bitrate_bps_ = 1000 * bitrate_kbps; | 257 bitrate_bps_ = 1000 * bitrate_kbps; |
269 } | 258 } |
270 | 259 |
271 bool PacedSender::SendPacket(RtpPacketSender::Priority priority, | 260 void PacedSender::InsertPacket(RtpPacketSender::Priority priority, |
272 uint32_t ssrc, | 261 uint32_t ssrc, |
273 uint16_t sequence_number, | 262 uint16_t sequence_number, |
274 int64_t capture_time_ms, | 263 int64_t capture_time_ms, |
275 size_t bytes, | 264 size_t bytes, |
276 bool retransmission) { | 265 bool retransmission) { |
277 CriticalSectionScoped cs(critsect_.get()); | 266 CriticalSectionScoped cs(critsect_.get()); |
278 | 267 |
279 if (!enabled_) { | |
280 return true; // We can send now. | |
281 } | |
282 if (probing_enabled_ && !prober_->IsProbing()) { | 268 if (probing_enabled_ && !prober_->IsProbing()) { |
283 prober_->SetEnabled(true); | 269 prober_->SetEnabled(true); |
284 } | 270 } |
285 prober_->MaybeInitializeProbe(bitrate_bps_); | 271 prober_->MaybeInitializeProbe(bitrate_bps_); |
286 | 272 |
287 if (capture_time_ms < 0) { | 273 if (capture_time_ms < 0) { |
288 capture_time_ms = clock_->TimeInMilliseconds(); | 274 capture_time_ms = clock_->TimeInMilliseconds(); |
289 } | 275 } |
290 | 276 |
291 packets_->Push(paced_sender::Packet( | 277 packets_->Push(paced_sender::Packet( |
292 priority, ssrc, sequence_number, capture_time_ms, | 278 priority, ssrc, sequence_number, capture_time_ms, |
293 clock_->TimeInMilliseconds(), bytes, retransmission, packet_counter_++)); | 279 clock_->TimeInMilliseconds(), bytes, retransmission, packet_counter_++)); |
294 return false; | |
295 } | 280 } |
296 | 281 |
297 int64_t PacedSender::ExpectedQueueTimeMs() const { | 282 int64_t PacedSender::ExpectedQueueTimeMs() const { |
298 CriticalSectionScoped cs(critsect_.get()); | 283 CriticalSectionScoped cs(critsect_.get()); |
299 int target_rate = media_budget_->target_rate_kbps(); | 284 int target_rate = media_budget_->target_rate_kbps(); |
300 assert(target_rate > 0); | 285 assert(target_rate > 0); |
301 return static_cast<int64_t>(packets_->SizeInBytes() * 8 / target_rate); | 286 return static_cast<int64_t>(packets_->SizeInBytes() * 8 / target_rate); |
302 } | 287 } |
303 | 288 |
304 size_t PacedSender::QueueSizePackets() const { | 289 size_t PacedSender::QueueSizePackets() const { |
(...skipping 22 matching lines...) Expand all Loading... |
327 int64_t elapsed_time_us = clock_->TimeInMicroseconds() - time_last_update_us_; | 312 int64_t elapsed_time_us = clock_->TimeInMicroseconds() - time_last_update_us_; |
328 int64_t elapsed_time_ms = (elapsed_time_us + 500) / 1000; | 313 int64_t elapsed_time_ms = (elapsed_time_us + 500) / 1000; |
329 return std::max<int64_t>(kMinPacketLimitMs - elapsed_time_ms, 0); | 314 return std::max<int64_t>(kMinPacketLimitMs - elapsed_time_ms, 0); |
330 } | 315 } |
331 | 316 |
332 int32_t PacedSender::Process() { | 317 int32_t PacedSender::Process() { |
333 int64_t now_us = clock_->TimeInMicroseconds(); | 318 int64_t now_us = clock_->TimeInMicroseconds(); |
334 CriticalSectionScoped cs(critsect_.get()); | 319 CriticalSectionScoped cs(critsect_.get()); |
335 int64_t elapsed_time_ms = (now_us - time_last_update_us_ + 500) / 1000; | 320 int64_t elapsed_time_ms = (now_us - time_last_update_us_ + 500) / 1000; |
336 time_last_update_us_ = now_us; | 321 time_last_update_us_ = now_us; |
337 if (!enabled_) { | 322 if (paused_) |
338 return 0; | 323 return 0; |
| 324 if (elapsed_time_ms > 0) { |
| 325 int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms); |
| 326 UpdateBytesPerInterval(delta_time_ms); |
339 } | 327 } |
340 if (!paused_) { | 328 while (!packets_->Empty()) { |
341 if (elapsed_time_ms > 0) { | 329 if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) { |
342 int64_t delta_time_ms = std::min(kMaxIntervalTimeMs, elapsed_time_ms); | 330 return 0; |
343 UpdateBytesPerInterval(delta_time_ms); | |
344 } | 331 } |
345 while (!packets_->Empty()) { | 332 |
346 if (media_budget_->bytes_remaining() == 0 && !prober_->IsProbing()) { | 333 // Since we need to release the lock in order to send, we first pop the |
| 334 // element from the priority queue but keep it in storage, so that we can |
| 335 // reinsert it if send fails. |
| 336 const paced_sender::Packet& packet = packets_->BeginPop(); |
| 337 if (SendPacket(packet)) { |
| 338 // Send succeeded, remove it from the queue. |
| 339 packets_->FinalizePop(packet); |
| 340 if (prober_->IsProbing()) { |
347 return 0; | 341 return 0; |
348 } | 342 } |
| 343 } else { |
| 344 // Send failed, put it back into the queue. |
| 345 packets_->CancelPop(packet); |
| 346 return 0; |
| 347 } |
| 348 } |
349 | 349 |
350 // Since we need to release the lock in order to send, we first pop the | 350 if (!packets_->Empty()) |
351 // element from the priority queue but keep it in storage, so that we can | 351 return 0; |
352 // reinsert it if send fails. | |
353 const paced_sender::Packet& packet = packets_->BeginPop(); | |
354 if (SendPacket(packet)) { | |
355 // Send succeeded, remove it from the queue. | |
356 packets_->FinalizePop(packet); | |
357 if (prober_->IsProbing()) { | |
358 return 0; | |
359 } | |
360 } else { | |
361 // Send failed, put it back into the queue. | |
362 packets_->CancelPop(packet); | |
363 return 0; | |
364 } | |
365 } | |
366 | 352 |
367 if (!packets_->Empty()) | 353 size_t padding_needed; |
368 return 0; | 354 if (prober_->IsProbing()) |
| 355 padding_needed = prober_->RecommendedPacketSize(); |
| 356 else |
| 357 padding_needed = padding_budget_->bytes_remaining(); |
369 | 358 |
370 size_t padding_needed; | 359 if (padding_needed > 0) |
371 if (prober_->IsProbing()) | 360 SendPadding(static_cast<size_t>(padding_needed)); |
372 padding_needed = prober_->RecommendedPacketSize(); | |
373 else | |
374 padding_needed = padding_budget_->bytes_remaining(); | |
375 | |
376 if (padding_needed > 0) | |
377 SendPadding(static_cast<size_t>(padding_needed)); | |
378 } | |
379 return 0; | 361 return 0; |
380 } | 362 } |
381 | 363 |
382 bool PacedSender::SendPacket(const paced_sender::Packet& packet) { | 364 bool PacedSender::SendPacket(const paced_sender::Packet& packet) { |
383 critsect_->Leave(); | 365 critsect_->Leave(); |
384 const bool success = callback_->TimeToSendPacket(packet.ssrc, | 366 const bool success = callback_->TimeToSendPacket(packet.ssrc, |
385 packet.sequence_number, | 367 packet.sequence_number, |
386 packet.capture_time_ms, | 368 packet.capture_time_ms, |
387 packet.retransmission); | 369 packet.retransmission); |
388 critsect_->Enter(); | 370 critsect_->Enter(); |
(...skipping 18 matching lines...) Expand all Loading... |
407 media_budget_->UseBudget(bytes_sent); | 389 media_budget_->UseBudget(bytes_sent); |
408 padding_budget_->UseBudget(bytes_sent); | 390 padding_budget_->UseBudget(bytes_sent); |
409 } | 391 } |
410 } | 392 } |
411 | 393 |
412 void PacedSender::UpdateBytesPerInterval(int64_t delta_time_ms) { | 394 void PacedSender::UpdateBytesPerInterval(int64_t delta_time_ms) { |
413 media_budget_->IncreaseBudget(delta_time_ms); | 395 media_budget_->IncreaseBudget(delta_time_ms); |
414 padding_budget_->IncreaseBudget(delta_time_ms); | 396 padding_budget_->IncreaseBudget(delta_time_ms); |
415 } | 397 } |
416 } // namespace webrtc | 398 } // namespace webrtc |
OLD | NEW |