noobs 0.0.84 → 0.0.115

package/src/obs_interface.cpp

@@ -1,58 +1,41 @@
-#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>
 #include <util/platform.h>
 
-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;
+void call_jscb(Napi::Env env, Napi::Function cb, SignalData* sd) {
+  Napi::Object obj = Napi::Object::New(env);
+  obj.Set("type", Napi::String::New(env, sd->type));
+  obj.Set("id", Napi::String::New(env, sd->id));
+  obj.Set("code", Napi::Number::New(env, sd->code));
 
-    if (video)
-      encoders.emplace_back(encoder_type);
+  if (sd->value.has_value()) {
+    obj.Set("value", Napi::Number::New(env, sd->value.value()));
   }
 
-  return encoders;
+  cb.Call({ obj });
+  delete sd;
 }
 
 void ObsInterface::list_encoders(obs_encoder_type type)
 {
-  blog(LOG_INFO, "List encoders");
-  blog(LOG_INFO, "List encoders of type: %d", type);
-  
+  blog(LOG_INFO, "Encoders:");
   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");
+  blog(LOG_INFO, "Sources:");
   size_t idx = 0;
   const char *src = nullptr;
 
@@ -61,20 +44,9 @@ void ObsInterface::list_source_types()
   }
 }
 
-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");
+  blog(LOG_INFO, "Outputs:");
   size_t idx = 0;
   const char *src = nullptr;
 
@@ -83,11 +55,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);
@@ -102,16 +75,50 @@ void ObsInterface::load_module(const char* module) {
   }
 }
 
-void ObsInterface::reset_video() {
-  blog(LOG_INFO, "Setup video info");
+void ObsInterface::setVideoContext(int fps, int width, int height) {
+  blog(LOG_INFO, "Reset video context");
 
+  blog(LOG_INFO, "FPS: %d", fps);
+  blog(LOG_INFO, "Width: %d", width);
+  blog(LOG_INFO, "Height: %d", height);
+
+  if (fps <= 10) {
+    blog(LOG_WARNING, "Invalid FPS provided for reset, using default 10");
+    fps = 60;
+  }
+
+  if (width <= 32 || height <= 32) {
+    blog(LOG_WARNING, "Invalid width or height provided for reset, using default 1920x1080");
+    width = 1920;
+    height = 1080;
+  }
+
+  int ret = reset_video(fps, width, height);
+
+  if (ret == OBS_VIDEO_CURRENTLY_ACTIVE) {
+    blog(LOG_WARNING, "Can't reset video as currently active");
+    return;
+  }
+
+  if (ret != OBS_VIDEO_SUCCESS) {
+    blog(LOG_ERROR, "Failed to reset video context: %d", ret);
+    throw std::runtime_error("Failed to reset video context");
+  }
+
+  // Recreate the encoders as they are tied to the video context.
+  create_video_encoders();
+}
+
+
+int ObsInterface::reset_video(int fps, int width, int height) {
+  blog(LOG_INFO, "Reset video");
   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.base_width = width;
+  ovi.base_height = height;
+  ovi.output_width = width;
+  ovi.output_height = height;
+  ovi.fps_num = fps;
   ovi.fps_den = 1;
 
   ovi.output_format = VIDEO_FORMAT_NV12;
@@ -122,32 +129,17 @@ void ObsInterface::reset_video() {
   ovi.gpu_conversion = true;
   ovi.graphics_module = "libobs-d3d11.dll"; 
 
-  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!");
-  }
+  return obs_reset_video(&ovi);
 }
 
-void ObsInterface::reset_audio() {
+bool 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!");
-  }
+  return obs_reset_audio(&oai);
 }
 
-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);
 
@@ -161,40 +153,59 @@ 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 += '/';
   }
 
-  // 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(dp.c_str());
+  std::string effectsPath = basePath + "data/effects/";
+  std::string pluginPath = basePath + "obs-plugins/";
+  std::string pluginDataPath = basePath + "data/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());
+  blog(LOG_INFO, "Data path: %s", pluginDataPath.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();
+  // Choose some sensible defaults that can be reconfigured.
+  int rc = reset_video(60, 1920, 1080);
+
+  if (rc != OBS_VIDEO_SUCCESS) {
+    blog(LOG_ERROR, "Failed to reset video!");
+    throw std::runtime_error("Failed to reset video!");
+  }
+
+  if (!reset_audio()) {
+    blog(LOG_ERROR, "Failed to reset audio!");
+    throw std::runtime_error("Failed to 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 = pluginDataPath + module;
+    load_module(modulePath.c_str(), moduleDataPath.c_str());
   }
   
   obs_post_load_modules();
 
   list_encoders();
   list_source_types();
-  list_input_types();
   list_output_types();
 
   blog(LOG_INFO, "Exit init_obs");
@@ -231,10 +242,10 @@ void ObsInterface::create_output() {
 
   blog(LOG_INFO, "Set ffmpeg_muxer settings");
   obs_data_t *ffmpeg_settings = obs_data_create();
-  // Need to specify the exact path for ffmpeg_muxer.
+  // Need to specify the exact path for ffmpeg_muxer. We will write this again at start recording.
   std::string filename = recording_path + "\\" + get_current_date_time() + ".mp4";
   obs_data_set_string(ffmpeg_settings, "path", filename.c_str());
-  recording_path = filename;
+  unbuffered_output_filename = filename;
 
   // Apply and release the settings.
   obs_output_update(file_output, ffmpeg_settings);
@@ -275,38 +286,48 @@ void ObsInterface::setRecordingDir(const std::string& recordingPath) {
 }
 
 void ObsInterface::create_video_encoders() {
-  blog(LOG_INFO, "Create video encoder");
+  blog(LOG_INFO, "Set video encoder: %s", video_encoder_id.c_str());
 
-  file_video_encoder = obs_video_encoder_create("obs_x264", "h264_stream_file", NULL, NULL);
+  if (file_video_encoder) {
+    blog(LOG_DEBUG, "Releasing file video encoder");
+    obs_encoder_release(file_video_encoder);
+    file_video_encoder = nullptr;
+  }
 
+  file_video_encoder = obs_video_encoder_create(
+    video_encoder_id.c_str(), 
+    "noobs_file_encoder", 
+    video_encoder_settings, 
+    NULL
+  );
 
   if (!file_video_encoder) {
     blog(LOG_ERROR, "Failed to create video encoder!");
     throw std::runtime_error("Failed to create video encoder!");
   }
 
-  buffer_video_encoder = obs_video_encoder_create("obs_x264", "h264_stream_buffer", NULL, NULL);
+  if (buffer_video_encoder) {
+    blog(LOG_DEBUG, "Releasing buffer video encoder");
+    obs_encoder_release(buffer_video_encoder);
+    buffer_video_encoder = nullptr;
+  }
+
+  buffer_video_encoder = obs_video_encoder_create(
+    video_encoder_id.c_str(), 
+    "noobs_buffer_encoder", 
+    video_encoder_settings, 
+    NULL
+  );
 
   if (!buffer_video_encoder) {
     blog(LOG_ERROR, "Failed to create buffer video encoder!");
     throw std::runtime_error("Failed to create buffer video encoder!");
   }
 
-  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, "rate_control", "CRF");
-  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
-
-  obs_encoder_update(file_video_encoder, venc_settings);
-  obs_encoder_update(buffer_video_encoder, venc_settings);
-  obs_data_release(venc_settings);
-
   obs_output_set_video_encoder(file_output, file_video_encoder);
-  obs_encoder_set_video(file_video_encoder, obs_get_video());
   obs_output_set_video_encoder(buffer_output, buffer_video_encoder);
+
+  obs_encoder_set_video(file_video_encoder, obs_get_video());
   obs_encoder_set_video(buffer_video_encoder, obs_get_video());
 }
 
@@ -371,12 +392,34 @@ void ObsInterface::create_scene() {
   obs_set_output_source(0, scene_source); // 0 = video track
 }
 
+void ObsInterface::volmeter_callback(void *data, 
+  const float magnitude[MAX_AUDIO_CHANNELS],
+  const float peak[MAX_AUDIO_CHANNELS], 
+  const float inputPeak[MAX_AUDIO_CHANNELS])
+{
+  // blog(LOG_DEBUG, "Volmeter callback triggered: %f %f %f", 
+  //   obs_db_to_mul(magnitude[0]), 
+  //   obs_db_to_mul(peak[0]), 
+  //   obs_db_to_mul(inputPeak[0])
+  // );
+
+  SignalContext* ctx = static_cast<SignalContext*>(data);
+  ObsInterface* self = ctx->self;
+
+  if (!self->volmeter_enabled) {
+    return;
+  }
+
+  SignalData* sd = new SignalData{ "volmeter", ctx->id.c_str(), 0, obs_db_to_mul(peak[0]) };
+  self->jscb.NonBlockingCall(sd, call_jscb);
+}
+
 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(), 
+    type.c_str(), // Type of source, e.g. "wasapi_input_capture"
+    name.c_str(), // Name of the source, e.g. "My Audio Input"
     NULL, // No settings.
     NULL  // No hotkey data.
   );
@@ -385,30 +428,77 @@ 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!");
   }
+
+  if (type == AUDIO_OUTPUT) {
+    blog(LOG_INFO, "Setting output volume for source: %s to %d", name.c_str(), output_volume);
+    obs_source_set_volume(source, output_volume);
+  } else if (type == AUDIO_INPUT) {
+    blog(LOG_INFO, "Setting input volume for source: %s to %d", name.c_str(), input_volume);
+    obs_source_set_volume(source, input_volume);
+  } else if (type == AUDIO_PROCESS) {
+    blog(LOG_INFO, "Setting process volume for source: %s to %d", name.c_str(), process_volume);
+    obs_source_set_volume(source, process_volume);
+  }
+
+  if (type == AUDIO_OUTPUT || type == AUDIO_INPUT || type == AUDIO_PROCESS) {
+    blog(LOG_INFO, "Creating volmeter for source: %s", name.c_str());
+
+    obs_volmeter_t *volmeter = obs_volmeter_create(OBS_FADER_CUBIC);
+    obs_volmeter_attach_source(volmeter, source);
+
+    SignalContext* ctx = new SignalContext{ this, name }; // TODO don't leak this.
+    obs_volmeter_add_callback(volmeter, volmeter_callback, ctx);
+
+    // Store the volmeter in the volmeters map.
+    volmeters[name] = volmeter;
+  }
+
+  // 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());
+
+  // First release a volmeter if there is one present.
+  // Only audio sources have volmeters ofcourse.
+  auto vol_it = volmeters.find(name);
   
-  if (!source) {
-    blog(LOG_WARNING, "Source not found: %s", name.c_str());
-    return; // Source not found, nothing to delete.
+  if (vol_it != volmeters.end()) {
+    obs_volmeter_t* volmeter = vol_it->second;
+    obs_volmeter_remove_callback(volmeter, volmeter_callback, this);
+    obs_volmeter_detach_source(volmeter);
+    obs_volmeter_destroy(volmeter);
+    blog(LOG_INFO, "Volmeter deleted for source: %s", name.c_str());
+    volmeters.erase(name);
+  }
+
+  // Now deal with the source itself.
+  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_remove(source); // ???
   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) {
@@ -416,30 +506,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) {
@@ -450,68 +544,33 @@ obs_properties_t* ObsInterface::getSourceProperties(std::string name) {
   return props;
 }
 
-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) {
+void ObsInterface::output_signal_handler(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);
-}
+  SignalContext* ctx = static_cast<SignalContext*>(data);
+  ObsInterface* self = ctx->self;
 
-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 };
+  SignalData* sd = new SignalData{ "output", ctx->id.c_str(), code };
   self->jscb.NonBlockingCall(sd, call_jscb);
 }
 
 void ObsInterface::connect_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);
+  signal_handler_connect(sh, "start", output_signal_handler,  start_ctx);
+  signal_handler_connect(sh, "starting", output_signal_handler,  starting_ctx);
+  signal_handler_connect(sh, "stopping", output_signal_handler,  stopping_ctx);
+  signal_handler_connect(sh, "stop", output_signal_handler,  stop_ctx);
 }
 
 void ObsInterface::disconnect_signal_handlers(obs_output_t *output) {
   signal_handler_t *sh = obs_output_get_signal_handler(output);
-  signal_handler_disconnect(sh, "starting", output_signal_handler_starting,  this);
-  signal_handler_disconnect(sh, "start", output_signal_handler_start,  this);
-  signal_handler_disconnect(sh, "stopping", output_signal_handler_stopping,  this);
-  signal_handler_disconnect(sh, "stop", output_signal_handler_stop,  this);
-  signal_handler_disconnect(sh, "saved", output_signal_handler_saved,  this);
+  signal_handler_disconnect(sh, "starting", output_signal_handler,  starting_ctx);
+  signal_handler_disconnect(sh, "start", output_signal_handler,  start_ctx);
+  signal_handler_disconnect(sh, "stopping", output_signal_handler,  stopping_ctx);
+  signal_handler_disconnect(sh, "stop", output_signal_handler,  stop_ctx);
 }
 
-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);
@@ -566,6 +625,12 @@ bool draw_box(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
   gs_draw_sprite(nullptr, 0, 4.0f, height);
   gs_matrix_pop();
 
+  // Dragging point box (25x25 pixels in bottom-right corner)
+  gs_matrix_push();
+  gs_matrix_translate3f(pos.x + width - 25.0f, pos.y + height - 25.0f, 0.0f);
+  gs_draw_sprite(nullptr, 0, 25.0f, 25.0f);
+  gs_matrix_pop();
+
   gs_matrix_pop();
 
   gs_technique_end_pass(tech);
@@ -575,6 +640,8 @@ bool draw_box(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
 }
 
 void draw_callback(void* data, uint32_t cx, uint32_t cy) {
+  ObsInterface* obsInterface = (ObsInterface*)data;
+
   obs_video_info ovi;
   obs_get_video_info(&ovi);
 
@@ -606,7 +673,9 @@ void draw_callback(void* data, uint32_t cx, uint32_t cy) {
 
   // 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();
@@ -657,13 +726,13 @@ 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);
 }
 
-void ObsInterface::showPreview(int x, int y, int width, int height) {
+void ObsInterface::configurePreview(int x, int y, int width, int height) {
   blog(LOG_INFO, "ObsInterface::showPreview");
 
   if (!preview_hwnd || !display) {
@@ -671,7 +740,7 @@ 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);
+  blog(LOG_INFO, "Moving preview child window to (%d, %d) with size (%d x %d)", x, y, width, height);
 
   // Resize and move the existing child window.
   bool success = SetWindowPos(
@@ -690,8 +759,18 @@ void ObsInterface::showPreview(int x, int y, int width, int height) {
   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);
+  obs_display_set_enabled(display, true);
+}
+
+void ObsInterface::showPreview() {
+  blog(LOG_INFO, "ObsInterface::showPreview");
+
+  if (!preview_hwnd || !display) {
+    blog(LOG_ERROR, "Preview window not initialized");
+    return;
+  }
+
   ShowWindow(preview_hwnd, SW_SHOW);
   obs_display_set_enabled(display, true);
 }
@@ -703,14 +782,24 @@ void ObsInterface::hidePreview() {
     ShowWindow(preview_hwnd, SW_HIDE);
     blog(LOG_INFO, "Preview child window hidden");
   }
+}
+
+void ObsInterface::disablePreview() {
+  blog(LOG_INFO, "ObsInterface::disablePreview");
+
+  if (!display) {
+    blog(LOG_ERROR, "Preview window not initialized");
+    return;
+  }
 
+  hidePreview();
   obs_display_set_enabled(display, false);
 }
 
-float ObsInterface::getPreviewScaleFactor() {
+PreviewInfo ObsInterface::getPreviewInfo() {
   if (!display) {
-    blog(LOG_WARNING, "Display not initialized");
-    return 1.0f; // Default scale
+    blog(LOG_WARNING, "Display not initialized when calling getPreviewInfo");
+    return { 1920, 1080, 1920, 1080 }; // Default values
   }
 
   obs_video_info ovi;
@@ -719,25 +808,27 @@ float ObsInterface::getPreviewScaleFactor() {
   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);
+  PreviewInfo info = {
+    ovi.base_width,
+    ovi.base_height,
+    width,
+    height,
+  };
 
-  float previewScale;
+  return info;
+}
 
-  // Pick the limiting scale factor.
-  if (scaleX < scaleY) {
-    previewScale = scaleX;
-  } else {
-    previewScale = scaleY;
-  }
+void ObsInterface::setDrawSourceOutline(bool enabled) {
+  drawSourceOutline = enabled;
+}
 
-  return previewScale;
+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
 ) {
@@ -746,16 +837,23 @@ 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;
   recording_path = recordingPath;
 
+  starting_ctx = new SignalContext{ this, "starting" };
+  start_ctx = new SignalContext{ this, "start" };
+  stopping_ctx = new SignalContext{ this, "stopping" };
+  stop_ctx = new SignalContext{ this, "stop" };
+
   // Create the resources we rely on.
   create_output();
   create_scene();
 
+  video_encoder_id = "obs_x264";
+  video_encoder_settings = obs_data_create();
   create_video_encoders();
   create_audio_encoders();
 }
@@ -763,14 +861,26 @@ ObsInterface::ObsInterface(
 ObsInterface::~ObsInterface() {
   blog(LOG_DEBUG, "Destroying ObsInterface");
 
-  if (jscb) {
-    blog(LOG_DEBUG, "Releasing JavaScript callback");
-    jscb.Release();
+  for (auto& kv : volmeters) {
+    obs_volmeter_t* volmeter = kv.second;
+    obs_volmeter_remove_callback(volmeter, volmeter_callback, this);
+    obs_volmeter_detach_source(volmeter);
+    obs_volmeter_destroy(volmeter);
+    blog(LOG_INFO, "Volmeter deleted for source: %s", kv.first.c_str());
+    volmeters.erase(kv.first);
   }
 
-  if (video_source) {
-    blog(LOG_DEBUG, "Releasing video source");
-    obs_source_release(video_source);
+  delete starting_ctx;
+  delete start_ctx;
+  delete stopping_ctx;
+  delete stop_ctx;
+
+  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);
+    sources.erase(name);
   }
 
   if (scene) {
@@ -810,6 +920,11 @@ ObsInterface::~ObsInterface() {
 
   blog(LOG_DEBUG, "Now shutting down OBS");
   obs_shutdown();
+
+  if (jscb) {
+    blog(LOG_DEBUG, "Releasing JavaScript callback");
+    jscb.Release();
+  }
 }
 
 bool ObsInterface::setBuffering(bool value) {
@@ -880,6 +995,14 @@ void ObsInterface::startRecording(int offset) {
       throw std::runtime_error("Failed to call convert procedure handler");
     }
   } else {
+    
+    obs_data_t *ffmpeg_settings = obs_data_create();
+    std::string filename = recording_path + "\\" + get_current_date_time() + ".mp4";
+    obs_data_set_string(ffmpeg_settings,  "path", filename.c_str());
+    obs_output_update(output, ffmpeg_settings);
+    obs_data_release(ffmpeg_settings);
+    unbuffered_output_filename = filename;
+
     blog(LOG_INFO, "Starting ffmpeg_muxer output");
 
     bool is_active = obs_output_active(output);
@@ -916,6 +1039,20 @@ void ObsInterface::stopRecording() {
   blog(LOG_INFO, "ObsInterface::stopRecording exited");
 }
 
+void ObsInterface::forceStopRecording() {
+  blog(LOG_INFO, "ObsInterface::forceStopRecording enter");
+  obs_output_t* output = buffering ? buffer_output : file_output;
+  bool is_active = obs_output_active(output);
+
+  if (!is_active) {
+    blog(LOG_WARNING, "Output is not active");
+    return;
+  }
+
+  obs_output_force_stop(output);
+  blog(LOG_INFO, "ObsInterface::forceStopRecording exited");
+}
+
 std::string ObsInterface::getLastRecording() {
   blog(LOG_INFO, "calling get last replay proc handler");
   calldata cd;
@@ -928,7 +1065,7 @@ std::string ObsInterface::getLastRecording() {
 
   if (!buffering) {
     blog(LOG_INFO, "Getting last recording path from ffmpeg_muxer");
-    return recording_path;
+    return unbuffered_output_filename;
   }
 
   bool success = proc_handler_call(ph, "get_last_replay", &cd);
@@ -952,21 +1089,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");
@@ -988,16 +1126,24 @@ void ObsInterface::removeSourceFromScene(std::string name) {
 
 void ObsInterface::getSourcePos(std::string name, vec2* pos, vec2* size, vec2* scale) 
 {
-  obs_source_t *src = obs_get_source_by_name(name.c_str());
-  obs_sceneitem_t *item = obs_scene_find_source(scene, 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!");
+  }
 
-  if (!src) {
-    blog(LOG_WARNING, "Did not find source for video source: %s", name);
+  obs_source_t* source = it->second;
+
+  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;
   }
 
@@ -1005,18 +1151,128 @@ 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);
+  size->x = obs_source_get_width(source);
+  size->y = obs_source_get_height(source);
 }
 
 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_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;
   }
 
   obs_sceneitem_set_pos(item, pos);
   obs_sceneitem_set_scale(item, scale);
+}
+
+std::vector<std::string> ObsInterface::listAvailableVideoEncoders()
+{
+  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::setVideoEncoder(std::string id, obs_data_t* settings) {
+  // TODO don't allow this if output is active.
+  video_encoder_id = id;
+  video_encoder_settings = settings;
+  create_video_encoders();
+}
+
+void ObsInterface::setMuteAudioInputs(bool mute) {
+  // Loop over all sources, and set the mute state if they are of type "wasapi_input_capture".
+  for (const auto& kv : sources) {
+    const std::string& name = kv.first;
+    obs_source_t* source = kv.second;
+
+    if (!source) {
+      blog(LOG_WARNING, "Source %s not found", name.c_str());
+      continue;
+    }
+
+    const char* type = obs_source_get_id(source);
+
+    if (strcmp(type, AUDIO_INPUT) == 0) {
+      obs_source_set_muted(source, mute);
+    }
+  }
+}
+
+void ObsInterface::setOutputVolume(float volume) {
+  blog(LOG_INFO, "Setting output volume to %f", volume);
+  output_volume = volume;
+
+  for (const auto& kv : sources) {
+    const std::string& name = kv.first;
+    obs_source_t* source = kv.second;
+
+    if (!source) {
+      blog(LOG_WARNING, "Source %s not found", name.c_str());
+      continue;
+    }
+
+    const char* type = obs_source_get_id(source);
+
+    if (strcmp(type, AUDIO_OUTPUT) == 0) {
+      obs_source_set_volume(source, output_volume);
+    }
+  }
+}
+
+void ObsInterface::setInputVolume(float volume) {
+  blog(LOG_INFO, "Setting input volume to %f", volume);
+  input_volume = volume;
+
+  for (const auto& kv : sources) {
+    const std::string& name = kv.first;
+    obs_source_t* source = kv.second;
+
+    if (!source) {
+      blog(LOG_WARNING, "Source %s not found", name.c_str());
+      continue;
+    }
+
+    const char* type = obs_source_get_id(source);
+
+    if (strcmp(type, AUDIO_INPUT) == 0) {
+      obs_source_set_volume(source, input_volume);
+    }
+  }
+}
+
+void ObsInterface::setProcessVolume(float volume) {
+  blog(LOG_INFO, "Setting process volume to %f", volume);
+  process_volume = volume;
+
+  for (const auto& kv : sources) {
+    const std::string& name = kv.first;
+    obs_source_t* source = kv.second;
+
+    if (!source) {
+      blog(LOG_WARNING, "Source %s not found", name.c_str());
+      continue;
+    }
+
+    const char* type = obs_source_get_id(source);
+
+    if (strcmp(type, AUDIO_PROCESS) == 0) {
+      obs_source_set_volume(source, process_volume);
+    }
+  }
+}
+
+void ObsInterface::setVolmeterEnabled(bool enabled) {
+  blog(LOG_INFO, "Setting volmeter enabled: %d", enabled);
+  volmeter_enabled = enabled;
 }