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 "base/single_thread_task_runner.h" | 7 #include "base/single_thread_task_runner.h" |
8 #include "media/cast/net/cast_transport_config.h" | 8 #include "media/cast/net/cast_transport_config.h" |
9 #include "media/cast/net/cast_transport_defines.h" | 9 #include "media/cast/net/cast_transport_defines.h" |
10 #include "media/cast/net/udp_transport.h" | 10 #include "media/cast/net/udp_transport.h" |
(...skipping 14 matching lines...) Expand all Loading... |
25 new CastTransportSenderImpl(net_log, | 25 new CastTransportSenderImpl(net_log, |
26 clock, | 26 clock, |
27 remote_end_point, | 27 remote_end_point, |
28 status_callback, | 28 status_callback, |
29 raw_events_callback, | 29 raw_events_callback, |
30 raw_events_callback_interval, | 30 raw_events_callback_interval, |
31 transport_task_runner.get(), | 31 transport_task_runner.get(), |
32 NULL)); | 32 NULL)); |
33 } | 33 } |
34 | 34 |
| 35 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() { |
| 36 return PacketReceiverCallback(); |
| 37 } |
| 38 |
35 CastTransportSenderImpl::CastTransportSenderImpl( | 39 CastTransportSenderImpl::CastTransportSenderImpl( |
36 net::NetLog* net_log, | 40 net::NetLog* net_log, |
37 base::TickClock* clock, | 41 base::TickClock* clock, |
38 const net::IPEndPoint& remote_end_point, | 42 const net::IPEndPoint& remote_end_point, |
39 const CastTransportStatusCallback& status_callback, | 43 const CastTransportStatusCallback& status_callback, |
40 const BulkRawEventsCallback& raw_events_callback, | 44 const BulkRawEventsCallback& raw_events_callback, |
41 base::TimeDelta raw_events_callback_interval, | 45 base::TimeDelta raw_events_callback_interval, |
42 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner, | 46 const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner, |
43 PacketSender* external_transport) | 47 PacketSender* external_transport) |
44 : clock_(clock), | 48 : clock_(clock), |
45 status_callback_(status_callback), | 49 status_callback_(status_callback), |
46 transport_task_runner_(transport_task_runner), | 50 transport_task_runner_(transport_task_runner), |
47 transport_(external_transport ? NULL | 51 transport_(external_transport ? NULL |
48 : new UdpTransport(net_log, | 52 : new UdpTransport(net_log, |
49 transport_task_runner, | 53 transport_task_runner, |
50 net::IPEndPoint(), | 54 net::IPEndPoint(), |
51 remote_end_point, | 55 remote_end_point, |
52 status_callback)), | 56 status_callback)), |
53 logging_(), | |
54 pacer_(clock, | 57 pacer_(clock, |
55 &logging_, | 58 &logging_, |
56 external_transport ? external_transport : transport_.get(), | 59 external_transport ? external_transport : transport_.get(), |
57 transport_task_runner), | 60 transport_task_runner), |
58 rtcp_builder_(&pacer_), | 61 raw_events_callback_(raw_events_callback), |
59 raw_events_callback_(raw_events_callback) { | 62 raw_events_callback_interval_(raw_events_callback_interval), |
| 63 weak_factory_(this) { |
60 DCHECK(clock_); | 64 DCHECK(clock_); |
61 if (!raw_events_callback_.is_null()) { | 65 if (!raw_events_callback_.is_null()) { |
62 DCHECK(raw_events_callback_interval > base::TimeDelta()); | 66 DCHECK(raw_events_callback_interval > base::TimeDelta()); |
63 event_subscriber_.reset(new SimpleEventSubscriber); | 67 event_subscriber_.reset(new SimpleEventSubscriber); |
64 logging_.AddRawEventSubscriber(event_subscriber_.get()); | 68 logging_.AddRawEventSubscriber(event_subscriber_.get()); |
65 raw_events_timer_.Start(FROM_HERE, | 69 transport_task_runner->PostDelayedTask( |
66 raw_events_callback_interval, | 70 FROM_HERE, |
67 this, | 71 base::Bind(&CastTransportSenderImpl::SendRawEvents, |
68 &CastTransportSenderImpl::SendRawEvents); | 72 weak_factory_.GetWeakPtr()), |
| 73 raw_events_callback_interval); |
69 } | 74 } |
70 if (transport_) { | 75 if (transport_) { |
71 // The default DSCP value for cast is AF41. Which gives it a higher | 76 // The default DSCP value for cast is AF41. Which gives it a higher |
72 // priority over other traffic. | 77 // priority over other traffic. |
73 transport_->SetDscp(net::DSCP_AF41); | 78 transport_->SetDscp(net::DSCP_AF41); |
74 } | 79 } |
75 } | 80 } |
76 | 81 |
77 CastTransportSenderImpl::~CastTransportSenderImpl() { | 82 CastTransportSenderImpl::~CastTransportSenderImpl() { |
78 if (event_subscriber_.get()) | 83 if (event_subscriber_.get()) |
79 logging_.RemoveRawEventSubscriber(event_subscriber_.get()); | 84 logging_.RemoveRawEventSubscriber(event_subscriber_.get()); |
80 } | 85 } |
81 | 86 |
82 void CastTransportSenderImpl::InitializeAudio( | 87 void CastTransportSenderImpl::InitializeAudio( |
83 const CastTransportRtpConfig& config) { | 88 const CastTransportRtpConfig& config, |
| 89 const RtcpCastMessageCallback& cast_message_cb, |
| 90 const RtcpRttCallback& rtt_cb) { |
84 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) | 91 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) |
85 << "Unsafe to send audio with encryption DISABLED."; | 92 << "Unsafe to send audio with encryption DISABLED."; |
86 if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { | 93 if (!audio_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { |
87 status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED); | 94 status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED); |
88 return; | 95 return; |
89 } | 96 } |
| 97 |
90 audio_sender_.reset(new RtpSender(clock_, transport_task_runner_, &pacer_)); | 98 audio_sender_.reset(new RtpSender(clock_, transport_task_runner_, &pacer_)); |
91 if (audio_sender_->Initialize(config)) { | 99 if (!audio_sender_->Initialize(config)) { |
92 pacer_.RegisterAudioSsrc(config.ssrc); | |
93 status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED); | |
94 } else { | |
95 audio_sender_.reset(); | 100 audio_sender_.reset(); |
96 status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED); | 101 status_callback_.Run(TRANSPORT_AUDIO_UNINITIALIZED); |
| 102 return; |
97 } | 103 } |
| 104 |
| 105 audio_rtcp_session_.reset( |
| 106 new Rtcp(cast_message_cb, |
| 107 rtt_cb, |
| 108 base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, |
| 109 weak_factory_.GetWeakPtr(), AUDIO_EVENT), |
| 110 clock_, |
| 111 &pacer_, |
| 112 config.ssrc, |
| 113 config.feedback_ssrc, |
| 114 config.c_name)); |
| 115 pacer_.RegisterAudioSsrc(config.ssrc); |
| 116 |
| 117 // Only start receiving once. |
| 118 if (!video_sender_) |
| 119 StartReceiving(); |
| 120 status_callback_.Run(TRANSPORT_AUDIO_INITIALIZED); |
98 } | 121 } |
99 | 122 |
100 void CastTransportSenderImpl::InitializeVideo( | 123 void CastTransportSenderImpl::InitializeVideo( |
101 const CastTransportRtpConfig& config) { | 124 const CastTransportRtpConfig& config, |
| 125 const RtcpCastMessageCallback& cast_message_cb, |
| 126 const RtcpRttCallback& rtt_cb) { |
102 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) | 127 LOG_IF(WARNING, config.aes_key.empty() || config.aes_iv_mask.empty()) |
103 << "Unsafe to send video with encryption DISABLED."; | 128 << "Unsafe to send video with encryption DISABLED."; |
104 if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { | 129 if (!video_encryptor_.Initialize(config.aes_key, config.aes_iv_mask)) { |
105 status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED); | 130 status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED); |
106 return; | 131 return; |
107 } | 132 } |
| 133 |
108 video_sender_.reset(new RtpSender(clock_, transport_task_runner_, &pacer_)); | 134 video_sender_.reset(new RtpSender(clock_, transport_task_runner_, &pacer_)); |
109 if (video_sender_->Initialize(config)) { | 135 if (!video_sender_->Initialize(config)) { |
110 pacer_.RegisterVideoSsrc(config.ssrc); | |
111 status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED); | |
112 } else { | |
113 video_sender_.reset(); | 136 video_sender_.reset(); |
114 status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED); | 137 status_callback_.Run(TRANSPORT_VIDEO_UNINITIALIZED); |
| 138 return; |
115 } | 139 } |
116 } | |
117 | 140 |
118 void CastTransportSenderImpl::SetPacketReceiver( | 141 video_rtcp_session_.reset( |
119 const PacketReceiverCallback& packet_receiver) { | 142 new Rtcp(cast_message_cb, |
120 transport_->StartReceiving(packet_receiver); | 143 rtt_cb, |
| 144 base::Bind(&CastTransportSenderImpl::OnReceivedLogMessage, |
| 145 weak_factory_.GetWeakPtr(), VIDEO_EVENT), |
| 146 clock_, |
| 147 &pacer_, |
| 148 config.ssrc, |
| 149 config.feedback_ssrc, |
| 150 config.c_name)); |
| 151 pacer_.RegisterVideoSsrc(config.ssrc); |
| 152 |
| 153 // Only start receiving once. |
| 154 if (!audio_sender_) |
| 155 StartReceiving(); |
| 156 status_callback_.Run(TRANSPORT_VIDEO_INITIALIZED); |
121 } | 157 } |
122 | 158 |
123 namespace { | 159 namespace { |
124 void EncryptAndSendFrame(const EncodedFrame& frame, | 160 void EncryptAndSendFrame(const EncodedFrame& frame, |
125 TransportEncryptionHandler* encryptor, | 161 TransportEncryptionHandler* encryptor, |
126 RtpSender* sender) { | 162 RtpSender* sender) { |
127 if (encryptor->is_activated()) { | 163 if (encryptor->is_activated()) { |
128 EncodedFrame encrypted_frame; | 164 EncodedFrame encrypted_frame; |
129 frame.CopyMetadataTo(&encrypted_frame); | 165 frame.CopyMetadataTo(&encrypted_frame); |
130 if (encryptor->Encrypt(frame.frame_id, frame.data, &encrypted_frame.data)) { | 166 if (encryptor->Encrypt(frame.frame_id, frame.data, &encrypted_frame.data)) { |
(...skipping 13 matching lines...) Expand all Loading... |
144 DCHECK(audio_sender_) << "Audio sender uninitialized"; | 180 DCHECK(audio_sender_) << "Audio sender uninitialized"; |
145 EncryptAndSendFrame(audio_frame, &audio_encryptor_, audio_sender_.get()); | 181 EncryptAndSendFrame(audio_frame, &audio_encryptor_, audio_sender_.get()); |
146 } | 182 } |
147 | 183 |
148 void CastTransportSenderImpl::InsertCodedVideoFrame( | 184 void CastTransportSenderImpl::InsertCodedVideoFrame( |
149 const EncodedFrame& video_frame) { | 185 const EncodedFrame& video_frame) { |
150 DCHECK(video_sender_) << "Video sender uninitialized"; | 186 DCHECK(video_sender_) << "Video sender uninitialized"; |
151 EncryptAndSendFrame(video_frame, &video_encryptor_, video_sender_.get()); | 187 EncryptAndSendFrame(video_frame, &video_encryptor_, video_sender_.get()); |
152 } | 188 } |
153 | 189 |
154 void CastTransportSenderImpl::SendRtcpFromRtpSender( | 190 void CastTransportSenderImpl::SendSenderReport( |
155 uint32 packet_type_flags, | 191 uint32 ssrc, |
156 uint32 ntp_seconds, | 192 base::TimeTicks current_time, |
157 uint32 ntp_fraction, | 193 uint32 current_time_as_rtp_timestamp) { |
158 uint32 rtp_timestamp, | 194 if (audio_sender_ && ssrc == audio_sender_->ssrc()) { |
159 const RtcpDlrrReportBlock& dlrr, | 195 audio_rtcp_session_->SendRtcpFromRtpSender( |
160 uint32 sending_ssrc, | 196 current_time, current_time_as_rtp_timestamp, |
161 const std::string& c_name) { | 197 audio_sender_->send_packet_count(), audio_sender_->send_octet_count()); |
162 RtcpSenderInfo sender_info; | 198 } else if (video_sender_ && ssrc == video_sender_->ssrc()) { |
163 sender_info.ntp_seconds = ntp_seconds; | 199 video_rtcp_session_->SendRtcpFromRtpSender( |
164 sender_info.ntp_fraction = ntp_fraction; | 200 current_time, current_time_as_rtp_timestamp, |
165 sender_info.rtp_timestamp = rtp_timestamp; | 201 video_sender_->send_packet_count(), video_sender_->send_octet_count()); |
166 if (audio_sender_ && audio_sender_->ssrc() == sending_ssrc) { | |
167 sender_info.send_packet_count = audio_sender_->send_packet_count(); | |
168 sender_info.send_octet_count = audio_sender_->send_octet_count(); | |
169 } else if (video_sender_ && video_sender_->ssrc() == sending_ssrc) { | |
170 sender_info.send_packet_count = video_sender_->send_packet_count(); | |
171 sender_info.send_octet_count = video_sender_->send_octet_count(); | |
172 } else { | 202 } else { |
173 LOG(ERROR) << "Sending RTCP with an invalid SSRC."; | 203 NOTREACHED() << "Invalid request for sending RTCP packet."; |
174 return; | |
175 } | 204 } |
176 rtcp_builder_.SendRtcpFromRtpSender( | |
177 packet_type_flags, sender_info, dlrr, sending_ssrc, c_name); | |
178 } | 205 } |
179 | 206 |
180 void CastTransportSenderImpl::ResendPackets( | 207 void CastTransportSenderImpl::ResendPackets( |
181 bool is_audio, | 208 bool is_audio, |
182 const MissingFramesAndPacketsMap& missing_packets, | 209 const MissingFramesAndPacketsMap& missing_packets, |
183 bool cancel_rtx_if_not_in_list, | 210 bool cancel_rtx_if_not_in_list, |
184 base::TimeDelta dedupe_window) { | 211 base::TimeDelta dedupe_window) { |
185 if (is_audio) { | 212 if (is_audio) { |
186 DCHECK(audio_sender_) << "Audio sender uninitialized"; | 213 DCHECK(audio_sender_) << "Audio sender uninitialized"; |
187 audio_sender_->ResendPackets(missing_packets, | 214 audio_sender_->ResendPackets(missing_packets, |
188 cancel_rtx_if_not_in_list, | 215 cancel_rtx_if_not_in_list, |
189 dedupe_window); | 216 dedupe_window); |
190 } else { | 217 } else { |
191 DCHECK(video_sender_) << "Video sender uninitialized"; | 218 DCHECK(video_sender_) << "Video sender uninitialized"; |
192 video_sender_->ResendPackets(missing_packets, | 219 video_sender_->ResendPackets(missing_packets, |
193 cancel_rtx_if_not_in_list, | 220 cancel_rtx_if_not_in_list, |
194 dedupe_window); | 221 dedupe_window); |
195 } | 222 } |
196 } | 223 } |
197 | 224 |
| 225 PacketReceiverCallback CastTransportSenderImpl::PacketReceiverForTesting() { |
| 226 return base::Bind(&CastTransportSenderImpl::OnReceivedPacket, |
| 227 weak_factory_.GetWeakPtr()); |
| 228 } |
| 229 |
198 void CastTransportSenderImpl::SendRawEvents() { | 230 void CastTransportSenderImpl::SendRawEvents() { |
199 DCHECK(event_subscriber_.get()); | 231 DCHECK(event_subscriber_.get()); |
200 DCHECK(!raw_events_callback_.is_null()); | 232 DCHECK(!raw_events_callback_.is_null()); |
201 std::vector<PacketEvent> packet_events; | 233 std::vector<PacketEvent> packet_events; |
| 234 std::vector<FrameEvent> frame_events; |
202 event_subscriber_->GetPacketEventsAndReset(&packet_events); | 235 event_subscriber_->GetPacketEventsAndReset(&packet_events); |
203 raw_events_callback_.Run(packet_events); | 236 event_subscriber_->GetFrameEventsAndReset(&frame_events); |
| 237 raw_events_callback_.Run(packet_events, frame_events); |
| 238 |
| 239 transport_task_runner_->PostDelayedTask( |
| 240 FROM_HERE, |
| 241 base::Bind(&CastTransportSenderImpl::SendRawEvents, |
| 242 weak_factory_.GetWeakPtr()), |
| 243 raw_events_callback_interval_); |
| 244 } |
| 245 |
| 246 void CastTransportSenderImpl::StartReceiving() { |
| 247 if (!transport_) |
| 248 return; |
| 249 transport_->StartReceiving( |
| 250 base::Bind(&CastTransportSenderImpl::OnReceivedPacket, |
| 251 weak_factory_.GetWeakPtr())); |
| 252 } |
| 253 |
| 254 void CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) { |
| 255 if (audio_rtcp_session_ && |
| 256 audio_rtcp_session_->IncomingRtcpPacket(&packet->front(), |
| 257 packet->size())) { |
| 258 return; |
| 259 } |
| 260 if (video_rtcp_session_ && |
| 261 video_rtcp_session_->IncomingRtcpPacket(&packet->front(), |
| 262 packet->size())) { |
| 263 return; |
| 264 } |
| 265 VLOG(1) << "Stale packet received."; |
| 266 } |
| 267 |
| 268 void CastTransportSenderImpl::OnReceivedLogMessage( |
| 269 EventMediaType media_type, |
| 270 const RtcpReceiverLogMessage& log) { |
| 271 // Add received log messages into our log system. |
| 272 RtcpReceiverLogMessage::const_iterator it = log.begin(); |
| 273 for (; it != log.end(); ++it) { |
| 274 uint32 rtp_timestamp = it->rtp_timestamp_; |
| 275 |
| 276 RtcpReceiverEventLogMessages::const_iterator event_it = |
| 277 it->event_log_messages_.begin(); |
| 278 for (; event_it != it->event_log_messages_.end(); ++event_it) { |
| 279 switch (event_it->type) { |
| 280 case PACKET_RECEIVED: |
| 281 logging_.InsertPacketEvent( |
| 282 event_it->event_timestamp, event_it->type, |
| 283 media_type, rtp_timestamp, |
| 284 kFrameIdUnknown, event_it->packet_id, 0, 0); |
| 285 break; |
| 286 case FRAME_ACK_SENT: |
| 287 case FRAME_DECODED: |
| 288 logging_.InsertFrameEvent( |
| 289 event_it->event_timestamp, event_it->type, media_type, |
| 290 rtp_timestamp, kFrameIdUnknown); |
| 291 break; |
| 292 case FRAME_PLAYOUT: |
| 293 logging_.InsertFrameEventWithDelay( |
| 294 event_it->event_timestamp, event_it->type, media_type, |
| 295 rtp_timestamp, kFrameIdUnknown, event_it->delay_delta); |
| 296 break; |
| 297 default: |
| 298 VLOG(2) << "Received log message via RTCP that we did not expect: " |
| 299 << static_cast<int>(event_it->type); |
| 300 break; |
| 301 } |
| 302 } |
| 303 } |
204 } | 304 } |
205 | 305 |
206 } // namespace cast | 306 } // namespace cast |
207 } // namespace media | 307 } // namespace media |
OLD | NEW |