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/acm2/acm_receiver.h"
12
13 #include <stdlib.h>
14 #include <string.h>
15
16 #include <cstdint>
17 #include <vector>
18
19 #include "absl/strings/match.h"
20 #include "api/audio/audio_frame.h"
21 #include "api/audio_codecs/audio_decoder.h"
22 #include "api/neteq/neteq.h"
23 #include "modules/audio_coding/acm2/acm_resampler.h"
24 #include "modules/audio_coding/acm2/call_statistics.h"
25 #include "modules/audio_coding/neteq/default_neteq_factory.h"
26 #include "rtc_base/checks.h"
27 #include "rtc_base/logging.h"
28 #include "rtc_base/numerics/safe_conversions.h"
29 #include "rtc_base/strings/audio_format_to_string.h"
30 #include "system_wrappers/include/clock.h"
31
32 namespace webrtc {
33
34 namespace acm2 {
35
36 namespace {
37
CreateNetEq(NetEqFactory * neteq_factory,const NetEq::Config & config,Clock * clock,const rtc::scoped_refptr<AudioDecoderFactory> & decoder_factory)38 std::unique_ptr<NetEq> CreateNetEq(
39 NetEqFactory* neteq_factory,
40 const NetEq::Config& config,
41 Clock* clock,
42 const rtc::scoped_refptr<AudioDecoderFactory>& decoder_factory) {
43 if (neteq_factory) {
44 return neteq_factory->CreateNetEq(config, decoder_factory, clock);
45 }
46 return DefaultNetEqFactory().CreateNetEq(config, decoder_factory, clock);
47 }
48
49 } // namespace
50
AcmReceiver(const AudioCodingModule::Config & config)51 AcmReceiver::AcmReceiver(const AudioCodingModule::Config& config)
52 : last_audio_buffer_(new int16_t[AudioFrame::kMaxDataSizeSamples]),
53 neteq_(CreateNetEq(config.neteq_factory,
54 config.neteq_config,
55 config.clock,
56 config.decoder_factory)),
57 clock_(config.clock),
58 resampled_last_output_frame_(true) {
59 RTC_DCHECK(clock_);
60 memset(last_audio_buffer_.get(), 0,
61 sizeof(int16_t) * AudioFrame::kMaxDataSizeSamples);
62 }
63
64 AcmReceiver::~AcmReceiver() = default;
65
SetMinimumDelay(int delay_ms)66 int AcmReceiver::SetMinimumDelay(int delay_ms) {
67 if (neteq_->SetMinimumDelay(delay_ms))
68 return 0;
69 RTC_LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms;
70 return -1;
71 }
72
SetMaximumDelay(int delay_ms)73 int AcmReceiver::SetMaximumDelay(int delay_ms) {
74 if (neteq_->SetMaximumDelay(delay_ms))
75 return 0;
76 RTC_LOG(LERROR) << "AcmReceiver::SetExtraDelay " << delay_ms;
77 return -1;
78 }
79
SetBaseMinimumDelayMs(int delay_ms)80 bool AcmReceiver::SetBaseMinimumDelayMs(int delay_ms) {
81 return neteq_->SetBaseMinimumDelayMs(delay_ms);
82 }
83
GetBaseMinimumDelayMs() const84 int AcmReceiver::GetBaseMinimumDelayMs() const {
85 return neteq_->GetBaseMinimumDelayMs();
86 }
87
last_packet_sample_rate_hz() const88 absl::optional<int> AcmReceiver::last_packet_sample_rate_hz() const {
89 MutexLock lock(&mutex_);
90 if (!last_decoder_) {
91 return absl::nullopt;
92 }
93 return last_decoder_->sample_rate_hz;
94 }
95
last_output_sample_rate_hz() const96 int AcmReceiver::last_output_sample_rate_hz() const {
97 return neteq_->last_output_sample_rate_hz();
98 }
99
InsertPacket(const RTPHeader & rtp_header,rtc::ArrayView<const uint8_t> incoming_payload)100 int AcmReceiver::InsertPacket(const RTPHeader& rtp_header,
101 rtc::ArrayView<const uint8_t> incoming_payload) {
102 if (incoming_payload.empty()) {
103 neteq_->InsertEmptyPacket(rtp_header);
104 return 0;
105 }
106
107 int payload_type = rtp_header.payloadType;
108 auto format = neteq_->GetDecoderFormat(payload_type);
109 if (format && absl::EqualsIgnoreCase(format->sdp_format.name, "red")) {
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) {
115 RTC_LOG_F(LS_ERROR) << "Payload-type " << payload_type
116 << " is not registered.";
117 return -1;
118 }
119
120 {
121 MutexLock lock(&mutex_);
122 if (absl::EqualsIgnoreCase(format->sdp_format.name, "cn")) {
123 if (last_decoder_ && last_decoder_->num_channels > 1) {
124 // This is a CNG and the audio codec is not mono, so skip pushing in
125 // packets into NetEq.
126 return 0;
127 }
128 } else {
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)};
133 }
134 } // |mutex_| is released.
135
136 if (neteq_->InsertPacket(rtp_header, incoming_payload) < 0) {
137 RTC_LOG(LERROR) << "AcmReceiver::InsertPacket "
138 << static_cast<int>(rtp_header.payloadType)
139 << " Failed to insert packet";
140 return -1;
141 }
142 return 0;
143 }
144
GetAudio(int desired_freq_hz,AudioFrame * audio_frame,bool * muted)145 int AcmReceiver::GetAudio(int desired_freq_hz,
146 AudioFrame* audio_frame,
147 bool* muted) {
148 RTC_DCHECK(muted);
149 // Accessing members, take the lock.
150 MutexLock lock(&mutex_);
151
152 if (neteq_->GetAudio(audio_frame, muted) != NetEq::kOK) {
153 RTC_LOG(LERROR) << "AcmReceiver::GetAudio - NetEq Failed.";
154 return -1;
155 }
156
157 const int current_sample_rate_hz = neteq_->last_output_sample_rate_hz();
158
159 // Update if resampling is required.
160 const bool need_resampling =
161 (desired_freq_hz != -1) && (current_sample_rate_hz != desired_freq_hz);
162
163 if (need_resampling && !resampled_last_output_frame_) {
164 // Prime the resampler with the last frame.
165 int16_t temp_output[AudioFrame::kMaxDataSizeSamples];
166 int samples_per_channel_int = resampler_.Resample10Msec(
167 last_audio_buffer_.get(), current_sample_rate_hz, desired_freq_hz,
168 audio_frame->num_channels_, AudioFrame::kMaxDataSizeSamples,
169 temp_output);
170 if (samples_per_channel_int < 0) {
171 RTC_LOG(LERROR) << "AcmReceiver::GetAudio - "
172 "Resampling last_audio_buffer_ failed.";
173 return -1;
174 }
175 }
176
177 // TODO(henrik.lundin) Glitches in the output may appear if the output rate
178 // from NetEq changes. See WebRTC issue 3923.
179 if (need_resampling) {
180 // TODO(yujo): handle this more efficiently for muted frames.
181 int samples_per_channel_int = resampler_.Resample10Msec(
182 audio_frame->data(), current_sample_rate_hz, desired_freq_hz,
183 audio_frame->num_channels_, AudioFrame::kMaxDataSizeSamples,
184 audio_frame->mutable_data());
185 if (samples_per_channel_int < 0) {
186 RTC_LOG(LERROR)
187 << "AcmReceiver::GetAudio - Resampling audio_buffer_ failed.";
188 return -1;
189 }
190 audio_frame->samples_per_channel_ =
191 static_cast<size_t>(samples_per_channel_int);
192 audio_frame->sample_rate_hz_ = desired_freq_hz;
193 RTC_DCHECK_EQ(
194 audio_frame->sample_rate_hz_,
195 rtc::dchecked_cast<int>(audio_frame->samples_per_channel_ * 100));
196 resampled_last_output_frame_ = true;
197 } else {
198 resampled_last_output_frame_ = false;
199 // We might end up here ONLY if codec is changed.
200 }
201
202 // Store current audio in |last_audio_buffer_| for next time.
203 memcpy(last_audio_buffer_.get(), audio_frame->data(),
204 sizeof(int16_t) * audio_frame->samples_per_channel_ *
205 audio_frame->num_channels_);
206
207 call_stats_.DecodedByNetEq(audio_frame->speech_type_, *muted);
208 return 0;
209 }
210
SetCodecs(const std::map<int,SdpAudioFormat> & codecs)211 void AcmReceiver::SetCodecs(const std::map<int, SdpAudioFormat>& codecs) {
212 neteq_->SetCodecs(codecs);
213 }
214
FlushBuffers()215 void AcmReceiver::FlushBuffers() {
216 neteq_->FlushBuffers();
217 }
218
RemoveAllCodecs()219 void AcmReceiver::RemoveAllCodecs() {
220 MutexLock lock(&mutex_);
221 neteq_->RemoveAllPayloadTypes();
222 last_decoder_ = absl::nullopt;
223 }
224
GetPlayoutTimestamp()225 absl::optional<uint32_t> AcmReceiver::GetPlayoutTimestamp() {
226 return neteq_->GetPlayoutTimestamp();
227 }
228
FilteredCurrentDelayMs() const229 int AcmReceiver::FilteredCurrentDelayMs() const {
230 return neteq_->FilteredCurrentDelayMs();
231 }
232
TargetDelayMs() const233 int AcmReceiver::TargetDelayMs() const {
234 return neteq_->TargetDelayMs();
235 }
236
LastDecoder() const237 absl::optional<std::pair<int, SdpAudioFormat>> AcmReceiver::LastDecoder()
238 const {
239 MutexLock lock(&mutex_);
240 if (!last_decoder_) {
241 return absl::nullopt;
242 }
243 RTC_DCHECK_NE(-1, last_decoder_->payload_type);
244 return std::make_pair(last_decoder_->payload_type, last_decoder_->sdp_format);
245 }
246
GetNetworkStatistics(NetworkStatistics * acm_stat) const247 void AcmReceiver::GetNetworkStatistics(NetworkStatistics* acm_stat) const {
248 NetEqNetworkStatistics neteq_stat;
249 // NetEq function always returns zero, so we don't check the return value.
250 neteq_->NetworkStatistics(&neteq_stat);
251
252 acm_stat->currentBufferSize = neteq_stat.current_buffer_size_ms;
253 acm_stat->preferredBufferSize = neteq_stat.preferred_buffer_size_ms;
254 acm_stat->jitterPeaksFound = neteq_stat.jitter_peaks_found ? true : false;
255 acm_stat->currentPacketLossRate = neteq_stat.packet_loss_rate;
256 acm_stat->currentExpandRate = neteq_stat.expand_rate;
257 acm_stat->currentSpeechExpandRate = neteq_stat.speech_expand_rate;
258 acm_stat->currentPreemptiveRate = neteq_stat.preemptive_rate;
259 acm_stat->currentAccelerateRate = neteq_stat.accelerate_rate;
260 acm_stat->currentSecondaryDecodedRate = neteq_stat.secondary_decoded_rate;
261 acm_stat->currentSecondaryDiscardedRate = neteq_stat.secondary_discarded_rate;
262 acm_stat->addedSamples = neteq_stat.added_zero_samples;
263 acm_stat->meanWaitingTimeMs = neteq_stat.mean_waiting_time_ms;
264 acm_stat->medianWaitingTimeMs = neteq_stat.median_waiting_time_ms;
265 acm_stat->minWaitingTimeMs = neteq_stat.min_waiting_time_ms;
266 acm_stat->maxWaitingTimeMs = neteq_stat.max_waiting_time_ms;
267
268 NetEqLifetimeStatistics neteq_lifetime_stat = neteq_->GetLifetimeStatistics();
269 acm_stat->totalSamplesReceived = neteq_lifetime_stat.total_samples_received;
270 acm_stat->concealedSamples = neteq_lifetime_stat.concealed_samples;
271 acm_stat->silentConcealedSamples =
272 neteq_lifetime_stat.silent_concealed_samples;
273 acm_stat->concealmentEvents = neteq_lifetime_stat.concealment_events;
274 acm_stat->jitterBufferDelayMs = neteq_lifetime_stat.jitter_buffer_delay_ms;
275 acm_stat->jitterBufferTargetDelayMs =
276 neteq_lifetime_stat.jitter_buffer_target_delay_ms;
277 acm_stat->jitterBufferEmittedCount =
278 neteq_lifetime_stat.jitter_buffer_emitted_count;
279 acm_stat->delayedPacketOutageSamples =
280 neteq_lifetime_stat.delayed_packet_outage_samples;
281 acm_stat->relativePacketArrivalDelayMs =
282 neteq_lifetime_stat.relative_packet_arrival_delay_ms;
283 acm_stat->interruptionCount = neteq_lifetime_stat.interruption_count;
284 acm_stat->totalInterruptionDurationMs =
285 neteq_lifetime_stat.total_interruption_duration_ms;
286 acm_stat->insertedSamplesForDeceleration =
287 neteq_lifetime_stat.inserted_samples_for_deceleration;
288 acm_stat->removedSamplesForAcceleration =
289 neteq_lifetime_stat.removed_samples_for_acceleration;
290 acm_stat->fecPacketsReceived = neteq_lifetime_stat.fec_packets_received;
291 acm_stat->fecPacketsDiscarded = neteq_lifetime_stat.fec_packets_discarded;
292
293 NetEqOperationsAndState neteq_operations_and_state =
294 neteq_->GetOperationsAndState();
295 acm_stat->packetBufferFlushes =
296 neteq_operations_and_state.packet_buffer_flushes;
297 }
298
EnableNack(size_t max_nack_list_size)299 int AcmReceiver::EnableNack(size_t max_nack_list_size) {
300 neteq_->EnableNack(max_nack_list_size);
301 return 0;
302 }
303
DisableNack()304 void AcmReceiver::DisableNack() {
305 neteq_->DisableNack();
306 }
307
GetNackList(int64_t round_trip_time_ms) const308 std::vector<uint16_t> AcmReceiver::GetNackList(
309 int64_t round_trip_time_ms) const {
310 return neteq_->GetNackList(round_trip_time_ms);
311 }
312
ResetInitialDelay()313 void AcmReceiver::ResetInitialDelay() {
314 neteq_->SetMinimumDelay(0);
315 // TODO(turajs): Should NetEq Buffer be flushed?
316 }
317
NowInTimestamp(int decoder_sampling_rate) const318 uint32_t AcmReceiver::NowInTimestamp(int decoder_sampling_rate) const {
319 // Down-cast the time to (32-6)-bit since we only care about
320 // the least significant bits. (32-6) bits cover 2^(32-6) = 67108864 ms.
321 // We masked 6 most significant bits of 32-bit so there is no overflow in
322 // the conversion from milliseconds to timestamp.
323 const uint32_t now_in_ms =
324 static_cast<uint32_t>(clock_->TimeInMilliseconds() & 0x03ffffff);
325 return static_cast<uint32_t>((decoder_sampling_rate / 1000) * now_in_ms);
326 }
327
GetDecodingCallStatistics(AudioDecodingCallStats * stats) const328 void AcmReceiver::GetDecodingCallStatistics(
329 AudioDecodingCallStats* stats) const {
330 MutexLock lock(&mutex_);
331 *stats = call_stats_.GetDecodingStatistics();
332 }
333
334 } // namespace acm2
335
336 } // namespace webrtc
337