Make Android min-resolution rotation-agnostic.

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"
@@ skipping 22 matching lines @@
 void QualityScaler::Init(int low_qp_threshold,
                          int high_qp_threshold,
                          bool use_framerate_reduction,
                          int initial_bitrate_kbps,
                          int width,
                          int height) {
   ClearSamples();
   low_qp_threshold_ = low_qp_threshold;
   high_qp_threshold_ = high_qp_threshold;
   use_framerate_reduction_ = use_framerate_reduction;
+  downscale_shift_ = 0;
+  const int init_width = width;
+  const int init_height = height;
   // TODO(glaznev): Investigate using thresholds for other resolutions
   // or threshold tables.
   if (initial_bitrate_kbps > 0 &&
       initial_bitrate_kbps < kHdBitrateThresholdKbps) {
     // Start scaling to roughly VGA.
     while (width * height > kHdResolutionThreshold) {
       ++downscale_shift_;
       width /= 2;
       height /= 2;
     }
   }
-  res_.width = width;
-  res_.height = height;
+  UpdateTargetResolution(init_width, init_height);
   target_framerate_ = -1;
 }
 
 void QualityScaler::SetMinResolution(int min_width, int min_height) {
   min_width_ = min_width;
   min_height_ = min_height;
 }
 
 // Report framerate(fps) to estimate # of samples.
 void QualityScaler::ReportFramerate(int framerate) {
   num_samples_ = static_cast<size_t>(
       kMeasureSeconds * (framerate < kMinFps ? kMinFps : framerate));
   framerate_ = framerate;
 }
 
 void QualityScaler::ReportQP(int qp) {
   framedrop_percent_.AddSample(0);
   average_qp_.AddSample(qp);
 }
 
 void QualityScaler::ReportDroppedFrame() {
   framedrop_percent_.AddSample(100);
 }
 
 void QualityScaler::OnEncodeFrame(const VideoFrame& frame) {
   // Should be set through InitEncode -> Should be set by now.
   assert(low_qp_threshold_ >= 0);
   assert(num_samples_ > 0);
-  res_.width = frame.width();
-  res_.height = frame.height();
 
   // Update scale factor.
   int avg_drop = 0;
   int avg_qp = 0;
 
   // When encoder consistently overshoots, framerate reduction and spatial
   // resizing will be triggered to get a smoother video.
   if ((framedrop_percent_.GetAverage(num_samples_, &avg_drop) &&
        avg_drop >= kFramedropPercentThreshold) ||
       (average_qp_.GetAverage(num_samples_, &avg_qp) &&
@@ skipping 14 matching lines @@
   } else if (average_qp_.GetAverage(num_samples_, &avg_qp) &&
              avg_qp <= low_qp_threshold_) {
     if (use_framerate_reduction_ && framerate_down_) {
       target_framerate_ = -1;
       framerate_down_ = false;
       ClearSamples();
     } else {
       AdjustScale(true);
     }
   }
-
-  assert(downscale_shift_ >= 0);
-  for (int shift = downscale_shift_;
-       shift > 0 && (res_.width / 2 >= min_width_) &&
-       (res_.height / 2 >= min_height_);
-       --shift) {
-    res_.width /= 2;
-    res_.height /= 2;
-  }
+  UpdateTargetResolution(frame.width(), frame.height());
 }
 
 QualityScaler::Resolution QualityScaler::GetScaledResolution() const {
   return res_;
 }
 
 int QualityScaler::GetTargetFramerate() const {
   return target_framerate_;
 }
 
 const VideoFrame& QualityScaler::GetScaledFrame(const VideoFrame& frame) {
   Resolution res = GetScaledResolution();
   if (res.width == frame.width())
     return frame;
 
   scaler_.Set(frame.width(), frame.height(), res.width, res.height, kI420,
               kI420, kScaleBox);
   if (scaler_.Scale(frame, &scaled_frame_) != 0)
     return frame;
 
   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());
 
   return scaled_frame_;
 }
 
+void QualityScaler::UpdateTargetResolution(int frame_width, int frame_height) {
+  assert(downscale_shift_ >= 0);
+  res_.width = frame_width;
+  res_.height = frame_height;
+  for (int shift = downscale_shift_;
+       shift > 0 && (res_.width / 2 >= min_width_) &&
+       (res_.height / 2 >= min_height_);
+       --shift) {
+    res_.width /= 2;
+    res_.height /= 2;
+  }
+}
+
 void QualityScaler::ClearSamples() {
   framedrop_percent_.Reset();
   average_qp_.Reset();
 }
 
 void QualityScaler::AdjustScale(bool up) {
   downscale_shift_ += up ? -1 : 1;
   if (downscale_shift_ < 0)
     downscale_shift_ = 0;
   ClearSamples();
 }
 
 }  // namespace webrtc