File size: 2,796 Bytes
5ef026e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package main

import (
	"bytes"
	"encoding/base64"
	"image"
	"image/jpeg"
	_ "image/png"
	"runtime"
	"sync"
	"time"

	"github.com/disintegration/imaging"
	"github.com/gofiber/fiber/v2"
)

type CompressRequest struct {
	Images  []string `json:"images"`  // Base64 encoded images
	Quality int      `json:"quality"` // JPEG quality 1-100
	MaxDim  int      `json:"max_dim"` // Max dimension for resize
}

type CompressResponse struct {
	Results      []string `json:"results"`       // Base64 encoded results
	ProcessingMs int64    `json:"processing_ms"` // Total processing time
	Count        int      `json:"count"`         // Number of images processed
	Errors       []string `json:"errors"`        // Any errors encountered
}

func HandleCompress(c *fiber.Ctx) error {
	start := time.Now()

	var req CompressRequest
	if err := c.BodyParser(&req); err != nil {
		return c.Status(400).JSON(fiber.Map{"error": "Invalid request: " + err.Error()})
	}

	// Defaults
	if req.Quality == 0 {
		req.Quality = 85
	}
	if req.MaxDim == 0 {
		req.MaxDim = 2048
	}

	if len(req.Images) == 0 {
		return c.Status(400).JSON(fiber.Map{"error": "No images provided"})
	}

	// Process images in parallel
	results := make([]string, len(req.Images))
	errors := make([]string, len(req.Images))
	var wg sync.WaitGroup
	sem := make(chan struct{}, runtime.NumCPU()) // Limit concurrency to CPU count

	for i, imgB64 := range req.Images {
		wg.Add(1)
		go func(idx int, data string) {
			defer wg.Done()
			sem <- struct{}{}        // Acquire
			defer func() { <-sem }() // Release

			result, err := compressImage(data, req.Quality, req.MaxDim)
			if err != nil {
				errors[idx] = err.Error()
				results[idx] = ""
				return
			}
			results[idx] = result
		}(i, imgB64)
	}
	wg.Wait()

	// Filter out empty errors
	var nonEmptyErrors []string
	for _, e := range errors {
		if e != "" {
			nonEmptyErrors = append(nonEmptyErrors, e)
		}
	}

	elapsed := time.Since(start).Milliseconds()

	return c.JSON(CompressResponse{
		Results:      results,
		ProcessingMs: elapsed,
		Count:        len(results),
		Errors:       nonEmptyErrors,
	})
}

func compressImage(b64 string, quality, maxDim int) (string, error) {
	// Decode base64
	data, err := base64.StdEncoding.DecodeString(b64)
	if err != nil {
		return "", err
	}

	// Decode image
	img, _, err := image.Decode(bytes.NewReader(data))
	if err != nil {
		return "", err
	}

	// Resize if needed (maintain aspect ratio)
	bounds := img.Bounds()
	w, h := bounds.Dx(), bounds.Dy()
	if w > maxDim || h > maxDim {
		img = imaging.Fit(img, maxDim, maxDim, imaging.Lanczos)
	}

	// Encode to JPEG
	var buf bytes.Buffer
	if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: quality}); err != nil {
		return "", err
	}

	return base64.StdEncoding.EncodeToString(buf.Bytes()), nil
}