Fixed some images crashing thumbnailer.

Author: UnChaotic

thumbnailer.c

@@ -87,11 +87,15 @@ static AVFrame* select_best_frame(AVFrame* frames[], int size)
 }
 
 // Calculate size and allocate buffer
-static void alloc_buffer(struct Buffer* dst)
+static int alloc_buffer(struct Buffer* dst)
 {
     dst->size
         = av_image_get_buffer_size(AV_PIX_FMT_RGBA, dst->width, dst->height, 1);
     dst->data = malloc(dst->size);
+    if (!dst->data) {
+        return AVERROR(ENOMEM);
+    }
+    return 0;
 }
 
 // Use point subsampling to scale image up to target size and convert to RGBA
@@ -125,6 +129,9 @@ static void downscale(struct Buffer* dst, const struct Buffer const* src)
     // First sum all pixels into a multidimensional array
     const size_t size = dst->height * dst->width * sizeof(struct Pixel);
     struct Pixel(*img)[dst->width] = malloc(size);
+    if (!img) {
+        return; // Handle allocation failure
+    }
     memset(img, 0, size);
 
     int i = 0;
@@ -161,6 +168,9 @@ static void downscale(struct Buffer* dst, const struct Buffer const* src)
             i += 4;
         }
     }
+    
+    // Free the temporary buffer
+    free(img);
 }
 
 // Decrease intensity of pixels with alpha
@@ -357,7 +367,10 @@ static int encode_frame(
     // scale_dims() does not work, if image size is exactly that of the target
     // thumbnail size. Perhaps a peculiarity of sws_scale().
     if (img->width < box.width && img->height < box.height) {
-        alloc_buffer(img);
+        err = alloc_buffer(img);
+        if (err) {
+            return err;
+        }
         err = resample(img, frame);
         if (err) {
             return err;
@@ -375,15 +388,22 @@ static int encode_frame(
     // around the thumbnail size and much bigger ones.
     struct Buffer enlarged
         = { .width = img->width * 4, .height = img->height * 4 };
-    alloc_buffer(&enlarged);
+    err = alloc_buffer(&enlarged);
+    if (err) {
+        return err;
+    }
     err = resample(&enlarged, frame);
     if (err) {
         free(enlarged.data);
         return err;
     }
-    alloc_buffer(img);
+    err = alloc_buffer(img);
+    if (err) {
+        free(enlarged.data);
+        return err;
+    }
     downscale(img, &enlarged);
-    free(enlarged.data);
+    // Don't free enlarged.data here - let Go handle all memory management
     adjust_orientation(img, orientation);
     return err;
 }
@@ -477,29 +497,42 @@ int generate_thumbnail(struct Buffer* img, AVFormatContext* avfc,
     int i = 0;
     AVFrame* frames[MAX_FRAMES] = { NULL };
     AVFrame* next = NULL;
+    
+    // Initialize the output buffer to ensure clean state
+    img->data = NULL;
+    img->size = 0;
+    img->width = 0;
+    img->height = 0;
 
     // Read up to 10 frames
     while (1) {
         next = av_frame_alloc();
+        if (!next) {
+            err = AVERROR(ENOMEM);
+            goto cleanup;
+        }
+        
         err = read_frame(avfc, avcc, next, stream);
         if (err) {
-            goto end;
+            av_frame_free(&next);
+            goto cleanup;
         }
 
         // Analyze only every 3rd frame to cover a larger time frame
         if (!(i++ % 3)) {
             frames[size++] = next;
             next = NULL;
             if (size == MAX_FRAMES) {
-                goto end;
+                break;
             }
         } else {
             av_frame_free(&next);
+            next = NULL;
         }
     }
 
-end:
-    if (size) {
+cleanup:
+    if (size > 0) {
         int orientation = 0;
         int rotation = get_rotation(avfc->streams[stream]);
 
@@ -522,8 +555,11 @@ int generate_thumbnail(struct Buffer* img, AVFormatContext* avfc,
             img, select_best_frame(frames, size), thumb_dims, orientation);
     }
 
+    // Clean up all frames
     for (int i = 0; i < size; i++) {
-        av_frame_free(&frames[i]);
+        if (frames[i]) {
+            av_frame_free(&frames[i]);
+        }
     }
     if (next) {
         av_frame_free(&next);