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 204 matching lines @@
       agc_startup_min_volume_(config.Get<ExperimentalAgc>().startup_min_volume),
 #if defined(WEBRTC_ANDROID) || defined(WEBRTC_IOS)
       transient_suppressor_enabled_(false),
 #else
       transient_suppressor_enabled_(config.Get<ExperimentalNs>().enabled),
 #endif
       beamformer_enabled_(config.Get<Beamforming>().enabled),
       beamformer_(beamformer),
       array_geometry_(config.Get<Beamforming>().array_geometry),
       intelligibility_enabled_(config.Get<Intelligibility>().enabled) {
-  echo_cancellation_ = new EchoCancellationImpl(this, crit_);
+  echo_cancellation_ =
+      new EchoCancellationImpl(this, crit_, &render_thread_, &capture_thread_);
   component_list_.push_back(echo_cancellation_);
 
-  echo_control_mobile_ = new EchoControlMobileImpl(this, crit_);
+  echo_control_mobile_ =
+      new EchoControlMobileImpl(this, crit_, &render_thread_, &capture_thread_);
   component_list_.push_back(echo_control_mobile_);
 
-  gain_control_ = new GainControlImpl(this, crit_);
+  gain_control_ =
+      new GainControlImpl(this, crit_, &render_thread_, &capture_thread_);
   component_list_.push_back(gain_control_);
 
   high_pass_filter_ = new HighPassFilterImpl(this, crit_);
   component_list_.push_back(high_pass_filter_);
 
   level_estimator_ = new LevelEstimatorImpl(this, crit_);
   component_list_.push_back(level_estimator_);
 
-  noise_suppression_ = new NoiseSuppressionImpl(this, crit_);
+  noise_suppression_ = new NoiseSuppressionImpl(this, crit_, &capture_thread_);
   component_list_.push_back(noise_suppression_);
 
-  voice_detection_ = new VoiceDetectionImpl(this, crit_);
+  voice_detection_ = new VoiceDetectionImpl(this, crit_, &capture_thread_);
   component_list_.push_back(voice_detection_);
 
   gain_control_for_new_agc_.reset(new GainControlForNewAgc(gain_control_));
 
   SetExtraOptions(config);
+
+  render_thread_.DetachFromThread();
+  capture_thread_.DetachFromThread();

[kwiberg-webrtc, 2015/10/26 13:57:56]

Move these as high up as possible, so that you never expose the half-initialized
state to your underlings? That way, it'll fail if one of them calls
CalledOnValidThread in its constructor.

[peah-webrtc, 2015/11/05 11:47:33]

I'm not convinced this is the right thing to do. If the work in the construction
would only be to initialize the state, it may be fine. But if the constructors
do more than just that and also calls other methods that have threadcheckers in
them, these calls will reinitialize the thread checkers to again point to the
initialization threads, which will cause things to start failing once the
threads are called using the render and capture threads. Does that make sense?

However, since it seems to work, I moved them according to your recommendation.

Done.

[kwiberg-webrtc, 2015/11/08 09:50:51]

Yes, that's exactly the sort of behavior you protect against by moving it up.
Having it very early is a proof that none of the potential issues you mentioned
are in fact happening.

 }
 
 AudioProcessingImpl::~AudioProcessingImpl() {
   {
     CriticalSectionScoped crit_scoped(crit_);
     // Depends on gain_control_ and gain_control_for_new_agc_.
     agc_manager_.reset();
     // Depends on gain_control_.
     gain_control_for_new_agc_.reset();
     while (!component_list_.empty()) {
@@ skipping 186 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();
   }
@@ skipping 15 matching lines @@
 int AudioProcessingImpl::num_input_channels() const {
   return shared_state_.api_format_.input_stream().num_channels();
 }
 
 int AudioProcessingImpl::num_output_channels() const {
   return shared_state_.api_format_.output_stream().num_channels();
 }
 
 void AudioProcessingImpl::set_output_will_be_muted(bool muted) {
   CriticalSectionScoped lock(crit_);
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   output_will_be_muted_ = muted;
   if (agc_manager_.get()) {
     agc_manager_->SetCaptureMuted(output_will_be_muted_);
   }
 }
 
 
 int AudioProcessingImpl::ProcessStream(const float* const* src,
                                        size_t samples_per_channel,
                                        int input_sample_rate_hz,
                                        ChannelLayout input_layout,
                                        int output_sample_rate_hz,
                                        ChannelLayout output_layout,
                                        float* const* dest) {
   CriticalSectionScoped crit_scoped(crit_);
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   StreamConfig input_stream = shared_state_.api_format_.input_stream();
   input_stream.set_sample_rate_hz(input_sample_rate_hz);
   input_stream.set_num_channels(ChannelsFromLayout(input_layout));
   input_stream.set_has_keyboard(LayoutHasKeyboard(input_layout));
 
   StreamConfig output_stream = shared_state_.api_format_.output_stream();
   output_stream.set_sample_rate_hz(output_sample_rate_hz);
   output_stream.set_num_channels(ChannelsFromLayout(output_layout));
   output_stream.set_has_keyboard(LayoutHasKeyboard(output_layout));
 
   if (samples_per_channel != input_stream.num_frames()) {
     return kBadDataLengthError;
   }
   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) {
   CriticalSectionScoped crit_scoped(crit_);
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   if (!src || !dest) {
     return kNullPointerError;
   }
 
   echo_cancellation_->ReadQueuedRenderData();
   echo_control_mobile_->ReadQueuedRenderData();
   gain_control_->ReadQueuedRenderData();
 
   ProcessingConfig processing_config = shared_state_.api_format_;
   processing_config.input_stream() = input_config;
@@ skipping 31 matching lines @@
       msg->add_output_channel(dest[i], channel_size);
     RETURN_ON_ERR(WriteMessageToDebugFile());
   }
 #endif
 
   return kNoError;
 }
 
 int AudioProcessingImpl::ProcessStream(AudioFrame* frame) {
   CriticalSectionScoped crit_scoped(crit_);
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   echo_cancellation_->ReadQueuedRenderData();
   echo_control_mobile_->ReadQueuedRenderData();
   gain_control_->ReadQueuedRenderData();
 
   if (!frame) {
     return kNullPointerError;
   }
   // Must be a native rate.
   if (frame->sample_rate_hz_ != kSampleRate8kHz &&
       frame->sample_rate_hz_ != kSampleRate16kHz &&
@@ skipping 124 matching lines @@
   RETURN_ON_ERR(level_estimator_->ProcessStream(ca));
 
   was_stream_delay_set_ = false;
   return kNoError;
 }
 
 int AudioProcessingImpl::AnalyzeReverseStream(const float* const* data,
                                               size_t samples_per_channel,
                                               int rev_sample_rate_hz,
                                               ChannelLayout layout) {
+  RTC_DCHECK(render_thread_.CalledOnValidThread());
   const StreamConfig reverse_config = {
       rev_sample_rate_hz, ChannelsFromLayout(layout), LayoutHasKeyboard(layout),
   };
   if (samples_per_channel != reverse_config.num_frames()) {
     return kBadDataLengthError;
   }
   return AnalyzeReverseStream(data, reverse_config, reverse_config);
 }
 
 int AudioProcessingImpl::ProcessReverseStream(
     const float* const* src,
     const StreamConfig& reverse_input_config,
     const StreamConfig& reverse_output_config,
     float* const* dest) {
+  RTC_DCHECK(render_thread_.CalledOnValidThread());
   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()) {
     render_converter_->Convert(src, reverse_input_config.num_samples(), dest,
                                reverse_output_config.num_samples());
   } else {
     CopyAudioIfNeeded(src, reverse_input_config.num_frames(),
@@ skipping 38 matching lines @@
     RETURN_ON_ERR(WriteMessageToDebugFile());
   }
 #endif
 
   render_audio_->CopyFrom(src,
                           shared_state_.api_format_.reverse_input_stream());
   return ProcessReverseStreamLocked();
 }
 
 int AudioProcessingImpl::ProcessReverseStream(AudioFrame* frame) {
+  RTC_DCHECK(render_thread_.CalledOnValidThread());
   RETURN_ON_ERR(AnalyzeReverseStream(frame));
   if (is_rev_processed()) {
     render_audio_->InterleaveTo(frame, true);
   }
 
   return kNoError;
 }
 
 int AudioProcessingImpl::AnalyzeReverseStream(AudioFrame* frame) {
+  RTC_DCHECK(render_thread_.CalledOnValidThread());
   CriticalSectionScoped crit_scoped(crit_);
   if (frame == NULL) {
     return kNullPointerError;
   }
   // 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;
@@ skipping 57 matching lines @@
 
   if (rev_proc_format_.sample_rate_hz() == kSampleRate32kHz &&
       is_rev_processed()) {
     ra->MergeFrequencyBands();
   }
 
   return kNoError;
 }
 
 int AudioProcessingImpl::set_stream_delay_ms(int delay) {
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   Error retval = kNoError;
   was_stream_delay_set_ = true;
   delay += delay_offset_ms_;
 
   if (delay < 0) {
     delay = 0;
     retval = kBadStreamParameterWarning;
   }
 
   // TODO(ajm): the max is rather arbitrarily chosen; investigate.
   if (delay > 500) {
     delay = 500;
     retval = kBadStreamParameterWarning;
   }
 
   stream_delay_ms_ = delay;
   return retval;
 }
 
 int AudioProcessingImpl::stream_delay_ms() const {
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   return stream_delay_ms_;
 }
 
 bool AudioProcessingImpl::was_stream_delay_set() const {
   return was_stream_delay_set_;
 }
 
 void AudioProcessingImpl::set_stream_key_pressed(bool key_pressed) {
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   key_pressed_ = key_pressed;
 }
 
 void AudioProcessingImpl::set_delay_offset_ms(int offset) {
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   CriticalSectionScoped crit_scoped(crit_);
   delay_offset_ms_ = offset;
 }
 
 int AudioProcessingImpl::delay_offset_ms() const {
+  RTC_DCHECK(capture_thread_.CalledOnValidThread());
   return delay_offset_ms_;
 }
 
 int AudioProcessingImpl::StartDebugRecording(
     const char filename[AudioProcessing::kMaxFilenameSize]) {
   CriticalSectionScoped crit_scoped(crit_);
   static_assert(kMaxFilenameSize == FileWrapper::kMaxFileNameSize, "");
 
   if (filename == NULL) {
     return kNullPointerError;
@@ skipping 358 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