From 3e69e5c2c0450002a03be5184f28647efccbb47a Mon Sep 17 00:00:00 2001 From: srte Date: Wed, 9 Aug 2017 06:13:45 -0700 Subject: [PATCH] Renamed fields in rtp_rtcp_defines.h/RTCPReportBlock Continues on https://codereview.webrtc.org/2992043002 BUG=webrtc:8033 Review-Url: https://codereview.webrtc.org/2994633002 Cr-Commit-Position: refs/heads/master@{#19286} --- .../bitrate_controller_impl.cc | 10 +-- .../test/estimators/remb.cc | 7 +- .../test/estimators/send_side.cc | 8 +- .../rtp_rtcp/include/rtp_rtcp_defines.h | 68 +++++++++++----- .../rtp_rtcp/source/playout_delay_oracle.cc | 5 +- .../source/playout_delay_oracle_unittest.cc | 4 +- .../modules/rtp_rtcp/source/rtcp_receiver.cc | 26 +++---- .../rtp_rtcp/source/rtcp_receiver_unittest.cc | 69 +++++++++-------- .../modules/rtp_rtcp/source/rtp_rtcp_impl.cc | 2 +- .../rtp_rtcp/test/testAPI/test_api_rtcp.cc | 13 ++-- webrtc/test/mock_voice_engine.h | 2 +- webrtc/video/report_block_stats.cc | 30 ++++---- webrtc/video/report_block_stats_unittest.cc | 77 ++++++++++--------- webrtc/voice_engine/channel.cc | 30 ++++---- 14 files changed, 194 insertions(+), 157 deletions(-) diff --git a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc index 70efe3e5cd..dc8805f39e 100644 --- a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc +++ b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc @@ -191,20 +191,20 @@ void BitrateControllerImpl::OnReceivedRtcpReceiverReport( for (const RTCPReportBlock& report_block : report_blocks) { std::map::iterator seq_num_it = ssrc_to_last_received_extended_high_seq_num_.find( - report_block.sourceSSRC); + report_block.source_ssrc); int number_of_packets = 0; if (seq_num_it != ssrc_to_last_received_extended_high_seq_num_.end()) { number_of_packets = - report_block.extendedHighSeqNum - seq_num_it->second; + report_block.extended_highest_sequence_number - seq_num_it->second; } - fraction_lost_aggregate += number_of_packets * report_block.fractionLost; + fraction_lost_aggregate += number_of_packets * report_block.fraction_lost; total_number_of_packets += number_of_packets; // Update last received for this SSRC. - ssrc_to_last_received_extended_high_seq_num_[report_block.sourceSSRC] = - report_block.extendedHighSeqNum; + ssrc_to_last_received_extended_high_seq_num_[report_block.source_ssrc] = + report_block.extended_highest_sequence_number; } if (total_number_of_packets < 0) { LOG(LS_WARNING) << "Received report block where extended high sequence " diff --git a/webrtc/modules/remote_bitrate_estimator/test/estimators/remb.cc b/webrtc/modules/remote_bitrate_estimator/test/estimators/remb.cc index 57f3f73411..1daf14e51e 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/estimators/remb.cc +++ b/webrtc/modules/remote_bitrate_estimator/test/estimators/remb.cc @@ -138,9 +138,10 @@ RTCPReportBlock RembReceiver::BuildReportBlock( RTCPReportBlock report_block; RtcpStatistics stats; RTC_DCHECK(statistician->GetStatistics(&stats, true)); - report_block.fractionLost = stats.fraction_lost; - report_block.cumulativeLost = stats.packets_lost; - report_block.extendedHighSeqNum = stats.extended_highest_sequence_number; + report_block.fraction_lost = stats.fraction_lost; + report_block.packets_lost = stats.packets_lost; + report_block.extended_highest_sequence_number = + stats.extended_highest_sequence_number; report_block.jitter = stats.jitter; return report_block; } diff --git a/webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc b/webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc index 6e6ac2949d..d4192402be 100644 --- a/webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc +++ b/webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc @@ -91,12 +91,12 @@ void SendSideBweSender::GiveFeedback(const FeedbackPacket& feedback) { if (expected_packets > 0) { int lost_packets = expected_packets - static_cast(fb.packet_feedback_vector().size()); - report_block_.fractionLost = (lost_packets << 8) / expected_packets; - report_block_.cumulativeLost += lost_packets; + report_block_.fraction_lost = (lost_packets << 8) / expected_packets; + report_block_.packets_lost += lost_packets; uint32_t unwrapped = seq_num_unwrapper_.Unwrap( packet_feedback_vector.back().sequence_number); - report_block_.extendedHighSeqNum = - std::max(unwrapped, report_block_.extendedHighSeqNum); + report_block_.extended_highest_sequence_number = + std::max(unwrapped, report_block_.extended_highest_sequence_number); ReportBlockList report_blocks; report_blocks.push_back(report_block_); feedback_observer_->OnReceivedRtcpReceiverReport( diff --git a/webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h index eb4625413a..7d54ea4b24 100644 --- a/webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h +++ b/webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h @@ -132,36 +132,62 @@ const size_t kRtxHeaderSize = 2; struct RTCPReportBlock { RTCPReportBlock() - : remoteSSRC(0), sourceSSRC(0), fractionLost(0), cumulativeLost(0), - extendedHighSeqNum(0), jitter(0), lastSR(0), - delaySinceLastSR(0) {} + : sender_ssrc(0), + source_ssrc(0), + fraction_lost(0), + packets_lost(0), + extended_highest_sequence_number(0), + jitter(0), + last_sender_report_timestamp(0), + delay_since_last_sender_report(0) {} - RTCPReportBlock(uint32_t remote_ssrc, + RTCPReportBlock(uint32_t sender_ssrc, uint32_t source_ssrc, uint8_t fraction_lost, - uint32_t cumulative_lost, - uint32_t extended_high_sequence_number, + uint32_t packets_lost, + uint32_t extended_highest_sequence_number, uint32_t jitter, - uint32_t last_sender_report, + uint32_t last_sender_report_timestamp, uint32_t delay_since_last_sender_report) - : remoteSSRC(remote_ssrc), - sourceSSRC(source_ssrc), - fractionLost(fraction_lost), - cumulativeLost(cumulative_lost), - extendedHighSeqNum(extended_high_sequence_number), + : sender_ssrc(sender_ssrc), + source_ssrc(source_ssrc), + fraction_lost(fraction_lost), + packets_lost(packets_lost), + extended_highest_sequence_number(extended_highest_sequence_number), jitter(jitter), - lastSR(last_sender_report), - delaySinceLastSR(delay_since_last_sender_report) {} + last_sender_report_timestamp(last_sender_report_timestamp), + delay_since_last_sender_report(delay_since_last_sender_report) {} // Fields as described by RFC 3550 6.4.2. - uint32_t remoteSSRC; // SSRC of sender of this report. - uint32_t sourceSSRC; // SSRC of the RTP packet sender. - uint8_t fractionLost; - uint32_t cumulativeLost; // 24 bits valid. - uint32_t extendedHighSeqNum; + union { + uint32_t sender_ssrc; // SSRC of sender of this report. + RTC_DEPRECATED uint32_t remoteSSRC; + }; + union { + uint32_t source_ssrc; // SSRC of the RTP packet sender. + RTC_DEPRECATED uint32_t sourceSSRC; + }; + union { + RTC_DEPRECATED uint8_t fractionLost; + uint8_t fraction_lost; + }; + union { + uint32_t packets_lost; // 24 bits valid. + RTC_DEPRECATED uint32_t cumulativeLost; + }; + union { + uint32_t extended_highest_sequence_number; + RTC_DEPRECATED uint32_t extendedHighSeqNum; + }; uint32_t jitter; - uint32_t lastSR; - uint32_t delaySinceLastSR; + union { + uint32_t last_sender_report_timestamp; + RTC_DEPRECATED uint32_t lastSR; + }; + union { + uint32_t delay_since_last_sender_report; + RTC_DEPRECATED uint32_t delaySinceLastSR; + }; }; typedef std::list ReportBlockList; diff --git a/webrtc/modules/rtp_rtcp/source/playout_delay_oracle.cc b/webrtc/modules/rtp_rtcp/source/playout_delay_oracle.cc index a85f7e9053..0ca81edca3 100644 --- a/webrtc/modules/rtp_rtcp/source/playout_delay_oracle.cc +++ b/webrtc/modules/rtp_rtcp/source/playout_delay_oracle.cc @@ -55,8 +55,9 @@ void PlayoutDelayOracle::OnReceivedRtcpReportBlocks( const ReportBlockList& report_blocks) { rtc::CritScope lock(&crit_sect_); for (const RTCPReportBlock& report_block : report_blocks) { - if ((ssrc_ == report_block.sourceSSRC) && send_playout_delay_ && - (report_block.extendedHighSeqNum > high_sequence_number_)) { + if ((ssrc_ == report_block.source_ssrc) && send_playout_delay_ && + (report_block.extended_highest_sequence_number > + high_sequence_number_)) { send_playout_delay_ = false; } } diff --git a/webrtc/modules/rtp_rtcp/source/playout_delay_oracle_unittest.cc b/webrtc/modules/rtp_rtcp/source/playout_delay_oracle_unittest.cc index e7034b0e09..f32e821ec2 100644 --- a/webrtc/modules/rtp_rtcp/source/playout_delay_oracle_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/playout_delay_oracle_unittest.cc @@ -26,8 +26,8 @@ class PlayoutDelayOracleTest : public ::testing::Test { protected: void ReportRTCPFeedback(int ssrc, int seq_num) { RTCPReportBlock report_block; - report_block.sourceSSRC = ssrc; - report_block.extendedHighSeqNum = seq_num; + report_block.source_ssrc = ssrc; + report_block.extended_highest_sequence_number = seq_num; report_blocks_.push_back(report_block); playout_delay_oracle_.OnReceivedRtcpReportBlocks(report_blocks_); } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc index 94783b721f..7270f3928a 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc @@ -458,23 +458,23 @@ void RTCPReceiver::HandleReportBlock(const ReportBlock& report_block, ReportBlockWithRtt* report_block_info = &received_report_blocks_[report_block.source_ssrc()][remote_ssrc]; - report_block_info->report_block.remoteSSRC = remote_ssrc; - report_block_info->report_block.sourceSSRC = report_block.source_ssrc(); - report_block_info->report_block.fractionLost = report_block.fraction_lost(); - report_block_info->report_block.cumulativeLost = - report_block.cumulative_lost(); + report_block_info->report_block.sender_ssrc = remote_ssrc; + report_block_info->report_block.source_ssrc = report_block.source_ssrc(); + report_block_info->report_block.fraction_lost = report_block.fraction_lost(); + report_block_info->report_block.packets_lost = report_block.cumulative_lost(); if (report_block.extended_high_seq_num() > - report_block_info->report_block.extendedHighSeqNum) { + report_block_info->report_block.extended_highest_sequence_number) { // We have successfully delivered new RTP packets to the remote side after // the last RR was sent from the remote side. last_increased_sequence_number_ms_ = clock_->TimeInMilliseconds(); } - report_block_info->report_block.extendedHighSeqNum = + report_block_info->report_block.extended_highest_sequence_number = report_block.extended_high_seq_num(); report_block_info->report_block.jitter = report_block.jitter(); - report_block_info->report_block.delaySinceLastSR = + report_block_info->report_block.delay_since_last_sender_report = report_block.delay_since_last_sr(); - report_block_info->report_block.lastSR = report_block.last_sr(); + report_block_info->report_block.last_sender_report_timestamp = + report_block.last_sr(); int64_t rtt_ms = 0; uint32_t send_time_ntp = report_block.last_sr(); @@ -992,13 +992,13 @@ void RTCPReceiver::TriggerCallbacksFromRtcpPacket( if (stats_callback_) { for (const auto& report_block : packet_information.report_blocks) { RtcpStatistics stats; - stats.packets_lost = report_block.cumulativeLost; + stats.packets_lost = report_block.packets_lost; stats.extended_highest_sequence_number = - report_block.extendedHighSeqNum; - stats.fraction_lost = report_block.fractionLost; + report_block.extended_highest_sequence_number; + stats.fraction_lost = report_block.fraction_lost; stats.jitter = report_block.jitter; - stats_callback_->StatisticsUpdated(stats, report_block.sourceSSRC); + stats_callback_->StatisticsUpdated(stats, report_block.source_ssrc); } } } diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc index 4813cc4bb3..3ad333c6b9 100644 --- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc +++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc @@ -349,8 +349,8 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { std::vector received_blocks; rtcp_receiver_.StatisticsReceived(&received_blocks); EXPECT_THAT(received_blocks, - UnorderedElementsAre(Field(&RTCPReportBlock::fractionLost, 0), - Field(&RTCPReportBlock::fractionLost, 10))); + UnorderedElementsAre(Field(&RTCPReportBlock::fraction_lost, 0), + Field(&RTCPReportBlock::fraction_lost, 10))); // Insert next receiver report with same ssrc but new values. rtcp::ReportBlock rb3; @@ -382,18 +382,19 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) { received_blocks.clear(); rtcp_receiver_.StatisticsReceived(&received_blocks); EXPECT_EQ(2u, received_blocks.size()); - EXPECT_THAT(received_blocks, - UnorderedElementsAre( - AllOf(Field(&RTCPReportBlock::sourceSSRC, kReceiverMainSsrc), - Field(&RTCPReportBlock::fractionLost, kFracLost[0]), - Field(&RTCPReportBlock::cumulativeLost, kCumLost[0]), - Field(&RTCPReportBlock::extendedHighSeqNum, - kSequenceNumbers[0])), - AllOf(Field(&RTCPReportBlock::sourceSSRC, kReceiverExtraSsrc), - Field(&RTCPReportBlock::fractionLost, kFracLost[1]), - Field(&RTCPReportBlock::cumulativeLost, kCumLost[1]), - Field(&RTCPReportBlock::extendedHighSeqNum, - kSequenceNumbers[1])))); + EXPECT_THAT( + received_blocks, + UnorderedElementsAre( + AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc), + Field(&RTCPReportBlock::fraction_lost, kFracLost[0]), + Field(&RTCPReportBlock::packets_lost, kCumLost[0]), + Field(&RTCPReportBlock::extended_highest_sequence_number, + kSequenceNumbers[0])), + AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverExtraSsrc), + Field(&RTCPReportBlock::fraction_lost, kFracLost[1]), + Field(&RTCPReportBlock::packets_lost, kCumLost[1]), + Field(&RTCPReportBlock::extended_highest_sequence_number, + kSequenceNumbers[1])))); } TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { @@ -423,11 +424,12 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { std::vector received_blocks; rtcp_receiver_.StatisticsReceived(&received_blocks); EXPECT_EQ(1u, received_blocks.size()); - EXPECT_EQ(kSenderSsrc, received_blocks[0].remoteSSRC); - EXPECT_EQ(kReceiverMainSsrc, 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); + EXPECT_EQ(kSenderSsrc, received_blocks[0].sender_ssrc); + EXPECT_EQ(kReceiverMainSsrc, received_blocks[0].source_ssrc); + EXPECT_EQ(kFracLost[0], received_blocks[0].fraction_lost); + EXPECT_EQ(kCumLost[0], received_blocks[0].packets_lost); + EXPECT_EQ(kSequenceNumbers[0], + received_blocks[0].extended_highest_sequence_number); rtcp::ReportBlock rb2; rb2.SetMediaSsrc(kReceiverMainSsrc); @@ -446,20 +448,21 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) { received_blocks.clear(); rtcp_receiver_.StatisticsReceived(&received_blocks); ASSERT_EQ(2u, received_blocks.size()); - EXPECT_THAT(received_blocks, - UnorderedElementsAre( - AllOf(Field(&RTCPReportBlock::sourceSSRC, kReceiverMainSsrc), - Field(&RTCPReportBlock::remoteSSRC, kSenderSsrc), - Field(&RTCPReportBlock::fractionLost, kFracLost[0]), - Field(&RTCPReportBlock::cumulativeLost, kCumLost[0]), - Field(&RTCPReportBlock::extendedHighSeqNum, - kSequenceNumbers[0])), - AllOf(Field(&RTCPReportBlock::sourceSSRC, kReceiverMainSsrc), - Field(&RTCPReportBlock::remoteSSRC, kSenderSsrc2), - Field(&RTCPReportBlock::fractionLost, kFracLost[1]), - Field(&RTCPReportBlock::cumulativeLost, kCumLost[1]), - Field(&RTCPReportBlock::extendedHighSeqNum, - kSequenceNumbers[1])))); + EXPECT_THAT( + received_blocks, + UnorderedElementsAre( + AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc), + Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc), + Field(&RTCPReportBlock::fraction_lost, kFracLost[0]), + Field(&RTCPReportBlock::packets_lost, kCumLost[0]), + Field(&RTCPReportBlock::extended_highest_sequence_number, + kSequenceNumbers[0])), + AllOf(Field(&RTCPReportBlock::source_ssrc, kReceiverMainSsrc), + Field(&RTCPReportBlock::sender_ssrc, kSenderSsrc2), + Field(&RTCPReportBlock::fraction_lost, kFracLost[1]), + Field(&RTCPReportBlock::packets_lost, kCumLost[1]), + Field(&RTCPReportBlock::extended_highest_sequence_number, + kSequenceNumbers[1])))); } TEST_F(RtcpReceiverTest, GetRtt) { diff --git a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc index c981ad7744..790319a996 100644 --- a/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc +++ b/webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc @@ -187,7 +187,7 @@ void ModuleRtpRtcpImpl::Process() { for (std::vector::iterator it = receive_blocks.begin(); it != receive_blocks.end(); ++it) { int64_t rtt = 0; - rtcp_receiver_.RTT(it->remoteSSRC, &rtt, NULL, NULL, NULL); + rtcp_receiver_.RTT(it->sender_ssrc, &rtt, NULL, NULL, NULL); max_rtt = (rtt > max_rtt) ? rtt : max_rtt; } // Report the rtt. diff --git a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc index a124f62725..3ce1af7859 100644 --- a/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc +++ b/webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc @@ -235,13 +235,14 @@ TEST_F(RtpRtcpRtcpTest, RemoteRTCPStatRemote) { ASSERT_EQ(1u, report_blocks.size()); // |test_ssrc+1| is the SSRC of module2 that send the report. - EXPECT_EQ(test_ssrc+1, report_blocks[0].remoteSSRC); - EXPECT_EQ(test_ssrc, report_blocks[0].sourceSSRC); + EXPECT_EQ(test_ssrc + 1, report_blocks[0].sender_ssrc); + EXPECT_EQ(test_ssrc, report_blocks[0].source_ssrc); - EXPECT_EQ(0u, report_blocks[0].cumulativeLost); - EXPECT_LT(0u, report_blocks[0].delaySinceLastSR); - EXPECT_EQ(test_sequence_number, report_blocks[0].extendedHighSeqNum); - EXPECT_EQ(0u, report_blocks[0].fractionLost); + EXPECT_EQ(0u, report_blocks[0].packets_lost); + EXPECT_LT(0u, report_blocks[0].delay_since_last_sender_report); + EXPECT_EQ(test_sequence_number, + report_blocks[0].extended_highest_sequence_number); + EXPECT_EQ(0u, report_blocks[0].fraction_lost); } } // namespace diff --git a/webrtc/test/mock_voice_engine.h b/webrtc/test/mock_voice_engine.h index e8eb5a2634..79443b99a1 100644 --- a/webrtc/test/mock_voice_engine.h +++ b/webrtc/test/mock_voice_engine.h @@ -227,7 +227,7 @@ class MockVoiceEngine : public VoiceEngineImpl { unsigned int& timestamp, unsigned int& playoutTimestamp, unsigned int* jitter, - unsigned short* fractionLost)); + unsigned short* fraction_lost)); MOCK_METHOD4(GetRTPStatistics, int(int channel, unsigned int& averageJitterMs, diff --git a/webrtc/video/report_block_stats.cc b/webrtc/video/report_block_stats.cc index f36feb9e67..ac5041d7fb 100644 --- a/webrtc/video/report_block_stats.cc +++ b/webrtc/video/report_block_stats.cc @@ -34,12 +34,13 @@ void ReportBlockStats::Store(const RtcpStatistics& rtcp_stats, uint32_t remote_ssrc, uint32_t source_ssrc) { RTCPReportBlock block; - block.cumulativeLost = rtcp_stats.packets_lost; - block.fractionLost = rtcp_stats.fraction_lost; - block.extendedHighSeqNum = rtcp_stats.extended_highest_sequence_number; + block.packets_lost = rtcp_stats.packets_lost; + block.fraction_lost = rtcp_stats.fraction_lost; + block.extended_highest_sequence_number = + rtcp_stats.extended_highest_sequence_number; block.jitter = rtcp_stats.jitter; - block.remoteSSRC = remote_ssrc; - block.sourceSSRC = source_ssrc; + block.sender_ssrc = remote_ssrc; + block.source_ssrc = source_ssrc; uint32_t num_sequence_numbers = 0; uint32_t num_lost_sequence_numbers = 0; StoreAndAddPacketIncrement( @@ -56,7 +57,7 @@ RTCPReportBlock ReportBlockStats::AggregateAndStore( uint32_t num_lost_sequence_numbers = 0; ReportBlockVector::const_iterator report_block = report_blocks.begin(); for (; report_block != report_blocks.end(); ++report_block) { - aggregate.cumulativeLost += report_block->cumulativeLost; + aggregate.packets_lost += report_block->packets_lost; aggregate.jitter += report_block->jitter; StoreAndAddPacketIncrement(*report_block, &num_sequence_numbers, @@ -68,7 +69,7 @@ RTCPReportBlock ReportBlockStats::AggregateAndStore( return report_blocks[0]; } // Fraction lost since previous report block. - aggregate.fractionLost = + aggregate.fraction_lost = FractionLost(num_lost_sequence_numbers, num_sequence_numbers); aggregate.jitter = static_cast( (aggregate.jitter + report_blocks.size() / 2) / report_blocks.size()); @@ -80,13 +81,14 @@ void ReportBlockStats::StoreAndAddPacketIncrement( uint32_t* num_sequence_numbers, uint32_t* num_lost_sequence_numbers) { // Get diff with previous report block. - ReportBlockMap::iterator prev_report_block = prev_report_blocks_.find( - report_block.sourceSSRC); + ReportBlockMap::iterator prev_report_block = + prev_report_blocks_.find(report_block.source_ssrc); if (prev_report_block != prev_report_blocks_.end()) { - int seq_num_diff = report_block.extendedHighSeqNum - - prev_report_block->second.extendedHighSeqNum; - int cum_loss_diff = report_block.cumulativeLost - - prev_report_block->second.cumulativeLost; + int seq_num_diff = + report_block.extended_highest_sequence_number - + prev_report_block->second.extended_highest_sequence_number; + int cum_loss_diff = + report_block.packets_lost - prev_report_block->second.packets_lost; if (seq_num_diff >= 0 && cum_loss_diff >= 0) { *num_sequence_numbers += seq_num_diff; *num_lost_sequence_numbers += cum_loss_diff; @@ -96,7 +98,7 @@ void ReportBlockStats::StoreAndAddPacketIncrement( } } // Store current report block. - prev_report_blocks_[report_block.sourceSSRC] = report_block; + prev_report_blocks_[report_block.source_ssrc] = report_block; } int ReportBlockStats::FractionLostInPercent() const { diff --git a/webrtc/video/report_block_stats_unittest.cc b/webrtc/video/report_block_stats_unittest.cc index d8bd7be49b..3ce49ee6db 100644 --- a/webrtc/video/report_block_stats_unittest.cc +++ b/webrtc/video/report_block_stats_unittest.cc @@ -19,32 +19,32 @@ class ReportBlockStatsTest : public ::testing::Test { void SetUp() override { // kSsrc1: block 1-3. - block1_1_.cumulativeLost = 10; - block1_1_.fractionLost = 123; - block1_1_.extendedHighSeqNum = 24000; + block1_1_.packets_lost = 10; + block1_1_.fraction_lost = 123; + block1_1_.extended_highest_sequence_number = 24000; block1_1_.jitter = 777; - block1_1_.sourceSSRC = kSsrc1; - block1_2_.cumulativeLost = 15; - block1_2_.fractionLost = 0; - block1_2_.extendedHighSeqNum = 24100; + block1_1_.source_ssrc = kSsrc1; + block1_2_.packets_lost = 15; + block1_2_.fraction_lost = 0; + block1_2_.extended_highest_sequence_number = 24100; block1_2_.jitter = 222; - block1_2_.sourceSSRC = kSsrc1; - block1_3_.cumulativeLost = 50; - block1_3_.fractionLost = 0; - block1_3_.extendedHighSeqNum = 24200; + block1_2_.source_ssrc = kSsrc1; + block1_3_.packets_lost = 50; + block1_3_.fraction_lost = 0; + block1_3_.extended_highest_sequence_number = 24200; block1_3_.jitter = 333; - block1_3_.sourceSSRC = kSsrc1; + block1_3_.source_ssrc = kSsrc1; // kSsrc2: block 1,2. - block2_1_.cumulativeLost = 111; - block2_1_.fractionLost = 222; - block2_1_.extendedHighSeqNum = 8500; + block2_1_.packets_lost = 111; + block2_1_.fraction_lost = 222; + block2_1_.extended_highest_sequence_number = 8500; block2_1_.jitter = 555; - block2_1_.sourceSSRC = kSsrc2; - block2_2_.cumulativeLost = 136; - block2_2_.fractionLost = 0; - block2_2_.extendedHighSeqNum = 8800; + block2_1_.source_ssrc = kSsrc2; + block2_2_.packets_lost = 136; + block2_2_.fraction_lost = 0; + block2_2_.extended_highest_sequence_number = 8800; block2_2_.jitter = 888; - block2_2_.sourceSSRC = kSsrc2; + block2_2_.source_ssrc = kSsrc2; ssrc1block1_.push_back(block1_1_); ssrc1block2_.push_back(block1_2_); @@ -57,9 +57,10 @@ class ReportBlockStatsTest : public ::testing::Test { RtcpStatistics RtcpReportBlockToRtcpStatistics( const RTCPReportBlock& stats) { RtcpStatistics block; - block.packets_lost = stats.cumulativeLost; - block.fraction_lost = stats.fractionLost; - block.extended_highest_sequence_number = stats.extendedHighSeqNum; + block.packets_lost = stats.packets_lost; + block.fraction_lost = stats.fraction_lost; + block.extended_highest_sequence_number = + stats.extended_highest_sequence_number; block.jitter = stats.jitter; return block; } @@ -81,26 +82,26 @@ TEST_F(ReportBlockStatsTest, AggregateAndStore_NoSsrc) { ReportBlockStats stats; std::vector empty; RTCPReportBlock aggregated = stats.AggregateAndStore(empty); - EXPECT_EQ(0U, aggregated.fractionLost); - EXPECT_EQ(0U, aggregated.cumulativeLost); + EXPECT_EQ(0U, aggregated.fraction_lost); + EXPECT_EQ(0U, aggregated.packets_lost); EXPECT_EQ(0U, aggregated.jitter); - EXPECT_EQ(0U, aggregated.extendedHighSeqNum); + EXPECT_EQ(0U, aggregated.extended_highest_sequence_number); } TEST_F(ReportBlockStatsTest, AggregateAndStore_OneSsrc) { ReportBlockStats stats; RTCPReportBlock aggregated = stats.AggregateAndStore(ssrc1block1_); // One ssrc, no aggregation done. - EXPECT_EQ(123U, aggregated.fractionLost); - EXPECT_EQ(10U, aggregated.cumulativeLost); + EXPECT_EQ(123U, aggregated.fraction_lost); + EXPECT_EQ(10U, aggregated.packets_lost); EXPECT_EQ(777U, aggregated.jitter); - EXPECT_EQ(24000U, aggregated.extendedHighSeqNum); + EXPECT_EQ(24000U, aggregated.extended_highest_sequence_number); aggregated = stats.AggregateAndStore(ssrc1block2_); - EXPECT_EQ(0U, aggregated.fractionLost); - EXPECT_EQ(15U, aggregated.cumulativeLost); + EXPECT_EQ(0U, aggregated.fraction_lost); + EXPECT_EQ(15U, aggregated.packets_lost); EXPECT_EQ(222U, aggregated.jitter); - EXPECT_EQ(24100U, aggregated.extendedHighSeqNum); + EXPECT_EQ(24100U, aggregated.extended_highest_sequence_number); // fl: 100 * (15-10) / (24100-24000) = 5% EXPECT_EQ(5, stats.FractionLostInPercent()); @@ -109,17 +110,17 @@ TEST_F(ReportBlockStatsTest, AggregateAndStore_OneSsrc) { TEST_F(ReportBlockStatsTest, AggregateAndStore_TwoSsrcs) { ReportBlockStats stats; RTCPReportBlock aggregated = stats.AggregateAndStore(ssrc12block1_); - EXPECT_EQ(0U, aggregated.fractionLost); - EXPECT_EQ(10U + 111U, aggregated.cumulativeLost); + EXPECT_EQ(0U, aggregated.fraction_lost); + EXPECT_EQ(10U + 111U, aggregated.packets_lost); EXPECT_EQ((777U + 555U) / 2, aggregated.jitter); - EXPECT_EQ(0U, aggregated.extendedHighSeqNum); + EXPECT_EQ(0U, aggregated.extended_highest_sequence_number); aggregated = stats.AggregateAndStore(ssrc12block2_); // fl: 255 * ((15-10) + (136-111)) / ((24100-24000) + (8800-8500)) = 19 - EXPECT_EQ(19U, aggregated.fractionLost); - EXPECT_EQ(15U + 136U, aggregated.cumulativeLost); + EXPECT_EQ(19U, aggregated.fraction_lost); + EXPECT_EQ(15U + 136U, aggregated.packets_lost); EXPECT_EQ((222U + 888U) / 2, aggregated.jitter); - EXPECT_EQ(0U, aggregated.extendedHighSeqNum); + EXPECT_EQ(0U, aggregated.extended_highest_sequence_number); // fl: 100 * ((15-10) + (136-111)) / ((24100-24000) + (8800-8500)) = 7% EXPECT_EQ(7, stats.FractionLostInPercent()); diff --git a/webrtc/voice_engine/channel.cc b/webrtc/voice_engine/channel.cc index d630575cbc..9158d362c6 100644 --- a/webrtc/voice_engine/channel.cc +++ b/webrtc/voice_engine/channel.cc @@ -373,16 +373,17 @@ class VoERtcpObserver : public RtcpBandwidthObserver { // to calculate the number of RTP packets this report refers to. Ignore if // we haven't seen this SSRC before. std::map::iterator seq_num_it = - extended_max_sequence_number_.find(block_it->sourceSSRC); + extended_max_sequence_number_.find(block_it->source_ssrc); int number_of_packets = 0; if (seq_num_it != extended_max_sequence_number_.end()) { - number_of_packets = block_it->extendedHighSeqNum - seq_num_it->second; + number_of_packets = + block_it->extended_highest_sequence_number - seq_num_it->second; } - fraction_lost_aggregate += number_of_packets * block_it->fractionLost; + fraction_lost_aggregate += number_of_packets * block_it->fraction_lost; total_number_of_packets += number_of_packets; - extended_max_sequence_number_[block_it->sourceSSRC] = - block_it->extendedHighSeqNum; + extended_max_sequence_number_[block_it->source_ssrc] = + block_it->extended_highest_sequence_number; } int weighted_fraction_lost = 0; if (total_number_of_packets > 0) { @@ -2648,14 +2649,15 @@ int Channel::GetRemoteRTCPReportBlocks( std::vector::const_iterator it = rtcp_report_blocks.begin(); for (; it != rtcp_report_blocks.end(); ++it) { ReportBlock report_block; - report_block.sender_SSRC = it->remoteSSRC; - report_block.source_SSRC = it->sourceSSRC; - report_block.fraction_lost = it->fractionLost; - report_block.cumulative_num_packets_lost = it->cumulativeLost; - report_block.extended_highest_sequence_number = it->extendedHighSeqNum; + report_block.sender_SSRC = it->sender_ssrc; + report_block.source_SSRC = it->source_ssrc; + report_block.fraction_lost = it->fraction_lost; + report_block.cumulative_num_packets_lost = it->packets_lost; + report_block.extended_highest_sequence_number = + it->extended_highest_sequence_number; report_block.interarrival_jitter = it->jitter; - report_block.last_SR_timestamp = it->lastSR; - report_block.delay_since_last_SR = it->delaySinceLastSR; + report_block.last_SR_timestamp = it->last_sender_report_timestamp; + report_block.delay_since_last_SR = it->delay_since_last_sender_report; report_blocks->push_back(report_block); } return 0; @@ -3145,7 +3147,7 @@ int64_t Channel::GetRTT(bool allow_associate_channel) const { uint32_t remoteSSRC = rtp_receiver_->SSRC(); std::vector::const_iterator it = report_blocks.begin(); for (; it != report_blocks.end(); ++it) { - if (it->remoteSSRC == remoteSSRC) + if (it->sender_ssrc == remoteSSRC) break; } if (it == report_blocks.end()) { @@ -3153,7 +3155,7 @@ int64_t Channel::GetRTT(bool allow_associate_channel) const { // To calculate RTT we try with the SSRC of the first report block. // This is very important for send-only channels where we don't know // the SSRC of the other end. - remoteSSRC = report_blocks[0].remoteSSRC; + remoteSSRC = report_blocks[0].sender_ssrc; } int64_t avg_rtt = 0;