noobs 0.0.6

package/src/obs_interface.cpp

@@ -0,0 +1,605 @@
+#include <iostream>
+#include <windows.h>
+#include <obs.h>
+#include "utils.h"
+#include <chrono>
+#include "obs_interface.h"
+#include <vector>
+#include <thread>
+
+
+
+std::vector<std::string> ObsInterface::get_available_video_encoders()
+{
+  std::vector<std::string> encoders;
+  size_t idx = 0;
+  const char *encoder_type;
+
+  while (obs_enum_encoder_types(idx++, &encoder_type)) {
+    bool video = obs_get_encoder_type(encoder_type) == OBS_ENCODER_VIDEO;
+
+    if (video)
+      encoders.emplace_back(encoder_type);
+  }
+
+  return encoders;
+}
+
+void ObsInterface::list_encoders(obs_encoder_type type)
+{
+  blog(LOG_INFO, "List encoders");
+  blog(LOG_INFO, "List encoders of type: %d", type);
+  
+  size_t idx = 0;
+  const char *encoder_type;
+
+  while (obs_enum_encoder_types(idx++, &encoder_type)) {
+    if (obs_get_encoder_type(encoder_type) != type) {
+      continue;
+    }
+
+    // if (obs_get_encoder_caps(encoder_type) & hide_flags) {
+    //   continue;
+    // }
+
+    blog(LOG_INFO, "\t- %s (%s)", encoder_type, obs_encoder_get_display_name(encoder_type));
+  }
+};
+
+void ObsInterface::list_source_types()
+{
+  blog(LOG_INFO, "List  src types");
+  size_t idx = 0;
+  const char *src = nullptr;
+
+  while (obs_enum_source_types(idx++, &src)) {
+    blog(LOG_INFO, "\t- %s", src);
+  }
+}
+
+void ObsInterface::list_input_types()
+{
+  blog(LOG_INFO, "List  input types");
+  size_t idx = 0;
+  const char *src = nullptr;
+
+  while (obs_enum_input_types(idx++, &src)) {
+    blog(LOG_INFO, "\t- %s", src);
+  }
+}
+
+void ObsInterface::list_output_types()
+{
+  blog(LOG_INFO, "List  output types");
+  size_t idx = 0;
+  const char *src = nullptr;
+
+  while (obs_enum_output_types(idx++, &src)) {
+    blog(LOG_INFO, "\t- %s", src);
+  }
+}
+
+void ObsInterface::load_module(const char* module) {
+  blog(LOG_INFO, "Loading module: %s", module);
+
+  obs_module_t *ptr = NULL;
+  int success = obs_open_module(&ptr, module, NULL);
+
+  if (success != MODULE_SUCCESS) {
+    blog(LOG_ERROR, "Failed to open module: %s", module);
+    throw std::runtime_error("Failed to open module!");
+  }
+
+  bool initmod = obs_init_module(ptr);
+
+  if (!initmod) {
+    blog(LOG_ERROR, "Failed to initialize module!");
+    throw std::runtime_error("Module initialization failed!");
+  }
+}
+
+void ObsInterface::reset_video() {
+  blog(LOG_INFO, "Setup video info");
+
+  obs_video_info ovi = {};
+
+  ovi.base_width = 1920;
+  ovi.base_height = 1080;
+  ovi.output_width = 1920;
+  ovi.output_height = 1080;
+  ovi.fps_num = 60;
+  ovi.fps_den = 1;
+
+  ovi.output_format = VIDEO_FORMAT_NV12;
+  ovi.colorspace = VIDEO_CS_DEFAULT;
+  ovi.range = VIDEO_RANGE_DEFAULT;
+  ovi.scale_type = OBS_SCALE_BILINEAR;
+  ovi.adapter = 0;
+  ovi.gpu_conversion = true;
+  ovi.graphics_module = "libobs-d3d11.dll"; 
+
+  int success = obs_reset_video(&ovi);
+
+  if (success != OBS_VIDEO_SUCCESS) {
+    blog(LOG_ERROR, "Failed to reset video!");
+    throw std::runtime_error("Failed to reset video!");
+  }
+}
+
+void ObsInterface::reset_audio() {
+  struct obs_audio_info oai = {0};
+  oai.samples_per_sec = 48000;
+  oai.speakers = SPEAKERS_STEREO;
+  bool reset = obs_reset_audio(&oai);
+
+  if (!reset) {
+    blog(LOG_ERROR, "Failed to reset audio!");
+    throw std::runtime_error("Failed to reset audio!");
+  }
+}
+
+void ObsInterface::init_obs(const std::string& pluginPath, const std::string& dataPath) {
+  blog(LOG_INFO, "Enter init_obs");
+  auto success = obs_startup("en-US", NULL, NULL);
+
+  if (!success) {
+    blog(LOG_ERROR, "Failed to start OBS!");
+    throw std::runtime_error("OBS startup failed");
+  }
+
+  if (!obs_initialized()) {
+    blog(LOG_ERROR, "OBS not initialized!");
+    throw std::runtime_error("OBS initialization failed");
+  }
+  
+  std::string dp = dataPath;
+
+  if (dp.back() != '/' && dp.back() != '\\') {
+    // Add a trailing slash if not present, else libobs gets upset.
+    dp += '/';
+  }
+
+  obs_add_data_path(dp.c_str());  // This is deprecated in libobs but it works for now.
+  std::vector<std::string> modules = { "obs-x264.dll", "obs-ffmpeg.dll", "win-capture.dll" };
+
+  for (const auto& module : modules) {
+    std::string path = pluginPath + "/" + module;
+    load_module(path.c_str());
+  }
+  
+  obs_post_load_modules();
+
+  list_encoders();
+  list_source_types();
+  list_input_types();
+  list_output_types();
+
+  reset_video();
+  reset_audio();
+
+  blog(LOG_INFO, "Exit init_obs");
+}
+
+obs_output_t* ObsInterface::create_output(const std::string& recordingPath) {
+  blog(LOG_INFO, "Create output");
+  obs_output_t *output = obs_output_create("replay_buffer", "recording_output", NULL, NULL);
+
+  if (!output) {
+    blog(LOG_ERROR, "Failed to create output!");
+    throw std::runtime_error("Failed to create output!");
+  }
+
+  blog(LOG_INFO, "Set output settings");
+  obs_data_t *settings = obs_data_create();
+  obs_data_set_int(settings, "max_time_sec", 60);
+  obs_data_set_int(settings, "max_size_mb", 1024);
+  obs_data_set_string(settings, "directory", recordingPath.c_str());
+  obs_data_set_string(settings, "format", "%CCYY-%MM-%DD %hh-%mm-%ss");
+  obs_data_set_string(settings, "extension", "mp4");
+  obs_output_update(output, settings);
+  obs_data_release(settings);
+
+  blog(LOG_INFO, "Create venc");
+  video_encoder = obs_video_encoder_create("h264_texture_amf", "simple_h264_stream", NULL, NULL);
+
+  if (!video_encoder) {
+    blog(LOG_ERROR, "Failed to create video encoder!");
+    throw std::runtime_error("Failed to create video encoder!");
+  }
+
+  blog(LOG_INFO, "Set video encoder settings");
+  obs_data_t* amf_settings = obs_data_create();
+  obs_data_set_string(amf_settings, "preset", "speed");  // Faster preset
+  //obs_data_set_int(amf_settings, "bitrate", 2500);
+  obs_data_set_string(amf_settings, "rate_control", "CQP");
+  obs_data_set_int(amf_settings, "cqp", 30);
+  obs_data_set_string(amf_settings, "profile", "main");
+  obs_data_set_int(amf_settings, "keyint_sec", 1); // Set keyframe interval to 1 second
+  obs_encoder_update(video_encoder, amf_settings);
+  obs_data_release(amf_settings);
+
+  blog(LOG_INFO, "Create aenc");
+  audio_encoder = obs_audio_encoder_create("ffmpeg_aac", "simple_aac", NULL, 0, NULL);
+
+  if (!audio_encoder) {
+    blog(LOG_ERROR, "Failed to create audio encoder!");
+    throw std::runtime_error("Failed to create audio encoder!");
+  }
+
+  blog(LOG_INFO, "Set audio encoder settings");
+  obs_data_t *aenc_settings = obs_data_create();
+  obs_data_set_int(aenc_settings, "bitrate", 128);
+  obs_encoder_update(audio_encoder, aenc_settings);
+  obs_data_release(aenc_settings);
+
+  obs_output_set_video_encoder(output, video_encoder);
+  obs_output_set_audio_encoder(output, audio_encoder, 0);
+
+  obs_encoder_set_video(video_encoder, obs_get_video());
+  obs_encoder_set_audio(audio_encoder, obs_get_audio());
+
+  return output;
+}
+
+obs_scene_t* ObsInterface::create_scene() {
+  blog(LOG_INFO, "Create scene and src");
+  obs_scene_t *scene = obs_scene_create("WCR Scene");
+
+  if (!scene)
+    throw std::runtime_error("Failed to create scene!");
+
+  obs_source_t *scene_source = obs_scene_get_source(scene);
+
+  if (!scene_source)
+    throw std::runtime_error("Failed to get scene src!");
+
+  obs_set_output_source(0, scene_source);  // 0 = video track
+  return scene;
+}
+
+obs_source_t* ObsInterface::create_video_source() {
+  blog(LOG_INFO, "Create display capture source");
+  // Create settings for monitor capture
+  obs_data_t *monitor_settings = obs_data_create();
+  obs_data_set_int(monitor_settings, "monitor", 0);  // Monitor 0
+  obs_data_set_bool(monitor_settings, "capture_cursor", true);
+
+  obs_source_t *source = obs_source_create("monitor_capture", "Monitor", monitor_settings, NULL);
+  obs_data_release(monitor_settings);
+
+  if (!source)
+    throw std::runtime_error("Failed to create video source!");
+
+  return source;
+}
+
+void call_jscb(Napi::Env env, Napi::Function cb, SignalData* sd) {
+  Napi::Object obj = Napi::Object::New(env);
+  obj.Set("id", Napi::String::New(env, sd->id));
+  obj.Set("code", Napi::Number::New(env, sd->code));
+  cb.Call({ obj });
+  delete sd;
+}
+
+void ObsInterface::output_signal_handler_starting(void *data, calldata_t *cd) {
+  long long code = calldata_int(cd, "code");
+  ObsInterface* self = static_cast<ObsInterface*>(data);
+  SignalData* sd = new SignalData{ "starting", code };
+  self->jscb.NonBlockingCall(sd, call_jscb);
+}
+
+void ObsInterface::output_signal_handler_start(void *data, calldata_t *cd) {
+  long long code = calldata_int(cd, "code");
+  ObsInterface* self = static_cast<ObsInterface*>(data);
+  SignalData* sd = new SignalData{ "start", code };
+  self->jscb.NonBlockingCall(sd, call_jscb);
+}
+
+void ObsInterface::output_signal_handler_stop(void *data, calldata_t *cd) {
+  long long code = calldata_int(cd, "code");
+  ObsInterface* self = static_cast<ObsInterface*>(data);
+  SignalData* sd = new SignalData{ "stop", code };
+  self->jscb.NonBlockingCall(sd, call_jscb);
+}
+
+void ObsInterface::output_signal_handler_stopping(void *data, calldata_t *cd) {
+  long long code = calldata_int(cd, "code");
+  ObsInterface* self = static_cast<ObsInterface*>(data);
+  SignalData* sd = new SignalData{ "stopping", code };
+  self->jscb.NonBlockingCall(sd, call_jscb);
+}
+
+void ObsInterface::output_signal_handler_saved(void *data, calldata_t *cd) {
+  long long code = calldata_int(cd, "code");
+  ObsInterface* self = static_cast<ObsInterface*>(data);
+  SignalData* sd = new SignalData{ "saved", code };
+  self->jscb.NonBlockingCall(sd, call_jscb);
+}
+
+void ObsInterface::create_signal_handlers(obs_output_t *output) {
+  signal_handler_t *sh = obs_output_get_signal_handler(output);
+  signal_handler_connect(sh, "starting", output_signal_handler_starting,  this);
+  signal_handler_connect(sh, "start", output_signal_handler_start,  this);
+  signal_handler_connect(sh, "stopping", output_signal_handler_stopping,  this);
+  signal_handler_connect(sh, "stop", output_signal_handler_stop,  this);
+  signal_handler_connect(sh, "saved", output_signal_handler_saved,  this);
+}
+
+void draw_callback(void* data, uint32_t cx, uint32_t cy) {
+  // Render the OBS preview scene here
+  obs_render_main_texture();
+}
+
+void ObsInterface::showPreview(HWND hwnd) {
+  blog(LOG_INFO, "ObsInterface::showPreview");
+
+  if (display) {
+    blog(LOG_INFO, "Display already exists, returning early");
+    return;  // Return early if display already exists
+  }
+
+  // Create an embedded child window for OBS preview
+  HWND previewWindow = CreateWindowExA(
+    0,                    // No extended styles
+    "STATIC",            // Simple static control class (ANSI string)
+    "OBS Preview",       // Window name (ANSI string)
+    WS_CHILD | WS_VISIBLE | WS_BORDER,  // Child + visible + border
+    20, 20,              // Position within parent (x, y)
+    1920, 1080,           // Size (width, height)
+    hwnd,                // Parent window (your Electron app)
+    NULL,                // No menu
+    GetModuleHandle(NULL), 
+    NULL
+  );
+
+  if (!previewWindow) {
+    blog(LOG_ERROR, "Failed to create preview child window");
+    return;
+  }
+
+  // Store for cleanup
+  previewHwnd = previewWindow;
+
+  blog(LOG_INFO, "Create OBS display in child window");
+  gs_init_data gs_data = {};
+  gs_data.adapter = 0;
+  gs_data.cx = 1920;              // Match child window size
+  gs_data.cy = 1080;              
+  gs_data.format = GS_BGRA;
+  gs_data.zsformat = GS_ZS_NONE;
+  gs_data.num_backbuffers = 1;
+  gs_data.window.hwnd = previewWindow;  // Use child window, not parent
+
+  display = obs_display_create(&gs_data, 0x0);
+  if (display) {
+    obs_display_add_draw_callback(display, draw_callback, NULL);
+    blog(LOG_INFO, "OBS preview embedded successfully");
+  } else {
+    blog(LOG_ERROR, "Failed to create OBS display");
+    DestroyWindow(previewWindow);
+    previewHwnd = nullptr;
+  }
+}
+
+void ObsInterface::resizePreview(int width, int height) {
+  blog(LOG_INFO, "ObsInterface::resizePreview to size (%d x %d)", width, height);
+
+  if (!previewHwnd) {
+    blog(LOG_WARNING, "No preview window to resize");
+    return;
+  }
+
+  // Resize the child window
+  BOOL windowSuccess = SetWindowPos(
+    previewHwnd,           // Handle to the child window
+    NULL,                  // No Z-order change
+    0, 0,                  // Keep current position (ignored due to SWP_NOMOVE)
+    width, height,         // New size (width, height)
+    SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE  // Don't change position, Z-order, or activation
+  );
+
+  if (!windowSuccess) {
+    blog(LOG_ERROR, "Failed to resize preview window to (%d x %d)", width, height);
+    return;
+  }
+
+  blog(LOG_INFO, "Preview window resized successfully to (%d x %d)", width, height);
+
+  // Resize the OBS display to match the new window size
+  if (display) {
+    obs_display_resize(display, width, height);
+    blog(LOG_INFO, "OBS display resized to (%d x %d)", width, height);
+  } else {
+    blog(LOG_WARNING, "No OBS display to resize");
+  }
+}
+
+void ObsInterface::movePreview(int x, int y) {
+  blog(LOG_INFO, "ObsInterface::movePreview to position (%d, %d)", x, y);
+
+  if (!previewHwnd) {
+    blog(LOG_WARNING, "No preview window to move");
+    return;
+  }
+
+  // Move the child window to the new position within the parent
+  BOOL success = SetWindowPos(
+    previewHwnd,           // Handle to the child window
+    NULL,                  // No Z-order change
+    x, y,                  // New position (x, y)
+    0, 0,                  // Keep current size (ignored due to SWP_NOSIZE)
+    SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE  // Don't change size, Z-order, or activation
+  );
+
+  if (success) {
+    blog(LOG_INFO, "Preview window moved successfully to (%d, %d)", x, y);
+  } else {
+    blog(LOG_ERROR, "Failed to move preview window to (%d, %d)", x, y);
+  }
+}
+
+void ObsInterface::hidePreview() {
+  blog(LOG_INFO, "ObsInterface::hidePreview");
+
+  if (display) {
+    obs_display_remove_draw_callback(display, draw_callback, NULL);
+    obs_display_destroy(display);
+    display = nullptr;
+    blog(LOG_INFO, "OBS display destroyed");
+  }
+
+  // Destroy the child window to fully clean up the preview
+  if (previewHwnd) {
+    DestroyWindow(previewHwnd);
+    previewHwnd = nullptr;
+    blog(LOG_INFO, "Preview child window destroyed");
+  }
+}
+
+ObsInterface::ObsInterface(
+  const std::string& pluginPath, 
+  const std::string& logPath, 
+  const std::string& dataPath,  
+  const std::string& recordingPath,
+  Napi::ThreadSafeFunction cb
+) {
+  // Setup logs first so we have logs for the initialization.
+  base_set_log_handler(log_handler, (void*)logPath.c_str());
+  blog(LOG_DEBUG, "Creating ObsInterface");
+
+  // Initialize OBS and load required modules.
+  init_obs(pluginPath, dataPath);
+
+  // Create the resources we rely on.
+  output = create_output(recordingPath);
+  scene = create_scene();
+  video_source = create_video_source();
+  obs_scene_add(scene, video_source);
+
+  // Add the signal handler callback.
+  jscb = cb;
+  create_signal_handlers(output);
+}
+
+ObsInterface::~ObsInterface() {
+  blog(LOG_DEBUG, "Destroying ObsInterface");
+
+  if (jscb) {
+    blog(LOG_DEBUG, "Releasing JavaScript callback");
+    jscb.Release();
+  }
+
+  if (video_source) {
+    blog(LOG_DEBUG, "Releasing video source");
+    obs_source_release(video_source);
+  }
+
+  if (scene) {
+    blog(LOG_DEBUG, "Releasing scene");
+    obs_scene_release(scene);
+  }
+
+  if (output) {
+    if (obs_output_active(output)) {
+      blog(LOG_DEBUG, "Force stopping output");
+      obs_output_force_stop(output);
+    }
+      
+    blog(LOG_DEBUG, "Releasing output");
+    obs_output_release(output);
+  }
+
+  if (video_encoder) {
+    blog(LOG_DEBUG, "Releasing video encoder");
+    obs_encoder_release(video_encoder);
+  }
+
+  if (audio_encoder) {
+    blog(LOG_DEBUG, "Releasing audio encoder");
+    obs_encoder_release(audio_encoder);
+  }
+
+  blog(LOG_DEBUG, "Now shutting down OBS");
+  obs_shutdown();
+}
+
+void ObsInterface::startBuffering() {
+  blog(LOG_INFO, "ObsInterface::startBuffering called");
+
+  if (!output) {
+    throw std::runtime_error("Output is not initialized!");
+  }
+
+  bool is_active = obs_output_active(output);
+      
+  if (is_active) {
+    blog(LOG_WARNING, "Output is already active");
+    return;
+  }
+
+  bool success = obs_output_start(output);
+
+  if (!success) {
+    throw std::runtime_error("Failed to start buffering!");
+  }
+    
+  blog(LOG_INFO, "ObsInterface::startBuffering exited");
+}
+
+void ObsInterface::startRecording(int offset) {
+  blog(LOG_INFO, "ObsInterface::startRecording enter");
+  bool is_active = obs_output_active(output);
+
+  if (!is_active) {
+    blog(LOG_ERROR, "Buffer is not active");
+    throw std::runtime_error("Buffer is not active");
+  }
+
+  blog(LOG_INFO, "calling save proc handler");
+  calldata cd;
+  calldata_init(&cd);
+  calldata_set_int(&cd, "offset_seconds", offset);
+  proc_handler_t *ph = obs_output_get_proc_handler(output);
+  bool success = proc_handler_call(ph, "convert", &cd);
+  calldata_free(&cd);
+
+  if (!success) {
+    throw std::runtime_error("Failed to call convert procedure handler");
+  }
+
+   blog(LOG_INFO, "ObsInterface::startRecording exit");
+}
+
+void ObsInterface::stopRecording() {
+  blog(LOG_INFO, "ObsInterface::stopRecording enter");
+  bool is_active = obs_output_active(output);
+
+  if (!is_active) {
+    blog(LOG_WARNING, "Buffer is not active");
+    return;
+  }
+
+  obs_output_stop(output);
+  blog(LOG_INFO, "ObsInterface::stopRecording exited");
+}
+
+std::string ObsInterface::getLastRecording() {
+  blog(LOG_INFO, "calling get last replay proc handler");
+  calldata cd;
+  calldata_init(&cd);
+  proc_handler_t *ph = obs_output_get_proc_handler(output);
+  bool success = proc_handler_call(ph, "get_last_replay", &cd);
+
+  if (!success) {
+    blog(LOG_ERROR, "Failed to call get_last_replay procedure handler");
+    calldata_free(&cd);
+    return "";
+  }
+
+  const char* p = calldata_string(&cd, "path");
+  std::string path = p ? p : "" ;
+  calldata_free(&cd);
+  
+  blog(LOG_INFO, "return path: %s", path.c_str());
+  return path;
+}

package/src/obs_interface.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <napi.h>
+
+struct SignalData {
+  std::string id;
+  long long code;
+};
+
+class ObsInterface {
+  public:
+    ObsInterface(
+      const std::string& pluginPath,    // where to look for plugins
+      const std::string& logPath,       // where to write logs to
+      const std::string& dataPath,      // where to look for effects
+      const std::string& recordingPath, // where to save recordings
+      Napi::ThreadSafeFunction cb       // JavaScript callback
+    );
+
+    ~ObsInterface();
+
+    void startBuffering();
+    void startRecording(int offset);
+    void stopRecording();
+    std::string getLastRecording();
+
+    void showPreview(HWND hwnd);
+    void hidePreview();
+    void resizePreview(int width, int height);
+    void movePreview(int x, int y);
+
+    std::vector<std::string> get_available_video_encoders();
+
+    // TODO
+    // Show preview
+    // Hide preview
+    // Configure video 
+    // Configure audio
+    // List audio source
+    // Reconfigure audio sources
+    // Reconfigure video sources
+  
+  private:
+    obs_output_t *output = nullptr;
+    obs_scene_t *scene = nullptr;
+    obs_source_t *video_source = nullptr;
+    obs_source_t *audio_source = nullptr;
+    obs_encoder_t *video_encoder = nullptr;
+    obs_encoder_t *audio_encoder = nullptr;
+    obs_display_t *display = nullptr;
+    HWND previewHwnd = nullptr; // window handle for scene preview
+    Napi::ThreadSafeFunction jscb; // javascript callback
+
+    void init_obs(const std::string& pluginPath, const std::string& dataPath);
+    void reset_video();
+    void reset_audio();
+    void load_module(const char* module);
+    void create_signal_handlers(obs_output_t *output);
+
+    static void output_signal_handler_starting(void *data, calldata_t *cd);
+    static void output_signal_handler_start(void *data, calldata_t *cd);
+    static void output_signal_handler_stop(void *data, calldata_t *cd);
+    static void output_signal_handler_stopping(void *data, calldata_t *cd);
+    static void output_signal_handler_saved(void *data, calldata_t *cd);
+
+    void list_encoders(obs_encoder_type type = OBS_ENCODER_VIDEO);
+    void list_source_types();
+    void list_input_types();
+    void list_output_types();
+
+    obs_output_t* create_output(const std::string& recordingPath);
+    obs_scene_t* create_scene();
+    obs_source_t* create_video_source();
+};