node-mac-recorder 2.21.22 → 2.21.23

package/electron-safe-index.js

@@ -44,8 +44,8 @@ class ElectronSafeMacRecorder extends EventEmitter {
 		this.options = {
 			includeMicrophone: false,
 			includeSystemAudio: false,
-			quality: "medium",
-			frameRate: 30,
+			quality: "high",
+			frameRate: 60,
 			captureArea: null,
 			captureCursor: false,
 			showClicks: false,

package/index.js

@@ -43,8 +43,8 @@ class MacRecorder extends EventEmitter {
 		this.options = {
 			includeMicrophone: false, // Default olarak mikrofon kapalı
 			includeSystemAudio: false, // Default olarak sistem sesi kapalı - kullanıcı explicit olarak açmalı
-			quality: "medium",
-			frameRate: 30,
+			quality: "high",
+			frameRate: 60,
 			captureArea: null, // { x, y, width, height }
 			captureCursor: false, // Default olarak cursor gizli
 			showClicks: false,
@@ -181,6 +181,13 @@ class MacRecorder extends EventEmitter {
 		if (options.captureCamera !== undefined) {
 			this.options.captureCamera = options.captureCamera === true;
 		}
+		if (options.frameRate !== undefined) {
+			const fps = parseInt(options.frameRate, 10);
+			if (!Number.isNaN(fps) && fps > 0) {
+				// Clamp reasonable range 1-120
+				this.options.frameRate = Math.min(Math.max(fps, 1), 120);
+			}
+		}
 		if (options.cameraDeviceId !== undefined) {
 			this.options.cameraDeviceId =
 				typeof options.cameraDeviceId === "string" && options.cameraDeviceId.length > 0
@@ -497,6 +504,8 @@ class MacRecorder extends EventEmitter {
 					captureCamera: this.options.captureCamera === true,
 					cameraDeviceId: this.options.cameraDeviceId || null,
 					sessionTimestamp,
+					frameRate: this.options.frameRate || 60,
+					quality: this.options.quality || "high",
 				};
 
 					if (cameraFilePath) {

package/package.json

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

package/src/avfoundation_recorder.mm

@@ -34,7 +34,8 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                                            bool includeMicrophone,
                                            bool includeSystemAudio,
                                            NSString* audioDeviceId,
-                                           NSString* audioOutputPath) {
+                                           NSString* audioOutputPath,
+                                           double requestedFrameRate) {
     
     if (g_avIsRecording) {
         NSLog(@"❌ AVFoundation recording already in progress");
@@ -129,15 +130,20 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         NSLog(@"🎬 ULTRA QUALITY AVFoundation: %dx%d, bitrate=%.2fMbps",
               (int)recordingSize.width, (int)recordingSize.height, bitrate / (1000.0 * 1000.0));
 
+        // Resolve target FPS
+        double fps = requestedFrameRate > 0 ? requestedFrameRate : 60.0;
+        if (fps < 1.0) fps = 1.0;
+        if (fps > 120.0) fps = 120.0;
+
         NSDictionary *videoSettings = @{
             AVVideoCodecKey: codecKey,
             AVVideoWidthKey: @((int)recordingSize.width),
             AVVideoHeightKey: @((int)recordingSize.height),
             AVVideoCompressionPropertiesKey: @{
                 AVVideoAverageBitRateKey: @(bitrate),
-                AVVideoMaxKeyFrameIntervalKey: @30,
+                AVVideoMaxKeyFrameIntervalKey: @((int)fps),
                 AVVideoAllowFrameReorderingKey: @YES,
-                AVVideoExpectedSourceFrameRateKey: @60,
+                AVVideoExpectedSourceFrameRateKey: @((int)fps),
                 AVVideoQualityKey: @(0.95),  // 0.0-1.0, higher is better
                 AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
                 AVVideoH264EntropyModeKey: AVVideoH264EntropyModeCABAC
@@ -266,7 +272,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             }
         }
 
-        // Start capture timer (10 FPS for Electron compatibility)
+        // Start capture timer using target FPS
         dispatch_queue_t captureQueue = dispatch_queue_create("AVFoundationCaptureQueue", DISPATCH_QUEUE_SERIAL);
         g_avTimer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, captureQueue);
         
@@ -275,7 +281,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
             return false;
         }
         
-        uint64_t interval = NSEC_PER_SEC / 10; // 10 FPS for Electron stability
+        uint64_t interval = (uint64_t)(NSEC_PER_SEC / fps);
         dispatch_source_set_timer(g_avTimer, dispatch_time(DISPATCH_TIME_NOW, 0), interval, interval / 10);
         
         // Retain objects before passing to block to prevent deallocation
@@ -371,7 +377,7 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
                             
                             // Write frame only if input is ready
                             if (localVideoInput && localVideoInput.readyForMoreMediaData) {
-                                CMTime frameTime = CMTimeAdd(g_avStartTime, CMTimeMakeWithSeconds(g_avFrameNumber / 10.0, 600));
+                                CMTime frameTime = CMTimeAdd(g_avStartTime, CMTimeMakeWithSeconds(((double)g_avFrameNumber) / fps, 600));
                                 BOOL appendSuccess = [localPixelBufferAdaptor appendPixelBuffer:pixelBuffer withPresentationTime:frameTime];
                                 if (appendSuccess) {
                                     g_avFrameNumber++;
@@ -401,8 +407,8 @@ extern "C" bool startAVFoundationRecording(const std::string& outputPath,
         dispatch_resume(g_avTimer);
         g_avIsRecording = true;
         
-        MRLog(@"🎥 AVFoundation recording started: %dx%d @ 10fps", 
-              (int)recordingSize.width, (int)recordingSize.height);
+        MRLog(@"🎥 AVFoundation recording started: %dx%d @ %.0ffps", 
+              (int)recordingSize.width, (int)recordingSize.height, fps);
         
         return true;
         

package/src/electron_safe/screen_capture_electron.mm

@@ -121,12 +121,27 @@ static void initializeSafeQueue() {
             SCDisplay *targetDisplay = nil;
             
             if (displayId) {
+                // First, try matching by real CGDirectDisplayID
                 for (SCDisplay *display in content.displays) {
                     if (display.displayID == [displayId unsignedIntValue]) {
                         targetDisplay = display;
                         break;
                     }
                 }
+
+                // If not matched, treat provided value as index (0-based or 1-based)
+                if (!targetDisplay && content.displays.count > 0) {
+                    NSUInteger count = content.displays.count;
+                    NSUInteger idx0 = (NSUInteger)[displayId unsignedIntValue];
+                    if (idx0 < count) {
+                        targetDisplay = content.displays[idx0];
+                    } else if ([displayId unsignedIntegerValue] > 0) {
+                        NSUInteger idx1 = [displayId unsignedIntegerValue] - 1;
+                        if (idx1 < count) {
+                            targetDisplay = content.displays[idx1];
+                        }
+                    }
+                }
             }
             
             if (!targetDisplay && content.displays.count > 0) {
@@ -154,9 +169,45 @@ static void initializeSafeQueue() {
         }
         
         // Video configuration
-        config.width = 1920;
-        config.height = 1080;
-        config.minimumFrameInterval = CMTimeMake(1, 30); // 30 FPS
+        // Prefer the target display's native resolution when available
+        if (filter && [filter isKindOfClass:[SCContentFilter class]]) {
+            // Try to infer dimensions from selected display or capture area
+            NSDictionary *captureArea = options[@"captureArea"];
+            if (captureArea) {
+                config.width = (size_t)[captureArea[@"width"] doubleValue];
+                config.height = (size_t)[captureArea[@"height"] doubleValue];
+            } else {
+                // Find the selected display again to get dimensions
+                NSNumber *displayId = options[@"displayId"];
+                if (displayId) {
+                    for (SCDisplay *display in content.displays) {
+                        if (display.displayID == [displayId unsignedIntValue]) {
+                            config.width = (size_t)display.width;
+                            config.height = (size_t)display.height;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        
+        // Fallback default resolution if not set above
+        if (config.width == 0 || config.height == 0) {
+            config.width = 1920;
+            config.height = 1080;
+        }
+        
+        // Frame rate from options (default 60)
+        NSInteger fps = 60;
+        if (options[@"frameRate"]) {
+            NSInteger v = [options[@"frameRate"] integerValue];
+            if (v > 0) {
+                if (v < 1) v = 1;
+                if (v > 120) v = 120;
+                fps = v;
+            }
+        }
+        config.minimumFrameInterval = CMTimeMake(1, (int)fps);
         config.queueDepth = 8;
         
         // Capture area if specified

package/src/mac_recorder.mm

@@ -19,7 +19,8 @@ extern "C" {
                                    bool includeMicrophone,
                                    bool includeSystemAudio,
                                    NSString* audioDeviceId,
-                                   NSString* audioOutputPath);
+                                   NSString* audioOutputPath,
+                                   double frameRate);
     bool stopAVFoundationRecording();
     bool isAVFoundationRecording();
     NSString* getAVFoundationAudioPath();
@@ -204,6 +205,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     NSString *cameraOutputPath = nil;
     int64_t sessionTimestamp = 0;
     NSString *audioOutputPath = nil;
+    double frameRate = 60.0;
     
     if (info.Length() > 1 && info[1].IsObject()) {
         Napi::Object options = info[1].As<Napi::Object>();
@@ -271,33 +273,57 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         if (options.Has("sessionTimestamp") && options.Get("sessionTimestamp").IsNumber()) {
             sessionTimestamp = options.Get("sessionTimestamp").As<Napi::Number>().Int64Value();
         }
+
+        // Frame rate
+        if (options.Has("frameRate") && options.Get("frameRate").IsNumber()) {
+            double fps = options.Get("frameRate").As<Napi::Number>().DoubleValue();
+            if (fps > 0) {
+                // Clamp to reasonable range
+                if (fps < 1.0) fps = 1.0;
+                if (fps > 120.0) fps = 120.0;
+                frameRate = fps;
+            }
+        }
         
-        // Display ID
+        // Display ID (accepts either real CGDirectDisplayID or index [0-based or 1-based])
         if (options.Has("displayId") && !options.Get("displayId").IsNull()) {
             double displayIdNum = options.Get("displayId").As<Napi::Number>().DoubleValue();
             
-            // Use the display ID directly (not as an index)
-            // The JavaScript layer passes the actual CGDirectDisplayID
-            displayID = (CGDirectDisplayID)displayIdNum;
+            // First, assume the provided value is a real CGDirectDisplayID
+            CGDirectDisplayID candidateID = (CGDirectDisplayID)displayIdNum;
             
-            // Verify that this display ID is valid
-            uint32_t displayCount;
+            // Verify against active displays
+            uint32_t displayCount = 0;
             CGGetActiveDisplayList(0, NULL, &displayCount);
             if (displayCount > 0) {
                 CGDirectDisplayID *displays = (CGDirectDisplayID*)malloc(displayCount * sizeof(CGDirectDisplayID));
                 CGGetActiveDisplayList(displayCount, displays, &displayCount);
                 
-                bool validDisplay = false;
+                bool matchedByID = false;
                 for (uint32_t i = 0; i < displayCount; i++) {
-                    if (displays[i] == displayID) {
-                        validDisplay = true;
+                    if (displays[i] == candidateID) {
+                        matchedByID = true;
+                        displayID = candidateID;
                         break;
                     }
                 }
                 
-                if (!validDisplay) {
-                    // Fallback to main display if invalid ID provided
-                    displayID = CGMainDisplayID();
+                if (!matchedByID) {
+                    // Tolerant mapping: allow passing index instead of CGDirectDisplayID
+                    // Try 0-based index
+                    int idx0 = (int)displayIdNum;
+                    if (idx0 >= 0 && idx0 < (int)displayCount) {
+                        displayID = displays[idx0];
+                    } else {
+                        // Try 1-based index (common in user examples)
+                        int idx1 = (int)displayIdNum - 1;
+                        if (idx1 >= 0 && idx1 < (int)displayCount) {
+                            displayID = displays[idx1];
+                        } else {
+                            // Fallback to main display
+                            displayID = CGMainDisplayID();
+                        }
+                    }
                 }
                 
                 free(displays);
@@ -400,6 +426,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                 if (sessionTimestamp != 0) {
                     sckConfig[@"sessionTimestamp"] = @(sessionTimestamp);
                 }
+                // Pass requested frame rate
+                sckConfig[@"frameRate"] = @(frameRate);
                 
                 if (!CGRectIsNull(captureRect)) {
                     sckConfig[@"captureRect"] = @{
@@ -511,7 +539,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
                                                    bool includeMicrophone,
                                                    bool includeSystemAudio,
                                                    NSString* audioDeviceId,
-                                                   NSString* audioOutputPath);
+                                                   NSString* audioOutputPath,
+                                                   double frameRate);
 
             // CRITICAL SYNC FIX: Start camera BEFORE screen recording for perfect sync
             // This ensures both capture their first frame at approximately the same time
@@ -529,7 +558,8 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             // Now start screen recording immediately after camera
             MRLog(@"🎯 SYNC: Starting screen recording immediately");
             bool avResult = startAVFoundationRecording(outputPath, displayID, windowID, captureRect,
-                                                      captureCursor, includeMicrophone, includeSystemAudio, audioDeviceId, audioOutputPath);
+                                                      captureCursor, includeMicrophone, includeSystemAudio,
+                                                      audioDeviceId, audioOutputPath, frameRate);
 
             if (avResult) {
                 MRLog(@"🎥 RECORDING METHOD: AVFoundation");

package/src/screen_capture_kit.mm

@@ -32,6 +32,7 @@ static BOOL g_audioWriterStarted = NO;
 
 static NSInteger g_configuredSampleRate = 48000;
 static NSInteger g_configuredChannelCount = 2;
+static NSInteger g_targetFPS = 60;
 
 // Frame rate debugging
 static NSInteger g_frameCount = 0;
@@ -342,9 +343,9 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
 
     NSDictionary *compressionProps = @{
         AVVideoAverageBitRateKey: @(bitrate),
-        AVVideoMaxKeyFrameIntervalKey: @30,
+        AVVideoMaxKeyFrameIntervalKey: @(MAX(1, g_targetFPS)),
         AVVideoAllowFrameReorderingKey: @YES,
-        AVVideoExpectedSourceFrameRateKey: @60,
+        AVVideoExpectedSourceFrameRateKey: @(MAX(1, g_targetFPS)),
         AVVideoQualityKey: @(0.95),  // 0.0-1.0, higher is better (0.95 = excellent)
         AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
         AVVideoH264EntropyModeKey: AVVideoH264EntropyModeCABAC
@@ -524,6 +525,17 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     NSString *audioOutputPath = MRNormalizePath(config[@"audioOutputPath"]);
     NSNumber *sessionTimestampNumber = config[@"sessionTimestamp"];
     
+    // Extract requested frame rate
+    NSNumber *frameRateNumber = config[@"frameRate"];
+    if (frameRateNumber && [frameRateNumber respondsToSelector:@selector(intValue)]) {
+        NSInteger fps = [frameRateNumber intValue];
+        if (fps < 1) fps = 1;
+        if (fps > 120) fps = 120;
+        g_targetFPS = fps;
+    } else {
+        g_targetFPS = 60;
+    }
+    
     MRLog(@"🎬 Starting PURE ScreenCaptureKit recording (NO AVFoundation)");
     MRLog(@"🔧 Config: cursor=%@ mic=%@ system=%@ display=%@ window=%@ crop=%@", 
           captureCursor, includeMicrophone, includeSystemAudio, displayId, windowId, captureRect);
@@ -641,7 +653,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         SCStreamConfiguration *streamConfig = [[SCStreamConfiguration alloc] init];
         streamConfig.width = recordingWidth;
         streamConfig.height = recordingHeight;
-        streamConfig.minimumFrameInterval = CMTimeMake(1, 60); // 60 FPS for smooth recording
+        streamConfig.minimumFrameInterval = CMTimeMake(1, (int)MAX(1, g_targetFPS));
         streamConfig.pixelFormat = kCVPixelFormatType_32BGRA;
         streamConfig.scalesToFit = NO;
 
@@ -650,7 +662,7 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             streamConfig.queueDepth = 8; // Larger queue for smoother capture
         }
 
-        MRLog(@"🎬 ScreenCaptureKit config: %ldx%ld @ 60fps", (long)recordingWidth, (long)recordingHeight);
+        MRLog(@"🎬 ScreenCaptureKit config: %ldx%ld @ %ldfps", (long)recordingWidth, (long)recordingHeight, (long)g_targetFPS);
         
         BOOL shouldCaptureMic = includeMicrophone ? [includeMicrophone boolValue] : NO;
         BOOL shouldCaptureSystemAudio = includeSystemAudio ? [includeSystemAudio boolValue] : NO;
@@ -735,8 +747,8 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         BOOL shouldShowCursor = captureCursor ? [captureCursor boolValue] : YES;
         streamConfig.showsCursor = shouldShowCursor;
         
-        MRLog(@"🎥 Pure ScreenCapture config: %ldx%ld @ 30fps, cursor=%d", 
-              recordingWidth, recordingHeight, shouldShowCursor);
+        MRLog(@"🎥 Pure ScreenCapture config: %ldx%ld @ %ldfps, cursor=%d", 
+              recordingWidth, recordingHeight, (long)g_targetFPS, shouldShowCursor);
         
         NSError *writerError = nil;
         if (![ScreenCaptureKitRecorder prepareVideoWriterWithWidth:recordingWidth height:recordingHeight error:&writerError]) {