126 lines
2.4 KiB
Go
126 lines
2.4 KiB
Go
package nori
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"io"
|
|
)
|
|
|
|
type Image struct {
|
|
Bpp uint32
|
|
Count uint32
|
|
Delay uint32
|
|
OffsetX int32
|
|
OffsetY int32
|
|
|
|
Width uint32
|
|
Height uint32
|
|
|
|
Size uint32
|
|
Data []byte
|
|
|
|
Img image.Image
|
|
}
|
|
|
|
func (i *Image) Decode(rd io.Reader, palette *PaletteSection) error {
|
|
if err := binary.Read(rd, end, &i.Count); err != nil {
|
|
return err
|
|
}
|
|
if i.Count != 1 {
|
|
return fmt.Errorf("img count should be 1")
|
|
}
|
|
|
|
if err := binary.Read(rd, end, &i.Size); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := binary.Read(rd, end, &i.Width); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := binary.Read(rd, end, &i.Height); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := binary.Read(rd, end, &i.Delay); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := binary.Read(rd, end, &i.OffsetX); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := binary.Read(rd, end, &i.OffsetY); err != nil {
|
|
return err
|
|
}
|
|
cf := image.NewRGBA64(image.Rect(0, 0, int(i.Width), int(i.Height)))
|
|
i.Img = cf
|
|
switch i.Bpp {
|
|
case 8:
|
|
if palette == nil {
|
|
return fmt.Errorf("bpp = 8, but no palette")
|
|
}
|
|
for idx := 0; idx < int(i.Size); idx++ {
|
|
b, err := readByte(rd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
col := palette.Palette[b]
|
|
cf.Set(idx%int(i.Width), idx/int(i.Width), col)
|
|
}
|
|
return nil
|
|
case 16:
|
|
var bgr uint16
|
|
for idx := 0; idx < int(i.Size/2); idx++ {
|
|
if err := binary.Read(rd, end, &bgr); err != nil {
|
|
return err
|
|
}
|
|
red := uint8(((0x7c00 & bgr) >> 10) * 255 / 31)
|
|
green := uint8(((0x3e0 & bgr) >> 5) * 255 / 31)
|
|
blue := uint8((0x1f & bgr) * 255 / 31)
|
|
alpha := uint8(0xff)
|
|
if red == 0xff && green == 0x00 && blue == 0xff {
|
|
alpha = 0x00
|
|
}
|
|
if red == 0x00 && blue == 0x00 && green == 0xff {
|
|
alpha = 0x00
|
|
}
|
|
col := &color.RGBA{
|
|
red, green, blue,
|
|
alpha,
|
|
}
|
|
cf.Set(idx%int(i.Width), idx/int(i.Width), col)
|
|
}
|
|
return nil
|
|
case 24:
|
|
i.Data = make([]byte, i.Size)
|
|
for idx := 0; idx < int(i.Size/3); idx++ {
|
|
rgb := [3]byte{}
|
|
_, err := io.ReadFull(rd, rgb[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
alpha := uint8(0xff)
|
|
|
|
if rgb[2] == 0x00 && rgb[1] == 0xff && rgb[0] == 0x00 {
|
|
alpha = 0x00
|
|
}
|
|
if rgb[2] == 0xff && rgb[1] == 0x00 && rgb[0] == 0xff {
|
|
alpha = 0x00
|
|
}
|
|
|
|
col := &color.RGBA{
|
|
rgb[2], rgb[1], rgb[0],
|
|
alpha,
|
|
}
|
|
|
|
cf.Set(idx%int(i.Width), idx/int(i.Width), col)
|
|
}
|
|
return nil
|
|
default:
|
|
return fmt.Errorf("unsupported bpp, %d", i.Bpp)
|
|
}
|
|
}
|