Replace NULL with nullptr in all C++ files.

webrtc/modules/video_coding/codecs/vp8/vp8_sequence_coder.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 24 matching lines @@
   size_t encoded_bytes() { return encoded_bytes_; }
 
  private:
   webrtc::EncodedImage encoded_image_;
   FILE* encoded_file_;
   size_t encoded_bytes_;
 };
 
 Vp8SequenceCoderEncodeCallback::~Vp8SequenceCoderEncodeCallback() {
   delete[] encoded_image_._buffer;
-  encoded_image_._buffer = NULL;
+  encoded_image_._buffer = nullptr;
 }
 
 webrtc::EncodedImageCallback::Result
 Vp8SequenceCoderEncodeCallback::OnEncodedImage(
     const webrtc::EncodedImage& encoded_image,
     const webrtc::CodecSpecificInfo* codecSpecificInfo,
     const webrtc::RTPFragmentationHeader* fragmentation) {
   if (encoded_image_._size < encoded_image._size) {
     delete[] encoded_image_._buffer;
-    encoded_image_._buffer = NULL;
+    encoded_image_._buffer = nullptr;
     encoded_image_._buffer = new uint8_t[encoded_image._size];
     encoded_image_._size = encoded_image._size;
   }
   memcpy(encoded_image_._buffer, encoded_image._buffer, encoded_image._size);
   encoded_image_._length = encoded_image._length;
-  if (encoded_file_ != NULL) {
+  if (encoded_file_ != nullptr) {
     if (fwrite(encoded_image._buffer, 1, encoded_image._length,
                encoded_file_) != encoded_image._length) {
       return Result(Result::ERROR_SEND_FAILED, 0);
     }
   }
   encoded_bytes_ += encoded_image_._length;
   return Result(Result::OK, 0);
 }
 
 // TODO(mikhal): Add support for varying the frame size.
@@ skipping 11 matching lines @@
  private:
   FILE* decoded_file_;
 };
 
 int Vp8SequenceCoderDecodeCallback::Decoded(webrtc::VideoFrame& image) {
   EXPECT_EQ(0, webrtc::PrintVideoFrame(image, decoded_file_));
   return 0;
 }
 
 int SequenceCoder(webrtc::test::CommandLineParser* parser) {
-  int width = strtol((parser->GetFlag("w")).c_str(), NULL, 10);
-  int height = strtol((parser->GetFlag("h")).c_str(), NULL, 10);
-  int framerate = strtol((parser->GetFlag("f")).c_str(), NULL, 10);
+  int width = strtol((parser->GetFlag("w")).c_str(), nullptr, 10);
+  int height = strtol((parser->GetFlag("h")).c_str(), nullptr, 10);
+  int framerate = strtol((parser->GetFlag("f")).c_str(), nullptr, 10);
 
   if (width <= 0 || height <= 0 || framerate <= 0) {
     fprintf(stderr, "Error: Resolution cannot be <= 0!\n");
     return -1;
   }
-  int target_bitrate = strtol((parser->GetFlag("b")).c_str(), NULL, 10);
+  int target_bitrate = strtol((parser->GetFlag("b")).c_str(), nullptr, 10);
   if (target_bitrate <= 0) {
     fprintf(stderr, "Error: Bit-rate cannot be <= 0!\n");
     return -1;
   }
 
   // SetUp
   // Open input file.
   std::string encoded_file_name = parser->GetFlag("encoded_file");
   FILE* encoded_file = fopen(encoded_file_name.c_str(), "wb");
-  if (encoded_file == NULL) {
+  if (encoded_file == nullptr) {
     fprintf(stderr, "Error: Cannot open encoded file\n");
     return -1;
   }
   std::string input_file_name = parser->GetFlag("input_file");
   FILE* input_file = fopen(input_file_name.c_str(), "rb");
-  if (input_file == NULL) {
+  if (input_file == nullptr) {
     fprintf(stderr, "Error: Cannot open input file\n");
     return -1;
   }
   // Open output file.
   std::string output_file_name = parser->GetFlag("output_file");
   FILE* output_file = fopen(output_file_name.c_str(), "wb");
-  if (output_file == NULL) {
+  if (output_file == nullptr) {
     fprintf(stderr, "Error: Cannot open output file\n");
     return -1;
   }
 
   // Get range of frames: will encode num_frames following start_frame).
-  int start_frame = strtol((parser->GetFlag("start_frame")).c_str(), NULL, 10);
-  int num_frames = strtol((parser->GetFlag("num_frames")).c_str(), NULL, 10);
+  int start_frame =
+      strtol((parser->GetFlag("start_frame")).c_str(), nullptr, 10);
+  int num_frames = strtol((parser->GetFlag("num_frames")).c_str(), nullptr, 10);
 
   // Codec SetUp.
   webrtc::VideoCodec inst;
   memset(&inst, 0, sizeof(inst));
   webrtc::VP8Encoder* encoder = webrtc::VP8Encoder::Create();
   webrtc::VP8Decoder* decoder = webrtc::VP8Decoder::Create();
   inst.codecType = webrtc::kVideoCodecVP8;
   inst.VP8()->feedbackModeOn = false;
   inst.VP8()->denoisingOn = true;
   inst.maxFramerate = framerate;
@@ skipping 23 matching lines @@
   int frame_cnt = 1;
   int frames_processed = 0;
   while (num_frames == -1 || frames_processed < num_frames) {
     rtc::scoped_refptr<VideoFrameBuffer> buffer(
         test::ReadI420Buffer(width, height, input_file));
     if (!buffer) {
       // EOF or read error.
       break;
     }
     if (frame_cnt >= start_frame) {
-      encoder->Encode(VideoFrame(buffer, webrtc::kVideoRotation_0, 0),
-                      NULL, NULL);
-      decoder->Decode(encoder_callback.encoded_image(), false, NULL);
+      encoder->Encode(VideoFrame(buffer, webrtc::kVideoRotation_0, 0), nullptr,
+                      nullptr);
+      decoder->Decode(encoder_callback.encoded_image(), false, nullptr);
       ++frames_processed;
     }
     ++frame_cnt;
   }
   printf("\nProcessed %d frames\n", frames_processed);
   int64_t endtime = rtc::TimeMillis();
   int64_t totalExecutionTime = endtime - starttime;
   printf("Total execution time: %.2lf ms\n",
          static_cast<double>(totalExecutionTime));
   double actual_bit_rate =
@@ skipping 53 matching lines @@
 
   parser.ProcessFlags();
   if (parser.GetFlag("help") == "true") {
     parser.PrintUsageMessage();
     exit(EXIT_SUCCESS);
   }
   parser.PrintEnteredFlags();
 
   return SequenceCoder(&parser);
 }