Remove additional channel constraints when Beamforming is enabled in AudioProcessing

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 208 matching lines @@
 #else
                  config.Get<ExperimentalAgc>().enabled,
 #endif
                  config.Get<Intelligibility>().enabled),
 
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
       capture_(false,
 #else
       capture_(config.Get<ExperimentalNs>().enabled,
 #endif
-               config.Get<Beamforming>().enabled,
                config.Get<Beamforming>().array_geometry,
-               config.Get<Beamforming>().target_direction)
+               config.Get<Beamforming>().target_direction),
+      capture_nonlocked_(config.Get<Beamforming>().enabled)
 {
   {
     rtc::CritScope cs_render(&crit_render_);
     rtc::CritScope cs_capture(&crit_capture_);
 
     public_submodules_->echo_cancellation =
         new EchoCancellationImpl(this, &crit_render_, &crit_capture_);
     public_submodules_->echo_control_mobile =
         new EchoControlMobileImpl(this, &crit_render_, &crit_capture_);
     public_submodules_->gain_control =
@@ skipping 96 matching lines @@
   if (processing_config == formats_.api_format) {
     return kNoError;
   }
 
   rtc::CritScope cs_capture(&crit_capture_);
   return InitializeLocked(processing_config);
 }
 
 int AudioProcessingImpl::InitializeLocked() {
   const int fwd_audio_buffer_channels =
-      capture_.beamformer_enabled
+      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(),
@@ skipping 62 matching lines @@
   const int num_in_channels = config.input_stream().num_channels();
   const int num_out_channels = config.output_stream().num_channels();
 
   // Need at least one input channel.
   // Need either one output channel or as many outputs as there are inputs.
   if (num_in_channels == 0 ||
       !(num_out_channels == 1 || num_out_channels == num_in_channels)) {
     return kBadNumberChannelsError;
   }
 
-  if (capture_.beamformer_enabled &&
-      (static_cast<size_t>(num_in_channels) != capture_.array_geometry.size() ||
-       num_out_channels > 1)) {
+  if (capture_nonlocked_.beamformer_enabled &&
+      static_cast<size_t>(num_in_channels) != capture_.array_geometry.size()) {
     return kBadNumberChannelsError;
   }
 
   formats_.api_format = config;
 
   // We process at the closest native rate >= min(input rate, output rate)...
   const int min_proc_rate =
       std::min(formats_.api_format.input_stream().sample_rate_hz(),
                formats_.api_format.output_stream().sample_rate_hz());
   int fwd_proc_rate;
@@ skipping 49 matching lines @@
   }
 
   if (capture_.transient_suppressor_enabled !=
       config.Get<ExperimentalNs>().enabled) {
     capture_.transient_suppressor_enabled =
         config.Get<ExperimentalNs>().enabled;
     InitializeTransient();
   }
 
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
-  if (capture_.beamformer_enabled != config.Get<Beamforming>().enabled) {
-    capture_.beamformer_enabled = config.Get<Beamforming>().enabled;
+  if (capture_nonlocked_.beamformer_enabled !=
+          config.Get<Beamforming>().enabled) {
+    capture_nonlocked_.beamformer_enabled = config.Get<Beamforming>().enabled;
     if (config.Get<Beamforming>().array_geometry.size() > 1) {
       capture_.array_geometry = config.Get<Beamforming>().array_geometry;
     }
     capture_.target_direction = config.Get<Beamforming>().target_direction;
     InitializeBeamformer();
   }
 #endif  // WEBRTC_ANDROID_PLATFORM_BUILD
 }
 
 int AudioProcessingImpl::input_sample_rate_hz() const {
@@ skipping 15 matching lines @@
 int AudioProcessingImpl::num_reverse_channels() const {
   // Used as callback from submodules, hence locking is not allowed.
   return formats_.rev_proc_format.num_channels();
 }
 
 int AudioProcessingImpl::num_input_channels() const {
   // Used as callback from submodules, hence locking is not allowed.
   return formats_.api_format.input_stream().num_channels();
 }
 
+int AudioProcessingImpl::num_proc_channels() const {
+  // Used as callback from submodules, hence locking is not allowed.
+  return capture_nonlocked_.beamformer_enabled ? 1 : num_output_channels();
+}
+
 int AudioProcessingImpl::num_output_channels() const {
   // Used as callback from submodules, hence locking is not allowed.
   return formats_.api_format.output_stream().num_channels();
 }
 
 void AudioProcessingImpl::set_output_will_be_muted(bool muted) {
   rtc::CritScope cs(&crit_capture_);
   capture_.output_will_be_muted = muted;
   if (private_submodules_->agc_manager.get()) {
     private_submodules_->agc_manager->SetCaptureMuted(
@@ skipping 214 matching lines @@
   if (analysis_needed(data_processed)) {
     ca->SplitIntoFrequencyBands();
   }
 
   if (constants_.intelligibility_enabled) {
     public_submodules_->intelligibility_enhancer->AnalyzeCaptureAudio(
         ca->split_channels_f(kBand0To8kHz), capture_nonlocked_.split_rate,
         ca->num_channels());
   }
 
-  if (capture_.beamformer_enabled) {
+  if (capture_nonlocked_.beamformer_enabled) {
     private_submodules_->beamformer->ProcessChunk(*ca->split_data_f(),
                                                   ca->split_data_f());
     ca->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);
   RETURN_ON_ERR(public_submodules_->echo_cancellation->ProcessCaptureAudio(ca));
 
   if (public_submodules_->echo_control_mobile->is_enabled() &&
       public_submodules_->noise_suppression->is_enabled()) {
     ca->CopyLowPassToReference();
   }
   public_submodules_->noise_suppression->ProcessCaptureAudio(ca);
   RETURN_ON_ERR(
       public_submodules_->echo_control_mobile->ProcessCaptureAudio(ca));
   public_submodules_->voice_detection->ProcessCaptureAudio(ca);
 
   if (constants_.use_new_agc &&
       public_submodules_->gain_control->is_enabled() &&
-      (!capture_.beamformer_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));
 
   if (synthesis_needed(data_processed)) {
     ca->MergeFrequencyBands();
   }
@@ skipping 369 matching lines @@
   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_data_processed() const {
-  if (capture_.beamformer_enabled) {
+  if (capture_nonlocked_.beamformer_enabled) {
     return true;
   }
 
   int enabled_count = 0;
   for (auto item : private_submodules_->component_list) {
     if (item->is_component_enabled()) {
       enabled_count++;
     }
   }
   if (public_submodules_->high_pass_filter->is_enabled()) {
@@ skipping 89 matching lines @@
 }
 
 void AudioProcessingImpl::InitializeTransient() {
   if (capture_.transient_suppressor_enabled) {
     if (!public_submodules_->transient_suppressor.get()) {
       public_submodules_->transient_suppressor.reset(new TransientSuppressor());
     }
     public_submodules_->transient_suppressor->Initialize(
         capture_nonlocked_.fwd_proc_format.sample_rate_hz(),
         capture_nonlocked_.split_rate,
-        formats_.api_format.output_stream().num_channels());
+        num_proc_channels());
   }
 }
 
 void AudioProcessingImpl::InitializeBeamformer() {
-  if (capture_.beamformer_enabled) {
+  if (capture_nonlocked_.beamformer_enabled) {
     if (!private_submodules_->beamformer) {
       private_submodules_->beamformer.reset(new NonlinearBeamformer(
           capture_.array_geometry, capture_.target_direction));
     }
     private_submodules_->beamformer->Initialize(kChunkSizeMs,
                                                 capture_nonlocked_.split_rate);
   }
 }
 
 void AudioProcessingImpl::InitializeIntelligibility() {
   if (constants_.intelligibility_enabled) {
     IntelligibilityEnhancer::Config config;
     config.sample_rate_hz = capture_nonlocked_.split_rate;
     config.num_capture_channels = capture_.capture_audio->num_channels();
     config.num_render_channels = render_.render_audio->num_channels();
     public_submodules_->intelligibility_enhancer.reset(
         new IntelligibilityEnhancer(config));
   }
 }
 
 void AudioProcessingImpl::InitializeHighPassFilter() {
-  public_submodules_->high_pass_filter->Initialize(num_output_channels(),
+  public_submodules_->high_pass_filter->Initialize(num_proc_channels(),
                                                    proc_sample_rate_hz());
 }
 
 void AudioProcessingImpl::InitializeNoiseSuppression() {
-  public_submodules_->noise_suppression->Initialize(num_output_channels(),
+  public_submodules_->noise_suppression->Initialize(num_proc_channels(),
                                                     proc_sample_rate_hz());
 }
 
 void AudioProcessingImpl::InitializeLevelEstimator() {
   public_submodules_->level_estimator->Initialize();
 }
 
 void AudioProcessingImpl::InitializeVoiceDetection() {
   public_submodules_->voice_detection->Initialize(proc_split_sample_rate_hz());
 }
@@ skipping 176 matching lines @@
   debug_dump_.capture.event_msg->set_type(audioproc::Event::CONFIG);
   debug_dump_.capture.event_msg->mutable_config()->CopyFrom(config);
 
   RETURN_ON_ERR(WriteMessageToDebugFile(debug_dump_.debug_file.get(),
                                         &crit_debug_, &debug_dump_.capture));
   return kNoError;
 }
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 }  // namespace webrtc