noobs 0.0.115 → 0.0.130

package/src/obs_interface.cpp

@@ -55,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);
@@ -69,8 +70,12 @@ 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!");
   }
 }
@@ -189,17 +194,23 @@ void ObsInterface::init_obs(const std::string& distPath) {
   }
 
   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 = pluginDataPath + module;
-    load_module(modulePath.c_str(), moduleDataPath.c_str());
+
+    // 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();
@@ -214,168 +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. 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());
-  unbuffered_output_filename = 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;
+  blog(LOG_INFO, "Set recording directory. Path: %s", recordingPath.c_str());
 
-  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");
-  }
+  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, "Set video encoder: %s", video_encoder_id.c_str());
 
-  if (file_video_encoder) {
+  if (video_encoder) {
     blog(LOG_DEBUG, "Releasing file video encoder");
-    obs_encoder_release(file_video_encoder);
-    file_video_encoder = nullptr;
+    obs_encoder_release(video_encoder);
+    video_encoder = nullptr;
   }
 
-  file_video_encoder = obs_video_encoder_create(
+  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!");
   }
 
-  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!");
-  }
-
-  obs_output_set_video_encoder(file_output, file_video_encoder);
-  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());
+  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!");
@@ -414,7 +376,7 @@ void ObsInterface::volmeter_callback(void *data,
   self->jscb.NonBlockingCall(sd, call_jscb);
 }
 
-void ObsInterface::createSource(std::string name, std::string type) {
+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(
@@ -429,32 +391,59 @@ void ObsInterface::createSource(std::string name, std::string type) {
     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);
-  }
+  // 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", name.c_str());
+    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, name }; // TODO don't leak this.
+    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[name] = volmeter;
+    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) {
@@ -477,14 +466,27 @@ void ObsInterface::deleteSource(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 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());
 }
 
@@ -494,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!");
   }
 
@@ -515,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) {
@@ -529,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!");
   }
 
@@ -671,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) {
@@ -733,7 +764,7 @@ void ObsInterface::initPreview(HWND parent) {
 }
 
 void ObsInterface::configurePreview(int x, int y, int width, int height) {
-  blog(LOG_INFO, "ObsInterface::showPreview");
+  blog(LOG_INFO, "ObsInterface::configurePreview");
 
   if (!preview_hwnd || !display) {
     blog(LOG_ERROR, "Preview window not initialized");
@@ -829,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.
@@ -841,19 +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();
-
-  video_encoder_id = "obs_x264";
-  video_encoder_settings = obs_data_create();
+  create_output();
   create_video_encoders();
   create_audio_encoders();
 }
@@ -878,6 +905,17 @@ ObsInterface::~ObsInterface() {
   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);
@@ -888,24 +926,14 @@ ObsInterface::~ObsInterface() {
     obs_scene_release(scene);
   }
 
-  if (buffer_output) {
-    if (obs_output_active(buffer_output)) {
+  if (output) {
+    if (obs_output_active(output)) {
       blog(LOG_DEBUG, "Force stopping output");
-      obs_output_force_stop(buffer_output);
+      obs_output_force_stop(output);
     }
       
     blog(LOG_DEBUG, "Releasing output");
-    obs_output_release(buffer_output);
-  }
-
-  if (file_output) {
-    if (obs_output_active(file_output)) {
-      blog(LOG_DEBUG, "Force stopping output");
-      obs_output_force_stop(file_output);
-    }
-      
-    blog(LOG_DEBUG, "Releasing output");
-    obs_output_release(file_output);
+    obs_output_release(output);
   }
 
   // if (video_encoder) {
@@ -927,16 +955,14 @@ ObsInterface::~ObsInterface() {
   }
 }
 
-bool ObsInterface::setBuffering(bool value) {
-  obs_output_t* output = buffering ? buffer_output : file_output;
-
+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() {
@@ -947,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!");
@@ -973,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);
@@ -992,10 +1020,10 @@ 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());
@@ -1027,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) {
@@ -1041,7 +1068,6 @@ void ObsInterface::stopRecording() {
 
 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) {
@@ -1058,7 +1084,6 @@ std::string ObsInterface::getLastRecording() {
   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);
@@ -1092,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!");
   }
 
@@ -1129,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!");
   }
 
@@ -1184,8 +1209,13 @@ std::vector<std::string> ObsInterface::listAvailableVideoEncoders()
 }
 
 void ObsInterface::setVideoEncoder(std::string id, obs_data_t* settings) {
-  // TODO don't allow this if output is active.
+  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();
 }
@@ -1197,7 +1227,7 @@ void ObsInterface::setMuteAudioInputs(bool mute) {
     obs_source_t* source = kv.second;
 
     if (!source) {
-      blog(LOG_WARNING, "Source %s not found", name.c_str());
+      blog(LOG_WARNING, "Source %s not found when muting audio inputs", name.c_str());
       continue;
     }
 
@@ -1209,70 +1239,132 @@ void ObsInterface::setMuteAudioInputs(bool mute) {
   }
 }
 
-void ObsInterface::setOutputVolume(float volume) {
-  blog(LOG_INFO, "Setting output volume to %f", volume);
-  output_volume = volume;
+void ObsInterface::setSourceVolume(std::string name, float volume) {
+  blog(LOG_INFO, "Setting source %s volume to %f", name.c_str(), volume);
 
-  for (const auto& kv : sources) {
-    const std::string& name = kv.first;
-    obs_source_t* source = kv.second;
+  auto it = sources.find(name);
 
-    if (!source) {
-      blog(LOG_WARNING, "Source %s not found", name.c_str());
-      continue;
-    }
+  if (it == sources.end()) {
+    blog(LOG_WARNING, "Source %s not found when setting volume", name.c_str());
+    return;
+  }
 
-    const char* type = obs_source_get_id(source);
+  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 (strcmp(type, AUDIO_OUTPUT) == 0) {
-      obs_source_set_volume(source, output_volume);
-    }
+  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::setInputVolume(float volume) {
-  blog(LOG_INFO, "Setting input volume to %f", volume);
-  input_volume = 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", name.c_str());
+      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) {
-      obs_source_set_volume(source, input_volume);
+    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::setProcessVolume(float volume) {
-  blog(LOG_INFO, "Setting process volume to %f", volume);
-  process_volume = volume;
+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", name.c_str());
+      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_PROCESS) == 0) {
-      obs_source_set_volume(source, process_volume);
+    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::setVolmeterEnabled(bool enabled) {
-  blog(LOG_INFO, "Setting volmeter enabled: %d", enabled);
-  volmeter_enabled = enabled;
-}
+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);
+}