fix: correct cursor coordinates for window, region, and secondary-display capture

The mouse tracker mapped global cursor points into recorded-file pixels
with scale = pixelSize / displayBounds and no origin subtraction — and
the session always passed full-display bounds with the *content's* pixel
size. For window capture that's the wrong ratio (window pixels over
display points) AND ignores where the window sits on screen, so the
synthetic cursor landed far from the real pointer in every window
recording. Only full-primary-display capture happened to map correctly.

- Capture now publishes a single CaptureGeometry-style rect: the
  content's global rect in points, top-left origin (the CGEvent space) —
  the filter's contentRect for window capture, display.frame for display
  capture (a secondary display's origin is not (0,0)), and the offset
  region rect for region capture. Mapping is
  (global − origin) × pixels-per-point, per axis.
- The seed sample now converts Cocoa→CG coordinates using the *primary*
  screen's height; it used NSScreen.main (the key window's screen),
  which corrupted the t=0 sample on multi-display setups. Tap events use
  CGEvent's native top-left coords directly instead of a
  flip-and-flip-back round trip.
- The regionOffsetPixels plumbing is folded into the content rect, and
  CaptureInfo.displayBounds (whose value was wrong for anything but
  full-display capture) is replaced by contentRectPoints.

Validation note: display recordings were previously validated correct
against real footage and keep identical math (primary display origin is
(0,0)); the window/secondary-display paths should be spot-checked with
the ffmpeg frame-extraction method on a real window recording.

Author: jasonzh0

CineScreen/Capture/MouseTrackingService.swift

@@ -36,16 +36,16 @@ enum MouseTrackingError: LocalizedError {
 
 @MainActor
 final class MouseTrackingService {
-    /// Display bounds in points; used to map global-coord mouse positions
-    /// onto the recorded image.
-    private var displayBoundsPoints: CGRect = .zero
-    /// Pixel size of the recorded image (output frame).
+    /// The captured content's rect in global screen points (top-left origin,
+    /// CGEvent space). Mouse points map into file pixels relative to this —
+    /// origin subtraction handles windows/regions/secondary displays that
+    /// don't sit at the global origin.
+    private var contentRectPoints: CGRect = .zero
+    /// Pixel size of the recorded image (output frame, after any downscale).
     private var pixelSize: CGSize = .zero
-    /// scaleFactor = pixelSize / displayBounds — cached for the hot path.
-    private var scale: CGFloat = 2.0
-    /// If a region was captured, this offset is subtracted (in pixels)
-    /// before clamping to pixelSize.
-    private var regionOffsetPixels: CGPoint = .zero
+    /// pixels-per-point, cached per axis for the hot path.
+    private var scaleX: CGFloat = 2.0
+    private var scaleY: CGFloat = 2.0
 
     private var startTime: CFAbsoluteTime = 0
     private var tap: CFMachPort?
@@ -62,18 +62,20 @@ final class MouseTrackingService {
 
     // MARK: - Lifecycle
 
-    func start(displayBoundsPoints: CGRect, pixelSize: CGSize, regionOffsetPixels: CGPoint = .zero) throws {
+    func start(contentRectPoints: CGRect, pixelSize: CGSize) throws {
         guard !isTracking else { return }
         guard AXIsProcessTrusted() else {
             throw MouseTrackingError.accessibilityNotGranted
         }
 
-        self.displayBoundsPoints = displayBoundsPoints
+        self.contentRectPoints = contentRectPoints
         self.pixelSize = pixelSize
-        self.scale = displayBoundsPoints.width > 0
-            ? CGFloat(pixelSize.width) / displayBoundsPoints.width
+        self.scaleX = contentRectPoints.width > 0
+            ? pixelSize.width / contentRectPoints.width
             : 2.0
-        self.regionOffsetPixels = regionOffsetPixels
+        self.scaleY = contentRectPoints.height > 0
+            ? pixelSize.height / contentRectPoints.height
+            : scaleX
         self.samples = []
         self.startTime = CFAbsoluteTimeGetCurrent()
         // Build the cursor lookup AFTER NSApp is fully up — see comment on
@@ -116,9 +118,16 @@ final class MouseTrackingService {
         self.runLoopSource = source
         self.isTracking = true
 
-        // Seed with the current cursor position so the timeline always has a t=0 sample.
-        let now = NSEvent.mouseLocation
-        record(point: now, kind: .move)
+        // Seed with the current cursor position so the timeline always has a
+        // t=0 sample. NSEvent.mouseLocation is Cocoa space (bottom-left of
+        // the PRIMARY screen) — convert once into the CG top-left global
+        // space every other sample arrives in. The old code flipped with
+        // NSScreen.main (the key window's screen), which is wrong whenever
+        // that isn't the primary display.
+        let cocoa = NSEvent.mouseLocation
+        let primaryHeight = NSScreen.screens.first(where: { $0.frame.origin == .zero })?.frame.height
+            ?? NSScreen.screens.first?.frame.height ?? 0
+        record(topLeftGlobalPoint: CGPoint(x: cocoa.x, y: primaryHeight - cocoa.y), kind: .move)
 
         Log.mouse.info("Mouse tracking started")
     }
@@ -158,29 +167,24 @@ final class MouseTrackingService {
         default:               kind = .move
         }
 
-        // Hop to main to mutate.
+        // Hop to main to mutate. CGEvent.location is already top-left-origin
+        // global points — the exact space `record` expects; the old
+        // flip-to-Cocoa-and-back round trip (via the key window's screen
+        // height) has been dropped.
         DispatchQueue.main.async { [self] in
-            // CGEvent.location is already top-left origin in *global* coords (points).
-            // Convert to bottom-left coordinates (NSEvent style) so we share the
-            // same path as the seed sample.
-            let screenHeight = NSScreen.main?.frame.height ?? 0
-            let point = CGPoint(x: location.x, y: screenHeight - location.y)
-            self.record(point: point, kind: kind)
+            self.record(topLeftGlobalPoint: location, kind: kind)
         }
     }
 
-    private func record(point pointInScreenPoints: CGPoint, kind: MouseSample.Kind) {
+    private func record(topLeftGlobalPoint point: CGPoint, kind: MouseSample.Kind) {
         let now = CFAbsoluteTimeGetCurrent()
         let elapsedMs = (now - startTime) * 1000.0
 
-        // Convert NSEvent-style (origin bottom-left) to top-left point coords.
-        let screenHeight = NSScreen.main?.frame.height ?? 0
-        let topLeftPoint = CGPoint(x: pointInScreenPoints.x, y: screenHeight - pointInScreenPoints.y)
-
-        // Clip out events that landed outside the recorded display, but record
-        // them anyway — the editor decides what to do.
-        let pixelX = (topLeftPoint.x * scale) - regionOffsetPixels.x
-        let pixelY = (topLeftPoint.y * scale) - regionOffsetPixels.y
+        // Map global points → recorded-file pixels: subtract the content
+        // origin, then scale points→pixels per axis. Events outside the
+        // captured content clamp to the edge — the editor decides what to do.
+        let pixelX = (point.x - contentRectPoints.minX) * scaleX
+        let pixelY = (point.y - contentRectPoints.minY) * scaleY
 
         let clampedX = min(max(pixelX, 0), pixelSize.width)
         let clampedY = min(max(pixelY, 0), pixelSize.height)

CineScreen/Capture/RecordingSession.swift

@@ -94,12 +94,10 @@ final class RecordingSession {
             throw SessionError.captureFailed(error.localizedDescription)
         }
 
-        let regionOffset: CGPoint = request.region?.origin ?? .zero
         do {
             try mouse.start(
-                displayBoundsPoints: info.displayBounds,
-                pixelSize: CGSize(width: info.pixelWidth, height: info.pixelHeight),
-                regionOffsetPixels: regionOffset
+                contentRectPoints: info.contentRectPoints,
+                pixelSize: CGSize(width: info.pixelWidth, height: info.pixelHeight)
             )
         } catch {
             Log.session.error("mouse.start failed: \(error.localizedDescription)")

CineScreen/Capture/ScreenCaptureService.swift

@@ -45,7 +45,12 @@ struct CaptureInfo {
     var pixelWidth: Int
     var pixelHeight: Int
     var fps: Int
-    var displayBounds: CGRect       // in points
+    /// Where the captured content lives on the desktop — global screen
+    /// points, top-left origin (CGEvent space). The mouse tracker maps
+    /// cursor events into file pixels relative to this rect: a captured
+    /// window is rarely at the display origin, and a secondary display
+    /// never is.
+    var contentRectPoints: CGRect
     var scaleFactor: CGFloat
     var hasSystemAudio: Bool
     var hasMic: Bool
@@ -160,12 +165,17 @@ final class ScreenCaptureService: NSObject {
         }
 
         let scale = Self.backingScale(for: display.displayID)
-        let displayPoints = CGRect(x: 0, y: 0, width: CGFloat(display.width), height: CGFloat(display.height))
 
-        // 2. Output dimensions in pixels, sourceRect in points
+        // 2. Output dimensions in pixels, sourceRect in points, and the
+        // content's global rect (points, top-left origin) for cursor mapping.
+        // Passing full-display bounds regardless of mode gave window captures
+        // the wrong point→pixel scale AND ignored the window's position — the
+        // synthetic cursor landed far from the real pointer for every window
+        // recording.
         var outputW: Int
         var outputH: Int
         var sourceRect: CGRect? = nil
+        var contentRectPoints: CGRect
         if let preBuilt = request.preBuiltFilter {
             // Native picker gave us a filter — its contentRect is in points,
             // and pointPixelScale converts to native pixels. Using contentRect
@@ -175,6 +185,7 @@ final class ScreenCaptureService: NSObject {
             let pxScale = CGFloat(preBuilt.pointPixelScale)
             outputW = Int(rect.width * pxScale)
             outputH = Int(rect.height * pxScale)
+            contentRectPoints = rect
         } else if let window = window {
             // Window capture (legacy windowID path): build the filter early
             // so we can use its contentRect for sizing. This is what makes
@@ -185,6 +196,7 @@ final class ScreenCaptureService: NSObject {
             let pxScale = CGFloat(probeFilter.pointPixelScale)
             outputW = Int(rect.width * pxScale)
             outputH = Int(rect.height * pxScale)
+            contentRectPoints = rect
         } else if let region = request.region {
             outputW = Int(region.width)
             outputH = Int(region.height)
@@ -194,9 +206,18 @@ final class ScreenCaptureService: NSObject {
                 width: region.size.width / scale,
                 height: region.size.height / scale
             )
+            contentRectPoints = CGRect(
+                x: display.frame.minX + region.origin.x / scale,
+                y: display.frame.minY + region.origin.y / scale,
+                width: region.size.width / scale,
+                height: region.size.height / scale
+            )
         } else {
             outputW = Int(CGFloat(display.width) * scale)
             outputH = Int(CGFloat(display.height) * scale)
+            // display.frame carries the display's global origin — (0,0) for
+            // the primary display, but not for secondaries.
+            contentRectPoints = display.frame
         }
 
         // Cap the longest side to 2560px so the encoder doesn't get drowned
@@ -427,7 +448,7 @@ final class ScreenCaptureService: NSObject {
             pixelWidth: outputW,
             pixelHeight: outputH,
             fps: request.fps,
-            displayBounds: displayPoints,
+            contentRectPoints: contentRectPoints,
             scaleFactor: scale,
             hasSystemAudio: sysInput != nil,
             hasMic: mInput != nil