Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_processing/utility/delay_estimator_wrapper.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 107 matching lines @@
       out = SetBit(out, i - kBandFirst);
     }
   }
 
   return out;
 }
 
 void WebRtc_FreeDelayEstimatorFarend(void* handle) {
   DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
 
-  if (handle == NULL) {
+  if (handle == nullptr) {
     return;
   }
 
   free(self->mean_far_spectrum);
-  self->mean_far_spectrum = NULL;
+  self->mean_far_spectrum = nullptr;
 
   WebRtc_FreeBinaryDelayEstimatorFarend(self->binary_farend);
-  self->binary_farend = NULL;
+  self->binary_farend = nullptr;
 
   free(self);
 }
 
 void* WebRtc_CreateDelayEstimatorFarend(int spectrum_size, int history_size) {
-  DelayEstimatorFarend* self = NULL;
+  DelayEstimatorFarend* self = nullptr;
 
   // Check if the sub band used in the delay estimation is small enough to fit
   // the binary spectra in a uint32_t.
   static_assert(kBandLast - kBandFirst < 32, "");
 
   if (spectrum_size >= kBandLast) {
     self = static_cast<DelayEstimatorFarend*>(
         malloc(sizeof(DelayEstimatorFarend)));
   }
 
-  if (self != NULL) {
+  if (self != nullptr) {
     int memory_fail = 0;
 
     // Allocate memory for the binary far-end spectrum handling.
     self->binary_farend = WebRtc_CreateBinaryDelayEstimatorFarend(history_size);
-    memory_fail |= (self->binary_farend == NULL);
+    memory_fail |= (self->binary_farend == nullptr);
 
     // Allocate memory for spectrum buffers.
     self->mean_far_spectrum =
         static_cast<SpectrumType*>(malloc(spectrum_size * sizeof(SpectrumType)));
-    memory_fail |= (self->mean_far_spectrum == NULL);
+    memory_fail |= (self->mean_far_spectrum == nullptr);
 
     self->spectrum_size = spectrum_size;
 
     if (memory_fail) {
       WebRtc_FreeDelayEstimatorFarend(self);
-      self = NULL;
+      self = nullptr;
     }
   }
 
   return self;
 }
 
 int WebRtc_InitDelayEstimatorFarend(void* handle) {
   DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
 
   // Initialize far-end part of binary delay estimator.
   WebRtc_InitBinaryDelayEstimatorFarend(self->binary_farend);
 
   // Set averaged far and near end spectra to zero.
   memset(self->mean_far_spectrum, 0,
          sizeof(SpectrumType) * self->spectrum_size);
   // Reset initialization indicators.
   self->far_spectrum_initialized = 0;
 
   return 0;
 }
 
 void WebRtc_SoftResetDelayEstimatorFarend(void* handle, int delay_shift) {
   DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
   RTC_DCHECK(self);
   WebRtc_SoftResetBinaryDelayEstimatorFarend(self->binary_farend, delay_shift);
 }
 
 int WebRtc_AddFarSpectrumFix(void* handle,
                              const uint16_t* far_spectrum,
                              int spectrum_size,
                              int far_q) {
   DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
   uint32_t binary_spectrum = 0;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
-  if (far_spectrum == NULL) {
+  if (far_spectrum == nullptr) {
     // Empty far end spectrum.
     return -1;
   }
   if (spectrum_size != self->spectrum_size) {
     // Data sizes don't match.
     return -1;
   }
   if (far_q > 15) {
     // If |far_q| is larger than 15 we cannot guarantee no wrap around.
     return -1;
   }
 
   // Get binary spectrum.
   binary_spectrum = BinarySpectrumFix(far_spectrum, self->mean_far_spectrum,
                                       far_q, &(self->far_spectrum_initialized));
   WebRtc_AddBinaryFarSpectrum(self->binary_farend, binary_spectrum);
 
   return 0;
 }
 
 int WebRtc_AddFarSpectrumFloat(void* handle,
                                const float* far_spectrum,
                                int spectrum_size) {
   DelayEstimatorFarend* self = (DelayEstimatorFarend*) handle;
   uint32_t binary_spectrum = 0;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
-  if (far_spectrum == NULL) {
+  if (far_spectrum == nullptr) {
     // Empty far end spectrum.
     return -1;
   }
   if (spectrum_size != self->spectrum_size) {
     // Data sizes don't match.
     return -1;
   }
 
   // Get binary spectrum.
   binary_spectrum = BinarySpectrumFloat(far_spectrum, self->mean_far_spectrum,
                                         &(self->far_spectrum_initialized));
   WebRtc_AddBinaryFarSpectrum(self->binary_farend, binary_spectrum);
 
   return 0;
 }
 
 void WebRtc_FreeDelayEstimator(void* handle) {
   DelayEstimator* self = (DelayEstimator*) handle;
 
-  if (handle == NULL) {
+  if (handle == nullptr) {
     return;
   }
 
   free(self->mean_near_spectrum);
-  self->mean_near_spectrum = NULL;
+  self->mean_near_spectrum = nullptr;
 
   WebRtc_FreeBinaryDelayEstimator(self->binary_handle);
-  self->binary_handle = NULL;
+  self->binary_handle = nullptr;
 
   free(self);
 }
 
 void* WebRtc_CreateDelayEstimator(void* farend_handle, int max_lookahead) {
-  DelayEstimator* self = NULL;
+  DelayEstimator* self = nullptr;
   DelayEstimatorFarend* farend = (DelayEstimatorFarend*) farend_handle;
 
-  if (farend_handle != NULL) {
+  if (farend_handle != nullptr) {
     self = static_cast<DelayEstimator*>(malloc(sizeof(DelayEstimator)));
   }
 
-  if (self != NULL) {
+  if (self != nullptr) {
     int memory_fail = 0;
 
     // Allocate memory for the farend spectrum handling.
     self->binary_handle =
         WebRtc_CreateBinaryDelayEstimator(farend->binary_farend, max_lookahead);
-    memory_fail |= (self->binary_handle == NULL);
+    memory_fail |= (self->binary_handle == nullptr);
 
     // Allocate memory for spectrum buffers.
     self->mean_near_spectrum = static_cast<SpectrumType*>(
         malloc(farend->spectrum_size * sizeof(SpectrumType)));
-    memory_fail |= (self->mean_near_spectrum == NULL);
+    memory_fail |= (self->mean_near_spectrum == nullptr);
 
     self->spectrum_size = farend->spectrum_size;
 
     if (memory_fail) {
       WebRtc_FreeDelayEstimator(self);
-      self = NULL;
+      self = nullptr;
     }
   }
 
   return self;
 }
 
 int WebRtc_InitDelayEstimator(void* handle) {
   DelayEstimator* self = (DelayEstimator*) handle;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
 
   // Initialize binary delay estimator.
   WebRtc_InitBinaryDelayEstimator(self->binary_handle);
 
   // Set averaged far and near end spectra to zero.
   memset(self->mean_near_spectrum, 0,
          sizeof(SpectrumType) * self->spectrum_size);
   // Reset initialization indicators.
   self->near_spectrum_initialized = 0;
 
   return 0;
 }
 
 int WebRtc_SoftResetDelayEstimator(void* handle, int delay_shift) {
   DelayEstimator* self = (DelayEstimator*) handle;
   RTC_DCHECK(self);
   return WebRtc_SoftResetBinaryDelayEstimator(self->binary_handle, delay_shift);
 }
 
 int WebRtc_set_history_size(void* handle, int history_size) {
   DelayEstimator* self = static_cast<DelayEstimator*>(handle);
 
-  if ((self == NULL) || (history_size <= 1)) {
+  if ((self == nullptr) || (history_size <= 1)) {
     return -1;
   }
   return WebRtc_AllocateHistoryBufferMemory(self->binary_handle, history_size);
 }
 
 int WebRtc_history_size(const void* handle) {
   const DelayEstimator* self = static_cast<const DelayEstimator*>(handle);
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
   if (self->binary_handle->farend->history_size !=
       self->binary_handle->history_size) {
     // Non matching history sizes.
     return -1;
   }
   return self->binary_handle->history_size;
 }
 
@@ skipping 12 matching lines @@
 int WebRtc_lookahead(void* handle) {
   DelayEstimator* self = (DelayEstimator*) handle;
   RTC_DCHECK(self);
   RTC_DCHECK(self->binary_handle);
   return self->binary_handle->lookahead;
 }
 
 int WebRtc_set_allowed_offset(void* handle, int allowed_offset) {
   DelayEstimator* self = (DelayEstimator*) handle;
 
-  if ((self == NULL) || (allowed_offset < 0)) {
+  if ((self == nullptr) || (allowed_offset < 0)) {
     return -1;
   }
   self->binary_handle->allowed_offset = allowed_offset;
   return 0;
 }
 
 int WebRtc_get_allowed_offset(const void* handle) {
   const DelayEstimator* self = (const DelayEstimator*) handle;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
   return self->binary_handle->allowed_offset;
 }
 
 int WebRtc_enable_robust_validation(void* handle, int enable) {
   DelayEstimator* self = (DelayEstimator*) handle;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
   if ((enable < 0) || (enable > 1)) {
     return -1;
   }
   RTC_DCHECK(self->binary_handle);
   self->binary_handle->robust_validation_enabled = enable;
   return 0;
 }
 
 int WebRtc_is_robust_validation_enabled(const void* handle) {
   const DelayEstimator* self = (const DelayEstimator*) handle;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
   return self->binary_handle->robust_validation_enabled;
 }
 
 int WebRtc_DelayEstimatorProcessFix(void* handle,
                                     const uint16_t* near_spectrum,
                                     int spectrum_size,
                                     int near_q) {
   DelayEstimator* self = (DelayEstimator*) handle;
   uint32_t binary_spectrum = 0;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
-  if (near_spectrum == NULL) {
+  if (near_spectrum == nullptr) {
     // Empty near end spectrum.
     return -1;
   }
   if (spectrum_size != self->spectrum_size) {
     // Data sizes don't match.
     return -1;
   }
   if (near_q > 15) {
     // If |near_q| is larger than 15 we cannot guarantee no wrap around.
     return -1;
   }
 
   // Get binary spectra.
   binary_spectrum = BinarySpectrumFix(near_spectrum,
                                       self->mean_near_spectrum,
                                       near_q,
                                       &(self->near_spectrum_initialized));
 
   return WebRtc_ProcessBinarySpectrum(self->binary_handle, binary_spectrum);
 }
 
 int WebRtc_DelayEstimatorProcessFloat(void* handle,
                                       const float* near_spectrum,
                                       int spectrum_size) {
   DelayEstimator* self = (DelayEstimator*) handle;
   uint32_t binary_spectrum = 0;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
-  if (near_spectrum == NULL) {
+  if (near_spectrum == nullptr) {
     // Empty near end spectrum.
     return -1;
   }
   if (spectrum_size != self->spectrum_size) {
     // Data sizes don't match.
     return -1;
   }
 
   // Get binary spectrum.
   binary_spectrum = BinarySpectrumFloat(near_spectrum, self->mean_near_spectrum,
                                         &(self->near_spectrum_initialized));
 
   return WebRtc_ProcessBinarySpectrum(self->binary_handle, binary_spectrum);
 }
 
 int WebRtc_last_delay(void* handle) {
   DelayEstimator* self = (DelayEstimator*) handle;
 
-  if (self == NULL) {
+  if (self == nullptr) {
     return -1;
   }
 
   return WebRtc_binary_last_delay(self->binary_handle);
 }
 
 float WebRtc_last_delay_quality(void* handle) {
   DelayEstimator* self = (DelayEstimator*) handle;
   RTC_DCHECK(self);
   return WebRtc_binary_last_delay_quality(self->binary_handle);
 }