node-mac-recorder 2.18.2 → 2.18.4

package/.claude/settings.local.json

@@ -9,7 +9,8 @@
       "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)"
     ],
     "deny": [],
     "ask": []

package/index.js

@@ -252,6 +252,12 @@ class MacRecorder extends EventEmitter {
 
 						// Recording için display bilgisini sakla (cursor capture için)
 						const targetDisplay = displays.find(d => d.id === targetDisplayId);
+
+						// CRITICAL FIX: Get actual physical dimensions for proper cursor scaling
+						// This fixes cursor coordinate issues on Retina displays during AVFoundation recording
+						const cursorPosition = nativeBinding.getCursorPosition();
+						const displayScalingInfo = cursorPosition.displayInfo;
+
 						this.recordingDisplayInfo = {
 							displayId: targetDisplayId,
 							x: targetDisplay.x,
@@ -261,6 +267,10 @@ class MacRecorder extends EventEmitter {
 							// Add scaling information for cursor coordinate transformation
 							logicalWidth: parseInt(targetDisplay.resolution.split("x")[0]),
 							logicalHeight: parseInt(targetDisplay.resolution.split("x")[1]),
+							// CRITICAL: Add physical dimensions for proper cursor scaling
+							physicalWidth: displayScalingInfo ? displayScalingInfo.physicalWidth : parseInt(targetDisplay.resolution.split("x")[0]),
+							physicalHeight: displayScalingInfo ? displayScalingInfo.physicalHeight : parseInt(targetDisplay.resolution.split("x")[1]),
+							scaleFactor: displayScalingInfo ? displayScalingInfo.scaleFactor : 1.0,
 						};
 					}
 
@@ -298,6 +308,11 @@ class MacRecorder extends EventEmitter {
 				}
 
 				if (targetDisplay) {
+					// CRITICAL FIX: Get actual physical dimensions for proper cursor scaling
+					// This fixes cursor coordinate issues on Retina displays during AVFoundation recording
+					const cursorPosition = nativeBinding.getCursorPosition();
+					const displayScalingInfo = cursorPosition.displayInfo;
+
 					this.recordingDisplayInfo = {
 						displayId: targetDisplay.id,
 						x: targetDisplay.x || 0,
@@ -307,6 +322,10 @@ class MacRecorder extends EventEmitter {
 						// Add scaling information for cursor coordinate transformation
 						logicalWidth: parseInt(targetDisplay.resolution.split("x")[0]),
 						logicalHeight: parseInt(targetDisplay.resolution.split("x")[1]),
+						// CRITICAL: Add physical dimensions for proper cursor scaling
+						physicalWidth: displayScalingInfo ? displayScalingInfo.physicalWidth : parseInt(targetDisplay.resolution.split("x")[0]),
+						physicalHeight: displayScalingInfo ? displayScalingInfo.physicalHeight : parseInt(targetDisplay.resolution.split("x")[1]),
+						scaleFactor: displayScalingInfo ? displayScalingInfo.scaleFactor : 1.0,
 					};
 				}
 			} catch (error) {
@@ -712,6 +731,10 @@ class MacRecorder extends EventEmitter {
 				displayY: options.displayInfo.y || 0,
 				displayWidth: options.displayInfo.width || options.displayInfo.logicalWidth,
 				displayHeight: options.displayInfo.height || options.displayInfo.logicalHeight,
+				// CRITICAL: Add physical dimensions for proper cursor scaling
+				physicalWidth: options.displayInfo.physicalWidth || options.displayInfo.width || options.displayInfo.logicalWidth,
+				physicalHeight: options.displayInfo.physicalHeight || options.displayInfo.height || options.displayInfo.logicalHeight,
+				scaleFactor: options.displayInfo.scaleFactor || 1.0,
 				videoOffsetX: videoOffsetX,
 				videoOffsetY: videoOffsetY,
 				videoWidth: videoWidth,
@@ -730,6 +753,10 @@ class MacRecorder extends EventEmitter {
 				displayY: this.recordingDisplayInfo.y || 0,
 				displayWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
 				displayHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
+				// CRITICAL: Include physical dimensions from recording display info
+				physicalWidth: this.recordingDisplayInfo.physicalWidth || this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
+				physicalHeight: this.recordingDisplayInfo.physicalHeight || this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
+				scaleFactor: this.recordingDisplayInfo.scaleFactor || 1.0,
 				videoOffsetX: 0,
 				videoOffsetY: 0,
 				videoWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
@@ -785,19 +812,32 @@ 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 = displayRelativeX - this.cursorDisplayInfo.videoOffsetX;
-							y = displayRelativeY - this.cursorDisplayInfo.videoOffsetY;
-							coordinateSystem = "video-relative";
+							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;
 
-							// Bounds check for video area (don't skip, just note if outside)
-							const outsideVideo = x < 0 || y < 0 ||
-								x >= this.cursorDisplayInfo.videoWidth ||
-								y >= this.cursorDisplayInfo.videoHeight;
+							const outsideVideo = x < 0 || y < 0 || x >= videoWidth || y >= videoHeight;
 
 							// For debugging - add metadata if cursor is outside video area
 							if (outsideVideo) {
-								coordinateSystem = "video-relative-outside";
+								coordinateSystem = coordinateSystem + "-outside";
 							}
 						}
 
@@ -815,12 +855,19 @@ class MacRecorder extends EventEmitter {
 								width: this.cursorDisplayInfo.videoWidth,
 								height: this.cursorDisplayInfo.videoHeight,
 								offsetX: this.cursorDisplayInfo.videoOffsetX,
-								offsetY: this.cursorDisplayInfo.videoOffsetY
+								offsetY: this.cursorDisplayInfo.videoOffsetY,
+								// CRITICAL: Add physical dimensions for debugging
+								physicalWidth: this.cursorDisplayInfo.physicalWidth,
+								physicalHeight: this.cursorDisplayInfo.physicalHeight
 							} : null,
 							displayInfo: this.cursorDisplayInfo ? {
 								displayId: this.cursorDisplayInfo.displayId,
 								width: this.cursorDisplayInfo.displayWidth,
-								height: this.cursorDisplayInfo.displayHeight
+								height: this.cursorDisplayInfo.displayHeight,
+								// CRITICAL: Add scaling info for debugging AVFoundation cursor issues
+								physicalWidth: this.cursorDisplayInfo.physicalWidth,
+								physicalHeight: this.cursorDisplayInfo.physicalHeight,
+								scaleFactor: this.cursorDisplayInfo.scaleFactor
 							} : null
 						};
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "node-mac-recorder",
-	"version": "2.18.2",
+	"version": "2.18.4",
 	"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);