Files
mtusi2026lab5/internal/imaging/render.go
T

187 lines
5.3 KiB
Go

package imaging
import (
"bytes"
"context"
"errors"
"fmt"
"image"
_ "image/jpeg"
_ "image/png"
"os"
"os/exec"
"path/filepath"
"strconv"
"time"
"golang.org/x/sync/semaphore"
)
const (
MaxUploadBytes int64 = 10 << 20
MaxImagePixels int64 = 40_000_000
// This bounds a 16-bit RGBA scanline on the ordinary codec path to 512 KiB.
maxMagickPNGAxis = 65_535
)
type Variant struct {
Name, MIMEType string
Width, Height int
Data []byte
}
var ErrInvalidImage = errors.New("invalid image or pipeline version")
// Reserve both slots for a PNG whose full-width decoder scanlines can each
// occupy hundreds of MiB. A worker with a 2 GiB cgroup can run two ordinary jobs.
var decoderSlots = semaphore.NewWeighted(2)
func scratchRoot() string {
return filepath.Join(os.TempDir(), "messenger-worker-imaging")
}
// CleanScratch reclaims pixel caches left by a killed worker. The consumer
// calls it before starting any jobs in its container's private filesystem.
func CleanScratch() error {
return os.RemoveAll(scratchRoot())
}
func newRenderDir() (string, error) {
root := scratchRoot()
if err := os.MkdirAll(root, 0700); err != nil {
return "", err
}
return os.MkdirTemp(root, "attachment-")
}
// Render decodes once in a deadline-bound child process. Its pixel cache can
// spill to a private disk directory when a high-resolution source exceeds RAM.
func Render(ctx context.Context, source []byte, version int) ([]Variant, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
if int64(len(source)) > MaxUploadBytes || (version != 1 && version != 2) {
return nil, ErrInvalidImage
}
cfg, format, err := image.DecodeConfig(bytes.NewReader(source))
if err != nil || (format != "jpeg" && format != "png") ||
cfg.Height < 1 || cfg.Width < 1 || int64(cfg.Width) > MaxImagePixels/int64(cfg.Height) {
return nil, ErrInvalidImage
}
ctx, cancel := context.WithTimeout(ctx, 45*time.Second)
defer cancel()
widePNG := format == "png" && max(cfg.Width, cfg.Height) > maxMagickPNGAxis
weight := int64(1)
if widePNG {
weight = 2
}
if err := decoderSlots.Acquire(ctx, weight); err != nil {
return nil, err
}
defer decoderSlots.Release(weight)
dir, err := newRenderDir()
if err != nil {
return nil, err
}
defer os.RemoveAll(dir)
input := format + ":-[0]"
if widePNG {
executable, err := os.Executable()
if err != nil {
return nil, err
}
cmd := exec.CommandContext(ctx, executable, "--prepare-large-png")
cmd.Env = append(os.Environ(), "GOMAXPROCS=1", "GOMEMLIMIT=1280MiB")
cmd.Dir = dir
cmd.Stdin = bytes.NewReader(source)
if err := cmd.Run(); err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, fmt.Errorf("reduce large PNG: %w", err)
}
input = "png:preview.png"
}
output := []Variant{
{Name: "thumbnail", MIMEType: "image/jpeg"},
{Name: "crop", MIMEType: "image/jpeg"},
{Name: "optimized", MIMEType: "image/webp"},
}
args := []string{
"-limit", "thread", "1", "-limit", "memory", "96MiB",
"-limit", "map", "0", "-limit", "disk", "2GiB",
input, "+repage", "-colorspace", "sRGB",
}
for _, v := range output {
args = append(args, "(")
if widePNG && v.Name == "crop" {
args = append(args, "png:center.png")
} else {
args = append(args, "+clone")
}
quality := 85
switch v.Name {
case "thumbnail":
args = append(args, "-resize", fit(cfg, 256), "-auto-orient")
case "crop":
side := min(cfg.Width, cfg.Height)
square := fmt.Sprintf("%dx%d+0+0", side, side)
args = append(args, "-auto-orient", "-gravity", "center", "-crop", square, "+repage", "-resize", "128x128!")
case "optimized":
quality = 80
if version == 2 {
quality = 64
}
args = append(args, "-resize", fit(cfg, 1280), "-auto-orient")
}
encoder := "webp"
if v.MIMEType == "image/jpeg" {
encoder = "jpeg"
args = append(args, "-background", "white", "-alpha", "remove", "-alpha", "off")
}
args = append(args, "-strip", "-quality", strconv.Itoa(quality), "-write", encoder+":"+v.Name,
"-format", "%w %h\n", "-write", "info:", "+delete", ")")
}
cmd := exec.CommandContext(ctx, "magick", append(args, "null:")...)
cmd.Dir = dir
cmd.Env = append(cmd.Environ(), "MAGICK_TEMPORARY_PATH="+dir)
if !widePNG {
cmd.Stdin = bytes.NewReader(source)
}
dimensions, err := cmd.Output()
if err != nil {
if ctx.Err() != nil {
return nil, ctx.Err()
}
return nil, fmt.Errorf("render image variants: %w", err)
}
sizes := bytes.NewReader(dimensions)
for i := range output {
v := &output[i]
if _, err := fmt.Fscan(sizes, &v.Width, &v.Height); err != nil {
return nil, fmt.Errorf("read %s dimensions: %w", v.Name, err)
}
v.Data, err = os.ReadFile(filepath.Join(dir, v.Name))
if err != nil {
return nil, err
}
}
return output, nil
}
// Compute geometry before auto-orientation. Rotation exchanges the axes after
// resizing; bounding by a square gives the same floor-rounded dimensions.
func fit(cfg image.Config, limit int) string {
size := fitSize(cfg, limit)
return fmt.Sprintf("%dx%d!", size.X, size.Y)
}
func fitSize(cfg image.Config, limit int) image.Point {
longest := max(cfg.Width, cfg.Height)
scale := int64(min(longest, limit))
width := max(1, int64(cfg.Width)*scale/int64(longest))
height := max(1, int64(cfg.Height)*scale/int64(longest))
return image.Pt(int(width), int(height))
}