1 /*
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/audio_coding/neteq/statistics_calculator.h"
12
13 #include <string.h> // memset
14
15 #include <algorithm>
16
17 #include "absl/strings/string_view.h"
18 #include "modules/audio_coding/neteq/delay_manager.h"
19 #include "rtc_base/checks.h"
20 #include "rtc_base/numerics/safe_conversions.h"
21 #include "system_wrappers/include/metrics.h"
22
23 namespace webrtc {
24
25 namespace {
AddIntToSizeTWithLowerCap(int a,size_t b)26 size_t AddIntToSizeTWithLowerCap(int a, size_t b) {
27 const size_t ret = b + a;
28 // If a + b is negative, resulting in a negative wrap, cap it to zero instead.
29 static_assert(sizeof(size_t) >= sizeof(int),
30 "int must not be wider than size_t for this to work");
31 return (a < 0 && ret > b) ? 0 : ret;
32 }
33
34 constexpr int kInterruptionLenMs = 150;
35 } // namespace
36
37 // Allocating the static const so that it can be passed by reference to
38 // RTC_DCHECK.
39 const size_t StatisticsCalculator::kLenWaitingTimes;
40
PeriodicUmaLogger(absl::string_view uma_name,int report_interval_ms,int max_value)41 StatisticsCalculator::PeriodicUmaLogger::PeriodicUmaLogger(
42 absl::string_view uma_name,
43 int report_interval_ms,
44 int max_value)
45 : uma_name_(uma_name),
46 report_interval_ms_(report_interval_ms),
47 max_value_(max_value),
48 timer_(0) {}
49
50 StatisticsCalculator::PeriodicUmaLogger::~PeriodicUmaLogger() = default;
51
AdvanceClock(int step_ms)52 void StatisticsCalculator::PeriodicUmaLogger::AdvanceClock(int step_ms) {
53 timer_ += step_ms;
54 if (timer_ < report_interval_ms_) {
55 return;
56 }
57 LogToUma(Metric());
58 Reset();
59 timer_ -= report_interval_ms_;
60 RTC_DCHECK_GE(timer_, 0);
61 }
62
LogToUma(int value) const63 void StatisticsCalculator::PeriodicUmaLogger::LogToUma(int value) const {
64 RTC_HISTOGRAM_COUNTS_SPARSE(uma_name_, value, 1, max_value_, 50);
65 }
66
PeriodicUmaCount(absl::string_view uma_name,int report_interval_ms,int max_value)67 StatisticsCalculator::PeriodicUmaCount::PeriodicUmaCount(
68 absl::string_view uma_name,
69 int report_interval_ms,
70 int max_value)
71 : PeriodicUmaLogger(uma_name, report_interval_ms, max_value) {}
72
~PeriodicUmaCount()73 StatisticsCalculator::PeriodicUmaCount::~PeriodicUmaCount() {
74 // Log the count for the current (incomplete) interval.
75 LogToUma(Metric());
76 }
77
RegisterSample()78 void StatisticsCalculator::PeriodicUmaCount::RegisterSample() {
79 ++counter_;
80 }
81
Metric() const82 int StatisticsCalculator::PeriodicUmaCount::Metric() const {
83 return counter_;
84 }
85
Reset()86 void StatisticsCalculator::PeriodicUmaCount::Reset() {
87 counter_ = 0;
88 }
89
PeriodicUmaAverage(absl::string_view uma_name,int report_interval_ms,int max_value)90 StatisticsCalculator::PeriodicUmaAverage::PeriodicUmaAverage(
91 absl::string_view uma_name,
92 int report_interval_ms,
93 int max_value)
94 : PeriodicUmaLogger(uma_name, report_interval_ms, max_value) {}
95
~PeriodicUmaAverage()96 StatisticsCalculator::PeriodicUmaAverage::~PeriodicUmaAverage() {
97 // Log the average for the current (incomplete) interval.
98 LogToUma(Metric());
99 }
100
RegisterSample(int value)101 void StatisticsCalculator::PeriodicUmaAverage::RegisterSample(int value) {
102 sum_ += value;
103 ++counter_;
104 }
105
Metric() const106 int StatisticsCalculator::PeriodicUmaAverage::Metric() const {
107 return counter_ == 0 ? 0 : static_cast<int>(sum_ / counter_);
108 }
109
Reset()110 void StatisticsCalculator::PeriodicUmaAverage::Reset() {
111 sum_ = 0.0;
112 counter_ = 0;
113 }
114
StatisticsCalculator()115 StatisticsCalculator::StatisticsCalculator()
116 : preemptive_samples_(0),
117 accelerate_samples_(0),
118 expanded_speech_samples_(0),
119 expanded_noise_samples_(0),
120 timestamps_since_last_report_(0),
121 secondary_decoded_samples_(0),
122 discarded_secondary_packets_(0),
123 delayed_packet_outage_counter_(
124 "WebRTC.Audio.DelayedPacketOutageEventsPerMinute",
125 60000, // 60 seconds report interval.
126 100),
127 excess_buffer_delay_("WebRTC.Audio.AverageExcessBufferDelayMs",
128 60000, // 60 seconds report interval.
129 1000),
130 buffer_full_counter_("WebRTC.Audio.JitterBufferFullPerMinute",
131 60000, // 60 seconds report interval.
132 100) {}
133
134 StatisticsCalculator::~StatisticsCalculator() = default;
135
Reset()136 void StatisticsCalculator::Reset() {
137 preemptive_samples_ = 0;
138 accelerate_samples_ = 0;
139 expanded_speech_samples_ = 0;
140 expanded_noise_samples_ = 0;
141 secondary_decoded_samples_ = 0;
142 discarded_secondary_packets_ = 0;
143 waiting_times_.clear();
144 }
145
ResetMcu()146 void StatisticsCalculator::ResetMcu() {
147 timestamps_since_last_report_ = 0;
148 }
149
ExpandedVoiceSamples(size_t num_samples,bool is_new_concealment_event)150 void StatisticsCalculator::ExpandedVoiceSamples(size_t num_samples,
151 bool is_new_concealment_event) {
152 expanded_speech_samples_ += num_samples;
153 ConcealedSamplesCorrection(rtc::dchecked_cast<int>(num_samples), true);
154 lifetime_stats_.concealment_events += is_new_concealment_event;
155 }
156
ExpandedNoiseSamples(size_t num_samples,bool is_new_concealment_event)157 void StatisticsCalculator::ExpandedNoiseSamples(size_t num_samples,
158 bool is_new_concealment_event) {
159 expanded_noise_samples_ += num_samples;
160 ConcealedSamplesCorrection(rtc::dchecked_cast<int>(num_samples), false);
161 lifetime_stats_.concealment_events += is_new_concealment_event;
162 }
163
ExpandedVoiceSamplesCorrection(int num_samples)164 void StatisticsCalculator::ExpandedVoiceSamplesCorrection(int num_samples) {
165 expanded_speech_samples_ =
166 AddIntToSizeTWithLowerCap(num_samples, expanded_speech_samples_);
167 ConcealedSamplesCorrection(num_samples, true);
168 }
169
ExpandedNoiseSamplesCorrection(int num_samples)170 void StatisticsCalculator::ExpandedNoiseSamplesCorrection(int num_samples) {
171 expanded_noise_samples_ =
172 AddIntToSizeTWithLowerCap(num_samples, expanded_noise_samples_);
173 ConcealedSamplesCorrection(num_samples, false);
174 }
175
DecodedOutputPlayed()176 void StatisticsCalculator::DecodedOutputPlayed() {
177 decoded_output_played_ = true;
178 }
179
EndExpandEvent(int fs_hz)180 void StatisticsCalculator::EndExpandEvent(int fs_hz) {
181 RTC_DCHECK_GE(lifetime_stats_.concealed_samples,
182 concealed_samples_at_event_end_);
183 const int event_duration_ms =
184 1000 *
185 (lifetime_stats_.concealed_samples - concealed_samples_at_event_end_) /
186 fs_hz;
187 if (event_duration_ms >= kInterruptionLenMs && decoded_output_played_) {
188 lifetime_stats_.interruption_count++;
189 lifetime_stats_.total_interruption_duration_ms += event_duration_ms;
190 RTC_HISTOGRAM_COUNTS("WebRTC.Audio.AudioInterruptionMs", event_duration_ms,
191 /*min=*/150, /*max=*/5000, /*bucket_count=*/50);
192 }
193 concealed_samples_at_event_end_ = lifetime_stats_.concealed_samples;
194 }
195
ConcealedSamplesCorrection(int num_samples,bool is_voice)196 void StatisticsCalculator::ConcealedSamplesCorrection(int num_samples,
197 bool is_voice) {
198 if (num_samples < 0) {
199 // Store negative correction to subtract from future positive additions.
200 // See also the function comment in the header file.
201 concealed_samples_correction_ -= num_samples;
202 if (!is_voice) {
203 silent_concealed_samples_correction_ -= num_samples;
204 }
205 return;
206 }
207
208 const size_t canceled_out =
209 std::min(static_cast<size_t>(num_samples), concealed_samples_correction_);
210 concealed_samples_correction_ -= canceled_out;
211 lifetime_stats_.concealed_samples += num_samples - canceled_out;
212
213 if (!is_voice) {
214 const size_t silent_canceled_out = std::min(
215 static_cast<size_t>(num_samples), silent_concealed_samples_correction_);
216 silent_concealed_samples_correction_ -= silent_canceled_out;
217 lifetime_stats_.silent_concealed_samples +=
218 num_samples - silent_canceled_out;
219 }
220 }
221
PreemptiveExpandedSamples(size_t num_samples)222 void StatisticsCalculator::PreemptiveExpandedSamples(size_t num_samples) {
223 preemptive_samples_ += num_samples;
224 operations_and_state_.preemptive_samples += num_samples;
225 lifetime_stats_.inserted_samples_for_deceleration += num_samples;
226 }
227
AcceleratedSamples(size_t num_samples)228 void StatisticsCalculator::AcceleratedSamples(size_t num_samples) {
229 accelerate_samples_ += num_samples;
230 operations_and_state_.accelerate_samples += num_samples;
231 lifetime_stats_.removed_samples_for_acceleration += num_samples;
232 }
233
GeneratedNoiseSamples(size_t num_samples)234 void StatisticsCalculator::GeneratedNoiseSamples(size_t num_samples) {
235 lifetime_stats_.generated_noise_samples += num_samples;
236 }
237
PacketsDiscarded(size_t num_packets)238 void StatisticsCalculator::PacketsDiscarded(size_t num_packets) {
239 lifetime_stats_.packets_discarded += num_packets;
240 }
241
SecondaryPacketsDiscarded(size_t num_packets)242 void StatisticsCalculator::SecondaryPacketsDiscarded(size_t num_packets) {
243 discarded_secondary_packets_ += num_packets;
244 lifetime_stats_.fec_packets_discarded += num_packets;
245 }
246
SecondaryPacketsReceived(size_t num_packets)247 void StatisticsCalculator::SecondaryPacketsReceived(size_t num_packets) {
248 lifetime_stats_.fec_packets_received += num_packets;
249 }
250
IncreaseCounter(size_t num_samples,int fs_hz)251 void StatisticsCalculator::IncreaseCounter(size_t num_samples, int fs_hz) {
252 const int time_step_ms =
253 rtc::CheckedDivExact(static_cast<int>(1000 * num_samples), fs_hz);
254 delayed_packet_outage_counter_.AdvanceClock(time_step_ms);
255 excess_buffer_delay_.AdvanceClock(time_step_ms);
256 buffer_full_counter_.AdvanceClock(time_step_ms);
257 timestamps_since_last_report_ += static_cast<uint32_t>(num_samples);
258 if (timestamps_since_last_report_ >
259 static_cast<uint32_t>(fs_hz * kMaxReportPeriod)) {
260 timestamps_since_last_report_ = 0;
261 }
262 lifetime_stats_.total_samples_received += num_samples;
263 }
264
JitterBufferDelay(size_t num_samples,uint64_t waiting_time_ms,uint64_t target_delay_ms,uint64_t unlimited_target_delay_ms)265 void StatisticsCalculator::JitterBufferDelay(
266 size_t num_samples,
267 uint64_t waiting_time_ms,
268 uint64_t target_delay_ms,
269 uint64_t unlimited_target_delay_ms) {
270 lifetime_stats_.jitter_buffer_delay_ms += waiting_time_ms * num_samples;
271 lifetime_stats_.jitter_buffer_target_delay_ms +=
272 target_delay_ms * num_samples;
273 lifetime_stats_.jitter_buffer_minimum_delay_ms +=
274 unlimited_target_delay_ms * num_samples;
275 lifetime_stats_.jitter_buffer_emitted_count += num_samples;
276 }
277
SecondaryDecodedSamples(int num_samples)278 void StatisticsCalculator::SecondaryDecodedSamples(int num_samples) {
279 secondary_decoded_samples_ += num_samples;
280 }
281
FlushedPacketBuffer()282 void StatisticsCalculator::FlushedPacketBuffer() {
283 operations_and_state_.packet_buffer_flushes++;
284 buffer_full_counter_.RegisterSample();
285 }
286
ReceivedPacket()287 void StatisticsCalculator::ReceivedPacket() {
288 ++lifetime_stats_.jitter_buffer_packets_received;
289 }
290
RelativePacketArrivalDelay(size_t delay_ms)291 void StatisticsCalculator::RelativePacketArrivalDelay(size_t delay_ms) {
292 lifetime_stats_.relative_packet_arrival_delay_ms += delay_ms;
293 }
294
LogDelayedPacketOutageEvent(int num_samples,int fs_hz)295 void StatisticsCalculator::LogDelayedPacketOutageEvent(int num_samples,
296 int fs_hz) {
297 int outage_duration_ms = num_samples / (fs_hz / 1000);
298 RTC_HISTOGRAM_COUNTS("WebRTC.Audio.DelayedPacketOutageEventMs",
299 outage_duration_ms, 1 /* min */, 2000 /* max */,
300 100 /* bucket count */);
301 delayed_packet_outage_counter_.RegisterSample();
302 lifetime_stats_.delayed_packet_outage_samples += num_samples;
303 }
304
StoreWaitingTime(int waiting_time_ms)305 void StatisticsCalculator::StoreWaitingTime(int waiting_time_ms) {
306 excess_buffer_delay_.RegisterSample(waiting_time_ms);
307 RTC_DCHECK_LE(waiting_times_.size(), kLenWaitingTimes);
308 if (waiting_times_.size() == kLenWaitingTimes) {
309 // Erase first value.
310 waiting_times_.pop_front();
311 }
312 waiting_times_.push_back(waiting_time_ms);
313 operations_and_state_.last_waiting_time_ms = waiting_time_ms;
314 }
315
GetNetworkStatistics(size_t samples_per_packet,NetEqNetworkStatistics * stats)316 void StatisticsCalculator::GetNetworkStatistics(size_t samples_per_packet,
317 NetEqNetworkStatistics* stats) {
318 RTC_DCHECK(stats);
319
320 stats->accelerate_rate =
321 CalculateQ14Ratio(accelerate_samples_, timestamps_since_last_report_);
322
323 stats->preemptive_rate =
324 CalculateQ14Ratio(preemptive_samples_, timestamps_since_last_report_);
325
326 stats->expand_rate =
327 CalculateQ14Ratio(expanded_speech_samples_ + expanded_noise_samples_,
328 timestamps_since_last_report_);
329
330 stats->speech_expand_rate = CalculateQ14Ratio(expanded_speech_samples_,
331 timestamps_since_last_report_);
332
333 stats->secondary_decoded_rate = CalculateQ14Ratio(
334 secondary_decoded_samples_, timestamps_since_last_report_);
335
336 const size_t discarded_secondary_samples =
337 discarded_secondary_packets_ * samples_per_packet;
338 stats->secondary_discarded_rate =
339 CalculateQ14Ratio(discarded_secondary_samples,
340 static_cast<uint32_t>(discarded_secondary_samples +
341 secondary_decoded_samples_));
342
343 if (waiting_times_.size() == 0) {
344 stats->mean_waiting_time_ms = -1;
345 stats->median_waiting_time_ms = -1;
346 stats->min_waiting_time_ms = -1;
347 stats->max_waiting_time_ms = -1;
348 } else {
349 std::sort(waiting_times_.begin(), waiting_times_.end());
350 // Find mid-point elements. If the size is odd, the two values
351 // `middle_left` and `middle_right` will both be the one middle element; if
352 // the size is even, they will be the the two neighboring elements at the
353 // middle of the list.
354 const int middle_left = waiting_times_[(waiting_times_.size() - 1) / 2];
355 const int middle_right = waiting_times_[waiting_times_.size() / 2];
356 // Calculate the average of the two. (Works also for odd sizes.)
357 stats->median_waiting_time_ms = (middle_left + middle_right) / 2;
358 stats->min_waiting_time_ms = waiting_times_.front();
359 stats->max_waiting_time_ms = waiting_times_.back();
360 double sum = 0;
361 for (auto time : waiting_times_) {
362 sum += time;
363 }
364 stats->mean_waiting_time_ms = static_cast<int>(sum / waiting_times_.size());
365 }
366
367 // Reset counters.
368 ResetMcu();
369 Reset();
370 }
371
GetLifetimeStatistics() const372 NetEqLifetimeStatistics StatisticsCalculator::GetLifetimeStatistics() const {
373 return lifetime_stats_;
374 }
375
GetOperationsAndState() const376 NetEqOperationsAndState StatisticsCalculator::GetOperationsAndState() const {
377 return operations_and_state_;
378 }
379
CalculateQ14Ratio(size_t numerator,uint32_t denominator)380 uint16_t StatisticsCalculator::CalculateQ14Ratio(size_t numerator,
381 uint32_t denominator) {
382 if (numerator == 0) {
383 return 0;
384 } else if (numerator < denominator) {
385 // Ratio must be smaller than 1 in Q14.
386 RTC_DCHECK_LT((numerator << 14) / denominator, (1 << 14));
387 return static_cast<uint16_t>((numerator << 14) / denominator);
388 } else {
389 // Will not produce a ratio larger than 1, since this is probably an error.
390 return 1 << 14;
391 }
392 }
393
394 } // namespace webrtc
395