Remove TMMBRSet class

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 89 matching lines @@
 int64_t RTCPReceiver::LastReceived() {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   return _lastReceived;
 }
 
 int64_t RTCPReceiver::LastReceivedReceiverReport() const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   int64_t last_received_rr = -1;
   for (ReceivedInfoMap::const_iterator it = _receivedInfoMap.begin();
        it != _receivedInfoMap.end(); ++it) {
-    if (it->second->lastTimeReceived > last_received_rr) {
-      last_received_rr = it->second->lastTimeReceived;
+    if (it->second->last_time_received_ms > last_received_rr) {
+      last_received_rr = it->second->last_time_received_ms;
     }
   }
   return last_received_rr;
 }
 
 void RTCPReceiver::SetRemoteSSRC(uint32_t ssrc) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   // new SSRC reset old reports
   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
@@ skipping 316 matching lines @@
         {
             rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
         }
     } else
     {
       TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
                            "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
 
         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
     }
-    UpdateReceiveInformation(*ptrReceiveInfo);
+    // Update that this remote is alive.
+    ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
 
     rtcpPacketType = rtcpParser.Iterate();
 
     while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
         HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
         rtcpPacketType = rtcpParser.Iterate();
     }
 }
 
 void RTCPReceiver::HandleReportBlock(
@@ skipping 173 matching lines @@
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
       _receivedInfoMap.find(remoteSSRC);
   if (it == _receivedInfoMap.end()) {
     return NULL;
   }
   return it->second;
 }
 
-void RTCPReceiver::UpdateReceiveInformation(
-    RTCPReceiveInformation& receiveInformation) {
-  // Update that this remote is alive
-  receiveInformation.lastTimeReceived = _clock->TimeInMilliseconds();
-}
-
 bool RTCPReceiver::RtcpRrTimeout(int64_t rtcp_interval_ms) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   if (_lastReceivedRrMs == 0)
     return false;
 
   int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
   if (_clock->TimeInMilliseconds() > _lastReceivedRrMs + time_out_ms) {
     // Reset the timer to only trigger one log.
     _lastReceivedRrMs = 0;
     return true;
@@ skipping 26 matching lines @@
       _receivedInfoMap.begin();
 
   while (receiveInfoIt != _receivedInfoMap.end()) {
     RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
     if (receiveInfo == NULL) {
       return updateBoundingSet;
     }
     // time since last received rtcp packet
     // when we dont have a lastTimeReceived and the object is marked
     // readyForDelete it's removed from the map
-    if (receiveInfo->lastTimeReceived) {
+    if (receiveInfo->last_time_received_ms > 0) {
       /// use audio define since we don't know what interval the remote peer is
       // using
-      if ((timeNow - receiveInfo->lastTimeReceived) >
+      if ((timeNow - receiveInfo->last_time_received_ms) >
           5 * RTCP_INTERVAL_AUDIO_MS) {
         // no rtcp packet for the last five regular intervals, reset limitations
-        receiveInfo->TmmbrSet.clearSet();
+        receiveInfo->ClearTmmbr();
         // prevent that we call this over and over again
-        receiveInfo->lastTimeReceived = 0;
+        receiveInfo->last_time_received_ms = 0;
         // send new TMMBN to all channels using the default codec
         updateBoundingSet = true;
       }
       receiveInfoIt++;
-    } else if (receiveInfo->readyForDelete) {
+    } else if (receiveInfo->ready_for_delete) {
       // store our current receiveInfoItem
       std::map<uint32_t, RTCPReceiveInformation*>::iterator
       receiveInfoItemToBeErased = receiveInfoIt;
       receiveInfoIt++;
       delete receiveInfoItemToBeErased->second;
       _receivedInfoMap.erase(receiveInfoItemToBeErased);
     } else {
       receiveInfoIt++;
     }
   }
   return updateBoundingSet;
 }
 
-int32_t RTCPReceiver::BoundingSet(bool* tmmbrOwner, TMMBRSet* boundingSetRec) {
+std::vector<rtcp::TmmbItem> RTCPReceiver::BoundingSet(bool* tmmbr_owner) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.find(_remoteSSRC);
 
   if (receiveInfoIt == _receivedInfoMap.end()) {
-    return -1;
+    return std::vector<rtcp::TmmbItem>();
   }
   RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
-  if (receiveInfo == NULL) {
-    return -1;
-  }
-  if (receiveInfo->TmmbnBoundingSet.lengthOfSet() > 0) {
-    boundingSetRec->VerifyAndAllocateSet(
-        receiveInfo->TmmbnBoundingSet.lengthOfSet() + 1);
-    for(uint32_t i=0; i< receiveInfo->TmmbnBoundingSet.lengthOfSet();
-        i++) {
-      if(receiveInfo->TmmbnBoundingSet.Ssrc(i) == main_ssrc_) {
-        // owner of bounding set
-        *tmmbrOwner = true;
-      }
-      boundingSetRec->SetEntry(i,
-                               receiveInfo->TmmbnBoundingSet.Tmmbr(i),
-                               receiveInfo->TmmbnBoundingSet.PacketOH(i),
-                               receiveInfo->TmmbnBoundingSet.Ssrc(i));
-    }
-  }
-  return receiveInfo->TmmbnBoundingSet.lengthOfSet();
+  RTC_DCHECK(receiveInfo);
+
+  *tmmbr_owner = TMMBRHelp::IsOwner(receiveInfo->tmmbn, main_ssrc_);
+  return receiveInfo->tmmbn;
 }
 
 void RTCPReceiver::HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser,
                               RTCPPacketInformation& rtcpPacketInformation) {
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kSdesChunk) {
     HandleSDESChunk(rtcpParser);
     pktType = rtcpParser.Iterate();
   }
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes;
@@ skipping 71 matching lines @@
       delete it_info->second;
       info_map->erase(it_info);
     }
   }
 
   //  we can't delete it due to TMMBR
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC);
 
   if (receiveInfoIt != _receivedInfoMap.end()) {
-    receiveInfoIt->second->readyForDelete = true;
+    receiveInfoIt->second->ready_for_delete = true;
   }
 
   std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt =
       _receivedCnameMap.find(rtcpPacket.BYE.SenderSSRC);
 
   if (cnameInfoIt != _receivedCnameMap.end()) {
     delete cnameInfoIt->second;
     _receivedCnameMap.erase(cnameInfoIt);
   }
   xr_rr_rtt_ms_ = 0;
@@ skipping 148 matching lines @@
   // Use packet length to calc max number of TMMBR blocks
   // each TMMBR block is 8 bytes
   ptrdiff_t maxNumOfTMMBRBlocks = rtcpParser.LengthLeft() / 8;
 
   // sanity, we can't have more than what's in one packet
   if (maxNumOfTMMBRBlocks > 200) {
     assert(false);
     rtcpParser.Iterate();
     return;
   }
-  ptrReceiveInfo->VerifyAndAllocateTMMBRSet((uint32_t)maxNumOfTMMBRBlocks);
 
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
     HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation, senderSSRC);
     pktType = rtcpParser.Iterate();
   }
 }
 
 void RTCPReceiver::HandleTMMBRItem(RTCPReceiveInformation& receiveInfo,
                                    const RTCPUtility::RTCPPacket& rtcpPacket,
                                    RTCPPacketInformation& rtcpPacketInformation,
                                    uint32_t senderSSRC) {
   if (main_ssrc_ == rtcpPacket.TMMBRItem.SSRC &&
       rtcpPacket.TMMBRItem.MaxTotalMediaBitRate > 0) {
-    receiveInfo.InsertTMMBRItem(senderSSRC, rtcpPacket.TMMBRItem,
-                                _clock->TimeInMilliseconds());
+    receiveInfo.InsertTmmbrItem(
+        senderSSRC,
+        rtcp::TmmbItem(rtcpPacket.TMMBRItem.SSRC,
+                       rtcpPacket.TMMBRItem.MaxTotalMediaBitRate * 1000,
+                       rtcpPacket.TMMBRItem.MeasuredOverhead),
+        _clock->TimeInMilliseconds());
     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr;
   }
 }
 
 void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser,
                                RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(
       rtcpPacket.TMMBN.SenderSSRC);
   if (ptrReceiveInfo == NULL) {
     // This remote SSRC must be saved before.
     rtcpParser.Iterate();
     return;
   }
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbn;
   // Use packet length to calc max number of TMMBN blocks
   // each TMMBN block is 8 bytes
   ptrdiff_t maxNumOfTMMBNBlocks = rtcpParser.LengthLeft() / 8;
 
   // sanity, we cant have more than what's in one packet
   if (maxNumOfTMMBNBlocks > 200) {
     assert(false);
     rtcpParser.Iterate();
     return;
   }
 
-  ptrReceiveInfo->VerifyAndAllocateBoundingSet((uint32_t)maxNumOfTMMBNBlocks);
-
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kRtpfbTmmbnItem) {
     HandleTMMBNItem(*ptrReceiveInfo, rtcpPacket);
     pktType = rtcpParser.Iterate();
   }
 }
 
 void RTCPReceiver::HandleSR_REQ(RTCPUtility::RTCPParserV2& rtcpParser,
                                 RTCPPacketInformation& rtcpPacketInformation) {
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq;
   rtcpParser.Iterate();
 }
 
 void RTCPReceiver::HandleTMMBNItem(RTCPReceiveInformation& receiveInfo,
                                    const RTCPUtility::RTCPPacket& rtcpPacket) {
-  receiveInfo.TmmbnBoundingSet.AddEntry(
-      rtcpPacket.TMMBNItem.MaxTotalMediaBitRate,
-      rtcpPacket.TMMBNItem.MeasuredOverhead,
-      rtcpPacket.TMMBNItem.SSRC);
+  receiveInfo.tmmbn.emplace_back(
+      rtcpPacket.TMMBNItem.SSRC,
+      rtcpPacket.TMMBNItem.MaxTotalMediaBitRate * 1000,
+      rtcpPacket.TMMBNItem.MeasuredOverhead);
 }
 
 void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser,
                              RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   while (pktType == RTCPPacketTypes::kPsfbSliItem) {
     HandleSLIItem(rtcpPacket, rtcpPacketInformation);
     pktType = rtcpParser.Iterate();
   }
@@ skipping 95 matching lines @@
     return;
   }
 
   ++packet_type_counter_.fir_packets;
 
   // rtcpPacket.FIR.MediaSSRC SHOULD be 0 but we ignore to check it
   // we don't know who this originate from
   if (receiveInfo) {
     // check if we have reported this FIRSequenceNumber before
     if (rtcpPacket.FIRItem.CommandSequenceNumber !=
-        receiveInfo->lastFIRSequenceNumber) {
+        receiveInfo->last_fir_sequence_number) {
       int64_t now = _clock->TimeInMilliseconds();
       // sanity; don't go crazy with the callbacks
-      if ((now - receiveInfo->lastFIRRequest) > RTCP_MIN_FRAME_LENGTH_MS) {
-        receiveInfo->lastFIRRequest = now;
-        receiveInfo->lastFIRSequenceNumber =
+      if ((now - receiveInfo->last_fir_request_ms) > RTCP_MIN_FRAME_LENGTH_MS) {
+        receiveInfo->last_fir_request_ms = now;
+        receiveInfo->last_fir_sequence_number =
             rtcpPacket.FIRItem.CommandSequenceNumber;
         // received signal that we need to send a new key frame
         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
       }
     }
   } else {
     // received signal that we need to send a new key frame
     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
   }
 }
@@ skipping 190 matching lines @@
 
 std::vector<rtcp::TmmbItem> RTCPReceiver::TMMBRReceived() const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
   std::vector<rtcp::TmmbItem> candidates;
 
   int64_t now_ms = _clock->TimeInMilliseconds();
 
   for (const auto& kv : _receivedInfoMap) {
     RTCPReceiveInformation* receive_info = kv.second;
     RTC_DCHECK(receive_info);
-    receive_info->GetTMMBRSet(now_ms, &candidates);
+    receive_info->GetTmmbrSet(now_ms, &candidates);
   }
   return candidates;
 }
 
 }  // namespace webrtc