OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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), | |
50 rtt_feedback_(rtt_feedback), | |
51 cast_environment_(cast_environment), | |
52 receiver_event_history_size_(0) {} | 47 receiver_event_history_size_(0) {} |
miu
2014/07/16 00:09:32
To simplify, consider adding DCHECK(handler_) here
Alpha Left Google
2014/07/17 01:01:45
Done.
| |
53 | 48 |
54 RtcpReceiver::~RtcpReceiver() {} | 49 RtcpReceiver::~RtcpReceiver() {} |
55 | 50 |
51 // static | |
52 bool RtcpReceiver::IsRtcpPacket(const uint8* packet, size_t length) { | |
miu
2014/07/16 00:09:32
You could get rid of this method, and roll it into
Alpha Left Google
2014/07/17 01:01:45
0 is a valid SSRC so I would like to keep this met
| |
53 DCHECK_GE(length, kMinLengthOfRtcp) << "Invalid RTCP packet"; | |
54 if (length < kMinLengthOfRtcp) return false; | |
55 | |
56 uint8 packet_type = packet[1]; | |
57 if (packet_type >= kPacketTypeLow && | |
58 packet_type <= kPacketTypeHigh) { | |
59 return true; | |
60 } | |
61 return false; | |
62 } | |
63 | |
64 // static | |
65 uint32 RtcpReceiver::GetSsrcOfSender(const uint8* rtcp_buffer, size_t length) { | |
66 DCHECK_GE(length, kMinLengthOfRtcp) << "Invalid RTCP packet"; | |
miu
2014/07/16 00:09:32
Don't need this DCHECK if checking big_endian_read
| |
67 uint32 ssrc_of_sender; | |
68 base::BigEndianReader big_endian_reader( | |
69 reinterpret_cast<const char*>(rtcp_buffer), length); | |
70 big_endian_reader.Skip(4); // Skip header | |
miu
2014/07/16 00:09:32
Note: These two method calls on big_endian_reader
Alpha Left Google
2014/07/17 01:01:45
IsRtcpPacket is actually useful because 0 is also
| |
71 big_endian_reader.ReadU32(&ssrc_of_sender); | |
72 return ssrc_of_sender; | |
73 } | |
74 | |
56 void RtcpReceiver::SetRemoteSSRC(uint32 ssrc) { remote_ssrc_ = ssrc; } | 75 void RtcpReceiver::SetRemoteSSRC(uint32 ssrc) { remote_ssrc_ = ssrc; } |
57 | 76 |
58 void RtcpReceiver::SetCastReceiverEventHistorySize(size_t size) { | 77 void RtcpReceiver::SetCastReceiverEventHistorySize(size_t size) { |
59 receiver_event_history_size_ = size; | 78 receiver_event_history_size_ = size; |
60 } | 79 } |
61 | 80 |
62 void RtcpReceiver::IncomingRtcpPacket(RtcpParser* rtcp_parser) { | 81 void RtcpReceiver::IncomingRtcpPacket(RtcpParser* rtcp_parser) { |
63 RtcpFieldTypes field_type = rtcp_parser->Begin(); | 82 RtcpFieldTypes field_type = rtcp_parser->Begin(); |
64 while (field_type != kRtcpNotValidCode) { | 83 while (field_type != kRtcpNotValidCode) { |
65 // Each "case" is responsible for iterate the parser to the next top | 84 // Each "case" is responsible for iterate the parser to the next top |
(...skipping 10 matching lines...) Expand all Loading... | |
76 break; | 95 break; |
77 case kRtcpByeCode: | 96 case kRtcpByeCode: |
78 HandleBYE(rtcp_parser); | 97 HandleBYE(rtcp_parser); |
79 break; | 98 break; |
80 case kRtcpXrCode: | 99 case kRtcpXrCode: |
81 HandleXr(rtcp_parser); | 100 HandleXr(rtcp_parser); |
82 break; | 101 break; |
83 case kRtcpGenericRtpFeedbackNackCode: | 102 case kRtcpGenericRtpFeedbackNackCode: |
84 HandleNACK(rtcp_parser); | 103 HandleNACK(rtcp_parser); |
85 break; | 104 break; |
86 case kRtcpGenericRtpFeedbackSrReqCode: | |
87 HandleSendReportRequest(rtcp_parser); | |
88 break; | |
89 case kRtcpPayloadSpecificPliCode: | 105 case kRtcpPayloadSpecificPliCode: |
90 HandlePLI(rtcp_parser); | 106 HandlePLI(rtcp_parser); |
91 break; | 107 break; |
92 case kRtcpPayloadSpecificRpsiCode: | 108 case kRtcpPayloadSpecificRpsiCode: |
93 HandleRpsi(rtcp_parser); | 109 HandleRpsi(rtcp_parser); |
94 break; | 110 break; |
95 case kRtcpPayloadSpecificFirCode: | 111 case kRtcpPayloadSpecificFirCode: |
96 HandleFIR(rtcp_parser); | 112 HandleFIR(rtcp_parser); |
97 break; | 113 break; |
98 case kRtcpPayloadSpecificAppCode: | 114 case kRtcpPayloadSpecificAppCode: |
99 HandlePayloadSpecificApp(rtcp_parser); | 115 HandlePayloadSpecificApp(rtcp_parser); |
100 break; | 116 break; |
101 case kRtcpApplicationSpecificCastReceiverLogCode: | 117 case kRtcpApplicationSpecificCastReceiverLogCode: |
102 HandleApplicationSpecificCastReceiverLog(rtcp_parser); | 118 HandleApplicationSpecificCastReceiverLog(rtcp_parser); |
103 break; | 119 break; |
104 case kRtcpPayloadSpecificRembCode: | 120 case kRtcpPayloadSpecificRembCode: |
105 case kRtcpPayloadSpecificRembItemCode: | 121 case kRtcpPayloadSpecificRembItemCode: |
106 case kRtcpPayloadSpecificCastCode: | 122 case kRtcpPayloadSpecificCastCode: |
107 case kRtcpPayloadSpecificCastNackItemCode: | 123 case kRtcpPayloadSpecificCastNackItemCode: |
108 case kRtcpApplicationSpecificCastReceiverLogFrameCode: | 124 case kRtcpApplicationSpecificCastReceiverLogFrameCode: |
109 case kRtcpApplicationSpecificCastReceiverLogEventCode: | 125 case kRtcpApplicationSpecificCastReceiverLogEventCode: |
110 case kRtcpNotValidCode: | 126 case kRtcpNotValidCode: |
111 case kRtcpReportBlockItemCode: | 127 case kRtcpReportBlockItemCode: |
112 case kRtcpSdesChunkCode: | 128 case kRtcpSdesChunkCode: |
129 case kRtcpGenericRtpFeedbackSrReqCode: | |
113 case kRtcpGenericRtpFeedbackNackItemCode: | 130 case kRtcpGenericRtpFeedbackNackItemCode: |
114 case kRtcpPayloadSpecificFirItemCode: | 131 case kRtcpPayloadSpecificFirItemCode: |
115 case kRtcpXrRrtrCode: | 132 case kRtcpXrRrtrCode: |
116 case kRtcpXrDlrrCode: | 133 case kRtcpXrDlrrCode: |
117 case kRtcpXrUnknownItemCode: | 134 case kRtcpXrUnknownItemCode: |
118 rtcp_parser->Iterate(); | 135 rtcp_parser->Iterate(); |
119 NOTREACHED() << "Invalid state"; | 136 NOTREACHED() << "Invalid state"; |
120 break; | 137 break; |
121 } | 138 } |
122 field_type = rtcp_parser->FieldType(); | 139 field_type = rtcp_parser->FieldType(); |
(...skipping 15 matching lines...) Expand all Loading... | |
138 RtcpSenderInfo remote_sender_info; | 155 RtcpSenderInfo remote_sender_info; |
139 remote_sender_info.ntp_seconds = | 156 remote_sender_info.ntp_seconds = |
140 rtcp_field.sender_report.ntp_most_significant; | 157 rtcp_field.sender_report.ntp_most_significant; |
141 remote_sender_info.ntp_fraction = | 158 remote_sender_info.ntp_fraction = |
142 rtcp_field.sender_report.ntp_least_significant; | 159 rtcp_field.sender_report.ntp_least_significant; |
143 remote_sender_info.rtp_timestamp = rtcp_field.sender_report.rtp_timestamp; | 160 remote_sender_info.rtp_timestamp = rtcp_field.sender_report.rtp_timestamp; |
144 remote_sender_info.send_packet_count = | 161 remote_sender_info.send_packet_count = |
145 rtcp_field.sender_report.sender_packet_count; | 162 rtcp_field.sender_report.sender_packet_count; |
146 remote_sender_info.send_octet_count = | 163 remote_sender_info.send_octet_count = |
147 rtcp_field.sender_report.sender_octet_count; | 164 rtcp_field.sender_report.sender_octet_count; |
148 if (receiver_feedback_) { | 165 if (handler_) { |
149 receiver_feedback_->OnReceivedSenderReport(remote_sender_info); | 166 handler_->OnReceivedSenderReport(remote_sender_info); |
150 } | 167 } |
151 } | 168 } |
152 rtcp_field_type = rtcp_parser->Iterate(); | 169 rtcp_field_type = rtcp_parser->Iterate(); |
153 while (rtcp_field_type == kRtcpReportBlockItemCode) { | 170 while (rtcp_field_type == kRtcpReportBlockItemCode) { |
154 HandleReportBlock(&rtcp_field, remote_ssrc); | 171 HandleReportBlock(&rtcp_field, remote_ssrc); |
155 rtcp_field_type = rtcp_parser->Iterate(); | 172 rtcp_field_type = rtcp_parser->Iterate(); |
156 } | 173 } |
157 } | 174 } |
158 | 175 |
159 void RtcpReceiver::HandleReceiverReport(RtcpParser* rtcp_parser) { | 176 void RtcpReceiver::HandleReceiverReport(RtcpParser* rtcp_parser) { |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
197 report_block.remote_ssrc = remote_ssrc; | 214 report_block.remote_ssrc = remote_ssrc; |
198 report_block.media_ssrc = rb.ssrc; | 215 report_block.media_ssrc = rb.ssrc; |
199 report_block.fraction_lost = rb.fraction_lost; | 216 report_block.fraction_lost = rb.fraction_lost; |
200 report_block.cumulative_lost = rb.cumulative_number_of_packets_lost; | 217 report_block.cumulative_lost = rb.cumulative_number_of_packets_lost; |
201 report_block.extended_high_sequence_number = | 218 report_block.extended_high_sequence_number = |
202 rb.extended_highest_sequence_number; | 219 rb.extended_highest_sequence_number; |
203 report_block.jitter = rb.jitter; | 220 report_block.jitter = rb.jitter; |
204 report_block.last_sr = rb.last_sender_report; | 221 report_block.last_sr = rb.last_sender_report; |
205 report_block.delay_since_last_sr = rb.delay_last_sender_report; | 222 report_block.delay_since_last_sr = rb.delay_last_sender_report; |
206 | 223 |
207 if (rtt_feedback_) { | 224 if (handler_) { |
208 rtt_feedback_->OnReceivedDelaySinceLastReport( | 225 handler_->OnReceivedDelaySinceLastReport( |
209 rb.ssrc, rb.last_sender_report, rb.delay_last_sender_report); | 226 rb.last_sender_report, rb.delay_last_sender_report); |
210 } | 227 } |
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 } |
(...skipping 28 matching lines...) Expand all Loading... | |
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 |
258 if (receiver_feedback_) { | 275 if (handler_) { |
259 receiver_feedback_->OnReceiverReferenceTimeReport(remote_time_report); | 276 handler_->OnReceiverReferenceTimeReport(remote_time_report); |
260 } | 277 } |
261 } | 278 } |
262 | 279 |
263 void RtcpReceiver::HandleDlrr(RtcpParser* rtcp_parser) { | 280 void RtcpReceiver::HandleDlrr(RtcpParser* rtcp_parser) { |
264 const RtcpField& rtcp_field = rtcp_parser->Field(); | 281 const RtcpField& rtcp_field = rtcp_parser->Field(); |
265 if (remote_ssrc_ != rtcp_field.dlrr.receivers_ssrc) { | 282 if (remote_ssrc_ != rtcp_field.dlrr.receivers_ssrc) { |
266 // Not to us. | 283 // Not to us. |
267 return; | 284 return; |
268 } | 285 } |
269 if (rtt_feedback_) { | 286 if (handler_) { |
270 rtt_feedback_->OnReceivedDelaySinceLastReport( | 287 handler_->OnReceivedDelaySinceLastReport( |
271 rtcp_field.dlrr.receivers_ssrc, | |
272 rtcp_field.dlrr.last_receiver_report, | 288 rtcp_field.dlrr.last_receiver_report, |
273 rtcp_field.dlrr.delay_last_receiver_report); | 289 rtcp_field.dlrr.delay_last_receiver_report); |
274 } | 290 } |
275 } | 291 } |
276 | 292 |
277 void RtcpReceiver::HandleNACK(RtcpParser* rtcp_parser) { | 293 void RtcpReceiver::HandleNACK(RtcpParser* rtcp_parser) { |
278 const RtcpField& rtcp_field = rtcp_parser->Field(); | 294 const RtcpField& rtcp_field = rtcp_parser->Field(); |
279 if (ssrc_ != rtcp_field.nack.media_ssrc) { | 295 if (ssrc_ != rtcp_field.nack.media_ssrc) { |
280 RtcpFieldTypes field_type; | 296 RtcpFieldTypes field_type; |
281 // Message not to us. Iterate until we have passed this message. | 297 // Message not to us. Iterate until we have passed this message. |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
319 | 335 |
320 void RtcpReceiver::HandlePLI(RtcpParser* rtcp_parser) { | 336 void RtcpReceiver::HandlePLI(RtcpParser* rtcp_parser) { |
321 const RtcpField& rtcp_field = rtcp_parser->Field(); | 337 const RtcpField& rtcp_field = rtcp_parser->Field(); |
322 if (ssrc_ == rtcp_field.pli.media_ssrc) { | 338 if (ssrc_ == rtcp_field.pli.media_ssrc) { |
323 // Received a signal that we need to send a new key frame. | 339 // Received a signal that we need to send a new key frame. |
324 VLOG(2) << "Cast RTCP received PLI on our SSRC " << ssrc_; | 340 VLOG(2) << "Cast RTCP received PLI on our SSRC " << ssrc_; |
325 } | 341 } |
326 rtcp_parser->Iterate(); | 342 rtcp_parser->Iterate(); |
327 } | 343 } |
328 | 344 |
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) { | 345 void RtcpReceiver::HandleRpsi(RtcpParser* rtcp_parser) { |
337 const RtcpField& rtcp_field = rtcp_parser->Field(); | 346 const RtcpField& rtcp_field = rtcp_parser->Field(); |
338 if (rtcp_parser->Iterate() != kRtcpPayloadSpecificRpsiCode) { | 347 if (rtcp_parser->Iterate() != kRtcpPayloadSpecificRpsiCode) { |
339 return; | 348 return; |
340 } | 349 } |
341 if (rtcp_field.rpsi.number_of_valid_bits % 8 != 0) { | 350 if (rtcp_field.rpsi.number_of_valid_bits % 8 != 0) { |
342 // Continue | 351 // Continue |
343 return; | 352 return; |
344 } | 353 } |
345 uint64 rpsi_picture_id = 0; | 354 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, | 438 rtcp_field.cast_receiver_log.rtp_timestamp, |
430 rtcp_parser, | 439 rtcp_parser, |
431 &frame_log.event_log_messages_); | 440 &frame_log.event_log_messages_); |
432 field_type = rtcp_parser->Iterate(); | 441 field_type = rtcp_parser->Iterate(); |
433 } | 442 } |
434 | 443 |
435 if (!frame_log.event_log_messages_.empty()) | 444 if (!frame_log.event_log_messages_.empty()) |
436 receiver_log.push_back(frame_log); | 445 receiver_log.push_back(frame_log); |
437 } | 446 } |
438 | 447 |
439 if (receiver_feedback_ && !receiver_log.empty()) { | 448 if (handler_ && !receiver_log.empty()) { |
440 receiver_feedback_->OnReceivedReceiverLog(receiver_log); | 449 handler_->OnReceivedReceiverLog(receiver_log); |
441 } | 450 } |
442 } | 451 } |
443 | 452 |
444 void RtcpReceiver::HandleApplicationSpecificCastReceiverEventLog( | 453 void RtcpReceiver::HandleApplicationSpecificCastReceiverEventLog( |
445 uint32 frame_rtp_timestamp, | 454 uint32 frame_rtp_timestamp, |
446 RtcpParser* rtcp_parser, | 455 RtcpParser* rtcp_parser, |
447 RtcpReceiverEventLogMessages* event_log_messages) { | 456 RtcpReceiverEventLogMessages* event_log_messages) { |
448 const RtcpField& rtcp_field = rtcp_parser->Field(); | 457 const RtcpField& rtcp_field = rtcp_parser->Field(); |
449 | 458 |
450 const uint8 event = rtcp_field.cast_receiver_log.event; | 459 const uint8 event = rtcp_field.cast_receiver_log.event; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
495 rtcp_field.cast_item.last_frame_id); | 504 rtcp_field.cast_item.last_frame_id); |
496 cast_message.target_delay_ms_ = rtcp_field.cast_item.target_delay_ms; | 505 cast_message.target_delay_ms_ = rtcp_field.cast_item.target_delay_ms; |
497 | 506 |
498 RtcpFieldTypes packet_type = rtcp_parser->Iterate(); | 507 RtcpFieldTypes packet_type = rtcp_parser->Iterate(); |
499 while (packet_type == kRtcpPayloadSpecificCastNackItemCode) { | 508 while (packet_type == kRtcpPayloadSpecificCastNackItemCode) { |
500 const RtcpField& rtcp_field = rtcp_parser->Field(); | 509 const RtcpField& rtcp_field = rtcp_parser->Field(); |
501 HandlePayloadSpecificCastNackItem( | 510 HandlePayloadSpecificCastNackItem( |
502 &rtcp_field, &cast_message.missing_frames_and_packets_); | 511 &rtcp_field, &cast_message.missing_frames_and_packets_); |
503 packet_type = rtcp_parser->Iterate(); | 512 packet_type = rtcp_parser->Iterate(); |
504 } | 513 } |
505 if (sender_feedback_) { | 514 if (handler_) { |
506 sender_feedback_->OnReceivedCastFeedback(cast_message); | 515 handler_->OnReceivedCastFeedback(cast_message); |
507 } | 516 } |
508 } | 517 } |
509 | 518 |
510 void RtcpReceiver::HandlePayloadSpecificCastNackItem( | 519 void RtcpReceiver::HandlePayloadSpecificCastNackItem( |
511 const RtcpField* rtcp_field, | 520 const RtcpField* rtcp_field, |
512 MissingFramesAndPacketsMap* missing_frames_and_packets) { | 521 MissingFramesAndPacketsMap* missing_frames_and_packets) { |
513 | 522 |
514 MissingFramesAndPacketsMap::iterator frame_it = | 523 MissingFramesAndPacketsMap::iterator frame_it = |
515 missing_frames_and_packets->find(rtcp_field->cast_nack_item.frame_id); | 524 missing_frames_and_packets->find(rtcp_field->cast_nack_item.frame_id); |
516 | 525 |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
555 void RtcpReceiver::HandleFIRItem(const RtcpField* rtcp_field) { | 564 void RtcpReceiver::HandleFIRItem(const RtcpField* rtcp_field) { |
556 // Is it our sender that is requested to generate a new keyframe. | 565 // Is it our sender that is requested to generate a new keyframe. |
557 if (ssrc_ != rtcp_field->fir_item.ssrc) | 566 if (ssrc_ != rtcp_field->fir_item.ssrc) |
558 return; | 567 return; |
559 | 568 |
560 VLOG(2) << "Cast RTCP received FIR on our SSRC " << ssrc_; | 569 VLOG(2) << "Cast RTCP received FIR on our SSRC " << ssrc_; |
561 } | 570 } |
562 | 571 |
563 } // namespace cast | 572 } // namespace cast |
564 } // namespace media | 573 } // namespace media |
OLD | NEW |