Added an "enable-audio-processor" flag and WebRtcAudioProcessor class

content/renderer/media/webrtc_audio_processor.cc

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/renderer/media/webrtc_audio_processor.h"
+
+#include "base/command_line.h"
+#include "base/debug/trace_event.h"
+#include "content/public/common/content_switches.h"
+#include "media/audio/audio_parameters.h"
+#include "media/base/audio_converter.h"
+#include "media/base/audio_fifo.h"
+#include "media/base/channel_layout.h"
+
+namespace content {
+
+namespace {
+
+using webrtc::AudioProcessing;
+using webrtc::MediaConstraintsInterface;
+
+#if defined(ANDROID)
+const int kAudioProcessingSampleRate = 16000;
+#else
+const int kAudioProcessingSampleRate = 32000;
+#endif
+const int kAudioProcessingNumberOfChannel = 1;
+
+const int kMaxNumberOfBuffersInFifo = 2;
+
+bool GetPropertyFromConstraints(const MediaConstraintsInterface* constraints,
+                                const std::string& key) {
+  bool value = false;
+  return webrtc::FindConstraint(constraints, key, &value, NULL) && value;
+}
+
+// Extract all these methods to a helper class.

[DaleCurtis, 2013/11/06 00:21:18]

Mark as TODO(xians) or do now.

[no longer working on chromium, 2013/11/06 16:45:14]

Done with extracting the methods to a separate util file. The methods will grow
substantially as we start supporting more features.

+void EnableEchoCancellation(AudioProcessing* audio_processing) {
+  DCHECK(audio_processing);

[DaleCurtis, 2013/11/06 00:21:18]

No point in DCHECK() if you're just going to deref immediately below.  Remove
here and elsewhere.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+#if defined(IOS) || defined(ANDROID)
+  // Mobile devices are using AECM.
+  if (audio_processing->echo_control_mobile()->Enable(true))
+    NOTREACHED();
+
+  if (audio_processing->echo_control_mobile()->set_routing_mode(
+      webrtc::EchoControlMobile::kSpeakerphone))
+    NOTREACHED();
+
+  return;
+#endif

[DaleCurtis, 2013/11/06 00:21:18]

Remove return above and use:

#else
...
#endif

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+  if (audio_processing->echo_cancellation()->Enable(true))
+    NOTREACHED();
+  if (audio_processing->echo_cancellation()->set_suppression_level(
+      webrtc::EchoCancellation::kHighSuppression))
+    NOTREACHED();
+
+  // Enable the metrics for AEC.
+  if (audio_processing->echo_cancellation()->enable_metrics(true))
+    NOTREACHED();
+  if (audio_processing->echo_cancellation()->enable_delay_logging(true))
+    NOTREACHED();
+}
+
+void EnableNoiseSuppression(AudioProcessing* audio_processing) {
+  DCHECK(audio_processing);
+  if (audio_processing->noise_suppression()->set_level(
+      webrtc::NoiseSuppression::kHigh))
+    NOTREACHED();
+
+  if (audio_processing->noise_suppression()->Enable(true))
+    NOTREACHED();
+}
+
+void EnableHighPassFilter(AudioProcessing* audio_processing) {
+  DCHECK(audio_processing);
+  if (audio_processing->high_pass_filter()->Enable(true))
+     NOTREACHED();
+}
+
+// TODO(xians): stereo swapping
+void EnableTypingDetection(AudioProcessing* audio_processing) {
+  DCHECK(audio_processing);
+  if (audio_processing->voice_detection()->Enable(true))
+    NOTREACHED();
+
+  if (audio_processing->voice_detection()->set_likelihood(
+      webrtc::VoiceDetection::kVeryLowLikelihood))
+    NOTREACHED();
+}
+
+void EnableExperimentalEchoCancellation(AudioProcessing* audio_processing) {
+  DCHECK(audio_processing);
+  webrtc::Config config;
+  config.Set<webrtc::DelayCorrection>(new webrtc::DelayCorrection(true));
+  audio_processing->SetExtraOptions(config);
+}
+
+void StartAecDump(AudioProcessing* audio_processin) {
+  static const char kAecDumpFilename[] = "/tmp/audio.aecdump";
+  if (audio_processin->StartDebugRecording(kAecDumpFilename))
+    LOG(ERROR) << "Fail to start AEC debug recording";

[DaleCurtis, 2013/11/06 00:21:18]

remove debug text?  DLOG() ?   Ditto below.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+}
+
+void StopAecDump(AudioProcessing* audio_processin) {
+  if (audio_processin->StopDebugRecording())
+    LOG(ERROR) << "Fail to stop AEC debug recording";
+}
+
+}  // namespace
+
+class WebRtcAudioProcessor::WebRtcAudioConverter
+    : public media::AudioConverter::InputCallback {

[DaleCurtis, 2013/11/06 00:21:18]

Add a thread_checker for construction/destruction or at least document which
thread is calling what.  It's important that access to audio_converter_ is
thread safe as it doesn't include a lock.

[no longer working on chromium, 2013/11/06 16:45:14]

Done with adding a thread check in destructor.

Thanks for the info, WebRtcAudioConverter is thread safe in terms of how it is
being used in this class.

+ public:
+  WebRtcAudioConverter(const media::AudioParameters& source_params,
+                       const media::AudioParameters& sink_params) {
+    source_params_ = source_params;

[DaleCurtis, 2013/11/06 00:21:18]

set in constructor syntax:

WebRtcAudioConverter(...)
   : source_params_(source_params)

etc. Ditto for all of these really. 

+    sink_params_ = sink_params;
+
+    // Create the audio converter which is responsible for down-mixing and
+    // resampling.
+    audio_converter_.reset(
+        new media::AudioConverter(source_params, sink_params_, false));
+    audio_converter_->AddInput(this);
+
+    // Create and initialize audio fifo and audio bus wrapper.
+    // The size of the FIFO should be at least twice of the source buffer size
+    // or twice of the sink buffer size.
+    int buffer_size = std::max(
+        kMaxNumberOfBuffersInFifo * source_params.frames_per_buffer(),
+        kMaxNumberOfBuffersInFifo * sink_params_.frames_per_buffer());

[DaleCurtis, 2013/11/06 00:21:18]

Consistently use member variables.  I.e., use source_params_ if you're going to
use sink_params_.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+    fifo_.reset(new media::AudioFifo(source_params.channels(), buffer_size));
+    // TODO(xians): Use CreateWrapper to save one memcpy.
+    audio_wrapper_ = media::AudioBus::Create(sink_params_.channels(),
+                                             sink_params_.frames_per_buffer());
+  }
+
+  ~WebRtcAudioConverter() {

[DaleCurtis, 2013/11/06 00:21:18]

virtual

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+    audio_converter_->RemoveInput(this);
+  }
+
+  void Push(media::AudioBus* audio_source) {
+    DCHECK(fifo_->frames() + audio_source->frames() <= fifo_->max_frames());

[DaleCurtis, 2013/11/06 00:21:18]

AudioFifo will check this already.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+    fifo_->Push(audio_source);
+  }
+
+  bool Convert() {
+    // Return false if there is no 10ms data in the FIFO.
+    if (fifo_->frames() < (source_params_.sample_rate() / 100))
+      return false;
+
+    // Convert 10ms data to the output format, this will trigger ProvideInput().
+    audio_converter_->Convert(audio_wrapper_.get());
+
+    // TODO(xians): Figure out a better way to handle the interleaved and
+    // deinterleaved format switching.
+    audio_wrapper_->ToInterleaved(audio_wrapper_->frames(), 2,

[DaleCurtis, 2013/11/06 00:21:18]

Instead of 2 maybe sizeof(*(data_[0])) ?

[no longer working on chromium, 2013/11/06 16:45:14]

Done with using sink_params_.bits_per_sample() / 8,

+                                  audio_frame_.data_);
+
+    audio_frame_.samples_per_channel_ = sink_params_.frames_per_buffer();
+    audio_frame_.sample_rate_hz_ = sink_params_.sample_rate();
+    audio_frame_.speech_type_ = webrtc::AudioFrame::kNormalSpeech;
+    audio_frame_.vad_activity_ = webrtc::AudioFrame::kVadUnknown;
+    audio_frame_.num_channels_ = sink_params_.channels();
+
+    return true;
+  }
+
+  webrtc::AudioFrame* audio_frame() { return &audio_frame_; }

[DaleCurtis, 2013/11/06 00:21:18]

const& as well?

[no longer working on chromium, 2013/11/06 16:45:14]

No, we can't. The webrtc::AudioProcessing takes the pointer of the audio_frame
as input, processes the content, and modify it directly.

+  const media::AudioParameters& source_parameters() const {
+    return source_params_;
+  }
+  const media::AudioParameters& sink_parameters() const {
+    return sink_params_;
+  }
+
+ private:
+  // AudioConverter::InputCallback implementation.
+  virtual double ProvideInput(media::AudioBus* audio_bus,
+                              base::TimeDelta buffer_delay) {
+    // The first Convert() can trigger ProvideInput two times, use SincResampler

[DaleCurtis, 2013/11/06 00:21:18]

Elaborate?  Comment should be a TODO() if it's something that needs fixing.

[no longer working on chromium, 2013/11/06 16:45:14]

I am not sure why, but the first audio_converter_->Convert(audio_wrapper_.get())
can trigger two ProvideInput, adding a TODO to figure it out why.

+    // to fix the problem.
+    if (fifo_->frames() < audio_bus->frames())
+      return 0;
+
+    fifo_->Consume(audio_bus, 0, audio_bus->frames());
+    return 1.0;
+  }
+
+  webrtc::AudioFrame audio_frame_;
+
+  // TODO(xians): consider using SincResampler to save some memcpy.

[DaleCurtis, 2013/11/06 00:21:18]

What does this mean?  SincResampler is automatically invoked by AudioConverter
if sample rates differ.

[no longer working on chromium, 2013/11/06 16:45:14]

I am only targeting the case where resampling is needed.

And since AudioConverter is designed to handle multiple InputCallbacks, it needs
to get the data from all the inputs, mix them, down mixing(if needed), then
resampling.
But for this WebRtcAudioProcessor::WebRtcAudioConverter, it only takes one
InputCallback as input, so we probably can save some memcpy by avoid
intermediate buffering.

Though I am not very sure if it worths the effort.

[DaleCurtis, 2013/11/07 01:36:00]

If you just need resampling you can use MultiChannelResampler or just
SincResampler for mono.

[no longer working on chromium, 2013/11/07 14:43:12]

We need down-mixing (if input is stereo) and resampling (SincResampler), so it
is more or less like AudioConverter.

+  // Handles mixing and resampling between input and output parameters.
+  scoped_ptr<media::AudioConverter> audio_converter_;

[DaleCurtis, 2013/11/06 00:21:18]

AudioConverter and AudioFifo can be stack allocated, no need for scoped_ptr

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+  scoped_ptr<media::AudioBus> audio_wrapper_;
+  scoped_ptr<media::AudioFifo> fifo_;
+
+  media::AudioParameters source_params_;
+  media::AudioParameters sink_params_;
+};
+
+WebRtcAudioProcessor::WebRtcAudioProcessor(

[DaleCurtis, 2013/11/06 00:21:18]

Again, it'd be nice to have a ThreadChecker or some DCHECKs for which message
loop you're on.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+    const webrtc::MediaConstraintsInterface* constraints)
+    : render_delay_ms_(0) {
+  InitializeAudioProcessingModule(constraints);
+}
+
+WebRtcAudioProcessor::~WebRtcAudioProcessor() {
+  StopAudioProcessing();
+}
+
+void WebRtcAudioProcessor::SetCaptureFormat(
+    const media::AudioParameters& source_params) {
+  DCHECK(source_params.IsValid());
+
+  // Create and initialize audio converter for the source data.
+  int sink_sample_rate = audio_processing_.get() ?

[DaleCurtis, 2013/11/06 00:21:18]

get shouldn't be necessary anymore.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+      kAudioProcessingSampleRate : source_params.sample_rate();
+  media::ChannelLayout sink_channel_layout = audio_processing_.get() ?

[DaleCurtis, 2013/11/06 00:21:18]

Comments? Why the separate path for when audio_processing_ is available?

[no longer working on chromium, 2013/11/06 16:45:14]

Done with adding the comment.

When the webrtc::audio_processing is valid, it means some processing components
are on. The output format of the post-processed data is 32k mono for desktops
and 16k mono for Android.
In case the  webrtc::audio_processing is NULL, we do not have any processing on
the data, so the output format will be the same as the input format.

+      media::CHANNEL_LAYOUT_MONO : source_params.channel_layout();
+
+  // WebRtc is using 10ms data as its native packet size.
+  media::AudioParameters sink_params(
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY, sink_channel_layout,
+      sink_sample_rate, 16, sink_sample_rate / 100);
+  capture_converter_.reset(
+      new WebRtcAudioConverter(source_params, sink_params));
+}
+
+void WebRtcAudioProcessor::PushCaptureData(media::AudioBus* audio_source) {
+  DCHECK(capture_converter_.get());

[DaleCurtis, 2013/11/06 00:21:18]

No point in checking, scoped_ptr has an internal check.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+  capture_converter_->Push(audio_source);
+}
+
+bool WebRtcAudioProcessor::ProcessAndConsume10MsData(
+    int capture_audio_delay_ms, int volume, bool key_pressed,
+    int16** out) {
+  TRACE_EVENT0("audio",
+               "WebRtcAudioProcessor::ProcessAndConsume10MsData");
+
+  if (!capture_converter_->Convert())
+    return false;
+
+  ProcessData(capture_audio_delay_ms, volume, key_pressed);
+  *out = capture_converter_->audio_frame()->data_;

[DaleCurtis, 2013/11/06 00:21:18]

Is out already allocated? Why not just convert directly into out instead of the
AudioFrame?  It doesn't look like you're actually using anything from the
AudioFrame despite setting it all up in the converter.

Leaving a stale audio_Frame() around across Convert() calls kind of smells to.

[no longer working on chromium, 2013/11/06 16:45:14]

|out| is a pointer to the data in AudioFrame.

It is because webrtc::AudioProcessing only takes AudioFrame as input, the
AudioFrame is used like:
audio_processing_->ProcessStream(capture_converter_->audio_frame());
audio_processing_->AnalyzeReverseStream(render_converter_->audio_frame());

[DaleCurtis, 2013/11/07 01:36:00]

I think the AudioFrame should be owned by WebRtcAudioProcessor and just the out*
passed into the converter. It's weird for the Converter to hold onto an
AudioFrame for the sole purpose of an external consumer.

[no longer working on chromium, 2013/11/07 14:43:12]

Done.

+
+  return true;
+}
+
+const media::AudioParameters& WebRtcAudioProcessor::OutputFormat() const {
+  return capture_converter_->sink_parameters();
+}
+
+void WebRtcAudioProcessor::ProcessData(int capture_audio_delay_ms,
+                                       int volume,
+                                       bool key_pressed) {
+  if (!audio_processing_.get())

[DaleCurtis, 2013/11/06 00:21:18]

No more .get().

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+    return;
+
+  TRACE_EVENT0("audio", "WebRtcAudioProcessor::Process10MsData");
+  DCHECK_EQ(audio_processing_->sample_rate_hz(),
+            capture_converter_->sink_parameters().sample_rate());
+  DCHECK_EQ(audio_processing_->num_input_channels(),
+            capture_converter_->sink_parameters().channels());
+  DCHECK_EQ(audio_processing_->num_output_channels(),
+            capture_converter_->sink_parameters().channels());
+
+  // TODO(xians): Sum the capture delay and render delay.
+  int total_delay_ms = 0;
+  {
+    base::AutoLock auto_lock(lock_);
+    total_delay_ms = capture_audio_delay_ms + render_delay_ms_;
+  }
+
+  audio_processing_->set_stream_delay_ms(total_delay_ms);
+  webrtc::GainControl* agc = audio_processing_->gain_control();
+  if (agc->set_stream_analog_level(volume))
+    NOTREACHED();
+  int err = audio_processing_->ProcessStream(
+      capture_converter_->audio_frame());
+  if (err) {
+    NOTREACHED() << "ProcessStream() error: " << err;

[DaleCurtis, 2013/11/06 00:21:18]

DLOG(ERROR) instead?

[no longer working on chromium, 2013/11/06 16:45:14]

We want to DCHECK this as well, is it fine to keep NOTREACHED()?

[DaleCurtis, 2013/11/07 01:36:00]

Why not just DCHECK(err) << "ProcessStream() error: " ...

[no longer working on chromium, 2013/11/07 14:43:12]

Done.

+  }
+
+  // TODO(xians): Fixed the AGC, typing detectin, audio level calculation,

[DaleCurtis, 2013/11/06 00:21:18]

Comment doesn't make sense?

[no longer working on chromium, 2013/11/06 16:45:14]

Done with changing the comment.

+  // stereo swapping.
+}
+
+void WebRtcAudioProcessor::FeedRenderDataToAudioProcessing(

[DaleCurtis, 2013/11/06 00:21:18]

This method isn't defined in the header file??  Is it even being used?

[no longer working on chromium, 2013/11/06 16:45:14]

I forgot to update the naming. Fixed now.

+    const int16* render_audio, int sample_rate, int number_of_channels,
+    int number_of_frames, int render_delay_ms) {
+  // Return immediately if the echo cancellation is off.
+  if (!audio_processing_.get() ||

[DaleCurtis, 2013/11/06 00:21:18]

Remove .get()

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+      !audio_processing_->echo_cancellation()->is_enabled())
+    return;
+
+  TRACE_EVENT0("audio",
+               "WebRtcAudioProcessor::FeedRenderDataToAudioProcessing");
+  {
+    base::AutoLock auto_lock(lock_);
+    render_delay_ms_ = render_delay_ms;
+  }
+
+  InitializeRenderConverterIfNeeded(sample_rate, number_of_channels,
+                                    number_of_frames);
+  DCHECK(render_converter_.get());

[DaleCurtis, 2013/11/06 00:21:18]

Unnecessary

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+
+  // TODO(xians): Avoid this extra interleave/deinterleave.
+  scoped_ptr<media::AudioBus> data_bus = media::AudioBus::Create(

[DaleCurtis, 2013/11/06 00:21:18]

Avoid allocating this every callback, it's slow to do so.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+      number_of_channels, number_of_frames);
+  data_bus->FromInterleaved(render_audio,
+                            data_bus->frames(),
+                            sizeof(render_audio[0]));
+  render_converter_->Push(data_bus.get());
+  while (render_converter_->Convert()) {
+    audio_processing_->AnalyzeReverseStream(render_converter_->audio_frame());
+  }
+}
+
+void WebRtcAudioProcessor::InitializeAudioProcessingModule(

[DaleCurtis, 2013/11/06 00:21:18]

I have no idea about any of these settings below, someone from WebRTC should
review this part.

[no longer working on chromium, 2013/11/06 16:45:14]

OK, I will ask Henrik G to review this.

+    const webrtc::MediaConstraintsInterface* constraints) {
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();

[DaleCurtis, 2013/11/06 00:21:18]

Why the const&? Just use ->

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+  if (!command_line.HasSwitch(switches::kEnableAudioTrackProcessing))
+    return;
+
+  if (!constraints)
+    return;
+
+  bool enable_aec = GetPropertyFromConstraints(

[DaleCurtis, 2013/11/06 00:21:18]

const all these?

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+      constraints, MediaConstraintsInterface::kEchoCancellation);
+  bool enable_experimental_aec = GetPropertyFromConstraints(
+      constraints, MediaConstraintsInterface::kExperimentalEchoCancellation);
+  bool enable_ns = GetPropertyFromConstraints(
+      constraints, MediaConstraintsInterface::kNoiseSuppression);
+  bool enable_high_pass_filter = GetPropertyFromConstraints(
+      constraints, MediaConstraintsInterface::kHighpassFilter);
+  bool enable_typing_detection = GetPropertyFromConstraints(
+      constraints, MediaConstraintsInterface::kTypingNoiseDetection);
+  // TODO(xians): How to start and stop AEC dump?
+  bool start_aec_dump = GetPropertyFromConstraints(
+      constraints, MediaConstraintsInterface::kInternalAecDump);
+#if defined(IOS) || defined(ANDROID)

[DaleCurtis, 2013/11/06 00:21:18]

Use #if .. #else and const these too.

[no longer working on chromium, 2013/11/06 16:45:14]

Done.

+  enable_typing_detection = false;
+  enable_experimental_aec = false;
+#endif
+
+  // Reset the audio processing to NULL if no audio processing component is
+  // enabled.
+  if (!enable_aec && !enable_experimental_aec && !enable_ns &&
+      !enable_high_pass_filter && !enable_typing_detection) {
+    return;
+  }
+
+  // Create and configure the audio processing if it does not exist.
+  if (!audio_processing_.get())
+    audio_processing_.reset(webrtc::AudioProcessing::Create(0));
+
+  // Enable the audio processing components.
+  if (enable_aec) {
+    EnableEchoCancellation(audio_processing_.get());
+
+    if (enable_experimental_aec)
+      EnableExperimentalEchoCancellation(audio_processing_.get());
+  }
+
+  if (enable_ns)
+    EnableNoiseSuppression(audio_processing_.get());
+
+  if (enable_high_pass_filter)
+    EnableHighPassFilter(audio_processing_.get());
+
+  if (enable_typing_detection)
+    EnableTypingDetection(audio_processing_.get());
+
+  if (enable_aec && start_aec_dump)
+    StartAecDump(audio_processing_.get());
+
+  // Configure the audio format the audio processing is running on. This
+  // has to be done after all the needed components are enabled.
+  if (audio_processing_->set_sample_rate_hz(kAudioProcessingSampleRate))
+    NOTREACHED();
+  if (audio_processing_->set_num_channels(kAudioProcessingNumberOfChannel,
+                                          kAudioProcessingNumberOfChannel))
+    NOTREACHED();
+}
+
+void WebRtcAudioProcessor::InitializeRenderConverterIfNeeded(

[DaleCurtis, 2013/11/06 00:21:18]

Is this necessary?  source_params_ and sink_params_ shouldn't change right? 

[no longer working on chromium, 2013/11/06 16:45:14]

Yes, it is necessary.
The first PushRenderData(const int16* render_audio, int sample_rate, int
number_of_channels, int number_of_frames, int render_delay_ms) will trigger the
initialization of the render_converter_, then the source_params might be changed
on the fly (this is not completely clear yet, depending on how we implement the
render mixer for webrtc).

+    int sample_rate, int number_of_channels, int frames_per_buffer) {
+  // TODO, figure out if we need to handle the buffer size change.
+  if (render_converter_.get() &&
+      render_converter_->source_parameters().sample_rate() == sample_rate &&
+      render_converter_->source_parameters().channels() == number_of_channels) {
+    // Do nothing if the |render_converter_| has been setup properly.
+    return;
+  }
+
+  media::AudioParameters source_params(
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+      media::GuessChannelLayout(number_of_channels), sample_rate, 16,
+      frames_per_buffer);
+  media::AudioParameters sink_params(
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+      media::CHANNEL_LAYOUT_MONO, kAudioProcessingSampleRate, 16,
+      kAudioProcessingSampleRate / 100);
+  render_converter_.reset(new WebRtcAudioConverter(source_params, sink_params));
+}
+
+void WebRtcAudioProcessor::StopAudioProcessing() {
+  if (!audio_processing_.get())
+    return;
+
+  // It is safe to stop the AEC dump even it is not started.
+  StopAecDump(audio_processing_.get());
+
+  audio_processing_.reset();
+}
+
+}  // namespace content