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}
diff --git a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
index 70efe3e..dc8805f 100644
--- a/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
+++ b/webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
@@ -191,20 +191,20 @@
for (const RTCPReportBlock& report_block : report_blocks) {
std::map<uint32_t, uint32_t>::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 57f3f73..1daf14e 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 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 6e6ac29..d419240 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 @@
if (expected_packets > 0) {
int lost_packets = expected_packets -
static_cast<int>(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 eb46254..7d54ea4 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 @@
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<RTCPReportBlock> ReportBlockList;
diff --git a/webrtc/modules/rtp_rtcp/source/playout_delay_oracle.cc b/webrtc/modules/rtp_rtcp/source/playout_delay_oracle.cc
index a85f7e9..0ca81ed 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 @@
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 e7034b0..f32e821 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 @@
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 94783b7..7270f39 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -458,23 +458,23 @@
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 @@
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 4813cc4..3ad333c 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 @@
std::vector<RTCPReportBlock> 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 @@
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 @@
std::vector<RTCPReportBlock> 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 @@
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 c981ad7..790319a 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 @@
for (std::vector<RTCPReportBlock>::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 a124f62..3ce1af7 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 @@
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 e8eb5a2..79443b9 100644
--- a/webrtc/test/mock_voice_engine.h
+++ b/webrtc/test/mock_voice_engine.h
@@ -227,7 +227,7 @@
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 f36feb9..ac5041d 100644
--- a/webrtc/video/report_block_stats.cc
+++ b/webrtc/video/report_block_stats.cc
@@ -34,12 +34,13 @@
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 @@
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 @@
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<uint32_t>(
(aggregate.jitter + report_blocks.size() / 2) / report_blocks.size());
@@ -80,13 +81,14 @@
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 @@
}
}
// 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 d8bd7be..3ce49ee 100644
--- a/webrtc/video/report_block_stats_unittest.cc
+++ b/webrtc/video/report_block_stats_unittest.cc
@@ -19,32 +19,32 @@
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 @@
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 @@
ReportBlockStats stats;
std::vector<RTCPReportBlock> 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_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 d630575..9158d36 100644
--- a/webrtc/voice_engine/channel.cc
+++ b/webrtc/voice_engine/channel.cc
@@ -373,16 +373,17 @@
// to calculate the number of RTP packets this report refers to. Ignore if
// we haven't seen this SSRC before.
std::map<uint32_t, uint32_t>::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 @@
std::vector<RTCPReportBlock>::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 @@
uint32_t remoteSSRC = rtp_receiver_->SSRC();
std::vector<RTCPReportBlock>::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 @@
// 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;
