Remove more CriticalSectionWrappers.

webrtc/modules/audio_device/win/audio_device_core_win.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 388 matching lines @@
 // ============================================================================
 //                            Construction & Destruction
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 //  AudioDeviceWindowsCore() - ctor
 // ----------------------------------------------------------------------------
 
 AudioDeviceWindowsCore::AudioDeviceWindowsCore(const int32_t id) :
     _comInit(ScopedCOMInitializer::kMTA),
-    _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
-    _volumeMutex(*CriticalSectionWrapper::CreateCriticalSection()),
     _id(id),
     _ptrAudioBuffer(NULL),
     _ptrEnumerator(NULL),
     _ptrRenderCollection(NULL),
     _ptrCaptureCollection(NULL),
     _ptrDeviceOut(NULL),
     _ptrDeviceIn(NULL),
     _ptrClientOut(NULL),
     _ptrClientIn(NULL),
     _ptrRenderClient(NULL),
@@ skipping 210 matching lines @@
         {
             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "AudioDeviceWindowsCore::~AudioDeviceWindowsCore() failed to free the loaded Avrt DLL module correctly");
         }
         else
         {
             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "AudioDeviceWindowsCore::~AudioDeviceWindowsCore() the Avrt DLL module is now unloaded");
         }
     }
-
-    delete &_critSect;
-    delete &_volumeMutex;
 }
 
 // ============================================================================
 //                                     API
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 //  AttachAudioBuffer
 // ----------------------------------------------------------------------------
 
@@ skipping 19 matching lines @@
 {
     audioLayer = AudioDeviceModule::kWindowsCoreAudio;
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  Init
 // ----------------------------------------------------------------------------
 
 AudioDeviceGeneric::InitStatus AudioDeviceWindowsCore::Init() {
-  CriticalSectionScoped lock(&_critSect);
+  rtc::CritScope lock(&_critSect);
 
   if (_initialized) {
     return InitStatus::OK;
   }
 
   _playWarning = 0;
   _playError = 0;
   _recWarning = 0;
   _recError = 0;
 
   // Enumerate all audio rendering and capturing endpoint devices.
   // Note that, some of these will not be able to select by the user.
   // The complete collection is for internal use only.
   _EnumerateEndpointDevicesAll(eRender);
   _EnumerateEndpointDevicesAll(eCapture);
 
   _initialized = true;
 
   return InitStatus::OK;
 }
 
 // ----------------------------------------------------------------------------
 //  Terminate
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::Terminate()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (!_initialized) {
         return 0;
     }
 
     _initialized = false;
     _speakerIsInitialized = false;
     _microphoneIsInitialized = false;
     _playing = false;
     _recording = false;
@@ skipping 21 matching lines @@
     return (_initialized);
 }
 
 // ----------------------------------------------------------------------------
 //  InitSpeaker
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::InitSpeaker()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_playing)
     {
         return -1;
     }
 
     if (_ptrDeviceOut == NULL)
     {
         return -1;
     }
@@ skipping 61 matching lines @@
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  InitMicrophone
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::InitMicrophone()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_recording)
     {
         return -1;
     }
 
     if (_ptrDeviceIn == NULL)
     {
         return -1;
     }
@@ skipping 69 matching lines @@
     return (_microphoneIsInitialized);
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerVolumeIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SpeakerVolumeIsAvailable(bool& available)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_ptrDeviceOut == NULL)
     {
         return -1;
     }
 
     HRESULT hr = S_OK;
     IAudioSessionManager* pManager = NULL;
     ISimpleAudioVolume* pVolume = NULL;
 
@@ skipping 24 matching lines @@
 }
 
 // ----------------------------------------------------------------------------
 //  SetSpeakerVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SetSpeakerVolume(uint32_t volume)
 {
 
     {
-        CriticalSectionScoped lock(&_critSect);
+        rtc::CritScope lock(&_critSect);
 
         if (!_speakerIsInitialized)
         {
         return -1;
         }
 
         if (_ptrDeviceOut == NULL)
         {
             return -1;
         }
@@ skipping 22 matching lines @@
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SpeakerVolume(uint32_t& volume) const
 {
 
     {
-        CriticalSectionScoped lock(&_critSect);
+        rtc::CritScope lock(&_critSect);
 
         if (!_speakerIsInitialized)
         {
             return -1;
         }
 
         if (_ptrDeviceOut == NULL)
         {
             return -1;
         }
@@ skipping 91 matching lines @@
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerMuteIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SpeakerMuteIsAvailable(bool& available)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_ptrDeviceOut == NULL)
     {
         return -1;
     }
 
     HRESULT hr = S_OK;
     IAudioEndpointVolume* pVolume = NULL;
 
     // Query the speaker system mute state.
@@ skipping 18 matching lines @@
     return -1;
 }
 
 // ----------------------------------------------------------------------------
 //  SetSpeakerMute
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SetSpeakerMute(bool enable)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (!_speakerIsInitialized)
     {
         return -1;
     }
 
     if (_ptrDeviceOut == NULL)
     {
         return -1;
     }
@@ skipping 59 matching lines @@
     return -1;
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneMuteIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::MicrophoneMuteIsAvailable(bool& available)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_ptrDeviceIn == NULL)
     {
         return -1;
     }
 
     HRESULT hr = S_OK;
     IAudioEndpointVolume* pVolume = NULL;
 
     // Query the microphone system mute state.
@@ skipping 139 matching lines @@
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  SetStereoRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SetStereoRecording(bool enable)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (enable)
     {
         _recChannelsPrioList[0] = 2;    // try stereo first
         _recChannelsPrioList[1] = 1;
         _recChannels = 2;
     }
     else
     {
         _recChannelsPrioList[0] = 1;    // try mono first
@@ skipping 30 matching lines @@
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  SetStereoPlayout
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SetStereoPlayout(bool enable)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (enable)
     {
         _playChannelsPrioList[0] = 2;    // try stereo first
         _playChannelsPrioList[1] = 1;
         _playChannels = 2;
     }
     else
     {
         _playChannelsPrioList[0] = 1;    // try mono first
@@ skipping 18 matching lines @@
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  SetAGC
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SetAGC(bool enable)
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     _AGC = enable;
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  AGC
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceWindowsCore::AGC() const
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     return _AGC;
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneVolumeIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::MicrophoneVolumeIsAvailable(bool& available)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_ptrDeviceIn == NULL)
     {
         return -1;
     }
 
     HRESULT hr = S_OK;
     IAudioEndpointVolume* pVolume = NULL;
 
     hr = _ptrDeviceIn->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&pVolume));
@@ skipping 18 matching lines @@
 
 // ----------------------------------------------------------------------------
 //  SetMicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SetMicrophoneVolume(uint32_t volume)
 {
     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "AudioDeviceWindowsCore::SetMicrophoneVolume(volume=%u)", volume);
 
     {
-        CriticalSectionScoped lock(&_critSect);
+        rtc::CritScope lock(&_critSect);
 
         if (!_microphoneIsInitialized)
         {
             return -1;
         }
 
         if (_ptrDeviceIn == NULL)
         {
             return -1;
         }
@@ skipping 20 matching lines @@
     return -1;
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::MicrophoneVolume(uint32_t& volume) const
 {
     {
-        CriticalSectionScoped lock(&_critSect);
+        rtc::CritScope lock(&_critSect);
 
         if (!_microphoneIsInitialized)
         {
             return -1;
         }
 
         if (_ptrDeviceIn == NULL)
         {
             return -1;
         }
@@ skipping 74 matching lines @@
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  PlayoutDevices
 // ----------------------------------------------------------------------------
 
 int16_t AudioDeviceWindowsCore::PlayoutDevices()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_RefreshDeviceList(eRender) != -1)
     {
         return (_DeviceListCount(eRender));
     }
 
     return -1;
 }
 
 // ----------------------------------------------------------------------------
@@ skipping 10 matching lines @@
 
     // Get current number of available rendering endpoint devices and refresh the rendering collection.
     UINT nDevices = PlayoutDevices();
 
     if (index < 0 || index > (nDevices-1))
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "device index is out of range [0,%u]", (nDevices-1));
         return -1;
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     HRESULT hr(S_OK);
 
     assert(_ptrRenderCollection != NULL);
 
     //  Select an endpoint rendering device given the specified index
     SAFE_RELEASE(_ptrDeviceOut);
     hr = _ptrRenderCollection->Item(
                                  index,
                                  &_ptrDeviceOut);
@@ skipping 34 matching lines @@
 
     if (device == AudioDeviceModule::kDefaultDevice)
     {
         role = eConsole;
     }
     else if (device == AudioDeviceModule::kDefaultCommunicationDevice)
     {
         role = eCommunications;
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     // Refresh the list of rendering endpoint devices
     _RefreshDeviceList(eRender);
 
     HRESULT hr(S_OK);
 
     assert(_ptrEnumerator != NULL);
 
     //  Select an endpoint rendering device given the specified role
     SAFE_RELEASE(_ptrDeviceOut);
@@ skipping 49 matching lines @@
         return -1;
     }
 
     memset(name, 0, kAdmMaxDeviceNameSize);
 
     if (guid != NULL)
     {
         memset(guid, 0, kAdmMaxGuidSize);
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     int32_t ret(-1);
     WCHAR szDeviceName[MAX_PATH];
     const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0];
 
     // Get the endpoint device's friendly-name
     if (defaultCommunicationDevice)
     {
         ret = _GetDefaultDeviceName(eRender, eCommunications, szDeviceName, bufferLen);
     }
@@ skipping 59 matching lines @@
         return -1;
     }
 
     memset(name, 0, kAdmMaxDeviceNameSize);
 
     if (guid != NULL)
     {
         memset(guid, 0, kAdmMaxGuidSize);
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     int32_t ret(-1);
     WCHAR szDeviceName[MAX_PATH];
     const int bufferLen = sizeof(szDeviceName)/sizeof(szDeviceName)[0];
 
     // Get the endpoint device's friendly-name
     if (defaultCommunicationDevice)
     {
         ret = _GetDefaultDeviceName(eCapture, eCommunications, szDeviceName, bufferLen);
     }
@@ skipping 33 matching lines @@
     return ret;
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDevices
 // ----------------------------------------------------------------------------
 
 int16_t AudioDeviceWindowsCore::RecordingDevices()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_RefreshDeviceList(eCapture) != -1)
     {
         return (_DeviceListCount(eCapture));
     }
 
     return -1;
 }
 
 // ----------------------------------------------------------------------------
@@ skipping 10 matching lines @@
 
     // Get current number of available capture endpoint devices and refresh the capture collection.
     UINT nDevices = RecordingDevices();
 
     if (index < 0 || index > (nDevices-1))
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "device index is out of range [0,%u]", (nDevices-1));
         return -1;
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     HRESULT hr(S_OK);
 
     assert(_ptrCaptureCollection != NULL);
 
     // Select an endpoint capture device given the specified index
     SAFE_RELEASE(_ptrDeviceIn);
     hr = _ptrCaptureCollection->Item(
                                  index,
                                  &_ptrDeviceIn);
@@ skipping 34 matching lines @@
 
     if (device == AudioDeviceModule::kDefaultDevice)
     {
         role = eConsole;
     }
     else if (device == AudioDeviceModule::kDefaultCommunicationDevice)
     {
         role = eCommunications;
     }
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     // Refresh the list of capture endpoint devices
     _RefreshDeviceList(eCapture);
 
     HRESULT hr(S_OK);
 
     assert(_ptrEnumerator != NULL);
 
     //  Select an endpoint capture device given the specified role
     SAFE_RELEASE(_ptrDeviceIn);
@@ skipping 69 matching lines @@
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  InitPlayout
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::InitPlayout()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_playing)
     {
         return -1;
     }
 
     if (_playIsInitialized)
     {
         return 0;
     }
@@ skipping 319 matching lines @@
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  InitRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::InitRecording()
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     if (_recording)
     {
         return -1;
     }
 
     if (_recIsInitialized)
     {
         return 0;
     }
@@ skipping 230 matching lines @@
     {
         return 0;
     }
 
     if (_recording)
     {
         return 0;
     }
 
     {
-        CriticalSectionScoped critScoped(&_critSect);
+        rtc::CritScope critScoped(&_critSect);
 
         // Create thread which will drive the capturing
         LPTHREAD_START_ROUTINE lpStartAddress = WSAPICaptureThread;
         if (_builtInAecEnabled)
         {
             // Redirect to the DMO polling method.
             lpStartAddress = WSAPICaptureThreadPollDMO;
 
             if (!_playing)
             {
@@ skipping 229 matching lines @@
     {
         return 0;
     }
 
     if (_playing)
     {
         return 0;
     }
 
     {
-        CriticalSectionScoped critScoped(&_critSect);
+        rtc::CritScope critScoped(&_critSect);
 
         // Create thread which will drive the rendering.
         assert(_hPlayThread == NULL);
         _hPlayThread = CreateThread(
                          NULL,
                          0,
                          WSAPIRenderThread,
                          this,
                          0,
                          NULL);
@@ skipping 29 matching lines @@
 
 int32_t AudioDeviceWindowsCore::StopPlayout()
 {
 
     if (!_playIsInitialized)
     {
         return 0;
     }
 
     {
-        CriticalSectionScoped critScoped(&_critSect) ;
+        rtc::CritScope critScoped(&_critSect) ;
 
         if (_hPlayThread == NULL)
         {
             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                 "no rendering stream is active => close down WASAPI only");
             SAFE_RELEASE(_ptrClientOut);
             SAFE_RELEASE(_ptrRenderClient);
             _playIsInitialized = false;
             _playing = false;
             return 0;
@@ skipping 12 matching lines @@
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
             "failed to close down webrtc_core_audio_render_thread");
         CloseHandle(_hPlayThread);
         _hPlayThread = NULL;
         _playIsInitialized = false;
         _playing = false;
         return -1;
     }
 
     {
-        CriticalSectionScoped critScoped(&_critSect);
+        rtc::CritScope critScoped(&_critSect);
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
             "webrtc_core_audio_render_thread is now closed");
 
         // to reset this event manually at each time we finish with it,
         // in case that the render thread has exited before StopPlayout(),
         // this event might be caught by the new render thread within same VoE instance.
         ResetEvent(_hShutdownRenderEvent);
 
         SAFE_RELEASE(_ptrClientOut);
         SAFE_RELEASE(_ptrRenderClient);
@@ skipping 23 matching lines @@
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  PlayoutDelay
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::PlayoutDelay(uint16_t& delayMS) const
 {
-    CriticalSectionScoped critScoped(&_critSect);
+    rtc::CritScope critScoped(&_critSect);
     delayMS = static_cast<uint16_t>(_sndCardPlayDelay);
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDelay
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::RecordingDelay(uint16_t& delayMS) const
 {
-    CriticalSectionScoped critScoped(&_critSect);
+    rtc::CritScope critScoped(&_critSect);
     delayMS = static_cast<uint16_t>(_sndCardRecDelay);
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  Playing
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceWindowsCore::Playing() const
 {
     return (_playing);
 }
 // ----------------------------------------------------------------------------
 //  SetPlayoutBuffer
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::SetPlayoutBuffer(const AudioDeviceModule::BufferType type, uint16_t sizeMS)
 {
 
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
 
     _playBufType = type;
 
     if (type == AudioDeviceModule::kFixedBufferSize)
     {
         _playBufDelayFixed = sizeMS;
     }
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  PlayoutBuffer
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsCore::PlayoutBuffer(AudioDeviceModule::BufferType& type, uint16_t& sizeMS) const
 {
-    CriticalSectionScoped lock(&_critSect);
+    rtc::CritScope lock(&_critSect);
     type = _playBufType;
 
     if (type == AudioDeviceModule::kFixedBufferSize)
     {
         sizeMS = _playBufDelayFixed;
     }
     else
     {
         // Use same value as for PlayoutDelay
         sizeMS = static_cast<uint16_t>(_sndCardPlayDelay);
@@ skipping 580 matching lines @@
         default:                    // unexpected error
             WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
                 "Unknown wait termination on capture side");
             hr = -1; // To signal an error callback.
             keepRecording = false;
             break;
         }
 
         while (keepRecording)
         {
-            CriticalSectionScoped critScoped(&_critSect);
+            rtc::CritScope critScoped(&_critSect);
 
             DWORD dwStatus = 0;
             {
                 DMO_OUTPUT_DATA_BUFFER dmoBuffer = {0};
                 dmoBuffer.pBuffer = _mediaBuffer;
                 dmoBuffer.pBuffer->AddRef();
 
                 // Poll the DMO for AEC processed capture data. The DMO will
                 // copy available data to |dmoBuffer|, and should only return
                 // 10 ms frames. The value of |dwStatus| should be ignored.
@@ skipping 1322 matching lines @@
   int key_down = 0;
   for (int key = VK_SPACE; key < VK_NUMLOCK; key++) {
     short res = GetAsyncKeyState(key);
     key_down |= res & 0x1; // Get the LSB
   }
   return (key_down > 0);
 }
 }  // namespace webrtc
 
 #endif  // WEBRTC_WINDOWS_CORE_AUDIO_BUILD