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 205 matching lines @@
 #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),
       target_direction_(config.Get<Beamforming>().target_direction),
       intelligibility_enabled_(config.Get<Intelligibility>().enabled) {
-  echo_cancellation_ = new EchoCancellationImpl(this, crit_);
+  render_thread_checker_.DetachFromThread();
+  capture_thread_checker_.DetachFromThread();
+
+  echo_cancellation_ =
+      new EchoCancellationImpl(this, crit_, &render_thread_checker_);
   component_list_.push_back(echo_cancellation_);
 
-  echo_control_mobile_ = new EchoControlMobileImpl(this, crit_);
+  echo_control_mobile_ =
+      new EchoControlMobileImpl(this, crit_, &render_thread_checker_);
   component_list_.push_back(echo_control_mobile_);
 
-  gain_control_ = new GainControlImpl(this, crit_);
+  gain_control_ = new GainControlImpl(this, crit_, &render_thread_checker_,
+                                      &capture_thread_checker_);
   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_);
   component_list_.push_back(noise_suppression_);
 
   voice_detection_ = new VoiceDetectionImpl(this, crit_);
   component_list_.push_back(voice_detection_);
 
   gain_control_for_new_agc_.reset(new GainControlForNewAgc(gain_control_));
 
   SetExtraOptions(config);
 }
 
 AudioProcessingImpl::~AudioProcessingImpl() {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   {
     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()) {
       ProcessingComponent* component = component_list_.front();
       component->Destroy();
       delete component;
       component_list_.pop_front();
     }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
     if (debug_file_->Open()) {
       debug_file_->CloseFile();
     }
 #endif
   }
   delete crit_;
   crit_ = NULL;
 }
 
 int AudioProcessingImpl::Initialize() {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   CriticalSectionScoped crit_scoped(crit_);
   return InitializeLocked();
 }
 
 int AudioProcessingImpl::Initialize(int input_sample_rate_hz,
                                     int output_sample_rate_hz,
                                     int reverse_sample_rate_hz,
                                     ChannelLayout input_layout,
                                     ChannelLayout output_layout,
                                     ChannelLayout reverse_layout) {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   const ProcessingConfig processing_config = {
       {{input_sample_rate_hz,
         ChannelsFromLayout(input_layout),
         LayoutHasKeyboard(input_layout)},
        {output_sample_rate_hz,
         ChannelsFromLayout(output_layout),
         LayoutHasKeyboard(output_layout)},
        {reverse_sample_rate_hz,
         ChannelsFromLayout(reverse_layout),
         LayoutHasKeyboard(reverse_layout)},
        {reverse_sample_rate_hz,
         ChannelsFromLayout(reverse_layout),
         LayoutHasKeyboard(reverse_layout)}}};
 
   return Initialize(processing_config);
 }
 
 int AudioProcessingImpl::Initialize(const ProcessingConfig& processing_config) {
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   CriticalSectionScoped crit_scoped(crit_);
   return InitializeLocked(processing_config);
 }
 
+int AudioProcessingImpl::MaybeInitializeLockedRender(
+    const ProcessingConfig& processing_config) {
+  RTC_DCHECK(render_thread_checker_.CalledOnValidThread());
+  return MaybeInitializeLocked(processing_config);
+}
+
+int AudioProcessingImpl::MaybeInitializeLockedCapture(
+    const ProcessingConfig& processing_config) {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
+  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) {
+  // This is called from the initialization functionality which is shared

[the sun, 2015/11/25 08:53:56]

I'm not a fan of repeated, verbose comments. Can you add a TODO(peah): instead,
that should be checked using the clang annotations, going forward?

[peah-webrtc, 2015/11/25 15:40:17]

Could not be happier to oblige! :-)
Done.

+  // between the render and capture parts, and also during the APM creation.
+  // Therefore it is neither possible to do thread checks nor to separate
+  // into different thread-specific implementations.
   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_);
+  RTC_DCHECK(signal_thread_checker_.CalledOnValidThread());
   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 {
+  // This is called from the initialization functionality which is shared
+  // between the render and capture parts, and also during the APM creation.
+  // Therefore it is neither possible to do thread checks nor to separate
+  // into different thread-specific implementations.
   return fwd_proc_format_.sample_rate_hz();
 }
 
 int AudioProcessingImpl::proc_split_sample_rate_hz() const {
+  // This is called from within the VAD submodule. It is used from code that is
+  // run by the capture and creation threads and is called via the
+  // public AudioProcessing API. Therefore it is not possible to do thread
+  // checks on these call without extending the public APM api.
   return split_rate_;
 }
 
 int AudioProcessingImpl::num_reverse_channels() const {
+  // This is called from within the submodules. It is used from code that is
+  // run by the render, capture and creation threads and is called via the
+  // public AudioProcessing API. Therefore it is not possible to do thread
+  // checks on these call without extending the public APM api.
   return rev_proc_format_.num_channels();
 }
 
 int AudioProcessingImpl::num_input_channels() const {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   return shared_state_.api_format_.input_stream().num_channels();
 }
 
 int AudioProcessingImpl::num_output_channels() const {
+  // This is called from within the submodules. It is used from code that is
+  // run by the render, capture and creation threads and is called via the
+  // public AudioProcessing API. Therefore it is not possible to do thread
+  // checks on these call without extending the public APM api.
   return shared_state_.api_format_.output_stream().num_channels();
 }
 
 void AudioProcessingImpl::set_output_will_be_muted(bool muted) {
   CriticalSectionScoped lock(crit_);
+  RTC_DCHECK(signal_thread_checker_.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_checker_.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_checker_.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;
   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 18 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_checker_.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 &&
       frame->sample_rate_hz_ != kSampleRate32kHz &&
       frame->sample_rate_hz_ != kSampleRate48kHz) {
     return kBadSampleRateError;
   }
 
   if (echo_control_mobile_->is_enabled() &&
       frame->sample_rate_hz_ > kMaxAECMSampleRateHz) {
     LOG(LS_ERROR) << "AECM only supports 16 or 8 kHz sample rates";
     return kUnsupportedComponentError;
   }
 
   // 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 13 matching lines @@
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_output_data(frame->data_, data_size);
     RETURN_ON_ERR(WriteMessageToDebugFile());
   }
 #endif
 
   return kNoError;
 }
 
 int AudioProcessingImpl::ProcessStreamLocked() {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   if (debug_file_->Open()) {
     audioproc::Stream* msg = event_msg_->mutable_stream();
     msg->set_delay(stream_delay_ms_);
     msg->set_drift(echo_cancellation_->stream_drift_samples());
     msg->set_level(gain_control()->stream_analog_level());
     msg->set_keypress(key_pressed_);
   }
 #endif
 
@@ skipping 61 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_checker_.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_checker_.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()) {
+  } 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_);
+  RTC_DCHECK(render_thread_checker_.CalledOnValidThread());
   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();
     for (int i = 0;
          i < shared_state_.api_format_.reverse_input_stream().num_channels();
          ++i)
       msg->add_channel(src[i], channel_size);
     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_checker_.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_checker_.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 11 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 =
         sizeof(int16_t) * frame->samples_per_channel_ * frame->num_channels_;
     msg->set_data(frame->data_, data_size);
     RETURN_ON_ERR(WriteMessageToDebugFile());
   }
 #endif
   render_audio_->DeinterleaveFrom(frame);
   return ProcessReverseStreamLocked();
 }
 
 int AudioProcessingImpl::ProcessReverseStreamLocked() {
+  RTC_DCHECK(render_thread_checker_.CalledOnValidThread());
   AudioBuffer* ra = render_audio_.get();  // For brevity.
   if (rev_proc_format_.sample_rate_hz() == kSampleRate32kHz) {
     ra->SplitIntoFrequencyBands();
   }
 
   if (intelligibility_enabled_) {
     intelligibility_enhancer_->ProcessRenderAudio(
         ra->split_channels_f(kBand0To8kHz), split_rate_, ra->num_channels());
   }
 
   RETURN_ON_ERR(echo_cancellation_->ProcessRenderAudio(ra));
   RETURN_ON_ERR(echo_control_mobile_->ProcessRenderAudio(ra));
   if (!use_new_agc_) {
     RETURN_ON_ERR(gain_control_->ProcessRenderAudio(ra));
   }
 
   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_checker_.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_checker_.CalledOnValidThread());
   return stream_delay_ms_;
 }
 
 bool AudioProcessingImpl::was_stream_delay_set() const {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   return was_stream_delay_set_;
 }
 
 void AudioProcessingImpl::set_stream_key_pressed(bool key_pressed) {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   key_pressed_ = key_pressed;
 }
 
 void AudioProcessingImpl::set_delay_offset_ms(int offset) {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   CriticalSectionScoped crit_scoped(crit_);
   delay_offset_ms_ = offset;
 }
 
 int AudioProcessingImpl::delay_offset_ms() const {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   return delay_offset_ms_;
 }
 
 int AudioProcessingImpl::StartDebugRecording(
     const char filename[AudioProcessing::kMaxFilenameSize]) {
   CriticalSectionScoped crit_scoped(crit_);
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   static_assert(kMaxFilenameSize == FileWrapper::kMaxFileNameSize, "");
 
   if (filename == NULL) {
     return kNullPointerError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stop any ongoing recording.
   if (debug_file_->Open()) {
     if (debug_file_->CloseFile() == -1) {
       return kFileError;
     }
   }
 
   if (debug_file_->OpenFile(filename, false) == -1) {
     debug_file_->CloseFile();
     return kFileError;
   }
 
   RETURN_ON_ERR(WriteConfigMessage(true));
   RETURN_ON_ERR(WriteInitMessage());
   return kNoError;
 #else
   return kUnsupportedFunctionError;
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 int AudioProcessingImpl::StartDebugRecording(FILE* handle) {
   CriticalSectionScoped crit_scoped(crit_);
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
 
   if (handle == NULL) {
     return kNullPointerError;
   }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // Stop any ongoing recording.
   if (debug_file_->Open()) {
     if (debug_file_->CloseFile() == -1) {
       return kFileError;
     }
   }
 
   if (debug_file_->OpenFromFileHandle(handle, true, false) == -1) {
     return kFileError;
   }
 
   RETURN_ON_ERR(WriteConfigMessage(true));
   RETURN_ON_ERR(WriteInitMessage());
   return kNoError;
 #else
   return kUnsupportedFunctionError;
 #endif  // WEBRTC_AUDIOPROC_DEBUG_DUMP
 }
 
 int AudioProcessingImpl::StartDebugRecordingForPlatformFile(
     rtc::PlatformFile handle) {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   FILE* stream = rtc::FdopenPlatformFileForWriting(handle);
   return StartDebugRecording(stream);
 }
 
 int AudioProcessingImpl::StopDebugRecording() {
   CriticalSectionScoped crit_scoped(crit_);
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
   // We just return if recording hasn't started.
   if (debug_file_->Open()) {
     if (debug_file_->CloseFile() == -1) {
       return kFileError;
     }
   }
   return kNoError;
 #else
@@ skipping 26 matching lines @@
 
 NoiseSuppression* AudioProcessingImpl::noise_suppression() const {
   return noise_suppression_;
 }
 
 VoiceDetection* AudioProcessingImpl::voice_detection() const {
   return voice_detection_;
 }
 
 bool AudioProcessingImpl::is_data_processed() const {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   if (beamformer_enabled_) {
     return true;
   }
 
   int enabled_count = 0;
   for (auto item : component_list_) {
     if (item->is_component_enabled()) {
       enabled_count++;
     }
   }
 
   // Data is unchanged if no components are enabled, or if only level_estimator_
   // or voice_detection_ is enabled.
   if (enabled_count == 0) {
     return false;
   } else if (enabled_count == 1) {
     if (level_estimator_->is_enabled() || voice_detection_->is_enabled()) {
       return false;
     }
   } else if (enabled_count == 2) {
     if (level_estimator_->is_enabled() && voice_detection_->is_enabled()) {
       return false;
     }
   }
   return true;
 }
 
 bool AudioProcessingImpl::output_copy_needed(bool is_data_processed) const {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   // Check if we've upmixed or downmixed the audio.
   return ((shared_state_.api_format_.output_stream().num_channels() !=
            shared_state_.api_format_.input_stream().num_channels()) ||
           is_data_processed || transient_suppressor_enabled_);
 }
 
 bool AudioProcessingImpl::synthesis_needed(bool is_data_processed) const {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   return (is_data_processed &&
           (fwd_proc_format_.sample_rate_hz() == kSampleRate32kHz ||
            fwd_proc_format_.sample_rate_hz() == kSampleRate48kHz));
 }
 
 bool AudioProcessingImpl::analysis_needed(bool is_data_processed) const {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   if (!is_data_processed && !voice_detection_->is_enabled() &&
       !transient_suppressor_enabled_) {
     // Only level_estimator_ is enabled.
     return false;
   } else if (fwd_proc_format_.sample_rate_hz() == kSampleRate32kHz ||
              fwd_proc_format_.sample_rate_hz() == kSampleRate48kHz) {
     // Something besides level_estimator_ is enabled, and we have super-wb.
     return true;
   }
   return false;
 }
 
 bool AudioProcessingImpl::is_rev_processed() const {
+  RTC_DCHECK(render_thread_checker_.CalledOnValidThread());
   return intelligibility_enabled_ && intelligibility_enhancer_->active();
 }
 
+bool AudioProcessingImpl::render_check_rev_conversion_needed() const {
+  RTC_DCHECK(render_thread_checker_.CalledOnValidThread());
+  return rev_conversion_needed();
+}
+
 bool AudioProcessingImpl::rev_conversion_needed() const {
+  // This is called from the initialization functionality, which is shared
+  // between the render and capture parts, and also during the APM creation.
+  // Therefore it is neither possible to do thread checks nor to separate
+  // into different thread-specific implementations.
   return (shared_state_.api_format_.reverse_input_stream() !=
           shared_state_.api_format_.reverse_output_stream());
 }
 
 void AudioProcessingImpl::InitializeExperimentalAgc() {
+  // This is called from the initialization functionality, which is shared
+  // between the render and capture parts, and also during the APM creation.
+  // Therefore it is neither possible to do thread checks nor to separate
+  // into different thread-specific implementations.
   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() {
+  // This is called from the initialization functionality, which is shared
+  // between the render and capture parts, and also during the APM creation.
+  // Therefore it is neither possible to do thread checks nor to separate
+  // into different thread-specific implementations.
   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() {
+  // This is called from the initialization functionality, which is shared
+  // between the render and capture parts, and also during the APM creation.
+  // Therefore it is neither possible to do thread checks nor to separate
+  // into different thread-specific implementations.
   if (beamformer_enabled_) {
     if (!beamformer_) {
       beamformer_.reset(
           new NonlinearBeamformer(array_geometry_, target_direction_));
     }
     beamformer_->Initialize(kChunkSizeMs, split_rate_);
   }
 }
 
 void AudioProcessingImpl::InitializeIntelligibility() {
+  // This is called from the initialization functionality, which is shared
+  // between the render and capture parts, and also during the APM creation.
+  // Therefore it is neither possible to do thread checks nor to separate
+  // into different thread-specific implementations.
   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() {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   static const int kMinDiffDelayMs = 60;
 
   if (echo_cancellation()->is_enabled()) {
     // Activate delay_jumps_ counters if we know echo_cancellation is runnning.
     // If a stream has echo we know that the echo_cancellation is in process.
     if (stream_delay_jumps_ == -1 && echo_cancellation()->stream_has_echo()) {
       stream_delay_jumps_ = 0;
     }
     if (aec_system_delay_jumps_ == -1 &&
         echo_cancellation()->stream_has_echo()) {
@@ skipping 26 matching lines @@
       if (aec_system_delay_jumps_ == -1) {
         aec_system_delay_jumps_ = 0;  // Activate counter if needed.
       }
       aec_system_delay_jumps_++;
     }
     last_aec_system_delay_ms_ = aec_system_delay_ms;
   }
 }
 
 void AudioProcessingImpl::UpdateHistogramsOnCallEnd() {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   CriticalSectionScoped crit_scoped(crit_);
   if (stream_delay_jumps_ > -1) {
     RTC_HISTOGRAM_ENUMERATION(
         "WebRTC.Audio.NumOfPlatformReportedStreamDelayJumps",
         stream_delay_jumps_, 51);
   }
   stream_delay_jumps_ = -1;
   last_stream_delay_ms_ = 0;
 
   if (aec_system_delay_jumps_ > -1) {
     RTC_HISTOGRAM_ENUMERATION("WebRTC.Audio.NumOfAecSystemDelayJumps",
                               aec_system_delay_jumps_, 51);
   }
   aec_system_delay_jumps_ = -1;
   last_aec_system_delay_ms_ = 0;
 }
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 int AudioProcessingImpl::WriteMessageToDebugFile() {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   int32_t size = event_msg_->ByteSize();
   if (size <= 0) {
     return kUnspecifiedError;
   }
 #if defined(WEBRTC_ARCH_BIG_ENDIAN)
 // TODO(ajm): Use little-endian "on the wire". For the moment, we can be
 //            pretty safe in assuming little-endian.
 #endif
 
   if (!event_msg_->SerializeToString(&event_str_)) {
     return kUnspecifiedError;
   }
 
   // Write message preceded by its size.
   if (!debug_file_->Write(&size, sizeof(int32_t))) {
     return kFileError;
   }
   if (!debug_file_->Write(event_str_.data(), event_str_.length())) {
     return kFileError;
   }
 
   event_msg_->Clear();
 
   return kNoError;
 }
 
 int AudioProcessingImpl::WriteInitMessage() {
+  // This is called from the initialization functionality, which is shared
+  // between the render and capture parts, and also during the APM creation.
+  // Therefore it is neither possible to do thread checks nor to separate
+  // into different thread-specific implementations.
   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());
   msg->set_reverse_sample_rate(
       shared_state_.api_format_.reverse_input_stream().sample_rate_hz());
   msg->set_output_sample_rate(
       shared_state_.api_format_.output_stream().sample_rate_hz());
   // TODO(ekmeyerson): Add reverse output fields to event_msg_.
 
   RETURN_ON_ERR(WriteMessageToDebugFile());
   return kNoError;
 }
 
 int AudioProcessingImpl::WriteConfigMessage(bool forced) {
+  RTC_DCHECK(capture_thread_checker_.CalledOnValidThread());
   audioproc::Config config;
 
   config.set_aec_enabled(echo_cancellation_->is_enabled());
   config.set_aec_delay_agnostic_enabled(
       echo_cancellation_->is_delay_agnostic_enabled());
   config.set_aec_drift_compensation_enabled(
       echo_cancellation_->is_drift_compensation_enabled());
   config.set_aec_extended_filter_enabled(
       echo_cancellation_->is_extended_filter_enabled());
   config.set_aec_suppression_level(
@@ skipping 26 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