Rename ReceiveInfo to TmmbrInfo

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 55 matching lines @@
   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 {
+// Structure for handing TMMBR and TMMBN rtcp messages (RFC5104, section 3.5.4).
+struct RTCPReceiver::TmmbrInformation {
   struct TimedTmmbrItem {
     rtcp::TmmbItem tmmbr_item;
     int64_t last_updated_ms;
   };
 
   int64_t last_time_received_ms = 0;
 
   bool ready_for_delete = false;
 
   std::vector<rtcp::TmmbItem> tmmbn;
@@ skipping 317 matching lines @@
   rtcp::SenderReport sender_report;
   if (!sender_report.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   const uint32_t remote_ssrc = sender_report.sender_ssrc();
 
   packet_information->remote_ssrc = remote_ssrc;
 
-  CreateReceiveInformation(remote_ssrc);
+  CreateTmmbrInformation(remote_ssrc);
 
   TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
                        "remote_ssrc", remote_ssrc, "ssrc", main_ssrc_);
 
   // Have I received RTP packets from this party?
   if (remote_ssrc_ == remote_ssrc) {
     // Only signal that we have received a SR when we accept one.
     packet_information->packet_type_flags |= kRtcpSr;
 
     // Save the NTP time of this report.
@@ skipping 21 matching lines @@
     ++num_skipped_packets_;
     return;
   }
 
   last_received_rr_ms_ = clock_->TimeInMilliseconds();
 
   const uint32_t remote_ssrc = receiver_report.sender_ssrc();
 
   packet_information->remote_ssrc = remote_ssrc;
 
-  CreateReceiveInformation(remote_ssrc);
+  CreateTmmbrInformation(remote_ssrc);
 
   TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
                        "remote_ssrc", remote_ssrc, "ssrc", main_ssrc_);
 
   packet_information->packet_type_flags |= kRtcpRr;
 
   for (const ReportBlock& report_block : receiver_report.report_blocks())
     HandleReportBlock(report_block, packet_information, remote_ssrc);
 }
 
@@ skipping 60 matching lines @@
     ++report_block_info->num_rtts;
   }
 
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT",
                     report_block.source_ssrc(), rtt_ms);
 
   packet_information->rtt_ms = rtt_ms;
   packet_information->report_blocks.push_back(report_block_info->report_block);
 }
 
-void RTCPReceiver::CreateReceiveInformation(uint32_t remote_ssrc) {
+void RTCPReceiver::CreateTmmbrInformation(uint32_t remote_ssrc) {
   // Create or find receive information.
-  ReceiveInformation* receive_info = &received_infos_[remote_ssrc];
+  TmmbrInformation* tmmbr_info = &tmmbr_infos_[remote_ssrc];
   // Update that this remote is alive.
-  receive_info->last_time_received_ms = clock_->TimeInMilliseconds();
+  tmmbr_info->last_time_received_ms = clock_->TimeInMilliseconds();
 }
 
-RTCPReceiver::ReceiveInformation* RTCPReceiver::GetReceiveInformation(
+RTCPReceiver::TmmbrInformation* RTCPReceiver::GetTmmbrInformation(
     uint32_t remote_ssrc) {
-  auto it = received_infos_.find(remote_ssrc);
-  if (it == received_infos_.end())
+  auto it = tmmbr_infos_.find(remote_ssrc);
+  if (it == tmmbr_infos_.end())
     return nullptr;
   return &it->second;
 }
 
 bool RTCPReceiver::RtcpRrTimeout(int64_t rtcp_interval_ms) {
   rtc::CritScope lock(&rtcp_receiver_lock_);
   if (last_received_rr_ms_ == 0)
     return false;
 
   int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
@@ skipping 13 matching lines @@
   int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
   if (clock_->TimeInMilliseconds() >
       last_increased_sequence_number_ms_ + time_out_ms) {
     // Reset the timer to only trigger one log.
     last_increased_sequence_number_ms_ = 0;
     return true;
   }
   return false;
 }
 
-bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() {
+bool RTCPReceiver::UpdateTmmbrTimers() {
   rtc::CritScope lock(&rtcp_receiver_lock_);
 
   int64_t now_ms = clock_->TimeInMilliseconds();
   // Use audio define since we don't know what interval the remote peer use.
   int64_t timeout_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
 
-  if (oldest_received_info_ms_ >= timeout_ms)
+  if (oldest_tmmbr_info_ms_ >= timeout_ms)
     return false;
 
   bool update_bounding_set = false;
-  oldest_received_info_ms_ = -1;
-  for (auto receive_info_it = received_infos_.begin();
-       receive_info_it != received_infos_.end();) {
-    ReceiveInformation* receive_info = &receive_info_it->second;
-    if (receive_info->last_time_received_ms > 0) {
-      if (receive_info->last_time_received_ms < timeout_ms) {
+  oldest_tmmbr_info_ms_ = -1;
+  for (auto tmmbr_it = tmmbr_infos_.begin(); tmmbr_it != tmmbr_infos_.end();) {
+    TmmbrInformation* tmmbr_info = &tmmbr_it->second;
+    if (tmmbr_info->last_time_received_ms > 0) {
+      if (tmmbr_info->last_time_received_ms < timeout_ms) {
         // No rtcp packet for the last 5 regular intervals, reset limitations.
-        receive_info->tmmbr.clear();
+        tmmbr_info->tmmbr.clear();
         // Prevent that we call this over and over again.
-        receive_info->last_time_received_ms = 0;
+        tmmbr_info->last_time_received_ms = 0;
         // Send new TMMBN to all channels using the default codec.
         update_bounding_set = true;
-      } else if (oldest_received_info_ms_ == -1 ||
-                 receive_info->last_time_received_ms <
-                     oldest_received_info_ms_) {
-        oldest_received_info_ms_ = receive_info->last_time_received_ms;
+      } else if (oldest_tmmbr_info_ms_ == -1 ||
+                 tmmbr_info->last_time_received_ms < oldest_tmmbr_info_ms_) {
+        oldest_tmmbr_info_ms_ = tmmbr_info->last_time_received_ms;
       }
-      ++receive_info_it;
-    } else if (receive_info->ready_for_delete) {
+      ++tmmbr_it;
+    } else if (tmmbr_info->ready_for_delete) {
       // When we dont have a last_time_received_ms and the object is marked
       // ready_for_delete it's removed from the map.
-      receive_info_it = received_infos_.erase(receive_info_it);
+      tmmbr_it = tmmbr_infos_.erase(tmmbr_it);
     } else {
-      ++receive_info_it;
+      ++tmmbr_it;
     }
   }
   return update_bounding_set;
 }
 
 std::vector<rtcp::TmmbItem> RTCPReceiver::BoundingSet(bool* tmmbr_owner) {
   rtc::CritScope lock(&rtcp_receiver_lock_);
-  ReceiveInformation* receive_info = GetReceiveInformation(remote_ssrc_);
-  if (!receive_info)
+  TmmbrInformation* tmmbr_info = GetTmmbrInformation(remote_ssrc_);
+  if (!tmmbr_info)
     return std::vector<rtcp::TmmbItem>();
 
-  *tmmbr_owner = TMMBRHelp::IsOwner(receive_info->tmmbn, main_ssrc_);
-  return receive_info->tmmbn;
+  *tmmbr_owner = TMMBRHelp::IsOwner(tmmbr_info->tmmbn, main_ssrc_);
+  return tmmbr_info->tmmbn;
 }
 
 void RTCPReceiver::HandleSdes(const CommonHeader& rtcp_block,
                               PacketInformation* packet_information) {
   rtcp::Sdes sdes;
   if (!sdes.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
@@ skipping 37 matching lines @@
   rtcp::Bye bye;
   if (!bye.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   // 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;
+  TmmbrInformation* tmmbr_info = GetTmmbrInformation(bye.sender_ssrc());
+  if (tmmbr_info)
+    tmmbr_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)) {
@@ skipping 78 matching lines @@
 
 void RTCPReceiver::HandleTmmbr(const CommonHeader& rtcp_block,
                                PacketInformation* packet_information) {
   rtcp::Tmmbr tmmbr;
   if (!tmmbr.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   uint32_t sender_ssrc = tmmbr.sender_ssrc();
-  ReceiveInformation* receive_info = GetReceiveInformation(sender_ssrc);
+  TmmbrInformation* receive_info = GetTmmbrInformation(sender_ssrc);
   if (!receive_info)  // This remote SSRC must be saved before.
     return;
 
   if (tmmbr.media_ssrc()) {
     // media_ssrc() SHOULD be 0 if same as SenderSSRC.
     // In relay mode this is a valid number.
     sender_ssrc = tmmbr.media_ssrc();
   }
 
   for (const rtcp::TmmbItem& request : tmmbr.requests()) {
@@ skipping 10 matching lines @@
 }
 
 void RTCPReceiver::HandleTmmbn(const CommonHeader& rtcp_block,
                                PacketInformation* packet_information) {
   rtcp::Tmmbn tmmbn;
   if (!tmmbn.Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
-  ReceiveInformation* receive_info = GetReceiveInformation(tmmbn.sender_ssrc());
+  TmmbrInformation* receive_info = GetTmmbrInformation(tmmbn.sender_ssrc());
   if (!receive_info)  // This remote SSRC must be saved before.
     return;
 
   packet_information->packet_type_flags |= kRtcpTmmbn;
 
   for (const auto& item : tmmbn.items())
     receive_info->tmmbn.push_back(item);
 }
 
 void RTCPReceiver::HandleSrReq(const CommonHeader& rtcp_block,
@@ skipping 92 matching lines @@
       new rtcp::TransportFeedback());
   if (!transport_feedback->Parse(rtcp_block)) {
     ++num_skipped_packets_;
     return;
   }
 
   packet_information->packet_type_flags |= kRtcpTransportFeedback;
   packet_information->transport_feedback = std::move(transport_feedback);
 }
 
-void RTCPReceiver::UpdateTmmbr() {
+void RTCPReceiver::NotifyTmmbrUpdated() {
   // Find bounding set.
   std::vector<rtcp::TmmbItem> bounding =
       TMMBRHelp::FindBoundingSet(TmmbrReceived());
 
   if (!bounding.empty() && rtcp_bandwidth_observer_) {
     // We have a new bandwidth estimate on this channel.
     uint64_t bitrate_bps = TMMBRHelp::CalcMinBitrateBps(bounding);
     if (bitrate_bps <= std::numeric_limits<uint32_t>::max())
       rtcp_bandwidth_observer_->OnReceivedEstimatedBitrate(bitrate_bps);
   }
 
-  // Set bounding set: inform remote clients about the new bandwidth.
+  // Send tmmbn to inform remote clients about the new bandwidth.
   rtp_rtcp_->SetTmmbn(std::move(bounding));
 }
 
 void RTCPReceiver::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
   rtc::CritScope cs(&feedbacks_lock_);
   stats_callback_ = callback;
 }
 
 RtcpStatisticsCallback* RTCPReceiver::GetRtcpStatisticsCallback() {
   rtc::CritScope cs(&feedbacks_lock_);
   return stats_callback_;
 }
 
 // Holding no Critical section.
 void RTCPReceiver::TriggerCallbacksFromRtcpPacket(
     const PacketInformation& packet_information) {
   // Process TMMBR and REMB first to avoid multiple callbacks
   // to OnNetworkChanged.
   if (packet_information.packet_type_flags & kRtcpTmmbr) {
     // Might trigger a OnReceivedBandwidthEstimateUpdate.
-    UpdateTmmbr();
+    NotifyTmmbrUpdated();
   }
   uint32_t local_ssrc;
   std::set<uint32_t> registered_ssrcs;
   {
     // We don't want to hold this critsect when triggering the callbacks below.
     rtc::CritScope lock(&rtcp_receiver_lock_);
     local_ssrc = main_ssrc_;
     registered_ssrcs = registered_ssrcs_;
   }
   if (!receiver_only_ && (packet_information.packet_type_flags & kRtcpSrReq)) {
@@ skipping 101 matching lines @@
 }
 
 std::vector<rtcp::TmmbItem> RTCPReceiver::TmmbrReceived() {
   rtc::CritScope lock(&rtcp_receiver_lock_);
   std::vector<rtcp::TmmbItem> candidates;
 
   int64_t now_ms = clock_->TimeInMilliseconds();
   // Use audio define since we don't know what interval the remote peer use.
   int64_t timeout_ms = now_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
 
-  for (auto& kv : received_infos_) {
+  for (auto& kv : tmmbr_infos_) {
     for (auto it = kv.second.tmmbr.begin(); it != kv.second.tmmbr.end();) {
       if (it->second.last_updated_ms < timeout_ms) {
         // Erase timeout entries.
         it = kv.second.tmmbr.erase(it);
       } else {
         candidates.push_back(it->second.tmmbr_item);
         ++it;
       }
     }
   }
   return candidates;
 }
 
 }  // namespace webrtc