OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include "webrtc/modules/audio_coding/neteq/statistics_calculator.h" | 11 #include "webrtc/modules/audio_coding/neteq/statistics_calculator.h" |
12 | 12 |
13 #include <assert.h> | 13 #include <assert.h> |
14 #include <string.h> // memset | 14 #include <string.h> // memset |
15 | 15 |
16 #include "webrtc/base/checks.h" | 16 #include "webrtc/base/checks.h" |
| 17 #include "webrtc/base/safe_conversions.h" |
17 #include "webrtc/modules/audio_coding/neteq/decision_logic.h" | 18 #include "webrtc/modules/audio_coding/neteq/decision_logic.h" |
18 #include "webrtc/modules/audio_coding/neteq/delay_manager.h" | 19 #include "webrtc/modules/audio_coding/neteq/delay_manager.h" |
19 #include "webrtc/system_wrappers/interface/metrics.h" | 20 #include "webrtc/system_wrappers/interface/metrics.h" |
20 | 21 |
21 namespace webrtc { | 22 namespace webrtc { |
22 | 23 |
23 StatisticsCalculator::PeriodicUmaLogger::PeriodicUmaLogger( | 24 StatisticsCalculator::PeriodicUmaLogger::PeriodicUmaLogger( |
24 const std::string& uma_name, | 25 const std::string& uma_name, |
25 int report_interval_ms, | 26 int report_interval_ms, |
26 int max_value) | 27 int max_value) |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
133 lost_timestamps_ = 0; | 134 lost_timestamps_ = 0; |
134 timestamps_since_last_report_ = 0; | 135 timestamps_since_last_report_ = 0; |
135 } | 136 } |
136 | 137 |
137 void StatisticsCalculator::ResetWaitingTimeStatistics() { | 138 void StatisticsCalculator::ResetWaitingTimeStatistics() { |
138 memset(waiting_times_, 0, kLenWaitingTimes * sizeof(waiting_times_[0])); | 139 memset(waiting_times_, 0, kLenWaitingTimes * sizeof(waiting_times_[0])); |
139 len_waiting_times_ = 0; | 140 len_waiting_times_ = 0; |
140 next_waiting_time_index_ = 0; | 141 next_waiting_time_index_ = 0; |
141 } | 142 } |
142 | 143 |
143 void StatisticsCalculator::ExpandedVoiceSamples(int num_samples) { | 144 void StatisticsCalculator::ExpandedVoiceSamples(size_t num_samples) { |
144 expanded_speech_samples_ += num_samples; | 145 expanded_speech_samples_ += num_samples; |
145 } | 146 } |
146 | 147 |
147 void StatisticsCalculator::ExpandedNoiseSamples(int num_samples) { | 148 void StatisticsCalculator::ExpandedNoiseSamples(size_t num_samples) { |
148 expanded_noise_samples_ += num_samples; | 149 expanded_noise_samples_ += num_samples; |
149 } | 150 } |
150 | 151 |
151 void StatisticsCalculator::PreemptiveExpandedSamples(int num_samples) { | 152 void StatisticsCalculator::PreemptiveExpandedSamples(size_t num_samples) { |
152 preemptive_samples_ += num_samples; | 153 preemptive_samples_ += num_samples; |
153 } | 154 } |
154 | 155 |
155 void StatisticsCalculator::AcceleratedSamples(int num_samples) { | 156 void StatisticsCalculator::AcceleratedSamples(size_t num_samples) { |
156 accelerate_samples_ += num_samples; | 157 accelerate_samples_ += num_samples; |
157 } | 158 } |
158 | 159 |
159 void StatisticsCalculator::AddZeros(int num_samples) { | 160 void StatisticsCalculator::AddZeros(size_t num_samples) { |
160 added_zero_samples_ += num_samples; | 161 added_zero_samples_ += num_samples; |
161 } | 162 } |
162 | 163 |
163 void StatisticsCalculator::PacketsDiscarded(int num_packets) { | 164 void StatisticsCalculator::PacketsDiscarded(size_t num_packets) { |
164 discarded_packets_ += num_packets; | 165 discarded_packets_ += num_packets; |
165 } | 166 } |
166 | 167 |
167 void StatisticsCalculator::LostSamples(int num_samples) { | 168 void StatisticsCalculator::LostSamples(size_t num_samples) { |
168 lost_timestamps_ += num_samples; | 169 lost_timestamps_ += num_samples; |
169 } | 170 } |
170 | 171 |
171 void StatisticsCalculator::IncreaseCounter(int num_samples, int fs_hz) { | 172 void StatisticsCalculator::IncreaseCounter(size_t num_samples, int fs_hz) { |
172 const int time_step_ms = rtc::CheckedDivExact(1000 * num_samples, fs_hz); | 173 const int time_step_ms = |
| 174 rtc::CheckedDivExact(static_cast<int>(1000 * num_samples), fs_hz); |
173 delayed_packet_outage_counter_.AdvanceClock(time_step_ms); | 175 delayed_packet_outage_counter_.AdvanceClock(time_step_ms); |
174 excess_buffer_delay_.AdvanceClock(time_step_ms); | 176 excess_buffer_delay_.AdvanceClock(time_step_ms); |
175 timestamps_since_last_report_ += static_cast<uint32_t>(num_samples); | 177 timestamps_since_last_report_ += static_cast<uint32_t>(num_samples); |
176 if (timestamps_since_last_report_ > | 178 if (timestamps_since_last_report_ > |
177 static_cast<uint32_t>(fs_hz * kMaxReportPeriod)) { | 179 static_cast<uint32_t>(fs_hz * kMaxReportPeriod)) { |
178 lost_timestamps_ = 0; | 180 lost_timestamps_ = 0; |
179 timestamps_since_last_report_ = 0; | 181 timestamps_since_last_report_ = 0; |
180 discarded_packets_ = 0; | 182 discarded_packets_ = 0; |
181 } | 183 } |
182 } | 184 } |
(...skipping 17 matching lines...) Expand all Loading... |
200 if (next_waiting_time_index_ >= kLenWaitingTimes) { | 202 if (next_waiting_time_index_ >= kLenWaitingTimes) { |
201 next_waiting_time_index_ = 0; | 203 next_waiting_time_index_ = 0; |
202 } | 204 } |
203 if (len_waiting_times_ < kLenWaitingTimes) { | 205 if (len_waiting_times_ < kLenWaitingTimes) { |
204 len_waiting_times_++; | 206 len_waiting_times_++; |
205 } | 207 } |
206 } | 208 } |
207 | 209 |
208 void StatisticsCalculator::GetNetworkStatistics( | 210 void StatisticsCalculator::GetNetworkStatistics( |
209 int fs_hz, | 211 int fs_hz, |
210 int num_samples_in_buffers, | 212 size_t num_samples_in_buffers, |
211 int samples_per_packet, | 213 size_t samples_per_packet, |
212 const DelayManager& delay_manager, | 214 const DelayManager& delay_manager, |
213 const DecisionLogic& decision_logic, | 215 const DecisionLogic& decision_logic, |
214 NetEqNetworkStatistics *stats) { | 216 NetEqNetworkStatistics *stats) { |
215 if (fs_hz <= 0 || !stats) { | 217 if (fs_hz <= 0 || !stats) { |
216 assert(false); | 218 assert(false); |
217 return; | 219 return; |
218 } | 220 } |
219 | 221 |
220 stats->added_zero_samples = added_zero_samples_; | 222 stats->added_zero_samples = added_zero_samples_; |
221 stats->current_buffer_size_ms = | 223 stats->current_buffer_size_ms = |
222 static_cast<uint16_t>(num_samples_in_buffers * 1000 / fs_hz); | 224 static_cast<uint16_t>(num_samples_in_buffers * 1000 / fs_hz); |
223 const int ms_per_packet = decision_logic.packet_length_samples() / | 225 const int ms_per_packet = rtc::checked_cast<int>( |
224 (fs_hz / 1000); | 226 decision_logic.packet_length_samples() / (fs_hz / 1000)); |
225 stats->preferred_buffer_size_ms = (delay_manager.TargetLevel() >> 8) * | 227 stats->preferred_buffer_size_ms = (delay_manager.TargetLevel() >> 8) * |
226 ms_per_packet; | 228 ms_per_packet; |
227 stats->jitter_peaks_found = delay_manager.PeakFound(); | 229 stats->jitter_peaks_found = delay_manager.PeakFound(); |
228 stats->clockdrift_ppm = delay_manager.AverageIAT(); | 230 stats->clockdrift_ppm = delay_manager.AverageIAT(); |
229 | 231 |
230 stats->packet_loss_rate = | 232 stats->packet_loss_rate = |
231 CalculateQ14Ratio(lost_timestamps_, timestamps_since_last_report_); | 233 CalculateQ14Ratio(lost_timestamps_, timestamps_since_last_report_); |
232 | 234 |
233 const unsigned discarded_samples = discarded_packets_ * samples_per_packet; | 235 const size_t discarded_samples = discarded_packets_ * samples_per_packet; |
234 stats->packet_discard_rate = | 236 stats->packet_discard_rate = |
235 CalculateQ14Ratio(discarded_samples, timestamps_since_last_report_); | 237 CalculateQ14Ratio(discarded_samples, timestamps_since_last_report_); |
236 | 238 |
237 stats->accelerate_rate = | 239 stats->accelerate_rate = |
238 CalculateQ14Ratio(accelerate_samples_, timestamps_since_last_report_); | 240 CalculateQ14Ratio(accelerate_samples_, timestamps_since_last_report_); |
239 | 241 |
240 stats->preemptive_rate = | 242 stats->preemptive_rate = |
241 CalculateQ14Ratio(preemptive_samples_, timestamps_since_last_report_); | 243 CalculateQ14Ratio(preemptive_samples_, timestamps_since_last_report_); |
242 | 244 |
243 stats->expand_rate = | 245 stats->expand_rate = |
(...skipping 14 matching lines...) Expand all Loading... |
258 } | 260 } |
259 | 261 |
260 void StatisticsCalculator::WaitingTimes(std::vector<int>* waiting_times) { | 262 void StatisticsCalculator::WaitingTimes(std::vector<int>* waiting_times) { |
261 if (!waiting_times) { | 263 if (!waiting_times) { |
262 return; | 264 return; |
263 } | 265 } |
264 waiting_times->assign(waiting_times_, waiting_times_ + len_waiting_times_); | 266 waiting_times->assign(waiting_times_, waiting_times_ + len_waiting_times_); |
265 ResetWaitingTimeStatistics(); | 267 ResetWaitingTimeStatistics(); |
266 } | 268 } |
267 | 269 |
268 uint16_t StatisticsCalculator::CalculateQ14Ratio(uint32_t numerator, | 270 uint16_t StatisticsCalculator::CalculateQ14Ratio(size_t numerator, |
269 uint32_t denominator) { | 271 uint32_t denominator) { |
270 if (numerator == 0) { | 272 if (numerator == 0) { |
271 return 0; | 273 return 0; |
272 } else if (numerator < denominator) { | 274 } else if (numerator < denominator) { |
273 // Ratio must be smaller than 1 in Q14. | 275 // Ratio must be smaller than 1 in Q14. |
274 assert((numerator << 14) / denominator < (1 << 14)); | 276 assert((numerator << 14) / denominator < (1 << 14)); |
275 return static_cast<uint16_t>((numerator << 14) / denominator); | 277 return static_cast<uint16_t>((numerator << 14) / denominator); |
276 } else { | 278 } else { |
277 // Will not produce a ratio larger than 1, since this is probably an error. | 279 // Will not produce a ratio larger than 1, since this is probably an error. |
278 return 1 << 14; | 280 return 1 << 14; |
279 } | 281 } |
280 } | 282 } |
281 | 283 |
282 } // namespace webrtc | 284 } // namespace webrtc |
OLD | NEW |