node-mac-recorder 2.18.10 → 2.19.0

package/binding.gyp

@@ -21,7 +21,7 @@
       "xcode_settings": {
         "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
         "CLANG_CXX_LIBRARY": "libc++",
-        "MACOSX_DEPLOYMENT_TARGET": "13.1",
+        "MACOSX_DEPLOYMENT_TARGET": "10.15",
         "OTHER_CFLAGS": [
           "-ObjC++"
         ]

package/index.js

@@ -252,12 +252,6 @@ class MacRecorder extends EventEmitter {
 
 						// Recording için display bilgisini sakla (cursor capture için)
 						const targetDisplay = displays.find(d => d.id === targetDisplayId);
-
-						// CRITICAL FIX: For now, use logical dimensions to avoid cross-display scaling issues
-						// This prevents using wrong display's physical dimensions
-						let displayScalingInfo = null;
-						// TODO: Implement proper per-display scaling detection in native layer
-
 						this.recordingDisplayInfo = {
 							displayId: targetDisplayId,
 							x: targetDisplay.x,
@@ -267,10 +261,6 @@ 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,
 						};
 					}
 
@@ -308,11 +298,6 @@ class MacRecorder extends EventEmitter {
 				}
 
 				if (targetDisplay) {
-					// CRITICAL FIX: For now, use logical dimensions to avoid cross-display scaling issues
-					// This prevents using wrong display's physical dimensions
-					const displayScalingInfo = null;
-					// TODO: Implement proper per-display scaling detection in native layer
-
 					this.recordingDisplayInfo = {
 						displayId: targetDisplay.id,
 						x: targetDisplay.x || 0,
@@ -322,10 +307,6 @@ 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) {
@@ -705,8 +686,6 @@ class MacRecorder extends EventEmitter {
 			// Calculate video offset based on recording type
 			let videoOffsetX = 0;
 			let videoOffsetY = 0;
-			// UNIFIED CURSOR SYSTEM: Always use logical dimensions for cursor coordinates
-			// This ensures cursor tracking works consistently across all recording engines
 			let videoWidth = options.displayInfo.width || options.displayInfo.logicalWidth;
 			let videoHeight = options.displayInfo.height || options.displayInfo.logicalHeight;
 
@@ -733,19 +712,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,
 				videoHeight: videoHeight,
-				// CRITICAL: Video output size for proper cursor scaling
-				videoOutputWidth: (options.displayInfo.scaleFactor > 1.0) ?
-					(options.displayInfo.physicalWidth || videoWidth) : videoWidth,
-				videoOutputHeight: (options.displayInfo.scaleFactor > 1.0) ?
-					(options.displayInfo.physicalHeight || videoHeight) : videoHeight,
 				videoRelative: true,
 				recordingType: options.recordingType || 'display',
 				// Store additional context for debugging
@@ -760,22 +730,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,
-				// UNIFIED CURSOR SYSTEM: Always use logical dimensions
 				videoWidth: this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth,
 				videoHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
-				// CRITICAL: Video output size for proper cursor scaling
-				videoOutputWidth: (this.recordingDisplayInfo.scaleFactor > 1.0) ?
-					(this.recordingDisplayInfo.physicalWidth || this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth) :
-					(this.recordingDisplayInfo.width || this.recordingDisplayInfo.logicalWidth),
-				videoOutputHeight: (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'
 			};
@@ -823,23 +781,6 @@ class MacRecorder extends EventEmitter {
 
 						// Apply video-relative transformation for all recording types
 						if (this.cursorDisplayInfo && this.cursorDisplayInfo.videoRelative) {
-							// FILTER: Only record cursor when it's on the target display
-							// Use cached display info to avoid async calls
-							const displayX = this.cursorDisplayInfo.displayX;
-							const displayY = this.cursorDisplayInfo.displayY;
-							const displayWidth = this.cursorDisplayInfo.displayWidth;
-							const displayHeight = this.cursorDisplayInfo.displayHeight;
-
-							const onTargetDisplay = position.x >= displayX &&
-								position.x < (displayX + displayWidth) &&
-								position.y >= displayY &&
-								position.y < (displayY + displayHeight);
-
-							if (!onTargetDisplay) {
-								// Skip cursor data when cursor is on different display
-								return;
-							}
-
 							// Step 1: Transform global → display-relative coordinates
 							const displayRelativeX = position.x - this.cursorDisplayInfo.displayX;
 							const displayRelativeY = position.y - this.cursorDisplayInfo.displayY;
@@ -847,31 +788,16 @@ class MacRecorder extends EventEmitter {
 							// Step 2: Transform display-relative → video-relative coordinates
 							x = displayRelativeX - this.cursorDisplayInfo.videoOffsetX;
 							y = displayRelativeY - this.cursorDisplayInfo.videoOffsetY;
+							coordinateSystem = "video-relative";
 
-							// Step 3: Scale to match actual video output size (for AVFoundation physical scaling)
-							if (this.cursorDisplayInfo.videoOutputWidth && this.cursorDisplayInfo.videoOutputHeight) {
-								const scaleX = this.cursorDisplayInfo.videoOutputWidth / this.cursorDisplayInfo.videoWidth;
-								const scaleY = this.cursorDisplayInfo.videoOutputHeight / this.cursorDisplayInfo.videoHeight;
-
-								if (scaleX !== 1.0 || scaleY !== 1.0) {
-									x = x * scaleX;
-									y = y * scaleY;
-									coordinateSystem = "video-output-scaled";
-								} else {
-									coordinateSystem = "video-relative";
-								}
-							} else {
-								coordinateSystem = "video-relative";
-							}
-
-							// Bounds check for video area using actual video output dimensions
-							const checkWidth = this.cursorDisplayInfo.videoOutputWidth || this.cursorDisplayInfo.videoWidth;
-							const checkHeight = this.cursorDisplayInfo.videoOutputHeight || this.cursorDisplayInfo.videoHeight;
-							const outsideVideo = x < 0 || y < 0 || x >= checkWidth || y >= checkHeight;
+							// 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;
 
 							// For debugging - add metadata if cursor is outside video area
 							if (outsideVideo) {
-								coordinateSystem = coordinateSystem + "-outside";
+								coordinateSystem = "video-relative-outside";
 							}
 						}
 
@@ -889,19 +815,12 @@ class MacRecorder extends EventEmitter {
 								width: this.cursorDisplayInfo.videoWidth,
 								height: this.cursorDisplayInfo.videoHeight,
 								offsetX: this.cursorDisplayInfo.videoOffsetX,
-								offsetY: this.cursorDisplayInfo.videoOffsetY,
-								// CRITICAL: Add physical dimensions for debugging
-								physicalWidth: this.cursorDisplayInfo.physicalWidth,
-								physicalHeight: this.cursorDisplayInfo.physicalHeight
+								offsetY: this.cursorDisplayInfo.videoOffsetY
 							} : null,
 							displayInfo: this.cursorDisplayInfo ? {
 								displayId: this.cursorDisplayInfo.displayId,
 								width: this.cursorDisplayInfo.displayWidth,
-								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
+								height: this.cursorDisplayInfo.displayHeight
 							} : null
 						};
 
@@ -954,13 +873,6 @@ class MacRecorder extends EventEmitter {
 					this.cursorCaptureFile = null;
 				}
 
-				// Native cursor tracking'i durdur
-				try {
-					nativeBinding.stopCursorTracking();
-				} catch (nativeError) {
-					console.warn('Native cursor tracking stop failed:', nativeError.message);
-				}
-
 				// Değişkenleri temizle
 				this.lastCapturedData = null;
 				this.cursorCaptureStartTime = null;

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -6,83 +6,6 @@
 #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;
@@ -130,35 +53,23 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             return false;
         }
         
-        // 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);
-        }
+        // 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 actual image dimensions to match what CGDisplayCreateImage returns
         // This prevents the "1/4 recording area" bug on Retina displays
@@ -174,18 +85,18 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             recordingSize = actualImageSize;
         }
         
-        NSLog(@"🎯 ADVANCED: Logical %.0fx%.0f → Actual image %.0fx%.0f",
+        NSLog(@"🎯 CRITICAL: 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 actual physical: %.0fx%.0f", actualImageSize.width, actualImageSize.height);
-
+        NSLog(@"🖥️ Display pixels (physical): %.0fx%.0f", physicalSize.width, physicalSize.height);
+        
         if (scaleFactor > 1.5) {
-            NSLog(@"🔍 ADVANCED Scale factor: %.2fx → Retina display detected", scaleFactor);
+            NSLog(@"🔍 Scale factor: %.1fx → Retina display detected (macOS 14/13 scaling fix applied)", scaleFactor);
         } else if (scaleFactor > 1.1) {
-            NSLog(@"🔍 ADVANCED Scale factor: %.2fx → Non-standard scaling detected", scaleFactor);
+            NSLog(@"🔍 Scale factor: %.1fx → Non-standard scaling detected", scaleFactor);
         } else {
-            NSLog(@"🔍 ADVANCED Scale factor: %.2fx → Standard display", scaleFactor);
+            NSLog(@"🔍 Scale factor: %.1fx → Standard display", scaleFactor);
         }
         
         NSLog(@"🎯 Recording size: %.0fx%.0f (using actual physical dimensions for Retina fix)", recordingSize.width, recordingSize.height);

package/src/screen_capture_kit.h

@@ -2,6 +2,7 @@
 #import <ScreenCaptureKit/ScreenCaptureKit.h>
 // NO AVFoundation - Pure ScreenCaptureKit implementation
 
+API_AVAILABLE(macos(15.0))
 @interface ScreenCaptureKitRecorder : NSObject
 
 + (BOOL)isScreenCaptureKitAvailable;

package/src/screen_capture_kit.mm

@@ -297,11 +297,9 @@ static NSString *g_outputPath = nil;
             }
         }
         
-        if (@available(macOS 15.0, *)) {
-            if (!g_recordingOutput) {
-                NSLog(@"❌ Failed to create SCRecordingOutput");
-                return;
-            }
+        if (!g_recordingOutput) {
+            NSLog(@"❌ Failed to create SCRecordingOutput");
+            return;
         }
         
         NSLog(@"✅ Pure ScreenCaptureKit recording output created");
@@ -391,11 +389,9 @@ static NSString *g_outputPath = nil;
         g_isCleaningUp = YES;
         g_isRecording = NO;
         
-        if (@available(macOS 15.0, *)) {
-            if (g_recordingOutput) {
-                // SCRecordingOutput finalizes automatically
-                NSLog(@"✅ Pure recording output finalized");
-            }
+        if (g_recordingOutput) {
+            // SCRecordingOutput finalizes automatically
+            NSLog(@"✅ Pure recording output finalized");
         }
         
         [ScreenCaptureKitRecorder cleanupVideoWriter];
@@ -417,11 +413,9 @@ static NSString *g_outputPath = nil;
             NSLog(@"✅ Stream reference cleared");
         }
         
-        if (@available(macOS 15.0, *)) {
-            if (g_recordingOutput) {
-                g_recordingOutput = nil;
-                NSLog(@"✅ Recording output reference cleared");
-            }
+        if (g_recordingOutput) {
+            g_recordingOutput = nil;
+            NSLog(@"✅ Recording output reference cleared");
         }
         
         if (g_streamDelegate) {