From 0beed5d69f9d64903bdbf665035cc487ab9ccadb Mon Sep 17 00:00:00 2001 From: Ilya Nikolaevskiy Date: Tue, 22 May 2018 10:54:30 +0200 Subject: [PATCH] Move SampleCounter from ReceiveStatisticsProxy to rtc_base/numerics MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This class will be used in upcoming VideoQualiyObserver. Bug: none Change-Id: I7d79a6caf3040a3f707ed8700842dea1de81e0a6 Reviewed-on: https://webrtc-review.googlesource.com/77724 Reviewed-by: Erik Språng Reviewed-by: Karl Wiberg Commit-Queue: Ilya Nikolaevskiy Cr-Commit-Position: refs/heads/master@{#23343} --- rtc_base/BUILD.gn | 3 + rtc_base/numerics/sample_counter.cc | 82 ++++++++++ rtc_base/numerics/sample_counter.h | 41 +++++ rtc_base/numerics/sample_counter_unittest.cc | 53 ++++++ video/receive_statistics_proxy.cc | 160 ++++++++----------- video/receive_statistics_proxy.h | 41 ++--- 6 files changed, 261 insertions(+), 119 deletions(-) create mode 100644 rtc_base/numerics/sample_counter.cc create mode 100644 rtc_base/numerics/sample_counter.h create mode 100644 rtc_base/numerics/sample_counter_unittest.cc diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn index aaf974ebee..43172a9ac3 100644 --- a/rtc_base/BUILD.gn +++ b/rtc_base/BUILD.gn @@ -417,6 +417,8 @@ rtc_source_set("rtc_base_approved_generic") { "numerics/histogram_percentile_counter.h", "numerics/mod_ops.h", "numerics/moving_max_counter.h", + "numerics/sample_counter.cc", + "numerics/sample_counter.h", "onetimeevent.h", "pathutils.cc", "pathutils.h", @@ -1140,6 +1142,7 @@ if (rtc_include_tests) { "numerics/moving_max_counter_unittest.cc", "numerics/safe_compare_unittest.cc", "numerics/safe_minmax_unittest.cc", + "numerics/sample_counter_unittest.cc", "onetimeevent_unittest.cc", "pathutils_unittest.cc", "platform_file_unittest.cc", diff --git a/rtc_base/numerics/sample_counter.cc b/rtc_base/numerics/sample_counter.cc new file mode 100644 index 0000000000..037fddc9df --- /dev/null +++ b/rtc_base/numerics/sample_counter.cc @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2018 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 + +#include "rtc_base/checks.h" +#include "rtc_base/numerics/safe_conversions.h" +#include "rtc_base/numerics/sample_counter.h" + +namespace rtc { + +SampleCounter::SampleCounter() = default; +SampleCounter::~SampleCounter() = default; + +void SampleCounter::Add(int sample) { + if (sum_ > 0) { + RTC_DCHECK_LE(sample, std::numeric_limits::max() - sum_); + } else { + RTC_DCHECK_GE(sample, std::numeric_limits::min() - sum_); + } + sum_ += sample; + // Prevent overflow in squaring. + RTC_DCHECK_GT(sample, std::numeric_limits::min()); + RTC_DCHECK_LE(int64_t{sample} * sample, + std::numeric_limits::max() - sum_squared_); + sum_squared_ += int64_t{sample} * sample; + ++num_samples_; + if (!max_ || sample > *max_) { + max_ = sample; + } +} + +void SampleCounter::Add(const SampleCounter& other) { + if (sum_ > 0) { + RTC_DCHECK_LE(other.sum_, std::numeric_limits::max() - sum_); + } else { + RTC_DCHECK_GE(other.sum_, std::numeric_limits::min() - sum_); + } + sum_ += other.sum_; + RTC_DCHECK_LE(other.sum_squared_, + std::numeric_limits::max() - sum_squared_); + sum_squared_ += other.sum_squared_; + RTC_DCHECK_LE(other.num_samples_, + std::numeric_limits::max() - num_samples_); + num_samples_ += other.num_samples_; + if (other.max_ && (!max_ || *max_ < *other.max_)) + max_ = other.max_; +} + +rtc::Optional SampleCounter::Avg(int64_t min_required_samples) const { + RTC_DCHECK_GT(min_required_samples, 0); + if (num_samples_ < min_required_samples) + return rtc::nullopt; + return rtc::dchecked_cast(sum_ / num_samples_); +} + +rtc::Optional SampleCounter::Variance( + int64_t min_required_samples) const { + RTC_DCHECK_GT(min_required_samples, 0); + if (num_samples_ < min_required_samples) + return rtc::nullopt; + // E[(x-mean)^2] = E[x^2] - mean^2 + int64_t mean = sum_ / num_samples_; + return sum_squared_ / num_samples_ - mean * mean; +} + +rtc::Optional SampleCounter::Max() const { + return max_; +} + +void SampleCounter::Reset() { + *this = {}; +} + +} // namespace rtc diff --git a/rtc_base/numerics/sample_counter.h b/rtc_base/numerics/sample_counter.h new file mode 100644 index 0000000000..0de6f25f19 --- /dev/null +++ b/rtc_base/numerics/sample_counter.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2018 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. + */ + +#ifndef RTC_BASE_NUMERICS_SAMPLE_COUNTER_H_ +#define RTC_BASE_NUMERICS_SAMPLE_COUNTER_H_ + +#include "api/optional.h" + +namespace rtc { + +// Simple utility class for counting basic statistics (max./avg./variance) on +// stream of samples. +class SampleCounter { + public: + SampleCounter(); + ~SampleCounter(); + void Add(int sample); + rtc::Optional Avg(int64_t min_required_samples) const; + rtc::Optional Variance(int64_t min_required_samples) const; + rtc::Optional Max() const; + void Reset(); + // Adds all the samples from the |other| SampleCounter as if they were all + // individually added using |Add(int)| method. + void Add(const SampleCounter& other); + + private: + int64_t sum_ = 0; + int64_t sum_squared_ = 0; + int64_t num_samples_ = 0; + rtc::Optional max_; +}; + +} // namespace rtc +#endif // RTC_BASE_NUMERICS_SAMPLE_COUNTER_H_ diff --git a/rtc_base/numerics/sample_counter_unittest.cc b/rtc_base/numerics/sample_counter_unittest.cc new file mode 100644 index 0000000000..844ea4ac6a --- /dev/null +++ b/rtc_base/numerics/sample_counter_unittest.cc @@ -0,0 +1,53 @@ +/* + * Copyright 2018 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 "rtc_base/numerics/sample_counter.h" + +#include +#include + +#include "test/gmock.h" +#include "test/gtest.h" + +using testing::Eq; + +namespace rtc { + +TEST(SampleCounterTest, ProcessesNoSamples) { + constexpr int kMinSamples = 1; + SampleCounter counter; + EXPECT_THAT(counter.Avg(kMinSamples), Eq(rtc::nullopt)); + EXPECT_THAT(counter.Avg(kMinSamples), Eq(rtc::nullopt)); + EXPECT_THAT(counter.Max(), Eq(rtc::nullopt)); +} + +TEST(SampleCounterTest, NotEnoughSamples) { + constexpr int kMinSamples = 6; + SampleCounter counter; + for (int value : {1, 2, 3, 4, 5}) { + counter.Add(value); + } + EXPECT_THAT(counter.Avg(kMinSamples), Eq(rtc::nullopt)); + EXPECT_THAT(counter.Avg(kMinSamples), Eq(rtc::nullopt)); + EXPECT_THAT(counter.Max(), Eq(5)); +} + +TEST(SampleCounterTest, EnoughSamples) { + constexpr int kMinSamples = 5; + SampleCounter counter; + for (int value : {1, 2, 3, 4, 5}) { + counter.Add(value); + } + EXPECT_THAT(counter.Avg(kMinSamples), Eq(3)); + EXPECT_THAT(counter.Variance(kMinSamples), Eq(2)); + EXPECT_THAT(counter.Max(), Eq(5)); +} + +} // namespace rtc diff --git a/video/receive_statistics_proxy.cc b/video/receive_statistics_proxy.cc index 62a68ed5ef..2cccd5a973 100644 --- a/video/receive_statistics_proxy.cc +++ b/video/receive_statistics_proxy.cc @@ -190,10 +190,12 @@ void ReceiveStatisticsProxy::UpdateHistograms() { round(render_pixel_tracker_.ComputeTotalRate())); } - int sync_offset_ms = sync_offset_counter_.Avg(kMinRequiredSamples); - if (sync_offset_ms != -1) { - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.AVSyncOffsetInMs", sync_offset_ms); - log_stream << "WebRTC.Video.AVSyncOffsetInMs " << sync_offset_ms << '\n'; + rtc::Optional sync_offset_ms = + sync_offset_counter_.Avg(kMinRequiredSamples); + if (sync_offset_ms) { + RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.AVSyncOffsetInMs", + *sync_offset_ms); + log_stream << "WebRTC.Video.AVSyncOffsetInMs " << *sync_offset_ms << '\n'; } AggregatedStats freq_offset_stats = freq_offset_counter_.GetStats(); if (freq_offset_stats.num_samples > 0) { @@ -215,37 +217,41 @@ void ReceiveStatisticsProxy::UpdateHistograms() { << key_frames_permille << '\n'; } - int qp = qp_counters_.vp8.Avg(kMinRequiredSamples); - if (qp != -1) { - RTC_HISTOGRAM_COUNTS_200("WebRTC.Video.Decoded.Vp8.Qp", qp); - log_stream << "WebRTC.Video.Decoded.Vp8.Qp " << qp << '\n'; + rtc::Optional qp = qp_counters_.vp8.Avg(kMinRequiredSamples); + if (qp) { + RTC_HISTOGRAM_COUNTS_200("WebRTC.Video.Decoded.Vp8.Qp", *qp); + log_stream << "WebRTC.Video.Decoded.Vp8.Qp " << *qp << '\n'; } - int decode_ms = decode_time_counter_.Avg(kMinRequiredSamples); - if (decode_ms != -1) { - RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DecodeTimeInMs", decode_ms); - log_stream << "WebRTC.Video.DecodeTimeInMs " << decode_ms << '\n'; + rtc::Optional decode_ms = decode_time_counter_.Avg(kMinRequiredSamples); + if (decode_ms) { + RTC_HISTOGRAM_COUNTS_1000("WebRTC.Video.DecodeTimeInMs", *decode_ms); + log_stream << "WebRTC.Video.DecodeTimeInMs " << *decode_ms << '\n'; } - int jb_delay_ms = jitter_buffer_delay_counter_.Avg(kMinRequiredSamples); - if (jb_delay_ms != -1) { + rtc::Optional jb_delay_ms = + jitter_buffer_delay_counter_.Avg(kMinRequiredSamples); + if (jb_delay_ms) { RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.JitterBufferDelayInMs", - jb_delay_ms); - log_stream << "WebRTC.Video.JitterBufferDelayInMs " << jb_delay_ms << '\n'; + *jb_delay_ms); + log_stream << "WebRTC.Video.JitterBufferDelayInMs " << *jb_delay_ms << '\n'; } - int target_delay_ms = target_delay_counter_.Avg(kMinRequiredSamples); - if (target_delay_ms != -1) { - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.TargetDelayInMs", target_delay_ms); - log_stream << "WebRTC.Video.TargetDelayInMs " << target_delay_ms << '\n'; + rtc::Optional target_delay_ms = + target_delay_counter_.Avg(kMinRequiredSamples); + if (target_delay_ms) { + RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.TargetDelayInMs", + *target_delay_ms); + log_stream << "WebRTC.Video.TargetDelayInMs " << *target_delay_ms << '\n'; } - int current_delay_ms = current_delay_counter_.Avg(kMinRequiredSamples); - if (current_delay_ms != -1) { + rtc::Optional current_delay_ms = + current_delay_counter_.Avg(kMinRequiredSamples); + if (current_delay_ms) { RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.CurrentDelayInMs", - current_delay_ms); - log_stream << "WebRTC.Video.CurrentDelayInMs " << current_delay_ms << '\n'; + *current_delay_ms); + log_stream << "WebRTC.Video.CurrentDelayInMs " << *current_delay_ms << '\n'; } - int delay_ms = delay_counter_.Avg(kMinRequiredSamples); - if (delay_ms != -1) - RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.OnewayDelayInMs", delay_ms); + rtc::Optional delay_ms = delay_counter_.Avg(kMinRequiredSamples); + if (delay_ms) + RTC_HISTOGRAM_COUNTS_10000("WebRTC.Video.OnewayDelayInMs", *delay_ms); // Aggregate content_specific_stats_ by removing experiment or simulcast // information; @@ -289,36 +295,38 @@ void ReceiveStatisticsProxy::UpdateHistograms() { RTC_DCHECK(videocontenttypehelpers::GetExperimentId(content_type) == 0 || videocontenttypehelpers::GetSimulcastId(content_type) == 0); - int e2e_delay_ms = stats.e2e_delay_counter.Avg(kMinRequiredSamples); - if (e2e_delay_ms != -1) { + rtc::Optional e2e_delay_ms = + stats.e2e_delay_counter.Avg(kMinRequiredSamples); + if (e2e_delay_ms) { RTC_HISTOGRAM_COUNTS_SPARSE_10000( - uma_prefix + ".EndToEndDelayInMs" + uma_suffix, e2e_delay_ms); + uma_prefix + ".EndToEndDelayInMs" + uma_suffix, *e2e_delay_ms); log_stream << uma_prefix << ".EndToEndDelayInMs" << uma_suffix << " " - << e2e_delay_ms << '\n'; + << *e2e_delay_ms << '\n'; } - int e2e_delay_max_ms = stats.e2e_delay_counter.Max(); - if (e2e_delay_max_ms != -1 && e2e_delay_ms != -1) { + rtc::Optional e2e_delay_max_ms = stats.e2e_delay_counter.Max(); + if (e2e_delay_max_ms && e2e_delay_ms) { RTC_HISTOGRAM_COUNTS_SPARSE_100000( - uma_prefix + ".EndToEndDelayMaxInMs" + uma_suffix, e2e_delay_max_ms); + uma_prefix + ".EndToEndDelayMaxInMs" + uma_suffix, *e2e_delay_max_ms); log_stream << uma_prefix << ".EndToEndDelayMaxInMs" << uma_suffix << " " - << e2e_delay_max_ms << '\n'; + << *e2e_delay_max_ms << '\n'; } - int interframe_delay_ms = + rtc::Optional interframe_delay_ms = stats.interframe_delay_counter.Avg(kMinRequiredSamples); - if (interframe_delay_ms != -1) { + if (interframe_delay_ms) { RTC_HISTOGRAM_COUNTS_SPARSE_10000( uma_prefix + ".InterframeDelayInMs" + uma_suffix, - interframe_delay_ms); + *interframe_delay_ms); log_stream << uma_prefix << ".InterframeDelayInMs" << uma_suffix << " " - << interframe_delay_ms << '\n'; + << *interframe_delay_ms << '\n'; } - int interframe_delay_max_ms = stats.interframe_delay_counter.Max(); - if (interframe_delay_max_ms != -1 && interframe_delay_ms != -1) { + rtc::Optional interframe_delay_max_ms = + stats.interframe_delay_counter.Max(); + if (interframe_delay_max_ms && interframe_delay_ms) { RTC_HISTOGRAM_COUNTS_SPARSE_10000( uma_prefix + ".InterframeDelayMaxInMs" + uma_suffix, - interframe_delay_max_ms); + *interframe_delay_max_ms); log_stream << uma_prefix << ".InterframeDelayMaxInMs" << uma_suffix << " " - << interframe_delay_max_ms << '\n'; + << *interframe_delay_max_ms << '\n'; } rtc::Optional interframe_delay_95p_ms = @@ -331,20 +339,20 @@ void ReceiveStatisticsProxy::UpdateHistograms() { << uma_suffix << " " << *interframe_delay_95p_ms << '\n'; } - int width = stats.received_width.Avg(kMinRequiredSamples); - if (width != -1) { + rtc::Optional width = stats.received_width.Avg(kMinRequiredSamples); + if (width) { RTC_HISTOGRAM_COUNTS_SPARSE_10000( - uma_prefix + ".ReceivedWidthInPixels" + uma_suffix, width); + uma_prefix + ".ReceivedWidthInPixels" + uma_suffix, *width); log_stream << uma_prefix << ".ReceivedWidthInPixels" << uma_suffix << " " - << width << '\n'; + << *width << '\n'; } - int height = stats.received_height.Avg(kMinRequiredSamples); - if (height != -1) { + rtc::Optional height = stats.received_height.Avg(kMinRequiredSamples); + if (height) { RTC_HISTOGRAM_COUNTS_SPARSE_10000( - uma_prefix + ".ReceivedHeightInPixels" + uma_suffix, height); + uma_prefix + ".ReceivedHeightInPixels" + uma_suffix, *height); log_stream << uma_prefix << ".ReceivedHeightInPixels" << uma_suffix << " " - << height << '\n'; + << *height << '\n'; } if (content_type != VideoContentType::UNSPECIFIED) { @@ -374,12 +382,12 @@ void ReceiveStatisticsProxy::UpdateHistograms() { << " " << key_frames_permille << '\n'; } - int qp = stats.qp_counter.Avg(kMinRequiredSamples); - if (qp != -1) { + rtc::Optional qp = stats.qp_counter.Avg(kMinRequiredSamples); + if (qp) { RTC_HISTOGRAM_COUNTS_SPARSE_200( - uma_prefix + ".Decoded.Vp8.Qp" + uma_suffix, qp); - log_stream << uma_prefix << ".Decoded.Vp8.Qp" << uma_suffix << " " << qp - << '\n'; + uma_prefix + ".Decoded.Vp8.Qp" + uma_suffix, *qp); + log_stream << uma_prefix << ".Decoded.Vp8.Qp" << uma_suffix << " " + << *qp << '\n'; } } } @@ -469,7 +477,7 @@ void ReceiveStatisticsProxy::QualitySample() { double fps = render_fps_tracker_.ComputeRateForInterval(now - last_sample_time_); - int qp = qp_sample_.Avg(1); + rtc::Optional qp = qp_sample_.Avg(1); bool prev_fps_bad = !fps_threshold_.IsHigh().value_or(true); bool prev_qp_bad = qp_threshold_.IsHigh().value_or(false); @@ -477,8 +485,8 @@ void ReceiveStatisticsProxy::QualitySample() { bool prev_any_bad = prev_fps_bad || prev_qp_bad || prev_variance_bad; fps_threshold_.AddMeasurement(static_cast(fps)); - if (qp != -1) - qp_threshold_.AddMeasurement(qp); + if (qp) + qp_threshold_.AddMeasurement(*qp); rtc::Optional fps_variance_opt = fps_threshold_.CalculateVariance(); double fps_variance = fps_variance_opt.value_or(0); if (fps_variance_opt) { @@ -516,7 +524,7 @@ void ReceiveStatisticsProxy::QualitySample() { RTC_LOG(LS_VERBOSE) << "SAMPLE: sample_length: " << (now - last_sample_time_) << " fps: " << fps << " fps_bad: " << fps_bad - << " qp: " << qp << " qp_bad: " << qp_bad + << " qp: " << qp.value_or(-1) << " qp_bad: " << qp_bad << " variance_bad: " << variance_bad << " fps_variance: " << fps_variance; @@ -816,38 +824,6 @@ void ReceiveStatisticsProxy::OnStreamInactive() { last_decoded_frame_time_ms_.reset(); } -void ReceiveStatisticsProxy::SampleCounter::Add(int sample) { - sum += sample; - ++num_samples; - if (!max || sample > *max) { - max.emplace(sample); - } -} - -void ReceiveStatisticsProxy::SampleCounter::Add(const SampleCounter& other) { - sum += other.sum; - num_samples += other.num_samples; - if (other.max && (!max || *max < *other.max)) - max = other.max; -} - -int ReceiveStatisticsProxy::SampleCounter::Avg( - int64_t min_required_samples) const { - if (num_samples < min_required_samples || num_samples == 0) - return -1; - return static_cast(sum / num_samples); -} - -int ReceiveStatisticsProxy::SampleCounter::Max() const { - return max.value_or(-1); -} - -void ReceiveStatisticsProxy::SampleCounter::Reset() { - num_samples = 0; - sum = 0; - max.reset(); -} - void ReceiveStatisticsProxy::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { rtc::CritScope lock(&crit_); diff --git a/video/receive_statistics_proxy.h b/video/receive_statistics_proxy.h index 73768a4609..9a2185e315 100644 --- a/video/receive_statistics_proxy.h +++ b/video/receive_statistics_proxy.h @@ -23,6 +23,7 @@ #include "rtc_base/criticalsection.h" #include "rtc_base/numerics/histogram_percentile_counter.h" #include "rtc_base/numerics/moving_max_counter.h" +#include "rtc_base/numerics/sample_counter.h" #include "rtc_base/rate_statistics.h" #include "rtc_base/ratetracker.h" #include "rtc_base/thread_annotations.h" @@ -103,22 +104,8 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback, void DecoderThreadStopped(); private: - struct SampleCounter { - SampleCounter() : sum(0), num_samples(0) {} - void Add(int sample); - int Avg(int64_t min_required_samples) const; - int Max() const; - void Reset(); - void Add(const SampleCounter& other); - - private: - int64_t sum; - int64_t num_samples; - rtc::Optional max; - }; - struct QpCounters { - SampleCounter vp8; + rtc::SampleCounter vp8; }; struct ContentSpecificStats { @@ -126,13 +113,13 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback, void Add(const ContentSpecificStats& other); - SampleCounter e2e_delay_counter; - SampleCounter interframe_delay_counter; + rtc::SampleCounter e2e_delay_counter; + rtc::SampleCounter interframe_delay_counter; int64_t flow_duration_ms = 0; int64_t total_media_bytes = 0; - SampleCounter received_width; - SampleCounter received_height; - SampleCounter qp_counter; + rtc::SampleCounter received_width; + rtc::SampleCounter received_height; + rtc::SampleCounter qp_counter; FrameCounts frame_counts; rtc::HistogramPercentileCounter interframe_delay_percentiles; }; @@ -161,7 +148,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback, QualityThreshold fps_threshold_ RTC_GUARDED_BY(crit_); QualityThreshold qp_threshold_ RTC_GUARDED_BY(crit_); QualityThreshold variance_threshold_ RTC_GUARDED_BY(crit_); - SampleCounter qp_sample_ RTC_GUARDED_BY(crit_); + rtc::SampleCounter qp_sample_ RTC_GUARDED_BY(crit_); int num_bad_states_ RTC_GUARDED_BY(crit_); int num_certain_states_ RTC_GUARDED_BY(crit_); mutable VideoReceiveStream::Stats stats_ RTC_GUARDED_BY(crit_); @@ -170,12 +157,12 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback, rtc::RateTracker render_fps_tracker_ RTC_GUARDED_BY(crit_); rtc::RateTracker render_pixel_tracker_ RTC_GUARDED_BY(crit_); rtc::RateTracker total_byte_tracker_ RTC_GUARDED_BY(crit_); - SampleCounter sync_offset_counter_ RTC_GUARDED_BY(crit_); - SampleCounter decode_time_counter_ RTC_GUARDED_BY(crit_); - SampleCounter jitter_buffer_delay_counter_ RTC_GUARDED_BY(crit_); - SampleCounter target_delay_counter_ RTC_GUARDED_BY(crit_); - SampleCounter current_delay_counter_ RTC_GUARDED_BY(crit_); - SampleCounter delay_counter_ RTC_GUARDED_BY(crit_); + rtc::SampleCounter sync_offset_counter_ RTC_GUARDED_BY(crit_); + rtc::SampleCounter decode_time_counter_ RTC_GUARDED_BY(crit_); + rtc::SampleCounter jitter_buffer_delay_counter_ RTC_GUARDED_BY(crit_); + rtc::SampleCounter target_delay_counter_ RTC_GUARDED_BY(crit_); + rtc::SampleCounter current_delay_counter_ RTC_GUARDED_BY(crit_); + rtc::SampleCounter delay_counter_ RTC_GUARDED_BY(crit_); mutable rtc::MovingMaxCounter interframe_delay_max_moving_ RTC_GUARDED_BY(crit_); std::map content_specific_stats_