Make Beamforming dynamically settable for Android platform builds

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 196 matching lines @@
 }
 
 AudioProcessingImpl::AudioProcessingImpl(const Config& config)
     : AudioProcessingImpl(config, nullptr) {}
 
 AudioProcessingImpl::AudioProcessingImpl(const Config& config,
                                          Beamformer<float>* beamformer)
     : public_submodules_(new ApmPublicSubmodules()),
       private_submodules_(new ApmPrivateSubmodules(beamformer)),
       constants_(config.Get<ExperimentalAgc>().startup_min_volume,
-                 config.Get<Beamforming>().array_geometry,
-                 config.Get<Beamforming>().target_direction,
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
                  false,
 #else
                  config.Get<ExperimentalAgc>().enabled,
 #endif
-                 config.Get<Intelligibility>().enabled,
-                 config.Get<Beamforming>().enabled),
+                 config.Get<Intelligibility>().enabled),
 
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
-      capture_(false)
+      capture_(false,
 #else
-      capture_(config.Get<ExperimentalNs>().enabled)
+      capture_(config.Get<ExperimentalNs>().enabled,
 #endif
+               config.Get<Beamforming>().enabled,
+               config.Get<Beamforming>().array_geometry,
+               config.Get<Beamforming>().target_direction)
 {
   {
     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 =
-      constants_.beamformer_enabled
+      capture_.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 (constants_.beamformer_enabled && (static_cast<size_t>(num_in_channels) !=
-                                            constants_.array_geometry.size() ||
-                                        num_out_channels > 1)) {
+  if (capture_.beamformer_enabled &&
+      static_cast<size_t>(num_in_channels) != capture_.array_geometry.size()) {

[hlundin-webrtc, 2016/01/08 12:38:38]

What happened to num_out_channels > 1?

[aluebs-webrtc, 2016/01/08 17:59:17]

I thought this was a fictitious restriction, since we upmix in InterleaveTo, but
I just realized we don't in CopyTo, so it actually is a restriction for the
float interface. I am adding it back here and will do a new CL for that.

     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 47 matching lines @@
   for (auto item : private_submodules_->component_list) {
     item->SetExtraOptions(config);
   }
 
   if (capture_.transient_suppressor_enabled !=
       config.Get<ExperimentalNs>().enabled) {
     capture_.transient_suppressor_enabled =
         config.Get<ExperimentalNs>().enabled;
     InitializeTransient();
   }
+
+#ifdef WEBRTC_ANDROID_PLATFORM_BUILD

[hlundin-webrtc, 2016/01/08 12:38:38]

Why not WEBRTC_ANDROID?

[aluebs-webrtc, 2016/01/08 17:59:17]

Because I want to be as restrictive as possible and that is only for an android
platform build.

[hlundin-webrtc, 2016/01/11 16:00:42]

Acknowledged.

+  if (capture_.beamformer_enabled != config.Get<Beamforming>().enabled) {
+    capture_.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_AUDIOPROC_DEBUG_DUMP

[hlundin-webrtc, 2016/01/08 12:38:38]

Wrong comment.

[aluebs-webrtc, 2016/01/08 17:59:17]

Done.

 }
 
 int AudioProcessingImpl::input_sample_rate_hz() const {
   // Accessed from outside APM, hence a lock is needed.
   rtc::CritScope cs(&crit_capture_);
   return formats_.api_format.input_stream().sample_rate_hz();
 }
 
 int AudioProcessingImpl::proc_sample_rate_hz() const {
   // Used as callback from submodules, hence locking is not allowed.
@@ skipping 242 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 (constants_.beamformer_enabled) {
+  if (capture_.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() &&
-      (!constants_.beamformer_enabled ||
+      (!capture_.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 (constants_.beamformer_enabled) {
+  if (capture_.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 94 matching lines @@
       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());
   }
 }
 
 void AudioProcessingImpl::InitializeBeamformer() {
-  if (constants_.beamformer_enabled) {
+  if (capture_.beamformer_enabled) {
     if (!private_submodules_->beamformer) {
       private_submodules_->beamformer.reset(new NonlinearBeamformer(
-          constants_.array_geometry, constants_.target_direction));
+          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;
@@ skipping 200 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