Refactor scaling.

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 711 matching lines @@
 int VP8EncoderImpl::Encode(const VideoFrame& frame,
                            const CodecSpecificInfo* codec_specific_info,
                            const std::vector<FrameType>* frame_types) {
   if (!inited_)
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   if (frame.IsZeroSize())
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   if (encoded_complete_callback_ == NULL)
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
 
-  if (quality_scaler_enabled_)
-    quality_scaler_.OnEncodeFrame(frame);
-  const VideoFrame& input_image =
-      quality_scaler_enabled_ ? quality_scaler_.GetScaledFrame(frame) : frame;
+  rtc::scoped_refptr<VideoFrameBuffer> input_image = frame.video_frame_buffer();
 
-  if (quality_scaler_enabled_ && (input_image.width() != codec_.width ||
-                                  input_image.height() != codec_.height)) {
-    int ret = UpdateCodecFrameSize(input_image);
-    if (ret < 0)
-      return ret;
+  if (quality_scaler_enabled_) {
+    quality_scaler_.OnEncodeFrame(frame.width(), frame.height());
+    input_image = quality_scaler_.GetScaledBuffer(input_image);
+
+    if (input_image->width() != codec_.width ||
+        input_image->height() != codec_.height) {
+      int ret =
+          UpdateCodecFrameSize(input_image->width(), input_image->height());
+      if (ret < 0)
+        return ret;
+    }
   }
 
   // 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(), static_cast<int>(raw_images_[0].d_w));
-  RTC_DCHECK_EQ(input_image.height(), static_cast<int>(raw_images_[0].d_h));
+  RTC_DCHECK_EQ(input_image->width(), static_cast<int>(raw_images_[0].d_w));
+  RTC_DCHECK_EQ(input_image->height(), static_cast<int>(raw_images_[0].d_h));
 
   // Image in vpx_image_t format.
   // Input image is const. VP8's raw image is not defined as const.
   raw_images_[0].planes[VPX_PLANE_Y] =
-      const_cast<uint8_t*>(input_image.video_frame_buffer()->DataY());
+      const_cast<uint8_t*>(input_image->DataY());
   raw_images_[0].planes[VPX_PLANE_U] =
-      const_cast<uint8_t*>(input_image.video_frame_buffer()->DataU());
+      const_cast<uint8_t*>(input_image->DataU());
   raw_images_[0].planes[VPX_PLANE_V] =
-      const_cast<uint8_t*>(input_image.video_frame_buffer()->DataV());
+      const_cast<uint8_t*>(input_image->DataV());
 
-  raw_images_[0].stride[VPX_PLANE_Y] =
-      input_image.video_frame_buffer()->StrideY();
-  raw_images_[0].stride[VPX_PLANE_U] =
-      input_image.video_frame_buffer()->StrideU();
-  raw_images_[0].stride[VPX_PLANE_V] =
-      input_image.video_frame_buffer()->StrideV();
+  raw_images_[0].stride[VPX_PLANE_Y] = input_image->StrideY();
+  raw_images_[0].stride[VPX_PLANE_U] = input_image->StrideU();
+  raw_images_[0].stride[VPX_PLANE_V] = input_image->StrideV();
 
   for (size_t i = 1; i < encoders_.size(); ++i) {
     // Scale the image down a number of times by downsampling factor
     libyuv::I420Scale(
         raw_images_[i - 1].planes[VPX_PLANE_Y],
         raw_images_[i - 1].stride[VPX_PLANE_Y],
         raw_images_[i - 1].planes[VPX_PLANE_U],
         raw_images_[i - 1].stride[VPX_PLANE_U],
         raw_images_[i - 1].planes[VPX_PLANE_V],
         raw_images_[i - 1].stride[VPX_PLANE_V], raw_images_[i - 1].d_w,
         raw_images_[i - 1].d_h, raw_images_[i].planes[VPX_PLANE_Y],
         raw_images_[i].stride[VPX_PLANE_Y], raw_images_[i].planes[VPX_PLANE_U],
         raw_images_[i].stride[VPX_PLANE_U], raw_images_[i].planes[VPX_PLANE_V],
         raw_images_[i].stride[VPX_PLANE_V], raw_images_[i].d_w,
         raw_images_[i].d_h, libyuv::kFilterBilinear);
   }
   vpx_enc_frame_flags_t flags[kMaxSimulcastStreams];
   for (size_t i = 0; i < encoders_.size(); ++i) {
-    int ret = temporal_layers_[i]->EncodeFlags(input_image.timestamp());
+    int ret = temporal_layers_[i]->EncodeFlags(frame.timestamp());
     if (ret < 0) {
       // Drop this frame.
       return WEBRTC_VIDEO_CODEC_OK;
     }
     flags[i] = ret;
   }
   bool send_key_frame = false;
   for (size_t i = 0; i < key_frame_request_.size() && i < send_stream_.size();
        ++i) {
     if (key_frame_request_[i] && send_stream_[i]) {
@@ skipping 31 matching lines @@
     std::fill(key_frame_request_.begin(), key_frame_request_.end(), false);
   } else if (codec_specific_info &&
              codec_specific_info->codecType == kVideoCodecVP8) {
     if (feedback_mode_) {
       // Handle RPSI and SLI messages and set up the appropriate encode flags.
       bool sendRefresh = false;
       if (codec_specific_info->codecSpecific.VP8.hasReceivedRPSI) {
         rps_.ReceivedRPSI(codec_specific_info->codecSpecific.VP8.pictureIdRPSI);
       }
       if (codec_specific_info->codecSpecific.VP8.hasReceivedSLI) {
-        sendRefresh = rps_.ReceivedSLI(input_image.timestamp());
+        sendRefresh = rps_.ReceivedSLI(frame.timestamp());
       }
       for (size_t i = 0; i < encoders_.size(); ++i) {
         flags[i] = rps_.EncodeFlags(picture_id_[i], sendRefresh,
-                                    input_image.timestamp());
+                                    frame.timestamp());
       }
     } else {
       if (codec_specific_info->codecSpecific.VP8.hasReceivedRPSI) {
         // Is this our last key frame? If not ignore.
         // |picture_id_| is defined per spatial stream/layer, so check that
         // |RPSI| matches the last key frame from any of the spatial streams.
         // If so, then all spatial streams for this encoding will predict from
         // its long-term reference (last key frame).
         int RPSI = codec_specific_info->codecSpecific.VP8.pictureIdRPSI;
         for (size_t i = 0; i < encoders_.size(); ++i) {
@@ skipping 47 matching lines @@
   int error = vpx_codec_encode(&encoders_[0], &raw_images_[0], timestamp_,
                                duration, 0, VPX_DL_REALTIME);
   // Reset specific intra frame thresholds, following the key frame.
   if (send_key_frame) {
     vpx_codec_control(&(encoders_[0]), VP8E_SET_MAX_INTRA_BITRATE_PCT,
                       rc_max_intra_target_);
   }
   if (error)
     return WEBRTC_VIDEO_CODEC_ERROR;
   timestamp_ += duration;
-  return GetEncodedPartitions(input_image, only_predict_from_key_frame);
+  // Examines frame timestamps only.
+  return GetEncodedPartitions(frame, only_predict_from_key_frame);
 }
 
 // TODO(pbos): Make sure this works for properly for >1 encoders.
-int VP8EncoderImpl::UpdateCodecFrameSize(const VideoFrame& input_image) {
-  codec_.width = input_image.width();
-  codec_.height = input_image.height();
+int VP8EncoderImpl::UpdateCodecFrameSize(int width, int height) {
+  codec_.width = width;
+  codec_.height = height;
   if (codec_.numberOfSimulcastStreams <= 1) {
     // For now scaling is only used for single-layer streams.
-    codec_.simulcastStream[0].width = input_image.width();
-    codec_.simulcastStream[0].height = input_image.height();
+    codec_.simulcastStream[0].width = width;
+    codec_.simulcastStream[0].height = height;
   }
   // Update the cpu_speed setting for resolution change.
   vpx_codec_control(&(encoders_[0]), VP8E_SET_CPUUSED,
                     SetCpuSpeed(codec_.width, codec_.height));
   raw_images_[0].w = codec_.width;
   raw_images_[0].h = codec_.height;
   raw_images_[0].d_w = codec_.width;
   raw_images_[0].d_h = codec_.height;
   vpx_img_set_rect(&raw_images_[0], 0, 0, codec_.width, codec_.height);
 
@@ skipping 487 matching lines @@
     return -1;
   }
   if (vpx_codec_control(copy->decoder_, VP8_SET_REFERENCE, ref_frame_) !=
       VPX_CODEC_OK) {
     return -1;
   }
   return 0;
 }
 
 }  // namespace webrtc