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

package/src/image_decoder.cc

@@ -19,6 +19,19 @@
 // Buffer size for AVIOContext (4KB is typical for image data)
 static const int kAVIOBufferSize = 4096;
 
+// Premultiply alpha in-place for RGBA data.
+// Applies premultiplication: R' = R * A / 255, G' = G * A / 255, B' = B * A / 255
+// Uses (value * alpha + 127) / 255 for correct rounding.
+static void PremultiplyAlpha(uint8_t* rgba_data, int width, int height) {
+  for (int i = 0; i < width * height; i++) {
+    uint8_t* pixel = rgba_data + i * 4;
+    uint8_t alpha = pixel[3];
+    pixel[0] = static_cast<uint8_t>((pixel[0] * alpha + 127) / 255);
+    pixel[1] = static_cast<uint8_t>((pixel[1] * alpha + 127) / 255);
+    pixel[2] = static_cast<uint8_t>((pixel[2] * alpha + 127) / 255);
+  }
+}
+
 // Custom read callback for AVIOContext to read from memory buffer
 struct MemoryBufferContext {
   const uint8_t* data;
@@ -65,6 +78,9 @@ static int64_t SeekPacket(void* opaque, int64_t offset, int whence) {
   return new_pos;
 }
 
+// Static member definition
+Napi::FunctionReference ImageDecoder::constructor_;
+
 Napi::Object ImageDecoder::Init(Napi::Env env, Napi::Object exports) {
   Napi::Function func = DefineClass(
       env, "ImageDecoder",
@@ -77,9 +93,9 @@ Napi::Object ImageDecoder::Init(Napi::Env env, Napi::Object exports) {
           StaticMethod("isTypeSupported", &ImageDecoder::IsTypeSupported),
       });
 
-  Napi::FunctionReference* constructor = new Napi::FunctionReference();
-  *constructor = Napi::Persistent(func);
-  env.SetInstanceData(constructor);
+  // Use static member pattern to avoid heap allocation leak
+  constructor_ = Napi::Persistent(func);
+  constructor_.SuppressDestruct();
 
   exports.Set("ImageDecoder", func);
   return exports;
@@ -88,12 +104,13 @@ Napi::Object ImageDecoder::Init(Napi::Env env, Napi::Object exports) {
 ImageDecoder::ImageDecoder(const Napi::CallbackInfo& info)
     : Napi::ObjectWrap<ImageDecoder>(info),
       codec_(nullptr),
-      codec_context_(nullptr),
-      sws_context_(nullptr),
-      frame_(nullptr),
-      packet_(nullptr),
+      codec_context_(),
+      sws_context_(),
+      frame_(),
+      packet_(),
       format_context_(nullptr),
       avio_context_(nullptr),
+      mem_ctx_(nullptr),
       video_stream_index_(-1),
       decoded_width_(0),
       decoded_height_(0),
@@ -101,7 +118,8 @@ ImageDecoder::ImageDecoder(const Napi::CallbackInfo& info)
       frame_count_(1),
       repetition_count_(0),
       complete_(false),
-      closed_(false) {
+      closed_(false),
+      premultiply_alpha_("default") {
   Napi::Env env = info.Env();
 
   if (info.Length() < 1 || !info[0].IsObject()) {
@@ -120,6 +138,16 @@ ImageDecoder::ImageDecoder(const Napi::CallbackInfo& info)
   }
   type_ = webcodecs::AttrAsStr(init, "type");
 
+  // Get premultiplyAlpha option
+  premultiply_alpha_ = webcodecs::AttrAsStr(init, "premultiplyAlpha", "default");
+  if (premultiply_alpha_ != "none" && premultiply_alpha_ != "premultiply" &&
+      premultiply_alpha_ != "default") {
+    Napi::TypeError::New(
+        env, "premultiplyAlpha must be 'none', 'premultiply', or 'default'")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
   // Get data
   if (!init.Has("data")) {
     Napi::TypeError::New(env, "data is required").ThrowAsJavaScriptException();
@@ -159,8 +187,8 @@ ImageDecoder::ImageDecoder(const Napi::CallbackInfo& info)
     return;
   }
 
-  // Create codec context
-  codec_context_ = avcodec_alloc_context3(codec_);
+  // Create codec context using RAII wrapper
+  codec_context_ = ffmpeg::make_codec_context(codec_);
   if (!codec_context_) {
     Napi::Error::New(env, "Failed to allocate codec context")
         .ThrowAsJavaScriptException();
@@ -168,15 +196,15 @@ ImageDecoder::ImageDecoder(const Napi::CallbackInfo& info)
   }
 
   // Open codec
-  if (avcodec_open2(codec_context_, codec_, nullptr) < 0) {
+  if (avcodec_open2(codec_context_.get(), codec_, nullptr) < 0) {
     Cleanup();
     Napi::Error::New(env, "Failed to open codec").ThrowAsJavaScriptException();
     return;
   }
 
-  // Allocate frame and packet
-  frame_ = av_frame_alloc();
-  packet_ = av_packet_alloc();
+  // Allocate frame and packet using RAII wrappers
+  frame_ = ffmpeg::make_frame();
+  packet_ = ffmpeg::make_packet();
   if (!frame_ || !packet_) {
     Cleanup();
     Napi::Error::New(env, "Failed to allocate frame/packet")
@@ -205,26 +233,20 @@ ImageDecoder::ImageDecoder(const Napi::CallbackInfo& info)
 ImageDecoder::~ImageDecoder() { Cleanup(); }
 
 void ImageDecoder::Cleanup() {
-  if (sws_context_) {
-    sws_freeContext(sws_context_);
-    sws_context_ = nullptr;
-  }
-  if (frame_) {
-    av_frame_free(&frame_);
-    frame_ = nullptr;
-  }
-  if (packet_) {
-    av_packet_free(&packet_);
-    packet_ = nullptr;
-  }
-  if (codec_context_) {
-    avcodec_free_context(&codec_context_);
-    codec_context_ = nullptr;
-  }
+  // RAII wrappers handle deallocation automatically via reset()
+  sws_context_.reset();
+  frame_.reset();
+  packet_.reset();
+  codec_context_.reset();
   if (format_context_) {
     avformat_close_input(&format_context_);
     format_context_ = nullptr;
   }
+  // Free MemoryBufferContext BEFORE avio_context_free (it's stored in opaque)
+  if (mem_ctx_) {
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
+  }
   if (avio_context_) {
     // The buffer is freed by avio_context_free
     av_freep(&avio_context_->buffer);
@@ -261,12 +283,12 @@ bool ImageDecoder::ConvertFrameToRGBA(AVFrame* src_frame,
     return false;
   }
 
-  // Create swscale context for conversion to RGBA
-  SwsContext* local_sws =
+  // Create swscale context for conversion to RGBA (RAII managed)
+  ffmpeg::SwsContextPtr local_sws(
       sws_getContext(src_frame->width, src_frame->height,
                      static_cast<AVPixelFormat>(src_frame->format),
                      src_frame->width, src_frame->height, AV_PIX_FMT_RGBA,
-                     SWS_BILINEAR, nullptr, nullptr, nullptr);
+                     SWS_BILINEAR, nullptr, nullptr, nullptr));
 
   if (!local_sws) {
     return false;
@@ -282,10 +304,14 @@ bool ImageDecoder::ConvertFrameToRGBA(AVFrame* src_frame,
   int dest_linesize[4] = {src_frame->width * 4, 0, 0, 0};
 
   // Convert
-  sws_scale(local_sws, src_frame->data, src_frame->linesize, 0,
+  sws_scale(local_sws.get(), src_frame->data, src_frame->linesize, 0,
             src_frame->height, dest_data, dest_linesize);
 
-  sws_freeContext(local_sws);
+  // Apply alpha premultiplication if requested
+  if (premultiply_alpha_ == "premultiply") {
+    PremultiplyAlpha(output->data(), src_frame->width, src_frame->height);
+  }
+
   return true;
 }
 
@@ -295,24 +321,26 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
   }
 
   // Allocate memory buffer context for custom I/O
-  MemoryBufferContext* mem_ctx = new MemoryBufferContext();
-  mem_ctx->data = data_.data();
-  mem_ctx->size = data_.size();
-  mem_ctx->position = 0;
+  mem_ctx_ = new MemoryBufferContext();
+  mem_ctx_->data = data_.data();
+  mem_ctx_->size = data_.size();
+  mem_ctx_->position = 0;
 
   // Allocate AVIO buffer
   uint8_t* avio_buffer = static_cast<uint8_t*>(av_malloc(kAVIOBufferSize));
   if (!avio_buffer) {
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
   // Create custom AVIO context
-  avio_context_ = avio_alloc_context(avio_buffer, kAVIOBufferSize, 0, mem_ctx,
+  avio_context_ = avio_alloc_context(avio_buffer, kAVIOBufferSize, 0, mem_ctx_,
                                      ReadPacket, nullptr, SeekPacket);
   if (!avio_context_) {
     av_free(avio_buffer);
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
@@ -321,7 +349,8 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
   if (!format_context_) {
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
@@ -345,7 +374,8 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
     avio_context_ = nullptr;
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
@@ -356,7 +386,8 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
     avio_context_ = nullptr;
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
@@ -375,7 +406,8 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
     avio_context_ = nullptr;
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
@@ -393,57 +425,58 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
     avio_context_ = nullptr;
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
-  // Allocate new codec context for the stream
-  AVCodecContext* stream_codec_ctx = avcodec_alloc_context3(stream_codec);
+  // Allocate new codec context for the stream (RAII managed)
+  ffmpeg::AVCodecContextPtr stream_codec_ctx =
+      ffmpeg::make_codec_context(stream_codec);
   if (!stream_codec_ctx) {
     avformat_close_input(&format_context_);
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
     avio_context_ = nullptr;
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
   // Copy codec parameters
-  ret = avcodec_parameters_to_context(stream_codec_ctx, codecpar);
+  ret = avcodec_parameters_to_context(stream_codec_ctx.get(), codecpar);
   if (ret < 0) {
-    avcodec_free_context(&stream_codec_ctx);
     avformat_close_input(&format_context_);
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
     avio_context_ = nullptr;
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
   // Open codec
-  ret = avcodec_open2(stream_codec_ctx, stream_codec, nullptr);
+  ret = avcodec_open2(stream_codec_ctx.get(), stream_codec, nullptr);
   if (ret < 0) {
-    avcodec_free_context(&stream_codec_ctx);
     avformat_close_input(&format_context_);
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
     avio_context_ = nullptr;
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
-  // Count frames and decode them
-  AVPacket* pkt = av_packet_alloc();
-  AVFrame* frm = av_frame_alloc();
+  // Count frames and decode them (RAII managed)
+  ffmpeg::AVPacketPtr pkt = ffmpeg::make_packet();
+  ffmpeg::AVFramePtr frm = ffmpeg::make_frame();
   if (!pkt || !frm) {
-    if (pkt) av_packet_free(&pkt);
-    if (frm) av_frame_free(&frm);
-    avcodec_free_context(&stream_codec_ctx);
     avformat_close_input(&format_context_);
     av_freep(&avio_context_->buffer);
     avio_context_free(&avio_context_);
     avio_context_ = nullptr;
-    delete mem_ctx;
+    delete mem_ctx_;
+    mem_ctx_ = nullptr;
     return false;
   }
 
@@ -492,13 +525,13 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
   }
 
   // Read all frames
-  while (av_read_frame(format_context_, pkt) >= 0) {
+  while (av_read_frame(format_context_, pkt.get()) >= 0) {
     if (pkt->stream_index == video_stream_index_) {
-      ret = avcodec_send_packet(stream_codec_ctx, pkt);
+      ret = avcodec_send_packet(stream_codec_ctx.get(), pkt.get());
       if (ret >= 0) {
-        while (avcodec_receive_frame(stream_codec_ctx, frm) >= 0) {
+        while (avcodec_receive_frame(stream_codec_ctx.get(), frm.get()) >= 0) {
           DecodedFrame decoded_frame;
-          if (ConvertFrameToRGBA(frm, &decoded_frame.data)) {
+          if (ConvertFrameToRGBA(frm.get(), &decoded_frame.data)) {
             decoded_frame.width = frm->width;
             decoded_frame.height = frm->height;
 
@@ -528,18 +561,18 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
             decoded_frames_.push_back(std::move(decoded_frame));
             frame_count_++;
           }
-          av_frame_unref(frm);
+          av_frame_unref(frm.get());
         }
       }
     }
-    av_packet_unref(pkt);
+    av_packet_unref(pkt.get());
   }
 
   // Flush decoder
-  avcodec_send_packet(stream_codec_ctx, nullptr);
-  while (avcodec_receive_frame(stream_codec_ctx, frm) >= 0) {
+  avcodec_send_packet(stream_codec_ctx.get(), nullptr);
+  while (avcodec_receive_frame(stream_codec_ctx.get(), frm.get()) >= 0) {
     DecodedFrame decoded_frame;
-    if (ConvertFrameToRGBA(frm, &decoded_frame.data)) {
+    if (ConvertFrameToRGBA(frm.get(), &decoded_frame.data)) {
       decoded_frame.width = frm->width;
       decoded_frame.height = frm->height;
       AVRational time_base = video_stream->time_base;
@@ -553,12 +586,10 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
       decoded_frames_.push_back(std::move(decoded_frame));
       frame_count_++;
     }
-    av_frame_unref(frm);
+    av_frame_unref(frm.get());
   }
 
-  av_packet_free(&pkt);
-  av_frame_free(&frm);
-  avcodec_free_context(&stream_codec_ctx);
+  // RAII handles cleanup of pkt, frm, and stream_codec_ctx
 
   // Determine if animated based on frame count
   animated_ = frame_count_ > 1;
@@ -567,7 +598,7 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
   if (frame_count_ == 0) {
     frame_count_ = 1;
     animated_ = false;
-    delete mem_ctx;
+    // mem_ctx_ will be cleaned up by Cleanup()
     return false;
   }
 
@@ -578,7 +609,7 @@ bool ImageDecoder::ParseAnimatedImageMetadata() {
     decoded_height_ = decoded_frames_[0].height;
   }
 
-  delete mem_ctx;
+  // mem_ctx_ stays alive for use by avio_context_, will be cleaned up by Cleanup()
   return true;
 }
 
@@ -606,18 +637,18 @@ bool ImageDecoder::DecodeImage() {
     return false;
   }
 
-  // Set packet data
+  // Set packet data - use .get() to access raw pointer from RAII wrapper
   packet_->data = data_.data();
   packet_->size = static_cast<int>(data_.size());
 
-  // Send packet to decoder
-  int ret = avcodec_send_packet(codec_context_, packet_);
+  // Send packet to decoder - use .get() for FFmpeg C API
+  int ret = avcodec_send_packet(codec_context_.get(), packet_.get());
   if (ret < 0) {
     return false;
   }
 
-  // Receive decoded frame
-  ret = avcodec_receive_frame(codec_context_, frame_);
+  // Receive decoded frame - use .get() for FFmpeg C API
+  ret = avcodec_receive_frame(codec_context_.get(), frame_.get());
   if (ret < 0) {
     return false;
   }
@@ -625,11 +656,12 @@ bool ImageDecoder::DecodeImage() {
   decoded_width_ = frame_->width;
   decoded_height_ = frame_->height;
 
-  // Convert to RGBA
-  sws_context_ = sws_getContext(frame_->width, frame_->height,
-                                static_cast<AVPixelFormat>(frame_->format),
-                                frame_->width, frame_->height, AV_PIX_FMT_RGBA,
-                                SWS_BILINEAR, nullptr, nullptr, nullptr);
+  // Convert to RGBA (RAII managed)
+  sws_context_.reset(sws_getContext(frame_->width, frame_->height,
+                                    static_cast<AVPixelFormat>(frame_->format),
+                                    frame_->width, frame_->height,
+                                    AV_PIX_FMT_RGBA, SWS_BILINEAR, nullptr,
+                                    nullptr, nullptr));
 
   if (!sws_context_) {
     return false;
@@ -645,8 +677,13 @@ bool ImageDecoder::DecodeImage() {
   int dest_linesize[4] = {frame_->width * 4, 0, 0, 0};
 
   // Convert
-  sws_scale(sws_context_, frame_->data, frame_->linesize, 0, frame_->height,
-            dest_data, dest_linesize);
+  sws_scale(sws_context_.get(), frame_->data, frame_->linesize, 0,
+            frame_->height, dest_data, dest_linesize);
+
+  // Apply alpha premultiplication if requested
+  if (premultiply_alpha_ == "premultiply") {
+    PremultiplyAlpha(decoded_data_.data(), frame_->width, frame_->height);
+  }
 
   return true;
 }

package/src/image_decoder.h

@@ -39,6 +39,9 @@ class ImageDecoder : public Napi::ObjectWrap<ImageDecoder> {
   explicit ImageDecoder(const Napi::CallbackInfo& info);
   ~ImageDecoder();
 
+  // Static constructor reference for NAPI class registration
+  static Napi::FunctionReference constructor_;
+
   // Disallow copy and assign.
   ImageDecoder(const ImageDecoder&) = delete;
   ImageDecoder& operator=(const ImageDecoder&) = delete;
@@ -66,14 +69,15 @@ class ImageDecoder : public Napi::ObjectWrap<ImageDecoder> {
 
   // FFmpeg state for static image decoding.
   const AVCodec* codec_;
-  AVCodecContext* codec_context_;
-  SwsContext* sws_context_;
-  AVFrame* frame_;
-  AVPacket* packet_;
+  ffmpeg::AVCodecContextPtr codec_context_;
+  ffmpeg::SwsContextPtr sws_context_;
+  ffmpeg::AVFramePtr frame_;
+  ffmpeg::AVPacketPtr packet_;
 
   // FFmpeg state for animated image parsing.
   AVFormatContext* format_context_;  // For container parsing
   AVIOContext* avio_context_;        // Custom I/O for memory buffer
+  struct MemoryBufferContext* mem_ctx_;  // Owned, freed in Cleanup()
   int video_stream_index_;           // Stream index for video track
 
   // Decoded frame data (static images).
@@ -89,6 +93,9 @@ class ImageDecoder : public Napi::ObjectWrap<ImageDecoder> {
 
   bool complete_;
   bool closed_;
+
+  // Premultiply alpha option: "none", "premultiply", or "default"
+  std::string premultiply_alpha_;
 };
 
 #endif  // SRC_IMAGE_DECODER_H_

package/src/muxer.cc

@@ -71,6 +71,7 @@ Muxer::Muxer(const Napi::CallbackInfo& info)
   // Open output file.
   ret = avio_open(&format_context_->pb, filename_.c_str(), AVIO_FLAG_WRITE);
   if (ret < 0) {
+    format_context_.reset();  // Explicitly clean up before throw
     char err[AV_ERROR_MAX_STRING_SIZE];
     av_strerror(ret, err, sizeof(err));
     Napi::Error::New(env, std::string("Failed to open output file: ") + err)

package/src/test_video_generator.cc

@@ -88,9 +88,10 @@ Napi::Value TestVideoGenerator::Configure(const Napi::CallbackInfo& info) {
     return env.Undefined();
   }
 
-  // Initialize swscale for YUV420P -> RGBA conversion
+  // Initialize swscale for RGB24 -> RGBA conversion
+  // Note: testsrc outputs RGB24 by default, not YUV420P
   sws_yuv_to_rgba_.reset(
-      sws_getContext(width_, height_, AV_PIX_FMT_YUV420P, width_, height_,
+      sws_getContext(width_, height_, AV_PIX_FMT_RGB24, width_, height_,
                      AV_PIX_FMT_RGBA, SWS_BILINEAR, nullptr, nullptr, nullptr));
 
   if (!sws_yuv_to_rgba_) {