Replace NULL with nullptr in all C++ files.

webrtc/modules/video_coding/codecs/vp8/vp8_impl.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 271 matching lines @@
       int layers = std::max(static_cast<uint8_t>(1),
                             codec.simulcastStream[i].numberOfTemporalLayers);
       temporal_layers_.push_back(tl_factory->Create(i, layers, rand()));
     }
   }
 }
 
 int VP8EncoderImpl::InitEncode(const VideoCodec* inst,
                                int number_of_cores,
                                size_t /*maxPayloadSize */) {
-  if (inst == NULL) {
+  if (inst == nullptr) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   if (inst->maxFramerate < 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // allow zero to represent an unspecified maxBitRate
   if (inst->maxBitrate > 0 && inst->startBitrate > inst->maxBitrate) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   if (inst->width <= 1 || inst->height <= 1) {
@@ skipping 63 matching lines @@
   if (number_of_streams > 1) {
     send_stream_[number_of_streams - 1] = false;
     downsampling_factors_[number_of_streams - 1].num = 1;
     downsampling_factors_[number_of_streams - 1].den = 1;
   }
   for (int i = 0; i < number_of_streams; ++i) {
     // Random start, 16 bits is enough.
     picture_id_[i] = static_cast<uint16_t>(rand()) & 0x7FFF;  // NOLINT
     last_key_frame_picture_id_[i] = -1;
     // allocate memory for encoded image
-    if (encoded_images_[i]._buffer != NULL) {
+    if (encoded_images_[i]._buffer != nullptr) {
       delete[] encoded_images_[i]._buffer;
     }
     encoded_images_[i]._size =
         CalcBufferSize(kI420, codec_.width, codec_.height);
     encoded_images_[i]._buffer = new uint8_t[encoded_images_[i]._size];
     encoded_images_[i]._completeFrame = true;
   }
   // populate encoder configuration with default values
   if (vpx_codec_enc_config_default(vpx_codec_vp8_cx(), &configurations_[0],
                                    0)) {
@@ skipping 82 matching lines @@
                     inst->simulcastStream[number_of_streams - 1 - i].height);
   }
   configurations_[0].g_w = inst->width;
   configurations_[0].g_h = inst->height;
 
   // Determine number of threads based on the image size and #cores.
   // TODO(fbarchard): Consider number of Simulcast layers.
   configurations_[0].g_threads = NumberOfThreads(
       configurations_[0].g_w, configurations_[0].g_h, number_of_cores);
 
-  // Creating a wrapper to the image - setting image data to NULL.
+  // Creating a wrapper to the image - setting image data to null.
   // Actual pointer will be set in encode. Setting align to 1, as it
   // is meaningless (no memory allocation is done here).
   vpx_img_wrap(&raw_images_[0], VPX_IMG_FMT_I420, inst->width, inst->height, 1,
-               NULL);
+               nullptr);
 
   // Note the order we use is different from webm, we have lowest resolution
   // at position 0 and they have highest resolution at position 0.
   int stream_idx = encoders_.size() - 1;
   SimulcastRateAllocator init_allocator(codec_, nullptr);
   BitrateAllocation allocation = init_allocator.GetAllocation(
       inst->startBitrate * 1000, inst->maxFramerate);
   std::vector<uint32_t> stream_bitrates;
   for (int i = 0; i == 0 || i < inst->numberOfSimulcastStreams; ++i) {
     uint32_t bitrate = allocation.GetSpatialLayerSum(i) / 1000;
@@ skipping 159 matching lines @@
 }
 
 int VP8EncoderImpl::Encode(const VideoFrame& frame,
                            const CodecSpecificInfo* codec_specific_info,
                            const std::vector<FrameType>* frame_types) {
   RTC_DCHECK_EQ(frame.width(), codec_.width);
   RTC_DCHECK_EQ(frame.height(), codec_.height);
 
   if (!inited_)
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
-  if (encoded_complete_callback_ == NULL)
+  if (encoded_complete_callback_ == nullptr)
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
 
   rtc::scoped_refptr<VideoFrameBuffer> input_image = frame.video_frame_buffer();
   // Since we are extracting raw pointers from |input_image| to
   // |raw_images_[0]|, the resolution of these frames must match. Note that
   // |input_image| might be scaled from |frame|. In that case, the resolution of
   // |raw_images_[0]| should have been updated in UpdateCodecFrameSize.
   RTC_DCHECK_EQ(input_image->width(), raw_images_[0].d_w);
   RTC_DCHECK_EQ(input_image->height(), raw_images_[0].d_h);
 
@@ skipping 182 matching lines @@
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void VP8EncoderImpl::PopulateCodecSpecific(
     CodecSpecificInfo* codec_specific,
     const vpx_codec_cx_pkt_t& pkt,
     int stream_idx,
     uint32_t timestamp,
     bool only_predicting_from_key_frame) {
-  assert(codec_specific != NULL);
+  assert(codec_specific != nullptr);
   codec_specific->codecType = kVideoCodecVP8;
   codec_specific->codec_name = ImplementationName();
   CodecSpecificInfoVP8* vp8Info = &(codec_specific->codecSpecific.VP8);
   vp8Info->pictureId = picture_id_[stream_idx];
   if (pkt.data.frame.flags & VPX_FRAME_IS_KEY) {
     last_key_frame_picture_id_[stream_idx] = picture_id_[stream_idx];
   }
   vp8Info->simulcastIdx = stream_idx;
   vp8Info->keyIdx = kNoKeyIdx;  // TODO(hlundin) populate this
   vp8Info->nonReference =
       (pkt.data.frame.flags & VPX_FRAME_IS_DROPPABLE) ? true : false;
   bool base_layer_sync_point = (pkt.data.frame.flags & VPX_FRAME_IS_KEY) ||
                                only_predicting_from_key_frame;
   temporal_layers_[stream_idx]->PopulateCodecSpecific(base_layer_sync_point,
                                                       vp8Info, timestamp);
   // Prepare next.
   picture_id_[stream_idx] = (picture_id_[stream_idx] + 1) & 0x7FFF;
 }
 
 int VP8EncoderImpl::GetEncodedPartitions(const VideoFrame& input_image,
                                          bool only_predicting_from_key_frame) {
   int bw_resolutions_disabled =
       (encoders_.size() > 1) ? NumStreamsDisabled(send_stream_) : -1;
 
   int stream_idx = static_cast<int>(encoders_.size()) - 1;
   int result = WEBRTC_VIDEO_CODEC_OK;
   for (size_t encoder_idx = 0; encoder_idx < encoders_.size();
        ++encoder_idx, --stream_idx) {
-    vpx_codec_iter_t iter = NULL;
+    vpx_codec_iter_t iter = nullptr;
     int part_idx = 0;
     encoded_images_[encoder_idx]._length = 0;
     encoded_images_[encoder_idx]._frameType = kVideoFrameDelta;
     RTPFragmentationHeader frag_info;
     // token_partitions_ is number of bits used.
     frag_info.VerifyAndAllocateFragmentationHeader((1 << token_partitions_) +
                                                    1);
     CodecSpecificInfo codec_specific;
-    const vpx_codec_cx_pkt_t* pkt = NULL;
+    const vpx_codec_cx_pkt_t* pkt = nullptr;
     while ((pkt = vpx_codec_get_cx_data(&encoders_[encoder_idx], &iter)) !=
-           NULL) {
+           nullptr) {
       switch (pkt->kind) {
         case VPX_CODEC_CX_FRAME_PKT: {
           size_t length = encoded_images_[encoder_idx]._length;
           if (pkt->data.frame.sz + length >
               encoded_images_[encoder_idx]._size) {
             uint8_t* buffer = new uint8_t[pkt->data.frame.sz + length];
             memcpy(buffer, encoded_images_[encoder_idx]._buffer, length);
             delete[] encoded_images_[encoder_idx]._buffer;
             encoded_images_[encoder_idx]._buffer = buffer;
             encoded_images_[encoder_idx]._size = pkt->data.frame.sz + length;
@@ skipping 73 matching lines @@
 }
 
 int VP8EncoderImpl::RegisterEncodeCompleteCallback(
     EncodedImageCallback* callback) {
   encoded_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 VP8DecoderImpl::VP8DecoderImpl()
     : buffer_pool_(false, 300 /* max_number_of_buffers*/),
-      decode_complete_callback_(NULL),
+      decode_complete_callback_(nullptr),
       inited_(false),
       feedback_mode_(false),
-      decoder_(NULL),
+      decoder_(nullptr),
       image_format_(VPX_IMG_FMT_NONE),
-      ref_frame_(NULL),
+      ref_frame_(nullptr),
       propagation_cnt_(-1),
       last_frame_width_(0),
       last_frame_height_(0),
       key_frame_required_(true) {}
 
 VP8DecoderImpl::~VP8DecoderImpl() {
   inited_ = true;  // in order to do the actual release
   Release();
 }
 
 int VP8DecoderImpl::InitDecode(const VideoCodec* inst, int number_of_cores) {
   int ret_val = Release();
   if (ret_val < 0) {
     return ret_val;
   }
-  if (decoder_ == NULL) {
+  if (decoder_ == nullptr) {
     decoder_ = new vpx_codec_ctx_t;
     memset(decoder_, 0, sizeof(*decoder_));
   }
   if (inst && inst->codecType == kVideoCodecVP8) {
     feedback_mode_ = inst->VP8().feedbackModeOn;
   }
   vpx_codec_dec_cfg_t cfg;
   // Setting number of threads to a constant value (1)
   cfg.threads = 1;
   cfg.h = cfg.w = 0;  // set after decode
@@ skipping 23 matching lines @@
 }
 
 int VP8DecoderImpl::Decode(const EncodedImage& input_image,
                            bool missing_frames,
                            const RTPFragmentationHeader* fragmentation,
                            const CodecSpecificInfo* codec_specific_info,
                            int64_t /*render_time_ms*/) {
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  if (decode_complete_callback_ == NULL) {
+  if (decode_complete_callback_ == nullptr) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  if (input_image._buffer == NULL && input_image._length > 0) {
+  if (input_image._buffer == nullptr && input_image._length > 0) {
     // Reset to avoid requesting key frames too often.
     if (propagation_cnt_ > 0)
       propagation_cnt_ = 0;
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
 #if !defined(WEBRTC_ARCH_ARM) && !defined(WEBRTC_ARCH_ARM64) && \
   !defined(ANDROID)
   vp8_postproc_cfg_t ppcfg;
   // MFQE enabled to reduce key frame popping.
@@ skipping 28 matching lines @@
       // Start count on first loss.
     } else if ((!input_image._completeFrame || missing_frames) &&
                propagation_cnt_ == -1) {
       propagation_cnt_ = 0;
     }
     if (propagation_cnt_ >= 0) {
       propagation_cnt_++;
     }
   }
 
-  vpx_codec_iter_t iter = NULL;
+  vpx_codec_iter_t iter = nullptr;
   vpx_image_t* img;
   int ret;
 
   // Check for missing frames.
   if (missing_frames) {
     // Call decoder with zero data length to signal missing frames.
-    if (vpx_codec_decode(decoder_, NULL, 0, 0, VPX_DL_REALTIME)) {
+    if (vpx_codec_decode(decoder_, nullptr, 0, 0, VPX_DL_REALTIME)) {
       // Reset to avoid requesting key frames too often.
       if (propagation_cnt_ > 0)
         propagation_cnt_ = 0;
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
     img = vpx_codec_get_frame(decoder_, &iter);
-    iter = NULL;
+    iter = nullptr;
   }
 
   uint8_t* buffer = input_image._buffer;
   if (input_image._length == 0) {
-    buffer = NULL;  // Triggers full frame concealment.
+    buffer = nullptr;  // Triggers full frame concealment.
   }
   if (vpx_codec_decode(decoder_, buffer, input_image._length, 0,
                        VPX_DL_REALTIME)) {
     // Reset to avoid requesting key frames too often.
     if (propagation_cnt_ > 0) {
       propagation_cnt_ = 0;
     }
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
@@ skipping 52 matching lines @@
     // Reset to avoid requesting key frames too often.
     propagation_cnt_ = 0;
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP8DecoderImpl::ReturnFrame(const vpx_image_t* img,
                                 uint32_t timestamp,
                                 int64_t ntp_time_ms) {
-  if (img == NULL) {
-    // Decoder OK and NULL image => No show frame
+  if (img == nullptr) {
+    // Decoder OK and null image => No show frame
     return WEBRTC_VIDEO_CODEC_NO_OUTPUT;
   }
   last_frame_width_ = img->d_w;
   last_frame_height_ = img->d_h;
   // Allocate memory for decoded image.
   rtc::scoped_refptr<I420Buffer> buffer =
       buffer_pool_.CreateBuffer(img->d_w, img->d_h);
   if (!buffer.get()) {
     // Pool has too many pending frames.
     RTC_HISTOGRAM_BOOLEAN("WebRTC.Video.VP8DecoderImpl.TooManyPendingFrames",
@@ skipping 20 matching lines @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP8DecoderImpl::RegisterDecodeCompleteCallback(
     DecodedImageCallback* callback) {
   decode_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP8DecoderImpl::Release() {
-  if (decoder_ != NULL) {
+  if (decoder_ != nullptr) {
     if (vpx_codec_destroy(decoder_)) {
       return WEBRTC_VIDEO_CODEC_MEMORY;
     }
     delete decoder_;
-    decoder_ = NULL;
+    decoder_ = nullptr;
   }
-  if (ref_frame_ != NULL) {
+  if (ref_frame_ != nullptr) {
     vpx_img_free(&ref_frame_->img);
     delete ref_frame_;
-    ref_frame_ = NULL;
+    ref_frame_ = nullptr;
   }
   buffer_pool_.Release();
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP8DecoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
 int VP8DecoderImpl::CopyReference(VP8DecoderImpl* copy) {
   // The type of frame to copy should be set in ref_frame_->frame_type
   // before the call to this function.
   if (vpx_codec_control(decoder_, VP8_COPY_REFERENCE, ref_frame_) !=
       VPX_CODEC_OK) {
     return -1;
   }
   if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_) !=
       VPX_CODEC_OK) {
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc