Add empty residual echo detector.

webrtc/modules/audio_processing/residual_echo_detector.cc

+/*
+ *  Copyright (c) 2016 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/residual_echo_detector.h"
+#include "webrtc/modules/audio_processing/audio_buffer.h"
+#include "webrtc/modules/audio_processing/echo_detector/echo_detector.h"
+
+namespace webrtc {
+
+ResidualEchoDetector::ResidualEchoDetector() = default;
+
+ResidualEchoDetector::~ResidualEchoDetector() = default;
+
+int ResidualEchoDetector::AnalyzeRenderAudio(const AudioBuffer* audio) const {

[hlundin-webrtc, 2016/10/14 12:36:21]

This is clearly not a const method. Remove const, and also remove the mutable
qualifiers on the two members.

[peah-webrtc, 2016/10/14 13:34:48]

I proposed this offline. The underlying idea is the following:
The AnalyzeRenderAudio method belongs to the render thread and should not touch
anything inside this class that has to do with the capture methods. 
The sole exception of this is the swapqueue object.

In order to (as far as possible) enforce proper access to the data inside this
class I see three ways:
1) Locks and lock annotation.
2) Put the render processing and capture processing parts into two objects, and
inject the swapqueue into these.
3) Let the render processing method be a const with the swapqueue declared
mutable as an exception to the constness.

I proposed 3) as
1) It allows simpler code
2) It does not require any extra locks.

The problem I see with that is that the method is not const which is confusing.

What do you propose? I think we should as far as possible write the code in
order to avoid illegal access to the capture-side data.

+  RTC_DCHECK_GE(160u, audio->num_frames_per_band());
+
+  render_queue_buffer_.clear();
+
+  // Buffer the samples in the render queue.
+  render_queue_buffer_.insert(render_queue_buffer_.end(),
+                              audio->split_bands_const_f(0)[kBand0To8kHz],
+                              (audio->split_bands_const_f(0)[kBand0To8kHz] +
+                               audio->num_frames_per_band()));
+
+  // Insert the samples into the queue.
+  if (!render_signal_queue_->Insert(&render_queue_buffer_)) {
+    // The buffer is full.
+    return -1;
+  }
+  return 0;
+}
+
+void ResidualEchoDetector::AnalyzeCaptureAudio(const AudioBuffer* audio) {
+  RTC_DCHECK_GE(160u, audio->num_frames_per_band());
+
+  detector_->Process(
+      rtc::ArrayView<const float>(audio->split_bands_const_f(0)[kBand0To8kHz],
+                                  audio->num_frames_per_band()));
+}
+
+void ResidualEchoDetector::Initialize(int sample_rate_hz) {
+  RTC_DCHECK(sample_rate_hz == AudioProcessing::kSampleRate8kHz ||
+             sample_rate_hz == AudioProcessing::kSampleRate16kHz ||
+             sample_rate_hz == AudioProcessing::kSampleRate32kHz ||
+             sample_rate_hz == AudioProcessing::kSampleRate48kHz);
+
+  detector_->Initialize(sample_rate_hz);
+}
+
+void ResidualEchoDetector::ReadQueuedRenderData() {
+  while (render_signal_queue_->Remove(&capture_queue_buffer_)) {
+    const size_t num_frames_per_band = capture_queue_buffer_.size();
+    detector_->BufferFarend(rtc::ArrayView<const float>(
+        capture_queue_buffer_.data(), num_frames_per_band));
+  }
+}
+
+float ResidualEchoDetector::get_echo_likelihood() const {
+  return 0.0f;
+}
+
+}  // namespace webrtc