Remove TMMBRSet class
by cleaning RTCPReceiveInfo class
and following cleaning of RTCPReceiver::BoundingSet function.
BUG=webrtc:5565
Review-Url: https://codereview.webrtc.org/2254703003
Cr-Commit-Position: refs/heads/master@{#13817}
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
index 340fb99..75c7eec 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -107,8 +107,8 @@
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;
@@ -445,7 +445,8 @@
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
}
- UpdateReceiveInformation(*ptrReceiveInfo);
+ // Update that this remote is alive.
+ ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
rtcpPacketType = rtcpParser.Iterate();
@@ -639,12 +640,6 @@
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)
@@ -691,20 +686,20 @@
// 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;
@@ -718,35 +713,20 @@
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,
@@ -838,7 +818,7 @@
_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 =
@@ -1007,7 +987,6 @@
rtcpParser.Iterate();
return;
}
- ptrReceiveInfo->VerifyAndAllocateTMMBRSet((uint32_t)maxNumOfTMMBRBlocks);
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
@@ -1022,8 +1001,12 @@
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;
}
}
@@ -1050,8 +1033,6 @@
return;
}
- ptrReceiveInfo->VerifyAndAllocateBoundingSet((uint32_t)maxNumOfTMMBNBlocks);
-
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPPacketTypes::kRtpfbTmmbnItem) {
HandleTMMBNItem(*ptrReceiveInfo, rtcpPacket);
@@ -1067,10 +1048,10 @@
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,
@@ -1186,12 +1167,12 @@
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;
@@ -1402,7 +1383,7 @@
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;
}
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
index f66df03..b4025f7 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -96,7 +96,7 @@
bool UpdateRTCPReceiveInformationTimers();
- int32_t BoundingSet(bool* tmmbrOwner, TMMBRSet* boundingSetRec);
+ std::vector<rtcp::TmmbItem> BoundingSet(bool* tmmbr_owner);
int32_t UpdateTMMBR();
@@ -112,9 +112,6 @@
uint32_t remoteSSRC);
RTCPHelp::RTCPReceiveInformation* GetReceiveInformation(uint32_t remoteSSRC);
- void UpdateReceiveInformation(
- RTCPHelp::RTCPReceiveInformation& receiveInformation);
-
void HandleSenderReceiverReport(
RTCPUtility::RTCPParserV2& rtcpParser,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
index 4ad1dde..8dba2e5 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.cc
@@ -115,72 +115,38 @@
{
}
-RTCPReceiveInformation::RTCPReceiveInformation()
- : lastTimeReceived(0),
- lastFIRSequenceNumber(-1),
- lastFIRRequest(0),
- readyForDelete(false) {
+RTCPReceiveInformation::RTCPReceiveInformation() = default;
+RTCPReceiveInformation::~RTCPReceiveInformation() = default;
+
+void RTCPReceiveInformation::InsertTmmbrItem(uint32_t sender_ssrc,
+ const rtcp::TmmbItem& tmmbr_item,
+ int64_t current_time_ms) {
+ TimedTmmbrItem* entry = &tmmbr_[sender_ssrc];
+ entry->tmmbr_item = rtcp::TmmbItem(sender_ssrc,
+ tmmbr_item.bitrate_bps(),
+ tmmbr_item.packet_overhead());
+ entry->last_updated_ms = current_time_ms;
}
-RTCPReceiveInformation::~RTCPReceiveInformation() {
-}
-
-// Increase size of TMMBRSet if needed, and also take care of
-// the _tmmbrSetTimeouts vector.
-void RTCPReceiveInformation::VerifyAndAllocateTMMBRSet(
- const uint32_t minimumSize) {
- if (minimumSize > TmmbrSet.sizeOfSet()) {
- TmmbrSet.VerifyAndAllocateSetKeepingData(minimumSize);
- // make sure that our buffers are big enough
- _tmmbrSetTimeouts.reserve(minimumSize);
- }
-}
-
-void RTCPReceiveInformation::InsertTMMBRItem(
- const uint32_t senderSSRC,
- const RTCPUtility::RTCPPacketRTPFBTMMBRItem& TMMBRItem,
- const int64_t currentTimeMS) {
- // serach to see if we have it in our list
- for (uint32_t i = 0; i < TmmbrSet.lengthOfSet(); i++) {
- if (TmmbrSet.Ssrc(i) == senderSSRC) {
- // we already have this SSRC in our list update it
- TmmbrSet.SetEntry(i,
- TMMBRItem.MaxTotalMediaBitRate,
- TMMBRItem.MeasuredOverhead,
- senderSSRC);
- _tmmbrSetTimeouts[i] = currentTimeMS;
- return;
- }
- }
- VerifyAndAllocateTMMBRSet(TmmbrSet.lengthOfSet() + 1);
- TmmbrSet.AddEntry(TMMBRItem.MaxTotalMediaBitRate,
- TMMBRItem.MeasuredOverhead,
- senderSSRC);
- _tmmbrSetTimeouts.push_back(currentTimeMS);
-}
-
-void RTCPReceiveInformation::GetTMMBRSet(
+void RTCPReceiveInformation::GetTmmbrSet(
int64_t current_time_ms,
std::vector<rtcp::TmmbItem>* candidates) {
- // Erase timeout entries.
- for (size_t source_idx = 0; source_idx < TmmbrSet.size();) {
- // Use audio define since we don't know what interval the remote peer is
- // using.
- if (current_time_ms - _tmmbrSetTimeouts[source_idx] >
- 5 * RTCP_INTERVAL_AUDIO_MS) {
- // Value timed out.
- TmmbrSet.erase(TmmbrSet.begin() + source_idx);
- _tmmbrSetTimeouts.erase(_tmmbrSetTimeouts.begin() + source_idx);
- continue;
+ // Use audio define since we don't know what interval the remote peer use.
+ int64_t timeouted_ms = current_time_ms - 5 * RTCP_INTERVAL_AUDIO_MS;
+ for (auto it = tmmbr_.begin(); it != tmmbr_.end();) {
+ if (it->second.last_updated_ms < timeouted_ms) {
+ // Erase timeout entries.
+ it = tmmbr_.erase(it);
+ } else {
+ candidates->push_back(it->second.tmmbr_item);
+ ++it;
}
- candidates->push_back(TmmbrSet[source_idx]);
- ++source_idx;
}
}
-void RTCPReceiveInformation::VerifyAndAllocateBoundingSet(
- const uint32_t minimumSize) {
- TmmbnBoundingSet.VerifyAndAllocateSet(minimumSize);
+void RTCPReceiveInformation::ClearTmmbr() {
+ tmmbr_.clear();
}
+
} // namespace RTCPHelp
} // namespace webrtc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
index d9febae..2296555 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
@@ -12,12 +12,12 @@
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_HELP_H_
#include <list>
+#include <map>
#include <memory>
#include <vector>
#include "webrtc/base/constructormagic.h"
-#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h" // RTCPReportBlock
-#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
#include "webrtc/typedefs.h"
@@ -95,38 +95,36 @@
RTC_DISALLOW_COPY_AND_ASSIGN(RTCPPacketInformation);
};
-class RTCPReceiveInformation
-{
-public:
- RTCPReceiveInformation();
- ~RTCPReceiveInformation();
+class RTCPReceiveInformation {
+ public:
+ RTCPReceiveInformation();
+ ~RTCPReceiveInformation();
- void VerifyAndAllocateBoundingSet(const uint32_t minimumSize);
- void VerifyAndAllocateTMMBRSet(const uint32_t minimumSize);
+ void InsertTmmbrItem(uint32_t sender_ssrc,
+ const rtcp::TmmbItem& tmmbr_item,
+ int64_t current_time_ms);
- void InsertTMMBRItem(const uint32_t senderSSRC,
- const RTCPUtility::RTCPPacketRTPFBTMMBRItem& TMMBRItem,
- const int64_t currentTimeMS);
+ void GetTmmbrSet(int64_t current_time_ms,
+ std::vector<rtcp::TmmbItem>* candidates);
- // get
- void GetTMMBRSet(int64_t current_time_ms,
- std::vector<rtcp::TmmbItem>* candidates);
+ void ClearTmmbr();
- int64_t lastTimeReceived;
+ int64_t last_time_received_ms = 0;
- // FIR
- int32_t lastFIRSequenceNumber;
- int64_t lastFIRRequest;
+ int32_t last_fir_sequence_number = -1;
+ int64_t last_fir_request_ms = 0;
- // TMMBN
- TMMBRSet TmmbnBoundingSet;
+ bool ready_for_delete = false;
- // TMMBR
- TMMBRSet TmmbrSet;
+ std::vector<rtcp::TmmbItem> tmmbn;
- bool readyForDelete;
-private:
- std::vector<int64_t> _tmmbrSetTimeouts;
+ private:
+ struct TimedTmmbrItem {
+ rtcp::TmmbItem tmmbr_item;
+ int64_t last_updated_ms;
+ };
+
+ std::map<uint32_t, TimedTmmbrItem> tmmbr_;
};
} // end namespace RTCPHelp
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
index 79d946a..a66c686 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
@@ -172,7 +172,7 @@
remb_bitrate_(0),
- tmmbr_send_(0),
+ tmmbr_send_bps_(0),
packet_oh_send_(0),
max_payload_length_(IP_PACKET_SIZE - 28), // IPv4 + UDP by default.
@@ -577,7 +577,7 @@
void RTCPSender::SetTargetBitrate(unsigned int target_bitrate) {
rtc::CritScope lock(&critical_section_rtcp_sender_);
- tmmbr_send_ = target_bitrate / 1000;
+ tmmbr_send_bps_ = target_bitrate;
}
std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBR(
@@ -590,48 +590,46 @@
// * If not an owner but the TMMBR would enter the TMMBN -> send TMMBR
// get current bounding set from RTCP receiver
- bool tmmbrOwner = false;
- TMMBRSet candidates;
+ bool tmmbr_owner = false;
// holding critical_section_rtcp_sender_ while calling RTCPreceiver which
// will accuire criticalSectionRTCPReceiver_ is a potental deadlock but
// since RTCPreceiver is not doing the reverse we should be fine
- int32_t lengthOfBoundingSet =
- ctx.feedback_state_.module->BoundingSet(&tmmbrOwner, &candidates);
+ std::vector<rtcp::TmmbItem> candidates =
+ ctx.feedback_state_.module->BoundingSet(&tmmbr_owner);
- if (lengthOfBoundingSet > 0) {
- for (int32_t i = 0; i < lengthOfBoundingSet; i++) {
- if (candidates.Tmmbr(i) == tmmbr_send_ &&
- candidates.PacketOH(i) == packet_oh_send_) {
+ if (!candidates.empty()) {
+ for (const auto& candidate : candidates) {
+ if (candidate.bitrate_bps() == tmmbr_send_bps_ &&
+ candidate.packet_overhead() == packet_oh_send_) {
// Do not send the same tuple.
return nullptr;
}
}
- if (!tmmbrOwner) {
- // use received bounding set as candidate set
- // add current tuple
- candidates.SetEntry(lengthOfBoundingSet, tmmbr_send_, packet_oh_send_,
- ssrc_);
+ if (!tmmbr_owner) {
+ // Use received bounding set as candidate set.
+ // Add current tuple.
+ candidates.emplace_back(ssrc_, tmmbr_send_bps_, packet_oh_send_);
- // find bounding set
+ // Find bounding set.
std::vector<rtcp::TmmbItem> bounding =
TMMBRHelp::FindBoundingSet(std::move(candidates));
- tmmbrOwner = TMMBRHelp::IsOwner(bounding, ssrc_);
- if (!tmmbrOwner) {
+ tmmbr_owner = TMMBRHelp::IsOwner(bounding, ssrc_);
+ if (!tmmbr_owner) {
// Did not enter bounding set, no meaning to send this request.
return nullptr;
}
}
}
- if (!tmmbr_send_)
+ if (!tmmbr_send_bps_)
return nullptr;
rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr();
tmmbr->From(ssrc_);
rtcp::TmmbItem request;
request.set_ssrc(remote_ssrc_);
- request.set_bitrate_bps(tmmbr_send_ * 1000);
+ request.set_bitrate_bps(tmmbr_send_bps_);
request.set_packet_overhead(packet_oh_send_);
tmmbr->WithTmmbr(request);
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
index 54f93f1..b979491 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_sender.h
@@ -241,7 +241,7 @@
std::vector<rtcp::TmmbItem> tmmbn_to_send_
GUARDED_BY(critical_section_rtcp_sender_);
- uint32_t tmmbr_send_ GUARDED_BY(critical_section_rtcp_sender_);
+ uint32_t tmmbr_send_bps_ GUARDED_BY(critical_section_rtcp_sender_);
uint32_t packet_oh_send_ GUARDED_BY(critical_section_rtcp_sender_);
size_t max_payload_length_;
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
index 9b9a0bf..e0b25f0 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
@@ -925,9 +925,8 @@
}
// Called from RTCPsender.
-int32_t ModuleRtpRtcpImpl::BoundingSet(bool* tmmbr_owner,
- TMMBRSet* bounding_set) {
- return rtcp_receiver_.BoundingSet(tmmbr_owner, bounding_set);
+std::vector<rtcp::TmmbItem> ModuleRtpRtcpImpl::BoundingSet(bool* tmmbr_owner) {
+ return rtcp_receiver_.BoundingSet(tmmbr_owner);
}
int64_t ModuleRtpRtcpImpl::RtcpReportInterval() {
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
index bd2899b..4e69993 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
+++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
@@ -297,7 +297,7 @@
bool LastReceivedXrReferenceTimeInfo(RtcpReceiveTimeInfo* info) const;
- int32_t BoundingSet(bool* tmmbr_owner, TMMBRSet* bounding_set_rec);
+ std::vector<rtcp::TmmbItem> BoundingSet(bool* tmmbr_owner);
void BitrateSent(uint32_t* total_rate,
uint32_t* video_rate,
diff --git a/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc b/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc
index 7c29ed8..7c99091 100644
--- a/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc
+++ b/webrtc/modules/rtp_rtcp/source/tmmbr_help.cc
@@ -16,40 +16,6 @@
#include "webrtc/base/checks.h"
namespace webrtc {
-void TMMBRSet::VerifyAndAllocateSet(uint32_t minimumSize) {
- clear();
- reserve(minimumSize);
-}
-
-void TMMBRSet::VerifyAndAllocateSetKeepingData(uint32_t minimumSize) {
- reserve(minimumSize);
-}
-
-void TMMBRSet::SetEntry(unsigned int i,
- uint32_t tmmbrSet,
- uint32_t packetOHSet,
- uint32_t ssrcSet) {
- RTC_DCHECK_LT(i, capacity());
- if (i >= size()) {
- resize(i + 1);
- }
- (*this)[i].set_bitrate_bps(tmmbrSet * 1000);
- (*this)[i].set_packet_overhead(packetOHSet);
- (*this)[i].set_ssrc(ssrcSet);
-}
-
-void TMMBRSet::AddEntry(uint32_t tmmbrSet,
- uint32_t packetOHSet,
- uint32_t ssrcSet) {
- RTC_DCHECK_LT(size(), capacity());
- SetEntry(size(), tmmbrSet, packetOHSet, ssrcSet);
-}
-
-void TMMBRSet::RemoveEntry(uint32_t sourceIdx) {
- RTC_DCHECK_LT(sourceIdx, size());
- erase(begin() + sourceIdx);
-}
-
std::vector<rtcp::TmmbItem> TMMBRHelp::FindBoundingSet(
std::vector<rtcp::TmmbItem> candidates) {
// Filter out candidates with 0 bitrate.
diff --git a/webrtc/modules/rtp_rtcp/source/tmmbr_help.h b/webrtc/modules/rtp_rtcp/source/tmmbr_help.h
index e08856e..9bd09c3 100644
--- a/webrtc/modules/rtp_rtcp/source/tmmbr_help.h
+++ b/webrtc/modules/rtp_rtcp/source/tmmbr_help.h
@@ -16,28 +16,6 @@
#include "webrtc/typedefs.h"
namespace webrtc {
-class TMMBRSet : public std::vector<rtcp::TmmbItem> {
- public:
- void VerifyAndAllocateSet(uint32_t minimumSize);
- void VerifyAndAllocateSetKeepingData(uint32_t minimumSize);
- // Number of valid data items in set.
- uint32_t lengthOfSet() const { return size(); }
- // Presently allocated max size of set.
- uint32_t sizeOfSet() const { return capacity(); }
- void clearSet() { clear(); }
- uint32_t Tmmbr(int i) const { return (*this)[i].bitrate_bps() / 1000; }
- uint32_t PacketOH(int i) const { return (*this)[i].packet_overhead(); }
- uint32_t Ssrc(int i) const { return (*this)[i].ssrc(); }
- void SetEntry(unsigned int i,
- uint32_t tmmbrSet,
- uint32_t packetOHSet,
- uint32_t ssrcSet);
-
- void AddEntry(uint32_t tmmbrSet, uint32_t packetOHSet, uint32_t ssrcSet);
-
- // Remove one entry from table, and move all others down.
- void RemoveEntry(uint32_t sourceIdx);
-};
class TMMBRHelp {
public: