1 /* 2 * Copyright (c) 2012 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 "webrtc/modules/audio_processing/gain_control_impl.h" 12 13 #include <assert.h> 14 15 #include "webrtc/modules/audio_processing/audio_buffer.h" 16 #include "webrtc/modules/audio_processing/agc/legacy/gain_control.h" 17 18 namespace webrtc { 19 20 typedef void Handle; 21 22 namespace { 23 int16_t MapSetting(GainControl::Mode mode) { 24 switch (mode) { 25 case GainControl::kAdaptiveAnalog: 26 return kAgcModeAdaptiveAnalog; 27 case GainControl::kAdaptiveDigital: 28 return kAgcModeAdaptiveDigital; 29 case GainControl::kFixedDigital: 30 return kAgcModeFixedDigital; 31 } 32 assert(false); 33 return -1; 34 } 35 36 // Maximum length that a frame of samples can have. 37 static const size_t kMaxAllowedValuesOfSamplesPerFrame = 160; 38 // Maximum number of frames to buffer in the render queue. 39 // TODO(peah): Decrease this once we properly handle hugely unbalanced 40 // reverse and forward call numbers. 41 static const size_t kMaxNumFramesToBuffer = 100; 42 43 } // namespace 44 45 GainControlImpl::GainControlImpl(const AudioProcessing* apm, 46 rtc::CriticalSection* crit_render, 47 rtc::CriticalSection* crit_capture) 48 : ProcessingComponent(), 49 apm_(apm), 50 crit_render_(crit_render), 51 crit_capture_(crit_capture), 52 mode_(kAdaptiveAnalog), 53 minimum_capture_level_(0), 54 maximum_capture_level_(255), 55 limiter_enabled_(true), 56 target_level_dbfs_(3), 57 compression_gain_db_(9), 58 analog_capture_level_(0), 59 was_analog_level_set_(false), 60 stream_is_saturated_(false), 61 render_queue_element_max_size_(0) { 62 RTC_DCHECK(apm); 63 RTC_DCHECK(crit_render); 64 RTC_DCHECK(crit_capture); 65 } 66 67 GainControlImpl::~GainControlImpl() {} 68 69 int GainControlImpl::ProcessRenderAudio(AudioBuffer* audio) { 70 rtc::CritScope cs(crit_render_); 71 if (!is_component_enabled()) { 72 return AudioProcessing::kNoError; 73 } 74 75 assert(audio->num_frames_per_band() <= 160); 76 77 render_queue_buffer_.resize(0); 78 for (size_t i = 0; i < num_handles(); i++) { 79 Handle* my_handle = static_cast<Handle*>(handle(i)); 80 int err = 81 WebRtcAgc_GetAddFarendError(my_handle, audio->num_frames_per_band()); 82 83 if (err != AudioProcessing::kNoError) 84 return GetHandleError(my_handle); 85 86 // Buffer the samples in the render queue. 87 render_queue_buffer_.insert( 88 render_queue_buffer_.end(), audio->mixed_low_pass_data(), 89 (audio->mixed_low_pass_data() + audio->num_frames_per_band())); 90 } 91 92 // Insert the samples into the queue. 93 if (!render_signal_queue_->Insert(&render_queue_buffer_)) { 94 // The data queue is full and needs to be emptied. 95 ReadQueuedRenderData(); 96 97 // Retry the insert (should always work). 98 RTC_DCHECK_EQ(render_signal_queue_->Insert(&render_queue_buffer_), true); 99 } 100 101 return AudioProcessing::kNoError; 102 } 103 104 // Read chunks of data that were received and queued on the render side from 105 // a queue. All the data chunks are buffered into the farend signal of the AGC. 106 void GainControlImpl::ReadQueuedRenderData() { 107 rtc::CritScope cs(crit_capture_); 108 109 if (!is_component_enabled()) { 110 return; 111 } 112 113 while (render_signal_queue_->Remove(&capture_queue_buffer_)) { 114 size_t buffer_index = 0; 115 const size_t num_frames_per_band = 116 capture_queue_buffer_.size() / num_handles(); 117 for (size_t i = 0; i < num_handles(); i++) { 118 Handle* my_handle = static_cast<Handle*>(handle(i)); 119 WebRtcAgc_AddFarend(my_handle, &capture_queue_buffer_[buffer_index], 120 num_frames_per_band); 121 122 buffer_index += num_frames_per_band; 123 } 124 } 125 } 126 127 int GainControlImpl::AnalyzeCaptureAudio(AudioBuffer* audio) { 128 rtc::CritScope cs(crit_capture_); 129 130 if (!is_component_enabled()) { 131 return AudioProcessing::kNoError; 132 } 133 134 assert(audio->num_frames_per_band() <= 160); 135 assert(audio->num_channels() == num_handles()); 136 137 int err = AudioProcessing::kNoError; 138 139 if (mode_ == kAdaptiveAnalog) { 140 capture_levels_.assign(num_handles(), analog_capture_level_); 141 for (size_t i = 0; i < num_handles(); i++) { 142 Handle* my_handle = static_cast<Handle*>(handle(i)); 143 err = WebRtcAgc_AddMic( 144 my_handle, 145 audio->split_bands(i), 146 audio->num_bands(), 147 audio->num_frames_per_band()); 148 149 if (err != AudioProcessing::kNoError) { 150 return GetHandleError(my_handle); 151 } 152 } 153 } else if (mode_ == kAdaptiveDigital) { 154 155 for (size_t i = 0; i < num_handles(); i++) { 156 Handle* my_handle = static_cast<Handle*>(handle(i)); 157 int32_t capture_level_out = 0; 158 159 err = WebRtcAgc_VirtualMic( 160 my_handle, 161 audio->split_bands(i), 162 audio->num_bands(), 163 audio->num_frames_per_band(), 164 analog_capture_level_, 165 &capture_level_out); 166 167 capture_levels_[i] = capture_level_out; 168 169 if (err != AudioProcessing::kNoError) { 170 return GetHandleError(my_handle); 171 } 172 173 } 174 } 175 176 return AudioProcessing::kNoError; 177 } 178 179 int GainControlImpl::ProcessCaptureAudio(AudioBuffer* audio) { 180 rtc::CritScope cs(crit_capture_); 181 182 if (!is_component_enabled()) { 183 return AudioProcessing::kNoError; 184 } 185 186 if (mode_ == kAdaptiveAnalog && !was_analog_level_set_) { 187 return AudioProcessing::kStreamParameterNotSetError; 188 } 189 190 assert(audio->num_frames_per_band() <= 160); 191 assert(audio->num_channels() == num_handles()); 192 193 stream_is_saturated_ = false; 194 for (size_t i = 0; i < num_handles(); i++) { 195 Handle* my_handle = static_cast<Handle*>(handle(i)); 196 int32_t capture_level_out = 0; 197 uint8_t saturation_warning = 0; 198 199 // The call to stream_has_echo() is ok from a deadlock perspective 200 // as the capture lock is allready held. 201 int err = WebRtcAgc_Process( 202 my_handle, 203 audio->split_bands_const(i), 204 audio->num_bands(), 205 audio->num_frames_per_band(), 206 audio->split_bands(i), 207 capture_levels_[i], 208 &capture_level_out, 209 apm_->echo_cancellation()->stream_has_echo(), 210 &saturation_warning); 211 212 if (err != AudioProcessing::kNoError) { 213 return GetHandleError(my_handle); 214 } 215 216 capture_levels_[i] = capture_level_out; 217 if (saturation_warning == 1) { 218 stream_is_saturated_ = true; 219 } 220 } 221 222 if (mode_ == kAdaptiveAnalog) { 223 // Take the analog level to be the average across the handles. 224 analog_capture_level_ = 0; 225 for (size_t i = 0; i < num_handles(); i++) { 226 analog_capture_level_ += capture_levels_[i]; 227 } 228 229 analog_capture_level_ /= num_handles(); 230 } 231 232 was_analog_level_set_ = false; 233 return AudioProcessing::kNoError; 234 } 235 236 // TODO(ajm): ensure this is called under kAdaptiveAnalog. 237 int GainControlImpl::set_stream_analog_level(int level) { 238 rtc::CritScope cs(crit_capture_); 239 240 was_analog_level_set_ = true; 241 if (level < minimum_capture_level_ || level > maximum_capture_level_) { 242 return AudioProcessing::kBadParameterError; 243 } 244 analog_capture_level_ = level; 245 246 return AudioProcessing::kNoError; 247 } 248 249 int GainControlImpl::stream_analog_level() { 250 rtc::CritScope cs(crit_capture_); 251 // TODO(ajm): enable this assertion? 252 //assert(mode_ == kAdaptiveAnalog); 253 254 return analog_capture_level_; 255 } 256 257 int GainControlImpl::Enable(bool enable) { 258 rtc::CritScope cs_render(crit_render_); 259 rtc::CritScope cs_capture(crit_capture_); 260 return EnableComponent(enable); 261 } 262 263 bool GainControlImpl::is_enabled() const { 264 rtc::CritScope cs(crit_capture_); 265 return is_component_enabled(); 266 } 267 268 int GainControlImpl::set_mode(Mode mode) { 269 rtc::CritScope cs_render(crit_render_); 270 rtc::CritScope cs_capture(crit_capture_); 271 if (MapSetting(mode) == -1) { 272 return AudioProcessing::kBadParameterError; 273 } 274 275 mode_ = mode; 276 return Initialize(); 277 } 278 279 GainControl::Mode GainControlImpl::mode() const { 280 rtc::CritScope cs(crit_capture_); 281 return mode_; 282 } 283 284 int GainControlImpl::set_analog_level_limits(int minimum, 285 int maximum) { 286 rtc::CritScope cs(crit_capture_); 287 if (minimum < 0) { 288 return AudioProcessing::kBadParameterError; 289 } 290 291 if (maximum > 65535) { 292 return AudioProcessing::kBadParameterError; 293 } 294 295 if (maximum < minimum) { 296 return AudioProcessing::kBadParameterError; 297 } 298 299 minimum_capture_level_ = minimum; 300 maximum_capture_level_ = maximum; 301 302 return Initialize(); 303 } 304 305 int GainControlImpl::analog_level_minimum() const { 306 rtc::CritScope cs(crit_capture_); 307 return minimum_capture_level_; 308 } 309 310 int GainControlImpl::analog_level_maximum() const { 311 rtc::CritScope cs(crit_capture_); 312 return maximum_capture_level_; 313 } 314 315 bool GainControlImpl::stream_is_saturated() const { 316 rtc::CritScope cs(crit_capture_); 317 return stream_is_saturated_; 318 } 319 320 int GainControlImpl::set_target_level_dbfs(int level) { 321 rtc::CritScope cs(crit_capture_); 322 if (level > 31 || level < 0) { 323 return AudioProcessing::kBadParameterError; 324 } 325 326 target_level_dbfs_ = level; 327 return Configure(); 328 } 329 330 int GainControlImpl::target_level_dbfs() const { 331 rtc::CritScope cs(crit_capture_); 332 return target_level_dbfs_; 333 } 334 335 int GainControlImpl::set_compression_gain_db(int gain) { 336 rtc::CritScope cs(crit_capture_); 337 if (gain < 0 || gain > 90) { 338 return AudioProcessing::kBadParameterError; 339 } 340 341 compression_gain_db_ = gain; 342 return Configure(); 343 } 344 345 int GainControlImpl::compression_gain_db() const { 346 rtc::CritScope cs(crit_capture_); 347 return compression_gain_db_; 348 } 349 350 int GainControlImpl::enable_limiter(bool enable) { 351 rtc::CritScope cs(crit_capture_); 352 limiter_enabled_ = enable; 353 return Configure(); 354 } 355 356 bool GainControlImpl::is_limiter_enabled() const { 357 rtc::CritScope cs(crit_capture_); 358 return limiter_enabled_; 359 } 360 361 int GainControlImpl::Initialize() { 362 int err = ProcessingComponent::Initialize(); 363 if (err != AudioProcessing::kNoError || !is_component_enabled()) { 364 return err; 365 } 366 367 AllocateRenderQueue(); 368 369 rtc::CritScope cs_capture(crit_capture_); 370 const int n = num_handles(); 371 RTC_CHECK_GE(n, 0) << "Bad number of handles: " << n; 372 373 capture_levels_.assign(n, analog_capture_level_); 374 return AudioProcessing::kNoError; 375 } 376 377 void GainControlImpl::AllocateRenderQueue() { 378 const size_t new_render_queue_element_max_size = 379 std::max<size_t>(static_cast<size_t>(1), 380 kMaxAllowedValuesOfSamplesPerFrame * num_handles()); 381 382 rtc::CritScope cs_render(crit_render_); 383 rtc::CritScope cs_capture(crit_capture_); 384 385 if (render_queue_element_max_size_ < new_render_queue_element_max_size) { 386 render_queue_element_max_size_ = new_render_queue_element_max_size; 387 std::vector<int16_t> template_queue_element(render_queue_element_max_size_); 388 389 render_signal_queue_.reset( 390 new SwapQueue<std::vector<int16_t>, RenderQueueItemVerifier<int16_t>>( 391 kMaxNumFramesToBuffer, template_queue_element, 392 RenderQueueItemVerifier<int16_t>(render_queue_element_max_size_))); 393 394 render_queue_buffer_.resize(render_queue_element_max_size_); 395 capture_queue_buffer_.resize(render_queue_element_max_size_); 396 } else { 397 render_signal_queue_->Clear(); 398 } 399 } 400 401 void* GainControlImpl::CreateHandle() const { 402 return WebRtcAgc_Create(); 403 } 404 405 void GainControlImpl::DestroyHandle(void* handle) const { 406 WebRtcAgc_Free(static_cast<Handle*>(handle)); 407 } 408 409 int GainControlImpl::InitializeHandle(void* handle) const { 410 rtc::CritScope cs_render(crit_render_); 411 rtc::CritScope cs_capture(crit_capture_); 412 413 return WebRtcAgc_Init(static_cast<Handle*>(handle), 414 minimum_capture_level_, 415 maximum_capture_level_, 416 MapSetting(mode_), 417 apm_->proc_sample_rate_hz()); 418 } 419 420 int GainControlImpl::ConfigureHandle(void* handle) const { 421 rtc::CritScope cs_render(crit_render_); 422 rtc::CritScope cs_capture(crit_capture_); 423 WebRtcAgcConfig config; 424 // TODO(ajm): Flip the sign here (since AGC expects a positive value) if we 425 // change the interface. 426 //assert(target_level_dbfs_ <= 0); 427 //config.targetLevelDbfs = static_cast<int16_t>(-target_level_dbfs_); 428 config.targetLevelDbfs = static_cast<int16_t>(target_level_dbfs_); 429 config.compressionGaindB = 430 static_cast<int16_t>(compression_gain_db_); 431 config.limiterEnable = limiter_enabled_; 432 433 return WebRtcAgc_set_config(static_cast<Handle*>(handle), config); 434 } 435 436 size_t GainControlImpl::num_handles_required() const { 437 // Not locked as it only relies on APM public API which is threadsafe. 438 return apm_->num_proc_channels(); 439 } 440 441 int GainControlImpl::GetHandleError(void* handle) const { 442 // The AGC has no get_error() function. 443 // (Despite listing errors in its interface...) 444 assert(handle != NULL); 445 return AudioProcessing::kUnspecifiedError; 446 } 447 } // namespace webrtc 448
