Lock scheme #8: Introduced the new locking scheme

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 19 matching lines @@
 #include "webrtc/modules/audio_processing/echo_control_mobile_impl.h"
 #include "webrtc/modules/audio_processing/gain_control_impl.h"
 #include "webrtc/modules/audio_processing/high_pass_filter_impl.h"
 #include "webrtc/modules/audio_processing/intelligibility/intelligibility_enhancer.h"
 #include "webrtc/modules/audio_processing/level_estimator_impl.h"
 #include "webrtc/modules/audio_processing/noise_suppression_impl.h"
 #include "webrtc/modules/audio_processing/processing_component.h"
 #include "webrtc/modules/audio_processing/transient/transient_suppressor.h"
 #include "webrtc/modules/audio_processing/voice_detection_impl.h"
 #include "webrtc/modules/interface/module_common_types.h"
-#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/file_wrapper.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/metrics.h"
 
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
 // Files generated at build-time by the protobuf compiler.
 #ifdef WEBRTC_ANDROID_PLATFORM_BUILD
 #include "external/webrtc/webrtc/modules/audio_processing/debug.pb.h"
 #else
 #include "webrtc/audio_processing/debug.pb.h"
@@ skipping 132 matching lines @@
 
 AudioProcessingImpl::AudioProcessingImpl(const Config& config,
                                          Beamformer<float>* beamformer)
     : echo_cancellation_(NULL),
       echo_control_mobile_(NULL),
       gain_control_(NULL),
       high_pass_filter_(NULL),
       level_estimator_(NULL),
       noise_suppression_(NULL),
       voice_detection_(NULL),
-      crit_(CriticalSectionWrapper::CreateCriticalSection()),
 #ifdef WEBRTC_AUDIOPROC_DEBUG_DUMP
       debug_file_(FileWrapper::Create()),
       event_msg_(new audioproc::Event()),
 #endif
       fwd_proc_format_(kSampleRate16kHz),
       rev_proc_format_(kSampleRate16kHz, 1),
       split_rate_(kSampleRate16kHz),
       stream_delay_ms_(0),
       delay_offset_ms_(0),
       was_stream_delay_set_(false),
@@ skipping 11 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_, &render_thread_, &capture_thread_);
+
+  echo_cancellation_ = new EchoCancellationImpl(
+      this, &crit_render_, &crit_capture_, &render_thread_, &capture_thread_);
   component_list_.push_back(echo_cancellation_);
 
-  echo_control_mobile_ =
-      new EchoControlMobileImpl(this, crit_, &render_thread_, &capture_thread_);
+  echo_control_mobile_ = new EchoControlMobileImpl(
+      this, &crit_render_, &crit_capture_, &render_thread_, &capture_thread_);
   component_list_.push_back(echo_control_mobile_);
 
-  gain_control_ =
-      new GainControlImpl(this, crit_, &render_thread_, &capture_thread_);
+  gain_control_ = new GainControlImpl(this, &crit_capture_, &crit_capture_,
+                                      &render_thread_, &capture_thread_);
+
   component_list_.push_back(gain_control_);
 
-  high_pass_filter_ = new HighPassFilterImpl(this, crit_);
+  high_pass_filter_ = new HighPassFilterImpl(this);
   component_list_.push_back(high_pass_filter_);
 
-  level_estimator_ = new LevelEstimatorImpl(this, crit_);
+  level_estimator_ = new LevelEstimatorImpl(this);
   component_list_.push_back(level_estimator_);
 
-  noise_suppression_ = new NoiseSuppressionImpl(this, crit_, &capture_thread_);
+  noise_suppression_ =
+      new NoiseSuppressionImpl(this, &crit_capture_, &capture_thread_);
   component_list_.push_back(noise_suppression_);
 
-  voice_detection_ = new VoiceDetectionImpl(this, crit_, &capture_thread_);
+  voice_detection_ =
+      new VoiceDetectionImpl(this, &crit_capture_, &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();
 }
 
 AudioProcessingImpl::~AudioProcessingImpl() {
   {
-    CriticalSectionScoped crit_scoped(crit_);
+    rtc::CritScope cs_render(&crit_render_);
+    rtc::CritScope cs_capture(&crit_capture_);
     // 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() {
-  CriticalSectionScoped crit_scoped(crit_);
+  // Run in a single-threaded manner during initialization.
+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
   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) {
+  // Run in a single-threaded manner during initialization.
+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
+
   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) {
-  CriticalSectionScoped crit_scoped(crit_);
+  // Run in a single-threaded manner during initialization.
+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
   return InitializeLocked(processing_config);
 }
 
 // Calls InitializeLocked() if any of the audio parameters have changed from
-// their current values.
-int AudioProcessingImpl::MaybeInitializeLocked(
+// their current values (needs to be called while holding the crit_render_
+// lock).
+int AudioProcessingImpl::MaybeInitialize(
     const ProcessingConfig& processing_config) {
+  RTC_DCHECK(crit_render_.IsLocked());

[kwiberg-webrtc, 2015/10/27 13:15:56]

Is this check useful? Doesn't it just check that *someone's* holding the mutex,
not that *we* are?

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

I added the check as a threadchecker instead which is how it should be.

The idea is that it is only allowed to call this function while holding the
render mutex.

Done.

   if (processing_config == shared_state_.api_format_) {
     return kNoError;
   }
+
+  rtc::CritScope cs_capture(&crit_capture_);
   return InitializeLocked(processing_config);
 }
 
 int AudioProcessingImpl::InitializeLocked() {
   const int fwd_audio_buffer_channels =
       beamformer_enabled_
           ? shared_state_.api_format_.input_stream().num_channels()
           : shared_state_.api_format_.output_stream().num_channels();
   const int rev_audio_buffer_out_num_frames =
       shared_state_.api_format_.reverse_output_stream().num_frames() == 0
@@ skipping 121 matching lines @@
       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_);
+  // Run in a single-threaded manner when setting ehe extra options.

[kwiberg-webrtc, 2015/10/27 13:15:57]

the

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

Done.

+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
   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 12 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::CritScope cs(&crit_capture_);
   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();
+  StreamConfig input_stream;
+  StreamConfig output_stream;
+  {
+    // Access the shared_state_.api_format_.input_stream beneath the capture
+    // lock.
+    // The lock must be released as it is later required in the call
+    // to ProcessStream(,,,);
+    rtc::CritScope cs(&crit_capture_);
+    input_stream = shared_state_.api_format_.input_stream();
+    output_stream = shared_state_.api_format_.output_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());
+  {
+    // Acquire the capture lock in order to safely call the function
+    // that retrieves the render side data. This function accesses apm
+    // getters that need the capture lock held when being called.
+    rtc::CritScope cs_capture(&crit_capture_);
+    echo_cancellation_->ReadQueuedRenderData();
+    echo_control_mobile_->ReadQueuedRenderData();
+    gain_control_->ReadQueuedRenderData();
+  }
   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));
+  {
+    // Do conditional reinitialization.
+    rtc::CritScope cs_render(&crit_render_);
+    RETURN_ON_ERR(MaybeInitialize(processing_config));
+  }
+  rtc::CritScope cs_capture(&crit_capture_);
+
   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 17 matching lines @@
          i < shared_state_.api_format_.output_stream().num_channels(); ++i)
       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();
+  {
+    // Acquire the capture lock in order to safely call the function
+    // that retrieves the render side data. This function accesses apm
+    // getters that need the capture lock held when being called.
+    // The lock needs to be released as
+    // echo_control_mobile_->is_enabled() aquires this lock as well.
+    rtc::CritScope cs_capture(&crit_capture_);
+    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_;
+  ProcessingConfig processing_config;
+  {
+    // Aquire lock for the access of api_format.
+    // The lock is released immediately due to the conditional
+    // reinitialization.
+    rtc::CritScope cs_capture(&crit_capture_);
+    // TODO(ajm): The input and output rates and channels are currently
+    // constrained to be identical in the int16 interface.
+    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));
+  {
+    // Do conditional reinitialization.
+    rtc::CritScope cs_render(&crit_render_);
+    RETURN_ON_ERR(MaybeInitialize(processing_config));
+  }
+  rtc::CritScope cs_capture(&crit_capture_);
   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 95 matching lines @@
 
   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());
+  rtc::CritScope cs(&crit_render_);
   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);
+  return AnalyzeReverseStreamLocked(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));
+  rtc::CritScope cs(&crit_render_);
+  RETURN_ON_ERR(AnalyzeReverseStreamLocked(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(),
                       reverse_input_config.num_channels(), dest);
   }
 
   return kNoError;
 }
 
-int AudioProcessingImpl::AnalyzeReverseStream(
+int AudioProcessingImpl::AnalyzeReverseStreamLocked(
     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(MaybeInitialize(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_.CalledOnValidThread());
   RETURN_ON_ERR(AnalyzeReverseStream(frame));
+  rtc::CritScope cs(&crit_render_);
   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_);
+  rtc::CritScope cs(&crit_render_);
   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 10 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(MaybeInitialize(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() {
   AudioBuffer* ra = render_audio_.get();  // For brevity.
   if (rev_proc_format_.sample_rate_hz() == kSampleRate32kHz) {
     ra->SplitIntoFrequencyBands();
   }
 
   if (intelligibility_enabled_) {
+    // Currently run in single-threaded mode when the intelligibility
+    // enhancer is activated.
+    // TODO(peah): Fix to be properly multi-threaded.
+    rtc::CritScope cs(&crit_capture_);
     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_.CalledOnValidThread());
+  rtc::CritScope cs(&crit_capture_);
   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());
+  rtc::CritScope cs(&crit_capture_);
   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());
+  rtc::CritScope cs(&crit_capture_);
   key_pressed_ = key_pressed;
 }
 
 void AudioProcessingImpl::set_delay_offset_ms(int offset) {
   RTC_DCHECK(capture_thread_.CalledOnValidThread());
-  CriticalSectionScoped crit_scoped(crit_);
+  rtc::CritScope cs(&crit_capture_);
   delay_offset_ms_ = offset;
 }
 
 int AudioProcessingImpl::delay_offset_ms() const {
   RTC_DCHECK(capture_thread_.CalledOnValidThread());
+  rtc::CritScope cs(&crit_capture_);
   return delay_offset_ms_;
 }
 
 int AudioProcessingImpl::StartDebugRecording(
     const char filename[AudioProcessing::kMaxFilenameSize]) {
-  CriticalSectionScoped crit_scoped(crit_);
+  // Run in a single-threaded manner.
+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
+
   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_);
+  // Run in a single-threaded manner.
+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
 
   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) {
+  // Run in a single-threaded manner.
+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
   FILE* stream = rtc::FdopenPlatformFileForWriting(handle);
   return StartDebugRecording(stream);
 }
 
 int AudioProcessingImpl::StopDebugRecording() {
-  CriticalSectionScoped crit_scoped(crit_);
+  // Run in a single-threaded manner.
+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
 
 #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 177 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() {
-  CriticalSectionScoped crit_scoped(crit_);
+  // Run in a single-threaded manner.
+  rtc::CritScope cs_render(&crit_render_);
+  rtc::CritScope cs_capture(&crit_capture_);
+
   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",
@@ skipping 92 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