lib/nie/nie.go

// Copyright 2022 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// ----------------

// Package nie provides access to NIE (Naïve Image Format) files.
//
// The NIE specification is at
// https://github.com/google/wuffs/blob/main/doc/spec/nie-spec.md
package nie

import (
	"errors"
	"image"
	"image/color"
	"io"
)

func u32le(b []byte) uint32 {
	return (uint32(b[0]) << 0) |
		(uint32(b[1]) << 8) |
		(uint32(b[2]) << 16) |
		(uint32(b[3]) << 24)
}

func init() {
	image.RegisterFormat("nie", "nïE", Decode, DecodeConfig)
}

var (
	errImageIsTooLarge = errors.New("nie: image is too large")
	errInvalidHeader   = errors.New("nie: invalid header")
)

func decodeConfig(r io.Reader) (image.Config, byte, byte, error) {
	b := [16]byte{}
	_, err := io.ReadFull(r, b[:])
	if err != nil {
		return image.Config{}, 0, 0, err
	}
	if (u32le(b[:]) != 0x45afc36e) ||
		(b[4] != 0xff) ||
		(b[5] != 'b') ||
		((b[6] != 'n') && (b[6] != 'p')) ||
		((b[7] != '4') && (b[7] != '8')) {
		return image.Config{}, 0, 0, errInvalidHeader
	}

	cm := color.Model(nil)
	switch {
	case (b[6] == 'n') && (b[7] == '4'):
		cm = color.NRGBAModel
	case (b[6] == 'n') && (b[7] == '8'):
		cm = color.NRGBA64Model
	case (b[6] == 'p') && (b[7] == '4'):
		cm = color.RGBAModel
	case (b[6] == 'p') && (b[7] == '8'):
		cm = color.RGBA64Model
	default:
		return image.Config{}, 0, 0, errInvalidHeader
	}

	w := u32le(b[8:])
	h := u32le(b[12:])
	if (w > 0x7fffffff) || (h > 0x7fffffff) {
		return image.Config{}, 0, 0, errInvalidHeader
	}
	return image.Config{
		ColorModel: cm,
		Width:      int(w),
		Height:     int(h),
	}, b[6], b[7], nil
}

// DecodeConfig returns the color model and dimensions of a NIE image without
// decoding the entire image.
func DecodeConfig(r io.Reader) (image.Config, error) {
	cfg, _, _, err := decodeConfig(r)
	return cfg, err
}

// Decode reads a NIE image from r.
func Decode(r io.Reader) (image.Image, error) {
	cfg, b6, b7, err := decodeConfig(r)
	if err != nil {
		return nil, err
	}

	const u64max = 0xffffffffffffffff
	tooBig := false
	wh := uint64(cfg.Width) * uint64(cfg.Height)
	if b7 == '4' {
		tooBig = (wh > (u64max / 4)) ||
			((wh * 4) != uint64(int((wh * 4))))
	} else {
		tooBig = (wh > (u64max / 8)) ||
			((wh * 8) != uint64(int((wh * 8))))
	}
	if tooBig {
		return nil, errImageIsTooLarge
	}

	img, pix := image.Image(nil), []byte(nil)
	switch {
	case (b6 == 'n') && (b7 == '4'):
		m := image.NewNRGBA(image.Rect(0, 0, int(cfg.Width), int(cfg.Height)))
		img, pix = m, m.Pix
	case (b6 == 'n') && (b7 == '8'):
		m := image.NewNRGBA64(image.Rect(0, 0, int(cfg.Width), int(cfg.Height)))
		img, pix = m, m.Pix
	case (b6 == 'p') && (b7 == '4'):
		m := image.NewRGBA(image.Rect(0, 0, int(cfg.Width), int(cfg.Height)))
		img, pix = m, m.Pix
	case (b6 == 'p') && (b7 == '8'):
		m := image.NewRGBA64(image.Rect(0, 0, int(cfg.Width), int(cfg.Height)))
		img, pix = m, m.Pix
	}
	if _, err := io.ReadFull(r, pix); err != nil {
		return nil, err
	}

	// NIE is little-endian BGRA. Go is big-endian RGBA.
	if b7 == '4' {
		for i := 0; i < len(pix); i += 4 {
			pix[i+0], pix[i+2] = pix[i+2], pix[i+0]
		}
	} else {
		for i := 0; i < len(pix); i += 8 {
			pix[i+0], pix[i+1], pix[i+2], pix[i+3], pix[i+4], pix[i+5], pix[i+6], pix[i+7] =
				pix[i+5], pix[i+4], pix[i+3], pix[i+2], pix[i+1], pix[i+0], pix[i+7], pix[i+6]
		}
	}

	return img, err
}