Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_processing/aecm/aecm_core.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 169 matching lines @@
 //
 // Inputs:
 //      - self              : Pointer to the AECM instance.
 //      - delay             : Current delay estimate.
 //
 // Output:
 //      - far_q             : The Q-domain of the aligned far end spectrum
 //
 // Return value:
 //      - far_spectrum      : Pointer to the aligned far end spectrum
-//                            NULL - Error
+//                            null - Error
 //
 const uint16_t* WebRtcAecm_AlignedFarend(AecmCore* self,
                                          int* far_q,
                                          int delay) {
   int buffer_position = 0;
   RTC_DCHECK(self);
   buffer_position = self->far_history_pos - delay;
 
   // Check buffer position
   if (buffer_position < 0) {
@@ skipping 11 matching lines @@
 ResetAdaptiveChannel WebRtcAecm_ResetAdaptiveChannel;
 
 AecmCore* WebRtcAecm_CreateCore() {
     AecmCore* aecm = static_cast<AecmCore*>(malloc(sizeof(AecmCore)));
 
     aecm->farFrameBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
                                             sizeof(int16_t));
     if (!aecm->farFrameBuf)
     {
         WebRtcAecm_FreeCore(aecm);
-        return NULL;
+        return nullptr;
     }
 
     aecm->nearNoisyFrameBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
                                                   sizeof(int16_t));
     if (!aecm->nearNoisyFrameBuf)
     {
         WebRtcAecm_FreeCore(aecm);
-        return NULL;
+        return nullptr;
     }
 
     aecm->nearCleanFrameBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
                                                   sizeof(int16_t));
     if (!aecm->nearCleanFrameBuf)
     {
         WebRtcAecm_FreeCore(aecm);
-        return NULL;
+        return nullptr;
     }
 
     aecm->outFrameBuf = WebRtc_CreateBuffer(FRAME_LEN + PART_LEN,
                                             sizeof(int16_t));
     if (!aecm->outFrameBuf)
     {
         WebRtcAecm_FreeCore(aecm);
-        return NULL;
+        return nullptr;
     }
 
     aecm->delay_estimator_farend = WebRtc_CreateDelayEstimatorFarend(PART_LEN1,
                                                                      MAX_DELAY);
-    if (aecm->delay_estimator_farend == NULL) {
+    if (aecm->delay_estimator_farend == nullptr) {
       WebRtcAecm_FreeCore(aecm);
-      return NULL;
+      return nullptr;
     }
     aecm->delay_estimator =
         WebRtc_CreateDelayEstimator(aecm->delay_estimator_farend, 0);
-    if (aecm->delay_estimator == NULL) {
+    if (aecm->delay_estimator == nullptr) {
       WebRtcAecm_FreeCore(aecm);
-      return NULL;
+      return nullptr;
     }
     // TODO(bjornv): Explicitly disable robust delay validation until no
     // performance regression has been established.  Then remove the line.
     WebRtc_enable_robust_validation(aecm->delay_estimator, 0);
 
     aecm->real_fft = WebRtcSpl_CreateRealFFT(PART_LEN_SHIFT);
-    if (aecm->real_fft == NULL) {
+    if (aecm->real_fft == nullptr) {
       WebRtcAecm_FreeCore(aecm);
-      return NULL;
+      return nullptr;
     }
 
     // Init some aecm pointers. 16 and 32 byte alignment is only necessary
     // for Neon code currently.
     aecm->xBuf = (int16_t*) (((uintptr_t)aecm->xBuf_buf + 31) & ~ 31);
     aecm->dBufClean = (int16_t*) (((uintptr_t)aecm->dBufClean_buf + 31) & ~ 31);
     aecm->dBufNoisy = (int16_t*) (((uintptr_t)aecm->dBufNoisy_buf + 31) & ~ 31);
     aecm->outBuf = (int16_t*) (((uintptr_t)aecm->outBuf_buf + 15) & ~ 15);
     aecm->channelStored = (int16_t*) (((uintptr_t)
                                              aecm->channelStored_buf + 15) & ~ 15);
@@ skipping 246 matching lines @@
 // TODO(bjornv): This function is currently not used. Add support for these
 // parameters from a higher level
 int WebRtcAecm_Control(AecmCore* aecm, int delay, int nlpFlag) {
     aecm->nlpFlag = nlpFlag;
     aecm->fixedDelay = delay;
 
     return 0;
 }
 
 void WebRtcAecm_FreeCore(AecmCore* aecm) {
-    if (aecm == NULL) {
-      return;
+  if (aecm == nullptr) {
+    return;
     }
 
     WebRtc_FreeBuffer(aecm->farFrameBuf);
     WebRtc_FreeBuffer(aecm->nearNoisyFrameBuf);
     WebRtc_FreeBuffer(aecm->nearCleanFrameBuf);
     WebRtc_FreeBuffer(aecm->outFrameBuf);
 
     WebRtc_FreeDelayEstimator(aecm->delay_estimator);
     WebRtc_FreeDelayEstimatorFarend(aecm->delay_estimator_farend);
     WebRtcSpl_FreeRealFFT(aecm->real_fft);
 
     free(aecm);
 }
 
 int WebRtcAecm_ProcessFrame(AecmCore* aecm,
                             const int16_t* farend,
                             const int16_t* nearendNoisy,
                             const int16_t* nearendClean,
                             int16_t* out) {
     int16_t outBlock_buf[PART_LEN + 8]; // Align buffer to 8-byte boundary.
     int16_t* outBlock = (int16_t*) (((uintptr_t) outBlock_buf + 15) & ~ 15);
 
     int16_t farFrame[FRAME_LEN];
-    const int16_t* out_ptr = NULL;
+    const int16_t* out_ptr = nullptr;
     int size = 0;
 
     // Buffer the current frame.
     // Fetch an older one corresponding to the delay.
     WebRtcAecm_BufferFarFrame(aecm, farend, FRAME_LEN);
     WebRtcAecm_FetchFarFrame(aecm, farFrame, FRAME_LEN, aecm->knownDelay);
 
     // Buffer the synchronized far and near frames,
     // to pass the smaller blocks individually.
     WebRtc_WriteBuffer(aecm->farFrameBuf, farFrame, FRAME_LEN);
     WebRtc_WriteBuffer(aecm->nearNoisyFrameBuf, nearendNoisy, FRAME_LEN);
-    if (nearendClean != NULL)
-    {
-        WebRtc_WriteBuffer(aecm->nearCleanFrameBuf, nearendClean, FRAME_LEN);
+    if (nearendClean != nullptr) {
+      WebRtc_WriteBuffer(aecm->nearCleanFrameBuf, nearendClean, FRAME_LEN);
     }
 
     // Process as many blocks as possible.
     while (WebRtc_available_read(aecm->farFrameBuf) >= PART_LEN)
     {
         int16_t far_block[PART_LEN];
-        const int16_t* far_block_ptr = NULL;
+        const int16_t* far_block_ptr = nullptr;
         int16_t near_noisy_block[PART_LEN];
-        const int16_t* near_noisy_block_ptr = NULL;
+        const int16_t* near_noisy_block_ptr = nullptr;
 
         WebRtc_ReadBuffer(aecm->farFrameBuf, (void**) &far_block_ptr, far_block,
                           PART_LEN);
         WebRtc_ReadBuffer(aecm->nearNoisyFrameBuf,
                           (void**) &near_noisy_block_ptr,
                           near_noisy_block,
                           PART_LEN);
-        if (nearendClean != NULL)
-        {
-            int16_t near_clean_block[PART_LEN];
-            const int16_t* near_clean_block_ptr = NULL;
+        if (nearendClean != nullptr) {
+          int16_t near_clean_block[PART_LEN];
+          const int16_t* near_clean_block_ptr = nullptr;
 
-            WebRtc_ReadBuffer(aecm->nearCleanFrameBuf,
-                              (void**) &near_clean_block_ptr,
-                              near_clean_block,
-                              PART_LEN);
-            if (WebRtcAecm_ProcessBlock(aecm,
-                                        far_block_ptr,
-                                        near_noisy_block_ptr,
-                                        near_clean_block_ptr,
-                                        outBlock) == -1)
-            {
-                return -1;
-            }
+          WebRtc_ReadBuffer(aecm->nearCleanFrameBuf,
+                            (void**)&near_clean_block_ptr, near_clean_block,
+                            PART_LEN);
+          if (WebRtcAecm_ProcessBlock(aecm, far_block_ptr, near_noisy_block_ptr,
+                                      near_clean_block_ptr, outBlock) == -1) {
+            return -1;
+          }
         } else
         {
-            if (WebRtcAecm_ProcessBlock(aecm,
-                                        far_block_ptr,
-                                        near_noisy_block_ptr,
-                                        NULL,
-                                        outBlock) == -1)
-            {
-                return -1;
+          if (WebRtcAecm_ProcessBlock(aecm, far_block_ptr, near_noisy_block_ptr,
+                                      nullptr, outBlock) == -1) {
+            return -1;
             }
         }
 
         WebRtc_WriteBuffer(aecm->outFrameBuf, outBlock, PART_LEN);
     }
 
     // Stuff the out buffer if we have less than a frame to output.
     // This should only happen for the first frame.
     size = (int) WebRtc_available_read(aecm->outFrameBuf);
     if (size < FRAME_LEN)
@@ skipping 595 matching lines @@
         memcpy(farend + readPos, aecm->farBuf + aecm->farBufReadPos,
                sizeof(int16_t) * readLen);
         aecm->farBufReadPos = 0;
         readPos = readLen;
         readLen = farLen - readLen;
     }
     memcpy(farend + readPos, aecm->farBuf + aecm->farBufReadPos,
            sizeof(int16_t) * readLen);
     aecm->farBufReadPos += readLen;
 }