node-mac-recorder 2.18.1 → 2.18.3

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) {
@@ -365,10 +384,10 @@ class MacRecorder extends EventEmitter {
 					this.isRecording = true;
 					this.recordingStartTime = Date.now();
 
-					// Start unified cursor tracking for all recording types
-					// Use the same standard cursor tracking logic that works best (display-relative)
+					// Start unified cursor tracking with video-relative coordinates
+					// This ensures cursor positions match exactly with video frames
 					const standardCursorOptions = {
-						displayRelative: true,
+						videoRelative: true,
 						displayInfo: this.recordingDisplayInfo,
 						recordingType: this.options.windowId ? 'window' :
 									  this.options.captureArea ? 'area' : 'display',
@@ -652,12 +671,14 @@ class MacRecorder extends EventEmitter {
 	}
 
 	/**
-	 * Unified cursor capture for all recording types - uses standardized display-relative coordinates
+	 * Unified cursor capture for all recording types - uses video-relative coordinates
 	 * @param {string|number} intervalOrFilepath - Cursor data JSON dosya yolu veya interval
 	 * @param {Object} options - Cursor capture seçenekleri
-	 * @param {boolean} options.displayRelative - Use display-relative coordinates (recommended)
+	 * @param {boolean} options.videoRelative - Use video-relative coordinates (recommended)
 	 * @param {Object} options.displayInfo - Display information for coordinate transformation
 	 * @param {string} options.recordingType - Type of recording: 'display', 'window', 'area'
+	 * @param {Object} options.captureArea - Capture area for area recording coordinate transformation
+	 * @param {number} options.windowId - Window ID for window recording coordinate transformation
 	 */
 	async startCursorCapture(intervalOrFilepath = 100, options = {}) {
 		let filepath;
@@ -679,16 +700,46 @@ class MacRecorder extends EventEmitter {
 			throw new Error("Cursor capture is already running");
 		}
 
-		// Use standardized display-relative coordinate system for all recording types
-		if (options.displayRelative && options.displayInfo) {
-			// Standardized display-relative coordinates for all recording types
+		// Use video-relative coordinate system for all recording types
+		if (options.videoRelative && options.displayInfo) {
+			// 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;
+
+			if (options.recordingType === 'window' && options.windowId) {
+				// For window recording: offset = window position in display
+				if (options.captureArea) {
+					videoOffsetX = options.captureArea.x;
+					videoOffsetY = options.captureArea.y;
+					videoWidth = options.captureArea.width;
+					videoHeight = options.captureArea.height;
+				}
+			} else if (options.recordingType === 'area' && options.captureArea) {
+				// For area recording: offset = area position in display
+				videoOffsetX = options.captureArea.x;
+				videoOffsetY = options.captureArea.y;
+				videoWidth = options.captureArea.width;
+				videoHeight = options.captureArea.height;
+			}
+			// For display recording: offset remains 0,0
+
 			this.cursorDisplayInfo = {
 				displayId: options.displayInfo.displayId || options.displayInfo.id,
-				x: options.displayInfo.x || 0,
-				y: options.displayInfo.y || 0,
-				width: options.displayInfo.width || options.displayInfo.logicalWidth,
-				height: options.displayInfo.height || options.displayInfo.logicalHeight,
-				displayRelative: true,
+				displayX: options.displayInfo.x || 0,
+				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,
+				videoRelative: true,
 				recordingType: options.recordingType || 'display',
 				// Store additional context for debugging
 				captureArea: options.captureArea,
@@ -698,7 +749,19 @@ class MacRecorder extends EventEmitter {
 			// Fallback: Use recording display info if available
 			this.cursorDisplayInfo = {
 				...this.recordingDisplayInfo,
-				displayRelative: true,
+				displayX: this.recordingDisplayInfo.x || 0,
+				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,
+				videoHeight: this.recordingDisplayInfo.height || this.recordingDisplayInfo.logicalHeight,
+				videoRelative: true,
 				recordingType: options.recordingType || 'display'
 			};
 		} else {
@@ -738,26 +801,43 @@ class MacRecorder extends EventEmitter {
 						const position = nativeBinding.getCursorPosition();
 						const timestamp = Date.now() - this.cursorCaptureStartTime;
 
-						// Standardized coordinate transformation for all recording types
+						// Video-relative coordinate transformation for all recording types
 						let x = position.x;
 						let y = position.y;
 						let coordinateSystem = "global";
 
-						// Apply display-relative transformation for all recording types
-						if (this.cursorDisplayInfo && this.cursorDisplayInfo.displayRelative) {
-							// Transform global → display-relative coordinates
-							x = position.x - this.cursorDisplayInfo.x;
-							y = position.y - this.cursorDisplayInfo.y;
-							coordinateSystem = "display-relative";
-
-							// Optional bounds check for display (don't skip, just note if outside)
-							const outsideDisplay = x < 0 || y < 0 ||
-								x >= this.cursorDisplayInfo.width ||
-								y >= this.cursorDisplayInfo.height;
-
-							// For debugging - add metadata if cursor is outside recording area
-							if (outsideDisplay) {
-								coordinateSystem = "display-relative-outside";
+						// Apply video-relative transformation for all recording types
+						if (this.cursorDisplayInfo && this.cursorDisplayInfo.videoRelative) {
+							// Step 1: Transform global → display-relative coordinates
+							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;
+
+							const outsideVideo = x < 0 || y < 0 || x >= videoWidth || y >= videoHeight;
+
+							// For debugging - add metadata if cursor is outside video area
+							if (outsideVideo) {
+								coordinateSystem = coordinateSystem + "-outside";
 							}
 						}
 
@@ -769,12 +849,25 @@ class MacRecorder extends EventEmitter {
 							cursorType: position.cursorType,
 							type: position.eventType || "move",
 							coordinateSystem: coordinateSystem,
-							// Standardized metadata for all recording types
+							// Video-relative metadata for all recording types
 							recordingType: this.cursorDisplayInfo?.recordingType || "display",
+							videoInfo: this.cursorDisplayInfo ? {
+								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
+							} : null,
 							displayInfo: this.cursorDisplayInfo ? {
 								displayId: this.cursorDisplayInfo.displayId,
-								width: this.cursorDisplayInfo.width,
-								height: this.cursorDisplayInfo.height
+								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
 							} : null
 						};
 

package/package.json

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