native-recorder-nodejs 1.0.1

package/native/mac/AVFEngine.mm

@@ -0,0 +1,274 @@
+#import "AVFEngine.h"
+#import "SCKAudioCapture.h"
+#import <AVFoundation/AVFoundation.h>
+#import <CoreMedia/CoreMedia.h>
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
+
+@interface AVFRecorderDelegate : NSObject <AVCaptureAudioDataOutputSampleBufferDelegate>
+@property (nonatomic, assign) AudioEngine::DataCallback dataCallback;
+@property (nonatomic, assign) AudioEngine::ErrorCallback errorCallback;
+@end
+
+@implementation AVFRecorderDelegate
+- (void)captureOutput:(AVCaptureOutput *)output didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection {
+    if (!self.dataCallback) return;
+
+    CMBlockBufferRef blockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer);
+    if (!blockBuffer) return;
+
+    size_t lengthAtOffset, totalLength;
+    char *dataPointer;
+    OSStatus status = CMBlockBufferGetDataPointer(blockBuffer, 0, &lengthAtOffset, &totalLength, &dataPointer);
+    
+    if (status == kCMBlockBufferNoErr) {
+        self.dataCallback((const uint8_t*)dataPointer, totalLength);
+    }
+}
+@end
+
+struct AVFEngine::Impl {
+    AVCaptureSession *session;
+    AVFRecorderDelegate *delegate;
+    SCKAudioCapture *sckCapture;
+    dispatch_queue_t queue;
+    
+    Impl() {
+        session = nil;
+        delegate = nil;
+        sckCapture = [[SCKAudioCapture alloc] init];
+        queue = nil;
+    }
+    
+    ~Impl() {
+        Stop();
+    }
+
+    void Stop() {
+        if (session) {
+            if ([session isRunning]) {
+                [session stopRunning];
+            }
+            session = nil;
+        }
+        if (sckCapture) {
+            [sckCapture stop];
+        }
+        delegate = nil;
+        queue = nil;
+    }
+};
+
+AVFEngine::AVFEngine() : impl(std::make_unique<Impl>()) {}
+
+AVFEngine::~AVFEngine() = default;
+
+void AVFEngine::Start(const std::string &deviceType, const std::string &deviceId, 
+                      DataCallback dataCb, ErrorCallback errorCb) {
+    impl->Stop();
+
+    // Determine if this is output (system audio) or input (microphone)
+    bool isOutputDevice = (deviceType == AudioEngine::DEVICE_TYPE_OUTPUT);
+
+    if (isOutputDevice) {
+        // Output device: use ScreenCaptureKit for system audio
+        // On macOS, we only support system-wide capture (deviceId should be "system")
+        if (deviceId != AudioEngine::SYSTEM_AUDIO_DEVICE_ID) {
+            if (errorCb) errorCb("macOS only supports system-wide audio capture for output devices. Use deviceId='system'.");
+            return;
+        }
+        
+        if (@available(macOS 12.3, *)) {
+            [impl->sckCapture startWithCallback:dataCb errorCallback:errorCb];
+        } else {
+            if (errorCb) errorCb("System audio recording requires macOS 12.3 or later.");
+        }
+        return;
+    }
+
+    // Input device: use AVFoundation for microphone
+    impl->session = [[AVCaptureSession alloc] init];
+    impl->delegate = [[AVFRecorderDelegate alloc] init];
+    impl->delegate.dataCallback = dataCb;
+    impl->delegate.errorCallback = errorCb;
+    impl->queue = dispatch_queue_create("com.native-recorder.audio", DISPATCH_QUEUE_SERIAL);
+
+    // Find device by ID
+    AVCaptureDevice *device = [AVCaptureDevice deviceWithUniqueID:[NSString stringWithUTF8String:deviceId.c_str()]];
+
+    if (!device) {
+        if (errorCb) errorCb("Device not found: " + deviceId);
+        return;
+    }
+
+    NSError *error = nil;
+    AVCaptureDeviceInput *input = [AVCaptureDeviceInput deviceInputWithDevice:device error:&error];
+    if (error || !input) {
+        if (errorCb) errorCb("Could not create device input: " + std::string([error.localizedDescription UTF8String]));
+        return;
+    }
+
+    if ([impl->session canAddInput:input]) {
+        [impl->session addInput:input];
+    } else {
+        if (errorCb) errorCb("Cannot add input to session");
+        return;
+    }
+
+    AVCaptureAudioDataOutput *output = [[AVCaptureAudioDataOutput alloc] init];
+    
+    // Configure output settings for 48kHz 16-bit stereo PCM
+    NSDictionary *settings = @{
+        AVFormatIDKey: @(kAudioFormatLinearPCM),
+        AVSampleRateKey: @48000.0,
+        AVNumberOfChannelsKey: @2,
+        AVLinearPCMBitDepthKey: @16,
+        AVLinearPCMIsFloatKey: @NO,
+        AVLinearPCMIsBigEndianKey: @NO,
+        AVLinearPCMIsNonInterleaved: @NO
+    };
+    [output setAudioSettings:settings];
+
+    [output setSampleBufferDelegate:impl->delegate queue:impl->queue];
+
+    if ([impl->session canAddOutput:output]) {
+        [impl->session addOutput:output];
+    } else {
+        if (errorCb) errorCb("Cannot add output to session");
+        return;
+    }
+
+    [impl->session startRunning];
+}
+
+void AVFEngine::Stop() {
+    impl->Stop();
+}
+
+std::vector<AudioDevice> AVFEngine::GetDevices() {
+    std::vector<AudioDevice> devices;
+    
+    // Get input devices (microphones)
+    AVCaptureDeviceDiscoverySession *discoverySession = [AVCaptureDeviceDiscoverySession 
+        discoverySessionWithDeviceTypes:@[AVCaptureDeviceTypeMicrophone, AVCaptureDeviceTypeExternal]
+        mediaType:AVMediaTypeAudio
+        position:AVCaptureDevicePositionUnspecified];
+        
+    NSArray<AVCaptureDevice *> *avDevices = discoverySession.devices;
+    AVCaptureDevice *defaultDevice = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];
+
+    for (AVCaptureDevice *device in avDevices) {
+        AudioDevice d;
+        d.id = [device.uniqueID UTF8String];
+        d.name = [device.localizedName UTF8String];
+        d.type = AudioEngine::DEVICE_TYPE_INPUT;
+        d.isDefault = (defaultDevice && [device.uniqueID isEqualToString:defaultDevice.uniqueID]);
+        devices.push_back(d);
+    }
+
+    // Add system audio output device (only one on macOS)
+    if (@available(macOS 12.3, *)) {
+        AudioDevice systemDevice;
+        systemDevice.id = AudioEngine::SYSTEM_AUDIO_DEVICE_ID;
+        systemDevice.name = "System Audio";
+        systemDevice.type = AudioEngine::DEVICE_TYPE_OUTPUT;
+        systemDevice.isDefault = true; // Only one output device on macOS
+        devices.push_back(systemDevice);
+    }
+
+    return devices;
+}
+
+AudioFormat AVFEngine::GetDeviceFormat(const std::string &deviceId) {
+    AudioFormat format = {0, 0, 0, 0};
+    
+    if (deviceId == AudioEngine::SYSTEM_AUDIO_DEVICE_ID) {
+        format.sampleRate = 48000;
+        format.channels = 2;
+        format.bitDepth = 16;
+        format.rawBitDepth = 32;
+        return format;
+    }
+
+    AVCaptureDevice *device = [AVCaptureDevice deviceWithUniqueID:[NSString stringWithUTF8String:deviceId.c_str()]];
+
+    if (!device) return format;
+
+    // Get the active format description
+    CMFormatDescriptionRef formatDesc = device.activeFormat.formatDescription;
+    const AudioStreamBasicDescription *asbd = CMAudioFormatDescriptionGetStreamBasicDescription(formatDesc);
+
+    if (asbd) {
+        format.sampleRate = 48000; // Fixed output sample rate
+        format.channels = 2; // Fixed output channels (we force stereo in output settings)
+        format.rawBitDepth = (int)asbd->mBitsPerChannel;
+        format.bitDepth = 16; // We always output 16-bit
+    }
+
+    return format;
+}
+
+PermissionStatus AVFEngine::CheckPermission() {
+    PermissionStatus status;
+    
+    // Check microphone permission
+    AVAuthorizationStatus micStatus = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeAudio];
+    status.mic = (micStatus == AVAuthorizationStatusAuthorized);
+    
+    // Check screen capture permission (for system audio)
+    // ScreenCaptureKit doesn't have a direct permission check API,
+    // but we can check if we can get shareable content
+    if (@available(macOS 12.3, *)) {
+        __block BOOL hasScreenPermission = NO;
+        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+        
+        [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent * _Nullable shareableContent, NSError * _Nullable error) {
+            // If we can get shareable content without error, we have permission
+            // If error is nil and we get valid content, permission is granted
+            hasScreenPermission = (error == nil && shareableContent != nil);
+            dispatch_semaphore_signal(semaphore);
+        }];
+        
+        // Wait for async call with timeout
+        dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC));
+        status.system = hasScreenPermission;
+    } else {
+        // System audio not supported on older macOS
+        status.system = NO;
+    }
+    
+    return status;
+}
+
+bool AVFEngine::RequestPermission(PermissionType type) {
+    __block BOOL granted = NO;
+    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
+    
+    if (type == PermissionType::Mic) {
+        // Request microphone permission
+        [AVCaptureDevice requestAccessForMediaType:AVMediaTypeAudio completionHandler:^(BOOL allowed) {
+            granted = allowed;
+            dispatch_semaphore_signal(semaphore);
+        }];
+        
+        dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 30 * NSEC_PER_SEC));
+        return granted;
+    } 
+    else if (type == PermissionType::System) {
+        // Request screen capture permission for system audio
+        if (@available(macOS 12.3, *)) {
+            // Attempting to get shareable content will trigger the permission prompt
+            // if not already granted
+            [SCShareableContent getShareableContentWithCompletionHandler:^(SCShareableContent * _Nullable shareableContent, NSError * _Nullable error) {
+                granted = (error == nil && shareableContent != nil);
+                dispatch_semaphore_signal(semaphore);
+            }];
+            
+            dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, 30 * NSEC_PER_SEC));
+            return granted;
+        } else {
+            return false;
+        }
+    }
+    
+    return false;
+}

package/native/mac/SCKAudioCapture.h

@@ -0,0 +1,13 @@
+#import <Foundation/Foundation.h>
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
+#include <functional>
+#include <string>
+
+typedef std::function<void(const uint8_t *, size_t)> SCKDataCallback;
+typedef std::function<void(std::string)> SCKErrorCallback;
+
+@interface SCKAudioCapture : NSObject
+- (void)startWithCallback:(SCKDataCallback)dataCb
+            errorCallback:(SCKErrorCallback)errorCb;
+- (void)stop;
+@end

package/native/mac/SCKAudioCapture.mm

@@ -0,0 +1,213 @@
+#import "SCKAudioCapture.h"
+#import <CoreMedia/CoreMedia.h>
+#include <vector>
+
+@interface SCKAudioCapture () <SCStreamOutput, SCStreamDelegate>
+@property (nonatomic, strong) SCStream *stream;
+@property (nonatomic, assign) SCKDataCallback dataCallback;
+@property (nonatomic, assign) SCKErrorCallback errorCallback;
+@property (nonatomic, strong) dispatch_queue_t captureQueue;
+@end
+
+@implementation SCKAudioCapture
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        // Create a dedicated serial queue for audio capture callbacks
+        // This is crucial because Node.js doesn't run the Cocoa main run loop
+        _captureQueue = dispatch_queue_create("com.native-recorder.sck-audio", DISPATCH_QUEUE_SERIAL);
+    }
+    return self;
+}
+
+- (void)dealloc {
+    [self stop];
+}
+
+- (void)startWithCallback:(SCKDataCallback)dataCb errorCallback:(SCKErrorCallback)errorCb {
+    self.dataCallback = dataCb;
+    self.errorCallback = errorCb;
+
+    if (@available(macOS 12.3, *)) {
+        [SCShareableContent getShareableContentExcludingDesktopWindows:YES
+                                                  onScreenWindowsOnly:NO
+                                                    completionHandler:^(SCShareableContent *content, NSError *error) {
+            dispatch_async(self.captureQueue, ^{
+                if (error) {
+                    if (self.errorCallback) self.errorCallback("Failed to get shareable content: " + std::string(error.localizedDescription.UTF8String));
+                    return;
+                }
+
+                SCDisplay *display = content.displays.firstObject;
+                if (!display) {
+                    if (self.errorCallback) self.errorCallback("No display found");
+                    return;
+                }
+
+                SCContentFilter *filter = [[SCContentFilter alloc] initWithDisplay:display excludingWindows:@[]];
+                
+                SCStreamConfiguration *config = [[SCStreamConfiguration alloc] init];
+                config.capturesAudio = YES;
+                config.sampleRate = 48000;
+                config.channelCount = 2;
+                config.excludesCurrentProcessAudio = NO;
+                
+                // Minimize video overhead since we only need audio
+                config.width = 2;
+                config.height = 2;
+                config.minimumFrameInterval = CMTimeMake(1, 1); // 1 fps for video
+                config.showsCursor = NO;
+
+                self.stream = [[SCStream alloc] initWithFilter:filter configuration:config delegate:self];
+                
+                NSError *addError = nil;
+                [self.stream addStreamOutput:self type:SCStreamOutputTypeAudio sampleHandlerQueue:self.captureQueue error:&addError];
+                if (addError) {
+                    if (self.errorCallback) self.errorCallback("Failed to add stream output: " + std::string(addError.localizedDescription.UTF8String));
+                    return;
+                }
+
+                [self.stream startCaptureWithCompletionHandler:^(NSError *startError) {
+                    if (startError) {
+                        if (self.errorCallback) self.errorCallback("Failed to start capture: " + std::string(startError.localizedDescription.UTF8String));
+                    }
+                }];
+            });
+        }];
+    } else {
+        if (self.errorCallback) self.errorCallback("ScreenCaptureKit is only available on macOS 12.3+");
+    }
+}
+
+- (void)stop {
+    if (@available(macOS 12.3, *)) {
+        if (self.stream) {
+            [self.stream stopCaptureWithCompletionHandler:nil];
+            self.stream = nil;
+        }
+    }
+}
+
+- (void)stream:(SCStream *)stream didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer ofType:(SCStreamOutputType)type {
+    if (type != SCStreamOutputTypeAudio || !self.dataCallback) return;
+
+    if (@available(macOS 12.3, *)) {
+        CMFormatDescriptionRef formatDesc = CMSampleBufferGetFormatDescription(sampleBuffer);
+        const AudioStreamBasicDescription *asbd = CMAudioFormatDescriptionGetStreamBasicDescription(formatDesc);
+        
+        if (!asbd) return;
+
+        // Check if audio is non-interleaved (planar)
+        bool isNonInterleaved = (asbd->mFormatFlags & kAudioFormatFlagIsNonInterleaved) != 0;
+        bool isFloat = (asbd->mFormatFlags & kAudioFormatFlagIsFloat) != 0;
+        int channels = asbd->mChannelsPerFrame;
+
+        if (isNonInterleaved) {
+            // Non-interleaved audio: each channel is in a separate buffer
+            // We need to use CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer
+            CMBlockBufferRef blockBuffer = NULL;
+            
+            // First, get the required buffer list size
+            size_t bufferListSizeNeeded = 0;
+            OSStatus status = CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer(
+                sampleBuffer,
+                &bufferListSizeNeeded,
+                NULL,
+                0,
+                NULL,
+                NULL,
+                0,
+                &blockBuffer
+            );
+            
+            if (bufferListSizeNeeded == 0) {
+                // Fallback: estimate size based on channel count
+                bufferListSizeNeeded = sizeof(AudioBufferList) + (channels - 1) * sizeof(AudioBuffer);
+            }
+            
+            AudioBufferList *audioBufferList = (AudioBufferList *)malloc(bufferListSizeNeeded);
+            status = CMSampleBufferGetAudioBufferListWithRetainedBlockBuffer(
+                sampleBuffer,
+                NULL,
+                audioBufferList,
+                bufferListSizeNeeded,
+                NULL,
+                NULL,
+                kCMSampleBufferFlag_AudioBufferList_Assure16ByteAlignment,
+                &blockBuffer
+            );
+            
+            if (status != noErr || !audioBufferList) {
+                if (audioBufferList) free(audioBufferList);
+                if (blockBuffer) CFRelease(blockBuffer);
+                return;
+            }
+            
+            // Get the number of frames
+            CMItemCount numFrames = CMSampleBufferGetNumSamples(sampleBuffer);
+            
+            if (isFloat && asbd->mBitsPerChannel == 32) {
+                // Interleave channels and convert float to int16
+                std::vector<int16_t> outputBuffer(numFrames * channels);
+                
+                for (CMItemCount frame = 0; frame < numFrames; frame++) {
+                    for (int ch = 0; ch < channels && ch < (int)audioBufferList->mNumberBuffers; ch++) {
+                        const float *channelData = (const float *)audioBufferList->mBuffers[ch].mData;
+                        float sample = channelData[frame];
+                        // Clamp to [-1.0, 1.0]
+                        if (sample > 1.0f) sample = 1.0f;
+                        if (sample < -1.0f) sample = -1.0f;
+                        // Convert to 16-bit and interleave
+                        outputBuffer[frame * channels + ch] = (int16_t)(sample * 32767.0f);
+                    }
+                }
+                
+                self.dataCallback((const uint8_t*)outputBuffer.data(), outputBuffer.size() * sizeof(int16_t));
+            }
+            
+            free(audioBufferList);
+            if (blockBuffer) CFRelease(blockBuffer);
+        } else {
+            // Interleaved audio: original code path
+            CMBlockBufferRef blockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer);
+            if (!blockBuffer) return;
+
+            size_t totalLength = 0;
+            char *dataPointer = NULL;
+            OSStatus status = CMBlockBufferGetDataPointer(blockBuffer, 0, NULL, &totalLength, &dataPointer);
+            
+            if (status != kCMBlockBufferNoErr || !dataPointer) return;
+
+            // ScreenCaptureKit outputs 32-bit float audio
+            // Convert to 16-bit signed integer PCM for consistency with other sources
+            if (isFloat && asbd->mBitsPerChannel == 32) {
+                size_t numSamples = totalLength / sizeof(float);
+                std::vector<int16_t> outputBuffer(numSamples);
+                
+                const float *floatData = (const float *)dataPointer;
+                for (size_t i = 0; i < numSamples; i++) {
+                    float sample = floatData[i];
+                    // Clamp to [-1.0, 1.0]
+                    if (sample > 1.0f) sample = 1.0f;
+                    if (sample < -1.0f) sample = -1.0f;
+                    // Convert to 16-bit
+                    outputBuffer[i] = (int16_t)(sample * 32767.0f);
+                }
+                
+                self.dataCallback((const uint8_t*)outputBuffer.data(), numSamples * sizeof(int16_t));
+            }
+        }
+    }
+}
+
+// SCStreamDelegate method
+- (void)stream:(SCStream *)stream didStopWithError:(NSError *)error {
+    if (@available(macOS 12.3, *)) {
+        if (error && self.errorCallback) {
+            self.errorCallback("Stream stopped with error: " + std::string(error.localizedDescription.UTF8String));
+        }
+    }
+}
+
+@end

package/native/main.cpp

@@ -0,0 +1,9 @@
+#include "AudioController.h"
+#include <napi.h>
+
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  return AudioController::Init(env, exports);
+}
+
+NODE_API_MODULE(native_audio_sdk, Init)