admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed fields in rtp_rtcp_defines.h/RTCPReportBlock

Browse Source 
Continues on https://codereview.webrtc.org/2992043002

BUG=webrtc:8033

Review-Url: https://codereview.webrtc.org/2994633002
Cr-Commit-Position: refs/heads/master@{#19286}
This commit is contained in:
srte 2017-08-09 06:13:45 -07:00 committed by Commit Bot
parent f1e08d0b58
commit 3e69e5c2c0
14 changed files with 194 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
webrtc/modules/bitrate_controller/bitrate_controller_impl.cc
View File

@ -191,20 +191,20 @@ void BitrateControllerImpl::OnReceivedRtcpReceiverReport(
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 "

7
webrtc/modules/remote_bitrate_estimator/test/estimators/remb.cc
View File

@ -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;
}

8
webrtc/modules/remote_bitrate_estimator/test/estimators/send_side.cc
View File

@ -91,12 +91,12 @@ void SendSideBweSender::GiveFeedback(const FeedbackPacket& feedback) {
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(

68
webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h
View File

@ -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<RTCPReportBlock> ReportBlockList;

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

@ -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;
}
}

4
webrtc/modules/rtp_rtcp/source/playout_delay_oracle_unittest.cc
View File

@ -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_);
}

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

@ -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);
}
}
}

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

@ -349,8 +349,8 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
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 @@ 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<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 @@ 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) {

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

@ -187,7 +187,7 @@ void ModuleRtpRtcpImpl::Process() {
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.

13
webrtc/modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
View File

@ -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

2
webrtc/test/mock_voice_engine.h
View File

@ -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,

30
webrtc/video/report_block_stats.cc
View File

@ -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<uint32_t>(
(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 {

77
webrtc/video/report_block_stats_unittest.cc
View File

@ -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<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_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());

30
webrtc/voice_engine/channel.cc
View File

@ -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<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 @@ int Channel::GetRemoteRTCPReportBlocks(
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 @@ int64_t Channel::GetRTT(bool allow_associate_channel) const {
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 @@ 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;