New helper function test::ReadI420Buffer, refactor FrameReader to use it.

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 38 matching lines @@
                                        Stats* stats)
     : encoder_(encoder),
       decoder_(decoder),
       frame_reader_(frame_reader),
       frame_writer_(frame_writer),
       packet_manipulator_(packet_manipulator),
       config_(config),
       stats_(stats),
       encode_callback_(NULL),
       decode_callback_(NULL),
-      source_buffer_(NULL),
       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) {
   assert(encoder);
   assert(decoder);
   assert(frame_reader);
   assert(frame_writer);
   assert(packet_manipulator);
   assert(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();
-  source_buffer_ = new uint8_t[frame_length_in_bytes];
   last_successful_frame_buffer_ = 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 =
@@ skipping 41 matching lines @@
     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);
   }
   initialized_ = true;
   return true;
 }
 
 VideoProcessorImpl::~VideoProcessorImpl() {
-  delete[] source_buffer_;
   delete[] last_successful_frame_buffer_;
   encoder_->RegisterEncodeCompleteCallback(NULL);
   delete encode_callback_;
   decoder_->RegisterDecodeCompleteCallback(NULL);
   delete decode_callback_;
 }
 
 void VideoProcessorImpl::SetRates(int bit_rate, int frame_rate) {
   int set_rates_result = encoder_->SetRates(bit_rate, frame_rate);
   assert(set_rates_result >= 0);
@@ skipping 26 matching lines @@
 bool VideoProcessorImpl::ProcessFrame(int frame_number) {
   assert(frame_number >= 0);
   if (!initialized_) {
     fprintf(stderr, "Attempting to use uninitialized VideoProcessor!\n");
     return false;
   }
   // |prev_time_stamp_| is used for getting number of dropped frames.
   if (frame_number == 0) {
     prev_time_stamp_ = -1;
   }
-  if (frame_reader_->ReadFrame(source_buffer_)) {
-    // Copy the source frame to the newly read frame data.
-    source_frame_.CreateFrame(source_buffer_, config_.codec_settings->width,
-                              config_.codec_settings->height, kVideoRotation_0);
+  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();
-    // Use the frame number as "timestamp" to identify frames
-    source_frame_.set_timestamp(frame_number);
 
     // 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, NULL, &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
   }
@@ skipping 197 matching lines @@
 }
 int32_t VideoProcessorImpl::VideoProcessorDecodeCompleteCallback::Decoded(
     VideoFrame& image) {
   // Forward to parent class.
   video_processor_->FrameDecoded(image);
   return 0;
 }
 
 }  // namespace test
 }  // namespace webrtc