Add support for high-DPI hosts under Mac OS X.

remoting/capturer/video_frame_capturer_mac.mm

 // 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 "remoting/capturer/video_frame_capturer.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <Cocoa/Cocoa.h>
 #include <dlfcn.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
 #include <OpenGL/CGLMacro.h>
 #include <OpenGL/OpenGL.h>
 #include <set>
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/file_path.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_native_library.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
 #include "remoting/capturer/capture_data.h"
+#include "remoting/capturer/mac/desktop_configuration.h"
 #include "remoting/capturer/mac/scoped_pixel_buffer_object.h"
 #include "remoting/capturer/mouse_cursor_shape.h"
 #include "remoting/capturer/video_frame.h"
 #include "remoting/capturer/video_frame_capturer_helper.h"
 #include "remoting/capturer/video_frame_queue.h"
+#include "skia/ext/skia_utils_mac.h"
 
 namespace remoting {
 
 namespace {
 
 // Definitions used to dynamic-link to deprecated OS 10.6 functions.
 const char* kApplicationServicesLibraryName =
     "/System/Library/Frameworks/ApplicationServices.framework/"
     "ApplicationServices";
 typedef void* (*CGDisplayBaseAddressFunc)(CGDirectDisplayID);
 typedef size_t (*CGDisplayBytesPerRowFunc)(CGDirectDisplayID);
 typedef size_t (*CGDisplayBitsPerPixelFunc)(CGDirectDisplayID);
 const char* kOpenGlLibraryName =
     "/System/Library/Frameworks/OpenGL.framework/OpenGL";
 typedef CGLError (*CGLSetFullScreenFunc)(CGLContextObj);
 
 // skia/ext/skia_utils_mac.h only defines CGRectToSkRect().
 SkIRect CGRectToSkIRect(const CGRect& rect) {
-  SkIRect sk_rect = {
-    SkScalarRound(rect.origin.x),
-    SkScalarRound(rect.origin.y),
-    SkScalarRound(rect.origin.x + rect.size.width),
-    SkScalarRound(rect.origin.y + rect.size.height)
+  SkIRect result;
+  gfx::CGRectToSkRect(rect).round(&result);
+  return result;
+}
+
+// Scales all coordinates of an SkRect by a specified factor.
+SkRect ScaleSkRect(const SkRect& rect, float scale) {

[Nico, 2013/01/24 00:26:58]

I believe we already have a function like this somewhere in ui/gfx, but maybe
remoting doesn't depend on that

[Wez, 2013/01/24 00:57:30]

I couldn't see anything in there that did a simple scale of an SkRect - the only
likely candidates looked to require converting to gfx::Rect and then applying a
matrix transform...

+  SkRect result = {
+    rect.left() * scale, rect.top() * scale,
+    rect.right() * scale, rect.bottom() * scale
   };
-  return sk_rect;
+  return result;
 }
 
 // Copy pixels in the |rect| from |src_place| to |dest_plane|.
 void CopyRect(const uint8* src_plane,
               int src_plane_stride,
               uint8* dest_plane,
               int dest_plane_stride,
               int bytes_per_pixel,
               const SkIRect& rect) {
   // Get the address of the starting point.
@@ skipping 12 matching lines @@
     dest_plane += dest_plane_stride;
   }
 }
 
 // The amount of time allowed for displays to reconfigure.
 const int64 kDisplayConfigurationEventTimeoutInSeconds = 10;
 
 // A class representing a full-frame pixel buffer.
 class VideoFrameMac : public VideoFrame {
  public:
-  explicit VideoFrameMac(const SkISize& size);
+  explicit VideoFrameMac(const MacDesktopConfiguration& desktop_config);
   virtual ~VideoFrameMac();
 
   const SkIPoint& dpi() const { return dpi_; }
 
  private:
   // Allocated pixel buffer.
   scoped_array<uint8> data_;
 
   // DPI settings for this buffer.
   SkIPoint dpi_;
@@ skipping 47 matching lines @@
 
   Delegate* delegate_;
 
   CGLContextObj cgl_context_;
   ScopedPixelBufferObject pixel_buffer_object_;
 
   // Queue of the frames buffers.
   VideoFrameQueue queue_;
 
   // Current display configuration.
-  std::vector<CGDirectDisplayID> display_ids_;
-  SkIRect desktop_bounds_;
+  MacDesktopConfiguration desktop_config_;
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   VideoFrameCapturerHelper helper_;
 
   // Image of the last cursor that we sent to the client.
   base::mac::ScopedCFTypeRef<CGImageRef> current_cursor_;
 
   // Contains an invalid region from the previous capture.
   SkRegion last_invalid_region_;
@@ skipping 16 matching lines @@
   base::ScopedNativeLibrary app_services_library_;
   CGDisplayBaseAddressFunc cg_display_base_address_;
   CGDisplayBytesPerRowFunc cg_display_bytes_per_row_;
   CGDisplayBitsPerPixelFunc cg_display_bits_per_pixel_;
   base::ScopedNativeLibrary opengl_library_;
   CGLSetFullScreenFunc cgl_set_full_screen_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCapturerMac);
 };
 
-VideoFrameMac::VideoFrameMac(const SkISize& size) {
+VideoFrameMac::VideoFrameMac(const MacDesktopConfiguration& desktop_config) {
+  SkISize size = SkISize::Make(desktop_config.pixel_bounds.width(),
+                               desktop_config.pixel_bounds.height());
   set_bytes_per_row(size.width() * sizeof(uint32_t));
   set_dimensions(size);
 
   size_t buffer_size = size.width() * size.height() * sizeof(uint32_t);
   data_.reset(new  uint8[buffer_size]);
   set_pixels(data_.get());
 
-  // TODO(wez): Move the ugly DPI code into a helper.
-  NSScreen* screen = [NSScreen mainScreen];
-  NSDictionary* attr = [screen deviceDescription];
-  NSSize resolution = [[attr objectForKey: NSDeviceResolution] sizeValue];
-  dpi_.set(resolution.width, resolution.height);
+  dpi_ = desktop_config.dpi;
 }
 
 VideoFrameMac::~VideoFrameMac() {
 }
 
 VideoFrameCapturerMac::VideoFrameCapturerMac()
     : delegate_(NULL),
       cgl_context_(NULL),
       display_configuration_capture_event_(false, true),
       power_assertion_id_display_(kIOPMNullAssertionID),
@@ skipping 105 matching lines @@
       base::TimeDelta::FromSeconds(
           kDisplayConfigurationEventTimeoutInSeconds)));
 
   SkRegion region;
   helper_.SwapInvalidRegion(&region);
 
   // If the current buffer is from an older generation then allocate a new one.
   // Note that we can't reallocate other buffers at this point, since the caller
   // may still be reading from them.
   if (queue_.current_frame_needs_update()) {
-    scoped_ptr<VideoFrameMac> buffer(new VideoFrameMac(
-        SkISize::Make(desktop_bounds_.width(), desktop_bounds_.height())));
+    scoped_ptr<VideoFrameMac> buffer(new VideoFrameMac(desktop_config_));
     queue_.ReplaceCurrentFrame(buffer.PassAs<VideoFrame>());
   }
 
   VideoFrame* current_buffer = queue_.current_frame();
 
   bool flip = false;  // GL capturers need flipping.
   if (base::mac::IsOSLionOrLater()) {
     // Lion requires us to use their new APIs for doing screen capture. These
     // APIS currently crash on 10.6.8 if there is no monitor attached.
     CgBlitPostLion(*current_buffer, region);
@@ skipping 202 matching lines @@
 
   // Copy the entire contents of the previous capture buffer, to capture over.
   // TODO(wez): Get rid of this as per crbug.com/145064, or implement
   // crbug.com/92354.
   if (queue_.previous_frame()) {
     memcpy(buffer.pixels(),
            queue_.previous_frame()->pixels(),
            buffer.bytes_per_row() * buffer_height);
   }
 
-  for (unsigned int d = 0; d < display_ids_.size(); ++d) {
+  for (size_t i = 0; i < desktop_config_.displays.size(); ++i) {
+    const MacDisplayConfiguration& display_config = desktop_config_.displays[i];
+
     // Use deprecated APIs to determine the display buffer layout.
     DCHECK(cg_display_base_address_ && cg_display_bytes_per_row_ &&
         cg_display_bits_per_pixel_);
     uint8* display_base_address =
-      reinterpret_cast<uint8*>((*cg_display_base_address_)(display_ids_[d]));
+      reinterpret_cast<uint8*>((*cg_display_base_address_)(display_config.id));
     CHECK(display_base_address);
-    int src_bytes_per_row = (*cg_display_bytes_per_row_)(display_ids_[d]);
+    int src_bytes_per_row = (*cg_display_bytes_per_row_)(display_config.id);
     int src_bytes_per_pixel =
-        (*cg_display_bits_per_pixel_)(display_ids_[d]) / 8;
+        (*cg_display_bits_per_pixel_)(display_config.id) / 8;
 
-    // Determine the position of the display in the buffer.
-    SkIRect display_bounds = CGRectToSkIRect(CGDisplayBounds(display_ids_[d]));
-    display_bounds.offset(-desktop_bounds_.left(), -desktop_bounds_.top());
+    // Determine the display's position relative to the desktop, in pixels.
+    SkIRect display_bounds = display_config.pixel_bounds;
+    display_bounds.offset(-desktop_config_.pixel_bounds.left(),
+                          -desktop_config_.pixel_bounds.top());
 
     // Determine which parts of the blit region, if any, lay within the monitor.
     SkRegion copy_region;
     if (!copy_region.op(region, display_bounds, SkRegion::kIntersect_Op))
       continue;
 
     // Translate the region to be copied into display-relative coordinates.
-    copy_region.translate(-display_bounds.left(), -display_bounds.top());
+    copy_region.translate(-desktop_config_.pixel_bounds.left(),
+                          -desktop_config_.pixel_bounds.top());
 
     // Calculate where in the output buffer the display's origin is.
     uint8* out_ptr = buffer.pixels() +
          (display_bounds.left() * src_bytes_per_pixel) +
          (display_bounds.top() * buffer.bytes_per_row());
 
     // Copy the dirty region from the display buffer into our desktop buffer.
     for(SkRegion::Iterator i(copy_region); !i.done(); i.next()) {
       CopyRect(display_base_address,
                src_bytes_per_row,
@@ skipping 11 matching lines @@
 
   // Copy the entire contents of the previous capture buffer, to capture over.
   // TODO(wez): Get rid of this as per crbug.com/145064, or implement
   // crbug.com/92354.
   if (queue_.previous_frame()) {
     memcpy(buffer.pixels(),
            queue_.previous_frame()->pixels(),
            buffer.bytes_per_row() * buffer_height);
   }
 
-  for (unsigned int d = 0; d < display_ids_.size(); ++d) {
-    // Determine the position of the display in the buffer.
-    SkIRect display_bounds = CGRectToSkIRect(CGDisplayBounds(display_ids_[d]));
-    display_bounds.offset(-desktop_bounds_.left(), -desktop_bounds_.top());
+  for (size_t i = 0; i < desktop_config_.displays.size(); ++i) {
+    const MacDisplayConfiguration& display_config = desktop_config_.displays[i];
+
+    // Determine the display's position relative to the desktop, in pixels.
+    SkIRect display_bounds = display_config.pixel_bounds;
+    display_bounds.offset(-desktop_config_.pixel_bounds.left(),
+                          -desktop_config_.pixel_bounds.top());
 
     // Determine which parts of the blit region, if any, lay within the monitor.
     SkRegion copy_region;
     if (!copy_region.op(region, display_bounds, SkRegion::kIntersect_Op))
       continue;
 
     // Translate the region to be copied into display-relative coordinates.
-    copy_region.translate(-display_bounds.left(), -display_bounds.top());
+    copy_region.translate(-desktop_config_.pixel_bounds.left(),
+                          -desktop_config_.pixel_bounds.top());
 
     // Create an image containing a snapshot of the display.
     base::mac::ScopedCFTypeRef<CGImageRef> image(
-        CGDisplayCreateImage(display_ids_[d]));
+        CGDisplayCreateImage(display_config.id));
     if (image.get() == NULL)
       continue;
 
     // Request access to the raw pixel data via the image's DataProvider.
     CGDataProviderRef provider = CGImageGetDataProvider(image);
     base::mac::ScopedCFTypeRef<CFDataRef> data(
         CGDataProviderCopyData(provider));
     if (data.get() == NULL)
       continue;
 
@@ skipping 18 matching lines @@
   }
 }
 
 void VideoFrameCapturerMac::ScreenConfigurationChanged() {
   // Release existing buffers, which will be of the wrong size.
   ReleaseBuffers();
 
   // Clear the dirty region, in case the display is down-sizing.
   helper_.ClearInvalidRegion();
 
-  // Fetch the list if active displays and calculate their bounds.
-  CGDisplayCount display_count;
-  CGError error = CGGetActiveDisplayList(0, NULL, &display_count);
-  CHECK_EQ(error, CGDisplayNoErr);
-
-  display_ids_.resize(display_count);
-  error = CGGetActiveDisplayList(display_count, &display_ids_[0],
-                                 &display_count);
-  CHECK_EQ(error, CGDisplayNoErr);
-  CHECK_EQ(display_count, display_ids_.size());
-
-  desktop_bounds_ = SkIRect::MakeEmpty();
-  for (unsigned int d = 0; d < display_count; ++d) {
-    CGRect display_bounds = CGDisplayBounds(display_ids_[d]);
-    desktop_bounds_.join(CGRectToSkIRect(display_bounds));
-  }
+  // Refresh the cached desktop configuration.
+  desktop_config_ = MacDesktopConfiguration::GetCurrent();
 
   // Re-mark the entire desktop as dirty.
-  helper_.InvalidateScreen(SkISize::Make(desktop_bounds_.width(),
-                                         desktop_bounds_.height()));
+  helper_.InvalidateScreen(
+      SkISize::Make(desktop_config_.pixel_bounds.width(),
+                    desktop_config_.pixel_bounds.height()));
 
   // Make sure the frame buffers will be reallocated.
   queue_.SetAllFramesNeedUpdate();
 
   // CgBlitPostLion uses CGDisplayCreateImage() to snapshot each display's
   // contents. Although the API exists in OS 10.6, it crashes the caller if
   // the machine has no monitor connected, so we fall back to depcreated APIs
   // when running on 10.6.
   if (base::mac::IsOSLionOrLater()) {
     LOG(INFO) << "Using CgBlitPostLion.";
@@ skipping 18 matching lines @@
       app_services_library_.GetFunctionPointer("CGDisplayBaseAddress"));
   cg_display_bytes_per_row_ = reinterpret_cast<CGDisplayBytesPerRowFunc>(
       app_services_library_.GetFunctionPointer("CGDisplayBytesPerRow"));
   cg_display_bits_per_pixel_ = reinterpret_cast<CGDisplayBitsPerPixelFunc>(
       app_services_library_.GetFunctionPointer("CGDisplayBitsPerPixel"));
   cgl_set_full_screen_ = reinterpret_cast<CGLSetFullScreenFunc>(
       opengl_library_.GetFunctionPointer("CGLSetFullScreen"));
   CHECK(cg_display_base_address_ && cg_display_bytes_per_row_ &&
         cg_display_bits_per_pixel_ && cgl_set_full_screen_);
 
-  if (display_ids_.size() > 1) {
+  if (desktop_config_.displays.size() > 1) {
     LOG(INFO) << "Using CgBlitPreLion (Multi-monitor).";
     return;
   }
 
   CGDirectDisplayID mainDevice = CGMainDisplayID();
   if (!CGDisplayUsesOpenGLAcceleration(mainDevice)) {
     LOG(INFO) << "Using CgBlitPreLion (OpenGL unavailable).";
     return;
   }
 
@@ skipping 10 matching lines @@
   CGLError err = CGLChoosePixelFormat(attributes,
                                       &pixel_format,
                                       &matching_pixel_format_count);
   DCHECK_EQ(err, kCGLNoError);
   err = CGLCreateContext(pixel_format, NULL, &cgl_context_);
   DCHECK_EQ(err, kCGLNoError);
   CGLDestroyPixelFormat(pixel_format);
   (*cgl_set_full_screen_)(cgl_context_);
   CGLSetCurrentContext(cgl_context_);
 
-  size_t buffer_size = desktop_bounds_.width() * desktop_bounds_.height() *
+  size_t buffer_size = desktop_config_.pixel_bounds.width() *
+                       desktop_config_.pixel_bounds.height() *
                        sizeof(uint32_t);
   pixel_buffer_object_.Init(cgl_context_, buffer_size);
 }
 
 void VideoFrameCapturerMac::ScreenRefresh(CGRectCount count,
                                           const CGRect* rect_array) {
-  if (desktop_bounds_.isEmpty()) {
+  if (desktop_config_.pixel_bounds.isEmpty()) {
     return;
   }
   SkIRect skirect_array[count];
+
   for (CGRectCount i = 0; i < count; ++i) {
-    skirect_array[i] = CGRectToSkIRect(rect_array[i]);
-    skirect_array[i].offset(-desktop_bounds_.left(), -desktop_bounds_.top());
+    SkRect sk_rect = gfx::CGRectToSkRect(rect_array[i]);
+
+    // Convert from logical to pixel (device-scale) coordinates.
+    sk_rect = ScaleSkRect(sk_rect, desktop_config_.logical_to_pixel_scale);
+    sk_rect.round(&skirect_array[i]);
+
+    // Translate from local desktop to capturer framebuffer coordinates.
+    skirect_array[i].offset(-desktop_config_.pixel_bounds.left(),
+                            -desktop_config_.pixel_bounds.top());
   }
+
   SkRegion region;
   region.setRects(skirect_array, count);
   InvalidateRegion(region);
 }
 
 void VideoFrameCapturerMac::ScreenUpdateMove(CGScreenUpdateMoveDelta delta,
                                              size_t count,
                                              const CGRect* rect_array) {
-  SkIRect skirect_array[count];
+  // Translate |rect_array| to identify the move's destination.
+  CGRect refresh_rects[count];
   for (CGRectCount i = 0; i < count; ++i) {
-    CGRect rect = rect_array[i];
-    rect = CGRectOffset(rect, delta.dX, delta.dY);
-    skirect_array[i] = CGRectToSkIRect(rect);
-    skirect_array[i].offset(-desktop_bounds_.left(), -desktop_bounds_.top());
+    refresh_rects[i] = CGRectOffset(rect_array[i], delta.dX, delta.dY);
   }
-  SkRegion region;
-  region.setRects(skirect_array, count);
-  InvalidateRegion(region);
+
+  // Currently we just treat move events the same as refreshes.
+  ScreenRefresh(count, refresh_rects);
 }
 
 void VideoFrameCapturerMac::DisplaysReconfigured(
     CGDirectDisplayID display,
     CGDisplayChangeSummaryFlags flags) {
   if (flags & kCGDisplayBeginConfigurationFlag) {
     if (reconfiguring_displays_.empty()) {
       // If this is the first display to start reconfiguring then wait on
       // |display_configuration_capture_event_| to block the capture thread
       // from accessing display memory until the reconfiguration completes.
@@ skipping 13 matching lines @@
       display_configuration_capture_event_.Signal();
     }
   }
 }
 
 void VideoFrameCapturerMac::ScreenRefreshCallback(CGRectCount count,
                                                   const CGRect* rect_array,
                                                   void* user_parameter) {
   VideoFrameCapturerMac* capturer = reinterpret_cast<VideoFrameCapturerMac*>(
       user_parameter);
-  if (capturer->desktop_bounds_.isEmpty()) {
+  if (capturer->desktop_config_.pixel_bounds.isEmpty()) {
     capturer->ScreenConfigurationChanged();
   }
   capturer->ScreenRefresh(count, rect_array);
 }
 
 void VideoFrameCapturerMac::ScreenUpdateMoveCallback(
     CGScreenUpdateMoveDelta delta,
     size_t count,
     const CGRect* rect_array,
     void* user_parameter) {
@@ skipping 22 matching lines @@
 }
 
 // static
 scoped_ptr<VideoFrameCapturer> VideoFrameCapturer::CreateWithFactory(
     SharedBufferFactory* shared_buffer_factory) {
   NOTIMPLEMENTED();
   return scoped_ptr<VideoFrameCapturer>();
 }
 
 }  // namespace remoting