Lock scheme #5: Applied the render queueing to the agc

webrtc/modules/audio_processing/gain_control_impl.cc

 /*
  *  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.
  */
 
@@ skipping 17 matching lines @@
     case GainControl::kAdaptiveDigital:
       return kAgcModeAdaptiveDigital;
     case GainControl::kFixedDigital:
       return kAgcModeFixedDigital;
   }
   assert(false);
   return -1;
 }
 }  // namespace
 
+const size_t GainControlImpl::kAllowedValuesOfSamplesPerFrame1;
+const size_t GainControlImpl::kAllowedValuesOfSamplesPerFrame2;
+
 GainControlImpl::GainControlImpl(const AudioProcessing* apm,
                                  CriticalSectionWrapper* crit)
-  : ProcessingComponent(),
-    apm_(apm),
-    crit_(crit),
-    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) {}
+    : ProcessingComponent(),
+      apm_(apm),
+      crit_(crit),
+      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) {
+  AllocateRenderQueue();
+}
 
 GainControlImpl::~GainControlImpl() {}
 
 int GainControlImpl::ProcessRenderAudio(AudioBuffer* audio) {
   if (!is_component_enabled()) {
     return apm_->kNoError;
   }
 
   assert(audio->num_frames_per_band() <= 160);
 
+  int buffer_index = 0;
   for (int i = 0; i < num_handles(); i++) {
     Handle* my_handle = static_cast<Handle*>(handle(i));
-    int err = WebRtcAgc_AddFarend(
-        my_handle,
-        audio->mixed_low_pass_data(),
-        audio->num_frames_per_band());
+    int err =
+        WebRtcAgc_GetAddFarendError(my_handle, audio->num_frames_per_band());
 
-    if (err != apm_->kNoError) {
+    if (err != apm_->kNoError)
       return GetHandleError(my_handle);
-    }
+
+    // Buffer the samples in the render queue.
+    RTC_DCHECK((buffer_index + audio->num_frames_per_band()) <=
+               render_queue_element_max_size_);
+
+    memcpy(&render_queue_buffer_[buffer_index], audio->mixed_low_pass_data(),
+           (audio->num_frames_per_band() *
+            sizeof(audio->mixed_low_pass_data()[0])));
+
+    buffer_index += audio->num_frames_per_band();
   }
 
+  render_queue_buffer_.resize(buffer_index);
+  render_signal_queue_->Insert(&render_queue_buffer_);
+
   return apm_->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() {

[the sun, 2015/10/27 16:42:49]

Why do you need this extra function? Why not pop the queue directly in
ProcessRenderAudio(), like before?

[peah-webrtc, 2015/10/29 14:05:23]

Not fully sure what you mean? Do you mean that it should be done on
AnalyzeCaptureAudio? In that case, it could be done on at the beginning of the
call to AnalyzeCaptureAudio but the problem then is that potentially something
else in APM has been done that relies on the agc render audio. 

Therefore, until we fully know the scheme for how APM operates I figured it was
safest to empty the queue as early as possible on a capture-thread call, as this
is the closest to how APM operated before this.

+  if (!is_component_enabled()) {
+    return;
+  }
+
+  bool samples_read = render_signal_queue_->Remove(&capture_queue_buffer_);
+  while (samples_read) {
+    int buffer_index = 0;
+    const int num_frames_per_band =
+        capture_queue_buffer_.size() / num_handles();
+    for (int i = 0; i < num_handles(); i++) {
+      Handle* my_handle = static_cast<Handle*>(handle(i));
+      (void)WebRtcAgc_AddFarend(my_handle, &capture_queue_buffer_[buffer_index],
+                                num_frames_per_band);
+
+      buffer_index += num_frames_per_band;
+    }
+    samples_read = render_signal_queue_->Remove(&capture_queue_buffer_);
+  }
+}
+
 int GainControlImpl::AnalyzeCaptureAudio(AudioBuffer* audio) {
   if (!is_component_enabled()) {
     return apm_->kNoError;
   }
 
   assert(audio->num_frames_per_band() <= 160);
   assert(audio->num_channels() == num_handles());
 
   int err = apm_->kNoError;
 
@@ skipping 85 matching lines @@
 
     analog_capture_level_ /= num_handles();
   }
 
   was_analog_level_set_ = false;
   return apm_->kNoError;
 }
 
 // TODO(ajm): ensure this is called under kAdaptiveAnalog.
 int GainControlImpl::set_stream_analog_level(int level) {
+  // TODO(peah): Verify that this is really needed to do the reading.
+  // here as well as in ProcessStream. It works since these functions
+  // are called from the same thread, but it is not nice to do it in two
+  // places if not needed.
+  ReadQueuedRenderData();
+
   CriticalSectionScoped crit_scoped(crit_);
   was_analog_level_set_ = true;
   if (level < minimum_capture_level_ || level > maximum_capture_level_) {
     return apm_->kBadParameterError;
   }
   analog_capture_level_ = level;
 
   return apm_->kNoError;
 }
 
@@ skipping 97 matching lines @@
 bool GainControlImpl::is_limiter_enabled() const {
   return limiter_enabled_;
 }
 
 int GainControlImpl::Initialize() {
   int err = ProcessingComponent::Initialize();
   if (err != apm_->kNoError || !is_component_enabled()) {
     return err;
   }
 
+  AllocateRenderQueue();
+
   capture_levels_.assign(num_handles(), analog_capture_level_);
   return apm_->kNoError;
 }
 
+void GainControlImpl::AllocateRenderQueue() {
+  const size_t max_frame_size = std::max(kAllowedValuesOfSamplesPerFrame1,
+                                         kAllowedValuesOfSamplesPerFrame2);
+  const size_t min_frame_size = std::min(kAllowedValuesOfSamplesPerFrame1,
+                                         kAllowedValuesOfSamplesPerFrame2);
+
+  render_queue_element_max_size_ =
+      (max_frame_size * num_handles());
+
+  const size_t render_queue_element_min_size =
+      (min_frame_size * num_handles());
+
+  std::vector<int16_t> template_queue_element(render_queue_element_max_size_);
+
+  render_signal_queue_.reset(
+      new SwapQueue<std::vector<int16_t>, AgcRenderQueueItemVerifier>(
+          kMaxNumFramesToBuffer,
+          AgcRenderQueueItemVerifier(render_queue_element_min_size,
+                                     render_queue_element_max_size_),
+          template_queue_element));
+
+  render_queue_buffer_.resize(render_queue_element_max_size_);
+  capture_queue_buffer_.resize(render_queue_element_max_size_);
+}
+
 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 {
   return WebRtcAgc_Init(static_cast<Handle*>(handle),
@@ skipping 21 matching lines @@
   return apm_->num_output_channels();
 }
 
 int GainControlImpl::GetHandleError(void* handle) const {
   // The AGC has no get_error() function.
   // (Despite listing errors in its interface...)
   assert(handle != NULL);
   return apm_->kUnspecifiedError;
 }
 }  // namespace webrtc