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. | 24 // Options for PaceSender. |
28 const char kOptionDscp[] = "DSCP"; | 25 const char kOptionPacerMaxBurstSize[] = "pacer_max_burst_size"; |
29 #if defined(OS_WIN) | |
30 const char kOptionDisableNonBlockingIO[] = "disable_non_blocking_io"; | |
31 #endif | |
32 const char kOptionPacerTargetBurstSize[] = "pacer_target_burst_size"; | 26 const char kOptionPacerTargetBurstSize[] = "pacer_target_burst_size"; |
33 const char kOptionPacerMaxBurstSize[] = "pacer_max_burst_size"; | 27 |
34 const char kOptionSendBufferMinSize[] = "send_buffer_min_size"; | 28 // Wifi options. |
35 const char kOptionWifiDisableScan[] = "disable_wifi_scan"; | 29 const char kOptionWifiDisableScan[] = "disable_wifi_scan"; |
36 const char kOptionWifiMediaStreamingMode[] = "media_streaming_mode"; | 30 const char kOptionWifiMediaStreamingMode[] = "media_streaming_mode"; |
37 | 31 |
38 int LookupOptionWithDefault(const base::DictionaryValue& options, | 32 int LookupOptionWithDefault(const base::DictionaryValue& options, |
39 const std::string& path, | 33 const std::string& path, |
40 int default_value) { | 34 int default_value) { |
41 int ret; | 35 int ret; |
42 if (options.GetInteger(path, &ret)) { | 36 if (options.GetInteger(path, &ret)) { |
43 return ret; | 37 return ret; |
44 } else { | 38 } else { |
45 return default_value; | 39 return default_value; |
46 } | 40 } |
47 } | 41 } |
48 | 42 |
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 | |
61 } // namespace | 43 } // namespace |
62 | 44 |
63 scoped_ptr<CastTransportSender> CastTransportSender::Create( | 45 scoped_ptr<CastTransportSender> CastTransportSender::Create( |
64 net::NetLog* net_log, | 46 base::TickClock* clock, // Owned by the caller. |
65 base::TickClock* clock, | 47 base::TimeDelta logging_flush_interval, |
66 const net::IPEndPoint& local_end_point, | 48 scoped_ptr<Client> client, |
67 const net::IPEndPoint& remote_end_point, | 49 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) { | 50 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) { |
74 return scoped_ptr<CastTransportSender>(new CastTransportSenderImpl( | 51 return scoped_ptr<CastTransportSender>(new CastTransportSenderImpl( |
75 net_log, clock, local_end_point, remote_end_point, std::move(options), | 52 clock, logging_flush_interval, std::move(client), std::move(transport), |
76 status_callback, raw_events_callback, raw_events_callback_interval, | 53 transport_task_runner.get())); |
77 transport_task_runner.get(), packet_callback, NULL)); | |
78 } | 54 } |
79 | 55 |
80 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() { | 56 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() { |
81 return PacketReceiverCallback(); | 57 return PacketReceiverCallback(); |
82 } | 58 } |
83 | 59 |
84 CastTransportSenderImpl::CastTransportSenderImpl( | 60 CastTransportSenderImpl::CastTransportSenderImpl( |
85 net::NetLog* net_log, | |
86 base::TickClock* clock, | 61 base::TickClock* clock, |
87 const net::IPEndPoint& local_end_point, | 62 base::TimeDelta logging_flush_interval, |
88 const net::IPEndPoint& remote_end_point, | 63 scoped_ptr<Client> client, |
89 scoped_ptr<base::DictionaryValue> options, | 64 scoped_ptr<PacketSender> transport, |
90 const CastTransportStatusCallback& status_callback, | 65 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), | 66 : clock_(clock), |
97 status_callback_(status_callback), | 67 logging_flush_interval_(logging_flush_interval), |
| 68 transport_client_(std::move(client)), |
| 69 transport_(std::move(transport)), |
98 transport_task_runner_(transport_task_runner), | 70 transport_task_runner_(transport_task_runner), |
99 transport_(external_transport | 71 pacer_(kTargetBurstSize, |
100 ? nullptr | 72 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, | 73 clock, |
114 raw_events_callback.is_null() ? nullptr : &recent_packet_events_, | 74 logging_flush_interval > base::TimeDelta() ? &recent_packet_events_ |
115 external_transport ? external_transport : transport_.get(), | 75 : nullptr, |
| 76 transport_.get(), |
116 transport_task_runner), | 77 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), | 78 last_byte_acked_for_audio_(0), |
120 packet_callback_(packet_callback), | |
121 weak_factory_(this) { | 79 weak_factory_(this) { |
122 DCHECK(clock_); | 80 DCHECK(clock); |
123 if (!raw_events_callback_.is_null()) { | 81 DCHECK(transport_client_); |
124 DCHECK(raw_events_callback_interval > base::TimeDelta()); | 82 DCHECK(transport_); |
125 transport_task_runner->PostDelayedTask( | 83 DCHECK(transport_task_runner_); |
126 FROM_HERE, | 84 if (logging_flush_interval_ > base::TimeDelta()) { |
127 base::Bind(&CastTransportSenderImpl::SendRawEvents, | 85 transport_task_runner_->PostDelayedTask( |
128 weak_factory_.GetWeakPtr()), | 86 FROM_HERE, base::Bind(&CastTransportSenderImpl::SendRawEvents, |
129 raw_events_callback_interval); | 87 weak_factory_.GetWeakPtr()), |
| 88 logging_flush_interval_); |
130 } | 89 } |
131 if (transport_) { | 90 transport_->StartReceiving(base::Bind( |
132 if (options->HasKey(kOptionDscp)) { | 91 &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 } | 92 } |
157 | 93 |
158 CastTransportSenderImpl::~CastTransportSenderImpl() { | 94 CastTransportSenderImpl::~CastTransportSenderImpl() { |
159 if (transport_) { | 95 transport_->StopReceiving(); |
160 transport_->StopReceiving(); | |
161 } | |
162 } | 96 } |
163 | 97 |
164 void CastTransportSenderImpl::InitializeAudio( | 98 void CastTransportSenderImpl::InitializeAudio( |
165 const CastTransportRtpConfig& config, | 99 const CastTransportRtpConfig& config, |
166 const RtcpCastMessageCallback& cast_message_cb, | 100 const RtcpCastMessageCallback& cast_message_cb, |
167 const RtcpRttCallback& rtt_cb) { | 101 const RtcpRttCallback& rtt_cb) { |
168 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) | 102 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) |
169 << "Unsafe to send audio with encryption DISABLED."; | 103 << "Unsafe to send audio with encryption DISABLED."; |
170 if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { | 104 if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { |
171 status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED); | 105 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED); |
172 return; | 106 return; |
173 } | 107 } |
174 | 108 |
175 audio_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); | 109 audio_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); |
176 if (audio_sender_->Initialize(config)) { | 110 if (audio_sender_->Initialize(config)) { |
177 // Audio packets have a higher priority. | 111 // Audio packets have a higher priority. |
178 pacer_.RegisterAudioSsrc(config.ssrc); | 112 pacer_.RegisterAudioSsrc(config.ssrc); |
179 pacer_.RegisterPrioritySsrc(config.ssrc); | 113 pacer_.RegisterPrioritySsrc(config.ssrc); |
180 status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED); | 114 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED); |
181 } else { | 115 } else { |
182 audio_sender_.reset(); | 116 audio_sender_.reset(); |
183 status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED); | 117 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED); |
184 return; | 118 return; |
185 } | 119 } |
186 | 120 |
187 audio_rtcp_session_.reset(new SenderRtcpSession( | 121 audio_rtcp_session_.reset(new SenderRtcpSession( |
188 base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage, | 122 base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage, |
189 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), | 123 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), |
190 rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, | 124 rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, |
191 weak_factory_.GetWeakPtr(), AUDIO_EVENT), | 125 weak_factory_.GetWeakPtr(), AUDIO_EVENT), |
192 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); | 126 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); |
193 pacer_.RegisterAudioSsrc(config.ssrc); | 127 pacer_.RegisterAudioSsrc(config.ssrc); |
194 AddValidSsrc(config.feedback_ssrc); | 128 AddValidSsrc(config.feedback_ssrc); |
195 status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED); | 129 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED); |
196 } | 130 } |
197 | 131 |
198 void CastTransportSenderImpl::InitializeVideo( | 132 void CastTransportSenderImpl::InitializeVideo( |
199 const CastTransportRtpConfig& config, | 133 const CastTransportRtpConfig& config, |
200 const RtcpCastMessageCallback& cast_message_cb, | 134 const RtcpCastMessageCallback& cast_message_cb, |
201 const RtcpRttCallback& rtt_cb) { | 135 const RtcpRttCallback& rtt_cb) { |
202 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) | 136 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) |
203 << "Unsafe to send video with encryption DISABLED."; | 137 << "Unsafe to send video with encryption DISABLED."; |
204 if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { | 138 if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { |
205 status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED); | 139 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED); |
206 return; | 140 return; |
207 } | 141 } |
208 | 142 |
209 video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); | 143 video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); |
210 if (!video_sender_->Initialize(config)) { | 144 if (!video_sender_->Initialize(config)) { |
211 video_sender_.reset(); | 145 video_sender_.reset(); |
212 status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED); | 146 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED); |
213 return; | 147 return; |
214 } | 148 } |
215 | 149 |
216 video_rtcp_session_.reset(new SenderRtcpSession( | 150 video_rtcp_session_.reset(new SenderRtcpSession( |
217 base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage, | 151 base::Bind(&CastTransportSenderImpl::OnReceivedCastMessage, |
218 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), | 152 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), |
219 rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, | 153 rtt_cb, base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, |
220 weak_factory_.GetWeakPtr(), VIDEO_EVENT), | 154 weak_factory_.GetWeakPtr(), VIDEO_EVENT), |
221 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); | 155 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); |
222 pacer_.RegisterVideoSsrc(config.ssrc); | 156 pacer_.RegisterVideoSsrc(config.ssrc); |
223 AddValidSsrc(config.feedback_ssrc); | 157 AddValidSsrc(config.feedback_ssrc); |
224 status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED); | 158 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_INITIALIZED); |
225 } | 159 } |
226 | 160 |
227 namespace { | 161 namespace { |
228 void EncryptAndSendFrame(const EncodedFrame& frame, | 162 void EncryptAndSendFrame(const EncodedFrame& frame, |
229 TransportEncryptionHandler* encryptor, | 163 TransportEncryptionHandler* encryptor, |
230 RtpSender* sender) { | 164 RtpSender* sender) { |
231 // TODO(miu): We probably shouldn't attempt to send an empty frame, but this | 165 // TODO(miu): We probably shouldn't attempt to send an empty frame, but this |
232 // issue is still under investigation. http://crbug.com/519022 | 166 // issue is still under investigation. http://crbug.com/519022 |
233 if (encryptor->is_activated() && !frame.data.empty()) { | 167 if (encryptor->is_activated() && !frame.data.empty()) { |
234 EncodedFrame encrypted_frame; | 168 EncodedFrame encrypted_frame; |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
320 } | 254 } |
321 } | 255 } |
322 | 256 |
323 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() { | 257 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() { |
324 return base::Bind( | 258 return base::Bind( |
325 base::IgnoreResult(&CastTransportSenderImpl::OnReceivedPacket), | 259 base::IgnoreResult(&CastTransportSenderImpl::OnReceivedPacket), |
326 weak_factory_.GetWeakPtr()); | 260 weak_factory_.GetWeakPtr()); |
327 } | 261 } |
328 | 262 |
329 void CastTransportSenderImpl::SendRawEvents() { | 263 void CastTransportSenderImpl::SendRawEvents() { |
330 DCHECK(!raw_events_callback_.is_null()); | 264 DCHECK(logging_flush_interval_ > base::TimeDelta()); |
331 | 265 |
332 if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) { | 266 if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) { |
333 scoped_ptr<std::vector<FrameEvent>> frame_events( | 267 scoped_ptr<std::vector<FrameEvent>> frame_events( |
334 new std::vector<FrameEvent>()); | 268 new std::vector<FrameEvent>()); |
335 frame_events->swap(recent_frame_events_); | 269 frame_events->swap(recent_frame_events_); |
336 scoped_ptr<std::vector<PacketEvent>> packet_events( | 270 scoped_ptr<std::vector<PacketEvent>> packet_events( |
337 new std::vector<PacketEvent>()); | 271 new std::vector<PacketEvent>()); |
338 packet_events->swap(recent_packet_events_); | 272 packet_events->swap(recent_packet_events_); |
339 raw_events_callback_.Run(std::move(frame_events), std::move(packet_events)); | 273 transport_client_->OnLoggingEventsReceived(std::move(frame_events), |
| 274 std::move(packet_events)); |
340 } | 275 } |
341 | 276 |
342 transport_task_runner_->PostDelayedTask( | 277 transport_task_runner_->PostDelayedTask( |
343 FROM_HERE, | 278 FROM_HERE, base::Bind(&CastTransportSenderImpl::SendRawEvents, |
344 base::Bind(&CastTransportSenderImpl::SendRawEvents, | 279 weak_factory_.GetWeakPtr()), |
345 weak_factory_.GetWeakPtr()), | 280 logging_flush_interval_); |
346 raw_events_callback_interval_); | |
347 } | 281 } |
348 | 282 |
349 bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) { | 283 bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) { |
350 const uint8_t* const data = &packet->front(); | 284 const uint8_t* const data = &packet->front(); |
351 const size_t length = packet->size(); | 285 const size_t length = packet->size(); |
352 uint32_t ssrc; | 286 uint32_t ssrc; |
353 if (IsRtcpPacket(data, length)) { | 287 if (IsRtcpPacket(data, length)) { |
354 ssrc = GetSsrcOfSender(data, length); | 288 ssrc = GetSsrcOfSender(data, length); |
355 } else if (!RtpParser::ParseSsrc(data, length, &ssrc)) { | 289 } else if (!RtpParser::ParseSsrc(data, length, &ssrc)) { |
356 VLOG(1) << "Invalid RTP packet."; | 290 VLOG(1) << "Invalid RTP packet."; |
357 return false; | 291 return false; |
358 } | 292 } |
359 if (valid_ssrcs_.find(ssrc) == valid_ssrcs_.end()) { | 293 if (valid_ssrcs_.find(ssrc) == valid_ssrcs_.end()) { |
360 VLOG(1) << "Stale packet received."; | 294 VLOG(1) << "Stale packet received."; |
361 return false; | 295 return false; |
362 } | 296 } |
363 | 297 |
364 if (audio_rtcp_session_ && | 298 if (audio_rtcp_session_ && |
365 audio_rtcp_session_->IncomingRtcpPacket(data, length)) { | 299 audio_rtcp_session_->IncomingRtcpPacket(data, length)) { |
366 return true; | 300 return true; |
367 } | 301 } |
368 if (video_rtcp_session_ && | 302 if (video_rtcp_session_ && |
369 video_rtcp_session_->IncomingRtcpPacket(data, length)) { | 303 video_rtcp_session_->IncomingRtcpPacket(data, length)) { |
370 return true; | 304 return true; |
371 } | 305 } |
372 if (packet_callback_.is_null()) { | 306 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; | 307 return true; |
378 } | 308 } |
379 | 309 |
380 void CastTransportSenderImpl::OnReceivedLogMessage( | 310 void CastTransportSenderImpl::OnReceivedLogMessage( |
381 EventMediaType media_type, | 311 EventMediaType media_type, |
382 const RtcpReceiverLogMessage& log) { | 312 const RtcpReceiverLogMessage& log) { |
383 if (raw_events_callback_.is_null()) | 313 if (logging_flush_interval_ <= base::TimeDelta()) |
384 return; | 314 return; |
385 | 315 |
386 // Add received log messages into our log system. | 316 // Add received log messages into our log system. |
387 for (const RtcpReceiverFrameLogMessage& frame_log_message : log) { | 317 for (const RtcpReceiverFrameLogMessage& frame_log_message : log) { |
388 for (const RtcpReceiverEventLogMessage& event_log_message : | 318 for (const RtcpReceiverEventLogMessage& event_log_message : |
389 frame_log_message.event_log_messages_) { | 319 frame_log_message.event_log_messages_) { |
390 switch (event_log_message.type) { | 320 switch (event_log_message.type) { |
391 case PACKET_RECEIVED: { | 321 case PACKET_RECEIVED: { |
392 recent_packet_events_.push_back(PacketEvent()); | 322 recent_packet_events_.push_back(PacketEvent()); |
393 PacketEvent& receive_event = recent_packet_events_.back(); | 323 PacketEvent& receive_event = recent_packet_events_.back(); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
453 ResendPackets(ssrc, | 383 ResendPackets(ssrc, |
454 cast_message.missing_frames_and_packets, | 384 cast_message.missing_frames_and_packets, |
455 true, | 385 true, |
456 dedup_info); | 386 dedup_info); |
457 } | 387 } |
458 | 388 |
459 void CastTransportSenderImpl::AddValidSsrc(uint32_t ssrc) { | 389 void CastTransportSenderImpl::AddValidSsrc(uint32_t ssrc) { |
460 valid_ssrcs_.insert(ssrc); | 390 valid_ssrcs_.insert(ssrc); |
461 } | 391 } |
462 | 392 |
| 393 void CastTransportSenderImpl::SetOptions(const base::DictionaryValue& options) { |
| 394 // Set PacedSender options. |
| 395 int burst_size = LookupOptionWithDefault(options, kOptionPacerTargetBurstSize, |
| 396 media::cast::kTargetBurstSize); |
| 397 if (burst_size != media::cast::kTargetBurstSize) |
| 398 pacer_.SetTargetBurstSize(burst_size); |
| 399 burst_size = LookupOptionWithDefault(options, kOptionPacerMaxBurstSize, |
| 400 media::cast::kMaxBurstSize); |
| 401 if (burst_size != media::cast::kMaxBurstSize) |
| 402 pacer_.SetMaxBurstSize(burst_size); |
| 403 |
| 404 // Set Wifi options. |
| 405 int wifi_options = 0; |
| 406 if (options.HasKey(kOptionWifiDisableScan)) { |
| 407 wifi_options |= net::WIFI_OPTIONS_DISABLE_SCAN; |
| 408 } |
| 409 if (options.HasKey(kOptionWifiMediaStreamingMode)) { |
| 410 wifi_options |= net::WIFI_OPTIONS_MEDIA_STREAMING_MODE; |
| 411 } |
| 412 if (wifi_options) |
| 413 wifi_options_autoreset_ = net::SetWifiOptions(wifi_options); |
| 414 } |
| 415 |
463 // TODO(isheriff): This interface needs clean up. | 416 // TODO(isheriff): This interface needs clean up. |
464 // https://crbug.com/569259 | 417 // https://crbug.com/569259 |
465 void CastTransportSenderImpl::SendRtcpFromRtpReceiver( | 418 void CastTransportSenderImpl::SendRtcpFromRtpReceiver( |
466 uint32_t ssrc, | 419 uint32_t ssrc, |
467 uint32_t sender_ssrc, | 420 uint32_t sender_ssrc, |
468 const RtcpTimeData& time_data, | 421 const RtcpTimeData& time_data, |
469 const RtcpCastMessage* cast_message, | 422 const RtcpCastMessage* cast_message, |
470 base::TimeDelta target_delay, | 423 base::TimeDelta target_delay, |
471 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events, | 424 const ReceiverRtcpEventSubscriber::RtcpEvents* rtcp_events, |
472 const RtpReceiverStatistics* rtp_receiver_statistics) { | 425 const RtpReceiverStatistics* rtp_receiver_statistics) { |
473 const ReceiverRtcpSession rtcp(clock_, &pacer_, ssrc, sender_ssrc); | 426 const ReceiverRtcpSession rtcp(clock_, &pacer_, ssrc, sender_ssrc); |
474 rtcp.SendRtcpReport(time_data, cast_message, target_delay, rtcp_events, | 427 rtcp.SendRtcpReport(time_data, cast_message, target_delay, rtcp_events, |
475 rtp_receiver_statistics); | 428 rtp_receiver_statistics); |
476 } | 429 } |
477 | 430 |
478 } // namespace cast | 431 } // namespace cast |
479 } // namespace media | 432 } // namespace media |
OLD | NEW |