Implement all resolution change policies for desktop and tab capture.

media/base/video_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/base/video_util.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "media/base/video_frame.h"
@@ skipping 252 matching lines @@
     uint8* dest_ptr = dest;
     for (int col = 0; col < num_cols; ++col) {
       *dest_ptr = *src_ptr++;
       dest_ptr += dest_col_step;
     }
     src += src_stride;
     dest += dest_row_step;
   }
 }
 
+// Common logic for the letterboxing and scale-within/scale-encompassing
+// functions.  Scales |size| to either fit within or encompass |target|,
+// depending on whether |fit_within_target| is true.
+static gfx::Size ScaleSizeToTarget(const gfx::Size& size,
+                                   const gfx::Size& target,
+                                   bool fit_within_target) {
+  if (size.IsEmpty())
+    return gfx::Size();  // Corner case: Aspect ratio is undefined.
+
+  const int64 x = static_cast<int64>(size.width()) * target.height();
+  const int64 y = static_cast<int64>(size.height()) * target.width();
+  const bool use_target_width = fit_within_target ? (y < x) : (x < y);
+  return use_target_width ?
+      gfx::Size(target.width(), static_cast<int>(y / size.width())) :
+      gfx::Size(static_cast<int>(x / size.height()), target.height());
+}
+
 gfx::Rect ComputeLetterboxRegion(const gfx::Rect& bounds,
                                  const gfx::Size& content) {
   // If |content| has an undefined aspect ratio, let's not try to divide by
   // zero.
   if (content.IsEmpty())
     return gfx::Rect();
 
-  int64 x = static_cast<int64>(content.width()) * bounds.height();
-  int64 y = static_cast<int64>(content.height()) * bounds.width();
+  gfx::Rect result = bounds;
+  result.ClampToCenteredSize(ScaleSizeToTarget(content, bounds.size(), true));
+  return result;
+}
 
-  gfx::Size letterbox(bounds.width(), bounds.height());
-  if (y < x)
-    letterbox.set_height(static_cast<int>(y / content.width()));
-  else
-    letterbox.set_width(static_cast<int>(x / content.height()));
-  gfx::Rect result = bounds;
-  result.ClampToCenteredSize(letterbox);
-  return result;
+gfx::Size ScaleSizeToFitWithinTarget(const gfx::Size& size,
+                                     const gfx::Size& target) {
+  return ScaleSizeToTarget(size, target, true);
+}
+
+gfx::Size ScaleSizeToEncompassTarget(const gfx::Size& size,
+                                     const gfx::Size& target) {
+  return ScaleSizeToTarget(size, target, false);
+}
+
+gfx::Size PadToMatchAspectRatio(const gfx::Size& size,
+                                const gfx::Size& target) {
+  if (target.IsEmpty())
+    return gfx::Size();  // Aspect ratio is undefined.
+
+  const int64 x = static_cast<int64>(size.width()) * target.height();
+  const int64 y = static_cast<int64>(size.height()) * target.width();
+  if (x < y)
+    return gfx::Size(static_cast<int>(y / target.height()), size.height());
+  return gfx::Size(size.width(), static_cast<int>(x / target.width()));
 }
 
 void CopyRGBToVideoFrame(const uint8* source,
                          int stride,
                          const gfx::Rect& region_in_frame,
                          VideoFrame* frame) {
   const int kY = VideoFrame::kYPlane;
   const int kU = VideoFrame::kUPlane;
   const int kV = VideoFrame::kVPlane;
   CHECK_EQ(frame->stride(kU), frame->stride(kV));
@@ skipping 13 matching lines @@
                     frame->data(kU) + uv_offset,
                     frame->data(kV) + uv_offset,
                     region_in_frame.width(),
                     region_in_frame.height(),
                     stride,
                     frame->stride(kY),
                     uv_stride);
 }
 
 }  // namespace media