From cb79141eabdf1d2de736fd4285dc59bb44de4682 Mon Sep 17 00:00:00 2001 From: "asapersson@webrtc.org" Date: Thu, 18 Dec 2014 14:30:32 +0000 Subject: [PATCH] Store the received report blocks map (mapped per remote ssrc) in a map per source ssrc. 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 --- webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h | 7 - webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h | 2 - .../modules/rtp_rtcp/source/rtcp_receiver.cc | 110 ++++++------ .../modules/rtp_rtcp/source/rtcp_receiver.h | 46 ++--- .../rtp_rtcp/source/rtcp_receiver_unittest.cc | 161 +++++++++++++++++- .../modules/rtp_rtcp/source/rtp_rtcp_impl.cc | 5 - .../modules/rtp_rtcp/source/rtp_rtcp_impl.h | 3 - 7 files changed, 236 insertions(+), 98 deletions(-) diff --git a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h index 745c90839..e284977d2 100644 --- a/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h +++ b/webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h @@ -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 diff --git a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h index 859d3e3a3..079f677e9 100644 --- a/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h +++ b/webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h @@ -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, diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc index b03b68ffe..8e5ac1237 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc @@ -62,11 +62,14 @@ RTCPReceiver::~RTCPReceiver() { delete _criticalSectionRTCPReceiver; delete _criticalSectionFeedbacks; - while (!_receivedReportBlockMap.empty()) { - std::map::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::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* receiveBlocks) const { assert(receiveBlocks); CriticalSectionScoped lock(_criticalSectionRTCPReceiver); - - std::map::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::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::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::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::iterator receiveInfoIt = _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC); diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h index ecc5ebed7..b8fcb41e9 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.h @@ -15,6 +15,7 @@ #include #include +#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 ReceivedInfoMap; - int32_t _id; - Clock* _clock; - RTCPMethod _method; - int64_t _lastReceived; - ModuleRtpRtcpImpl& _rtpRtcp; + // RTCP report block information mapped by remote SSRC. + typedef std::map + ReportBlockInfoMap; + // RTCP report block information map mapped by source SSRC. + typedef std::map 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 registered_ssrcs_; // Received send report @@ -250,18 +259,17 @@ protected: uint16_t xr_rr_rtt_ms_; // Received report blocks. - std::map - _receivedReportBlockMap; + ReportBlockMap _receivedReportBlockMap + GUARDED_BY(_criticalSectionRTCPReceiver); ReceivedInfoMap _receivedInfoMap; - std::map - _receivedCnameMap; + std::map _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; diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc index f0ffd9ee7..a7d84778e 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc @@ -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 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 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 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 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 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 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 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 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 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 ssrcs; diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc index 6877e830a..642428e1f 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc @@ -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(); diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h index 7e7b0df66..4b1123572 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h @@ -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;