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

Cleanup rtcp StreamStatistician::OnRtpPacket

Browse Source 
inline InOrder check
remove it from IsRetransmit check as redundant
avoid call to IsRetransmitOfOldPacket when packet arrived in order
take current time once
Remove packet overhead counting as unused

Bug: None
Change-Id: Icd8bf69b5076e4469c349529c9ac79a1b15d9515
Reviewed-on: https://webrtc-review.googlesource.com/c/111746
Reviewed-by: Niels Moller <nisse@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#25749}
This commit is contained in:
Danil Chapovalov 2018-11-22 11:28:45 +01:00 committed by Commit Bot
parent af228ee761
commit 44727b48d6
2 changed files with 25 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -48,7 +48,6 @@ StreamStatisticianImpl::StreamStatisticianImpl(
received_seq_first_(0),
received_seq_max_(0),
received_seq_wraps_(0),
received_packet_overhead_(12),
last_report_inorder_packets_(0),
last_report_old_packets_(0),
last_report_seq_max_(0),
@ -58,31 +57,34 @@ StreamStatisticianImpl::StreamStatisticianImpl(
StreamStatisticianImpl::~StreamStatisticianImpl() = default;
void StreamStatisticianImpl::OnRtpPacket(const RtpPacketReceived& packet) {
StreamDataCounters counters;
{
rtc::CritScope cs(&stream_lock_);
bool retransmitted =
enable_retransmit_detection_ && IsRetransmitOfOldPacket(packet);
counters = UpdateCounters(packet, retransmitted);
}
StreamDataCounters counters = UpdateCounters(packet);
rtp_callback_->DataCountersUpdated(counters, ssrc_);
}
StreamDataCounters StreamStatisticianImpl::UpdateCounters(
const RtpPacketReceived& packet,
bool retransmitted) {
bool in_order = InOrderPacketInternal(packet.SequenceNumber());
const RtpPacketReceived& packet) {
rtc::CritScope cs(&stream_lock_);
RTC_DCHECK_EQ(ssrc_, packet.Ssrc());
incoming_bitrate_.Update(packet.size(), clock_->TimeInMilliseconds());
uint16_t sequence_number = packet.SequenceNumber();
bool in_order =
// First packet is always in order.
last_receive_time_ms_ == 0 ||
IsNewerSequenceNumber(sequence_number, received_seq_max_) ||
// If we have a restart of the remote side this packet is still in order.
!IsNewerSequenceNumber(sequence_number,
received_seq_max_ - max_reordering_threshold_);
int64_t now_ms = clock_->TimeInMilliseconds();
incoming_bitrate_.Update(packet.size(), now_ms);
receive_counters_.transmitted.AddPacket(packet);
if (!in_order && retransmitted) {
if (!in_order && enable_retransmit_detection_ &&
IsRetransmitOfOldPacket(packet, now_ms)) {
receive_counters_.retransmitted.AddPacket(packet);
}
if (receive_counters_.transmitted.packets == 1) {
received_seq_first_ = packet.SequenceNumber();
receive_counters_.first_packet_time_ms = clock_->TimeInMilliseconds();
receive_counters_.first_packet_time_ms = now_ms;
}
// Count only the new packets received. That is, if packets 1, 2, 3, 5, 4, 6
@ -109,14 +111,8 @@ StreamDataCounters StreamStatisticianImpl::UpdateCounters(
}
last_received_timestamp_ = packet.Timestamp();
last_receive_time_ntp_ = receive_time;
last_receive_time_ms_ = clock_->TimeInMilliseconds();
last_receive_time_ms_ = now_ms;
}
size_t packet_oh = packet.headers_size() + packet.padding_size();
// Our measured overhead. Filter from RFC 5104 4.2.1.2:
// avg_OH (new) = 15/16*avg_OH (old) + 1/16*pckt_OH,
received_packet_overhead_ = (15 * received_packet_overhead_ + packet_oh) >> 4;
return receive_counters_;
}
@ -310,14 +306,12 @@ uint32_t StreamStatisticianImpl::BitrateReceived() const {
}
bool StreamStatisticianImpl::IsRetransmitOfOldPacket(
const RtpPacketReceived& packet) const {
if (InOrderPacketInternal(packet.SequenceNumber())) {
return false;
}
const RtpPacketReceived& packet,
int64_t now_ms) const {
uint32_t frequency_khz = packet.payload_type_frequency() / 1000;
assert(frequency_khz > 0);
RTC_DCHECK_GT(frequency_khz, 0);
int64_t time_diff_ms = clock_->TimeInMilliseconds() - last_receive_time_ms_;
int64_t time_diff_ms = now_ms - last_receive_time_ms_;
// Diff in time stamp since last received in order.
uint32_t timestamp_diff = packet.Timestamp() - last_received_timestamp_;
@ -339,21 +333,6 @@ bool StreamStatisticianImpl::IsRetransmitOfOldPacket(
return time_diff_ms > rtp_time_stamp_diff_ms + max_delay_ms;
}
bool StreamStatisticianImpl::InOrderPacketInternal(
uint16_t sequence_number) const {
// First packet is always in order.
if (last_receive_time_ms_ == 0)
return true;
if (IsNewerSequenceNumber(sequence_number, received_seq_max_)) {
return true;
} else {
// If we have a restart of the remote side this packet is still in order.
return !IsNewerSequenceNumber(
sequence_number, received_seq_max_ - max_reordering_threshold_);
}
}
ReceiveStatistics* ReceiveStatistics::Create(Clock* clock) {
return new ReceiveStatisticsImpl(clock);
}

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

@ -50,17 +50,14 @@ class StreamStatisticianImpl : public StreamStatistician,
void EnableRetransmitDetection(bool enable);
private:
bool IsRetransmitOfOldPacket(const RtpPacketReceived& packet) const
RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
bool InOrderPacketInternal(uint16_t sequence_number) const
bool IsRetransmitOfOldPacket(const RtpPacketReceived& packet,
int64_t now_ms) const
RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
RtcpStatistics CalculateRtcpStatistics()
RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
void UpdateJitter(const RtpPacketReceived& packet, NtpTime receive_time)
RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
StreamDataCounters UpdateCounters(const RtpPacketReceived& packet,
bool retransmitted)
RTC_EXCLUSIVE_LOCKS_REQUIRED(stream_lock_);
StreamDataCounters UpdateCounters(const RtpPacketReceived& packet);
const uint32_t ssrc_;
Clock* const clock_;
@ -82,7 +79,6 @@ class StreamStatisticianImpl : public StreamStatistician,
uint16_t received_seq_wraps_ RTC_GUARDED_BY(&stream_lock_);
// Current counter values.
size_t received_packet_overhead_ RTC_GUARDED_BY(&stream_lock_);
StreamDataCounters receive_counters_ RTC_GUARDED_BY(&stream_lock_);
// Counter values when we sent the last report.