noobs 0.0.89 → 0.0.130

package/src/obs_interface.cpp

@@ -8,46 +8,34 @@
 #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;
 
@@ -56,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;
 
@@ -78,9 +55,10 @@ void ObsInterface::list_output_types()
   }
 }
 
-void ObsInterface::load_module(const char* module, const char* data) {
+void ObsInterface::load_module(const char* module, const char* data, bool allowFail) {
   blog(LOG_INFO, "Loading module: %s", module);
   blog(LOG_INFO, "Data path: %s", data);
+  blog(LOG_INFO, "Allow fail: %d", allowFail);
 
   obs_module_t *ptr = NULL;
   int success = obs_open_module(&ptr, module, data);
@@ -92,22 +70,60 @@ void ObsInterface::load_module(const char* module, const char* data) {
 
   bool initmod = obs_init_module(ptr);
 
-  if (!initmod) {
-    blog(LOG_ERROR, "Failed to initialize module!");
+  if (initmod) {
+    blog(LOG_INFO, "Module initialized successfully!");
+  } else if (allowFail) {
+    blog(LOG_INFO, "Module initialization failed, but allowed to fail: %s", module);
+  } else {
+    blog(LOG_ERROR, "Failed to initialize module: %s", module);
     throw std::runtime_error("Module initialization failed!");
   }
 }
 
-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;
@@ -118,29 +134,14 @@ 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& distPath) {
@@ -166,10 +167,12 @@ void ObsInterface::init_obs(const std::string& distPath) {
 
   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
@@ -177,28 +180,43 @@ void ObsInterface::init_obs(const std::string& distPath) {
   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", 
-    "obs-ffmpeg",
+    "obs-x264",     // Software encoder.
+    "obs-ffmpeg",   // Contains AMF (AMD) encoder support.
     "win-capture",  // Required for basically all forms of capture on Windows.
     "image-source", // Required for image sources.
-    "win-wasapi"    // Required for WASAPI audio input.
+    "win-wasapi",   // Required for WASAPI audio input.
+    "obs-nvenc",    // Required for NVENC video encoding.
+    "obs-qsv11",    // Required for QSV video encoding.
+    "obs-filters"   // Required for audio filters.
   };
 
   for (const auto& module : modules) {
     std::string modulePath = pluginPath + module + ".dll";
-    std::string moduleDataPath = pluginPath + module;
-    load_module(modulePath.c_str(), moduleDataPath.c_str());
+    std::string moduleDataPath = pluginDataPath + module;
+
+    // NVENC fails if there is no NVENC hardware support.
+    bool allowFail = module == "obs-nvenc";
+    load_module(modulePath.c_str(), moduleDataPath.c_str(), allowFail);
   }
   
   obs_post_load_modules();
 
   list_encoders();
   list_source_types();
-  list_input_types();
   list_output_types();
 
   blog(LOG_INFO, "Exit init_obs");
@@ -207,158 +225,119 @@ void ObsInterface::init_obs(const std::string& distPath) {
 void ObsInterface::create_output() {
   blog(LOG_INFO, "Create outputs");
 
-  blog(LOG_INFO, "Creating replay buffer output");
-  buffer_output = obs_output_create("replay_buffer", "Buffer Output", NULL, NULL);
+  const char* type = buffering ? "replay_buffer" : "ffmpeg_muxer";
+  const char* name = buffering ? "Buffer Output" : "File Output";
 
-  if (!buffer_output) {
-    blog(LOG_ERROR, "Failed to create buffer output!");
-    throw std::runtime_error("Failed to create buffer output!");
+  if (output) {
+    blog(LOG_DEBUG, "Releasing existing output");
+    obs_output_release(output);
   }
 
-  blog(LOG_INFO, "Creating file output");
-  file_output = obs_output_create("ffmpeg_muxer", "File Output", NULL, NULL);
+  blog(LOG_INFO, "Creating replay buffer output");
+  output = obs_output_create(type, name, NULL, NULL);
 
-  if (!file_output) {
-    blog(LOG_ERROR, "Failed to create file output!");
-    throw std::runtime_error("Failed to create file output!");
+  if (!output) {
+    blog(LOG_ERROR, "Failed to create output!");
+    throw std::runtime_error("Failed to create output!");
   }
 
-  obs_data_t *buffer_settings = obs_data_create();
-  blog(LOG_INFO, "Set replay_buffer settings");
-  obs_data_set_int(buffer_settings, "max_time_sec", 60);
-  obs_data_set_int(buffer_settings, "max_size_mb", 1024);
-  obs_data_set_string(buffer_settings, "directory", recording_path.c_str());
-  obs_data_set_string(buffer_settings, "format", "%CCYY-%MM-%DD %hh-%mm-%ss");
-  obs_data_set_string(buffer_settings, "extension", "mp4");
-  obs_output_update(buffer_output, buffer_settings);
-  obs_data_release(buffer_settings);
+  obs_data_t *settings = obs_data_create();
 
-  blog(LOG_INFO, "Set ffmpeg_muxer settings");
-  obs_data_t *ffmpeg_settings = obs_data_create();
-  // Need to specify the exact path for ffmpeg_muxer.
-  std::string filename = recording_path + "\\" + get_current_date_time() + ".mp4";
-  obs_data_set_string(ffmpeg_settings, "path", filename.c_str());
-  recording_path = filename;
-
-  // Apply and release the settings.
-  obs_output_update(file_output, ffmpeg_settings);
-  obs_data_release(ffmpeg_settings);
+  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", recording_path.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");
+    // 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(settings, "path", filename.c_str());
+    unbuffered_output_filename = filename;
+  }
 
-  // Add the signal handler callback.
-  connect_signal_handlers(buffer_output);
-  connect_signal_handlers(file_output);
+  obs_output_update(output, settings);
+  obs_data_release(settings);
+  connect_signal_handlers(output);
 }
 
 void ObsInterface::setRecordingDir(const std::string& recordingPath) {
-  blog(LOG_INFO, "Set recording directory");
-  // TODO make this work for file output also.
-
-  obs_output_t *output = buffering ? buffer_output : file_output;
-
-  if (!output) {
-    blog(LOG_ERROR, "No output to update recording directory");
-    throw std::runtime_error("Output not initialized");
-  }
+  blog(LOG_INFO, "Set recording directory. Path: %s", recordingPath.c_str());
 
-  // 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");
-  }
+  recording_path = recordingPath;
+  create_output();
 
-  obs_data_set_string(settings, "directory", recordingPath.c_str());
-  obs_output_update(output, settings);
-  obs_data_release(settings);
+  create_video_encoders();
+  create_audio_encoders();
 }
 
 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 (video_encoder) {
+    blog(LOG_DEBUG, "Releasing file video encoder");
+    obs_encoder_release(video_encoder);
+    video_encoder = nullptr;
+  }
 
+  video_encoder = obs_video_encoder_create(
+    video_encoder_id.c_str(), 
+    "noobs_file_encoder", 
+    video_encoder_settings, 
+    NULL
+  );
 
-  if (!file_video_encoder) {
+  if (!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_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(buffer_video_encoder, obs_get_video());
+  obs_output_set_video_encoder(output, video_encoder);
+  obs_encoder_set_video(video_encoder, obs_get_video());
 }
 
 void ObsInterface::create_audio_encoders() {
   blog(LOG_INFO, "Create audio encoder");
 
-  // if (!output) {
-  //   blog(LOG_ERROR, "No output on create_audio_encoders");
-  //   throw std::runtime_error("Failed to create audio encoder!");
-  // }
-
-  // if (audio_encoder) {
-  //   blog(LOG_DEBUG, "Releasing audio encoder");
-  //   obs_encoder_release(audio_encoder);
-  //   audio_encoder = nullptr;
-  // }
+  if (audio_encoder) {
+    blog(LOG_DEBUG, "Releasing audio encoder");
+    obs_encoder_release(audio_encoder);
+    audio_encoder = nullptr;
+  }
 
-  file_audio_encoder = obs_audio_encoder_create("ffmpeg_aac", "aac_file", NULL, 0, NULL);
+  audio_encoder = obs_audio_encoder_create(
+    "ffmpeg_aac", 
+    "aac_file",
+    NULL, 
+    0, 
+    NULL
+  );
 
-  if (!file_audio_encoder) {
+  if (!audio_encoder) {
     blog(LOG_ERROR, "Failed to create audio encoder!");
     throw std::runtime_error("Failed to create audio encoder!");
   }
 
-  buffer_audio_encoder = obs_audio_encoder_create("ffmpeg_aac", "aac_buffer", NULL, 0, NULL);
-
-  if (!buffer_audio_encoder) {
-    blog(LOG_ERROR, "Failed to create buffer audio encoder!");
-    throw std::runtime_error("Failed to create buffer 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(file_audio_encoder, aenc_settings);
-  obs_encoder_update(buffer_audio_encoder, aenc_settings);
+  obs_encoder_update(audio_encoder, aenc_settings);
   obs_data_release(aenc_settings);
 
-  obs_output_set_audio_encoder(file_output, file_audio_encoder, 0);
-  obs_encoder_set_audio(file_audio_encoder, obs_get_audio());
-
-  obs_output_set_audio_encoder(buffer_output, buffer_audio_encoder, 0);
-  obs_encoder_set_audio(buffer_audio_encoder, obs_get_audio());
+  obs_output_set_audio_encoder(output, audio_encoder, 0);
+  obs_encoder_set_audio(audio_encoder, obs_get_audio());
 }
 
 void ObsInterface::create_scene() {
   blog(LOG_INFO, "Create scene");
-  scene = obs_scene_create("WCR Scene");
+  scene = obs_scene_create("Base Scene");
 
   if (!scene) {
     blog(LOG_ERROR, "Failed to create scene!");
@@ -375,12 +354,34 @@ void ObsInterface::create_scene() {
   obs_set_output_source(0, scene_source); // 0 = video track
 }
 
-void ObsInterface::createSource(std::string name, std::string type) {
+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);
+}
+
+std::string 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.
   );
@@ -390,23 +391,102 @@ void ObsInterface::createSource(std::string name, std::string type) {
     throw std::runtime_error("Failed to create source!");
   }
 
+  // The name might not match what we asked for if there is a duplicate.
+  // So pass it back to the client to avoid potential for a mismatch.
+  std::string real_name = obs_source_get_name(source);
+
+  if (type == AUDIO_OUTPUT || type == AUDIO_INPUT || type == AUDIO_PROCESS) {
+    blog(LOG_INFO, "Creating volmeter for source: %s", real_name.c_str());
+
+    obs_volmeter_t *volmeter = obs_volmeter_create(OBS_FADER_CUBIC);
+    obs_volmeter_attach_source(volmeter, source);
+
+    SignalContext* ctx = new SignalContext{ this, real_name }; // TODO don't leak this.
+    obs_volmeter_add_callback(volmeter, volmeter_callback, ctx);
+
+    // Store the volmeter in the volmeters map.
+    volmeters[real_name] = volmeter;
+  }
+
+  if (type == AUDIO_INPUT && force_mono) {
+    blog(LOG_INFO, "Setting force mono for new source: %s", real_name.c_str());
+    uint32_t flags = obs_source_get_flags(source);
+    obs_source_set_flags(source, flags | OBS_SOURCE_FLAG_FORCE_MONO);
+  }
+
+  if (type == AUDIO_INPUT && audio_suppression) {
+    blog(LOG_INFO, "Setting up filter for new source: %s", real_name.c_str());
+    std::string filter_name = "Filter for " + real_name;
+
+
+    obs_source_t *filter = obs_source_create(
+      "noise_suppress_filter_v2",   
+      filter_name.c_str(),   
+      nullptr, // Defaults are sensible.
+      nullptr
+    );
+
+    if (!filter) {
+      blog(LOG_ERROR, "Failed to create filter for source: %s", real_name.c_str());
+      throw std::runtime_error("Failed to create filter!");
+    }
+
+    filters[real_name] = filter;
+    obs_source_filter_add(source, filter);
+  }
+
   // Store the source in the sources map.
-  sources[name] = source;
+  sources[real_name] = source;
+
+  // Store the dimensions so we can fire a callback if they change.
+  uint32_t w = obs_source_get_width(source);
+  uint32_t h = obs_source_get_height(source);
+  sizes[real_name] = { w, h };
+
+  return real_name;
 }
 
 void ObsInterface::deleteSource(std::string name) {
   blog(LOG_INFO, "Delete source: %s", 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 (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());
+    blog(LOG_WARNING, "Source %s not found when deleting", name.c_str());
     return;
   }
 
   obs_source_t* source = it->second;
+
+  // Remove and release any filters.
+  auto filter_it = filters.find(name);
+  
+  if (filter_it != filters.end()) {
+    obs_source_t* filter = filter_it->second;
+    obs_source_filter_remove(source, filter);
+    obs_source_release(filter);
+    filters.erase(name);
+    blog(LOG_INFO, "Filter deleted for source: %s", name.c_str());
+  }
+
+  obs_source_remove(source); // ???
   obs_source_release(source);
   sources.erase(name);
+  sizes.erase(name);
   blog(LOG_INFO, "Source deleted: %s", name.c_str());
 }
 
@@ -416,7 +496,7 @@ obs_data_t* ObsInterface::getSourceSettings(std::string name) {
   auto it = sources.find(name);
 
   if (it == sources.end()) {
-    blog(LOG_WARNING, "Source %s not found", name.c_str());
+    blog(LOG_WARNING, "Source %s not found when getting settings", name.c_str());
     throw std::runtime_error("Source not found!");
   }
 
@@ -437,13 +517,27 @@ void ObsInterface::setSourceSettings(std::string name, obs_data_t* settings) {
   auto it = sources.find(name);
 
   if (it == sources.end()) {
-    blog(LOG_WARNING, "Source %s not found", name.c_str());
+    blog(LOG_WARNING, "Source %s not found when setting settings", name.c_str());
     throw std::runtime_error("Source not found!");
   }
 
   obs_source_t* source = it->second;
-
   obs_source_update(source, settings);
+
+  // If this is an audio source, it may have an attached volmeter.
+  auto vol_it = volmeters.find(name);
+  
+  if (vol_it != volmeters.end()) {
+    // Rebind it. This avoids leaving it attached to stale audio stream
+    // in the event of a device change.
+    blog(LOG_INFO, "Rebinding volmeter for source: %s", name.c_str());
+    obs_volmeter_t* volmeter = vol_it->second;
+    obs_volmeter_attach_source(volmeter, source);
+
+    // Flush the volmeter: send a zero signal in-case it never triggers any
+    // more callbacks. That can happen on selecting a device with no audio.
+    zeroVolmeter(name);
+  }
 }
 
 obs_properties_t* ObsInterface::getSourceProperties(std::string name) {
@@ -451,7 +545,7 @@ obs_properties_t* ObsInterface::getSourceProperties(std::string name) {
   auto it = sources.find(name);
 
   if (it == sources.end()) {
-    blog(LOG_WARNING, "Source %s not found", name.c_str());
+    blog(LOG_WARNING, "Source %s not found when getting properties", name.c_str());
     throw std::runtime_error("Source not found!");
   }
 
@@ -466,65 +560,30 @@ 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_source_outline(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
@@ -582,6 +641,12 @@ bool draw_source_outline(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);
@@ -622,15 +687,30 @@ void draw_callback(void* data, uint32_t cx, uint32_t cy) {
   // 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");
+  // Draw boxes around sources, if enabled.
   if (obsInterface->getDrawSourceOutlineEnabled()) {
+    obs_scene_t* scene = obs_get_scene_by_name("Base Scene");
     obs_scene_enum_items(scene, draw_source_outline, NULL);
+    obs_scene_release(scene);
   }
-  obs_scene_release(scene);
 
 	gs_projection_pop();
 	gs_viewport_pop();
+
+  // Iterate over the sources and check for changes to size.
+  for (const auto& [name, source] : obsInterface->sources) {
+    SourceSize last = obsInterface->sizes[name];
+
+    uint32_t w = obs_source_get_width(source);
+    uint32_t h = obs_source_get_height(source);
+
+    if (w != last.width || h != last.height) {
+      blog(LOG_INFO, "Source %s changed size from (%d x %d) to (%d x %d)",
+            name.c_str(), last.width, last.height, w, h);
+      obsInterface->sourceCallback(name);
+      obsInterface->sizes[name] = { w, h };
+    }
+  }
 }
 
 void ObsInterface::initPreview(HWND parent) {
@@ -683,15 +763,15 @@ void ObsInterface::initPreview(HWND parent) {
   obs_display_set_enabled(display, false);
 }
 
-void ObsInterface::showPreview(int x, int y, int width, int height) {
-  blog(LOG_INFO, "ObsInterface::showPreview");
+void ObsInterface::configurePreview(int x, int y, int width, int height) {
+  blog(LOG_INFO, "ObsInterface::configurePreview");
 
   if (!preview_hwnd || !display) {
     blog(LOG_ERROR, "Preview window not initialized");
     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(
@@ -710,8 +790,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);
 }
@@ -723,14 +813,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;
@@ -739,19 +839,14 @@ 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);
-
-  float previewScale;
-
-  // Pick the limiting scale factor.
-  if (scaleX < scaleY) {
-    previewScale = scaleX;
-  } else {
-    previewScale = scaleY;
-  }
+  PreviewInfo info = {
+    ovi.base_width,
+    ovi.base_height,
+    width,
+    height,
+  };
 
-  return previewScale;
+  return info;
 }
 
 void ObsInterface::setDrawSourceOutline(bool enabled) {
@@ -765,7 +860,6 @@ bool ObsInterface::getDrawSourceOutlineEnabled() {
 ObsInterface::ObsInterface(
   const std::string& distPath, 
   const std::string& logPath, 
-  const std::string& recordingPath,
   Napi::ThreadSafeFunction cb
 ) {
   // Setup logs first so we have logs for the initialization.
@@ -777,12 +871,16 @@ ObsInterface::ObsInterface(
 
   // Setup callback function.
   jscb = cb;
-  recording_path = recordingPath;
+
+  // Contexts for signal callbacks.
+  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();
-
+  create_output();
   create_video_encoders();
   create_audio_encoders();
 }
@@ -790,16 +888,37 @@ 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);
   }
 
+  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;
+
+    auto filter_it = filters.find(name);
+
+    if (filter_it != filters.end()) {
+      obs_source_t* filter = filter_it->second;
+      obs_source_filter_remove(source, filter);
+      obs_source_release(filter);
+      filters.erase(name);
+      blog(LOG_INFO, "Filter removed for source: %s on shutdown", name.c_str());
+    }
+
     blog(LOG_DEBUG, "Releasing source: %s", name.c_str());
     obs_source_release(source);
+    sources.erase(name);
   }
 
   if (scene) {
@@ -807,24 +926,14 @@ ObsInterface::~ObsInterface() {
     obs_scene_release(scene);
   }
 
-  if (buffer_output) {
-    if (obs_output_active(buffer_output)) {
-      blog(LOG_DEBUG, "Force stopping output");
-      obs_output_force_stop(buffer_output);
-    }
-      
-    blog(LOG_DEBUG, "Releasing output");
-    obs_output_release(buffer_output);
-  }
-
-  if (file_output) {
-    if (obs_output_active(file_output)) {
+  if (output) {
+    if (obs_output_active(output)) {
       blog(LOG_DEBUG, "Force stopping output");
-      obs_output_force_stop(file_output);
+      obs_output_force_stop(output);
     }
       
     blog(LOG_DEBUG, "Releasing output");
-    obs_output_release(file_output);
+    obs_output_release(output);
   }
 
   // if (video_encoder) {
@@ -839,18 +948,21 @@ ObsInterface::~ObsInterface() {
 
   blog(LOG_DEBUG, "Now shutting down OBS");
   obs_shutdown();
-}
 
-bool ObsInterface::setBuffering(bool value) {
-  obs_output_t* output = buffering ? buffer_output : file_output;
+  if (jscb) {
+    blog(LOG_DEBUG, "Releasing JavaScript callback");
+    jscb.Release();
+  }
+}
 
+void ObsInterface::setBuffering(bool value) {
   if (obs_output_active(output)) {
     blog(LOG_ERROR, "Cannot change buffering state while output is active");
-    return false;
+    throw new std::runtime_error("Cannot change buffering state while output is active");
   }
 
   buffering = value;
-  return buffering;
+  create_output();
 }
 
 void ObsInterface::startBuffering() {
@@ -861,8 +973,6 @@ void ObsInterface::startBuffering() {
     throw std::runtime_error("Buffering is not enabled!");
   }
 
-  obs_output_t* output = buffer_output;
-
   if (!output) {
     blog(LOG_ERROR, "Output is not initialized!");
     throw std::runtime_error("Output is not initialized!");
@@ -887,7 +997,11 @@ void ObsInterface::startBuffering() {
 
 void ObsInterface::startRecording(int offset) {
   blog(LOG_INFO, "ObsInterface::startRecording enter");
-  obs_output_t* output = buffering ? buffer_output : file_output;
+
+  if (recording_path == "") {
+    blog(LOG_ERROR, "Recording path is not set");
+    throw std::runtime_error("Recording path is not set");
+  }
 
   if (buffering) {
     bool is_active = obs_output_active(output);
@@ -906,9 +1020,17 @@ void ObsInterface::startRecording(int offset) {
     calldata_free(&cd);
 
     if (!success) {
+      blog(LOG_ERROR, "Failed to call convert procedure handler");
       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);
@@ -933,7 +1055,6 @@ void ObsInterface::startRecording(int offset) {
 
 void ObsInterface::stopRecording() {
   blog(LOG_INFO, "ObsInterface::stopRecording enter");
-  obs_output_t* output = buffering ? buffer_output : file_output;
   bool is_active = obs_output_active(output);
 
   if (!is_active) {
@@ -945,19 +1066,31 @@ void ObsInterface::stopRecording() {
   blog(LOG_INFO, "ObsInterface::stopRecording exited");
 }
 
+void ObsInterface::forceStopRecording() {
+  blog(LOG_INFO, "ObsInterface::forceStopRecording enter");
+  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;
   calldata_init(&cd);
 
-  obs_output_t* output = buffering ? buffer_output : file_output;
   proc_handler_t *ph = obs_output_get_proc_handler(output);
 
   const char* type = obs_output_get_id(output);
 
   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);
@@ -984,7 +1117,7 @@ void ObsInterface::addSourceToScene(std::string name) {
   auto it = sources.find(name);
 
   if (it == sources.end()) {
-    blog(LOG_WARNING, "Source %s not found", name.c_str());
+    blog(LOG_WARNING, "Source %s not found when adding to scene", name.c_str());
     throw std::runtime_error("Source not found!");
   }
 
@@ -1021,7 +1154,7 @@ void ObsInterface::getSourcePos(std::string name, vec2* pos, vec2* size, vec2* s
   auto it = sources.find(name);
 
   if (it == sources.end()) {
-    blog(LOG_WARNING, "Source %s not found", name.c_str());
+    blog(LOG_WARNING, "Source %s not found when getting source position", name.c_str());
     throw std::runtime_error("Source not found!");
   }
 
@@ -1057,4 +1190,181 @@ void ObsInterface::setSourcePos(std::string name, vec2* pos, vec2* scale) {
 
   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) {
+  if (obs_output_active(output)) {
+    blog(LOG_WARNING, "Cannot change video encoder while output is active");
+    throw new std::runtime_error("Output is active when trying to change encoder");
+  }
+
+  video_encoder_id = id;
+  obs_data_release(video_encoder_settings);
+  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 when muting audio inputs", 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::setSourceVolume(std::string name, float volume) {
+  blog(LOG_INFO, "Setting source %s volume to %f", name.c_str(), volume);
+
+  auto it = sources.find(name);
+
+  if (it == sources.end()) {
+    blog(LOG_WARNING, "Source %s not found when setting volume", name.c_str());
+    return;
+  }
+
+  obs_source_t* source = it->second;
+  const char* type = obs_source_get_id(source);
+  
+  bool audio = 
+    strcmp(type, AUDIO_OUTPUT) == 0 || 
+    strcmp(type, AUDIO_INPUT) == 0  || 
+    strcmp(type, AUDIO_PROCESS) == 0;
+
+  if (!audio) {
+    blog(LOG_WARNING, "Source %s is not a valid audio source", name.c_str());
+    return;
+  }
+
+  obs_source_set_volume(source, volume);
+}
+
+void ObsInterface::setVolmeterEnabled(bool enabled) {
+  blog(LOG_INFO, "Setting volmeter enabled: %d", enabled);
+  volmeter_enabled = enabled;
+}
+
+void ObsInterface::setForceMono(bool enabled) {
+  blog(LOG_INFO, "%s force mono on all input sources", enabled ? "Enabling" : "Disabling");
+  force_mono = enabled;
+
+  // Loop over existing sources and update the force mono flags.
+  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 when setting force mono", name.c_str());
+      continue;
+    }
+
+    const char* type = obs_source_get_id(source);
+
+    if (strcmp(type, AUDIO_INPUT) != 0) {
+      // Force mono is only applicable to microphones, skip other types.
+      continue;
+    }
+
+    if (enabled) {
+      blog(LOG_INFO, "Setting force mono flag on source %s", name.c_str());
+      uint32_t flags = obs_source_get_flags(source);
+      obs_source_set_flags(source, flags | OBS_SOURCE_FLAG_FORCE_MONO);
+    } else {
+      blog(LOG_INFO, "Unsetting force mono flag on source %s", name.c_str());
+      uint32_t flags = obs_source_get_flags(source);
+      obs_source_set_flags(source, flags & ~OBS_SOURCE_FLAG_FORCE_MONO);
+    }
+  }
+}
+
+void ObsInterface::setAudioSuppression(bool enabled) {
+  blog(LOG_INFO, "%s audio suppression on all input devices", enabled ? "Enabling" : "Disabling");
+  audio_suppression = enabled;
+
+  // Loop over existing sources and add filters to any that need it.
+  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 when adding filters", name.c_str());
+      continue;
+    }
+
+    const char* type = obs_source_get_id(source);
+
+    if (strcmp(type, AUDIO_INPUT) != 0) {
+      // Don't care about non-input sources. This is purely for suppressing
+      // microphone background noise.
+      continue;
+    }
+
+    // Check for a filter existing and add or remove it as appropriate.
+    auto filter_it = filters.find(name);
+    
+    if (audio_suppression && filter_it == filters.end()) {
+      blog(LOG_INFO, "Setting up filter for source: %s", name.c_str());
+      
+      std::string filter_name = "Filter for " + name;
+
+      obs_source_t *filter = obs_source_create(
+        "noise_suppress_filter_v2",   
+        filter_name.c_str(),   
+        nullptr, // Defaults are sensible.
+        nullptr
+      );
+
+      if (!filter) {
+        blog(LOG_ERROR, "Failed to create filter for source: %s", name.c_str());
+        throw std::runtime_error("Failed to create filter!");
+      }
+
+      filters[name] = filter;
+      obs_source_filter_add(source, filter);
+    } else if (!audio_suppression && filter_it != filters.end()) {
+      blog(LOG_INFO, "Removing filters for source: %s", name.c_str());
+      obs_source_t* filter = filter_it->second;
+      obs_source_filter_remove(source, filter);
+      filters.erase(name);
+      obs_source_release(filter);
+    }
+  }
+}
+
+void ObsInterface::sourceCallback(std::string name) {
+  blog(LOG_INFO, "Source callback triggered for %s", name.c_str());
+  SignalData* sd = new SignalData{ "source", name.c_str(), 0 };
+  jscb.NonBlockingCall(sd, call_jscb);
+}
+
+void ObsInterface::zeroVolmeter(std::string name) {
+  blog(LOG_INFO, "Zeroing volmeter for %s", name.c_str());
+  SignalData* sd = new SignalData{ "volmeter", name.c_str(), 0, 0 };
+  jscb.NonBlockingCall(sd, call_jscb);
+}