1 /* 2 * Copyright (c) 2011 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 "gain_control_impl.h" 12 13 #include <cassert> 14 15 #include "critical_section_wrapper.h" 16 #include "gain_control.h" 17 18 #include "audio_processing_impl.h" 19 #include "audio_buffer.h" 20 21 namespace webrtc { 22 23 typedef void Handle; 24 25 /*template <class T> 26 class GainControlHandle : public ComponentHandle<T> { 27 public: 28 GainControlHandle(); 29 virtual ~GainControlHandle(); 30 31 virtual int Create(); 32 virtual T* ptr() const; 33 34 private: 35 T* handle; 36 };*/ 37 38 namespace { 39 WebRtc_Word16 MapSetting(GainControl::Mode mode) { 40 switch (mode) { 41 case GainControl::kAdaptiveAnalog: 42 return kAgcModeAdaptiveAnalog; 43 break; 44 case GainControl::kAdaptiveDigital: 45 return kAgcModeAdaptiveDigital; 46 break; 47 case GainControl::kFixedDigital: 48 return kAgcModeFixedDigital; 49 break; 50 default: 51 return -1; 52 } 53 } 54 } // namespace 55 56 GainControlImpl::GainControlImpl(const AudioProcessingImpl* apm) 57 : ProcessingComponent(apm), 58 apm_(apm), 59 mode_(kAdaptiveAnalog), 60 minimum_capture_level_(0), 61 maximum_capture_level_(255), 62 limiter_enabled_(true), 63 target_level_dbfs_(3), 64 compression_gain_db_(9), 65 analog_capture_level_(0), 66 was_analog_level_set_(false), 67 stream_is_saturated_(false) {} 68 69 GainControlImpl::~GainControlImpl() {} 70 71 int GainControlImpl::ProcessRenderAudio(AudioBuffer* audio) { 72 if (!is_component_enabled()) { 73 return apm_->kNoError; 74 } 75 76 assert(audio->samples_per_split_channel() <= 160); 77 78 WebRtc_Word16* mixed_data = audio->low_pass_split_data(0); 79 if (audio->num_channels() > 1) { 80 audio->CopyAndMixLowPass(1); 81 mixed_data = audio->mixed_low_pass_data(0); 82 } 83 84 for (int i = 0; i < num_handles(); i++) { 85 Handle* my_handle = static_cast<Handle*>(handle(i)); 86 int err = WebRtcAgc_AddFarend( 87 my_handle, 88 mixed_data, 89 static_cast<WebRtc_Word16>(audio->samples_per_split_channel())); 90 91 if (err != apm_->kNoError) { 92 return GetHandleError(my_handle); 93 } 94 } 95 96 return apm_->kNoError; 97 } 98 99 int GainControlImpl::AnalyzeCaptureAudio(AudioBuffer* audio) { 100 if (!is_component_enabled()) { 101 return apm_->kNoError; 102 } 103 104 assert(audio->samples_per_split_channel() <= 160); 105 assert(audio->num_channels() == num_handles()); 106 107 int err = apm_->kNoError; 108 109 if (mode_ == kAdaptiveAnalog) { 110 for (int i = 0; i < num_handles(); i++) { 111 Handle* my_handle = static_cast<Handle*>(handle(i)); 112 err = WebRtcAgc_AddMic( 113 my_handle, 114 audio->low_pass_split_data(i), 115 audio->high_pass_split_data(i), 116 static_cast<WebRtc_Word16>(audio->samples_per_split_channel())); 117 118 if (err != apm_->kNoError) { 119 return GetHandleError(my_handle); 120 } 121 } 122 } else if (mode_ == kAdaptiveDigital) { 123 124 for (int i = 0; i < num_handles(); i++) { 125 Handle* my_handle = static_cast<Handle*>(handle(i)); 126 WebRtc_Word32 capture_level_out = 0; 127 128 err = WebRtcAgc_VirtualMic( 129 my_handle, 130 audio->low_pass_split_data(i), 131 audio->high_pass_split_data(i), 132 static_cast<WebRtc_Word16>(audio->samples_per_split_channel()), 133 //capture_levels_[i], 134 analog_capture_level_, 135 &capture_level_out); 136 137 capture_levels_[i] = capture_level_out; 138 139 if (err != apm_->kNoError) { 140 return GetHandleError(my_handle); 141 } 142 143 } 144 } 145 146 return apm_->kNoError; 147 } 148 149 int GainControlImpl::ProcessCaptureAudio(AudioBuffer* audio) { 150 if (!is_component_enabled()) { 151 return apm_->kNoError; 152 } 153 154 if (mode_ == kAdaptiveAnalog && !was_analog_level_set_) { 155 return apm_->kStreamParameterNotSetError; 156 } 157 158 assert(audio->samples_per_split_channel() <= 160); 159 assert(audio->num_channels() == num_handles()); 160 161 stream_is_saturated_ = false; 162 for (int i = 0; i < num_handles(); i++) { 163 Handle* my_handle = static_cast<Handle*>(handle(i)); 164 WebRtc_Word32 capture_level_out = 0; 165 WebRtc_UWord8 saturation_warning = 0; 166 167 int err = WebRtcAgc_Process( 168 my_handle, 169 audio->low_pass_split_data(i), 170 audio->high_pass_split_data(i), 171 static_cast<WebRtc_Word16>(audio->samples_per_split_channel()), 172 audio->low_pass_split_data(i), 173 audio->high_pass_split_data(i), 174 capture_levels_[i], 175 &capture_level_out, 176 apm_->echo_cancellation()->stream_has_echo(), 177 &saturation_warning); 178 179 if (err != apm_->kNoError) { 180 return GetHandleError(my_handle); 181 } 182 183 capture_levels_[i] = capture_level_out; 184 if (saturation_warning == 1) { 185 stream_is_saturated_ = true; 186 } 187 } 188 189 if (mode_ == kAdaptiveAnalog) { 190 // Take the analog level to be the average across the handles. 191 analog_capture_level_ = 0; 192 for (int i = 0; i < num_handles(); i++) { 193 analog_capture_level_ += capture_levels_[i]; 194 } 195 196 analog_capture_level_ /= num_handles(); 197 } 198 199 was_analog_level_set_ = false; 200 return apm_->kNoError; 201 } 202 203 // TODO(ajm): ensure this is called under kAdaptiveAnalog. 204 int GainControlImpl::set_stream_analog_level(int level) { 205 was_analog_level_set_ = true; 206 if (level < minimum_capture_level_ || level > maximum_capture_level_) { 207 return apm_->kBadParameterError; 208 } 209 210 if (mode_ == kAdaptiveAnalog) { 211 if (level != analog_capture_level_) { 212 // The analog level has been changed; update our internal levels. 213 capture_levels_.assign(num_handles(), level); 214 } 215 } 216 analog_capture_level_ = level; 217 218 return apm_->kNoError; 219 } 220 221 int GainControlImpl::stream_analog_level() { 222 // TODO(ajm): enable this assertion? 223 //assert(mode_ == kAdaptiveAnalog); 224 225 return analog_capture_level_; 226 } 227 228 int GainControlImpl::Enable(bool enable) { 229 CriticalSectionScoped crit_scoped(*apm_->crit()); 230 return EnableComponent(enable); 231 } 232 233 bool GainControlImpl::is_enabled() const { 234 return is_component_enabled(); 235 } 236 237 int GainControlImpl::set_mode(Mode mode) { 238 CriticalSectionScoped crit_scoped(*apm_->crit()); 239 if (MapSetting(mode) == -1) { 240 return apm_->kBadParameterError; 241 } 242 243 mode_ = mode; 244 return Initialize(); 245 } 246 247 GainControl::Mode GainControlImpl::mode() const { 248 return mode_; 249 } 250 251 int GainControlImpl::set_analog_level_limits(int minimum, 252 int maximum) { 253 CriticalSectionScoped crit_scoped(*apm_->crit()); 254 if (minimum < 0) { 255 return apm_->kBadParameterError; 256 } 257 258 if (maximum > 65535) { 259 return apm_->kBadParameterError; 260 } 261 262 if (maximum < minimum) { 263 return apm_->kBadParameterError; 264 } 265 266 minimum_capture_level_ = minimum; 267 maximum_capture_level_ = maximum; 268 269 return Initialize(); 270 } 271 272 int GainControlImpl::analog_level_minimum() const { 273 return minimum_capture_level_; 274 } 275 276 int GainControlImpl::analog_level_maximum() const { 277 return maximum_capture_level_; 278 } 279 280 bool GainControlImpl::stream_is_saturated() const { 281 return stream_is_saturated_; 282 } 283 284 int GainControlImpl::set_target_level_dbfs(int level) { 285 CriticalSectionScoped crit_scoped(*apm_->crit()); 286 if (level > 31 || level < 0) { 287 return apm_->kBadParameterError; 288 } 289 290 target_level_dbfs_ = level; 291 return Configure(); 292 } 293 294 int GainControlImpl::target_level_dbfs() const { 295 return target_level_dbfs_; 296 } 297 298 int GainControlImpl::set_compression_gain_db(int gain) { 299 CriticalSectionScoped crit_scoped(*apm_->crit()); 300 if (gain < 0 || gain > 90) { 301 return apm_->kBadParameterError; 302 } 303 304 compression_gain_db_ = gain; 305 return Configure(); 306 } 307 308 int GainControlImpl::compression_gain_db() const { 309 return compression_gain_db_; 310 } 311 312 int GainControlImpl::enable_limiter(bool enable) { 313 CriticalSectionScoped crit_scoped(*apm_->crit()); 314 limiter_enabled_ = enable; 315 return Configure(); 316 } 317 318 bool GainControlImpl::is_limiter_enabled() const { 319 return limiter_enabled_; 320 } 321 322 int GainControlImpl::Initialize() { 323 int err = ProcessingComponent::Initialize(); 324 if (err != apm_->kNoError || !is_component_enabled()) { 325 return err; 326 } 327 328 analog_capture_level_ = 329 (maximum_capture_level_ - minimum_capture_level_) >> 1; 330 capture_levels_.assign(num_handles(), analog_capture_level_); 331 was_analog_level_set_ = false; 332 333 return apm_->kNoError; 334 } 335 336 int GainControlImpl::get_version(char* version, int version_len_bytes) const { 337 if (WebRtcAgc_Version(version, version_len_bytes) != 0) { 338 return apm_->kBadParameterError; 339 } 340 341 return apm_->kNoError; 342 } 343 344 void* GainControlImpl::CreateHandle() const { 345 Handle* handle = NULL; 346 if (WebRtcAgc_Create(&handle) != apm_->kNoError) { 347 handle = NULL; 348 } else { 349 assert(handle != NULL); 350 } 351 352 return handle; 353 } 354 355 int GainControlImpl::DestroyHandle(void* handle) const { 356 return WebRtcAgc_Free(static_cast<Handle*>(handle)); 357 } 358 359 int GainControlImpl::InitializeHandle(void* handle) const { 360 return WebRtcAgc_Init(static_cast<Handle*>(handle), 361 minimum_capture_level_, 362 maximum_capture_level_, 363 MapSetting(mode_), 364 apm_->sample_rate_hz()); 365 } 366 367 int GainControlImpl::ConfigureHandle(void* handle) const { 368 WebRtcAgc_config_t config; 369 // TODO(ajm): Flip the sign here (since AGC expects a positive value) if we 370 // change the interface. 371 //assert(target_level_dbfs_ <= 0); 372 //config.targetLevelDbfs = static_cast<WebRtc_Word16>(-target_level_dbfs_); 373 config.targetLevelDbfs = static_cast<WebRtc_Word16>(target_level_dbfs_); 374 config.compressionGaindB = 375 static_cast<WebRtc_Word16>(compression_gain_db_); 376 config.limiterEnable = limiter_enabled_; 377 378 return WebRtcAgc_set_config(static_cast<Handle*>(handle), config); 379 } 380 381 int GainControlImpl::num_handles_required() const { 382 return apm_->num_output_channels(); 383 } 384 385 int GainControlImpl::GetHandleError(void* handle) const { 386 // The AGC has no get_error() function. 387 // (Despite listing errors in its interface...) 388 assert(handle != NULL); 389 return apm_->kUnspecifiedError; 390 } 391 } // namespace webrtc 392
