Replace NULL with nullptr in all C++ files.

webrtc/modules/audio_processing/utility/delay_estimator.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 240 matching lines @@
   // iii) With one exception, i.e., the histogram based algorithm can overrule
   //      the instantaneous one if |is_histogram_valid| = 1 and the histogram
   //      is significantly strong.
   is_robust |= is_histogram_valid &&
       (self->histogram[candidate_delay] > self->last_delay_histogram);
 
   return is_robust;
 }
 
 void WebRtc_FreeBinaryDelayEstimatorFarend(BinaryDelayEstimatorFarend* self) {
-
-  if (self == NULL) {
+  if (self == nullptr) {
     return;
   }
 
   free(self->binary_far_history);
-  self->binary_far_history = NULL;
+  self->binary_far_history = nullptr;
 
   free(self->far_bit_counts);
-  self->far_bit_counts = NULL;
+  self->far_bit_counts = nullptr;
 
   free(self);
 }
 
 BinaryDelayEstimatorFarend* WebRtc_CreateBinaryDelayEstimatorFarend(
     int history_size) {
-  BinaryDelayEstimatorFarend* self = NULL;
+  BinaryDelayEstimatorFarend* self = nullptr;
 
   if (history_size > 1) {
     // Sanity conditions fulfilled.
     self = static_cast<BinaryDelayEstimatorFarend*>(
         malloc(sizeof(BinaryDelayEstimatorFarend)));
   }
-  if (self == NULL) {
-    return NULL;
+  if (self == nullptr) {
+    return nullptr;
   }
 
   self->history_size = 0;
-  self->binary_far_history = NULL;
-  self->far_bit_counts = NULL;
+  self->binary_far_history = nullptr;
+  self->far_bit_counts = nullptr;
   if (WebRtc_AllocateFarendBufferMemory(self, history_size) == 0) {
     WebRtc_FreeBinaryDelayEstimatorFarend(self);
-    self = NULL;
+    self = nullptr;
   }
   return self;
 }
 
 int WebRtc_AllocateFarendBufferMemory(BinaryDelayEstimatorFarend* self,
                                       int history_size) {
   RTC_DCHECK(self);
   // (Re-)Allocate memory for history buffers.
   self->binary_far_history = static_cast<uint32_t*>(
       realloc(self->binary_far_history,
               history_size * sizeof(*self->binary_far_history)));
   self->far_bit_counts = static_cast<int*>(
       realloc(self->far_bit_counts,
               history_size * sizeof(*self->far_bit_counts)));
-  if ((self->binary_far_history == NULL) || (self->far_bit_counts == NULL)) {
+  if ((self->binary_far_history == nullptr) ||
+      (self->far_bit_counts == nullptr)) {
     history_size = 0;
   }
   // Fill with zeros if we have expanded the buffers.
   if (history_size > self->history_size) {
     int size_diff = history_size - self->history_size;
     memset(&self->binary_far_history[self->history_size],
            0,
            sizeof(*self->binary_far_history) * size_diff);
     memset(&self->far_bit_counts[self->history_size],
            0,
@@ skipping 52 matching lines @@
   handle->binary_far_history[0] = binary_far_spectrum;
 
   // Shift history of far-end binary spectrum bit counts and insert bit count
   // of current |binary_far_spectrum|.
   memmove(&(handle->far_bit_counts[1]), &(handle->far_bit_counts[0]),
           (handle->history_size - 1) * sizeof(int));
   handle->far_bit_counts[0] = BitCount(binary_far_spectrum);
 }
 
 void WebRtc_FreeBinaryDelayEstimator(BinaryDelayEstimator* self) {
-
-  if (self == NULL) {
+  if (self == nullptr) {
     return;
   }
 
   free(self->mean_bit_counts);
-  self->mean_bit_counts = NULL;
+  self->mean_bit_counts = nullptr;
 
   free(self->bit_counts);
-  self->bit_counts = NULL;
+  self->bit_counts = nullptr;
 
   free(self->binary_near_history);
-  self->binary_near_history = NULL;
+  self->binary_near_history = nullptr;
 
   free(self->histogram);
-  self->histogram = NULL;
+  self->histogram = nullptr;
 
   // BinaryDelayEstimator does not have ownership of |farend|, hence we do not
   // free the memory here. That should be handled separately by the user.
-  self->farend = NULL;
+  self->farend = nullptr;
 
   free(self);
 }
 
 BinaryDelayEstimator* WebRtc_CreateBinaryDelayEstimator(
     BinaryDelayEstimatorFarend* farend, int max_lookahead) {
-  BinaryDelayEstimator* self = NULL;
+  BinaryDelayEstimator* self = nullptr;
 
-  if ((farend != NULL) && (max_lookahead >= 0)) {
+  if ((farend != nullptr) && (max_lookahead >= 0)) {
     // Sanity conditions fulfilled.
     self = static_cast<BinaryDelayEstimator*>(
         malloc(sizeof(BinaryDelayEstimator)));
   }
-  if (self == NULL) {
-    return NULL;
+  if (self == nullptr) {
+    return nullptr;
   }
 
   self->farend = farend;
   self->near_history_size = max_lookahead + 1;
   self->history_size = 0;
   self->robust_validation_enabled = 0;  // Disabled by default.
   self->allowed_offset = 0;
 
   self->lookahead = max_lookahead;
 
   // Allocate memory for spectrum and history buffers.
-  self->mean_bit_counts = NULL;
-  self->bit_counts = NULL;
-  self->histogram = NULL;
+  self->mean_bit_counts = nullptr;
+  self->bit_counts = nullptr;
+  self->histogram = nullptr;
   self->binary_near_history = static_cast<uint32_t*>(
       malloc((max_lookahead + 1) * sizeof(*self->binary_near_history)));
-  if (self->binary_near_history == NULL ||
+  if (self->binary_near_history == nullptr ||
       WebRtc_AllocateHistoryBufferMemory(self, farend->history_size) == 0) {
     WebRtc_FreeBinaryDelayEstimator(self);
-    self = NULL;
+    self = nullptr;
   }
 
   return self;
 }
 
 int WebRtc_AllocateHistoryBufferMemory(BinaryDelayEstimator* self,
                                        int history_size) {
   BinaryDelayEstimatorFarend* far = self->farend;
   // (Re-)Allocate memory for spectrum and history buffers.
   if (history_size != far->history_size) {
     // Only update far-end buffers if we need.
     history_size = WebRtc_AllocateFarendBufferMemory(far, history_size);
   }
   // The extra array element in |mean_bit_counts| and |histogram| is a dummy
   // element only used while |last_delay| == -2, i.e., before we have a valid
   // estimate.
   self->mean_bit_counts = static_cast<int32_t*>(
       realloc(self->mean_bit_counts,
               (history_size + 1) * sizeof(*self->mean_bit_counts)));
   self->bit_counts = static_cast<int32_t*>(
       realloc(self->bit_counts, history_size * sizeof(*self->bit_counts)));
   self->histogram = static_cast<float*>(
       realloc(self->histogram, (history_size + 1) * sizeof(*self->histogram)));
 
-  if ((self->mean_bit_counts == NULL) ||
-      (self->bit_counts == NULL) ||
-      (self->histogram == NULL)) {
+  if ((self->mean_bit_counts == nullptr) || (self->bit_counts == nullptr) ||
+      (self->histogram == nullptr)) {
     history_size = 0;
   }
   // Fill with zeros if we have expanded the buffers.
   if (history_size > self->history_size) {
     int size_diff = history_size - self->history_size;
     memset(&self->mean_bit_counts[self->history_size],
            0,
            sizeof(*self->mean_bit_counts) * size_diff);
     memset(&self->bit_counts[self->history_size],
            0,
@@ skipping 221 matching lines @@
   int32_t diff = new_value - *mean_value;
 
   // mean_new = mean_value + ((new_value - mean_value) >> factor);
   if (diff < 0) {
     diff = -((-diff) >> factor);
   } else {
     diff = (diff >> factor);
   }
   *mean_value += diff;
 }