decode.go

package xtx

import (
	"fmt"
	"image"
	"io"
)

func init() {
	// Register XTG format: magic bytes "XTG\0" at offset 0.
	image.RegisterFormat("xtg",
		"XTG\x00", // magic string (XTG\0 in little-endian starts with 'X','T','G',0)
		func(r io.Reader) (image.Image, error) { return Decode(r) },
		func(r io.Reader) (image.Config, error) { return DecodeConfig(r) },
	)
	// Register XTH format: magic bytes "XTH\0" at offset 0.
	image.RegisterFormat("xth",
		"XTH\x00",
		func(r io.Reader) (image.Image, error) { return Decode(r) },
		func(r io.Reader) (image.Config, error) { return DecodeConfig(r) },
	)
}

// Decode reads an XTG or XTH image from r, auto-detecting the format from
// the magic bytes in the header.
func Decode(r io.Reader) (image.Image, error) {
	var h Header
	if _, err := h.ReadFrom(r); err != nil {
		return nil, err
	}
	if err := h.Validate(); err != nil {
		return nil, err
	}

	data := make([]byte, h.DataSize)
	if _, err := io.ReadFull(r, data); err != nil {
		return nil, fmt.Errorf("xtx: reading image data: %w", err)
	}

	switch h.Mark {
	case MagicXTG:
		return decodeMono(&h, data), nil
	case MagicXTH:
		return decodeGray(&h, data), nil
	default:
		return nil, ErrInvalidMagic
	}
}

// DecodeConfig returns the image dimensions and color model without reading
// the pixel data.
func DecodeConfig(r io.Reader) (image.Config, error) {
	var h Header
	if _, err := h.ReadFrom(r); err != nil {
		return image.Config{}, err
	}

	var model image.Config
	model.Width = int(h.Width)
	model.Height = int(h.Height)

	switch h.Mark {
	case MagicXTG:
		model.ColorModel = MonoModel
	case MagicXTH:
		model.ColorModel = Gray4Model
	default:
		return image.Config{}, ErrInvalidMagic
	}
	return model, nil
}

// decodeMono constructs a Monochrome image from the header and raw pixel data.
func decodeMono(h *Header, data []byte) *Monochrome {
	w, ht := int(h.Width), int(h.Height)
	stride := (w + 7) / 8
	img := &Monochrome{
		Pix:    data,
		Stride: stride,
		Rect:   image.Rect(0, 0, w, ht),
	}
	return img
}

// decodeGray constructs a Grayscale image from the header and raw pixel data.
func decodeGray(h *Header, data []byte) *Grayscale {
	w, ht := int(h.Width), int(h.Height)
	colBytes := (ht + 7) / 8
	planeSize := w * colBytes
	img := &Grayscale{
		Pix:       data,
		Rect:      image.Rect(0, 0, w, ht),
		PlaneSize: planeSize,
		ColBytes:  colBytes,
	}
	return img
}