Remove CriticalSectionWrapper from audio conference mixer.

webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_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 110 matching lines @@
       _audioFramePool(NULL),
       _participantList(),
       _additionalParticipantList(),
       _numMixedParticipants(0),
       use_limiter_(true),
       _timeStamp(0),
       _timeScheduler(kProcessPeriodicityInMs),
       _processCalls(0) {}
 
 bool AudioConferenceMixerImpl::Init() {
-    _crit.reset(CriticalSectionWrapper::CreateCriticalSection());
-    if (_crit.get() == NULL)
-        return false;
-
-    _cbCrit.reset(CriticalSectionWrapper::CreateCriticalSection());
-    if(_cbCrit.get() == NULL)
-        return false;
-
     Config config;
     config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
     _limiter.reset(AudioProcessing::Create(config));
     if(!_limiter.get())
         return false;
 
     MemoryPool<AudioFrame>::CreateMemoryPool(_audioFramePool,
                                              DEFAULT_AUDIO_FRAME_POOLSIZE);
     if(_audioFramePool == NULL)
         return false;
@@ skipping 25 matching lines @@
 }
 
 AudioConferenceMixerImpl::~AudioConferenceMixerImpl() {
     MemoryPool<AudioFrame>::DeleteMemoryPool(_audioFramePool);
     assert(_audioFramePool == NULL);
 }
 
 // Process should be called every kProcessPeriodicityInMs ms
 int64_t AudioConferenceMixerImpl::TimeUntilNextProcess() {
     int64_t timeUntilNextProcess = 0;
-    CriticalSectionScoped cs(_crit.get());
+    rtc::CritScope cs(&_crit);
     if(_timeScheduler.TimeToNextUpdate(timeUntilNextProcess) != 0) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "failed in TimeToNextUpdate() call");
         // Sanity check
         assert(false);
         return -1;
     }
     return timeUntilNextProcess;
 }
 
 void AudioConferenceMixerImpl::Process() {
     size_t remainingParticipantsAllowedToMix =
         kMaximumAmountOfMixedParticipants;
     {
-        CriticalSectionScoped cs(_crit.get());
+        rtc::CritScope cs(&_crit);
         assert(_processCalls == 0);
         _processCalls++;
 
         // Let the scheduler know that we are running one iteration.
         _timeScheduler.UpdateScheduler();
     }
 
     AudioFrameList mixList;
     AudioFrameList rampOutList;
     AudioFrameList additionalFramesList;
     std::map<int, MixerParticipant*> mixedParticipantsMap;
     {
-        CriticalSectionScoped cs(_cbCrit.get());
+        rtc::CritScope cs(&_cbCrit);
 
         int32_t lowFreq = GetLowestMixingFrequency();
         // SILK can run in 12 kHz and 24 kHz. These frequencies are not
         // supported so use the closest higher frequency to not lose any
         // information.
         // TODO(henrike): this is probably more appropriate to do in
         //                GetLowestMixingFrequency().
         if (lowFreq == 12000) {
             lowFreq = 16000;
         } else if (lowFreq == 24000) {
             lowFreq = 32000;
         }
         if(lowFreq <= 0) {
-            CriticalSectionScoped cs(_crit.get());
-            _processCalls--;
-            return;
+          rtc::CritScope cs(&_crit);
+          _processCalls--;
+          return;
         } else {
             switch(lowFreq) {
             case 8000:
                 if(OutputFrequency() != kNbInHz) {
                     SetOutputFrequency(kNbInHz);
                 }
                 break;
             case 16000:
                 if(OutputFrequency() != kWbInHz) {
                     SetOutputFrequency(kWbInHz);
                 }
                 break;
             case 32000:
                 if(OutputFrequency() != kSwbInHz) {
                     SetOutputFrequency(kSwbInHz);
                 }
                 break;
             case 48000:
                 if(OutputFrequency() != kFbInHz) {
                     SetOutputFrequency(kFbInHz);
                 }
                 break;
             default:
                 assert(false);
 
-                CriticalSectionScoped cs(_crit.get());
+                rtc::CritScope cs(&_crit);
                 _processCalls--;
                 return;
             }
         }
 
         UpdateToMix(&mixList, &rampOutList, &mixedParticipantsMap,
                     &remainingParticipantsAllowedToMix);
 
         GetAdditionalAudio(&additionalFramesList);
         UpdateMixedStatus(mixedParticipantsMap);
     }
 
     // Get an AudioFrame for mixing from the memory pool.
     AudioFrame* mixedAudio = NULL;
     if(_audioFramePool->PopMemory(mixedAudio) == -1) {
         WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
                      "failed PopMemory() call");
         assert(false);
         return;
     }
 
     {
-        CriticalSectionScoped cs(_crit.get());
+        rtc::CritScope cs(&_crit);
 
         // TODO(henrike): it might be better to decide the number of channels
         //                with an API instead of dynamically.
 
         // Find the max channels over all mixing lists.
         const size_t num_mixed_channels = std::max(MaxNumChannels(&mixList),
             std::max(MaxNumChannels(&additionalFramesList),
                      MaxNumChannels(&rampOutList)));
 
         mixedAudio->UpdateFrame(-1, _timeStamp, NULL, 0, _outputFrequency,
@@ skipping 16 matching lines @@
             // Nothing was mixed, set the audio samples to silence.
             mixedAudio->samples_per_channel_ = _sampleSize;
             AudioFrameOperations::Mute(mixedAudio);
         } else {
             // Only call the limiter if we have something to mix.
             LimitMixedAudio(mixedAudio);
         }
     }
 
     {
-        CriticalSectionScoped cs(_cbCrit.get());
+        rtc::CritScope cs(&_cbCrit);
         if(_mixReceiver != NULL) {
             const AudioFrame** dummy = NULL;
             _mixReceiver->NewMixedAudio(
                 _id,
                 *mixedAudio,
                 dummy,
                 0);
         }
     }
 
     // Reclaim all outstanding memory.
     _audioFramePool->PushMemory(mixedAudio);
     ClearAudioFrameList(&mixList);
     ClearAudioFrameList(&rampOutList);
     ClearAudioFrameList(&additionalFramesList);
     {
-        CriticalSectionScoped cs(_crit.get());
+        rtc::CritScope cs(&_crit);
         _processCalls--;
     }
     return;
 }
 
 int32_t AudioConferenceMixerImpl::RegisterMixedStreamCallback(
     AudioMixerOutputReceiver* mixReceiver) {
-    CriticalSectionScoped cs(_cbCrit.get());
+    rtc::CritScope cs(&_cbCrit);
     if(_mixReceiver != NULL) {
         return -1;
     }
     _mixReceiver = mixReceiver;
     return 0;
 }
 
 int32_t AudioConferenceMixerImpl::UnRegisterMixedStreamCallback() {
-    CriticalSectionScoped cs(_cbCrit.get());
+    rtc::CritScope cs(&_cbCrit);
     if(_mixReceiver == NULL) {
         return -1;
     }
     _mixReceiver = NULL;
     return 0;
 }
 
 int32_t AudioConferenceMixerImpl::SetOutputFrequency(
     const Frequency& frequency) {
-    CriticalSectionScoped cs(_crit.get());
+    rtc::CritScope cs(&_crit);
 
     _outputFrequency = frequency;
     _sampleSize =
         static_cast<size_t>((_outputFrequency*kProcessPeriodicityInMs) / 1000);
 
     return 0;
 }
 
 AudioConferenceMixer::Frequency
 AudioConferenceMixerImpl::OutputFrequency() const {
-    CriticalSectionScoped cs(_crit.get());
+    rtc::CritScope cs(&_crit);
     return _outputFrequency;
 }
 
 int32_t AudioConferenceMixerImpl::SetMixabilityStatus(
     MixerParticipant* participant, bool mixable) {
     if (!mixable) {
         // Anonymous participants are in a separate list. Make sure that the
         // participant is in the _participantList if it is being mixed.
         SetAnonymousMixabilityStatus(participant, false);
     }
     size_t numMixedParticipants;
     {
-        CriticalSectionScoped cs(_cbCrit.get());
+        rtc::CritScope cs(&_cbCrit);
         const bool isMixed =
             IsParticipantInList(*participant, _participantList);
         // API must be called with a new state.
         if(!(mixable ^ isMixed)) {
             WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                          "Mixable is aready %s",
                          isMixed ? "ON" : "off");
             return -1;
         }
         bool success = false;
@@ skipping 13 matching lines @@
         size_t numMixedNonAnonymous = _participantList.size();
         if (numMixedNonAnonymous > kMaximumAmountOfMixedParticipants) {
             numMixedNonAnonymous = kMaximumAmountOfMixedParticipants;
         }
         numMixedParticipants =
             numMixedNonAnonymous + _additionalParticipantList.size();
     }
     // A MixerParticipant was added or removed. Make sure the scratch
     // buffer is updated if necessary.
     // Note: The scratch buffer may only be updated in Process().
-    CriticalSectionScoped cs(_crit.get());
+    rtc::CritScope cs(&_crit);
     _numMixedParticipants = numMixedParticipants;
     return 0;
 }
 
 bool AudioConferenceMixerImpl::MixabilityStatus(
     const MixerParticipant& participant) const {
-    CriticalSectionScoped cs(_cbCrit.get());
+    rtc::CritScope cs(&_cbCrit);
     return IsParticipantInList(participant, _participantList);
 }
 
 int32_t AudioConferenceMixerImpl::SetAnonymousMixabilityStatus(
     MixerParticipant* participant, bool anonymous) {
-    CriticalSectionScoped cs(_cbCrit.get());
+    rtc::CritScope cs(&_cbCrit);
     if(IsParticipantInList(*participant, _additionalParticipantList)) {
         if(anonymous) {
             return 0;
         }
         if(!RemoveParticipantFromList(participant,
                                       &_additionalParticipantList)) {
             WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                          "unable to remove participant from anonymous list");
             assert(false);
             return -1;
@@ skipping 14 matching lines @@
         // Setting anonymous status is only possible if MixerParticipant is
         // already registered.
         return -1;
     }
     return AddParticipantToList(participant, &_additionalParticipantList) ?
         0 : -1;
 }
 
 bool AudioConferenceMixerImpl::AnonymousMixabilityStatus(
     const MixerParticipant& participant) const {
-    CriticalSectionScoped cs(_cbCrit.get());
+    rtc::CritScope cs(&_cbCrit);
     return IsParticipantInList(participant, _additionalParticipantList);
 }
 
 int32_t AudioConferenceMixerImpl::SetMinimumMixingFrequency(
     Frequency freq) {
     // Make sure that only allowed sampling frequencies are used. Use closest
     // higher sampling frequency to avoid losing information.
     if (static_cast<int>(freq) == 12000) {
          freq = kWbInHz;
     } else if (static_cast<int>(freq) == 24000) {
@@ skipping 290 matching lines @@
                  "UpdateMixedStatus(mixedParticipantsMap)");
     assert(mixedParticipantsMap.size() <= kMaximumAmountOfMixedParticipants);
 
     // Loop through all participants. If they are in the mix map they
     // were mixed.
     for (MixerParticipantList::const_iterator
         participant =_participantList.begin();
         participant != _participantList.end();
          ++participant) {
         bool isMixed = false;
-        for (std::map<int, MixerParticipant*>::const_iterator it =
-                 mixedParticipantsMap.begin();
+        for (auto it = mixedParticipantsMap.begin();
              it != mixedParticipantsMap.end();
              ++it) {
           if (it->second == *participant) {
             isMixed = true;
             break;
           }
         }
         (*participant)->_mixHistory->SetIsMixed(isMixed);
     }
 }
@@ skipping 139 matching lines @@
 
     if(error != _limiter->kNoError) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "Error from AudioProcessing: %d", error);
         assert(false);
         return false;
     }
     return true;
 }
 }  // namespace webrtc