Lock scheme #8: Introduced the new locking scheme

webrtc/modules/audio_processing/echo_cancellation_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.
  */
 
 #include "webrtc/modules/audio_processing/echo_cancellation_impl.h"
 
 #include <assert.h>
 #include <string.h>
 
 extern "C" {
 #include "webrtc/modules/audio_processing/aec/aec_core.h"
 }
+#include "webrtc/base/criticalsection.h"
 #include "webrtc/modules/audio_processing/aec/include/echo_cancellation.h"
 #include "webrtc/modules/audio_processing/audio_buffer.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 
 namespace webrtc {
 
 typedef void Handle;
 
 namespace {
 int16_t MapSetting(EchoCancellation::SuppressionLevel level) {
   switch (level) {
     case EchoCancellation::kLowSuppression:
       return kAecNlpConservative;
@@ skipping 21 matching lines @@
       return AudioProcessing::kUnspecifiedError;
   }
 }
 }  // namespace
 
 const size_t EchoCancellationImpl::kAllowedValuesOfSamplesPerFrame1;
 const size_t EchoCancellationImpl::kAllowedValuesOfSamplesPerFrame2;
 
 EchoCancellationImpl::EchoCancellationImpl(
     const AudioProcessing* apm,
-    CriticalSectionWrapper* crit,
+    rtc::CriticalSection* crit_render,
+    rtc::CriticalSection* crit_capture,
     rtc::ThreadChecker* render_thread_checker)
     : ProcessingComponent(),
       apm_(apm),
-      crit_(crit),
+      crit_render_(crit_render),
+      crit_capture_(crit_capture),
       render_thread_checker_(render_thread_checker),
       drift_compensation_enabled_(false),
       metrics_enabled_(false),
       suppression_level_(kModerateSuppression),
       stream_drift_samples_(0),
       was_stream_drift_set_(false),
       stream_has_echo_(false),
       delay_logging_enabled_(false),
       extended_filter_enabled_(false),
       delay_agnostic_enabled_(false),
@@ skipping 31 matching lines @@
       }
 
       // Buffer the samples in the render queue.
       render_queue_buffer_.insert(render_queue_buffer_.end(),
                                   audio->split_bands_const_f(j)[kBand0To8kHz],
                                   (audio->split_bands_const_f(j)[kBand0To8kHz] +
                                    audio->num_frames_per_band()));
     }
   }
 
-  // Check of success is temporarily disabled as it breaks a unit test.
-  // TODO(peah): Will be fixed in the next CL.
-  (void)render_signal_queue_->Insert(&render_queue_buffer_);
+  // Insert the samples into the queue.
+  bool success = render_signal_queue_->Insert(&render_queue_buffer_);

[hlundin-webrtc, 2015/11/05 16:11:22]

You don't need success.
if (!render_signal_queue_->Insert(&render_queue_buffer_)) {
...

[peah-webrtc, 2015/11/06 09:54:32]

Done.

+  if (!success) {
+    // The data queue is full and needs to be emptied.
+    {
+      rtc::CritScope cs_capture(crit_capture_);
+      ReadQueuedRenderData();
+    }
+
+    // Retry the insert (should always work).
+    RTC_DCHECK_EQ(render_signal_queue_->Insert(&render_queue_buffer_), true);
+  }
 
   return apm_->kNoError;
 }
 
 // Read chunks of data that were received and queued on the render side from
 // a queue. All the data chunks are buffered into the farend signal of the AEC.
 void EchoCancellationImpl::ReadQueuedRenderData() {
   if (!is_component_enabled()) {
     return;
   }
@@ skipping 71 matching lines @@
 
       handle_index++;
     }
   }
 
   was_stream_drift_set_ = false;
   return apm_->kNoError;
 }
 
 int EchoCancellationImpl::Enable(bool enable) {
-  CriticalSectionScoped crit_scoped(crit_);
+  // Run in a single-threaded manner.
+  rtc::CritScope cs_render(crit_render_);
+  rtc::CritScope cs_capture(crit_capture_);
   // Ensure AEC and AECM are not both enabled.
   if (enable && apm_->echo_control_mobile()->is_enabled()) {
     return apm_->kBadParameterError;
   }
 
   return EnableComponent(enable);
 }
 
 bool EchoCancellationImpl::is_enabled() const {
+  rtc::CritScope cs(crit_capture_);
   return is_component_enabled();
 }
 
 int EchoCancellationImpl::set_suppression_level(SuppressionLevel level) {
-  CriticalSectionScoped crit_scoped(crit_);
+  rtc::CritScope cs(crit_capture_);
   if (MapSetting(level) == -1) {
     return apm_->kBadParameterError;
   }
 
   suppression_level_ = level;
   return Configure();
 }
 
 EchoCancellation::SuppressionLevel EchoCancellationImpl::suppression_level()
     const {
+  rtc::CritScope cs(crit_capture_);
   return suppression_level_;
 }
 
 int EchoCancellationImpl::enable_drift_compensation(bool enable) {
-  CriticalSectionScoped crit_scoped(crit_);
+  rtc::CritScope cs(crit_capture_);
   drift_compensation_enabled_ = enable;
   return Configure();
 }
 
 bool EchoCancellationImpl::is_drift_compensation_enabled() const {
+  rtc::CritScope cs(crit_capture_);
   return drift_compensation_enabled_;
 }
 
 void EchoCancellationImpl::set_stream_drift_samples(int drift) {
+  rtc::CritScope cs(crit_capture_);
   was_stream_drift_set_ = true;
   stream_drift_samples_ = drift;
 }
 
 int EchoCancellationImpl::stream_drift_samples() const {
+  rtc::CritScope cs(crit_capture_);
   return stream_drift_samples_;
 }
 
 int EchoCancellationImpl::enable_metrics(bool enable) {
-  CriticalSectionScoped crit_scoped(crit_);
+  rtc::CritScope cs(crit_capture_);
   metrics_enabled_ = enable;
   return Configure();
 }
 
 bool EchoCancellationImpl::are_metrics_enabled() const {
+  rtc::CritScope cs(crit_capture_);
   return metrics_enabled_;
 }
 
 // TODO(ajm): we currently just use the metrics from the first AEC. Think more
 //            aboue the best way to extend this to multi-channel.
 int EchoCancellationImpl::GetMetrics(Metrics* metrics) {
-  CriticalSectionScoped crit_scoped(crit_);
+  rtc::CritScope cs(crit_capture_);
   if (metrics == NULL) {
     return apm_->kNullPointerError;
   }
 
   if (!is_component_enabled() || !metrics_enabled_) {
     return apm_->kNotEnabledError;
   }
 
   AecMetrics my_metrics;
   memset(&my_metrics, 0, sizeof(my_metrics));
@@ skipping 22 matching lines @@
 
   metrics->a_nlp.instant = my_metrics.aNlp.instant;
   metrics->a_nlp.average = my_metrics.aNlp.average;
   metrics->a_nlp.maximum = my_metrics.aNlp.max;
   metrics->a_nlp.minimum = my_metrics.aNlp.min;
 
   return apm_->kNoError;
 }
 
 bool EchoCancellationImpl::stream_has_echo() const {
-  return stream_has_echo_;
+  // This is called both from within and from outside of APM, with and
+  // without locks set. Hence the conditional lock handling below.
+  bool stream_has_echo;
+  if (crit_capture_->TryEnter()) {

[hlundin-webrtc, 2015/11/05 16:11:22]

I don't understand this code, but I wonder if rtc::TryCritScope is what you want
to use.

[peah-webrtc, 2015/11/06 09:54:32]

Sounds like that! Thanks!
Done.

+    stream_has_echo = stream_has_echo_;
+    crit_capture_->Leave();
+  } else {
+    stream_has_echo = stream_has_echo_;
+  }
+  return stream_has_echo;
 }
 
 int EchoCancellationImpl::enable_delay_logging(bool enable) {
-  CriticalSectionScoped crit_scoped(crit_);
+  rtc::CritScope cs(crit_capture_);
   delay_logging_enabled_ = enable;
   return Configure();
 }
 
 bool EchoCancellationImpl::is_delay_logging_enabled() const {
+  rtc::CritScope cs(crit_capture_);
   return delay_logging_enabled_;
 }
 
 bool EchoCancellationImpl::is_delay_agnostic_enabled() const {
+  // Only called from within APM, hence no locking is needed.
   return delay_agnostic_enabled_;
 }
 
 bool EchoCancellationImpl::is_extended_filter_enabled() const {
+  // Only called from within APM, hence no locking is needed.
   return extended_filter_enabled_;
 }
 
 // TODO(bjornv): How should we handle the multi-channel case?
 int EchoCancellationImpl::GetDelayMetrics(int* median, int* std) {
+  rtc::CritScope cs(crit_capture_);
   float fraction_poor_delays = 0;
   return GetDelayMetrics(median, std, &fraction_poor_delays);
 }
 
 int EchoCancellationImpl::GetDelayMetrics(int* median, int* std,
                                           float* fraction_poor_delays) {
-  CriticalSectionScoped crit_scoped(crit_);
+  rtc::CritScope cs(crit_capture_);
   if (median == NULL) {
     return apm_->kNullPointerError;
   }
   if (std == NULL) {
     return apm_->kNullPointerError;
   }
 
   if (!is_component_enabled() || !delay_logging_enabled_) {
     return apm_->kNotEnabledError;
   }
 
   Handle* my_handle = static_cast<Handle*>(handle(0));
   const int err =
       WebRtcAec_GetDelayMetrics(my_handle, median, std, fraction_poor_delays);
   if (err != apm_->kNoError) {
     return MapError(err);
   }
 
   return apm_->kNoError;
 }
 
 struct AecCore* EchoCancellationImpl::aec_core() const {
-  CriticalSectionScoped crit_scoped(crit_);
+  // Only called from within APM, hence no locking is needed.
   if (!is_component_enabled()) {
     return NULL;
   }
   Handle* my_handle = static_cast<Handle*>(handle(0));
   return WebRtcAec_aec_core(my_handle);
 }
 
 int EchoCancellationImpl::Initialize() {
+  // Only called from within APM, hence no locking is needed.
   int err = ProcessingComponent::Initialize();
   if (err != apm_->kNoError || !is_component_enabled()) {
     return err;
   }
 
   AllocateRenderQueue();
 
   return apm_->kNoError;
 }
 
 void EchoCancellationImpl::AllocateRenderQueue() {
+  // Only called from within APM, hence no locking is needed.
   const size_t max_frame_size = std::max(kAllowedValuesOfSamplesPerFrame1,
                                          kAllowedValuesOfSamplesPerFrame2);
 
   const size_t new_render_queue_element_max_size =
       std::max(1UL, max_frame_size * num_handles_required());
 
   // Reallocate the queue if the queue item size is too small to fit the
   // data to put in the queue.
   if (new_render_queue_element_max_size > render_queue_element_max_size_) {
     render_queue_element_max_size_ = new_render_queue_element_max_size;
 
     std::vector<float> template_queue_element(render_queue_element_max_size_);
 
     render_signal_queue_.reset(
         new SwapQueue<std::vector<float>, AecRenderQueueItemVerifier>(
             kMaxNumFramesToBuffer,
             AecRenderQueueItemVerifier(render_queue_element_max_size_),
             template_queue_element));
   } else {
     render_signal_queue_->Clear();
   }
 
   render_queue_buffer_.resize(new_render_queue_element_max_size);
   capture_queue_buffer_.resize(new_render_queue_element_max_size);
 }
 
 void EchoCancellationImpl::SetExtraOptions(const Config& config) {
+  // This is called both from within and from outside of APM, with and
+  // without locks set. Hence the conditional lock handling below.
+  bool locked_locally = crit_capture_->TryEnter();
   extended_filter_enabled_ = config.Get<ExtendedFilter>().enabled;
   delay_agnostic_enabled_ = config.Get<DelayAgnostic>().enabled;
   Configure();
+  if (locked_locally) {
+    crit_capture_->Leave();
+  }
 }
 
 void* EchoCancellationImpl::CreateHandle() const {
+  // Only called from within APM, hence no locking is needed.
   return WebRtcAec_Create();
 }
 
 void EchoCancellationImpl::DestroyHandle(void* handle) const {
+  // Only called from within APM, hence no locking is needed.
   assert(handle != NULL);
   WebRtcAec_Free(static_cast<Handle*>(handle));
 }
 
 int EchoCancellationImpl::InitializeHandle(void* handle) const {
+  // Only called from within APM, hence no locking is needed.
   assert(handle != NULL);
   // TODO(ajm): Drift compensation is disabled in practice. If restored, it
   // should be managed internally and not depend on the hardware sample rate.
   // For now, just hardcode a 48 kHz value.
   return WebRtcAec_Init(static_cast<Handle*>(handle),
                        apm_->proc_sample_rate_hz(),
                        48000);
 }
 
 int EchoCancellationImpl::ConfigureHandle(void* handle) const {
+  // Only called from within APM, hence no locking is needed.
   assert(handle != NULL);
   AecConfig config;
   config.metricsMode = metrics_enabled_;
   config.nlpMode = MapSetting(suppression_level_);
   config.skewMode = drift_compensation_enabled_;
   config.delay_logging = delay_logging_enabled_;
 
   WebRtcAec_enable_extended_filter(
       WebRtcAec_aec_core(static_cast<Handle*>(handle)),
       extended_filter_enabled_ ? 1 : 0);
   WebRtcAec_enable_delay_agnostic(
       WebRtcAec_aec_core(static_cast<Handle*>(handle)),
       delay_agnostic_enabled_ ? 1 : 0);
   return WebRtcAec_set_config(static_cast<Handle*>(handle), config);
 }
 
 int EchoCancellationImpl::num_handles_required() const {
+  // Only called from within APM, hence no locking is needed.
   return apm_->num_output_channels() *
          apm_->num_reverse_channels();
 }
 
 int EchoCancellationImpl::GetHandleError(void* handle) const {
+  // Only called from within APM, hence no locking is needed.
   assert(handle != NULL);
   return AudioProcessing::kUnspecifiedError;
 }
 
 }  // namespace webrtc