Replace NULL with nullptr in all C++ files.

webrtc/tools/agc/activity_metric.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 61 matching lines @@
 
 class AgcStat {
  public:
   AgcStat()
       : video_index_(0),
         activity_threshold_(kDefaultActivityThreshold),
         audio_content_(LoudnessHistogram::Create(kAgcAnalWindowSamples)),
         audio_processing_(new VadAudioProc()),
         vad_(new PitchBasedVad()),
         standalone_vad_(StandaloneVad::Create()),
-        audio_content_fid_(NULL) {
+        audio_content_fid_(nullptr) {
     for (size_t n = 0; n < kMaxNumFrames; n++)
       video_vad_[n] = 0.5;
   }
 
   ~AgcStat() {
-    if (audio_content_fid_ != NULL) {
+    if (audio_content_fid_ != nullptr) {
       fclose(audio_content_fid_);
     }
   }
 
   void set_audio_content_file(FILE* audio_content_fid) {
     audio_content_fid_ = audio_content_fid;
   }
 
   int AddAudio(const AudioFrame& frame, double p_video,
                int* combined_vad) {
@@ skipping 23 matching lines @@
         double p_passive = (1 - p[n]) * (1 - video_vad_[n]);
         p[n]  = p_active / (p_active + p_passive);
         // Limit probabilities.
         p[n] = std::min(std::max(p[n], 0.01), 0.99);
       }
       if (vad_->VoicingProbability(features, p) < 0)
         return -1;
       for (size_t n = 0; n < features.num_frames; n++) {
         audio_content_->Update(features.rms[n], p[n]);
         double ac = audio_content_->AudioContent();
-        if (audio_content_fid_ != NULL) {
+        if (audio_content_fid_ != nullptr) {
           fwrite(&ac, sizeof(ac), 1, audio_content_fid_);
         }
         if (ac > kAgcAnalWindowSamples * activity_threshold_) {
           combined_vad[n] = 1;
         } else {
           combined_vad[n] = 0;
         }
       }
       video_index_ = 0;
     }
@@ skipping 18 matching lines @@
   std::unique_ptr<StandaloneVad> standalone_vad_;
 
   FILE* audio_content_fid_;
 };
 
 
 void void_main(int argc, char* argv[]) {
   webrtc::AgcStat agc_stat;
 
   FILE* pcm_fid = fopen(argv[1], "rb");
-  ASSERT_TRUE(pcm_fid != NULL) << "Cannot open PCM file " << argv[1];
+  ASSERT_TRUE(pcm_fid != nullptr) << "Cannot open PCM file " << argv[1];
 
   if (argc < 2) {
     fprintf(stderr, "\nNot Enough arguments\n");
   }
 
-  FILE* true_vad_fid = NULL;
+  FILE* true_vad_fid = nullptr;
   ASSERT_GT(FLAGS_true_vad.size(), 0u) << "Specify the file containing true "
       "VADs using --true_vad flag.";
   true_vad_fid = fopen(FLAGS_true_vad.c_str(), "rb");
-  ASSERT_TRUE(true_vad_fid != NULL) << "Cannot open the active list " <<
-      FLAGS_true_vad;
+  ASSERT_TRUE(true_vad_fid != nullptr) << "Cannot open the active list "
+                                       << FLAGS_true_vad;
 
-  FILE* results_fid = NULL;
+  FILE* results_fid = nullptr;
   if (FLAGS_result.size() > 0) {
     // True if this is the first time writing to this function and we add a
     // header to the beginning of the file.
     bool write_header;
     // Open in the read mode. If it fails, the file doesn't exist and has to
     // write a header for it. Otherwise no need to write a header.
     results_fid = fopen(FLAGS_result.c_str(), "r");
-    if (results_fid == NULL) {
+    if (results_fid == nullptr) {
       write_header = true;
     } else {
       fclose(results_fid);
       write_header = false;
     }
     // Open in append mode.
     results_fid = fopen(FLAGS_result.c_str(), "a");
-    ASSERT_TRUE(results_fid != NULL) << "Cannot open the file, " <<
-              FLAGS_result << ", to write the results.";
+    ASSERT_TRUE(results_fid != nullptr) << "Cannot open the file, "
+                                        << FLAGS_result
+                                        << ", to write the results.";
     // Write the header if required.
     if (write_header) {
       fprintf(results_fid, "%% Total Active,  Misdetection,  "
               "Total inactive,  False Positive,  On-sets,  Missed segments,  "
               "Average response\n");
     }
   }
 
-  FILE* video_vad_fid = NULL;
+  FILE* video_vad_fid = nullptr;
   if (FLAGS_video_vad.size() > 0) {
     video_vad_fid = fopen(FLAGS_video_vad.c_str(), "rb");
-    ASSERT_TRUE(video_vad_fid != NULL) <<  "Cannot open the file, " <<
-              FLAGS_video_vad << " to read video-based VAD decisions.\n";
+    ASSERT_TRUE(video_vad_fid != nullptr)
+        << "Cannot open the file, " << FLAGS_video_vad
+        << " to read video-based VAD decisions.\n";
   }
 
   // AgsStat will be the owner of this file and will close it at its
   // destructor.
-  FILE* audio_content_fid = NULL;
+  FILE* audio_content_fid = nullptr;
   if (FLAGS_audio_content.size() > 0) {
     audio_content_fid = fopen(FLAGS_audio_content.c_str(), "wb");
-    ASSERT_TRUE(audio_content_fid != NULL) << "Cannot open file, " <<
-              FLAGS_audio_content << " to write audio-content.\n";
+    ASSERT_TRUE(audio_content_fid != nullptr) << "Cannot open file, "
+                                              << FLAGS_audio_content
+                                              << " to write audio-content.\n";
     agc_stat.set_audio_content_file(audio_content_fid);
   }
 
   webrtc::AudioFrame frame;
   frame.num_channels_ = 1;
   frame.sample_rate_hz_ = 16000;
   frame.samples_per_channel_ = frame.sample_rate_hz_ / 100;
   const size_t kSamplesToRead = frame.num_channels_ *
       frame.samples_per_channel_;
 
@@ skipping 16 matching lines @@
   size_t true_vad_index = 0;
   bool in_false_positive_region = false;
   int total_false_positive_duration = 0;
   bool video_adapted = false;
   while (kSamplesToRead == fread(frame.data_, sizeof(int16_t),
                                  kSamplesToRead, pcm_fid)) {
     assert(true_vad_index < kMaxNumFrames);
     ASSERT_EQ(1u, fread(&true_vad[true_vad_index], sizeof(*true_vad), 1,
                         true_vad_fid))
         << "Size mismatch between True-VAD and the PCM file.\n";
-    if (video_vad_fid != NULL) {
+    if (video_vad_fid != nullptr) {
       ASSERT_EQ(1u, fread(&p_video, sizeof(p_video), 1, video_vad_fid)) <<
           "Not enough video-based VAD probabilities.";
     }
 
     // Negative video activity indicates that the video-based VAD is not yet
     // adapted. Disregards the learning phase in statistics.
     if (p_video < 0) {
       if (video_adapted) {
         fprintf(stderr, "Negative video probabilities ONLY allowed at the "
             "beginning of the sequence, not in the middle.\n");
@@ skipping 55 matching lines @@
           }
         } else {
           ASSERT_TRUE(false) << "Invalid value for true-VAD.\n";
         }
         previous_true_vad = true_vad[n];
       }
       true_vad_index = 0;
     }
   }
 
-  if (results_fid != NULL) {
+  if (results_fid != nullptr) {
     fprintf(results_fid, "%4d  %4d  %4d  %4d  %4d  %4d  %4.0f %4.0f\n",
             total_active,
             total_missed_detection,
             total_passive,
             total_false_positive,
             num_onsets,
             num_not_adapted,
             static_cast<float>(onset_adaptation) / (num_onsets + 1e-12),
             static_cast<float>(total_false_positive_duration) /
             (total_passive + 1e-12));
   }
   fprintf(stdout, "%4d %4d %4d %4d %4d %4d %4.0f %4.0f\n",
           total_active,
           total_missed_detection,
           total_passive,
           total_false_positive,
           num_onsets,
           num_not_adapted,
           static_cast<float>(onset_adaptation) / (num_onsets + 1e-12),
           static_cast<float>(total_false_positive_duration) /
               (total_passive + 1e-12));
 
   fclose(true_vad_fid);
   fclose(pcm_fid);
-  if (video_vad_fid != NULL) {
+  if (video_vad_fid != nullptr) {
     fclose(video_vad_fid);
   }
-  if (results_fid != NULL) {
+  if (results_fid != nullptr) {
     fclose(results_fid);
   }
 }
 
 }  // namespace webrtc
 
 int main(int argc, char* argv[]) {
   char kUsage[] =
       "\nCompute the number of misdetected and false-positive frames. Not\n"
       " that for each frame of audio (10 ms) there should be one true\n"
       " activity. If any video-based activity is given, there should also be\n"
       " one probability per frame.\n"
       "\nUsage:\n\n"
       "activity_metric input_pcm [options]\n"
       "where 'input_pcm' is the input audio sampled at 16 kHz in 16 bits "
       "format.\n\n";
   google::SetUsageMessage(kUsage);
   google::ParseCommandLineFlags(&argc, &argv, true);
   webrtc::void_main(argc, argv);
   return 0;
 }