Don't always downsample to 16kHz in the reverse stream in APM

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 348 matching lines @@
       num_in_channels != capture_.array_geometry.size()) {
     return kBadNumberChannelsError;
   }
 
   formats_.api_format = config;
 
   capture_nonlocked_.fwd_proc_format = StreamConfig(ClosestNativeRate(std::min(
       formats_.api_format.input_stream().sample_rate_hz(),
       formats_.api_format.output_stream().sample_rate_hz())));
 
-  // We normally process the reverse stream at 16 kHz. Unless...
-  int rev_proc_rate = kSampleRate16kHz;
+  int rev_proc_rate = ClosestNativeRate(std::min(
+      formats_.api_format.reverse_input_stream().sample_rate_hz(),
+      formats_.api_format.reverse_output_stream().sample_rate_hz()));
+  // TODO(aluebs): Remove this restriction once we figure out why the 3-band
+  // splitting filter degrades the AEC performance.
+  if (rev_proc_rate > kSampleRate32kHz) {
+    if (is_rev_processed()) {
+      rev_proc_rate = kSampleRate32kHz;
+    } else {
+      rev_proc_rate = kSampleRate16kHz;
+    }
+  }

[peah-webrtc, 2016/04/22 12:36:57]

I think that with the new changes this and the following if-statements could be
simplified quite a lot.

[aluebs-webrtc, 2016/04/22 17:46:14]

But then the separation between what is temporary and what is not will be less
obvious and will be harder to reference by the TODO.

+  // 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) {
-    // ...the forward stream is at 8 kHz.
     rev_proc_rate = kSampleRate8kHz;
   } else {
-    if (formats_.api_format.reverse_input_stream().sample_rate_hz() ==
-        kSampleRate32kHz) {
-      // ...or the input is at 32 kHz, in which case we use the splitting
-      // filter rather than the resampler.
-      rev_proc_rate = kSampleRate32kHz;
-    }
+    rev_proc_rate = std::max(rev_proc_rate, static_cast<int>(kSampleRate16kHz));
   }
 
   // Always downmix the reverse 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);
 
   if (capture_nonlocked_.fwd_proc_format.sample_rate_hz() == kSampleRate32kHz ||
       capture_nonlocked_.fwd_proc_format.sample_rate_hz() == kSampleRate48kHz) {
     capture_nonlocked_.split_rate = kSampleRate16kHz;
   } else {
@@ skipping 753 matching lines @@
   }
   return false;
 }
 
 bool AudioProcessingImpl::is_rev_processed() const {
   return constants_.intelligibility_enabled;
 }
 
 bool AudioProcessingImpl::rev_synthesis_needed() const {
   return (is_rev_processed() &&
-          formats_.rev_proc_format.sample_rate_hz() == kSampleRate32kHz);
+          is_multi_band(formats_.rev_proc_format.sample_rate_hz()));
 }
 
 bool AudioProcessingImpl::rev_analysis_needed() const {
-  return formats_.rev_proc_format.sample_rate_hz() == kSampleRate32kHz &&
+  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();
@@ skipping 280 matching lines @@
   debug_dump_.capture.event_msg->mutable_config()->CopyFrom(config);
 
   RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                         &debug_dump_.num_bytes_left_for_log_,
                                         &crit_debug_, &debug_dump_.capture));
   return kNoError;
 }
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 }  // namespace webrtc