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

package/src/async_decode_worker.cc

@@ -5,6 +5,9 @@
 
 #include "src/async_decode_worker.h"
 
+#include <chrono>
+#include <cmath>
+#include <cstdio>
 #include <string>
 #include <utility>
 #include <vector>
@@ -14,38 +17,54 @@ extern "C" {
 #include <libswscale/swscale.h>
 }
 
+#include "src/common.h"
 #include "src/video_decoder.h"
 #include "src/video_frame.h"
 
-AsyncDecodeWorker::AsyncDecodeWorker(VideoDecoder* decoder,
+AsyncDecodeWorker::AsyncDecodeWorker(VideoDecoder* /* decoder */,
                                      Napi::ThreadSafeFunction output_tsfn,
                                      Napi::ThreadSafeFunction error_tsfn)
-    : decoder_(decoder),
-      output_tsfn_(output_tsfn),
+    : output_tsfn_(output_tsfn),
       error_tsfn_(error_tsfn),
       codec_context_(nullptr),
-      sws_context_(nullptr) {}
+      sws_context_(nullptr),
+      frame_(nullptr),
+      packet_(nullptr),
+      output_width_(0),
+      output_height_(0) {}
 
 AsyncDecodeWorker::~AsyncDecodeWorker() {
   Stop();
-  if (frame_) {
-    av_frame_free(&frame_);
-  }
-  if (packet_) {
-    av_packet_free(&packet_);
+  // frame_, packet_, and sws_context_ are RAII-managed, automatically cleaned up
+  // Note: codec_context_ is owned by VideoDecoder
+
+  // Clean up buffer pool
+  for (auto* buffer : buffer_pool_) {
+    delete buffer;
   }
-  // Note: codec_context_ and sws_context_ are owned by VideoDecoder
-  // They are cleaned up there, not here
+  buffer_pool_.clear();
 }
 
-void AsyncDecodeWorker::SetCodecContext(AVCodecContext* ctx, SwsContext* sws,
+void AsyncDecodeWorker::SetCodecContext(AVCodecContext* ctx,
+                                        SwsContext* /* sws_unused */,
                                         int width, int height) {
+  std::lock_guard<std::mutex> lock(codec_mutex_);
   codec_context_ = ctx;
-  sws_context_ = sws;
+  // sws_context_ is created lazily in EmitFrame when we know the frame format
+  sws_context_.reset();
   output_width_ = width;
   output_height_ = height;
-  frame_ = av_frame_alloc();
-  packet_ = av_packet_alloc();
+  frame_ = ffmpeg::make_frame();
+  packet_ = ffmpeg::make_packet();
+
+  // DARWIN-X64 FIX: Mark codec as valid only after successful initialization.
+  // ProcessPacket checks this flag to avoid accessing codec during shutdown.
+  codec_valid_.store(true, std::memory_order_release);
+}
+
+void AsyncDecodeWorker::SetMetadataConfig(const DecoderMetadataConfig& config) {
+  std::lock_guard<std::mutex> lock(codec_mutex_);
+  metadata_config_ = config;
 }
 
 void AsyncDecodeWorker::Start() {
@@ -56,9 +75,26 @@ void AsyncDecodeWorker::Start() {
 }
 
 void AsyncDecodeWorker::Stop() {
+  // DARWIN-X64 FIX: Use stop_mutex_ to prevent double-stop race.
+  // Cleanup() and destructor may both call Stop().
+  std::lock_guard<std::mutex> stop_lock(stop_mutex_);
+
   if (!running_.load()) return;
 
-  running_.store(false);
+  // DARWIN-X64 FIX: Invalidate codec FIRST, before signaling shutdown.
+  // This prevents ProcessPacket from accessing codec_context_ during the
+  // race window between setting running_=false and the worker thread exiting.
+  codec_valid_.store(false, std::memory_order_release);
+
+  {
+    // CRITICAL: Hold mutex while modifying condition predicate to prevent
+    // lost wakeup race on x86_64. Without mutex, there's a window where:
+    // 1. Worker checks predicate (running_==true), starts entering wait()
+    // 2. Main thread sets running_=false, calls notify_all()
+    // 3. Worker enters wait() after notification - blocked forever
+    std::lock_guard<std::mutex> lock(queue_mutex_);
+    running_.store(false, std::memory_order_release);
+  }
   queue_cv_.notify_all();
 
   if (worker_thread_.joinable()) {
@@ -75,13 +111,22 @@ void AsyncDecodeWorker::Enqueue(DecodeTask task) {
 }
 
 void AsyncDecodeWorker::Flush() {
-  flushing_.store(true);
+  // Enqueue a flush task to drain FFmpeg's internal frame buffers
+  DecodeTask flush_task;
+  flush_task.is_flush = true;
+  {
+    std::lock_guard<std::mutex> lock(queue_mutex_);
+    task_queue_.push(std::move(flush_task));
+  }
   queue_cv_.notify_one();
 
-  // Wait for queue to drain
+  flushing_.store(true);
+
+  // Wait for queue to drain AND all in-flight processing to complete
   std::unique_lock<std::mutex> lock(queue_mutex_);
-  queue_cv_.wait(lock,
-                 [this] { return task_queue_.empty() || !running_.load(); });
+  queue_cv_.wait(lock, [this] {
+    return (task_queue_.empty() && processing_.load() == 0) || !running_.load();
+  });
 
   flushing_.store(false);
 }
@@ -91,6 +136,28 @@ size_t AsyncDecodeWorker::QueueSize() const {
   return task_queue_.size();
 }
 
+std::vector<uint8_t>* AsyncDecodeWorker::AcquireBuffer(size_t size) {
+  std::lock_guard<std::mutex> lock(pool_mutex_);
+  for (auto it = buffer_pool_.begin(); it != buffer_pool_.end(); ++it) {
+    if ((*it)->capacity() >= size) {
+      auto* buffer = *it;
+      buffer_pool_.erase(it);
+      buffer->resize(size);
+      return buffer;
+    }
+  }
+  return new std::vector<uint8_t>(size);
+}
+
+void AsyncDecodeWorker::ReleaseBuffer(std::vector<uint8_t>* buffer) {
+  std::lock_guard<std::mutex> lock(pool_mutex_);
+  if (buffer_pool_.size() < 4) {  // Keep up to 4 buffers
+    buffer_pool_.push_back(buffer);
+  } else {
+    delete buffer;
+  }
+}
+
 void AsyncDecodeWorker::WorkerThread() {
   while (running_.load()) {
     DecodeTask task;
@@ -111,71 +178,211 @@ void AsyncDecodeWorker::WorkerThread() {
 
       task = std::move(task_queue_.front());
       task_queue_.pop();
+      processing_++;  // Track that we're processing this task
     }
 
     ProcessPacket(task);
 
-    if (task_queue_.empty()) {
-      queue_cv_.notify_all();
+    // Decrement counter and notify under lock (fixes race condition).
+    {
+      std::lock_guard<std::mutex> lock(queue_mutex_);
+      processing_--;
+      if (task_queue_.empty() && processing_.load() == 0) {
+        queue_cv_.notify_all();
+      }
     }
   }
 }
 
 void AsyncDecodeWorker::ProcessPacket(const DecodeTask& task) {
+  // DARWIN-X64 FIX: Check codec_valid_ BEFORE acquiring mutex.
+  // During shutdown, Stop() sets codec_valid_=false before running_=false.
+  // This creates a window where the worker thread could still be running
+  // but the codec is being destroyed. Early exit prevents the race.
+  if (!codec_valid_.load(std::memory_order_acquire)) {
+    return;
+  }
+
+  std::lock_guard<std::mutex> lock(codec_mutex_);
   if (!codec_context_ || !packet_ || !frame_) {
     return;
   }
 
+  // Handle flush task - send NULL packet to drain decoder
+  if (task.is_flush) {
+    avcodec_send_packet(codec_context_, nullptr);
+    // Drain all remaining frames from the decoder
+    while (avcodec_receive_frame(codec_context_, frame_.get()) == 0) {
+      EmitFrame(frame_.get());
+      av_frame_unref(frame_.get());
+    }
+    // Reset decoder to accept new packets after drain.
+    // Without this, decoder stays in drain mode and rejects further input.
+    avcodec_flush_buffers(codec_context_);
+    return;
+  }
+
   // Set up packet from task data
-  av_packet_unref(packet_);
+  av_packet_unref(packet_.get());
   packet_->data = const_cast<uint8_t*>(task.data.data());
   packet_->size = static_cast<int>(task.data.size());
   packet_->pts = task.timestamp;
 
-  int ret = avcodec_send_packet(codec_context_, packet_);
+  int ret = avcodec_send_packet(codec_context_, packet_.get());
   if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
     // Post error to main thread
     std::string error_msg = "Decode error: " + std::to_string(ret);
     error_tsfn_.NonBlockingCall(
         new std::string(error_msg),
         [](Napi::Env env, Napi::Function fn, std::string* msg) {
+          // If env is null, TSFN is closing during teardown. Just cleanup.
+          if (env == nullptr) {
+            delete msg;
+            return;
+          }
           fn.Call({Napi::Error::New(env, *msg).Value()});
           delete msg;
         });
     return;
   }
 
-  while (avcodec_receive_frame(codec_context_, frame_) == 0) {
-    EmitFrame(frame_);
-    av_frame_unref(frame_);
+  while (avcodec_receive_frame(codec_context_, frame_.get()) == 0) {
+    EmitFrame(frame_.get());
+    av_frame_unref(frame_.get());
   }
 }
 
 void AsyncDecodeWorker::EmitFrame(AVFrame* frame) {
-  if (!sws_context_) {
-    return;
+  // Initialize or recreate SwsContext if frame format/dimensions change
+  // (convert from decoder's pixel format to RGBA). RAII managed.
+  AVPixelFormat frame_format = static_cast<AVPixelFormat>(frame->format);
+
+  if (!sws_context_ || last_frame_format_ != frame_format ||
+      last_frame_width_ != frame->width ||
+      last_frame_height_ != frame->height) {
+    // RAII handles cleanup of old context automatically via reset()
+    sws_context_.reset(
+        sws_getContext(frame->width, frame->height, frame_format, frame->width,
+                       frame->height, AV_PIX_FMT_RGBA, SWS_BILINEAR, nullptr,
+                       nullptr, nullptr));
+
+    if (!sws_context_) {
+      std::string error_msg = "Could not create sws context";
+      error_tsfn_.NonBlockingCall(
+          new std::string(error_msg),
+          [](Napi::Env env, Napi::Function fn, std::string* msg) {
+            // If env is null, TSFN is closing during teardown. Just cleanup.
+            if (env == nullptr) {
+              delete msg;
+              return;
+            }
+            fn.Call({Napi::Error::New(env, *msg).Value()});
+            delete msg;
+          });
+      return;
+    }
+
+    last_frame_format_ = frame_format;
+    last_frame_width_ = frame->width;
+    last_frame_height_ = frame->height;
+    // Update output dimensions based on actual frame
+    output_width_ = frame->width;
+    output_height_ = frame->height;
   }
 
+  // Copy metadata under lock to prevent torn reads
+  // Note: codec_mutex_ is already held by ProcessPacket caller
+  DecoderMetadataConfig metadata_copy = metadata_config_;
+
   // Convert YUV to RGBA
   size_t rgba_size = output_width_ * output_height_ * 4;
-  auto* rgba_data = new std::vector<uint8_t>(rgba_size);
+  auto* rgba_data = AcquireBuffer(rgba_size);
 
   uint8_t* dst_data[1] = {rgba_data->data()};
   int dst_linesize[1] = {output_width_ * 4};
 
-  sws_scale(sws_context_, frame->data, frame->linesize, 0, frame->height,
+  sws_scale(sws_context_.get(), frame->data, frame->linesize, 0, frame->height,
             dst_data, dst_linesize);
 
   int64_t timestamp = frame->pts;
   int width = output_width_;
   int height = output_height_;
 
+  // Capture metadata for lambda
+  int rotation = metadata_copy.rotation;
+  bool flip = metadata_copy.flip;
+
+  // Calculate display dimensions based on aspect ratio (per W3C spec).
+  // If displayAspectWidth/displayAspectHeight are set, compute display
+  // dimensions maintaining the height and adjusting width to match ratio.
+  int disp_width = width;
+  int disp_height = height;
+  if (metadata_copy.display_width > 0 && metadata_copy.display_height > 0) {
+    // Per W3C spec: displayWidth = codedHeight * aspectWidth / aspectHeight
+    disp_width = static_cast<int>(
+        std::round(static_cast<double>(height) *
+                   static_cast<double>(metadata_copy.display_width) /
+                   static_cast<double>(metadata_copy.display_height)));
+    disp_height = height;
+  }
+  std::string color_primaries = metadata_copy.color_primaries;
+  std::string color_transfer = metadata_copy.color_transfer;
+  std::string color_matrix = metadata_copy.color_matrix;
+  bool color_full_range = metadata_copy.color_full_range;
+  bool has_color_space = metadata_copy.has_color_space;
+
+  // Increment pending BEFORE queueing callback for accurate tracking
+  (*pending_frames_)++;
+
+  // Capture shared_ptr to pending counter, NOT raw worker pointer.
+  // This ensures the counter remains valid even if the worker is destroyed
+  // before the TSFN callback executes on the main thread.
+  // Note: Buffer is managed via raw delete since buffer pool access is unsafe
+  // after worker destruction.
+  auto pending_counter = pending_frames_;
   output_tsfn_.NonBlockingCall(
-      rgba_data, [width, height, timestamp](Napi::Env env, Napi::Function fn,
-                                            std::vector<uint8_t>* data) {
-        Napi::Object frame_obj = VideoFrame::CreateInstance(
-            env, data->data(), data->size(), width, height, timestamp, "RGBA");
-        fn.Call({frame_obj});
+      rgba_data,
+      [pending_counter, width, height, timestamp, rotation, flip, disp_width,
+       disp_height, color_primaries, color_transfer, color_matrix,
+       color_full_range,
+       has_color_space](Napi::Env env, Napi::Function fn,
+                        std::vector<uint8_t>* data) {
+        // CRITICAL: If env is null, TSFN is closing during teardown.
+        // Must still clean up data and counters, then return.
+        // NOTE: Do NOT access static variables (like counterQueue) here - they may
+        // already be destroyed due to static destruction order during process exit.
+        if (env == nullptr) {
+          delete data;
+          (*pending_counter)--;
+          // Skip counterQueue-- : static may be destroyed during process exit
+          return;
+        }
+
+        // Always clean up, even if callback throws
+        try {
+          Napi::Object frame_obj;
+          if (has_color_space) {
+            frame_obj = VideoFrame::CreateInstance(
+                env, data->data(), data->size(), width, height, timestamp,
+                "RGBA", rotation, flip, disp_width, disp_height, color_primaries,
+                color_transfer, color_matrix, color_full_range);
+          } else {
+            frame_obj = VideoFrame::CreateInstance(
+                env, data->data(), data->size(), width, height, timestamp,
+                "RGBA", rotation, flip, disp_width, disp_height);
+          }
+          fn.Call({frame_obj});
+        } catch (const std::exception& e) {
+          // Log but don't propagate - cleanup must happen
+          fprintf(stderr, "AsyncDecodeWorker callback error: %s\n", e.what());
+        } catch (...) {
+          fprintf(stderr,
+                  "AsyncDecodeWorker callback error: unknown exception\n");
+        }
+        // Delete buffer directly (can't use pool after worker destruction)
         delete data;
+        // Decrement pending counter via shared_ptr (safe after worker destruction)
+        (*pending_counter)--;
+        webcodecs::counterQueue--;  // Decrement global queue counter
       });
 }

package/src/async_decode_worker.h

@@ -12,22 +12,40 @@ extern "C" {
 #include <libswscale/swscale.h>
 }
 
+#include "src/ffmpeg_raii.h"
+
 #include <napi.h>
 
 #include <atomic>
 #include <condition_variable>
+#include <memory>
 #include <mutex>
 #include <queue>
+#include <string>
 #include <thread>
 #include <vector>
 
 class VideoDecoder;
 
+// Metadata config for decoded video frames (mirrors EncoderMetadataConfig pattern)
+struct DecoderMetadataConfig {
+  int rotation = 0;
+  bool flip = false;
+  int display_width = 0;
+  int display_height = 0;
+  std::string color_primaries;
+  std::string color_transfer;
+  std::string color_matrix;
+  bool color_full_range = false;
+  bool has_color_space = false;
+};
+
 struct DecodeTask {
   std::vector<uint8_t> data;
   int64_t timestamp;
   int64_t duration;
   bool is_key;
+  bool is_flush = false;  // When true, flush the decoder instead of decoding
 };
 
 struct DecodedFrame {
@@ -55,15 +73,20 @@ class AsyncDecodeWorker {
   void Flush();
   void SetCodecContext(AVCodecContext* ctx, SwsContext* sws, int width,
                        int height);
+  void SetMetadataConfig(const DecoderMetadataConfig& config);
   bool IsRunning() const { return running_.load(); }
   size_t QueueSize() const;
+  int GetPendingFrames() const { return pending_frames_->load(); }
+  // Get shared pending counter for TSFN callbacks to capture
+  std::shared_ptr<std::atomic<int>> GetPendingFramesPtr() const {
+    return pending_frames_;
+  }
 
  private:
   void WorkerThread();
   void ProcessPacket(const DecodeTask& task);
   void EmitFrame(AVFrame* frame);
 
-  VideoDecoder* decoder_;
   Napi::ThreadSafeFunction output_tsfn_;
   Napi::ThreadSafeFunction error_tsfn_;
 
@@ -71,16 +94,44 @@ class AsyncDecodeWorker {
   std::queue<DecodeTask> task_queue_;
   mutable std::mutex queue_mutex_;  // mutable for const QueueSize()
   std::condition_variable queue_cv_;
+  std::mutex codec_mutex_;  // Protects codec_context_, sws_context_, frame_, packet_, metadata_config_
   std::atomic<bool> running_{false};
   std::atomic<bool> flushing_{false};
+  std::atomic<int> processing_{0};  // Track tasks currently being processed
+  // DARWIN-X64 FIX: Guard against codec access during shutdown race window.
+  // Set to true after SetCodecContext, false at START of Stop().
+  // ProcessPacket checks this before accessing codec_context_.
+  std::atomic<bool> codec_valid_{false};
+  // Mutex to synchronize Stop() calls from Cleanup() and destructor
+  std::mutex stop_mutex_;
+  // Use shared_ptr for pending counter so TSFN callbacks can safely access it
+  // even after the worker object is destroyed. The shared_ptr is captured by
+  // the callback lambda, ensuring the atomic counter remains valid.
+  std::shared_ptr<std::atomic<int>> pending_frames_ =
+      std::make_shared<std::atomic<int>>(0);
 
   // FFmpeg contexts (owned by VideoDecoder, just references here)
   AVCodecContext* codec_context_;
-  SwsContext* sws_context_;
-  AVFrame* frame_;
-  AVPacket* packet_;
+  ffmpeg::SwsContextPtr sws_context_;  // RAII-managed, created lazily on first frame
+  ffmpeg::AVFramePtr frame_;           // RAII-managed, owned by this worker
+  ffmpeg::AVPacketPtr packet_;         // RAII-managed, owned by this worker
   int output_width_;
   int output_height_;
+
+  // Track last frame format/dimensions for sws_context recreation
+  AVPixelFormat last_frame_format_ = AV_PIX_FMT_NONE;
+  int last_frame_width_ = 0;
+  int last_frame_height_ = 0;
+
+  // Buffer pool for decoded frame data to reduce allocations
+  std::vector<std::vector<uint8_t>*> buffer_pool_;
+  std::mutex pool_mutex_;
+
+  // Decoder metadata for output frames
+  DecoderMetadataConfig metadata_config_;
+
+  std::vector<uint8_t>* AcquireBuffer(size_t size);
+  void ReleaseBuffer(std::vector<uint8_t>* buffer);
 };
 
 #endif  // SRC_ASYNC_DECODE_WORKER_H_