noobs 0.0.89 → 0.0.115

package/index.d.ts

@@ -136,8 +136,10 @@ export type ObsProperty =
   | ObsGenericProperty;
 
 export type Signal = {
+  type: string; // Either "output" or "volmeter".
   id: string; // Signal identifier, e.g. "stop"
   code: number; // 0 for success, other values for errors
+  value?: number; // Currently only used for volmeters.
 };
 
 export type SceneItemPosition = {
@@ -162,43 +164,50 @@ interface Noobs {
 
   Shutdown(): void;
 
-  // Recording functions
+  // Recording functions.
   SetBuffering(buffering: boolean): void; // In buffering mode, the recording is stored in memory and can be converted to a file later.
   StartBuffer(): void;
   StartRecording(offset: number): void;
   StopRecording(): void;
+  ForceStopRecording(): void;
   GetLastRecording(): string;
   SetRecordingDir(recordingPath: string): void;
+  ResetVideoContext(fps: number, width: number, height: number): void;
 
-  // Source management functions
+  // Encoder functions.
+  ListVideoEncoders(): string[]; // Returns a list of available video encoders.
+  SetVideoEncoder(id: string, settings: ObsData): void; // Create the video encoder to use.
+
+  // Source management functions.
   CreateSource(name: string, type: string): void;
   DeleteSource(name: string): void;
   GetSourceSettings(name: string): ObsData;
   SetSourceSettings(name: string, settings: ObsData): void;
   GetSourceProperties(name: string): ObsProperty[];
 
-  // Scene management functions
+  // Audio source management functions.
+  SetMuteAudioInputs(mute: boolean): void; // Mute or unmute all audio inputs.
+  SetInputVolume(volume: number): void; // Set the volume for all audio inputs sources.
+  SetOutputVolume(volume: number): void; // Set the volume for all audio outputs sources.
+  SetProcessVolume(volume: number): void; // Set the volume for all audio process sources.
+
+  SetVolmeterEnabled(enabled: boolean): void; // Enable or disable the volume meter.
+
+  // Scene management functions.
   AddSourceToScene(sourceName: string): void;
   RemoveSourceFromScene(sourceName: string): void;
   GetSourcePos(name: string): SceneItemPosition & SourceDimensions;
   SetSourcePos(name: string, pos: SceneItemPosition): void;
   // TODO: Cropping?
 
-  // Preview functions
+  // Preview functions.
   InitPreview(hwnd: Buffer): void;
-  ShowPreview(x: number, y: number, width: number, height: number): void;
+  ConfigurePreview(x: number, y: number, width: number, height: number): void;
+  ShowPreview(): void;
   HidePreview(): void;
-  GetPreviewScaleFactor(): number;
-  /**
-   * Draws a red border around source preview
-   * @param enabled
-   */
+  DisablePreview(): void;
+  GetPreviewInfo(): { canvasWidth: number; canvasHeight: number; previewWidth: number; previewHeight: number };
   SetDrawSourceOutline(enabled: boolean): void;
-  /**
-   * Gets the current state of the preview outline, a red border around the source preview
-   *
-   * Default: *false*
-   */
   GetDrawSourceOutlineEnabled(): boolean;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noobs",
-  "version": "0.0.89",
+  "version": "0.0.115",
   "description": "A native Node.js addon with libobs bindings for Warcraft Recorder.",
   "main": "index.js",
   "types": "index.d.ts",

package/src/main.cpp

@@ -54,6 +54,75 @@ Napi::Value ObsSetRecordingDir(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value ObsResetVideoContext(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsResetVideoContext called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 3 && info[0].IsNumber() && info[1].IsNumber() && info[2].IsNumber();
+
+  if (!valid) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsResetVideo").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  int fps = info[0].As<Napi::Number>().Int32Value();
+  int width = info[1].As<Napi::Number>().Int32Value();
+  int height = info[2].As<Napi::Number>().Int32Value();
+
+  obs->setVideoContext(fps, width, height);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsListVideoEncoders(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsListVideoEncoders called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 0;
+
+  if (!valid) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsListVideoEncoders").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  auto encoders = obs->listAvailableVideoEncoders();
+  Napi::Array result = Napi::Array::New(info.Env(), encoders.size());
+
+  for (size_t i = 0; i < encoders.size(); ++i) {
+    result[i] = Napi::String::New(info.Env(), encoders[i]);
+  }
+
+  return result;
+}
+
+Napi::Value ObsSetVideoEncoder(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsSetVideoEncoder called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 2 &&
+    info[0].IsString() && // Encoder ID
+    info[1].IsObject(); // Settings object
+
+  if (!valid) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsSetVideoEncoder").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  std::string id = info[0].As<Napi::String>().Utf8Value();
+  Napi::Object obj = info[1].As<Napi::Object>();
+
+  obs_data_t* settings = napi_to_data(obj);
+  obs->setVideoEncoder(id, settings);
+  obs_data_release(settings);
+
+  return info.Env().Undefined();
+}
+
 Napi::Value ObsSetBuffering(const Napi::CallbackInfo& info) {
   blog(LOG_INFO, "ObsSetBuffering called");
 
@@ -118,6 +187,16 @@ Napi::Value ObsStopRecording(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value ObsForceStopRecording(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsForceStopRecording called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  obs->forceStopRecording();
+  return info.Env().Undefined();
+}
+
 Napi::Value ObsGetLastRecording(const Napi::CallbackInfo& info) {
   if (!obs) {
     blog(LOG_ERROR, "ObsGetLastRecording called but obs is not initialized");
@@ -155,11 +234,11 @@ Napi::Value ObsInitPreview(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
-Napi::Value ObsShowPreview(const Napi::CallbackInfo& info) {
-  blog(LOG_INFO, "ObsShowPreview called");
+Napi::Value ObsConfigurePreview(const Napi::CallbackInfo& info) {
+  blog(LOG_INFO, "ObsConfigurePreview called");
 
   if (!obs) {
-    blog(LOG_ERROR, "ObsShowPreview called but obs is not initialized");
+    blog(LOG_ERROR, "ObsConfigurePreview called but obs is not initialized");
     throw std::runtime_error("Obs not initialized");
   }
 
@@ -170,7 +249,7 @@ Napi::Value ObsShowPreview(const Napi::CallbackInfo& info) {
     info[3].IsNumber(); // Height
 
   if (!valid) {
-    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsShowPreview").ThrowAsJavaScriptException();
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsConfigurePreview").ThrowAsJavaScriptException();
     return info.Env().Undefined();
   }
 
@@ -179,7 +258,19 @@ Napi::Value ObsShowPreview(const Napi::CallbackInfo& info) {
   int width = info[2].As<Napi::Number>().Int32Value();
   int height = info[3].As<Napi::Number>().Int32Value();
 
-  obs->showPreview(x, y, width, height);
+  obs->configurePreview(x, y, width, height);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsShowPreview(const Napi::CallbackInfo& info) {
+  blog(LOG_INFO, "ObsShowPreview called");
+
+  if (!obs) {
+    blog(LOG_ERROR, "ObsShowPreview called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  obs->showPreview();
   return info.Env().Undefined();
 }
 
@@ -193,14 +284,31 @@ Napi::Value ObsHidePreview(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
-Napi::Value ObsGetPreviewScaleFactor(const Napi::CallbackInfo& info) {
+Napi::Value ObsDisablePreview(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsDisablePreview called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  obs->disablePreview();
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsGetPreviewInfo(const Napi::CallbackInfo& info) {
   if (!obs) {
-    blog(LOG_ERROR, "ObsGetPreviewScaleFactor called but obs is not initialized");
+    blog(LOG_ERROR, "ObsGetPreviewInfo called but obs is not initialized");
     throw std::runtime_error("Obs not initialized");
   }
 
-  float scaleFactor = obs->getPreviewScaleFactor();
-  return Napi::Number::New(info.Env(), scaleFactor);
+  PreviewInfo previewInfo = obs->getPreviewInfo();
+
+  Napi::Object result = Napi::Object::New(info.Env());
+  result.Set("canvasWidth", Napi::Number::New(info.Env(), previewInfo.canvasWidth));
+  result.Set("canvasHeight", Napi::Number::New(info.Env(), previewInfo.canvasHeight));
+  result.Set("previewWidth", Napi::Number::New(info.Env(), previewInfo.displayWidth));
+  result.Set("previewHeight", Napi::Number::New(info.Env(), previewInfo.displayHeight));
+
+  return result;
 }
 
 Napi::Value ObsCreateSource(const Napi::CallbackInfo& info) {
@@ -309,6 +417,98 @@ Napi::Value ObsGetSourceProperties(const Napi::CallbackInfo& info) {
   return result;
 }
 
+
+Napi::Value ObsSetMuteAudioInputs(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsSetMuteAudioInputs called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 1 && info[0].IsBoolean();
+
+  if (!valid) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsSetMuteAudioInputs").ThrowAsJavaScriptException();
+    return info.Env().Undefined();  
+  }
+
+  bool mute = info[0].As<Napi::Boolean>().Value();
+  obs->setMuteAudioInputs(mute);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsSetOutputVolume(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsSetOutputVolume called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 1 && info[0].IsNumber();
+  float volume = info[0].As<Napi::Number>().FloatValue();
+
+  if (!valid || (volume < 0.0f || volume > 1.0f)) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsSetOutputVolume").ThrowAsJavaScriptException();
+    return info.Env().Undefined();  
+  }
+
+  obs->setOutputVolume(volume);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsSetInputVolume(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsSetInputVolume called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 1 && info[0].IsNumber();
+  float volume = info[0].As<Napi::Number>().FloatValue();
+
+  if (!valid || (volume < 0.0f || volume > 1.0f)) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsSetInputVolume").ThrowAsJavaScriptException();
+    return info.Env().Undefined();  
+  }
+  
+  obs->setInputVolume(volume);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsSetProcessVolume(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsSetProcessVolume called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 1 && info[0].IsNumber();
+  float volume = info[0].As<Napi::Number>().FloatValue();
+
+  if (!valid || (volume < 0.0f || volume > 1.0f)) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsSetProcessVolume").ThrowAsJavaScriptException();
+    return info.Env().Undefined();  
+  }
+
+  obs->setProcessVolume(volume);
+  return info.Env().Undefined();
+}
+
+Napi::Value ObsSetVolmeterEnabled(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsSetVolmeterEnabled called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 1 && info[0].IsBoolean();
+
+
+  if (!valid) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsSetVolmeterEnabled").ThrowAsJavaScriptException();
+    return info.Env().Undefined();  
+  }
+
+  bool enabled = info[0].As<Napi::Boolean>().Value();
+  obs->setVolmeterEnabled(enabled);
+  return info.Env().Undefined();
+}
+
 Napi::Value ObsCreateScene(const Napi::CallbackInfo& info) {
   if (!obs) {
     blog(LOG_ERROR, "ObsCreateScene called but obs is not initialized");
@@ -447,11 +647,15 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("Init", Napi::Function::New(env, ObsInit));
   exports.Set("Shutdown", Napi::Function::New(env, ObsShutdown));
   exports.Set("SetRecordingDir", Napi::Function::New(env, ObsSetRecordingDir));
+  exports.Set("ResetVideoContext", Napi::Function::New(env, ObsResetVideoContext));
+  exports.Set("ListVideoEncoders", Napi::Function::New(env, ObsListVideoEncoders));
+  exports.Set("SetVideoEncoder", Napi::Function::New(env, ObsSetVideoEncoder));
 
   exports.Set("SetBuffering", Napi::Function::New(env, ObsSetBuffering));
   exports.Set("StartBuffer", Napi::Function::New(env, ObsStartBuffer));
   exports.Set("StartRecording", Napi::Function::New(env, ObsStartRecording));
   exports.Set("StopRecording", Napi::Function::New(env, ObsStopRecording));
+  exports.Set("ForceStopRecording", Napi::Function::New(env, ObsForceStopRecording));
   exports.Set("GetLastRecording", Napi::Function::New(env, ObsGetLastRecording));
 
   exports.Set("CreateSource", Napi::Function::New(env, ObsCreateSource));
@@ -459,6 +663,13 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("GetSourceSettings", Napi::Function::New(env, ObsGetSourceSettings));
   exports.Set("SetSourceSettings", Napi::Function::New(env, ObsSetSourceSettings));
   exports.Set("GetSourceProperties", Napi::Function::New(env, ObsGetSourceProperties));
+  exports.Set("SetMuteAudioInputs", Napi::Function::New(env, ObsSetMuteAudioInputs));
+
+  exports.Set("SetOutputVolume", Napi::Function::New(env, ObsSetOutputVolume));
+  exports.Set("SetInputVolume", Napi::Function::New(env, ObsSetInputVolume));
+  exports.Set("SetProcessVolume", Napi::Function::New(env, ObsSetProcessVolume));
+
+  exports.Set("SetVolmeterEnabled", Napi::Function::New(env, ObsSetVolmeterEnabled));
 
   exports.Set("AddSourceToScene", Napi::Function::New(env, ObsAddSourceToScene));
   exports.Set("RemoveSourceFromScene", Napi::Function::New(env, ObsRemoveSourceFromScene));
@@ -466,9 +677,11 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("SetSourcePos", Napi::Function::New(env, ObsSetSourcePos));
 
   exports.Set("InitPreview", Napi::Function::New(env, ObsInitPreview));
+  exports.Set("ConfigurePreview", Napi::Function::New(env, ObsConfigurePreview));
   exports.Set("ShowPreview", Napi::Function::New(env, ObsShowPreview));
   exports.Set("HidePreview", Napi::Function::New(env, ObsHidePreview));
-  exports.Set("GetPreviewScaleFactor", Napi::Function::New(env, ObsGetPreviewScaleFactor));
+  exports.Set("DisablePreview", Napi::Function::New(env, ObsDisablePreview));
+  exports.Set("GetPreviewInfo", Napi::Function::New(env, ObsGetPreviewInfo));
   exports.Set("GetDrawSourceOutlineEnabled", Napi::Function::New(env, ObsGetDrawSourceOutlineEnabled));
   exports.Set("SetDrawSourceOutline", Napi::Function::New(env, ObsSetDrawSourceOutline));
 

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;
 
@@ -98,16 +75,50 @@ void ObsInterface::load_module(const char* module, const char* data) {
   }
 }
 
-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 +129,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 +162,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,8 +175,18 @@ 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", 
@@ -190,7 +198,7 @@ void ObsInterface::init_obs(const std::string& distPath) {
 
   for (const auto& module : modules) {
     std::string modulePath = pluginPath + module + ".dll";
-    std::string moduleDataPath = pluginPath + module;
+    std::string moduleDataPath = pluginDataPath + module;
     load_module(modulePath.c_str(), moduleDataPath.c_str());
   }
   
@@ -198,7 +206,6 @@ void ObsInterface::init_obs(const std::string& distPath) {
 
   list_encoders();
   list_source_types();
-  list_input_types();
   list_output_types();
 
   blog(LOG_INFO, "Exit init_obs");
@@ -235,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);
@@ -279,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());
 }
 
@@ -375,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.
   );
@@ -390,6 +429,30 @@ 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);
+  }
+
+  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;
 }
@@ -397,6 +460,20 @@ void ObsInterface::createSource(std::string name, std::string type) {
 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()) {
@@ -405,6 +482,7 @@ void ObsInterface::deleteSource(std::string name) {
   }
 
   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());
@@ -466,65 +544,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) {
+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{ "start", code };
-  self->jscb.NonBlockingCall(sd, call_jscb);
-}
-
-void ObsInterface::output_signal_handler_stop(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 +625,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);
@@ -683,7 +732,7 @@ void ObsInterface::initPreview(HWND parent) {
   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) {
@@ -691,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(
@@ -710,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);
 }
@@ -723,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;
@@ -739,19 +808,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) {
@@ -779,10 +843,17 @@ ObsInterface::ObsInterface(
   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();
 }
@@ -790,16 +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);
   }
 
+  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) {
@@ -839,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) {
@@ -909,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);
@@ -945,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;
@@ -957,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);
@@ -1057,4 +1165,114 @@ 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) {
+  // 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;
 }

package/src/obs_interface.h

@@ -4,10 +4,30 @@
 #include <napi.h>
 #include <windows.h>
 #include <map>
+#include <string>
+#include <optional>
+
+#define AUDIO_INPUT "wasapi_input_capture"
+#define AUDIO_OUTPUT "wasapi_output_capture"
+#define AUDIO_PROCESS "wasapi_process_output_capture"
+
+class ObsInterface;
 
 struct SignalData {
+  std::string type;
   std::string id;
   long long code;
+  std::optional<float> value;
+};
+
+struct SignalContext {
+  ObsInterface* self;
+  std::string id;
+};
+
+struct PreviewInfo {
+  uint32_t canvasWidth, canvasHeight;
+  uint32_t displayWidth, displayHeight;
 };
 
 class ObsInterface {
@@ -22,17 +42,25 @@ class ObsInterface {
     ~ObsInterface();
 
     bool setBuffering(bool buffering); // In buffering mode, the recording is stored in memory and can be converted to a file later.
-    void startBuffering();             // Start buffering to memory.
-    void startRecording(int offset);   // Convert the active buffered recording to a real one.
-    void stopRecording();              // Stop the recording.
-    std::string getLastRecording();    // Get the last recorded file path.
+    void startBuffering(); // Start buffering to memory.
+    void startRecording(int offset); // Convert the active buffered recording to a real one.
+    void stopRecording(); // Stop the recording.
+    void forceStopRecording(); // Force stop the recording, this will not save the current recording.
+    std::string getLastRecording(); // Get the last recorded file path.
     void setRecordingDir(const std::string& recordingPath); // Output must not be active when calling this.
+    void setVideoContext(int fps, int width, int height); // Reset video settings.
 
-    void createSource(std::string name, std::string type);          // Create a new source
-    void deleteSource(std::string name);                            // Release a source.
-    obs_data_t* getSourceSettings(std::string name);                // Get the current settings.
+    void createSource(std::string name, std::string type); // Create a new source
+    void deleteSource(std::string name); // Release a source.
+    obs_data_t* getSourceSettings(std::string name); // Get the current settings.
     void setSourceSettings(std::string name, obs_data_t* settings); // Set settings.
-    obs_properties_t* getSourceProperties(std::string name);        // Get the settings schema.
+    obs_properties_t* getSourceProperties(std::string name); // Get the settings schema.
+    void setMuteAudioInputs(bool mute); // Mute or unmute all audio inputs.
+    void setOutputVolume(float volume);
+    void setInputVolume(float volume); 
+    void setProcessVolume(float volume); 
+
+    void setVolmeterEnabled(bool enabled);
 
     void addSourceToScene(std::string name); // Add source to scene.
     void removeSourceFromScene(std::string name); // Remove source from scene.
@@ -40,49 +68,56 @@ class ObsInterface {
     void setSourcePos(std::string name, vec2* pos, vec2* scale); // Size does not get set here because it's set by the source itself.
 
     void initPreview(HWND parent); // Must call this before showPreview to setup resources.
-    void showPreview(int x, int y, int width, int height); // Also used for moving and resizing.
-    void hidePreview(); // Hide the preview display.
-    float getPreviewScaleFactor(); // Get the current scale factor of the preview.
+    void configurePreview(int x, int y, int width, int height); // Move and resize the preview display.
+    void showPreview(); // Show the preview display.
+    void hidePreview(); // Hide the preview display, but leave it running.
+    void disablePreview(); // Disable the preview display, to save resources.
+    PreviewInfo getPreviewInfo(); // Get the dimensions of the display, and the base canvas.
     void setDrawSourceOutline(bool enabled); // Red box around source
     bool getDrawSourceOutlineEnabled();
 
-    std::vector<std::string> get_available_video_encoders();
-
-    // TODO
-    // Configure video 
-    // Configure audio
-    // List audio source
-    // Reconfigure audio sources
-    // Reconfigure video sources
+    std::vector<std::string> listAvailableVideoEncoders(); // Return a list of available video encoders.
+    void setVideoEncoder(std::string id, obs_data_t* settings); // Set the video encoder to use.
   
   private:
     obs_output_t *file_output = nullptr;
     obs_output_t *buffer_output = nullptr;
+
     obs_scene_t *scene = nullptr;
+
     obs_encoder_t *file_video_encoder = nullptr;
     obs_encoder_t *file_audio_encoder = nullptr;
+
     obs_encoder_t *buffer_video_encoder = nullptr;
     obs_encoder_t *buffer_audio_encoder = nullptr;
+
+    float output_volume = 1.0f; // Volume for the output.
+    float input_volume = 1.0f; // Volume for the input.
+    float process_volume = 1.0f; // Volume for the process.
+    
     obs_display_t *display = nullptr;
     HWND preview_hwnd = nullptr; // window handle for scene preview
     Napi::ThreadSafeFunction jscb; // javascript callback
     std::string recording_path = ""; 
+    std::string unbuffered_output_filename = "";
+
     bool buffering = false; // Whether we are buffering the recording in memory.
     bool drawSourceOutline = false; // Draw red outline around source
     std::map<std::string, obs_source_t*> sources; // Map of source names to obs_source_t pointers. 
+    std::map<std::string, obs_volmeter_t*> volmeters; // Map of source names to obs_volmeter_t pointers.
 
     void init_obs(const std::string& distPath);
-    void reset_video();
-    void reset_audio();
+    int reset_video(int fps, int width, int height);
+    bool reset_audio();
     void load_module(const char* module, const char* data); // Load a module, data is optional.
     void connect_signal_handlers(obs_output_t *output);
     void disconnect_signal_handlers(obs_output_t *output);
 
-    static void output_signal_handler_starting(void *data, calldata_t *cd);
-    static void output_signal_handler_start(void *data, calldata_t *cd);
-    static void output_signal_handler_stop(void *data, calldata_t *cd);
-    static void output_signal_handler_stopping(void *data, calldata_t *cd);
-    static void output_signal_handler_saved(void *data, calldata_t *cd);
+    SignalContext* starting_ctx;
+    SignalContext* start_ctx;
+    SignalContext* stopping_ctx;
+    SignalContext* stop_ctx;
+    static void output_signal_handler(void *data, calldata_t *cd);
 
     void list_encoders(obs_encoder_type type = OBS_ENCODER_VIDEO);
     void list_source_types();
@@ -92,6 +127,17 @@ class ObsInterface {
     void create_scene();
     void create_output();
 
+    std::string video_encoder_id; // The video encoder ID to use.
+    obs_data_t* video_encoder_settings; // Settings for the video encoder.
     void create_video_encoders();
     void create_audio_encoders();
+
+    bool volmeter_enabled = false; // Whether the volmeter callback is enabled.
+
+    static void volmeter_callback(
+      void *data, 
+      const float magnitude[MAX_AUDIO_CHANNELS],
+      const float peak[MAX_AUDIO_CHANNELS], 
+      const float inputPeak[MAX_AUDIO_CHANNELS]
+    );
 };