noobs 0.0.29 → 0.0.31

package/index.d.ts

@@ -4,7 +4,7 @@ type Signal = { // TODO export type?
 }
 
 interface Noobs {
-  ObsInit(
+  Init(
     pluginPath: string, 
     logPath: string, 
     dataPath: string,
@@ -12,15 +12,17 @@ interface Noobs {
     cb: (signal: Signal) => void
   ): void;
 
-  ObsShutdown(): void;
-  ObsStartBuffer(): void;
-  ObsStartRecording(offset: number): void;
-  ObsStopRecording(): void;
-  ObsGetLastRecording(): string;
+  Shutdown(): void;
+  StartBuffer(): void;
+  StartRecording(offset: number): void;
+  StopRecording(): void;
+  GetLastRecording(): string;
 
-  ObsInitPreview(hwnd: Buffer): void;
-  ObsShowPreview(x: number, y: number, width: number, height: number): void;
-  ObsHidePreview(): void;
+  UpdateSource(x: number, y: number, scale: number): void;
+
+  InitPreview(hwnd: Buffer): void;
+  ShowPreview(x: number, y: number, width: number, height: number): void;
+  HidePreview(): void;
 }
 
 declare const noobs: Noobs;

package/package.json

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

package/src/main.cpp

@@ -157,18 +157,39 @@ Napi::Value ObsHidePreview(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value ObsUpdateSourcePos(const Napi::CallbackInfo& info) {
+  if (!obs) {
+    blog(LOG_ERROR, "ObsUpdateSource called but obs is not initialized");
+    throw std::runtime_error("Obs not initialized");
+  }
+
+  bool valid = info.Length() == 3 &&
+    info[0].IsNumber() && // X position (px)
+    info[1].IsNumber() && // Y position (px)
+    info[2].IsNumber();   // Scale (multiplier)
+
+  int x = info[0].As<Napi::Number>().Int32Value();
+  int y = info[1].As<Napi::Number>().Int32Value();
+  float scale = info[2].As<Napi::Number>().FloatValue();
+
+  obs->updateSourcePos(x, y, scale);
+  return info.Env().Undefined();
+}
+
 Napi::Object Init(Napi::Env env, Napi::Object exports) {
-  exports.Set("ObsInit", Napi::Function::New(env, ObsInit));
-  exports.Set("ObsShutdown", Napi::Function::New(env, ObsShutdown));
+  exports.Set("Init", Napi::Function::New(env, ObsInit));
+  exports.Set("Shutdown", Napi::Function::New(env, ObsShutdown));
+
+  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("GetLastRecording", Napi::Function::New(env, ObsGetLastRecording));
 
-  exports.Set("ObsStartBuffer", Napi::Function::New(env, ObsStartBuffer));
-  exports.Set("ObsStartRecording", Napi::Function::New(env, ObsStartRecording));
-  exports.Set("ObsStopRecording", Napi::Function::New(env, ObsStopRecording));
-  exports.Set("ObsGetLastRecording", Napi::Function::New(env, ObsGetLastRecording));
+  exports.Set("UpdateSourcePos", Napi::Function::New(env, ObsUpdateSourcePos));
 
-  exports.Set("ObsInitPreview", Napi::Function::New(env, ObsInitPreview));
-  exports.Set("ObsShowPreview", Napi::Function::New(env, ObsShowPreview));
-  exports.Set("ObsHidePreview", Napi::Function::New(env, ObsHidePreview));
+  exports.Set("InitPreview", Napi::Function::New(env, ObsInitPreview));
+  exports.Set("ShowPreview", Napi::Function::New(env, ObsShowPreview));
+  exports.Set("HidePreview", Napi::Function::New(env, ObsHidePreview));
   return exports;
 }
 

package/src/obs_interface.cpp

@@ -178,15 +178,26 @@ void ObsInterface::init_obs(const std::string& pluginPath, const std::string& da
   blog(LOG_INFO, "Exit init_obs");
 }
 
-obs_output_t* ObsInterface::create_output(const std::string& recordingPath) {
+void ObsInterface::configure_output(const std::string& recordingPath) {
   blog(LOG_INFO, "Create output");
-  obs_output_t *output = obs_output_create("replay_buffer", "recording_output", NULL, NULL);
+
+  if (output && obs_output_active(output)) {
+    blog(LOG_ERROR, "Tried to recreate active output");
+    throw std::runtime_error("Failed to create output!");
+  }
+
+  if (output) {
+    blog(LOG_DEBUG, "Releasing output");
+    obs_output_release(output);
+  }
+
+  output = obs_output_create("replay_buffer", "recording_output", NULL, NULL);
 
   if (!output) {
     blog(LOG_ERROR, "Failed to create output!");
     throw std::runtime_error("Failed to create output!");
   }
-
+  
   blog(LOG_INFO, "Set output settings");
   obs_data_t *settings = obs_data_create();
   obs_data_set_int(settings, "max_time_sec", 60);
@@ -197,7 +208,24 @@ obs_output_t* ObsInterface::create_output(const std::string& recordingPath) {
   obs_output_update(output, settings);
   obs_data_release(settings);
 
-  blog(LOG_INFO, "Create venc");
+  // Add the signal handler callback.
+  create_signal_handlers(output);
+}
+
+void ObsInterface::configure_video_encoder() {
+  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!");
+  }
+
+  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) {
@@ -205,18 +233,31 @@ obs_output_t* ObsInterface::create_output(const std::string& recordingPath) {
     throw std::runtime_error("Failed to create video encoder!");
   }
 
-  // blog(LOG_INFO, "Set video encoder settings");
-  // obs_data_t* amf_settings = obs_data_create();
-  // obs_data_set_string(amf_settings, "preset", "speed");  // Faster preset
-  // //obs_data_set_int(amf_settings, "bitrate", 2500);
-  // obs_data_set_string(amf_settings, "rate_control", "CQP");
-  // obs_data_set_int(amf_settings, "cqp", 30);
-  // obs_data_set_string(amf_settings, "profile", "main");
-  // obs_data_set_int(amf_settings, "keyint_sec", 1); // Set keyframe interval to 1 second
-  // obs_encoder_update(video_encoder, amf_settings);
-  // obs_data_release(amf_settings);
+  blog(LOG_INFO, "Set 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_data_release(venc_settings);
+}
+
+void ObsInterface::configure_audio_encoder() {
+  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 (audio_encoder) {
+    blog(LOG_DEBUG, "Releasing audio encoder");
+    obs_encoder_release(audio_encoder);
+    audio_encoder = nullptr;
+  }
 
-  blog(LOG_INFO, "Create aenc");
   audio_encoder = obs_audio_encoder_create("ffmpeg_aac", "simple_aac", NULL, 0, NULL);
 
   if (!audio_encoder) {
@@ -235,40 +276,50 @@ obs_output_t* ObsInterface::create_output(const std::string& recordingPath) {
 
   obs_encoder_set_video(video_encoder, obs_get_video());
   obs_encoder_set_audio(audio_encoder, obs_get_audio());
-
-  return output;
 }
 
-obs_scene_t* ObsInterface::create_scene() {
-  blog(LOG_INFO, "Create scene and src");
-  obs_scene_t *scene = obs_scene_create("WCR Scene");
+void ObsInterface::configure_scene() {
+  blog(LOG_INFO, "Configure scene");
+
+  if (scene) {
+    blog(LOG_DEBUG, "Releasing scene");
+    obs_scene_release(scene);
+    scene = nullptr;
+  }
+
+  scene = obs_scene_create("WCR Scene");
 
-  if (!scene)
+  if (!scene) {
+    blog(LOG_ERROR, "Failed to create scene!");
     throw std::runtime_error("Failed to create scene!");
+  }
 
   obs_source_t *scene_source = obs_scene_get_source(scene);
 
-  if (!scene_source)
-    throw std::runtime_error("Failed to get scene src!");
+  if (!scene_source) {
+    blog(LOG_ERROR, "Failed to get scene source!");
+    throw std::runtime_error("Failed to get scene source!");
+  }
 
-  obs_set_output_source(0, scene_source);  // 0 = video track
-  return scene;
+  obs_set_output_source(0, scene_source); // 0 = video track
+  obs_scene_add(scene, video_source);
 }
 
-obs_source_t* ObsInterface::create_video_source() {
-  blog(LOG_INFO, "Create display capture source");
+void ObsInterface::configure_video_source() {
+  blog(LOG_INFO, "Create monitor capture source");
+
   // Create settings for monitor capture
   obs_data_t *monitor_settings = obs_data_create();
   obs_data_set_int(monitor_settings, "monitor", 0);  // Monitor 0
   obs_data_set_bool(monitor_settings, "capture_cursor", true);
 
-  obs_source_t *source = obs_source_create("monitor_capture", "Monitor", monitor_settings, NULL);
+  video_source = obs_source_create("monitor_capture", "video_source", monitor_settings, NULL);
   obs_data_release(monitor_settings);
 
-  if (!source)
+  if (!video_source) {
+    blog(LOG_ERROR, "Failed to create video source!");
     throw std::runtime_error("Failed to create video source!");
-
-  return source;
+  }
 }
 
 void call_jscb(Napi::Env env, Napi::Function cb, SignalData* sd) {
@@ -428,15 +479,15 @@ ObsInterface::ObsInterface(
   // Initialize OBS and load required modules.
   init_obs(pluginPath, dataPath);
 
-  // Create the resources we rely on.
-  output = create_output(recordingPath);
-  scene = create_scene();
-  video_source = create_video_source();
-  obs_scene_add(scene, video_source);
-
-  // Add the signal handler callback.
+  // Setup callback function.
   jscb = cb;
-  create_signal_handlers(output);
+
+  // Create the resources we rely on.
+  configure_output(recordingPath);
+  configure_video_encoder();
+  configure_audio_encoder();
+  configure_video_source();
+  configure_scene();
 }
 
 ObsInterface::~ObsInterface() {
@@ -560,4 +611,20 @@ std::string ObsInterface::getLastRecording() {
   
   blog(LOG_INFO, "return path: %s", path.c_str());
   return path;
+}
+
+void ObsInterface::updateSourcePos(int x, int y, float scale) {
+  blog(LOG_INFO, "ObsInterface::moveSource called at (%d, %d)", x, y);
+  obs_sceneitem_t *item = obs_scene_find_source(scene, "video_source");
+
+  if (!item) {
+    blog(LOG_ERROR, "Did not find scene item for video source");
+    return;
+  }
+
+  struct vec2 pos = { (float)x, (float)y };
+  obs_sceneitem_set_pos(item, &pos);
+
+  struct vec2 scalep = { scale, scale };
+  obs_sceneitem_set_scale(item, &scalep);
 }

package/src/obs_interface.h

@@ -24,6 +24,8 @@ class ObsInterface {
     void stopRecording();
     std::string getLastRecording();
 
+    void updateSourcePos(int x, int y, float scale);
+
     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();
@@ -65,7 +67,9 @@ class ObsInterface {
     void list_input_types();
     void list_output_types();
 
-    obs_output_t* create_output(const std::string& recordingPath);
-    obs_scene_t* create_scene();
-    obs_source_t* create_video_source();
+    void configure_output(const std::string& recordingPath);
+    void configure_video_encoder();
+    void configure_audio_encoder();
+    void configure_scene();
+    void configure_video_source();
 };