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.
  */
+
 #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);
+  RTC_DCHECK_GE(low_qp_threshold_, 0);
+  RTC_DCHECK_GT(num_samples_upscale_, 0u);
+  RTC_DCHECK_GT(num_samples_downscale_, 0u);
 
   // 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::GetScaledBuffer(
+    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_buffer =
+      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;
+  scaled_buffer->ScaleFrom(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_buffer;
 }
 
 void QualityScaler::UpdateTargetResolution(int frame_width, int frame_height) {
-  assert(downscale_shift_ >= 0);
+  RTC_DCHECK_GE(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;
     frame_height /= 2;
   }
   // Clamp to number of shifts actually performed to not be stuck trying to
   // scale way beyond QVGA.
@@ skipping 25 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