Fix correctness, safety, and performance issues in video frame handling

Addresses three critical issues identified in code review:

1. Performance: Extract duplicate stride calculation logic into a shared
   calculateAlignedStride helper function to eliminate code duplication
   between NewFramebuffer and resizeMat

2. Memory Safety: Add buffer bounds validation in avcodec_decoder_convert_frame
   to prevent potential buffer overruns when stride exceeds allocated space

3. Const Correctness: Remove const qualifier from avcodec_decoder_decode as
   it modifies decoder state during multi-frame extraction

Author: skidder

avcodec.cpp

@@ -496,6 +496,14 @@ static int avcodec_decoder_convert_frame(const avcodec_decoder d, opencv_mat mat
         // This ensures consistency with OpenCV operations and encoding
         int stepSize = cvMat->step;
 
+        // Validate that the stride and height are within the allocated buffer bounds
+        size_t required_size = stepSize * cvMat->rows;
+        size_t available_size = (cvMat->datalimit && cvMat->data) ?
+                                (cvMat->datalimit - cvMat->data) : 0;
+        if (available_size > 0 && required_size > available_size) {
+            return -1;
+        }
+
         // Create SwsContext for converting the frame format and scaling
         struct SwsContext* sws =
           sws_getContext(frame->width,
@@ -582,7 +590,7 @@ static int avcodec_decoder_decode_packet(const avcodec_decoder d, opencv_mat mat
     return res;
 }
 
-bool avcodec_decoder_decode(const avcodec_decoder d, opencv_mat mat)
+bool avcodec_decoder_decode(avcodec_decoder d, opencv_mat mat)
 {
     if (!d || !d->container || !d->codec || !mat) {
         return false;

avcodec.hpp

@@ -17,7 +17,7 @@ int avcodec_decoder_get_width(const avcodec_decoder d);
 int avcodec_decoder_get_height(const avcodec_decoder d);
 int avcodec_decoder_get_orientation(const avcodec_decoder d);
 float avcodec_decoder_get_duration(const avcodec_decoder d);
-bool avcodec_decoder_decode(const avcodec_decoder d, opencv_mat mat);
+bool avcodec_decoder_decode(avcodec_decoder d, opencv_mat mat);
 bool avcodec_decoder_is_streamable(const opencv_mat buf);
 bool avcodec_decoder_has_subtitles(const avcodec_decoder d);
 const char* avcodec_decoder_get_description(const avcodec_decoder d);

opencv.go

@@ -197,6 +197,19 @@ func (h *ImageHeader) ContentLength() int {
 	return h.contentLength
 }
 
+// calculateAlignedStride computes a 32-byte aligned stride for the given width and channel count.
+// This alignment is crucial for SIMD performance.
+// For example, with 4 channels (BGRA): 8 pixels * 4 bytes = 32 bytes alignment.
+func calculateAlignedStride(width, channels int) int {
+	stride := width * channels
+	alignmentPixels := 32 / channels // 8 for 4-channel, 16 for 2-channel, etc.
+	if alignmentPixels > 0 && width%alignmentPixels != 0 {
+		alignedWidth := width + alignmentPixels - (width % alignmentPixels)
+		stride = alignedWidth * channels
+	}
+	return stride
+}
+
 // NewFramebuffer creates a backing store for a pixel frame buffer with the specified dimensions.
 // The buffer is allocated with 32-byte aligned strides for optimal SIMD performance.
 //
@@ -209,13 +222,7 @@ func (h *ImageHeader) ContentLength() int {
 //
 // The resizeMat method will use the appropriate stride based on the actual pixel type.
 func NewFramebuffer(width, height int) *Framebuffer {
-	// Calculate aligned stride (32-byte aligned for SIMD performance)
-	// 8 pixels * 4 bytes = 32 bytes
-	stride := width * 4
-	if width%8 != 0 {
-		alignedWidth := width + 8 - (width % 8)
-		stride = alignedWidth * 4
-	}
+	stride := calculateAlignedStride(width, 4) // Allocate for 4-channel (BGRA)
 	return &Framebuffer{
 		buf: make([]byte, stride*height),
 		mat: nil,
@@ -268,13 +275,7 @@ func (f *Framebuffer) resizeMat(width, height int, pixelType PixelType) error {
 	}
 
 	// Calculate aligned stride (32-byte aligned for SIMD performance)
-	// For BGRA (4 channels): 8 pixels * 4 bytes = 32 bytes
-	stride := width * pixelType.Channels()
-	alignmentPixels := 32 / pixelType.Channels() // 8 for 4-channel, 16 for 2-channel, etc.
-	if alignmentPixels > 0 && width%alignmentPixels != 0 {
-		alignedWidth := width + alignmentPixels - (width % alignmentPixels)
-		stride = alignedWidth * pixelType.Channels()
-	}
+	stride := calculateAlignedStride(width, pixelType.Channels())
 
 	newMat := C.opencv_mat_create_from_data_with_stride(C.int(width), C.int(height), C.int(pixelType), unsafe.Pointer(&f.buf[0]), C.size_t(len(f.buf)), C.size_t(stride))
 	if newMat == nil {