[Splitting] TMMBRHelp class simplifted (and disappear because become too simple)

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 26 matching lines @@
 const int64_t kMaxWarningLogIntervalMs = 10000;
 
 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,
     ModuleRtpRtcpImpl* owner)
-    : TMMBRHelp(),
-      _clock(clock),
+    : _clock(clock),
       receiver_only_(receiver_only),
       _lastReceived(0),
       _rtpRtcp(*owner),
       _cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
       _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
       _cbTransportFeedbackObserver(transport_feedback_observer),
       main_ssrc_(0),
       _remoteSSRC(0),
       _remoteSenderInfo(),
       _lastReceivedSRNTPsecs(0),
@@ skipping 629 matching lines @@
     }
     // 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) {
       /// use audio define since we don't know what interval the remote peer is
       // using
       if ((timeNow - receiveInfo->lastTimeReceived) >
           5 * RTCP_INTERVAL_AUDIO_MS) {
         // no rtcp packet for the last five regular intervals, reset limitations
-        receiveInfo->TmmbrSet.clearSet();
+        receiveInfo->TmmbrSet.clear();
         // prevent that we call this over and over again
         receiveInfo->lastTimeReceived = 0;
         // send new TMMBN to all channels using the default codec
         updateBoundingSet = true;
       }
       receiveInfoIt++;
     } else if (receiveInfo->readyForDelete) {
       // 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) {
+int32_t RTCPReceiver::BoundingSet(bool* tmmbrOwner,
+                                  std::vector<rtcp::TmmbItem>* boundingSetRec) {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
 
   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
       _receivedInfoMap.find(_remoteSSRC);
 
   if (receiveInfoIt == _receivedInfoMap.end()) {
     return -1;
   }
   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_) {
+  if (receiveInfo->TmmbnBoundingSet.size() > 0) {
+    boundingSetRec->clear();
+    boundingSetRec->reserve(receiveInfo->TmmbnBoundingSet.size() + 1);
+    for (uint32_t i = 0; i < receiveInfo->TmmbnBoundingSet.size(); i++) {
+      if (receiveInfo->TmmbnBoundingSet[i].ssrc() == main_ssrc_) {
         // owner of bounding set
         *tmmbrOwner = true;
       }
-      boundingSetRec->SetEntry(i,
-                               receiveInfo->TmmbnBoundingSet.Tmmbr(i),
-                               receiveInfo->TmmbnBoundingSet.PacketOH(i),
-                               receiveInfo->TmmbnBoundingSet.Ssrc(i));
+      boundingSetRec->push_back(receiveInfo->TmmbnBoundingSet[i]);
     }
   }
-  return receiveInfo->TmmbnBoundingSet.lengthOfSet();
+  return receiveInfo->TmmbnBoundingSet.size();
 }
 
 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 300 matching lines @@
 }
 
 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.TmmbnBoundingSet.push_back(
+      rtcp::TmmbItem(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 143 matching lines @@
     RTCPUtility::RTCPParserV2* rtcp_parser,
     RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
   rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket();
   RTC_DCHECK(packet != nullptr);
   rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
   rtcp_packet_information->transport_feedback_.reset(
       static_cast<rtcp::TransportFeedback*>(packet));
 
   rtcp_parser->Iterate();
 }
+
 int32_t RTCPReceiver::UpdateTMMBR() {
-  int32_t numBoundingSet = 0;
-  uint32_t bitrate = 0;
-  uint32_t accNumCandidates = 0;
+  std::vector<rtcp::TmmbItem> candidates = TMMBRReceived();
+  // Find bounding set
+  FindTMMBRBoundingSet(&candidates);
 
-  int32_t size = TMMBRReceived(0, 0, NULL);
-  if (size > 0) {
-    TMMBRSet* candidateSet = VerifyAndAllocateCandidateSet(size);
-    // Get candidate set from receiver.
-    accNumCandidates = TMMBRReceived(size, accNumCandidates, candidateSet);
-  } else {
-    // Candidate set empty.
-    VerifyAndAllocateCandidateSet(0);  // resets candidate set
-  }
-  // Find bounding set
-  TMMBRSet* boundingSet = NULL;
-  numBoundingSet = FindTMMBRBoundingSet(boundingSet);
-  if (numBoundingSet == -1) {
-    LOG(LS_WARNING) << "Failed to find TMMBR bounding set.";
-    return -1;
-  }
   // Set bounding set
   // Inform remote clients about the new bandwidth
   // inform the remote client
-  _rtpRtcp.SetTMMBN(boundingSet);
+  _rtpRtcp.SetTMMBN(&candidates);
 
   // might trigger a TMMBN
-  if (numBoundingSet == 0) {
+  if (candidates.empty()) {
     // owner of max bitrate request has timed out
     // empty bounding set has been sent
     return 0;
   }
-  // Get net bitrate from bounding set depending on sent packet rate
-  if (CalcMinBitRate(&bitrate)) {
+  if (_cbRtcpBandwidthObserver) {
+    // Get net bitrate from bounding set depending on sent packet rate
+    uint32_t min_bitrate_bps = std::numeric_limits<uint32_t>::max();
+    for (const rtcp::TmmbItem& entry : candidates) {
+      if (min_bitrate_bps > entry.bitrate_bps()) {
+        min_bitrate_bps = entry.bitrate_bps();
+      }
+    }
+    if (min_bitrate_bps < MIN_VIDEO_BW_MANAGEMENT_BITRATE * 1000)
+      min_bitrate_bps = MIN_VIDEO_BW_MANAGEMENT_BITRATE * 1000;
     // we have a new bandwidth estimate on this channel
-    if (_cbRtcpBandwidthObserver) {
-        _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(bitrate * 1000);
-    }
+    _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(min_bitrate_bps);
   }
   return 0;
 }
 
 void RTCPReceiver::RegisterRtcpStatisticsCallback(
     RtcpStatisticsCallback* callback) {
   rtc::CritScope cs(&_criticalSectionFeedbacks);
   stats_callback_ = callback;
 }
 
@@ skipping 114 matching lines @@
   RTCPCnameInformation* cnameInfo = GetCnameInformation(remoteSSRC);
   if (cnameInfo == NULL) {
     return -1;
   }
   cName[RTCP_CNAME_SIZE - 1] = 0;
   strncpy(cName, cnameInfo->name, RTCP_CNAME_SIZE - 1);
   return 0;
 }
 
 // no callbacks allowed inside this function
-int32_t RTCPReceiver::TMMBRReceived(uint32_t size,
-                                    uint32_t accNumCandidates,
-                                    TMMBRSet* candidateSet) const {
+std::vector<rtcp::TmmbItem> RTCPReceiver::TMMBRReceived() const {
   rtc::CritScope lock(&_criticalSectionRTCPReceiver);
+  std::vector<rtcp::TmmbItem> candidates;
 
-  std::map<uint32_t, RTCPReceiveInformation*>::const_iterator
-      receiveInfoIt = _receivedInfoMap.begin();
-  if (receiveInfoIt == _receivedInfoMap.end()) {
-    return -1;
+  for (auto receive_info_it : _receivedInfoMap) {
+    RTCPReceiveInformation* receive_info = receive_info_it.second;
+    RTC_DCHECK(receive_info);
+    receive_info->GetTMMBRSet(_clock->TimeInMilliseconds(), &candidates);
   }
-  uint32_t num = accNumCandidates;
-  if (candidateSet) {
-    while( num < size && receiveInfoIt != _receivedInfoMap.end()) {
-      RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
-      if (receiveInfo == NULL) {
-        return 0;
-      }
-      for (uint32_t i = 0;
-           (num < size) && (i < receiveInfo->TmmbrSet.lengthOfSet()); i++) {
-        if (receiveInfo->GetTMMBRSet(i, num, candidateSet,
-                                     _clock->TimeInMilliseconds()) == 0) {
-          num++;
-        }
-      }
-      receiveInfoIt++;
-    }
-  } else {
-    while (receiveInfoIt != _receivedInfoMap.end()) {
-      RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
-      if(receiveInfo == NULL) {
-        return -1;
-      }
-      num += receiveInfo->TmmbrSet.lengthOfSet();
-      receiveInfoIt++;
-    }
-  }
-  return num;
+  return candidates;
 }
 
 }  // namespace webrtc