This CL renames variables and method and removes some one-line methods inside the APM

webrtc/modules/audio_processing/audio_processing_impl.cc

Index: webrtc/modules/audio_processing/audio_processing_impl.cc
diff --git a/webrtc/modules/audio_processing/audio_processing_impl.cc b/webrtc/modules/audio_processing/audio_processing_impl.cc
index 9b7b95334542f70241458488324d614a4ec19554..300fc02e546e72589ae50ccf8bad6f5c9d1fb7b5 100644
--- a/webrtc/modules/audio_processing/audio_processing_impl.cc
+++ b/webrtc/modules/audio_processing/audio_processing_impl.cc
@@ -323,25 +323,22 @@ int AudioProcessingImpl::Initialize() {
   return InitializeLocked();
 }
 
-int AudioProcessingImpl::Initialize(int input_sample_rate_hz,
-                                    int output_sample_rate_hz,
-                                    int reverse_sample_rate_hz,
-                                    ChannelLayout input_layout,
-                                    ChannelLayout output_layout,
-                                    ChannelLayout reverse_layout) {
+int AudioProcessingImpl::Initialize(int capture_input_sample_rate_hz,
+                                    int capture_output_sample_rate_hz,
+                                    int render_input_sample_rate_hz,
+                                    ChannelLayout capture_input_layout,
+                                    ChannelLayout capture_output_layout,
+                                    ChannelLayout render_input_layout) {
   const ProcessingConfig processing_config = {
-      {{input_sample_rate_hz,
-        ChannelsFromLayout(input_layout),
-        LayoutHasKeyboard(input_layout)},
-       {output_sample_rate_hz,
-        ChannelsFromLayout(output_layout),
-        LayoutHasKeyboard(output_layout)},
-       {reverse_sample_rate_hz,
-        ChannelsFromLayout(reverse_layout),
-        LayoutHasKeyboard(reverse_layout)},
-       {reverse_sample_rate_hz,
-        ChannelsFromLayout(reverse_layout),
-        LayoutHasKeyboard(reverse_layout)}}};
+      {{capture_input_sample_rate_hz, ChannelsFromLayout(capture_input_layout),
+        LayoutHasKeyboard(capture_input_layout)},
+       {capture_output_sample_rate_hz,
+        ChannelsFromLayout(capture_output_layout),
+        LayoutHasKeyboard(capture_output_layout)},
+       {render_input_sample_rate_hz, ChannelsFromLayout(render_input_layout),
+        LayoutHasKeyboard(render_input_layout)},
+       {render_input_sample_rate_hz, ChannelsFromLayout(render_input_layout),
+        LayoutHasKeyboard(render_input_layout)}}};
 
   return Initialize(processing_config);
 }
@@ -393,21 +390,21 @@ int AudioProcessingImpl::MaybeInitialize(
 }
 
 int AudioProcessingImpl::InitializeLocked() {
-  const int fwd_audio_buffer_channels =
+  const int capture_audiobuffer_num_channels =
       capture_nonlocked_.beamformer_enabled
           ? formats_.api_format.input_stream().num_channels()
           : formats_.api_format.output_stream().num_channels();
-  const int rev_audio_buffer_out_num_frames =
+  const int render_audiobuffer_num_output_frames =
       formats_.api_format.reverse_output_stream().num_frames() == 0
-          ? formats_.rev_proc_format.num_frames()
+          ? formats_.render_processing_format.num_frames()
           : formats_.api_format.reverse_output_stream().num_frames();
   if (formats_.api_format.reverse_input_stream().num_channels() > 0) {
     render_.render_audio.reset(new AudioBuffer(
         formats_.api_format.reverse_input_stream().num_frames(),
         formats_.api_format.reverse_input_stream().num_channels(),
-        formats_.rev_proc_format.num_frames(),
-        formats_.rev_proc_format.num_channels(),
-        rev_audio_buffer_out_num_frames));
+        formats_.render_processing_format.num_frames(),
+        formats_.render_processing_format.num_channels(),
+        render_audiobuffer_num_output_frames));
     if (formats_.api_format.reverse_input_stream() !=
         formats_.api_format.reverse_output_stream()) {
       render_.render_converter = AudioConverter::Create(
@@ -425,23 +422,40 @@ int AudioProcessingImpl::InitializeLocked() {
   capture_.capture_audio.reset(
       new AudioBuffer(formats_.api_format.input_stream().num_frames(),
                       formats_.api_format.input_stream().num_channels(),
-                      capture_nonlocked_.fwd_proc_format.num_frames(),
-                      fwd_audio_buffer_channels,
+                      capture_nonlocked_.capture_processing_format.num_frames(),
+                      capture_audiobuffer_num_channels,
                       formats_.api_format.output_stream().num_frames()));
 
-  InitializeGainController();
-  InitializeEchoCanceller();
-  InitializeEchoControlMobile();
-  InitializeExperimentalAgc();
+  public_submodules_->gain_control->Initialize(num_proc_channels(),
+                                               proc_sample_rate_hz());
+  public_submodules_->echo_cancellation->Initialize(
+      proc_sample_rate_hz(), num_reverse_channels(), num_output_channels(),
+      num_proc_channels());
+  public_submodules_->echo_control_mobile->Initialize(
+      proc_split_sample_rate_hz(), num_reverse_channels(),
+      num_output_channels());
+  if (constants_.use_experimental_agc) {
+    if (!private_submodules_->agc_manager.get()) {
+      private_submodules_->agc_manager.reset(new AgcManagerDirect(
+          public_submodules_->gain_control.get(),
+          public_submodules_->gain_control_for_experimental_agc.get(),
+          constants_.agc_startup_min_volume));
+    }
+    private_submodules_->agc_manager->Initialize();
+    private_submodules_->agc_manager->SetCaptureMuted(
+        capture_.output_will_be_muted);
+  }
   InitializeTransient();
   InitializeBeamformer();
 #if WEBRTC_INTELLIGIBILITY_ENHANCER
   InitializeIntelligibility();
 #endif
-  InitializeHighPassFilter();
-  InitializeNoiseSuppression();
-  InitializeLevelEstimator();
-  InitializeVoiceDetection();
+  public_submodules_->high_pass_filter->Initialize(num_proc_channels(),
+                                                   proc_sample_rate_hz());
+  public_submodules_->noise_suppression->Initialize(num_proc_channels(),
+                                                    proc_sample_rate_hz());
+  public_submodules_->voice_detection->Initialize(proc_split_sample_rate_hz());
+  public_submodules_->level_estimator->Initialize();
   InitializeLevelController();
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
@@ -480,44 +494,49 @@ int AudioProcessingImpl::InitializeLocked(const ProcessingConfig& config) {
 
   formats_.api_format = config;
 
-  int fwd_proc_rate = FindNativeProcessRateToUse(
+  int capture_processing_rate = FindNativeProcessRateToUse(
       std::min(formats_.api_format.input_stream().sample_rate_hz(),
                formats_.api_format.output_stream().sample_rate_hz()),
       submodule_states_.CaptureMultiBandSubModulesActive() ||
           submodule_states_.RenderMultiBandSubModulesActive());
 
-  capture_nonlocked_.fwd_proc_format = StreamConfig(fwd_proc_rate);
+  capture_nonlocked_.capture_processing_format =
+      StreamConfig(capture_processing_rate);
 
-  int rev_proc_rate = FindNativeProcessRateToUse(
+  int render_processing_rate = FindNativeProcessRateToUse(
       std::min(formats_.api_format.reverse_input_stream().sample_rate_hz(),
                formats_.api_format.reverse_output_stream().sample_rate_hz()),
       submodule_states_.CaptureMultiBandSubModulesActive() ||
           submodule_states_.RenderMultiBandSubModulesActive());
   // TODO(aluebs): Remove this restriction once we figure out why the 3-band
   // splitting filter degrades the AEC performance.
-  if (rev_proc_rate > kSampleRate32kHz) {
-    rev_proc_rate = submodule_states_.RenderMultiBandProcessingActive()
-                        ? kSampleRate32kHz
-                        : kSampleRate16kHz;
+  if (render_processing_rate > kSampleRate32kHz) {
+    render_processing_rate = submodule_states_.RenderMultiBandProcessingActive()
+                                 ? kSampleRate32kHz
+                                 : kSampleRate16kHz;
   }
-  // If the forward sample rate is 8 kHz, the reverse stream is also processed
+  // If the forward sample rate is 8 kHz, the render stream is also processed
   // at this rate.
-  if (capture_nonlocked_.fwd_proc_format.sample_rate_hz() == kSampleRate8kHz) {
-    rev_proc_rate = kSampleRate8kHz;
+  if (capture_nonlocked_.capture_processing_format.sample_rate_hz() ==
+      kSampleRate8kHz) {
+    render_processing_rate = kSampleRate8kHz;
   } else {
-    rev_proc_rate = std::max(rev_proc_rate, static_cast<int>(kSampleRate16kHz));
+    render_processing_rate =
+        std::max(render_processing_rate, static_cast<int>(kSampleRate16kHz));
   }
 
-  // Always downmix the reverse stream to mono for analysis. This has been
+  // Always downmix the render stream to mono for analysis. This has been
   // demonstrated to work well for AEC in most practical scenarios.
-  formats_.rev_proc_format = StreamConfig(rev_proc_rate, 1);
+  formats_.render_processing_format = StreamConfig(render_processing_rate, 1);
 
-  if (capture_nonlocked_.fwd_proc_format.sample_rate_hz() == kSampleRate32kHz ||
-      capture_nonlocked_.fwd_proc_format.sample_rate_hz() == kSampleRate48kHz) {
+  if (capture_nonlocked_.capture_processing_format.sample_rate_hz() ==
+          kSampleRate32kHz ||
+      capture_nonlocked_.capture_processing_format.sample_rate_hz() ==
+          kSampleRate48kHz) {
     capture_nonlocked_.split_rate = kSampleRate16kHz;
   } else {
     capture_nonlocked_.split_rate =
-        capture_nonlocked_.fwd_proc_format.sample_rate_hz();
+        capture_nonlocked_.capture_processing_format.sample_rate_hz();
   }
 
   return InitializeLocked();
@@ -588,7 +607,7 @@ void AudioProcessingImpl::SetExtraOptions(const webrtc::Config& config) {
 
 int AudioProcessingImpl::proc_sample_rate_hz() const {
   // Used as callback from submodules, hence locking is not allowed.
-  return capture_nonlocked_.fwd_proc_format.sample_rate_hz();
+  return capture_nonlocked_.capture_processing_format.sample_rate_hz();
 }
 
 int AudioProcessingImpl::proc_split_sample_rate_hz() const {
@@ -598,7 +617,7 @@ int AudioProcessingImpl::proc_split_sample_rate_hz() const {
 
 size_t AudioProcessingImpl::num_reverse_channels() const {
   // Used as callback from submodules, hence locking is not allowed.
-  return formats_.rev_proc_format.num_channels();
+  return formats_.render_processing_format.num_channels();
 }
 
 size_t AudioProcessingImpl::num_input_channels() const {
@@ -710,7 +729,7 @@ int AudioProcessingImpl::ProcessStream(const float* const* src,
 #endif
 
   capture_.capture_audio->CopyFrom(src, formats_.api_format.input_stream());
-  RETURN_ON_ERR(ProcessStreamLocked());
+  RETURN_ON_ERR(ProcessCaptureStreamLocked());
   capture_.capture_audio->CopyTo(formats_.api_format.output_stream(), dest);
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
@@ -799,7 +818,7 @@ int AudioProcessingImpl::ProcessStream(AudioFrame* frame) {
 #endif
 
   capture_.capture_audio->DeinterleaveFrom(frame);
-  RETURN_ON_ERR(ProcessStreamLocked());
+  RETURN_ON_ERR(ProcessCaptureStreamLocked());
   capture_.capture_audio->InterleaveTo(
       frame, submodule_states_.CaptureMultiBandProcessingActive());
 
@@ -818,7 +837,7 @@ int AudioProcessingImpl::ProcessStream(AudioFrame* frame) {
   return kNoError;
 }
 
-int AudioProcessingImpl::ProcessStreamLocked() {
+int AudioProcessingImpl::ProcessCaptureStreamLocked() {
   // Ensure that not both the AEC and AECM are active at the same time.
   // TODO(peah): Simplify once the public API Enable functions for these
   // are moved to APM.
@@ -838,30 +857,32 @@ int AudioProcessingImpl::ProcessStreamLocked() {
 
   MaybeUpdateHistograms();
 
-  AudioBuffer* ca = capture_.capture_audio.get();  // For brevity.
+  AudioBuffer* capture_buffer = capture_.capture_audio.get();  // For brevity.
 
   if (constants_.use_experimental_agc &&
       public_submodules_->gain_control->is_enabled()) {
     private_submodules_->agc_manager->AnalyzePreProcess(
-        ca->channels()[0], ca->num_channels(),
-        capture_nonlocked_.fwd_proc_format.num_frames());
+        capture_buffer->channels()[0], capture_buffer->num_channels(),
+        capture_nonlocked_.capture_processing_format.num_frames());
   }
 
   if (submodule_states_.CaptureMultiBandSubModulesActive() &&
       SampleRateSupportsMultiBand(
-          capture_nonlocked_.fwd_proc_format.sample_rate_hz())) {
-    ca->SplitIntoFrequencyBands();
+          capture_nonlocked_.capture_processing_format.sample_rate_hz())) {
+    capture_buffer->SplitIntoFrequencyBands();
   }
 
   if (capture_nonlocked_.beamformer_enabled) {
-    private_submodules_->beamformer->AnalyzeChunk(*ca->split_data_f());
+    private_submodules_->beamformer->AnalyzeChunk(
+        *capture_buffer->split_data_f());
     // Discards all channels by the leftmost one.
-    ca->set_num_channels(1);
+    capture_buffer->set_num_channels(1);
   }
 
-  public_submodules_->high_pass_filter->ProcessCaptureAudio(ca);
-  RETURN_ON_ERR(public_submodules_->gain_control->AnalyzeCaptureAudio(ca));
-  public_submodules_->noise_suppression->AnalyzeCaptureAudio(ca);
+  public_submodules_->high_pass_filter->ProcessCaptureAudio(capture_buffer);
+  RETURN_ON_ERR(
+      public_submodules_->gain_control->AnalyzeCaptureAudio(capture_buffer));
+  public_submodules_->noise_suppression->AnalyzeCaptureAudio(capture_buffer);
 
   // Ensure that the stream delay was set before the call to the
   // AEC ProcessCaptureAudio function.
@@ -871,13 +892,13 @@ int AudioProcessingImpl::ProcessStreamLocked() {
   }
 
   RETURN_ON_ERR(public_submodules_->echo_cancellation->ProcessCaptureAudio(
-      ca, stream_delay_ms()));
+      capture_buffer, stream_delay_ms()));
 
   if (public_submodules_->echo_control_mobile->is_enabled() &&
       public_submodules_->noise_suppression->is_enabled()) {
-    ca->CopyLowPassToReference();
+    capture_buffer->CopyLowPassToReference();
   }
-  public_submodules_->noise_suppression->ProcessCaptureAudio(ca);
+  public_submodules_->noise_suppression->ProcessCaptureAudio(capture_buffer);
 #if WEBRTC_INTELLIGIBILITY_ENHANCER
   if (capture_nonlocked_.intelligibility_enabled) {
     RTC_DCHECK(public_submodules_->noise_suppression->is_enabled());
@@ -901,29 +922,29 @@ int AudioProcessingImpl::ProcessStreamLocked() {
   }
 
   RETURN_ON_ERR(public_submodules_->echo_control_mobile->ProcessCaptureAudio(
-      ca, stream_delay_ms()));
+      capture_buffer, stream_delay_ms()));
 
   if (capture_nonlocked_.beamformer_enabled) {
-    private_submodules_->beamformer->PostFilter(ca->split_data_f());
+    private_submodules_->beamformer->PostFilter(capture_buffer->split_data_f());
   }
 
-  public_submodules_->voice_detection->ProcessCaptureAudio(ca);
+  public_submodules_->voice_detection->ProcessCaptureAudio(capture_buffer);
 
   if (constants_.use_experimental_agc &&
       public_submodules_->gain_control->is_enabled() &&
       (!capture_nonlocked_.beamformer_enabled ||
        private_submodules_->beamformer->is_target_present())) {
     private_submodules_->agc_manager->Process(
-        ca->split_bands_const(0)[kBand0To8kHz], ca->num_frames_per_band(),
-        capture_nonlocked_.split_rate);
+        capture_buffer->split_bands_const(0)[kBand0To8kHz],
+        capture_buffer->num_frames_per_band(), capture_nonlocked_.split_rate);
   }
   RETURN_ON_ERR(public_submodules_->gain_control->ProcessCaptureAudio(
-      ca, echo_cancellation()->stream_has_echo()));
+      capture_buffer, echo_cancellation()->stream_has_echo()));
 
   if (submodule_states_.CaptureMultiBandProcessingActive() &&
       SampleRateSupportsMultiBand(
-          capture_nonlocked_.fwd_proc_format.sample_rate_hz())) {
-    ca->MergeFrequencyBands();
+          capture_nonlocked_.capture_processing_format.sample_rate_hz())) {
+    capture_buffer->MergeFrequencyBands();
   }
 
   // TODO(aluebs): Investigate if the transient suppression placement should be
@@ -935,18 +956,20 @@ int AudioProcessingImpl::ProcessStreamLocked() {
             : 1.f;
 
     public_submodules_->transient_suppressor->Suppress(
-        ca->channels_f()[0], ca->num_frames(), ca->num_channels(),
-        ca->split_bands_const_f(0)[kBand0To8kHz], ca->num_frames_per_band(),
-        ca->keyboard_data(), ca->num_keyboard_frames(), voice_probability,
+        capture_buffer->channels_f()[0], capture_buffer->num_frames(),
+        capture_buffer->num_channels(),
+        capture_buffer->split_bands_const_f(0)[kBand0To8kHz],
+        capture_buffer->num_frames_per_band(), capture_buffer->keyboard_data(),
+        capture_buffer->num_keyboard_frames(), voice_probability,
         capture_.key_pressed);
   }
 
   if (capture_nonlocked_.level_controller_enabled) {
-    private_submodules_->level_controller->Process(ca);
+    private_submodules_->level_controller->Process(capture_buffer);
   }
 
   // The level estimator operates on the recombined data.
-  public_submodules_->level_estimator->ProcessStream(ca);
+  public_submodules_->level_estimator->ProcessStream(capture_buffer);
 
   capture_.was_stream_delay_set = false;
   return kNoError;
@@ -954,12 +977,12 @@ int AudioProcessingImpl::ProcessStreamLocked() {
 
 int AudioProcessingImpl::AnalyzeReverseStream(const float* const* data,
                                               size_t samples_per_channel,
-                                              int rev_sample_rate_hz,
+                                              int sample_rate_hz,
                                               ChannelLayout layout) {
   TRACE_EVENT0("webrtc", "AudioProcessing::AnalyzeReverseStream_ChannelLayout");
   rtc::CritScope cs(&crit_render_);
   const StreamConfig reverse_config = {
-      rev_sample_rate_hz, ChannelsFromLayout(layout), LayoutHasKeyboard(layout),
+      sample_rate_hz, ChannelsFromLayout(layout), LayoutHasKeyboard(layout),
   };
   if (samples_per_channel != reverse_config.num_frames()) {
     return kBadDataLengthError;
@@ -967,26 +990,23 @@ int AudioProcessingImpl::AnalyzeReverseStream(const float* const* data,
   return AnalyzeReverseStreamLocked(data, reverse_config, reverse_config);
 }
 
-int AudioProcessingImpl::ProcessReverseStream(
-    const float* const* src,
-    const StreamConfig& reverse_input_config,
-    const StreamConfig& reverse_output_config,
-    float* const* dest) {
+int AudioProcessingImpl::ProcessReverseStream(const float* const* src,
+                                              const StreamConfig& input_config,
+                                              const StreamConfig& output_config,
+                                              float* const* dest) {
   TRACE_EVENT0("webrtc", "AudioProcessing::ProcessReverseStream_StreamConfig");
   rtc::CritScope cs(&crit_render_);
-  RETURN_ON_ERR(AnalyzeReverseStreamLocked(src, reverse_input_config,
-                                           reverse_output_config));
+  RETURN_ON_ERR(AnalyzeReverseStreamLocked(src, input_config, output_config));
   if (submodule_states_.RenderMultiBandProcessingActive()) {
     render_.render_audio->CopyTo(formats_.api_format.reverse_output_stream(),
                                  dest);
   } else if (formats_.api_format.reverse_input_stream() !=
              formats_.api_format.reverse_output_stream()) {
-    render_.render_converter->Convert(src, reverse_input_config.num_samples(),
-                                      dest,
-                                      reverse_output_config.num_samples());
+    render_.render_converter->Convert(src, input_config.num_samples(), dest,
+                                      output_config.num_samples());
   } else {
-    CopyAudioIfNeeded(src, reverse_input_config.num_frames(),
-                      reverse_input_config.num_channels(), dest);
+    CopyAudioIfNeeded(src, input_config.num_frames(),
+                      input_config.num_channels(), dest);
   }
 
   return kNoError;
@@ -994,23 +1014,23 @@ int AudioProcessingImpl::ProcessReverseStream(
 
 int AudioProcessingImpl::AnalyzeReverseStreamLocked(
     const float* const* src,
-    const StreamConfig& reverse_input_config,
-    const StreamConfig& reverse_output_config) {
+    const StreamConfig& input_config,
+    const StreamConfig& output_config) {
   if (src == nullptr) {
     return kNullPointerError;
   }
 
-  if (reverse_input_config.num_channels() == 0) {
+  if (input_config.num_channels() == 0) {
     return kBadNumberChannelsError;
   }
 
   ProcessingConfig processing_config = formats_.api_format;
-  processing_config.reverse_input_stream() = reverse_input_config;
-  processing_config.reverse_output_stream() = reverse_output_config;
+  processing_config.reverse_input_stream() = input_config;
+  processing_config.reverse_output_stream() = output_config;
 
   RETURN_ON_ERR(MaybeInitializeRender(processing_config));
-  RTC_DCHECK_EQ(reverse_input_config.num_frames(),
-                formats_.api_format.reverse_input_stream().num_frames());
+  assert(input_config.num_frames() ==
+         formats_.api_format.reverse_input_stream().num_frames());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_dump_.debug_file->is_open()) {
@@ -1030,7 +1050,7 @@ int AudioProcessingImpl::AnalyzeReverseStreamLocked(
 
   render_.render_audio->CopyFrom(src,
                                  formats_.api_format.reverse_input_stream());
-  return ProcessReverseStreamLocked();
+  return ProcessRenderStreamLocked();
 }
 
 int AudioProcessingImpl::ProcessReverseStream(AudioFrame* frame) {
@@ -1081,37 +1101,41 @@ int AudioProcessingImpl::ProcessReverseStream(AudioFrame* frame) {
   }
 #endif
   render_.render_audio->DeinterleaveFrom(frame);
-  RETURN_ON_ERR(ProcessReverseStreamLocked());
+  RETURN_ON_ERR(ProcessRenderStreamLocked());
   render_.render_audio->InterleaveTo(
       frame, submodule_states_.RenderMultiBandProcessingActive());
   return kNoError;
 }
 
-int AudioProcessingImpl::ProcessReverseStreamLocked() {
-  AudioBuffer* ra = render_.render_audio.get();  // For brevity.
+int AudioProcessingImpl::ProcessRenderStreamLocked() {
+  AudioBuffer* render_buffer = render_.render_audio.get();  // For brevity.
   if (submodule_states_.RenderMultiBandSubModulesActive() &&
-      SampleRateSupportsMultiBand(formats_.rev_proc_format.sample_rate_hz())) {
-    ra->SplitIntoFrequencyBands();
+      SampleRateSupportsMultiBand(
+          formats_.render_processing_format.sample_rate_hz())) {
+    render_buffer->SplitIntoFrequencyBands();
   }
 
 #if WEBRTC_INTELLIGIBILITY_ENHANCER
   if (capture_nonlocked_.intelligibility_enabled) {
     public_submodules_->intelligibility_enhancer->ProcessRenderAudio(
-        ra->split_channels_f(kBand0To8kHz), capture_nonlocked_.split_rate,
-        ra->num_channels());
+        render_buffer->split_channels_f(kBand0To8kHz),
+        capture_nonlocked_.split_rate, render_buffer->num_channels());
   }
 #endif
 
-  RETURN_ON_ERR(public_submodules_->echo_cancellation->ProcessRenderAudio(ra));
   RETURN_ON_ERR(
-      public_submodules_->echo_control_mobile->ProcessRenderAudio(ra));
+      public_submodules_->echo_cancellation->ProcessRenderAudio(render_buffer));
+  RETURN_ON_ERR(public_submodules_->echo_control_mobile->ProcessRenderAudio(
+      render_buffer));
   if (!constants_.use_experimental_agc) {
-    RETURN_ON_ERR(public_submodules_->gain_control->ProcessRenderAudio(ra));
+    RETURN_ON_ERR(
+        public_submodules_->gain_control->ProcessRenderAudio(render_buffer));
   }
 
   if (submodule_states_.RenderMultiBandProcessingActive() &&
-      SampleRateSupportsMultiBand(formats_.rev_proc_format.sample_rate_hz())) {
-    ra->MergeFrequencyBands();
+      SampleRateSupportsMultiBand(
+          formats_.render_processing_format.sample_rate_hz())) {
+    render_buffer->MergeFrequencyBands();
   }
 
   return kNoError;
@@ -1289,19 +1313,6 @@ bool AudioProcessingImpl::UpdateActiveSubmoduleStates() {
       capture_.transient_suppressor_enabled);
 }
 
-void AudioProcessingImpl::InitializeExperimentalAgc() {
-  if (constants_.use_experimental_agc) {
-    if (!private_submodules_->agc_manager.get()) {
-      private_submodules_->agc_manager.reset(new AgcManagerDirect(
-          public_submodules_->gain_control.get(),
-          public_submodules_->gain_control_for_experimental_agc.get(),
-          constants_.agc_startup_min_volume));
-    }
-    private_submodules_->agc_manager->Initialize();
-    private_submodules_->agc_manager->SetCaptureMuted(
-        capture_.output_will_be_muted);
-  }
-}
 
 void AudioProcessingImpl::InitializeTransient() {
   if (capture_.transient_suppressor_enabled) {
@@ -1309,9 +1320,8 @@ void AudioProcessingImpl::InitializeTransient() {
       public_submodules_->transient_suppressor.reset(new TransientSuppressor());
     }
     public_submodules_->transient_suppressor->Initialize(
-        capture_nonlocked_.fwd_proc_format.sample_rate_hz(),
-        capture_nonlocked_.split_rate,
-        num_proc_channels());
+        capture_nonlocked_.capture_processing_format.sample_rate_hz(),
+        capture_nonlocked_.split_rate, num_proc_channels());
   }
 }
 
@@ -1337,46 +1347,10 @@ void AudioProcessingImpl::InitializeIntelligibility() {
 #endif
 }
 
-void AudioProcessingImpl::InitializeHighPassFilter() {
-  public_submodules_->high_pass_filter->Initialize(num_proc_channels(),
-                                                   proc_sample_rate_hz());
-}
-
-void AudioProcessingImpl::InitializeNoiseSuppression() {
-  public_submodules_->noise_suppression->Initialize(num_proc_channels(),
-                                                    proc_sample_rate_hz());
-}
-
-void AudioProcessingImpl::InitializeEchoCanceller() {
-  public_submodules_->echo_cancellation->Initialize(
-      proc_sample_rate_hz(), num_reverse_channels(), num_output_channels(),
-      num_proc_channels());
-}
-
-void AudioProcessingImpl::InitializeGainController() {
-  public_submodules_->gain_control->Initialize(num_proc_channels(),
-                                               proc_sample_rate_hz());
-}
-
-void AudioProcessingImpl::InitializeEchoControlMobile() {
-  public_submodules_->echo_control_mobile->Initialize(
-      proc_split_sample_rate_hz(),
-      num_reverse_channels(),
-      num_output_channels());
-}
-
-void AudioProcessingImpl::InitializeLevelEstimator() {
-  public_submodules_->level_estimator->Initialize();
-}
-
 void AudioProcessingImpl::InitializeLevelController() {
   private_submodules_->level_controller->Initialize(proc_sample_rate_hz());
 }
 
-void AudioProcessingImpl::InitializeVoiceDetection() {
-  public_submodules_->voice_detection->Initialize(proc_split_sample_rate_hz());
-}
-
 void AudioProcessingImpl::MaybeUpdateHistograms() {
   static const int kMinDiffDelayMs = 60;
 
@@ -1605,7 +1579,7 @@ AudioProcessingImpl::ApmCaptureState::ApmCaptureState(
       transient_suppressor_enabled(transient_suppressor_enabled),
       array_geometry(array_geometry),
       target_direction(target_direction),
-      fwd_proc_format(kSampleRate16kHz),
+      capture_processing_format(kSampleRate16kHz),
       split_rate(kSampleRate16kHz) {}
 
 AudioProcessingImpl::ApmCaptureState::~ApmCaptureState() = default;