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
}
|