Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_device/win/audio_mixer_manager_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 13 matching lines @@
 #ifndef WAVE_MAPPED_kDefaultCommunicationDevice
 #define  WAVE_MAPPED_kDefaultCommunicationDevice   0x0010
 #endif
 
 namespace webrtc {
 
 // ============================================================================
 //                             CONSTRUCTION/DESTRUCTION
 // ============================================================================
 
-AudioMixerManager::AudioMixerManager(const int32_t id) :
-    _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
-    _id(id),
-    _inputMixerHandle(NULL),
-    _outputMixerHandle(NULL)
-{
-    WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s constructed", __FUNCTION__);
-    ClearSpeakerState();
-    ClearMicrophoneState();
+AudioMixerManager::AudioMixerManager(const int32_t id)
+    : _critSect(*CriticalSectionWrapper::CreateCriticalSection()),
+      _id(id),
+      _inputMixerHandle(nullptr),
+      _outputMixerHandle(nullptr) {
+  WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s constructed",
+               __FUNCTION__);
+  ClearSpeakerState();
+  ClearMicrophoneState();
 }
 
 AudioMixerManager::~AudioMixerManager()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s destructed", __FUNCTION__);
 
     Close();
 
     delete &_critSect;
 }
 
 // ============================================================================
 //                                 PUBLIC METHODS
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 //  Close
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::Close()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__);
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_outputMixerHandle != NULL)
-    {
-        mixerClose(_outputMixerHandle);
-        _outputMixerHandle = NULL;
+    if (_outputMixerHandle != nullptr) {
+      mixerClose(_outputMixerHandle);
+      _outputMixerHandle = nullptr;
     }
-    if (_inputMixerHandle != NULL)
-    {
-        mixerClose(_inputMixerHandle);
-        _inputMixerHandle = NULL;
+    if (_inputMixerHandle != nullptr) {
+      mixerClose(_inputMixerHandle);
+      _inputMixerHandle = nullptr;
     }
     return 0;
 
 }
 
 // ----------------------------------------------------------------------------
 //  CloseSpeaker
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::CloseSpeaker()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__);
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_outputMixerHandle == NULL)
-    {
-        return -1;
+    if (_outputMixerHandle == nullptr) {
+      return -1;
     }
 
     ClearSpeakerState(_outputMixerID);
 
     mixerClose(_outputMixerHandle);
-    _outputMixerHandle = NULL;
+    _outputMixerHandle = nullptr;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  CloseMicrophone
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::CloseMicrophone()
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "%s", __FUNCTION__);
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_inputMixerHandle == NULL)
-    {
-        return -1;
+    if (_inputMixerHandle == nullptr) {
+      return -1;
     }
 
     ClearMicrophoneState(_inputMixerID);
 
     mixerClose(_inputMixerHandle);
-    _inputMixerHandle = NULL;
+    _inputMixerHandle = nullptr;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  EnumerateAll
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::EnumerateAll()
 {
@@ skipping 443 matching lines @@
     }
     else if (device == AudioDeviceModule::kDefaultCommunicationDevice)
     {
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::OpenSpeaker(kDefaultCommunicationDevice)");
     }
 
     CriticalSectionScoped lock(&_critSect);
 
     // Close any existing output mixer handle
     //
-    if (_outputMixerHandle != NULL)
-    {
-        mixerClose(_outputMixerHandle);
-        _outputMixerHandle = NULL;
+    if (_outputMixerHandle != nullptr) {
+      mixerClose(_outputMixerHandle);
+      _outputMixerHandle = nullptr;
     }
 
     MMRESULT     res = MMSYSERR_NOERROR;
     WAVEFORMATEX waveFormat;
-    HWAVEOUT     hWaveOut(NULL);
+    HWAVEOUT hWaveOut(nullptr);
 
     waveFormat.wFormatTag      = WAVE_FORMAT_PCM ;
     waveFormat.nChannels       = 2;
     waveFormat.nSamplesPerSec  = 48000;
     waveFormat.wBitsPerSample  = 16;
     waveFormat.nBlockAlign     = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
     waveFormat.cbSize          = 0;
 
     // We need a waveform-audio output handle for the currently selected output device.
     // This handle will then give us the corresponding mixer identifier. Once the mixer
     // ID is known, it is possible to open the output mixer.
     //
     if (device == 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_kDefaultCommunicationDevice | WAVE_FORMAT_QUERY);
+        res = waveOutOpen(nullptr, WAVE_MAPPER, &waveFormat, 0, 0,
+                          CALLBACK_NULL |
+                              WAVE_MAPPED_kDefaultCommunicationDevice |
+                              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_kDefaultCommunicationDevice);
+            res = waveOutOpen(
+                &hWaveOut, WAVE_MAPPER, &waveFormat, 0, 0,
+                CALLBACK_NULL | WAVE_MAPPED_kDefaultCommunicationDevice);
             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 (device == AudioDeviceModule::kDefaultDevice)
     {
         // open default device since it has been requested
-        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, "opening default output device");
     }
 
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutOpen() failed (err=%d)", res);
         TraceWaveOutError(res);
     }
 
     UINT   mixerId(0);
-    HMIXER hMixer(NULL);
+    HMIXER hMixer(nullptr);
 
     // Retrieve the device identifier for a mixer device associated with the
     // aquired waveform-audio output handle.
     //
     res = mixerGetID((HMIXEROBJ)hWaveOut, &mixerId, MIXER_OBJECTF_HWAVEOUT);
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "mixerGetID(MIXER_OBJECTF_HWAVEOUT) failed (err=%d)", res);
         // identification failed => use default mixer identifier (=0)
         mixerId = 0;
@@ skipping 20 matching lines @@
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "mixerOpen() failed (err=%d)", res);
     }
 
     // Store the output mixer handle and active mixer identifier
     //
     _outputMixerHandle = hMixer;
     _outputMixerID = mixerId;
 
-    if (_outputMixerHandle != NULL)
-    {
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "the output mixer device is now open (0x%x)", _outputMixerHandle);
+    if (_outputMixerHandle != nullptr) {
+      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                   "the output mixer device is now open (0x%x)",
+                   _outputMixerHandle);
     }
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  OpenSpeaker II(II)
 //
 //  Verifies that the mixer contains a valid speaker destination line.
 //  Avoids opening the mixer if valid control has not been found.
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::OpenSpeaker(uint16_t index)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::OpenSpeaker(index=%d)", index);
 
     CriticalSectionScoped lock(&_critSect);
 
     // Close any existing output mixer handle
     //
-    if (_outputMixerHandle != NULL)
-    {
-        mixerClose(_outputMixerHandle);
-        _outputMixerHandle = NULL;
+    if (_outputMixerHandle != nullptr) {
+      mixerClose(_outputMixerHandle);
+      _outputMixerHandle = nullptr;
     }
 
     MMRESULT     res;
     WAVEFORMATEX waveFormat;
-    HWAVEOUT     hWaveOut(NULL);
+    HWAVEOUT hWaveOut(nullptr);
 
     const UINT   deviceID(index);  // use index parameter as device identifier
 
     waveFormat.wFormatTag      = WAVE_FORMAT_PCM ;
     waveFormat.nChannels       = 2;
     waveFormat.nSamplesPerSec  = 48000;
     waveFormat.wBitsPerSample  = 16;
     waveFormat.nBlockAlign     = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
     waveFormat.cbSize          = 0;
 
     // We need a waveform-audio output handle for the currently selected output device.
     // This handle will then give us the corresponding mixer identifier. Once the mixer
     // ID is known, it is possible to open the output mixer.
     //
     res = waveOutOpen(&hWaveOut, deviceID, &waveFormat, 0, 0, CALLBACK_NULL);
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveOutOpen(deviceID=%u) failed (err=%d)", index, res);
         TraceWaveOutError(res);
     }
 
     UINT   mixerId(0);
-    HMIXER hMixer(NULL);
+    HMIXER hMixer(nullptr);
 
     // Retrieve the device identifier for a mixer device associated with the
     // aquired waveform-audio output handle.
     //
     res = mixerGetID((HMIXEROBJ)hWaveOut, &mixerId, MIXER_OBJECTF_HWAVEOUT);
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "mixerGetID(MIXER_OBJECTF_HWAVEOUT) failed (err=%d)", res);
         // identification failed => use default mixer identifier (=0)
         mixerId = 0;
@@ skipping 20 matching lines @@
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "mixerOpen() failed (err=%d)", res);
     }
 
     // Store the output mixer handle and active mixer identifier
     //
     _outputMixerHandle = hMixer;
     _outputMixerID = mixerId;
 
-    if (_outputMixerHandle != NULL)
-    {
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "the output mixer device is now open (0x%x)", _outputMixerHandle);
+    if (_outputMixerHandle != nullptr) {
+      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                   "the output mixer device is now open (0x%x)",
+                   _outputMixerHandle);
     }
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  OpenMicrophone I(II)
 //
 //  Verifies that the mixer contains a valid wave-in destination line.
 //  Avoids opening the mixer if valid control has not been found.
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::OpenMicrophone(AudioDeviceModule::WindowsDeviceType device)
 {
     if (device == AudioDeviceModule::kDefaultDevice)
     {
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::OpenMicrophone(kDefaultDevice)");
     }
     else if (device == AudioDeviceModule::kDefaultCommunicationDevice)
     {
         WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::OpenMicrophone(kDefaultCommunicationDevice)");
     }
 
     CriticalSectionScoped lock(&_critSect);
 
     // Close any existing output mixer handle
     //
-    if (_inputMixerHandle != NULL)
-    {
-        mixerClose(_inputMixerHandle);
-        _inputMixerHandle = NULL;
+    if (_inputMixerHandle != nullptr) {
+      mixerClose(_inputMixerHandle);
+      _inputMixerHandle = nullptr;
     }
 
     MMRESULT     res = MMSYSERR_NOERROR;
     WAVEFORMATEX waveFormat;
-    HWAVEIN         hWaveIn(NULL);
+    HWAVEIN hWaveIn(nullptr);
 
     waveFormat.wFormatTag      = WAVE_FORMAT_PCM ;
     waveFormat.nChannels       = 1;
     waveFormat.nSamplesPerSec  = 48000;
     waveFormat.wBitsPerSample  = 16;
     waveFormat.nBlockAlign     = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
     waveFormat.cbSize          = 0 ;
 
     // We need a waveform-audio input handle for the currently selected input device.
     // This handle will then give us the corresponding mixer identifier. Once the mixer
     // ID is known, it is possible to open the input mixer.
     //
     if (device == 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_kDefaultCommunicationDevice | WAVE_FORMAT_QUERY);
+        res =
+            waveInOpen(nullptr, WAVE_MAPPER, &waveFormat, 0, 0,
+                       CALLBACK_NULL | WAVE_MAPPED_kDefaultCommunicationDevice |
+                           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_kDefaultCommunicationDevice);
+            res = waveInOpen(
+                &hWaveIn, WAVE_MAPPER, &waveFormat, 0, 0,
+                CALLBACK_NULL | WAVE_MAPPED_kDefaultCommunicationDevice);
             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 (device == AudioDeviceModule::kDefaultDevice)
     {
         // open default device since it has been requested
-        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, "opening default input device");
     }
 
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInOpen() failed (err=%d)", res);
         TraceWaveInError(res);
     }
 
     UINT   mixerId(0);
-    HMIXER hMixer(NULL);
+    HMIXER hMixer(nullptr);
 
     // Retrieve the device identifier for a mixer device associated with the
     // aquired waveform-audio input handle.
     //
     res = mixerGetID((HMIXEROBJ)hWaveIn, &mixerId, MIXER_OBJECTF_HWAVEIN);
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "mixerGetID(MIXER_OBJECTF_HWAVEIN) failed (err=%d)", res);
         // identification failed => use default mixer identifier (=0)
         mixerId = 0;
@@ skipping 20 matching lines @@
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "mixerOpen() failed (err=%d)", res);
     }
 
     // Store the input mixer handle and active mixer identifier
     //
     _inputMixerHandle = hMixer;
     _inputMixerID = mixerId;
 
-    if (_inputMixerHandle != NULL)
-    {
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "the input mixer device is now open (0x%x)", _inputMixerHandle);
+    if (_inputMixerHandle != nullptr) {
+      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                   "the input mixer device is now open (0x%x)",
+                   _inputMixerHandle);
     }
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  OpenMicrophone II(II)
 //
 //  Verifies that the mixer contains a valid wave-in destination line.
 //  Avoids opening the mixer if valid control has not been found.
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::OpenMicrophone(uint16_t index)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::OpenMicrophone(index=%d)", index);
 
     CriticalSectionScoped lock(&_critSect);
 
     // Close any existing input mixer handle
     //
-    if (_inputMixerHandle != NULL)
-    {
-        mixerClose(_inputMixerHandle);
-        _inputMixerHandle = NULL;
+    if (_inputMixerHandle != nullptr) {
+      mixerClose(_inputMixerHandle);
+      _inputMixerHandle = nullptr;
     }
 
     MMRESULT     res;
     WAVEFORMATEX waveFormat;
-    HWAVEIN         hWaveIn(NULL);
+    HWAVEIN hWaveIn(nullptr);
 
     const UINT   deviceID(index);  // use index parameter as device identifier
 
     waveFormat.wFormatTag      = WAVE_FORMAT_PCM ;
     waveFormat.nChannels       = 1;
     waveFormat.nSamplesPerSec  = 48000;
     waveFormat.wBitsPerSample  = 16;
     waveFormat.nBlockAlign     = waveFormat.nChannels * waveFormat.wBitsPerSample / 8;
     waveFormat.nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
     waveFormat.cbSize          = 0;
 
     // We need a waveform-audio input handle for the currently selected input device.
     // This handle will then give us the corresponding mixer identifier. Once the mixer
     // ID is known, it is possible to open the input mixer.
     //
     res = waveInOpen(&hWaveIn, deviceID, &waveFormat, 0, 0, CALLBACK_NULL);
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "waveInOpen(deviceID=%u) failed (err=%d)", index, res);
         TraceWaveInError(res);
     }
 
     UINT   mixerId(0);
-    HMIXER hMixer(NULL);
+    HMIXER hMixer(nullptr);
 
     // Retrieve the device identifier for a mixer device associated with the
     // aquired waveform-audio input handle.
     //
     res = mixerGetID((HMIXEROBJ)hWaveIn, &mixerId, MIXER_OBJECTF_HWAVEIN);
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "mixerGetID(MIXER_OBJECTF_HWAVEIN) failed (err=%d)", res);
         // identification failed => use default mixer identifier (=0)
         mixerId = 0;
@@ skipping 20 matching lines @@
     if (MMSYSERR_NOERROR != res)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "mixerOpen() failed (err=%d)", res);
     }
 
     // Store the input mixer handle and active mixer identifier
     //
     _inputMixerHandle = hMixer;
     _inputMixerID = mixerId;
 
-    if (_inputMixerHandle != NULL)
-    {
-        WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "the input mixer device is now open (0x%x)", _inputMixerHandle);
+    if (_inputMixerHandle != nullptr) {
+      WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id,
+                   "the input mixer device is now open (0x%x)",
+                   _inputMixerHandle);
     }
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 // SpeakerIsInitialized
 // ----------------------------------------------------------------------------
 
 bool AudioMixerManager::SpeakerIsInitialized() const
 {
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__);
 
-    return (_outputMixerHandle != NULL);
+    return (_outputMixerHandle != nullptr);
 }
 
 // ----------------------------------------------------------------------------
 // MicrophoneIsInitialized
 // ----------------------------------------------------------------------------
 
 bool AudioMixerManager::MicrophoneIsInitialized() const
 {
     WEBRTC_TRACE(kTraceMemory, kTraceAudioDevice, _id, "%s", __FUNCTION__);
 
-    return (_inputMixerHandle != NULL);
+    return (_inputMixerHandle != nullptr);
 }
 
 // ----------------------------------------------------------------------------
 // SetSpeakerVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SetSpeakerVolume(uint32_t volume)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::SetSpeakerVolume(volume=%u)", volume);
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+    if (_outputMixerHandle == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no avaliable output mixer exists");
+      return -1;
     }
 
     const UINT mixerID(_outputMixerID);
     const DWORD dwControlID(_speakerState[_outputMixerID].dwVolumeControlID);
     DWORD dwValue(volume);
 
     // Set one unsigned control value for a specified volume-control identifier
     //
     if (!SetUnsignedControlValue(mixerID, dwControlID, dwValue))
     {
         return -1;
     }
 
     return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerVolume
 //
 //  Note that (MIXERCONTROL_CONTROLTYPE_VOLUME & MIXERCONTROL_CT_UNITS_MASK)
 //  always equals MIXERCONTROL_CT_UNITS_UNSIGNED;
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SpeakerVolume(uint32_t& volume) const
 {
-
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+  if (_outputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable output mixer exists");
+    return -1;
     }
 
     const UINT mixerID(_outputMixerID);
     const DWORD dwControlID(_speakerState[_outputMixerID].dwVolumeControlID);
     DWORD dwValue(0);
 
     // Retrieve one unsigned control value for a specified volume-control identifier
     //
     if (!GetUnsignedControlValue(mixerID, dwControlID, dwValue))
     {
         return -1;
     }
 
     volume = dwValue;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  MaxSpeakerVolume
 //
 //  Note that (MIXERCONTROL_CONTROLTYPE_VOLUME & MIXERCONTROL_CT_UNITS_MASK)
 //  always equals MIXERCONTROL_CT_UNITS_UNSIGNED
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MaxSpeakerVolume(uint32_t& maxVolume) const
 {
-
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+  if (_outputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable output mixer exists");
+    return -1;
     }
 
     const UINT mixerID(_outputMixerID);
     const DWORD dwControlID(_speakerState[_outputMixerID].dwVolumeControlID);
     MIXERCONTROL mixerControl;
 
     // Retrieve one control line for a specified volume-control identifier
     //
     if (!GetLineControl(mixerID, dwControlID, mixerControl))
     {
         return -1;
     }
 
     maxVolume = mixerControl.Bounds.dwMaximum;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 // MinSpeakerVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MinSpeakerVolume(uint32_t& minVolume) const
 {
-
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+  if (_outputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable output mixer exists");
+    return -1;
     }
 
     const UINT mixerID(_outputMixerID);
     const DWORD dwControlID(_speakerState[_outputMixerID].dwVolumeControlID);
     MIXERCONTROL mixerControl;
 
     // Retrieve one control line for a specified volume-control identifier
     //
     if (!GetLineControl(mixerID, dwControlID, mixerControl))
     {
         return -1;
     }
 
     minVolume = mixerControl.Bounds.dwMinimum;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 // SpeakerVolumeStepSize
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SpeakerVolumeStepSize(uint16_t& stepSize) const
 {
-
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+  if (_outputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable output mixer exists");
+    return -1;
     }
 
     const UINT mixerID(_outputMixerID);
     MIXERCONTROL mixerControl;
 
     // Retrieve one control line for a specified volume-control identifier
     //
     if (!GetLineControl(mixerID, _speakerState[mixerID].dwVolumeControlID, mixerControl))
     {
         return -1;
     }
 
     stepSize = static_cast<uint16_t> (mixerControl.Metrics.cSteps);
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 // SpeakerVolumeIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SpeakerVolumeIsAvailable(bool& available)
 {
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+  if (_outputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable output mixer exists");
+    return -1;
     }
 
     available = _speakerState[_outputMixerID].volumeControlIsValid;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 // SpeakerMuteIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SpeakerMuteIsAvailable(bool& available)
 {
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+  if (_outputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable output mixer exists");
+    return -1;
     }
 
     available = _speakerState[_outputMixerID].muteControlIsValid;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  SetSpeakerMute
 //
 //  This mute function works a master mute for the output speaker.
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SetSpeakerMute(bool enable)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::SetSpeakerMute(enable=%u)", enable);
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+    if (_outputMixerHandle == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no avaliable output mixer exists");
+      return -1;
     }
 
     // Ensure that the selected speaker destination has a valid mute control.
     // If so, its identifier was stored during the enumeration phase which must
     // have taken place since the output mixer handle exists.
     //
     if (!_speakerState[_outputMixerID].muteControlIsValid)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "it is not possible to mute this speaker line");
         return -1;
@@ skipping 10 matching lines @@
 
     return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  SpeakerMute
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SpeakerMute(bool& enabled) const
 {
-
-    if (_outputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable output mixer exists");
-        return -1;
+  if (_outputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable output mixer exists");
+    return -1;
     }
 
     // Ensure that the selected speaker destination has a valid mute control.
     // If so, its identifier was stored during the enumeration phase which must
     // have taken place since the output mixer handle exists.
     //
     if (!_speakerState[_outputMixerID].muteControlIsValid)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "it is not possible to mute this speaker line");
         return -1;
@@ skipping 13 matching lines @@
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneMuteIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MicrophoneMuteIsAvailable(bool& available)
 {
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+  if (_inputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable input mixer exists");
+    return -1;
     }
 
     available = _microphoneState[_inputMixerID].muteControlIsValid;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 // SetMicrophoneMute
 //
 //  This mute function works a master mute for the input microphone.
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SetMicrophoneMute(bool enable)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::SetMicrophoneMute(enable=%u)", enable);
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+    if (_inputMixerHandle == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no avaliable input mixer exists");
+      return -1;
     }
 
     // Ensure that the selected wave-in destinationhas a valid mute control.
     // If so, its identifier was stored during the enumeration phase which must
     // have taken place since the input mixer handle exists.
     //
     if (!_microphoneState[_inputMixerID].muteControlIsValid)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "it is not possible to mute this microphone line");
         return -1;
@@ skipping 10 matching lines @@
 
     return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneMute
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MicrophoneMute(bool& enabled) const
 {
-
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+  if (_inputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable input mixer exists");
+    return -1;
     }
 
     // Ensure that the selected wave-in destinationhas a valid mute control.
     // If so, its identifier was stored during the enumeration phase which must
     // have taken place since the input mixer handle exists.
     //
     if (!_microphoneState[_inputMixerID].muteControlIsValid)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "it is not possible to mute this microphone line");
         return -1;
@@ skipping 13 matching lines @@
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneBoostIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MicrophoneBoostIsAvailable(bool& available)
 {
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+  if (_inputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable input mixer exists");
+    return -1;
     }
 
     available = _microphoneState[_inputMixerID].onOffControlIsValid;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  SetMicrophoneBoost
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SetMicrophoneBoost(bool enable)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceAudioDevice, _id, "AudioMixerManager::SetMicrophoneBoost(enable=%u)", enable);
 
     CriticalSectionScoped lock(&_critSect);
 
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+    if (_inputMixerHandle == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no avaliable input mixer exists");
+      return -1;
     }
 
     // Ensure that the selected wave-in destination has a valid boost (on/off) control.
     // If so, its identifier was stored during the enumeration phase which must
     // have taken place since the input mixer handle exists.
     //
     if (!_microphoneState[_inputMixerID].onOffControlIsValid)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no boost control exists for this wave-in line");
         return -1;
@@ skipping 10 matching lines @@
 
     return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneBoost
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MicrophoneBoost(bool& enabled) const
 {
-
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+  if (_inputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable input mixer exists");
+    return -1;
     }
 
     // Ensure that the selected wave-in destination has a valid boost (on/off) control.
     // If so, its identifier was stored during the enumeration phase which must
     // have taken place since the input mixer handle exists.
     //
     if (!_microphoneState[_inputMixerID].onOffControlIsValid)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no boost control exists for this wave-in line");
         return -1;
@@ skipping 13 matching lines @@
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneVolumeIsAvailable
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MicrophoneVolumeIsAvailable(bool& available)
 {
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+  if (_inputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable input mixer exists");
+    return -1;
     }
 
     available = _microphoneState[_inputMixerID].volumeControlIsValid;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  SetMicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::SetMicrophoneVolume(uint32_t volume)
 {
     CriticalSectionScoped lock(&_critSect);
 
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+    if (_inputMixerHandle == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no avaliable input mixer exists");
+      return -1;
     }
 
     const UINT mixerID(_inputMixerID);
     const DWORD dwControlID(_microphoneState[_inputMixerID].dwVolumeControlID);
     DWORD dwValue(volume);
 
     // Set one unsigned control value for a specified volume-control identifier
     //
     if (!SetUnsignedControlValue(mixerID, dwControlID, dwValue))
     {
         return -1;
     }
 
     return (0);
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MicrophoneVolume(uint32_t& volume) const
 {
     CriticalSectionScoped lock(&_critSect);
 
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+    if (_inputMixerHandle == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no avaliable input mixer exists");
+      return -1;
     }
 
     const UINT mixerID(_inputMixerID);
     const DWORD dwControlID(_microphoneState[_inputMixerID].dwVolumeControlID);
     DWORD dwValue(0);
 
     // Retrieve one unsigned control value for a specified volume-control identifier
     //
     if (!GetUnsignedControlValue(mixerID, dwControlID, dwValue))
     {
         return -1;
     }
 
     volume = dwValue;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  MaxMicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MaxMicrophoneVolume(uint32_t& maxVolume) const
 {
     WEBRTC_TRACE(kTraceStream, kTraceAudioDevice, _id, "%s", __FUNCTION__);
 
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+    if (_inputMixerHandle == nullptr) {
+      WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                   "no avaliable input mixer exists");
+      return -1;
     }
 
     const UINT mixerID(_inputMixerID);
     const DWORD dwControlID(_microphoneState[_inputMixerID].dwVolumeControlID);
     MIXERCONTROL mixerControl;
 
     // Retrieve one control line for a specified volume-control identifier
     //
     if (!GetLineControl(mixerID, dwControlID, mixerControl))
     {
         return -1;
     }
 
     maxVolume = mixerControl.Bounds.dwMaximum;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 // MinMicrophoneVolume
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MinMicrophoneVolume(uint32_t& minVolume) const
 {
-
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+  if (_inputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable input mixer exists");
+    return -1;
     }
 
     const UINT mixerID(_inputMixerID);
     const DWORD dwControlID(_microphoneState[_inputMixerID].dwVolumeControlID);
     MIXERCONTROL mixerControl;
 
     // Retrieve one control line for a specified volume-control identifier
     //
     if (!GetLineControl(mixerID, dwControlID, mixerControl))
     {
         return -1;
     }
 
     minVolume = mixerControl.Bounds.dwMinimum;
 
     return 0;
 }
 
 // ----------------------------------------------------------------------------
 //  MicrophoneVolumeStepSize
 // ----------------------------------------------------------------------------
 
 int32_t AudioMixerManager::MicrophoneVolumeStepSize(uint16_t& stepSize) const
 {
-
-    if (_inputMixerHandle == NULL)
-    {
-        WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id, "no avaliable input mixer exists");
-        return -1;
+  if (_inputMixerHandle == nullptr) {
+    WEBRTC_TRACE(kTraceWarning, kTraceAudioDevice, _id,
+                 "no avaliable input mixer exists");
+    return -1;
     }
 
     const UINT mixerID(_inputMixerID);
     const DWORD dwControlID(_microphoneState[_inputMixerID].dwVolumeControlID);
     MIXERCONTROL mixerControl;
 
     // Retrieve one control line for a specified volume-control identifier
     //
     if (!GetLineControl(mixerID, dwControlID, mixerControl))
     {
@@ skipping 1079 matching lines @@
         if (WideCharToMultiByte(CP_UTF8, 0, src, -1, _str, kStrLen, 0, 0) == 0)
             memset(_str, 0, kStrLen);
     }
     return _str;
 #else
     return const_cast<char*>(src);
 #endif
 }
 
 }  // namespace webrtc