electron-native-screenshare 1.0.0

package/src/mac/coreaudio_capture.mm

@@ -0,0 +1,267 @@
+/**
+ * macOS Audio Capture via ScreenCaptureKit (macOS 13 Ventura+)
+ *
+ * Process-level audio isolation using SCStream:
+ * - Include mode: SCContentFilter with includingApplications → only target app audio
+ * - Exclude mode: SCContentFilter with excludingApplications → all audio except target
+ *
+ * Audio is delivered as raw PCM float32, stereo, 48kHz — matching the Windows WASAPI output.
+ */
+
+#import <ScreenCaptureKit/ScreenCaptureKit.h>
+#import <CoreMedia/CoreMedia.h>
+#import <AudioToolbox/AudioToolbox.h>
+#import <Foundation/Foundation.h>
+#include "coreaudio_capture.h"
+#include <dispatch/dispatch.h>
+#include <iostream>
+#include <thread>
+
+// --- SCStream delegate that forwards audio samples to the C++ callback ---
+
+@interface AudioStreamDelegate : NSObject <SCStreamOutput, SCStreamDelegate>
+@property (nonatomic, assign) CoreAudioCapture::DataCallback dataCallback;
+@property (nonatomic, assign) std::atomic<bool>* isCapturingRef;
+@end
+
+@implementation AudioStreamDelegate
+
+- (void)stream:(SCStream *)stream didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer ofType:(SCStreamOutputType)type {
+    if (type != SCStreamOutputTypeAudio) return;
+    if (!self.isCapturingRef || !self.isCapturingRef->load()) return;
+    if (!self.dataCallback) return;
+
+    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 || totalLength == 0) return;
+
+    // Extract format from the sample buffer
+    CMFormatDescriptionRef formatDesc = CMSampleBufferGetFormatDescription(sampleBuffer);
+    const AudioStreamBasicDescription* asbd = CMAudioFormatDescriptionGetStreamBasicDescription(formatDesc);
+
+    CoreAudioCapture::AudioMetadata meta;
+    meta.sampleRate = (uint32_t)asbd->mSampleRate;
+    meta.channels = (uint16_t)asbd->mChannelsPerFrame;
+    meta.bitsPerSample = (uint16_t)asbd->mBitsPerChannel;
+    meta.isFloat = (asbd->mFormatFlags & kAudioFormatFlagIsFloat) != 0;
+
+    self.dataCallback((const uint8_t*)dataPointer, totalLength, meta);
+}
+
+- (void)stream:(SCStream *)stream didStopWithError:(NSError *)error {
+    if (error) {
+        std::cerr << "[electron-native-screenshare] SCStream stopped with error: "
+                  << error.localizedDescription.UTF8String << std::endl;
+    }
+}
+
+@end
+
+// --- Pimpl implementation ---
+
+struct CoreAudioCapture::Impl {
+    SCStream* stream = nil;
+    AudioStreamDelegate* delegate = nil;
+    dispatch_queue_t captureQueue = nil;
+    uint32_t targetPid = 0;
+    bool includeMode = false;
+};
+
+CoreAudioCapture::CoreAudioCapture() : pImpl(new Impl()) {
+    pImpl->captureQueue = dispatch_queue_create("com.electron-native-screenshare.audio", DISPATCH_QUEUE_SERIAL);
+}
+
+CoreAudioCapture::~CoreAudioCapture() {
+    Stop();
+    if (pImpl) {
+        if (pImpl->delegate) {
+            pImpl->delegate = nil;
+        }
+        if (pImpl->captureQueue) {
+            pImpl->captureQueue = nil;
+        }
+        delete pImpl;
+        pImpl = nullptr;
+    }
+}
+
+int CoreAudioCapture::Initialize(uint32_t processId, bool isIncludeMode, std::string& outError) {
+    pImpl->targetPid = processId;
+    pImpl->includeMode = isIncludeMode;
+
+    __block int result = 0;
+    __block std::string blockError;
+
+    // ScreenCaptureKit requires async content enumeration — bridge to sync with semaphore
+    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
+
+    [SCShareableContent getShareableContentExcludingDesktopWindows:NO
+                                              onScreenWindowsOnly:NO
+                                                completionHandler:^(SCShareableContent* _Nullable content, NSError* _Nullable error) {
+        if (error || !content) {
+            blockError = error ? std::string(error.localizedDescription.UTF8String)
+                               : "Failed to get shareable content";
+            result = -1;
+            dispatch_semaphore_signal(sema);
+            return;
+        }
+
+        // Find the target application by PID
+        SCRunningApplication* targetApp = nil;
+        for (SCRunningApplication* app in content.applications) {
+            if (app.processID == (pid_t)processId) {
+                targetApp = app;
+                break;
+            }
+        }
+
+        if (!targetApp) {
+            blockError = "Target process not found in running applications (PID: "
+                         + std::to_string(processId) + ")";
+            result = -2;
+            dispatch_semaphore_signal(sema);
+            return;
+        }
+
+        // Build content filter
+        SCContentFilter* filter = nil;
+        SCDisplay* primaryDisplay = content.displays.firstObject;
+        if (!primaryDisplay) {
+            blockError = "No display found for content filter";
+            result = -3;
+            dispatch_semaphore_signal(sema);
+            return;
+        }
+
+        if (isIncludeMode) {
+            // Include mode: capture ONLY the target app's audio
+            filter = [[SCContentFilter alloc] initWithDisplay:primaryDisplay
+                                        includingApplications:@[targetApp]
+                                             exceptingWindows:@[]];
+        } else {
+            // Exclude mode: capture everything EXCEPT the target app
+            filter = [[SCContentFilter alloc] initWithDisplay:primaryDisplay
+                                       excludingApplications:@[targetApp]
+                                            exceptingWindows:@[]];
+        }
+
+        // Configure for audio capture (48kHz stereo float32, matching Windows WASAPI output)
+        SCStreamConfiguration* config = [[SCStreamConfiguration alloc] init];
+        config.capturesAudio = YES;
+        config.excludesCurrentProcessAudio = NO; // handled by the filter
+        config.sampleRate = 48000;
+        config.channelCount = 2;
+
+        // Minimize video overhead — we only need audio
+        config.width = 2;
+        config.height = 2;
+        config.minimumFrameInterval = CMTimeMake(1, 1); // 1 fps minimum
+
+        // Create the stream
+        pImpl->stream = [[SCStream alloc] initWithFilter:filter
+                                                 configuration:config
+                                                      delegate:nil];
+
+        dispatch_semaphore_signal(sema);
+    }];
+
+    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
+
+    if (result != 0) {
+        outError = blockError;
+    }
+    return result;
+}
+
+void CoreAudioCapture::Start(DataCallback callback) {
+    if (isCapturing.load() || !pImpl->stream) return;
+
+    onData = callback;
+    isCapturing.store(true);
+
+    // Set up the delegate
+    pImpl->delegate = [[AudioStreamDelegate alloc] init];
+    pImpl->delegate.dataCallback = onData;
+    pImpl->delegate.isCapturingRef = &isCapturing;
+
+    NSError* addOutputError = nil;
+    [pImpl->stream addStreamOutput:pImpl->delegate
+                              type:SCStreamOutputTypeAudio
+                sampleHandlerQueue:pImpl->captureQueue
+                             error:&addOutputError];
+
+    if (addOutputError) {
+        std::cerr << "[electron-native-screenshare] Failed to add stream output: "
+                  << addOutputError.localizedDescription.UTF8String << std::endl;
+        isCapturing.store(false);
+        return;
+    }
+
+    dispatch_semaphore_t startSema = dispatch_semaphore_create(0);
+    __block bool startSuccess = false;
+
+    [pImpl->stream startCaptureWithCompletionHandler:^(NSError* _Nullable error) {
+        if (error) {
+            std::cerr << "[electron-native-screenshare] SCStream start failed: "
+                      << error.localizedDescription.UTF8String << std::endl;
+        } else {
+            startSuccess = true;
+        }
+        dispatch_semaphore_signal(startSema);
+    }];
+
+    dispatch_semaphore_wait(startSema, DISPATCH_TIME_FOREVER);
+
+    if (!startSuccess) {
+        isCapturing.store(false);
+    }
+}
+
+void CoreAudioCapture::Stop() {
+    if (!isCapturing.load()) return;
+    isCapturing.store(false);
+
+    if (pImpl->stream) {
+        dispatch_semaphore_t stopSema = dispatch_semaphore_create(0);
+        [pImpl->stream stopCaptureWithCompletionHandler:^(NSError* _Nullable error) {
+            dispatch_semaphore_signal(stopSema);
+        }];
+        dispatch_semaphore_wait(stopSema, dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC));
+        pImpl->stream = nil;
+    }
+    pImpl->delegate = nil;
+}
+
+// --- getPidFromWindowId using CGWindowListCopyWindowInfo ---
+
+uint32_t getPidFromWindowId(uint32_t windowId) {
+    CFArrayRef windowList = CGWindowListCopyWindowInfo(
+        kCGWindowListOptionIncludingWindow, (CGWindowID)windowId);
+
+    if (!windowList) return 0;
+
+    uint32_t pid = 0;
+    CFIndex count = CFArrayGetCount(windowList);
+    for (CFIndex i = 0; i < count; i++) {
+        CFDictionaryRef windowInfo = (CFDictionaryRef)CFArrayGetValueAtIndex(windowList, i);
+
+        CFNumberRef windowNumber = (CFNumberRef)CFDictionaryGetValue(windowInfo, kCGWindowNumber);
+        int wid = 0;
+        CFNumberGetValue(windowNumber, kCFNumberIntType, &wid);
+
+        if ((uint32_t)wid == windowId) {
+            CFNumberRef ownerPid = (CFNumberRef)CFDictionaryGetValue(windowInfo, kCGWindowOwnerPID);
+            int p = 0;
+            CFNumberGetValue(ownerPid, kCFNumberIntType, &p);
+            pid = (uint32_t)p;
+            break;
+        }
+    }
+
+    CFRelease(windowList);
+    return pid;
+}

package/src/win/addon.cpp

@@ -0,0 +1,136 @@
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0A00
+#undef NTDDI_VERSION
+#define NTDDI_VERSION 0x0A00000A
+
+#include <napi.h>
+#include "wasapi_capture.h"
+
+WasapiCapture capture;
+
+Napi::ThreadSafeFunction tsfn;
+
+Napi::Value StartCapture(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    
+    DWORD processId = 0;
+    if (info.Length() > 0 && info[0].IsNumber()) {
+        processId = info[0].As<Napi::Number>().Uint32Value();
+    }
+
+    bool isIncludeMode = false;
+    if (info.Length() > 1 && info[1].IsBoolean()) {
+        isIncludeMode = info[1].As<Napi::Boolean>().Value();
+    }
+
+    if (info.Length() < 3 || !info[2].IsFunction()) {
+        Napi::TypeError::New(env, "Callback function expected as third argument").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    std::string errorMsg;
+    HRESULT hr = capture.Initialize(processId, isIncludeMode, errorMsg);
+    if (FAILED(hr) || !errorMsg.empty()) {
+        char buf[256];
+        snprintf(buf, sizeof(buf), "WASAPI Init Failed: %s (HRESULT: 0x%08lX)", errorMsg.c_str(), hr);
+        Napi::TypeError::New(env, buf).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    tsfn = Napi::ThreadSafeFunction::New(
+        env,
+        info[2].As<Napi::Function>(),
+        "WASAPICaptureCallback",
+        0,
+        1
+    );
+
+    auto callback = [](const uint8_t* data, size_t length, WasapiCapture::AudioMetadata metadata) {
+        if (!tsfn) return;
+        
+        struct Payload {
+            std::vector<uint8_t> buffer;
+            WasapiCapture::AudioMetadata meta;
+        };
+        auto* payload = new Payload{ std::vector<uint8_t>(data, data + length), metadata };
+        
+        auto napiCallback = [](Napi::Env env, Napi::Function jsCallback, Payload* p) {
+            Napi::Object metaObj = Napi::Object::New(env);
+            metaObj.Set("sampleRate", p->meta.sampleRate);
+            metaObj.Set("channels", p->meta.channels);
+            metaObj.Set("bitsPerSample", p->meta.bitsPerSample);
+            metaObj.Set("isFloat", p->meta.isFloat);
+
+            Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(env, p->buffer.data(), p->buffer.size());
+            jsCallback.Call({ buffer, metaObj });
+            delete p;
+        };
+        
+        tsfn.NonBlockingCall(payload, napiCallback);
+    };
+
+    capture.Start(callback);
+    return Napi::Boolean::New(env, true);
+}
+
+Napi::Value StopCapture(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    capture.Stop();
+    if (tsfn) {
+        tsfn.Release();
+        tsfn = nullptr;
+    }
+    return Napi::Boolean::New(env, true);
+}
+
+struct EnumUWPData {
+    DWORD pid;
+    bool found;
+};
+
+BOOL CALLBACK EnumChildProc(HWND hwnd, LPARAM lParam) {
+    char className[256];
+    if (GetClassNameA(hwnd, className, sizeof(className))) {
+        if (strcmp(className, "Windows.UI.Core.CoreWindow") == 0) {
+            EnumUWPData* data = (EnumUWPData*)lParam;
+            GetWindowThreadProcessId(hwnd, &data->pid);
+            data->found = true;
+            return FALSE; // Stop enumeration
+        }
+    }
+    return TRUE;
+}
+
+Napi::Value GetPidFromHwnd(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsNumber()) {
+        Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    HWND hwnd = (HWND)(uintptr_t)info[0].As<Napi::Number>().Uint32Value();
+    DWORD pid = 0;
+    GetWindowThreadProcessId(hwnd, &pid);
+
+    // Optimization & Fix: If the window is a UWP ApplicationFrameWindow, the actual media process is a child window.
+    char className[256];
+    if (GetClassNameA(hwnd, className, sizeof(className))) {
+        if (strcmp(className, "ApplicationFrameWindow") == 0) {
+            EnumUWPData data = { pid, false };
+            EnumChildWindows(hwnd, EnumChildProc, (LPARAM)&data);
+            if (data.found) {
+                pid = data.pid;
+            }
+        }
+    }
+
+    return Napi::Number::New(env, pid);
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    exports.Set(Napi::String::New(env, "startCapture"), Napi::Function::New(env, StartCapture));
+    exports.Set(Napi::String::New(env, "stopCapture"), Napi::Function::New(env, StopCapture));
+    exports.Set(Napi::String::New(env, "getPidFromHwnd"), Napi::Function::New(env, GetPidFromHwnd));
+    return exports;
+}
+
+NODE_API_MODULE(topluyo_capture, Init)

package/src/win/wasapi_capture.cpp

@@ -0,0 +1,223 @@
+#include "wasapi_capture.h"
+#include <iostream>
+
+#pragma comment(lib, "Mmdevapi.lib")
+
+WasapiCapture::WasapiCapture() {}
+
+WasapiCapture::~WasapiCapture() {
+    Stop();
+    if (pCaptureClient) pCaptureClient->Release();
+    if (pAudioClient) pAudioClient->Release();
+    if (pDevice) pDevice->Release();
+}
+
+#include <objidl.h>
+
+#ifndef VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK
+#define VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK L"VAD\\Process_Loopback"
+#endif
+
+// Define IAgileObject IID manually in case it's missing in some SDKs
+static const IID IID_IAgileObject_Manual = { 0x94ea2b94, 0xe9cc, 0x49e0, { 0xc0, 0xff, 0xee, 0x64, 0xca, 0x8f, 0x5b, 0x90 } };
+
+class AudioInterfaceCompletionHandler : public IActivateAudioInterfaceCompletionHandler, public IAgileObject {
+    LONG m_cRef;
+    HANDLE m_hEvent;
+    IAudioClient** m_ppAudioClient;
+    IUnknown* m_pUnkFTM;
+public:
+    AudioInterfaceCompletionHandler(HANDLE hEvent, IAudioClient** ppAudioClient)
+        : m_cRef(1), m_hEvent(hEvent), m_ppAudioClient(ppAudioClient), m_pUnkFTM(nullptr) {
+        IUnknown* pUnkThis = static_cast<IActivateAudioInterfaceCompletionHandler*>(this);
+        CoCreateFreeThreadedMarshaler(pUnkThis, &m_pUnkFTM);
+    }
+
+    ~AudioInterfaceCompletionHandler() {
+        if (m_pUnkFTM) {
+            m_pUnkFTM->Release();
+        }
+    }
+
+    ULONG STDMETHODCALLTYPE AddRef() { return InterlockedIncrement(&m_cRef); }
+    ULONG STDMETHODCALLTYPE Release() {
+        ULONG ulRef = InterlockedDecrement(&m_cRef);
+        if (0 == ulRef) { delete this; }
+        return ulRef;
+    }
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void** ppvInterface) {
+        if (riid == __uuidof(IUnknown) || riid == __uuidof(IActivateAudioInterfaceCompletionHandler)) {
+            *ppvInterface = static_cast<IActivateAudioInterfaceCompletionHandler*>(this);
+            AddRef();
+            return S_OK;
+        }
+        if (riid == IID_IAgileObject_Manual || riid == __uuidof(IAgileObject)) {
+            *ppvInterface = static_cast<IAgileObject*>(this);
+            AddRef();
+            return S_OK;
+        }
+        if (riid == __uuidof(IMarshal) && m_pUnkFTM != nullptr) {
+            return m_pUnkFTM->QueryInterface(riid, ppvInterface);
+        }
+        *ppvInterface = NULL;
+        return E_NOINTERFACE;
+    }
+    HRESULT STDMETHODCALLTYPE ActivateCompleted(IActivateAudioInterfaceAsyncOperation* operation) {
+        HRESULT hrActivateResult = S_OK;
+        IUnknown* punkAudioInterface = NULL;
+        HRESULT hr = operation->GetActivateResult(&hrActivateResult, &punkAudioInterface);
+        if (FAILED(hr) || FAILED(hrActivateResult) || punkAudioInterface == NULL) {
+            printf("[NativeCapture] ActivateCompleted FAILED! hr=0x%08lX, hrActivateResult=0x%08lX, punk=%p\n", hr, hrActivateResult, punkAudioInterface);
+        }
+        if (SUCCEEDED(hr) && SUCCEEDED(hrActivateResult) && punkAudioInterface != NULL) {
+            punkAudioInterface->QueryInterface(__uuidof(IAudioClient), (void**)m_ppAudioClient);
+            punkAudioInterface->Release();
+        }
+        SetEvent(m_hEvent);
+        return S_OK;
+    }
+};
+
+#include <thread>
+
+HRESULT WasapiCapture::Initialize(DWORD processId, bool isIncludeMode, std::string& outError) {
+    HRESULT finalHr = S_OK;
+
+    // Electron's main thread is an STA. ActivateAudioInterfaceAsync strictly requires an MTA thread.
+    // If called on an STA, it throws E_ILLEGAL_METHOD_CALL. We bypass this by spawning an MTA worker.
+    std::thread initThread([&]() {
+        HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+        
+        AUDIOCLIENT_ACTIVATION_PARAMS activationParams = {};
+        activationParams.ActivationType = AUDIOCLIENT_ACTIVATION_TYPE_PROCESS_LOOPBACK;
+        activationParams.ProcessLoopbackParams.TargetProcessId = processId;
+        activationParams.ProcessLoopbackParams.ProcessLoopbackMode = isIncludeMode ? PROCESS_LOOPBACK_MODE_INCLUDE_TARGET_PROCESS_TREE : PROCESS_LOOPBACK_MODE_EXCLUDE_TARGET_PROCESS_TREE;
+
+        PROPVARIANT activateParams;
+        PropVariantInit(&activateParams);
+        activateParams.vt = VT_BLOB;
+        activateParams.blob.cbSize = sizeof(activationParams);
+        activateParams.blob.pBlobData = (BYTE*)&activationParams;
+
+        HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+        AudioInterfaceCompletionHandler* pHandler = new AudioInterfaceCompletionHandler(hEvent, &pAudioClient);
+        
+        IActivateAudioInterfaceAsyncOperation* asyncOp = nullptr;
+        hr = ActivateAudioInterfaceAsync(VIRTUAL_AUDIO_DEVICE_PROCESS_LOOPBACK, __uuidof(IAudioClient), &activateParams, pHandler, &asyncOp);
+        
+        if (FAILED(hr)) {
+            outError = "ActivateAudioInterfaceAsync failed synchronously";
+            finalHr = hr;
+        } else {
+            WaitForSingleObject(hEvent, INFINITE);
+            if (asyncOp) asyncOp->Release();
+        }
+        
+        CloseHandle(hEvent);
+        pHandler->Release();
+
+        if (SUCCEEDED(finalHr)) {
+            if (!pAudioClient) {
+                outError = "pAudioClient is NULL after Wait";
+                finalHr = E_FAIL;
+            } else {
+                WAVEFORMATEXTENSIBLE wfx = {};
+                wfx.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
+                wfx.Format.nChannels = 2;
+                wfx.Format.nSamplesPerSec = 48000;
+                wfx.Format.wBitsPerSample = 32;
+                wfx.Format.nBlockAlign = (wfx.Format.nChannels * wfx.Format.wBitsPerSample) / 8;
+                wfx.Format.nAvgBytesPerSec = wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign;
+                wfx.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
+                wfx.Samples.wValidBitsPerSample = 32;
+                wfx.dwChannelMask = 3; // SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT
+                
+                static const GUID SUBTYPE_IEEE_FLOAT_GUID = { 0x00000003, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 } };
+                wfx.SubFormat = SUBTYPE_IEEE_FLOAT_GUID;
+
+                // Process loopback requires AUDCLNT_STREAMFLAGS_LOOPBACK and AUDCLNT_STREAMFLAGS_EVENTCALLBACK
+                // We use AUTOCONVERTPCM to let Windows resample if needed
+                // Note: AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY causes AUDCLNT_E_INVALID_STREAM_FLAG (0x88890021)
+                DWORD streamFlags = AUDCLNT_STREAMFLAGS_LOOPBACK | AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM;
+
+                hr = pAudioClient->Initialize(AUDCLNT_SHAREMODE_SHARED,
+                                              streamFlags,
+                                              0, 0, (WAVEFORMATEX*)&wfx, NULL);
+                if (FAILED(hr)) {
+                    outError = "IAudioClient::Initialize failed";
+                    finalHr = hr;
+                } else {
+                    hr = pAudioClient->GetService(__uuidof(IAudioCaptureClient), (void**)&pCaptureClient);
+                    if (FAILED(hr)) {
+                        outError = "GetService(IAudioCaptureClient) failed";
+                        finalHr = hr;
+                    }
+                }
+            }
+        }
+        CoUninitialize();
+    });
+
+    initThread.join();
+    return finalHr;
+}
+
+void WasapiCapture::Start(DataCallback callback) {
+    if (isCapturing || !pAudioClient) return;
+    onData = callback;
+    isCapturing = true;
+    hCaptureThread = CreateThread(NULL, 0, CaptureThreadProc, this, 0, NULL);
+}
+
+void WasapiCapture::Stop() {
+    isCapturing = false;
+    if (hCaptureThread) {
+        WaitForSingleObject(hCaptureThread, INFINITE);
+        CloseHandle(hCaptureThread);
+        hCaptureThread = nullptr;
+    }
+}
+
+DWORD WINAPI WasapiCapture::CaptureThreadProc(LPVOID pContext) {
+    WasapiCapture* pThis = static_cast<WasapiCapture*>(pContext);
+    pThis->CaptureLoop();
+    return 0;
+}
+
+void WasapiCapture::CaptureLoop() {
+    HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
+    HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    pAudioClient->SetEventHandle(hEvent);
+    pAudioClient->Start();
+
+    while (isCapturing) {
+        DWORD waitResult = WaitForSingleObject(hEvent, 100);
+        if (waitResult == WAIT_OBJECT_0) {
+            UINT32 packetLength = 0;
+            pCaptureClient->GetNextPacketSize(&packetLength);
+            while (packetLength != 0) {
+                BYTE* pData;
+                UINT32 numFramesAvailable;
+                DWORD flags;
+                pCaptureClient->GetBuffer(&pData, &numFramesAvailable, &flags, NULL, NULL);
+
+                // Here we push pData to the callback
+                if (onData && pData) {
+                    size_t bytesPerFrame = 8; // 2 channels * 4 bytes
+                    
+                    AudioMetadata meta;
+                    meta.sampleRate = 48000;
+                    meta.channels = 2;
+                    meta.bitsPerSample = 32;
+                    meta.isFloat = true;
+                    onData(pData, numFramesAvailable * bytesPerFrame, meta);
+                }
+                pCaptureClient->ReleaseBuffer(numFramesAvailable);
+                pCaptureClient->GetNextPacketSize(&packetLength);
+            }
+        }
+    }
+    pAudioClient->Stop();
+    CloseHandle(hEvent);
+    CoUninitialize();
+}

package/src/win/wasapi_capture.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0A00
+#undef NTDDI_VERSION
+#define NTDDI_VERSION 0x0A00000A
+
+#include <windows.h>
+#include <mmdeviceapi.h>
+#include <Audioclient.h>
+#include <audioclientactivationparams.h>
+#include <functional>
+#include <functional>
+#include <vector>
+#include <string>
+#include <thread>
+
+class WasapiCapture {
+public:
+    struct AudioMetadata {
+        uint32_t sampleRate;
+        uint16_t channels;
+        uint16_t bitsPerSample;
+        bool isFloat;
+    };
+    using DataCallback = std::function<void(const uint8_t* data, size_t length, AudioMetadata metadata)>;
+
+    WasapiCapture();
+    ~WasapiCapture();
+
+    HRESULT Initialize(DWORD processId, bool isIncludeMode, std::string& outError);
+    void Start(DataCallback callback);
+    void Stop();
+
+private:
+    IMMDevice* pDevice = nullptr;
+    IAudioClient* pAudioClient = nullptr;
+    IAudioCaptureClient* pCaptureClient = nullptr;
+    HANDLE hCaptureThread = nullptr;
+    bool isCapturing = false;
+    DataCallback onData;
+
+    static DWORD WINAPI CaptureThreadProc(LPVOID pContext);
+    void CaptureLoop();
+};