Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_processing/aec/echo_cancellation.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 106 matching lines @@
                             size_t num_bands,
                             float* const* out,
                             size_t num_samples,
                             int16_t reported_delay_ms,
                             int32_t skew);
 
 void* WebRtcAec_Create() {
   Aec* aecpc = new Aec();
 
   if (!aecpc) {
-    return NULL;
+    return nullptr;
   }
   aecpc->data_dumper.reset(new ApmDataDumper(aecpc->instance_count));
 
   aecpc->aec = WebRtcAec_CreateAec(aecpc->instance_count);
   if (!aecpc->aec) {
     WebRtcAec_Free(aecpc);
-    return NULL;
+    return nullptr;
   }
   aecpc->resampler = WebRtcAec_CreateResampler();
   if (!aecpc->resampler) {
     WebRtcAec_Free(aecpc);
-    return NULL;
+    return nullptr;
   }
   // Create far-end pre-buffer. The buffer size has to be large enough for
   // largest possible drift compensation (kResamplerBufferSize) + "almost" an
   // FFT buffer (PART_LEN2 - 1).
   aecpc->far_pre_buf =
       WebRtc_CreateBuffer(PART_LEN2 + kResamplerBufferSize, sizeof(float));
   if (!aecpc->far_pre_buf) {
     WebRtcAec_Free(aecpc);
-    return NULL;
+    return nullptr;
   }
 
   aecpc->initFlag = 0;
 
   aecpc->instance_count++;
   return aecpc;
 }
 
 void WebRtcAec_Free(void* aecInst) {
   Aec* aecpc = reinterpret_cast<Aec*>(aecInst);
 
-  if (aecpc == NULL) {
+  if (aecpc == nullptr) {
     return;
   }
 
   WebRtc_FreeBuffer(aecpc->far_pre_buf);
 
   WebRtcAec_FreeAec(aecpc->aec);
   WebRtcAec_FreeResampler(aecpc->resampler);
   delete aecpc;
 }
 
@@ skipping 122 matching lines @@
   WebRtcAec_SetSystemDelay(aecpc->aec, WebRtcAec_system_delay(aecpc->aec) +
                            static_cast<int>(newNrOfSamples));
 
   // Write the time-domain data to |far_pre_buf|.
   WebRtc_WriteBuffer(aecpc->far_pre_buf, farend_ptr, newNrOfSamples);
 
   // TODO(minyue): reduce to |PART_LEN| samples for each buffering.
   while (WebRtc_available_read(aecpc->far_pre_buf) >= PART_LEN2) {
     // We have enough data to pass to the FFT, hence read PART_LEN2 samples.
     {
-      float* ptmp = NULL;
+      float* ptmp = nullptr;
       float tmp[PART_LEN2];
       WebRtc_ReadBuffer(aecpc->far_pre_buf,
                         reinterpret_cast<void**>(&ptmp), tmp, PART_LEN2);
       WebRtcAec_BufferFarendBlock(aecpc->aec, &ptmp[PART_LEN]);
     }
 
     // Rewind |far_pre_buf| PART_LEN samples for overlap before continuing.
     WebRtc_MoveReadPtr(aecpc->far_pre_buf, -PART_LEN);
   }
 
   return 0;
 }
 
 int32_t WebRtcAec_Process(void* aecInst,
                           const float* const* nearend,
                           size_t num_bands,
                           float* const* out,
                           size_t nrOfSamples,
                           int16_t msInSndCardBuf,
                           int32_t skew) {
   Aec* aecpc = reinterpret_cast<Aec*>(aecInst);
   int32_t retVal = 0;
 
-  if (out == NULL) {
+  if (out == nullptr) {
     return AEC_NULL_POINTER_ERROR;
   }
 
   if (aecpc->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
 
   // number of samples == 160 for SWB input
   if (nrOfSamples != 80 && nrOfSamples != 160) {
     return AEC_BAD_PARAMETER_ERROR;
@@ skipping 48 matching lines @@
     return AEC_BAD_PARAMETER_ERROR;
   }
 
   WebRtcAec_SetConfigCore(self->aec, config.nlpMode, config.metricsMode,
                           config.delay_logging);
   return 0;
 }
 
 int WebRtcAec_get_echo_status(void* handle, int* status) {
   Aec* self = reinterpret_cast<Aec*>(handle);
-  if (status == NULL) {
+  if (status == nullptr) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
 
   *status = WebRtcAec_echo_state(self->aec);
 
   return 0;
 }
 
 int WebRtcAec_GetMetrics(void* handle, AecMetrics* metrics) {
   const float kUpWeight = 0.7f;
   float dtmp;
   int stmp;
   Aec* self = reinterpret_cast<Aec*>(handle);
   Stats erl;
   Stats erle;
   Stats a_nlp;
 
-  if (handle == NULL) {
+  if (handle == nullptr) {
     return -1;
   }
-  if (metrics == NULL) {
+  if (metrics == nullptr) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
 
   WebRtcAec_GetEchoStats(self->aec, &erl, &erle, &a_nlp,
                          &metrics->divergent_filter_fraction);
 
   // ERL
@@ skipping 68 matching lines @@
   }
 
   return 0;
 }
 
 int WebRtcAec_GetDelayMetrics(void* handle,
                               int* median,
                               int* std,
                               float* fraction_poor_delays) {
   Aec* self = reinterpret_cast<Aec*>(handle);
-  if (median == NULL) {
+  if (median == nullptr) {
     return AEC_NULL_POINTER_ERROR;
   }
-  if (std == NULL) {
+  if (std == nullptr) {
     return AEC_NULL_POINTER_ERROR;
   }
   if (self->initFlag != initCheck) {
     return AEC_UNINITIALIZED_ERROR;
   }
   if (WebRtcAec_GetDelayMetricsCore(self->aec, median, std,
                                     fraction_poor_delays) == -1) {
     // Logging disabled.
     return AEC_UNSUPPORTED_FUNCTION_ERROR;
   }
 
   return 0;
 }
 
 AecCore* WebRtcAec_aec_core(void* handle) {
   if (!handle) {
-    return NULL;
+    return nullptr;
   }
   return reinterpret_cast<Aec*>(handle)->aec;
 }
 
 static int ProcessNormal(Aec* aecpc,
                          const float* const* nearend,
                          size_t num_bands,
                          float* const* out,
                          size_t nrOfSamples,
                          int16_t msInSndCardBuf,
@@ skipping 314 matching lines @@
   } else {
     self->timeForDelayChange = 0;
   }
   self->lastDelayDiff = delay_difference;
 
   if (self->timeForDelayChange > 25) {
     self->knownDelay = WEBRTC_SPL_MAX((int)self->filtDelay - 256, 0);
   }
 }
 }  // namespace webrtc