node-mac-recorder 2.18.3 → 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/package.json

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