noobs 0.0.32 → 0.0.60

package/src/obs_interface.cpp

@@ -6,6 +6,12 @@
 #include "obs_interface.h"
 #include <vector>
 #include <thread>
+#include <iostream>
+#include <map>
+#include <string>
+#include <graphics/matrix4.h>
+#include <graphics/vec4.h>
+#include <util/platform.h>
 
 std::vector<std::string> ObsInterface::get_available_video_encoders()
 {
@@ -158,7 +164,14 @@ void ObsInterface::init_obs(const std::string& pluginPath, const std::string& da
   }
 
   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" };
+
+  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.
+  };
 
   for (const auto& module : modules) {
     std::string path = pluginPath + "/" + module;
@@ -178,33 +191,46 @@ void ObsInterface::init_obs(const std::string& pluginPath, const std::string& da
   blog(LOG_INFO, "Exit init_obs");
 }
 
-void ObsInterface::configure_output(const std::string& recordingPath) {
+void ObsInterface::create_output(const std::string& recordingPath, bool buffering) {
   blog(LOG_INFO, "Create output");
 
-  if (output && obs_output_active(output)) {
-    blog(LOG_ERROR, "Tried to recreate active output");
-    throw std::runtime_error("Failed to create output!");
-  }
-
   if (output) {
     blog(LOG_DEBUG, "Releasing output");
     obs_output_release(output);
   }
 
-  output = obs_output_create("replay_buffer", "recording_output", NULL, NULL);
+  if (buffering) {
+    blog(LOG_INFO, "Creating replay buffer output");
+    output = obs_output_create("replay_buffer", "recording_output", NULL, NULL);
+  } else {
+    blog(LOG_INFO, "Creating file output");
+    output = obs_output_create("ffmpeg_muxer", "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");
+
+  if (buffering) {
+    blog(LOG_INFO, "Set replay_buffer settings");
+    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");
+  } else {
+    blog(LOG_INFO, "Set ffmpeg_muxer settings");
+		obs_data_set_string(settings, "extension", "mp4");
+    // Apparently need to specify the exact path for ffmpeg_muxer.
+    // TODO add something to auto generate this ?
+    obs_data_set_string(settings, "path", (recordingPath + "/noobs.mp4").c_str()); 
+    recording_path = recordingPath + "/noobs.mp4";
+  }
+
+  // Apply and release the settings.
   obs_output_update(output, settings);
   obs_data_release(settings);
 
@@ -212,6 +238,32 @@ void ObsInterface::configure_output(const std::string& recordingPath) {
   create_signal_handlers(output);
 }
 
+void ObsInterface::updateRecordingDir(const std::string& recordingPath) {
+  blog(LOG_INFO, "Updating recording directory");
+
+  if (!output) {
+    blog(LOG_ERROR, "No output to update recording directory");
+    throw std::runtime_error("Output not initialized");
+  }
+
+  // check its not active
+  if (obs_output_active(output)) {
+    blog(LOG_ERROR, "Output is active, cannot update recording path");
+    throw std::runtime_error("Output is active, cannot update recording path");
+  }
+
+  obs_data_t *settings = obs_output_get_settings(output);
+
+  if (!settings) {
+    blog(LOG_ERROR, "Failed to get output settings");
+    throw std::runtime_error("Failed to get output settings");
+  }
+
+  obs_data_set_string(settings, "directory", recordingPath.c_str());
+  obs_output_update(output, settings);
+  obs_data_release(settings);
+}
+
 void ObsInterface::configure_video_encoder() {
   blog(LOG_INFO, "Create video encoder");
 
@@ -278,15 +330,8 @@ void ObsInterface::configure_audio_encoder() {
   obs_encoder_set_audio(audio_encoder, obs_get_audio());
 }
 
-void ObsInterface::configure_scene() {
-  blog(LOG_INFO, "Configure scene");
-
-  if (scene) {
-    blog(LOG_DEBUG, "Releasing scene");
-    obs_scene_release(scene);
-    scene = nullptr;
-  }
-
+void ObsInterface::create_scene() {
+  blog(LOG_INFO, "Create scene");
   scene = obs_scene_create("WCR Scene");
 
   if (!scene) {
@@ -302,24 +347,85 @@ void ObsInterface::configure_scene() {
   }
 
   obs_set_output_source(0, scene_source); // 0 = video track
-  obs_scene_add(scene, video_source);
 }
 
-void ObsInterface::configure_video_source() {
-  blog(LOG_INFO, "Create monitor capture source");
+void ObsInterface::createSource(std::string name, std::string type) {
+  blog(LOG_INFO, "Create source: %s of type %s", name.c_str(), type.c_str());
+
+  obs_source_t *source = obs_source_create(
+    type.c_str(), 
+    name.c_str(), 
+    NULL, // No settings.
+    NULL  // No hotkey data.
+  );
+
+  if (!source) {
+    blog(LOG_ERROR, "Failed to create source: %s", name.c_str());
+    throw std::runtime_error("Failed to create 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.
+  }
+
+  obs_source_release(source);
+  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());
+    throw std::runtime_error("Source not found!");
+  }
+
+  obs_data_t *settings = obs_source_get_settings(source);
+  
+  if (!settings) {
+    blog(LOG_ERROR, "Failed to get settings for source: %s", name.c_str());
+    throw std::runtime_error("Failed to get source settings!");
+  }
+
+  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());
+
+  if (!source) {
+    blog(LOG_ERROR, "Source not found: %s", name.c_str());
+    throw std::runtime_error("Source not found!");
+  }
+
+  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());
 
-  // 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);
+  if (!source) {
+    blog(LOG_ERROR, "Source not found: %s", name.c_str());
+    throw std::runtime_error("Source not found!");
+  }
 
-  video_source = obs_source_create("monitor_capture", "video_source", monitor_settings, NULL);
-  obs_data_release(monitor_settings);
+  obs_properties_t *props = obs_source_properties(source);
 
-  if (!video_source) {
-    blog(LOG_ERROR, "Failed to create video source!");
-    throw std::runtime_error("Failed to create video source!");
+  if (!props) {
+    blog(LOG_ERROR, "Failed to get properties for source: %s", name.c_str());
+    throw std::runtime_error("Failed to get source properties!");
   }
+
+  return props;
 }
 
 void call_jscb(Napi::Env env, Napi::Function cb, SignalData* sd) {
@@ -374,8 +480,84 @@ void ObsInterface::create_signal_handlers(obs_output_t *output) {
   signal_handler_connect(sh, "saved", output_signal_handler_saved,  this);
 }
 
+bool draw_box(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);
+    obs_sceneitem_get_scale(item, &scale);
+
+    obs_source_t *src = obs_sceneitem_get_source(item);
+    uint32_t sizex = obs_source_get_width(src);
+    uint32_t sizey = obs_source_get_height(src);
+
+    // Calculate actual size with scaling
+    float width = sizex * scale.x;
+    float height = sizey * scale.y;
+
+    // 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");
+    gs_technique_t *tech = gs_effect_get_technique(solid, "Solid");
+
+    vec4 col = {0.733f, 0.267f, 0.125f, 1.0f}; // #BB4420
+    gs_effect_set_vec4(color, &col);
+
+    gs_technique_begin(tech);
+    gs_technique_begin_pass(tech, 0);
+
+    gs_matrix_push();
+    gs_matrix_identity();
+
+    // Top border
+    gs_matrix_push();
+    gs_matrix_translate3f(pos.x, pos.y, 0.0f);
+    //gs_matrix_scale3f(width, 1.0f, 1.0f);
+    gs_draw_sprite(nullptr, 0, width, 1.0f);
+    gs_matrix_pop();
+
+    // Bottom border
+    gs_matrix_push();
+    gs_matrix_translate3f(pos.x, pos.y + height - 1.0f, 0.0f);
+    // gs_matrix_scale3f(width, 1.0f, 1.0f);
+    gs_draw_sprite(nullptr, 0, width, 1.0f);
+    gs_matrix_pop();
+
+    // Left border
+    gs_matrix_push();
+    gs_matrix_translate3f(pos.x, pos.y, 0.0f);
+    // gs_matrix_scale3f(1.0f, height, 1.0f);
+    gs_draw_sprite(nullptr, 0, 1.0f, height);
+    gs_matrix_pop();
+
+    // Right border
+    gs_matrix_push();
+    gs_matrix_translate3f(pos.x + width - 1.0f, pos.y, 0.0f);
+    //  gs_matrix_scale3f(1.0f, height, 1.0f);
+    gs_draw_sprite(nullptr, 0, 1.0f, height);
+    gs_matrix_pop();
+
+    gs_matrix_pop();
+
+    gs_technique_end_pass(tech);
+    gs_technique_end(tech);
+
+    return true;
+}
+
 void draw_callback(void* data, uint32_t cx, uint32_t cy) {
+  // Initially, draw the OBS scene texture
   obs_render_main_texture();
+
+  // 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);
+
+  // This was me trying to understand what OSN does.
+  obs_scene_t* scene = obs_get_scene_by_name("WCR Scene");
+  obs_scene_enum_items(scene, draw_box, NULL);
+  obs_scene_release(scene);
 }
 
 void ObsInterface::initPreview(HWND parent) {
@@ -470,7 +652,8 @@ ObsInterface::ObsInterface(
   const std::string& logPath, 
   const std::string& dataPath,  
   const std::string& recordingPath,
-  Napi::ThreadSafeFunction cb
+  Napi::ThreadSafeFunction cb,
+  bool buffering
 ) {
   // Setup logs first so we have logs for the initialization.
   base_set_log_handler(log_handler, (void*)logPath.c_str());
@@ -483,11 +666,11 @@ ObsInterface::ObsInterface(
   jscb = cb;
 
   // Create the resources we rely on.
-  configure_output(recordingPath);
+  create_output(recordingPath, buffering);
+  create_scene();
+
   configure_video_encoder();
   configure_audio_encoder();
-  configure_video_source();
-  configure_scene();
 }
 
 ObsInterface::~ObsInterface() {
@@ -557,26 +740,52 @@ void ObsInterface::startBuffering() {
 
 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");
-  }
+  const char* type = obs_output_get_id(output);
 
-  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 (strcmp(type, "replay_buffer") == 0) {
+    bool is_active = obs_output_active(output);
 
-  if (!success) {
-    throw std::runtime_error("Failed to call convert procedure handler");
+    if (!is_active) {
+      blog(LOG_WARNING, "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");
+    }
+  } else if (strcmp(type, "ffmpeg_muxer") == 0) {
+    blog(LOG_INFO, "Starting ffmpeg_muxer output");
+
+    bool is_active = obs_output_active(output);
+
+    if (is_active) {
+      blog(LOG_WARNING, "Output already active");
+      return;
+    }
+
+    blog(LOG_WARNING, "Call start");
+    bool success = obs_output_start(output);
+
+    if (!success) {
+      const char *err = obs_output_get_last_error(output);
+      blog(LOG_ERROR, "Failed to start recording: %s", err ? err : "Unknown error");
+      throw std::runtime_error("Failed to start recording");
+    }
+  } else {
+    blog(LOG_ERROR, "Unknown output type: %s", type);
+    throw std::runtime_error("Unknown output type!");
   }
 
-   blog(LOG_INFO, "ObsInterface::startRecording exit");
+  blog(LOG_INFO, "ObsInterface::startRecording exit");
 }
 
 void ObsInterface::stopRecording() {
@@ -597,10 +806,26 @@ std::string ObsInterface::getLastRecording() {
   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);
+
+  const char* type = obs_output_get_id(output);
+
+
+
+  if (strcmp(type, "ffmpeg_muxer") == 0) {
+    return recording_path;
+  }
+
+  bool success;
+
+  if (strcmp(type, "replay_buffer") != 0) {
+    blog(LOG_ERROR, "Unknown output type: %s", type);
+    throw std::runtime_error("Unknown output type!");
+  }
 
   if (!success) {
-    blog(LOG_ERROR, "Failed to call get_last_replay procedure handler");
+    blog(LOG_ERROR, "Failed to call procedure handler");
+    const char *err = obs_output_get_last_error(output);
+    blog(LOG_ERROR, "%s", err ? err : "Unknown error");
     calldata_free(&cd);
     return "";
   }
@@ -613,6 +838,43 @@ std::string ObsInterface::getLastRecording() {
   return path;
 }
 
+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;
+  }
+
+  // TODO refuse to add twice?
+
+  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;
+  }
+  
+  blog(LOG_INFO, "ObsInterface::addSourceToScene exited");
+}
+
+void ObsInterface::removeSourceFromScene(std::string name) {
+  blog(LOG_INFO, "ObsInterface::removeSourceFromScene called for source: %s", name.c_str());
+
+  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.c_str());
+    return;
+  }
+
+  obs_sceneitem_remove(item);
+  blog(LOG_INFO, "ObsInterface::removeSourceFromScene exited");
+}
+
 void ObsInterface::getSourcePos(std::string name, vec2* pos, vec2* size, vec2* scale) 
 {
   blog(LOG_INFO, "ObsInterface::getSourcePos called");
@@ -621,12 +883,12 @@ void ObsInterface::getSourcePos(std::string name, vec2* pos, vec2* size, vec2* s
   obs_sceneitem_t *item = obs_scene_find_source(scene, name.c_str());
 
   if (!src) {
-    blog(LOG_ERROR, "Did not find source for video  ");
+    blog(LOG_WARNING, "Did not find source for video source: %s", name);
     return;
   }
 
   if (!item) {
-    blog(LOG_ERROR, "Did not find scene item for video source");
+    blog(LOG_WARNING, "Did not find scene item for video source: %s", name);
     return;
   }
 
@@ -645,7 +907,7 @@ void ObsInterface::setSourcePos(std::string name, vec2* pos, vec2* scale) {
   obs_sceneitem_t *item = obs_scene_find_source(scene, name.c_str());
 
   if (!item) {
-    blog(LOG_ERROR, "Did not find scene item for video source");
+    blog(LOG_WARNING, "Did not find scene item for video source: %s", name);
     return;
   }
 

package/src/obs_interface.h

@@ -10,26 +10,36 @@ struct SignalData {
 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
+      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
+      bool buffering                    // Whether to enable buffering the recording in memory
     );
 
     ~ObsInterface();
 
-    void startBuffering();
-    void startRecording(int offset);
-    void stopRecording();
-    std::string getLastRecording();
+    void startBuffering();             // Start buffering to memory.
+    void startRecording(int offset);   // Convert the active buffered recording to a real one.
+    void stopRecording();              // Stop the recording.
+    std::string getLastRecording();    // Get the last recorded file path.
+    void updateRecordingDir(const std::string& recordingPath); // Output must not be active when calling this.
 
+    void createSource(std::string name, std::string type);          // Create a new source
+    void deleteSource(std::string name);                            // Release a source.
+    obs_data_t* getSourceSettings(std::string name);                // Get the current settings.
+    void setSourceSettings(std::string name, obs_data_t* settings); // Set settings.
+    obs_properties_t* getSourceProperties(std::string name);        // Get the settings schema.
+
+    void addSourceToScene(std::string name); // Add source to scene.
+    void removeSourceFromScene(std::string name); // Remove source from scene.
     void getSourcePos(std::string name, vec2* pos, vec2* size, vec2* scale); // Size is returned to allow clients to calculate scale.
     void setSourcePos(std::string name, vec2* pos, vec2* scale); // Size does not get set here because it's set by the source itself.
 
     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();
+    void hidePreview(); // Hide the preview display.
 
     std::vector<std::string> get_available_video_encoders();
 
@@ -50,6 +60,7 @@ class ObsInterface {
     obs_display_t *display = nullptr;
     HWND preview_hwnd = nullptr; // window handle for scene preview
     Napi::ThreadSafeFunction jscb; // javascript callback
+    std::string recording_path = ""; 
 
     void init_obs(const std::string& pluginPath, const std::string& dataPath);
     void reset_video();
@@ -68,9 +79,9 @@ class ObsInterface {
     void list_input_types();
     void list_output_types();
 
-    void configure_output(const std::string& recordingPath);
+    void create_scene();
+    void create_output(const std::string& recordingPath, bool buffering);
+
     void configure_video_encoder();
     void configure_audio_encoder();
-    void configure_scene();
-    void configure_video_source();
 };