Replace NULL with nullptr in all C++ files.

webrtc/modules/video_coding/codecs/vp9/vp9_impl.cc

 /*
  *  Copyright (c) 2014 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 46 matching lines @@
 }
 
 void VP9EncoderImpl::EncoderOutputCodedPacketCallback(vpx_codec_cx_pkt* pkt,
                                                       void* user_data) {
   VP9EncoderImpl* enc = static_cast<VP9EncoderImpl*>(user_data);
   enc->GetEncodedLayerFrame(pkt);
 }
 
 VP9EncoderImpl::VP9EncoderImpl()
     : encoded_image_(),
-      encoded_complete_callback_(NULL),
+      encoded_complete_callback_(nullptr),
       inited_(false),
       timestamp_(0),
       picture_id_(0),
       cpu_speed_(3),
       rc_max_intra_target_(0),
-      encoder_(NULL),
-      config_(NULL),
-      raw_(NULL),
-      input_image_(NULL),
+      encoder_(nullptr),
+      config_(nullptr),
+      raw_(nullptr),
+      input_image_(nullptr),
       tl0_pic_idx_(0),
       frames_since_kf_(0),
       num_temporal_layers_(0),
       num_spatial_layers_(0),
       is_flexible_mode_(false),
       frames_encoded_(0),
       // Use two spatial when screensharing with flexible mode.
       spatial_layer_(new ScreenshareLayersVP9(2)) {
   memset(&codec_, 0, sizeof(codec_));
   memset(&svc_params_, 0, sizeof(vpx_svc_extra_cfg_t));
   uint32_t seed = rtc::Time32();
   srand(seed);
 }
 
 VP9EncoderImpl::~VP9EncoderImpl() {
   Release();
 }
 
 int VP9EncoderImpl::Release() {
-  if (encoded_image_._buffer != NULL) {
+  if (encoded_image_._buffer != nullptr) {
     delete[] encoded_image_._buffer;
-    encoded_image_._buffer = NULL;
+    encoded_image_._buffer = nullptr;
   }
-  if (encoder_ != NULL) {
+  if (encoder_ != nullptr) {
     if (vpx_codec_destroy(encoder_)) {
       return WEBRTC_VIDEO_CODEC_MEMORY;
     }
     delete encoder_;
-    encoder_ = NULL;
+    encoder_ = nullptr;
   }
-  if (config_ != NULL) {
+  if (config_ != nullptr) {
     delete config_;
-    config_ = NULL;
+    config_ = nullptr;
   }
-  if (raw_ != NULL) {
+  if (raw_ != nullptr) {
     vpx_img_free(raw_);
-    raw_ = NULL;
+    raw_ = nullptr;
   }
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 bool VP9EncoderImpl::ExplicitlyConfiguredSpatialLayers() const {
   // We check target_bitrate_bps of the 0th layer to see if the spatial layers
   // (i.e. bitrates) were explicitly configured.
   return num_spatial_layers_ > 1 &&
          codec_.spatialLayers[0].target_bitrate_bps > 0;
@@ skipping 101 matching lines @@
   // Update encoder context
   if (vpx_codec_enc_config_set(encoder_, config_)) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP9EncoderImpl::InitEncode(const VideoCodec* inst,
                                int number_of_cores,
                                size_t /*max_payload_size*/) {
-  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) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   if (number_of_cores < 1) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   if (inst->VP9().numberOfTemporalLayers > 3) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   // libvpx currently supports only one or two spatial layers.
   if (inst->VP9().numberOfSpatialLayers > 2) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
   int ret_val = Release();
   if (ret_val < 0) {
     return ret_val;
   }
-  if (encoder_ == NULL) {
+  if (encoder_ == nullptr) {
     encoder_ = new vpx_codec_ctx_t;
     // Only randomize pid/tl0 the first time the encoder is initialized
     // in order to not make random jumps mid-stream.
     picture_id_ = static_cast<uint16_t>(rand()) & 0x7FFF;  // NOLINT
     tl0_pic_idx_ = static_cast<uint8_t>(rand());           // NOLINT
   }
-  if (config_ == NULL) {
+  if (config_ == nullptr) {
     config_ = new vpx_codec_enc_cfg_t;
   }
   timestamp_ = 0;
   if (&codec_ != inst) {
     codec_ = *inst;
   }
 
   num_spatial_layers_ = inst->VP9().numberOfSpatialLayers;
   num_temporal_layers_ = inst->VP9().numberOfTemporalLayers;
   if (num_temporal_layers_ == 0)
     num_temporal_layers_ = 1;
 
   // Allocate memory for encoded image
-  if (encoded_image_._buffer != NULL) {
+  if (encoded_image_._buffer != nullptr) {
     delete[] encoded_image_._buffer;
   }
   encoded_image_._size = CalcBufferSize(kI420, codec_.width, codec_.height);
   encoded_image_._buffer = new uint8_t[encoded_image_._size];
   encoded_image_._completeFrame = true;
-  // Creating a wrapper to the image - setting image data to NULL. Actual
+  // 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
   // (actual memory is not allocated).
-  raw_ = vpx_img_wrap(NULL, VPX_IMG_FMT_I420, codec_.width, codec_.height, 1,
-                      NULL);
+  raw_ = vpx_img_wrap(nullptr, VPX_IMG_FMT_I420, codec_.width, codec_.height, 1,
+                      nullptr);
   // Populate encoder configuration with default values.
   if (vpx_codec_enc_config_default(vpx_codec_vp9_cx(), config_, 0)) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   config_->g_w = codec_.width;
   config_->g_h = codec_.height;
   config_->rc_target_bitrate = inst->startBitrate;  // in kbit/s
   config_->g_error_resilient = 1;
   // Setting the time base of the codec.
   config_->g_timebase.num = 1;
@@ skipping 175 matching lines @@
   const uint32_t min_intra_size = 300;
   return (target_pct < min_intra_size) ? min_intra_size : target_pct;
 }
 
 int VP9EncoderImpl::Encode(const VideoFrame& input_image,
                            const CodecSpecificInfo* codec_specific_info,
                            const std::vector<FrameType>* frame_types) {
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  if (encoded_complete_callback_ == NULL) {
+  if (encoded_complete_callback_ == nullptr) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   FrameType frame_type = kVideoFrameDelta;
   // We only support one stream at the moment.
   if (frame_types && frame_types->size() > 0) {
     frame_type = (*frame_types)[0];
   }
   RTC_DCHECK_EQ(input_image.width(), raw_->d_w);
   RTC_DCHECK_EQ(input_image.height(), raw_->d_h);
 
@@ skipping 51 matching lines @@
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   timestamp_ += duration;
 
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void VP9EncoderImpl::PopulateCodecSpecific(CodecSpecificInfo* codec_specific,
                                            const vpx_codec_cx_pkt& pkt,
                                            uint32_t timestamp) {
-  assert(codec_specific != NULL);
+  assert(codec_specific != nullptr);
   codec_specific->codecType = kVideoCodecVP9;
   codec_specific->codec_name = ImplementationName();
   CodecSpecificInfoVP9* vp9_info = &(codec_specific->codecSpecific.VP9);
   // TODO(asapersson): Set correct value.
   vp9_info->inter_pic_predicted =
       (pkt.data.frame.flags & VPX_FRAME_IS_KEY) ? false : true;
   vp9_info->flexible_mode = codec_.VP9()->flexibleMode;
   vp9_info->ss_data_available =
       ((pkt.data.frame.flags & VPX_FRAME_IS_KEY) && !codec_.VP9()->flexibleMode)
           ? true
@@ skipping 259 matching lines @@
 
 bool VP9Decoder::IsSupported() {
   return true;
 }
 
 VP9Decoder* VP9Decoder::Create() {
   return new VP9DecoderImpl();
 }
 
 VP9DecoderImpl::VP9DecoderImpl()
-    : decode_complete_callback_(NULL),
+    : decode_complete_callback_(nullptr),
       inited_(false),
-      decoder_(NULL),
+      decoder_(nullptr),
       key_frame_required_(true) {
   memset(&codec_, 0, sizeof(codec_));
 }
 
 VP9DecoderImpl::~VP9DecoderImpl() {
   inited_ = true;  // in order to do the actual release
   Release();
   int num_buffers_in_use = frame_buffer_pool_.GetNumBuffersInUse();
   if (num_buffers_in_use > 0) {
     // The frame buffers are reference counted and frames are exposed after
     // decoding. There may be valid usage cases where previous frames are still
     // referenced after ~VP9DecoderImpl that is not a leak.
     LOG(LS_INFO) << num_buffers_in_use << " Vp9FrameBuffers are still "
                  << "referenced during ~VP9DecoderImpl.";
   }
 }
 
 int VP9DecoderImpl::InitDecode(const VideoCodec* inst, int number_of_cores) {
-  if (inst == NULL) {
+  if (inst == nullptr) {
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   int ret_val = Release();
   if (ret_val < 0) {
     return ret_val;
   }
-  if (decoder_ == NULL) {
+  if (decoder_ == nullptr) {
     decoder_ = new vpx_codec_ctx_t;
   }
   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
   vpx_codec_flags_t flags = 0;
   if (vpx_codec_dec_init(decoder_, vpx_codec_vp9_dx(), &cfg, flags)) {
     return WEBRTC_VIDEO_CODEC_MEMORY;
   }
@@ skipping 13 matching lines @@
 }
 
 int VP9DecoderImpl::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;
   }
   // Always start with a complete key frame.
   if (key_frame_required_) {
     if (input_image._frameType != kVideoFrameKey)
       return WEBRTC_VIDEO_CODEC_ERROR;
     // We have a key frame - is it complete?
     if (input_image._completeFrame) {
       key_frame_required_ = false;
     } else {
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
   }
-  vpx_codec_iter_t iter = NULL;
+  vpx_codec_iter_t iter = nullptr;
   vpx_image_t* img;
   uint8_t* buffer = input_image._buffer;
   if (input_image._length == 0) {
-    buffer = NULL;  // Triggers full frame concealment.
+    buffer = nullptr;  // Triggers full frame concealment.
   }
   // During decode libvpx may get and release buffers from |frame_buffer_pool_|.
   // In practice libvpx keeps a few (~3-4) buffers alive at a time.
   if (vpx_codec_decode(decoder_, buffer,
                        static_cast<unsigned int>(input_image._length), 0,
                        VPX_DL_REALTIME)) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   // |img->fb_priv| contains the image data, a reference counted Vp9FrameBuffer.
   // It may be released by libvpx during future vpx_codec_decode or
   // vpx_codec_destroy calls.
   img = vpx_codec_get_frame(decoder_, &iter);
   int ret = ReturnFrame(img, input_image._timeStamp, input_image.ntp_time_ms_);
   if (ret != 0) {
     return ret;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP9DecoderImpl::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;
   }
 
   // This buffer contains all of |img|'s image data, a reference counted
   // Vp9FrameBuffer. (libvpx is done with the buffers after a few
   // vpx_codec_decode calls or vpx_codec_destroy).
   Vp9FrameBufferPool::Vp9FrameBuffer* img_buffer =
       static_cast<Vp9FrameBufferPool::Vp9FrameBuffer*>(img->fb_priv);
   // The buffer can be used directly by the VideoFrame (without copy) by
   // using a WrappedI420Buffer.
@@ skipping 18 matching lines @@
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP9DecoderImpl::RegisterDecodeCompleteCallback(
     DecodedImageCallback* callback) {
   decode_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int VP9DecoderImpl::Release() {
-  if (decoder_ != NULL) {
+  if (decoder_ != nullptr) {
     // When a codec is destroyed libvpx will release any buffers of
     // |frame_buffer_pool_| it is currently using.
     if (vpx_codec_destroy(decoder_)) {
       return WEBRTC_VIDEO_CODEC_MEMORY;
     }
     delete decoder_;
-    decoder_ = NULL;
+    decoder_ = nullptr;
   }
   // Releases buffers from the pool. Any buffers not in use are deleted. Buffers
   // still referenced externally are deleted once fully released, not returning
   // to the pool.
   frame_buffer_pool_.ClearPool();
   inited_ = false;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 const char* VP9DecoderImpl::ImplementationName() const {
   return "libvpx";
 }
 
 }  // namespace webrtc