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_impl.h" | 5 #include "media/cast/net/cast_transport_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/memory/ptr_util.h" | |
12 #include "base/single_thread_task_runner.h" | 13 #include "base/single_thread_task_runner.h" |
13 #include "build/build_config.h" | 14 #include "build/build_config.h" |
14 #include "media/cast/net/cast_transport_defines.h" | 15 #include "media/cast/net/cast_transport_defines.h" |
15 #include "media/cast/net/rtcp/sender_rtcp_session.h" | 16 #include "media/cast/net/rtcp/sender_rtcp_session.h" |
16 #include "net/base/net_errors.h" | 17 #include "net/base/net_errors.h" |
17 | 18 |
18 namespace media { | 19 namespace media { |
19 namespace cast { | 20 namespace cast { |
20 | 21 |
21 namespace { | 22 namespace { |
(...skipping 10 matching lines...) Expand all Loading... | |
32 const std::string& path, | 33 const std::string& path, |
33 int default_value) { | 34 int default_value) { |
34 int ret; | 35 int ret; |
35 if (options.GetInteger(path, &ret)) { | 36 if (options.GetInteger(path, &ret)) { |
36 return ret; | 37 return ret; |
37 } else { | 38 } else { |
38 return default_value; | 39 return default_value; |
39 } | 40 } |
40 } | 41 } |
41 | 42 |
43 class RtcpClient : public SenderRtcpSession::Client { | |
44 public: | |
45 RtcpClient(std::unique_ptr<RtpSenderRtcpClient> client, | |
46 uint32_t rtp_sender_ssrc, | |
47 EventMediaType media_type, | |
48 CastTransportImpl* const cast_transport_impl) | |
49 : rtp_sender_ssrc_(rtp_sender_ssrc), | |
50 sender_rtcp_client_(std::move(client)), | |
51 media_type_(media_type), | |
52 cast_transport_impl_(cast_transport_impl) {} | |
53 | |
54 void OnCastMessageReceived(const RtcpCastMessage& cast_message) override { | |
55 sender_rtcp_client_->OnCastMessageReceived(cast_message); | |
56 cast_transport_impl_->OnReceivedCastMessage(rtp_sender_ssrc_, cast_message); | |
57 } | |
58 | |
59 void OnRttReceived(base::TimeDelta round_trip_time) override { | |
60 sender_rtcp_client_->OnRttReceived(round_trip_time); | |
61 } | |
62 | |
63 void OnReceiverLogReceived(const RtcpReceiverLogMessage& log) override { | |
64 cast_transport_impl_->OnReceivedLogMessage(media_type_, log); | |
65 } | |
66 | |
67 void OnPliReceived() override { sender_rtcp_client_->OnPliReceived(); } | |
68 | |
69 private: | |
70 uint32_t rtp_sender_ssrc_; | |
miu
2016/04/15 23:14:39
ditto: All const, please.
xjz
2016/04/20 01:09:03
Done.
| |
71 const std::unique_ptr<RtpSenderRtcpClient> sender_rtcp_client_; | |
72 EventMediaType media_type_; | |
73 CastTransportImpl* const cast_transport_impl_; | |
74 | |
75 DISALLOW_COPY_AND_ASSIGN(RtcpClient); | |
76 }; | |
77 | |
42 } // namespace | 78 } // namespace |
43 | 79 |
44 scoped_ptr<CastTransport> CastTransport::Create( | 80 std::unique_ptr<CastTransport> CastTransport::Create( |
45 base::TickClock* clock, // Owned by the caller. | 81 base::TickClock* clock, // Owned by the caller. |
46 base::TimeDelta logging_flush_interval, | 82 base::TimeDelta logging_flush_interval, |
47 scoped_ptr<Client> client, | 83 std::unique_ptr<Client> client, |
48 scoped_ptr<PacketTransport> transport, | 84 std::unique_ptr<PacketTransport> transport, |
49 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) { | 85 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) { |
50 return scoped_ptr<CastTransport>( | 86 return std::unique_ptr<CastTransport>( |
51 new CastTransportImpl(clock, logging_flush_interval, std::move(client), | 87 new CastTransportImpl(clock, logging_flush_interval, std::move(client), |
52 std::move(transport), transport_task_runner.get())); | 88 std::move(transport), transport_task_runner.get())); |
53 } | 89 } |
54 | 90 |
55 PacketReceiverCallback CastTransport::PacketReceiverForTesting() { | 91 PacketReceiverCallback CastTransport::PacketReceiverForTesting() { |
56 return PacketReceiverCallback(); | 92 return PacketReceiverCallback(); |
57 } | 93 } |
58 | 94 |
59 CastTransportImpl::CastTransportImpl( | 95 CastTransportImpl::CastTransportImpl( |
60 base::TickClock* clock, | 96 base::TickClock* clock, |
61 base::TimeDelta logging_flush_interval, | 97 base::TimeDelta logging_flush_interval, |
62 scoped_ptr<Client> client, | 98 std::unique_ptr<Client> client, |
63 scoped_ptr<PacketTransport> transport, | 99 std::unique_ptr<PacketTransport> transport, |
64 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) | 100 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) |
65 : clock_(clock), | 101 : clock_(clock), |
66 logging_flush_interval_(logging_flush_interval), | 102 logging_flush_interval_(logging_flush_interval), |
67 transport_client_(std::move(client)), | 103 transport_client_(std::move(client)), |
68 transport_(std::move(transport)), | 104 transport_(std::move(transport)), |
69 transport_task_runner_(transport_task_runner), | 105 transport_task_runner_(transport_task_runner), |
70 pacer_(kTargetBurstSize, | 106 pacer_(kTargetBurstSize, |
71 kMaxBurstSize, | 107 kMaxBurstSize, |
72 clock, | 108 clock, |
73 logging_flush_interval > base::TimeDelta() ? &recent_packet_events_ | 109 logging_flush_interval > base::TimeDelta() ? &recent_packet_events_ |
(...skipping 15 matching lines...) Expand all Loading... | |
89 transport_->StartReceiving( | 125 transport_->StartReceiving( |
90 base::Bind(&CastTransportImpl::OnReceivedPacket, base::Unretained(this))); | 126 base::Bind(&CastTransportImpl::OnReceivedPacket, base::Unretained(this))); |
91 } | 127 } |
92 | 128 |
93 CastTransportImpl::~CastTransportImpl() { | 129 CastTransportImpl::~CastTransportImpl() { |
94 transport_->StopReceiving(); | 130 transport_->StopReceiving(); |
95 } | 131 } |
96 | 132 |
97 void CastTransportImpl::InitializeAudio( | 133 void CastTransportImpl::InitializeAudio( |
98 const CastTransportRtpConfig& config, | 134 const CastTransportRtpConfig& config, |
99 const RtcpCastMessageCallback& cast_message_cb, | 135 std::unique_ptr<RtpSenderRtcpClient> rtcp_client) { |
100 const RtcpRttCallback& rtt_cb, | |
101 const RtcpPliCallback& pli_cb) { | |
102 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()) |
103 << "Unsafe to send audio with encryption DISABLED."; | 137 << "Unsafe to send audio with encryption DISABLED."; |
104 if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { | 138 if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { |
105 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED); | 139 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED); |
106 return; | 140 return; |
107 } | 141 } |
108 | 142 |
109 audio_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); | 143 audio_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); |
110 if (audio_sender_->Initialize(config)) { | 144 if (audio_sender_->Initialize(config)) { |
111 // Audio packets have a higher priority. | 145 // Audio packets have a higher priority. |
112 pacer_.RegisterAudioSsrc(config.ssrc); | 146 pacer_.RegisterAudioSsrc(config.ssrc); |
113 pacer_.RegisterPrioritySsrc(config.ssrc); | 147 pacer_.RegisterPrioritySsrc(config.ssrc); |
114 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED); | 148 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED); |
115 } else { | 149 } else { |
116 audio_sender_.reset(); | 150 audio_sender_.reset(); |
117 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED); | 151 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_UNINITIALIZED); |
118 return; | 152 return; |
119 } | 153 } |
120 | 154 |
121 audio_rtcp_session_.reset(new SenderRtcpSession( | 155 audio_rtcp_session_.reset(new SenderRtcpSession( |
122 base::Bind(&CastTransportImpl::OnReceivedCastMessage, | 156 base::WrapUnique(new RtcpClient(std::move(rtcp_client), config.ssrc, |
123 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), | 157 AUDIO_EVENT, this)), |
124 rtt_cb, base::Bind(&CastTransportImpl::OnReceivedLogMessage, | 158 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); |
125 weak_factory_.GetWeakPtr(), AUDIO_EVENT), | |
126 pli_cb, clock_, &pacer_, config.ssrc, config.feedback_ssrc)); | |
127 pacer_.RegisterAudioSsrc(config.ssrc); | 159 pacer_.RegisterAudioSsrc(config.ssrc); |
128 valid_sender_ssrcs_.insert(config.feedback_ssrc); | 160 valid_sender_ssrcs_.insert(config.feedback_ssrc); |
129 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED); | 161 transport_client_->OnStatusChanged(TRANSPORT_AUDIO_INITIALIZED); |
130 } | 162 } |
131 | 163 |
132 void CastTransportImpl::InitializeVideo( | 164 void CastTransportImpl::InitializeVideo( |
133 const CastTransportRtpConfig& config, | 165 const CastTransportRtpConfig& config, |
134 const RtcpCastMessageCallback& cast_message_cb, | 166 std::unique_ptr<RtpSenderRtcpClient> rtcp_client) { |
135 const RtcpRttCallback& rtt_cb, | |
136 const RtcpPliCallback& pli_cb) { | |
137 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) | 167 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) |
138 << "Unsafe to send video with encryption DISABLED."; | 168 << "Unsafe to send video with encryption DISABLED."; |
139 if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { | 169 if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { |
140 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED); | 170 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED); |
141 return; | 171 return; |
142 } | 172 } |
143 | 173 |
144 video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); | 174 video_sender_.reset(new RtpSender(transport_task_runner_, &pacer_)); |
145 if (!video_sender_->Initialize(config)) { | 175 if (!video_sender_->Initialize(config)) { |
146 video_sender_.reset(); | 176 video_sender_.reset(); |
147 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED); | 177 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_UNINITIALIZED); |
148 return; | 178 return; |
149 } | 179 } |
150 | 180 |
151 video_rtcp_session_.reset(new SenderRtcpSession( | 181 video_rtcp_session_.reset(new SenderRtcpSession( |
152 base::Bind(&CastTransportImpl::OnReceivedCastMessage, | 182 base::WrapUnique(new RtcpClient(std::move(rtcp_client), config.ssrc, |
153 weak_factory_.GetWeakPtr(), config.ssrc, cast_message_cb), | 183 VIDEO_EVENT, this)), |
154 rtt_cb, base::Bind(&CastTransportImpl::OnReceivedLogMessage, | 184 clock_, &pacer_, config.ssrc, config.feedback_ssrc)); |
155 weak_factory_.GetWeakPtr(), VIDEO_EVENT), | |
156 pli_cb, clock_, &pacer_, config.ssrc, config.feedback_ssrc)); | |
157 pacer_.RegisterVideoSsrc(config.ssrc); | 185 pacer_.RegisterVideoSsrc(config.ssrc); |
158 valid_sender_ssrcs_.insert(config.feedback_ssrc); | 186 valid_sender_ssrcs_.insert(config.feedback_ssrc); |
159 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_INITIALIZED); | 187 transport_client_->OnStatusChanged(TRANSPORT_VIDEO_INITIALIZED); |
160 } | 188 } |
161 | 189 |
162 namespace { | 190 namespace { |
163 void EncryptAndSendFrame(const EncodedFrame& frame, | 191 void EncryptAndSendFrame(const EncodedFrame& frame, |
164 TransportEncryptionHandler* encryptor, | 192 TransportEncryptionHandler* encryptor, |
165 RtpSender* sender) { | 193 RtpSender* sender) { |
166 // TODO(miu): We probably shouldn't attempt to send an empty frame, but this | 194 // TODO(miu): We probably shouldn't attempt to send an empty frame, but this |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
252 | 280 |
253 PacketReceiverCallback CastTransportImpl::PacketReceiverForTesting() { | 281 PacketReceiverCallback CastTransportImpl::PacketReceiverForTesting() { |
254 return base::Bind(base::IgnoreResult(&CastTransportImpl::OnReceivedPacket), | 282 return base::Bind(base::IgnoreResult(&CastTransportImpl::OnReceivedPacket), |
255 weak_factory_.GetWeakPtr()); | 283 weak_factory_.GetWeakPtr()); |
256 } | 284 } |
257 | 285 |
258 void CastTransportImpl::SendRawEvents() { | 286 void CastTransportImpl::SendRawEvents() { |
259 DCHECK(logging_flush_interval_ > base::TimeDelta()); | 287 DCHECK(logging_flush_interval_ > base::TimeDelta()); |
260 | 288 |
261 if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) { | 289 if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) { |
262 scoped_ptr<std::vector<FrameEvent>> frame_events( | 290 std::unique_ptr<std::vector<FrameEvent>> frame_events( |
263 new std::vector<FrameEvent>()); | 291 new std::vector<FrameEvent>()); |
264 frame_events->swap(recent_frame_events_); | 292 frame_events->swap(recent_frame_events_); |
265 scoped_ptr<std::vector<PacketEvent>> packet_events( | 293 std::unique_ptr<std::vector<PacketEvent>> packet_events( |
266 new std::vector<PacketEvent>()); | 294 new std::vector<PacketEvent>()); |
267 packet_events->swap(recent_packet_events_); | 295 packet_events->swap(recent_packet_events_); |
268 transport_client_->OnLoggingEventsReceived(std::move(frame_events), | 296 transport_client_->OnLoggingEventsReceived(std::move(frame_events), |
269 std::move(packet_events)); | 297 std::move(packet_events)); |
270 } | 298 } |
271 | 299 |
272 transport_task_runner_->PostDelayedTask( | 300 transport_task_runner_->PostDelayedTask( |
273 FROM_HERE, | 301 FROM_HERE, |
274 base::Bind(&CastTransportImpl::SendRawEvents, weak_factory_.GetWeakPtr()), | 302 base::Bind(&CastTransportImpl::SendRawEvents, weak_factory_.GetWeakPtr()), |
275 logging_flush_interval_); | 303 logging_flush_interval_); |
276 } | 304 } |
277 | 305 |
278 bool CastTransportImpl::OnReceivedPacket(scoped_ptr<Packet> packet) { | 306 bool CastTransportImpl::OnReceivedPacket(std::unique_ptr<Packet> packet) { |
279 const uint8_t* const data = &packet->front(); | 307 const uint8_t* const data = &packet->front(); |
280 const size_t length = packet->size(); | 308 const size_t length = packet->size(); |
281 uint32_t ssrc; | 309 uint32_t ssrc; |
282 if (IsRtcpPacket(data, length)) { | 310 if (IsRtcpPacket(data, length)) { |
283 ssrc = GetSsrcOfSender(data, length); | 311 ssrc = GetSsrcOfSender(data, length); |
284 } else if (!RtpParser::ParseSsrc(data, length, &ssrc)) { | 312 } else if (!RtpParser::ParseSsrc(data, length, &ssrc)) { |
285 VLOG(1) << "Invalid RTP packet."; | 313 VLOG(1) << "Invalid RTP packet."; |
286 return false; | 314 return false; |
287 } | 315 } |
288 if (valid_sender_ssrcs_.find(ssrc) == valid_sender_ssrcs_.end()) { | 316 if (valid_sender_ssrcs_.find(ssrc) == valid_sender_ssrcs_.end()) { |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
340 VLOG(2) << "Received log message via RTCP that we did not expect: " | 368 VLOG(2) << "Received log message via RTCP that we did not expect: " |
341 << event_log_message.type; | 369 << event_log_message.type; |
342 break; | 370 break; |
343 } | 371 } |
344 } | 372 } |
345 } | 373 } |
346 } | 374 } |
347 | 375 |
348 void CastTransportImpl::OnReceivedCastMessage( | 376 void CastTransportImpl::OnReceivedCastMessage( |
349 uint32_t ssrc, | 377 uint32_t ssrc, |
350 const RtcpCastMessageCallback& cast_message_cb, | |
351 const RtcpCastMessage& cast_message) { | 378 const RtcpCastMessage& cast_message) { |
352 if (!cast_message_cb.is_null()) | |
353 cast_message_cb.Run(cast_message); | |
354 | 379 |
355 DedupInfo dedup_info; | 380 DedupInfo dedup_info; |
356 if (audio_sender_ && audio_sender_->ssrc() == ssrc) { | 381 if (audio_sender_ && audio_sender_->ssrc() == ssrc) { |
357 const int64_t acked_bytes = | 382 const int64_t acked_bytes = |
358 audio_sender_->GetLastByteSentForFrame(cast_message.ack_frame_id); | 383 audio_sender_->GetLastByteSentForFrame(cast_message.ack_frame_id); |
359 last_byte_acked_for_audio_ = | 384 last_byte_acked_for_audio_ = |
360 std::max(acked_bytes, last_byte_acked_for_audio_); | 385 std::max(acked_bytes, last_byte_acked_for_audio_); |
361 } else if (video_sender_ && video_sender_->ssrc() == ssrc) { | 386 } else if (video_sender_ && video_sender_->ssrc() == ssrc) { |
362 dedup_info.resend_interval = video_rtcp_session_->current_round_trip_time(); | 387 dedup_info.resend_interval = video_rtcp_session_->current_round_trip_time(); |
363 | 388 |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
481 "calling CastTransportImpl::SendRtcpFromRtpReceiver."; | 506 "calling CastTransportImpl::SendRtcpFromRtpReceiver."; |
482 return; | 507 return; |
483 } | 508 } |
484 pacer_.SendRtcpPacket(rtcp_builder_at_rtp_receiver_->local_ssrc(), | 509 pacer_.SendRtcpPacket(rtcp_builder_at_rtp_receiver_->local_ssrc(), |
485 rtcp_builder_at_rtp_receiver_->Finish()); | 510 rtcp_builder_at_rtp_receiver_->Finish()); |
486 rtcp_builder_at_rtp_receiver_.reset(); | 511 rtcp_builder_at_rtp_receiver_.reset(); |
487 } | 512 } |
488 | 513 |
489 } // namespace cast | 514 } // namespace cast |
490 } // namespace media | 515 } // namespace media |
OLD | NEW |