Slight refactoring of resize/resample

gd.go

@@ -6,14 +6,15 @@ import "C"
 
 import (
 	//	"bytes"
-	// "fmt"
+	//	"fmt"
 	"errors"
 	"unsafe"
 )
 
 var (
-	imageError = errors.New("image is nil")
-	writeError = errors.New("image cannot be accessed")
+	imageError = errors.New("[GD] image is nil")
+	createError = errors.New("[GD] cannot create new image")
+	writeError = errors.New("[GD] image cannot be written")
 )
 
 type gdImage struct {
@@ -55,7 +56,7 @@ func (p *gdImage) gdDestroy() {
 }
 
 func isInvalid(p *gdImage) bool {
-	return p == nil
+	return p == nil || p.img.pixels != nil
 }
 
 func (p *gdImage) width() int {
@@ -72,37 +73,72 @@ func (p *gdImage) height() int {
 	return int((*p.img).sy)
 }
 
-func (p *gdImage) gdCopyResampled(dst *gdImage, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH int) {
+func (p *gdImage) gdCopyResampled(dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH int) (*gdImage) {
 	if p == nil || p.img == nil {
 		panic(imageError)
 	}
 
+	dst := gdCreate(dstW, dstH)
+
+	if dst == nil {
+		return nil
+	}
+
 	C.gdImageCopyResampled(dst.img, p.img, C.int(dstX), C.int(dstY), C.int(srcX), C.int(srcY),
 		C.int(dstW), C.int(dstH), C.int(srcW), C.int(srcH))
+
+	if isInvalid(dst) {
+		dst.gdDestroy()
+		return nil
+	}
+
+	return dst
 }
 
-func (p *gdImage) gdCopyResized(dst *gdImage, dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH int) {
-	if p == nil {
+func (p *gdImage) gdCopyResized(dstX, dstY, srcX, srcY, dstW, dstH, srcW, srcH int) (*gdImage) {
+	if p == nil || p.img == nil {
 		panic(imageError)
 	}
+
+	dst := gdCreate(dstW, dstH)
+
+	if dst == nil {
+		return nil
+	}
+
 	C.gdImageCopyResized(dst.img, p.img, C.int(dstX), C.int(dstY), C.int(srcX), C.int(srcY),
 		C.int(dstW), C.int(dstH), C.int(srcW), C.int(srcH))
-}
 
-// func (p *gdImage) gdImagePng() ([]byte, error) {
-// 	var size int
+	if isInvalid(dst) {
+		dst.gdDestroy()
+		return nil
+	}
 
-// 	data := C.gdImagePngPtr(p.img, &size)
-// 	if data == nil {
-// 		return []byte{}, writeError
-// 	}
+	return dst
+}
 
-// 	defer C.gdFree(unsafe.Pointer(data))	
+func (p *gdImage) gdImagePng() ([]byte, error) {
+	if p == nil {
+		panic(imageError)
+	}
+
+	var size C.int
+
+	data := C.gdImagePngPtr(p.img, &size)
+	if data == nil || int(size) == 0 {
+		return []byte{}, writeError
+	}
+
+	defer C.gdFree(unsafe.Pointer(data))	
 
-// 	return C.GoBytes(data)
-// }
+	return C.GoBytes(data, size), nil
+}
 
 func (p *gdImage) gdImageJpeg() ([]byte, error) {
+	if p == nil {
+		panic(imageError)
+	}
+
 	var size C.int
 
 	// use -1 as quality, this will mean to use standard Jpeg quality

image.go

@@ -2,6 +2,13 @@ package mogrify
 
 import (
 	"fmt"
+  "errors"
+)
+
+var (
+  resampleError = errors.New("Resampling failed")
+  resizeError = errors.New("Resampling failed")
+  loadError  = errors.New("Image cannot be loaded")
 )
 
 type Image interface {

jpg.go

@@ -3,7 +3,6 @@ package mogrify
 import (
 	"bytes"
 	"errors"
-	"fmt"
 	"io"
 )
 
@@ -12,8 +11,7 @@ var (
 )
 
 var (
-	jpgLoadError  = errors.New("Jpeg cannot be loaded")
-	resampleError = errors.New("Resampling failed")
+
 )
 
 type Jpg struct {
@@ -23,7 +21,6 @@ type Jpg struct {
 func NewJpg(reader io.Reader) *Jpg {
 	var image Jpg
 	if _, err := image.ReadFrom(reader); err != nil {
-		fmt.Printf("%s", err)
 		return nil
 	}
 	return &image
@@ -41,32 +38,29 @@ func NewBlankJpg(width, height int) *Jpg {
 
 func (img *Jpg) ReadFrom(reader io.Reader) (n int64, err error) {
 	var buffer bytes.Buffer
-	n, err = buffer.ReadFrom(reader)
 
+	n, err = buffer.ReadFrom(reader)
 	if err != nil {
 		return
 	}
 
 	gd := gdCreateFromJpeg(buffer.Bytes())
 	if gd == nil {
-		return n, jpgLoadError
-	}
-
-	if img.gd != nil {
-		img.Destroy()
+		return n, loadError
 	}
 
+	img.Destroy()
 	img.gd = gd
 	return
 }
 
 func (img *Jpg) WriteTo(writer io.Writer) (n int64, err error) {
-
 	slice, err := img.gd.gdImageJpeg() 
 	if err != nil {
 		return 0, err
 	}
 
+
 	_, err = writer.Write(slice) 
 
 	return 0, err
@@ -81,25 +75,21 @@ func (img *Jpg) Height() int {
 }
 
 func (img *Jpg) NewResized(width, height int) (*Jpg, error) {
-	resized := NewBlankJpg(width, height)
-	img.gd.gdCopyResized(resized.gd, 0, 0, 0, 0, width, height, img.Width(), img.Height())
-
-	return resized, nil
-}
-
-func (img *Jpg) NewResampled(width, height int) (*Jpg, error) {
-	resized := NewBlankJpg(width, height)
+	resized := img.gd.gdCopyResized(0, 0, 0, 0, width, height, img.gd.width(), img.gd.height())
 	if resized == nil {
 		return nil, resampleError
 	}
 
-	img.gd.gdCopyResampled(resized.gd, 0, 0, 0, 0, width, height, img.gd.width(), img.gd.height())
+	return &Jpg{resized}, nil
+}
 
-	if isInvalid(resized.gd) {
+func (img *Jpg) NewResampled(width, height int) (*Jpg, error) {
+	resized := img.gd.gdCopyResampled(0, 0, 0, 0, width, height, img.gd.width(), img.gd.height())
+	if resized == nil {
 		return nil, resampleError
 	}
 
-	return resized, nil
+	return &Jpg{resized}, nil
 }
 
 func (img *Jpg) Destroy() {