blob: f871852b478bb0ae145233512874aae32c507b6b [file] [log] [blame]
niklase@google.com470e71d2011-07-07 08:21:25 +00001/*
bjornv@webrtc.org0c6f9312012-01-30 09:39:08 +00002 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
niklase@google.com470e71d2011-07-07 08:21:25 +00003 *
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
bjornv@webrtc.org21a2fc92013-02-15 17:01:03 +000011#include "webrtc/modules/audio_processing/echo_cancellation_impl.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000012
bjornv@webrtc.org21a2fc92013-02-15 17:01:03 +000013#include <assert.h>
niklase@google.com470e71d2011-07-07 08:21:25 +000014#include <string.h>
15
andrew@webrtc.org1760a172013-09-25 23:17:38 +000016extern "C" {
17#include "webrtc/modules/audio_processing/aec/aec_core.h"
18}
19#include "webrtc/modules/audio_processing/aec/include/echo_cancellation.h"
bjornv@webrtc.org21a2fc92013-02-15 17:01:03 +000020#include "webrtc/modules/audio_processing/audio_buffer.h"
bjornv@webrtc.org21a2fc92013-02-15 17:01:03 +000021#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
niklase@google.com470e71d2011-07-07 08:21:25 +000022
niklase@google.com470e71d2011-07-07 08:21:25 +000023namespace webrtc {
24
25typedef void Handle;
26
27namespace {
pbos@webrtc.orgb7192b82013-04-10 07:50:54 +000028int16_t MapSetting(EchoCancellation::SuppressionLevel level) {
niklase@google.com470e71d2011-07-07 08:21:25 +000029 switch (level) {
30 case EchoCancellation::kLowSuppression:
31 return kAecNlpConservative;
32 case EchoCancellation::kModerateSuppression:
33 return kAecNlpModerate;
34 case EchoCancellation::kHighSuppression:
35 return kAecNlpAggressive;
niklase@google.com470e71d2011-07-07 08:21:25 +000036 }
andrew@webrtc.org648af742012-02-08 01:57:29 +000037 assert(false);
mflodman@webrtc.org657b2a42012-02-06 11:06:01 +000038 return -1;
niklase@google.com470e71d2011-07-07 08:21:25 +000039}
40
andrew@webrtc.org648af742012-02-08 01:57:29 +000041AudioProcessing::Error MapError(int err) {
niklase@google.com470e71d2011-07-07 08:21:25 +000042 switch (err) {
43 case AEC_UNSUPPORTED_FUNCTION_ERROR:
44 return AudioProcessing::kUnsupportedFunctionError;
niklase@google.com470e71d2011-07-07 08:21:25 +000045 case AEC_BAD_PARAMETER_ERROR:
46 return AudioProcessing::kBadParameterError;
niklase@google.com470e71d2011-07-07 08:21:25 +000047 case AEC_BAD_PARAMETER_WARNING:
48 return AudioProcessing::kBadStreamParameterWarning;
niklase@google.com470e71d2011-07-07 08:21:25 +000049 default:
50 // AEC_UNSPECIFIED_ERROR
51 // AEC_UNINITIALIZED_ERROR
52 // AEC_NULL_POINTER_ERROR
53 return AudioProcessing::kUnspecifiedError;
54 }
55}
56} // namespace
57
andrew@webrtc.org56e4a052014-02-27 22:23:17 +000058EchoCancellationImpl::EchoCancellationImpl(const AudioProcessing* apm,
59 CriticalSectionWrapper* crit)
60 : ProcessingComponent(),
niklase@google.com470e71d2011-07-07 08:21:25 +000061 apm_(apm),
andrew@webrtc.org56e4a052014-02-27 22:23:17 +000062 crit_(crit),
niklase@google.com470e71d2011-07-07 08:21:25 +000063 drift_compensation_enabled_(false),
64 metrics_enabled_(false),
65 suppression_level_(kModerateSuppression),
niklase@google.com470e71d2011-07-07 08:21:25 +000066 stream_drift_samples_(0),
67 was_stream_drift_set_(false),
bjornv@google.com1ba3dbe2011-10-03 08:18:10 +000068 stream_has_echo_(false),
andrew@webrtc.org1760a172013-09-25 23:17:38 +000069 delay_logging_enabled_(false),
bjornv@webrtc.orge9d37602014-04-23 13:20:07 +000070 delay_correction_enabled_(false),
71 reported_delay_enabled_(true) {}
niklase@google.com470e71d2011-07-07 08:21:25 +000072
73EchoCancellationImpl::~EchoCancellationImpl() {}
74
75int EchoCancellationImpl::ProcessRenderAudio(const AudioBuffer* audio) {
76 if (!is_component_enabled()) {
77 return apm_->kNoError;
78 }
79
80 assert(audio->samples_per_split_channel() <= 160);
81 assert(audio->num_channels() == apm_->num_reverse_channels());
82
83 int err = apm_->kNoError;
84
85 // The ordering convention must be followed to pass to the correct AEC.
86 size_t handle_index = 0;
87 for (int i = 0; i < apm_->num_output_channels(); i++) {
88 for (int j = 0; j < audio->num_channels(); j++) {
89 Handle* my_handle = static_cast<Handle*>(handle(handle_index));
90 err = WebRtcAec_BufferFarend(
91 my_handle,
aluebs@webrtc.orga7384a12014-12-03 01:06:35 +000092 audio->split_data_const_f(j, kBand0To8kHz),
pbos@webrtc.orgb7192b82013-04-10 07:50:54 +000093 static_cast<int16_t>(audio->samples_per_split_channel()));
niklase@google.com470e71d2011-07-07 08:21:25 +000094
95 if (err != apm_->kNoError) {
96 return GetHandleError(my_handle); // TODO(ajm): warning possible?
97 }
98
99 handle_index++;
100 }
101 }
102
103 return apm_->kNoError;
104}
105
106int EchoCancellationImpl::ProcessCaptureAudio(AudioBuffer* audio) {
107 if (!is_component_enabled()) {
108 return apm_->kNoError;
109 }
110
111 if (!apm_->was_stream_delay_set()) {
112 return apm_->kStreamParameterNotSetError;
113 }
114
115 if (drift_compensation_enabled_ && !was_stream_drift_set_) {
116 return apm_->kStreamParameterNotSetError;
117 }
118
119 assert(audio->samples_per_split_channel() <= 160);
120 assert(audio->num_channels() == apm_->num_output_channels());
121
122 int err = apm_->kNoError;
123
124 // The ordering convention must be followed to pass to the correct AEC.
125 size_t handle_index = 0;
126 stream_has_echo_ = false;
127 for (int i = 0; i < audio->num_channels(); i++) {
128 for (int j = 0; j < apm_->num_reverse_channels(); j++) {
129 Handle* my_handle = handle(handle_index);
130 err = WebRtcAec_Process(
131 my_handle,
aluebs@webrtc.orga7384a12014-12-03 01:06:35 +0000132 audio->split_data_const_f(i, kBand0To8kHz),
133 audio->split_data_const_f(i, kBand8To16kHz),
134 audio->split_data_f(i, kBand0To8kHz),
135 audio->split_data_f(i, kBand8To16kHz),
pbos@webrtc.orgb7192b82013-04-10 07:50:54 +0000136 static_cast<int16_t>(audio->samples_per_split_channel()),
niklase@google.com470e71d2011-07-07 08:21:25 +0000137 apm_->stream_delay_ms(),
138 stream_drift_samples_);
139
140 if (err != apm_->kNoError) {
141 err = GetHandleError(my_handle);
142 // TODO(ajm): Figure out how to return warnings properly.
143 if (err != apm_->kBadStreamParameterWarning) {
144 return err;
145 }
146 }
147
bjornv@webrtc.org21a2fc92013-02-15 17:01:03 +0000148 int status = 0;
niklase@google.com470e71d2011-07-07 08:21:25 +0000149 err = WebRtcAec_get_echo_status(my_handle, &status);
150 if (err != apm_->kNoError) {
151 return GetHandleError(my_handle);
152 }
153
154 if (status == 1) {
155 stream_has_echo_ = true;
156 }
157
158 handle_index++;
159 }
160 }
161
162 was_stream_drift_set_ = false;
163 return apm_->kNoError;
164}
165
166int EchoCancellationImpl::Enable(bool enable) {
andrew@webrtc.org56e4a052014-02-27 22:23:17 +0000167 CriticalSectionScoped crit_scoped(crit_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000168 // Ensure AEC and AECM are not both enabled.
169 if (enable && apm_->echo_control_mobile()->is_enabled()) {
170 return apm_->kBadParameterError;
171 }
172
173 return EnableComponent(enable);
174}
175
176bool EchoCancellationImpl::is_enabled() const {
177 return is_component_enabled();
178}
179
180int EchoCancellationImpl::set_suppression_level(SuppressionLevel level) {
andrew@webrtc.org56e4a052014-02-27 22:23:17 +0000181 CriticalSectionScoped crit_scoped(crit_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000182 if (MapSetting(level) == -1) {
183 return apm_->kBadParameterError;
184 }
185
186 suppression_level_ = level;
187 return Configure();
188}
189
190EchoCancellation::SuppressionLevel EchoCancellationImpl::suppression_level()
191 const {
192 return suppression_level_;
193}
194
195int EchoCancellationImpl::enable_drift_compensation(bool enable) {
andrew@webrtc.org56e4a052014-02-27 22:23:17 +0000196 CriticalSectionScoped crit_scoped(crit_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000197 drift_compensation_enabled_ = enable;
198 return Configure();
199}
200
201bool EchoCancellationImpl::is_drift_compensation_enabled() const {
202 return drift_compensation_enabled_;
203}
204
andrew@webrtc.org6be1e932013-03-01 18:47:28 +0000205void EchoCancellationImpl::set_stream_drift_samples(int drift) {
niklase@google.com470e71d2011-07-07 08:21:25 +0000206 was_stream_drift_set_ = true;
207 stream_drift_samples_ = drift;
niklase@google.com470e71d2011-07-07 08:21:25 +0000208}
209
210int EchoCancellationImpl::stream_drift_samples() const {
211 return stream_drift_samples_;
212}
213
214int EchoCancellationImpl::enable_metrics(bool enable) {
andrew@webrtc.org56e4a052014-02-27 22:23:17 +0000215 CriticalSectionScoped crit_scoped(crit_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000216 metrics_enabled_ = enable;
217 return Configure();
218}
219
220bool EchoCancellationImpl::are_metrics_enabled() const {
221 return metrics_enabled_;
222}
223
224// TODO(ajm): we currently just use the metrics from the first AEC. Think more
225// aboue the best way to extend this to multi-channel.
226int EchoCancellationImpl::GetMetrics(Metrics* metrics) {
andrew@webrtc.org56e4a052014-02-27 22:23:17 +0000227 CriticalSectionScoped crit_scoped(crit_);
niklase@google.com470e71d2011-07-07 08:21:25 +0000228 if (metrics == NULL) {
229 return apm_->kNullPointerError;
230 }
231
232 if (!is_component_enabled() || !metrics_enabled_) {
233 return apm_->kNotEnabledError;
234 }
235
236 AecMetrics my_metrics;
237 memset(&my_metrics, 0, sizeof(my_metrics));
238 memset(metrics, 0, sizeof(Metrics));
239
240 Handle* my_handle = static_cast<Handle*>(handle(0));
241 int err = WebRtcAec_GetMetrics(my_handle, &my_metrics);
242 if (err != apm_->kNoError) {
243 return GetHandleError(my_handle);
244 }
245
246 metrics->residual_echo_return_loss.instant = my_metrics.rerl.instant;
247 metrics->residual_echo_return_loss.average = my_metrics.rerl.average;
248 metrics->residual_echo_return_loss.maximum = my_metrics.rerl.max;
249 metrics->residual_echo_return_loss.minimum = my_metrics.rerl.min;
250
251 metrics->echo_return_loss.instant = my_metrics.erl.instant;
252 metrics->echo_return_loss.average = my_metrics.erl.average;
253 metrics->echo_return_loss.maximum = my_metrics.erl.max;
254 metrics->echo_return_loss.minimum = my_metrics.erl.min;
255
256 metrics->echo_return_loss_enhancement.instant = my_metrics.erle.instant;
257 metrics->echo_return_loss_enhancement.average = my_metrics.erle.average;
258 metrics->echo_return_loss_enhancement.maximum = my_metrics.erle.max;
259 metrics->echo_return_loss_enhancement.minimum = my_metrics.erle.min;
260
261 metrics->a_nlp.instant = my_metrics.aNlp.instant;
262 metrics->a_nlp.average = my_metrics.aNlp.average;
263 metrics->a_nlp.maximum = my_metrics.aNlp.max;
264 metrics->a_nlp.minimum = my_metrics.aNlp.min;
265
266 return apm_->kNoError;
267}
268
269bool EchoCancellationImpl::stream_has_echo() const {
270 return stream_has_echo_;
271}
272
bjornv@google.com1ba3dbe2011-10-03 08:18:10 +0000273int EchoCancellationImpl::enable_delay_logging(bool enable) {
andrew@webrtc.org56e4a052014-02-27 22:23:17 +0000274 CriticalSectionScoped crit_scoped(crit_);
bjornv@google.com1ba3dbe2011-10-03 08:18:10 +0000275 delay_logging_enabled_ = enable;
276 return Configure();
277}
278
279bool EchoCancellationImpl::is_delay_logging_enabled() const {
280 return delay_logging_enabled_;
281}
282
283// TODO(bjornv): How should we handle the multi-channel case?
284int EchoCancellationImpl::GetDelayMetrics(int* median, int* std) {
andrew@webrtc.org56e4a052014-02-27 22:23:17 +0000285 CriticalSectionScoped crit_scoped(crit_);
bjornv@google.com1ba3dbe2011-10-03 08:18:10 +0000286 if (median == NULL) {
287 return apm_->kNullPointerError;
288 }
289 if (std == NULL) {
290 return apm_->kNullPointerError;
291 }
292
293 if (!is_component_enabled() || !delay_logging_enabled_) {
294 return apm_->kNotEnabledError;
295 }
296
297 Handle* my_handle = static_cast<Handle*>(handle(0));
298 if (WebRtcAec_GetDelayMetrics(my_handle, median, std) !=
299 apm_->kNoError) {
300 return GetHandleError(my_handle);
301 }
302
303 return apm_->kNoError;
304}
305
bjornv@webrtc.org91d11b32013-03-05 16:53:09 +0000306struct AecCore* EchoCancellationImpl::aec_core() const {
andrew@webrtc.org56e4a052014-02-27 22:23:17 +0000307 CriticalSectionScoped crit_scoped(crit_);
bjornv@webrtc.org91d11b32013-03-05 16:53:09 +0000308 if (!is_component_enabled()) {
309 return NULL;
310 }
311 Handle* my_handle = static_cast<Handle*>(handle(0));
312 return WebRtcAec_aec_core(my_handle);
313}
314
niklase@google.com470e71d2011-07-07 08:21:25 +0000315int EchoCancellationImpl::Initialize() {
316 int err = ProcessingComponent::Initialize();
317 if (err != apm_->kNoError || !is_component_enabled()) {
318 return err;
319 }
320
niklase@google.com470e71d2011-07-07 08:21:25 +0000321 return apm_->kNoError;
322}
323
andrew@webrtc.org1760a172013-09-25 23:17:38 +0000324void EchoCancellationImpl::SetExtraOptions(const Config& config) {
325 delay_correction_enabled_ = config.Get<DelayCorrection>().enabled;
bjornv@webrtc.org3f830722014-06-11 04:48:11 +0000326 reported_delay_enabled_ = config.Get<ReportedDelay>().enabled;
andrew@webrtc.org1760a172013-09-25 23:17:38 +0000327 Configure();
328}
329
niklase@google.com470e71d2011-07-07 08:21:25 +0000330void* EchoCancellationImpl::CreateHandle() const {
331 Handle* handle = NULL;
332 if (WebRtcAec_Create(&handle) != apm_->kNoError) {
333 handle = NULL;
334 } else {
335 assert(handle != NULL);
336 }
337
338 return handle;
339}
340
bjornv@webrtc.org5964fe02014-04-22 06:52:28 +0000341void EchoCancellationImpl::DestroyHandle(void* handle) const {
niklase@google.com470e71d2011-07-07 08:21:25 +0000342 assert(handle != NULL);
bjornv@webrtc.org5964fe02014-04-22 06:52:28 +0000343 WebRtcAec_Free(static_cast<Handle*>(handle));
niklase@google.com470e71d2011-07-07 08:21:25 +0000344}
345
346int EchoCancellationImpl::InitializeHandle(void* handle) const {
347 assert(handle != NULL);
andrew@webrtc.orgddbb8a22014-04-22 21:00:04 +0000348 // TODO(ajm): Drift compensation is disabled in practice. If restored, it
349 // should be managed internally and not depend on the hardware sample rate.
350 // For now, just hardcode a 48 kHz value.
niklase@google.com470e71d2011-07-07 08:21:25 +0000351 return WebRtcAec_Init(static_cast<Handle*>(handle),
andrew@webrtc.orgddbb8a22014-04-22 21:00:04 +0000352 apm_->proc_sample_rate_hz(),
353 48000);
niklase@google.com470e71d2011-07-07 08:21:25 +0000354}
355
356int EchoCancellationImpl::ConfigureHandle(void* handle) const {
357 assert(handle != NULL);
358 AecConfig config;
359 config.metricsMode = metrics_enabled_;
360 config.nlpMode = MapSetting(suppression_level_);
361 config.skewMode = drift_compensation_enabled_;
bjornv@google.com1ba3dbe2011-10-03 08:18:10 +0000362 config.delay_logging = delay_logging_enabled_;
niklase@google.com470e71d2011-07-07 08:21:25 +0000363
andrew@webrtc.org1760a172013-09-25 23:17:38 +0000364 WebRtcAec_enable_delay_correction(WebRtcAec_aec_core(
365 static_cast<Handle*>(handle)), delay_correction_enabled_ ? 1 : 0);
bjornv@webrtc.orge9d37602014-04-23 13:20:07 +0000366 WebRtcAec_enable_reported_delay(WebRtcAec_aec_core(
367 static_cast<Handle*>(handle)), reported_delay_enabled_ ? 1 : 0);
niklase@google.com470e71d2011-07-07 08:21:25 +0000368 return WebRtcAec_set_config(static_cast<Handle*>(handle), config);
369}
370
371int EchoCancellationImpl::num_handles_required() const {
372 return apm_->num_output_channels() *
373 apm_->num_reverse_channels();
374}
375
376int EchoCancellationImpl::GetHandleError(void* handle) const {
377 assert(handle != NULL);
378 return MapError(WebRtcAec_get_error_code(static_cast<Handle*>(handle)));
379}
380} // namespace webrtc