Fix stride alignment for SIMD performance and decoder correctness

Adds 32-byte aligned stride support for framebuffers to enable SIMD optimizations
(AVX/SSE) and fixes stride-related bugs in WebP and GIF decoders that were causing
data corruption.

Changes:
- opencv.cpp/hpp: Add opencv_mat_create_from_data_with_stride() to support custom strides
- opencv.go: Update NewFramebuffer() and resizeMat() to use 32-byte aligned strides
- webp.cpp: Fix decoder to use Mat's actual stride instead of intermediate buffer
- giflib.cpp: Fix decoder and encoder to copy frame data row-by-row respecting stride

Fixes thumbhash test failures where stride mismatches were corrupting pixel data.

Author: skidder

giflib.cpp

@@ -484,7 +484,12 @@ static bool giflib_decoder_render_frame(giflib_decoder d, GraphicsControlBlock*
 
     // Save current frame content before drawing new frame
     if (d->have_read_first_frame) {
-        memcpy(d->prev_frame_bgra.data(), cvMat->data, buf_width * buf_height * BYTES_PER_PIXEL);
+        // Copy row by row to handle stride correctly
+        for (int y = 0; y < buf_height; y++) {
+            memcpy(d->prev_frame_bgra.data() + y * buf_width * BYTES_PER_PIXEL,
+                   cvMat->data + y * cvMat->step,
+                   buf_width * BYTES_PER_PIXEL);
+        }
     }
 
     // Draw the new frame
@@ -1083,7 +1088,12 @@ static bool giflib_encoder_render_frame(giflib_encoder e,
     }
 
     // XXX change this if we do partial frames (only copy over some)
-    memcpy(e->prev_frame_bgra, frame->data, 4 * e->gif->SWidth * e->gif->SHeight);
+    // Copy row by row to handle stride correctly
+    for (int y = 0; y < e->gif->SHeight; y++) {
+        memcpy(e->prev_frame_bgra + y * e->gif->SWidth * 4,
+               frame->data + y * frame->step,
+               e->gif->SWidth * 4);
+    }
 
     e->prev_frame_color_map = color_map;
     e->prev_frame_disposal = gcb.DisposalMode;

opencv.cpp

@@ -29,6 +29,17 @@ opencv_mat opencv_mat_create_from_data(int width, int height, int type, void* da
     return mat;
 }
 
+opencv_mat opencv_mat_create_from_data_with_stride(int width, int height, int type, void* data, size_t data_len, size_t step)
+{
+    size_t min_size = step * height;
+    if (min_size > data_len) {
+        return NULL;
+    }
+    auto mat = new cv::Mat(height, width, type, data, step);
+    mat->datalimit = (uint8_t*)data + data_len;
+    return mat;
+}
+
 opencv_mat opencv_mat_create_empty_from_data(int length, void* data)
 {
     // this is slightly sketchy - what we're going to do is build a 1x0 matrix

opencv.go

@@ -192,9 +192,17 @@ func (h *ImageHeader) ContentLength() int {
 }
 
 // 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.
 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
+	}
 	return &Framebuffer{
-		buf: make([]byte, width*height*4),
+		buf: make([]byte, stride*height),
 		mat: nil,
 	}
 }
@@ -243,7 +251,17 @@ func (f *Framebuffer) resizeMat(width, height int, pixelType PixelType) error {
 	if pixelType.Depth() > 8 {
 		pixelType = PixelType(C.opencv_type_convert_depth(C.int(pixelType), C.CV_8U))
 	}
-	newMat := C.opencv_mat_create_from_data(C.int(width), C.int(height), C.int(pixelType), unsafe.Pointer(&f.buf[0]), C.size_t(len(f.buf)))
+
+	// 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()
+	}
+
+	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 {
 		return ErrBufTooSmall
 	}

opencv.hpp

@@ -98,6 +98,12 @@ opencv_mat opencv_mat_create_from_data(int width,
                                        int type,
                                        void* data,
                                        size_t data_len);
+opencv_mat opencv_mat_create_from_data_with_stride(int width,
+                                                    int height,
+                                                    int type,
+                                                    void* data,
+                                                    size_t data_len,
+                                                    size_t step);
 opencv_mat opencv_mat_create_empty_from_data(int length, void* data);
 bool opencv_mat_set_row_stride(opencv_mat mat, size_t stride);
 void opencv_mat_release(opencv_mat mat);

webp.cpp

@@ -322,41 +322,35 @@ bool webp_decoder_decode(const webp_decoder d, opencv_mat mat)
     auto cvMat = static_cast<cv::Mat*>(mat);
     cvMat->create(features.height, features.width, webp_decoder_get_pixel_type(d));
 
-    // Recalculate row size based on the new dimensions
-    int row_size = cvMat->cols * cvMat->elemSize();
-
     // Store frame properties for future use
     d->prev_frame_delay_time = frame.duration;
     d->prev_frame_x_offset = frame.x_offset;
     d->prev_frame_y_offset = frame.y_offset;
     d->prev_frame_dispose = frame.dispose_method;
     d->prev_frame_blend = frame.blend_method;
 
-    // Decode the frame
+    // Decode the frame directly into the Mat using its actual stride
+    // This ensures proper handling of any row alignment/padding
     uint8_t* res = nullptr;
     switch (webp_decoder_get_pixel_type(d)) {
     case CV_8UC4:
         res = WebPDecodeBGRAInto(frame.bitstream.bytes,
                                  frame.bitstream.size,
-                                 d->decode_buffer,
-                                 d->decode_buffer_size,
-                                 row_size);
+                                 cvMat->data,
+                                 cvMat->rows * cvMat->step,
+                                 cvMat->step);
         break;
     case CV_8UC3:
         res = WebPDecodeBGRInto(frame.bitstream.bytes,
                                 frame.bitstream.size,
-                                d->decode_buffer,
-                                d->decode_buffer_size,
-                                row_size);
+                                cvMat->data,
+                                cvMat->rows * cvMat->step,
+                                cvMat->step);
         break;
     default:
         return false;
     }
 
-    if (res) {
-        memcpy(cvMat->data, d->decode_buffer, cvMat->total() * cvMat->elemSize());
-    }
-
     WebPDataClear(&frame.bitstream);
     return res != nullptr;
 }