Issue with JPEG encoding? about imaging HOT 2 CLOSED

func (s SpriteImage) GetBytes() ([]byte, error) {
    var b bytes.Buffer
    w := bufio.NewWriter(&b)

    if s.sprite == nil {
        return nil, fmt.Errorf("sprite is nil")
    }

    if err := imaging.Encode(w, s.sprite, imaging.JPEG); err != nil {
        return nil, err
    }

    if err := w.Flush(); err != nil {
        return nil, err
    }

    return b.Bytes(), nil
}

func (s SpriteImage) GetBytes() ([]byte, error) {
    var b bytes.Buffer

    if s.sprite == nil {
        return nil, fmt.Errorf("sprite is nil")
    }

    if err := imaging.Encode(&b, s.sprite, imaging.JPEG); err != nil {
        return nil, err
    }

    return b.Bytes(), nil
}

func (s SpriteImage) GetBytes() ([]byte, error) {
    var b bytes.Buffer

    if s.sprite == nil {
        return nil, fmt.Errorf("sprite is nil")
    }

    if err := jpeg.Encode(&b, s.sprite, nil); err != nil {
        return nil, err
    }

    return b.Bytes(), nil
}

package main

import (
    "bufio"
    "bytes"
    "fmt"
    "image"
    "image/color"
    "log"
    "os"

    "github.com/disintegration/imaging"
)

func main() {
    const size = 50

    images := []image.Image{
        imaging.New(size, size, color.RGBA{255, 0, 0, 255}),
        imaging.New(size, size, color.RGBA{0, 255, 0, 255}),
        imaging.New(size, size, color.RGBA{0, 0, 255, 255}),
    }

    spriteImg := NewSpriteImage(size, size*3)

    for _, img := range images {
        err := spriteImg.AddImage(img)
        if err != nil {
            log.Fatal(err)
        }
    }

    b, err := spriteImg.GetBytes()
    if err != nil {
        log.Fatal(err)
    }

    // Test decoding
    _, format, err := image.Decode(bytes.NewReader(b))
    if err != nil {
        log.Fatal(err)
    }
    log.Println("Format:", format)

    // Saving bytes to test.jpg
    f, err := os.Create("test.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    _, err = f.Write(b)
    if err != nil {
        log.Fatal(err)
    }
}

type SpriteImage struct {
    dimentions      image.Point
    lastImgPosition image.Point
    sprite          *image.NRGBA
}

func NewSpriteImage(width, height int) SpriteImage {
    c := color.RGBA{0xff, 0xff, 0xff, 0xff}
    blankImage := imaging.New(width, height, c)

    return SpriteImage{
        dimentions:      image.Point{X: width, Y: height},
        lastImgPosition: image.Point{X: 0, Y: 0},
        sprite:          blankImage,
    }
}

func (s *SpriteImage) AddImage(img image.Image) error {
    imgWidth := img.Bounds().Dx()
    imgHeight := img.Bounds().Dy()

    // Make sure new image will fit into the sprite.
    if imgWidth != s.dimentions.X {
        return fmt.Errorf("image width %d mismatch sprite width %d", imgWidth, s.dimentions.X)
    }

    spriteHeightLeft := s.dimentions.Y - s.lastImgPosition.Y
    if imgHeight > spriteHeightLeft {
        return fmt.Errorf("image height %d won't fit into sprite, sprite free space %d ", imgHeight, s.dimentions.Y)
    }

    // add image to sprite
    s.sprite = imaging.Paste(s.sprite, img, s.lastImgPosition)

    // update next image position within sprite
    s.lastImgPosition = s.lastImgPosition.Add(image.Point{X: 0, Y: imgHeight})

    return nil
}

func (s SpriteImage) GetBytes() ([]byte, error) {
    var b bytes.Buffer
    w := bufio.NewWriter(&b)

    if s.sprite == nil {
        return nil, fmt.Errorf("sprite is nil")
    }

    if err := imaging.Encode(w, s.sprite, imaging.JPEG); err != nil {
        return nil, err
    }

    if err := w.Flush(); err != nil {
        return nil, err
    }

    return b.Bytes(), nil
}