niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 1 | /* |
bjornv@webrtc.org | 0c6f931 | 2012-01-30 09:39:08 +0000 | [diff] [blame] | 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 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 06:47:31 +0200 | [diff] [blame] | 11 | #include "modules/audio_processing/gain_control_impl.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 12 | |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 13 | #include <cstdint> |
| 14 | |
Danil Chapovalov | db9f7ab | 2018-06-19 10:50:11 +0200 | [diff] [blame] | 15 | #include "absl/types/optional.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 16 | #include "modules/audio_processing/agc/legacy/gain_control.h" |
| 17 | #include "modules/audio_processing/audio_buffer.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 18 | #include "modules/audio_processing/include/audio_processing.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "modules/audio_processing/logging/apm_data_dumper.h" |
Yves Gerey | 988cc08 | 2018-10-23 12:03:01 +0200 | [diff] [blame] | 20 | #include "rtc_base/checks.h" |
Per Åhgren | 3daedb6 | 2019-11-22 12:11:40 +0100 | [diff] [blame] | 21 | #include "rtc_base/logging.h" |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 22 | #include "system_wrappers/include/field_trial.h" |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 23 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 24 | namespace webrtc { |
| 25 | |
| 26 | typedef void Handle; |
| 27 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 28 | namespace { |
pbos@webrtc.org | b7192b8 | 2013-04-10 07:50:54 +0000 | [diff] [blame] | 29 | int16_t MapSetting(GainControl::Mode mode) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 30 | switch (mode) { |
| 31 | case GainControl::kAdaptiveAnalog: |
| 32 | return kAgcModeAdaptiveAnalog; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 33 | case GainControl::kAdaptiveDigital: |
| 34 | return kAgcModeAdaptiveDigital; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 35 | case GainControl::kFixedDigital: |
| 36 | return kAgcModeFixedDigital; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 37 | } |
nisse | eb4ca4e | 2017-01-12 02:24:27 -0800 | [diff] [blame] | 38 | RTC_NOTREACHED(); |
mflodman@webrtc.org | 657b2a4 | 2012-02-06 11:06:01 +0000 | [diff] [blame] | 39 | return -1; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 40 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 41 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 42 | // Checks whether the legacy digital gain application should be used. |
| 43 | bool UseLegacyDigitalGainApplier() { |
| 44 | return field_trial::IsEnabled("WebRTC-UseLegacyDigitalGainApplier"); |
| 45 | } |
| 46 | |
| 47 | // Floating point variant of WebRtcAgc_Process. |
| 48 | void ApplyDigitalGain(const int32_t gains[11], |
| 49 | size_t num_bands, |
| 50 | float* const* out) { |
| 51 | constexpr float kScaling = 1.f / 65536.f; |
| 52 | constexpr int kNumSubSections = 16; |
| 53 | constexpr float kOneByNumSubSections = 1.f / kNumSubSections; |
| 54 | |
| 55 | float gains_scaled[11]; |
| 56 | for (int k = 0; k < 11; ++k) { |
| 57 | gains_scaled[k] = gains[k] * kScaling; |
| 58 | } |
| 59 | |
| 60 | for (size_t b = 0; b < num_bands; ++b) { |
| 61 | float* out_band = out[b]; |
| 62 | for (int k = 0, sample = 0; k < 10; ++k) { |
| 63 | const float delta = |
| 64 | (gains_scaled[k + 1] - gains_scaled[k]) * kOneByNumSubSections; |
| 65 | float gain = gains_scaled[k]; |
| 66 | for (int n = 0; n < kNumSubSections; ++n, ++sample) { |
| 67 | RTC_DCHECK_EQ(k * kNumSubSections + n, sample); |
| 68 | out_band[sample] *= gain; |
| 69 | out_band[sample] = |
| 70 | std::min(32767.f, std::max(-32768.f, out_band[sample])); |
| 71 | gain += delta; |
| 72 | } |
| 73 | } |
| 74 | } |
| 75 | } |
| 76 | |
peah | 2446e5a | 2015-11-18 06:11:13 -0800 | [diff] [blame] | 77 | } // namespace |
peah | 4d291f7 | 2015-11-16 23:52:25 -0800 | [diff] [blame] | 78 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 79 | struct GainControlImpl::MonoAgcState { |
| 80 | MonoAgcState() { |
| 81 | state = WebRtcAgc_Create(); |
| 82 | RTC_CHECK(state); |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 83 | } |
| 84 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 85 | ~MonoAgcState() { |
| 86 | RTC_DCHECK(state); |
| 87 | WebRtcAgc_Free(state); |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 88 | } |
| 89 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 90 | MonoAgcState(const MonoAgcState&) = delete; |
| 91 | MonoAgcState& operator=(const MonoAgcState&) = delete; |
| 92 | int32_t gains[11]; |
| 93 | Handle* state; |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 94 | }; |
| 95 | |
peah | 135259a | 2016-10-28 03:12:11 -0700 | [diff] [blame] | 96 | int GainControlImpl::instance_counter_ = 0; |
| 97 | |
Sam Zackrisson | f0d1c03 | 2019-03-27 13:28:08 +0100 | [diff] [blame] | 98 | GainControlImpl::GainControlImpl() |
| 99 | : data_dumper_(new ApmDataDumper(instance_counter_)), |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 100 | use_legacy_gain_applier_(UseLegacyDigitalGainApplier()), |
peah | 4d291f7 | 2015-11-16 23:52:25 -0800 | [diff] [blame] | 101 | mode_(kAdaptiveAnalog), |
| 102 | minimum_capture_level_(0), |
| 103 | maximum_capture_level_(255), |
| 104 | limiter_enabled_(true), |
| 105 | target_level_dbfs_(3), |
| 106 | compression_gain_db_(9), |
| 107 | analog_capture_level_(0), |
| 108 | was_analog_level_set_(false), |
Sam Zackrisson | f0d1c03 | 2019-03-27 13:28:08 +0100 | [diff] [blame] | 109 | stream_is_saturated_(false) {} |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 110 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 111 | GainControlImpl::~GainControlImpl() = default; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 112 | |
peah | 701d628 | 2016-10-25 05:42:20 -0700 | [diff] [blame] | 113 | void GainControlImpl::ProcessRenderAudio( |
| 114 | rtc::ArrayView<const int16_t> packed_render_audio) { |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 115 | for (size_t ch = 0; ch < mono_agcs_.size(); ++ch) { |
| 116 | WebRtcAgc_AddFarend(mono_agcs_[ch]->state, packed_render_audio.data(), |
peah | 701d628 | 2016-10-25 05:42:20 -0700 | [diff] [blame] | 117 | packed_render_audio.size()); |
peah | 4d291f7 | 2015-11-16 23:52:25 -0800 | [diff] [blame] | 118 | } |
| 119 | } |
| 120 | |
peah | 701d628 | 2016-10-25 05:42:20 -0700 | [diff] [blame] | 121 | void GainControlImpl::PackRenderAudioBuffer( |
Per Åhgren | e35b32c | 2019-11-22 18:22:04 +0100 | [diff] [blame] | 122 | const AudioBuffer& audio, |
peah | 701d628 | 2016-10-25 05:42:20 -0700 | [diff] [blame] | 123 | std::vector<int16_t>* packed_buffer) { |
Per Åhgren | e35b32c | 2019-11-22 18:22:04 +0100 | [diff] [blame] | 124 | RTC_DCHECK_GE(AudioBuffer::kMaxSplitFrameLength, audio.num_frames_per_band()); |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 125 | std::array<int16_t, AudioBuffer::kMaxSplitFrameLength> |
| 126 | mixed_16_kHz_render_data; |
| 127 | rtc::ArrayView<const int16_t> mixed_16_kHz_render( |
| 128 | mixed_16_kHz_render_data.data(), audio.num_frames_per_band()); |
Per Åhgren | e35b32c | 2019-11-22 18:22:04 +0100 | [diff] [blame] | 129 | if (audio.num_channels() == 1) { |
| 130 | FloatS16ToS16(audio.split_bands_const(0)[kBand0To8kHz], |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 131 | audio.num_frames_per_band(), mixed_16_kHz_render_data.data()); |
Per Åhgren | a135127 | 2019-08-15 12:15:46 +0200 | [diff] [blame] | 132 | } else { |
Per Åhgren | e35b32c | 2019-11-22 18:22:04 +0100 | [diff] [blame] | 133 | const int num_channels = static_cast<int>(audio.num_channels()); |
| 134 | for (size_t i = 0; i < audio.num_frames_per_band(); ++i) { |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 135 | int32_t sum = 0; |
| 136 | for (int ch = 0; ch < num_channels; ++ch) { |
| 137 | sum += FloatS16ToS16(audio.split_channels_const(kBand0To8kHz)[ch][i]); |
Per Åhgren | a135127 | 2019-08-15 12:15:46 +0200 | [diff] [blame] | 138 | } |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 139 | mixed_16_kHz_render_data[i] = sum / num_channels; |
Per Åhgren | a135127 | 2019-08-15 12:15:46 +0200 | [diff] [blame] | 140 | } |
Per Åhgren | a135127 | 2019-08-15 12:15:46 +0200 | [diff] [blame] | 141 | } |
| 142 | |
peah | 701d628 | 2016-10-25 05:42:20 -0700 | [diff] [blame] | 143 | packed_buffer->clear(); |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 144 | packed_buffer->insert( |
| 145 | packed_buffer->end(), mixed_16_kHz_render.data(), |
| 146 | (mixed_16_kHz_render.data() + audio.num_frames_per_band())); |
peah | 701d628 | 2016-10-25 05:42:20 -0700 | [diff] [blame] | 147 | } |
| 148 | |
Per Åhgren | e35b32c | 2019-11-22 18:22:04 +0100 | [diff] [blame] | 149 | int GainControlImpl::AnalyzeCaptureAudio(const AudioBuffer& audio) { |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 150 | RTC_DCHECK(num_proc_channels_); |
Per Åhgren | e35b32c | 2019-11-22 18:22:04 +0100 | [diff] [blame] | 151 | RTC_DCHECK_GE(AudioBuffer::kMaxSplitFrameLength, audio.num_frames_per_band()); |
| 152 | RTC_DCHECK_EQ(audio.num_channels(), *num_proc_channels_); |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 153 | RTC_DCHECK_LE(*num_proc_channels_, mono_agcs_.size()); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 154 | |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 155 | int16_t split_band_data[AudioBuffer::kMaxNumBands] |
| 156 | [AudioBuffer::kMaxSplitFrameLength]; |
| 157 | int16_t* split_bands[AudioBuffer::kMaxNumBands] = { |
| 158 | split_band_data[0], split_band_data[1], split_band_data[2]}; |
| 159 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 160 | if (mode_ == kAdaptiveAnalog) { |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 161 | for (size_t ch = 0; ch < mono_agcs_.size(); ++ch) { |
| 162 | capture_levels_[ch] = analog_capture_level_; |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 163 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 164 | audio.ExportSplitChannelData(ch, split_bands); |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 165 | |
| 166 | int err = |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 167 | WebRtcAgc_AddMic(mono_agcs_[ch]->state, split_bands, |
Per Åhgren | e35b32c | 2019-11-22 18:22:04 +0100 | [diff] [blame] | 168 | audio.num_bands(), audio.num_frames_per_band()); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 169 | |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 170 | if (err != AudioProcessing::kNoError) { |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 171 | return AudioProcessing::kUnspecifiedError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 172 | } |
| 173 | } |
| 174 | } else if (mode_ == kAdaptiveDigital) { |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 175 | for (size_t ch = 0; ch < mono_agcs_.size(); ++ch) { |
pbos@webrtc.org | b7192b8 | 2013-04-10 07:50:54 +0000 | [diff] [blame] | 176 | int32_t capture_level_out = 0; |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 177 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 178 | audio.ExportSplitChannelData(ch, split_bands); |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 179 | |
| 180 | int err = |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 181 | WebRtcAgc_VirtualMic(mono_agcs_[ch]->state, split_bands, |
Per Åhgren | e35b32c | 2019-11-22 18:22:04 +0100 | [diff] [blame] | 182 | audio.num_bands(), audio.num_frames_per_band(), |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 183 | analog_capture_level_, &capture_level_out); |
| 184 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 185 | capture_levels_[ch] = capture_level_out; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 186 | |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 187 | if (err != AudioProcessing::kNoError) { |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 188 | return AudioProcessing::kUnspecifiedError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 189 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 190 | } |
| 191 | } |
| 192 | |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 193 | return AudioProcessing::kNoError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 194 | } |
| 195 | |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 196 | int GainControlImpl::ProcessCaptureAudio(AudioBuffer* audio, |
| 197 | bool stream_has_echo) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 198 | if (mode_ == kAdaptiveAnalog && !was_analog_level_set_) { |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 199 | return AudioProcessing::kStreamParameterNotSetError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 200 | } |
| 201 | |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 202 | RTC_DCHECK(num_proc_channels_); |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 203 | RTC_DCHECK_GE(AudioBuffer::kMaxSplitFrameLength, |
| 204 | audio->num_frames_per_band()); |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 205 | RTC_DCHECK_EQ(audio->num_channels(), *num_proc_channels_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 206 | |
| 207 | stream_is_saturated_ = false; |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 208 | bool error_reported = false; |
| 209 | for (size_t ch = 0; ch < mono_agcs_.size(); ++ch) { |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 210 | int16_t split_band_data[AudioBuffer::kMaxNumBands] |
| 211 | [AudioBuffer::kMaxSplitFrameLength]; |
| 212 | int16_t* split_bands[AudioBuffer::kMaxNumBands] = { |
| 213 | split_band_data[0], split_band_data[1], split_band_data[2]}; |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 214 | audio->ExportSplitChannelData(ch, split_bands); |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 215 | |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 216 | // The call to stream_has_echo() is ok from a deadlock perspective |
| 217 | // as the capture lock is allready held. |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 218 | int32_t new_capture_level = 0; |
| 219 | uint8_t saturation_warning = 0; |
| 220 | int err_analyze = WebRtcAgc_Analyze( |
| 221 | mono_agcs_[ch]->state, split_bands, audio->num_bands(), |
| 222 | audio->num_frames_per_band(), capture_levels_[ch], &new_capture_level, |
| 223 | stream_has_echo, &saturation_warning, mono_agcs_[ch]->gains); |
| 224 | capture_levels_[ch] = new_capture_level; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 225 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 226 | error_reported = error_reported || err_analyze != AudioProcessing::kNoError; |
Per Åhgren | 928146f | 2019-08-20 09:19:21 +0200 | [diff] [blame] | 227 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 228 | stream_is_saturated_ = stream_is_saturated_ || saturation_warning == 1; |
| 229 | } |
| 230 | |
| 231 | // Choose the minimun gain for application |
| 232 | size_t index_to_apply = 0; |
| 233 | for (size_t ch = 1; ch < mono_agcs_.size(); ++ch) { |
| 234 | if (mono_agcs_[index_to_apply]->gains[10] < mono_agcs_[ch]->gains[10]) { |
| 235 | index_to_apply = ch; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 236 | } |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 237 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 238 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 239 | if (use_legacy_gain_applier_) { |
| 240 | for (size_t ch = 0; ch < mono_agcs_.size(); ++ch) { |
| 241 | int16_t split_band_data[AudioBuffer::kMaxNumBands] |
| 242 | [AudioBuffer::kMaxSplitFrameLength]; |
| 243 | int16_t* split_bands[AudioBuffer::kMaxNumBands] = { |
| 244 | split_band_data[0], split_band_data[1], split_band_data[2]}; |
| 245 | audio->ExportSplitChannelData(ch, split_bands); |
| 246 | |
| 247 | int err_process = WebRtcAgc_Process( |
| 248 | mono_agcs_[ch]->state, mono_agcs_[index_to_apply]->gains, split_bands, |
| 249 | audio->num_bands(), split_bands); |
| 250 | RTC_DCHECK_EQ(err_process, 0); |
| 251 | |
| 252 | audio->ImportSplitChannelData(ch, split_bands); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 253 | } |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 254 | } else { |
| 255 | for (size_t ch = 0; ch < mono_agcs_.size(); ++ch) { |
| 256 | ApplyDigitalGain(mono_agcs_[index_to_apply]->gains, audio->num_bands(), |
| 257 | audio->split_bands(ch)); |
| 258 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 259 | } |
| 260 | |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 261 | RTC_DCHECK_LT(0ul, *num_proc_channels_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 262 | if (mode_ == kAdaptiveAnalog) { |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 263 | // Take the analog level to be the minimum accross all channels. |
| 264 | analog_capture_level_ = capture_levels_[0]; |
| 265 | for (size_t ch = 1; ch < mono_agcs_.size(); ++ch) { |
| 266 | analog_capture_level_ = |
| 267 | std::min(analog_capture_level_, capture_levels_[ch]); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 268 | } |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 269 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 270 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 271 | if (error_reported) { |
| 272 | return AudioProcessing::kUnspecifiedError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 273 | } |
| 274 | |
| 275 | was_analog_level_set_ = false; |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 276 | |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 277 | return AudioProcessing::kNoError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 278 | } |
| 279 | |
aluebs | 11d4a42 | 2016-04-28 14:58:32 -0700 | [diff] [blame] | 280 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 281 | // TODO(ajm): ensure this is called under kAdaptiveAnalog. |
| 282 | int GainControlImpl::set_stream_analog_level(int level) { |
peah | 135259a | 2016-10-28 03:12:11 -0700 | [diff] [blame] | 283 | data_dumper_->DumpRaw("gain_control_set_stream_analog_level", 1, &level); |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 284 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 285 | was_analog_level_set_ = true; |
| 286 | if (level < minimum_capture_level_ || level > maximum_capture_level_) { |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 287 | return AudioProcessing::kBadParameterError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 288 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 289 | analog_capture_level_ = level; |
| 290 | |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 291 | return AudioProcessing::kNoError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 292 | } |
| 293 | |
Sam Zackrisson | f0d1c03 | 2019-03-27 13:28:08 +0100 | [diff] [blame] | 294 | int GainControlImpl::stream_analog_level() const { |
peah | 135259a | 2016-10-28 03:12:11 -0700 | [diff] [blame] | 295 | data_dumper_->DumpRaw("gain_control_stream_analog_level", 1, |
| 296 | &analog_capture_level_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 297 | return analog_capture_level_; |
| 298 | } |
| 299 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 300 | int GainControlImpl::set_mode(Mode mode) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 301 | if (MapSetting(mode) == -1) { |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 302 | return AudioProcessing::kBadParameterError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 303 | } |
| 304 | |
| 305 | mode_ = mode; |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 306 | RTC_DCHECK(num_proc_channels_); |
| 307 | RTC_DCHECK(sample_rate_hz_); |
| 308 | Initialize(*num_proc_channels_, *sample_rate_hz_); |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 309 | return AudioProcessing::kNoError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 310 | } |
| 311 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 312 | |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 313 | int GainControlImpl::set_analog_level_limits(int minimum, int maximum) { |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 314 | if (minimum < 0 || maximum > 65535 || maximum < minimum) { |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 315 | return AudioProcessing::kBadParameterError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 316 | } |
| 317 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 318 | minimum_capture_level_ = minimum; |
| 319 | maximum_capture_level_ = maximum; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 320 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 321 | RTC_DCHECK(num_proc_channels_); |
| 322 | RTC_DCHECK(sample_rate_hz_); |
| 323 | Initialize(*num_proc_channels_, *sample_rate_hz_); |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 324 | return AudioProcessing::kNoError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 325 | } |
| 326 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 327 | |
| 328 | int GainControlImpl::set_target_level_dbfs(int level) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 329 | if (level > 31 || level < 0) { |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 330 | return AudioProcessing::kBadParameterError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 331 | } |
Sam Zackrisson | 421c859 | 2019-02-11 13:39:46 +0100 | [diff] [blame] | 332 | target_level_dbfs_ = level; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 333 | return Configure(); |
| 334 | } |
| 335 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 336 | int GainControlImpl::set_compression_gain_db(int gain) { |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 337 | if (gain < 0 || gain > 90) { |
Per Åhgren | 3daedb6 | 2019-11-22 12:11:40 +0100 | [diff] [blame] | 338 | RTC_LOG(LS_ERROR) << "set_compression_gain_db(" << gain << ") failed."; |
peah | df3efa8 | 2015-11-28 12:35:15 -0800 | [diff] [blame] | 339 | return AudioProcessing::kBadParameterError; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 340 | } |
Sam Zackrisson | 421c859 | 2019-02-11 13:39:46 +0100 | [diff] [blame] | 341 | compression_gain_db_ = gain; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 342 | return Configure(); |
| 343 | } |
| 344 | |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 345 | int GainControlImpl::enable_limiter(bool enable) { |
Sam Zackrisson | 421c859 | 2019-02-11 13:39:46 +0100 | [diff] [blame] | 346 | limiter_enabled_ = enable; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 347 | return Configure(); |
| 348 | } |
| 349 | |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 350 | void GainControlImpl::Initialize(size_t num_proc_channels, int sample_rate_hz) { |
peah | 135259a | 2016-10-28 03:12:11 -0700 | [diff] [blame] | 351 | data_dumper_->InitiateNewSetOfRecordings(); |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 352 | |
Per Åhgren | 27bd76b | 2019-11-26 09:23:45 +0100 | [diff] [blame] | 353 | RTC_DCHECK(sample_rate_hz == 16000 || sample_rate_hz == 32000 || |
| 354 | sample_rate_hz == 48000); |
| 355 | |
Oskar Sundbom | aa8b67d | 2017-11-17 14:34:48 +0100 | [diff] [blame] | 356 | num_proc_channels_ = num_proc_channels; |
| 357 | sample_rate_hz_ = sample_rate_hz; |
peah | b8fbb54 | 2016-03-15 02:28:08 -0700 | [diff] [blame] | 358 | |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 359 | mono_agcs_.resize(*num_proc_channels_); |
| 360 | capture_levels_.resize(*num_proc_channels_); |
| 361 | for (size_t ch = 0; ch < mono_agcs_.size(); ++ch) { |
| 362 | if (!mono_agcs_[ch]) { |
| 363 | mono_agcs_[ch].reset(new MonoAgcState()); |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 364 | } |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 365 | |
| 366 | int error = WebRtcAgc_Init(mono_agcs_[ch]->state, minimum_capture_level_, |
| 367 | maximum_capture_level_, MapSetting(mode_), |
| 368 | *sample_rate_hz_); |
| 369 | RTC_DCHECK_EQ(error, 0); |
| 370 | capture_levels_[ch] = analog_capture_level_; |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 371 | } |
| 372 | |
| 373 | Configure(); |
peah | 4d291f7 | 2015-11-16 23:52:25 -0800 | [diff] [blame] | 374 | } |
| 375 | |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 376 | int GainControlImpl::Configure() { |
pbos@webrtc.org | e468bc9 | 2014-12-18 09:11:33 +0000 | [diff] [blame] | 377 | WebRtcAgcConfig config; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 378 | // TODO(ajm): Flip the sign here (since AGC expects a positive value) if we |
| 379 | // change the interface. |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 380 | // RTC_DCHECK_LE(target_level_dbfs_, 0); |
| 381 | // config.targetLevelDbfs = static_cast<int16_t>(-target_level_dbfs_); |
pbos@webrtc.org | b7192b8 | 2013-04-10 07:50:54 +0000 | [diff] [blame] | 382 | config.targetLevelDbfs = static_cast<int16_t>(target_level_dbfs_); |
Yves Gerey | 665174f | 2018-06-19 15:03:05 +0200 | [diff] [blame] | 383 | config.compressionGaindB = static_cast<int16_t>(compression_gain_db_); |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 384 | config.limiterEnable = limiter_enabled_; |
| 385 | |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 386 | int error = AudioProcessing::kNoError; |
Per Åhgren | 77dc199 | 2019-11-23 00:14:31 +0100 | [diff] [blame] | 387 | for (size_t ch = 0; ch < mono_agcs_.size(); ++ch) { |
| 388 | int error_ch = WebRtcAgc_set_config(mono_agcs_[ch]->state, config); |
| 389 | if (error_ch != AudioProcessing::kNoError) { |
| 390 | error = error_ch; |
peah | bfa9711 | 2016-03-10 21:09:04 -0800 | [diff] [blame] | 391 | } |
| 392 | } |
| 393 | return error; |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 394 | } |
niklase@google.com | 470e71d | 2011-07-07 08:21:25 +0000 | [diff] [blame] | 395 | } // namespace webrtc |