Bug Fix: Mac Retina Screen Capture's Mouse Cursor Too Small

webrtc/modules/desktop_capture/mouse_cursor_monitor_mac.mm

 /*
  *  Copyright (c) 2013 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 12 matching lines @@
 #include "webrtc/modules/desktop_capture/desktop_capture_options.h"
 #include "webrtc/modules/desktop_capture/desktop_frame.h"
 #include "webrtc/modules/desktop_capture/mac/desktop_configuration.h"
 #include "webrtc/modules/desktop_capture/mac/desktop_configuration_monitor.h"
 #include "webrtc/modules/desktop_capture/mac/full_screen_chrome_window_detector.h"
 #include "webrtc/modules/desktop_capture/mouse_cursor.h"
 #include "webrtc/system_wrappers/include/logging.h"
 
 namespace webrtc {
 
+namespace {
+NSImage* PaintInCurrentContext(NSImage* source, NSSize new_size) {

[Sergey Ulanov, 2016/09/20 22:53:22]

Add a comment to explain why we need this function.

[qiangchen, 2016/09/21 16:38:31]

Done.

+  NSImage* new_image = [[[NSImage alloc] initWithSize:new_size] autorelease];
+  [source setSize:new_size];
+  [new_image lockFocus];
+  NSRect frame = NSMakeRect(0, 0, new_size.width, new_size.height);
+  [source drawInRect:frame
+            fromRect:frame
+           operation:NSCompositeCopy
+            fraction:1.0];
+  [new_image unlockFocus];
+  return new_image;
+}
+}

[Sergey Ulanov, 2016/09/20 22:53:22]

// namespace

[qiangchen, 2016/09/21 16:38:32]

Done.

+
 class MouseCursorMonitorMac : public MouseCursorMonitor {
  public:
   MouseCursorMonitorMac(const DesktopCaptureOptions& options,
                         CGWindowID window_id,
                         ScreenId screen_id);
   virtual ~MouseCursorMonitorMac();
 
   void Init(Callback* callback, Mode mode) override;
   void Capture() override;
 
  private:
   static void DisplaysReconfiguredCallback(CGDirectDisplayID display,
                                            CGDisplayChangeSummaryFlags flags,
                                            void *user_parameter);
   void DisplaysReconfigured(CGDirectDisplayID display,
                             CGDisplayChangeSummaryFlags flags);
 
-  void CaptureImage();
+  void CaptureImage(float scale);
 
   rtc::scoped_refptr<DesktopConfigurationMonitor> configuration_monitor_;
   CGWindowID window_id_;
   ScreenId screen_id_;
   Callback* callback_;
   Mode mode_;
   std::unique_ptr<MouseCursor> last_cursor_;
   rtc::scoped_refptr<FullScreenChromeWindowDetector>
       full_screen_chrome_window_detector_;
 };
@@ skipping 23 matching lines @@
   assert(!callback_);
   assert(callback);
 
   callback_ = callback;
   mode_ = mode;
 }
 
 void MouseCursorMonitorMac::Capture() {
   assert(callback_);
 
-  CaptureImage();
-
-  if (mode_ != SHAPE_AND_POSITION)
-    return;
-
   CursorState state = INSIDE;
 
   CGEventRef event = CGEventCreate(NULL);
   CGPoint gc_position = CGEventGetLocation(event);
   CFRelease(event);
 
   DesktopVector position(gc_position.x, gc_position.y);
 
   configuration_monitor_->Lock();
   MacDesktopConfiguration configuration =
       configuration_monitor_->desktop_configuration();
   configuration_monitor_->Unlock();
   float scale = 1.0f;
 
   // Find the dpi to physical pixel scale for the screen where the mouse cursor
   // is.
   for (MacDisplayConfigurations::iterator it = configuration.displays.begin();
-      it != configuration.displays.end(); ++it) {
+       it != configuration.displays.end(); ++it) {
     if (it->bounds.Contains(position)) {
       scale = it->dip_to_pixel_scale;
       break;
     }
   }
+
+  CaptureImage(scale);
+
+  if (mode_ != SHAPE_AND_POSITION)
+    return;
+
   // If we are capturing cursor for a specific window then we need to figure out
   // if the current mouse position is covered by another window and also adjust
   // |position| to make it relative to the window origin.
   if (window_id_ != kCGNullWindowID) {
     CGWindowID on_screen_window = window_id_;
     if (full_screen_chrome_window_detector_) {
       CGWindowID full_screen_window =
           full_screen_chrome_window_detector_->FindFullScreenWindow(window_id_);
 
       if (full_screen_window != kCGNullWindowID)
@@ skipping 89 matching lines @@
     }
   }
   if (state == INSIDE) {
     // Convert Density Independent Pixel to physical pixel.
     position = DesktopVector(round(position.x() * scale),
                              round(position.y() * scale));
   }
   callback_->OnMouseCursorPosition(state, position);
 }
 
-void MouseCursorMonitorMac::CaptureImage() {
+void MouseCursorMonitorMac::CaptureImage(float scale) {
   NSCursor* nscursor = [NSCursor currentSystemCursor];
 
   NSImage* nsimage = [nscursor image];
-  NSSize nssize = [nsimage size];
-  DesktopSize size(nssize.width, nssize.height);
+  NSSize nssize = [nsimage size];  // DIP size
+
+  // For retina screen, we need to paint the cursor in current graphic context
+  // to get retina representation.
+  if (scale != 1.0)
+    nsimage = PaintInCurrentContext(nsimage, nssize);

[Sergey Ulanov, 2016/09/20 22:53:22]

Do we need to nssize here? the function can just call [nscursor image]. Also
It's not clear how this accomplishes anything: you pass current size as new
size.

[qiangchen, 2016/09/21 16:38:31]

Done.

Originally, I thought we need to plug in nssize*2 to scale it. By testing, nope.

+
+  DesktopSize size(round(nssize.width * scale),
+                   round(nssize.height * scale));  // Pixel size
   NSPoint nshotspot = [nscursor hotSpot];
   DesktopVector hotspot(
-      std::max(0, std::min(size.width(), static_cast<int>(nshotspot.x))),
-      std::max(0, std::min(size.height(), static_cast<int>(nshotspot.y))));
+      std::max(0,
+               std::min(size.width(), static_cast<int>(nshotspot.x * scale))),
+      std::max(0,
+               std::min(size.height(), static_cast<int>(nshotspot.y * scale))));
   CGImageRef cg_image =
       [nsimage CGImageForProposedRect:NULL context:nil hints:nil];
   if (!cg_image)
     return;
 
   if (CGImageGetBitsPerPixel(cg_image) != DesktopFrame::kBytesPerPixel * 8 ||
-      CGImageGetBytesPerRow(cg_image) !=
-          static_cast<size_t>(DesktopFrame::kBytesPerPixel * size.width()) ||
+      CGImageGetWidth(cg_image) != static_cast<size_t>(size.width()) ||
       CGImageGetBitsPerComponent(cg_image) != 8) {
     return;
   }
 
   CGDataProviderRef provider = CGImageGetDataProvider(cg_image);
   CFDataRef image_data_ref = CGDataProviderCopyData(provider);
   if (image_data_ref == NULL)
     return;
 
   const uint8_t* src_data =
       reinterpret_cast<const uint8_t*>(CFDataGetBytePtr(image_data_ref));
 
   // Compare the cursor with the previous one.
   if (last_cursor_.get() &&
       last_cursor_->image()->size().equals(size) &&
       last_cursor_->hotspot().equals(hotspot) &&
       memcmp(last_cursor_->image()->data(), src_data,
              last_cursor_->image()->stride() * size.height()) == 0) {
     CFRelease(image_data_ref);
     return;
   }
 
   // Create a MouseCursor that describes the cursor and pass it to
   // the client.
   std::unique_ptr<DesktopFrame> image(
       new BasicDesktopFrame(DesktopSize(size.width(), size.height())));
-  memcpy(image->data(), src_data,
-         size.width() * size.height() * DesktopFrame::kBytesPerPixel);
+
+  int src_stride = CGImageGetBytesPerRow(cg_image);
+  int dst_stride = size.width() * DesktopFrame::kBytesPerPixel;
+  if (src_stride == dst_stride) {
+    memcpy(image->data(), src_data, size.height() * src_stride);
+  } else {
+    for (int y = 0; y < size.height(); y++) {

[Sergey Ulanov, 2016/09/20 22:53:22]

Use CopyPixelsFrom() here?

[qiangchen, 2016/09/21 16:38:32]

Done.

+      memcpy(image->data() + y * dst_stride, src_data + y * src_stride,
+             dst_stride);
+    }
+  }
 
   CFRelease(image_data_ref);
 
   std::unique_ptr<MouseCursor> cursor(
       new MouseCursor(image.release(), hotspot));
   last_cursor_.reset(MouseCursor::CopyOf(*cursor));
 
   callback_->OnMouseCursor(cursor.release());
 }
 
 MouseCursorMonitor* MouseCursorMonitor::CreateForWindow(
     const DesktopCaptureOptions& options, WindowId window) {
   return new MouseCursorMonitorMac(options, window, kInvalidScreenId);
 }
 
 MouseCursorMonitor* MouseCursorMonitor::CreateForScreen(
     const DesktopCaptureOptions& options,
     ScreenId screen) {
   return new MouseCursorMonitorMac(options, kCGNullWindowID, screen);
 }
 
 }  // namespace webrtc