Moved the AGC render sample queue into the audio processing module

webrtc/modules/audio_processing/audio_processing_impl.h

 /*
  *  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 220 matching lines @@
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
   void InitializeIntelligibility()
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
   int InitializeLocked(const ProcessingConfig& config)
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
   void InitializeLevelController() EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
 
   void EmptyQueuedRenderAudio();
   void AllocateRenderQueue()
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
-  void QueueRenderAudio(const AudioBuffer* audio)
+  void QueueRenderAudio(AudioBuffer* audio)
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_);
 
   // Capture-side exclusive methods possibly running APM in a multi-threaded
   // manner that are called with the render lock already acquired.
   int ProcessCaptureStreamLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
   void MaybeUpdateHistograms() EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
 
   // Render-side exclusive methods possibly running APM in a multi-threaded
   // manner that are called with the render lock already acquired.
   // TODO(ekm): Remove once all clients updated to new interface.
@@ skipping 112 matching lines @@
     bool level_controller_enabled = false;
   } capture_nonlocked_;
 
   struct ApmRenderState {
     ApmRenderState();
     ~ApmRenderState();
     std::unique_ptr<AudioConverter> render_converter;
     std::unique_ptr<AudioBuffer> render_audio;
   } render_ GUARDED_BY(crit_render_);
 
-  size_t float_render_queue_element_max_size_ GUARDED_BY(crit_render_)
+  size_t aec_render_queue_element_max_size_ GUARDED_BY(crit_render_)
       GUARDED_BY(crit_capture_) = 0;
-  std::vector<float> float_render_queue_buffer_ GUARDED_BY(crit_render_);
-  std::vector<float> float_capture_queue_buffer_ GUARDED_BY(crit_capture_);
+  std::vector<float> aec_render_queue_buffer_ GUARDED_BY(crit_render_);
+  std::vector<float> aec_capture_queue_buffer_ GUARDED_BY(crit_capture_);
 
-  size_t int16_render_queue_element_max_size_ GUARDED_BY(crit_render_)
+  size_t aecm_render_queue_element_max_size_ GUARDED_BY(crit_render_)
       GUARDED_BY(crit_capture_) = 0;
-  std::vector<int16_t> int16_render_queue_buffer_ GUARDED_BY(crit_render_);
-  std::vector<int16_t> int16_capture_queue_buffer_ GUARDED_BY(crit_capture_);
+  std::vector<int16_t> aecm_render_queue_buffer_ GUARDED_BY(crit_render_);
+  std::vector<int16_t> aecm_capture_queue_buffer_ GUARDED_BY(crit_capture_);
+
+  size_t agc_render_queue_element_max_size_ GUARDED_BY(crit_render_)
+      GUARDED_BY(crit_capture_) = 0;
+  std::vector<int16_t> agc_render_queue_buffer_ GUARDED_BY(crit_render_);
+  std::vector<int16_t> agc_capture_queue_buffer_ GUARDED_BY(crit_capture_);
 
   // Lock protection not needed.
   std::unique_ptr<SwapQueue<std::vector<float>, RenderQueueItemVerifier<float>>>
-      float_render_signal_queue_;
+      aec_render_signal_queue_;
   std::unique_ptr<
       SwapQueue<std::vector<int16_t>, RenderQueueItemVerifier<int16_t>>>
-      int16_render_signal_queue_;
+      aecm_render_signal_queue_;
+  std::unique_ptr<
+      SwapQueue<std::vector<int16_t>, RenderQueueItemVerifier<int16_t>>>
+      agc_render_signal_queue_;

[ivoc, 2016/10/25 11:23:54]

It was hoping it would be possible to do more sharing of the swapqueues between
different components. Would it be possible to put the AudioBuffer itself into
the swapqueue instead of the packed samples?

[peah-webrtc, 2016/10/25 11:34:24]

I was too hoping for that, but it was a bit less straightforward that I hoped.

I think we should:
1) Land this CL.
2) For any other functionality that need to pass data from the render to the
capture sides, for the time being (until bullet 3) replicate the scheme that is
used for the AEC, AECM and AGC.
3) Change the scheme to pass one copy of the render data and distribute in the
format desired for the submodules.

Step 3 has the advantage that as little data as possible is passed in the
swapqueue. Now, for instance, the AEC passes several copies of the same render
to the swapqueue.

I don't think we should pass the audiobuffer since
1) It contains several copies of the data, float, int16, bandsplit data, etc.
2) It will increase our dependency on the AudioBuffer class.

Regardless of this series of CLs not immediately achieving a unified render
queue, it allows for the submodules to be changed to be lock-free. In
particular, submodules that are not in the public APM interface do not need
locks.

WDYT?

 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_AUDIO_PROCESSING_IMPL_H_