/*
|
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
*
|
* Use of this source code is governed by a BSD-style license
|
* that can be found in the LICENSE file in the root of the source
|
* tree. An additional intellectual property rights grant can be found
|
* in the file PATENTS. All contributing project authors may
|
* be found in the AUTHORS file in the root of the source tree.
|
*/
|
|
#include "webrtc/modules/audio_processing/gain_control_impl.h"
|
|
#include <assert.h>
|
|
#include "webrtc/modules/audio_processing/audio_buffer.h"
|
#include "webrtc/modules/audio_processing/agc/legacy/gain_control.h"
|
|
namespace webrtc {
|
|
typedef void Handle;
|
|
namespace {
|
int16_t MapSetting(GainControl::Mode mode) {
|
switch (mode) {
|
case GainControl::kAdaptiveAnalog:
|
return kAgcModeAdaptiveAnalog;
|
case GainControl::kAdaptiveDigital:
|
return kAgcModeAdaptiveDigital;
|
case GainControl::kFixedDigital:
|
return kAgcModeFixedDigital;
|
}
|
assert(false);
|
return -1;
|
}
|
|
// Maximum length that a frame of samples can have.
|
static const size_t kMaxAllowedValuesOfSamplesPerFrame = 160;
|
// Maximum number of frames to buffer in the render queue.
|
// TODO(peah): Decrease this once we properly handle hugely unbalanced
|
// reverse and forward call numbers.
|
static const size_t kMaxNumFramesToBuffer = 100;
|
|
} // namespace
|
|
GainControlImpl::GainControlImpl(const AudioProcessing* apm,
|
rtc::CriticalSection* crit_render,
|
rtc::CriticalSection* crit_capture)
|
: ProcessingComponent(),
|
apm_(apm),
|
crit_render_(crit_render),
|
crit_capture_(crit_capture),
|
mode_(kAdaptiveAnalog),
|
minimum_capture_level_(0),
|
maximum_capture_level_(255),
|
limiter_enabled_(true),
|
target_level_dbfs_(3),
|
compression_gain_db_(9),
|
analog_capture_level_(0),
|
was_analog_level_set_(false),
|
stream_is_saturated_(false),
|
render_queue_element_max_size_(0) {
|
RTC_DCHECK(apm);
|
RTC_DCHECK(crit_render);
|
RTC_DCHECK(crit_capture);
|
}
|
|
GainControlImpl::~GainControlImpl() {}
|
|
int GainControlImpl::ProcessRenderAudio(AudioBuffer* audio) {
|
rtc::CritScope cs(crit_render_);
|
if (!is_component_enabled()) {
|
return AudioProcessing::kNoError;
|
}
|
|
assert(audio->num_frames_per_band() <= 160);
|
|
render_queue_buffer_.resize(0);
|
for (size_t i = 0; i < num_handles(); i++) {
|
Handle* my_handle = static_cast<Handle*>(handle(i));
|
int err =
|
WebRtcAgc_GetAddFarendError(my_handle, audio->num_frames_per_band());
|
|
if (err != AudioProcessing::kNoError)
|
return GetHandleError(my_handle);
|
|
// Buffer the samples in the render queue.
|
render_queue_buffer_.insert(
|
render_queue_buffer_.end(), audio->mixed_low_pass_data(),
|
(audio->mixed_low_pass_data() + audio->num_frames_per_band()));
|
}
|
|
// Insert the samples into the queue.
|
if (!render_signal_queue_->Insert(&render_queue_buffer_)) {
|
// The data queue is full and needs to be emptied.
|
ReadQueuedRenderData();
|
|
// Retry the insert (should always work).
|
RTC_DCHECK_EQ(render_signal_queue_->Insert(&render_queue_buffer_), true);
|
}
|
|
return AudioProcessing::kNoError;
|
}
|
|
// Read chunks of data that were received and queued on the render side from
|
// a queue. All the data chunks are buffered into the farend signal of the AGC.
|
void GainControlImpl::ReadQueuedRenderData() {
|
rtc::CritScope cs(crit_capture_);
|
|
if (!is_component_enabled()) {
|
return;
|
}
|
|
while (render_signal_queue_->Remove(&capture_queue_buffer_)) {
|
size_t buffer_index = 0;
|
const size_t num_frames_per_band =
|
capture_queue_buffer_.size() / num_handles();
|
for (size_t i = 0; i < num_handles(); i++) {
|
Handle* my_handle = static_cast<Handle*>(handle(i));
|
WebRtcAgc_AddFarend(my_handle, &capture_queue_buffer_[buffer_index],
|
num_frames_per_band);
|
|
buffer_index += num_frames_per_band;
|
}
|
}
|
}
|
|
int GainControlImpl::AnalyzeCaptureAudio(AudioBuffer* audio) {
|
rtc::CritScope cs(crit_capture_);
|
|
if (!is_component_enabled()) {
|
return AudioProcessing::kNoError;
|
}
|
|
assert(audio->num_frames_per_band() <= 160);
|
assert(audio->num_channels() == num_handles());
|
|
int err = AudioProcessing::kNoError;
|
|
if (mode_ == kAdaptiveAnalog) {
|
capture_levels_.assign(num_handles(), analog_capture_level_);
|
for (size_t i = 0; i < num_handles(); i++) {
|
Handle* my_handle = static_cast<Handle*>(handle(i));
|
err = WebRtcAgc_AddMic(
|
my_handle,
|
audio->split_bands(i),
|
audio->num_bands(),
|
audio->num_frames_per_band());
|
|
if (err != AudioProcessing::kNoError) {
|
return GetHandleError(my_handle);
|
}
|
}
|
} else if (mode_ == kAdaptiveDigital) {
|
|
for (size_t i = 0; i < num_handles(); i++) {
|
Handle* my_handle = static_cast<Handle*>(handle(i));
|
int32_t capture_level_out = 0;
|
|
err = WebRtcAgc_VirtualMic(
|
my_handle,
|
audio->split_bands(i),
|
audio->num_bands(),
|
audio->num_frames_per_band(),
|
analog_capture_level_,
|
&capture_level_out);
|
|
capture_levels_[i] = capture_level_out;
|
|
if (err != AudioProcessing::kNoError) {
|
return GetHandleError(my_handle);
|
}
|
|
}
|
}
|
|
return AudioProcessing::kNoError;
|
}
|
|
int GainControlImpl::ProcessCaptureAudio(AudioBuffer* audio) {
|
rtc::CritScope cs(crit_capture_);
|
|
if (!is_component_enabled()) {
|
return AudioProcessing::kNoError;
|
}
|
|
if (mode_ == kAdaptiveAnalog && !was_analog_level_set_) {
|
return AudioProcessing::kStreamParameterNotSetError;
|
}
|
|
assert(audio->num_frames_per_band() <= 160);
|
assert(audio->num_channels() == num_handles());
|
|
stream_is_saturated_ = false;
|
for (size_t i = 0; i < num_handles(); i++) {
|
Handle* my_handle = static_cast<Handle*>(handle(i));
|
int32_t capture_level_out = 0;
|
uint8_t saturation_warning = 0;
|
|
// The call to stream_has_echo() is ok from a deadlock perspective
|
// as the capture lock is allready held.
|
int err = WebRtcAgc_Process(
|
my_handle,
|
audio->split_bands_const(i),
|
audio->num_bands(),
|
audio->num_frames_per_band(),
|
audio->split_bands(i),
|
capture_levels_[i],
|
&capture_level_out,
|
apm_->echo_cancellation()->stream_has_echo(),
|
&saturation_warning);
|
|
if (err != AudioProcessing::kNoError) {
|
return GetHandleError(my_handle);
|
}
|
|
capture_levels_[i] = capture_level_out;
|
if (saturation_warning == 1) {
|
stream_is_saturated_ = true;
|
}
|
}
|
|
if (mode_ == kAdaptiveAnalog) {
|
// Take the analog level to be the average across the handles.
|
analog_capture_level_ = 0;
|
for (size_t i = 0; i < num_handles(); i++) {
|
analog_capture_level_ += capture_levels_[i];
|
}
|
|
analog_capture_level_ /= num_handles();
|
}
|
|
was_analog_level_set_ = false;
|
return AudioProcessing::kNoError;
|
}
|
|
// TODO(ajm): ensure this is called under kAdaptiveAnalog.
|
int GainControlImpl::set_stream_analog_level(int level) {
|
rtc::CritScope cs(crit_capture_);
|
|
was_analog_level_set_ = true;
|
if (level < minimum_capture_level_ || level > maximum_capture_level_) {
|
return AudioProcessing::kBadParameterError;
|
}
|
analog_capture_level_ = level;
|
|
return AudioProcessing::kNoError;
|
}
|
|
int GainControlImpl::stream_analog_level() {
|
rtc::CritScope cs(crit_capture_);
|
// TODO(ajm): enable this assertion?
|
//assert(mode_ == kAdaptiveAnalog);
|
|
return analog_capture_level_;
|
}
|
|
int GainControlImpl::Enable(bool enable) {
|
rtc::CritScope cs_render(crit_render_);
|
rtc::CritScope cs_capture(crit_capture_);
|
return EnableComponent(enable);
|
}
|
|
bool GainControlImpl::is_enabled() const {
|
rtc::CritScope cs(crit_capture_);
|
return is_component_enabled();
|
}
|
|
int GainControlImpl::set_mode(Mode mode) {
|
rtc::CritScope cs_render(crit_render_);
|
rtc::CritScope cs_capture(crit_capture_);
|
if (MapSetting(mode) == -1) {
|
return AudioProcessing::kBadParameterError;
|
}
|
|
mode_ = mode;
|
return Initialize();
|
}
|
|
GainControl::Mode GainControlImpl::mode() const {
|
rtc::CritScope cs(crit_capture_);
|
return mode_;
|
}
|
|
int GainControlImpl::set_analog_level_limits(int minimum,
|
int maximum) {
|
rtc::CritScope cs(crit_capture_);
|
if (minimum < 0) {
|
return AudioProcessing::kBadParameterError;
|
}
|
|
if (maximum > 65535) {
|
return AudioProcessing::kBadParameterError;
|
}
|
|
if (maximum < minimum) {
|
return AudioProcessing::kBadParameterError;
|
}
|
|
minimum_capture_level_ = minimum;
|
maximum_capture_level_ = maximum;
|
|
return Initialize();
|
}
|
|
int GainControlImpl::analog_level_minimum() const {
|
rtc::CritScope cs(crit_capture_);
|
return minimum_capture_level_;
|
}
|
|
int GainControlImpl::analog_level_maximum() const {
|
rtc::CritScope cs(crit_capture_);
|
return maximum_capture_level_;
|
}
|
|
bool GainControlImpl::stream_is_saturated() const {
|
rtc::CritScope cs(crit_capture_);
|
return stream_is_saturated_;
|
}
|
|
int GainControlImpl::set_target_level_dbfs(int level) {
|
rtc::CritScope cs(crit_capture_);
|
if (level > 31 || level < 0) {
|
return AudioProcessing::kBadParameterError;
|
}
|
|
target_level_dbfs_ = level;
|
return Configure();
|
}
|
|
int GainControlImpl::target_level_dbfs() const {
|
rtc::CritScope cs(crit_capture_);
|
return target_level_dbfs_;
|
}
|
|
int GainControlImpl::set_compression_gain_db(int gain) {
|
rtc::CritScope cs(crit_capture_);
|
if (gain < 0 || gain > 90) {
|
return AudioProcessing::kBadParameterError;
|
}
|
|
compression_gain_db_ = gain;
|
return Configure();
|
}
|
|
int GainControlImpl::compression_gain_db() const {
|
rtc::CritScope cs(crit_capture_);
|
return compression_gain_db_;
|
}
|
|
int GainControlImpl::enable_limiter(bool enable) {
|
rtc::CritScope cs(crit_capture_);
|
limiter_enabled_ = enable;
|
return Configure();
|
}
|
|
bool GainControlImpl::is_limiter_enabled() const {
|
rtc::CritScope cs(crit_capture_);
|
return limiter_enabled_;
|
}
|
|
int GainControlImpl::Initialize() {
|
int err = ProcessingComponent::Initialize();
|
if (err != AudioProcessing::kNoError || !is_component_enabled()) {
|
return err;
|
}
|
|
AllocateRenderQueue();
|
|
rtc::CritScope cs_capture(crit_capture_);
|
const int n = num_handles();
|
RTC_CHECK_GE(n, 0) << "Bad number of handles: " << n;
|
|
capture_levels_.assign(n, analog_capture_level_);
|
return AudioProcessing::kNoError;
|
}
|
|
void GainControlImpl::AllocateRenderQueue() {
|
const size_t new_render_queue_element_max_size =
|
std::max<size_t>(static_cast<size_t>(1),
|
kMaxAllowedValuesOfSamplesPerFrame * num_handles());
|
|
rtc::CritScope cs_render(crit_render_);
|
rtc::CritScope cs_capture(crit_capture_);
|
|
if (render_queue_element_max_size_ < new_render_queue_element_max_size) {
|
render_queue_element_max_size_ = new_render_queue_element_max_size;
|
std::vector<int16_t> template_queue_element(render_queue_element_max_size_);
|
|
render_signal_queue_.reset(
|
new SwapQueue<std::vector<int16_t>, RenderQueueItemVerifier<int16_t>>(
|
kMaxNumFramesToBuffer, template_queue_element,
|
RenderQueueItemVerifier<int16_t>(render_queue_element_max_size_)));
|
|
render_queue_buffer_.resize(render_queue_element_max_size_);
|
capture_queue_buffer_.resize(render_queue_element_max_size_);
|
} else {
|
render_signal_queue_->Clear();
|
}
|
}
|
|
void* GainControlImpl::CreateHandle() const {
|
return WebRtcAgc_Create();
|
}
|
|
void GainControlImpl::DestroyHandle(void* handle) const {
|
WebRtcAgc_Free(static_cast<Handle*>(handle));
|
}
|
|
int GainControlImpl::InitializeHandle(void* handle) const {
|
rtc::CritScope cs_render(crit_render_);
|
rtc::CritScope cs_capture(crit_capture_);
|
|
return WebRtcAgc_Init(static_cast<Handle*>(handle),
|
minimum_capture_level_,
|
maximum_capture_level_,
|
MapSetting(mode_),
|
apm_->proc_sample_rate_hz());
|
}
|
|
int GainControlImpl::ConfigureHandle(void* handle) const {
|
rtc::CritScope cs_render(crit_render_);
|
rtc::CritScope cs_capture(crit_capture_);
|
WebRtcAgcConfig config;
|
// TODO(ajm): Flip the sign here (since AGC expects a positive value) if we
|
// change the interface.
|
//assert(target_level_dbfs_ <= 0);
|
//config.targetLevelDbfs = static_cast<int16_t>(-target_level_dbfs_);
|
config.targetLevelDbfs = static_cast<int16_t>(target_level_dbfs_);
|
config.compressionGaindB =
|
static_cast<int16_t>(compression_gain_db_);
|
config.limiterEnable = limiter_enabled_;
|
|
return WebRtcAgc_set_config(static_cast<Handle*>(handle), config);
|
}
|
|
size_t GainControlImpl::num_handles_required() const {
|
// Not locked as it only relies on APM public API which is threadsafe.
|
return apm_->num_proc_channels();
|
}
|
|
int GainControlImpl::GetHandleError(void* handle) const {
|
// The AGC has no get_error() function.
|
// (Despite listing errors in its interface...)
|
assert(handle != NULL);
|
return AudioProcessing::kUnspecifiedError;
|
}
|
} // namespace webrtc
|
