icns

rle.go (5329B)

---

 package icns
 
 import (
 	"fmt"
 	"image"
 	"image/color"
 )
 
 // Legacy icon types store their colour as three run-length encoded planes,
 // one per channel, and their alpha in a separate mask element.
 
 // unpackRLE expands the icns variant of PackBits until want bytes are
 // produced. A lead byte below 128 introduces lead+1 literal bytes; a lead
 // byte of 128 or above repeats the byte after it lead-125 times. Data that is
 // already want bytes long is stored uncompressed and is returned as it is.
 //
 // The second result is how many bytes of data were read, which is short of
 // its length when the stream carries padding after the last run.
 func unpackRLE(data []byte, want int) ([]byte, int, error) {
 	if len(data) == want {
 		return data, want, nil
 	}
 	out := make([]byte, 0, want)
 	used := 0
 	for i := 0; i < len(data) && len(out) < want; {
 		lead := int(data[i])
 		i++
 		if lead < 128 {
 			n := lead + 1
 			if i+n > len(data) {
 				return nil, i, fmt.Errorf("%w: literal run of %d bytes overruns the element", ErrMalformed, n)
 			}
 			out = append(out, data[i:i+n]...)
 			i += n
 			used = i
 			continue
 		}
 		if i == len(data) {
 			return nil, i, fmt.Errorf("%w: repeat run with no byte to repeat", ErrMalformed)
 		}
 		for n := lead - 125; n > 0; n-- {
 			out = append(out, data[i])
 		}
 		i++
 		used = i
 	}
 	if len(out) != want {
 		return nil, len(data), fmt.Errorf("%w: expanded to %d bytes, want %d", ErrMalformed, len(out), want)
 	}
 	return out, used, nil
 }
 
 // packRLE compresses data into the icns variant of PackBits. A run of three
 // or more equal bytes is worth encoding, since it costs two bytes either way,
 // and anything shorter goes out as literals. Data that does not compress is
 // returned unchanged, which the decoder recognises by its length.
 func packRLE(data []byte) []byte {
 	out := make([]byte, 0, len(data))
 	for i := 0; i < len(data); {
 		run := 1
 		for i+run < len(data) && run < maxRepeat && data[i+run] == data[i] {
 			run++
 		}
 		if run >= 3 {
 			out = append(out, byte(run+125), data[i])
 			i += run
 			continue
 		}
 		// Literals up to the next run of three, since that run encodes more
 		// cheaply on its own.
 		start := i
 		for i < len(data) && i-start < maxLiteral {
 			if i+2 < len(data) && data[i] == data[i+1] && data[i] == data[i+2] {
 				break
 			}
 			i++
 		}
 		out = append(out, byte(i-start-1))
 		out = append(out, data[start:i]...)
 	}
 	if len(out) >= len(data) {
 		return data
 	}
 	return out
 }
 
 const (
 	// maxLiteral is the longest literal run, from a lead byte of 127.
 	maxLiteral = 128
 	// maxRepeat is the longest repeat, from a lead byte of 255.
 	maxRepeat = 130
 )
 
 // padRLE appends a byte to compressed data, which a decoder that drops the
 // last value of a stream then loses instead of a pixel. Apple's own reader
 // does exactly that on Apple silicon, turning the tail of the blue plane
 // black. Data that was stored uncompressed is left at its exact length,
 // which is how a reader tells the two apart.
 func padRLE(data []byte, uncompressed int) []byte {
 	if len(data) == uncompressed {
 		return data
 	}
 	return append(data, 0)
 }
 
 // splitPlanes separates an image into the three colour planes and the alpha
 // mask that the legacy elements store separately. The planes hold straight
 // colour, so alpha is divided back out.
 func splitPlanes(img image.Image, side int) (planes, mask []byte) {
 	pixels := side * side
 	planes = make([]byte, pixels*3)
 	mask = make([]byte, pixels)
 	origin := img.Bounds().Min
 	for y := 0; y < side; y++ {
 		for x := 0; x < side; x++ {
 			c := color.NRGBAModel.Convert(img.At(origin.X+x, origin.Y+y)).(color.NRGBA)
 			i := y*side + x
 			planes[i] = c.R
 			planes[pixels+i] = c.G
 			planes[pixels*2+i] = c.B
 			mask[i] = c.A
 		}
 	}
 	return planes, mask
 }
 
 // decodeARGB builds an image from the four run-length encoded planes that
 // follow an ARGB header, alpha first and then the colour channels.
 func decodeARGB(data []byte, side int) (image.Image, error) {
 	pixels := side * side
 	planes, _, err := unpackRLE(data, pixels*4)
 	if err != nil {
 		return nil, err
 	}
 	// Alpha is a plane of its own rather than folded into the colour, so the
 	// result is non-premultiplied.
 	img := image.NewNRGBA(image.Rect(0, 0, side, side))
 	for i := 0; i < pixels; i++ {
 		px := img.Pix[i*4 : i*4+4 : i*4+4]
 		px[3] = planes[i]
 		px[0] = planes[pixels+i]
 		px[1] = planes[pixels*2+i]
 		px[2] = planes[pixels*3+i]
 	}
 	return img, nil
 }
 
 // decodeRGB builds an image from run-length encoded colour planes and the
 // raw alpha of the matching mask element. A missing mask leaves the icon
 // opaque, which is how the icons that predate masks are meant to render.
 func decodeRGB(data, mask []byte, side int) (image.Image, error) {
 	pixels := side * side
 	planes, _, err := unpackRLE(data, pixels*3)
 	if err != nil {
 		return nil, err
 	}
 	if mask != nil && len(mask) != pixels {
 		return nil, fmt.Errorf("%w: mask holds %d bytes, want %d", ErrMalformed, len(mask), pixels)
 	}
 	// The planes carry straight colour and the mask carries alpha, so the
 	// result is non-premultiplied.
 	img := image.NewNRGBA(image.Rect(0, 0, side, side))
 	for i := 0; i < pixels; i++ {
 		px := img.Pix[i*4 : i*4+4 : i*4+4]
 		px[0] = planes[i]
 		px[1] = planes[pixels+i]
 		px[2] = planes[pixels*2+i]
 		px[3] = 0xFF
 		if mask != nil {
 			px[3] = mask[i]
 		}
 	}
 	return img, nil
 }