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

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 30 matching lines @@
 class AudioProcessingImpl : public AudioProcessing {
  public:
   // Methods forcing APM to run in a single-threaded manner.
   // Acquires both the render and capture locks.
   explicit AudioProcessingImpl(const webrtc::Config& config);
   // AudioProcessingImpl takes ownership of beamformer.
   AudioProcessingImpl(const webrtc::Config& config,
                       NonlinearBeamformer* beamformer);
   ~AudioProcessingImpl() override;
   int Initialize() override;
-  int 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) override;
+  int Initialize(int capture_input_sample_rate_hz,
+                 int capture_output_sample_rate_hz,
+                 int render_sample_rate_hz,
+                 ChannelLayout capture_input_layout,
+                 ChannelLayout capture_output_layout,
+                 ChannelLayout render_input_layout) override;
   int Initialize(const ProcessingConfig& processing_config) override;
   void ApplyConfig(const AudioProcessing::Config& config) override;
   void SetExtraOptions(const webrtc::Config& config) override;
   void UpdateHistogramsOnCallEnd() override;
   int StartDebugRecording(const char filename[kMaxFilenameSize],
                           int64_t max_log_size_bytes) override;
   int StartDebugRecording(FILE* handle, int64_t max_log_size_bytes) override;
 
   int StartDebugRecordingForPlatformFile(rtc::PlatformFile handle) override;
   int StopDebugRecording() override;
@@ skipping 19 matching lines @@
   void set_stream_key_pressed(bool key_pressed) override;
 
   // Render-side exclusive methods possibly running APM in a
   // multi-threaded manner. Acquire the render lock.
   int ProcessReverseStream(AudioFrame* frame) override;
   int AnalyzeReverseStream(const float* const* data,
                            size_t samples_per_channel,
                            int sample_rate_hz,
                            ChannelLayout layout) override;
   int ProcessReverseStream(const float* const* src,
-                           const StreamConfig& reverse_input_config,
-                           const StreamConfig& reverse_output_config,
+                           const StreamConfig& input_config,
+                           const StreamConfig& output_config,
                            float* const* dest) override;
 
   // Methods only accessed from APM submodules or
   // from AudioProcessing tests in a single-threaded manner.
   // Hence there is no need for locks in these.
   int proc_sample_rate_hz() const override;
   int proc_split_sample_rate_hz() const override;
   size_t num_input_channels() const override;
   size_t num_proc_channels() const override;
   size_t num_output_channels() const override;
@@ skipping 99 matching lines @@
                              bool force_initialization)
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_);
 
   // Method for updating the state keeping track of the active submodules.
   // Returns a bool indicating whether the state has changed.
   bool UpdateActiveSubmoduleStates() EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
 
   // Methods requiring APM running in a single-threaded manner.
   // Are called with both the render and capture locks already
   // acquired.
-  void InitializeExperimentalAgc()
-      EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
   void InitializeTransient()
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
   void InitializeBeamformer()
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
   void InitializeIntelligibility()
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
-  void InitializeHighPassFilter()
-      EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
-  void InitializeNoiseSuppression()
-      EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
-  void InitializeLevelEstimator()
-      EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
-  void InitializeVoiceDetection()
-      EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
-  void InitializeEchoCanceller()
-      EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
-  void InitializeGainController()
-      EXCLUSIVE_LOCKS_REQUIRED(crit_render_, crit_capture_);
-  void InitializeEchoControlMobile()
-      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_);
 
   // Capture-side exclusive methods possibly running APM in a multi-threaded
   // manner that are called with the render lock already acquired.
-  int ProcessStreamLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_capture_);
+  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.
   int AnalyzeReverseStreamLocked(const float* const* src,
                                  const StreamConfig& input_config,
                                  const StreamConfig& output_config)
       EXCLUSIVE_LOCKS_REQUIRED(crit_render_);
-  int ProcessReverseStreamLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_render_);
+  int ProcessRenderStreamLocked() EXCLUSIVE_LOCKS_REQUIRED(crit_render_);
 
 // Debug dump methods that are internal and called without locks.
 // TODO(peah): Make thread safe.
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // TODO(andrew): make this more graceful. Ideally we would split this stuff
   // out into a separate class with an "enabled" and "disabled" implementation.
   static int WriteMessageToDebugFile(FileWrapper* debug_file,
                                      int64_t* filesize_limit_bytes,
                                      rtc::CriticalSection* crit_debug,
                                      ApmDebugDumpThreadState* debug_state);
@@ skipping 29 matching lines @@
   // As this is only accessed internally of APM, and all internal methods in APM
   // either are holding the render or capture locks, this construct is safe as
   // it is not possible to read the variables while writing them.
   struct ApmFormatState {
     ApmFormatState()
         :  // Format of processing streams at input/output call sites.
           api_format({{{kSampleRate16kHz, 1, false},
                        {kSampleRate16kHz, 1, false},
                        {kSampleRate16kHz, 1, false},
                        {kSampleRate16kHz, 1, false}}}),
-          rev_proc_format(kSampleRate16kHz, 1) {}
+          render_processing_format(kSampleRate16kHz, 1) {}
     ProcessingConfig api_format;
-    StreamConfig rev_proc_format;
+    StreamConfig render_processing_format;
   } formats_;
 
   // APM constants.
   const struct ApmConstants {
     ApmConstants(int agc_startup_min_volume, bool use_experimental_agc)
         :  // Format of processing streams at input/output call sites.
           agc_startup_min_volume(agc_startup_min_volume),
           use_experimental_agc(use_experimental_agc) {}
     int agc_startup_min_volume;
     bool use_experimental_agc;
   } constants_;
 
   struct ApmCaptureState {
     ApmCaptureState(bool transient_suppressor_enabled,
                     const std::vector<Point>& array_geometry,
                     SphericalPointf target_direction);
     ~ApmCaptureState();
     int aec_system_delay_jumps;
     int delay_offset_ms;
     bool was_stream_delay_set;
     int last_stream_delay_ms;
     int last_aec_system_delay_ms;
     int stream_delay_jumps;
     bool output_will_be_muted;
     bool key_pressed;
     bool transient_suppressor_enabled;
     std::vector<Point> array_geometry;
     SphericalPointf target_direction;
     std::unique_ptr<AudioBuffer> capture_audio;
-    // Only the rate and samples fields of fwd_proc_format_ are used because the
-    // forward processing number of channels is mutable and is tracked by the
-    // capture_audio_.
-    StreamConfig fwd_proc_format;
+    // Only the rate and samples fields of capture_processing_format_ are used
+    // because the capture processing number of channels is mutable and is
+    // tracked by the capture_audio_.
+    StreamConfig capture_processing_format;
     int split_rate;
   } capture_ GUARDED_BY(crit_capture_);
 
   struct ApmCaptureNonLockedState {
     ApmCaptureNonLockedState(bool beamformer_enabled,
                              bool intelligibility_enabled)
-        : fwd_proc_format(kSampleRate16kHz),
+        : capture_processing_format(kSampleRate16kHz),
           split_rate(kSampleRate16kHz),
           stream_delay_ms(0),
           beamformer_enabled(beamformer_enabled),
           intelligibility_enabled(intelligibility_enabled) {}
-    // Only the rate and samples fields of fwd_proc_format_ are used because the
-    // forward processing number of channels is mutable and is tracked by the
-    // capture_audio_.
-    StreamConfig fwd_proc_format;
+    // Only the rate and samples fields of capture_processing_format_ are used
+    // because the forward processing number of channels is mutable and is
+    // tracked by the capture_audio_.
+    StreamConfig capture_processing_format;
     int split_rate;
     int stream_delay_ms;
     bool beamformer_enabled;
     bool intelligibility_enabled;
     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_);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_AUDIO_PROCESSING_IMPL_H_