OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/cast/transport/pacing/paced_sender.h" | 5 #include "media/cast/transport/pacing/paced_sender.h" |
6 | 6 |
7 #include "base/big_endian.h" | 7 #include "base/big_endian.h" |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/message_loop/message_loop.h" | 9 #include "base/message_loop/message_loop.h" |
10 | 10 |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
66 for (size_t i = 0; i < packets.size(); i++) { | 66 for (size_t i = 0; i < packets.size(); i++) { |
67 packet_list_[packets[i].first] = | 67 packet_list_[packets[i].first] = |
68 make_pair(PacketType_Normal, packets[i].second); | 68 make_pair(PacketType_Normal, packets[i].second); |
69 } | 69 } |
70 if (state_ == State_Unblocked) { | 70 if (state_ == State_Unblocked) { |
71 SendStoredPackets(); | 71 SendStoredPackets(); |
72 } | 72 } |
73 return true; | 73 return true; |
74 } | 74 } |
75 | 75 |
76 bool PacedSender::ResendPackets(const SendPacketVector& packets) { | 76 bool PacedSender::ResendPackets(const SendPacketVector& packets, |
| 77 base::TimeDelta rtt) { |
77 if (packets.empty()) { | 78 if (packets.empty()) { |
78 return true; | 79 return true; |
79 } | 80 } |
| 81 base::TimeTicks now = clock_->NowTicks(); |
80 for (size_t i = 0; i < packets.size(); i++) { | 82 for (size_t i = 0; i < packets.size(); i++) { |
| 83 std::map<PacketKey, base::TimeTicks>::const_iterator j = |
| 84 sent_time_.find(packets[i].first); |
| 85 |
| 86 if (j != sent_time_.end() && now - j->second < rtt) { |
| 87 // TODO(hubbe): Log this. |
| 88 continue; |
| 89 } |
| 90 |
81 packet_list_[packets[i].first] = | 91 packet_list_[packets[i].first] = |
82 make_pair(PacketType_Resend, packets[i].second); | 92 make_pair(PacketType_Resend, packets[i].second); |
83 } | 93 } |
84 if (state_ == State_Unblocked) { | 94 if (state_ == State_Unblocked) { |
85 SendStoredPackets(); | 95 SendStoredPackets(); |
86 } | 96 } |
87 return true; | 97 return true; |
88 } | 98 } |
89 | 99 |
90 bool PacedSender::SendRtcpPacket(uint32 ssrc, PacketRef packet) { | 100 bool PacedSender::SendRtcpPacket(uint32 ssrc, PacketRef packet) { |
(...skipping 10 matching lines...) Expand all Loading... |
101 } | 111 } |
102 | 112 |
103 } | 113 } |
104 return true; | 114 return true; |
105 } | 115 } |
106 | 116 |
107 void PacedSender::CancelSendingPacket(const PacketKey& packet_key) { | 117 void PacedSender::CancelSendingPacket(const PacketKey& packet_key) { |
108 packet_list_.erase(packet_key); | 118 packet_list_.erase(packet_key); |
109 } | 119 } |
110 | 120 |
111 PacketRef PacedSender::GetNextPacket(PacketType* packet_type) { | 121 PacketRef PacedSender::GetNextPacket(PacketType* packet_type, |
| 122 PacketKey* packet_key) { |
112 std::map<PacketKey, std::pair<PacketType, PacketRef> >::iterator i; | 123 std::map<PacketKey, std::pair<PacketType, PacketRef> >::iterator i; |
113 i = packet_list_.begin(); | 124 i = packet_list_.begin(); |
114 DCHECK(i != packet_list_.end()); | 125 DCHECK(i != packet_list_.end()); |
115 *packet_type = i->second.first; | 126 *packet_type = i->second.first; |
| 127 *packet_key = i->first; |
116 PacketRef ret = i->second.second; | 128 PacketRef ret = i->second.second; |
117 packet_list_.erase(i); | 129 packet_list_.erase(i); |
118 return ret; | 130 return ret; |
119 } | 131 } |
120 | 132 |
121 bool PacedSender::empty() const { | 133 bool PacedSender::empty() const { |
122 return packet_list_.empty(); | 134 return packet_list_.empty(); |
123 } | 135 } |
124 | 136 |
125 size_t PacedSender::size() const { | 137 size_t PacedSender::size() const { |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
178 weak_factory_.GetWeakPtr()); | 190 weak_factory_.GetWeakPtr()); |
179 while (!empty()) { | 191 while (!empty()) { |
180 if (current_burst_size_ >= max_burst_size_) { | 192 if (current_burst_size_ >= max_burst_size_) { |
181 transport_task_runner_->PostDelayedTask(FROM_HERE, | 193 transport_task_runner_->PostDelayedTask(FROM_HERE, |
182 cb, | 194 cb, |
183 burst_end_ - now); | 195 burst_end_ - now); |
184 state_ = State_BurstFull; | 196 state_ = State_BurstFull; |
185 return; | 197 return; |
186 } | 198 } |
187 PacketType packet_type; | 199 PacketType packet_type; |
188 PacketRef packet = GetNextPacket(&packet_type); | 200 PacketKey packet_key; |
| 201 PacketRef packet = GetNextPacket(&packet_type, &packet_key); |
| 202 sent_time_[packet_key] = now; |
| 203 sent_time_buffer_[packet_key] = now; |
189 | 204 |
190 switch (packet_type) { | 205 switch (packet_type) { |
191 case PacketType_Resend: | 206 case PacketType_Resend: |
192 LogPacketEvent(packet->data, true); | 207 LogPacketEvent(packet->data, true); |
193 break; | 208 break; |
194 case PacketType_Normal: | 209 case PacketType_Normal: |
195 LogPacketEvent(packet->data, false); | 210 LogPacketEvent(packet->data, false); |
196 break; | 211 break; |
197 case PacketType_RTCP: | 212 case PacketType_RTCP: |
198 break; | 213 break; |
199 } | 214 } |
200 if (!transport_->SendPacket(packet, cb)) { | 215 if (!transport_->SendPacket(packet, cb)) { |
201 state_ = State_TransportBlocked; | 216 state_ = State_TransportBlocked; |
202 return; | 217 return; |
203 } | 218 } |
204 current_burst_size_++; | 219 current_burst_size_++; |
205 } | 220 } |
| 221 // Keep ~1 second of data (1000 packets) |
| 222 if (sent_time_buffer_.size() > kMaxBurstSize * 1000 / kPacingIntervalMs) { |
| 223 sent_time_.swap(sent_time_buffer_); |
| 224 sent_time_buffer_.clear(); |
| 225 } |
206 state_ = State_Unblocked; | 226 state_ = State_Unblocked; |
207 } | 227 } |
208 | 228 |
209 void PacedSender::LogPacketEvent(const Packet& packet, bool retransmit) { | 229 void PacedSender::LogPacketEvent(const Packet& packet, bool retransmit) { |
210 // Get SSRC from packet and compare with the audio_ssrc / video_ssrc to see | 230 // Get SSRC from packet and compare with the audio_ssrc / video_ssrc to see |
211 // if the packet is audio or video. | 231 // if the packet is audio or video. |
212 DCHECK_GE(packet.size(), 12u); | 232 DCHECK_GE(packet.size(), 12u); |
213 base::BigEndianReader reader(reinterpret_cast<const char*>(&packet[8]), 4); | 233 base::BigEndianReader reader(reinterpret_cast<const char*>(&packet[8]), 4); |
214 uint32 ssrc; | 234 uint32 ssrc; |
215 bool success = reader.ReadU32(&ssrc); | 235 bool success = reader.ReadU32(&ssrc); |
(...skipping 11 matching lines...) Expand all Loading... |
227 CastLoggingEvent event = retransmit ? | 247 CastLoggingEvent event = retransmit ? |
228 PACKET_RETRANSMITTED : PACKET_SENT_TO_NETWORK; | 248 PACKET_RETRANSMITTED : PACKET_SENT_TO_NETWORK; |
229 EventMediaType media_type = is_audio ? AUDIO_EVENT : VIDEO_EVENT; | 249 EventMediaType media_type = is_audio ? AUDIO_EVENT : VIDEO_EVENT; |
230 logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, media_type, | 250 logging_->InsertSinglePacketEvent(clock_->NowTicks(), event, media_type, |
231 packet); | 251 packet); |
232 } | 252 } |
233 | 253 |
234 } // namespace transport | 254 } // namespace transport |
235 } // namespace cast | 255 } // namespace cast |
236 } // namespace media | 256 } // namespace media |
OLD | NEW |