Split LastFir status out of RTCPReceiver::ReceiveInfo

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 37 matching lines @@
 namespace webrtc {
 namespace {
 
 using rtcp::CommonHeader;
 using rtcp::ReportBlock;
 
 // The number of RTCP time intervals needed to trigger a timeout.
 const int kRrTimeoutIntervals = 3;
 
 const int64_t kMaxWarningLogIntervalMs = 10000;
+const int64_t kRtcpMinFrameLengthMs = 17;
 
 }  // namespace
 
 struct RTCPReceiver::PacketInformation {
   uint32_t packet_type_flags = 0;  // RTCPPacketTypeFlags bit field.
 
   uint32_t remote_ssrc = 0;
   std::vector<uint16_t> nack_sequence_numbers;
   ReportBlockList report_blocks;
   int64_t rtt_ms = 0;
   uint8_t sli_picture_id = 0;
   uint64_t rpsi_picture_id = 0;
   uint32_t receiver_estimated_max_bitrate_bps = 0;
   std::unique_ptr<rtcp::TransportFeedback> transport_feedback;
   rtc::Optional<BitrateAllocation> target_bitrate_allocation;
 };
 
 struct RTCPReceiver::ReceiveInformation {
   struct TimedTmmbrItem {
     rtcp::TmmbItem tmmbr_item;
     int64_t last_updated_ms;
   };
 
   int64_t last_time_received_ms = 0;
 
-  int64_t last_fir_request_ms = 0;
-  int32_t last_fir_sequence_number = -1;
-
   bool ready_for_delete = false;
 
   std::vector<rtcp::TmmbItem> tmmbn;
   std::map<uint32_t, TimedTmmbrItem> tmmbr;
 };
 
 struct RTCPReceiver::ReportBlockWithRtt {
   RTCPReportBlock report_block;
 
   int64_t last_rtt_ms = 0;
   int64_t min_rtt_ms = 0;
   int64_t max_rtt_ms = 0;
   int64_t sum_rtt_ms = 0;
   size_t num_rtts = 0;
 };
 
+struct RTCPReceiver::LastFirStatus {
+  LastFirStatus(int64_t now_ms, uint8_t sequence_number)
+      : request_ms(now_ms), sequence_number(sequence_number) {}
+  int64_t request_ms;
+  uint8_t sequence_number;
+};
+
 RTCPReceiver::RTCPReceiver(
     Clock* clock,
     bool receiver_only,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcpBandwidthObserver* rtcp_bandwidth_observer,
     RtcpIntraFrameObserver* rtcp_intra_frame_observer,
     TransportFeedbackObserver* transport_feedback_observer,
     VideoBitrateAllocationObserver* bitrate_allocation_observer,
     ModuleRtpRtcp* owner)
     : clock_(clock),
@@ skipping 564 matching lines @@
 
   // Clear our lists.
   for (auto& reports_per_receiver : received_report_blocks_)
     reports_per_receiver.second.erase(bye.sender_ssrc());
 
   // We can't delete it due to TMMBR.
   ReceiveInformation* receive_info = GetReceiveInformation(bye.sender_ssrc());
   if (receive_info)
     receive_info->ready_for_delete = true;
 
+  last_fir_.erase(bye.sender_ssrc());
   received_cnames_.erase(bye.sender_ssrc());
   xr_rr_rtt_ms_ = 0;
 }
 
 void RTCPReceiver::HandleXr(const CommonHeader& rtcp_block,
                             PacketInformation* packet_information) {
   rtcp::ExtendedReports xr;
   if (!xr.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
@@ skipping 177 matching lines @@
 }
 
 void RTCPReceiver::HandleFir(const CommonHeader& rtcp_block,
                              PacketInformation* packet_information) {
   rtcp::Fir fir;
   if (!fir.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
-  ReceiveInformation* receive_info = GetReceiveInformation(fir.sender_ssrc());
-
   for (const rtcp::Fir::Request& fir_request : fir.requests()) {
     // Is it our sender that is requested to generate a new keyframe.
     if (main_ssrc_ != fir_request.ssrc)
       continue;
 
     ++packet_type_counter_.fir_packets;
 
-    if (receive_info) {
+    int64_t now_ms = clock_->TimeInMilliseconds();
+    auto inserted = last_fir_.insert(std::make_pair(
+        fir.sender_ssrc(), LastFirStatus(now_ms, fir_request.seq_nr)));
+    if (!inserted.second) {  // There was already an entry.
+      LastFirStatus* last_fir = &inserted.first->second;
+
       // Check if we have reported this FIRSequenceNumber before.
-      if (fir_request.seq_nr == receive_info->last_fir_sequence_number)
+      if (fir_request.seq_nr == last_fir->sequence_number)
         continue;
 
-      int64_t now_ms = clock_->TimeInMilliseconds();
       // Sanity: don't go crazy with the callbacks.
-      if (now_ms - receive_info->last_fir_request_ms < RTCP_MIN_FRAME_LENGTH_MS)
+      if (now_ms - last_fir->request_ms < kRtcpMinFrameLengthMs)
         continue;
 
-      receive_info->last_fir_request_ms = now_ms;
-      receive_info->last_fir_sequence_number = fir_request.seq_nr;
+      last_fir->request_ms = now_ms;
+      last_fir->sequence_number = fir_request.seq_nr;
     }
     // Received signal that we need to send a new key frame.
     packet_information->packet_type_flags |= kRtcpFir;
   }
 }
 
 void RTCPReceiver::HandleTransportFeedback(
     const CommonHeader& rtcp_block,
     PacketInformation* packet_information) {
   std::unique_ptr<rtcp::TransportFeedback> transport_feedback(
@@ skipping 171 matching lines @@
       } else {
         candidates.push_back(it->second.tmmbr_item);
         ++it;
       }
     }
   }
   return candidates;
 }
 
 }  // namespace webrtc