Add ability to scale to arbitrary factors

webrtc/media/base/videoadapter_unittest.cc

 /*
  *  Copyright (c) 2010 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 559 matching lines @@
   EXPECT_EQ(200, out_height_);
 
   // Request resolution of 3 / 8. Expect adapt down.
   format.width = 640 * 3 / 8;
   format.height = 400 * 3 / 8;
   adapter_.OnOutputFormatRequest(format);
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
-  EXPECT_EQ(400, cropped_height_);
+  EXPECT_EQ(384, cropped_height_);
   EXPECT_EQ(640 * 3 / 8, out_width_);
-  EXPECT_EQ(400 * 3 / 8, out_height_);
+  EXPECT_EQ(384 * 3 / 8, out_height_);
 
   // Switch back up. Expect adapt.
   format.width = 320;
   format.height = 200;
   adapter_.OnOutputFormatRequest(format);
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 400, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(400, cropped_height_);
@@ skipping 121 matching lines @@
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 
   // Adapt down one step more.
   adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
                                rtc::Optional<int>());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
-  EXPECT_EQ(720, cropped_height_);
+  EXPECT_EQ(704, cropped_height_);
   EXPECT_EQ(480, out_width_);
-  EXPECT_EQ(270, out_height_);
+  EXPECT_EQ(264, out_height_);
 
   // Adapt up one step.
   adapter_.OnResolutionRequest(rtc::Optional<int>(),
                                rtc::Optional<int>(480 * 270));
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(640, out_width_);
@@ skipping 37 matching lines @@
                                              &out_width_, &out_height_));
 }
 
 TEST_F(VideoAdapterTest, TestOnResolutionRequestInLargeSteps) {
   adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
                                rtc::Optional<int>());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
-  EXPECT_EQ(720, cropped_height_);
+  EXPECT_EQ(704, cropped_height_);
   EXPECT_EQ(480, out_width_);
-  EXPECT_EQ(270, out_height_);
+  EXPECT_EQ(264, out_height_);
 
   adapter_.OnResolutionRequest(rtc::Optional<int>(),
                                rtc::Optional<int>(960 * 720));
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 }
 
 TEST_F(VideoAdapterTest, TestOnOutputFormatRequestCapsMaxResolution) {
   adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
                                rtc::Optional<int>());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
-  EXPECT_EQ(720, cropped_height_);
+  EXPECT_EQ(704, cropped_height_);
   EXPECT_EQ(480, out_width_);
-  EXPECT_EQ(270, out_height_);
+  EXPECT_EQ(264, out_height_);
 
   VideoFormat new_format(640, 360, 0, FOURCC_I420);
   adapter_.OnOutputFormatRequest(new_format);
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
-  EXPECT_EQ(720, cropped_height_);
+  EXPECT_EQ(704, cropped_height_);
   EXPECT_EQ(480, out_width_);
-  EXPECT_EQ(270, out_height_);
+  EXPECT_EQ(264, out_height_);
 
   adapter_.OnResolutionRequest(rtc::Optional<int>(),
                                rtc::Optional<int>(960 * 720));
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(640, out_width_);
   EXPECT_EQ(360, out_height_);
 }
 
 TEST_F(VideoAdapterTest, TestOnResolutionRequestReset) {
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 
   adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
                                rtc::Optional<int>());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
-  EXPECT_EQ(720, cropped_height_);
+  EXPECT_EQ(704, cropped_height_);
   EXPECT_EQ(480, out_width_);
-  EXPECT_EQ(270, out_height_);
+  EXPECT_EQ(264, out_height_);
 
   adapter_.OnResolutionRequest(rtc::Optional<int>(), rtc::Optional<int>());
   EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(1280, cropped_width_);
   EXPECT_EQ(720, cropped_height_);
   EXPECT_EQ(1280, out_width_);
   EXPECT_EQ(720, out_height_);
 }
@@ skipping 12 matching lines @@
   EXPECT_EQ(360, out_height_);
 
   // Adapt down one step.
   adapter_.OnResolutionRequest(rtc::Optional<int>(640 * 360 - 1),
                                rtc::Optional<int>());
   // Expect cropping to 16:9 format and 3/4 scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
-  EXPECT_EQ(360, cropped_height_);
+  EXPECT_EQ(368, cropped_height_);
   EXPECT_EQ(480, out_width_);
-  EXPECT_EQ(270, out_height_);
+  EXPECT_EQ(276, out_height_);
 
   // Adapt down one step more.
   adapter_.OnResolutionRequest(rtc::Optional<int>(480 * 270 - 1),
                                rtc::Optional<int>());
   // Expect cropping to 16:9 format and 1/2 scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(360, cropped_height_);
   EXPECT_EQ(320, out_width_);
   EXPECT_EQ(180, out_height_);
 
   // Adapt up one step.
   adapter_.OnResolutionRequest(rtc::Optional<int>(),
                                rtc::Optional<int>(320 * 180));
   // Expect cropping to 16:9 format and 3/4 scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
-  EXPECT_EQ(360, cropped_height_);
+  EXPECT_EQ(368, cropped_height_);
   EXPECT_EQ(480, out_width_);
-  EXPECT_EQ(270, out_height_);
+  EXPECT_EQ(276, out_height_);
 
   // Adapt up one step more.
   adapter_.OnResolutionRequest(rtc::Optional<int>(),
                                rtc::Optional<int>(480 * 270));
   // Expect cropping to 16:9 format and no scaling.
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
   EXPECT_EQ(640, cropped_width_);
   EXPECT_EQ(360, cropped_height_);
@@ skipping 21 matching lines @@
                                rtc::Optional<int>());
 
   // Send 640x480 (4:3 aspect).
   EXPECT_TRUE(adapter_.AdaptFrameResolution(640, 480, 0,
                                             &cropped_width_, &cropped_height_,
                                             &out_width_, &out_height_));
 
   // Instead of getting the exact aspect ratio with cropped resolution 640x360,
   // the resolution should be adjusted to get a perfect scale factor instead.
   EXPECT_EQ(640, cropped_width_);
-  EXPECT_EQ(368, cropped_height_);
+  EXPECT_EQ(384, cropped_height_);
   EXPECT_EQ(120, out_width_);
-  EXPECT_EQ(69, out_height_);
+  EXPECT_EQ(72, out_height_);
 }
 
+TEST_F(VideoAdapterTest, TestScaleToReallySmall) {
+  // Ask for 960x720 (4:3 aspect) with 3/32 scaling.
+  const int w = 960;
+  const int h = 720;
+  adapter_.OnOutputFormatRequest(VideoFormat(w, h, 0, FOURCC_I420));
+  adapter_.OnResolutionRequest(rtc::Optional<int>(w * h * 3 / 32 * 3 / 32),
+                               rtc::Optional<int>());
+
+  // Send 1280x720 (16:9 aspect).
+  EXPECT_TRUE(adapter_.AdaptFrameResolution(1280, 720, 0, &cropped_width_,
+                                            &cropped_height_, &out_width_,
+                                            &out_height_));
+
+  EXPECT_EQ(1024, cropped_width_);
+  EXPECT_EQ(640, cropped_height_);
+  EXPECT_EQ(96, out_width_);
+  EXPECT_EQ(60, out_height_);
+}
+
+TEST_F(VideoAdapterTest, TestScaleFromReallyBig) {
+  // Ask for 7680x4320 (16:9 aspect) with 1/16 scaling.
+  const int w = 7680;
+  const int h = 4320;
+  adapter_.OnOutputFormatRequest(VideoFormat(w, h, 0, FOURCC_I420));
+  adapter_.OnResolutionRequest(rtc::Optional<int>(w * h * 1 / 16 * 1 / 16),
+                               rtc::Optional<int>());
+
+  // Send 8K (16:9 aspect).
+  EXPECT_TRUE(adapter_.AdaptFrameResolution(
+      w, h, 0, &cropped_width_, &cropped_height_, &out_width_, &out_height_));
+
+  EXPECT_EQ(7680, cropped_width_);
+  EXPECT_EQ(4288, cropped_height_);
+  EXPECT_EQ(480, out_width_);
+  EXPECT_EQ(268, out_height_);
+}
 }  // namespace cricket