Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_device/win/audio_device_wave_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 27 matching lines @@
 namespace webrtc {
 
 // ============================================================================
 //                            Construction & Destruction
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 //  AudioDeviceWindowsWave - ctor
 // ----------------------------------------------------------------------------
 
-AudioDeviceWindowsWave::AudioDeviceWindowsWave(const int32_t id) :
-    _ptrAudioBuffer(NULL),
-    _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
-    _timeEvent(*EventTimerWrapper::Create()),
-    _recStartEvent(*EventWrapper::Create()),
-    _playStartEvent(*EventWrapper::Create()),
-    _hGetCaptureVolumeThread(NULL),
-    _hShutdownGetVolumeEvent(NULL),
-    _hSetCaptureVolumeThread(NULL),
-    _hShutdownSetVolumeEvent(NULL),
-    _hSetCaptureVolumeEvent(NULL),
-    _critSectCb(*CriticalSectionWrapper::CreateCriticalSection()),
-    _id(id),
-    _mixerManager(id),
-    _usingInputDeviceIndex(false),
-    _usingOutputDeviceIndex(false),
-    _inputDevice(AudioDeviceModule::kDefaultDevice),
-    _outputDevice(AudioDeviceModule::kDefaultDevice),
-    _inputDeviceIndex(0),
-    _outputDeviceIndex(0),
-    _inputDeviceIsSpecified(false),
-    _outputDeviceIsSpecified(false),
-    _initialized(false),
-    _recIsInitialized(false),
-    _playIsInitialized(false),
-    _recording(false),
-    _playing(false),
-    _startRec(false),
-    _stopRec(false),
-    _startPlay(false),
-    _stopPlay(false),
-    _AGC(false),
-    _hWaveIn(NULL),
-    _hWaveOut(NULL),
-    _recChannels(N_REC_CHANNELS),
-    _playChannels(N_PLAY_CHANNELS),
-    _recBufCount(0),
-    _recPutBackDelay(0),
-    _recDelayCount(0),
-    _playBufCount(0),
-    _prevPlayTime(0),
-    _prevRecTime(0),
-    _prevTimerCheckTime(0),
-    _timesdwBytes(0),
-    _timerFaults(0),
-    _timerRestartAttempts(0),
-    _no_of_msecleft_warnings(0),
-    _MAX_minBuffer(65),
-    _useHeader(0),
-    _dTcheckPlayBufDelay(10),
-    _playBufDelay(80),
-    _playBufDelayFixed(80),
-    _minPlayBufDelay(20),
-    _avgCPULoad(0),
-    _sndCardPlayDelay(0),
-    _sndCardRecDelay(0),
-    _plSampOld(0),
-    _rcSampOld(0),
-    _playBufType(AudioDeviceModule::kAdaptiveBufferSize),
-    _recordedBytes(0),
-    _playWarning(0),
-    _playError(0),
-    _recWarning(0),
-    _recError(0),
-    _newMicLevel(0),
-    _minMicVolume(0),
-    _maxMicVolume(0)
-{
-    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__);
+AudioDeviceWindowsWave::AudioDeviceWindowsWave(const int32_t id)
+    : _ptrAudioBuffer(nullptr),
+      _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
+      _timeEvent(*EventTimerWrapper::Create()),
+      _recStartEvent(*EventWrapper::Create()),
+      _playStartEvent(*EventWrapper::Create()),
+      _hGetCaptureVolumeThread(nullptr),
+      _hShutdownGetVolumeEvent(nullptr),
+      _hSetCaptureVolumeThread(nullptr),
+      _hShutdownSetVolumeEvent(nullptr),
+      _hSetCaptureVolumeEvent(nullptr),
+      _critSectCb(*CriticalSectionWrapper::CreateCriticalSection()),
+      _id(id),
+      _mixerManager(id),
+      _usingInputDeviceIndex(false),
+      _usingOutputDeviceIndex(false),
+      _inputDevice(AudioDeviceModule::kDefaultDevice),
+      _outputDevice(AudioDeviceModule::kDefaultDevice),
+      _inputDeviceIndex(0),
+      _outputDeviceIndex(0),
+      _inputDeviceIsSpecified(false),
+      _outputDeviceIsSpecified(false),
+      _initialized(false),
+      _recIsInitialized(false),
+      _playIsInitialized(false),
+      _recording(false),
+      _playing(false),
+      _startRec(false),
+      _stopRec(false),
+      _startPlay(false),
+      _stopPlay(false),
+      _AGC(false),
+      _hWaveIn(nullptr),
+      _hWaveOut(nullptr),
+      _recChannels(N_REC_CHANNELS),
+      _playChannels(N_PLAY_CHANNELS),
+      _recBufCount(0),
+      _recPutBackDelay(0),
+      _recDelayCount(0),
+      _playBufCount(0),
+      _prevPlayTime(0),
+      _prevRecTime(0),
+      _prevTimerCheckTime(0),
+      _timesdwBytes(0),
+      _timerFaults(0),
+      _timerRestartAttempts(0),
+      _no_of_msecleft_warnings(0),
+      _MAX_minBuffer(65),
+      _useHeader(0),
+      _dTcheckPlayBufDelay(10),
+      _playBufDelay(80),
+      _playBufDelayFixed(80),
+      _minPlayBufDelay(20),
+      _avgCPULoad(0),
+      _sndCardPlayDelay(0),
+      _sndCardRecDelay(0),
+      _plSampOld(0),
+      _rcSampOld(0),
+      _playBufType(AudioDeviceModule::kAdaptiveBufferSize),
+      _recordedBytes(0),
+      _playWarning(0),
+      _playError(0),
+      _recWarning(0),
+      _recError(0),
+      _newMicLevel(0),
+      _minMicVolume(0),
+      _maxMicVolume(0) {
+  WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, id, "%s created", __FUNCTION__);
 
-    // Initialize value, set to 0 if it fails
-    if (!QueryPerformanceFrequency(&_perfFreq))
-    {
-        _perfFreq.QuadPart = 0;
-    }
+  // Initialize value, set to 0 if it fails
+  if (!QueryPerformanceFrequency(&_perfFreq)) {
+    _perfFreq.QuadPart = 0;
+  }
 
-    _hShutdownGetVolumeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
-    _hShutdownSetVolumeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
-    _hSetCaptureVolumeEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+  _hShutdownGetVolumeEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+  _hShutdownSetVolumeEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
+  _hSetCaptureVolumeEvent = CreateEvent(nullptr, FALSE, FALSE, nullptr);
 }
 
 // ----------------------------------------------------------------------------
 //  AudioDeviceWindowsWave - dtor
 // ----------------------------------------------------------------------------
 
 AudioDeviceWindowsWave::~AudioDeviceWindowsWave()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s destroyed", __FUNCTION__);
 
     Terminate();
 
     delete &_recStartEvent;
     delete &_playStartEvent;
     delete &_timeEvent;
     delete &_critSect;
     delete &_critSectCb;
 
-    if (NULL != _hShutdownGetVolumeEvent)
-    {
-        CloseHandle(_hShutdownGetVolumeEvent);
-        _hShutdownGetVolumeEvent = NULL;
+    if (nullptr != _hShutdownGetVolumeEvent) {
+      CloseHandle(_hShutdownGetVolumeEvent);
+      _hShutdownGetVolumeEvent = nullptr;
     }
 
-    if (NULL != _hShutdownSetVolumeEvent)
-    {
-        CloseHandle(_hShutdownSetVolumeEvent);
-        _hShutdownSetVolumeEvent = NULL;
+    if (nullptr != _hShutdownSetVolumeEvent) {
+      CloseHandle(_hShutdownSetVolumeEvent);
+      _hShutdownSetVolumeEvent = nullptr;
     }
 
-    if (NULL != _hSetCaptureVolumeEvent)
-    {
-        CloseHandle(_hSetCaptureVolumeEvent);
-        _hSetCaptureVolumeEvent = NULL;
+    if (nullptr != _hSetCaptureVolumeEvent) {
+      CloseHandle(_hSetCaptureVolumeEvent);
+      _hSetCaptureVolumeEvent = nullptr;
     }
 }
 
 // ============================================================================
 //                                     API
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 //  AttachAudioBuffer
 // ----------------------------------------------------------------------------
@@ skipping 62 matching lines @@
   if (!_timeEvent.StartTimer(periodic, TIMER_PERIOD_MS)) {
     LOG(LS_ERROR) << "failed to start the timer event";
     _ptrThread->Stop();
     _ptrThread.reset();
     return InitStatus::OTHER_ERROR;
   }
   WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
                "periodic timer (dT=%d) is now active", TIMER_PERIOD_MS);
 
   _hGetCaptureVolumeThread =
-      CreateThread(NULL, 0, GetCaptureVolumeThread, this, 0, NULL);
-  if (_hGetCaptureVolumeThread == NULL) {
+      CreateThread(nullptr, 0, GetCaptureVolumeThread, this, 0, nullptr);
+  if (_hGetCaptureVolumeThread == nullptr) {
     LOG(LS_ERROR) << "  failed to create the volume getter thread";
     return InitStatus::OTHER_ERROR;
   }
 
   SetThreadPriority(_hGetCaptureVolumeThread, THREAD_PRIORITY_NORMAL);
 
   _hSetCaptureVolumeThread =
-      CreateThread(NULL, 0, SetCaptureVolumeThread, this, 0, NULL);
-  if (_hSetCaptureVolumeThread == NULL) {
+      CreateThread(nullptr, 0, SetCaptureVolumeThread, this, 0, nullptr);
+  if (_hSetCaptureVolumeThread == nullptr) {
     LOG(LS_ERROR) << "  failed to create the volume setter thread";
     return InitStatus::OTHER_ERROR;
   }
 
   SetThreadPriority(_hSetCaptureVolumeThread, THREAD_PRIORITY_NORMAL);
 
   _initialized = true;
 
   return InitStatus::OK;
 }
@@ skipping 32 matching lines @@
     _critSect.Enter();
     SetEvent(_hShutdownGetVolumeEvent);
     _critSect.Leave();
     int32_t ret = WaitForSingleObject(_hGetCaptureVolumeThread, 2000);
     if (ret != WAIT_OBJECT_0)
     {
         // the thread did not stop as it should
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
             "  failed to close down volume getter thread");
         CloseHandle(_hGetCaptureVolumeThread);
-        _hGetCaptureVolumeThread = NULL;
+        _hGetCaptureVolumeThread = nullptr;
         return -1;
     }
     _critSect.Enter();
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
         "  volume getter thread is now closed");
 
     SetEvent(_hShutdownSetVolumeEvent);
     _critSect.Leave();
     ret = WaitForSingleObject(_hSetCaptureVolumeThread, 2000);
     if (ret != WAIT_OBJECT_0)
     {
         // the thread did not stop as it should
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
             "  failed to close down volume setter thread");
         CloseHandle(_hSetCaptureVolumeThread);
-        _hSetCaptureVolumeThread = NULL;
+        _hSetCaptureVolumeThread = nullptr;
         return -1;
     }
     _critSect.Enter();
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
         "  volume setter thread is now closed");
 
     CloseHandle(_hGetCaptureVolumeThread);
-    _hGetCaptureVolumeThread = NULL;
+    _hGetCaptureVolumeThread = nullptr;
 
     CloseHandle(_hSetCaptureVolumeThread);
-    _hSetCaptureVolumeThread = NULL;
+    _hSetCaptureVolumeThread = nullptr;
 
     _critSect.Leave();
 
     _timeEvent.StopTimer();
 
     _initialized = false;
     _outputDeviceIsSpecified = false;
     _inputDeviceIsSpecified = false;
 
     return 0;
@@ skipping 275 matching lines @@
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::SetWaveOutVolume(uint16_t volumeLeft, uint16_t volumeRight)
 {
 
     MMRESULT res(0);
     WAVEOUTCAPS caps;
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_hWaveOut == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no open playout device exists => using default");
+    if (_hWaveOut == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no open playout device exists => using default");
     }
 
     // To determine whether the device supports volume control on both
     // the left and right channels, use the WAVECAPS_LRVOLUME flag.
     //
     res = waveOutGetDevCaps((UINT_PTR)_hWaveOut, &caps, sizeof(WAVEOUTCAPS));
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetDevCaps() failed (err=%d)", res);
         TraceWaveOutError(res);
@@ skipping 41 matching lines @@
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::WaveOutVolume(uint16_t& volumeLeft, uint16_t& volumeRight) const
 {
 
     MMRESULT res(0);
     WAVEOUTCAPS caps;
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_hWaveOut == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no open playout device exists => using default");
+    if (_hWaveOut == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no open playout device exists => using default");
     }
 
     // To determine whether the device supports volume control on both
     // the left and right channels, use the WAVECAPS_LRVOLUME flag.
     //
     res = waveOutGetDevCaps((UINT_PTR)_hWaveOut, &caps, sizeof(WAVEOUTCAPS));
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetDevCaps() failed (err=%d)", res);
         TraceWaveOutError(res);
@@ skipping 565 matching lines @@
 
     uint16_t nDevices(PlayoutDevices());
 
     // Special fix for the case when the user asks for the name of the default device.
     //
     if (index == (uint16_t)(-1))
     {
         index = 0;
     }
 
-    if ((index > (nDevices-1)) || (name == NULL))
-    {
-        return -1;
+    if ((index > (nDevices - 1)) || (name == nullptr)) {
+      return -1;
     }
 
     memset(name, 0, kAdmMaxDeviceNameSize);
 
-    if (guid != NULL)
-    {
-        memset(guid, 0, kAdmMaxGuidSize);
+    if (guid != nullptr) {
+      memset(guid, 0, kAdmMaxGuidSize);
     }
 
-    WAVEOUTCAPSW caps;    // szPname member (product name (NULL terminated) is a WCHAR
+    WAVEOUTCAPSW
+    caps;  // szPname member (product name (nullptr terminated) is a WCHAR
     MMRESULT res;
 
     res = waveOutGetDevCapsW(index, &caps, sizeof(WAVEOUTCAPSW));
     if (res != MMSYSERR_NOERROR)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutGetDevCapsW() failed (err=%d)", res);
         return -1;
     }
-    if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, name, kAdmMaxDeviceNameSize, NULL, NULL) == 0)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 1", GetLastError());
+    if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, name,
+                            kAdmMaxDeviceNameSize, nullptr, nullptr) == 0) {
+      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                   "WideCharToMultiByte(CP_UTF8) failed with error code %d - 1",
+                   GetLastError());
     }
 
-    if (guid == NULL)
-    {
-        return 0;
+    if (guid == nullptr) {
+      return 0;
     }
 
     // It is possible to get the unique endpoint ID string using the Wave API.
     // However, it is only supported on Windows Vista and Windows 7.
 
     size_t cbEndpointId(0);
 
     // Get the size (including the terminating null) of the endpoint ID string of the waveOut device.
     // Windows Vista supports the DRV_QUERYFUNCTIONINSTANCEIDSIZE and DRV_QUERYFUNCTIONINSTANCEID messages.
     res = waveOutMessage((HWAVEOUT)IntToPtr(index),
-                          DRV_QUERYFUNCTIONINSTANCEIDSIZE,
+                         DRV_QUERYFUNCTIONINSTANCEIDSIZE,
                          (DWORD_PTR)&cbEndpointId, NULL);
     if (res != MMSYSERR_NOERROR)
     {
         // DRV_QUERYFUNCTIONINSTANCEIDSIZE is not supported <=> earlier version of Windows than Vista
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveOutMessage(DRV_QUERYFUNCTIONINSTANCEIDSIZE) failed (err=%d)", res);
         TraceWaveOutError(res);
         // Best we can do is to copy the friendly name and use it as guid
-        if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 2", GetLastError());
+        if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid,
+                                kAdmMaxGuidSize, nullptr, nullptr) == 0) {
+          WEBRTC_TRACE(
+              kTraceError, kTraceAudioDevice, _id,
+              "WideCharToMultiByte(CP_UTF8) failed with error code %d - 2",
+              GetLastError());
         }
         return 0;
     }
 
     // waveOutMessage(DRV_QUERYFUNCTIONINSTANCEIDSIZE) worked => we are on a Vista or Windows 7 device
 
-    WCHAR *pstrEndpointId = NULL;
+    WCHAR* pstrEndpointId = nullptr;
     pstrEndpointId = (WCHAR*)CoTaskMemAlloc(cbEndpointId);
 
     // Get the endpoint ID string for this waveOut device.
     res = waveOutMessage((HWAVEOUT)IntToPtr(index),
                           DRV_QUERYFUNCTIONINSTANCEID,
                          (DWORD_PTR)pstrEndpointId,
                           cbEndpointId);
     if (res != MMSYSERR_NOERROR)
     {
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveOutMessage(DRV_QUERYFUNCTIONINSTANCEID) failed (err=%d)", res);
         TraceWaveOutError(res);
         // Best we can do is to copy the friendly name and use it as guid
-        if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 3", GetLastError());
+        if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid,
+                                kAdmMaxGuidSize, nullptr, nullptr) == 0) {
+          WEBRTC_TRACE(
+              kTraceError, kTraceAudioDevice, _id,
+              "WideCharToMultiByte(CP_UTF8) failed with error code %d - 3",
+              GetLastError());
         }
         CoTaskMemFree(pstrEndpointId);
         return 0;
     }
 
-    if (WideCharToMultiByte(CP_UTF8, 0, pstrEndpointId, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 4", GetLastError());
+    if (WideCharToMultiByte(CP_UTF8, 0, pstrEndpointId, -1, guid,
+                            kAdmMaxGuidSize, nullptr, nullptr) == 0) {
+      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                   "WideCharToMultiByte(CP_UTF8) failed with error code %d - 4",
+                   GetLastError());
     }
     CoTaskMemFree(pstrEndpointId);
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDeviceName
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::RecordingDeviceName(
     uint16_t index,
     char name[kAdmMaxDeviceNameSize],
     char guid[kAdmMaxGuidSize])
 {
 
     uint16_t nDevices(RecordingDevices());
 
     // Special fix for the case when the user asks for the name of the default device.
     //
     if (index == (uint16_t)(-1))
     {
         index = 0;
     }
 
-    if ((index > (nDevices-1)) || (name == NULL))
-    {
-        return -1;
+    if ((index > (nDevices - 1)) || (name == nullptr)) {
+      return -1;
     }
 
     memset(name, 0, kAdmMaxDeviceNameSize);
 
-    if (guid != NULL)
-    {
-        memset(guid, 0, kAdmMaxGuidSize);
+    if (guid != nullptr) {
+      memset(guid, 0, kAdmMaxGuidSize);
     }
 
-    WAVEINCAPSW caps;    // szPname member (product name (NULL terminated) is a WCHAR
+    WAVEINCAPSW
+    caps;  // szPname member (product name (nullptr terminated) is a WCHAR
     MMRESULT res;
 
     res = waveInGetDevCapsW(index, &caps, sizeof(WAVEINCAPSW));
     if (res != MMSYSERR_NOERROR)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInGetDevCapsW() failed (err=%d)", res);
         return -1;
     }
-    if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, name, kAdmMaxDeviceNameSize, NULL, NULL) == 0)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 1", GetLastError());
+    if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, name,
+                            kAdmMaxDeviceNameSize, nullptr, nullptr) == 0) {
+      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                   "WideCharToMultiByte(CP_UTF8) failed with error code %d - 1",
+                   GetLastError());
     }
 
-    if (guid == NULL)
-    {
-        return 0;
+    if (guid == nullptr) {
+      return 0;
     }
 
     // It is possible to get the unique endpoint ID string using the Wave API.
     // However, it is only supported on Windows Vista and Windows 7.
 
     size_t cbEndpointId(0);
 
     // Get the size (including the terminating null) of the endpoint ID string of the waveOut device.
     // Windows Vista supports the DRV_QUERYFUNCTIONINSTANCEIDSIZE and DRV_QUERYFUNCTIONINSTANCEID messages.
-    res = waveInMessage((HWAVEIN)IntToPtr(index),
-                         DRV_QUERYFUNCTIONINSTANCEIDSIZE,
-                        (DWORD_PTR)&cbEndpointId, NULL);
+    res =
+        waveInMessage((HWAVEIN)IntToPtr(index), DRV_QUERYFUNCTIONINSTANCEIDSIZE,
+                      (DWORD_PTR)&cbEndpointId, NULL);
     if (res != MMSYSERR_NOERROR)
     {
         // DRV_QUERYFUNCTIONINSTANCEIDSIZE is not supported <=> earlier version of Windows than Vista
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveInMessage(DRV_QUERYFUNCTIONINSTANCEIDSIZE) failed (err=%d)", res);
         TraceWaveInError(res);
         // Best we can do is to copy the friendly name and use it as guid
-        if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 2", GetLastError());
+        if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid,
+                                kAdmMaxGuidSize, nullptr, nullptr) == 0) {
+          WEBRTC_TRACE(
+              kTraceError, kTraceAudioDevice, _id,
+              "WideCharToMultiByte(CP_UTF8) failed with error code %d - 2",
+              GetLastError());
         }
         return 0;
     }
 
     // waveOutMessage(DRV_QUERYFUNCTIONINSTANCEIDSIZE) worked => we are on a Vista or Windows 7 device
 
-    WCHAR *pstrEndpointId = NULL;
+    WCHAR* pstrEndpointId = nullptr;
     pstrEndpointId = (WCHAR*)CoTaskMemAlloc(cbEndpointId);
 
     // Get the endpoint ID string for this waveOut device.
     res = waveInMessage((HWAVEIN)IntToPtr(index),
                           DRV_QUERYFUNCTIONINSTANCEID,
                          (DWORD_PTR)pstrEndpointId,
                           cbEndpointId);
     if (res != MMSYSERR_NOERROR)
     {
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "waveInMessage(DRV_QUERYFUNCTIONINSTANCEID) failed (err=%d)", res);
         TraceWaveInError(res);
         // Best we can do is to copy the friendly name and use it as guid
-        if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 3", GetLastError());
+        if (WideCharToMultiByte(CP_UTF8, 0, caps.szPname, -1, guid,
+                                kAdmMaxGuidSize, nullptr, nullptr) == 0) {
+          WEBRTC_TRACE(
+              kTraceError, kTraceAudioDevice, _id,
+              "WideCharToMultiByte(CP_UTF8) failed with error code %d - 3",
+              GetLastError());
         }
         CoTaskMemFree(pstrEndpointId);
         return 0;
     }
 
-    if (WideCharToMultiByte(CP_UTF8, 0, pstrEndpointId, -1, guid, kAdmMaxGuidSize, NULL, NULL) == 0)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "WideCharToMultiByte(CP_UTF8) failed with error code %d - 4", GetLastError());
+    if (WideCharToMultiByte(CP_UTF8, 0, pstrEndpointId, -1, guid,
+                            kAdmMaxGuidSize, nullptr, nullptr) == 0) {
+      WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                   "WideCharToMultiByte(CP_UTF8) failed with error code %d - 4",
+                   GetLastError());
     }
     CoTaskMemFree(pstrEndpointId);
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingDevices
 // ----------------------------------------------------------------------------
 
@@ skipping 132 matching lines @@
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "InitSpeaker() failed");
     }
 
     // Enumerate all availiable output devices
     EnumeratePlayoutDevices();
 
     // Start by closing any existing wave-output devices
     //
     MMRESULT res(MMSYSERR_ERROR);
 
-    if (_hWaveOut != NULL)
-    {
-        res = waveOutClose(_hWaveOut);
-        if (MMSYSERR_NOERROR != res)
-        {
-            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutClose() failed (err=%d)", res);
-            TraceWaveOutError(res);
-        }
+    if (_hWaveOut != nullptr) {
+      res = waveOutClose(_hWaveOut);
+      if (MMSYSERR_NOERROR != res) {
+        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                     "waveOutClose() failed (err=%d)", res);
+        TraceWaveOutError(res);
+      }
     }
 
     // Set the output wave format
     //
     WAVEFORMATEX waveFormat;
 
     waveFormat.wFormatTag      = WAVE_FORMAT_PCM;
     waveFormat.nChannels       = _playChannels;  // mono <=> 1, stereo <=> 2
     waveFormat.nSamplesPerSec  = N_PLAY_SAMPLES_PER_SEC;
     waveFormat.wBitsPerSample  = 16;
     waveFormat.nBlockAlign     = waveFormat.nChannels * (waveFormat.wBitsPerSample/8);
     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
     waveFormat.cbSize          = 0;
 
     // Open the given waveform-audio output device for playout
     //
-    HWAVEOUT hWaveOut(NULL);
+    HWAVEOUT hWaveOut(nullptr);
 
     if (IsUsingOutputDeviceIndex())
     {
         // verify settings first
-        res = waveOutOpen(NULL, _outputDeviceIndex, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_FORMAT_QUERY);
+        res = waveOutOpen(nullptr, _outputDeviceIndex, &waveFormat, 0, 0,
+                          CALLBACK_NULL | WAVE_FORMAT_QUERY);
         if (MMSYSERR_NOERROR == res)
         {
             // open the given waveform-audio output device for recording
-            res = waveOutOpen(&hWaveOut, _outputDeviceIndex, &waveFormat, 0, 0, CALLBACK_NULL);
+            res = waveOutOpen(&hWaveOut, _outputDeviceIndex, &waveFormat, 0, 0,
+                              CALLBACK_NULL);
             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening output device corresponding to device ID %u", _outputDeviceIndex);
         }
     }
     else
     {
         if (_outputDevice == AudioDeviceModule::kDefaultCommunicationDevice)
         {
             // check if it is possible to open the default communication device (supported on Windows 7)
-            res = waveOutOpen(NULL, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE | WAVE_FORMAT_QUERY);
+            res = waveOutOpen(nullptr, WAVE_MAPPER, &waveFormat, 0, 0,
+                              CALLBACK_NULL |
+                                  WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE |
+                                  WAVE_FORMAT_QUERY);
             if (MMSYSERR_NOERROR == res)
             {
                 // if so, open the default communication device for real
-                res = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL |  WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE);
+                res = waveOutOpen(
+                    &hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0,
+                    CALLBACK_NULL | WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE);
                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening default communication device");
             }
             else
             {
                 // use default device since default communication device was not avaliable
-                res = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL);
+                res = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0,
+                                  CALLBACK_NULL);
                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "unable to open default communication device => using default instead");
             }
         }
         else if (_outputDevice == AudioDeviceModule::kDefaultDevice)
         {
             // open default device since it has been requested
-            res = waveOutOpen(NULL, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_FORMAT_QUERY);
+            res = waveOutOpen(nullptr, WAVE_MAPPER, &waveFormat, 0, 0,
+                              CALLBACK_NULL | WAVE_FORMAT_QUERY);
             if (MMSYSERR_NOERROR == res)
             {
-                res = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL);
-                WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening default output device");
+              res = waveOutOpen(&hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0,
+                                CALLBACK_NULL);
+              WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                           "opening default output device");
             }
         }
     }
 
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveOutOpen() failed (err=%d)", res);
         TraceWaveOutError(res);
         return -1;
     }
@@ skipping 115 matching lines @@
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "InitMicrophone() failed");
     }
 
     // Enumerate all availiable input devices
     EnumerateRecordingDevices();
 
     // Start by closing any existing wave-input devices
     //
     MMRESULT res(MMSYSERR_ERROR);
 
-    if (_hWaveIn != NULL)
-    {
-        res = waveInClose(_hWaveIn);
-        if (MMSYSERR_NOERROR != res)
-        {
-            WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInClose() failed (err=%d)", res);
-            TraceWaveInError(res);
-        }
+    if (_hWaveIn != nullptr) {
+      res = waveInClose(_hWaveIn);
+      if (MMSYSERR_NOERROR != res) {
+        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                     "waveInClose() failed (err=%d)", res);
+        TraceWaveInError(res);
+      }
     }
 
     // Set the input wave format
     //
     WAVEFORMATEX waveFormat;
 
     waveFormat.wFormatTag      = WAVE_FORMAT_PCM;
     waveFormat.nChannels       = _recChannels;  // mono <=> 1, stereo <=> 2
     waveFormat.nSamplesPerSec  = N_REC_SAMPLES_PER_SEC;
     waveFormat.wBitsPerSample  = 16;
     waveFormat.nBlockAlign     = waveFormat.nChannels * (waveFormat.wBitsPerSample/8);
     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
     waveFormat.cbSize          = 0;
 
     // Open the given waveform-audio input device for recording
     //
-    HWAVEIN hWaveIn(NULL);
+    HWAVEIN hWaveIn(nullptr);
 
     if (IsUsingInputDeviceIndex())
     {
         // verify settings first
-        res = waveInOpen(NULL, _inputDeviceIndex, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_FORMAT_QUERY);
+        res = waveInOpen(nullptr, _inputDeviceIndex, &waveFormat, 0, 0,
+                         CALLBACK_NULL | WAVE_FORMAT_QUERY);
         if (MMSYSERR_NOERROR == res)
         {
             // open the given waveform-audio input device for recording
-            res = waveInOpen(&hWaveIn, _inputDeviceIndex, &waveFormat, 0, 0, CALLBACK_NULL);
+            res = waveInOpen(&hWaveIn, _inputDeviceIndex, &waveFormat, 0, 0,
+                             CALLBACK_NULL);
             WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening input device corresponding to device ID %u", _inputDeviceIndex);
         }
     }
     else
     {
         if (_inputDevice == AudioDeviceModule::kDefaultCommunicationDevice)
         {
             // check if it is possible to open the default communication device (supported on Windows 7)
-            res = waveInOpen(NULL, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE | WAVE_FORMAT_QUERY);
+            res = waveInOpen(nullptr, WAVE_MAPPER, &waveFormat, 0, 0,
+                             CALLBACK_NULL |
+                                 WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE |
+                                 WAVE_FORMAT_QUERY);
             if (MMSYSERR_NOERROR == res)
             {
                 // if so, open the default communication device for real
-                res = waveInOpen(&hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE);
+                res = waveInOpen(
+                    &hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0,
+                    CALLBACK_NULL | WAVE_MAPPED_DEFAULT_COMMUNICATION_DEVICE);
                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening default communication device");
             }
             else
             {
                 // use default device since default communication device was not avaliable
-                res = waveInOpen(&hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL);
+                res = waveInOpen(&hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0,
+                                 CALLBACK_NULL);
                 WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "unable to open default communication device => using default instead");
             }
         }
         else if (_inputDevice == AudioDeviceModule::kDefaultDevice)
         {
             // open default device since it has been requested
-            res = waveInOpen(NULL, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL | WAVE_FORMAT_QUERY);
+            res = waveInOpen(nullptr, WAVE_MAPPER, &waveFormat, 0, 0,
+                             CALLBACK_NULL | WAVE_FORMAT_QUERY);
             if (MMSYSERR_NOERROR == res)
             {
-                res = waveInOpen(&hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0, CALLBACK_NULL);
-                WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "opening default input device");
+              res = waveInOpen(&hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0,
+                               CALLBACK_NULL);
+              WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                           "opening default input device");
             }
         }
     }
 
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "waveInOpen() failed (err=%d)", res);
         TraceWaveInError(res);
         return -1;
     }
@@ skipping 83 matching lines @@
 int32_t AudioDeviceWindowsWave::StopRecording()
 {
 
     CriticalSectionScoped lock(&_critSect);
 
     if (!_recIsInitialized)
     {
         return 0;
     }
 
-    if (_hWaveIn == NULL)
-    {
-        return -1;
+    if (_hWaveIn == nullptr) {
+      return -1;
     }
 
     bool wasRecording = _recording;
     _recIsInitialized = false;
     _recording = false;
 
     MMRESULT res;
 
     // Stop waveform-adio input. If there are any buffers in the queue, the
     // current buffer will be marked as done (the dwBytesRecorded member in
@@ skipping 37 matching lines @@
 
     // Close the given waveform-audio input device.
     //
     res = waveInClose(_hWaveIn);
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInClose() failed (err=%d)", res);
         TraceWaveInError(res);
     }
 
-    // Set the wave input handle to NULL
+    // Set the wave input handle to null
     //
-    _hWaveIn = NULL;
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_hWaveIn is now set to NULL");
+    _hWaveIn = nullptr;
+    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                 "_hWaveIn is now set to null");
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  RecordingIsInitialized
 // ----------------------------------------------------------------------------
 
 bool AudioDeviceWindowsWave::RecordingIsInitialized() const
 {
@@ skipping 67 matching lines @@
 int32_t AudioDeviceWindowsWave::StopPlayout()
 {
 
     CriticalSectionScoped lock(&_critSect);
 
     if (!_playIsInitialized)
     {
         return 0;
     }
 
-    if (_hWaveOut == NULL)
-    {
-        return -1;
+    if (_hWaveOut == nullptr) {
+      return -1;
     }
 
     _playIsInitialized = false;
     _playing = false;
     _sndCardPlayDelay = 0;
     _sndCardRecDelay = 0;
 
     MMRESULT res;
 
     // The waveOutReset function stops playback on the given waveform-audio
@@ skipping 30 matching lines @@
     // waveOutClose, the application must wait for all buffers to finish playing
     // or call the waveOutReset function to terminate playback.
     //
     res = waveOutClose(_hWaveOut);
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutClose() failed (err=%d)", res);
         TraceWaveOutError(res);
     }
 
-    _hWaveOut = NULL;
-    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "_hWaveOut is now set to NULL");
+    _hWaveOut = nullptr;
+    WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                 "_hWaveOut is now set to null");
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  PlayoutDelay
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::PlayoutDelay(uint16_t& delayMS) const
 {
@@ skipping 143 matching lines @@
 // ============================================================================
 //                                 Private Methods
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 //  InputSanityCheckAfterUnlockedPeriod
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::InputSanityCheckAfterUnlockedPeriod() const
 {
-    if (_hWaveIn == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "input state has been modified during unlocked period");
-        return -1;
+  if (_hWaveIn == nullptr) {
+    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                 "input state has been modified during unlocked period");
+    return -1;
     }
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  OutputSanityCheckAfterUnlockedPeriod
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::OutputSanityCheckAfterUnlockedPeriod() const
 {
-    if (_hWaveOut == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id, "output state has been modified during unlocked period");
-        return -1;
+  if (_hWaveOut == nullptr) {
+    WEBRTC_TRACE(kTraceError, kTraceAudioDevice, _id,
+                 "output state has been modified during unlocked period");
+    return -1;
     }
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  EnumeratePlayoutDevices
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::EnumeratePlayoutDevices()
 {
@@ skipping 170 matching lines @@
 
 // ----------------------------------------------------------------------------
 //  PrepareStartPlayout
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::PrepareStartPlayout()
 {
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_hWaveOut == NULL)
-    {
-        return -1;
+    if (_hWaveOut == nullptr) {
+      return -1;
     }
 
     // A total of 30ms of data is immediately placed in the SC buffer
     //
     int8_t zeroVec[4*PLAY_BUF_SIZE_IN_SAMPLES];  // max allocation
     memset(zeroVec, 0, 4*PLAY_BUF_SIZE_IN_SAMPLES);
 
     {
         Write(zeroVec, PLAY_BUF_SIZE_IN_SAMPLES);
         Write(zeroVec, PLAY_BUF_SIZE_IN_SAMPLES);
@@ skipping 14 matching lines @@
 
 // ----------------------------------------------------------------------------
 //  PrepareStartRecording
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::PrepareStartRecording()
 {
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_hWaveIn == NULL)
-    {
-        return -1;
+    if (_hWaveIn == nullptr) {
+      return -1;
     }
 
     _playAcc = 0;
     _recordedBytes = 0;
     _recPutBackDelay = REC_PUT_BACK_DELAY;
 
     MMRESULT res;
     MMTIME mmtime;
     mmtime.wType = TIME_SAMPLES;
 
@@ skipping 900 matching lines @@
 
     return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  Write
 // ----------------------------------------------------------------------------
 
 int32_t AudioDeviceWindowsWave::Write(int8_t* data, uint16_t nSamples)
 {
-    if (_hWaveOut == NULL)
-    {
-        return -1;
+  if (_hWaveOut == nullptr) {
+    return -1;
     }
 
     if (_playIsInitialized)
     {
         MMRESULT res;
 
         const uint16_t bufCount(_playBufCount);
 
         // Place data in the memory associated with _waveHeaderOut[bufCount]
         //
@@ skipping 180 matching lines @@
 bool AudioDeviceWindowsWave::KeyPressed() const{
 
   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