OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2015 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 26 matching lines...) Expand all Loading... | |
37 ++it; | 37 ++it; |
38 } | 38 } |
39 } | 39 } |
40 return fb_packets; | 40 return fb_packets; |
41 } | 41 } |
42 | 42 |
43 VideoSender::VideoSender(PacketProcessorListener* listener, | 43 VideoSender::VideoSender(PacketProcessorListener* listener, |
44 VideoSource* source, | 44 VideoSource* source, |
45 BandwidthEstimatorType estimator_type) | 45 BandwidthEstimatorType estimator_type) |
46 : PacketSender(listener, source->flow_id()), | 46 : PacketSender(listener, source->flow_id()), |
47 running_(true), | |
47 source_(source), | 48 source_(source), |
48 bwe_(CreateBweSender(estimator_type, | 49 bwe_(CreateBweSender(estimator_type, |
49 source_->bits_per_second() / 1000, | 50 source_->bits_per_second() / 1000, |
50 this, | 51 this, |
51 &clock_)) { | 52 &clock_)) { |
52 modules_.push_back(bwe_.get()); | 53 modules_.push_back(bwe_.get()); |
53 } | 54 } |
54 | 55 |
55 VideoSender::~VideoSender() { | 56 VideoSender::~VideoSender() { |
56 } | 57 } |
(...skipping 12 matching lines...) Expand all Loading... | |
69 // Make sure to at least run Process() below every 100 ms. | 70 // Make sure to at least run Process() below every 100 ms. |
70 int64_t time_to_run_ms = std::min<int64_t>(time_ms, 100); | 71 int64_t time_to_run_ms = std::min<int64_t>(time_ms, 100); |
71 if (!feedbacks->empty()) { | 72 if (!feedbacks->empty()) { |
72 int64_t time_until_feedback_ms = | 73 int64_t time_until_feedback_ms = |
73 feedbacks->front()->send_time_us() / 1000 - | 74 feedbacks->front()->send_time_us() / 1000 - |
74 clock_.TimeInMilliseconds(); | 75 clock_.TimeInMilliseconds(); |
75 time_to_run_ms = | 76 time_to_run_ms = |
76 std::max<int64_t>(std::min(time_ms, time_until_feedback_ms), 0); | 77 std::max<int64_t>(std::min(time_ms, time_until_feedback_ms), 0); |
77 } | 78 } |
78 Packets generated; | 79 Packets generated; |
80 | |
79 source_->RunFor(time_to_run_ms, &generated); | 81 source_->RunFor(time_to_run_ms, &generated); |
80 bwe_->OnPacketsSent(generated); | 82 bwe_->OnPacketsSent(generated); |
83 | |
81 packets->merge(generated, DereferencingComparator<Packet>); | 84 packets->merge(generated, DereferencingComparator<Packet>); |
85 | |
82 clock_.AdvanceTimeMilliseconds(time_to_run_ms); | 86 clock_.AdvanceTimeMilliseconds(time_to_run_ms); |
87 | |
83 if (!feedbacks->empty()) { | 88 if (!feedbacks->empty()) { |
84 bwe_->GiveFeedback(*feedbacks->front()); | 89 bwe_->GiveFeedback(*feedbacks->front()); |
85 delete feedbacks->front(); | 90 delete feedbacks->front(); |
86 feedbacks->pop_front(); | 91 feedbacks->pop_front(); |
87 } | 92 } |
93 | |
88 bwe_->Process(); | 94 bwe_->Process(); |
95 | |
89 time_ms -= time_to_run_ms; | 96 time_ms -= time_to_run_ms; |
90 } while (time_ms > 0); | 97 } while (time_ms > 0); |
91 assert(feedbacks->empty()); | 98 assert(feedbacks->empty()); |
92 } | 99 } |
93 | 100 |
94 int VideoSender::GetFeedbackIntervalMs() const { | 101 int VideoSender::GetFeedbackIntervalMs() const { |
95 return bwe_->GetFeedbackIntervalMs(); | 102 return bwe_->GetFeedbackIntervalMs(); |
96 } | 103 } |
97 | 104 |
98 void VideoSender::OnNetworkChanged(uint32_t target_bitrate_bps, | 105 void VideoSender::OnNetworkChanged(uint32_t target_bitrate_bps, |
99 uint8_t fraction_lost, | 106 uint8_t fraction_lost, |
100 int64_t rtt) { | 107 int64_t rtt) { |
101 source_->SetBitrateBps(target_bitrate_bps); | 108 source_->SetBitrateBps(target_bitrate_bps); |
102 } | 109 } |
103 | 110 |
111 void VideoSender::Pause() { | |
112 running_ = false; | |
113 source_->Pause(); | |
114 bwe_->Pause(); | |
115 } | |
116 | |
117 void VideoSender::Resume() { | |
118 running_ = true; | |
119 source_->Resume(); | |
120 bwe_->Resume(); | |
121 } | |
122 | |
123 uint32_t VideoSender::TargetBitrateKbps() { | |
124 return (source_->bits_per_second() + 500) / 1000; | |
125 } | |
126 | |
104 PacedVideoSender::PacedVideoSender(PacketProcessorListener* listener, | 127 PacedVideoSender::PacedVideoSender(PacketProcessorListener* listener, |
105 VideoSource* source, | 128 VideoSource* source, |
106 BandwidthEstimatorType estimator) | 129 BandwidthEstimatorType estimator) |
107 : VideoSender(listener, source, estimator), | 130 : VideoSender(listener, source, estimator), |
108 pacer_(&clock_, | 131 pacer_(&clock_, |
109 this, | 132 this, |
110 source->bits_per_second() / 1000, | 133 source->bits_per_second() / 1000, |
111 PacedSender::kDefaultPaceMultiplier * source->bits_per_second() / | 134 PacedSender::kDefaultPaceMultiplier * source->bits_per_second() / |
112 1000, | 135 1000, |
113 0) { | 136 0) { |
(...skipping 141 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
255 | 278 |
256 void PacedVideoSender::OnNetworkChanged(uint32_t target_bitrate_bps, | 279 void PacedVideoSender::OnNetworkChanged(uint32_t target_bitrate_bps, |
257 uint8_t fraction_lost, | 280 uint8_t fraction_lost, |
258 int64_t rtt) { | 281 int64_t rtt) { |
259 VideoSender::OnNetworkChanged(target_bitrate_bps, fraction_lost, rtt); | 282 VideoSender::OnNetworkChanged(target_bitrate_bps, fraction_lost, rtt); |
260 pacer_.UpdateBitrate( | 283 pacer_.UpdateBitrate( |
261 target_bitrate_bps / 1000, | 284 target_bitrate_bps / 1000, |
262 PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, 0); | 285 PacedSender::kDefaultPaceMultiplier * target_bitrate_bps / 1000, 0); |
263 } | 286 } |
264 | 287 |
288 const int kNoLimit = std::numeric_limits<int>::max(); | |
289 const int kPacketSizeBytes = 1200; | |
290 | |
291 TcpSender::TcpSender(PacketProcessorListener* listener, | |
292 int flow_id, | |
293 int64_t offset_ms) | |
294 : PacketSender(listener, flow_id), | |
295 cwnd_(10), | |
296 ssthresh_(kNoLimit), | |
297 ack_received_(false), | |
298 last_acked_seq_num_(0), | |
299 next_sequence_number_(0), | |
300 offset_ms_(offset_ms), | |
301 last_reduction_time_ms_(-1), | |
302 last_rtt_ms_(0), | |
303 total_sent_bytes_(0), | |
304 send_limit_bytes_(kNoLimit), | |
305 running_(true), | |
306 last_generated_packets_ms_(0), | |
307 num_recent_sent_packets_(0), | |
308 bitrate_kbps_(0) { | |
309 } | |
310 | |
311 TcpSender::TcpSender(PacketProcessorListener* listener, | |
312 int flow_id, | |
313 int64_t offset_ms, | |
314 int send_limit_bytes) | |
315 : TcpSender(listener, flow_id, offset_ms) { | |
316 send_limit_bytes_ = send_limit_bytes; | |
stefan-webrtc
2015/07/06 08:24:51
Set in initializer list.
magalhaesc
2015/07/06 09:28:07
Done.
| |
317 } | |
318 | |
265 void TcpSender::RunFor(int64_t time_ms, Packets* in_out) { | 319 void TcpSender::RunFor(int64_t time_ms, Packets* in_out) { |
266 if (clock_.TimeInMilliseconds() + time_ms < offset_ms_) { | 320 if (clock_.TimeInMilliseconds() + time_ms < offset_ms_) { |
267 clock_.AdvanceTimeMilliseconds(time_ms); | 321 clock_.AdvanceTimeMilliseconds(time_ms); |
322 if (running_) { | |
323 running_ = false; | |
324 } | |
268 return; | 325 return; |
269 } | 326 } |
327 | |
328 if (!running_) { | |
329 running_ = true; | |
330 } | |
331 | |
270 int64_t start_time_ms = clock_.TimeInMilliseconds(); | 332 int64_t start_time_ms = clock_.TimeInMilliseconds(); |
271 BWE_TEST_LOGGING_CONTEXT("Sender"); | 333 BWE_TEST_LOGGING_CONTEXT("Sender"); |
272 BWE_TEST_LOGGING_CONTEXT(*flow_ids().begin()); | 334 BWE_TEST_LOGGING_CONTEXT(*flow_ids().begin()); |
273 | 335 |
274 std::list<FeedbackPacket*> feedbacks = GetFeedbackPackets( | 336 std::list<FeedbackPacket*> feedbacks = GetFeedbackPackets( |
275 in_out, clock_.TimeInMilliseconds() + time_ms, *flow_ids().begin()); | 337 in_out, clock_.TimeInMilliseconds() + time_ms, *flow_ids().begin()); |
276 // The number of packets which are sent in during time_ms depends on the | 338 // The number of packets which are sent in during time_ms depends on the |
277 // number of packets in_flight_ and the max number of packets in flight | 339 // number of packets in_flight_ and the max number of packets in flight |
278 // (cwnd_). Therefore SendPackets() isn't directly dependent on time_ms. | 340 // (cwnd_). Therefore SendPackets() isn't directly dependent on time_ms. |
279 for (FeedbackPacket* fb : feedbacks) { | 341 for (FeedbackPacket* fb : feedbacks) { |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
352 void TcpSender::HandleLoss() { | 414 void TcpSender::HandleLoss() { |
353 if (clock_.TimeInMilliseconds() - last_reduction_time_ms_ < last_rtt_ms_) | 415 if (clock_.TimeInMilliseconds() - last_reduction_time_ms_ < last_rtt_ms_) |
354 return; | 416 return; |
355 last_reduction_time_ms_ = clock_.TimeInMilliseconds(); | 417 last_reduction_time_ms_ = clock_.TimeInMilliseconds(); |
356 ssthresh_ = std::max(static_cast<int>(in_flight_.size() / 2), 2); | 418 ssthresh_ = std::max(static_cast<int>(in_flight_.size() / 2), 2); |
357 cwnd_ = ssthresh_; | 419 cwnd_ = ssthresh_; |
358 } | 420 } |
359 | 421 |
360 Packets TcpSender::GeneratePackets(size_t num_packets) { | 422 Packets TcpSender::GeneratePackets(size_t num_packets) { |
361 Packets generated; | 423 Packets generated; |
424 | |
425 UpdateSendBitrateEstimate(num_packets); | |
426 | |
362 for (size_t i = 0; i < num_packets; ++i) { | 427 for (size_t i = 0; i < num_packets; ++i) { |
363 generated.push_back(new MediaPacket(*flow_ids().begin(), | 428 if ((total_sent_bytes_ + kPacketSizeBytes) > send_limit_bytes_) { |
364 1000 * clock_.TimeInMilliseconds(), | 429 if (running_) { |
365 1200, next_sequence_number_++)); | 430 running_ = false; |
431 } | |
432 break; | |
433 } | |
434 generated.push_back( | |
435 new MediaPacket(*flow_ids().begin(), 1000 * clock_.TimeInMilliseconds(), | |
436 kPacketSizeBytes, next_sequence_number_++)); | |
366 generated.back()->set_sender_timestamp_us( | 437 generated.back()->set_sender_timestamp_us( |
367 1000 * clock_.TimeInMilliseconds()); | 438 1000 * clock_.TimeInMilliseconds()); |
439 | |
440 total_sent_bytes_ += kPacketSizeBytes; | |
368 } | 441 } |
442 | |
369 return generated; | 443 return generated; |
370 } | 444 } |
445 | |
446 void TcpSender::UpdateSendBitrateEstimate(size_t num_packets) { | |
447 const int kTimeWindowMs = 500; | |
448 num_recent_sent_packets_ += num_packets; | |
449 | |
450 int64_t delta_ms = clock_.TimeInMilliseconds() - last_generated_packets_ms_; | |
451 if (delta_ms >= kTimeWindowMs) { | |
452 bitrate_kbps_ = | |
453 static_cast<uint32_t>(8 * num_recent_sent_packets_ * kPacketSizeBytes) / | |
454 delta_ms; | |
455 last_generated_packets_ms_ = clock_.TimeInMilliseconds(); | |
456 num_recent_sent_packets_ = 0; | |
457 } | |
458 } | |
459 | |
460 uint32_t TcpSender::TargetBitrateKbps() { | |
461 return bitrate_kbps_; | |
462 } | |
463 | |
371 } // namespace bwe | 464 } // namespace bwe |
372 } // namespace testing | 465 } // namespace testing |
373 } // namespace webrtc | 466 } // namespace webrtc |
OLD | NEW |