node-mac-recorder 2.21.1 → 2.21.3

package/package.json

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

package/src/camera_recorder.mm

@@ -82,6 +82,10 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
 @property (atomic, assign) BOOL writerStarted;
 @property (atomic, assign) BOOL isShuttingDown;
 @property (nonatomic, assign) CMTime firstSampleTime;
+@property (nonatomic, assign) int32_t expectedWidth;
+@property (nonatomic, assign) int32_t expectedHeight;
+@property (nonatomic, assign) double expectedFrameRate;
+@property (atomic, assign) BOOL needsReconfiguration;
 
 + (instancetype)sharedRecorder;
 + (NSArray<NSDictionary *> *)availableCameraDevices;
@@ -242,23 +246,28 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     AVCaptureDeviceFormat *bestFormat = nil;
     int64_t bestResolutionScore = 0;
     double bestFrameRate = 0.0;
-    
+
+    MRLog(@"🔍 Scanning formats for device: %@", device.localizedName);
+
     for (AVCaptureDeviceFormat *format in device.formats) {
         CMVideoDimensions dims = CMVideoFormatDescriptionGetDimensions(format.formatDescription);
         if (dims.width <= 0 || dims.height <= 0) {
             continue;
         }
-        
+
+        // No filtering - use whatever the device supports
+        // The device knows best what it can capture
+
         int64_t score = (int64_t)dims.width * (int64_t)dims.height;
-        
+
         double maxFrameRate = 0.0;
         for (AVFrameRateRange *range in format.videoSupportedFrameRateRanges) {
             maxFrameRate = MAX(maxFrameRate, range.maxFrameRate);
         }
-        
+
         BOOL usesBetterResolution = score > bestResolutionScore;
         BOOL sameResolutionHigherFps = (score == bestResolutionScore) && (maxFrameRate > bestFrameRate);
-        
+
         if (!bestFormat || usesBetterResolution || sameResolutionHigherFps) {
             bestFormat = format;
             bestResolutionScore = score;
@@ -266,9 +275,17 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
             if (widthOut) *widthOut = dims.width;
             if (heightOut) *heightOut = dims.height;
             if (frameRateOut) *frameRateOut = bestFrameRate;
+            MRLog(@"   ✅ New best: %dx%d @ %.0ffps (score=%lld)",
+                  dims.width, dims.height, maxFrameRate, score);
         }
     }
-    
+
+    if (bestFormat) {
+        MRLog(@"📹 Selected format: %dx%d @ %.0ffps", *widthOut, *heightOut, *frameRateOut);
+    } else {
+        MRLog(@"❌ No suitable format found");
+    }
+
     return bestFormat;
 }
 
@@ -415,17 +432,28 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
         MRLog(@"ℹ️ CameraRecorder: WebM unavailable, storing data in QuickTime container");
     }
     
-    NSInteger bitrate = (NSInteger)(width * height * 6); // Empirical bitrate multiplier
-    bitrate = MAX(bitrate, 5 * 1000 * 1000); // Minimum 5 Mbps
+    // Calculate bitrate based on resolution for high quality
+    // Use higher multiplier for better quality (10 instead of 6)
+    NSInteger bitrate = (NSInteger)(width * height * 10);
+    bitrate = MAX(bitrate, 8 * 1000 * 1000); // Minimum 8 Mbps for quality
+    bitrate = MIN(bitrate, 50 * 1000 * 1000); // Maximum 50 Mbps to avoid excessive file size
+
+    MRLog(@"🎬 Camera encoder settings: %dx%d @ %.2ffps, bitrate=%.2fMbps",
+          width, height, frameRate, bitrate / (1000.0 * 1000.0));
     
     NSMutableDictionary *compressionProps = [@{
         AVVideoAverageBitRateKey: @(bitrate),
         AVVideoMaxKeyFrameIntervalKey: @(MAX(1, (int)round(frameRate))),
-        AVVideoAllowFrameReorderingKey: @YES
+        AVVideoAllowFrameReorderingKey: @YES,
+        AVVideoExpectedSourceFrameRateKey: @(frameRate),
+        // Add quality hint for better encoding
+        AVVideoQualityKey: @(0.9) // 0.0-1.0, higher is better quality
     } mutableCopy];
-    
+
     if ([codec isEqualToString:AVVideoCodecTypeH264]) {
         compressionProps[AVVideoProfileLevelKey] = AVVideoProfileLevelH264HighAutoLevel;
+        // Use Main profile for better quality
+        compressionProps[AVVideoH264EntropyModeKey] = AVVideoH264EntropyModeCABAC;
     }
     
     NSDictionary *videoSettings = @{
@@ -440,9 +468,12 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     self.assetWriterInput.expectsMediaDataInRealTime = YES;
     
     NSDictionary *pixelBufferAttributes = @{
-        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarFullRange),
+        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange),
         (NSString *)kCVPixelBufferWidthKey: @(width),
-        (NSString *)kCVPixelBufferHeightKey: @(height)
+        (NSString *)kCVPixelBufferHeightKey: @(height),
+        // Preserve aspect ratio and use high quality scaling
+        (NSString *)kCVPixelBufferCGImageCompatibilityKey: @YES,
+        (NSString *)kCVPixelBufferCGBitmapContextCompatibilityKey: @YES
     };
     
     self.pixelBufferAdaptor = [AVAssetWriterInputPixelBufferAdaptor assetWriterInputPixelBufferAdaptorWithAssetWriterInput:self.assetWriterInput
@@ -572,8 +603,10 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     
     self.videoOutput = [[AVCaptureVideoDataOutput alloc] init];
     self.videoOutput.alwaysDiscardsLateVideoFrames = NO;
+    // Use video range (not full range) for better compatibility and quality
+    // YpCbCr 4:2:0 biplanar is the native format for most cameras
     self.videoOutput.videoSettings = @{
-        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarFullRange)
+        (NSString *)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange)
     };
     
     self.captureQueue = dispatch_queue_create("node_mac_recorder.camera.queue", DISPATCH_QUEUE_SERIAL);
@@ -594,31 +627,39 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     
     AVCaptureConnection *connection = [self.videoOutput connectionWithMediaType:AVMediaTypeVideo];
     if (connection) {
-        if (connection.isVideoOrientationSupported) {
-            connection.videoOrientation = AVCaptureVideoOrientationPortrait;
-        }
+        // DON'T set orientation - let the camera use its natural orientation
+        // The device knows best (portrait for phones, landscape for webcams)
+        // We just capture whatever comes through
+
+        // Mirror front cameras for natural preview
         if (connection.isVideoMirroringSupported && device.position == AVCaptureDevicePositionFront) {
             if ([connection respondsToSelector:@selector(setAutomaticallyAdjustsVideoMirroring:)]) {
                 connection.automaticallyAdjustsVideoMirroring = NO;
             }
             connection.videoMirrored = YES;
         }
+
+        // Log actual connection properties for debugging
+        MRLog(@"📐 Camera connection: orientation=%ld (native), mirrored=%d, format=%dx%d",
+              (long)connection.videoOrientation,
+              connection.isVideoMirrored,
+              width, height);
     }
     
-    NSURL *outputURL = [NSURL fileURLWithPath:outputPath];
-    if (![self setupWriterWithURL:outputURL width:width height:height frameRate:frameRate error:error]) {
-        [self.session stopRunning];
-        [self resetState];
-        return NO;
-    }
-    
+    // DON'T setup writer yet - wait for first frame to get actual dimensions
+    // Store configuration for lazy initialization
     self.outputPath = outputPath;
     self.isRecording = YES;
     self.isShuttingDown = NO;
-    
+    self.expectedWidth = width;
+    self.expectedHeight = height;
+    self.expectedFrameRate = frameRate;
+    self.needsReconfiguration = NO;
+
     [self.session startRunning];
-    
-    MRLog(@"🎥 CameraRecorder started: %@ (%dx%d @ %.2ffps)", device.localizedName, width, height, frameRate);
+
+    MRLog(@"🎥 CameraRecorder started: %@ (will use actual frame dimensions)", device.localizedName);
+    MRLog(@"   Format reports: %dx%d @ %.2ffps", width, height, frameRate);
     return YES;
 }
 
@@ -674,18 +715,54 @@ static BOOL MRIsContinuityCamera(AVCaptureDevice *device) {
     if (!self.isRecording || self.isShuttingDown) {
         return;
     }
-    
+
     if (!sampleBuffer) {
         return;
     }
-    
+
     CMTime timestamp = CMSampleBufferGetPresentationTimeStamp(sampleBuffer);
+
+    // Lazy initialization - setup writer with actual frame dimensions
+    if (!self.assetWriter) {
+        CVPixelBufferRef pixelBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);
+        if (!pixelBuffer) {
+            MRLog(@"❌ No pixel buffer in first frame");
+            return;
+        }
+
+        size_t actualWidth = CVPixelBufferGetWidth(pixelBuffer);
+        size_t actualHeight = CVPixelBufferGetHeight(pixelBuffer);
+
+        MRLog(@"🎬 First frame received: %zux%zu (format said %dx%d)",
+              actualWidth, actualHeight, self.expectedWidth, self.expectedHeight);
+
+        // Use ACTUAL dimensions from the frame, not format dimensions
+        NSURL *outputURL = [NSURL fileURLWithPath:self.outputPath];
+        NSError *setupError = nil;
+
+        // Use frame rate from device configuration
+        double frameRate = self.expectedFrameRate > 0 ? self.expectedFrameRate : 30.0;
+
+        if (![self setupWriterWithURL:outputURL
+                                width:(int32_t)actualWidth
+                               height:(int32_t)actualHeight
+                            frameRate:frameRate
+                                error:&setupError]) {
+            MRLog(@"❌ Failed to setup writer with actual dimensions: %@", setupError);
+            self.isRecording = NO;
+            return;
+        }
+
+        MRLog(@"✅ Writer configured with ACTUAL dimensions: %zux%zu", actualWidth, actualHeight);
+    }
+
     if (!self.writerStarted) {
         if (self.assetWriter.status == AVAssetWriterStatusUnknown) {
             if ([self.assetWriter startWriting]) {
                 [self.assetWriter startSessionAtSourceTime:timestamp];
                 self.writerStarted = YES;
                 self.firstSampleTime = timestamp;
+                MRLog(@"✅ Camera writer started");
             } else {
                 MRLog(@"❌ CameraRecorder: Failed to start asset writer: %@", self.assetWriter.error);
                 self.isRecording = NO;

package/src/screen_capture_kit.mm

@@ -121,27 +121,30 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
 @implementation PureScreenCaptureDelegate
 - (void)stream:(SCStream * API_AVAILABLE(macos(12.3)))stream didStopWithError:(NSError *)error API_AVAILABLE(macos(12.3)) {
     MRLog(@"🛑 Pure ScreenCapture stream stopped");
-    
+
     // Prevent recursive calls during cleanup
     if (g_isCleaningUp) {
         MRLog(@"⚠️ Already cleaning up, ignoring delegate callback");
         return;
     }
-    
-    g_isRecording = NO;
-    
+
+    @synchronized([ScreenCaptureKitRecorder class]) {
+        g_isRecording = NO;
+    }
+
     if (error) {
         NSLog(@"❌ Stream error: %@", error);
     } else {
         MRLog(@"✅ Stream stopped cleanly");
     }
-    
-    // Use dispatch_async to prevent potential deadlocks in Electron
-    dispatch_async(dispatch_get_main_queue(), ^{
-        if (!g_isCleaningUp) {  // Double-check before finalizing
+
+    // ELECTRON FIX: Don't use dispatch_async to main queue - it can cause crashes
+    // Instead, finalize directly on current thread with synchronization
+    @synchronized([ScreenCaptureKitRecorder class]) {
+        if (!g_isCleaningUp) {
             [ScreenCaptureKitRecorder finalizeRecording];
         }
-    });
+    }
 }
 @end
 
@@ -450,17 +453,23 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
 + (BOOL)startRecordingWithConfiguration:(NSDictionary *)config delegate:(id)delegate error:(NSError **)error {
     @synchronized([ScreenCaptureKitRecorder class]) {
         if (g_isRecording || g_isCleaningUp) {
-        MRLog(@"⚠️ Already recording or cleaning up (recording:%d cleaning:%d)", g_isRecording, g_isCleaningUp);
+            MRLog(@"⚠️ Already recording or cleaning up (recording:%d cleaning:%d)", g_isRecording, g_isCleaningUp);
             return NO;
         }
-        
+
         // Reset any stale state
         g_isCleaningUp = NO;
+
+        // Set flag early to prevent race conditions in Electron
+        g_isRecording = YES;
     }
-    
+
     NSString *outputPath = config[@"outputPath"];
     if (!outputPath || [outputPath length] == 0) {
         NSLog(@"❌ Invalid output path provided");
+        @synchronized([ScreenCaptureKitRecorder class]) {
+            g_isRecording = NO;
+        }
         return NO;
     }
     g_outputPath = outputPath;
@@ -483,12 +492,17 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
     // CRITICAL DEBUG: Log EXACT audio parameter values
     MRLog(@"🔍 AUDIO DEBUG: includeMicrophone type=%@ value=%d", [includeMicrophone class], [includeMicrophone boolValue]);
     MRLog(@"🔍 AUDIO DEBUG: includeSystemAudio type=%@ value=%d", [includeSystemAudio class], [includeSystemAudio boolValue]);
-    
-    // Get shareable content
+
+    // ELECTRON FIX: Get shareable content FULLY ASYNCHRONOUSLY
+    // NO semaphores, NO blocking - pure async to prevent Electron crashes
     [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent *content, NSError *contentError) {
+        @autoreleasepool {
         if (contentError) {
             NSLog(@"❌ Content error: %@", contentError);
-            return;
+            @synchronized([ScreenCaptureKitRecorder class]) {
+                g_isRecording = NO;
+            }
+            return;  // Early return from completion handler block
         }
         
         MRLog(@"✅ Got %lu displays, %lu windows for pure recording", 
@@ -529,7 +543,10 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
                 recordingHeight = (NSInteger)targetWindow.frame.size.height;
             } else {
                 NSLog(@"❌ Window ID %@ not found", windowId);
-                return;
+                @synchronized([ScreenCaptureKitRecorder class]) {
+                    g_isRecording = NO;
+                }
+                return;  // Early return from completion handler block
             }
         }
         // DISPLAY RECORDING
@@ -558,7 +575,10 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
             
             if (!targetDisplay) {
                 NSLog(@"❌ Display not found");
-                return;
+                @synchronized([ScreenCaptureKitRecorder class]) {
+                    g_isRecording = NO;
+                }
+                return;  // Early return from completion handler block
             }
             
             MRLog(@"🖥️ Recording display %u (%dx%d)", 
@@ -660,7 +680,10 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         NSError *writerError = nil;
         if (![ScreenCaptureKitRecorder prepareVideoWriterWithWidth:recordingWidth height:recordingHeight error:&writerError]) {
             NSLog(@"❌ Failed to prepare video writer: %@", writerError);
-            return;
+            @synchronized([ScreenCaptureKitRecorder class]) {
+                g_isRecording = NO;
+            }
+            return;  // Early return from completion handler block
         }
         
         g_videoQueue = dispatch_queue_create("screen_capture_video_queue", DISPATCH_QUEUE_SERIAL);
@@ -678,7 +701,10 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         if (!g_stream) {
             NSLog(@"❌ Failed to create pure stream");
             CleanupWriters();
-            return;
+            @synchronized([ScreenCaptureKitRecorder class]) {
+                g_isRecording = NO;
+            }
+            return;  // Early return from completion handler block
         }
         
         NSError *outputError = nil;
@@ -686,7 +712,10 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         if (!videoOutputAdded || outputError) {
             NSLog(@"❌ Failed to add video output: %@", outputError);
             CleanupWriters();
-            return;
+            @synchronized([ScreenCaptureKitRecorder class]) {
+                g_isRecording = NO;
+            }
+            return;  // Early return from completion handler block
         }
         
         if (g_shouldCaptureAudio) {
@@ -696,7 +725,10 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
                 if (!audioOutputAdded || audioError) {
                     NSLog(@"❌ Failed to add audio output: %@", audioError);
                     CleanupWriters();
-                    return;
+                    @synchronized([ScreenCaptureKitRecorder class]) {
+                        g_isRecording = NO;
+                    }
+                    return;  // Early return from completion handler block
                 }
             } else {
                 NSLog(@"⚠️ Audio capture requested but requires macOS 13.0+");
@@ -708,19 +740,24 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         if (sessionTimestampNumber) {
             MRLog(@"🕒 Session timestamp: %@", sessionTimestampNumber);
         }
-        
+
+        // ELECTRON FIX: Start capture FULLY ASYNCHRONOUSLY - NO blocking
         [g_stream startCaptureWithCompletionHandler:^(NSError *startError) {
             if (startError) {
                 NSLog(@"❌ Failed to start pure capture: %@", startError);
-                g_isRecording = NO;
                 CleanupWriters();
+                @synchronized([ScreenCaptureKitRecorder class]) {
+                    g_isRecording = NO;
+                }
             } else {
                 MRLog(@"🎉 PURE ScreenCaptureKit recording started successfully!");
-                g_isRecording = YES;
+                // g_isRecording already set to YES at the beginning
             }
         }];
-    }];
-    
+        }  // End of autoreleasepool
+    }];  // End of getShareableContentWithCompletionHandler
+
+    // Return immediately - async completion will handle success/failure
     return YES;
 }
 
@@ -729,26 +766,30 @@ extern "C" NSString *ScreenCaptureKitCurrentAudioPath(void) {
         NSLog(@"⚠️ Cannot stop: recording=%d stream=%@ cleaning=%d", g_isRecording, g_stream, g_isCleaningUp);
         return;
     }
-    
+
     MRLog(@"🛑 Stopping pure ScreenCaptureKit recording");
-    
+
     // Store stream reference to prevent it from being deallocated
     SCStream *streamToStop = g_stream;
-    
-    [streamToStop stopCaptureWithCompletionHandler:^(NSError *error) {
-        if (error) {
-            NSLog(@"❌ Stop error: %@", error);
-        }
-        MRLog(@"✅ Pure stream stopped");
-        
-        // Immediately reset recording state to allow new recordings
-        g_isRecording = NO;
-        
-        // Finalize on main queue to prevent threading issues
-        dispatch_async(dispatch_get_main_queue(), ^{
+
+    // ELECTRON FIX: Stop FULLY ASYNCHRONOUSLY - NO blocking, NO semaphores
+    [streamToStop stopCaptureWithCompletionHandler:^(NSError *stopError) {
+        @autoreleasepool {
+            if (stopError) {
+                NSLog(@"❌ Stop error: %@", stopError);
+            } else {
+                MRLog(@"✅ Pure stream stopped");
+            }
+
+            // Reset recording state to allow new recordings
+            @synchronized([ScreenCaptureKitRecorder class]) {
+                g_isRecording = NO;
+            }
+
+            // Cleanup after stop completes
             CleanupWriters();
             [ScreenCaptureKitRecorder cleanupVideoWriter];
-        });
+        }
     }];
 }
 

package/test-electron-fix.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Test script for Electron crash fix
+ * Tests ScreenCaptureKit recording with synchronous semaphore-based approach
+ */
+
+const MacRecorder = require('./index.js');
+const path = require('path');
+const fs = require('fs');
+
+async function testRecording() {
+    console.log('🧪 Testing ScreenCaptureKit Electron crash fix...\n');
+
+    const recorder = new MacRecorder();
+
+    // Check permissions first
+    console.log('1️⃣ Checking permissions...');
+    const permissions = await recorder.checkPermissions();
+    console.log('   Permissions:', permissions);
+
+    if (!permissions.screenRecording) {
+        console.error('❌ Screen recording permission not granted');
+        console.log('   Please enable screen recording in System Settings > Privacy & Security');
+        process.exit(1);
+    }
+
+    // Get displays
+    console.log('\n2️⃣ Getting displays...');
+    const displays = await recorder.getDisplays();
+    console.log(`   Found ${displays.length} display(s):`);
+    displays.forEach(d => {
+        console.log(`   - Display ${d.id}: ${d.width}x${d.height} (Primary: ${d.isPrimary})`);
+    });
+
+    // Prepare output path
+    const outputDir = path.join(__dirname, 'test-output');
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    const outputPath = path.join(outputDir, `electron-fix-test-${Date.now()}.mov`);
+
+    try {
+        // Start recording
+        console.log('\n3️⃣ Starting recording...');
+        console.log(`   Output: ${outputPath}`);
+
+        await recorder.startRecording(outputPath, {
+            displayId: displays[0].id,
+            captureCursor: true,
+            includeMicrophone: false,
+            includeSystemAudio: false
+        });
+
+        console.log('✅ Recording started successfully!');
+        console.log('   Recording for 3 seconds...\n');
+
+        // Record for 3 seconds
+        await new Promise(resolve => setTimeout(resolve, 3000));
+
+        // Stop recording
+        console.log('4️⃣ Stopping recording...');
+        const result = await recorder.stopRecording();
+        console.log('✅ Recording stopped successfully!');
+        console.log('   Result:', result);
+
+        // Check output file
+        if (fs.existsSync(outputPath)) {
+            const stats = fs.statSync(outputPath);
+            console.log(`\n✅ Output file created: ${outputPath}`);
+            console.log(`   File size: ${(stats.size / 1024).toFixed(2)} KB`);
+        } else {
+            console.log('\n⚠️ Output file not found (may still be finalizing)');
+        }
+
+        console.log('\n🎉 Test completed successfully! No crashes detected.');
+        console.log('   The Electron crash fix appears to be working.\n');
+
+    } catch (error) {
+        console.error('\n❌ Test failed:', error.message);
+        console.error('   Stack:', error.stack);
+        process.exit(1);
+    }
+}
+
+// Run test
+testRecording().catch(error => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});