noobs 0.0.66 → 0.0.89

package/src/obs_interface.cpp

@@ -1,13 +1,8 @@
-#include <iostream>
 #include <windows.h>
 #include <obs.h>
 #include "utils.h"
-#include <chrono>
 #include "obs_interface.h"
 #include <vector>
-#include <thread>
-#include <iostream>
-#include <map>
 #include <string>
 #include <graphics/matrix4.h>
 #include <graphics/vec4.h>
@@ -83,11 +78,12 @@ void ObsInterface::list_output_types()
   }
 }
 
-void ObsInterface::load_module(const char* module) {
+void ObsInterface::load_module(const char* module, const char* data) {
   blog(LOG_INFO, "Loading module: %s", module);
+  blog(LOG_INFO, "Data path: %s", data);
 
   obs_module_t *ptr = NULL;
-  int success = obs_open_module(&ptr, module, NULL);
+  int success = obs_open_module(&ptr, module, data);
 
   if (success != MODULE_SUCCESS) {
     blog(LOG_ERROR, "Failed to open module: %s", module);
@@ -124,6 +120,11 @@ void ObsInterface::reset_video() {
 
   int success = obs_reset_video(&ovi);
 
+  obs_enter_graphics();
+  int  dt = gs_get_device_type();
+  blog(LOG_INFO, "Device type = %d", dt);  // should be 1 for D3D11
+  obs_leave_graphics();
+
   if (success != OBS_VIDEO_SUCCESS) {
     blog(LOG_ERROR, "Failed to reset video!");
     throw std::runtime_error("Failed to reset video!");
@@ -142,7 +143,7 @@ void ObsInterface::reset_audio() {
   }
 }
 
-void ObsInterface::init_obs(const std::string& pluginPath, const std::string& dataPath) {
+void ObsInterface::init_obs(const std::string& distPath) {
   blog(LOG_INFO, "Enter init_obs");
   auto success = obs_startup("en-US", NULL, NULL);
 
@@ -156,26 +157,41 @@ void ObsInterface::init_obs(const std::string& pluginPath, const std::string& da
     throw std::runtime_error("OBS initialization failed");
   }
   
-  std::string dp = dataPath;
+  std::string basePath = distPath;
 
-  if (dp.back() != '/' && dp.back() != '\\') {
-    // Add a trailing slash if not present, else libobs gets upset.
-    dp += '/';
+  if (basePath.back() != '/' && basePath.back() != '\\') {
+    // Add a trailing slash if not present.
+    basePath += '/';
   }
 
-  obs_add_data_path(dp.c_str());  // This is deprecated in libobs but it works for now.
+  std::string effectsPath = basePath + "data/effects/";
+  std::string pluginPath = basePath + "obs-plugins/";
+
+  blog(LOG_INFO, "Base path: %s", basePath.c_str());
+  blog(LOG_INFO, "Effects path: %s", effectsPath.c_str());
+  blog(LOG_INFO, "Plugin path: %s", pluginPath.c_str());
+
+  // Add the effects path. We need this before resetting video and audio
+  // to ensure the effects are available. The function is deprecated in
+  // libobs but it works for now.
+  obs_add_data_path(effectsPath.c_str());
+
+  // This must come before loading modules to initialize D3D11.
+  reset_video();
+  reset_audio();
 
   std::vector<std::string> modules = { 
-    "obs-x264.dll", 
-    "obs-ffmpeg.dll",
-    "win-capture.dll",  // Required for basically all forms of capture on Windows.
-    "image-source.dll", // Required for image sources.
-    "win-wasapi.dll"    // Required for WASAPI audio input.
+    "obs-x264", 
+    "obs-ffmpeg",
+    "win-capture",  // Required for basically all forms of capture on Windows.
+    "image-source", // Required for image sources.
+    "win-wasapi"    // Required for WASAPI audio input.
   };
 
   for (const auto& module : modules) {
-    std::string path = pluginPath + "/" + module;
-    load_module(path.c_str());
+    std::string modulePath = pluginPath + module + ".dll";
+    std::string moduleDataPath = pluginPath + module;
+    load_module(modulePath.c_str(), moduleDataPath.c_str());
   }
   
   obs_post_load_modules();
@@ -185,9 +201,6 @@ void ObsInterface::init_obs(const std::string& pluginPath, const std::string& da
   list_input_types();
   list_output_types();
 
-  reset_video();
-  reset_audio();
-
   blog(LOG_INFO, "Exit init_obs");
 }
 
@@ -285,9 +298,9 @@ void ObsInterface::create_video_encoders() {
 
   blog(LOG_INFO, "Set file video encoder settings");
   obs_data_t* venc_settings = obs_data_create();
-  obs_data_set_string(venc_settings, "preset", "speed");  // Faster preset
+  // obs_data_set_string(venc_settings, "preset", "speed");  // Faster preset
   obs_data_set_string(venc_settings, "rate_control", "CRF");
-  obs_data_set_int(venc_settings, "crf", 30);
+  obs_data_set_int(venc_settings, "crf", 22);
   obs_data_set_string(venc_settings, "profile", "main");
   obs_data_set_int(venc_settings, "keyint_sec", 1); // Set keyframe interval to 1 second
 
@@ -376,30 +389,38 @@ void ObsInterface::createSource(std::string name, std::string type) {
     blog(LOG_ERROR, "Failed to create source: %s", name.c_str());
     throw std::runtime_error("Failed to create source!");
   }
+
+  // Store the source in the sources map.
+  sources[name] = source;
 }
 
 void ObsInterface::deleteSource(std::string name) {
   blog(LOG_INFO, "Delete source: %s", name.c_str());
-  obs_source_t *source = obs_get_source_by_name(name.c_str());
-  
-  if (!source) {
-    blog(LOG_WARNING, "Source not found: %s", name.c_str());
-    return; // Source not found, nothing to delete.
+
+  auto it = sources.find(name);
+
+  if (it == sources.end()) {
+    blog(LOG_WARNING, "Source %s not found", name.c_str());
+    return;
   }
 
+  obs_source_t* source = it->second;
   obs_source_release(source);
+  sources.erase(name);
   blog(LOG_INFO, "Source deleted: %s", name.c_str());
 }
 
 obs_data_t* ObsInterface::getSourceSettings(std::string name) {
   blog(LOG_INFO, "Get source settings for: %s", name.c_str());
-  obs_source_t *source = obs_get_source_by_name(name.c_str());
-  
-  if (!source) {
-    blog(LOG_ERROR, "Source not found: %s", name.c_str());
+
+  auto it = sources.find(name);
+
+  if (it == sources.end()) {
+    blog(LOG_WARNING, "Source %s not found", name.c_str());
     throw std::runtime_error("Source not found!");
   }
 
+  obs_source_t* source = it->second;
   obs_data_t *settings = obs_source_get_settings(source);
   
   if (!settings) {
@@ -407,30 +428,34 @@ obs_data_t* ObsInterface::getSourceSettings(std::string name) {
     throw std::runtime_error("Failed to get source settings!");
   }
 
+  // obs_data_release(settings); TODO release after returning to client.
   return settings;
 }
 
 void ObsInterface::setSourceSettings(std::string name, obs_data_t* settings) {
   blog(LOG_INFO, "Set source settings for: %s", name.c_str());
-  obs_source_t *source = obs_get_source_by_name(name.c_str());
+  auto it = sources.find(name);
 
-  if (!source) {
-    blog(LOG_ERROR, "Source not found: %s", name.c_str());
+  if (it == sources.end()) {
+    blog(LOG_WARNING, "Source %s not found", name.c_str());
     throw std::runtime_error("Source not found!");
   }
 
+  obs_source_t* source = it->second;
+
   obs_source_update(source, settings);
 }
 
 obs_properties_t* ObsInterface::getSourceProperties(std::string name) {
   blog(LOG_INFO, "Get source properties for: %s", name.c_str());
-  obs_source_t *source = obs_get_source_by_name(name.c_str());
+  auto it = sources.find(name);
 
-  if (!source) {
-    blog(LOG_ERROR, "Source not found: %s", name.c_str());
+  if (it == sources.end()) {
+    blog(LOG_WARNING, "Source %s not found", name.c_str());
     throw std::runtime_error("Source not found!");
   }
 
+  obs_source_t* source = it->second;
   obs_properties_t *props = obs_source_properties(source);
 
   if (!props) {
@@ -502,7 +527,7 @@ void ObsInterface::disconnect_signal_handlers(obs_output_t *output) {
   signal_handler_disconnect(sh, "saved", output_signal_handler_saved,  this);
 }
 
-bool draw_box(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
+bool draw_source_outline(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
   // Get the item position and size
   vec2 pos; vec2 scale;
   obs_sceneitem_get_pos(item, &pos);
@@ -513,6 +538,12 @@ bool draw_box(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
   float width =  obs_source_get_width(src) * scale.x;
   float height = obs_source_get_height(src) * scale.y;
 
+  if (width <= 0 || height <= 0) {
+    // Don't want to call gs_draw_sprite with zero width or height.
+    // It is obviously nonsense and leads to log spam. Just return early.
+    return true;
+  }
+
   // Draw rectangle around the source using the position and size
   gs_effect_t *solid = obs_get_base_effect(OBS_EFFECT_SOLID);
   gs_eparam_t *color = gs_effect_get_param_by_name(solid, "color");
@@ -530,25 +561,25 @@ bool draw_box(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
   // Top border
   gs_matrix_push();
   gs_matrix_translate3f(pos.x, pos.y, 0.0f);
-  gs_draw_sprite(nullptr, 0, width, 2.0f);
+  gs_draw_sprite(nullptr, 0, width, 4.0f);
   gs_matrix_pop();
 
   // Bottom border
   gs_matrix_push();
-  gs_matrix_translate3f(pos.x, pos.y + height - 2.0f, 0.0f);
-  gs_draw_sprite(nullptr, 0, width, 2.0f);
+  gs_matrix_translate3f(pos.x, pos.y + height - 4.0f, 0.0f);
+  gs_draw_sprite(nullptr, 0, width, 4.0f);
   gs_matrix_pop();
 
   // Left border
   gs_matrix_push();
   gs_matrix_translate3f(pos.x, pos.y, 0.0f);
-  gs_draw_sprite(nullptr, 0, 2.0f, height);
+  gs_draw_sprite(nullptr, 0, 4.0f, height);
   gs_matrix_pop();
 
   // Right border
   gs_matrix_push();
-  gs_matrix_translate3f(pos.x + width - 2.0f, pos.y, 0.0f);
-  gs_draw_sprite(nullptr, 0, 2.0f, height);
+  gs_matrix_translate3f(pos.x + width - 4.0f, pos.y, 0.0f);
+  gs_draw_sprite(nullptr, 0, 4.0f, height);
   gs_matrix_pop();
 
   gs_matrix_pop();
@@ -560,18 +591,46 @@ bool draw_box(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
 }
 
 void draw_callback(void* data, uint32_t cx, uint32_t cy) {
-  // Initially, draw the OBS scene texture
-  obs_render_main_texture();
+  ObsInterface* obsInterface = (ObsInterface*)data;
+
+  obs_video_info ovi;
+  obs_get_video_info(&ovi);
+
+  float scaleX = float(cx) / float(ovi.base_width);
+  float scaleY = float(cy) / float(ovi.base_height);
+
+  float previewScale;
 
-  // This is some AI code that would draw a rectangle (and works).
-  // Set projection and viewport
-  gs_ortho(0.0f, float(cx), 0.0f, float(cy), -100.0f, 100.0f);
-  gs_set_viewport(0, 0, cx, cy);
+  // Pick the limiting scale factor.
+  if (scaleX < scaleY) {
+    previewScale = scaleX;
+  } else {
+    previewScale = scaleY;
+  }
+
+  int previewCX = int(previewScale * ovi.base_width);
+  int previewCY = int(previewScale * ovi.base_height);
+  int previewX = (cx - previewCX) / 2;
+  int previewY = (cy - previewCY) / 2;
+
+  gs_viewport_push();
+	gs_projection_push();
+
+  gs_ortho(0.0f, float(ovi.base_width), 0.0f, float(ovi.base_height), -100.0f, 100.0f);
+  gs_set_viewport(previewX, previewY, previewCX, previewCY);
 
-  // This was me trying to understand what OSN does.
+  // Renders the scene now the graphics context is setup.
+  obs_render_main_texture();
+
+  // Draw boxes around sources.
   obs_scene_t* scene = obs_get_scene_by_name("WCR Scene");
-  obs_scene_enum_items(scene, draw_box, NULL);
+  if (obsInterface->getDrawSourceOutlineEnabled()) {
+    obs_scene_enum_items(scene, draw_source_outline, NULL);
+  }
   obs_scene_release(scene);
+
+	gs_projection_pop();
+	gs_viewport_pop();
 }
 
 void ObsInterface::initPreview(HWND parent) {
@@ -618,7 +677,7 @@ void ObsInterface::initPreview(HWND parent) {
       return;
     }
 
-    obs_display_add_draw_callback(display, draw_callback, NULL);
+    obs_display_add_draw_callback(display, draw_callback, this);
   }
 
   obs_display_set_enabled(display, false);
@@ -632,13 +691,15 @@ void ObsInterface::showPreview(int x, int y, int width, int height) {
     return;
   }
 
+  blog(LOG_INFO, "Showing preview child window at (%d, %d) with size (%d x %d)", x, y, width, height);
+
   // Resize and move the existing child window.
   bool success = SetWindowPos(
     preview_hwnd,                  // Handle to the child window
     NULL,                          // No Z-order change
     x, y,                          // New position (x, y)
     width, height,                 // New size (width, height)
-     SWP_NOACTIVATE  // Flags
+    SWP_NOACTIVATE                 // Flags
   );
 
   if (!success) {
@@ -646,6 +707,10 @@ void ObsInterface::showPreview(int x, int y, int width, int height) {
     return;
   }
 
+  uint32_t w, h;
+  obs_display_size(display, &w, &h); // Get the display size to match the video context.
+  blog(LOG_INFO, "Current Display size set to (%d x %d)", w, h);
+
   obs_display_resize(display, width, height);
   ShowWindow(preview_hwnd, SW_SHOW);
   obs_display_set_enabled(display, true);
@@ -662,10 +727,44 @@ void ObsInterface::hidePreview() {
   obs_display_set_enabled(display, false);
 }
 
+float ObsInterface::getPreviewScaleFactor() {
+  if (!display) {
+    blog(LOG_WARNING, "Display not initialized");
+    return 1.0f; // Default scale
+  }
+
+  obs_video_info ovi;
+  obs_get_video_info(&ovi);
+
+  uint32_t width, height;
+	obs_display_size(display, &width, &height);
+
+  float scaleX = float(width) / float(ovi.base_width);
+  float scaleY = float(height) / float(ovi.base_height);
+
+  float previewScale;
+
+  // Pick the limiting scale factor.
+  if (scaleX < scaleY) {
+    previewScale = scaleX;
+  } else {
+    previewScale = scaleY;
+  }
+
+  return previewScale;
+}
+
+void ObsInterface::setDrawSourceOutline(bool enabled) {
+  drawSourceOutline = enabled;
+}
+
+bool ObsInterface::getDrawSourceOutlineEnabled() {
+  return drawSourceOutline;
+}
+
 ObsInterface::ObsInterface(
-  const std::string& pluginPath, 
+  const std::string& distPath, 
   const std::string& logPath, 
-  const std::string& dataPath,  
   const std::string& recordingPath,
   Napi::ThreadSafeFunction cb
 ) {
@@ -674,7 +773,7 @@ ObsInterface::ObsInterface(
   blog(LOG_DEBUG, "Creating ObsInterface");
 
   // Initialize OBS and load required modules.
-  init_obs(pluginPath, dataPath);
+  init_obs(distPath);
 
   // Setup callback function.
   jscb = cb;
@@ -696,9 +795,11 @@ ObsInterface::~ObsInterface() {
     jscb.Release();
   }
 
-  if (video_source) {
-    blog(LOG_DEBUG, "Releasing video source");
-    obs_source_release(video_source);
+  for (auto& kv : sources) {
+    std::string name = kv.first;
+    obs_source_t* source = kv.second;
+    blog(LOG_DEBUG, "Releasing source: %s", name.c_str());
+    obs_source_release(source);
   }
 
   if (scene) {
@@ -880,21 +981,22 @@ std::string ObsInterface::getLastRecording() {
 void ObsInterface::addSourceToScene(std::string name) {
   blog(LOG_INFO, "ObsInterface::addSourceToScene called for source: %s", name.c_str());
 
-  obs_source_t *src = obs_get_source_by_name(name.c_str());
-  
-  if (!src) {
-    blog(LOG_WARNING, "Did not find source for video source: %s", name.c_str());
-    return;
+  auto it = sources.find(name);
+
+  if (it == sources.end()) {
+    blog(LOG_WARNING, "Source %s not found", name.c_str());
+    throw std::runtime_error("Source not found!");
   }
 
+  obs_source_t* source = it->second;
+
   // TODO refuse to add twice?
+  obs_sceneitem_t *item = obs_scene_add(scene, source);
 
-  obs_sceneitem_t *item = obs_scene_add(scene, src);
-  
   if (!item) {
     blog(LOG_ERROR, "Failed to add source to scene: %s", name.c_str());
-    obs_source_release(src);
-    return;
+    obs_source_release(source);
+    throw std::runtime_error("Failed to add source to scene");
   }
   
   blog(LOG_INFO, "ObsInterface::addSourceToScene exited");
@@ -916,18 +1018,24 @@ void ObsInterface::removeSourceFromScene(std::string name) {
 
 void ObsInterface::getSourcePos(std::string name, vec2* pos, vec2* size, vec2* scale) 
 {
-  blog(LOG_INFO, "ObsInterface::getSourcePos called");
+  auto it = sources.find(name);
 
-  obs_source_t *src = obs_get_source_by_name(name.c_str());
-  obs_sceneitem_t *item = obs_scene_find_source(scene, name.c_str());
+  if (it == sources.end()) {
+    blog(LOG_WARNING, "Source %s not found", name.c_str());
+    throw std::runtime_error("Source not found!");
+  }
+
+  obs_source_t* source = it->second;
 
-  if (!src) {
-    blog(LOG_WARNING, "Did not find source for video source: %s", name);
+  if (!source) {
+    blog(LOG_WARNING, "Did not find source for video source: %s", name.c_str());
     return;
   }
 
+  obs_sceneitem_t *item = obs_scene_find_source(scene, name.c_str());
+
   if (!item) {
-    blog(LOG_WARNING, "Did not find scene item for video source: %s", name);
+    blog(LOG_WARNING, "Did not find scene item for video source: %s", name.c_str());
     return;
   }
 
@@ -935,18 +1043,15 @@ void ObsInterface::getSourcePos(std::string name, vec2* pos, vec2* size, vec2* s
   obs_sceneitem_get_scale(item, scale);
 
   // Pre-scaled sizes.
-  size->x = obs_source_get_width(src);
-  size->y = obs_source_get_height(src);
-
-  blog(LOG_INFO, "ObsInterface::getSourcePos exited");
+  size->x = obs_source_get_width(source);
+  size->y = obs_source_get_height(source);
 }
 
 void ObsInterface::setSourcePos(std::string name, vec2* pos, vec2* scale) {
-  blog(LOG_INFO, "ObsInterface::moveSource called");
   obs_sceneitem_t *item = obs_scene_find_source(scene, name.c_str());
 
   if (!item) {
-    blog(LOG_WARNING, "Did not find scene item for video source: %s", name);
+    blog(LOG_WARNING, "Did not find scene item for video source: %s", name.c_str());
     return;
   }
 

package/src/obs_interface.h

@@ -1,6 +1,9 @@
 #pragma once
 
+#include <obs.h>
 #include <napi.h>
+#include <windows.h>
+#include <map>
 
 struct SignalData {
   std::string id;
@@ -10,9 +13,8 @@ struct SignalData {
 class ObsInterface {
   public:
     ObsInterface(
-      const std::string& pluginPath,    // Where to look for plugins
+      const std::string& distPath,      // Where to look for plugins and data
       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
     );
@@ -40,6 +42,9 @@ class ObsInterface {
     void initPreview(HWND parent); // Must call this before showPreview to setup resources.
     void showPreview(int x, int y, int width, int height); // Also used for moving and resizing.
     void hidePreview(); // Hide the preview display.
+    float getPreviewScaleFactor(); // Get the current scale factor of the preview.
+    void setDrawSourceOutline(bool enabled); // Red box around source
+    bool getDrawSourceOutlineEnabled();
 
     std::vector<std::string> get_available_video_encoders();
 
@@ -54,8 +59,6 @@ class ObsInterface {
     obs_output_t *file_output = nullptr;
     obs_output_t *buffer_output = nullptr;
     obs_scene_t *scene = nullptr;
-    obs_source_t *video_source = nullptr;
-    obs_source_t *audio_source = nullptr;
     obs_encoder_t *file_video_encoder = nullptr;
     obs_encoder_t *file_audio_encoder = nullptr;
     obs_encoder_t *buffer_video_encoder = nullptr;
@@ -65,11 +68,13 @@ class ObsInterface {
     Napi::ThreadSafeFunction jscb; // javascript callback
     std::string recording_path = ""; 
     bool buffering = false; // Whether we are buffering the recording in memory.
+    bool drawSourceOutline = false; // Draw red outline around source
+    std::map<std::string, obs_source_t*> sources; // Map of source names to obs_source_t pointers. 
 
-    void init_obs(const std::string& pluginPath, const std::string& dataPath);
+    void init_obs(const std::string& distPath);
     void reset_video();
     void reset_audio();
-    void load_module(const char* module);
+    void load_module(const char* module, const char* data); // Load a module, data is optional.
     void connect_signal_handlers(obs_output_t *output);
     void disconnect_signal_handlers(obs_output_t *output);