turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 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 | |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 11 | #include "modules/audio_coding/acm2/acm_receiver.h" |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 12 | |
Yves Gerey | 988cc08 | 2018-10-23 10:03:01 | [diff] [blame] | 13 | #include <stdlib.h> |
| 14 | #include <string.h> |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 15 | |
Yves Gerey | 988cc08 | 2018-10-23 10:03:01 | [diff] [blame] | 16 | #include <cstdint> |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 17 | #include <vector> |
| 18 | |
Niels Möller | 2edab4c | 2018-10-22 07:48:08 | [diff] [blame] | 19 | #include "absl/strings/match.h" |
Yves Gerey | 988cc08 | 2018-10-23 10:03:01 | [diff] [blame] | 20 | #include "api/audio/audio_frame.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 21 | #include "api/audio_codecs/audio_decoder.h" |
Ivo Creusen | 3ce44a3 | 2019-10-31 13:38:11 | [diff] [blame] | 22 | #include "api/neteq/neteq.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 23 | #include "modules/audio_coding/acm2/acm_resampler.h" |
| 24 | #include "modules/audio_coding/acm2/call_statistics.h" |
Ivo Creusen | 68c6572 | 2019-11-26 11:29:05 | [diff] [blame] | 25 | #include "modules/audio_coding/neteq/default_neteq_factory.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 26 | #include "rtc_base/checks.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 27 | #include "rtc_base/logging.h" |
Karl Wiberg | e40468b | 2017-11-22 09:42:26 | [diff] [blame] | 28 | #include "rtc_base/numerics/safe_conversions.h" |
Jonas Olsson | abbe841 | 2018-04-03 11:40:05 | [diff] [blame] | 29 | #include "rtc_base/strings/audio_format_to_string.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 04:47:31 | [diff] [blame] | 30 | #include "system_wrappers/include/clock.h" |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 31 | |
| 32 | namespace webrtc { |
| 33 | |
turaj@webrtc.org | 6d5d248 | 2013-10-06 04:47:28 | [diff] [blame] | 34 | namespace acm2 { |
| 35 | |
Ivo Creusen | 3ce44a3 | 2019-10-31 13:38:11 | [diff] [blame] | 36 | namespace { |
| 37 | |
| 38 | std::unique_ptr<NetEq> CreateNetEq( |
Ivo Creusen | c3d1f9b | 2019-11-01 10:47:51 | [diff] [blame] | 39 | NetEqFactory* neteq_factory, |
Ivo Creusen | 3ce44a3 | 2019-10-31 13:38:11 | [diff] [blame] | 40 | const NetEq::Config& config, |
| 41 | Clock* clock, |
| 42 | const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory) { |
Ivo Creusen | c3d1f9b | 2019-11-01 10:47:51 | [diff] [blame] | 43 | if (neteq_factory) { |
Ivo Creusen | 68c6572 | 2019-11-26 11:29:05 | [diff] [blame] | 44 | return neteq_factory->CreateNetEq(config, decoder_factory, clock); |
Ivo Creusen | c3d1f9b | 2019-11-01 10:47:51 | [diff] [blame] | 45 | } |
Ivo Creusen | 68c6572 | 2019-11-26 11:29:05 | [diff] [blame] | 46 | return DefaultNetEqFactory().CreateNetEq(config, decoder_factory, clock); |
Ivo Creusen | 3ce44a3 | 2019-10-31 13:38:11 | [diff] [blame] | 47 | } |
| 48 | |
| 49 | } // namespace |
| 50 | |
henrik.lundin@webrtc.org | 0bc9b5a | 2014-04-29 08:09:31 | [diff] [blame] | 51 | AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config) |
kwiberg | 6f0f616 | 2016-09-20 10:07:46 | [diff] [blame] | 52 | : last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]), |
Ivo Creusen | c3d1f9b | 2019-11-01 10:47:51 | [diff] [blame] | 53 | neteq_(CreateNetEq(config.neteq_factory, |
| 54 | config.neteq_config, |
Ivo Creusen | 3ce44a3 | 2019-10-31 13:38:11 | [diff] [blame] | 55 | config.clock, |
| 56 | config.decoder_factory)), |
henrik.lundin@webrtc.org | 0bc9b5a | 2014-04-29 08:09:31 | [diff] [blame] | 57 | clock_(config.clock), |
henrik.lundin | 678c903 | 2015-11-02 16:31:23 | [diff] [blame] | 58 | resampled_last_output_frame_(true) { |
Henrik Lundin | 02ed201 | 2017-06-08 07:03:55 | [diff] [blame] | 59 | RTC_DCHECK(clock_); |
Henrik Lundin | 76c1067 | 2018-05-07 11:47:28 | [diff] [blame] | 60 | memset(last_audio_buffer_.get(), 0, |
| 61 | sizeof(int16_t) * AudioFrame::kMaxDataSizeSamples); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 62 | } |
| 63 | |
Henrik Lundin | 6af9399 | 2017-06-14 12:13:02 | [diff] [blame] | 64 | AcmReceiver::~AcmReceiver() = default; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 65 | |
| 66 | int AcmReceiver::SetMinimumDelay(int delay_ms) { |
| 67 | if (neteq_->SetMinimumDelay(delay_ms)) |
| 68 | return 0; |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 69 | RTC_LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 70 | return -1; |
| 71 | } |
| 72 | |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 73 | int AcmReceiver::SetMaximumDelay(int delay_ms) { |
| 74 | if (neteq_->SetMaximumDelay(delay_ms)) |
| 75 | return 0; |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 76 | RTC_LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 77 | return -1; |
| 78 | } |
| 79 | |
Ruslan Burakov | 9bee67c | 2019-02-05 12:49:26 | [diff] [blame] | 80 | bool AcmReceiver::SetBaseMinimumDelayMs(int delay_ms) { |
| 81 | return neteq_->SetBaseMinimumDelayMs(delay_ms); |
| 82 | } |
| 83 | |
| 84 | int AcmReceiver::GetBaseMinimumDelayMs() const { |
| 85 | return neteq_->GetBaseMinimumDelayMs(); |
| 86 | } |
| 87 | |
Danil Chapovalov | b602123 | 2018-06-19 11:26:36 | [diff] [blame] | 88 | absl::optional<int> AcmReceiver::last_packet_sample_rate_hz() const { |
Markus Handell | 0df0fae | 2020-07-07 13:53:34 | [diff] [blame] | 89 | MutexLock lock(&mutex_); |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 90 | if (!last_decoder_) { |
| 91 | return absl::nullopt; |
| 92 | } |
Karl Wiberg | 4b64411 | 2019-10-11 07:37:42 | [diff] [blame] | 93 | return last_decoder_->sample_rate_hz; |
henrik.lundin | 057fb89 | 2015-11-23 16:19:52 | [diff] [blame] | 94 | } |
| 95 | |
henrik.lundin | d89814b | 2015-11-23 14:49:25 | [diff] [blame] | 96 | int AcmReceiver::last_output_sample_rate_hz() const { |
| 97 | return neteq_->last_output_sample_rate_hz(); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 98 | } |
| 99 | |
Niels Möller | afb5dbb | 2019-02-15 14:21:47 | [diff] [blame] | 100 | int AcmReceiver::InsertPacket(const RTPHeader& rtp_header, |
kwiberg | ee2bac2 | 2015-11-11 18:34:00 | [diff] [blame] | 101 | rtc::ArrayView<const uint8_t> incoming_payload) { |
henrik.lundin | b8c55b1 | 2017-05-10 14:38:01 | [diff] [blame] | 102 | if (incoming_payload.empty()) { |
Niels Möller | afb5dbb | 2019-02-15 14:21:47 | [diff] [blame] | 103 | neteq_->InsertEmptyPacket(rtp_header); |
henrik.lundin | b8c55b1 | 2017-05-10 14:38:01 | [diff] [blame] | 104 | return 0; |
| 105 | } |
| 106 | |
Niels Möller | afb5dbb | 2019-02-15 14:21:47 | [diff] [blame] | 107 | int payload_type = rtp_header.payloadType; |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 108 | auto format = neteq_->GetDecoderFormat(payload_type); |
Karl Wiberg | 4b64411 | 2019-10-11 07:37:42 | [diff] [blame] | 109 | if (format && absl::EqualsIgnoreCase(format->sdp_format.name, "red")) { |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 110 | // 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 Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 115 | RTC_LOG_F(LS_ERROR) << "Payload-type " << payload_type |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 116 | << " is not registered."; |
| 117 | return -1; |
| 118 | } |
| 119 | |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 120 | { |
Markus Handell | 0df0fae | 2020-07-07 13:53:34 | [diff] [blame] | 121 | MutexLock lock(&mutex_); |
Karl Wiberg | 4b64411 | 2019-10-11 07:37:42 | [diff] [blame] | 122 | if (absl::EqualsIgnoreCase(format->sdp_format.name, "cn")) { |
| 123 | if (last_decoder_ && last_decoder_->num_channels > 1) { |
kwiberg | 6f0f616 | 2016-09-20 10:07:46 | [diff] [blame] | 124 | // This is a CNG and the audio codec is not mono, so skip pushing in |
| 125 | // packets into NetEq. |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 126 | return 0; |
kwiberg | 6f0f616 | 2016-09-20 10:07:46 | [diff] [blame] | 127 | } |
| 128 | } else { |
Karl Wiberg | 4b64411 | 2019-10-11 07:37:42 | [diff] [blame] | 129 | 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.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 133 | } |
Markus Handell | 0df0fae | 2020-07-07 13:53:34 | [diff] [blame] | 134 | } // |mutex_| is released. |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 135 | |
Karl Wiberg | 45eb135 | 2019-10-10 12:23:00 | [diff] [blame] | 136 | if (neteq_->InsertPacket(rtp_header, incoming_payload) < 0) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 137 | RTC_LOG(LERROR) << "AcmReceiver::InsertPacket " |
Niels Möller | afb5dbb | 2019-02-15 14:21:47 | [diff] [blame] | 138 | << static_cast<int>(rtp_header.payloadType) |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 139 | << " Failed to insert packet"; |
henrik.lundin@webrtc.org | eecf5e6 | 2014-06-24 13:11:22 | [diff] [blame] | 140 | return -1; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 141 | } |
| 142 | return 0; |
| 143 | } |
| 144 | |
henrik.lundin | 834a6ea | 2016-05-13 10:45:24 | [diff] [blame] | 145 | int AcmReceiver::GetAudio(int desired_freq_hz, |
| 146 | AudioFrame* audio_frame, |
| 147 | bool* muted) { |
henrik.lundin | 6348978 | 2016-09-20 08:47:12 | [diff] [blame] | 148 | RTC_DCHECK(muted); |
henrik.lundin@webrtc.org | 913f7b8 | 2014-10-21 06:54:23 | [diff] [blame] | 149 | |
Tommi | 3cc68ec | 2021-06-09 17:30:41 | [diff] [blame^] | 150 | int current_sample_rate_hz = 0; |
| 151 | if (neteq_->GetAudio(audio_frame, muted, ¤t_sample_rate_hz) != |
| 152 | NetEq::kOK) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 153 | RTC_LOG(LERROR) << "AcmReceiver::GetAudio - NetEq Failed."; |
henrik.lundin@webrtc.org | eecf5e6 | 2014-06-24 13:11:22 | [diff] [blame] | 154 | return -1; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 155 | } |
| 156 | |
Tommi | 3cc68ec | 2021-06-09 17:30:41 | [diff] [blame^] | 157 | RTC_DCHECK_NE(current_sample_rate_hz, 0); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 158 | |
| 159 | // Update if resampling is required. |
henrik.lundin | d89814b | 2015-11-23 14:49:25 | [diff] [blame] | 160 | const bool need_resampling = |
| 161 | (desired_freq_hz != -1) && (current_sample_rate_hz != desired_freq_hz); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 162 | |
Tommi | 3cc68ec | 2021-06-09 17:30:41 | [diff] [blame^] | 163 | // Accessing members, take the lock. |
| 164 | MutexLock lock(&mutex_); |
henrik.lundin@webrtc.org | 913f7b8 | 2014-10-21 06:54:23 | [diff] [blame] | 165 | if (need_resampling && !resampled_last_output_frame_) { |
| 166 | // Prime the resampler with the last frame. |
| 167 | int16_t temp_output[AudioFrame::kMaxDataSizeSamples]; |
henrik.lundin | d89814b | 2015-11-23 14:49:25 | [diff] [blame] | 168 | int samples_per_channel_int = resampler_.Resample10Msec( |
| 169 | last_audio_buffer_.get(), current_sample_rate_hz, desired_freq_hz, |
henrik.lundin | 6d8e011 | 2016-03-04 18:34:21 | [diff] [blame] | 170 | audio_frame->num_channels_, AudioFrame::kMaxDataSizeSamples, |
| 171 | temp_output); |
Peter Kasting | dce40cf | 2015-08-24 21:52:23 | [diff] [blame] | 172 | if (samples_per_channel_int < 0) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 173 | RTC_LOG(LERROR) << "AcmReceiver::GetAudio - " |
| 174 | "Resampling last_audio_buffer_ failed."; |
henrik.lundin@webrtc.org | 913f7b8 | 2014-10-21 06:54:23 | [diff] [blame] | 175 | return -1; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 176 | } |
| 177 | } |
| 178 | |
Tommi | 3cc68ec | 2021-06-09 17:30:41 | [diff] [blame^] | 179 | // TODO(bugs.webrtc.org/3923) Glitches in the output may appear if the output |
| 180 | // rate from NetEq changes. |
henrik.lundin@webrtc.org | 913f7b8 | 2014-10-21 06:54:23 | [diff] [blame] | 181 | if (need_resampling) { |
yujo | 36b1a5f | 2017-06-12 19:45:32 | [diff] [blame] | 182 | // TODO(yujo): handle this more efficiently for muted frames. |
henrik.lundin | d89814b | 2015-11-23 14:49:25 | [diff] [blame] | 183 | int samples_per_channel_int = resampler_.Resample10Msec( |
yujo | 36b1a5f | 2017-06-12 19:45:32 | [diff] [blame] | 184 | audio_frame->data(), current_sample_rate_hz, desired_freq_hz, |
henrik.lundin | 6d8e011 | 2016-03-04 18:34:21 | [diff] [blame] | 185 | audio_frame->num_channels_, AudioFrame::kMaxDataSizeSamples, |
yujo | 36b1a5f | 2017-06-12 19:45:32 | [diff] [blame] | 186 | audio_frame->mutable_data()); |
Peter Kasting | dce40cf | 2015-08-24 21:52:23 | [diff] [blame] | 187 | if (samples_per_channel_int < 0) { |
Mirko Bonadei | 675513b | 2017-11-09 10:09:25 | [diff] [blame] | 188 | RTC_LOG(LERROR) |
| 189 | << "AcmReceiver::GetAudio - Resampling audio_buffer_ failed."; |
henrik.lundin@webrtc.org | 913f7b8 | 2014-10-21 06:54:23 | [diff] [blame] | 190 | return -1; |
| 191 | } |
henrik.lundin | 6d8e011 | 2016-03-04 18:34:21 | [diff] [blame] | 192 | 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_, |
kwiberg | d3edd77 | 2017-03-02 02:52:48 | [diff] [blame] | 197 | rtc::dchecked_cast<int>(audio_frame->samples_per_channel_ * 100)); |
henrik.lundin@webrtc.org | 913f7b8 | 2014-10-21 06:54:23 | [diff] [blame] | 198 | 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.org | 913f7b8 | 2014-10-21 06:54:23 | [diff] [blame] | 202 | } |
| 203 | |
henrik.lundin | 6d8e011 | 2016-03-04 18:34:21 | [diff] [blame] | 204 | // Store current audio in |last_audio_buffer_| for next time. |
yujo | 36b1a5f | 2017-06-12 19:45:32 | [diff] [blame] | 205 | memcpy(last_audio_buffer_.get(), audio_frame->data(), |
henrik.lundin | 6d8e011 | 2016-03-04 18:34:21 | [diff] [blame] | 206 | sizeof(int16_t) * audio_frame->samples_per_channel_ * |
| 207 | audio_frame->num_channels_); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 208 | |
henrik.lundin | 6348978 | 2016-09-20 08:47:12 | [diff] [blame] | 209 | call_stats_.DecodedByNetEq(audio_frame->speech_type_, *muted); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 210 | return 0; |
| 211 | } |
| 212 | |
kwiberg | 1c07c70 | 2017-03-27 14:15:49 | [diff] [blame] | 213 | void AcmReceiver::SetCodecs(const std::map<int, SdpAudioFormat>& codecs) { |
| 214 | neteq_->SetCodecs(codecs); |
| 215 | } |
| 216 | |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 217 | void AcmReceiver::FlushBuffers() { |
| 218 | neteq_->FlushBuffers(); |
| 219 | } |
| 220 | |
kwiberg | 6b19b56 | 2016-09-20 11:02:25 | [diff] [blame] | 221 | void AcmReceiver::RemoveAllCodecs() { |
Markus Handell | 0df0fae | 2020-07-07 13:53:34 | [diff] [blame] | 222 | MutexLock lock(&mutex_); |
kwiberg | 6b19b56 | 2016-09-20 11:02:25 | [diff] [blame] | 223 | neteq_->RemoveAllPayloadTypes(); |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 224 | last_decoder_ = absl::nullopt; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 225 | } |
| 226 | |
Danil Chapovalov | b602123 | 2018-06-19 11:26:36 | [diff] [blame] | 227 | absl::optional<uint32_t> AcmReceiver::GetPlayoutTimestamp() { |
henrik.lundin | 9a410dd | 2016-04-06 08:39:22 | [diff] [blame] | 228 | return neteq_->GetPlayoutTimestamp(); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 229 | } |
| 230 | |
henrik.lundin | b3f1c5d | 2016-08-22 22:39:53 | [diff] [blame] | 231 | int AcmReceiver::FilteredCurrentDelayMs() const { |
| 232 | return neteq_->FilteredCurrentDelayMs(); |
| 233 | } |
| 234 | |
Henrik Lundin | abbff89 | 2017-11-29 08:14:04 | [diff] [blame] | 235 | int AcmReceiver::TargetDelayMs() const { |
| 236 | return neteq_->TargetDelayMs(); |
| 237 | } |
| 238 | |
Jonas Olsson | a4d8737 | 2019-07-05 17:08:33 | [diff] [blame] | 239 | absl::optional<std::pair<int, SdpAudioFormat>> AcmReceiver::LastDecoder() |
| 240 | const { |
Markus Handell | 0df0fae | 2020-07-07 13:53:34 | [diff] [blame] | 241 | MutexLock lock(&mutex_); |
Fredrik Solenberg | f693bfa | 2018-12-11 11:22:10 | [diff] [blame] | 242 | if (!last_decoder_) { |
| 243 | return absl::nullopt; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 244 | } |
Karl Wiberg | 4b64411 | 2019-10-11 07:37:42 | [diff] [blame] | 245 | RTC_DCHECK_NE(-1, last_decoder_->payload_type); |
| 246 | return std::make_pair(last_decoder_->payload_type, last_decoder_->sdp_format); |
ossu | e280cde | 2016-10-12 18:04:10 | [diff] [blame] | 247 | } |
| 248 | |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 249 | void AcmReceiver::GetNetworkStatistics( |
| 250 | NetworkStatistics* acm_stat, |
| 251 | bool get_and_clear_legacy_stats /* = true */) const { |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 252 | NetEqNetworkStatistics neteq_stat; |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 253 | 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.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 256 | |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 257 | 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öller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 264 | acm_stat->meanWaitingTimeMs = neteq_stat.mean_waiting_time_ms; |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 265 | acm_stat->maxWaitingTimeMs = neteq_stat.max_waiting_time_ms; |
| 266 | } else { |
| 267 | neteq_stat = neteq_->CurrentNetworkStatistics(); |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 268 | 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öller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 274 | acm_stat->meanWaitingTimeMs = -1; |
Niels Möller | 6b4d962 | 2020-09-14 08:47:50 | [diff] [blame] | 275 | acm_stat->maxWaitingTimeMs = 1; |
| 276 | } |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 277 | acm_stat->currentBufferSize = neteq_stat.current_buffer_size_ms; |
| 278 | acm_stat->preferredBufferSize = neteq_stat.preferred_buffer_size_ms; |
turaj@webrtc.org | 532f3dc | 2013-09-19 00:12:23 | [diff] [blame] | 279 | acm_stat->jitterPeaksFound = neteq_stat.jitter_peaks_found ? true : false; |
Steve Anton | 2dbc69f | 2017-08-25 00:15:13 | [diff] [blame] | 280 | |
| 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 Creusen | 8d8ffdb | 2019-04-30 07:45:21 | [diff] [blame] | 284 | acm_stat->silentConcealedSamples = |
| 285 | neteq_lifetime_stat.silent_concealed_samples; |
Gustaf Ullberg | 9a2e906 | 2017-09-18 07:28:20 | [diff] [blame] | 286 | acm_stat->concealmentEvents = neteq_lifetime_stat.concealment_events; |
Gustaf Ullberg | b0a0207 | 2017-10-02 10:00:34 | [diff] [blame] | 287 | acm_stat->jitterBufferDelayMs = neteq_lifetime_stat.jitter_buffer_delay_ms; |
Artem Titov | e618cc9 | 2020-03-11 10:18:54 | [diff] [blame] | 288 | acm_stat->jitterBufferTargetDelayMs = |
| 289 | neteq_lifetime_stat.jitter_buffer_target_delay_ms; |
Chen Xing | 0acffb5 | 2019-01-15 14:46:29 | [diff] [blame] | 290 | acm_stat->jitterBufferEmittedCount = |
| 291 | neteq_lifetime_stat.jitter_buffer_emitted_count; |
Jakob Ivarsson | 352ce5c | 2018-11-27 11:52:16 | [diff] [blame] | 292 | acm_stat->delayedPacketOutageSamples = |
| 293 | neteq_lifetime_stat.delayed_packet_outage_samples; |
Jakob Ivarsson | 232b3fd | 2019-03-06 08:18:40 | [diff] [blame] | 294 | acm_stat->relativePacketArrivalDelayMs = |
| 295 | neteq_lifetime_stat.relative_packet_arrival_delay_ms; |
Henrik Lundin | 44125fa | 2019-04-29 15:00:46 | [diff] [blame] | 296 | acm_stat->interruptionCount = neteq_lifetime_stat.interruption_count; |
| 297 | acm_stat->totalInterruptionDurationMs = |
| 298 | neteq_lifetime_stat.total_interruption_duration_ms; |
Ivo Creusen | 8d8ffdb | 2019-04-30 07:45:21 | [diff] [blame] | 299 | 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 Burakov | 8af8896 | 2018-11-22 16:21:10 | [diff] [blame] | 305 | |
| 306 | NetEqOperationsAndState neteq_operations_and_state = |
| 307 | neteq_->GetOperationsAndState(); |
| 308 | acm_stat->packetBufferFlushes = |
| 309 | neteq_operations_and_state.packet_buffer_flushes; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 310 | } |
| 311 | |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 312 | int AcmReceiver::EnableNack(size_t max_nack_list_size) { |
henrik.lundin | 48ed930 | 2015-10-29 12:36:24 | [diff] [blame] | 313 | neteq_->EnableNack(max_nack_list_size); |
| 314 | return 0; |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 315 | } |
| 316 | |
| 317 | void AcmReceiver::DisableNack() { |
henrik.lundin | 48ed930 | 2015-10-29 12:36:24 | [diff] [blame] | 318 | neteq_->DisableNack(); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | std::vector<uint16_t> AcmReceiver::GetNackList( |
pkasting@chromium.org | 16825b1 | 2015-01-12 21:51:21 | [diff] [blame] | 322 | int64_t round_trip_time_ms) const { |
henrik.lundin | 48ed930 | 2015-10-29 12:36:24 | [diff] [blame] | 323 | return neteq_->GetNackList(round_trip_time_ms); |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 324 | } |
| 325 | |
| 326 | void AcmReceiver::ResetInitialDelay() { |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 327 | neteq_->SetMinimumDelay(0); |
| 328 | // TODO(turajs): Should NetEq Buffer be flushed? |
| 329 | } |
| 330 | |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 331 | uint32_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 Gerey | 665174f | 2018-06-19 13:03:05 | [diff] [blame] | 336 | 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.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 339 | } |
| 340 | |
wu@webrtc.org | 24301a6 | 2013-12-13 19:17:43 | [diff] [blame] | 341 | void AcmReceiver::GetDecodingCallStatistics( |
| 342 | AudioDecodingCallStats* stats) const { |
Markus Handell | 0df0fae | 2020-07-07 13:53:34 | [diff] [blame] | 343 | MutexLock lock(&mutex_); |
wu@webrtc.org | 24301a6 | 2013-12-13 19:17:43 | [diff] [blame] | 344 | *stats = call_stats_.GetDecodingStatistics(); |
| 345 | } |
| 346 | |
turaj@webrtc.org | 6d5d248 | 2013-10-06 04:47:28 | [diff] [blame] | 347 | } // namespace acm2 |
| 348 | |
turaj@webrtc.org | 7959e16 | 2013-09-12 18:30:26 | [diff] [blame] | 349 | } // namespace webrtc |