zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Store the received report blocks map (mapped per remote ssrc) in a map per source ssrc.

Browse Source 
When using rtx, receiver reports with two report blocks are received. The report blocks have the same remote ssrc and therefore the first report block was overwritten by the second report block when stored in the ReportBlockInfoMap.

Removed unused function ResetRTT.

BUG=4114
R=mflodman@webrtc.org, stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/33659005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@7952 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
asapersson@webrtc.org
2014-12-18 14:30:32 +00:00
parent ce4e9a3562
commit cb79141eab
7 changed files with 236 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
View File

@ -397,13 +397,6 @@ class RtpRtcp : public Module {
uint16_t* minRTT,
uint16_t* maxRTT) const = 0 ;
/*
* Reset RoundTripTime statistics
*
* return -1 on failure else 0
*/
virtual int32_t ResetRTT(const uint32_t remoteSSRC)= 0 ;
/*
* Force a send of a RTCP packet
* normal SR and RR are triggered via the process function

2
webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
View File

@ -160,8 +160,6 @@ class MockRtpRtcp : public RtpRtcp {
int32_t(const uint32_t SSRC));
MOCK_CONST_METHOD5(RTT,
int32_t(const uint32_t remoteSSRC, uint16_t* RTT, uint16_t* avgRTT, uint16_t* minRTT, uint16_t* maxRTT));
MOCK_METHOD1(ResetRTT,
int32_t(const uint32_t remoteSSRC));
MOCK_METHOD1(SendRTCP,
int32_t(uint32_t rtcpPacketType));
MOCK_METHOD1(SendRTCPReferencePictureSelection,

110
webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@ -62,11 +62,14 @@ RTCPReceiver::~RTCPReceiver() {
delete _criticalSectionRTCPReceiver;
delete _criticalSectionFeedbacks;
while (!_receivedReportBlockMap.empty()) {
std::map<uint32_t, RTCPReportBlockInformation*>::iterator first =
_receivedReportBlockMap.begin();
delete first->second;
_receivedReportBlockMap.erase(first);
ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
for (; it != _receivedReportBlockMap.end(); ++it) {
ReportBlockInfoMap* info_map = &(it->second);
while (!info_map->empty()) {
ReportBlockInfoMap::iterator it_info = info_map->begin();
delete it_info->second;
info_map->erase(it_info);
}
}
while (!_receivedInfoMap.empty()) {
std::map<uint32_t, RTCPReceiveInformation*>::iterator first =
@ -167,21 +170,6 @@ void RTCPReceiver::SetSsrcs(uint32_t main_ssrc,
}
}
int32_t RTCPReceiver::ResetRTT(const uint32_t remoteSSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
RTCPReportBlockInformation* reportBlock =
GetReportBlockInformation(remoteSSRC);
if (reportBlock == NULL) {
LOG(LS_WARNING) << "Failed to reset rtt for ssrc " << remoteSSRC;
return -1;
}
reportBlock->RTT = 0;
reportBlock->avgRTT = 0;
reportBlock->minRTT = 0;
reportBlock->maxRTT = 0;
return 0;
}
int32_t RTCPReceiver::RTT(uint32_t remoteSSRC,
uint16_t* RTT,
uint16_t* avgRTT,
@ -190,7 +178,7 @@ int32_t RTCPReceiver::RTT(uint32_t remoteSSRC,
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
RTCPReportBlockInformation* reportBlock =
GetReportBlockInformation(remoteSSRC);
GetReportBlockInformation(remoteSSRC, main_ssrc_);
if (reportBlock == NULL) {
return -1;
@ -291,13 +279,13 @@ int32_t RTCPReceiver::StatisticsReceived(
std::vector<RTCPReportBlock>* receiveBlocks) const {
assert(receiveBlocks);
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
std::map<uint32_t, RTCPReportBlockInformation*>::const_iterator it =
_receivedReportBlockMap.begin();
while (it != _receivedReportBlockMap.end()) {
receiveBlocks->push_back(it->second->remoteReceiveBlock);
it++;
ReportBlockMap::const_iterator it = _receivedReportBlockMap.begin();
for (; it != _receivedReportBlockMap.end(); ++it) {
const ReportBlockInfoMap* info_map = &(it->second);
ReportBlockInfoMap::const_iterator it_info = info_map->begin();
for (; it_info != info_map->end(); ++it_info) {
receiveBlocks->push_back(it_info->second->remoteReceiveBlock);
}
}
return 0;
}
@ -505,7 +493,8 @@ void RTCPReceiver::HandleReportBlock(
_criticalSectionRTCPReceiver->Enter();
RTCPReportBlockInformation* reportBlock =
CreateReportBlockInformation(remoteSSRC);
CreateOrGetReportBlockInformation(remoteSSRC,
rtcpPacket.ReportBlockItem.SSRC);
if (reportBlock == NULL) {
LOG(LS_WARNING) << "Failed to CreateReportBlockInformation("
<< remoteSSRC << ")";
@ -592,34 +581,38 @@ void RTCPReceiver::HandleReportBlock(
rtcpPacketInformation.AddReportInfo(*reportBlock);
}
RTCPReportBlockInformation*
RTCPReceiver::CreateReportBlockInformation(uint32_t remoteSSRC) {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
std::map<uint32_t, RTCPReportBlockInformation*>::iterator it =
_receivedReportBlockMap.find(remoteSSRC);
RTCPReportBlockInformation* ptrReportBlockInfo = NULL;
RTCPReportBlockInformation* RTCPReceiver::CreateOrGetReportBlockInformation(
uint32_t remote_ssrc,
uint32_t source_ssrc) {
ReportBlockMap::iterator it = _receivedReportBlockMap.find(source_ssrc);
if (it != _receivedReportBlockMap.end()) {
ptrReportBlockInfo = it->second;
} else {
ptrReportBlockInfo = new RTCPReportBlockInformation;
_receivedReportBlockMap[remoteSSRC] = ptrReportBlockInfo;
ReportBlockInfoMap* info_map = &(it->second);
ReportBlockInfoMap::iterator it_info = info_map->find(remote_ssrc);
if (it_info != info_map->end()) {
return it_info->second;
}
RTCPReportBlockInformation* info = new RTCPReportBlockInformation;
(*info_map)[remote_ssrc] = info;
return info;
}
return ptrReportBlockInfo;
RTCPReportBlockInformation* info = new RTCPReportBlockInformation;
_receivedReportBlockMap[source_ssrc][remote_ssrc] = info;
return info;
}
RTCPReportBlockInformation*
RTCPReceiver::GetReportBlockInformation(uint32_t remoteSSRC) const {
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
std::map<uint32_t, RTCPReportBlockInformation*>::const_iterator it =
_receivedReportBlockMap.find(remoteSSRC);
RTCPReportBlockInformation* RTCPReceiver::GetReportBlockInformation(
uint32_t remote_ssrc,
uint32_t source_ssrc) const {
ReportBlockMap::const_iterator it = _receivedReportBlockMap.find(source_ssrc);
if (it == _receivedReportBlockMap.end()) {
return NULL;
}
return it->second;
const ReportBlockInfoMap* info_map = &(it->second);
ReportBlockInfoMap::const_iterator it_info = info_map->find(remote_ssrc);
if (it_info == info_map->end()) {
return NULL;
}
return it_info->second;
}
RTCPCnameInformation*
@ -874,14 +867,17 @@ void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
// clear our lists
CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
std::map<uint32_t, RTCPReportBlockInformation*>::iterator
reportBlockInfoIt = _receivedReportBlockMap.find(
rtcpPacket.BYE.SenderSSRC);
if (reportBlockInfoIt != _receivedReportBlockMap.end()) {
delete reportBlockInfoIt->second;
_receivedReportBlockMap.erase(reportBlockInfoIt);
ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
for (; it != _receivedReportBlockMap.end(); ++it) {
ReportBlockInfoMap* info_map = &(it->second);
ReportBlockInfoMap::iterator it_info = info_map->find(
rtcpPacket.BYE.SenderSSRC);
if (it_info != info_map->end()) {
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);

46
webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
View File

@ -15,6 +15,7 @@
#include <vector>
#include <set>
#include "webrtc/base/thread_annotations.h"
#include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
@ -77,8 +78,6 @@ public:
uint16_t* minRTT,
uint16_t* maxRTT) const;
int32_t ResetRTT(const uint32_t remoteSSRC);
int32_t SenderInfoReceived(RTCPSenderInfo* senderInfo) const;
bool GetAndResetXrRrRtt(uint16_t* rtt_ms);
@ -114,9 +113,6 @@ public:
RtcpStatisticsCallback* GetRtcpStatisticsCallback();
protected:
RTCPHelp::RTCPReportBlockInformation* CreateReportBlockInformation(const uint32_t remoteSSRC);
RTCPHelp::RTCPReportBlockInformation* GetReportBlockInformation(const uint32_t remoteSSRC) const;
RTCPUtility::RTCPCnameInformation* CreateCnameInformation(const uint32_t remoteSSRC);
RTCPUtility::RTCPCnameInformation* GetCnameInformation(const uint32_t remoteSSRC) const;
@ -220,19 +216,32 @@ protected:
private:
typedef std::map<uint32_t, RTCPHelp::RTCPReceiveInformation*>
ReceivedInfoMap;
int32_t _id;
Clock* _clock;
RTCPMethod _method;
int64_t _lastReceived;
ModuleRtpRtcpImpl& _rtpRtcp;
// RTCP report block information mapped by remote SSRC.
typedef std::map<uint32_t, RTCPHelp::RTCPReportBlockInformation*>
ReportBlockInfoMap;
// RTCP report block information map mapped by source SSRC.
typedef std::map<uint32_t, ReportBlockInfoMap> ReportBlockMap;
RTCPHelp::RTCPReportBlockInformation* CreateOrGetReportBlockInformation(
uint32_t remote_ssrc, uint32_t source_ssrc)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
RTCPHelp::RTCPReportBlockInformation* GetReportBlockInformation(
uint32_t remote_ssrc, uint32_t source_ssrc) const
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
int32_t _id;
Clock* _clock;
RTCPMethod _method;
int64_t _lastReceived;
ModuleRtpRtcpImpl& _rtpRtcp;
CriticalSectionWrapper* _criticalSectionFeedbacks;
RtcpBandwidthObserver* _cbRtcpBandwidthObserver;
RtcpBandwidthObserver* _cbRtcpBandwidthObserver;
RtcpIntraFrameObserver* _cbRtcpIntraFrameObserver;
CriticalSectionWrapper* _criticalSectionRTCPReceiver;
uint32_t main_ssrc_;
uint32_t _remoteSSRC;
uint32_t main_ssrc_;
uint32_t _remoteSSRC;
std::set<uint32_t> registered_ssrcs_;
// Received send report
@ -250,18 +259,17 @@ protected:
uint16_t xr_rr_rtt_ms_;
// Received report blocks.
std::map<uint32_t, RTCPHelp::RTCPReportBlockInformation*>
_receivedReportBlockMap;
ReportBlockMap _receivedReportBlockMap
GUARDED_BY(_criticalSectionRTCPReceiver);
ReceivedInfoMap _receivedInfoMap;
std::map<uint32_t, RTCPUtility::RTCPCnameInformation*>
_receivedCnameMap;
std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> _receivedCnameMap;
uint32_t _packetTimeOutMS;
uint32_t _packetTimeOutMS;
// The last time we received an RTCP RR.
int64_t _lastReceivedRrMs;
// The time we last received an RTCP RR telling we have ssuccessfully
// The time we last received an RTCP RR telling we have successfully
// delivered RTP packet to the remote side.
int64_t _lastIncreasedSequenceNumberMs;

161
webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
View File

@ -204,6 +204,10 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
ASSERT_EQ(0u, rtcp_packet_info_.report_blocks.size());
std::vector<RTCPReportBlock> received_blocks;
rtcp_receiver_->StatisticsReceived(&received_blocks);
EXPECT_TRUE(received_blocks.empty());
}
TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
@ -223,12 +227,18 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
std::vector<RTCPReportBlock> received_blocks;
rtcp_receiver_->StatisticsReceived(&received_blocks);
EXPECT_EQ(1u, received_blocks.size());
}
TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
const uint32_t kSenderSsrc = 0x10203;
const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
const uint16_t kSequenceNumbers[] = {10, 12423};
const uint32_t kCumLost[] = {13, 555};
const uint8_t kFracLost[] = {20, 11};
const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
@ -258,12 +268,14 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
rtcp::ReportBlock rb3;
rb3.To(kSourceSsrcs[0]);
rb3.WithExtHighestSeqNum(kSequenceNumbers[0]);
rb3.WithFractionLost(kFracLost[0]);
rb3.WithCumulativeLost(kCumLost[0]);
rtcp::ReportBlock rb4;
rb4.To(kSourceSsrcs[1]);
rb4.WithExtHighestSeqNum(kSequenceNumbers[1]);
rb4.WithFractionLost(20);
rb4.WithCumulativeLost(10);
rb4.WithFractionLost(kFracLost[1]);
rb4.WithCumulativeLost(kCumLost[1]);
rtcp::ReceiverReport rr2;
rr2.From(kSenderSsrc);
@ -273,8 +285,106 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
rtcp::RawPacket p2 = rr2.Build();
EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
EXPECT_EQ(0, rtcp_packet_info_.report_blocks.front().fractionLost);
EXPECT_EQ(20, rtcp_packet_info_.report_blocks.back().fractionLost);
EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost);
EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.back().fractionLost);
std::vector<RTCPReportBlock> received_blocks;
rtcp_receiver_->StatisticsReceived(&received_blocks);
EXPECT_EQ(2u, received_blocks.size());
for (size_t i = 0; i < received_blocks.size(); ++i) {
EXPECT_EQ(kSenderSsrc, received_blocks[i].remoteSSRC);
EXPECT_EQ(kSourceSsrcs[i], received_blocks[i].sourceSSRC);
EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost);
EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost);
EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum);
}
}
TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
const uint32_t kSenderSsrc1 = 0x10203;
const uint32_t kSenderSsrc2 = 0x20304;
const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
const uint16_t kSequenceNumbers[] = {10, 12423};
const uint32_t kCumLost[] = {13, 555};
const uint8_t kFracLost[] = {20, 11};
const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
rtcp::ReportBlock rb1;
rb1.To(kSourceSsrcs[0]);
rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
rb1.WithFractionLost(kFracLost[0]);
rb1.WithCumulativeLost(kCumLost[0]);
rtcp::ReceiverReport rr1;
rr1.From(kSenderSsrc1);
rr1.WithReportBlock(&rb1);
rtcp::RawPacket p1 = rr1.Build();
EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
EXPECT_EQ(kFracLost[0], rtcp_packet_info_.report_blocks.front().fractionLost);
std::vector<RTCPReportBlock> received_blocks;
rtcp_receiver_->StatisticsReceived(&received_blocks);
EXPECT_EQ(1u, received_blocks.size());
EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC);
EXPECT_EQ(kSourceSsrcs[0], received_blocks[0].sourceSSRC);
EXPECT_EQ(kFracLost[0], received_blocks[0].fractionLost);
EXPECT_EQ(kCumLost[0], received_blocks[0].cumulativeLost);
EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum);
rtcp::ReportBlock rb2;
rb2.To(kSourceSsrcs[0]);
rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
rb2.WithFractionLost(kFracLost[1]);
rb2.WithCumulativeLost(kCumLost[1]);
rtcp::ReceiverReport rr2;
rr2.From(kSenderSsrc2);
rr2.WithReportBlock(&rb2);
rtcp::RawPacket p2 = rr2.Build();
EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
ASSERT_EQ(1u, rtcp_packet_info_.report_blocks.size());
EXPECT_EQ(kFracLost[1], rtcp_packet_info_.report_blocks.front().fractionLost);
received_blocks.clear();
rtcp_receiver_->StatisticsReceived(&received_blocks);
ASSERT_EQ(2u, received_blocks.size());
EXPECT_EQ(kSenderSsrc1, received_blocks[0].remoteSSRC);
EXPECT_EQ(kSenderSsrc2, received_blocks[1].remoteSSRC);
for (size_t i = 0; i < received_blocks.size(); ++i) {
EXPECT_EQ(kSourceSsrcs[0], received_blocks[i].sourceSSRC);
EXPECT_EQ(kFracLost[i], received_blocks[i].fractionLost);
EXPECT_EQ(kCumLost[i], received_blocks[i].cumulativeLost);
EXPECT_EQ(kSequenceNumbers[i], received_blocks[i].extendedHighSeqNum);
}
}
TEST_F(RtcpReceiverTest, GetRtt) {
const uint32_t kSenderSsrc = 0x10203;
const uint32_t kSourceSsrc = 0x123456;
std::set<uint32_t> ssrcs;
ssrcs.insert(kSourceSsrc);
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
// No report block received.
EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
rtcp::ReportBlock rb;
rb.To(kSourceSsrc);
rtcp::ReceiverReport rr;
rr.From(kSenderSsrc);
rr.WithReportBlock(&rb);
rtcp::RawPacket p = rr.Build();
EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
EXPECT_EQ(kRtcpRr, rtcp_packet_info_.rtcpPacketTypeFlags);
EXPECT_EQ(1u, rtcp_packet_info_.report_blocks.size());
EXPECT_EQ(0, rtcp_receiver_->RTT(kSenderSsrc, NULL, NULL, NULL, NULL));
// Report block not received.
EXPECT_EQ(-1, rtcp_receiver_->RTT(kSenderSsrc + 1, NULL, NULL, NULL, NULL));
}
TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
@ -343,7 +453,7 @@ TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
EXPECT_EQ(0, strncmp(cName, "alice@host", RTCP_CNAME_SIZE));
}
TEST_F(RtcpReceiverTest, InjectByePacket) {
TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
const uint32_t kSenderSsrc = 0x123456;
rtcp::Sdes sdes;
sdes.WithCName(kSenderSsrc, "alice@host");
@ -361,6 +471,47 @@ TEST_F(RtcpReceiverTest, InjectByePacket) {
EXPECT_EQ(-1, rtcp_receiver_->CNAME(kSenderSsrc, cName));
}
TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
const uint32_t kSenderSsrc = 0x10203;
const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
rtcp::ReportBlock rb1;
rb1.To(kSourceSsrcs[0]);
rtcp::ReportBlock rb2;
rb2.To(kSourceSsrcs[1]);
rtcp::ReceiverReport rr;
rr.From(kSenderSsrc);
rr.WithReportBlock(&rb1);
rr.WithReportBlock(&rb2);
rtcp::RawPacket p1 = rr.Build();
EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
std::vector<RTCPReportBlock> received_blocks;
rtcp_receiver_->StatisticsReceived(&received_blocks);
EXPECT_EQ(2u, received_blocks.size());
// Verify that BYE removes the report blocks.
rtcp::Bye bye;
bye.From(kSenderSsrc);
rtcp::RawPacket p2 = bye.Build();
EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
received_blocks.clear();
rtcp_receiver_->StatisticsReceived(&received_blocks);
EXPECT_TRUE(received_blocks.empty());
// Inject packet.
EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
received_blocks.clear();
rtcp_receiver_->StatisticsReceived(&received_blocks);
EXPECT_EQ(2u, received_blocks.size());
}
TEST_F(RtcpReceiverTest, InjectPliPacket) {
const uint32_t kSourceSsrc = 0x123456;
std::set<uint32_t> ssrcs;

5
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -767,11 +767,6 @@ int32_t ModuleRtpRtcpImpl::RTT(const uint32_t remote_ssrc,
return ret;
}
// Reset RoundTripTime statistics.
int32_t ModuleRtpRtcpImpl::ResetRTT(const uint32_t remote_ssrc) {
return rtcp_receiver_.ResetRTT(remote_ssrc);
}
// Reset RTP data counters for the sending side.
int32_t ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
rtp_sender_.ResetDataCounters();

3
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@ -164,9 +164,6 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
uint16_t* min_rtt,
uint16_t* max_rtt) const OVERRIDE;
// Reset RoundTripTime statistics.
virtual int32_t ResetRTT(const uint32_t remote_ssrc) OVERRIDE;
// Force a send of an RTCP packet.
// Normal SR and RR are triggered via the process function.
virtual int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) OVERRIDE;