Replace NULL with nullptr in all C++ files.

webrtc/modules/media_file/media_file_impl.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 13 matching lines @@
 
 void MediaFile::DestroyMediaFile(MediaFile* module)
 {
     delete static_cast<MediaFileImpl*>(module);
 }
 
 MediaFileImpl::MediaFileImpl(const int32_t id)
     : _id(id),
       _crit(CriticalSectionWrapper::CreateCriticalSection()),
       _callbackCrit(CriticalSectionWrapper::CreateCriticalSection()),
-      _ptrFileUtilityObj(NULL),
+      _ptrFileUtilityObj(nullptr),
       codec_info_(),
-      _ptrInStream(NULL),
-      _ptrOutStream(NULL),
+      _ptrInStream(nullptr),
+      _ptrOutStream(nullptr),
       _fileFormat((FileFormats)-1),
       _recordDurationMs(0),
       _playoutPositionMs(0),
       _notificationMs(0),
       _playingActive(false),
       _recordingActive(false),
       _isStereo(false),
       _openFile(false),
       _fileName(),
-      _ptrCallback(NULL)
-{
-    WEBRTC_TRACE(kTraceMemory, kTraceFile, id, "Created");
+      _ptrCallback(nullptr) {
+  WEBRTC_TRACE(kTraceMemory, kTraceFile, id, "Created");
 
-    codec_info_.plname[0] = '\0';
-    _fileName[0] = '\0';
+  codec_info_.plname[0] = '\0';
+  _fileName[0] = '\0';
 }
 
 
 MediaFileImpl::~MediaFileImpl()
 {
     WEBRTC_TRACE(kTraceMemory, kTraceFile, _id, "~MediaFileImpl()");
     {
         CriticalSectionScoped lock(_crit);
 
         if(_playingActive)
         {
             StopPlaying();
         }
 
         if(_recordingActive)
         {
             StopRecording();
         }
 
         delete _ptrFileUtilityObj;
 
         if(_openFile)
         {
             delete _ptrInStream;
-            _ptrInStream = NULL;
+            _ptrInStream = nullptr;
             delete _ptrOutStream;
-            _ptrOutStream = NULL;
+            _ptrOutStream = nullptr;
         }
     }
 
     delete _crit;
     delete _callbackCrit;
 }
 
 int64_t MediaFileImpl::TimeUntilNextProcess()
 {
     WEBRTC_TRACE(
@@ skipping 13 matching lines @@
 int32_t MediaFileImpl::PlayoutAudioData(int8_t* buffer,
                                         size_t& dataLengthInBytes)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                "MediaFileImpl::PlayoutData(buffer= 0x%x, bufLen= %" PRIuS ")",
                  buffer, dataLengthInBytes);
 
     const size_t bufferLengthInBytes = dataLengthInBytes;
     dataLengthInBytes = 0;
 
-    if(buffer == NULL || bufferLengthInBytes == 0)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                     "Buffer pointer or length is NULL!");
-        return -1;
+    if (buffer == nullptr || bufferLengthInBytes == 0) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "Buffer pointer or length is null!");
+      return -1;
     }
 
     int32_t bytesRead = 0;
     {
         CriticalSectionScoped lock(_crit);
 
         if(!_playingActive)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                          "Not currently playing!");
@@ skipping 107 matching lines @@
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "MediaFileImpl::PlayoutStereoData(Left = 0x%x, Right = 0x%x,"
                  " Len= %" PRIuS ")",
                  bufferLeft,
                  bufferRight,
                  dataLengthInBytes);
 
     const size_t bufferLengthInBytes = dataLengthInBytes;
     dataLengthInBytes = 0;
 
-    if(bufferLeft == NULL || bufferRight == NULL || bufferLengthInBytes == 0)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                     "A buffer pointer or the length is NULL!");
-        return -1;
+    if (bufferLeft == nullptr || bufferRight == nullptr ||
+        bufferLengthInBytes == 0) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "A buffer pointer or the length is null!");
+      return -1;
     }
 
     bool playEnded = false;
     uint32_t callbackNotifyMs = 0;
     {
         CriticalSectionScoped lock(_crit);
 
         if(!_playingActive || !_isStereo)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                          "Not currently playing stereo!");
             return -1;
         }
 
         if(!_ptrFileUtilityObj)
         {
-            WEBRTC_TRACE(
-                kTraceError,
-                kTraceFile,
-                _id,
-                "Playing stereo, but the FileUtility objects is NULL!");
-            StopPlaying();
-            return -1;
+          WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                       "Playing stereo, but the FileUtility objects is null!");
+          StopPlaying();
+          return -1;
         }
 
         // Stereo playout only supported for WAV files.
         int32_t bytesRead = 0;
         switch(_fileFormat)
         {
             case kFileFormatWavFile:
                     bytesRead = _ptrFileUtilityObj->ReadWavDataAsStereo(
                         *_ptrInStream,
                         bufferLeft,
@@ skipping 74 matching lines @@
         WEBRTC_TRACE(
             kTraceError,
             kTraceFile,
             _id,
             "specified notification time is longer than amount of ms that will\
  be played");
         return -1;
     }
 
     FileWrapper* inputStream = FileWrapper::Create();
-    if(inputStream == NULL)
-    {
-       WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
-                    "Failed to allocate input stream for file %s", fileName);
-        return -1;
+    if (inputStream == nullptr) {
+      WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
+                   "Failed to allocate input stream for file %s", fileName);
+      return -1;
     }
 
     if (!inputStream->OpenFile(fileName, true)) {
       delete inputStream;
       WEBRTC_TRACE(kTraceError, kTraceFile, _id, "Could not open input file %s",
                    fileName);
       return -1;
     }
 
     if(StartPlayingStream(*inputStream, loop, notificationTimeMs,
@@ skipping 47 matching lines @@
     {
         WEBRTC_TRACE(
             kTraceError,
             kTraceFile,
             _id,
             "StartPlaying called, but already playing or recording file %s",
             (_fileName[0] == '\0') ? "(name not set)" : _fileName);
         return -1;
     }
 
-    if(_ptrFileUtilityObj != NULL)
-    {
-        WEBRTC_TRACE(kTraceError,
-                     kTraceFile,
-                     _id,
-                     "StartPlaying called, but FileUtilityObj already exists!");
-        StopPlaying();
-        return -1;
+    if (_ptrFileUtilityObj != nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "StartPlaying called, but FileUtilityObj already exists!");
+      StopPlaying();
+      return -1;
     }
 
     _ptrFileUtilityObj = new ModuleFileUtility(_id);
-    if(_ptrFileUtilityObj == NULL)
-    {
-        WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
-                     "Failed to create FileUtilityObj!");
-        return -1;
+    if (_ptrFileUtilityObj == nullptr) {
+      WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
+                   "Failed to create FileUtilityObj!");
+      return -1;
     }
 
     switch(format)
     {
         case kFileFormatWavFile:
         {
             if(_ptrFileUtilityObj->InitWavReading(stream, startPointMs,
                                                   stopPointMs) == -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
@@ skipping 15 matching lines @@
                 return -1;
             }
             _fileFormat = kFileFormatCompressedFile;
             break;
         }
         case kFileFormatPcm8kHzFile:
         case kFileFormatPcm16kHzFile:
         case kFileFormatPcm32kHzFile:
         {
             // ValidFileFormat() called in the beginneing of this function
-            // prevents codecInst from being NULL here.
-            assert(codecInst != NULL);
+            // prevents codecInst from being null here.
+            assert(codecInst != nullptr);
             if(!ValidFrequency(codecInst->plfreq) ||
                _ptrFileUtilityObj->InitPCMReading(stream, startPointMs,
                                                   stopPointMs,
                                                   codecInst->plfreq) == -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                              "Not a valid raw 8 or 16 KHz PCM file!");
                 StopPlaying();
                 return -1;
             }
 
             _fileFormat = format;
             break;
         }
         case kFileFormatPreencodedFile:
         {
             // ValidFileFormat() called in the beginneing of this function
-            // prevents codecInst from being NULL here.
-            assert(codecInst != NULL);
+            // prevents codecInst from being null here.
+            assert(codecInst != nullptr);
             if(_ptrFileUtilityObj->InitPreEncodedReading(stream, *codecInst) ==
                -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                              "Not a valid PreEncoded file!");
                 StopPlaying();
                 return -1;
             }
 
             _fileFormat = kFileFormatPreencodedFile;
@@ skipping 32 matching lines @@
 }
 
 int32_t MediaFileImpl::StopPlaying()
 {
 
     CriticalSectionScoped lock(_crit);
     _isStereo = false;
     if(_ptrFileUtilityObj)
     {
         delete _ptrFileUtilityObj;
-        _ptrFileUtilityObj = NULL;
+        _ptrFileUtilityObj = nullptr;
     }
     if(_ptrInStream)
     {
         // If MediaFileImpl opened the InStream it must be reclaimed here.
         if(_openFile)
         {
             delete _ptrInStream;
             _openFile = false;
         }
-        _ptrInStream = NULL;
+        _ptrInStream = nullptr;
     }
 
     codec_info_.pltype = 0;
     codec_info_.plname[0] = '\0';
 
     if(!_playingActive)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                      "playing is not active!");
         return -1;
@@ skipping 11 matching lines @@
 }
 
 int32_t MediaFileImpl::IncomingAudioData(
     const int8_t*  buffer,
     const size_t bufferLengthInBytes)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "MediaFile::IncomingData(buffer= 0x%x, bufLen= %" PRIuS,
                  buffer, bufferLengthInBytes);
 
-    if(buffer == NULL || bufferLengthInBytes == 0)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                     "Buffer pointer or length is NULL!");
-        return -1;
+    if (buffer == nullptr || bufferLengthInBytes == 0) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "Buffer pointer or length is null!");
+      return -1;
     }
 
     bool recordingEnded = false;
     uint32_t callbackNotifyMs = 0;
     {
         CriticalSectionScoped lock(_crit);
 
         if(!_recordingActive)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                          "Not currently recording!");
             return -1;
         }
-        if(_ptrOutStream == NULL)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                         "Recording is active, but output stream is NULL!");
-            assert(false);
-            return -1;
+        if (_ptrOutStream == nullptr) {
+          WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                       "Recording is active, but output stream is null!");
+          assert(false);
+          return -1;
         }
 
         int32_t bytesWritten = 0;
         uint32_t samplesWritten = codec_info_.pacsize;
         if(_ptrFileUtilityObj)
         {
             switch(_fileFormat)
             {
                 case kFileFormatPcm8kHzFile:
                 case kFileFormatPcm16kHzFile:
@@ skipping 94 matching lines @@
     if(!ValidFileName(fileName))
     {
         return -1;
     }
     if(!ValidFileFormat(format,&codecInst))
     {
         return -1;
     }
 
     FileWrapper* outputStream = FileWrapper::Create();
-    if(outputStream == NULL)
-    {
-        WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
-                     "Failed to allocate memory for output stream");
-        return -1;
+    if (outputStream == nullptr) {
+      WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
+                   "Failed to allocate memory for output stream");
+      return -1;
     }
 
     if (!outputStream->OpenFile(fileName, false)) {
       delete outputStream;
       WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                    "Could not open output file '%s' for writing!", fileName);
       return -1;
     }
 
     if(maxSizeBytes)
@@ skipping 33 matching lines @@
     {
         WEBRTC_TRACE(
             kTraceError,
             kTraceFile,
             _id,
             "StartRecording called, but already recording or playing file %s!",
                    _fileName);
         return -1;
     }
 
-    if(_ptrFileUtilityObj != NULL)
-    {
-        WEBRTC_TRACE(
-            kTraceError,
-            kTraceFile,
-            _id,
-            "StartRecording called, but fileUtilityObj already exists!");
-        StopRecording();
-        return -1;
+    if (_ptrFileUtilityObj != nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "StartRecording called, but fileUtilityObj already exists!");
+      StopRecording();
+      return -1;
     }
 
     _ptrFileUtilityObj = new ModuleFileUtility(_id);
-    if(_ptrFileUtilityObj == NULL)
-    {
-        WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
-                     "Cannot allocate fileUtilityObj!");
-        return -1;
+    if (_ptrFileUtilityObj == nullptr) {
+      WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
+                   "Cannot allocate fileUtilityObj!");
+      return -1;
     }
 
     CodecInst tmpAudioCodec;
     memcpy(&tmpAudioCodec, &codecInst, sizeof(CodecInst));
     switch(format)
     {
         case kFileFormatWavFile:
         {
             if(_ptrFileUtilityObj->InitWavWriting(stream, codecInst) == -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                              "Failed to initialize WAV file!");
                 delete _ptrFileUtilityObj;
-                _ptrFileUtilityObj = NULL;
+                _ptrFileUtilityObj = nullptr;
                 return -1;
             }
             _fileFormat = kFileFormatWavFile;
             break;
         }
         case kFileFormatCompressedFile:
         {
             // Write compression codec name at beginning of file
             if(_ptrFileUtilityObj->InitCompressedWriting(stream, codecInst) ==
                -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                              "Failed to initialize Compressed file!");
                 delete _ptrFileUtilityObj;
-                _ptrFileUtilityObj = NULL;
+                _ptrFileUtilityObj = nullptr;
                 return -1;
             }
             _fileFormat = kFileFormatCompressedFile;
             break;
         }
         case kFileFormatPcm8kHzFile:
         case kFileFormatPcm16kHzFile:
         {
             if(!ValidFrequency(codecInst.plfreq) ||
                _ptrFileUtilityObj->InitPCMWriting(stream, codecInst.plfreq) ==
                -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                              "Failed to initialize 8 or 16KHz PCM file!");
                 delete _ptrFileUtilityObj;
-                _ptrFileUtilityObj = NULL;
+                _ptrFileUtilityObj = nullptr;
                 return -1;
             }
             _fileFormat = format;
             break;
         }
         case kFileFormatPreencodedFile:
         {
             if(_ptrFileUtilityObj->InitPreEncodedWriting(stream, codecInst) ==
                -1)
             {
                 WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                              "Failed to initialize Pre-Encoded file!");
                 delete _ptrFileUtilityObj;
-                _ptrFileUtilityObj = NULL;
+                _ptrFileUtilityObj = nullptr;
                 return -1;
             }
 
             _fileFormat = kFileFormatPreencodedFile;
             break;
         }
         default:
         {
             WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                          "Invalid file format %d specified!", format);
             delete _ptrFileUtilityObj;
-            _ptrFileUtilityObj = NULL;
+            _ptrFileUtilityObj = nullptr;
             return -1;
         }
     }
     _isStereo = (tmpAudioCodec.channels == 2);
     if(_isStereo)
     {
         if(_fileFormat != kFileFormatWavFile)
         {
             WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                          "Stereo is only allowed for WAV files");
@@ skipping 27 matching lines @@
     CriticalSectionScoped lock(_crit);
     if(!_recordingActive)
     {
         WEBRTC_TRACE(kTraceWarning, kTraceFile, _id,
                      "recording is not active!");
         return -1;
     }
 
     _isStereo = false;
 
-    if(_ptrFileUtilityObj != NULL)
-    {
-        // Both AVI and WAV header has to be updated before closing the stream
-        // because they contain size information.
-        if((_fileFormat == kFileFormatWavFile) &&
-            (_ptrOutStream != NULL))
-        {
-            _ptrFileUtilityObj->UpdateWavHeader(*_ptrOutStream);
-        }
-        delete _ptrFileUtilityObj;
-        _ptrFileUtilityObj = NULL;
+    if (_ptrFileUtilityObj != nullptr) {
+      // Both AVI and WAV header has to be updated before closing the stream
+      // because they contain size information.
+      if ((_fileFormat == kFileFormatWavFile) && (_ptrOutStream != nullptr)) {
+        _ptrFileUtilityObj->UpdateWavHeader(*_ptrOutStream);
+      }
+      delete _ptrFileUtilityObj;
+      _ptrFileUtilityObj = nullptr;
     }
 
-    if(_ptrOutStream != NULL)
-    {
-        // If MediaFileImpl opened the OutStream it must be reclaimed here.
-        if(_openFile)
-        {
-            delete _ptrOutStream;
-            _openFile = false;
-        }
-        _ptrOutStream = NULL;
+    if (_ptrOutStream != nullptr) {
+      // If MediaFileImpl opened the OutStream it must be reclaimed here.
+      if (_openFile) {
+        delete _ptrOutStream;
+        _openFile = false;
+      }
+      _ptrOutStream = nullptr;
     }
 
     _recordingActive = false;
     codec_info_.pltype = 0;
     codec_info_.plname[0] = '\0';
 
     return 0;
 }
 
 bool MediaFileImpl::IsRecording()
@@ skipping 41 matching lines @@
     if(!ValidFileName(fileName))
     {
         return -1;
     }
     if(!ValidFrequency(freqInHz))
     {
         return -1;
     }
 
     ModuleFileUtility* utilityObj = new ModuleFileUtility(_id);
-    if(utilityObj == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                     "failed to allocate utility object!");
-        return -1;
+    if (utilityObj == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "failed to allocate utility object!");
+      return -1;
     }
 
     const int32_t duration = utilityObj->FileDurationMs(fileName, format,
                                                         freqInHz);
     delete utilityObj;
     if(duration == -1)
     {
         durationMs = 0;
         return -1;
     }
@@ skipping 30 matching lines @@
             _playingActive ? "Playback" : "Recording");
         return -1;
     }
     memcpy(&codecInst,&codec_info_,sizeof(CodecInst));
     return 0;
 }
 
 bool MediaFileImpl::ValidFileFormat(const FileFormats format,
                                     const CodecInst*  codecInst)
 {
-    if(codecInst == NULL)
-    {
-        if(format == kFileFormatPreencodedFile ||
-           format == kFileFormatPcm8kHzFile    ||
-           format == kFileFormatPcm16kHzFile   ||
-           format == kFileFormatPcm32kHzFile)
-        {
-            WEBRTC_TRACE(kTraceError, kTraceFile, -1,
-                         "Codec info required for file format specified!");
-            return false;
-        }
+  if (codecInst == nullptr) {
+    if (format == kFileFormatPreencodedFile ||
+        format == kFileFormatPcm8kHzFile || format == kFileFormatPcm16kHzFile ||
+        format == kFileFormatPcm32kHzFile) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, -1,
+                   "Codec info required for file format specified!");
+      return false;
+    }
     }
     return true;
 }
 
 bool MediaFileImpl::ValidFileName(const char* fileName)
 {
-    if((fileName == NULL) ||(fileName[0] == '\0'))
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, -1, "FileName not specified!");
-        return false;
+  if ((fileName == nullptr) || (fileName[0] == '\0')) {
+    WEBRTC_TRACE(kTraceError, kTraceFile, -1, "FileName not specified!");
+    return false;
     }
     return true;
 }
 
 
 bool MediaFileImpl::ValidFilePositions(const uint32_t startPointMs,
                                        const uint32_t stopPointMs)
 {
     if(startPointMs == 0 && stopPointMs == 0) // Default values
     {
@@ skipping 18 matching lines @@
 {
     if((frequency == 8000) || (frequency == 16000)|| (frequency == 32000))
     {
         return true;
     }
     WEBRTC_TRACE(kTraceError, kTraceFile, -1,
                  "Frequency should be 8000, 16000 or 32000 (Hz)");
     return false;
 }
 }  // namespace webrtc