zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete StreamDataCountersCallback from ReceiveStatistics

Browse Source 
Bug: webrtc:10679
Change-Id: Ife6a4f598c5b70478244b15fc884f6a424d1505b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/148521
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28841}
This commit is contained in:
Niels Möller
2019-08-13 14:43:02 +02:00
committed by Commit Bot
parent 01525f9e03
commit d78196576d
8 changed files with 208 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
modules/rtp_rtcp/include/receive_statistics.h
View File

@ -57,10 +57,9 @@ class ReceiveStatistics : public ReceiveStatisticsProvider,
public:
~ReceiveStatistics() override = default;
static std::unique_ptr<ReceiveStatistics> Create(Clock* clock) {
return Create(clock, nullptr);
}
static std::unique_ptr<ReceiveStatistics> Create(Clock* clock);
RTC_DEPRECATED
static std::unique_ptr<ReceiveStatistics> Create(
Clock* clock,
StreamDataCountersCallback* rtp_callback);

45
modules/rtp_rtcp/source/receive_statistics_impl.cc
View File

@ -30,11 +30,9 @@ const int64_t kStatisticsProcessIntervalMs = 1000;
StreamStatistician::~StreamStatistician() {}
StreamStatisticianImpl::StreamStatisticianImpl(
uint32_t ssrc,
Clock* clock,
int max_reordering_threshold,
StreamDataCountersCallback* rtp_callback)
StreamStatisticianImpl::StreamStatisticianImpl(uint32_t ssrc,
Clock* clock,
int max_reordering_threshold)
: ssrc_(ssrc),
clock_(clock),
incoming_bitrate_(kStatisticsProcessIntervalMs,
@ -49,15 +47,12 @@ StreamStatisticianImpl::StreamStatisticianImpl(
received_seq_max_(-1),
last_report_inorder_packets_(0),
last_report_old_packets_(0),
last_report_seq_max_(-1),
rtp_callback_(rtp_callback) {}
last_report_seq_max_(-1) {}
StreamStatisticianImpl::~StreamStatisticianImpl() = default;
void StreamStatisticianImpl::OnRtpPacket(const RtpPacketReceived& packet) {
StreamDataCounters counters = UpdateCounters(packet);
if (rtp_callback_)
rtp_callback_->DataCountersUpdated(counters, ssrc_);
UpdateCounters(packet);
}
bool StreamStatisticianImpl::UpdateOutOfOrder(const RtpPacketReceived& packet,
@ -156,14 +151,8 @@ void StreamStatisticianImpl::UpdateJitter(const RtpPacketReceived& packet,
void StreamStatisticianImpl::FecPacketReceived(
const RtpPacketReceived& packet) {
StreamDataCounters counters;
{
rtc::CritScope cs(&stream_lock_);
receive_counters_.fec.AddPacket(packet);
counters = receive_counters_;
}
if (rtp_callback_)
rtp_callback_->DataCountersUpdated(counters, ssrc_);
rtc::CritScope cs(&stream_lock_);
receive_counters_.fec.AddPacket(packet);
}
void StreamStatisticianImpl::SetMaxReorderingThreshold(
@ -332,10 +321,15 @@ bool StreamStatisticianImpl::IsRetransmitOfOldPacket(
return time_diff_ms > rtp_time_stamp_diff_ms + max_delay_ms;
}
std::unique_ptr<ReceiveStatistics> ReceiveStatistics::Create(Clock* clock) {
return absl::make_unique<ReceiveStatisticsImpl>(clock);
}
std::unique_ptr<ReceiveStatistics> ReceiveStatistics::Create(
Clock* clock,
StreamDataCountersCallback* rtp_callback) {
return absl::make_unique<ReceiveStatisticsImpl>(clock, rtp_callback);
RTC_CHECK(rtp_callback == nullptr);
return Create(clock);
}
std::unique_ptr<ReceiveStatistics> ReceiveStatistics::Create(
@ -343,16 +337,14 @@ std::unique_ptr<ReceiveStatistics> ReceiveStatistics::Create(
RtcpStatisticsCallback* rtcp_callback,
StreamDataCountersCallback* rtp_callback) {
RTC_CHECK(rtcp_callback == nullptr);
return Create(clock, rtp_callback);
RTC_CHECK(rtp_callback == nullptr);
return Create(clock);
}
ReceiveStatisticsImpl::ReceiveStatisticsImpl(
Clock* clock,
StreamDataCountersCallback* rtp_callback)
ReceiveStatisticsImpl::ReceiveStatisticsImpl(Clock* clock)
: clock_(clock),
last_returned_ssrc_(0),
max_reordering_threshold_(kDefaultMaxReorderingThreshold),
rtp_stats_callback_(rtp_callback) {}
max_reordering_threshold_(kDefaultMaxReorderingThreshold) {}
ReceiveStatisticsImpl::~ReceiveStatisticsImpl() {
while (!statisticians_.empty()) {
@ -391,8 +383,7 @@ StreamStatisticianImpl* ReceiveStatisticsImpl::GetOrCreateStatistician(
rtc::CritScope cs(&receive_statistics_lock_);
StreamStatisticianImpl*& impl = statisticians_[ssrc];
if (impl == nullptr) { // new element
impl = new StreamStatisticianImpl(ssrc, clock_, max_reordering_threshold_,
rtp_stats_callback_);
impl = new StreamStatisticianImpl(ssrc, clock_, max_reordering_threshold_);
}
return impl;
}

11
modules/rtp_rtcp/source/receive_statistics_impl.h
View File

@ -29,8 +29,7 @@ class StreamStatisticianImpl : public StreamStatistician,
public:
StreamStatisticianImpl(uint32_t ssrc,
Clock* clock,
int max_reordering_threshold,
StreamDataCountersCallback* rtp_callback);
int max_reordering_threshold);
~StreamStatisticianImpl() override;
// |reset| here and in next method restarts calculation of fraction_lost stat.
@ -98,15 +97,11 @@ class StreamStatisticianImpl : public StreamStatistician,
uint32_t last_report_old_packets_ RTC_GUARDED_BY(&stream_lock_);
int64_t last_report_seq_max_ RTC_GUARDED_BY(&stream_lock_);
RtcpStatistics last_reported_statistics_ RTC_GUARDED_BY(&stream_lock_);
// stream_lock_ shouldn't be held when calling callbacks.
StreamDataCountersCallback* const rtp_callback_;
};
class ReceiveStatisticsImpl : public ReceiveStatistics {
public:
ReceiveStatisticsImpl(Clock* clock,
StreamDataCountersCallback* rtp_callback);
explicit ReceiveStatisticsImpl(Clock* clock);
~ReceiveStatisticsImpl() override;
@ -134,8 +129,6 @@ class ReceiveStatisticsImpl : public ReceiveStatistics {
int max_reordering_threshold_ RTC_GUARDED_BY(receive_statistics_lock_);
std::map<uint32_t, StreamStatisticianImpl*> statisticians_
RTC_GUARDED_BY(receive_statistics_lock_);
StreamDataCountersCallback* const rtp_stats_callback_;
};
} // namespace webrtc
#endif // MODULES_RTP_RTCP_SOURCE_RECEIVE_STATISTICS_IMPL_H_

158
modules/rtp_rtcp/source/receive_statistics_unittest.cc
View File

@ -68,8 +68,7 @@ void IncrementSequenceNumber(RtpPacketReceived* packet) {
class ReceiveStatisticsTest : public ::testing::Test {
public:
ReceiveStatisticsTest()
: clock_(0),
receive_statistics_(ReceiveStatistics::Create(&clock_, nullptr)) {
: clock_(0), receive_statistics_(ReceiveStatistics::Create(&clock_)) {
packet1_ = CreateRtpPacket(kSsrc1, kPacketSize1);
packet2_ = CreateRtpPacket(kSsrc2, kPacketSize2);
}
@ -460,45 +459,8 @@ TEST_F(ReceiveStatisticsTest, WrapsAroundExtendedHighestSequenceNumber) {
EXPECT_EQ(0x20001u, statistics.extended_highest_sequence_number);
}
class RtpTestCallback : public StreamDataCountersCallback {
public:
RtpTestCallback()
: StreamDataCountersCallback(), num_calls_(0), ssrc_(0), stats_() {}
~RtpTestCallback() override = default;
void DataCountersUpdated(const StreamDataCounters& counters,
uint32_t ssrc) override {
ssrc_ = ssrc;
stats_ = counters;
++num_calls_;
}
void MatchPacketCounter(const RtpPacketCounter& expected,
const RtpPacketCounter& actual) {
EXPECT_EQ(expected.payload_bytes, actual.payload_bytes);
EXPECT_EQ(expected.header_bytes, actual.header_bytes);
EXPECT_EQ(expected.padding_bytes, actual.padding_bytes);
EXPECT_EQ(expected.packets, actual.packets);
}
void Matches(uint32_t num_calls,
uint32_t ssrc,
const StreamDataCounters& expected) {
EXPECT_EQ(num_calls, num_calls_);
EXPECT_EQ(ssrc, ssrc_);
MatchPacketCounter(expected.transmitted, stats_.transmitted);
MatchPacketCounter(expected.retransmitted, stats_.retransmitted);
MatchPacketCounter(expected.fec, stats_.fec);
}
uint32_t num_calls_;
uint32_t ssrc_;
StreamDataCounters stats_;
};
TEST_F(ReceiveStatisticsTest, RtpCallbacks) {
RtpTestCallback callback;
receive_statistics_ = ReceiveStatistics::Create(&clock_, &callback);
TEST_F(ReceiveStatisticsTest, StreamDataCounters) {
receive_statistics_ = ReceiveStatistics::Create(&clock_);
receive_statistics_->EnableRetransmitDetection(kSsrc1, true);
const size_t kHeaderLength = 20;
@ -508,17 +470,17 @@ TEST_F(ReceiveStatisticsTest, RtpCallbacks) {
RtpPacketReceived packet1 =
CreateRtpPacket(kSsrc1, kHeaderLength, kPacketSize1, 0);
receive_statistics_->OnRtpPacket(packet1);
StreamDataCounters expected;
expected.transmitted.payload_bytes = kPacketSize1;
expected.transmitted.header_bytes = kHeaderLength;
expected.transmitted.padding_bytes = 0;
expected.transmitted.packets = 1;
expected.retransmitted.payload_bytes = 0;
expected.retransmitted.header_bytes = 0;
expected.retransmitted.padding_bytes = 0;
expected.retransmitted.packets = 0;
expected.fec.packets = 0;
callback.Matches(1, kSsrc1, expected);
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 =
@ -526,77 +488,89 @@ TEST_F(ReceiveStatisticsTest, RtpCallbacks) {
packet2.SetSequenceNumber(packet1.SequenceNumber() + 1);
clock_.AdvanceTimeMilliseconds(5);
receive_statistics_->OnRtpPacket(packet2);
expected.transmitted.payload_bytes = kPacketSize1 * 2;
expected.transmitted.header_bytes = kHeaderLength * 2;
expected.transmitted.padding_bytes = kPaddingLength;
expected.transmitted.packets = 2;
callback.Matches(2, kSsrc1, expected);
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);
expected.transmitted.payload_bytes = kPacketSize1 * 3;
expected.transmitted.header_bytes = kHeaderLength * 3;
expected.transmitted.padding_bytes = kPaddingLength * 2;
expected.transmitted.packets = 3;
expected.retransmitted.payload_bytes = kPacketSize1;
expected.retransmitted.header_bytes = kHeaderLength;
expected.retransmitted.padding_bytes = kPaddingLength;
expected.retransmitted.packets = 1;
callback.Matches(3, kSsrc1, expected);
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);
// One FEC packet.
packet1.SetSequenceNumber(packet2.SequenceNumber() + 1);
clock_.AdvanceTimeMilliseconds(5);
receive_statistics_->OnRtpPacket(packet1);
receive_statistics_->FecPacketReceived(packet1);
expected.transmitted.payload_bytes = kPacketSize1 * 4;
expected.transmitted.header_bytes = kHeaderLength * 4;
expected.transmitted.packets = 4;
expected.fec.payload_bytes = kPacketSize1;
expected.fec.header_bytes = kHeaderLength;
expected.fec.packets = 1;
callback.Matches(5, kSsrc1, expected);
counters = receive_statistics_->GetStatistician(kSsrc1)
->GetReceiveStreamDataCounters();
EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1 * 4);
EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength * 4);
EXPECT_EQ(counters.transmitted.packets, 4u);
EXPECT_EQ(counters.fec.payload_bytes, kPacketSize1);
EXPECT_EQ(counters.fec.header_bytes, kHeaderLength);
EXPECT_EQ(counters.fec.packets, 1u);
}
TEST_F(ReceiveStatisticsTest, LastPacketReceivedTimestamp) {
RtpTestCallback callback;
receive_statistics_ = ReceiveStatistics::Create(&clock_, &callback);
receive_statistics_ = ReceiveStatistics::Create(&clock_);
clock_.AdvanceTimeMilliseconds(42);
receive_statistics_->OnRtpPacket(packet1_);
EXPECT_EQ(42, callback.stats_.last_packet_received_timestamp_ms);
StreamDataCounters counters = receive_statistics_->GetStatistician(kSsrc1)
->GetReceiveStreamDataCounters();
EXPECT_EQ(42, counters.last_packet_received_timestamp_ms);
clock_.AdvanceTimeMilliseconds(3);
receive_statistics_->OnRtpPacket(packet1_);
EXPECT_EQ(45, callback.stats_.last_packet_received_timestamp_ms);
counters = receive_statistics_->GetStatistician(kSsrc1)
->GetReceiveStreamDataCounters();
EXPECT_EQ(45, counters.last_packet_received_timestamp_ms);
}
TEST_F(ReceiveStatisticsTest, RtpCallbacksFecFirst) {
RtpTestCallback callback;
receive_statistics_ = ReceiveStatistics::Create(&clock_, &callback);
TEST_F(ReceiveStatisticsTest, FecFirst) {
receive_statistics_ = ReceiveStatistics::Create(&clock_);
const uint32_t kHeaderLength = 20;
RtpPacketReceived packet =
CreateRtpPacket(kSsrc1, kHeaderLength, kPacketSize1, 0);
// If first packet is FEC, ignore it.
receive_statistics_->FecPacketReceived(packet);
EXPECT_EQ(0u, callback.num_calls_);
EXPECT_EQ(receive_statistics_->GetStatistician(kSsrc1), nullptr);
receive_statistics_->OnRtpPacket(packet);
StreamDataCounters expected;
expected.transmitted.payload_bytes = kPacketSize1;
expected.transmitted.header_bytes = kHeaderLength;
expected.transmitted.padding_bytes = 0;
expected.transmitted.packets = 1;
expected.fec.packets = 0;
callback.Matches(1, kSsrc1, expected);
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.fec.packets, 0u);
receive_statistics_->FecPacketReceived(packet);
expected.fec.payload_bytes = kPacketSize1;
expected.fec.header_bytes = kHeaderLength;
expected.fec.packets = 1;
callback.Matches(2, kSsrc1, expected);
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.fec.payload_bytes, kPacketSize1);
EXPECT_EQ(counters.fec.header_bytes, kHeaderLength);
EXPECT_EQ(counters.fec.packets, 1u);
}
} // namespace