noobs 0.0.30 → 0.0.32

package/index.d.ts

@@ -1,10 +1,22 @@
-type Signal = { // TODO export type? 
-  id: string;
-  code: number;
+export type Signal = {
+  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
+  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
 }
 
 interface Noobs {
-  ObsInit(
+  Init(
     pluginPath: string, 
     logPath: string, 
     dataPath: string,
@@ -12,16 +24,19 @@ 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;
+
+  GetSourcePos(src: string): SceneItemPosition & SourceDimensions;
+  SetSourcePos(src: string, pos: SceneItemPosition): void;
 
-  ObsInitPreview(hwnd: Buffer): void;
-  ObsShowPreview(x: number, y: number, width: number, height: number): void;
-  ObsHidePreview(): void;
+  InitPreview(hwnd: Buffer): void;
+  ShowPreview(x: number, y: number, width: number, height: number): void;
+  HidePreview(): void;
 }
 
 declare const noobs: Noobs;
-export = noobs;
+export default noobs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noobs",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "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,81 @@ Napi::Value ObsHidePreview(const Napi::CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+Napi::Value ObsGetSourcePos(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() == 1 && info[0].IsString();
+
+  if (!valid) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsGetSourcePos").ThrowAsJavaScriptException();
+    return info.Env().Undefined();  
+  }
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+
+  vec2 pos; vec2 size; vec2 scale;
+  obs->getSourcePos(name, &pos, &size, &scale);
+
+  Napi::Object result = Napi::Object::New(info.Env());
+  result.Set("x", Napi::Number::New(info.Env(), pos.x));
+  result.Set("y", Napi::Number::New(info.Env(), pos.y));
+  result.Set("width", Napi::Number::New(info.Env(), size.x));
+  result.Set("height", Napi::Number::New(info.Env(), size.y));
+  result.Set("scaleX", Napi::Number::New(info.Env(), scale.x));
+  result.Set("scaleY", Napi::Number::New(info.Env(), scale.y));
+  return result;
+}
+
+Napi::Value ObsSetSourcePos(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() == 6 &&
+    info[0].IsString() && // Source name
+    info[1].IsNumber() && // X position (px)
+    info[2].IsNumber() && // Y position (px)
+    info[3].IsNumber() && // Scale factor (X)
+    info[4].IsNumber();   // Scale factor (Y)
+
+  if (!valid) {
+    Napi::TypeError::New(info.Env(), "Invalid arguments passed to ObsSetSourcePos").ThrowAsJavaScriptException();
+    return info.Env().Undefined();  
+  }
+
+  std::string name = info[0].As<Napi::String>().Utf8Value();
+
+  float x = info[1].As<Napi::Number>().FloatValue();
+  float y = info[2].As<Napi::Number>().FloatValue();
+  vec2 pos = { x, y };
+
+  float scaleX = info[3].As<Napi::Number>().FloatValue();
+  float scaleY = info[4].As<Napi::Number>().FloatValue();
+  vec2 scale = { scaleX, scaleY };
+
+  obs->setSourcePos(name, &pos, &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("GetSourcePos", Napi::Function::New(env, ObsGetSourcePos));
+  exports.Set("SetSourcePos", Napi::Function::New(env, ObsSetSourcePos));
 
-  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) {
@@ -208,15 +236,28 @@ obs_output_t* ObsInterface::create_output(const std::string& recordingPath) {
   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_int(amf_settings, "bitrate", 2500);
   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)
+  if (scene) {
+    blog(LOG_DEBUG, "Releasing scene");
+    obs_scene_release(scene);
+    scene = nullptr;
+  }
+
+  scene = obs_scene_create("WCR 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,44 @@ std::string ObsInterface::getLastRecording() {
   
   blog(LOG_INFO, "return path: %s", path.c_str());
   return path;
+}
+
+void ObsInterface::getSourcePos(std::string name, vec2* pos, vec2* size, vec2* scale) 
+{
+  blog(LOG_INFO, "ObsInterface::getSourcePos called");
+
+  obs_source_t *src = obs_get_source_by_name(name.c_str());
+  obs_sceneitem_t *item = obs_scene_find_source(scene, name.c_str());
+
+  if (!src) {
+    blog(LOG_ERROR, "Did not find source for video  ");
+    return;
+  }
+
+  if (!item) {
+    blog(LOG_ERROR, "Did not find scene item for video source");
+    return;
+  }
+
+  obs_sceneitem_get_pos(item, pos);
+  obs_sceneitem_get_scale(item, scale);
+
+  // Pre-scaled sizes.
+  size->x = obs_source_get_width(src);
+  size->y = obs_source_get_height(src);
+
+  blog(LOG_INFO, "ObsInterface::getSourcePos exited");
+}
+
+void ObsInterface::setSourcePos(std::string name, vec2* pos, vec2* scale) {
+  blog(LOG_INFO, "ObsInterface::moveSource called");
+  obs_sceneitem_t *item = obs_scene_find_source(scene, name.c_str());
+
+  if (!item) {
+    blog(LOG_ERROR, "Did not find scene item for video source");
+    return;
+  }
+
+  obs_sceneitem_set_pos(item, pos);
+  obs_sceneitem_set_scale(item, scale);
 }

package/src/obs_interface.h

@@ -24,6 +24,9 @@ class ObsInterface {
     void stopRecording();
     std::string getLastRecording();
 
+    void getSourcePos(std::string name, vec2* pos, vec2* size, vec2* scale); // Size is returned to allow clients to calculate scale.
+    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();
@@ -65,7 +68,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();
 };