noobs 0.0.63 → 0.0.65

package/README.md

@@ -19,12 +19,56 @@ npm install noobs
 
 ## Usage
 
+### Lifecycle
 ```javascript
 import noobs from 'noobs';
 
+const pluginPath = ...;
+const logPath = ...;
+const dataPath = ...;
+const recordingPath = ...;
+const cb = (signal) => console.log(signal);
+
+noobs.Init(pluginPath, logPath, dataPath, recordingPath, cb);
+...
+noobs.Shutdown();
+```
+
+### Sources
+```javascript
+noobs.CreateSource('Test Source', 'monitor_capture'); // Creates a source
+noobs.AddSourceToScene('Test Source'); // Add the source to the scene
+const s = noobs.GetSourceSettings('Test Source'); // View current settings
+const p = noobs.GetSourceProperties('Test Source'); // View settings schema
+noobs.SetSourceSettings('Test Source', { ...s, monitor: 1 });
+noobs.RemoveSourceFromScene('Test Source'); // Remove a source from the scene
+noobs.DeleteSource('Test Source') // Release a source
+```
+
+###  Basic Recording Usage
+```javascript
+noobs.StartRecording();
 ...
+noobs.StopRecording();
+```
+
+### Buffer Recording
+```javascript
+noobs.SetBuffering(true);
+
+noobs.StartBuffering();
+...
+noobs.StartRecording(5); // include last 5 seconds of the recording buffer
+...
+noobs.StopRecording();
+```
 
-noobs.ObsInit(pluginPath, logPath, dataPath, recordingPath, cb);
+### Preview
+```javascript
+const hwnd = this.mainWindow.getNativeWindowHandle();
+noobs.InitPreview(hwnd);
+noobs.ShowPreview(x, y, width, height); // Use this for moving/resizing
+// noobs.HidePreview();
 ```
 
 See `test.js` for more.

package/index.d.ts

@@ -1,15 +1,21 @@
 // OBS Data Types
-export type ObsDataValue = string | number | boolean | ObsData | ObsData[] | null;
+export type ObsDataValue =
+  | string
+  | number
+  | boolean
+  | ObsData
+  | ObsData[]
+  | null;
 
 export interface ObsData {
   [key: string]: ObsDataValue;
 }
 
 // OBS Property Types
-export type ObsPropertyType = 
+export type ObsPropertyType =
   | 'invalid'
   | 'bool'
-  | 'int' 
+  | 'int'
   | 'float'
   | 'text'
   | 'path'
@@ -114,7 +120,7 @@ export interface ObsGenericProperty extends ObsPropertyBase {
   type: 'invalid' | 'unknown';
 }
 
-export type ObsProperty = 
+export type ObsProperty =
   | ObsIntProperty
   | ObsFloatProperty
   | ObsTextProperty
@@ -130,35 +136,35 @@ export type ObsProperty =
   | ObsGenericProperty;
 
 export type Signal = {
-  id: string;   // Signal identifier, e.g. "stop"
+  id: string; // Signal identifier, e.g. "stop"
   code: number; // 0 for success, other values for errors
-}
+};
 
 export type SceneItemPosition = {
-  x: number;      // X position in pixels
-  y: number;      // Y position in pixels
+  x: number; // X position in pixels
+  y: number; // Y position in pixels
   scaleX: number; // X scaling factor
   scaleY: number; // Y scaling factor
 };
 
 export type SourceDimensions = {
   height: number; // Height in pixels, before scaling
-  width: number;  // Width in pixels, before scaling
-}
+  width: number; // Width in pixels, before scaling
+};
 
 interface Noobs {
   Init(
-    pluginPath: string, 
-    logPath: string, 
+    pluginPath: string,
+    logPath: string,
     dataPath: string,
     recordingPath: string,
     cb: (signal: Signal) => void,
-    buffering: boolean,
   ): void;
 
   Shutdown(): void;
-  
+
   // 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;

package/index.js

@@ -1,8 +1,8 @@
 const path = require('path');
 
-process.env.Path += ";";
+process.env.Path += ';';
 process.env.Path += path.resolve(__dirname, 'dist', 'bin').replace('app.asar', 'app.asar.unpacked');
 
 const packageName = 'noobs.node';
-const noobs = require(`./dist/${packageName}`)
+const noobs = require(`./dist/${packageName}`);
 module.exports = noobs;

package/package.json

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

package/src/main.cpp

@@ -7,13 +7,12 @@
 ObsInterface* obs = nullptr;
 
 Napi::Value ObsInit(const Napi::CallbackInfo& info) {
-  bool valid = info.Length() == 6 &&
+  bool valid = info.Length() == 5 &&
    info[0].IsString() &&   // Plugin path
    info[1].IsString() &&   // Log path
    info[2].IsString() &&   // Data path
    info[3].IsString() &&   // Recording path
-   info[4].IsFunction() && // JavaScript callback
-   info[5].IsBoolean();    // IsBuffer
+   info[4].IsFunction();   // JavaScript callback
 
   if (!valid) {
     Napi::Error::New(info.Env(), "Invalid arguments passed to ObsInit").ThrowAsJavaScriptException();
@@ -25,12 +24,11 @@ Napi::Value ObsInit(const Napi::CallbackInfo& info) {
   std::string dataPath = info[2].As<Napi::String>().Utf8Value();
   std::string recordingPath = info[3].As<Napi::String>().Utf8Value();
   Napi::Function fn = info[4].As<Napi::Function>();
-  bool isBuffer = info[5].As<Napi::Boolean>().Value();
 
   Napi::ThreadSafeFunction jscb =
     Napi::ThreadSafeFunction::New(info.Env(), fn, "JavaScript callback", 0, 1);
 
-  obs = new ObsInterface(pluginPath, logPath, dataPath, recordingPath, jscb, isBuffer);
+  obs = new ObsInterface(pluginPath, logPath, dataPath, recordingPath, jscb);
   return info.Env().Undefined();
 }
 
@@ -58,6 +56,32 @@ Napi::Value ObsSetRecordingDir(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value ObsSetBuffering(const Napi::CallbackInfo& info) {
+  blog(LOG_INFO, "ObsSetBuffering called");
+
+  if (!obs) {
+    blog(LOG_ERROR, "ObsSetBuffering 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 ObsSetBuffering").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  bool buffering = info[0].As<Napi::Boolean>().Value();
+  bool success = obs->setBuffering(buffering);
+
+  if (!success) {
+    Napi::Error::New(info.Env(), "Failed to set buffering mode, is recording active?").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  return info.Env().Undefined();
+}
+
 Napi::Value ObsStartBuffer(const Napi::CallbackInfo& info) {
   blog(LOG_INFO, "ObsStartBuffer called");
 
@@ -399,6 +423,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("Shutdown", Napi::Function::New(env, ObsShutdown));
   exports.Set("SetRecordingDir", Napi::Function::New(env, ObsSetRecordingDir));
 
+  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));

package/src/obs_interface.cpp

@@ -191,57 +191,57 @@ void ObsInterface::init_obs(const std::string& pluginPath, const std::string& da
   blog(LOG_INFO, "Exit init_obs");
 }
 
-void ObsInterface::create_output(const std::string& recordingPath, bool buffering) {
-  blog(LOG_INFO, "Create output");
+void ObsInterface::create_output() {
+  blog(LOG_INFO, "Create outputs");
 
-  if (output) {
-    blog(LOG_DEBUG, "Releasing output");
-    obs_output_release(output);
-  }
+  blog(LOG_INFO, "Creating replay buffer output");
+  buffer_output = obs_output_create("replay_buffer", "Buffer Output", NULL, NULL);
 
-  if (buffering) {
-    blog(LOG_INFO, "Creating replay buffer output");
-    output = obs_output_create("replay_buffer", "recording_output", NULL, NULL);
-  } else {
-    blog(LOG_INFO, "Creating file output");
-    output = obs_output_create("ffmpeg_muxer", "recording_output", NULL, NULL);
+  if (!buffer_output) {
+    blog(LOG_ERROR, "Failed to create buffer output!");
+    throw std::runtime_error("Failed to create buffer output!");
   }
 
-  if (!output) {
-    blog(LOG_ERROR, "Failed to create output!");
-    throw std::runtime_error("Failed to create output!");
+  blog(LOG_INFO, "Creating file output");
+  file_output = obs_output_create("ffmpeg_muxer", "File Output", NULL, NULL);
+
+  if (!file_output) {
+    blog(LOG_ERROR, "Failed to create file output!");
+    throw std::runtime_error("Failed to create file output!");
   }
 
-  obs_data_t *settings = obs_data_create();
+  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);
 
-  if (buffering) {
-    blog(LOG_INFO, "Set replay_buffer settings");
-    obs_data_set_int(settings, "max_time_sec", 60);
-    obs_data_set_int(settings, "max_size_mb", 1024);
-    obs_data_set_string(settings, "directory", recordingPath.c_str());
-    obs_data_set_string(settings, "format", "%CCYY-%MM-%DD %hh-%mm-%ss");
-    obs_data_set_string(settings, "extension", "mp4");
-  } else {
-    blog(LOG_INFO, "Set ffmpeg_muxer settings");
-		obs_data_set_string(settings, "extension", "mp4");
-    // Apparently need to specify the exact path for ffmpeg_muxer.
-    // TODO add something to auto generate this ?
-    obs_data_set_string(settings, "path", (recordingPath + "/noobs.mp4").c_str()); 
-    recording_path = recordingPath + "/noobs.mp4";
-  }
+  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(output, settings);
-  obs_data_release(settings);
+  obs_output_update(file_output, ffmpeg_settings);
+  obs_data_release(ffmpeg_settings);
 
   // Add the signal handler callback.
-  create_signal_handlers(output);
+  connect_signal_handlers(buffer_output);
+  connect_signal_handlers(file_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");
@@ -265,70 +265,82 @@ void ObsInterface::setRecordingDir(const std::string& recordingPath) {
   obs_data_release(settings);
 }
 
-void ObsInterface::configure_video_encoder() {
+void ObsInterface::create_video_encoders() {
   blog(LOG_INFO, "Create video encoder");
 
-  if (!output) {
-    blog(LOG_ERROR, "No output on configure_video_encoder");
-    throw std::runtime_error("Failed to create video encoder!");
-  }
+  file_video_encoder = obs_video_encoder_create("obs_x264", "h264_stream_file", NULL, NULL);
 
-  if (video_encoder) {
-    blog(LOG_DEBUG, "Releasing video encoder");
-    obs_encoder_release(video_encoder);
-    video_encoder = nullptr;
-  }
-
-  video_encoder = obs_video_encoder_create("obs_x264", "simple_h264_stream", NULL, NULL);
 
-  if (!video_encoder) {
+  if (!file_video_encoder) {
     blog(LOG_ERROR, "Failed to create video encoder!");
     throw std::runtime_error("Failed to create video encoder!");
   }
 
-  blog(LOG_INFO, "Set video encoder settings");
+  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", 30);
   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(video_encoder, venc_settings);
+
+  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());
 }
 
-void ObsInterface::configure_audio_encoder() {
+void ObsInterface::create_audio_encoders() {
   blog(LOG_INFO, "Create audio encoder");
 
-  if (!output) {
-    blog(LOG_ERROR, "No output on configure_audio_encoder");
-    throw std::runtime_error("Failed to 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;
+  // }
 
-  audio_encoder = obs_audio_encoder_create("ffmpeg_aac", "simple_aac", NULL, 0, NULL);
+  file_audio_encoder = obs_audio_encoder_create("ffmpeg_aac", "aac_file", NULL, 0, NULL);
 
-  if (!audio_encoder) {
+  if (!file_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(audio_encoder, aenc_settings);
+  obs_encoder_update(file_audio_encoder, aenc_settings);
+  obs_encoder_update(buffer_audio_encoder, aenc_settings);
   obs_data_release(aenc_settings);
 
-  obs_output_set_video_encoder(output, video_encoder);
-  obs_output_set_audio_encoder(output, audio_encoder, 0);
+  obs_output_set_audio_encoder(file_output, file_audio_encoder, 0);
+  obs_encoder_set_audio(file_audio_encoder, obs_get_audio());
 
-  obs_encoder_set_video(video_encoder, obs_get_video());
-  obs_encoder_set_audio(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());
 }
 
 void ObsInterface::create_scene() {
@@ -472,7 +484,7 @@ void ObsInterface::output_signal_handler_saved(void *data, calldata_t *cd) {
   self->jscb.NonBlockingCall(sd, call_jscb);
 }
 
-void ObsInterface::create_signal_handlers(obs_output_t *output) {
+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);
@@ -481,6 +493,15 @@ void ObsInterface::create_signal_handlers(obs_output_t *output) {
   signal_handler_connect(sh, "saved", output_signal_handler_saved,  this);
 }
 
+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);
+}
+
 bool draw_box(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
   // Get the item position and size
   vec2 pos; vec2 scale;
@@ -645,8 +666,7 @@ ObsInterface::ObsInterface(
   const std::string& logPath, 
   const std::string& dataPath,  
   const std::string& recordingPath,
-  Napi::ThreadSafeFunction cb,
-  bool buffering
+  Napi::ThreadSafeFunction cb
 ) {
   // Setup logs first so we have logs for the initialization.
   base_set_log_handler(log_handler, (void*)logPath.c_str());
@@ -657,13 +677,14 @@ ObsInterface::ObsInterface(
 
   // Setup callback function.
   jscb = cb;
+  recording_path = recordingPath;
 
   // Create the resources we rely on.
-  create_output(recordingPath, buffering);
+  create_output();
   create_scene();
 
-  configure_video_encoder();
-  configure_audio_encoder();
+  create_video_encoders();
+  create_audio_encoders();
 }
 
 ObsInterface::~ObsInterface() {
@@ -684,39 +705,69 @@ ObsInterface::~ObsInterface() {
     obs_scene_release(scene);
   }
 
-  if (output) {
-    if (obs_output_active(output)) {
+  if (buffer_output) {
+    if (obs_output_active(buffer_output)) {
       blog(LOG_DEBUG, "Force stopping output");
-      obs_output_force_stop(output);
+      obs_output_force_stop(buffer_output);
     }
       
     blog(LOG_DEBUG, "Releasing output");
-    obs_output_release(output);
+    obs_output_release(buffer_output);
   }
 
-  if (video_encoder) {
-    blog(LOG_DEBUG, "Releasing video encoder");
-    obs_encoder_release(video_encoder);
+  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);
   }
 
-  if (audio_encoder) {
-    blog(LOG_DEBUG, "Releasing audio encoder");
-    obs_encoder_release(audio_encoder);
-  }
+  // if (video_encoder) {
+  //   blog(LOG_DEBUG, "Releasing video encoder");
+  //   obs_encoder_release(video_encoder);
+  // }
+
+  // if (audio_encoder) {
+  //   blog(LOG_DEBUG, "Releasing audio encoder");
+  //   obs_encoder_release(audio_encoder);
+  // }
 
   blog(LOG_DEBUG, "Now shutting down OBS");
   obs_shutdown();
 }
 
+bool ObsInterface::setBuffering(bool value) {
+  obs_output_t* output = buffering ? buffer_output : file_output;
+
+  if (obs_output_active(output)) {
+    blog(LOG_ERROR, "Cannot change buffering state while output is active");
+    return false;
+  }
+
+  buffering = value;
+  return buffering;
+}
+
 void ObsInterface::startBuffering() {
   blog(LOG_INFO, "ObsInterface::startBuffering called");
 
+  if (!buffering) {
+    blog(LOG_ERROR, "Buffering is not enabled!");
+    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!");
   }
 
   bool is_active = obs_output_active(output);
-      
+
   if (is_active) {
     blog(LOG_WARNING, "Output is already active");
     return;
@@ -725,6 +776,7 @@ void ObsInterface::startBuffering() {
   bool success = obs_output_start(output);
 
   if (!success) {
+    blog(LOG_ERROR, "Failed to start buffering!");
     throw std::runtime_error("Failed to start buffering!");
   }
     
@@ -733,10 +785,9 @@ void ObsInterface::startBuffering() {
 
 void ObsInterface::startRecording(int offset) {
   blog(LOG_INFO, "ObsInterface::startRecording enter");
+  obs_output_t* output = buffering ? buffer_output : file_output;
 
-  const char* type = obs_output_get_id(output);
-
-  if (strcmp(type, "replay_buffer") == 0) {
+  if (buffering) {
     bool is_active = obs_output_active(output);
 
     if (!is_active) {
@@ -755,7 +806,7 @@ void ObsInterface::startRecording(int offset) {
     if (!success) {
       throw std::runtime_error("Failed to call convert procedure handler");
     }
-  } else if (strcmp(type, "ffmpeg_muxer") == 0) {
+  } else {
     blog(LOG_INFO, "Starting ffmpeg_muxer output");
 
     bool is_active = obs_output_active(output);
@@ -773,9 +824,6 @@ void ObsInterface::startRecording(int offset) {
       blog(LOG_ERROR, "Failed to start recording: %s", err ? err : "Unknown error");
       throw std::runtime_error("Failed to start recording");
     }
-  } else {
-    blog(LOG_ERROR, "Unknown output type: %s", type);
-    throw std::runtime_error("Unknown output type!");
   }
 
   blog(LOG_INFO, "ObsInterface::startRecording exit");
@@ -783,10 +831,11 @@ 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) {
-    blog(LOG_WARNING, "Buffer is not active");
+    blog(LOG_WARNING, "Output is not active");
     return;
   }
 
@@ -798,23 +847,18 @@ 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 (strcmp(type, "ffmpeg_muxer") == 0) {
+  if (!buffering) {
     blog(LOG_INFO, "Getting last recording path from ffmpeg_muxer");
     return recording_path;
   }
 
-  bool success;
-
-  if (strcmp(type, "replay_buffer") != 0) {
-    blog(LOG_ERROR, "Unknown output type: %s", type);
-    throw std::runtime_error("Unknown output type!");
-  }
-
-  success = proc_handler_call(ph, "get_last_replay", &cd);
+  bool success = proc_handler_call(ph, "get_last_replay", &cd);
 
   if (!success) {
     blog(LOG_ERROR, "Failed to call procedure handler");

package/src/obs_interface.h

@@ -14,12 +14,12 @@ class ObsInterface {
       const std::string& logPath,       // Where to write logs to
       const std::string& dataPath,      // Where to look for effects
       const std::string& recordingPath, // Where to save recordings
-      Napi::ThreadSafeFunction cb,      // JavaScript callback
-      bool buffering                    // Whether to enable buffering the recording in memory
+      Napi::ThreadSafeFunction cb       // JavaScript callback
     );
 
     ~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.
@@ -51,22 +51,27 @@ class ObsInterface {
     // Reconfigure video sources
   
   private:
-    obs_output_t *output = nullptr;
+    obs_output_t *file_output = nullptr;
+    obs_output_t *buffer_output = nullptr;
     obs_scene_t *scene = nullptr;
     obs_source_t *video_source = nullptr;
     obs_source_t *audio_source = nullptr;
-    obs_encoder_t *video_encoder = nullptr;
-    obs_encoder_t *audio_encoder = 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;
     obs_display_t *display = nullptr;
     HWND preview_hwnd = nullptr; // window handle for scene preview
     Napi::ThreadSafeFunction jscb; // javascript callback
     std::string recording_path = ""; 
+    bool buffering = false; // Whether we are buffering the recording in memory.
 
     void init_obs(const std::string& pluginPath, const std::string& dataPath);
     void reset_video();
     void reset_audio();
     void load_module(const char* module);
-    void create_signal_handlers(obs_output_t *output);
+    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);
@@ -80,8 +85,8 @@ class ObsInterface {
     void list_output_types();
 
     void create_scene();
-    void create_output(const std::string& recordingPath, bool buffering);
+    void create_output();
 
-    void configure_video_encoder();
-    void configure_audio_encoder();
+    void create_video_encoders();
+    void create_audio_encoders();
 };

package/src/utils.cpp

@@ -394,3 +394,11 @@ Napi::Object property_to_napi(Napi::Env env, obs_property_t* property) {
   
   return obj;
 }
+
+std::string get_current_date_time() {
+    auto now = std::chrono::system_clock::now();
+    auto time_t = std::chrono::system_clock::to_time_t(now);
+    std::stringstream ss;
+    ss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H-%M-%S");
+    return ss.str();
+}

package/src/utils.h

@@ -9,4 +9,5 @@ Napi::Object data_to_napi(Napi::Env env,obs_data_t* data);
 obs_data_t* napi_to_data(Napi::Object obj);
 
 Napi::Object property_to_napi(Napi::Env env, obs_property_t* property);
-Napi::Array properties_to_napi(Napi::Env env, obs_properties_t* properties);
+Napi::Array properties_to_napi(Napi::Env env, obs_properties_t* properties);
+std::string get_current_date_time();