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