Mac: Properly support all display scaling and resolutions (fix BoboTiG#23)

Also:
  - Generate namedtuple classes only once.

Improves performance whilst also allowing the classes to be
instantiated elsewhere.

Author: karanlyons

CHANGELOG

@@ -8,6 +8,7 @@ dev     2017/xx/xx
       - tests: a lot of tests added for better coverage
       - MSS: possibility to use custom class to handle screen shot data
       - Mac: handle screenshot's width not divisible by 16 (fix #14, #19, #21)
+      - Mac: properly support all display scaling and resolutions (fix #23)
       - Mac: fix memory leak (fix #24)
       - Linux: handle bad display value
       - Windows: Take into account zoom factor for high-DPI displays (fix #20)

CONTRIBUTORS

@@ -21,6 +21,9 @@ David Becker [https://davide.me] and redodo [https://github.com/redodo]
 Jochen 'cycomanic' Schroeder [https://github.com/cycomanic]
     - GNU/Linux: use errcheck instead of deprecated restype with callable, for enum_display_monitors()
 
+Karan Lyons <karan@karanlyons.com> [https://karanlyons.com] [https://github.com/karanlyons]
+    - MacOS: Proper support for display scaling
+
 Oros <oros@ecirtam.net> [https://ecirtam.net]
     - GNU/Linux tester
 

mss/darwin.py

@@ -4,19 +4,19 @@
 Source: https://github.com/BoboTiG/python-mss
 """
 
-# pylint: disable=import-error
+# pylint: disable=import-error, too-many-locals
 
 from __future__ import division
 
 import ctypes
 import ctypes.util
-import math
 import sys
 
 from .base import MSSBase
 from .exception import ScreenShotError
+from .screenshot import Size
 
-__all__ = ['MSS']
+__all__ = ('MSS',)
 
 
 def cgfloat():
@@ -94,10 +94,13 @@ def _set_argtypes(self):
             ctypes.c_uint32,
             ctypes.c_uint32]
         self.core.CGImageGetWidth.argtypes = [ctypes.c_void_p]
+        self.core.CGImageGetHeight.argtypes = [ctypes.c_void_p]
         self.core.CGImageGetDataProvider.argtypes = [ctypes.c_void_p]
         self.core.CGDataProviderCopyData.argtypes = [ctypes.c_void_p]
         self.core.CFDataGetBytePtr.argtypes = [ctypes.c_void_p]
         self.core.CFDataGetLength.argtypes = [ctypes.c_void_p]
+        self.core.CGImageGetBytesPerRow.argtypes = [ctypes.c_void_p]
+        self.core.CGImageGetBitsPerPixel.argtypes = [ctypes.c_void_p]
         self.core.CGDataProviderRelease.argtypes = [ctypes.c_void_p]
         self.core.CFRelease.argtypes = [ctypes.c_void_p]
 
@@ -111,11 +114,14 @@ def _set_restypes(self):
         self.core.CGRectUnion.restype = CGRect
         self.core.CGDisplayRotation.restype = ctypes.c_float
         self.core.CGWindowListCreateImage.restype = ctypes.c_void_p
-        self.core.CGImageGetWidth.restype = ctypes.c_uint32
+        self.core.CGImageGetWidth.restype = ctypes.c_size_t
+        self.core.CGImageGetHeight.restype = ctypes.c_size_t
         self.core.CGImageGetDataProvider.restype = ctypes.c_void_p
         self.core.CGDataProviderCopyData.restype = ctypes.c_void_p
         self.core.CFDataGetBytePtr.restype = ctypes.c_void_p
         self.core.CFDataGetLength.restype = ctypes.c_uint64
+        self.core.CGImageGetBytesPerRow.restype = ctypes.c_size_t
+        self.core.CGImageGetBitsPerPixel.restype = ctypes.c_size_t
         self.core.CGDataProviderRelease.restype = ctypes.c_void_p
         self.core.CFRelease.restype = ctypes.c_void_p
 
@@ -181,45 +187,42 @@ def grab(self, monitor):
                 'height': monitor[3] - monitor[1],
             }
 
-        # When the monitor width is not divisible by 16, extra padding
-        # is added by macOS in the form of black pixels, which results
-        # in a screenshot with shifted pixels.  To counter this, we
-        # round the width to the nearest integer divisible by 16, and
-        # we remove the extra width from the image after taking the
-        # screenshot.
-        rounded_width = math.ceil(monitor['width'] / 16) * 16
-
         rect = CGRect((monitor['left'], monitor['top']),
-                      (rounded_width, monitor['height']))
+                      (monitor['width'], monitor['height']))
 
         image_ref = self.core.CGWindowListCreateImage(rect, 1, 0, 0)
         if not image_ref:
             raise ScreenShotError(
                 'CoreGraphics.CGWindowListCreateImage() failed.', locals())
 
         width = int(self.core.CGImageGetWidth(image_ref))
-        prov = self.core.CGImageGetDataProvider(image_ref)
-        copy_data = self.core.CGDataProviderCopyData(prov)
-        data_ref = self.core.CFDataGetBytePtr(copy_data)
-        buf_len = self.core.CFDataGetLength(copy_data)
-        raw = ctypes.cast(data_ref, ctypes.POINTER(ctypes.c_ubyte * buf_len))
-        data = bytearray(raw.contents)
-        self.core.CGDataProviderRelease(prov)
-        self.core.CFRelease(copy_data)
-
-        if rounded_width != monitor['width']:
-            data = self._crop_width(data, monitor, width)
-
-        return self.cls_image(data, monitor)
-
-    @staticmethod
-    def _crop_width(image, monitor, width_to):
-        # type: (bytearray, Dict[str, int], int) -> bytearray
-        """ Cut off the pixels from an image buffer at a particular width. """
-
-        cropped = bytearray()
-        for row in range(monitor['height']):
-            start = row * width_to * 4
-            end = start + monitor['width'] * 4
-            cropped.extend(image[start:end])
-        return cropped
+        height = int(self.core.CGImageGetHeight(image_ref))
+        prov = copy_data = None
+        try:
+            prov = self.core.CGImageGetDataProvider(image_ref)
+            copy_data = self.core.CGDataProviderCopyData(prov)
+            data_ref = self.core.CFDataGetBytePtr(copy_data)
+            buf_len = self.core.CFDataGetLength(copy_data)
+            raw = ctypes.cast(
+                data_ref, ctypes.POINTER(ctypes.c_ubyte * buf_len))
+            data = bytearray(raw.contents)
+
+            # Remove padding per row
+            bytes_per_row = int(self.core.CGImageGetBytesPerRow(image_ref))
+            bytes_per_pixel = int(self.core.CGImageGetBitsPerPixel(image_ref))
+            bytes_per_pixel = (bytes_per_pixel + 7) // 8
+
+            if bytes_per_pixel * width != bytes_per_row:
+                cropped = bytearray()
+                for row in range(height):
+                    start = row * bytes_per_row
+                    end = start + width * bytes_per_pixel
+                    cropped.extend(data[start:end])
+                data = cropped
+        finally:
+            if prov:
+                self.core.CGDataProviderRelease(prov)
+            if copy_data:
+                self.core.CFRelease(copy_data)
+
+        return self.cls_image(data, monitor, size=Size(width, height))

mss/linux.py

@@ -11,7 +11,7 @@
 from .base import MSSBase
 from .exception import ScreenShotError
 
-__all__ = ['MSS']
+__all__ = ('MSS',)
 
 
 class Display(ctypes.Structure):

mss/screenshot.py

@@ -9,6 +9,10 @@
 from .exception import ScreenShotError
 
 
+Pos = collections.namedtuple('Pos', 'left, top')
+Size = collections.namedtuple('Size', 'width, height')
+
+
 class ScreenShot(object):
     """
     Screen shot object.
@@ -22,19 +26,20 @@ class ScreenShot(object):
     __pixels = None  # type: List[Tuple[int, int, int]]
     __rgb = None  # type: bytes
 
-    def __init__(self, data, monitor):
-        # type: (bytearray, Dict[str, int]) -> None
+    def __init__(self, data, monitor, size=None):
+        # type: (bytearray, Dict[str, int], Any) -> None
         #: Bytearray of the raw BGRA pixels retrieved by ctype
         #: OS independent implementations.
         self.raw = bytearray(data)  # type: bytearray
 
         #: NamedTuple of the screen shot coordinates.
-        self.pos = collections.namedtuple('pos', 'left, top')(
-            monitor['left'], monitor['top'])  # type: Any
+        self.pos = Pos(monitor['left'], monitor['top'])  # type: Pos
 
-        #: NamedTuple of the screen shot size.
-        self.size = collections.namedtuple('size', 'width, height')(
-            monitor['width'], monitor['height'])  # type: Any
+        if size is not None:
+            #: NamedTuple of the screen shot size.
+            self.size = size  # type: Size
+        else:
+            self.size = Size(monitor['width'], monitor['height'])  # type: Size
 
     def __repr__(self):
         # type: () -> str

mss/windows.py

@@ -12,7 +12,7 @@
 from .base import MSSBase
 from .exception import ScreenShotError
 
-__all__ = ['MSS']
+__all__ = ('MSS',)
 
 
 class BITMAPINFOHEADER(ctypes.Structure):

tests/test_cls_image.py

@@ -3,7 +3,7 @@
 
 class SimpleScreenShot(object):
 
-    def __init__(self, data, monitor):
+    def __init__(self, data, monitor, **kwargs):
         self.raw = bytes(data)
         self.monitor = monitor