noobs 0.0.6

package/include/util/util_uint64.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2020 Hans Petter Selasky <hps@selasky.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#if defined(_MSC_VER) && defined(_M_X64)
+#include <intrin.h>
+#endif
+
+static inline uint64_t util_mul_div64(uint64_t num, uint64_t mul, uint64_t div)
+{
+#if defined(_MSC_VER) && defined(_M_X64) && (_MSC_VER >= 1920)
+	unsigned __int64 high;
+	const unsigned __int64 low = _umul128(num, mul, &high);
+	unsigned __int64 rem;
+	return _udiv128(high, low, div, &rem);
+#else
+	const uint64_t rem = num % div;
+	return (num / div) * mul + (rem * mul) / div;
+#endif
+}

package/include/util/windows/device-enum.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "../c99defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef bool (*device_luid_cb)(void *param, uint32_t idx, uint64_t luid);
+EXPORT void enum_graphics_device_luids(device_luid_cb device_luid, void *param);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/windows/obfuscate.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "../c99defs.h"
+#include <Windows.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* this is a workaround to A/Vs going crazy whenever certain functions (such as
+ * OpenProcess) are used */
+void *ms_get_obfuscated_func(HMODULE module, const char *str, uint64_t val);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/windows/win-registry.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ * Copyright (c) 2017 Ryan Foster <RytoEX@gmail.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#include <windows.h>
+#include "../c99defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct reg_dword {
+	LSTATUS status;
+	DWORD size;
+	DWORD return_value;
+};
+
+EXPORT void get_reg_dword(HKEY hkey, LPCWSTR sub_key, LPCWSTR value_name, struct reg_dword *info);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/windows/win-version.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#include "../c99defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct win_version_info {
+	int major;
+	int minor;
+	int build;
+	int revis;
+};
+
+static inline int win_version_compare(const struct win_version_info *dst, const struct win_version_info *src)
+{
+	if (dst->major > src->major)
+		return 1;
+	if (dst->major == src->major) {
+		if (dst->minor > src->minor)
+			return 1;
+		if (dst->minor == src->minor) {
+			if (dst->build > src->build)
+				return 1;
+			if (dst->build == src->build)
+				return 0;
+		}
+	}
+	return -1;
+}
+
+EXPORT bool is_64_bit_windows(void);
+EXPORT bool is_arm64_windows(void);
+EXPORT bool get_dll_ver(const wchar_t *lib, struct win_version_info *info);
+EXPORT void get_win_ver(struct win_version_info *info);
+EXPORT uint32_t get_win_ver_int(void);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/windows/window-helpers.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <obs-properties.h>
+#include <util/c99defs.h>
+#include <util/dstr.h>
+#include <Windows.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum window_priority {
+	WINDOW_PRIORITY_CLASS,
+	WINDOW_PRIORITY_TITLE,
+	WINDOW_PRIORITY_EXE,
+};
+
+enum window_search_mode {
+	INCLUDE_MINIMIZED,
+	EXCLUDE_MINIMIZED,
+};
+
+EXPORT bool ms_get_window_exe(struct dstr *name, HWND window);
+EXPORT void ms_get_window_title(struct dstr *name, HWND hwnd);
+EXPORT void ms_get_window_class(struct dstr *window_class, HWND hwnd);
+EXPORT bool ms_is_uwp_window(HWND hwnd);
+EXPORT HWND ms_get_uwp_actual_window(HWND parent);
+
+typedef bool (*add_window_cb)(const char *title, const char *window_class, const char *exe);
+
+EXPORT void ms_fill_window_list(obs_property_t *p, enum window_search_mode mode, add_window_cb callback);
+
+EXPORT void ms_build_window_strings(const char *str, char **window_class, char **title, char **exe);
+
+EXPORT bool ms_check_window_property_setting(obs_properties_t *ppts, obs_property_t *p, obs_data_t *settings,
+					     const char *val, size_t idx);
+
+EXPORT void ms_build_window_strings(const char *str, char **window_class, char **title, char **exe);
+
+EXPORT HWND ms_find_window(enum window_search_mode mode, enum window_priority priority, const char *window_class,
+			   const char *title, const char *exe);
+EXPORT HWND ms_find_window_top_level(enum window_search_mode mode, enum window_priority priority,
+				     const char *window_class, const char *title, const char *exe);
+
+#ifdef __cplusplus
+}
+#endif

package/index.d.ts

@@ -0,0 +1,38 @@
+interface ProcessInfo {
+  name: string;
+  pid: number;
+  parentPid: number;
+  threads: number;
+}
+
+type Signal = { // TODO export type? 
+  id: string;
+  code: number;
+}
+
+interface Noobs {
+  getUptime(): number;
+  listProcesses(): Promise<ProcessInfo[]>;
+
+  ObsInit(
+    pluginPath: string, 
+    logPath: string, 
+    dataPath: string,
+    recordingPath: string,
+    cb: (signal: Signal) => void
+  ): void;
+
+  ObsShutdown(): void;
+  ObsStartBuffer(): void;
+  ObsStartRecording(offset: number): void;
+  ObsStopRecording(): void;
+  ObsGetLastRecording(): string;
+
+  ObsShowPreview(hwnd: Buffer): void;
+  ObsHidePreview(): void;
+  ObsResizePreview(width: number, height: number): void;
+  ObsMovePreview(x: number, y: number): void;
+}
+
+declare const noobs: Noobs;
+export = noobs;

package/index.js

@@ -0,0 +1,8 @@
+const path = require('path');
+
+process.env.Path += ";";
+process.env.Path += path.resolve(__dirname, 'dist', 'bin');
+
+const packageName = 'noobs.node';
+const noobs = require(`./dist/${packageName}`)
+module.exports = noobs;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "noobs",
+  "version": "0.0.6",
+  "description": "A native Node.js addon with libobs bindings for Warcraft Recorder.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "scripts": {
+    "build": "node-gyp rebuild && node dist.js"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "binding.gyp",
+    "bin/64bit/obs.lib",
+    "src/**/*",
+    "include/**/*",
+    "dist/**/*"
+  ],
+  "author": "Warcraft Recorder LTD",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^24.1.0",
+    "node-gyp": "^11.2.0"
+  },
+  "dependencies": {
+    "node-addon-api": "^8.4.0"
+  }
+}

package/src/main.cpp

@@ -0,0 +1,321 @@
+#include <napi.h>
+#include <windows.h>
+#include <tlhelp32.h>
+#include <string>
+#include <vector>
+#include <obs.h>
+#include <iostream>
+#include <future>
+#include <chrono>
+
+#include "obs_interface.h"
+
+ObsInterface* obs = nullptr;
+
+LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+    if (uMsg == WM_DESTROY) {
+        PostQuitMessage(0);
+        return 0;
+    }
+    return DefWindowProc(hwnd, uMsg, wParam, lParam);
+}
+
+
+void WindowThread(std::promise<HWND> hwndPromise) {
+    const wchar_t CLASS_NAME[] = L"MyWindowClass";
+    HINSTANCE hInstance = GetModuleHandle(nullptr);
+
+    WNDCLASSW wc = {};
+    wc.lpfnWndProc = WindowProc;
+    wc.hInstance = hInstance;
+    wc.lpszClassName = CLASS_NAME;
+    RegisterClassW(&wc);
+
+    HWND hwnd = CreateWindowExW(
+        0, CLASS_NAME, L"My Window",
+        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, 800, 600,
+        nullptr, nullptr, hInstance, nullptr
+    );
+
+    hwndPromise.set_value(hwnd);  // Send hwnd back to main thread
+    ShowWindow(hwnd, SW_SHOW);
+
+    MSG msg = {};
+    while (GetMessage(&msg, nullptr, 0, 0)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+}
+
+Napi::Value ObsInit(const Napi::CallbackInfo& info) {
+  bool valid = info.Length() == 5 &&
+   info[0].IsString() && // Plugin path
+   info[1].IsString() && // Log path
+   info[2].IsString() && // Data path
+   info[3].IsString() && // Recording path
+   info[4].IsFunction(); // JavaScript callback
+
+  if (!valid) {
+    Napi::Error::New(info.Env(), "Invalid arguments passed to ObsInit").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  std::string pluginPath = info[0].As<Napi::String>().Utf8Value();
+  std::string logPath = info[1].As<Napi::String>().Utf8Value();
+  std::string dataPath = info[2].As<Napi::String>().Utf8Value();
+  std::string recordingPath = info[3].As<Napi::String>().Utf8Value();
+  Napi::Function fn = info[4].As<Napi::Function>();
+
+  Napi::ThreadSafeFunction jscb =
+    Napi::ThreadSafeFunction::New(info.Env(), fn, "JavaScript callback", 0, 1);
+
+  obs = new ObsInterface(pluginPath, logPath, dataPath, recordingPath, jscb);
+  return info.Env().Undefined();
+}
+
+
+Napi::Value ObsShutdown(const Napi::CallbackInfo& info) {
+  delete obs;
+  obs = nullptr;
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsStartBuffer(const Napi::CallbackInfo& info) {
+  blog(LOG_INFO, "ObsStartBuffer called");
+
+  if (!obs) 
+    throw std::runtime_error("Obs not initialized");
+
+  obs->startBuffering();
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsStartRecording(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  int offset = 0;
+
+  if (info.Length() == 1 && info[0].IsNumber()) {
+    offset = info[0].As<Napi::Number>().Int32Value();
+  }
+
+  obs->startRecording(offset);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsStopRecording(const Napi::CallbackInfo& info) {
+  if (!obs) 
+    throw std::runtime_error("Obs not initialized");
+
+  obs->stopRecording();
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsGetLastRecording(const Napi::CallbackInfo& info) {
+  if (!obs)
+    throw std::runtime_error("Obs not initialized");
+
+  std::string lastRecording = obs->getLastRecording();
+  return Napi::String::New(info.Env(), lastRecording);
+}
+
+Napi::Value ObsShowPreview(const Napi::CallbackInfo& info) {
+  blog(LOG_INFO, "ObsShowPreview called");
+
+  if (!obs) 
+    throw std::runtime_error("Obs not initialized");
+
+  if (info.Length() < 1 || !info[0].IsBuffer()) {
+    Napi::TypeError::New(info.Env(), "Expected HWND as Buffer").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  Napi::Buffer<uint8_t> buffer = info[0].As<Napi::Buffer<uint8_t>>();
+
+  if (buffer.Length() < sizeof(HWND)) {
+    Napi::TypeError::New(info.Env(), "Buffer too small for HWND").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  } else {
+    blog(LOG_INFO, "ObsShowPreview buffer length: %zu", buffer.Length());
+    blog(LOG_INFO, "ObsShowPreview hwnd length: %zu", sizeof(HWND));
+  }
+
+  // Union to safely read the bytes
+  union {
+    uint8_t bytes[8];
+    uint64_t value;
+    HWND hwnd;
+  } hwndUnion;
+  
+  memcpy(hwndUnion.bytes, buffer.Data(), sizeof(hwndUnion.bytes));
+
+  obs->showPreview(hwndUnion.hwnd);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsResizePreview(const Napi::CallbackInfo& info) {
+  if (!obs) 
+    throw std::runtime_error("Obs not initialized");
+
+  if (info.Length() < 2) {
+    Napi::TypeError::New(info.Env(), "Expected width and height").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  int width = info[0].As<Napi::Number>().Int32Value();
+  int height = info[1].As<Napi::Number>().Int32Value();
+
+  obs->resizePreview(width, height);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsMovePreview(const Napi::CallbackInfo& info) {
+  if (!obs) 
+    throw std::runtime_error("Obs not initialized");
+
+  if (info.Length() < 2) {
+    Napi::TypeError::New(info.Env(), "Expected x and y").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  int x = info[0].As<Napi::Number>().Int32Value();
+  int y = info[1].As<Napi::Number>().Int32Value();
+
+  obs->movePreview(x, y);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsHidePreview(const Napi::CallbackInfo& info) {
+  if (!obs) 
+    throw std::runtime_error("Obs not initialized");
+
+  obs->hidePreview();
+  return info.Env().Undefined();
+}
+
+
+Napi::Number GetUptime(const Napi::CallbackInfo& info) {
+  DWORD ticks = GetTickCount();
+  return Napi::Number::New(info.Env(), static_cast<double>(ticks));
+}
+
+class ProcessListWorker : public Napi::AsyncWorker {
+public:
+    ProcessListWorker(Napi::Function& callback) 
+        : Napi::AsyncWorker(callback) {}
+
+    ~ProcessListWorker() {}
+
+    // This runs on a background thread - won't block JS
+    void Execute() override {
+        HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+        if (snapshot == INVALID_HANDLE_VALUE) {
+            SetError("Failed to create process snapshot");
+            return;
+        }
+        
+        PROCESSENTRY32W pe32;
+        pe32.dwSize = sizeof(PROCESSENTRY32W);
+        
+        if (!Process32FirstW(snapshot, &pe32)) {
+            CloseHandle(snapshot);
+            SetError("Failed to get first process");
+            return;
+        }
+        
+        do {
+            ProcessInfo info;
+            
+            // Convert wide string to UTF-8
+            int utf8Length = WideCharToMultiByte(CP_UTF8, 0, pe32.szExeFile, -1, nullptr, 0, nullptr, nullptr);
+            if (utf8Length > 0) {
+                std::vector<char> utf8Buffer(utf8Length);
+                WideCharToMultiByte(CP_UTF8, 0, pe32.szExeFile, -1, utf8Buffer.data(), utf8Length, nullptr, nullptr);
+                
+                info.name = std::string(utf8Buffer.data());
+                info.pid = pe32.th32ProcessID;
+                info.parentPid = pe32.th32ParentProcessID;
+                info.threads = pe32.cntThreads;
+                
+                processes.push_back(info);
+            }
+        } while (Process32NextW(snapshot, &pe32));
+        
+        CloseHandle(snapshot);
+    }
+
+    // This runs back on the main thread
+    void OnOK() override {
+        Napi::HandleScope scope(Env());
+        Napi::Array result = Napi::Array::New(Env());
+        
+        for (size_t i = 0; i < processes.size(); i++) {
+            Napi::Object process = Napi::Object::New(Env());
+            process.Set("name", Napi::String::New(Env(), processes[i].name));
+            process.Set("pid", Napi::Number::New(Env(), processes[i].pid));
+            process.Set("parentPid", Napi::Number::New(Env(), processes[i].parentPid));
+            process.Set("threads", Napi::Number::New(Env(), processes[i].threads));
+            result.Set(i, process);
+        }
+        
+        Callback().Call({Env().Null(), result});
+    }
+
+    void OnError(const Napi::Error& e) override {
+        Napi::HandleScope scope(Env());
+        Callback().Call({e.Value(), Env().Undefined()});
+    }
+
+private:
+    struct ProcessInfo {
+        std::string name;
+        DWORD pid;
+        DWORD parentPid;
+        DWORD threads;
+    };
+    
+    std::vector<ProcessInfo> processes;
+};
+
+Napi::Value ListProcesses(const Napi::CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    auto deferred = Napi::Promise::Deferred::New(env);
+    
+    auto callback = Napi::Function::New(env, [deferred](const Napi::CallbackInfo& info) {
+        if (!info[0].IsNull()) {
+            // Error case
+            deferred.Reject(info[0]);
+        } else {
+            // Success case
+            deferred.Resolve(info[1]);
+        }
+        return info.Env().Undefined();
+    });
+    
+    ProcessListWorker* worker = new ProcessListWorker(callback);
+    worker->Queue();
+    
+    return deferred.Promise();
+}
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  exports.Set("ObsInit", Napi::Function::New(env, ObsInit));
+  exports.Set("ObsShutdown", Napi::Function::New(env, ObsShutdown));
+  exports.Set("ObsStartBuffer", Napi::Function::New(env, ObsStartBuffer));
+  exports.Set("ObsStartRecording", Napi::Function::New(env, ObsStartRecording));
+  exports.Set("ObsStopRecording", Napi::Function::New(env, ObsStopRecording));
+  exports.Set("ObsGetLastRecording", Napi::Function::New(env, ObsGetLastRecording));
+
+  exports.Set("ObsShowPreview", Napi::Function::New(env, ObsShowPreview));
+  exports.Set("ObsHidePreview", Napi::Function::New(env, ObsHidePreview));
+  exports.Set("ObsResizePreview", Napi::Function::New(env, ObsResizePreview));
+  exports.Set("ObsMovePreview", Napi::Function::New(env, ObsMovePreview));
+  
+  exports.Set("getUptime", Napi::Function::New(env, GetUptime));
+  exports.Set("listProcesses", Napi::Function::New(env, ListProcesses));
+  return exports;
+}
+
+NODE_API_MODULE(addon, Init)