node-mac-recorder 2.18.3 → 2.18.5

package/.claude/settings.local.json

@@ -9,7 +9,10 @@
       "WebFetch(domain:stackoverflow.com)",
       "Bash(timeout:*)",
       "Bash(grep:*)",
-      "Bash(./test-cleanup.sh:*)"
+      "Bash(./test-cleanup.sh:*)",
+      "Bash(FORCE_AVFOUNDATION=1 node test-avfoundation-dpr.js)",
+      "Bash(FORCE_AVFOUNDATION=1 node test-cursor-fix.js)",
+      "Bash(pkill:*)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -705,8 +705,18 @@ class MacRecorder extends EventEmitter {
 			// Calculate video offset based on recording type
 			let videoOffsetX = 0;
 			let videoOffsetY = 0;
-			let videoWidth = options.displayInfo.width || options.displayInfo.logicalWidth;
-			let videoHeight = options.displayInfo.height || options.displayInfo.logicalHeight;
+			// CRITICAL FIX: Use physical dimensions for video when scale factor > 1 (AVFoundation)
+			// AVFoundation records at physical resolution, ScreenCaptureKit at logical resolution
+			let videoWidth, videoHeight;
+			if (options.displayInfo.scaleFactor && options.displayInfo.scaleFactor > 1.0) {
+				// AVFoundation case: use physical dimensions to match actual video size
+				videoWidth = options.displayInfo.physicalWidth || options.displayInfo.width || options.displayInfo.logicalWidth;
+				videoHeight = options.displayInfo.physicalHeight || options.displayInfo.height || options.displayInfo.logicalHeight;
+			} else {
+				// ScreenCaptureKit case: use logical dimensions
+				videoWidth = options.displayInfo.width || options.displayInfo.logicalWidth;
+				videoHeight = options.displayInfo.height || options.displayInfo.logicalHeight;
+			}
 
 			if (options.recordingType === 'window' && options.windowId) {
 				// For window recording: offset = window position in display
@@ -759,8 +769,13 @@ class MacRecorder extends EventEmitter {
 				scaleFactor: this.recordingDisplayInfo.scaleFactor || 1.0,
 				videoOffsetX: 0,
 				videoOffsetY: 0,
-				videoWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
-				videoHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
+				// CRITICAL FIX: Use physical dimensions for video when scale factor > 1 (AVFoundation)
+				videoWidth: (this.recordingDisplayInfo.scaleFactor > 1.0) ?
+					(this.recordingDisplayInfo.physicalWidth || this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth) :
+					(this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth),
+				videoHeight: (this.recordingDisplayInfo.scaleFactor > 1.0) ?
+					(this.recordingDisplayInfo.physicalHeight || this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight) :
+					(this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight),
 				videoRelative: true,
 				recordingType: options.recordingType || 'display'
 			};
@@ -812,32 +827,20 @@ class MacRecorder extends EventEmitter {
 							const displayRelativeX = position.x - this.cursorDisplayInfo.displayX;
 							const displayRelativeY = position.y - this.cursorDisplayInfo.displayY;
 
-							// CRITICAL FIX: Apply physical scaling for AVFoundation recording
-							// AVFoundation records at physical resolution while cursor coordinates are logical
-							let scaledX = displayRelativeX;
-							let scaledY = displayRelativeY;
-
-							if (this.cursorDisplayInfo.scaleFactor && this.cursorDisplayInfo.scaleFactor > 1.0) {
-								// Scale logical cursor coordinates to match physical video dimensions
-								scaledX = displayRelativeX * this.cursorDisplayInfo.scaleFactor;
-								scaledY = displayRelativeY * this.cursorDisplayInfo.scaleFactor;
-								coordinateSystem = "video-relative-scaled";
-							}
-
 							// Step 2: Transform display-relative → video-relative coordinates
-							x = scaledX - this.cursorDisplayInfo.videoOffsetX;
-							y = scaledY - this.cursorDisplayInfo.videoOffsetY;
-							coordinateSystem = this.cursorDisplayInfo.scaleFactor > 1.0 ? "video-relative-scaled" : "video-relative";
-
-							// Bounds check for video area (use physical video dimensions for AVFoundation)
-							const videoWidth = this.cursorDisplayInfo.physicalWidth || this.cursorDisplayInfo.videoWidth;
-							const videoHeight = this.cursorDisplayInfo.physicalHeight || this.cursorDisplayInfo.videoHeight;
+							// videoWidth/Height already account for physical vs logical dimensions
+							x = displayRelativeX - this.cursorDisplayInfo.videoOffsetX;
+							y = displayRelativeY - this.cursorDisplayInfo.videoOffsetY;
+							coordinateSystem = "video-relative";
 
-							const outsideVideo = x < 0 || y < 0 || x >= videoWidth || y >= videoHeight;
+							// Bounds check for video area using correct video dimensions
+							const outsideVideo = x < 0 || y < 0 ||
+								x >= this.cursorDisplayInfo.videoWidth ||
+								y >= this.cursorDisplayInfo.videoHeight;
 
 							// For debugging - add metadata if cursor is outside video area
 							if (outsideVideo) {
-								coordinateSystem = coordinateSystem + "-outside";
+								coordinateSystem = "video-relative-outside";
 							}
 						}
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.18.3",
+	"version": "2.18.5",
 	"description": "Native macOS screen recording package for Node.js applications",
 	"main": "index.js",
 	"keywords": [

package/src/avfoundation_recorder.mm

@@ -6,6 +6,83 @@
 #import <AppKit/AppKit.h>
 #include <string>
 
+// Advanced display scaling detection (same algorithm as cursor_tracker.mm)
+NSDictionary* getAdvancedDisplayScalingInfo(CGDirectDisplayID displayID) {
+    @try {
+        CGRect displayBounds = CGDisplayBounds(displayID);
+        CGSize logicalSize = displayBounds.size;
+
+        NSLog(@"🔍 Advanced scaling detection for display %u:", displayID);
+        NSLog(@"   Logical bounds: %.0fx%.0f", logicalSize.width, logicalSize.height);
+
+        // CRITICAL FIX: Get REAL physical dimensions using multiple detection methods
+        // Method 1: CGDisplayCreateImage (may be scaled on some systems)
+        CGImageRef testImage = CGDisplayCreateImage(displayID);
+        CGSize imageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
+        CGImageRelease(testImage);
+
+        // Method 2: Native display mode detection for true physical resolution
+        CGSize actualPhysicalSize = imageSize;
+        CFArrayRef displayModes = CGDisplayCopyAllDisplayModes(displayID, NULL);
+        if (displayModes) {
+            CFIndex modeCount = CFArrayGetCount(displayModes);
+            CGSize maxResolution = CGSizeMake(0, 0);
+
+            // Find the highest resolution mode (native resolution)
+            for (CFIndex i = 0; i < modeCount; i++) {
+                CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(displayModes, i);
+                CGSize modeSize = CGSizeMake(CGDisplayModeGetWidth(mode), CGDisplayModeGetHeight(mode));
+
+                if (modeSize.width > maxResolution.width ||
+                    (modeSize.width == maxResolution.width && modeSize.height > maxResolution.height)) {
+                    maxResolution = modeSize;
+                }
+            }
+
+            // Use the max resolution if it's significantly higher than image size
+            if (maxResolution.width > imageSize.width * 1.5 || maxResolution.height > imageSize.height * 1.5) {
+                actualPhysicalSize = maxResolution;
+                NSLog(@"   Using display mode detection: %.0fx%.0f (was %.0fx%.0f)",
+                      maxResolution.width, maxResolution.height, imageSize.width, imageSize.height);
+            } else {
+                actualPhysicalSize = imageSize;
+                NSLog(@"   Using image size detection: %.0fx%.0f", imageSize.width, imageSize.height);
+            }
+
+            CFRelease(displayModes);
+        } else {
+            actualPhysicalSize = imageSize;
+        }
+
+        CGSize reportedPhysicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
+
+        NSLog(@"🔍 ADVANCED scaling info:");
+        NSLog(@"   Logical: %.0fx%.0f", logicalSize.width, logicalSize.height);
+        NSLog(@"   Reported physical: %.0fx%.0f", reportedPhysicalSize.width, reportedPhysicalSize.height);
+        NSLog(@"   ACTUAL physical: %.0fx%.0f", actualPhysicalSize.width, actualPhysicalSize.height);
+
+        CGFloat scaleX = actualPhysicalSize.width / logicalSize.width;
+        CGFloat scaleY = actualPhysicalSize.height / logicalSize.height;
+        CGFloat scaleFactor = MAX(scaleX, scaleY);
+
+        NSLog(@"🔍 ADVANCED scale factors: X=%.2f, Y=%.2f, Final=%.2f", scaleX, scaleY, scaleFactor);
+
+        return @{
+            @"displayID": @(displayID),
+            @"logicalSize": [NSValue valueWithSize:NSMakeSize(logicalSize.width, logicalSize.height)],
+            @"physicalSize": [NSValue valueWithSize:NSMakeSize(actualPhysicalSize.width, actualPhysicalSize.height)],
+            @"reportedPhysicalSize": [NSValue valueWithSize:NSMakeSize(reportedPhysicalSize.width, reportedPhysicalSize.height)],
+            @"scaleFactor": @(scaleFactor),
+            @"scaleX": @(scaleX),
+            @"scaleY": @(scaleY),
+            @"displayBounds": [NSValue valueWithRect:NSMakeRect(displayBounds.origin.x, displayBounds.origin.y, displayBounds.size.width, displayBounds.size.height)]
+        };
+    } @catch (NSException *exception) {
+        NSLog(@"❌ Advanced scaling detection failed: %@", exception);
+        return nil;
+    }
+}
+
 static AVAssetWriter *g_avWriter = nil;
 static AVAssetWriterInput *g_avVideoInput = nil;
 static AVAssetWriterInputPixelBufferAdaptor *g_avPixelBufferAdaptor = nil;
@@ -53,23 +130,35 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             return false;
         }
         
-        // Get display dimensions with proper scaling for macOS 14/13 compatibility
-        CGRect displayBounds = CGDisplayBounds(displayID);
-        
-        // Get both logical (bounds) and physical (pixels) dimensions
-        CGSize logicalSize = displayBounds.size;
-        CGSize physicalSize = CGSizeMake(CGDisplayPixelsWide(displayID), CGDisplayPixelsHigh(displayID));
-        
-        // Calculate scale factor
-        CGFloat scaleX = physicalSize.width / logicalSize.width;
-        CGFloat scaleY = physicalSize.height / logicalSize.height;
-        CGFloat scaleFactor = MAX(scaleX, scaleY); // Use max to handle non-uniform scaling
-        
-        // CRITICAL FIX: Use actual captured image dimensions for pixel buffer
-        // CGDisplayCreateImage returns physical pixels on Retina displays
-        CGImageRef testImage = CGDisplayCreateImage(displayID);
-        CGSize actualImageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
-        CGImageRelease(testImage);
+        // CRITICAL FIX: Use advanced scaling detection (same as cursor_tracker.mm)
+        NSDictionary *advancedScalingInfo = getAdvancedDisplayScalingInfo(displayID);
+
+        CGSize logicalSize;
+        CGSize actualImageSize;
+        CGFloat scaleFactor;
+
+        if (advancedScalingInfo) {
+            // Use advanced detection results
+            NSSize logicalSizeValue = [[advancedScalingInfo objectForKey:@"logicalSize"] sizeValue];
+            NSSize physicalSizeValue = [[advancedScalingInfo objectForKey:@"physicalSize"] sizeValue];
+
+            logicalSize = CGSizeMake(logicalSizeValue.width, logicalSizeValue.height);
+            actualImageSize = CGSizeMake(physicalSizeValue.width, physicalSizeValue.height);
+            scaleFactor = [[advancedScalingInfo objectForKey:@"scaleFactor"] doubleValue];
+
+            NSLog(@"✅ Using ADVANCED scaling detection for AVFoundation");
+        } else {
+            // Fallback to old method
+            NSLog(@"⚠️ Advanced scaling detection failed, using fallback");
+            CGRect displayBounds = CGDisplayBounds(displayID);
+            logicalSize = displayBounds.size;
+
+            CGImageRef testImage = CGDisplayCreateImage(displayID);
+            actualImageSize = CGSizeMake(CGImageGetWidth(testImage), CGImageGetHeight(testImage));
+            CGImageRelease(testImage);
+
+            scaleFactor = MAX(actualImageSize.width / logicalSize.width, actualImageSize.height / logicalSize.height);
+        }
         
         // CRITICAL FIX: Use actual image dimensions to match what CGDisplayCreateImage returns
         // This prevents the "1/4 recording area" bug on Retina displays
@@ -85,18 +174,18 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             recordingSize = actualImageSize;
         }
         
-        NSLog(@"🎯 CRITICAL: Logical %.0fx%.0f → Actual image %.0fx%.0f", 
+        NSLog(@"🎯 ADVANCED: Logical %.0fx%.0f → Actual image %.0fx%.0f",
               logicalSize.width, logicalSize.height, actualImageSize.width, actualImageSize.height);
-        
+
         NSLog(@"🖥️ Display bounds (logical): %.0fx%.0f", logicalSize.width, logicalSize.height);
-        NSLog(@"🖥️ Display pixels (physical): %.0fx%.0f", physicalSize.width, physicalSize.height);
-        
+        NSLog(@"🖥️ Display actual physical: %.0fx%.0f", actualImageSize.width, actualImageSize.height);
+
         if (scaleFactor > 1.5) {
-            NSLog(@"🔍 Scale factor: %.1fx → Retina display detected (macOS 14/13 scaling fix applied)", scaleFactor);
+            NSLog(@"🔍 ADVANCED Scale factor: %.2fx → Retina display detected", scaleFactor);
         } else if (scaleFactor > 1.1) {
-            NSLog(@"🔍 Scale factor: %.1fx → Non-standard scaling detected", scaleFactor);
+            NSLog(@"🔍 ADVANCED Scale factor: %.2fx → Non-standard scaling detected", scaleFactor);
         } else {
-            NSLog(@"🔍 Scale factor: %.1fx → Standard display", scaleFactor);
+            NSLog(@"🔍 ADVANCED Scale factor: %.2fx → Standard display", scaleFactor);
         }
         
         NSLog(@"🎯 Recording size: %.0fx%.0f (using actual physical dimensions for Retina fix)", recordingSize.width, recordingSize.height);