Preparational work for an upcoming addition of a threadchecking scheme for 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 288 matching lines @@
         LayoutHasKeyboard(reverse_layout)}}};
 
   return Initialize(processing_config);
 }
 
 int AudioProcessingImpl::Initialize(const ProcessingConfig& processing_config) {
   CriticalSectionScoped crit_scoped(crit_);
   return InitializeLocked(processing_config);
 }
 
+int AudioProcessingImpl::MaybeInitializeLockedRender(
+    const ProcessingConfig& processing_config) {
+  return MaybeInitializeLocked(processing_config);
+}
+
+int AudioProcessingImpl::MaybeInitializeLockedCapture(
+    const ProcessingConfig& processing_config) {
+  return MaybeInitializeLocked(processing_config);
+}
+
 // Calls InitializeLocked() if any of the audio parameters have changed from
 // their current values.
 int AudioProcessingImpl::MaybeInitializeLocked(
     const ProcessingConfig& processing_config) {
   if (processing_config == shared_state_.api_format_) {
     return kNoError;
   }
   return InitializeLocked(processing_config);
 }
 
@@ skipping 53 matching lines @@
     if (err != kNoError) {
       return err;
     }
   }
 #endif
 
   return kNoError;
 }
 
 int AudioProcessingImpl::InitializeLocked(const ProcessingConfig& config) {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   for (const auto& stream : config.streams) {
     if (stream.num_channels() < 0) {
       return kBadNumberChannelsError;
     }
     if (stream.num_channels() > 0 && stream.sample_rate_hz() <= 0) {
       return kBadSampleRateError;
     }
   }
 
   const int num_in_channels = config.input_stream().num_channels();
@@ skipping 54 matching lines @@
   if (fwd_proc_format_.sample_rate_hz() == kSampleRate32kHz ||
       fwd_proc_format_.sample_rate_hz() == kSampleRate48kHz) {
     split_rate_ = kSampleRate16kHz;
   } else {
     split_rate_ = fwd_proc_format_.sample_rate_hz();
   }
 
   return InitializeLocked();
 }
 
-
 void AudioProcessingImpl::SetExtraOptions(const Config& config) {
   CriticalSectionScoped crit_scoped(crit_);
   for (auto item : component_list_) {
     item->SetExtraOptions(config);
   }
 
   if (transient_suppressor_enabled_ != config.Get<ExperimentalNs>().enabled) {
     transient_suppressor_enabled_ = config.Get<ExperimentalNs>().enabled;
     InitializeTransient();
   }
 }
 
 
 int AudioProcessingImpl::proc_sample_rate_hz() const {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   return fwd_proc_format_.sample_rate_hz();
 }
 
 int AudioProcessingImpl::proc_split_sample_rate_hz() const {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
+
   return split_rate_;
 }
 
 int AudioProcessingImpl::num_reverse_channels() const {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   return rev_proc_format_.num_channels();
 }
 
 int AudioProcessingImpl::num_input_channels() const {
   return shared_state_.api_format_.input_stream().num_channels();
 }
 
 int AudioProcessingImpl::num_output_channels() const {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   return shared_state_.api_format_.output_stream().num_channels();
 }
 
 void AudioProcessingImpl::set_output_will_be_muted(bool muted) {
   CriticalSectionScoped lock(crit_);
   output_will_be_muted_ = muted;
   if (agc_manager_.get()) {
     agc_manager_->SetCaptureMuted(output_will_be_muted_);
   }
 }
@@ skipping 33 matching lines @@
   }
 
   echo_cancellation_->ReadQueuedRenderData();
   echo_control_mobile_->ReadQueuedRenderData();
   gain_control_->ReadQueuedRenderData();
 
   ProcessingConfig processing_config = shared_state_.api_format_;
   processing_config.input_stream() = input_config;
   processing_config.output_stream() = output_config;
 
-  RETURN_ON_ERR(MaybeInitializeLocked(processing_config));
+  RETURN_ON_ERR(MaybeInitializeLockedCapture(processing_config));
   assert(processing_config.input_stream().num_frames() ==
          shared_state_.api_format_.input_stream().num_frames());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_file_->Open()) {
     RETURN_ON_ERR(WriteConfigMessage(false));
 
     event_msg_->set_type(audioproc::Event::STREAM);
     audioproc::Stream* msg = event_msg_->mutable_stream();
     const size_t channel_size =
@@ skipping 47 matching lines @@
   }
 
   // TODO(ajm): The input and output rates and channels are currently
   // constrained to be identical in the int16 interface.
   ProcessingConfig processing_config = shared_state_.api_format_;
   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_);
 
-  RETURN_ON_ERR(MaybeInitializeLocked(processing_config));
+  RETURN_ON_ERR(MaybeInitializeLockedCapture(processing_config));
   if (frame->samples_per_channel_ !=
       shared_state_.api_format_.input_stream().num_frames()) {
     return kBadDataLengthError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_file_->Open()) {
     event_msg_->set_type(audioproc::Event::STREAM);
     audioproc::Stream* msg = event_msg_->mutable_stream();
     const size_t data_size =
@@ skipping 113 matching lines @@
 int AudioProcessingImpl::ProcessReverseStream(
     const float* const* src,
     const StreamConfig& reverse_input_config,
     const StreamConfig& reverse_output_config,
     float* const* dest) {
   RETURN_ON_ERR(
       AnalyzeReverseStream(src, reverse_input_config, reverse_output_config));
   if (is_rev_processed()) {
     render_audio_->CopyTo(shared_state_.api_format_.reverse_output_stream(),
                           dest);
-  } else if (rev_conversion_needed()) {
+  } else if (render_check_rev_conversion_needed()) {
     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;
 }
 
 int AudioProcessingImpl::AnalyzeReverseStream(
     const float* const* src,
     const StreamConfig& reverse_input_config,
     const StreamConfig& reverse_output_config) {
   CriticalSectionScoped crit_scoped(crit_);
   if (src == NULL) {
     return kNullPointerError;
   }
 
   if (reverse_input_config.num_channels() <= 0) {
     return kBadNumberChannelsError;
   }
 
   ProcessingConfig processing_config = shared_state_.api_format_;
   processing_config.reverse_input_stream() = reverse_input_config;
   processing_config.reverse_output_stream() = reverse_output_config;
 
-  RETURN_ON_ERR(MaybeInitializeLocked(processing_config));
+  RETURN_ON_ERR(MaybeInitializeLockedRender(processing_config));
   assert(reverse_input_config.num_frames() ==
          shared_state_.api_format_.reverse_input_stream().num_frames());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_file_->Open()) {
     event_msg_->set_type(audioproc::Event::REVERSE_STREAM);
     audioproc::ReverseStream* msg = event_msg_->mutable_reverse_stream();
     const size_t channel_size =
         sizeof(float) *
         shared_state_.api_format_.reverse_input_stream().num_frames();
@@ skipping 44 matching lines @@
   ProcessingConfig processing_config = shared_state_.api_format_;
   processing_config.reverse_input_stream().set_sample_rate_hz(
       frame->sample_rate_hz_);
   processing_config.reverse_input_stream().set_num_channels(
       frame->num_channels_);
   processing_config.reverse_output_stream().set_sample_rate_hz(
       frame->sample_rate_hz_);
   processing_config.reverse_output_stream().set_num_channels(
       frame->num_channels_);
 
-  RETURN_ON_ERR(MaybeInitializeLocked(processing_config));
+  RETURN_ON_ERR(MaybeInitializeLockedRender(processing_config));
   if (frame->samples_per_channel_ !=
       shared_state_.api_format_.reverse_input_stream().num_frames()) {
     return kBadDataLengthError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_file_->Open()) {
     event_msg_->set_type(audioproc::Event::REVERSE_STREAM);
     audioproc::ReverseStream* msg = event_msg_->mutable_reverse_stream();
     const size_t data_size =
@@ skipping 233 matching lines @@
     // Something besides level_estimator_ is enabled, and we have super-wb.
     return true;
   }
   return false;
 }
 
 bool AudioProcessingImpl::is_rev_processed() const {
   return intelligibility_enabled_ && intelligibility_enhancer_->active();
 }
 
+bool AudioProcessingImpl::render_check_rev_conversion_needed() const {
+  return rev_conversion_needed();
+}
+
 bool AudioProcessingImpl::rev_conversion_needed() const {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   return (shared_state_.api_format_.reverse_input_stream() !=
           shared_state_.api_format_.reverse_output_stream());
 }
 
 void AudioProcessingImpl::InitializeExperimentalAgc() {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   if (use_new_agc_) {
     if (!agc_manager_.get()) {
       agc_manager_.reset(new AgcManagerDirect(gain_control_,
                                               gain_control_for_new_agc_.get(),
                                               agc_startup_min_volume_));
     }
     agc_manager_->Initialize();
     agc_manager_->SetCaptureMuted(output_will_be_muted_);
   }
 }
 
 void AudioProcessingImpl::InitializeTransient() {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   if (transient_suppressor_enabled_) {
     if (!transient_suppressor_.get()) {
       transient_suppressor_.reset(new TransientSuppressor());
     }
     transient_suppressor_->Initialize(
         fwd_proc_format_.sample_rate_hz(), split_rate_,
         shared_state_.api_format_.output_stream().num_channels());
   }
 }
 
 void AudioProcessingImpl::InitializeBeamformer() {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   if (beamformer_enabled_) {
     if (!beamformer_) {
       beamformer_.reset(
           new NonlinearBeamformer(array_geometry_, target_direction_));
     }
     beamformer_->Initialize(kChunkSizeMs, split_rate_);
   }
 }
 
 void AudioProcessingImpl::InitializeIntelligibility() {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   if (intelligibility_enabled_) {
     IntelligibilityEnhancer::Config config;
     config.sample_rate_hz = split_rate_;
     config.num_capture_channels = capture_audio_->num_channels();
     config.num_render_channels = render_audio_->num_channels();
     intelligibility_enhancer_.reset(new IntelligibilityEnhancer(config));
   }
 }
 
 void AudioProcessingImpl::MaybeUpdateHistograms() {
@@ skipping 82 matching lines @@
   if (!debug_file_->Write(event_str_.data(), event_str_.length())) {
     return kFileError;
   }
 
   event_msg_->Clear();
 
   return kNoError;
 }
 
 int AudioProcessingImpl::WriteInitMessage() {
+  // TODO(peah): Refactor to be allowed to verify using thread annotations.
   event_msg_->set_type(audioproc::Event::INIT);
   audioproc::Init* msg = event_msg_->mutable_init();
   msg->set_sample_rate(
       shared_state_.api_format_.input_stream().sample_rate_hz());
   msg->set_num_input_channels(
       shared_state_.api_format_.input_stream().num_channels());
   msg->set_num_output_channels(
       shared_state_.api_format_.output_stream().num_channels());
   msg->set_num_reverse_channels(
       shared_state_.api_format_.reverse_input_stream().num_channels());
@@ skipping 47 matching lines @@
 
   event_msg_->set_type(audioproc::Event::CONFIG);
   event_msg_->mutable_config()->CopyFrom(config);
 
   RETURN_ON_ERR(WriteMessageToDebugFile());
   return kNoError;
 }
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 
 }  // namespace webrtc