Replace NULL with nullptr in all C++ files.

webrtc/voice_engine/transmit_mixer.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 138 matching lines @@
                      "module is shutdown");
     }
 }
 
 int32_t
 TransmitMixer::Create(TransmitMixer*& mixer, uint32_t instanceId)
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1),
                  "TransmitMixer::Create(instanceId=%d)", instanceId);
     mixer = new TransmitMixer(instanceId);
-    if (mixer == NULL)
-    {
-        WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1),
-                     "TransmitMixer::Create() unable to allocate memory"
-                     "for mixer");
-        return -1;
+    if (mixer == nullptr) {
+      WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(instanceId, -1),
+                   "TransmitMixer::Create() unable to allocate memory"
+                   "for mixer");
+      return -1;
     }
     return 0;
 }
 
 void
 TransmitMixer::Destroy(TransmitMixer*& mixer)
 {
     if (mixer)
     {
         delete mixer;
-        mixer = NULL;
+        mixer = nullptr;
     }
 }
 
-TransmitMixer::TransmitMixer(uint32_t instanceId) :
-    _engineStatisticsPtr(NULL),
-    _channelManagerPtr(NULL),
-    audioproc_(NULL),
-    _voiceEngineObserverPtr(NULL),
-    _processThreadPtr(NULL),
-    // Avoid conflict with other channels by adding 1024 - 1026,
-    // won't use as much as 1024 channels.
-    _filePlayerId(instanceId + 1024),
-    _fileRecorderId(instanceId + 1025),
-    _fileCallRecorderId(instanceId + 1026),
-    _filePlaying(false),
-    _fileRecording(false),
-    _fileCallRecording(false),
-    _audioLevel(),
+TransmitMixer::TransmitMixer(uint32_t instanceId)
+    : _engineStatisticsPtr(nullptr),
+      _channelManagerPtr(nullptr),
+      audioproc_(nullptr),
+      _voiceEngineObserverPtr(nullptr),
+      _processThreadPtr(nullptr),
+      // Avoid conflict with other channels by adding 1024 - 1026,
+      // won't use as much as 1024 channels.
+      _filePlayerId(instanceId + 1024),
+      _fileRecorderId(instanceId + 1025),
+      _fileCallRecorderId(instanceId + 1026),
+      _filePlaying(false),
+      _fileRecording(false),
+      _fileCallRecording(false),
+      _audioLevel(),
 #if WEBRTC_VOICE_ENGINE_TYPING_DETECTION
-    _typingNoiseWarningPending(false),
-    _typingNoiseDetected(false),
+      _typingNoiseWarningPending(false),
+      _typingNoiseDetected(false),
 #endif
-    _saturationWarning(false),
-    _instanceId(instanceId),
-    _mixFileWithMicrophone(false),
-    _captureLevel(0),
-    external_postproc_ptr_(NULL),
-    external_preproc_ptr_(NULL),
-    _mute(false),
-    stereo_codec_(false),
-    swap_stereo_channels_(false)
-{
+      _saturationWarning(false),
+      _instanceId(instanceId),
+      _mixFileWithMicrophone(false),
+      _captureLevel(0),
+      external_postproc_ptr_(nullptr),
+      external_preproc_ptr_(nullptr),
+      _mute(false),
+      stereo_codec_(false),
+      swap_stereo_channels_(false) {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::TransmitMixer() - ctor");
 }
 
 TransmitMixer::~TransmitMixer()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::~TransmitMixer() - dtor");
     _monitorModule.DeRegisterObserver();
     if (_processThreadPtr)
     {
         _processThreadPtr->DeRegisterModule(&_monitorModule);
     }
     DeRegisterExternalMediaProcessing(kRecordingAllChannelsMixed);
     DeRegisterExternalMediaProcessing(kRecordingPreprocessing);
     {
         rtc::CritScope cs(&_critSect);
         if (file_recorder_) {
-          file_recorder_->RegisterModuleFileCallback(NULL);
+          file_recorder_->RegisterModuleFileCallback(nullptr);
           file_recorder_->StopRecording();
         }
         if (file_call_recorder_) {
-          file_call_recorder_->RegisterModuleFileCallback(NULL);
+          file_call_recorder_->RegisterModuleFileCallback(nullptr);
           file_call_recorder_->StopRecording();
         }
         if (file_player_) {
-          file_player_->RegisterModuleFileCallback(NULL);
+          file_player_->RegisterModuleFileCallback(nullptr);
           file_player_->StopPlayingFile();
         }
     }
 }
 
 int32_t
 TransmitMixer::SetEngineInformation(ProcessThread& processThread,
                                     Statistics& engineStatistics,
                                     ChannelManager& channelManager)
 {
@@ skipping 233 matching lines @@
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceWarning,
             "StartPlayingFileAsMicrophone() is already playing");
         return 0;
     }
 
     rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
     if (file_player_) {
-      file_player_->RegisterModuleFileCallback(NULL);
+      file_player_->RegisterModuleFileCallback(nullptr);
       file_player_.reset();
     }
 
     // Dynamically create the instance
     file_player_ =
         FilePlayer::CreateFilePlayer(_filePlayerId, (const FileFormats)format);
 
     if (!file_player_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
@@ skipping 25 matching lines @@
                                                 int startPosition,
                                                 float volumeScaling,
                                                 int stopPosition,
                                                 const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,-1),
                  "TransmitMixer::StartPlayingFileAsMicrophone(format=%d,"
                  " volumeScaling=%5.3f, startPosition=%d, stopPosition=%d)",
                  format, volumeScaling, startPosition, stopPosition);
 
-    if (stream == NULL)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_FILE, kTraceError,
-            "StartPlayingFileAsMicrophone() NULL as input stream");
-        return -1;
+    if (stream == nullptr) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_FILE, kTraceError,
+          "StartPlayingFileAsMicrophone() null as input stream");
+      return -1;
     }
 
     if (_filePlaying)
     {
         _engineStatisticsPtr->SetLastError(
             VE_ALREADY_PLAYING, kTraceWarning,
             "StartPlayingFileAsMicrophone() is already playing");
         return 0;
     }
 
     rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
     if (file_player_) {
-      file_player_->RegisterModuleFileCallback(NULL);
+      file_player_->RegisterModuleFileCallback(nullptr);
       file_player_.reset();
     }
 
     // Dynamically create the instance
     file_player_ =
         FilePlayer::CreateFilePlayer(_filePlayerId, (const FileFormats)format);
 
     if (!file_player_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceWarning,
@@ skipping 31 matching lines @@
 
     rtc::CritScope cs(&_critSect);
 
     if (file_player_->StopPlayingFile() != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_CANNOT_STOP_PLAYOUT, kTraceError,
           "StopPlayingFile() couldnot stop playing file");
       return -1;
     }
 
-    file_player_->RegisterModuleFileCallback(NULL);
+    file_player_->RegisterModuleFileCallback(nullptr);
     file_player_.reset();
     _filePlaying = false;
 
     return 0;
 }
 
 int TransmitMixer::IsPlayingFileAsMicrophone() const
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::IsPlayingFileAsMicrophone()");
@@ skipping 13 matching lines @@
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                      "StartRecordingMicrophone() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0); // Not supported in VoE
     CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
 
-    if (codecInst != NULL && codecInst->channels > 2)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_ARGUMENT, kTraceError,
-            "StartRecordingMicrophone() invalid compression");
-        return (-1);
+    if (codecInst != nullptr && codecInst->channels > 2) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_ARGUMENT, kTraceError,
+          "StartRecordingMicrophone() invalid compression");
+      return (-1);
     }
-    if (codecInst == NULL)
-    {
-        format = kFileFormatPcm16kHzFile;
-        codecInst = &dummyCodec;
+    if (codecInst == nullptr) {
+      format = kFileFormatPcm16kHzFile;
+      codecInst = &dummyCodec;
     } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
     // Destroy the old instance
     if (file_recorder_) {
-      file_recorder_->RegisterModuleFileCallback(NULL);
+      file_recorder_->RegisterModuleFileCallback(nullptr);
       file_recorder_.reset();
     }
 
     file_recorder_ = FileRecorder::CreateFileRecorder(
         _fileRecorderId, (const FileFormats)format);
     if (!file_recorder_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
           "StartRecordingMicrophone() fileRecorder format isnot correct");
       return -1;
@@ skipping 26 matching lines @@
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                    "StartRecordingMicrophone() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0); // Not supported in VoE
     CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
 
-    if (codecInst != NULL && codecInst->channels != 1)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_ARGUMENT, kTraceError,
-            "StartRecordingMicrophone() invalid compression");
-        return (-1);
+    if (codecInst != nullptr && codecInst->channels != 1) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_ARGUMENT, kTraceError,
+          "StartRecordingMicrophone() invalid compression");
+      return (-1);
     }
-    if (codecInst == NULL)
-    {
-        format = kFileFormatPcm16kHzFile;
-        codecInst = &dummyCodec;
+    if (codecInst == nullptr) {
+      format = kFileFormatPcm16kHzFile;
+      codecInst = &dummyCodec;
     } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
     // Destroy the old instance
     if (file_recorder_) {
-      file_recorder_->RegisterModuleFileCallback(NULL);
+      file_recorder_->RegisterModuleFileCallback(nullptr);
       file_recorder_.reset();
     }
 
     file_recorder_ = FileRecorder::CreateFileRecorder(
         _fileRecorderId, (const FileFormats)format);
     if (!file_recorder_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
           "StartRecordingMicrophone() fileRecorder format isnot correct");
       return -1;
@@ skipping 29 matching lines @@
                    "StopRecordingMicrophone() isnot recording");
         return 0;
     }
 
     if (file_recorder_->StopRecording() != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_STOP_RECORDING_FAILED, kTraceError,
           "StopRecording(), could not stop recording");
       return -1;
     }
-    file_recorder_->RegisterModuleFileCallback(NULL);
+    file_recorder_->RegisterModuleFileCallback(nullptr);
     file_recorder_.reset();
     _fileRecording = false;
 
     return 0;
 }
 
 int TransmitMixer::StartRecordingCall(const char* fileName,
                                       const CodecInst* codecInst)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                  "TransmitMixer::StartRecordingCall(fileName=%s)", fileName);
 
     if (_fileCallRecording)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                      "StartRecordingCall() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0); // Not supported in VoE
     CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
 
-    if (codecInst != NULL && codecInst->channels != 1)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_ARGUMENT, kTraceError,
-            "StartRecordingCall() invalid compression");
-        return (-1);
+    if (codecInst != nullptr && codecInst->channels != 1) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_ARGUMENT, kTraceError,
+          "StartRecordingCall() invalid compression");
+      return (-1);
     }
-    if (codecInst == NULL)
-    {
-        format = kFileFormatPcm16kHzFile;
-        codecInst = &dummyCodec;
+    if (codecInst == nullptr) {
+      format = kFileFormatPcm16kHzFile;
+      codecInst = &dummyCodec;
     } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
     rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
     if (file_call_recorder_) {
-      file_call_recorder_->RegisterModuleFileCallback(NULL);
+      file_call_recorder_->RegisterModuleFileCallback(nullptr);
       file_call_recorder_.reset();
     }
 
     file_call_recorder_ = FileRecorder::CreateFileRecorder(
         _fileCallRecorderId, (const FileFormats)format);
     if (!file_call_recorder_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
           "StartRecordingCall() fileRecorder format isnot correct");
       return -1;
@@ skipping 24 matching lines @@
     {
         WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, -1),
                      "StartRecordingCall() is already recording");
         return 0;
     }
 
     FileFormats format;
     const uint32_t notificationTime(0); // Not supported in VoE
     CodecInst dummyCodec = { 100, "L16", 16000, 320, 1, 320000 };
 
-    if (codecInst != NULL && codecInst->channels != 1)
-    {
-        _engineStatisticsPtr->SetLastError(
-            VE_BAD_ARGUMENT, kTraceError,
-            "StartRecordingCall() invalid compression");
-        return (-1);
+    if (codecInst != nullptr && codecInst->channels != 1) {
+      _engineStatisticsPtr->SetLastError(
+          VE_BAD_ARGUMENT, kTraceError,
+          "StartRecordingCall() invalid compression");
+      return (-1);
     }
-    if (codecInst == NULL)
-    {
-        format = kFileFormatPcm16kHzFile;
-        codecInst = &dummyCodec;
+    if (codecInst == nullptr) {
+      format = kFileFormatPcm16kHzFile;
+      codecInst = &dummyCodec;
     } else if ((STR_CASE_CMP(codecInst->plname,"L16") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMU") == 0) ||
         (STR_CASE_CMP(codecInst->plname,"PCMA") == 0))
     {
         format = kFileFormatWavFile;
     } else
     {
         format = kFileFormatCompressedFile;
     }
 
     rtc::CritScope cs(&_critSect);
 
     // Destroy the old instance
     if (file_call_recorder_) {
-      file_call_recorder_->RegisterModuleFileCallback(NULL);
+      file_call_recorder_->RegisterModuleFileCallback(nullptr);
       file_call_recorder_.reset();
     }
 
     file_call_recorder_ = FileRecorder::CreateFileRecorder(
         _fileCallRecorderId, (const FileFormats)format);
     if (!file_call_recorder_) {
       _engineStatisticsPtr->SetLastError(
           VE_INVALID_ARGUMENT, kTraceError,
           "StartRecordingCall() fileRecorder format isnot correct");
       return -1;
@@ skipping 29 matching lines @@
 
     rtc::CritScope cs(&_critSect);
 
     if (file_call_recorder_->StopRecording() != 0) {
       _engineStatisticsPtr->SetLastError(
           VE_STOP_RECORDING_FAILED, kTraceError,
           "StopRecording(), could not stop recording");
       return -1;
     }
 
-    file_call_recorder_->RegisterModuleFileCallback(NULL);
+    file_call_recorder_->RegisterModuleFileCallback(nullptr);
     file_call_recorder_.reset();
     _fileCallRecording = false;
 
     return 0;
 }
 
 void
 TransmitMixer::SetMixWithMicStatus(bool mix)
 {
     _mixFileWithMicrophone = mix;
@@ skipping 20 matching lines @@
   }
   return 0;
 }
 
 int TransmitMixer::DeRegisterExternalMediaProcessing(ProcessingTypes type) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
                "TransmitMixer::DeRegisterExternalMediaProcessing()");
 
   rtc::CritScope cs(&_callbackCritSect);
   if (type == kRecordingAllChannelsMixed) {
-    external_postproc_ptr_ = NULL;
+    external_postproc_ptr_ = nullptr;
   } else if (type == kRecordingPreprocessing) {
-    external_preproc_ptr_ = NULL;
+    external_preproc_ptr_ = nullptr;
   } else {
     return -1;
   }
   return 0;
 }
 
 int
 TransmitMixer::SetMute(bool enable)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, -1),
@@ skipping 222 matching lines @@
 void TransmitMixer::EnableStereoChannelSwapping(bool enable) {
   swap_stereo_channels_ = enable;
 }
 
 bool TransmitMixer::IsStereoChannelSwappingEnabled() {
   return swap_stereo_channels_;
 }
 
 }  // namespace voe
 }  // namespace webrtc