Add PSD writer

composite/render_test.go

@@ -24,7 +24,7 @@ var tree = load()
 
 func BenchmarkRender(b *testing.B) {
 	ctx := context.Background()
-	dest := image.NewRGBA(tree.CanvasRect)
+	dest := image.NewNRGBA(tree.CanvasRect)
 	if err := tree.Renderer.Render(ctx, dest); err != nil {
 		b.Fatal(err)
 	}

encode.go

@@ -0,0 +1,162 @@
+package psd
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"io"
+
+	"github.com/depp/packbits"
+)
+
+func Encode(psd *PSD, w io.Writer) error {
+	if err := psd.Config.encode(w); err != nil {
+		return err
+	}
+	if err := psd.encodeLayers(w); err != nil {
+		return err
+	}
+
+	// image data
+	return psd.Config.CompressionMethod.encode(psd.Data, &psd.Config, w)
+}
+
+func (psd *PSD) encodeLayers(w io.Writer) error {
+	// empty data block for layers
+	if err := writeDataBlock([]byte{}, w); err != nil {
+		return err
+	}
+	if len(psd.Layer) > 0 {
+		return fmt.Errorf("encoding layers not yet supported")
+	}
+	return nil
+}
+
+func (c *Config) encode(w io.Writer) error {
+	// header
+	h := &headerWrite{
+		Signature: headerSignatureBytes,
+		Version:   uint16(c.Version),
+		Channels:  uint16(c.Channels),
+		Height:    uint32(c.Rect.Dy()),
+		Width:     uint32(c.Rect.Dx()),
+		Depth:     uint16(c.Depth),
+		ColorMode: uint16(c.ColorMode),
+	}
+
+	if err := binaryWrite(w, h); err != nil {
+		return err
+	}
+
+	// color mode data
+	if err := writeDataBlock(c.ColorModeData, w); err != nil {
+		return err
+	}
+
+	// image resources
+	buf := &bytes.Buffer{}
+	for id, imgResource := range c.Res {
+		if err := imgResource.encode(id, buf); err != nil {
+			return err
+		}
+	}
+	if err := writeDataBlock(buf.Bytes(), w); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (i *ImageResource) encode(id int, w io.Writer) error {
+	if _, err := w.Write(imageResourceSignatureBytes[:]); err != nil {
+		return err
+	}
+	if err := binaryWrite(w, uint16(id)); err != nil {
+		return err
+	}
+	b, err := stringToPascalBytes(i.Name, true)
+	if err != nil {
+		return err
+	}
+	if _, err := w.Write(b); err != nil {
+		return err
+	}
+	return writeDataBlockEvenLength(i.Data, w)
+}
+
+func (c CompressionMethod) encode(imgDataRaw []byte, cfg *Config, w io.Writer) error {
+	// compression method
+	if err := binaryWrite(w, uint16(c)); err != nil {
+		return err
+	}
+	// data
+	switch c {
+	case CompressionMethodRaw:
+		if _, err := w.Write(imgDataRaw); err != nil {
+			return err
+		}
+	case CompressionMethodRLE:
+		rowSize := cfg.Rect.Dx() * cfg.Depth / 8
+		buf := bytes.NewBuffer([]byte{})
+		read := 0
+		for i := 0; i < cfg.Rect.Dy()*cfg.Channels; i++ {
+			n, err := buf.Write(packbits.Pack(imgDataRaw[read : read+rowSize]))
+			if err != nil {
+				return err
+			}
+			read += rowSize
+			if err := binaryWrite(w, uint16(n)); err != nil {
+				return err
+			}
+		}
+
+		if _, err := w.Write(buf.Bytes()); err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("%d image data econding not supported", c)
+	}
+	return nil
+}
+
+func binaryWrite(w io.Writer, data any) error {
+	return binary.Write(w, binary.BigEndian, data)
+}
+func writeDataBlock(data []byte, w io.Writer) error {
+	if err := binaryWrite(w, uint32(len(data))); err != nil {
+		return err
+	}
+	if _, err := w.Write(data); err != nil {
+		return err
+	}
+	return nil
+}
+func writeDataBlockEvenLength(data []byte, w io.Writer) error {
+	if err := writeDataBlock(data, w); err != nil {
+		return err
+	}
+	if len(data)%2 == 1 {
+		if _, err := w.Write([]byte{0}); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type headerWrite struct {
+	Signature [4]byte
+	Version   uint16
+	Reserved  [6]byte
+	Channels  uint16
+	Height    uint32
+	Width     uint32
+	Depth     uint16
+	ColorMode uint16
+}
+
+var headerSignatureBytes [4]byte
+var imageResourceSignatureBytes [4]byte
+
+func init() {
+	copy(headerSignatureBytes[:], []byte(headerSignature))
+	copy(imageResourceSignatureBytes[:], []byte(sectionSignature))
+}

encode_test.go

@@ -0,0 +1,176 @@
+package psd_test
+
+import (
+	"bytes"
+	"fmt"
+	"image"
+	"image/png"
+	"log"
+	"os"
+	"testing"
+
+	"github.com/oov/psd"
+	"github.com/stretchr/testify/assert"
+)
+
+func init() {
+	psd.Debug = log.New(os.Stdout, "psd: ", log.Lshortfile)
+}
+
+func getOrig(t *testing.T) *psd.PSD {
+	fr, err := os.Open("testdata/cmyk-spot.psd")
+	if err != nil {
+		t.Fatal(err)
+	}
+	doc, _, err := psd.Decode(fr, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return doc
+}
+
+func TestEncodeDecode(t *testing.T) {
+	doc := buildNew(t, psd.CompressionMethodRaw)
+
+	// re-read and compare image data again
+	docReread := writeRead(t, doc)
+	assert.Equal(t, doc.Config.Channels, docReread.Config.Channels)
+}
+
+func TestDecodeChannelImages(t *testing.T) {
+	doc := getOrig(t)
+	imgs, err := doc.GetChannelImages()
+	if err != nil {
+		t.Fatal(err)
+	}
+	writeImage(t, imgs, "orig") // write imges to compare
+}
+
+func TestEncodeChannelImages(t *testing.T) {
+	// add images to new doc
+	doc := buildNew(t, psd.CompressionMethodRLE)
+	imgs := make([]*image.Gray, doc.Config.Channels)
+
+	var err error
+	for i, fnm := range []string{
+		"testdata/cmyk-spot-channel-5.png",
+		"testdata/cmyk-spot-channel-6.png",
+		"testdata/cmyk-spot-channel-7.png",
+	} {
+		imgs[i+4], err = readGrayImage(fnm)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := doc.AddImageChannelData(imgs); err != nil {
+		t.Fatal(err)
+	}
+
+	// compare image data
+	docOrig := getOrig(t)
+	assert.Len(t, doc.Data, doc.Config.Channels*doc.Config.Rect.Dx()*doc.Config.Rect.Dy())
+	assert.EqualValues(t, docOrig.Data, doc.Data)
+	for i := 4; i < doc.Config.Channels; i++ {
+		assert.EqualValues(t, docOrig.Channel[i].Data, doc.Channel[i].Data)
+	}
+
+	// write
+	fw, err := os.Create("output/cmyk-spot.psd")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer fw.Close()
+	if err := psd.Encode(doc, fw); err != nil {
+		t.Fatal(err)
+	}
+
+	// read again and write those images to compare
+	docNew := writeRead(t, doc)
+	imgsEnc, err := docNew.GetChannelImages()
+	if err != nil {
+		t.Fatal(err)
+	}
+	writeImage(t, imgsEnc, "encoded")
+}
+
+func buildNew(t *testing.T, cmp psd.CompressionMethod) *psd.PSD {
+	doc := &psd.PSD{
+		Config: psd.Config{
+			Version:           1,
+			Rect:              image.Rect(0, 0, 640, 637),
+			Channels:          7, // CMYK plus three spot channels
+			Depth:             8,
+			ColorMode:         psd.ColorModeCMYK,
+			CompressionMethod: cmp,
+		},
+	}
+	imgResources := make(map[int]psd.ImageResource)
+	irAlphaNames, err := testAlphaNames.Encode()
+	if err != nil {
+		t.Fatal(err)
+	}
+	irDisplayInfo, err := testDisplayInfo.Encode()
+	if err != nil {
+		t.Fatal(err)
+	}
+	irResInfo, err := testResolutionInfo.Encode()
+	if err != nil {
+		t.Fatal(err)
+	}
+	imgResources[irAlphaNames.ID] = *irAlphaNames
+	imgResources[irDisplayInfo.ID] = *irDisplayInfo
+	imgResources[irResInfo.ID] = *irResInfo
+	doc.Config.Res = imgResources
+
+	// dummy image data
+	imgs := make([]*image.Gray, doc.Config.Channels)
+	for i := range imgs {
+		imgs[i] = image.NewGray(doc.Config.Rect)
+	}
+	if err := doc.AddImageChannelData(imgs); err != nil {
+		t.Fatal(err)
+	}
+	return doc
+}
+
+func writeRead(t *testing.T, doc *psd.PSD) *psd.PSD {
+	buf := bytes.NewBuffer([]byte{})
+	if err := psd.Encode(doc, buf); err != nil {
+		t.Fatal(err)
+	}
+
+	log.Printf("The file is %d bytes long", len(buf.Bytes()))
+
+	out, _, err := psd.Decode(buf, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return out
+}
+
+func writeImage(t *testing.T, imgs []*image.Gray, prefix string) {
+	for c, img := range imgs {
+		w, err := os.Create(fmt.Sprintf("output/%s-c%d.png", prefix, c))
+		if err != nil {
+			t.Fatal(err)
+		}
+		defer w.Close()
+		if err := png.Encode(w, img); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func readGrayImage(fnm string) (*image.Gray, error) {
+	r, err := os.Open(fnm)
+	if err != nil {
+		return nil, err
+	}
+	defer r.Close()
+
+	img, _, err := image.Decode(r)
+	if err != nil {
+		return nil, err
+	}
+	return psd.ImgToGray(img), nil
+}

go.mod

@@ -0,0 +1,22 @@
+module github.com/oov/psd
+
+go 1.20
+
+require (
+	github.com/gopherjs/gopherjs v1.17.2
+	golang.org/x/text v0.18.0
+)
+
+require (
+	github.com/oov/downscale v0.0.0-20170819221759-1bbcb5d498e2
+	github.com/pkg/errors v0.9.1
+	github.com/stretchr/testify v1.9.0
+	golang.org/x/image v0.20.0
+)
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/depp/packbits v1.1.0 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,21 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/depp/packbits v1.1.0 h1:8X9+Jejw2+MhDTiy/EEg4N59Og96+zpbOLdwoooXSQo=
+github.com/depp/packbits v1.1.0/go.mod h1:wDV3NXiMB4a+KztSJ93UMH9cBKj5cEGooAbgRXTpQ78=
+github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
+github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k=
+github.com/oov/downscale v0.0.0-20170819221759-1bbcb5d498e2 h1:DOkvJh3Bh7i1p5QitV4aJEyxBIivy1GhPk7S19bWn9c=
+github.com/oov/downscale v0.0.0-20170819221759-1bbcb5d498e2/go.mod h1:YE+WWC4V4TL0IBHoNZtnZeIZ6e/Jr0oHKajiPwx+B7E=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+golang.org/x/image v0.20.0 h1:7cVCUjQwfL18gyBJOmYvptfSHS8Fb3YUDtfLIZ7Nbpw=
+golang.org/x/image v0.20.0/go.mod h1:0a88To4CYVBAHp5FXJm8o7QbUl37Vd85ply1vyD8auM=
+golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
+golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=