// Package images turns pictures found on the user's own disk into the covers the // API serves, and keeps them in a data folder. // // Pictures are untrusted input: a file called cover.jpg can be anything. They are // size-checked before they are decoded, decoded with the standard library only, and // stored re-encoded, so what is served is always a plain JPEG made here. package images import ( "bytes" "errors" "fmt" "image" "image/color" "image/draw" _ "image/gif" // registered for image.Decode "image/jpeg" _ "image/png" // registered for image.Decode ) // Limits and sizes. const ( // MaxSourceBytes is the largest picture file that is read at all. MaxSourceBytes = 20 << 20 // MaxPixels is the largest picture that is decoded: a 4000 by 4000 cover. A file // of a few kilobytes can claim billions of pixels and fill the memory. MaxPixels = 16_000_000 // LargeEdge and SmallEdge are the longest side of the two stored sizes. LargeEdge = 1000 SmallEdge = 300 jpegQuality = 85 ) // ErrUnusable is returned for a file that is not a picture Sonda can use. var ErrUnusable = errors.New("not a usable picture") // Processed is a picture in the two stored sizes, as JPEG. type Processed struct { Large, Small []byte Width, Height int // of the original } // Process decodes a GIF, JPEG or PNG and returns it scaled down to fit LargeEdge and // SmallEdge (never enlarged), on a white background where it was transparent. The // same input always gives the same bytes. func Process(data []byte) (Processed, error) { return ProcessLimited(data, MaxPixels) } // ProcessLimited is Process with a smaller limit on the number of pixels, for pictures that // are known to be small (a 960 pixel copy is never millions of pixels high). func ProcessLimited(data []byte, maxPixels int64) (Processed, error) { if len(data) == 0 || len(data) > MaxSourceBytes { return Processed{}, fmt.Errorf("%w: %d bytes", ErrUnusable, len(data)) } cfg, _, err := image.DecodeConfig(bytes.NewReader(data)) if err != nil { return Processed{}, fmt.Errorf("%w: %v", ErrUnusable, err) } if cfg.Width <= 0 || cfg.Height <= 0 || int64(cfg.Width)*int64(cfg.Height) > maxPixels { // int64: a 32-bit int would overflow return Processed{}, fmt.Errorf("%w: %dx%d pixels", ErrUnusable, cfg.Width, cfg.Height) } src, _, err := image.Decode(bytes.NewReader(data)) if err != nil { return Processed{}, fmt.Errorf("%w: %v", ErrUnusable, err) } flat := image.NewRGBA(src.Bounds()) draw.Draw(flat, flat.Bounds(), image.NewUniform(color.White), image.Point{}, draw.Src) draw.Draw(flat, flat.Bounds(), src, src.Bounds().Min, draw.Over) large := fit(flat, LargeEdge) small := fit(large, SmallEdge) out := Processed{Width: cfg.Width, Height: cfg.Height} if out.Large, err = encode(large); err != nil { return Processed{}, err } if out.Small, err = encode(small); err != nil { return Processed{}, err } return out, nil } func encode(img *image.RGBA) ([]byte, error) { var b bytes.Buffer if err := jpeg.Encode(&b, img, &jpeg.Options{Quality: jpegQuality}); err != nil { return nil, fmt.Errorf("encode picture: %w", err) } return b.Bytes(), nil } // fit returns src scaled down so that its longest side is at most edge, averaging // the source pixels under each new one. A picture that is small enough is returned as it is. func fit(src *image.RGBA, edge int) *image.RGBA { b := src.Bounds() sw, sh := b.Dx(), b.Dy() if sw <= edge && sh <= edge { return src } dw, dh := edge, edge if sw >= sh { dh = max(1, sh*edge/sw) } else { dw = max(1, sw*edge/sh) } dst := image.NewRGBA(image.Rect(0, 0, dw, dh)) for y := 0; y < dh; y++ { y0, y1 := y*sh/dh, max(y*sh/dh+1, (y+1)*sh/dh) for x := 0; x < dw; x++ { x0, x1 := x*sw/dw, max(x*sw/dw+1, (x+1)*sw/dw) var r, g, bl, n uint32 for sy := y0; sy < y1; sy++ { row := src.Pix[(sy)*src.Stride:] for sx := x0; sx < x1; sx++ { p := row[sx*4 : sx*4+4] r, g, bl, n = r+uint32(p[0]), g+uint32(p[1]), bl+uint32(p[2]), n+1 } } o := dst.PixOffset(x, y) dst.Pix[o], dst.Pix[o+1], dst.Pix[o+2], dst.Pix[o+3] = uint8(r/n), uint8(g/n), uint8(bl/n), 255 } } return dst }