117 lines
3.1 KiB
Go
117 lines
3.1 KiB
Go
package pngmeta
|
|
|
|
import (
|
|
"bytes"
|
|
"elefant/models"
|
|
"encoding/base64"
|
|
"encoding/binary"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"hash/crc32"
|
|
"io"
|
|
"os"
|
|
)
|
|
|
|
type Writer struct {
|
|
w io.Writer
|
|
}
|
|
|
|
func NewPNGWriter(w io.Writer) (*Writer, error) {
|
|
if _, err := io.WriteString(w, writeHeader); err != nil {
|
|
return nil, err
|
|
}
|
|
return &Writer{w}, nil
|
|
}
|
|
|
|
func (w *Writer) WriteChunk(length int32, typ string, r io.Reader) error {
|
|
if err := binary.Write(w.w, binary.BigEndian, length); err != nil {
|
|
return err
|
|
}
|
|
if _, err := w.w.Write([]byte(typ)); err != nil {
|
|
return err
|
|
}
|
|
checksummer := crc32.NewIEEE()
|
|
checksummer.Write([]byte(typ))
|
|
if _, err := io.CopyN(io.MultiWriter(w.w, checksummer), r, int64(length)); err != nil {
|
|
return err
|
|
}
|
|
if err := binary.Write(w.w, binary.BigEndian, checksummer.Sum32()); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func WriteToPng(c *models.CharCardSpec, fpath, outfile string) error {
|
|
data, err := os.ReadFile(fpath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
jsonData, err := json.Marshal(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Base64 encode the JSON data
|
|
base64Data := base64.StdEncoding.EncodeToString(jsonData)
|
|
pe := PngEmbed{
|
|
Key: cKey,
|
|
Value: base64Data,
|
|
}
|
|
w, err := WritetEXtToPngBytes(data, pe)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(outfile, w.Bytes(), 0666)
|
|
}
|
|
|
|
func WritetEXtToPngBytes(inputBytes []byte, pe PngEmbed) (outputBytes bytes.Buffer, err error) {
|
|
if !(string(inputBytes[:8]) == header) {
|
|
return outputBytes, errors.New("wrong file format")
|
|
}
|
|
reader := bytes.NewReader(inputBytes)
|
|
pngr, err := NewPNGStepReader(reader)
|
|
if err != nil {
|
|
return outputBytes, fmt.Errorf("NewReader(): %s", err)
|
|
}
|
|
pngw, err := NewPNGWriter(&outputBytes)
|
|
if err != nil {
|
|
return outputBytes, fmt.Errorf("NewWriter(): %s", err)
|
|
}
|
|
for {
|
|
chunk, err := pngr.Next()
|
|
if err != nil {
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
return outputBytes, fmt.Errorf("NextChunk(): %s", err)
|
|
}
|
|
if chunk.Type() != embType {
|
|
// IENDChunkType will only appear on the final iteration of a valid PNG
|
|
if chunk.Type() == IEND {
|
|
// This is where we inject tEXtChunkType as the penultimate chunk with the new value
|
|
newtEXtChunk := []byte(fmt.Sprintf(tEXtChunkDataSpecification, pe.Key, pe.Value))
|
|
if err := pngw.WriteChunk(int32(len(newtEXtChunk)), embType, bytes.NewBuffer(newtEXtChunk)); err != nil {
|
|
return outputBytes, fmt.Errorf("WriteChunk(): %s", err)
|
|
}
|
|
// Now we end the buffer with IENDChunkType chunk
|
|
if err := pngw.WriteChunk(chunk.length, chunk.Type(), chunk); err != nil {
|
|
return outputBytes, fmt.Errorf("WriteChunk(): %s", err)
|
|
}
|
|
} else {
|
|
// writes back original chunk to buffer
|
|
if err := pngw.WriteChunk(chunk.length, chunk.Type(), chunk); err != nil {
|
|
return outputBytes, fmt.Errorf("WriteChunk(): %s", err)
|
|
}
|
|
}
|
|
} else {
|
|
if _, err := io.Copy(io.Discard, chunk); err != nil {
|
|
return outputBytes, fmt.Errorf("io.Copy(io.Discard, chunk): %s", err)
|
|
}
|
|
}
|
|
if err := chunk.Close(); err != nil {
|
|
return outputBytes, fmt.Errorf("chunk.Close(): %s", err)
|
|
}
|
|
}
|
|
return outputBytes, nil
|
|
}
|