node-mac-recorder 1.2.3 → 1.2.5

package/README.md

@@ -92,6 +92,7 @@ await recorder.startRecording("./recording.mov", {
 	// Audio Controls
 	includeMicrophone: false, // Enable microphone (default: false)
 	includeSystemAudio: true, // Enable system audio (default: true)
+	audioDeviceId: "device-id", // Specific audio input device (default: system default)
 
 	// Display & Window Selection
 	displayId: 0, // Display index (null = main display)
@@ -159,14 +160,14 @@ console.log(displays);
 
 #### `getAudioDevices()`
 
-Lists all available audio input devices.
+Returns a list of available audio input devices.
 
 ```javascript
 const devices = await recorder.getAudioDevices();
 console.log(devices);
 // [
 //   {
-//     id: "device-id-123",
+//     id: "device-id",
 //     name: "Built-in Microphone",
 //     manufacturer: "Apple Inc.",
 //     isDefault: true

package/capture-test.js

@@ -0,0 +1,87 @@
+const MacRecorder = require("./");
+const fs = require("fs");
+const path = require("path");
+
+async function saveBase64Image(base64String, filePath) {
+	// Remove the data:image/png;base64, prefix if it exists
+	const base64Data = base64String.replace(/^data:image\/png;base64,/, "");
+
+	// Create directory if it doesn't exist
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) {
+		fs.mkdirSync(dir, { recursive: true });
+	}
+
+	// Write the file
+	fs.writeFileSync(filePath, base64Data, "base64");
+	console.log(`✅ Saved image to: ${filePath}`);
+}
+
+async function captureTest() {
+	const recorder = new MacRecorder();
+
+	// Create output directory
+	const outputDir = path.join(__dirname, "thumbnails");
+	if (!fs.existsSync(outputDir)) {
+		fs.mkdirSync(outputDir, { recursive: true });
+	}
+
+	console.log("📸 Testing Display Capture");
+
+	// Get displays
+	const displays = await recorder.getDisplays();
+	console.log(`Found ${displays.length} displays`);
+
+	// Capture each display
+	for (const display of displays) {
+		console.log(
+			`\nCapturing display ${display.id} (${display.width}x${display.height})`
+		);
+		try {
+			const thumbnail = await recorder.getDisplayThumbnail(display.id, {
+				maxWidth: 800,
+				maxHeight: 600,
+			});
+
+			const fileName = `display_${display.id}.png`;
+			const filePath = path.join(outputDir, fileName);
+			await saveBase64Image(thumbnail, filePath);
+		} catch (error) {
+			console.error(`Failed to capture display ${display.id}:`, error);
+		}
+	}
+
+	console.log("\n📸 Testing Window Capture");
+
+	// Get windows
+	const windows = await recorder.getWindows();
+	console.log(`Found ${windows.length} windows`);
+
+	// Capture each window
+	for (const window of windows) {
+		console.log(
+			`\nCapturing window "${window.appName}" (${window.width}x${window.height})`
+		);
+		try {
+			const thumbnail = await recorder.getWindowThumbnail(window.id, {
+				maxWidth: 800,
+				maxHeight: 600,
+			});
+
+			const fileName = `window_${window.id}_${window.appName.replace(
+				/[^a-z0-9]/gi,
+				"_"
+			)}.png`;
+			const filePath = path.join(outputDir, fileName);
+			await saveBase64Image(thumbnail, filePath);
+		} catch (error) {
+			console.error(`Failed to capture window "${window.appName}":`, error);
+		}
+	}
+
+	console.log(
+		"\n✅ Test completed. Check the thumbnails directory for results."
+	);
+}
+
+captureTest().catch(console.error);

package/index.js

@@ -69,31 +69,17 @@ class MacRecorder extends EventEmitter {
 	 * macOS ekranlarını listeler
 	 */
 	async getDisplays() {
-		return new Promise((resolve, reject) => {
-			try {
-				const displays = nativeBinding.getDisplays();
-				const formattedDisplays = displays.map((display, index) => ({
-					id: index,
-					name:
-						typeof display === "string"
-							? display
-							: display.name || `Display ${index + 1}`,
-					resolution:
-						typeof display === "object"
-							? `${display.width}x${display.height}`
-							: "Unknown",
-					width: typeof display === "object" ? display.width : null,
-					height: typeof display === "object" ? display.height : null,
-					x: typeof display === "object" ? display.x : 0,
-					y: typeof display === "object" ? display.y : 0,
-					isPrimary:
-						typeof display === "object" ? display.isPrimary : index === 0,
-				}));
-				resolve(formattedDisplays);
-			} catch (error) {
-				reject(error);
-			}
-		});
+		const displays = nativeBinding.getDisplays();
+		return displays.map((display, index) => ({
+			id: display.id, // Use the actual display ID from native code
+			name: display.name,
+			width: display.width,
+			height: display.height,
+			x: display.x,
+			y: display.y,
+			isPrimary: display.isPrimary,
+			resolution: `${display.width}x${display.height}`,
+		}));
 	}
 
 	/**
@@ -113,8 +99,16 @@ class MacRecorder extends EventEmitter {
 	/**
 	 * Kayıt seçeneklerini ayarlar
 	 */
-	setOptions(options) {
-		this.options = { ...this.options, ...options };
+	setOptions(options = {}) {
+		this.options = {
+			includeMicrophone: options.includeMicrophone || false,
+			includeSystemAudio: options.includeSystemAudio !== false, // Default true
+			captureCursor: options.captureCursor || false,
+			displayId: options.displayId || null, // null = ana ekran
+			windowId: options.windowId || null, // null = tam ekran
+			audioDeviceId: options.audioDeviceId || null, // null = default device
+			captureArea: options.captureArea || null,
+		};
 	}
 
 	/**
@@ -233,6 +227,7 @@ class MacRecorder extends EventEmitter {
 					captureCursor: this.options.captureCursor || false,
 					displayId: this.options.displayId || null, // null = ana ekran
 					windowId: this.options.windowId || null, // null = tam ekran
+					audioDeviceId: this.options.audioDeviceId || null, // null = default device
 				};
 
 				// Manuel captureArea varsa onu kullan
@@ -404,8 +399,16 @@ class MacRecorder extends EventEmitter {
 
 		return new Promise((resolve, reject) => {
 			try {
+				// Get all displays first to validate the ID
+				const displays = nativeBinding.getDisplays();
+				const display = displays.find((d) => d.id === displayId);
+
+				if (!display) {
+					throw new Error(`Display with ID ${displayId} not found`);
+				}
+
 				const base64Image = nativeBinding.getDisplayThumbnail(
-					displayId,
+					display.id, // Use the actual CGDirectDisplayID
 					maxWidth,
 					maxHeight
 				);
@@ -586,6 +589,52 @@ class MacRecorder extends EventEmitter {
 			nativeModule: "mac_recorder.node",
 		};
 	}
+
+	async getDisplaysWithThumbnails(options = {}) {
+		const displays = await this.getDisplays();
+
+		// Get thumbnails for each display
+		const displayPromises = displays.map(async (display) => {
+			try {
+				const thumbnail = await this.getDisplayThumbnail(display.id, options);
+				return {
+					...display,
+					thumbnail,
+				};
+			} catch (error) {
+				return {
+					...display,
+					thumbnail: null,
+					thumbnailError: error.message,
+				};
+			}
+		});
+
+		return Promise.all(displayPromises);
+	}
+
+	async getWindowsWithThumbnails(options = {}) {
+		const windows = await this.getWindows();
+
+		// Get thumbnails for each window
+		const windowPromises = windows.map(async (window) => {
+			try {
+				const thumbnail = await this.getWindowThumbnail(window.id, options);
+				return {
+					...window,
+					thumbnail,
+				};
+			} catch (error) {
+				return {
+					...window,
+					thumbnail: null,
+					thumbnailError: error.message,
+				};
+			}
+		});
+
+		return Promise.all(windowPromises);
+	}
 }
 
 module.exports = MacRecorder;

package/list-test.js

@@ -0,0 +1,46 @@
+const MacRecorder = require("./");
+
+async function testListing() {
+	const recorder = new MacRecorder();
+
+	console.log("📺 Testing Displays with Thumbnails");
+	const displays = await recorder.getDisplaysWithThumbnails({
+		maxWidth: 200,
+		maxHeight: 150,
+	});
+	console.log(`Found ${displays.length} displays:`);
+	for (const display of displays) {
+		console.log(`\nDisplay ID: ${display.id}`);
+		console.log(`Resolution: ${display.width}x${display.height}`);
+		console.log(`Position: (${display.x}, ${display.y})`);
+		console.log(`Primary: ${display.isPrimary}`);
+		console.log(
+			`Thumbnail included: ${display.thumbnail.substring(0, 50)}... (${
+				display.thumbnail.length
+			} chars)`
+		);
+	}
+
+	console.log("\n🪟 Testing Windows with Thumbnails");
+	const windows = await recorder.getWindowsWithThumbnails({
+		maxWidth: 200,
+		maxHeight: 150,
+	});
+	console.log(`Found ${windows.length} windows:`);
+	for (const window of windows.slice(0, 3)) {
+		// Just show first 3 for brevity
+		console.log(`\nWindow: ${window.appName}`);
+		console.log(`ID: ${window.id}`);
+		console.log(`Size: ${window.width}x${window.height}`);
+		console.log(
+			`Thumbnail included: ${window.thumbnail.substring(0, 50)}... (${
+				window.thumbnail.length
+			} chars)`
+		);
+	}
+	if (windows.length > 3) {
+		console.log(`\n... and ${windows.length - 3} more windows`);
+	}
+}
+
+testListing().catch(console.error);

package/package.json

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

package/src/mac_recorder.mm

@@ -7,6 +7,9 @@
 #import <ImageIO/ImageIO.h>
 #import <CoreAudio/CoreAudio.h>
 
+// Import screen capture
+#import "screen_capture.h"
+
 // Cursor tracker function declarations
 Napi::Object InitCursorTracker(Napi::Env env, Napi::Object exports);
 
@@ -67,6 +70,7 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
     bool includeMicrophone = false; // Default olarak mikrofon kapalı
     bool includeSystemAudio = true; // Default olarak sistem sesi açık
     CGDirectDisplayID displayID = CGMainDisplayID(); // Default ana ekran
+    NSString *audioDeviceId = nil; // Default audio device ID
     
     if (info.Length() > 1 && info[1].IsObject()) {
         Napi::Object options = info[1].As<Napi::Object>();
@@ -94,6 +98,12 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
             includeMicrophone = options.Get("includeMicrophone").As<Napi::Boolean>();
         }
         
+        // Audio device ID
+        if (options.Has("audioDeviceId") && !options.Get("audioDeviceId").IsNull()) {
+            std::string deviceId = options.Get("audioDeviceId").As<Napi::String>().Utf8Value();
+            audioDeviceId = [NSString stringWithUTF8String:deviceId.c_str()];
+        }
+        
         // System audio
         if (options.Has("includeSystemAudio")) {
             includeSystemAudio = options.Get("includeSystemAudio").As<Napi::Boolean>();
@@ -151,12 +161,41 @@ Napi::Value StartRecording(const Napi::CallbackInfo& info) {
         
         // Add microphone input if requested
         if (includeMicrophone) {
-            AVCaptureDevice *audioDevice = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];
+            AVCaptureDevice *audioDevice = nil;
+            
+            if (audioDeviceId) {
+                // Try to find the specified device
+                NSArray *devices = [AVCaptureDevice devicesWithMediaType:AVMediaTypeAudio];
+                NSLog(@"[DEBUG] Looking for audio device with ID: %@", audioDeviceId);
+                NSLog(@"[DEBUG] Available audio devices:");
+                for (AVCaptureDevice *device in devices) {
+                    NSLog(@"[DEBUG] - Device: %@ (ID: %@)", device.localizedName, device.uniqueID);
+                    if ([device.uniqueID isEqualToString:audioDeviceId]) {
+                        NSLog(@"[DEBUG] Found matching device: %@", device.localizedName);
+                        audioDevice = device;
+                        break;
+                    }
+                }
+                
+                if (!audioDevice) {
+                    NSLog(@"[DEBUG] Specified audio device not found, falling back to default");
+                }
+            }
+            
+            // Fallback to default device if specified device not found
+            if (!audioDevice) {
+                audioDevice = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];
+                NSLog(@"[DEBUG] Using default audio device: %@ (ID: %@)", audioDevice.localizedName, audioDevice.uniqueID);
+            }
+            
             if (audioDevice) {
                 NSError *error;
                 g_audioInput = [[AVCaptureDeviceInput alloc] initWithDevice:audioDevice error:&error];
                 if (g_audioInput && [g_captureSession canAddInput:g_audioInput]) {
                     [g_captureSession addInput:g_audioInput];
+                    NSLog(@"[DEBUG] Successfully added audio input device");
+                } else {
+                    NSLog(@"[DEBUG] Failed to add audio input device: %@", error);
                 }
             }
         }
@@ -363,35 +402,20 @@ Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
     Napi::Env env = info.Env();
     
     @try {
-        NSMutableArray *displays = [NSMutableArray array];
-        
-        uint32_t displayCount;
-        CGGetActiveDisplayList(0, NULL, &displayCount);
-        
-        CGDirectDisplayID *displayList = (CGDirectDisplayID *)malloc(displayCount * sizeof(CGDirectDisplayID));
-        CGGetActiveDisplayList(displayCount, displayList, &displayCount);
-        
-        for (uint32_t i = 0; i < displayCount; i++) {
-            CGDirectDisplayID displayID = displayList[i];
-            CGRect bounds = CGDisplayBounds(displayID);
-            
-            [displays addObject:@{
-                @"id": @(displayID),
-                @"name": [NSString stringWithFormat:@"Display %d", i + 1],
-                @"width": @(bounds.size.width),
-                @"height": @(bounds.size.height),
-                @"x": @(bounds.origin.x),
-                @"y": @(bounds.origin.y),
-                @"isPrimary": @(CGDisplayIsMain(displayID))
-            }];
-        }
+        NSArray *displays = [ScreenCapture getAvailableDisplays];
+        Napi::Array result = Napi::Array::New(env, displays.count);
         
-        free(displayList);
+        NSLog(@"Found %lu displays", (unsigned long)displays.count);
         
-        // Convert to NAPI array
-        Napi::Array result = Napi::Array::New(env, displays.count);
         for (NSUInteger i = 0; i < displays.count; i++) {
             NSDictionary *display = displays[i];
+            NSLog(@"Display %lu: ID=%u, Name=%@, Size=%@x%@", 
+                  (unsigned long)i,
+                  [display[@"id"] unsignedIntValue],
+                  display[@"name"],
+                  display[@"width"],
+                  display[@"height"]);
+                  
             Napi::Object displayObj = Napi::Object::New(env);
             displayObj.Set("id", Napi::Number::New(env, [display[@"id"] unsignedIntValue]));
             displayObj.Set("name", Napi::String::New(env, [display[@"name"] UTF8String]));
@@ -406,6 +430,7 @@ Napi::Value GetDisplays(const Napi::CallbackInfo& info) {
         return result;
         
     } @catch (NSException *exception) {
+        NSLog(@"Exception in GetDisplays: %@", exception);
         return Napi::Array::New(env, 0);
     }
 }
@@ -536,10 +561,34 @@ Napi::Value GetDisplayThumbnail(const Napi::CallbackInfo& info) {
     }
     
     @try {
+        // Verify display exists
+        CGDirectDisplayID activeDisplays[32];
+        uint32_t displayCount;
+        CGError err = CGGetActiveDisplayList(32, activeDisplays, &displayCount);
+        
+        if (err != kCGErrorSuccess) {
+            NSLog(@"Failed to get active display list: %d", err);
+            return env.Null();
+        }
+        
+        bool displayFound = false;
+        for (uint32_t i = 0; i < displayCount; i++) {
+            if (activeDisplays[i] == displayID) {
+                displayFound = true;
+                break;
+            }
+        }
+        
+        if (!displayFound) {
+            NSLog(@"Display ID %u not found in active displays", displayID);
+            return env.Null();
+        }
+        
         // Create display image
         CGImageRef displayImage = CGDisplayCreateImage(displayID);
         
         if (!displayImage) {
+            NSLog(@"CGDisplayCreateImage failed for display ID: %u", displayID);
             return env.Null();
         }
         
@@ -547,6 +596,8 @@ Napi::Value GetDisplayThumbnail(const Napi::CallbackInfo& info) {
         size_t originalWidth = CGImageGetWidth(displayImage);
         size_t originalHeight = CGImageGetHeight(displayImage);
         
+        NSLog(@"Original dimensions: %zux%zu", originalWidth, originalHeight);
+        
         // Calculate scaled dimensions maintaining aspect ratio
         double scaleX = (double)maxWidth / originalWidth;
         double scaleY = (double)maxHeight / originalHeight;
@@ -555,6 +606,8 @@ Napi::Value GetDisplayThumbnail(const Napi::CallbackInfo& info) {
         size_t thumbnailWidth = (size_t)(originalWidth * scale);
         size_t thumbnailHeight = (size_t)(originalHeight * scale);
         
+        NSLog(@"Thumbnail dimensions: %zux%zu (scale: %f)", thumbnailWidth, thumbnailHeight, scale);
+        
         // Create scaled image
         CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
         CGContextRef context = CGBitmapContextCreate(
@@ -564,43 +617,61 @@ Napi::Value GetDisplayThumbnail(const Napi::CallbackInfo& info) {
             8,
             thumbnailWidth * 4,
             colorSpace,
-            kCGImageAlphaPremultipliedLast
+            kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big
         );
         
-        if (context) {
-            CGContextDrawImage(context, CGRectMake(0, 0, thumbnailWidth, thumbnailHeight), displayImage);
-            CGImageRef thumbnailImage = CGBitmapContextCreateImage(context);
-            
-            if (thumbnailImage) {
-                // Convert to PNG data
-                NSBitmapImageRep *imageRep = [[NSBitmapImageRep alloc] initWithCGImage:thumbnailImage];
-                NSData *pngData = [imageRep representationUsingType:NSBitmapImageFileTypePNG properties:@{}];
-                
-                if (pngData) {
-                    // Convert to Base64
-                    NSString *base64String = [pngData base64EncodedStringWithOptions:0];
-                    std::string base64Std = [base64String UTF8String];
-                    
-                    CGImageRelease(thumbnailImage);
-                    CGContextRelease(context);
-                    CGColorSpaceRelease(colorSpace);
-                    CGImageRelease(displayImage);
-                    
-                    return Napi::String::New(env, base64Std);
-                }
-                
-                CGImageRelease(thumbnailImage);
-            }
-            
+        if (!context) {
+            NSLog(@"Failed to create bitmap context");
+            CGImageRelease(displayImage);
+            CGColorSpaceRelease(colorSpace);
+            return env.Null();
+        }
+        
+        // Set interpolation quality for better scaling
+        CGContextSetInterpolationQuality(context, kCGInterpolationHigh);
+        
+        // Draw the image
+        CGContextDrawImage(context, CGRectMake(0, 0, thumbnailWidth, thumbnailHeight), displayImage);
+        CGImageRef thumbnailImage = CGBitmapContextCreateImage(context);
+        
+        if (!thumbnailImage) {
+            NSLog(@"Failed to create thumbnail image");
             CGContextRelease(context);
+            CGImageRelease(displayImage);
+            CGColorSpaceRelease(colorSpace);
+            return env.Null();
         }
         
+        // Convert to PNG data
+        NSBitmapImageRep *imageRep = [[NSBitmapImageRep alloc] initWithCGImage:thumbnailImage];
+        NSDictionary *properties = @{NSImageCompressionFactor: @0.8};
+        NSData *pngData = [imageRep representationUsingType:NSBitmapImageFileTypePNG properties:properties];
+        
+        if (!pngData) {
+            NSLog(@"Failed to convert image to PNG data");
+            CGImageRelease(thumbnailImage);
+            CGContextRelease(context);
+            CGImageRelease(displayImage);
+            CGColorSpaceRelease(colorSpace);
+            return env.Null();
+        }
+        
+        // Convert to Base64
+        NSString *base64String = [pngData base64EncodedStringWithOptions:0];
+        std::string base64Std = [base64String UTF8String];
+        
+        NSLog(@"Successfully created thumbnail with base64 length: %lu", (unsigned long)base64Std.length());
+        
+        // Cleanup
+        CGImageRelease(thumbnailImage);
+        CGContextRelease(context);
         CGColorSpaceRelease(colorSpace);
         CGImageRelease(displayImage);
         
-        return env.Null();
+        return Napi::String::New(env, base64Std);
         
     } @catch (NSException *exception) {
+        NSLog(@"Exception in GetDisplayThumbnail: %@", exception);
         return env.Null();
     }
 }

package/src/screen_capture.h

@@ -0,0 +1,19 @@
+#ifndef SCREEN_CAPTURE_H
+#define SCREEN_CAPTURE_H
+
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+
+@interface ScreenCapture : NSObject
+
++ (NSArray *)getAvailableDisplays;
++ (BOOL)captureDisplay:(CGDirectDisplayID)displayID 
+                toFile:(NSString *)filePath 
+                  rect:(CGRect)rect
+           includeCursor:(BOOL)includeCursor;
++ (CGImageRef)createScreenshotFromDisplay:(CGDirectDisplayID)displayID 
+                                     rect:(CGRect)rect;
+
+@end
+
+#endif // SCREEN_CAPTURE_H