Replace NULL with nullptr in all C++ files.

webrtc/modules/media_file/media_file_utility.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 407 matching lines @@
     const size_t totalBytesNeeded = _readSizeBytes;
     // The number of bytes that will be written to outData.
     const size_t bytesRequested = (codec_info_.channels == 2) ?
         totalBytesNeeded >> 1 : totalBytesNeeded;
     if(bufferSize < bytesRequested)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "ReadWavDataAsMono: output buffer is too short!");
         return -1;
     }
-    if(outData == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                     "ReadWavDataAsMono: output buffer NULL!");
-        return -1;
+    if (outData == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "ReadWavDataAsMono: output buffer null!");
+      return -1;
     }
 
     if(!_reading)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "ReadWavDataAsMono: no longer reading file.");
         return -1;
     }
 
     int32_t bytesRead = ReadWavData(
@@ skipping 44 matching lines @@
         kTraceStream,
         kTraceFile,
         _id,
         "ModuleFileUtility::ReadWavDataAsStereo(wav= 0x%x, outLeft= 0x%x, "
         "outRight= 0x%x, bufSize= %" PRIuS ")",
         &wav,
         outDataLeft,
         outDataRight,
         bufferSize);
 
-    if((outDataLeft == NULL) ||
-       (outDataRight == NULL))
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                     "ReadWavDataAsMono: an input buffer is NULL!");
-        return -1;
+    if ((outDataLeft == nullptr) || (outDataRight == nullptr)) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "ReadWavDataAsMono: an input buffer is null!");
+      return -1;
     }
     if(codec_info_.channels != 2)
     {
         WEBRTC_TRACE(
             kTraceError,
             kTraceFile,
             _id,
             "ReadWavDataAsStereo: WAV file does not contain stereo data!");
         return -1;
     }
@@ skipping 60 matching lines @@
 }
 
 int32_t ModuleFileUtility::ReadWavData(InStream& wav,
                                        uint8_t* buffer,
                                        size_t dataLengthInBytes)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::ReadWavData(wav= 0x%x, buffer= 0x%x, "
                  "dataLen= %" PRIuS ")", &wav, buffer, dataLengthInBytes);
 
-
-    if(buffer == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                     "ReadWavDataAsMono: output buffer NULL!");
-        return -1;
+    if (buffer == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "ReadWavDataAsMono: output buffer null!");
+      return -1;
     }
 
     // Make sure that a read won't return too few samples.
     // TODO (hellner): why not read the remaining bytes needed from the start
     //                 of the file?
     if(_dataSize < (_readPos + dataLengthInBytes))
     {
         // Rewind() being -1 may be due to the file not supposed to be looped.
         if(wav.Rewind() == -1)
         {
@@ skipping 105 matching lines @@
 }
 
 int32_t ModuleFileUtility::WriteWavData(OutStream& out,
                                         const int8_t*  buffer,
                                         const size_t dataLength)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::WriteWavData(out= 0x%x, buf= 0x%x, "
                  "dataLen= %" PRIuS ")", &out, buffer, dataLength);
 
-    if(buffer == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,
-                     "WriteWavData: input buffer NULL!");
-        return -1;
+    if (buffer == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id,
+                   "WriteWavData: input buffer null!");
+      return -1;
     }
 
     if(!out.Write(buffer, dataLength))
     {
         return -1;
     }
     _bytesWritten += dataLength;
     return static_cast<int32_t>(dataLength);
 }
 
@@ skipping 79 matching lines @@
 int32_t ModuleFileUtility::ReadPreEncodedData(
     InStream& in,
     int8_t* outData,
     const size_t bufferSize)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::ReadPreEncodedData(in= 0x%x, "
                  "outData= 0x%x, bufferSize= %" PRIuS ")", &in, outData,
                  bufferSize);
 
-    if(outData == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "output buffer NULL");
+    if (outData == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id, "output buffer null");
     }
 
     size_t frameLen;
     uint8_t buf[64];
     // Each frame has a two byte header containing the frame length.
     int32_t res = in.Read(buf, 2);
     if(res != 2)
     {
         if(!in.Rewind())
         {
@@ skipping 36 matching lines @@
 int32_t ModuleFileUtility::WritePreEncodedData(
     OutStream& out,
     const int8_t* buffer,
     const size_t dataLength)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::WritePreEncodedData(out= 0x%x, "
                  "inData= 0x%x, dataLen= %" PRIuS ")", &out, buffer,
                  dataLength);
 
-    if(buffer == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,"buffer NULL");
+    if (buffer == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer null");
     }
 
     size_t bytesWritten = 0;
     // The first two bytes is the size of the frame.
     int16_t lengthBuf;
     lengthBuf = (int16_t)dataLength;
     if(dataLength > static_cast<size_t>(std::numeric_limits<int16_t>::max()) ||
        !out.Write(&lengthBuf, 2))
     {
        return -1;
@@ skipping 222 matching lines @@
 
 int32_t ModuleFileUtility::WriteCompressedData(
     OutStream& out,
     const int8_t* buffer,
     const size_t dataLength)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::WriteCompressedData(out= 0x%x, buf= 0x%x, "
                  "dataLen= %" PRIuS ")", &out, buffer, dataLength);
 
-    if(buffer == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id,"buffer NULL");
+    if (buffer == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer null");
     }
 
     if(!out.Write(buffer, dataLength))
     {
         return -1;
     }
     return static_cast<int32_t>(dataLength);
 }
 
 int32_t ModuleFileUtility::InitPCMReading(InStream& pcm,
@@ skipping 63 matching lines @@
 }
 
 int32_t ModuleFileUtility::ReadPCMData(InStream& pcm,
                                        int8_t* outData,
                                        size_t bufferSize)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::ReadPCMData(pcm= 0x%x, outData= 0x%x, "
                  "bufSize= %" PRIuS ")", &pcm, outData, bufferSize);
 
-    if(outData == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer NULL");
+    if (outData == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer null");
     }
 
     // Readsize for 10ms of audio data (2 bytes per sample).
     size_t bytesRequested = static_cast<size_t>(2 * codec_info_.plfreq / 100);
     if(bufferSize <  bytesRequested)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                    "ReadPCMData: buffer not long enough for a 10ms frame.");
         assert(false);
         return -1;
@@ skipping 106 matching lines @@
 }
 
 int32_t ModuleFileUtility::WritePCMData(OutStream& out,
                                         const int8_t*  buffer,
                                         const size_t dataLength)
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::WritePCMData(out= 0x%x, buf= 0x%x, "
                  "dataLen= %" PRIuS ")", &out, buffer, dataLength);
 
-    if(buffer == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer NULL");
+    if (buffer == nullptr) {
+      WEBRTC_TRACE(kTraceError, kTraceFile, _id, "buffer null");
     }
 
     if(!out.Write(buffer, dataLength))
     {
         return -1;
     }
 
     _bytesWritten += dataLength;
     return static_cast<int32_t>(dataLength);
 }
@@ skipping 77 matching lines @@
         return -1;
     }
     memcpy(&codec_info_, &codecInst, sizeof(CodecInst));
     return 0;
 }
 
 int32_t ModuleFileUtility::FileDurationMs(const char* fileName,
                                           const FileFormats fileFormat,
                                           const uint32_t freqInHz)
 {
-
-    if(fileName == NULL)
-    {
-        WEBRTC_TRACE(kTraceError, kTraceFile, _id, "filename NULL");
-        return -1;
+  if (fileName == nullptr) {
+    WEBRTC_TRACE(kTraceError, kTraceFile, _id, "filename null");
+    return -1;
     }
 
     int32_t time_in_ms = -1;
     struct stat file_size;
     if(stat(fileName,&file_size) == -1)
     {
         WEBRTC_TRACE(kTraceError, kTraceFile, _id,
                      "failed to retrieve file size with stat!");
         return -1;
     }
     FileWrapper* inStreamObj = FileWrapper::Create();
-    if(inStreamObj == NULL)
-    {
-        WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
-                     "failed to create InStream object!");
-        return -1;
+    if (inStreamObj == nullptr) {
+      WEBRTC_TRACE(kTraceMemory, kTraceFile, _id,
+                   "failed to create InStream object!");
+      return -1;
     }
     if (!inStreamObj->OpenFile(fileName, true)) {
       delete inStreamObj;
       WEBRTC_TRACE(kTraceError, kTraceFile, _id, "failed to open file %s!",
                    fileName);
       return -1;
     }
 
     switch (fileFormat)
     {
@@ skipping 81 matching lines @@
 }
 
 uint32_t ModuleFileUtility::PlayoutPositionMs()
 {
     WEBRTC_TRACE(kTraceStream, kTraceFile, _id,
                  "ModuleFileUtility::PlayoutPosition()");
 
     return _reading ? _playoutPositionMs : 0;
 }
 }  // namespace webrtc