Use std::unique_ptr in VideoProcessor.

webrtc/modules/video_coding/codecs/test/videoprocessor.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 42 matching lines @@
                                        PacketManipulator* packet_manipulator,
                                        const TestConfig& config,
                                        Stats* stats)
     : encoder_(encoder),
       decoder_(decoder),
       frame_reader_(frame_reader),
       frame_writer_(frame_writer),
       packet_manipulator_(packet_manipulator),
       config_(config),
       stats_(stats),
-      encode_callback_(nullptr),
-      decode_callback_(nullptr),
-      last_successful_frame_buffer_(nullptr),
       first_key_frame_has_been_excluded_(false),
       last_frame_missing_(false),
       initialized_(false),
       encoded_frame_size_(0),
       encoded_frame_type_(kVideoFrameKey),
       prev_time_stamp_(0),
       num_dropped_frames_(0),
       num_spatial_resizes_(0),
       last_encoder_frame_width_(0),
       last_encoder_frame_height_(0),
@@ skipping 14 matching lines @@
   RTC_DCHECK(packet_manipulator);
   RTC_DCHECK(stats);
 }
 
 bool VideoProcessorImpl::Init() {
   // Calculate a factor used for bit rate calculations:
   bit_rate_factor_ = config_.codec_settings->maxFramerate * 0.001 * 8;  // bits
 
   // Initialize data structures used by the encoder/decoder APIs
   size_t frame_length_in_bytes = frame_reader_->FrameLength();
-  last_successful_frame_buffer_ = new uint8_t[frame_length_in_bytes];
+  last_successful_frame_buffer_.reset(new uint8_t[frame_length_in_bytes]);
   // Set fixed properties common for all frames.
   // To keep track of spatial resize actions by encoder.
   last_encoder_frame_width_ = config_.codec_settings->width;
   last_encoder_frame_height_ = config_.codec_settings->height;
 
   // Setup required callbacks for the encoder/decoder:
-  encode_callback_ = new VideoProcessorEncodeCompleteCallback(this);
-  decode_callback_ = new VideoProcessorDecodeCompleteCallback(this);
-  int32_t register_result =
-      encoder_->RegisterEncodeCompleteCallback(encode_callback_);
-  if (register_result != WEBRTC_VIDEO_CODEC_OK) {
-    fprintf(stderr,
-            "Failed to register encode complete callback, return code: "
-            "%d\n",
-            register_result);
-    return false;
-  }
-  register_result = decoder_->RegisterDecodeCompleteCallback(decode_callback_);
-  if (register_result != WEBRTC_VIDEO_CODEC_OK) {
-    fprintf(stderr,
-            "Failed to register decode complete callback, return code: "
-            "%d\n",
-            register_result);
-    return false;
-  }
+  encode_callback_.reset(new VideoProcessorEncodeCompleteCallback(this));
+  decode_callback_.reset(new VideoProcessorDecodeCompleteCallback(this));
+  RTC_CHECK_EQ(encoder_->RegisterEncodeCompleteCallback(encode_callback_.get()),
+               WEBRTC_VIDEO_CODEC_OK)
+      << "Failed to register encode complete callback";
+  RTC_CHECK_EQ(decoder_->RegisterDecodeCompleteCallback(decode_callback_.get()),
+               WEBRTC_VIDEO_CODEC_OK)
+      << "Failed to register decode complete callback";
+
   // Init the encoder and decoder
   uint32_t nbr_of_cores = 1;
   if (!config_.use_single_core) {
     nbr_of_cores = CpuInfo::DetectNumberOfCores();
   }
-  int32_t init_result =
+  RTC_CHECK_EQ(
       encoder_->InitEncode(config_.codec_settings, nbr_of_cores,
-                           config_.networking_config.max_payload_size_in_bytes);
-  if (init_result != WEBRTC_VIDEO_CODEC_OK) {
-    fprintf(stderr, "Failed to initialize VideoEncoder, return code: %d\n",
-            init_result);
-    return false;
-  }
-  init_result = decoder_->InitDecode(config_.codec_settings, nbr_of_cores);
-  if (init_result != WEBRTC_VIDEO_CODEC_OK) {
-    fprintf(stderr, "Failed to initialize VideoDecoder, return code: %d\n",
-            init_result);
-    return false;
-  }
+                           config_.networking_config.max_payload_size_in_bytes),
+      WEBRTC_VIDEO_CODEC_OK)
+      << "Failed to initialize VideoEncoder";
+
+  RTC_CHECK_EQ(decoder_->InitDecode(config_.codec_settings, nbr_of_cores),
+               WEBRTC_VIDEO_CODEC_OK)
+      << "Failed to initialize VideoDecoder";
 
   if (config_.verbose) {
     printf("Video Processor:\n");
     printf("  #CPU cores used  : %d\n", nbr_of_cores);
     printf("  Total # of frames: %d\n", frame_reader_->NumberOfFrames());
     printf("  Codec settings:\n");
     printf("    Start bitrate    : %d kbps\n",
            config_.codec_settings->startBitrate);
     printf("    Width            : %d\n", config_.codec_settings->width);
     printf("    Height           : %d\n", config_.codec_settings->height);
@@ skipping 16 matching lines @@
     } else if (config_.codec_settings->codecType == kVideoCodecVP9) {
       printf("    Resilience       : %d\n",
              config_.codec_settings->VP9()->resilience);
     }
   }
   initialized_ = true;
   return true;
 }
 
 VideoProcessorImpl::~VideoProcessorImpl() {
-  delete[] last_successful_frame_buffer_;
-  encoder_->RegisterEncodeCompleteCallback(NULL);
-  delete encode_callback_;
-  decoder_->RegisterDecodeCompleteCallback(NULL);
-  delete decode_callback_;
+  encoder_->RegisterEncodeCompleteCallback(nullptr);
+  decoder_->RegisterDecodeCompleteCallback(nullptr);
 }
 
 void VideoProcessorImpl::SetRates(int bit_rate, int frame_rate) {
   int set_rates_result = encoder_->SetRateAllocation(
       bitrate_allocator_->GetAllocation(bit_rate * 1000, frame_rate),
       frame_rate);
-  RTC_CHECK_GE(set_rates_result, 0);
-  if (set_rates_result < 0) {
-    fprintf(stderr,
-            "Failed to update encoder with new rate %d, "
-            "return code: %d\n",
-            bit_rate, set_rates_result);
-  }
+  RTC_CHECK_GE(set_rates_result, 0) << "Failed to update encoder with new rate "
+                                    << bit_rate;
   num_dropped_frames_ = 0;
   num_spatial_resizes_ = 0;
 }
 
 size_t VideoProcessorImpl::EncodedFrameSize() {
   return encoded_frame_size_;
 }
 
 FrameType VideoProcessorImpl::EncodedFrameType() {
   return encoded_frame_type_;
 }
 
 int VideoProcessorImpl::NumberDroppedFrames() {
   return num_dropped_frames_;
 }
 
 int VideoProcessorImpl::NumberSpatialResizes() {
   return num_spatial_resizes_;
 }
 
 bool VideoProcessorImpl::ProcessFrame(int frame_number) {
   RTC_DCHECK_GE(frame_number, 0);
-  if (!initialized_) {
-    fprintf(stderr, "Attempting to use uninitialized VideoProcessor!\n");
-    return false;
-  }
+  RTC_CHECK(initialized_) << "Attempting to use uninitialized VideoProcessor";
+
   // |prev_time_stamp_| is used for getting number of dropped frames.
   if (frame_number == 0) {
     prev_time_stamp_ = -1;
   }
   rtc::scoped_refptr<VideoFrameBuffer> buffer(frame_reader_->ReadFrame());
   if (buffer) {
     // Use the frame number as "timestamp" to identify frames
     VideoFrame source_frame(buffer, frame_number, 0, webrtc::kVideoRotation_0);
 
     // Ensure we have a new statistics data object we can fill:
     FrameStatistic& stat = stats_->NewFrame(frame_number);
 
     encode_start_ns_ = rtc::TimeNanos();
 
     // Decide if we're going to force a keyframe:
     std::vector<FrameType> frame_types(1, kVideoFrameDelta);
     if (config_.keyframe_interval > 0 &&
         frame_number % config_.keyframe_interval == 0) {
       frame_types[0] = kVideoFrameKey;
     }
 
     // For dropped frames, we regard them as zero size encoded frames.
     encoded_frame_size_ = 0;
     encoded_frame_type_ = kVideoFrameDelta;
 
-    int32_t encode_result = encoder_->Encode(source_frame, NULL, &frame_types);
+    int32_t encode_result =
+        encoder_->Encode(source_frame, nullptr, &frame_types);
 
     if (encode_result != WEBRTC_VIDEO_CODEC_OK) {
       fprintf(stderr, "Failed to encode frame %d, return code: %d\n",
               frame_number, encode_result);
     }
     stat.encode_return_code = encode_result;
     return true;
   } else {
     return false;  // we've reached the last frame
   }
 }
 
 void VideoProcessorImpl::FrameEncoded(
     webrtc::VideoCodecType codec,
     const EncodedImage& encoded_image,
     const webrtc::RTPFragmentationHeader* fragmentation) {
   // Timestamp is frame number, so this gives us #dropped frames.
   int num_dropped_from_prev_encode =
       encoded_image._timeStamp - prev_time_stamp_ - 1;
   num_dropped_frames_ += num_dropped_from_prev_encode;
   prev_time_stamp_ = encoded_image._timeStamp;
   if (num_dropped_from_prev_encode > 0) {
     // For dropped frames, we write out the last decoded frame to avoid getting
     // out of sync for the computation of PSNR and SSIM.
     for (int i = 0; i < num_dropped_from_prev_encode; i++) {
-      frame_writer_->WriteFrame(last_successful_frame_buffer_);
+      frame_writer_->WriteFrame(last_successful_frame_buffer_.get());
     }
   }
   // Frame is not dropped, so update the encoded frame size
   // (encoder callback is only called for non-zero length frames).
   encoded_frame_size_ = encoded_image._length;
 
   encoded_frame_type_ = encoded_image._frameType;
 
   int64_t encode_stop_ns = rtc::TimeNanos();
   int frame_number = encoded_image._timeStamp;
@@ skipping 43 matching lines @@
     stat.packets_dropped =
         packet_manipulator_->ManipulatePackets(&copied_image);
   }
 
   // Keep track of if frames are lost due to packet loss so we can tell
   // this to the encoder (this is handled by the RTP logic in the full stack)
   decode_start_ns_ = rtc::TimeNanos();
   // TODO(kjellander): Pass fragmentation header to the decoder when
   // CL 172001 has been submitted and PacketManipulator supports this.
   int32_t decode_result =
-      decoder_->Decode(copied_image, last_frame_missing_, NULL);
+      decoder_->Decode(copied_image, last_frame_missing_, nullptr);
   stat.decode_return_code = decode_result;
   if (decode_result != WEBRTC_VIDEO_CODEC_OK) {
     // Write the last successful frame the output file to avoid getting it out
     // of sync with the source file for SSIM and PSNR comparisons:
-    frame_writer_->WriteFrame(last_successful_frame_buffer_);
+    frame_writer_->WriteFrame(last_successful_frame_buffer_.get());
   }
   // save status for losses so we can inform the decoder for the next frame:
   last_frame_missing_ = copied_image._length == 0;
 }
 
 void VideoProcessorImpl::FrameDecoded(const VideoFrame& image) {
   int64_t decode_stop_ns = rtc::TimeNanos();
   int frame_number = image.timestamp();
   // Report stats
   FrameStatistic& stat = stats_->stats_[frame_number];
@@ skipping 19 matching lines @@
     // Should be the same aspect ratio, no cropping needed.
     up_image->ScaleFrom(*image.video_frame_buffer());
 
     // TODO(mikhal): Extracting the buffer for now - need to update test.
     size_t length =
         CalcBufferSize(kI420, up_image->width(), up_image->height());
     std::unique_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
     int extracted_length = ExtractBuffer(up_image, length, image_buffer.get());
     RTC_DCHECK_GT(extracted_length, 0);
     // Update our copy of the last successful frame:
-    memcpy(last_successful_frame_buffer_, image_buffer.get(), extracted_length);
+    memcpy(last_successful_frame_buffer_.get(), image_buffer.get(),
+           extracted_length);
     bool write_success = frame_writer_->WriteFrame(image_buffer.get());
     RTC_DCHECK(write_success);
     if (!write_success) {
       fprintf(stderr, "Failed to write frame %d to disk!", frame_number);
     }
   } else {  // No resize.
     // Update our copy of the last successful frame:
     // TODO(mikhal): Add as a member function, so won't be allocated per frame.
     size_t length = CalcBufferSize(kI420, image.width(), image.height());
     std::unique_ptr<uint8_t[]> image_buffer(new uint8_t[length]);
     int extracted_length = ExtractBuffer(image, length, image_buffer.get());
     RTC_DCHECK_GT(extracted_length, 0);
-    memcpy(last_successful_frame_buffer_, image_buffer.get(), extracted_length);
+    memcpy(last_successful_frame_buffer_.get(), image_buffer.get(),
+           extracted_length);
 
     bool write_success = frame_writer_->WriteFrame(image_buffer.get());
     RTC_DCHECK(write_success);
     if (!write_success) {
       fprintf(stderr, "Failed to write frame %d to disk!", frame_number);
     }
   }
 }
 
 int VideoProcessorImpl::GetElapsedTimeMicroseconds(int64_t start,
@@ skipping 31 matching lines @@
 }
 int32_t VideoProcessorImpl::VideoProcessorDecodeCompleteCallback::Decoded(
     VideoFrame& image) {
   // Forward to parent class.
   video_processor_->FrameDecoded(image);
   return 0;
 }
 
 }  // namespace test
 }  // namespace webrtc