OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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/net/cast_transport_sender_impl.h" | 5 #include "media/cast/net/cast_transport_sender_impl.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <algorithm> | 8 #include <algorithm> |
9 #include <string> | 9 #include <string> |
10 #include <utility> | 10 #include <utility> |
11 | 11 |
12 #include "base/single_thread_task_runner.h" | 12 #include "base/single_thread_task_runner.h" |
13 #include "base/values.h" | |
14 #include "build/build_config.h" | 13 #include "build/build_config.h" |
15 #include "media/cast/net/cast_transport_defines.h" | 14 #include "media/cast/net/cast_transport_defines.h" |
16 #include "media/cast/net/rtcp/receiver_rtcp_session.h" | 15 #include "media/cast/net/rtcp/receiver_rtcp_session.h" |
17 #include "media/cast/net/rtcp/sender_rtcp_session.h" | 16 #include "media/cast/net/rtcp/sender_rtcp_session.h" |
18 #include "media/cast/net/udp_transport.h" | |
19 #include "net/base/net_errors.h" | 17 #include "net/base/net_errors.h" |
20 #include "net/base/network_interfaces.h" | |
21 | 18 |
22 namespace media { | 19 namespace media { |
23 namespace cast { | 20 namespace cast { |
24 | 21 |
25 namespace { | 22 namespace { |
26 | 23 |
27 // See header file for what these mean. | |
28 const char kOptionDscp[] = "DSCP"; | |
29 #if defined(OS_WIN) | |
30 const char kOptionDisableNonBlockingIO[] = "disable_non_blocking_io"; | |
31 #endif | |
32 const char kOptionPacerTargetBurstSize[] = "pacer_target_burst_size"; | |
33 const char kOptionPacerMaxBurstSize[] = "pacer_max_burst_size"; | |
34 const char kOptionSendBufferMinSize[] = "send_buffer_min_size"; | |
35 const char kOptionWifiDisableScan[] = "disable_wifi_scan"; | |
36 const char kOptionWifiMediaStreamingMode[] = "media_streaming_mode"; | |
37 | |
38 int LookupOptionWithDefault(const base::DictionaryValue& options, | |
39 const std::string& path, | |
40 int default_value) { | |
41 int ret; | |
42 if (options.GetInteger(path, &ret)) { | |
43 return ret; | |
44 } else { | |
45 return default_value; | |
46 } | |
47 } | |
48 | |
49 int32_t GetTransportSendBufferSize(const base::DictionaryValue& options) { | |
50 // Socket send buffer size needs to be at least greater than one burst | |
51 // size. | |
52 int32_t max_burst_size = | |
53 LookupOptionWithDefault(options, kOptionPacerMaxBurstSize, | |
54 kMaxBurstSize) * | |
55 kMaxIpPacketSize; | |
56 int32_t min_send_buffer_size = | |
57 LookupOptionWithDefault(options, kOptionSendBufferMinSize, 0); | |
58 return std::max(max_burst_size, min_send_buffer_size); | |
59 } | |
60 | 24 |
61 } // namespace | 25 } // namespace |
62 | 26 |
63 scoped_ptr<CastTransportSender> CastTransportSender::Create( | 27 scoped_ptr<CastTransportSender> CastTransportSender::Create( |
64 net::NetLog* net_log, | 28 base::TickClock* clock, // Owned by the caller. |
65 base::TickClock* clock, | 29 base::TimeDelta logging_flush_interval, |
66 const net::IPEndPoint& local_end_point, | 30 scoped_ptr<Client> client, |
67 const net::IPEndPoint& remote_end_point, | 31 scoped_ptr<PacketSender> transport, |
68 scoped_ptr<base::DictionaryValue> options, | |
69 const CastTransportStatusCallback& status_callback, | |
70 const BulkRawEventsCallback& raw_events_callback, | |
71 base::TimeDelta raw_events_callback_interval, | |
72 const PacketReceiverCallback& packet_callback, | |
73 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) { | 32 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) { |
74 return scoped_ptr<CastTransportSender>(new CastTransportSenderImpl( | 33 return scoped_ptr<CastTransportSender>(new CastTransportSenderImpl( |
75 net_log, clock, local_end_point, remote_end_point, std::move(options), | 34 clock, logging_flush_interval, std::move(client), std::move(transport), |
76 status_callback, raw_events_callback, raw_events_callback_interval, | 35 transport_task_runner.get())); |
77 transport_task_runner.get(), packet_callback, NULL)); | |
78 } | 36 } |
79 | 37 |
80 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() { | 38 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() { |
81 return PacketReceiverCallback(); | 39 return PacketReceiverCallback(); |
82 } | 40 } |
83 | 41 |
84 CastTransportSenderImpl::CastTransportSenderImpl( | 42 CastTransportSenderImpl::CastTransportSenderImpl( |
85 net::NetLog* net_log, | |
86 base::TickClock* clock, | 43 base::TickClock* clock, |
87 const net::IPEndPoint& local_end_point, | 44 base::TimeDelta logging_flush_interval, |
88 const net::IPEndPoint& remote_end_point, | 45 scoped_ptr<Client> client, |
89 scoped_ptr<base::DictionaryValue> options, | 46 scoped_ptr<PacketSender> transport, |
90 const CastTransportStatusCallback& status_callback, | 47 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) |
91 const BulkRawEventsCallback& raw_events_callback, | |
92 base::TimeDelta raw_events_callback_interval, | |
93 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner, | |
94 const PacketReceiverCallback& packet_callback, | |
95 PacketSender* external_transport) | |
96 : clock_(clock), | 48 : clock_(clock), |
97 status_callback_(status_callback), | 49 logging_flush_interval_(logging_flush_interval), |
50 transport_client_(std::move(client)), | |
51 transport_(std::move(transport)), | |
98 transport_task_runner_(transport_task_runner), | 52 transport_task_runner_(transport_task_runner), |
99 transport_(external_transport | 53 pacer_(kTargetBurstSize, |
100 ? nullptr | 54 kMaxBurstSize, |
101 : new UdpTransport(net_log, | |
102 transport_task_runner, | |
103 local_end_point, | |
104 remote_end_point, | |
105 GetTransportSendBufferSize(*options), | |
106 status_callback)), | |
107 pacer_(LookupOptionWithDefault(*options, | |
108 kOptionPacerTargetBurstSize, | |
109 kTargetBurstSize), | |
110 LookupOptionWithDefault(*options, | |
111 kOptionPacerMaxBurstSize, | |
112 kMaxBurstSize), | |
113 clock, | 55 clock, |
114 raw_events_callback.is_null() ? nullptr : &recent_packet_events_, | 56 logging_flush_interval > base::TimeDelta() ? &recent_packet_events_ |
115 external_transport ? external_transport : transport_.get(), | 57 : nullptr, |
58 transport_.get(), | |
116 transport_task_runner), | 59 transport_task_runner), |
117 raw_events_callback_(raw_events_callback), | |
118 raw_events_callback_interval_(raw_events_callback_interval), | |
119 last_byte_acked_for_audio_(0), | 60 last_byte_acked_for_audio_(0), |
120 packet_callback_(packet_callback), | |
121 weak_factory_(this) { | 61 weak_factory_(this) { |
122 DCHECK(clock_); | 62 DCHECK(clock); |
miu
2016/01/27 02:18:04
Since the whole class assumes |transport_client_|,
xjz
2016/01/30 01:19:26
Done.
| |
123 if (!raw_events_callback_.is_null()) { | 63 if (logging_flush_interval_ > base::TimeDelta()) { |
124 DCHECK(raw_events_callback_interval > base::TimeDelta()); | 64 transport_task_runner_->PostDelayedTask( |
125 transport_task_runner->PostDelayedTask( | 65 FROM_HERE, base::Bind(&CastTransportSenderImpl::SendRawEvents, |
126 FROM_HERE, | 66 weak_factory_.GetWeakPtr()), |
127 base::Bind(&CastTransportSenderImpl::SendRawEvents, | 67 logging_flush_interval_); |
128 weak_factory_.GetWeakPtr()), | |
129 raw_events_callback_interval); | |
130 } | 68 } |
131 if (transport_) { | 69 transport_->StartReceiving(base::Bind( |
132 if (options->HasKey(kOptionDscp)) { | 70 &CastTransportSenderImpl::OnReceivedPacket, base::Unretained(this))); |
133 // The default DSCP value for cast is AF41. Which gives it a higher | |
134 // priority over other traffic. | |
135 transport_->SetDscp(net::DSCP_AF41); | |
136 } | |
137 #if defined(OS_WIN) | |
138 if (!options->HasKey(kOptionDisableNonBlockingIO)) { | |
139 transport_->UseNonBlockingIO(); | |
140 } | |
141 #endif | |
142 transport_->StartReceiving( | |
143 base::Bind(&CastTransportSenderImpl::OnReceivedPacket, | |
144 base::Unretained(this))); | |
145 int wifi_options = 0; | |
146 if (options->HasKey(kOptionWifiDisableScan)) { | |
147 wifi_options |= net::WIFI_OPTIONS_DISABLE_SCAN; | |
148 } | |
149 if (options->HasKey(kOptionWifiMediaStreamingMode)) { | |
150 wifi_options |= net::WIFI_OPTIONS_MEDIA_STREAMING_MODE; | |
151 } | |
152 if (wifi_options) { | |
153 wifi_options_autoreset_ = net::SetWifiOptions(wifi_options); | |
154 } | |
155 } | |
156 } | 71 } |
157 | 72 |
158 CastTransportSenderImpl::~CastTransportSenderImpl() { | 73 CastTransportSenderImpl::~CastTransportSenderImpl() { |
159 if (transport_) { | 74 transport_->StopReceiving(); |
160 transport_->StopReceiving(); | |
161 } | |
162 } | 75 } |
163 | 76 |
164 void CastTransportSenderImpl::InitializeAudio( | 77 void CastTransportSenderImpl::InitializeAudio( |
165 const CastTransportRtpConfig& config, | 78 const CastTransportRtpConfig& config, |
166 const RtcpCastMessageCallback& cast_message_cb, | 79 const RtcpCastMessageCallback& cast_message_cb, |
167 const RtcpRttCallback& rtt_cb) { | 80 const RtcpRttCallback& rtt_cb) { |
168 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) | 81 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) |
169 << "Unsafe to send audio with encryption DISABLED."; | 82 << "Unsafe to send audio with encryption DISABLED."; |
170 if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { | 83 if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { |
171 status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED); | 84 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED); |
172 return; | 85 return; |
173 } | 86 } |
174 | 87 |
175 audio_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); | 88 audio_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); |
176 if (audio_sender_->Initialize(config)) { | 89 if (audio_sender_->Initialize(config)) { |
177 // Audio packets have a higher priority. | 90 // Audio packets have a higher priority. |
178 pacer_.RegisterAudioSsrc(config.ssrc); | 91 pacer_.RegisterAudioSsrc(config.ssrc); |
179 pacer_.RegisterPrioritySsrc(config.ssrc); | 92 pacer_.RegisterPrioritySsrc(config.ssrc); |
180 status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED); | 93 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED); |
181 } else { | 94 } else { |
182 audio_sender_.reset(); | 95 audio_sender_.reset(); |
183 status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED); | 96 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED); |
184 return; | 97 return; |
185 } | 98 } |
186 | 99 |
187 audio_rtcp_session_.reset(new SenderRtcpSession( | 100 audio_rtcp_session_.reset(new SenderRtcpSession( |
188 base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage, | 101 base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage, |
189 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), | 102 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), |
190 rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, | 103 rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, |
191 weak_factory_.GetWeakPtr(), AUDIO_EVENT), | 104 weak_factory_.GetWeakPtr(), AUDIO_EVENT), |
192 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); | 105 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); |
193 pacer_.RegisterAudioSsrc(config.ssrc); | 106 pacer_.RegisterAudioSsrc(config.ssrc); |
194 AddValidSsrc(config.feedback_ssrc); | 107 AddValidSsrc(config.feedback_ssrc); |
195 status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED); | 108 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED); |
196 } | 109 } |
197 | 110 |
198 void CastTransportSenderImpl::InitializeVideo( | 111 void CastTransportSenderImpl::InitializeVideo( |
199 const CastTransportRtpConfig& config, | 112 const CastTransportRtpConfig& config, |
200 const RtcpCastMessageCallback& cast_message_cb, | 113 const RtcpCastMessageCallback& cast_message_cb, |
201 const RtcpRttCallback& rtt_cb) { | 114 const RtcpRttCallback& rtt_cb) { |
202 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) | 115 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) |
203 << "Unsafe to send video with encryption DISABLED."; | 116 << "Unsafe to send video with encryption DISABLED."; |
204 if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { | 117 if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { |
205 status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED); | 118 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED); |
206 return; | 119 return; |
207 } | 120 } |
208 | 121 |
209 video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); | 122 video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); |
210 if (!video_sender_->Initialize(config)) { | 123 if (!video_sender_->Initialize(config)) { |
211 video_sender_.reset(); | 124 video_sender_.reset(); |
212 status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED); | 125 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED); |
213 return; | 126 return; |
214 } | 127 } |
215 | 128 |
216 video_rtcp_session_.reset(new SenderRtcpSession( | 129 video_rtcp_session_.reset(new SenderRtcpSession( |
217 base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage, | 130 base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage, |
218 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), | 131 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), |
219 rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, | 132 rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, |
220 weak_factory_.GetWeakPtr(), VIDEO_EVENT), | 133 weak_factory_.GetWeakPtr(), VIDEO_EVENT), |
221 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); | 134 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); |
222 pacer_.RegisterVideoSsrc(config.ssrc); | 135 pacer_.RegisterVideoSsrc(config.ssrc); |
223 AddValidSsrc(config.feedback_ssrc); | 136 AddValidSsrc(config.feedback_ssrc); |
224 status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED); | 137 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_INITIALIZED); |
225 } | 138 } |
226 | 139 |
227 namespace { | 140 namespace { |
228 void EncryptAndSendFrame(const EncodedFrame& frame, | 141 void EncryptAndSendFrame(const EncodedFrame& frame, |
229 TransportEncryptionHandler* encryptor, | 142 TransportEncryptionHandler* encryptor, |
230 RtpSender* sender) { | 143 RtpSender* sender) { |
231 // TODO(miu): We probably shouldn't attempt to send an empty frame, but this | 144 // TODO(miu): We probably shouldn't attempt to send an empty frame, but this |
232 // issue is still under investigation. http://crbug.com/519022 | 145 // issue is still under investigation. http://crbug.com/519022 |
233 if (encryptor->is_activated() && !frame.data.empty()) { | 146 if (encryptor->is_activated() && !frame.data.empty()) { |
234 EncodedFrame encrypted_frame; | 147 EncodedFrame encrypted_frame; |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
320 } | 233 } |
321 } | 234 } |
322 | 235 |
323 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() { | 236 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() { |
324 return base::Bind( | 237 return base::Bind( |
325 base::IgnoreResult(&CastTransportSenderImpl::OnReceivedPacket), | 238 base::IgnoreResult(&CastTransportSenderImpl::OnReceivedPacket), |
326 weak_factory_.GetWeakPtr()); | 239 weak_factory_.GetWeakPtr()); |
327 } | 240 } |
328 | 241 |
329 void CastTransportSenderImpl::SendRawEvents() { | 242 void CastTransportSenderImpl::SendRawEvents() { |
330 DCHECK(!raw_events_callback_.is_null()); | 243 DCHECK(logging_flush_interval_ > base::TimeDelta()); |
331 | 244 |
332 if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) { | 245 if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) { |
333 scoped_ptr<std::vector<FrameEvent>> frame_events( | 246 scoped_ptr<std::vector<FrameEvent>> frame_events( |
334 new std::vector<FrameEvent>()); | 247 new std::vector<FrameEvent>()); |
335 frame_events->swap(recent_frame_events_); | 248 frame_events->swap(recent_frame_events_); |
336 scoped_ptr<std::vector<PacketEvent>> packet_events( | 249 scoped_ptr<std::vector<PacketEvent>> packet_events( |
337 new std::vector<PacketEvent>()); | 250 new std::vector<PacketEvent>()); |
338 packet_events->swap(recent_packet_events_); | 251 packet_events->swap(recent_packet_events_); |
339 raw_events_callback_.Run(std::move(frame_events), std::move(packet_events)); | 252 transport_client_->OnLoggingEventsReceived(std::move(frame_events), |
253 std::move(packet_events)); | |
340 } | 254 } |
341 | 255 |
342 transport_task_runner_->PostDelayedTask( | 256 transport_task_runner_->PostDelayedTask( |
343 FROM_HERE, | 257 FROM_HERE, base::Bind(&CastTransportSenderImpl::SendRawEvents, |
344 base::Bind(&CastTransportSenderImpl::SendRawEvents, | 258 weak_factory_.GetWeakPtr()), |
345 weak_factory_.GetWeakPtr()), | 259 logging_flush_interval_); |
346 raw_events_callback_interval_); | |
347 } | 260 } |
348 | 261 |
349 bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) { | 262 bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) { |
350 const uint8_t* const data = &packet->front(); | 263 const uint8_t* const data = &packet->front(); |
351 const size_t length = packet->size(); | 264 const size_t length = packet->size(); |
352 uint32_t ssrc; | 265 uint32_t ssrc; |
353 if (IsRtcpPacket(data, length)) { | 266 if (IsRtcpPacket(data, length)) { |
354 ssrc = GetSsrcOfSender(data, length); | 267 ssrc = GetSsrcOfSender(data, length); |
355 } else if (!RtpParser::ParseSsrc(data, length, &ssrc)) { | 268 } else if (!RtpParser::ParseSsrc(data, length, &ssrc)) { |
356 VLOG(1) << "Invalid RTP packet."; | 269 VLOG(1) << "Invalid RTP packet."; |
357 return false; | 270 return false; |
358 } | 271 } |
359 if (valid_ssrcs_.find(ssrc) == valid_ssrcs_.end()) { | 272 if (valid_ssrcs_.find(ssrc) == valid_ssrcs_.end()) { |
360 VLOG(1) << "Stale packet received."; | 273 VLOG(1) << "Stale packet received."; |
361 return false; | 274 return false; |
362 } | 275 } |
363 | 276 |
364 if (audio_rtcp_session_ && | 277 if (audio_rtcp_session_ && |
365 audio_rtcp_session_->IncomingRtcpPacket(data, length)) { | 278 audio_rtcp_session_->IncomingRtcpPacket(data, length)) { |
366 return true; | 279 return true; |
367 } | 280 } |
368 if (video_rtcp_session_ && | 281 if (video_rtcp_session_ && |
369 video_rtcp_session_->IncomingRtcpPacket(data, length)) { | 282 video_rtcp_session_->IncomingRtcpPacket(data, length)) { |
370 return true; | 283 return true; |
371 } | 284 } |
372 if (packet_callback_.is_null()) { | 285 transport_client_->ProcessRtpPacket(std::move(packet)); |
373 VLOG(1) << "Stale packet received."; | |
374 return false; | |
375 } | |
376 packet_callback_.Run(std::move(packet)); | |
377 return true; | 286 return true; |
378 } | 287 } |
379 | 288 |
380 void CastTransportSenderImpl::OnReceivedLogMessage( | 289 void CastTransportSenderImpl::OnReceivedLogMessage( |
381 EventMediaType media_type, | 290 EventMediaType media_type, |
382 const RtcpReceiverLogMessage& log) { | 291 const RtcpReceiverLogMessage& log) { |
383 if (raw_events_callback_.is_null()) | 292 if (logging_flush_interval_ <= base::TimeDelta()) |
384 return; | 293 return; |
385 | 294 |
386 // Add received log messages into our log system. | 295 // Add received log messages into our log system. |
387 for (const RtcpReceiverFrameLogMessage& frame_log_message : log) { | 296 for (const RtcpReceiverFrameLogMessage& frame_log_message : log) { |
388 for (const RtcpReceiverEventLogMessage& event_log_message : | 297 for (const RtcpReceiverEventLogMessage& event_log_message : |
389 frame_log_message.event_log_messages_) { | 298 frame_log_message.event_log_messages_) { |
390 switch (event_log_message.type) { | 299 switch (event_log_message.type) { |
391 case PACKET_RECEIVED: { | 300 case PACKET_RECEIVED: { |
392 recent_packet_events_.push_back(PacketEvent()); | 301 recent_packet_events_.push_back(PacketEvent()); |
393 PacketEvent& receive_event = recent_packet_events_.back(); | 302 PacketEvent& receive_event = recent_packet_events_.back(); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
453 ResendPackets(ssrc, | 362 ResendPackets(ssrc, |
454 cast_message.missing_frames_and_packets, | 363 cast_message.missing_frames_and_packets, |
455 true, | 364 true, |
456 dedup_info); | 365 dedup_info); |
457 } | 366 } |
458 | 367 |
459 void CastTransportSenderImpl::AddValidSsrc(uint32_t ssrc) { | 368 void CastTransportSenderImpl::AddValidSsrc(uint32_t ssrc) { |
460 valid_ssrcs_.insert(ssrc); | 369 valid_ssrcs_.insert(ssrc); |
461 } | 370 } |
462 | 371 |
372 PacedSender* CastTransportSenderImpl::GetPacedSender() { | |
373 return &pacer_; | |
374 } | |
375 | |
376 void CastTransportSenderImpl::SetWifiOptions(int wifi_options) { | |
377 wifi_options_autoreset_ = net::SetWifiOptions(wifi_options); | |
378 } | |
379 | |
463 // TODO(isheriff): This interface needs clean up. | 380 // TODO(isheriff): This interface needs clean up. |
464 // https://crbug.com/569259 | 381 // https://crbug.com/569259 |
465 void CastTransportSenderImpl::SendRtcpFromRtpReceiver( | 382 void CastTransportSenderImpl::SendRtcpFromRtpReceiver( |
466 uint32_t ssrc, | 383 uint32_t ssrc, |
467 uint32_t sender_ssrc, | 384 uint32_t sender_ssrc, |
468 const RtcpTimeData& time_data, | 385 const RtcpTimeData& time_data, |
469 const RtcpCastMessage* cast_message, | 386 const RtcpCastMessage* cast_message, |
470 base::TimeDelta target_delay, | 387 base::TimeDelta target_delay, |
471 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events, | 388 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events, |
472 const RtpReceiverStatistics* rtp_receiver_statistics) { | 389 const RtpReceiverStatistics* rtp_receiver_statistics) { |
473 const ReceiverRtcpSession rtcp(clock_, &pacer_, ssrc, sender_ssrc); | 390 const ReceiverRtcpSession rtcp(clock_, &pacer_, ssrc, sender_ssrc); |
474 rtcp.SendRtcpReport(time_data, cast_message, target_delay, rtcp_events, | 391 rtcp.SendRtcpReport(time_data, cast_message, target_delay, rtcp_events, |
475 rtp_receiver_statistics); | 392 rtp_receiver_statistics); |
476 } | 393 } |
477 | 394 |
478 } // namespace cast | 395 } // namespace cast |
479 } // namespace media | 396 } // namespace media |
OLD | NEW |