blob: 3214ce6f7bd77f78f0dd56b47f55e61e9e397b4d [file] [log] [blame]
turaj@webrtc.org7959e162013-09-12 18:30:261/*
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
Mirko Bonadei92ea95e2017-09-15 04:47:3111#include "modules/audio_coding/acm2/acm_receiver.h"
turaj@webrtc.org7959e162013-09-12 18:30:2612
Yves Gerey988cc082018-10-23 10:03:0113#include <stdlib.h>
14#include <string.h>
Jonas Olssona4d87372019-07-05 17:08:3315
Yves Gerey988cc082018-10-23 10:03:0116#include <cstdint>
turaj@webrtc.org7959e162013-09-12 18:30:2617#include <vector>
18
Niels Möller2edab4c2018-10-22 07:48:0819#include "absl/strings/match.h"
Yves Gerey988cc082018-10-23 10:03:0120#include "api/audio/audio_frame.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3121#include "api/audio_codecs/audio_decoder.h"
Ivo Creusen3ce44a32019-10-31 13:38:1122#include "api/neteq/neteq.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3123#include "modules/audio_coding/acm2/acm_resampler.h"
24#include "modules/audio_coding/acm2/call_statistics.h"
Ivo Creusen68c65722019-11-26 11:29:0525#include "modules/audio_coding/neteq/default_neteq_factory.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3126#include "rtc_base/checks.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3127#include "rtc_base/logging.h"
Karl Wiberge40468b2017-11-22 09:42:2628#include "rtc_base/numerics/safe_conversions.h"
Jonas Olssonabbe8412018-04-03 11:40:0529#include "rtc_base/strings/audio_format_to_string.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3130#include "system_wrappers/include/clock.h"
turaj@webrtc.org7959e162013-09-12 18:30:2631
32namespace webrtc {
33
turaj@webrtc.org6d5d2482013-10-06 04:47:2834namespace acm2 {
35
Ivo Creusen3ce44a32019-10-31 13:38:1136namespace {
37
38std::unique_ptr<NetEq> CreateNetEq(
Ivo Creusenc3d1f9b2019-11-01 10:47:5139 NetEqFactory* neteq_factory,
Ivo Creusen3ce44a32019-10-31 13:38:1140 const NetEq::Config& config,
41 Clock* clock,
42 const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory) {
Ivo Creusenc3d1f9b2019-11-01 10:47:5143 if (neteq_factory) {
Ivo Creusen68c65722019-11-26 11:29:0544 return neteq_factory->CreateNetEq(config, decoder_factory, clock);
Ivo Creusenc3d1f9b2019-11-01 10:47:5145 }
Ivo Creusen68c65722019-11-26 11:29:0546 return DefaultNetEqFactory().CreateNetEq(config, decoder_factory, clock);
Ivo Creusen3ce44a32019-10-31 13:38:1147}
48
49} // namespace
50
henrik.lundin@webrtc.org0bc9b5a2014-04-29 08:09:3151AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config)
kwiberg6f0f6162016-09-20 10:07:4652 : last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
Ivo Creusenc3d1f9b2019-11-01 10:47:5153 neteq_(CreateNetEq(config.neteq_factory,
54 config.neteq_config,
Ivo Creusen3ce44a32019-10-31 13:38:1155 config.clock,
56 config.decoder_factory)),
henrik.lundin@webrtc.org0bc9b5a2014-04-29 08:09:3157 clock_(config.clock),
henrik.lundin678c9032015-11-02 16:31:2358 resampled_last_output_frame_(true) {
Henrik Lundin02ed2012017-06-08 07:03:5559 RTC_DCHECK(clock_);
Henrik Lundin76c10672018-05-07 11:47:2860 memset(last_audio_buffer_.get(), 0,
61 sizeof(int16_t) * AudioFrame::kMaxDataSizeSamples);
turaj@webrtc.org7959e162013-09-12 18:30:2662}
63
Henrik Lundin6af93992017-06-14 12:13:0264AcmReceiver::~AcmReceiver() = default;
turaj@webrtc.org7959e162013-09-12 18:30:2665
66int AcmReceiver::SetMinimumDelay(int delay_ms) {
67 if (neteq_->SetMinimumDelay(delay_ms))
68 return 0;
Mirko Bonadei675513b2017-11-09 10:09:2569 RTC_LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms;
turaj@webrtc.org7959e162013-09-12 18:30:2670 return -1;
71}
72
turaj@webrtc.org7959e162013-09-12 18:30:2673int AcmReceiver::SetMaximumDelay(int delay_ms) {
74 if (neteq_->SetMaximumDelay(delay_ms))
75 return 0;
Mirko Bonadei675513b2017-11-09 10:09:2576 RTC_LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms;
turaj@webrtc.org7959e162013-09-12 18:30:2677 return -1;
78}
79
Ruslan Burakov9bee67c2019-02-05 12:49:2680bool AcmReceiver::SetBaseMinimumDelayMs(int delay_ms) {
81 return neteq_->SetBaseMinimumDelayMs(delay_ms);
82}
83
84int AcmReceiver::GetBaseMinimumDelayMs() const {
85 return neteq_->GetBaseMinimumDelayMs();
86}
87
Danil Chapovalovb6021232018-06-19 11:26:3688absl::optional<int> AcmReceiver::last_packet_sample_rate_hz() const {
Markus Handell0df0fae2020-07-07 13:53:3489 MutexLock lock(&mutex_);
Fredrik Solenbergf693bfa2018-12-11 11:22:1090 if (!last_decoder_) {
91 return absl::nullopt;
92 }
Karl Wiberg4b644112019-10-11 07:37:4293 return last_decoder_->sample_rate_hz;
henrik.lundin057fb892015-11-23 16:19:5294}
95
henrik.lundind89814b2015-11-23 14:49:2596int AcmReceiver::last_output_sample_rate_hz() const {
97 return neteq_->last_output_sample_rate_hz();
turaj@webrtc.org7959e162013-09-12 18:30:2698}
99
Niels Möllerafb5dbb2019-02-15 14:21:47100int AcmReceiver::InsertPacket(const RTPHeader& rtp_header,
kwibergee2bac22015-11-11 18:34:00101 rtc::ArrayView<const uint8_t> incoming_payload) {
henrik.lundinb8c55b12017-05-10 14:38:01102 if (incoming_payload.empty()) {
Niels Möllerafb5dbb2019-02-15 14:21:47103 neteq_->InsertEmptyPacket(rtp_header);
henrik.lundinb8c55b12017-05-10 14:38:01104 return 0;
105 }
106
Niels Möllerafb5dbb2019-02-15 14:21:47107 int payload_type = rtp_header.payloadType;
Fredrik Solenbergf693bfa2018-12-11 11:22:10108 auto format = neteq_->GetDecoderFormat(payload_type);
Karl Wiberg4b644112019-10-11 07:37:42109 if (format && absl::EqualsIgnoreCase(format->sdp_format.name, "red")) {
Fredrik Solenbergf693bfa2018-12-11 11:22:10110 // This is a RED packet. Get the format of the audio codec.
111 payload_type = incoming_payload[0] & 0x7f;
112 format = neteq_->GetDecoderFormat(payload_type);
113 }
114 if (!format) {
Jonas Olssona4d87372019-07-05 17:08:33115 RTC_LOG_F(LS_ERROR) << "Payload-type " << payload_type
Fredrik Solenbergf693bfa2018-12-11 11:22:10116 << " is not registered.";
117 return -1;
118 }
119
turaj@webrtc.org7959e162013-09-12 18:30:26120 {
Markus Handell0df0fae2020-07-07 13:53:34121 MutexLock lock(&mutex_);
Karl Wiberg4b644112019-10-11 07:37:42122 if (absl::EqualsIgnoreCase(format->sdp_format.name, "cn")) {
123 if (last_decoder_ && last_decoder_->num_channels > 1) {
kwiberg6f0f6162016-09-20 10:07:46124 // This is a CNG and the audio codec is not mono, so skip pushing in
125 // packets into NetEq.
turaj@webrtc.org7959e162013-09-12 18:30:26126 return 0;
kwiberg6f0f6162016-09-20 10:07:46127 }
128 } else {
Karl Wiberg4b644112019-10-11 07:37:42129 last_decoder_ = DecoderInfo{/*payload_type=*/payload_type,
130 /*sample_rate_hz=*/format->sample_rate_hz,
131 /*num_channels=*/format->num_channels,
132 /*sdp_format=*/std::move(format->sdp_format)};
turaj@webrtc.org7959e162013-09-12 18:30:26133 }
Markus Handell0df0fae2020-07-07 13:53:34134 } // |mutex_| is released.
turaj@webrtc.org7959e162013-09-12 18:30:26135
Karl Wiberg45eb1352019-10-10 12:23:00136 if (neteq_->InsertPacket(rtp_header, incoming_payload) < 0) {
Mirko Bonadei675513b2017-11-09 10:09:25137 RTC_LOG(LERROR) << "AcmReceiver::InsertPacket "
Niels Möllerafb5dbb2019-02-15 14:21:47138 << static_cast<int>(rtp_header.payloadType)
Mirko Bonadei675513b2017-11-09 10:09:25139 << " Failed to insert packet";
henrik.lundin@webrtc.orgeecf5e62014-06-24 13:11:22140 return -1;
turaj@webrtc.org7959e162013-09-12 18:30:26141 }
142 return 0;
143}
144
henrik.lundin834a6ea2016-05-13 10:45:24145int AcmReceiver::GetAudio(int desired_freq_hz,
146 AudioFrame* audio_frame,
147 bool* muted) {
henrik.lundin63489782016-09-20 08:47:12148 RTC_DCHECK(muted);
henrik.lundin@webrtc.org913f7b82014-10-21 06:54:23149
Tommi3cc68ec2021-06-09 17:30:41150 int current_sample_rate_hz = 0;
151 if (neteq_->GetAudio(audio_frame, muted, &current_sample_rate_hz) !=
152 NetEq::kOK) {
Mirko Bonadei675513b2017-11-09 10:09:25153 RTC_LOG(LERROR) << "AcmReceiver::GetAudio - NetEq Failed.";
henrik.lundin@webrtc.orgeecf5e62014-06-24 13:11:22154 return -1;
turaj@webrtc.org7959e162013-09-12 18:30:26155 }
156
Tommi3cc68ec2021-06-09 17:30:41157 RTC_DCHECK_NE(current_sample_rate_hz, 0);
turaj@webrtc.org7959e162013-09-12 18:30:26158
159 // Update if resampling is required.
henrik.lundind89814b2015-11-23 14:49:25160 const bool need_resampling =
161 (desired_freq_hz != -1) && (current_sample_rate_hz != desired_freq_hz);
turaj@webrtc.org7959e162013-09-12 18:30:26162
Tommi3cc68ec2021-06-09 17:30:41163 // Accessing members, take the lock.
164 MutexLock lock(&mutex_);
henrik.lundin@webrtc.org913f7b82014-10-21 06:54:23165 if (need_resampling && !resampled_last_output_frame_) {
166 // Prime the resampler with the last frame.
167 int16_t temp_output[AudioFrame::kMaxDataSizeSamples];
henrik.lundind89814b2015-11-23 14:49:25168 int samples_per_channel_int = resampler_.Resample10Msec(
169 last_audio_buffer_.get(), current_sample_rate_hz, desired_freq_hz,
henrik.lundin6d8e0112016-03-04 18:34:21170 audio_frame->num_channels_, AudioFrame::kMaxDataSizeSamples,
171 temp_output);
Peter Kastingdce40cf2015-08-24 21:52:23172 if (samples_per_channel_int < 0) {
Mirko Bonadei675513b2017-11-09 10:09:25173 RTC_LOG(LERROR) << "AcmReceiver::GetAudio - "
174 "Resampling last_audio_buffer_ failed.";
henrik.lundin@webrtc.org913f7b82014-10-21 06:54:23175 return -1;
turaj@webrtc.org7959e162013-09-12 18:30:26176 }
177 }
178
Tommi3cc68ec2021-06-09 17:30:41179 // TODO(bugs.webrtc.org/3923) Glitches in the output may appear if the output
180 // rate from NetEq changes.
henrik.lundin@webrtc.org913f7b82014-10-21 06:54:23181 if (need_resampling) {
yujo36b1a5f2017-06-12 19:45:32182 // TODO(yujo): handle this more efficiently for muted frames.
henrik.lundind89814b2015-11-23 14:49:25183 int samples_per_channel_int = resampler_.Resample10Msec(
yujo36b1a5f2017-06-12 19:45:32184 audio_frame->data(), current_sample_rate_hz, desired_freq_hz,
henrik.lundin6d8e0112016-03-04 18:34:21185 audio_frame->num_channels_, AudioFrame::kMaxDataSizeSamples,
yujo36b1a5f2017-06-12 19:45:32186 audio_frame->mutable_data());
Peter Kastingdce40cf2015-08-24 21:52:23187 if (samples_per_channel_int < 0) {
Mirko Bonadei675513b2017-11-09 10:09:25188 RTC_LOG(LERROR)
189 << "AcmReceiver::GetAudio - Resampling audio_buffer_ failed.";
henrik.lundin@webrtc.org913f7b82014-10-21 06:54:23190 return -1;
191 }
henrik.lundin6d8e0112016-03-04 18:34:21192 audio_frame->samples_per_channel_ =
193 static_cast<size_t>(samples_per_channel_int);
194 audio_frame->sample_rate_hz_ = desired_freq_hz;
195 RTC_DCHECK_EQ(
196 audio_frame->sample_rate_hz_,
kwibergd3edd772017-03-02 02:52:48197 rtc::dchecked_cast<int>(audio_frame->samples_per_channel_ * 100));
henrik.lundin@webrtc.org913f7b82014-10-21 06:54:23198 resampled_last_output_frame_ = true;
199 } else {
200 resampled_last_output_frame_ = false;
201 // We might end up here ONLY if codec is changed.
henrik.lundin@webrtc.org913f7b82014-10-21 06:54:23202 }
203
henrik.lundin6d8e0112016-03-04 18:34:21204 // Store current audio in |last_audio_buffer_| for next time.
yujo36b1a5f2017-06-12 19:45:32205 memcpy(last_audio_buffer_.get(), audio_frame->data(),
henrik.lundin6d8e0112016-03-04 18:34:21206 sizeof(int16_t) * audio_frame->samples_per_channel_ *
207 audio_frame->num_channels_);
turaj@webrtc.org7959e162013-09-12 18:30:26208
henrik.lundin63489782016-09-20 08:47:12209 call_stats_.DecodedByNetEq(audio_frame->speech_type_, *muted);
turaj@webrtc.org7959e162013-09-12 18:30:26210 return 0;
211}
212
kwiberg1c07c702017-03-27 14:15:49213void AcmReceiver::SetCodecs(const std::map<int, SdpAudioFormat>& codecs) {
214 neteq_->SetCodecs(codecs);
215}
216
turaj@webrtc.org7959e162013-09-12 18:30:26217void AcmReceiver::FlushBuffers() {
218 neteq_->FlushBuffers();
219}
220
kwiberg6b19b562016-09-20 11:02:25221void AcmReceiver::RemoveAllCodecs() {
Markus Handell0df0fae2020-07-07 13:53:34222 MutexLock lock(&mutex_);
kwiberg6b19b562016-09-20 11:02:25223 neteq_->RemoveAllPayloadTypes();
Fredrik Solenbergf693bfa2018-12-11 11:22:10224 last_decoder_ = absl::nullopt;
turaj@webrtc.org7959e162013-09-12 18:30:26225}
226
Danil Chapovalovb6021232018-06-19 11:26:36227absl::optional<uint32_t> AcmReceiver::GetPlayoutTimestamp() {
henrik.lundin9a410dd2016-04-06 08:39:22228 return neteq_->GetPlayoutTimestamp();
turaj@webrtc.org7959e162013-09-12 18:30:26229}
230
henrik.lundinb3f1c5d2016-08-22 22:39:53231int AcmReceiver::FilteredCurrentDelayMs() const {
232 return neteq_->FilteredCurrentDelayMs();
233}
234
Henrik Lundinabbff892017-11-29 08:14:04235int AcmReceiver::TargetDelayMs() const {
236 return neteq_->TargetDelayMs();
237}
238
Jonas Olssona4d87372019-07-05 17:08:33239absl::optional<std::pair<int, SdpAudioFormat>> AcmReceiver::LastDecoder()
240 const {
Markus Handell0df0fae2020-07-07 13:53:34241 MutexLock lock(&mutex_);
Fredrik Solenbergf693bfa2018-12-11 11:22:10242 if (!last_decoder_) {
243 return absl::nullopt;
turaj@webrtc.org7959e162013-09-12 18:30:26244 }
Karl Wiberg4b644112019-10-11 07:37:42245 RTC_DCHECK_NE(-1, last_decoder_->payload_type);
246 return std::make_pair(last_decoder_->payload_type, last_decoder_->sdp_format);
ossue280cde2016-10-12 18:04:10247}
248
Niels Möller6b4d9622020-09-14 08:47:50249void AcmReceiver::GetNetworkStatistics(
250 NetworkStatistics* acm_stat,
251 bool get_and_clear_legacy_stats /* = true */) const {
turaj@webrtc.org7959e162013-09-12 18:30:26252 NetEqNetworkStatistics neteq_stat;
Niels Möller6b4d9622020-09-14 08:47:50253 if (get_and_clear_legacy_stats) {
254 // NetEq function always returns zero, so we don't check the return value.
255 neteq_->NetworkStatistics(&neteq_stat);
turaj@webrtc.org7959e162013-09-12 18:30:26256
Niels Möller6b4d9622020-09-14 08:47:50257 acm_stat->currentExpandRate = neteq_stat.expand_rate;
258 acm_stat->currentSpeechExpandRate = neteq_stat.speech_expand_rate;
259 acm_stat->currentPreemptiveRate = neteq_stat.preemptive_rate;
260 acm_stat->currentAccelerateRate = neteq_stat.accelerate_rate;
261 acm_stat->currentSecondaryDecodedRate = neteq_stat.secondary_decoded_rate;
262 acm_stat->currentSecondaryDiscardedRate =
263 neteq_stat.secondary_discarded_rate;
Niels Möller6b4d9622020-09-14 08:47:50264 acm_stat->meanWaitingTimeMs = neteq_stat.mean_waiting_time_ms;
Niels Möller6b4d9622020-09-14 08:47:50265 acm_stat->maxWaitingTimeMs = neteq_stat.max_waiting_time_ms;
266 } else {
267 neteq_stat = neteq_->CurrentNetworkStatistics();
Niels Möller6b4d9622020-09-14 08:47:50268 acm_stat->currentExpandRate = 0;
269 acm_stat->currentSpeechExpandRate = 0;
270 acm_stat->currentPreemptiveRate = 0;
271 acm_stat->currentAccelerateRate = 0;
272 acm_stat->currentSecondaryDecodedRate = 0;
273 acm_stat->currentSecondaryDiscardedRate = 0;
Niels Möller6b4d9622020-09-14 08:47:50274 acm_stat->meanWaitingTimeMs = -1;
Niels Möller6b4d9622020-09-14 08:47:50275 acm_stat->maxWaitingTimeMs = 1;
276 }
turaj@webrtc.org7959e162013-09-12 18:30:26277 acm_stat->currentBufferSize = neteq_stat.current_buffer_size_ms;
278 acm_stat->preferredBufferSize = neteq_stat.preferred_buffer_size_ms;
turaj@webrtc.org532f3dc2013-09-19 00:12:23279 acm_stat->jitterPeaksFound = neteq_stat.jitter_peaks_found ? true : false;
Steve Anton2dbc69f2017-08-25 00:15:13280
281 NetEqLifetimeStatistics neteq_lifetime_stat = neteq_->GetLifetimeStatistics();
282 acm_stat->totalSamplesReceived = neteq_lifetime_stat.total_samples_received;
283 acm_stat->concealedSamples = neteq_lifetime_stat.concealed_samples;
Ivo Creusen8d8ffdb2019-04-30 07:45:21284 acm_stat->silentConcealedSamples =
285 neteq_lifetime_stat.silent_concealed_samples;
Gustaf Ullberg9a2e9062017-09-18 07:28:20286 acm_stat->concealmentEvents = neteq_lifetime_stat.concealment_events;
Gustaf Ullbergb0a02072017-10-02 10:00:34287 acm_stat->jitterBufferDelayMs = neteq_lifetime_stat.jitter_buffer_delay_ms;
Artem Titove618cc92020-03-11 10:18:54288 acm_stat->jitterBufferTargetDelayMs =
289 neteq_lifetime_stat.jitter_buffer_target_delay_ms;
Chen Xing0acffb52019-01-15 14:46:29290 acm_stat->jitterBufferEmittedCount =
291 neteq_lifetime_stat.jitter_buffer_emitted_count;
Jakob Ivarsson352ce5c2018-11-27 11:52:16292 acm_stat->delayedPacketOutageSamples =
293 neteq_lifetime_stat.delayed_packet_outage_samples;
Jakob Ivarsson232b3fd2019-03-06 08:18:40294 acm_stat->relativePacketArrivalDelayMs =
295 neteq_lifetime_stat.relative_packet_arrival_delay_ms;
Henrik Lundin44125fa2019-04-29 15:00:46296 acm_stat->interruptionCount = neteq_lifetime_stat.interruption_count;
297 acm_stat->totalInterruptionDurationMs =
298 neteq_lifetime_stat.total_interruption_duration_ms;
Ivo Creusen8d8ffdb2019-04-30 07:45:21299 acm_stat->insertedSamplesForDeceleration =
300 neteq_lifetime_stat.inserted_samples_for_deceleration;
301 acm_stat->removedSamplesForAcceleration =
302 neteq_lifetime_stat.removed_samples_for_acceleration;
303 acm_stat->fecPacketsReceived = neteq_lifetime_stat.fec_packets_received;
304 acm_stat->fecPacketsDiscarded = neteq_lifetime_stat.fec_packets_discarded;
Ruslan Burakov8af88962018-11-22 16:21:10305
306 NetEqOperationsAndState neteq_operations_and_state =
307 neteq_->GetOperationsAndState();
308 acm_stat->packetBufferFlushes =
309 neteq_operations_and_state.packet_buffer_flushes;
turaj@webrtc.org7959e162013-09-12 18:30:26310}
311
turaj@webrtc.org7959e162013-09-12 18:30:26312int AcmReceiver::EnableNack(size_t max_nack_list_size) {
henrik.lundin48ed9302015-10-29 12:36:24313 neteq_->EnableNack(max_nack_list_size);
314 return 0;
turaj@webrtc.org7959e162013-09-12 18:30:26315}
316
317void AcmReceiver::DisableNack() {
henrik.lundin48ed9302015-10-29 12:36:24318 neteq_->DisableNack();
turaj@webrtc.org7959e162013-09-12 18:30:26319}
320
321std::vector<uint16_t> AcmReceiver::GetNackList(
pkasting@chromium.org16825b12015-01-12 21:51:21322 int64_t round_trip_time_ms) const {
henrik.lundin48ed9302015-10-29 12:36:24323 return neteq_->GetNackList(round_trip_time_ms);
turaj@webrtc.org7959e162013-09-12 18:30:26324}
325
326void AcmReceiver::ResetInitialDelay() {
turaj@webrtc.org7959e162013-09-12 18:30:26327 neteq_->SetMinimumDelay(0);
328 // TODO(turajs): Should NetEq Buffer be flushed?
329}
330
turaj@webrtc.org7959e162013-09-12 18:30:26331uint32_t AcmReceiver::NowInTimestamp(int decoder_sampling_rate) const {
332 // Down-cast the time to (32-6)-bit since we only care about
333 // the least significant bits. (32-6) bits cover 2^(32-6) = 67108864 ms.
334 // We masked 6 most significant bits of 32-bit so there is no overflow in
335 // the conversion from milliseconds to timestamp.
Yves Gerey665174f2018-06-19 13:03:05336 const uint32_t now_in_ms =
337 static_cast<uint32_t>(clock_->TimeInMilliseconds() & 0x03ffffff);
338 return static_cast<uint32_t>((decoder_sampling_rate / 1000) * now_in_ms);
turaj@webrtc.org7959e162013-09-12 18:30:26339}
340
wu@webrtc.org24301a62013-12-13 19:17:43341void AcmReceiver::GetDecodingCallStatistics(
342 AudioDecodingCallStats* stats) const {
Markus Handell0df0fae2020-07-07 13:53:34343 MutexLock lock(&mutex_);
wu@webrtc.org24301a62013-12-13 19:17:43344 *stats = call_stats_.GetDecodingStatistics();
345}
346
turaj@webrtc.org6d5d2482013-10-06 04:47:28347} // namespace acm2
348
turaj@webrtc.org7959e162013-09-12 18:30:26349} // namespace webrtc