169 lines
4.8 KiB
Go
169 lines
4.8 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)
|
|
|
|
// 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 := os.MkdirTemp("", "attachment-")
|
|
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, "-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))
|
|
}
|