noobs 0.0.187 → 0.0.200

package/README.md

@@ -93,6 +93,8 @@ npm run build     # compile it
 
 npm version patch # version bump
 npm pack          # build tgz locally
+
+npm login
 npm publish       # publish to npm
 ```
 

package/index.d.ts

@@ -171,6 +171,7 @@ interface Noobs {
 
   // Recording functions.
   SetBuffering(buffering: boolean): void; // In buffering mode, the recording is stored in memory and can be converted to a file later.
+  SetFragmentation(fragmented: boolean): void; // Use fragmented MP4.
   StartBuffer(): void;
   StartRecording(offset: number): void;
   StopRecording(): void;

package/package.json

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

package/src/main.cpp

@@ -156,6 +156,28 @@ Napi::Value ObsSetBuffering(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value ObsSetFragmentation(const Napi::CallbackInfo& info) {
+  blog(LOG_INFO, "ObsSetFragmentation called");
+
+  if (!obs) {
+    blog(LOG_ERROR, "ObsSetFragmentation called but obs is not initialized");
+    Napi::Error::New(info.Env(), "Obs not initialized").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  bool valid = info.Length() == 1 && info[0].IsBoolean();
+
+  if (!valid) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsSetFragmentation").ThrowAsJavaScriptException();
+    return info.Env().Undefined();
+  }
+
+  bool fragmented = info[0].As<Napi::Boolean>().Value();
+  obs->setFragmentation(fragmented);
+
+  return info.Env().Undefined();
+}
+
 Napi::Value ObsStartBuffer(const Napi::CallbackInfo& info) {
   blog(LOG_INFO, "ObsStartBuffer called");
 
@@ -678,6 +700,7 @@ Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("SetVideoEncoder", Napi::Function::New(env, ObsSetVideoEncoder));
 
   exports.Set("SetBuffering", Napi::Function::New(env, ObsSetBuffering));
+  exports.Set("SetFragmentation", Napi::Function::New(env, ObsSetFragmentation));
   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

@@ -23,6 +23,10 @@ void call_jscb(Napi::Env env, Napi::Function cb, SignalData* sd) {
     obj.Set("error", Napi::String::New(env, sd->error.value()));
   }
 
+  if (sd->path.has_value()) {
+    obj.Set("path", Napi::String::New(env, sd->path.value()));
+  }
+
   cb.Call({ obj });
   delete sd;
 }
@@ -271,6 +275,12 @@ void ObsInterface::create_output() {
     unbuffered_output_filename = filename;
   }
 
+  if (fragmented && file_extension == "mp4") {
+    blog(LOG_INFO, "Fragmentation enabled");
+    std::string mux_frag = "movflags=frag_keyframe+empty_moov+delay_moov";
+    obs_data_set_string(settings, "muxer_settings", mux_frag.c_str());
+  }
+
   obs_output_update(output, settings);
   obs_data_release(settings);
   connect_signal_handlers(output);
@@ -591,25 +601,40 @@ obs_properties_t* ObsInterface::getSourceProperties(std::string name) {
 }
 
 void ObsInterface::output_signal_handler(void *data, calldata_t *cd) {
-  long long code = calldata_int(cd, "code");
-  const char *err = calldata_string(cd, "last_error");
+  SignalContext* ctx = static_cast<SignalContext*>(data);
+  ObsInterface* self = ctx->self;
+  SignalData* sd;
 
-  std::optional<std::string> error;
+  blog(LOG_INFO, "Handling %s signal from libobs", ctx->id.c_str());
 
-  if (err) {
-    error = std::string(err);
-  }
+  if (ctx->id == "converted") {
+    const char *path = calldata_string(cd, "file");
 
-  SignalContext* ctx = static_cast<SignalContext*>(data);
-  ObsInterface* self = ctx->self;
+    sd = new SignalData{ 
+      "output", 
+      "converted", 
+      0, // Never actually get a code for a converted signal, so just set it to 0.
+      std::nullopt, // No value, that's only used for volmeters.
+      std::nullopt, // Never expect errors here.
+      std::string(path),
+    };
+  } else {
+    long long code = calldata_int(cd, "code");
+    const char *err = calldata_string(cd, "last_error");
+    std::optional<std::string> error;
 
-  SignalData* sd = new SignalData{ 
-    "output", 
-    ctx->id.c_str(), 
-    code, 
-    std::nullopt, // No value, that's only used for volmeters.
-    error,
-  };
+    if (err) {
+      error = std::string(err);
+    }
+
+    sd = new SignalData{ 
+      "output", 
+      ctx->id.c_str(), 
+      code, 
+      std::nullopt, // No value, that's only used for volmeters.
+      error,
+    };
+  }
 
   self->jscb.NonBlockingCall(sd, call_jscb);
 }
@@ -622,6 +647,7 @@ void ObsInterface::connect_signal_handlers(obs_output_t *output) {
   signal_handler_connect(sh, "stop", output_signal_handler,  stop_ctx);
   signal_handler_connect(sh, "activate", output_signal_handler, activate_ctx);
   signal_handler_connect(sh, "deactivate", output_signal_handler, deactivate_ctx);
+  signal_handler_connect(sh, "converted", output_signal_handler, converted_ctx);
 }
 
 void ObsInterface::disconnect_signal_handlers(obs_output_t *output) {
@@ -631,7 +657,8 @@ void ObsInterface::disconnect_signal_handlers(obs_output_t *output) {
   signal_handler_disconnect(sh, "stopping", output_signal_handler,  stopping_ctx);
   signal_handler_disconnect(sh, "stop", output_signal_handler,  stop_ctx);
   signal_handler_disconnect(sh, "activate", output_signal_handler, activate_ctx);
-  signal_handler_disconnect(sh, "deactivate ", output_signal_handler, deactivate_ctx);
+  signal_handler_disconnect(sh, "deactivate", output_signal_handler, deactivate_ctx);
+  signal_handler_disconnect(sh, "converted ", output_signal_handler, converted_ctx);
 }
 
 bool draw_source_outline(obs_scene_t *scene, obs_sceneitem_t *item, void *p) {
@@ -949,6 +976,7 @@ ObsInterface::ObsInterface(
   stop_ctx = new SignalContext{ this, "stop" };
   activate_ctx = new SignalContext{this, "activate"};
   deactivate_ctx = new SignalContext{this, "deactivate"};
+  converted_ctx = new SignalContext{this, "converted"};
 
   // Create the resources we rely on.
   create_scene();
@@ -981,6 +1009,7 @@ ObsInterface::~ObsInterface() {
   delete stop_ctx;
   delete activate_ctx;
   delete deactivate_ctx;
+  delete converted_ctx;
 
   for (auto& kv : sources) {
     std::string name = kv.first;
@@ -1047,6 +1076,16 @@ void ObsInterface::setBuffering(bool value) {
   create_output();
 }
 
+void ObsInterface::setFragmentation(bool value) {
+  if (obs_output_active(output)) {
+    blog(LOG_ERROR, "Cannot change fragmentation state while output is active");
+    throw new std::runtime_error("Cannot change fragmentation state while output is active");
+  }
+
+  fragmented = value;
+  create_output();
+}
+
 void ObsInterface::startBuffering() {
   blog(LOG_INFO, "ObsInterface::startBuffering called");
 

package/src/obs_interface.h

@@ -19,6 +19,7 @@ struct SignalData {
   long long code;
   std::optional<float> value;
   std::optional<std::string> error;
+  std::optional<std::string> path; // used by converted signal handler
 };
 
 struct SignalContext {
@@ -52,6 +53,7 @@ class ObsInterface {
     void forceStopRecording(); // Force stop the recording, this will not save the current recording.
     std::string getLastRecording(); // Get the last recorded file path.
     void setBuffering(bool buffer); // Enable or disable buffering.
+    void setFragmentation(bool fragmented); // Enable or disable fragmented MP4.
     void setRecordingCfg(const std::string& recordingPath, const std::string& fileExtension); // Set the recording path.
     void setVideoContext(int fps, int width, int height); // Reset video settings.
 
@@ -108,6 +110,7 @@ class ObsInterface {
     std::string file_extension = "mp4"; // File extension for recordings.
 
     bool buffering = false; // Whether we are buffering the recording in memory.
+    bool fragmented = false; // Use fragmented MP4.
     bool drawSourceOutline = false; // Draw red outline around source
     void init_obs(const std::string& distPath);
     int reset_video(int fps, int width, int height);
@@ -122,6 +125,7 @@ class ObsInterface {
     SignalContext* stop_ctx;
     SignalContext* activate_ctx;
     SignalContext* deactivate_ctx;
+    SignalContext* converted_ctx;
     static void output_signal_handler(void *data, calldata_t *cd);
 
     void list_encoders(obs_encoder_type type = OBS_ENCODER_VIDEO);