noobs 0.0.145 → 0.0.147

package/package.json

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

package/src/obs_interface.cpp

@@ -10,14 +10,20 @@
 
 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 (sd->value.has_value()) {
     obj.Set("value", Napi::Number::New(env, sd->value.value()));
   }
 
+  if (sd->error.has_value()) {
+    obj.Set("error", Napi::String::New(env, sd->error.value()));
+  }
+
   cb.Call({ obj });
   delete sd;
 }
@@ -55,6 +61,22 @@ void ObsInterface::list_output_types()
   }
 }
 
+bool log_adapter(void *param, const char *node, uint32_t idx)
+{
+  blog(LOG_INFO, "  - %d: %s", idx, node);
+  return true;
+}
+
+void list_adapters()
+{
+  // Pretty sure OBS logs all this stuff anyway but do it ourselves for good measure.
+  obs_enter_graphics();
+  uint32_t count = gs_get_adapter_count();
+  blog(LOG_INFO, "Adapter count: %d", count);
+  gs_enum_adapters(log_adapter, NULL);
+  obs_leave_graphics();
+}
+
 void ObsInterface::load_module(const char* module, const char* data, bool allowFail) {
   blog(LOG_INFO, "Loading module: %s", module);
   blog(LOG_INFO, "Data path: %s", data);
@@ -145,7 +167,7 @@ bool ObsInterface::reset_audio() {
 }
 
 void ObsInterface::init_obs(const std::string& distPath) {
-  blog(LOG_INFO, "Enter init_obs");
+  blog(LOG_INFO, "Initializing OBS");
   auto success = obs_startup("en-US", NULL, NULL);
 
   if (!success) {
@@ -218,10 +240,12 @@ void ObsInterface::init_obs(const std::string& distPath) {
   list_encoders();
   list_source_types();
   list_output_types();
+  list_adapters();
 
-  blog(LOG_INFO, "Exit init_obs");
+  blog(LOG_INFO, "Initializing complete");
 }
 
+
 void ObsInterface::create_output() {
   blog(LOG_INFO, "Create outputs");
 
@@ -571,11 +595,25 @@ 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");
+
+  std::optional<std::string> error;
+
+  if (err) {
+    error = std::string(err);
+  }
 
   SignalContext* ctx = static_cast<SignalContext*>(data);
   ObsInterface* self = ctx->self;
 
-  SignalData* sd = new SignalData{ "output", ctx->id.c_str(), code };
+  SignalData* 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);
 }
 
@@ -896,7 +934,7 @@ ObsInterface::ObsInterface(
 }
 
 ObsInterface::~ObsInterface() {
-  blog(LOG_DEBUG, "Destroying ObsInterface");
+  blog(LOG_DEBUG, "Shutting down");
 
   for (auto& kv : volmeters) {
     obs_volmeter_t* volmeter = kv.second;
@@ -969,6 +1007,8 @@ ObsInterface::~ObsInterface() {
     blog(LOG_DEBUG, "Releasing JavaScript callback");
     jscb.Release();
   }
+
+  blog(LOG_DEBUG, "Shutdown complete");
 }
 
 void ObsInterface::setBuffering(bool value) {

package/src/obs_interface.h

@@ -18,6 +18,7 @@ struct SignalData {
   std::string id;
   long long code;
   std::optional<float> value;
+  std::optional<std::string> error;
 };
 
 struct SignalContext {

package/src/utils.cpp

@@ -7,77 +7,56 @@
 #include "utils.h"
 
 void log_handler(int lvl, const char *msg, va_list args, void *p) {
-  // Use the passed log path parameter
-  static std::string log_filename;
-  static bool filename_initialized = false;
-  
-  if (!filename_initialized) {
+    static std::ofstream logFile;
+    static bool initialized = false;
+
+    if (!initialized) {
+        // Build log filename
+        auto now = std::chrono::system_clock::now();
+        auto t = std::chrono::system_clock::to_time_t(now);
+        std::stringstream filename;
+        filename << "OBS-" << std::put_time(std::localtime(&t), "%Y-%m-%d") << ".log";
+
+        std::string log_dir = static_cast<const char*>(p);
+        if (!log_dir.empty() && log_dir.back() != '\\' && log_dir.back() != '/')
+            log_dir += '\\';
+
+        logFile.open(log_dir + filename.str(), std::ios::app);
+        initialized = true;
+    }
+
+    if (!logFile.is_open()) return;
+
+    // Timestamp
     auto now = std::chrono::system_clock::now();
-    auto time_t = std::chrono::system_clock::to_time_t(now);
-    
-    std::stringstream filename_stream;
-    filename_stream << "OBS-" << std::put_time(std::localtime(&time_t), "%Y-%m-%d") << ".log";
-    
-    // Use the provided directory path and append the filename
-    std::string log_dir = static_cast<const char*>(p);
+    auto t = std::chrono::system_clock::to_time_t(now);
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                  now.time_since_epoch()) % 1000;
+
+    std::stringstream timestamp;
+    timestamp << "[" << std::put_time(std::localtime(&t), "%Y-%m-%d %H:%M:%S")
+              << "." << std::setfill('0') << std::setw(3) << ms.count() << "] ";
 
-    // Ensure the directory path ends with a separator
-    if (!log_dir.empty() && log_dir.back() != '\\' && log_dir.back() != '/') {
-      log_dir += "\\";
+    // Log level
+    const char* level_str = "UNKNOWN";
+    switch (lvl) {
+        case LOG_ERROR:   level_str = "ERROR"; break;
+        case LOG_WARNING: level_str = "WARN";  break;
+        case LOG_INFO:    level_str = "INFO";  break;
+        case LOG_DEBUG:   level_str = "DEBUG"; break;
     }
+    timestamp << "[" << level_str << "]  ";
 
-    log_filename = log_dir + filename_stream.str();
-    filename_initialized = true;
-  }
-  
-  // Get current timestamp
-  auto now = std::chrono::system_clock::now();
-  auto time_t = std::chrono::system_clock::to_time_t(now);
-  auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-    now.time_since_epoch()) % 1000;
-  
-  // Convert log level to string
-  const char* level_str;
-  switch (lvl) {
-    case LOG_ERROR:   level_str = "ERROR"; break;
-    case LOG_WARNING: level_str = "WARN";  break;
-    case LOG_INFO:    level_str = "INFO";  break;
-    case LOG_DEBUG:   level_str = "DEBUG"; break;
-    default:          level_str = "UNKNOWN"; break;
-  }
-  
-  // Format the log message
-  char buffer[4096];
-  vsnprintf(buffer, sizeof(buffer), msg, args);
-  
-  // Create timestamp string
-  std::stringstream timestamp;
-  timestamp << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S");
-  timestamp << "." << std::setfill('0') << std::setw(3) << ms.count();
-  
-  std::string timestamp_str = "[" + timestamp.str() + "] [" + level_str + "] ";
-  
-  // Split the message by newlines and add timestamp to each line
-  std::string message(buffer);
-  std::istringstream iss(message);
-  std::string line;
-  std::string formatted_output;
-  
-  while (std::getline(iss, line)) {
-    formatted_output += timestamp_str + line + "\n";
-  }
-  
-  // Remove the last newline if it exists
-  if (!formatted_output.empty() && formatted_output.back() == '\n') {
-    formatted_output.pop_back();
-  }
-  
-  // Write to log file
-  std::ofstream logFile(log_filename, std::ios::app);
-  if (logFile.is_open()) {
-    logFile << formatted_output << std::endl;
-    logFile.close();
-  }
+    // Format message
+    char buffer[4096];
+    vsnprintf(buffer, sizeof(buffer), msg, args);
+
+    // Prepend timestamp and flush per line
+    std::istringstream iss(buffer);
+    std::string line;
+    while (std::getline(iss, line)) {
+        logFile << timestamp.str() << line << std::endl;  // std::endl flushes
+    }
 }
 
 Napi::Object data_to_napi(Napi::Env env, obs_data_t* data) {