Cleaned up and revised the handling of resampling and bandsplitting in APM and

webrtc/modules/audio_processing/audio_processing_impl.cc

 /*
  *  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 64 matching lines @@
     AudioProcessing::kSampleRate16kHz,
     AudioProcessing::kSampleRate32kHz,
     AudioProcessing::kSampleRate48kHz};
 const size_t AudioProcessing::kNumNativeSampleRates =
     arraysize(AudioProcessing::kNativeSampleRatesHz);
 const int AudioProcessing::kMaxNativeSampleRateHz = AudioProcessing::
     kNativeSampleRatesHz[AudioProcessing::kNumNativeSampleRates - 1];
 
 namespace {
 
-const int kInternalNativeRates[] = {AudioProcessing::kSampleRate8kHz,
-                                    AudioProcessing::kSampleRate16kHz,
-#ifdef WEBRTC_ARCH_ARM_FAMILY
-                                    AudioProcessing::kSampleRate32kHz};
-#else
-                                    AudioProcessing::kSampleRate32kHz,
-                                    AudioProcessing::kSampleRate48kHz};
-#endif  // WEBRTC_ARCH_ARM_FAMILY
-
 static bool LayoutHasKeyboard(AudioProcessing::ChannelLayout layout) {
   switch (layout) {
     case AudioProcessing::kMono:
     case AudioProcessing::kStereo:
       return false;
     case AudioProcessing::kMonoAndKeyboard:
     case AudioProcessing::kStereoAndKeyboard:
       return true;
   }
 
   assert(false);
   return false;
 }
 
-bool is_multi_band(int sample_rate_hz) {
+bool SampleRateSupportsMultiBand(int sample_rate_hz) {
   return sample_rate_hz == AudioProcessing::kSampleRate32kHz ||
          sample_rate_hz == AudioProcessing::kSampleRate48kHz;
 }
 
-int ClosestHigherNativeRate(int min_proc_rate) {
-  for (int rate : kInternalNativeRates) {
-    if (rate >= min_proc_rate) {
+int NativeProcessRateToUse(int minimum_rate, bool band_splitting_required) {
+#ifdef WEBRTC_ARCH_ARM_FAMILY
+  const size_t kMaxSplittingNativeProcessRateIndex = 2;
+#else
+  const size_t kMaxSplittingNativeProcessRateIndex = 3;
+#endif
+  RTC_DCHECK_LT(kMaxSplittingNativeProcessRateIndex,

[hlundin-webrtc, 2016/09/06 10:41:32]

You should be able to use a static_assert instead.

[peah-webrtc, 2016/09/07 06:28:11]

Great suggestion but I ran into some problems. See below.

[hlundin-webrtc, 2016/09/07 21:36:05]

Weird. I thought it'd work if you used constexpr in enough places. Never mind
that; keep the DCHECK.

[peah-webrtc, 2016/09/08 08:44:03]

Acknowledged.

+                AudioProcessing::kNumNativeSampleRates);
+  size_t uppermost_native_rate_index =
+      (band_splitting_required ? kMaxSplittingNativeProcessRateIndex : 3);
+
+  for (size_t k = 0; k <= uppermost_native_rate_index; ++k) {

[hlundin-webrtc, 2016/09/06 10:41:32]

Consider this alternative implementation of the function, using the frequencies
directly instead of the indices. Not saying that it is very much better, but
think about it...

#ifdef WEBRTC_ARCH_ARM_FAMILY
const int kMaxSplittingNativeProcessRate = AudioProcessing::kSampleRate32kHz;
#else
const int kMaxSplittingNativeProcessRate = AudioProcessing::kSampleRate48kHz;
#endif
static_assert(kMaxSplittingNativeProcessRate <=
AudioProcessing::kMaxNativeSampleRateHz, "Stupid error string that will no
longer be needed in C++17");

const int uppermost_native_rate = band_splitting_required ?
kMaxSplittingNativeProcessRate : AudioProcessing::kSampleRate48kHz;

for (auto rate : AudioProcessing::kNativeSampleRatesHz) {
  if (rate >= uppermost_native_rate) {
    return uppermost_native_rate;
  }
  if (rate >= minimum_rate) {
    return rate;
  }
}
RTC_NOTREACHED();

[peah-webrtc, 2016/09/07 06:28:11]

This is a much nicer variant! Thanks!!!

I could not, however, get the static assertion to work and get the error
"static_assert expression is not an integral constant expression".

Somehow it is caused by AudioProcessing::kMaxNativeSampleRateHz. The
initialization of that is a bit intricate. I tried to avoid the issue using
constexpr but did not manage that. Is it ok to keep iot as a DCHECK?

[kwiberg-webrtc, 2016/09/08 08:17:27]

What problems did you encounter? It feels like this ought to work if you change
enough "const"s to "constexpr"s.

[peah-webrtc, 2016/09/08 08:44:03]

There are not that many constexpr's to add. I tried adding that for 
const int AudioProcessing::kMaxNativeSampleRateHz =
AudioProcessing::kNativeSampleRatesHz[AudioProcessing::kNumNativeSampleRates -
1];
as well as for
const size_t AudioProcessing::kNumNativeSampleRates =
arraysize(AudioProcessing::kNativeSampleRatesHz); 
const int kMaxSplittingNativeProcessRate = AudioProcessing::kSampleRate48kHz;

But it did not work. My guess was that the arraysize was an issue.

+    int rate = AudioProcessing::kNativeSampleRatesHz[k];
+    if (rate >= minimum_rate) {
       return rate;
     }
   }
-  return kInternalNativeRates[arraysize(kInternalNativeRates) - 1];
+  return AudioProcessing::kNativeSampleRatesHz[uppermost_native_rate_index];
 }
 
 }  // namespace
 
 // Throughout webrtc, it's assumed that success is represented by zero.
 static_assert(AudioProcessing::kNoError == 0, "kNoError must be zero");
 
+class AudioProcessingImpl::ApmSubmoduleStates {
+ public:
+  ApmSubmoduleStates(){};
+  // Updates the submodule state and returns true if it has changed.
+  bool Update(bool hpf_enabled,
+              bool aec_enabled,
+              bool aecm_enabled,
+              bool ns_enabled,
+              bool ie_enabled,
+              bool bf_enabled,
+              bool agc_enabled,
+              bool lc_enabled,
+              bool vad_enabled,
+              bool le_enabled,
+              bool ts_enabled) {

[the sun, 2016/09/02 20:11:34]

What's "ts"? (I could look it up, but I pretend to be a casual reader of the
code.)

Generally the style guide advises against heavy use of abbreviations. Agree we
have a few that are common in this field, but looking at this list I think we've
crossed a border in terms of obscurity. :/

[peah-webrtc, 2016/09/07 06:28:11]

ts is the transient suppressor. 

The abbreviations point is great! I'll remove/reduce those as much as possible.

Done.

+    bool changed = false;
+    changed |= (hpf_enabled != hpf_enabled_);
+    changed |= (aec_enabled != aec_enabled_);
+    changed |= (aecm_enabled != aecm_enabled_);
+    changed |= (ns_enabled != ns_enabled_);
+    changed |= (ie_enabled != ie_enabled_);
+    changed |= (bf_enabled != bf_enabled_);
+    changed |= (agc_enabled != agc_enabled_);
+    changed |= (lc_enabled != lc_enabled_);
+    changed |= (le_enabled != le_enabled_);
+    changed |= (vad_enabled != vad_enabled_);
+    changed |= (ts_enabled != ts_enabled_);
+    if (changed) {
+      hpf_enabled_ = hpf_enabled;
+      aec_enabled_ = aec_enabled;
+      aecm_enabled_ = aecm_enabled;
+      ns_enabled_ = ns_enabled;
+      ie_enabled_ = ie_enabled;
+      bf_enabled_ = bf_enabled;
+      agc_enabled_ = agc_enabled;
+      lc_enabled_ = lc_enabled;
+      le_enabled_ = le_enabled;
+      vad_enabled_ = vad_enabled;
+      ts_enabled_ = ts_enabled;
+    }
+
+    changed |= first_update_;
+    first_update_ = false;
+    return changed;
+  }
+
+  bool CaptureMultiBandModulesActive() const {
+    return CaptureMultiBandEffectsActive() || ie_enabled_ || vad_enabled_;
+  }
+
+  bool CaptureMultiBandEffectsActive() const {
+    return (hpf_enabled_ || aec_enabled_ || aecm_enabled_ || ns_enabled_ ||

[hlundin-webrtc, 2016/09/06 10:41:32]

You can drop the () here too.

[peah-webrtc, 2016/09/07 06:28:11]

Done.

+            bf_enabled_ || agc_enabled_);
+  }
+
+  bool RenderMultiBandModulesActive() const {
+    return RenderMultiBandEffectsActive() || aec_enabled_ || aecm_enabled_ ||
+           agc_enabled_;
+  }
+
+  bool RenderMultiBandEffectsActive() const { return ie_enabled_; }
+
+ private:
+  bool hpf_enabled_ = false;
+  bool aec_enabled_ = false;
+  bool aecm_enabled_ = false;
+  bool ns_enabled_ = false;
+  bool ie_enabled_ = false;
+  bool bf_enabled_ = false;
+  bool agc_enabled_ = false;
+  bool lc_enabled_ = false;
+  bool le_enabled_ = false;
+  bool vad_enabled_ = false;
+  bool ts_enabled_ = false;
+  bool first_update_ = true;
+};
+
 struct AudioProcessingImpl::ApmPublicSubmodules {
   ApmPublicSubmodules() {}
   // Accessed externally of APM without any lock acquired.
   std::unique_ptr<EchoCancellationImpl> echo_cancellation;
   std::unique_ptr<EchoControlMobileImpl> echo_control_mobile;
   std::unique_ptr<GainControlImpl> gain_control;
   std::unique_ptr<HighPassFilterImpl> high_pass_filter;
   std::unique_ptr<LevelEstimatorImpl> level_estimator;
   std::unique_ptr<NoiseSuppressionImpl> noise_suppression;
   std::unique_ptr<VoiceDetectionImpl> voice_detection;
@@ skipping 34 matching lines @@
   }
 
   return apm;
 }
 
 AudioProcessingImpl::AudioProcessingImpl(const Config& config)
     : AudioProcessingImpl(config, nullptr) {}
 
 AudioProcessingImpl::AudioProcessingImpl(const Config& config,
                                          NonlinearBeamformer* beamformer)
-    : public_submodules_(new ApmPublicSubmodules()),
+    : submodule_states_(new ApmSubmoduleStates()),
+      public_submodules_(new ApmPublicSubmodules()),
       private_submodules_(new ApmPrivateSubmodules(beamformer)),
       constants_(config.Get<ExperimentalAgc>().startup_min_volume,
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
                  false),
 #else
                  config.Get<ExperimentalAgc>().enabled),
 #endif
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
       capture_(false,
 #else
@@ skipping 76 matching lines @@
 
 int AudioProcessingImpl::Initialize(const ProcessingConfig& processing_config) {
   // Run in a single-threaded manner during initialization.
   rtc::CritScope cs_render(&crit_render_);
   rtc::CritScope cs_capture(&crit_capture_);
   return InitializeLocked(processing_config);
 }
 
 int AudioProcessingImpl::MaybeInitializeRender(
     const ProcessingConfig& processing_config) {
-  return MaybeInitialize(processing_config);
+  return MaybeInitialize(processing_config, false);
 }
 
 int AudioProcessingImpl::MaybeInitializeCapture(
-    const ProcessingConfig& processing_config) {
-  return MaybeInitialize(processing_config);
+    const ProcessingConfig& processing_config,
+    bool force_initialization) {
+  return MaybeInitialize(processing_config, force_initialization);
 }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 AudioProcessingImpl::ApmDebugDumpThreadState::ApmDebugDumpThreadState()
     : event_msg(new audioproc::Event()) {}
 
 AudioProcessingImpl::ApmDebugDumpThreadState::~ApmDebugDumpThreadState() {}
 
 AudioProcessingImpl::ApmDebugDumpState::ApmDebugDumpState()
     : debug_file(FileWrapper::Create()) {}
 
 AudioProcessingImpl::ApmDebugDumpState::~ApmDebugDumpState() {}
 
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 // Calls InitializeLocked() if any of the audio parameters have changed from
 // their current values (needs to be called while holding the crit_render_lock).
 int AudioProcessingImpl::MaybeInitialize(
-    const ProcessingConfig& processing_config) {
+    const ProcessingConfig& processing_config,
+    bool force_initialization) {
   // Called from both threads. Thread check is therefore not possible.
-  if (processing_config == formats_.api_format) {
+  if (processing_config == formats_.api_format && !force_initialization) {
     return kNoError;
   }
 
   rtc::CritScope cs_capture(&crit_capture_);
   return InitializeLocked(processing_config);
 }
 
 int AudioProcessingImpl::InitializeLocked() {
   const int fwd_audio_buffer_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 =
       formats_.api_format.reverse_output_stream().num_frames() == 0
           ? formats_.rev_proc_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));
-    if (rev_conversion_needed()) {
+    if (formats_.api_format.reverse_input_stream() !=
+        formats_.api_format.reverse_output_stream()) {
       render_.render_converter = AudioConverter::Create(
           formats_.api_format.reverse_input_stream().num_channels(),
           formats_.api_format.reverse_input_stream().num_frames(),
           formats_.api_format.reverse_output_stream().num_channels(),
           formats_.api_format.reverse_output_stream().num_frames());
     } else {
       render_.render_converter.reset(nullptr);
     }
   } else {
     render_.render_audio.reset(nullptr);
@@ skipping 50 matching lines @@
     return kBadNumberChannelsError;
   }
 
   if (capture_nonlocked_.beamformer_enabled &&
       num_in_channels != capture_.array_geometry.size()) {
     return kBadNumberChannelsError;
   }
 
   formats_.api_format = config;
 
-  capture_nonlocked_.fwd_proc_format = StreamConfig(ClosestHigherNativeRate(
+  int fwd_proc_rate = NativeProcessRateToUse(
       std::min(formats_.api_format.input_stream().sample_rate_hz(),
-               formats_.api_format.output_stream().sample_rate_hz())));
+               formats_.api_format.output_stream().sample_rate_hz()),
+      submodule_states_->CaptureMultiBandModulesActive() ||
+          submodule_states_->RenderMultiBandModulesActive());
 
-  int rev_proc_rate = ClosestHigherNativeRate(std::min(
-      formats_.api_format.reverse_input_stream().sample_rate_hz(),
-      formats_.api_format.reverse_output_stream().sample_rate_hz()));
+  capture_nonlocked_.fwd_proc_format = StreamConfig(fwd_proc_rate);
+
+  int rev_proc_rate = NativeProcessRateToUse(
+      std::min(formats_.api_format.reverse_input_stream().sample_rate_hz(),
+               formats_.api_format.reverse_output_stream().sample_rate_hz()),
+      submodule_states_->CaptureMultiBandModulesActive() ||
+          submodule_states_->RenderMultiBandModulesActive());
   // 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 = is_rev_processed() ? kSampleRate32kHz : kSampleRate16kHz;
+    rev_proc_rate = submodule_states_->RenderMultiBandEffectsActive()
+                        ? kSampleRate32kHz
+                        : kSampleRate16kHz;
   }
   // If the forward sample rate is 8 kHz, the reverse stream is also processed
   // at this rate.
   if (capture_nonlocked_.fwd_proc_format.sample_rate_hz() == kSampleRate8kHz) {
     rev_proc_rate = kSampleRate8kHz;
   } else {
     rev_proc_rate = std::max(rev_proc_rate, static_cast<int>(kSampleRate16kHz));
   }
 
   // Always downmix the reverse stream to mono for analysis. This has been
@@ skipping 128 matching lines @@
   }
   return ProcessStream(src, input_stream, output_stream, dest);
 }
 
 int AudioProcessingImpl::ProcessStream(const float* const* src,
                                        const StreamConfig& input_config,
                                        const StreamConfig& output_config,
                                        float* const* dest) {
   TRACE_EVENT0("webrtc", "AudioProcessing::ProcessStream_StreamConfig");
   ProcessingConfig processing_config;
+  bool reeinitialization_required;

[hlundin-webrtc, 2016/09/06 10:41:32]

Typo: reeinit... -> reinit...

[peah-webrtc, 2016/09/07 06:28:11]

Done.

   {
     // Acquire the capture lock in order to safely call the function
     // that retrieves the render side data. This function accesses apm
     // getters that need the capture lock held when being called.
     rtc::CritScope cs_capture(&crit_capture_);
     public_submodules_->echo_cancellation->ReadQueuedRenderData();
     public_submodules_->echo_control_mobile->ReadQueuedRenderData();
     public_submodules_->gain_control->ReadQueuedRenderData();
 
     if (!src || !dest) {
       return kNullPointerError;
     }
 
     processing_config = formats_.api_format;
+    reeinitialization_required = UpdateActiveSubmoduleStates();
   }
 
   processing_config.input_stream() = input_config;
   processing_config.output_stream() = output_config;
 
   {
     // Do conditional reinitialization.
     rtc::CritScope cs_render(&crit_render_);
-    RETURN_ON_ERR(MaybeInitializeCapture(processing_config));
+    RETURN_ON_ERR(
+        MaybeInitializeCapture(processing_config, reeinitialization_required));
   }
   rtc::CritScope cs_capture(&crit_capture_);
   assert(processing_config.input_stream().num_frames() ==
          formats_.api_format.input_stream().num_frames());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_dump_.debug_file->is_open()) {
     RETURN_ON_ERR(WriteConfigMessage(false));
 
     debug_dump_.capture.event_msg->set_type(audioproc::Event::STREAM);
@@ skipping 47 matching lines @@
   }
   // Must be a native rate.
   if (frame->sample_rate_hz_ != kSampleRate8kHz &&
       frame->sample_rate_hz_ != kSampleRate16kHz &&
       frame->sample_rate_hz_ != kSampleRate32kHz &&
       frame->sample_rate_hz_ != kSampleRate48kHz) {
     return kBadSampleRateError;
   }
 
   ProcessingConfig processing_config;
+  bool reeinitialization_required;

[hlundin-webrtc, 2016/09/06 10:41:32]

Same typo.

[peah-webrtc, 2016/09/07 06:28:11]

Done.

   {
     // Aquire lock for the access of api_format.
     // The lock is released immediately due to the conditional
     // reinitialization.
     rtc::CritScope cs_capture(&crit_capture_);
     // TODO(ajm): The input and output rates and channels are currently
     // constrained to be identical in the int16 interface.
     processing_config = formats_.api_format;
+
+    reeinitialization_required = UpdateActiveSubmoduleStates();
   }
   processing_config.input_stream().set_sample_rate_hz(frame->sample_rate_hz_);
   processing_config.input_stream().set_num_channels(frame->num_channels_);
   processing_config.output_stream().set_sample_rate_hz(frame->sample_rate_hz_);
   processing_config.output_stream().set_num_channels(frame->num_channels_);
 
   {
     // Do conditional reinitialization.
     rtc::CritScope cs_render(&crit_render_);
-    RETURN_ON_ERR(MaybeInitializeCapture(processing_config));
+    RETURN_ON_ERR(
+        MaybeInitializeCapture(processing_config, reeinitialization_required));
   }
   rtc::CritScope cs_capture(&crit_capture_);
   if (frame->samples_per_channel_ !=
       formats_.api_format.input_stream().num_frames()) {
     return kBadDataLengthError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_dump_.debug_file->is_open()) {
     RETURN_ON_ERR(WriteConfigMessage(false));
 
     debug_dump_.capture.event_msg->set_type(audioproc::Event::STREAM);
     audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
     const size_t data_size =
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_input_data(frame->data_, data_size);
   }
 #endif
 
   capture_.capture_audio->DeinterleaveFrom(frame);
   RETURN_ON_ERR(ProcessStreamLocked());
-  capture_.capture_audio->InterleaveTo(frame, output_copy_needed());
+  capture_.capture_audio->InterleaveTo(frame, true);
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_dump_.debug_file->is_open()) {
     audioproc::Stream* msg = debug_dump_.capture.event_msg->mutable_stream();
     const size_t data_size =
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_output_data(frame->data_, data_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                           &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.capture));
@@ skipping 25 matching lines @@
 
   AudioBuffer* ca = 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());
   }
 
-  if (fwd_analysis_needed()) {
+  if (submodule_states_->CaptureMultiBandModulesActive() &&
+      SampleRateSupportsMultiBand(
+          capture_nonlocked_.fwd_proc_format.sample_rate_hz())) {
     ca->SplitIntoFrequencyBands();
   }
 
   if (capture_nonlocked_.beamformer_enabled) {
     private_submodules_->beamformer->AnalyzeChunk(*ca->split_data_f());
     // Discards all channels by the leftmost one.
     ca->set_num_channels(1);
   }
 
   public_submodules_->high_pass_filter->ProcessCaptureAudio(ca);
@@ skipping 50 matching lines @@
       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);
   }
   RETURN_ON_ERR(public_submodules_->gain_control->ProcessCaptureAudio(
       ca, echo_cancellation()->stream_has_echo()));
 
-  if (fwd_synthesis_needed()) {
+  if (submodule_states_->CaptureMultiBandEffectsActive() &&
+      SampleRateSupportsMultiBand(
+          capture_nonlocked_.fwd_proc_format.sample_rate_hz())) {
     ca->MergeFrequencyBands();
   }
 
   // TODO(aluebs): Investigate if the transient suppression placement should be
   // before or after the AGC.
   if (capture_.transient_suppressor_enabled) {
     float voice_probability =
         private_submodules_->agc_manager.get()
             ? private_submodules_->agc_manager->voice_probability()
             : 1.f;
@@ skipping 33 matching lines @@
 
 int AudioProcessingImpl::ProcessReverseStream(
     const float* const* src,
     const StreamConfig& reverse_input_config,
     const StreamConfig& reverse_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));
-  if (is_rev_processed()) {
+  if (submodule_states_->RenderMultiBandEffectsActive()) {
     render_.render_audio->CopyTo(formats_.api_format.reverse_output_stream(),
                                  dest);
-  } else if (render_check_rev_conversion_needed()) {
+  } 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());
   } else {
     CopyAudioIfNeeded(src, reverse_input_config.num_frames(),
                       reverse_input_config.num_channels(), dest);
   }
 
   return kNoError;
 }
@@ skipping 81 matching lines @@
     const size_t data_size =
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_data(frame->data_, data_size);
     RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                           &debug_dump_.num_bytes_left_for_log_,
                                           &crit_debug_, &debug_dump_.render));
   }
 #endif
   render_.render_audio->DeinterleaveFrom(frame);
   RETURN_ON_ERR(ProcessReverseStreamLocked());
-  if (is_rev_processed()) {
-    render_.render_audio->InterleaveTo(frame, true);
-  }
+  render_.render_audio->InterleaveTo(frame, true);
   return kNoError;
 }
 
 int AudioProcessingImpl::ProcessReverseStreamLocked() {
   AudioBuffer* ra = render_.render_audio.get();  // For brevity.
-  if (rev_analysis_needed()) {
+  if (submodule_states_->RenderMultiBandModulesActive() &&
+      SampleRateSupportsMultiBand(formats_.rev_proc_format.sample_rate_hz())) {
     ra->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());
   }
 #endif
 
   RETURN_ON_ERR(public_submodules_->echo_cancellation->ProcessRenderAudio(ra));
   RETURN_ON_ERR(
       public_submodules_->echo_control_mobile->ProcessRenderAudio(ra));
   if (!constants_.use_experimental_agc) {
     RETURN_ON_ERR(public_submodules_->gain_control->ProcessRenderAudio(ra));
   }
 
-  if (rev_synthesis_needed()) {
+  if (submodule_states_->RenderMultiBandEffectsActive() &&
+      SampleRateSupportsMultiBand(formats_.rev_proc_format.sample_rate_hz())) {
     ra->MergeFrequencyBands();
   }
 
   return kNoError;
 }
 
 int AudioProcessingImpl::set_stream_delay_ms(int delay) {
   rtc::CritScope cs(&crit_capture_);
   Error retval = kNoError;
   capture_.was_stream_delay_set = true;
@@ skipping 113 matching lines @@
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // We just return if recording hasn't started.
   debug_dump_.debug_file->CloseFile();
   return kNoError;
 #else
   return kUnsupportedFunctionError;
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 EchoCancellation* AudioProcessingImpl::echo_cancellation() const {
-  // Adding a lock here has no effect as it allows any access to the submodule
-  // from the returned pointer.
   return public_submodules_->echo_cancellation.get();
 }
 
 EchoControlMobile* AudioProcessingImpl::echo_control_mobile() const {
-  // Adding a lock here has no effect as it allows any access to the submodule
-  // from the returned pointer.
   return public_submodules_->echo_control_mobile.get();
 }
 
 GainControl* AudioProcessingImpl::gain_control() const {
-  // Adding a lock here has no effect as it allows any access to the submodule
-  // from the returned pointer.
   if (constants_.use_experimental_agc) {
     return public_submodules_->gain_control_for_experimental_agc.get();
   }
   return public_submodules_->gain_control.get();
 }
 
 HighPassFilter* AudioProcessingImpl::high_pass_filter() const {
-  // Adding a lock here has no effect as it allows any access to the submodule
-  // from the returned pointer.
   return public_submodules_->high_pass_filter.get();
 }
 
 LevelEstimator* AudioProcessingImpl::level_estimator() const {
-  // Adding a lock here has no effect as it allows any access to the submodule
-  // from the returned pointer.
   return public_submodules_->level_estimator.get();
 }
 
 NoiseSuppression* AudioProcessingImpl::noise_suppression() const {
-  // Adding a lock here has no effect as it allows any access to the submodule
-  // from the returned pointer.
   return public_submodules_->noise_suppression.get();
 }
 
 VoiceDetection* AudioProcessingImpl::voice_detection() const {
-  // Adding a lock here has no effect as it allows any access to the submodule
-  // from the returned pointer.
   return public_submodules_->voice_detection.get();
 }
 
-bool AudioProcessingImpl::is_fwd_processed() const {
-  // The beamformer, noise suppressor and highpass filter
-  // modify the data.
-  if (capture_nonlocked_.beamformer_enabled ||
-      public_submodules_->high_pass_filter->is_enabled() ||
-      public_submodules_->noise_suppression->is_enabled() ||
-      public_submodules_->echo_cancellation->is_enabled() ||
-      public_submodules_->echo_control_mobile->is_enabled() ||
-      public_submodules_->gain_control->is_enabled()) {
-    return true;
-  }
-
-  // The capture data is otherwise unchanged.
-  return false;
-}
-
-bool AudioProcessingImpl::output_copy_needed() const {
-  // Check if we've upmixed or downmixed the audio.
-  return ((formats_.api_format.output_stream().num_channels() !=
-           formats_.api_format.input_stream().num_channels()) ||
-          is_fwd_processed() || capture_.transient_suppressor_enabled ||
-          capture_nonlocked_.level_controller_enabled);
-}
-
-bool AudioProcessingImpl::fwd_synthesis_needed() const {
-  return (is_fwd_processed() &&
-          is_multi_band(capture_nonlocked_.fwd_proc_format.sample_rate_hz()));
-}
-
-bool AudioProcessingImpl::fwd_analysis_needed() const {
-  if (!is_fwd_processed() &&
-      !public_submodules_->voice_detection->is_enabled() &&
-      !capture_.transient_suppressor_enabled) {
-    // Only public_submodules_->level_estimator is enabled.
-    return false;
-  } else if (is_multi_band(
-                 capture_nonlocked_.fwd_proc_format.sample_rate_hz())) {
-    // Something besides public_submodules_->level_estimator is enabled, and we
-    // have super-wb.
-    return true;
-  }
-  return false;
-}
-
-bool AudioProcessingImpl::is_rev_processed() const {
-#if WEBRTC_INTELLIGIBILITY_ENHANCER
-  return capture_nonlocked_.intelligibility_enabled;
-#else
-  return false;
-#endif
-}
-
-bool AudioProcessingImpl::rev_synthesis_needed() const {
-  return (is_rev_processed() &&
-          is_multi_band(formats_.rev_proc_format.sample_rate_hz()));
-}
-
-bool AudioProcessingImpl::rev_analysis_needed() const {
-  return is_multi_band(formats_.rev_proc_format.sample_rate_hz()) &&
-         (is_rev_processed() ||
-          public_submodules_->echo_cancellation
-              ->is_enabled_render_side_query() ||
-          public_submodules_->echo_control_mobile
-              ->is_enabled_render_side_query() ||
-          public_submodules_->gain_control->is_enabled_render_side_query());
-}
-
-bool AudioProcessingImpl::render_check_rev_conversion_needed() const {
-  return rev_conversion_needed();
-}
-
-bool AudioProcessingImpl::rev_conversion_needed() const {
-  return (formats_.api_format.reverse_input_stream() !=
-          formats_.api_format.reverse_output_stream());
+bool AudioProcessingImpl::UpdateActiveSubmoduleStates() {
+  return submodule_states_->Update(
+      public_submodules_->high_pass_filter->is_enabled(),
+      public_submodules_->echo_cancellation->is_enabled(),
+      public_submodules_->echo_control_mobile->is_enabled(),
+      public_submodules_->noise_suppression->is_enabled(),
+      capture_nonlocked_.intelligibility_enabled,
+      capture_nonlocked_.beamformer_enabled,
+      public_submodules_->gain_control->is_enabled(),
+      capture_nonlocked_.level_controller_enabled,
+      public_submodules_->voice_detection->is_enabled(),
+      public_submodules_->level_estimator->is_enabled(),
+      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));
     }
@@ skipping 308 matching lines @@
       fwd_proc_format(kSampleRate16kHz),
       split_rate(kSampleRate16kHz) {}
 
 AudioProcessingImpl::ApmCaptureState::~ApmCaptureState() = default;
 
 AudioProcessingImpl::ApmRenderState::ApmRenderState() = default;
 
 AudioProcessingImpl::ApmRenderState::~ApmRenderState() = default;
 
 }  // namespace webrtc