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