media/cast/rtcp/rtcp_receiver.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "media/cast/rtcp/rtcp_receiver.h"
   6
   7 #include "base/logging.h"
   8 #include "media/cast/rtcp/rtcp_utility.h"
   9 #include "media/cast/transport/cast_transport_defines.h"
  10
  11 namespace {
  12
  13 // A receiver frame event is identified by frame RTP timestamp, event timestamp
  14 // and event type.
  15 // A receiver packet event is identified by all of the above plus packet id.
  16 // The key format is as follows:
  17 // First uint64:
  18 //   bits 0-11: zeroes (unused).
  19 //   bits 12-15: event type ID.
  20 //   bits 16-31: packet ID if packet event, 0 otherwise.
  21 //   bits 32-63: RTP timestamp.
  22 // Second uint64:
  23 //   bits 0-63: event TimeTicks internal value.
  24 std::pair<uint64, uint64> GetReceiverEventKey(
  25     uint32 frame_rtp_timestamp, const base::TimeTicks& event_timestamp,
  26     uint8 event_type, uint16 packet_id_or_zero) {
  27   uint64 value1 = event_type;
  28   value1 <<= 16;
  29   value1 |= packet_id_or_zero;
  30   value1 <<= 32;
  31   value1 |= frame_rtp_timestamp;
  32   return std::make_pair(
  33       value1, static_cast<uint64>(event_timestamp.ToInternalValue()));
  34 }
  35
  36 }  // namespace
  37
  38 namespace media {
  39 namespace cast {
  40
  41 RtcpReceiver::RtcpReceiver(scoped_refptr<CastEnvironment> cast_environment,
  42                            RtcpSenderFeedback* sender_feedback,
  43                            RtcpReceiverFeedback* receiver_feedback,
  44                            RtcpRttFeedback* rtt_feedback,
  45                            uint32 local_ssrc)
  46     : ssrc_(local_ssrc),
  47       remote_ssrc_(0),
  48       sender_feedback_(sender_feedback),
  49       receiver_feedback_(receiver_feedback),
  50       rtt_feedback_(rtt_feedback),
  51       cast_environment_(cast_environment),
  52       receiver_event_history_size_(0) {}
  53
  54 RtcpReceiver::~RtcpReceiver() {}
  55
  56 void RtcpReceiver::SetRemoteSSRC(uint32 ssrc) { remote_ssrc_ = ssrc; }
  57
  58 void RtcpReceiver::SetCastReceiverEventHistorySize(size_t size) {
  59   receiver_event_history_size_ = size;
  60 }
  61
  62 void RtcpReceiver::IncomingRtcpPacket(RtcpParser* rtcp_parser) {
  63   RtcpFieldTypes field_type = rtcp_parser->Begin();
  64   while (field_type != kRtcpNotValidCode) {
  65     // Each "case" is responsible for iterate the parser to the next top
  66     // level packet.
  67     switch (field_type) {
  68       case kRtcpSrCode:
  69         HandleSenderReport(rtcp_parser);
  70         break;
  71       case kRtcpRrCode:
  72         HandleReceiverReport(rtcp_parser);
  73         break;
  74       case kRtcpSdesCode:
  75         HandleSDES(rtcp_parser);
  76         break;
  77       case kRtcpByeCode:
  78         HandleBYE(rtcp_parser);
  79         break;
  80       case kRtcpXrCode:
  81         HandleXr(rtcp_parser);
  82         break;
  83       case kRtcpGenericRtpFeedbackNackCode:
  84         HandleNACK(rtcp_parser);
  85         break;
  86       case kRtcpGenericRtpFeedbackSrReqCode:
  87         HandleSendReportRequest(rtcp_parser);
  88         break;
  89       case kRtcpPayloadSpecificPliCode:
  90         HandlePLI(rtcp_parser);
  91         break;
  92       case kRtcpPayloadSpecificRpsiCode:
  93         HandleRpsi(rtcp_parser);
  94         break;
  95       case kRtcpPayloadSpecificFirCode:
  96         HandleFIR(rtcp_parser);
  97         break;
  98       case kRtcpPayloadSpecificAppCode:
  99         HandlePayloadSpecificApp(rtcp_parser);
 100         break;
 101       case kRtcpApplicationSpecificCastReceiverLogCode:
 102         HandleApplicationSpecificCastReceiverLog(rtcp_parser);
 103         break;
 104       case kRtcpPayloadSpecificRembCode:
 105       case kRtcpPayloadSpecificRembItemCode:
 106       case kRtcpPayloadSpecificCastCode:
 107       case kRtcpPayloadSpecificCastNackItemCode:
 108       case kRtcpApplicationSpecificCastReceiverLogFrameCode:
 109       case kRtcpApplicationSpecificCastReceiverLogEventCode:
 110       case kRtcpNotValidCode:
 111       case kRtcpReportBlockItemCode:
 112       case kRtcpSdesChunkCode:
 113       case kRtcpGenericRtpFeedbackNackItemCode:
 114       case kRtcpPayloadSpecificFirItemCode:
 115       case kRtcpXrRrtrCode:
 116       case kRtcpXrDlrrCode:
 117       case kRtcpXrUnknownItemCode:
 118         rtcp_parser->Iterate();
 119         NOTREACHED() << "Invalid state";
 120         break;
 121     }
 122     field_type = rtcp_parser->FieldType();
 123   }
 124 }
 125
 126 void RtcpReceiver::HandleSenderReport(RtcpParser* rtcp_parser) {
 127   RtcpFieldTypes rtcp_field_type = rtcp_parser->FieldType();
 128   const RtcpField& rtcp_field = rtcp_parser->Field();
 129
 130   DCHECK(rtcp_field_type == kRtcpSrCode) << "Invalid state";
 131
 132   // Synchronization source identifier for the originator of this SR packet.
 133   uint32 remote_ssrc = rtcp_field.sender_report.sender_ssrc;
 134
 135   VLOG(2) << "Cast RTCP received SR from SSRC " << remote_ssrc;
 136
 137   if (remote_ssrc_ == remote_ssrc) {
 138     transport::RtcpSenderInfo remote_sender_info;
 139     remote_sender_info.ntp_seconds =
 140         rtcp_field.sender_report.ntp_most_significant;
 141     remote_sender_info.ntp_fraction =
 142         rtcp_field.sender_report.ntp_least_significant;
 143     remote_sender_info.rtp_timestamp = rtcp_field.sender_report.rtp_timestamp;
 144     remote_sender_info.send_packet_count =
 145         rtcp_field.sender_report.sender_packet_count;
 146     remote_sender_info.send_octet_count =
 147         rtcp_field.sender_report.sender_octet_count;
 148     if (receiver_feedback_) {
 149       receiver_feedback_->OnReceivedSenderReport(remote_sender_info);
 150     }
 151   }
 152   rtcp_field_type = rtcp_parser->Iterate();
 153   while (rtcp_field_type == kRtcpReportBlockItemCode) {
 154     HandleReportBlock(&rtcp_field, remote_ssrc);
 155     rtcp_field_type = rtcp_parser->Iterate();
 156   }
 157 }
 158
 159 void RtcpReceiver::HandleReceiverReport(RtcpParser* rtcp_parser) {
 160   RtcpFieldTypes rtcp_field_type = rtcp_parser->FieldType();
 161   const RtcpField& rtcp_field = rtcp_parser->Field();
 162
 163   DCHECK(rtcp_field_type == kRtcpRrCode) << "Invalid state";
 164
 165   uint32 remote_ssrc = rtcp_field.receiver_report.sender_ssrc;
 166
 167   VLOG(2) << "Cast RTCP received RR from SSRC " << remote_ssrc;
 168
 169   rtcp_field_type = rtcp_parser->Iterate();
 170   while (rtcp_field_type == kRtcpReportBlockItemCode) {
 171     HandleReportBlock(&rtcp_field, remote_ssrc);
 172     rtcp_field_type = rtcp_parser->Iterate();
 173   }
 174 }
 175
 176 void RtcpReceiver::HandleReportBlock(const RtcpField* rtcp_field,
 177                                      uint32 remote_ssrc) {
 178   // This will be called once per report block in the Rtcp packet.
 179   // We filter out all report blocks that are not for us.
 180   // Each packet has max 31 RR blocks.
 181   //
 182   // We can calculate RTT if we send a send report and get a report block back.
 183
 184   // |rtcp_field.ReportBlockItem.ssrc| is the ssrc identifier of the source to
 185   // which the information in this reception report block pertains.
 186
 187   const RtcpFieldReportBlockItem& rb = rtcp_field->report_block_item;
 188
 189   // Filter out all report blocks that are not for us.
 190   if (rb.ssrc != ssrc_) {
 191     // This block is not for us ignore it.
 192     return;
 193   }
 194   VLOG(2) << "Cast RTCP received RB from SSRC " << remote_ssrc;
 195
 196   transport::RtcpReportBlock report_block;
 197   report_block.remote_ssrc = remote_ssrc;
 198   report_block.media_ssrc = rb.ssrc;
 199   report_block.fraction_lost = rb.fraction_lost;
 200   report_block.cumulative_lost = rb.cumulative_number_of_packets_lost;
 201   report_block.extended_high_sequence_number =
 202       rb.extended_highest_sequence_number;
 203   report_block.jitter = rb.jitter;
 204   report_block.last_sr = rb.last_sender_report;
 205   report_block.delay_since_last_sr = rb.delay_last_sender_report;
 206
 207   if (rtt_feedback_) {
 208     rtt_feedback_->OnReceivedDelaySinceLastReport(
 209         rb.ssrc, rb.last_sender_report, rb.delay_last_sender_report);
 210   }
 211 }
 212
 213 void RtcpReceiver::HandleSDES(RtcpParser* rtcp_parser) {
 214   RtcpFieldTypes field_type = rtcp_parser->Iterate();
 215   while (field_type == kRtcpSdesChunkCode) {
 216     HandleSDESChunk(rtcp_parser);
 217     field_type = rtcp_parser->Iterate();
 218   }
 219 }
 220
 221 void RtcpReceiver::HandleSDESChunk(RtcpParser* rtcp_parser) {
 222   const RtcpField& rtcp_field = rtcp_parser->Field();
 223   VLOG(2) << "Cast RTCP received SDES with cname " << rtcp_field.c_name.name;
 224 }
 225
 226 void RtcpReceiver::HandleXr(RtcpParser* rtcp_parser) {
 227   RtcpFieldTypes rtcp_field_type = rtcp_parser->FieldType();
 228   const RtcpField& rtcp_field = rtcp_parser->Field();
 229
 230   DCHECK(rtcp_field_type == kRtcpXrCode) << "Invalid state";
 231
 232   uint32 remote_ssrc = rtcp_field.extended_report.sender_ssrc;
 233   rtcp_field_type = rtcp_parser->Iterate();
 234
 235   while (rtcp_field_type == kRtcpXrDlrrCode ||
 236          rtcp_field_type == kRtcpXrRrtrCode ||
 237          rtcp_field_type == kRtcpXrUnknownItemCode) {
 238     if (rtcp_field_type == kRtcpXrRrtrCode) {
 239       HandleRrtr(rtcp_parser, remote_ssrc);
 240     } else if (rtcp_field_type == kRtcpXrDlrrCode) {
 241       HandleDlrr(rtcp_parser);
 242     }
 243     rtcp_field_type = rtcp_parser->Iterate();
 244   }
 245 }
 246
 247 void RtcpReceiver::HandleRrtr(RtcpParser* rtcp_parser, uint32 remote_ssrc) {
 248   if (remote_ssrc_ != remote_ssrc) {
 249     // Not to us.
 250     return;
 251   }
 252   const RtcpField& rtcp_field = rtcp_parser->Field();
 253   RtcpReceiverReferenceTimeReport remote_time_report;
 254   remote_time_report.remote_ssrc = remote_ssrc;
 255   remote_time_report.ntp_seconds = rtcp_field.rrtr.ntp_most_significant;
 256   remote_time_report.ntp_fraction = rtcp_field.rrtr.ntp_least_significant;
 257
 258   if (receiver_feedback_) {
 259     receiver_feedback_->OnReceiverReferenceTimeReport(remote_time_report);
 260   }
 261 }
 262
 263 void RtcpReceiver::HandleDlrr(RtcpParser* rtcp_parser) {
 264   const RtcpField& rtcp_field = rtcp_parser->Field();
 265   if (remote_ssrc_ != rtcp_field.dlrr.receivers_ssrc) {
 266     // Not to us.
 267     return;
 268   }
 269   if (rtt_feedback_) {
 270     rtt_feedback_->OnReceivedDelaySinceLastReport(
 271         rtcp_field.dlrr.receivers_ssrc,
 272         rtcp_field.dlrr.last_receiver_report,
 273         rtcp_field.dlrr.delay_last_receiver_report);
 274   }
 275 }
 276
 277 void RtcpReceiver::HandleNACK(RtcpParser* rtcp_parser) {
 278   const RtcpField& rtcp_field = rtcp_parser->Field();
 279   if (ssrc_ != rtcp_field.nack.media_ssrc) {
 280     RtcpFieldTypes field_type;
 281     // Message not to us. Iterate until we have passed this message.
 282     do {
 283       field_type = rtcp_parser->Iterate();
 284     } while (field_type == kRtcpGenericRtpFeedbackNackItemCode);
 285     return;
 286   }
 287   std::list<uint16> nackSequenceNumbers;
 288
 289   RtcpFieldTypes field_type = rtcp_parser->Iterate();
 290   while (field_type == kRtcpGenericRtpFeedbackNackItemCode) {
 291     HandleNACKItem(&rtcp_field, &nackSequenceNumbers);
 292     field_type = rtcp_parser->Iterate();
 293   }
 294 }
 295
 296 void RtcpReceiver::HandleNACKItem(const RtcpField* rtcp_field,
 297                                   std::list<uint16>* nack_sequence_numbers) {
 298   nack_sequence_numbers->push_back(rtcp_field->nack_item.packet_id);
 299
 300   uint16 bitmask = rtcp_field->nack_item.bitmask;
 301   if (bitmask) {
 302     for (int i = 1; i <= 16; ++i) {
 303       if (bitmask & 1) {
 304         nack_sequence_numbers->push_back(rtcp_field->nack_item.packet_id + i);
 305       }
 306       bitmask = bitmask >> 1;
 307     }
 308   }
 309 }
 310
 311 void RtcpReceiver::HandleBYE(RtcpParser* rtcp_parser) {
 312   const RtcpField& rtcp_field = rtcp_parser->Field();
 313   uint32 remote_ssrc = rtcp_field.bye.sender_ssrc;
 314   if (remote_ssrc_ == remote_ssrc) {
 315     VLOG(2) << "Cast RTCP received BYE from SSRC " << remote_ssrc;
 316   }
 317   rtcp_parser->Iterate();
 318 }
 319
 320 void RtcpReceiver::HandlePLI(RtcpParser* rtcp_parser) {
 321   const RtcpField& rtcp_field = rtcp_parser->Field();
 322   if (ssrc_ == rtcp_field.pli.media_ssrc) {
 323     // Received a signal that we need to send a new key frame.
 324     VLOG(2) << "Cast RTCP received PLI on our SSRC " << ssrc_;
 325   }
 326   rtcp_parser->Iterate();
 327 }
 328
 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) {
 337   const RtcpField& rtcp_field = rtcp_parser->Field();
 338   if (rtcp_parser->Iterate() != kRtcpPayloadSpecificRpsiCode) {
 339     return;
 340   }
 341   if (rtcp_field.rpsi.number_of_valid_bits % 8 != 0) {
 342     // Continue
 343     return;
 344   }
 345   uint64 rpsi_picture_id = 0;
 346
 347   // Convert native_bit_string to rpsi_picture_id
 348   uint8 bytes = rtcp_field.rpsi.number_of_valid_bits / 8;
 349   for (uint8 n = 0; n < (bytes - 1); ++n) {
 350     rpsi_picture_id += (rtcp_field.rpsi.native_bit_string[n] & 0x7f);
 351     rpsi_picture_id <<= 7;  // Prepare next.
 352   }
 353   rpsi_picture_id += (rtcp_field.rpsi.native_bit_string[bytes - 1] & 0x7f);
 354
 355   VLOG(2) << "Cast RTCP received RPSI with picture_id " << rpsi_picture_id;
 356 }
 357
 358 void RtcpReceiver::HandlePayloadSpecificApp(RtcpParser* rtcp_parser) {
 359   const RtcpField& rtcp_field = rtcp_parser->Field();
 360   uint32 remote_ssrc = rtcp_field.application_specific.sender_ssrc;
 361   if (remote_ssrc_ != remote_ssrc) {
 362     // Message not to us. Iterate until we have passed this message.
 363     RtcpFieldTypes field_type;
 364     do {
 365       field_type = rtcp_parser->Iterate();
 366     } while (field_type == kRtcpPayloadSpecificRembCode ||
 367              field_type == kRtcpPayloadSpecificRembItemCode ||
 368              field_type == kRtcpPayloadSpecificCastCode ||
 369              field_type == kRtcpPayloadSpecificCastNackItemCode);
 370     return;
 371   }
 372
 373   RtcpFieldTypes packet_type = rtcp_parser->Iterate();
 374   switch (packet_type) {
 375     case kRtcpPayloadSpecificRembCode:
 376       packet_type = rtcp_parser->Iterate();
 377       if (packet_type == kRtcpPayloadSpecificRembItemCode) {
 378         HandlePayloadSpecificRembItem(rtcp_parser);
 379         rtcp_parser->Iterate();
 380       }
 381       break;
 382     case kRtcpPayloadSpecificCastCode:
 383       packet_type = rtcp_parser->Iterate();
 384       if (packet_type == kRtcpPayloadSpecificCastCode) {
 385         HandlePayloadSpecificCastItem(rtcp_parser);
 386       }
 387       break;
 388     default:
 389       return;
 390   }
 391 }
 392
 393 void RtcpReceiver::HandlePayloadSpecificRembItem(RtcpParser* rtcp_parser) {
 394   const RtcpField& rtcp_field = rtcp_parser->Field();
 395
 396   for (int i = 0; i < rtcp_field.remb_item.number_of_ssrcs; ++i) {
 397     if (rtcp_field.remb_item.ssrcs[i] == ssrc_) {
 398       // Found matching ssrc.
 399       VLOG(2) << "Cast RTCP received REMB with received_bitrate "
 400               << rtcp_field.remb_item.bitrate;
 401       return;
 402     }
 403   }
 404 }
 405
 406 void RtcpReceiver::HandleApplicationSpecificCastReceiverLog(
 407     RtcpParser* rtcp_parser) {
 408   const RtcpField& rtcp_field = rtcp_parser->Field();
 409
 410   uint32 remote_ssrc = rtcp_field.cast_receiver_log.sender_ssrc;
 411   if (remote_ssrc_ != remote_ssrc) {
 412     // Message not to us. Iterate until we have passed this message.
 413     RtcpFieldTypes field_type;
 414     do {
 415       field_type = rtcp_parser->Iterate();
 416     } while (field_type == kRtcpApplicationSpecificCastReceiverLogFrameCode ||
 417              field_type == kRtcpApplicationSpecificCastReceiverLogEventCode);
 418     return;
 419   }
 420   RtcpReceiverLogMessage receiver_log;
 421   RtcpFieldTypes field_type = rtcp_parser->Iterate();
 422   while (field_type == kRtcpApplicationSpecificCastReceiverLogFrameCode) {
 423     RtcpReceiverFrameLogMessage frame_log(
 424         rtcp_field.cast_receiver_log.rtp_timestamp);
 425
 426     field_type = rtcp_parser->Iterate();
 427     while (field_type == kRtcpApplicationSpecificCastReceiverLogEventCode) {
 428       HandleApplicationSpecificCastReceiverEventLog(
 429           rtcp_field.cast_receiver_log.rtp_timestamp,
 430           rtcp_parser,
 431           &frame_log.event_log_messages_);
 432       field_type = rtcp_parser->Iterate();
 433     }
 434
 435     if (!frame_log.event_log_messages_.empty())
 436       receiver_log.push_back(frame_log);
 437   }
 438
 439   if (receiver_feedback_ && !receiver_log.empty()) {
 440     receiver_feedback_->OnReceivedReceiverLog(receiver_log);
 441   }
 442 }
 443
 444 void RtcpReceiver::HandleApplicationSpecificCastReceiverEventLog(
 445     uint32 frame_rtp_timestamp,
 446     RtcpParser* rtcp_parser,
 447     RtcpReceiverEventLogMessages* event_log_messages) {
 448   const RtcpField& rtcp_field = rtcp_parser->Field();
 449
 450   const uint8 event = rtcp_field.cast_receiver_log.event;
 451   const CastLoggingEvent event_type = TranslateToLogEventFromWireFormat(event);
 452   uint16 packet_id = event_type == PACKET_RECEIVED ?
 453       rtcp_field.cast_receiver_log.delay_delta_or_packet_id.packet_id : 0;
 454   const base::TimeTicks event_timestamp =
 455       base::TimeTicks() +
 456       base::TimeDelta::FromMilliseconds(
 457           rtcp_field.cast_receiver_log.event_timestamp_base +
 458           rtcp_field.cast_receiver_log.event_timestamp_delta);
 459
 460   // The following code checks to see if we have already seen this event.
 461   // The algorithm works by maintaining a sliding window of events. We have
 462   // a queue and a set of events. We enqueue every new event and insert it
 463   // into the set. When the queue becomes too big we remove the oldest event
 464   // from both the queue and the set.
 465   ReceiverEventKey key =
 466       GetReceiverEventKey(
 467           frame_rtp_timestamp, event_timestamp, event, packet_id);
 468   if (receiver_event_key_set_.find(key) != receiver_event_key_set_.end()) {
 469     return;
 470   } else {
 471     receiver_event_key_set_.insert(key);
 472     receiver_event_key_queue_.push(key);
 473
 474     if (receiver_event_key_queue_.size() > receiver_event_history_size_) {
 475       const ReceiverEventKey oldest_key = receiver_event_key_queue_.front();
 476       receiver_event_key_queue_.pop();
 477       receiver_event_key_set_.erase(oldest_key);
 478     }
 479   }
 480
 481   RtcpReceiverEventLogMessage event_log;
 482   event_log.type = event_type;
 483   event_log.event_timestamp = event_timestamp;
 484   event_log.delay_delta = base::TimeDelta::FromMilliseconds(
 485       rtcp_field.cast_receiver_log.delay_delta_or_packet_id.delay_delta);
 486   event_log.packet_id =
 487       rtcp_field.cast_receiver_log.delay_delta_or_packet_id.packet_id;
 488   event_log_messages->push_back(event_log);
 489 }
 490
 491 void RtcpReceiver::HandlePayloadSpecificCastItem(RtcpParser* rtcp_parser) {
 492   const RtcpField& rtcp_field = rtcp_parser->Field();
 493   RtcpCastMessage cast_message(remote_ssrc_);
 494   cast_message.ack_frame_id_ = ack_frame_id_wrap_helper_.MapTo32bitsFrameId(
 495       rtcp_field.cast_item.last_frame_id);
 496   cast_message.target_delay_ms_ = rtcp_field.cast_item.target_delay_ms;
 497
 498   RtcpFieldTypes packet_type = rtcp_parser->Iterate();
 499   while (packet_type == kRtcpPayloadSpecificCastNackItemCode) {
 500     const RtcpField& rtcp_field = rtcp_parser->Field();
 501     HandlePayloadSpecificCastNackItem(
 502         &rtcp_field, &cast_message.missing_frames_and_packets_);
 503     packet_type = rtcp_parser->Iterate();
 504   }
 505   if (sender_feedback_) {
 506     sender_feedback_->OnReceivedCastFeedback(cast_message);
 507   }
 508 }
 509
 510 void RtcpReceiver::HandlePayloadSpecificCastNackItem(
 511     const RtcpField* rtcp_field,
 512     MissingFramesAndPacketsMap* missing_frames_and_packets) {
 513
 514   MissingFramesAndPacketsMap::iterator frame_it =
 515       missing_frames_and_packets->find(rtcp_field->cast_nack_item.frame_id);
 516
 517   if (frame_it == missing_frames_and_packets->end()) {
 518     // First missing packet in a frame.
 519     PacketIdSet empty_set;
 520     std::pair<MissingFramesAndPacketsMap::iterator, bool> ret =
 521         missing_frames_and_packets->insert(std::pair<uint8, PacketIdSet>(
 522             rtcp_field->cast_nack_item.frame_id, empty_set));
 523     frame_it = ret.first;
 524     DCHECK(frame_it != missing_frames_and_packets->end()) << "Invalid state";
 525   }
 526   uint16 packet_id = rtcp_field->cast_nack_item.packet_id;
 527   frame_it->second.insert(packet_id);
 528
 529   if (packet_id == kRtcpCastAllPacketsLost) {
 530     // Special case all packets in a frame is missing.
 531     return;
 532   }
 533   uint8 bitmask = rtcp_field->cast_nack_item.bitmask;
 534
 535   if (bitmask) {
 536     for (int i = 1; i <= 8; ++i) {
 537       if (bitmask & 1) {
 538         frame_it->second.insert(packet_id + i);
 539       }
 540       bitmask = bitmask >> 1;
 541     }
 542   }
 543 }
 544
 545 void RtcpReceiver::HandleFIR(RtcpParser* rtcp_parser) {
 546   const RtcpField& rtcp_field = rtcp_parser->Field();
 547
 548   RtcpFieldTypes field_type = rtcp_parser->Iterate();
 549   while (field_type == kRtcpPayloadSpecificFirItemCode) {
 550     HandleFIRItem(&rtcp_field);
 551     field_type = rtcp_parser->Iterate();
 552   }
 553 }
 554
 555 void RtcpReceiver::HandleFIRItem(const RtcpField* rtcp_field) {
 556   // Is it our sender that is requested to generate a new keyframe.
 557   if (ssrc_ != rtcp_field->fir_item.ssrc)
 558     return;
 559
 560   VLOG(2) << "Cast RTCP received FIR on our SSRC " << ssrc_;
 561 }
 562
 563 }  // namespace cast
 564 }  // namespace media