Lock scheme #4: Introduced the render sample queue for the aec and aecm

webrtc/modules/audio_processing/echo_cancellation_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.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_PROCESSING_ECHO_CANCELLATION_IMPL_H_
 #define WEBRTC_MODULES_AUDIO_PROCESSING_ECHO_CANCELLATION_IMPL_H_
 
+#include "webrtc/base/scoped_ptr.h"
+#include "webrtc/common_audio/swap_queue.h"
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
 #include "webrtc/modules/audio_processing/processing_component.h"
 
 namespace webrtc {
 
 class AudioBuffer;
 class CriticalSectionWrapper;
 
+// Functor to use when supplying a verifier function for the queue item

[hlundin-webrtc, 2015/11/06 07:05:13]

I'm not sure, but isn't there a risk you'll get multiple definitions of this
now? I recall this being duplicated in several .h files, and if they are
included in the same place, what happens?

If the idea with the unnamed namespace was to hide AecRenderQueueItemVerifier
from the outside world, you may want to move that inside EchoCancellationImpl as
a nested private class. On the other hand, maybe it is best added as a protected
nested class under ProcessingComponent for all to use? Just a thought, if it
doesn't work out I'm fine with it.

[peah-webrtc, 2015/11/06 10:44:20]

Good point! It works as it is, but I instead created a template for this in the
ProcessingComponent. Please verify that what I did makes sense. I did not put it
as nested beneath processingcomponent though as that would cause that class to
be a template. Or is there a better way to do it?

+// verifcation.
+class AecRenderQueueItemVerifier {
+ public:
+  explicit AecRenderQueueItemVerifier(size_t minimum_capacity)
+      : minimum_capacity_(minimum_capacity) {}
+
+  bool operator()(const std::vector<float>& v) const {
+    return v.capacity() >= minimum_capacity_;
+  }
+
+ private:
+  size_t minimum_capacity_;
+};
+
 class EchoCancellationImpl : public EchoCancellation,
                              public ProcessingComponent {
  public:
   EchoCancellationImpl(const AudioProcessing* apm,
                        CriticalSectionWrapper* crit);
   virtual ~EchoCancellationImpl();
 
   int ProcessRenderAudio(const AudioBuffer* audio);
   int ProcessCaptureAudio(AudioBuffer* audio);
 
   // EchoCancellation implementation.
   bool is_enabled() const override;
   int stream_drift_samples() const override;
   SuppressionLevel suppression_level() const override;
   bool is_drift_compensation_enabled() const override;
 
   // ProcessingComponent implementation.
   int Initialize() override;
   void SetExtraOptions(const Config& config) override;
 
   bool is_delay_agnostic_enabled() const;
   bool is_extended_filter_enabled() const;
 
+  // Reads render side data that has been queued on the render call.
+  void ReadQueuedRenderData();
+
  private:
+  static const size_t kAllowedValuesOfSamplesPerFrame1 = 80;
+  static const size_t kAllowedValuesOfSamplesPerFrame2 = 160;
+  // TODO(peah): Decrease this once we properly handle hugely unbalanced
+  // reverse and forward call numbers.
+  static const size_t kMaxNumFramesToBuffer = 100;
+
   // EchoCancellation implementation.
   int Enable(bool enable) override;
   int enable_drift_compensation(bool enable) override;
   void set_stream_drift_samples(int drift) override;
   int set_suppression_level(SuppressionLevel level) override;
   int enable_metrics(bool enable) override;
   bool are_metrics_enabled() const override;
   bool stream_has_echo() const override;
   int GetMetrics(Metrics* metrics) override;
   int enable_delay_logging(bool enable) override;
   bool is_delay_logging_enabled() const override;
   int GetDelayMetrics(int* median, int* std) override;
   int GetDelayMetrics(int* median,
                       int* std,
                       float* fraction_poor_delays) override;
   struct AecCore* aec_core() const override;
 
   // ProcessingComponent implementation.
   void* CreateHandle() const override;
   int InitializeHandle(void* handle) const override;
   int ConfigureHandle(void* handle) const override;
   void DestroyHandle(void* handle) const override;
   int num_handles_required() const override;
   int GetHandleError(void* handle) const override;
 
+  void AllocateRenderQueue();
+
   const AudioProcessing* apm_;
   CriticalSectionWrapper* crit_;
   bool drift_compensation_enabled_;
   bool metrics_enabled_;
   SuppressionLevel suppression_level_;
   int stream_drift_samples_;
   bool was_stream_drift_set_;
   bool stream_has_echo_;
   bool delay_logging_enabled_;
   bool extended_filter_enabled_;
   bool delay_agnostic_enabled_;
+
+  size_t render_queue_element_max_size_;
+  std::vector<float> render_queue_buffer_;
+  std::vector<float> capture_queue_buffer_;
+  rtc::scoped_ptr<SwapQueue<std::vector<float>, AecRenderQueueItemVerifier>>
+      render_signal_queue_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_ECHO_CANCELLATION_IMPL_H_