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/rtcp/rtcp_receiver.h" | 5 #include "media/cast/net/rtcp/rtcp_receiver.h" |
6 | 6 |
| 7 #include "base/big_endian.h" |
7 #include "base/logging.h" | 8 #include "base/logging.h" |
8 #include "media/cast/net/cast_transport_defines.h" | 9 #include "media/cast/net/cast_transport_defines.h" |
9 #include "media/cast/net/rtcp/rtcp_utility.h" | 10 #include "media/cast/net/rtcp/rtcp_utility.h" |
10 | 11 |
11 namespace { | 12 namespace { |
12 | 13 |
13 // A receiver frame event is identified by frame RTP timestamp, event timestamp | 14 // A receiver frame event is identified by frame RTP timestamp, event timestamp |
14 // and event type. | 15 // and event type. |
15 // A receiver packet event is identified by all of the above plus packet id. | 16 // A receiver packet event is identified by all of the above plus packet id. |
16 // The key format is as follows: | 17 // The key format is as follows: |
(...skipping 14 matching lines...) Expand all Loading... |
31 value1 |= frame_rtp_timestamp; | 32 value1 |= frame_rtp_timestamp; |
32 return std::make_pair( | 33 return std::make_pair( |
33 value1, static_cast<uint64>(event_timestamp.ToInternalValue())); | 34 value1, static_cast<uint64>(event_timestamp.ToInternalValue())); |
34 } | 35 } |
35 | 36 |
36 } // namespace | 37 } // namespace |
37 | 38 |
38 namespace media { | 39 namespace media { |
39 namespace cast { | 40 namespace cast { |
40 | 41 |
41 RtcpReceiver::RtcpReceiver(scoped_refptr<CastEnvironment> cast_environment, | 42 RtcpReceiver::RtcpReceiver(RtcpMessageHandler* handler, |
42 RtcpSenderFeedback* sender_feedback, | |
43 RtcpReceiverFeedback* receiver_feedback, | |
44 RtcpRttFeedback* rtt_feedback, | |
45 uint32 local_ssrc) | 43 uint32 local_ssrc) |
46 : ssrc_(local_ssrc), | 44 : ssrc_(local_ssrc), |
47 remote_ssrc_(0), | 45 remote_ssrc_(0), |
48 sender_feedback_(sender_feedback), | 46 handler_(handler), |
49 receiver_feedback_(receiver_feedback), | 47 receiver_event_history_size_(0) { |
50 rtt_feedback_(rtt_feedback), | 48 DCHECK(handler_); |
51 cast_environment_(cast_environment), | 49 } |
52 receiver_event_history_size_(0) {} | |
53 | 50 |
54 RtcpReceiver::~RtcpReceiver() {} | 51 RtcpReceiver::~RtcpReceiver() {} |
55 | 52 |
| 53 // static |
| 54 bool RtcpReceiver::IsRtcpPacket(const uint8* packet, size_t length) { |
| 55 if (length < kMinLengthOfRtcp) { |
| 56 LOG(ERROR) << "Invalid RTCP packet received."; |
| 57 return false; |
| 58 } |
| 59 |
| 60 uint8 packet_type = packet[1]; |
| 61 if (packet_type >= kPacketTypeLow && |
| 62 packet_type <= kPacketTypeHigh) { |
| 63 return true; |
| 64 } |
| 65 return false; |
| 66 } |
| 67 |
| 68 // static |
| 69 uint32 RtcpReceiver::GetSsrcOfSender(const uint8* rtcp_buffer, size_t length) { |
| 70 if (length < kMinLengthOfRtcp) |
| 71 return 0; |
| 72 uint32 ssrc_of_sender; |
| 73 base::BigEndianReader big_endian_reader( |
| 74 reinterpret_cast<const char*>(rtcp_buffer), length); |
| 75 big_endian_reader.Skip(4); // Skip header |
| 76 big_endian_reader.ReadU32(&ssrc_of_sender); |
| 77 return ssrc_of_sender; |
| 78 } |
| 79 |
56 void RtcpReceiver::SetRemoteSSRC(uint32 ssrc) { remote_ssrc_ = ssrc; } | 80 void RtcpReceiver::SetRemoteSSRC(uint32 ssrc) { remote_ssrc_ = ssrc; } |
57 | 81 |
58 void RtcpReceiver::SetCastReceiverEventHistorySize(size_t size) { | 82 void RtcpReceiver::SetCastReceiverEventHistorySize(size_t size) { |
59 receiver_event_history_size_ = size; | 83 receiver_event_history_size_ = size; |
60 } | 84 } |
61 | 85 |
62 void RtcpReceiver::IncomingRtcpPacket(RtcpParser* rtcp_parser) { | 86 void RtcpReceiver::IncomingRtcpPacket(RtcpParser* rtcp_parser) { |
63 RtcpFieldTypes field_type = rtcp_parser->Begin(); | 87 RtcpFieldTypes field_type = rtcp_parser->Begin(); |
64 while (field_type != kRtcpNotValidCode) { | 88 while (field_type != kRtcpNotValidCode) { |
65 // Each "case" is responsible for iterate the parser to the next top | 89 // Each "case" is responsible for iterate the parser to the next top |
(...skipping 10 matching lines...) Expand all Loading... |
76 break; | 100 break; |
77 case kRtcpByeCode: | 101 case kRtcpByeCode: |
78 HandleBYE(rtcp_parser); | 102 HandleBYE(rtcp_parser); |
79 break; | 103 break; |
80 case kRtcpXrCode: | 104 case kRtcpXrCode: |
81 HandleXr(rtcp_parser); | 105 HandleXr(rtcp_parser); |
82 break; | 106 break; |
83 case kRtcpGenericRtpFeedbackNackCode: | 107 case kRtcpGenericRtpFeedbackNackCode: |
84 HandleNACK(rtcp_parser); | 108 HandleNACK(rtcp_parser); |
85 break; | 109 break; |
86 case kRtcpGenericRtpFeedbackSrReqCode: | |
87 HandleSendReportRequest(rtcp_parser); | |
88 break; | |
89 case kRtcpPayloadSpecificPliCode: | 110 case kRtcpPayloadSpecificPliCode: |
90 HandlePLI(rtcp_parser); | 111 HandlePLI(rtcp_parser); |
91 break; | 112 break; |
92 case kRtcpPayloadSpecificRpsiCode: | 113 case kRtcpPayloadSpecificRpsiCode: |
93 HandleRpsi(rtcp_parser); | 114 HandleRpsi(rtcp_parser); |
94 break; | 115 break; |
95 case kRtcpPayloadSpecificFirCode: | 116 case kRtcpPayloadSpecificFirCode: |
96 HandleFIR(rtcp_parser); | 117 HandleFIR(rtcp_parser); |
97 break; | 118 break; |
98 case kRtcpPayloadSpecificAppCode: | 119 case kRtcpPayloadSpecificAppCode: |
99 HandlePayloadSpecificApp(rtcp_parser); | 120 HandlePayloadSpecificApp(rtcp_parser); |
100 break; | 121 break; |
101 case kRtcpApplicationSpecificCastReceiverLogCode: | 122 case kRtcpApplicationSpecificCastReceiverLogCode: |
102 HandleApplicationSpecificCastReceiverLog(rtcp_parser); | 123 HandleApplicationSpecificCastReceiverLog(rtcp_parser); |
103 break; | 124 break; |
104 case kRtcpPayloadSpecificRembCode: | 125 case kRtcpPayloadSpecificRembCode: |
105 case kRtcpPayloadSpecificRembItemCode: | 126 case kRtcpPayloadSpecificRembItemCode: |
106 case kRtcpPayloadSpecificCastCode: | 127 case kRtcpPayloadSpecificCastCode: |
107 case kRtcpPayloadSpecificCastNackItemCode: | 128 case kRtcpPayloadSpecificCastNackItemCode: |
108 case kRtcpApplicationSpecificCastReceiverLogFrameCode: | 129 case kRtcpApplicationSpecificCastReceiverLogFrameCode: |
109 case kRtcpApplicationSpecificCastReceiverLogEventCode: | 130 case kRtcpApplicationSpecificCastReceiverLogEventCode: |
110 case kRtcpNotValidCode: | 131 case kRtcpNotValidCode: |
111 case kRtcpReportBlockItemCode: | 132 case kRtcpReportBlockItemCode: |
112 case kRtcpSdesChunkCode: | 133 case kRtcpSdesChunkCode: |
| 134 case kRtcpGenericRtpFeedbackSrReqCode: |
113 case kRtcpGenericRtpFeedbackNackItemCode: | 135 case kRtcpGenericRtpFeedbackNackItemCode: |
114 case kRtcpPayloadSpecificFirItemCode: | 136 case kRtcpPayloadSpecificFirItemCode: |
115 case kRtcpXrRrtrCode: | 137 case kRtcpXrRrtrCode: |
116 case kRtcpXrDlrrCode: | 138 case kRtcpXrDlrrCode: |
117 case kRtcpXrUnknownItemCode: | 139 case kRtcpXrUnknownItemCode: |
118 rtcp_parser->Iterate(); | 140 rtcp_parser->Iterate(); |
119 NOTREACHED() << "Invalid state"; | 141 NOTREACHED() << "Invalid state"; |
120 break; | 142 break; |
121 } | 143 } |
122 field_type = rtcp_parser->FieldType(); | 144 field_type = rtcp_parser->FieldType(); |
(...skipping 15 matching lines...) Expand all Loading... |
138 RtcpSenderInfo remote_sender_info; | 160 RtcpSenderInfo remote_sender_info; |
139 remote_sender_info.ntp_seconds = | 161 remote_sender_info.ntp_seconds = |
140 rtcp_field.sender_report.ntp_most_significant; | 162 rtcp_field.sender_report.ntp_most_significant; |
141 remote_sender_info.ntp_fraction = | 163 remote_sender_info.ntp_fraction = |
142 rtcp_field.sender_report.ntp_least_significant; | 164 rtcp_field.sender_report.ntp_least_significant; |
143 remote_sender_info.rtp_timestamp = rtcp_field.sender_report.rtp_timestamp; | 165 remote_sender_info.rtp_timestamp = rtcp_field.sender_report.rtp_timestamp; |
144 remote_sender_info.send_packet_count = | 166 remote_sender_info.send_packet_count = |
145 rtcp_field.sender_report.sender_packet_count; | 167 rtcp_field.sender_report.sender_packet_count; |
146 remote_sender_info.send_octet_count = | 168 remote_sender_info.send_octet_count = |
147 rtcp_field.sender_report.sender_octet_count; | 169 rtcp_field.sender_report.sender_octet_count; |
148 if (receiver_feedback_) { | 170 handler_->OnReceivedSenderReport(remote_sender_info); |
149 receiver_feedback_->OnReceivedSenderReport(remote_sender_info); | |
150 } | |
151 } | 171 } |
152 rtcp_field_type = rtcp_parser->Iterate(); | 172 rtcp_field_type = rtcp_parser->Iterate(); |
153 while (rtcp_field_type == kRtcpReportBlockItemCode) { | 173 while (rtcp_field_type == kRtcpReportBlockItemCode) { |
154 HandleReportBlock(&rtcp_field, remote_ssrc); | 174 HandleReportBlock(&rtcp_field, remote_ssrc); |
155 rtcp_field_type = rtcp_parser->Iterate(); | 175 rtcp_field_type = rtcp_parser->Iterate(); |
156 } | 176 } |
157 } | 177 } |
158 | 178 |
159 void RtcpReceiver::HandleReceiverReport(RtcpParser* rtcp_parser) { | 179 void RtcpReceiver::HandleReceiverReport(RtcpParser* rtcp_parser) { |
160 RtcpFieldTypes rtcp_field_type = rtcp_parser->FieldType(); | 180 RtcpFieldTypes rtcp_field_type = rtcp_parser->FieldType(); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
196 RtcpReportBlock report_block; | 216 RtcpReportBlock report_block; |
197 report_block.remote_ssrc = remote_ssrc; | 217 report_block.remote_ssrc = remote_ssrc; |
198 report_block.media_ssrc = rb.ssrc; | 218 report_block.media_ssrc = rb.ssrc; |
199 report_block.fraction_lost = rb.fraction_lost; | 219 report_block.fraction_lost = rb.fraction_lost; |
200 report_block.cumulative_lost = rb.cumulative_number_of_packets_lost; | 220 report_block.cumulative_lost = rb.cumulative_number_of_packets_lost; |
201 report_block.extended_high_sequence_number = | 221 report_block.extended_high_sequence_number = |
202 rb.extended_highest_sequence_number; | 222 rb.extended_highest_sequence_number; |
203 report_block.jitter = rb.jitter; | 223 report_block.jitter = rb.jitter; |
204 report_block.last_sr = rb.last_sender_report; | 224 report_block.last_sr = rb.last_sender_report; |
205 report_block.delay_since_last_sr = rb.delay_last_sender_report; | 225 report_block.delay_since_last_sr = rb.delay_last_sender_report; |
206 | 226 handler_->OnReceivedDelaySinceLastReport( |
207 if (rtt_feedback_) { | 227 rb.last_sender_report, rb.delay_last_sender_report); |
208 rtt_feedback_->OnReceivedDelaySinceLastReport( | |
209 rb.ssrc, rb.last_sender_report, rb.delay_last_sender_report); | |
210 } | |
211 } | 228 } |
212 | 229 |
213 void RtcpReceiver::HandleSDES(RtcpParser* rtcp_parser) { | 230 void RtcpReceiver::HandleSDES(RtcpParser* rtcp_parser) { |
214 RtcpFieldTypes field_type = rtcp_parser->Iterate(); | 231 RtcpFieldTypes field_type = rtcp_parser->Iterate(); |
215 while (field_type == kRtcpSdesChunkCode) { | 232 while (field_type == kRtcpSdesChunkCode) { |
216 HandleSDESChunk(rtcp_parser); | 233 HandleSDESChunk(rtcp_parser); |
217 field_type = rtcp_parser->Iterate(); | 234 field_type = rtcp_parser->Iterate(); |
218 } | 235 } |
219 } | 236 } |
220 | 237 |
(...skipping 26 matching lines...) Expand all Loading... |
247 void RtcpReceiver::HandleRrtr(RtcpParser* rtcp_parser, uint32 remote_ssrc) { | 264 void RtcpReceiver::HandleRrtr(RtcpParser* rtcp_parser, uint32 remote_ssrc) { |
248 if (remote_ssrc_ != remote_ssrc) { | 265 if (remote_ssrc_ != remote_ssrc) { |
249 // Not to us. | 266 // Not to us. |
250 return; | 267 return; |
251 } | 268 } |
252 const RtcpField& rtcp_field = rtcp_parser->Field(); | 269 const RtcpField& rtcp_field = rtcp_parser->Field(); |
253 RtcpReceiverReferenceTimeReport remote_time_report; | 270 RtcpReceiverReferenceTimeReport remote_time_report; |
254 remote_time_report.remote_ssrc = remote_ssrc; | 271 remote_time_report.remote_ssrc = remote_ssrc; |
255 remote_time_report.ntp_seconds = rtcp_field.rrtr.ntp_most_significant; | 272 remote_time_report.ntp_seconds = rtcp_field.rrtr.ntp_most_significant; |
256 remote_time_report.ntp_fraction = rtcp_field.rrtr.ntp_least_significant; | 273 remote_time_report.ntp_fraction = rtcp_field.rrtr.ntp_least_significant; |
257 | 274 handler_->OnReceiverReferenceTimeReport(remote_time_report); |
258 if (receiver_feedback_) { | |
259 receiver_feedback_->OnReceiverReferenceTimeReport(remote_time_report); | |
260 } | |
261 } | 275 } |
262 | 276 |
263 void RtcpReceiver::HandleDlrr(RtcpParser* rtcp_parser) { | 277 void RtcpReceiver::HandleDlrr(RtcpParser* rtcp_parser) { |
264 const RtcpField& rtcp_field = rtcp_parser->Field(); | 278 const RtcpField& rtcp_field = rtcp_parser->Field(); |
265 if (remote_ssrc_ != rtcp_field.dlrr.receivers_ssrc) { | 279 if (remote_ssrc_ != rtcp_field.dlrr.receivers_ssrc) { |
266 // Not to us. | 280 // Not to us. |
267 return; | 281 return; |
268 } | 282 } |
269 if (rtt_feedback_) { | 283 handler_->OnReceivedDelaySinceLastReport( |
270 rtt_feedback_->OnReceivedDelaySinceLastReport( | 284 rtcp_field.dlrr.last_receiver_report, |
271 rtcp_field.dlrr.receivers_ssrc, | 285 rtcp_field.dlrr.delay_last_receiver_report); |
272 rtcp_field.dlrr.last_receiver_report, | |
273 rtcp_field.dlrr.delay_last_receiver_report); | |
274 } | |
275 } | 286 } |
276 | 287 |
277 void RtcpReceiver::HandleNACK(RtcpParser* rtcp_parser) { | 288 void RtcpReceiver::HandleNACK(RtcpParser* rtcp_parser) { |
278 const RtcpField& rtcp_field = rtcp_parser->Field(); | 289 const RtcpField& rtcp_field = rtcp_parser->Field(); |
279 if (ssrc_ != rtcp_field.nack.media_ssrc) { | 290 if (ssrc_ != rtcp_field.nack.media_ssrc) { |
280 RtcpFieldTypes field_type; | 291 RtcpFieldTypes field_type; |
281 // Message not to us. Iterate until we have passed this message. | 292 // Message not to us. Iterate until we have passed this message. |
282 do { | 293 do { |
283 field_type = rtcp_parser->Iterate(); | 294 field_type = rtcp_parser->Iterate(); |
284 } while (field_type == kRtcpGenericRtpFeedbackNackItemCode); | 295 } while (field_type == kRtcpGenericRtpFeedbackNackItemCode); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
319 | 330 |
320 void RtcpReceiver::HandlePLI(RtcpParser* rtcp_parser) { | 331 void RtcpReceiver::HandlePLI(RtcpParser* rtcp_parser) { |
321 const RtcpField& rtcp_field = rtcp_parser->Field(); | 332 const RtcpField& rtcp_field = rtcp_parser->Field(); |
322 if (ssrc_ == rtcp_field.pli.media_ssrc) { | 333 if (ssrc_ == rtcp_field.pli.media_ssrc) { |
323 // Received a signal that we need to send a new key frame. | 334 // Received a signal that we need to send a new key frame. |
324 VLOG(2) << "Cast RTCP received PLI on our SSRC " << ssrc_; | 335 VLOG(2) << "Cast RTCP received PLI on our SSRC " << ssrc_; |
325 } | 336 } |
326 rtcp_parser->Iterate(); | 337 rtcp_parser->Iterate(); |
327 } | 338 } |
328 | 339 |
329 void RtcpReceiver::HandleSendReportRequest(RtcpParser* rtcp_parser) { | |
330 if (receiver_feedback_) { | |
331 receiver_feedback_->OnReceivedSendReportRequest(); | |
332 } | |
333 rtcp_parser->Iterate(); | |
334 } | |
335 | |
336 void RtcpReceiver::HandleRpsi(RtcpParser* rtcp_parser) { | 340 void RtcpReceiver::HandleRpsi(RtcpParser* rtcp_parser) { |
337 const RtcpField& rtcp_field = rtcp_parser->Field(); | 341 const RtcpField& rtcp_field = rtcp_parser->Field(); |
338 if (rtcp_parser->Iterate() != kRtcpPayloadSpecificRpsiCode) { | 342 if (rtcp_parser->Iterate() != kRtcpPayloadSpecificRpsiCode) { |
339 return; | 343 return; |
340 } | 344 } |
341 if (rtcp_field.rpsi.number_of_valid_bits % 8 != 0) { | 345 if (rtcp_field.rpsi.number_of_valid_bits % 8 != 0) { |
342 // Continue | 346 // Continue |
343 return; | 347 return; |
344 } | 348 } |
345 uint64 rpsi_picture_id = 0; | 349 uint64 rpsi_picture_id = 0; |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
429 rtcp_field.cast_receiver_log.rtp_timestamp, | 433 rtcp_field.cast_receiver_log.rtp_timestamp, |
430 rtcp_parser, | 434 rtcp_parser, |
431 &frame_log.event_log_messages_); | 435 &frame_log.event_log_messages_); |
432 field_type = rtcp_parser->Iterate(); | 436 field_type = rtcp_parser->Iterate(); |
433 } | 437 } |
434 | 438 |
435 if (!frame_log.event_log_messages_.empty()) | 439 if (!frame_log.event_log_messages_.empty()) |
436 receiver_log.push_back(frame_log); | 440 receiver_log.push_back(frame_log); |
437 } | 441 } |
438 | 442 |
439 if (receiver_feedback_ && !receiver_log.empty()) { | 443 if (!receiver_log.empty()) |
440 receiver_feedback_->OnReceivedReceiverLog(receiver_log); | 444 handler_->OnReceivedReceiverLog(receiver_log); |
441 } | |
442 } | 445 } |
443 | 446 |
444 void RtcpReceiver::HandleApplicationSpecificCastReceiverEventLog( | 447 void RtcpReceiver::HandleApplicationSpecificCastReceiverEventLog( |
445 uint32 frame_rtp_timestamp, | 448 uint32 frame_rtp_timestamp, |
446 RtcpParser* rtcp_parser, | 449 RtcpParser* rtcp_parser, |
447 RtcpReceiverEventLogMessages* event_log_messages) { | 450 RtcpReceiverEventLogMessages* event_log_messages) { |
448 const RtcpField& rtcp_field = rtcp_parser->Field(); | 451 const RtcpField& rtcp_field = rtcp_parser->Field(); |
449 | 452 |
450 const uint8 event = rtcp_field.cast_receiver_log.event; | 453 const uint8 event = rtcp_field.cast_receiver_log.event; |
451 const CastLoggingEvent event_type = TranslateToLogEventFromWireFormat(event); | 454 const CastLoggingEvent event_type = TranslateToLogEventFromWireFormat(event); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
484 event_log.delay_delta = base::TimeDelta::FromMilliseconds( | 487 event_log.delay_delta = base::TimeDelta::FromMilliseconds( |
485 rtcp_field.cast_receiver_log.delay_delta_or_packet_id.delay_delta); | 488 rtcp_field.cast_receiver_log.delay_delta_or_packet_id.delay_delta); |
486 event_log.packet_id = | 489 event_log.packet_id = |
487 rtcp_field.cast_receiver_log.delay_delta_or_packet_id.packet_id; | 490 rtcp_field.cast_receiver_log.delay_delta_or_packet_id.packet_id; |
488 event_log_messages->push_back(event_log); | 491 event_log_messages->push_back(event_log); |
489 } | 492 } |
490 | 493 |
491 void RtcpReceiver::HandlePayloadSpecificCastItem(RtcpParser* rtcp_parser) { | 494 void RtcpReceiver::HandlePayloadSpecificCastItem(RtcpParser* rtcp_parser) { |
492 const RtcpField& rtcp_field = rtcp_parser->Field(); | 495 const RtcpField& rtcp_field = rtcp_parser->Field(); |
493 RtcpCastMessage cast_message(remote_ssrc_); | 496 RtcpCastMessage cast_message(remote_ssrc_); |
494 cast_message.ack_frame_id_ = ack_frame_id_wrap_helper_.MapTo32bitsFrameId( | 497 cast_message.ack_frame_id = ack_frame_id_wrap_helper_.MapTo32bitsFrameId( |
495 rtcp_field.cast_item.last_frame_id); | 498 rtcp_field.cast_item.last_frame_id); |
496 cast_message.target_delay_ms_ = rtcp_field.cast_item.target_delay_ms; | 499 cast_message.target_delay_ms = rtcp_field.cast_item.target_delay_ms; |
497 | 500 |
498 RtcpFieldTypes packet_type = rtcp_parser->Iterate(); | 501 RtcpFieldTypes packet_type = rtcp_parser->Iterate(); |
499 while (packet_type == kRtcpPayloadSpecificCastNackItemCode) { | 502 while (packet_type == kRtcpPayloadSpecificCastNackItemCode) { |
500 const RtcpField& rtcp_field = rtcp_parser->Field(); | 503 const RtcpField& rtcp_field = rtcp_parser->Field(); |
501 HandlePayloadSpecificCastNackItem( | 504 HandlePayloadSpecificCastNackItem( |
502 &rtcp_field, &cast_message.missing_frames_and_packets_); | 505 &rtcp_field, &cast_message.missing_frames_and_packets); |
503 packet_type = rtcp_parser->Iterate(); | 506 packet_type = rtcp_parser->Iterate(); |
504 } | 507 } |
505 if (sender_feedback_) { | 508 handler_->OnReceivedCastFeedback(cast_message); |
506 sender_feedback_->OnReceivedCastFeedback(cast_message); | |
507 } | |
508 } | 509 } |
509 | 510 |
510 void RtcpReceiver::HandlePayloadSpecificCastNackItem( | 511 void RtcpReceiver::HandlePayloadSpecificCastNackItem( |
511 const RtcpField* rtcp_field, | 512 const RtcpField* rtcp_field, |
512 MissingFramesAndPacketsMap* missing_frames_and_packets) { | 513 MissingFramesAndPacketsMap* missing_frames_and_packets) { |
513 | 514 |
514 MissingFramesAndPacketsMap::iterator frame_it = | 515 MissingFramesAndPacketsMap::iterator frame_it = |
515 missing_frames_and_packets->find(rtcp_field->cast_nack_item.frame_id); | 516 missing_frames_and_packets->find(rtcp_field->cast_nack_item.frame_id); |
516 | 517 |
517 if (frame_it == missing_frames_and_packets->end()) { | 518 if (frame_it == missing_frames_and_packets->end()) { |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
555 void RtcpReceiver::HandleFIRItem(const RtcpField* rtcp_field) { | 556 void RtcpReceiver::HandleFIRItem(const RtcpField* rtcp_field) { |
556 // Is it our sender that is requested to generate a new keyframe. | 557 // Is it our sender that is requested to generate a new keyframe. |
557 if (ssrc_ != rtcp_field->fir_item.ssrc) | 558 if (ssrc_ != rtcp_field->fir_item.ssrc) |
558 return; | 559 return; |
559 | 560 |
560 VLOG(2) << "Cast RTCP received FIR on our SSRC " << ssrc_; | 561 VLOG(2) << "Cast RTCP received FIR on our SSRC " << ssrc_; |
561 } | 562 } |
562 | 563 |
563 } // namespace cast | 564 } // namespace cast |
564 } // namespace media | 565 } // namespace media |
OLD | NEW |