Refactor scaling.

webrtc/modules/video_coding/utility/quality_scaler.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.
  */
+
+// TODO(nisse): Switch to RTC_CHECK (or RTC_DCHECK) ?

[pbos-webrtc, 2016/05/31 14:14:02]

Do that now, please. Pref DCHECK. :)

[nisse-webrtc, 2016/06/01 09:15:18]

Done.

+#include <assert.h>
+
 #include "webrtc/modules/video_coding/utility/quality_scaler.h"
 
 namespace webrtc {
 
 namespace {
 static const int kMinFps = 5;
 // Threshold constant used until first downscale (to permit fast rampup).
 static const int kMeasureSecondsFastUpscale = 2;
 static const int kMeasureSecondsUpscale = 5;
 static const int kMeasureSecondsDownscale = 5;
@@ skipping 67 matching lines @@
 void QualityScaler::ReportQP(int qp) {
   framedrop_percent_.AddSample(0);
   average_qp_downscale_.AddSample(qp);
   average_qp_upscale_.AddSample(qp);
 }
 
 void QualityScaler::ReportDroppedFrame() {
   framedrop_percent_.AddSample(100);
 }
 
-void QualityScaler::OnEncodeFrame(const VideoFrame& frame) {
+void QualityScaler::OnEncodeFrame(int width, int height) {
   // Should be set through InitEncode -> Should be set by now.
   assert(low_qp_threshold_ >= 0);
   assert(num_samples_upscale_ > 0);
   assert(num_samples_downscale_ > 0);
 
   // Update scale factor.
   int avg_drop = 0;
   int avg_qp = 0;
 
   if ((framedrop_percent_.GetAverage(num_samples_downscale_, &avg_drop) &&
        avg_drop >= kFramedropPercentThreshold) ||
       (average_qp_downscale_.GetAverage(num_samples_downscale_, &avg_qp) &&
        avg_qp > high_qp_threshold_)) {
     AdjustScale(false);
   } else if (average_qp_upscale_.GetAverage(num_samples_upscale_, &avg_qp) &&
              avg_qp <= low_qp_threshold_) {
     AdjustScale(true);
   }
-  UpdateTargetResolution(frame.width(), frame.height());
+  UpdateTargetResolution(width, height);
 }
 
 QualityScaler::Resolution QualityScaler::GetScaledResolution() const {
   return res_;
 }
 
-const VideoFrame& QualityScaler::GetScaledFrame(const VideoFrame& frame) {
+rtc::scoped_refptr<VideoFrameBuffer> QualityScaler::GetScaledFrame(
+    const rtc::scoped_refptr<VideoFrameBuffer>& frame) {
   Resolution res = GetScaledResolution();
-  if (res.width == frame.width())
+  int src_width = frame->width();
+  int src_height = frame->height();
+
+  if (res.width == src_width && res.height == src_height)
     return frame;
+  rtc::scoped_refptr<I420Buffer> scaled =
+      pool_.CreateBuffer(res.width, res.height);
 
-  scaler_.Set(frame.width(), frame.height(), res.width, res.height, kI420,
-              kI420, kScaleBox);
-  if (scaler_.Scale(frame, &scaled_frame_) != 0)
-    return frame;
+  I420Buffer::CenterCropAndScale(scaled, frame);
 
-  // TODO(perkj): Refactor the scaler to not own |scaled_frame|. VideoFrame are
-  // just thin wrappers so instead the scaler should return a
-  // rtc::scoped_refptr<VideoFrameBuffer> and a new VideoFrame be created with
-  // the meta data from |frame|. That way we would not have to set all these
-  // meta data.
-  scaled_frame_.set_ntp_time_ms(frame.ntp_time_ms());
-  scaled_frame_.set_timestamp(frame.timestamp());
-  scaled_frame_.set_render_time_ms(frame.render_time_ms());
-  scaled_frame_.set_rotation(frame.rotation());
-
-  return scaled_frame_;
+  return scaled;
 }
 
 void QualityScaler::UpdateTargetResolution(int frame_width, int frame_height) {
   assert(downscale_shift_ >= 0);
   int shifts_performed = 0;
   for (int shift = downscale_shift_;
        shift > 0 && (frame_width / 2 >= kMinDownscaleDimension) &&
        (frame_height / 2 >= kMinDownscaleDimension);
        --shift, ++shifts_performed) {
     frame_width /= 2;
@@ skipping 29 matching lines @@
   if (downscale_shift_ < 0)
     downscale_shift_ = 0;
   if (!up) {
     // First downscale hit, start using a slower threshold for going up.
     measure_seconds_upscale_ = kMeasureSecondsUpscale;
     UpdateSampleCounts();
   }
 }
 
 }  // namespace webrtc