@pproenca/node-webcodecs 0.1.0 → 0.1.1-alpha.5

package/src/audio_encoder.cc

@@ -3,6 +3,7 @@
 
 #include "src/audio_encoder.h"
 
+#include <cstdio>
 #include <string>
 #include <vector>
 
@@ -43,6 +44,8 @@ AudioEncoder::AudioEncoder(const Napi::CallbackInfo& info)
       number_of_channels_(0),
       timestamp_(0),
       frame_count_(0) {
+  // Track active encoder instance
+  webcodecs::counterAudioEncoders++;
   Napi::Env env = info.Env();
 
   if (info.Length() < 1 || !info[0].IsObject()) {
@@ -62,9 +65,27 @@ AudioEncoder::AudioEncoder(const Napi::CallbackInfo& info)
   error_callback_ = Napi::Persistent(init.Get("error").As<Napi::Function>());
 }
 
-AudioEncoder::~AudioEncoder() { Cleanup(); }
+AudioEncoder::~AudioEncoder() {
+  // CRITICAL: Call Cleanup() first to ensure codec context is properly
+  // flushed before any further cleanup.
+  Cleanup();
+
+  // Now safe to disable FFmpeg logging.
+  webcodecs::ShutdownFFmpegLogging();
+
+  webcodecs::counterAudioEncoders--;
+}
 
 void AudioEncoder::Cleanup() {
+  // Flush codec internal buffers BEFORE destroying resources.
+  // Audio codecs (opus, aac, mp3) may have internal queued samples. Flushing
+  // ensures they're drained before context destruction.
+  // CRITICAL: Only flush if codec was successfully opened. avcodec_flush_buffers
+  // crashes on an unopened codec context (the internal codec pointer is NULL).
+  if (codec_context_ && avcodec_is_open(codec_context_.get())) {
+    avcodec_flush_buffers(codec_context_.get());
+  }
+
   frame_.reset();
   packet_.reset();
   swr_context_.reset();
@@ -94,6 +115,12 @@ Napi::Value AudioEncoder::Configure(const Napi::CallbackInfo& info) {
     codec_id = AV_CODEC_ID_OPUS;
   } else if (codec_str.find("mp4a.40") == 0) {
     codec_id = AV_CODEC_ID_AAC;
+  } else if (codec_str == "flac") {
+    codec_id = AV_CODEC_ID_FLAC;
+  } else if (codec_str == "mp3") {
+    codec_id = AV_CODEC_ID_MP3;
+  } else if (codec_str == "vorbis") {
+    codec_id = AV_CODEC_ID_VORBIS;
   }
 
   // Find encoder.
@@ -133,10 +160,19 @@ Napi::Value AudioEncoder::Configure(const Napi::CallbackInfo& info) {
   codec_context_->bit_rate = webcodecs::AttrAsInt64(config, "bitrate", 128000);
 
   // Set sample format based on codec.
-  // Opus uses non-planar float (flt), AAC uses planar float (fltp).
+  // Different codecs require different sample formats:
+  // - Opus: non-planar float (flt)
+  // - AAC/Vorbis: planar float (fltp)
+  // - MP3: planar signed 16-bit (s16p) or planar float (fltp)
+  // - FLAC: signed 16-bit (s16) or signed 32-bit (s32)
   if (codec_id == AV_CODEC_ID_OPUS) {
     codec_context_->sample_fmt = AV_SAMPLE_FMT_FLT;
+  } else if (codec_id == AV_CODEC_ID_FLAC) {
+    codec_context_->sample_fmt = AV_SAMPLE_FMT_S16;
+  } else if (codec_id == AV_CODEC_ID_MP3) {
+    codec_context_->sample_fmt = AV_SAMPLE_FMT_S16P;
   } else {
+    // AAC and Vorbis use planar float
     codec_context_->sample_fmt = AV_SAMPLE_FMT_FLTP;
   }
 
@@ -298,9 +334,9 @@ void AudioEncoder::Close(const Napi::CallbackInfo& info) {
 Napi::Value AudioEncoder::Reset(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
+  // W3C spec: reset() is a no-op when closed (don't throw)
   if (state_ == "closed") {
-    throw Napi::Error::New(env,
-                           "InvalidStateError: Cannot reset closed encoder");
+    return env.Undefined();
   }
 
   Cleanup();
@@ -554,6 +590,21 @@ Napi::Value AudioEncoder::IsConfigSupported(const Napi::CallbackInfo& info) {
       if (!c) {
         supported = false;
       }
+    } else if (codec == "flac") {
+      const AVCodec* c = avcodec_find_encoder(AV_CODEC_ID_FLAC);
+      if (!c) {
+        supported = false;
+      }
+    } else if (codec == "mp3") {
+      const AVCodec* c = avcodec_find_encoder(AV_CODEC_ID_MP3);
+      if (!c) {
+        supported = false;
+      }
+    } else if (codec == "vorbis") {
+      const AVCodec* c = avcodec_find_encoder(AV_CODEC_ID_VORBIS);
+      if (!c) {
+        supported = false;
+      }
     } else {
       supported = false;
     }

package/src/common.cc

@@ -13,10 +13,70 @@
 
 namespace webcodecs {
 
-// Global counters
-std::atomic<int> counterQueue{0};
-std::atomic<int> counterProcess{0};
-std::atomic<int> counterFrames{0};
+// STATIC DESTRUCTION ORDER FIX: Use heap-allocated "immortal" counters.
+// During process exit, static destructors may run in unpredictable order.
+// Codec destructors access these counters, so we must ensure they're never
+// destroyed. We trade a tiny memory leak at exit for crash-free shutdown.
+// This matches the pattern used for FFmpeg logging queue/mutex.
+
+// Per-class instance counters for deterministic leak detection
+static std::atomic<int64_t>& GetCounterVideoFrames() {
+  static auto* counter = new std::atomic<int64_t>(0);
+  return *counter;
+}
+static std::atomic<int64_t>& GetCounterAudioData() {
+  static auto* counter = new std::atomic<int64_t>(0);
+  return *counter;
+}
+static std::atomic<int64_t>& GetCounterVideoEncoders() {
+  static auto* counter = new std::atomic<int64_t>(0);
+  return *counter;
+}
+static std::atomic<int64_t>& GetCounterVideoDecoders() {
+  static auto* counter = new std::atomic<int64_t>(0);
+  return *counter;
+}
+static std::atomic<int64_t>& GetCounterAudioEncoders() {
+  static auto* counter = new std::atomic<int64_t>(0);
+  return *counter;
+}
+static std::atomic<int64_t>& GetCounterAudioDecoders() {
+  static auto* counter = new std::atomic<int64_t>(0);
+  return *counter;
+}
+
+// Legacy counters (maintained for backwards compatibility)
+static std::atomic<int>& GetCounterQueue() {
+  static auto* counter = new std::atomic<int>(0);
+  return *counter;
+}
+static std::atomic<int>& GetCounterProcess() {
+  static auto* counter = new std::atomic<int>(0);
+  return *counter;
+}
+static std::atomic<int>& GetCounterFrames() {
+  static auto* counter = new std::atomic<int>(0);
+  return *counter;
+}
+
+// References to immortal counters for extern linkage
+std::atomic<int64_t>& counterVideoFrames = GetCounterVideoFrames();
+std::atomic<int64_t>& counterAudioData = GetCounterAudioData();
+std::atomic<int64_t>& counterVideoEncoders = GetCounterVideoEncoders();
+std::atomic<int64_t>& counterVideoDecoders = GetCounterVideoDecoders();
+std::atomic<int64_t>& counterAudioEncoders = GetCounterAudioEncoders();
+std::atomic<int64_t>& counterAudioDecoders = GetCounterAudioDecoders();
+
+std::atomic<int>& counterQueue = GetCounterQueue();
+std::atomic<int>& counterProcess = GetCounterProcess();
+std::atomic<int>& counterFrames = GetCounterFrames();
+
+// FreeCallback for consistent buffer deallocation (following sharp pattern).
+// Default implementation uses delete[]. Can be overridden for platform-specific
+// memory management (e.g., Windows mixed runtime scenarios).
+std::function<void(void*, uint8_t*)> FreeCallback = [](void*, uint8_t* data) {
+  delete[] data;
+};
 
 //==============================================================================
 // Attribute Helpers
@@ -276,8 +336,14 @@ Napi::Error FFmpegError(Napi::Env env, const std::string& operation,
 }
 
 std::string FFmpegErrorString(int errnum) {
-  char errbuf[AV_ERROR_MAX_STRING_SIZE];
-  av_strerror(errnum, errbuf, sizeof(errbuf));
+  char errbuf[AV_ERROR_MAX_STRING_SIZE] = {0};
+  int ret = av_strerror(errnum, errbuf, sizeof(errbuf));
+  // Check for explicit failure OR empty buffer (ABI mismatch with strerror_r).
+  // FFmpeg built on musl expects XSI strerror_r (returns int, writes to buffer).
+  // When running on glibc, GNU strerror_r returns char* without writing to buffer.
+  if (ret < 0 || errbuf[0] == '\0') {
+    snprintf(errbuf, sizeof(errbuf), "Error code %d", errnum);
+  }
   return std::string(errbuf);
 }
 
@@ -333,6 +399,15 @@ std::string PixelFormatToString(AVPixelFormat format) {
   }
 }
 
+//==============================================================================
+// String Utilities
+//==============================================================================
+
+std::string TrimEnd(const std::string& str) {
+  size_t end = str.find_last_not_of(" \t\n\r\f\v");
+  return (end == std::string::npos) ? "" : str.substr(0, end + 1);
+}
+
 //==============================================================================
 // FFmpeg Initialization
 //==============================================================================
@@ -351,13 +426,31 @@ void InitFFmpeg() {
 // FFmpeg Logging
 //==============================================================================
 
-static std::queue<std::string> ffmpegWarnings;
-static std::mutex ffmpegWarningsMutex;
+// STATIC DESTRUCTION ORDER FIX: Use heap-allocated "immortal" objects to prevent
+// crashes during process exit. When vitest worker processes exit, static
+// destructors may run in unpredictable order, causing FFmpeg's log callback
+// to access destroyed mutex/queue. By never destroying these, we trade a tiny
+// memory leak at exit for crash-free shutdown.
+static std::queue<std::string>& GetWarningsQueue() {
+  static auto* queue = new std::queue<std::string>();
+  return *queue;
+}
+static std::mutex& GetWarningsMutex() {
+  static auto* mutex = new std::mutex();
+  return *mutex;
+}
+static std::atomic<bool> ffmpegLoggingActive{false};
 
 void InitFFmpegLogging() {
   static std::once_flag log_init_once;
   std::call_once(log_init_once, []() {
+    ffmpegLoggingActive.store(true, std::memory_order_release);
     av_log_set_callback([](void* ptr, int level, const char* fmt, va_list vl) {
+      // Guard against callbacks during/after shutdown to prevent
+      // static destruction order fiasco on process exit.
+      if (!ffmpegLoggingActive.load(std::memory_order_acquire)) {
+        return;
+      }
       if (level <= AV_LOG_WARNING) {
         char buf[1024];
         vsnprintf(buf, sizeof(buf), fmt, vl);
@@ -369,28 +462,43 @@ void InitFFmpegLogging() {
         // Skip empty messages
         if (strlen(buf) == 0) return;
 
-        std::lock_guard<std::mutex> lock(ffmpegWarningsMutex);
-        ffmpegWarnings.push(buf);
+        std::lock_guard<std::mutex> lock(GetWarningsMutex());
+        GetWarningsQueue().push(buf);
       }
     });
     av_log_set_level(AV_LOG_WARNING);
   });
 }
 
+void ShutdownFFmpegLogging() {
+  // Ensure shutdown runs exactly once - multiple concurrent calls from
+  // encoder/decoder destructors and cleanup hook could race on av_log_set_callback.
+  static std::once_flag shutdown_once;
+  std::call_once(shutdown_once, []() {
+    // Disable logging callback before static destructors run.
+    // This prevents the callback from accessing destroyed statics
+    // during process exit (static destruction order fiasco).
+    ffmpegLoggingActive.store(false, std::memory_order_release);
+    av_log_set_callback(nullptr);
+  });
+}
+
 std::vector<std::string> GetFFmpegWarnings() {
-  std::lock_guard<std::mutex> lock(ffmpegWarningsMutex);
+  std::lock_guard<std::mutex> lock(GetWarningsMutex());
   std::vector<std::string> result;
-  while (!ffmpegWarnings.empty()) {
-    result.push_back(ffmpegWarnings.front());
-    ffmpegWarnings.pop();
+  auto& queue = GetWarningsQueue();
+  while (!queue.empty()) {
+    result.push_back(queue.front());
+    queue.pop();
   }
   return result;
 }
 
 void ClearFFmpegWarnings() {
-  std::lock_guard<std::mutex> lock(ffmpegWarningsMutex);
-  while (!ffmpegWarnings.empty()) {
-    ffmpegWarnings.pop();
+  std::lock_guard<std::mutex> lock(GetWarningsMutex());
+  auto& queue = GetWarningsQueue();
+  while (!queue.empty()) {
+    queue.pop();
   }
 }
 

package/src/common.h

@@ -14,6 +14,7 @@ extern "C" {
 #include <napi.h>
 
 #include <atomic>
+#include <functional>
 #include <mutex>
 #include <string>
 #include <tuple>
@@ -109,12 +110,40 @@ AVPixelFormat PixelFormatFromString(const std::string& format);
 std::string PixelFormatToString(AVPixelFormat format);
 
 //==============================================================================
-// Global Counters (for monitoring, following sharp pattern)
+// Global Counters (for monitoring and leak detection)
 //==============================================================================
 
-extern std::atomic<int> counterQueue;
-extern std::atomic<int> counterProcess;
-extern std::atomic<int> counterFrames;
+// Per-class instance counters for deterministic leak detection.
+// Increment in constructor, decrement in destructor.
+// NOTE: These are references to heap-allocated "immortal" atomics to prevent
+// static destruction order issues during process exit (darwin-x64 fix).
+extern std::atomic<int64_t>& counterVideoFrames;
+extern std::atomic<int64_t>& counterAudioData;
+extern std::atomic<int64_t>& counterVideoEncoders;
+extern std::atomic<int64_t>& counterVideoDecoders;
+extern std::atomic<int64_t>& counterAudioEncoders;
+extern std::atomic<int64_t>& counterAudioDecoders;
+
+// Legacy counters (maintained for backwards compatibility)
+extern std::atomic<int>& counterQueue;
+extern std::atomic<int>& counterProcess;
+extern std::atomic<int>& counterFrames;  // Legacy frame counter (use counterVideoFrames)
+
+//==============================================================================
+// Memory Management (following sharp pattern for Windows compatibility)
+//==============================================================================
+
+// FreeCallback for consistent buffer deallocation across platforms.
+// Windows mixed runtime libraries can have issues with different allocators,
+// so using a consistent deallocation function avoids potential crashes.
+extern std::function<void(void*, uint8_t*)> FreeCallback;
+
+//==============================================================================
+// String Utilities
+//==============================================================================
+
+// Trim whitespace from end of string (following sharp pattern)
+std::string TrimEnd(const std::string& str);
 
 //==============================================================================
 // FFmpeg Initialization
@@ -127,6 +156,7 @@ void InitFFmpeg();
 //==============================================================================
 
 void InitFFmpegLogging();
+void ShutdownFFmpegLogging();
 std::vector<std::string> GetFFmpegWarnings();
 void ClearFFmpegWarnings();
 

package/src/demuxer.cc

@@ -20,6 +20,7 @@ Napi::Object Demuxer::Init(Napi::Env env, Napi::Object exports) {
                   {
                       InstanceMethod("open", &Demuxer::Open),
                       InstanceMethod("demux", &Demuxer::DemuxPackets),
+                      InstanceMethod("demuxPackets", &Demuxer::DemuxPackets),
                       InstanceMethod("close", &Demuxer::Close),
                       InstanceMethod("getVideoTrack", &Demuxer::GetVideoTrack),
                       InstanceMethod("getAudioTrack", &Demuxer::GetAudioTrack),
@@ -65,6 +66,11 @@ void Demuxer::Cleanup() {
   tracks_.clear();
   video_stream_index_ = -1;
   audio_stream_index_ = -1;
+
+  // Clear callback references
+  on_track_callback_.Reset();
+  on_chunk_callback_.Reset();
+  on_error_callback_.Reset();
 }
 
 Napi::Value Demuxer::Open(const Napi::CallbackInfo& info) {
@@ -175,6 +181,11 @@ Napi::Value Demuxer::DemuxPackets(const Napi::CallbackInfo& info) {
     return env.Undefined();
   }
 
+  int max_packets = 0;  // 0 = unlimited (backwards compatible)
+  if (info.Length() > 0 && info[0].IsNumber()) {
+    max_packets = info[0].As<Napi::Number>().Int32Value();
+  }
+
   ffmpeg::AVPacketPtr packet = ffmpeg::make_packet();
   if (!packet) {
     Napi::Error::New(env, "Failed to allocate packet")
@@ -182,15 +193,18 @@ Napi::Value Demuxer::DemuxPackets(const Napi::CallbackInfo& info) {
     return env.Undefined();
   }
 
-  while (av_read_frame(format_context_.get(), packet.get()) >= 0) {
+  int packets_read = 0;
+  while ((max_packets == 0 || packets_read < max_packets) &&
+         av_read_frame(format_context_.get(), packet.get()) >= 0) {
     if (packet->stream_index == video_stream_index_ ||
         packet->stream_index == audio_stream_index_) {
       EmitChunk(env, packet.get(), packet->stream_index);
+      packets_read++;
     }
     av_packet_unref(packet.get());
   }
 
-  return env.Undefined();
+  return Napi::Number::New(env, packets_read);
 }
 
 void Demuxer::EmitChunk(Napi::Env env, AVPacket* packet, int track_index) {

package/src/encoded_audio_chunk.cc

@@ -26,6 +26,7 @@ Napi::Object EncodedAudioChunk::Init(Napi::Env env, Napi::Object exports) {
           InstanceAccessor("byteLength", &EncodedAudioChunk::GetByteLength,
                            nullptr),
           InstanceMethod("copyTo", &EncodedAudioChunk::CopyTo),
+          InstanceMethod("close", &EncodedAudioChunk::Close),
       });
 
   constructor_ = Napi::Persistent(func);
@@ -173,3 +174,12 @@ void EncodedAudioChunk::CopyTo(const Napi::CallbackInfo& info) {
 
   std::memcpy(dest_data, data_.data(), data_.size());
 }
+
+void EncodedAudioChunk::Close(const Napi::CallbackInfo& info) {
+  if (!closed_) {
+    // clear() + shrink_to_fit() actually releases memory.
+    data_.clear();
+    data_.shrink_to_fit();
+    closed_ = true;
+  }
+}

package/src/encoded_audio_chunk.h

@@ -30,6 +30,7 @@ class EncodedAudioChunk : public Napi::ObjectWrap<EncodedAudioChunk> {
 
   // Methods.
   void CopyTo(const Napi::CallbackInfo& info);
+  void Close(const Napi::CallbackInfo& info);
 
   // Internal access.
   const std::vector<uint8_t>& GetData() const { return data_; }
@@ -41,6 +42,7 @@ class EncodedAudioChunk : public Napi::ObjectWrap<EncodedAudioChunk> {
   int64_t timestamp_;
   int64_t duration_;
   std::vector<uint8_t> data_;
+  bool closed_ = false;
 };
 
 #endif  // SRC_ENCODED_AUDIO_CHUNK_H_

package/src/encoded_video_chunk.h

@@ -28,6 +28,7 @@ class EncodedVideoChunk : public Napi::ObjectWrap<EncodedVideoChunk> {
   const uint8_t* GetData() const { return data_.data(); }
   size_t GetDataSize() const { return data_.size(); }
   int64_t GetTimestampValue() const { return timestamp_; }
+  int64_t GetDurationValue() const { return has_duration_ ? duration_ : 0; }
   const std::string& GetTypeValue() const { return type_; }
 
  private:

package/src/error_builder.cc

@@ -20,10 +20,6 @@ Napi::Object ErrorBuilder::Init(Napi::Env env, Napi::Object exports) {
           InstanceMethod("throwError", &ErrorBuilder::ThrowErrorJS),
       });
 
-  Napi::FunctionReference* constructor = new Napi::FunctionReference();
-  *constructor = Napi::Persistent(func);
-  env.SetInstanceData(constructor);
-
   exports.Set("ErrorBuilder", func);
   return exports;
 }