blob: a2558545f0499874de838aafef67fb5293650f5f [file] [log] [blame]
/*
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/rtp_rtcp/include/receive_statistics.h"
#include <cstdint>
#include <memory>
#include <vector>
#include "api/units/time_delta.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/random.h"
#include "system_wrappers/include/clock.h"
#include "test/gmock.h"
#include "test/gtest.h"
namespace webrtc {
namespace {
using ::testing::SizeIs;
using ::testing::UnorderedElementsAre;
const size_t kPacketSize1 = 100;
const size_t kPacketSize2 = 300;
const uint32_t kSsrc1 = 101;
const uint32_t kSsrc2 = 202;
const uint32_t kSsrc3 = 203;
const uint32_t kSsrc4 = 304;
RtpPacketReceived CreateRtpPacket(uint32_t ssrc,
size_t header_size,
size_t payload_size,
size_t padding_size) {
RtpPacketReceived packet;
packet.SetSsrc(ssrc);
packet.SetSequenceNumber(100);
packet.set_payload_type_frequency(90000);
RTC_CHECK_GE(header_size, 12);
RTC_CHECK_EQ(header_size % 4, 0);
if (header_size > 12) {
// Insert csrcs to increase header size.
const int num_csrcs = (header_size - 12) / 4;
std::vector<uint32_t> csrcs(num_csrcs);
packet.SetCsrcs(csrcs);
}
packet.SetPayloadSize(payload_size);
packet.SetPadding(padding_size);
return packet;
}
RtpPacketReceived MakeRtpPacket(int payload_type_frequency,
uint32_t timestamp) {
RtpPacketReceived packet =
CreateRtpPacket(kSsrc1,
/*header_size=*/12, kPacketSize1 - 12,
/*padding_size=*/0);
packet.SetTimestamp(timestamp);
packet.set_payload_type_frequency(payload_type_frequency);
return packet;
}
RtpPacketReceived MakeNextRtpPacket(const RtpPacketReceived& previous_packet,
int payload_type_frequency,
uint32_t timestamp) {
RtpPacketReceived packet = MakeRtpPacket(payload_type_frequency, timestamp);
packet.SetSequenceNumber(previous_packet.SequenceNumber() + 1);
return packet;
}
RtpPacketReceived CreateRtpPacket(uint32_t ssrc, size_t packet_size) {
return CreateRtpPacket(ssrc, 12, packet_size - 12, 0);
}
void IncrementSequenceNumber(RtpPacketReceived* packet, uint16_t incr) {
packet->SetSequenceNumber(packet->SequenceNumber() + incr);
}
void IncrementSequenceNumber(RtpPacketReceived* packet) {
IncrementSequenceNumber(packet, 1);
}
uint32_t GetJitter(const ReceiveStatistics& stats) {
return stats.GetStatistician(kSsrc1)->GetStats().jitter;
}
class ReceiveStatisticsTest : public ::testing::TestWithParam<bool> {
public:
ReceiveStatisticsTest()
: clock_(0),
receive_statistics_(
GetParam() ? ReceiveStatistics::Create(&clock_)
: ReceiveStatistics::CreateThreadCompatible(&clock_)) {
packet1_ = CreateRtpPacket(kSsrc1, kPacketSize1);
packet2_ = CreateRtpPacket(kSsrc2, kPacketSize2);
}
protected:
SimulatedClock clock_;
std::unique_ptr<ReceiveStatistics> receive_statistics_;
RtpPacketReceived packet1_;
RtpPacketReceived packet2_;
};
INSTANTIATE_TEST_SUITE_P(All,
ReceiveStatisticsTest,
::testing::Bool(),
[](::testing::TestParamInfo<bool> info) {
return info.param ? "WithMutex" : "WithoutMutex";
});
TEST_P(ReceiveStatisticsTest, TwoIncomingSsrcs) {
receive_statistics_->OnRtpPacket(packet1_);
IncrementSequenceNumber(&packet1_);
receive_statistics_->OnRtpPacket(packet2_);
IncrementSequenceNumber(&packet2_);
clock_.AdvanceTimeMilliseconds(100);
receive_statistics_->OnRtpPacket(packet1_);
IncrementSequenceNumber(&packet1_);
receive_statistics_->OnRtpPacket(packet2_);
IncrementSequenceNumber(&packet2_);
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
ASSERT_TRUE(statistician != NULL);
EXPECT_GT(statistician->BitrateReceived(), 0u);
StreamDataCounters counters = statistician->GetReceiveStreamDataCounters();
EXPECT_EQ(176u, counters.transmitted.payload_bytes);
EXPECT_EQ(24u, counters.transmitted.header_bytes);
EXPECT_EQ(0u, counters.transmitted.padding_bytes);
EXPECT_EQ(2u, counters.transmitted.packets);
statistician = receive_statistics_->GetStatistician(kSsrc2);
ASSERT_TRUE(statistician != NULL);
EXPECT_GT(statistician->BitrateReceived(), 0u);
counters = statistician->GetReceiveStreamDataCounters();
EXPECT_EQ(576u, counters.transmitted.payload_bytes);
EXPECT_EQ(24u, counters.transmitted.header_bytes);
EXPECT_EQ(0u, counters.transmitted.padding_bytes);
EXPECT_EQ(2u, counters.transmitted.packets);
EXPECT_EQ(2u, receive_statistics_->RtcpReportBlocks(3).size());
// Add more incoming packets and verify that they are registered in both
// access methods.
receive_statistics_->OnRtpPacket(packet1_);
IncrementSequenceNumber(&packet1_);
receive_statistics_->OnRtpPacket(packet2_);
IncrementSequenceNumber(&packet2_);
counters = receive_statistics_->GetStatistician(kSsrc1)
->GetReceiveStreamDataCounters();
EXPECT_EQ(264u, counters.transmitted.payload_bytes);
EXPECT_EQ(36u, counters.transmitted.header_bytes);
EXPECT_EQ(0u, counters.transmitted.padding_bytes);
EXPECT_EQ(3u, counters.transmitted.packets);
counters = receive_statistics_->GetStatistician(kSsrc2)
->GetReceiveStreamDataCounters();
EXPECT_EQ(864u, counters.transmitted.payload_bytes);
EXPECT_EQ(36u, counters.transmitted.header_bytes);
EXPECT_EQ(0u, counters.transmitted.padding_bytes);
EXPECT_EQ(3u, counters.transmitted.packets);
}
TEST_P(ReceiveStatisticsTest,
RtcpReportBlocksReturnsMaxBlocksWhenThereAreMoreStatisticians) {
RtpPacketReceived packet1 = CreateRtpPacket(kSsrc1, kPacketSize1);
RtpPacketReceived packet2 = CreateRtpPacket(kSsrc2, kPacketSize1);
RtpPacketReceived packet3 = CreateRtpPacket(kSsrc3, kPacketSize1);
receive_statistics_->OnRtpPacket(packet1);
receive_statistics_->OnRtpPacket(packet2);
receive_statistics_->OnRtpPacket(packet3);
EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2));
EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2));
EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2));
}
TEST_P(ReceiveStatisticsTest,
RtcpReportBlocksReturnsAllObservedSsrcsWithMultipleCalls) {
RtpPacketReceived packet1 = CreateRtpPacket(kSsrc1, kPacketSize1);
RtpPacketReceived packet2 = CreateRtpPacket(kSsrc2, kPacketSize1);
RtpPacketReceived packet3 = CreateRtpPacket(kSsrc3, kPacketSize1);
RtpPacketReceived packet4 = CreateRtpPacket(kSsrc4, kPacketSize1);
receive_statistics_->OnRtpPacket(packet1);
receive_statistics_->OnRtpPacket(packet2);
receive_statistics_->OnRtpPacket(packet3);
receive_statistics_->OnRtpPacket(packet4);
std::vector<uint32_t> observed_ssrcs;
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(2);
ASSERT_THAT(report_blocks, SizeIs(2));
observed_ssrcs.push_back(report_blocks[0].source_ssrc());
observed_ssrcs.push_back(report_blocks[1].source_ssrc());
report_blocks = receive_statistics_->RtcpReportBlocks(2);
ASSERT_THAT(report_blocks, SizeIs(2));
observed_ssrcs.push_back(report_blocks[0].source_ssrc());
observed_ssrcs.push_back(report_blocks[1].source_ssrc());
EXPECT_THAT(observed_ssrcs,
UnorderedElementsAre(kSsrc1, kSsrc2, kSsrc3, kSsrc4));
}
TEST_P(ReceiveStatisticsTest, ActiveStatisticians) {
receive_statistics_->OnRtpPacket(packet1_);
IncrementSequenceNumber(&packet1_);
clock_.AdvanceTimeMilliseconds(1000);
receive_statistics_->OnRtpPacket(packet2_);
IncrementSequenceNumber(&packet2_);
// Nothing should time out since only 1000 ms has passed since the first
// packet came in.
EXPECT_EQ(2u, receive_statistics_->RtcpReportBlocks(3).size());
clock_.AdvanceTimeMilliseconds(7000);
// kSsrc1 should have timed out.
EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size());
clock_.AdvanceTimeMilliseconds(1000);
// kSsrc2 should have timed out.
EXPECT_EQ(0u, receive_statistics_->RtcpReportBlocks(3).size());
receive_statistics_->OnRtpPacket(packet1_);
IncrementSequenceNumber(&packet1_);
// kSsrc1 should be active again and the data counters should have survived.
EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size());
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
ASSERT_TRUE(statistician != NULL);
StreamDataCounters counters = statistician->GetReceiveStreamDataCounters();
EXPECT_EQ(176u, counters.transmitted.payload_bytes);
EXPECT_EQ(24u, counters.transmitted.header_bytes);
EXPECT_EQ(0u, counters.transmitted.padding_bytes);
EXPECT_EQ(2u, counters.transmitted.packets);
}
TEST_P(ReceiveStatisticsTest,
DoesntCreateRtcpReportBlockUntilFirstReceivedPacketForSsrc) {
// Creates a statistician object for the ssrc.
receive_statistics_->EnableRetransmitDetection(kSsrc1, true);
EXPECT_TRUE(receive_statistics_->GetStatistician(kSsrc1) != nullptr);
EXPECT_EQ(0u, receive_statistics_->RtcpReportBlocks(3).size());
// Receive first packet
receive_statistics_->OnRtpPacket(packet1_);
EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size());
}
TEST_P(ReceiveStatisticsTest, GetReceiveStreamDataCounters) {
receive_statistics_->OnRtpPacket(packet1_);
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
ASSERT_TRUE(statistician != NULL);
StreamDataCounters counters = statistician->GetReceiveStreamDataCounters();
EXPECT_TRUE(counters.first_packet_time.IsFinite());
EXPECT_EQ(1u, counters.transmitted.packets);
receive_statistics_->OnRtpPacket(packet1_);
counters = statistician->GetReceiveStreamDataCounters();
EXPECT_TRUE(counters.first_packet_time.IsFinite());
EXPECT_EQ(2u, counters.transmitted.packets);
}
TEST_P(ReceiveStatisticsTest, SimpleLossComputation) {
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(3);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(4);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(5);
receive_statistics_->OnRtpPacket(packet1_);
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
// 20% = 51/255.
EXPECT_EQ(51u, report_blocks[0].fraction_lost());
EXPECT_EQ(1, report_blocks[0].cumulative_lost());
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
EXPECT_EQ(20, statistician->GetFractionLostInPercent());
}
TEST_P(ReceiveStatisticsTest, LossComputationWithReordering) {
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(3);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(2);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(5);
receive_statistics_->OnRtpPacket(packet1_);
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
// 20% = 51/255.
EXPECT_EQ(51u, report_blocks[0].fraction_lost());
EXPECT_EQ(1, report_blocks[0].cumulative_lost());
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
EXPECT_EQ(20, statistician->GetFractionLostInPercent());
}
TEST_P(ReceiveStatisticsTest, LossComputationWithDuplicates) {
// Lose 2 packets, but also receive 1 duplicate. Should actually count as
// only 1 packet being lost.
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(4);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(4);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(5);
receive_statistics_->OnRtpPacket(packet1_);
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
// 20% = 51/255.
EXPECT_EQ(51u, report_blocks[0].fraction_lost());
EXPECT_EQ(1, report_blocks[0].cumulative_lost());
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
EXPECT_EQ(20, statistician->GetFractionLostInPercent());
}
TEST_P(ReceiveStatisticsTest, LossComputationWithSequenceNumberWrapping) {
// First, test loss computation over a period that included a sequence number
// rollover.
packet1_.SetSequenceNumber(0xfffd);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(0);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(0xfffe);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
// Only one packet was actually lost, 0xffff.
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
// 20% = 51/255.
EXPECT_EQ(51u, report_blocks[0].fraction_lost());
EXPECT_EQ(1, report_blocks[0].cumulative_lost());
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
EXPECT_EQ(20, statistician->GetFractionLostInPercent());
// Now test losing one packet *after* the rollover.
packet1_.SetSequenceNumber(3);
receive_statistics_->OnRtpPacket(packet1_);
report_blocks = receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
// 50% = 127/255.
EXPECT_EQ(127u, report_blocks[0].fraction_lost());
EXPECT_EQ(2, report_blocks[0].cumulative_lost());
// 2 packets lost, 7 expected
EXPECT_EQ(28, statistician->GetFractionLostInPercent());
}
TEST_P(ReceiveStatisticsTest, StreamRestartDoesntCountAsLoss) {
receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
packet1_.SetSequenceNumber(0);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(400);
receive_statistics_->OnRtpPacket(packet1_);
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(0, report_blocks[0].fraction_lost());
EXPECT_EQ(0, report_blocks[0].cumulative_lost());
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
EXPECT_EQ(0, statistician->GetFractionLostInPercent());
packet1_.SetSequenceNumber(401);
receive_statistics_->OnRtpPacket(packet1_);
report_blocks = receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(0, report_blocks[0].fraction_lost());
EXPECT_EQ(0, report_blocks[0].cumulative_lost());
EXPECT_EQ(0, statistician->GetFractionLostInPercent());
}
TEST_P(ReceiveStatisticsTest, CountsLossAfterStreamRestart) {
receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
packet1_.SetSequenceNumber(0);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(400);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(401);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(403);
receive_statistics_->OnRtpPacket(packet1_);
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(1, report_blocks[0].cumulative_lost());
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
// Is this reasonable? */
EXPECT_EQ(0, statistician->GetFractionLostInPercent());
}
TEST_P(ReceiveStatisticsTest, StreamCanRestartAtSequenceNumberWrapAround) {
receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
packet1_.SetSequenceNumber(0xffff - 401);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(0xffff - 400);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(0xffff);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(0);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(2);
receive_statistics_->OnRtpPacket(packet1_);
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(1, report_blocks[0].cumulative_lost());
}
TEST_P(ReceiveStatisticsTest, StreamRestartNeedsTwoConsecutivePackets) {
receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
packet1_.SetSequenceNumber(400);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(401);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(3);
receive_statistics_->OnRtpPacket(packet1_);
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(401u, report_blocks[0].extended_high_seq_num());
packet1_.SetSequenceNumber(4);
receive_statistics_->OnRtpPacket(packet1_);
report_blocks = receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(4u, report_blocks[0].extended_high_seq_num());
}
TEST_P(ReceiveStatisticsTest, WrapsAroundExtendedHighestSequenceNumber) {
packet1_.SetSequenceNumber(0xffff);
receive_statistics_->OnRtpPacket(packet1_);
std::vector<rtcp::ReportBlock> report_blocks =
receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(0xffffu, report_blocks[0].extended_high_seq_num());
// Wrap around.
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
report_blocks = receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(0x10001u, report_blocks[0].extended_high_seq_num());
// Should be treated as out of order; shouldn't increment highest extended
// sequence number.
packet1_.SetSequenceNumber(0x10000 - 6);
report_blocks = receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(0x10001u, report_blocks[0].extended_high_seq_num());
// Receive a couple packets then wrap around again.
receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
for (int i = 10; i < 0xffff; i += 150) {
packet1_.SetSequenceNumber(i);
receive_statistics_->OnRtpPacket(packet1_);
}
packet1_.SetSequenceNumber(1);
receive_statistics_->OnRtpPacket(packet1_);
report_blocks = receive_statistics_->RtcpReportBlocks(1);
ASSERT_THAT(report_blocks, SizeIs(1));
EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
EXPECT_EQ(0x20001u, report_blocks[0].extended_high_seq_num());
}
TEST_P(ReceiveStatisticsTest, StreamDataCounters) {
receive_statistics_->EnableRetransmitDetection(kSsrc1, true);
const size_t kHeaderLength = 20;
const size_t kPaddingLength = 9;
// One packet with payload size kPacketSize1.
RtpPacketReceived packet1 =
CreateRtpPacket(kSsrc1, kHeaderLength, kPacketSize1, 0);
receive_statistics_->OnRtpPacket(packet1);
StreamDataCounters counters = receive_statistics_->GetStatistician(kSsrc1)
->GetReceiveStreamDataCounters();
EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1);
EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength);
EXPECT_EQ(counters.transmitted.padding_bytes, 0u);
EXPECT_EQ(counters.transmitted.packets, 1u);
EXPECT_EQ(counters.retransmitted.payload_bytes, 0u);
EXPECT_EQ(counters.retransmitted.header_bytes, 0u);
EXPECT_EQ(counters.retransmitted.padding_bytes, 0u);
EXPECT_EQ(counters.retransmitted.packets, 0u);
EXPECT_EQ(counters.fec.packets, 0u);
// Another packet of size kPacketSize1 with 9 bytes padding.
RtpPacketReceived packet2 =
CreateRtpPacket(kSsrc1, kHeaderLength, kPacketSize1, 9);
packet2.SetSequenceNumber(packet1.SequenceNumber() + 1);
clock_.AdvanceTimeMilliseconds(5);
receive_statistics_->OnRtpPacket(packet2);
counters = receive_statistics_->GetStatistician(kSsrc1)
->GetReceiveStreamDataCounters();
EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1 * 2);
EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength * 2);
EXPECT_EQ(counters.transmitted.padding_bytes, kPaddingLength);
EXPECT_EQ(counters.transmitted.packets, 2u);
clock_.AdvanceTimeMilliseconds(5);
// Retransmit last packet.
receive_statistics_->OnRtpPacket(packet2);
counters = receive_statistics_->GetStatistician(kSsrc1)
->GetReceiveStreamDataCounters();
EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1 * 3);
EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength * 3);
EXPECT_EQ(counters.transmitted.padding_bytes, kPaddingLength * 2);
EXPECT_EQ(counters.transmitted.packets, 3u);
EXPECT_EQ(counters.retransmitted.payload_bytes, kPacketSize1);
EXPECT_EQ(counters.retransmitted.header_bytes, kHeaderLength);
EXPECT_EQ(counters.retransmitted.padding_bytes, kPaddingLength);
EXPECT_EQ(counters.retransmitted.packets, 1u);
}
TEST_P(ReceiveStatisticsTest, LastPacketReceivedTimestamp) {
clock_.AdvanceTimeMilliseconds(42);
packet1_.SetSequenceNumber(100);
receive_statistics_->OnRtpPacket(packet1_);
RtpReceiveStats counters =
receive_statistics_->GetStatistician(kSsrc1)->GetStats();
EXPECT_EQ(counters.last_packet_received, Timestamp::Millis(42));
clock_.AdvanceTimeMilliseconds(3);
packet1_.SetSequenceNumber(101);
receive_statistics_->OnRtpPacket(packet1_);
counters = receive_statistics_->GetStatistician(kSsrc1)->GetStats();
EXPECT_EQ(counters.last_packet_received, Timestamp::Millis(45));
}
TEST_P(ReceiveStatisticsTest, SimpleJitterComputation) {
const int kMsPerPacket = 20;
const int kCodecSampleRate = 48'000;
const int kSamplesPerPacket = kMsPerPacket * kCodecSampleRate / 1'000;
const int kLateArrivalDeltaMs = 100;
const int kLateArrivalDeltaSamples =
kLateArrivalDeltaMs * kCodecSampleRate / 1'000;
packet1_.set_payload_type_frequency(kCodecSampleRate);
packet1_.SetSequenceNumber(1);
packet1_.SetTimestamp(0);
receive_statistics_->OnRtpPacket(packet1_);
packet1_.SetSequenceNumber(2);
packet1_.SetTimestamp(kSamplesPerPacket);
// Arrives 100 ms late.
clock_.AdvanceTimeMilliseconds(kMsPerPacket + kLateArrivalDeltaMs);
receive_statistics_->OnRtpPacket(packet1_);
StreamStatistician* statistician =
receive_statistics_->GetStatistician(kSsrc1);
// See jitter caluculation in https://www.rfc-editor.org/rfc/rfc3550 6.4.1.
const uint32_t expected_jitter = (kLateArrivalDeltaSamples) / 16;
EXPECT_EQ(expected_jitter, statistician->GetStats().jitter);
EXPECT_EQ(webrtc::TimeDelta::Seconds(expected_jitter) / kCodecSampleRate,
statistician->GetStats().interarrival_jitter);
}
TEST(ReviseJitterTest, AllPacketsHaveSamePayloadTypeFrequency) {
SimulatedClock clock(0);
std::unique_ptr<ReceiveStatistics> statistics =
ReceiveStatistics::Create(&clock);
RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/8'000,
/*timestamp=*/1);
RtpPacketReceived packet2 = MakeNextRtpPacket(
packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160);
RtpPacketReceived packet3 = MakeNextRtpPacket(
packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 2 * 160);
statistics->OnRtpPacket(packet1);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet2);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet3);
// packet1: no jitter calculation
// packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
// / 16 = 240
// packet3: jitter = 240[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 240[jitter] + 8)
// / 16 = 465
// final jitter: 465 / 16 = 29
EXPECT_EQ(GetJitter(*statistics), 29U);
}
TEST(ReviseJitterTest, AllPacketsHaveDifferentPayloadTypeFrequency) {
SimulatedClock clock(0);
std::unique_ptr<ReceiveStatistics> statistics =
ReceiveStatistics::Create(&clock);
RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/8'000,
/*timestamp=*/1);
RtpPacketReceived packet2 = MakeNextRtpPacket(
packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160);
RtpPacketReceived packet3 = MakeNextRtpPacket(
packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960);
statistics->OnRtpPacket(packet1);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet2);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet3);
// packet1: no jitter calculation
// packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
// / 16 = 240
// packet3: revised jitter: 240 * 48[frequency KHz] / 8[frequency KHz] = 1'440
// jitter = 1'440[jitter] + (abs(50[receive time ms] *
// 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'440[jitter] + 8)
// / 16 = 2'790
// final jitter: 2'790 / 16 = 174
EXPECT_EQ(GetJitter(*statistics), 174U);
}
TEST(ReviseJitterTest,
FirstPacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) {
SimulatedClock clock(0);
std::unique_ptr<ReceiveStatistics> statistics =
ReceiveStatistics::Create(&clock);
RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0,
/*timestamp=*/1);
RtpPacketReceived packet2 = MakeNextRtpPacket(
packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160);
RtpPacketReceived packet3 = MakeNextRtpPacket(
packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960);
statistics->OnRtpPacket(packet1);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet2);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet3);
// packet1: no jitter calculation
// packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
// / 16 = 240
// packet3: revised jitter: 240 * 48[frequency KHz] / 8[frequency KHz] = 1'440
// jitter = 1'440[jitter] + (abs(50[receive time ms] *
// 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'440[jitter] + 8)
// / 16 = 2'790
// final jitter: 2'790 / 16 = 174
EXPECT_EQ(GetJitter(*statistics), 174U);
}
TEST(ReviseJitterTest,
FirstPacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) {
SimulatedClock clock(0);
std::unique_ptr<ReceiveStatistics> statistics =
ReceiveStatistics::Create(&clock);
RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0,
/*timestamp=*/1);
RtpPacketReceived packet2 = MakeNextRtpPacket(
packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160);
RtpPacketReceived packet3 = MakeNextRtpPacket(
packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160 + 160);
statistics->OnRtpPacket(packet1);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet2);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet3);
// packet1: no jitter calculation
// packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
// / 16 = 240
// packet3: jitter = 240[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 240[jitter] + 8)
// / 16 = 465
// final jitter: 465 / 16 = 29
EXPECT_EQ(GetJitter(*statistics), 29U);
}
TEST(ReviseJitterTest,
TwoFirstPacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) {
SimulatedClock clock(0);
std::unique_ptr<ReceiveStatistics> statistics =
ReceiveStatistics::Create(&clock);
RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0,
/*timestamp=*/1);
RtpPacketReceived packet2 = MakeNextRtpPacket(
packet1, /*payload_type_frequency=*/0, /*timestamp=*/1 + 160);
RtpPacketReceived packet3 = MakeNextRtpPacket(
packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960);
RtpPacketReceived packet4 =
MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000,
/*timestamp=*/1 + 160 + 960 + 160);
statistics->OnRtpPacket(packet1);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet2);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet3);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet4);
// packet1: no jitter calculation
// packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
// 0[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
// / 16 = 160
// packet3: jitter = 160[jitter] + (abs(50[receive time ms] *
// 48[frequency KHz] - 960[timestamp diff]) * 16 - 160[jitter] + 8)
// / 16 = 1'590
// packet4: revised jitter: 1'590 * 8[frequency KHz] / 48[frequency KHz] = 265
// packet4: jitter = 265[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 265[jitter] + 8)
// / 16 = 488
// final jitter: 488 / 16 = 30
EXPECT_EQ(GetJitter(*statistics), 30U);
}
TEST(ReviseJitterTest,
TwoFirstPacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) {
SimulatedClock clock(0);
std::unique_ptr<ReceiveStatistics> statistics =
ReceiveStatistics::Create(&clock);
RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0,
/*timestamp=*/1);
RtpPacketReceived packet2 = MakeNextRtpPacket(
packet1, /*payload_type_frequency=*/0, /*timestamp=*/1 + 160);
RtpPacketReceived packet3 = MakeNextRtpPacket(
packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160 + 160);
RtpPacketReceived packet4 =
MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000,
/*timestamp=*/1 + 160 + 160 + 160);
statistics->OnRtpPacket(packet1);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet2);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet3);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet4);
// packet1: no jitter calculation
// packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
// 0[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
// / 16 = 160
// packet3: jitter = 160[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 160[jitter] + 8)
// / 16 = 390
// packet4: jitter = 390[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 390[jitter] + 8)
// / 16 = 606
// final jitter: 606 / 16 = 37
EXPECT_EQ(GetJitter(*statistics), 37U);
}
TEST(ReviseJitterTest,
MiddlePacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) {
SimulatedClock clock(0);
std::unique_ptr<ReceiveStatistics> statistics =
ReceiveStatistics::Create(&clock);
RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/48'000,
/*timestamp=*/1);
RtpPacketReceived packet2 = MakeNextRtpPacket(
packet1, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 960);
RtpPacketReceived packet3 = MakeNextRtpPacket(
packet2, /*payload_type_frequency=*/0, /*timestamp=*/1 + 960 + 55);
RtpPacketReceived packet4 =
MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000,
/*timestamp=*/1 + 960 + 55 + 160);
statistics->OnRtpPacket(packet1);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet2);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet3);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet4);
// packet1: no jitter calculation
// packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
// 48[frequency KHz] - 960[timestamp diff]) * 16 - 0[jitter] + 8)
// / 16 = 1'440
// packet3: jitter = 1'440[jitter] + (abs(50[receive time ms] *
// 0[frequency KHz] - 55[timestamp diff]) * 16 - 1'440[jitter] + 8)
// / 16 = 1'405
// packet4: revised jitter: 1'405 * 8[frequency KHz] / 48[frequency KHz] = 234
// jitter = 234[jitter] + (abs(50[receive time ms] *
// 8[frequency KHz] - 160[timestamp diff]) * 16 - 234[jitter] + 8)
// / 16 = 459
// final jitter: 459 / 16 = 28
EXPECT_EQ(GetJitter(*statistics), 28U);
}
TEST(ReviseJitterTest,
MiddlePacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) {
SimulatedClock clock(0);
std::unique_ptr<ReceiveStatistics> statistics =
ReceiveStatistics::Create(&clock);
RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/48'000,
/*timestamp=*/1);
RtpPacketReceived packet2 = MakeNextRtpPacket(
packet1, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 960);
RtpPacketReceived packet3 = MakeNextRtpPacket(
packet2, /*payload_type_frequency=*/0, /*timestamp=*/1 + 960 + 55);
RtpPacketReceived packet4 =
MakeNextRtpPacket(packet3, /*payload_type_frequency=*/48'000,
/*timestamp=*/1 + 960 + 55 + 960);
statistics->OnRtpPacket(packet1);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet2);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet3);
clock.AdvanceTimeMilliseconds(50);
statistics->OnRtpPacket(packet4);
// packet1: no jitter calculation
// packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
// 48[frequency KHz] - 960[timestamp diff]) * 16 - 0[jitter] + 8)
// / 16 = 1'440
// packet3: jitter = 1'440[jitter] + (abs(50[receive time ms] *
// 0[frequency KHz] - 55[timestamp diff]) * 16 - 1'440[jitter] + 8)
// / 16 = 1'405
// packet4: jitter = 1'405[jitter] + (abs(50[receive time ms] *
// 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'405[jitter] + 8)
// / 16 = 2'757
// final jitter: 2'757 / 16 = 172
EXPECT_EQ(GetJitter(*statistics), 172U);
}
} // namespace
} // namespace webrtc