@0biwank/screen-capture 1.0.1 → 2.0.1

package/src/addon.cpp

@@ -0,0 +1,347 @@
+#include "DesktopCapturer.h"
+#include "CameraCapturer.h"
+#include "SourceHelperWrapper.h"
+#include <napi.h>
+#include <atomic>
+#include <memory>
+#include <vector>
+
+#ifdef __APPLE__
+#include <CoreAudio/CoreAudio.h>
+#include <CoreFoundation/CoreFoundation.h>
+#endif
+
+static std::unique_ptr<DesktopCapturer> g_capturer;
+static std::string g_last_error;
+static Napi::ThreadSafeFunction g_segment_ready_tsfn;
+static std::atomic<bool> g_has_segment_ready_tsfn{false};
+
+static void releaseSegmentReadyCallback()
+{
+    if (g_has_segment_ready_tsfn.exchange(false))
+    {
+        g_segment_ready_tsfn.Release();
+        g_segment_ready_tsfn = Napi::ThreadSafeFunction();
+    }
+}
+
+#ifdef __APPLE__
+static std::string cfStringToUtf8(CFStringRef value)
+{
+    if (!value)
+        return {};
+    char buffer[1024] = {0};
+    if (CFStringGetCString(value, buffer, sizeof(buffer), kCFStringEncodingUTF8))
+    {
+        return buffer;
+    }
+    return {};
+}
+
+static std::string getDeviceString(AudioDeviceID device, AudioObjectPropertySelector selector)
+{
+    AudioObjectPropertyAddress addr = {
+        selector,
+        kAudioObjectPropertyScopeGlobal,
+        kAudioObjectPropertyElementMain};
+    CFStringRef value = nullptr;
+    UInt32 size = sizeof(value);
+    OSStatus status = AudioObjectGetPropertyData(device, &addr, 0, nullptr, &size, &value);
+    if (status != noErr || !value)
+        return {};
+    std::string out = cfStringToUtf8(value);
+    CFRelease(value);
+    return out;
+}
+
+static bool hasInputChannels(AudioDeviceID device)
+{
+    AudioObjectPropertyAddress addr = {
+        kAudioDevicePropertyStreamConfiguration,
+        kAudioObjectPropertyScopeInput,
+        kAudioObjectPropertyElementMain};
+
+    UInt32 size = 0;
+    OSStatus status = AudioObjectGetPropertyDataSize(device, &addr, 0, nullptr, &size);
+    if (status != noErr || size == 0)
+        return false;
+
+    std::vector<uint8_t> storage(size);
+    auto *buffers = reinterpret_cast<AudioBufferList *>(storage.data());
+    status = AudioObjectGetPropertyData(device, &addr, 0, nullptr, &size, buffers);
+    if (status != noErr)
+        return false;
+
+    for (UInt32 i = 0; i < buffers->mNumberBuffers; ++i)
+    {
+        if (buffers->mBuffers[i].mNumberChannels > 0)
+            return true;
+    }
+    return false;
+}
+#endif
+
+Napi::Value startCapture(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+
+    CaptureOptions opts;
+
+    if (info.Length() >= 1 && info[0].IsObject())
+    {
+        Napi::Object o = info[0].As<Napi::Object>();
+        auto get_u32 = [&](const char *key, uint32_t def) -> uint32_t
+        {
+            if (o.Has(key) && o.Get(key).IsNumber())
+                return o.Get(key).As<Napi::Number>().Uint32Value();
+            return def;
+        };
+        auto get_bool = [&](const char *key, bool def) -> bool
+        {
+            if (o.Has(key) && o.Get(key).IsBoolean())
+                return o.Get(key).As<Napi::Boolean>().Value();
+            return def;
+        };
+        auto get_str = [&](const char *key) -> std::string
+        {
+            if (o.Has(key) && o.Get(key).IsString())
+                return o.Get(key).As<Napi::String>().Utf8Value();
+            return {};
+        };
+
+        opts.display_id = get_u32("displayId", 0);
+        opts.capture_window = get_bool("captureWindow", false);
+        opts.window_id = get_u32("windowId", 0);
+        opts.no_screen = get_bool("noScreen", false);
+        
+        opts.camera = get_bool("camera", false);
+        opts.camera_device_uid = get_str("cameraDeviceUid");
+
+        opts.width = get_u32("width", 1920);
+        opts.height = get_u32("height", 1080);
+        opts.fps = get_u32("fps", 30);
+        opts.gop_size = get_u32("gopSize", opts.fps);
+        opts.video_bitrate = get_u32("videoBitrate", 9'000'000);
+        opts.crop_x = get_u32("cropX", 0);
+        opts.crop_y = get_u32("cropY", 0);
+        opts.crop_width = get_u32("cropWidth", 0);
+        opts.crop_height = get_u32("cropHeight", 0);
+        opts.crop_enabled = opts.crop_width > 0 && opts.crop_height > 0;
+        
+        opts.system_audio = get_bool("systemAudio", true);
+        opts.microphone = get_bool("microphone", false);
+        opts.mic_device_uid = get_str("micDeviceUid");
+        opts.sample_rate = get_u32("sampleRate", 48000);
+        opts.audio_bitrate = get_u32("audioBitrate", 128'000);
+        opts.channels = 2;
+
+        opts.output_dir = get_str("outputDir");
+        opts.recording_id = get_str("recordingId");
+        opts.segment_time_sec = get_u32("segmentTime", 4);
+    }
+
+    if (g_capturer)
+    {
+        g_capturer->stopCapture();
+        g_capturer.reset();
+    }
+
+    g_capturer = std::make_unique<DesktopCapturer>();
+
+    g_last_error.clear();
+
+    bool ok = g_capturer->startCapture(opts, [](const std::string &full_path) {
+        if (!g_has_segment_ready_tsfn.load())
+            return;
+
+        auto *payload = new std::string(full_path);
+        napi_status status = g_segment_ready_tsfn.NonBlockingCall(
+            payload,
+            [](Napi::Env env, Napi::Function callback, std::string *path) {
+                callback.Call({Napi::String::New(env, *path)});
+                delete path;
+            });
+
+        if (status != napi_ok)
+        {
+            delete payload;
+        }
+    });
+
+    if (!ok)
+    {
+        g_last_error = g_capturer->lastError();
+        g_capturer.reset();
+    }
+
+    return Napi::Boolean::New(env, ok);
+}
+
+Napi::Value listVideoInputDevices(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    auto cameras = CameraCapturer::listDevices();
+    Napi::Array arr = Napi::Array::New(env, cameras.size());
+    for (size_t i = 0; i < cameras.size(); ++i)
+    {
+        Napi::Object c = Napi::Object::New(env);
+        c.Set("uid", Napi::String::New(env, cameras[i].uid));
+        c.Set("name", Napi::String::New(env, cameras[i].name));
+        arr.Set(static_cast<uint32_t>(i), c);
+    }
+    return arr;
+}
+
+Napi::Value getLastError(const Napi::CallbackInfo &info)
+{
+    return Napi::String::New(info.Env(), g_last_error);
+}
+
+Napi::Value setSegmentReadyCallback(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    releaseSegmentReadyCallback();
+
+    if (info.Length() < 1 || info[0].IsNull() || info[0].IsUndefined())
+    {
+        return env.Undefined();
+    }
+
+    if (!info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "setSegmentReadyCallback expects a function").ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+
+    g_segment_ready_tsfn = Napi::ThreadSafeFunction::New(
+        env,
+        info[0].As<Napi::Function>(),
+        "NativeSegmentReadyCallback",
+        256,
+        1);
+    g_has_segment_ready_tsfn.store(true);
+
+    return env.Undefined();
+}
+
+Napi::Value pauseCapture(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!g_capturer) return Napi::Boolean::New(env, false);
+    return Napi::Boolean::New(env, g_capturer->pauseCapture());
+}
+
+Napi::Value resumeCapture(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!g_capturer) return Napi::Boolean::New(env, false);
+    return Napi::Boolean::New(env, g_capturer->resumeCapture());
+}
+
+Napi::Value stopCapture(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!g_capturer) return Napi::Boolean::New(env, false);
+    bool ok = g_capturer->stopCapture();
+    g_capturer.reset();
+    releaseSegmentReadyCallback();
+    return Napi::Boolean::New(env, ok);
+}
+
+Napi::Value listDisplaySources(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    auto displays = SourceHelperWrapper::getDisplaySources();
+
+    Napi::Array arr = Napi::Array::New(env, displays.size());
+    for (size_t i = 0; i < displays.size(); ++i)
+    {
+        Napi::Object d = Napi::Object::New(env);
+        d.Set("id", Napi::Number::New(env, displays[i].id));
+        d.Set("name", Napi::String::New(env, std::to_string(displays[i].id)));
+        d.Set("isMain", Napi::Boolean::New(env, displays[i].isMain));
+        d.Set("width", Napi::Number::New(env, displays[i].width));
+        d.Set("height", Napi::Number::New(env, displays[i].height));
+        arr.Set(static_cast<uint32_t>(i), d);
+    }
+    return arr;
+}
+
+Napi::Value listWindowSources(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    auto windows = SourceHelperWrapper::getWindowSources();
+
+    Napi::Array arr = Napi::Array::New(env, windows.size());
+    for (size_t i = 0; i < windows.size(); ++i)
+    {
+        Napi::Object w = Napi::Object::New(env);
+        w.Set("id", Napi::Number::New(env, windows[i].id));
+        w.Set("name", Napi::String::New(env, windows[i].title));
+        arr.Set(static_cast<uint32_t>(i), w);
+    }
+    return arr;
+}
+
+Napi::Value listAudioInputDevices(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    Napi::Array arr = Napi::Array::New(env);
+
+#ifdef __APPLE__
+    AudioObjectPropertyAddress addr = {
+        kAudioHardwarePropertyDevices,
+        kAudioObjectPropertyScopeGlobal,
+        kAudioObjectPropertyElementMain};
+
+    UInt32 data_size = 0;
+    OSStatus status = AudioObjectGetPropertyDataSize(
+        kAudioObjectSystemObject, &addr, 0, nullptr, &data_size);
+    if (status != noErr || data_size == 0)
+        return arr;
+
+    std::vector<AudioDeviceID> devices(data_size / sizeof(AudioDeviceID));
+    status = AudioObjectGetPropertyData(
+        kAudioObjectSystemObject, &addr, 0, nullptr, &data_size, devices.data());
+    if (status != noErr)
+        return arr;
+
+    uint32_t index = 0;
+    for (AudioDeviceID device : devices)
+    {
+        if (!hasInputChannels(device))
+            continue;
+
+        const std::string uid = getDeviceString(device, kAudioDevicePropertyDeviceUID);
+        if (uid.empty())
+            continue;
+
+        Napi::Object d = Napi::Object::New(env);
+        d.Set("uid", Napi::String::New(env, uid));
+        d.Set("name", Napi::String::New(env, getDeviceString(device, kAudioObjectPropertyName)));
+        d.Set(
+            "manufacturer",
+            Napi::String::New(env, getDeviceString(device, kAudioObjectPropertyManufacturer)));
+        arr.Set(index++, d);
+    }
+#endif
+
+    return arr;
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+    exports.Set("startCapture", Napi::Function::New(env, startCapture));
+    exports.Set("stopCapture", Napi::Function::New(env, stopCapture));
+    exports.Set("setSegmentReadyCallback", Napi::Function::New(env, setSegmentReadyCallback));
+    exports.Set("getLastError", Napi::Function::New(env, getLastError));
+    exports.Set("listDisplaySources", Napi::Function::New(env, listDisplaySources));
+    exports.Set("listWindowSources", Napi::Function::New(env, listWindowSources));
+    exports.Set("listAudioInputDevices", Napi::Function::New(env, listAudioInputDevices));
+    exports.Set("listVideoInputDevices", Napi::Function::New(env, listVideoInputDevices));
+    exports.Set("pauseCapture", Napi::Function::New(env, pauseCapture));
+    exports.Set("resumeCapture", Napi::Function::New(env, resumeCapture));
+    return exports;
+}
+
+NODE_API_MODULE(native_capture, Init)

package/vendor/ffmpeg/README.md

@@ -0,0 +1,40 @@
+# Vendored FFmpeg Static Libraries
+
+This directory contains static macOS FFmpeg libraries used by the native
+capture addon. The addon links these archives directly so packaged builds do not
+depend on Homebrew FFmpeg dylibs being present on the user's machine.
+
+Required libraries linked by the addon:
+
+- `darwin-<arch>/lib/libavformat.a`
+- `darwin-<arch>/lib/libavcodec.a`
+- `darwin-<arch>/lib/libavutil.a`
+- `darwin-<arch>/lib/libswscale.a`
+- `darwin-<arch>/lib/libswresample.a`
+- `darwin-<arch>/lib/libx264.a`
+
+The generated FFmpeg install may also contain additional static archives such as
+`libavfilter.a` and `libavdevice.a`; those are not linked by `binding.gyp`.
+
+The generated `darwin-*` folders are ignored by git. Rebuild them with:
+
+```sh
+npm run build:vendor
+```
+
+From the app repo root, the equivalent convenience command is
+`npm run build:native-vendor`.
+
+`npm run build` inside this package also runs the vendor build automatically when
+the required static archives are missing, unless `SKIP_NATIVE_FFMPEG_VENDOR_BUILD=1`
+is set. The app repo's `npm run build:native-capture` delegates to this package
+build.
+
+The FFmpeg archive is configured for the native recorder's MPEG-TS HLS output.
+The vendored `libavformat.a` disables fMP4 HLS at compile time to avoid pulling
+in the MOV/MP4 muxer symbols that are not needed by the app's HLS pipeline.
+
+The x264 archive is built locally for arm64 or x64 with
+`MACOSX_DEPLOYMENT_TARGET=14.0`. Set `NATIVE_CAPTURE_ARCH=arm64` or
+`NATIVE_CAPTURE_ARCH=x64` before running the vendor or addon build. Optimized
+x64 builds require NASM.