fix: image type unknown from memory (#19)

* more test cases

* more test cases

* fix: image type unknown from memory

* fix tabs

* readme

* readme

* readme

* readme

* build: update generated vips package

Author: cshum

README.md

@@ -1,14 +1,18 @@
 # vipsgen
 
+[![Go Reference](https://pkg.go.dev/badge/github.com/cshum/vipsgen.svg)](https://pkg.go.dev/github.com/cshum/vipsgen)
+![GitHub release (latest SemVer)](https://img.shields.io/github/v/release/cshum/vipsgen)
+[![CI](https://github.com/cshum/vipsgen/actions/workflows/ci.yml/badge.svg)](https://github.com/cshum/vipsgen/actions/workflows/ci.yml)
+
 vipsgen is a Go binding generator for [libvips](https://github.com/libvips/libvips) - a fast and efficient image processing library.
 
-Existing Go libvips bindings rely on manually written code that is often incomplete, error-prone, and difficult to maintain as libvips evolves. vipsgen aims to solve this problem by using GObject introspection to automatically generate type-safe, efficient, and fully documented Go bindings that adapt to your specific libvips installation.
+Existing Go libvips bindings rely on manually written code that is often incomplete, error-prone, and difficult to maintain as libvips evolves. vipsgen aims to solve this problem by generating type-safe, robust, and fully documented Go bindings using GObject introspection.
 
-vipsgen provides a pre-generated library you can import directly `github.com/cshum/vipsgen/vips`. Also allows code generation via `vipsgen` command for your specific libvips installation.
+vipsgen provides a pre-generated library you can import directly `github.com/cshum/vipsgen/vips`. Also allows code generation via `vipsgen` command that adapts to your specific libvips installation.
 
-- **Coverage**: Comprehensive bindings that cover most of the libvips operations, with allowing custom code
+- **Coverage**: Comprehensive bindings for over 200 libvips operations
 - **Type-Safe**: Generates proper Go types for libvips enums and structs
-- **Idiomatic**: Creates Go style code that feels natural to use
+- **Idiomatic**: Creates clear Go style code that feels natural to use
 - **Streaming**: Includes `VipsSource` bindings with `io.ReadCloser` integration for streaming
 
 ## Quick Start
@@ -31,52 +35,68 @@ Use the package directly:
 go get -u github.com/cshum/vipsgen/vips
 ```
 
+vipsgen provides rich options for fine-tuning image operations. Each operation can accept a nil value for default options, or customize optional arguments with specific option structs:
+
 ```go
 package main
 
 import (
 	"fmt"
 	"log"
 	"net/http"
-	"os"
+	
 	"github.com/cshum/vipsgen/vips"
 )
 
 func main() {
-	// Fetch an image from URL
+	// Fetch an image from http.Get
 	resp, err := http.Get("https://raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png")
 	if err != nil {
 		log.Fatalf("Failed to fetch image: %v", err)
 	}
+	defer resp.Body.Close()
 
 	// Create source from io.ReadCloser
 	source := vips.NewSource(resp.Body)
 	defer source.Close() // source needs to remain available during image lifetime
 
-	// Load image from source
-	image, err := vips.NewImageFromSource(source, nil)
+	// Shrink-on-load via creating image from thumbnail source with options
+	image, err := vips.NewThumbnailSource(source, 800, &vips.ThumbnailSourceOptions{
+		Height: 1000,
+		FailOn: vips.FailOnError, // Fail on first error
+	})
 	if err != nil {
 		log.Fatalf("Failed to load image: %v", err)
 	}
 	defer image.Close() // always close images to free memory
 
-	// Resize the image
-	if err := image.Resize(0.5, nil); err != nil {
-		log.Fatalf("Failed to resize image: %v", err)
+	// Add a yellow border using vips_embed
+	border := 10
+	if err := image.Embed(
+		border, border,
+		image.Width()+border*2,
+		image.Height()+border*2,
+		&vips.EmbedOptions{
+			Extend:     vips.ExtendBackground, // extend with colour from the background property
+			Background: []float64{255, 255, 0, 255}, // Yellow border
+		},
+	); err != nil {
+		log.Fatalf("Failed to add border: %v", err)
 	}
 
-	// Save the result as WebP
-	buf, err := image.WebpsaveBuffer(nil)
+	fmt.Printf("Processed image: %dx%d\n", image.Width(), image.Height())
+
+	// Save the result as WebP file with options
+	err = image.Webpsave("resized-gopher.webp", &vips.WebpsaveOptions{
+		Q:              85,    // Quality factor (0-100)
+		Lossless:       false, // Use lossy compression
+		Effort:         4,     // Compression effort (0-6)
+		SmartSubsample: true,  // Better chroma subsampling
+	})
 	if err != nil {
 		log.Fatalf("Failed to save image as WebP: %v", err)
 	}
-
-	// Write to file
-	if err := os.WriteFile("resized-gopher.webp", buf, 0666); err != nil {
-		log.Fatalf("Failed to write file: %v", err)
-	}
-
-	fmt.Println("Successfully resized image to resized-gopher.webp")
+	fmt.Println("Successfully saved processed images")
 }
 ```
 

cmd/example/main.go

@@ -44,8 +44,8 @@ func (r *Image) {{.GoName}}({{generateImageMethodParams .}}) ({{generateImageMet
 {{range .Operations}}{{if and (not .HasThisImageInput) (not .HasImageOutput)}}
 // {{.GoName}} {{.Description}}
 func {{.GoName}}({{generateMethodParams .}}) ([]byte, error) {
-    Startup(nil)
-    return vipsgen{{.GoName}}({{generateUtilFunctionCallArgs .}})
+	Startup(nil)
+	return vipsgen{{.GoName}}({{generateUtilFunctionCallArgs .}})
 }
 {{end}}{{end}}
 
@@ -110,8 +110,15 @@ func (i *LoadOptions) OptionString() string {
 	if v := i.Memory; v {
 		values = append(values, "memory="+boolToStr(v))
 	}
-	if v := i.Access; v != 0 {
-		values = append(values, "access="+strconv.Itoa(int(v)))
+	if access := i.Access; access != 0 {
+		switch access {
+		case AccessSequential:
+			values = append(values, "access=sequential")
+		case AccessRandom:
+			values = append(values, "access=random")
+		case AccessSequentialUnbuffered:
+			values = append(values, "access=sequential-unbuffered")
+		}
 	}
 	return strings.Join(values, ",")
 }
@@ -162,7 +169,7 @@ func NewImageFromMemory(buf []byte, width, height, bands int) (*Image, error) {
 	if err != nil {
 		return nil, err
 	}
-	return newImageRef(vipsImage, vipsDetermineImageType(vipsImage), buf), nil
+	return newImageRef(vipsImage, ImageTypeUnknown, buf), nil
 }
 
 
@@ -240,14 +247,14 @@ func (r *Image) Interpretation() Interpretation {
 // Pages returns the number of pages in the Image
 // For animated images this corresponds to the number of frames
 func (r *Image) Pages() int {
-    {{range .ImageTypes}}{{if eq .TypeName "jp2k"}}
-    // libvips uses the same attribute (n_pages) to represent the number of pyramid layers in JP2K
-    // as we interpret the attribute as frames and JP2K does not support animation we override this with 1
-    if r.format == ImageTypeJp2k {
-        return 1
-    }
-    {{end}}{{end}}
-    return vipsGetImageNPages(r.image)
+	{{range .ImageTypes}}{{if eq .TypeName "jp2k"}}
+	// libvips uses the same attribute (n_pages) to represent the number of pyramid layers in JP2K
+	// as we interpret the attribute as frames and JP2K does not support animation we override this with 1
+	if r.format == ImageTypeJp2k {
+		return 1
+	}
+	{{end}}{{end}}
+	return vipsGetImageNPages(r.image)
 }
 
 // PageHeight return the height of a single page

internal/templates/image.go.tmpl

@@ -270,46 +270,46 @@ func clearImage(img *C.VipsImage) {
 // bufferToBytes converts a C buffer to Go bytes and frees the original buffer.
 // This function takes ownership of the buffer and will free it after conversion.
 func bufferToBytes(buf unsafe.Pointer, length C.size_t) []byte {
-    if buf == nil {
-        return nil
-    }
-    bytes := C.GoBytes(buf, C.int(length))
-    C.g_free(C.gpointer(buf))
-    return bytes
+	if buf == nil {
+		return nil
+	}
+	bytes := C.GoBytes(buf, C.int(length))
+	C.g_free(C.gpointer(buf))
+	return bytes
 }
 
 // convertImagesToVipsImages converts from Image slice to VipsImage slice
 func convertImagesToVipsImages(images []*Image) []*C.VipsImage {
-    vipsImages := make([]*C.VipsImage, len(images))
-    for i, img := range images {
-        vipsImages[i] = img.image
-    }
-    return vipsImages
+	vipsImages := make([]*C.VipsImage, len(images))
+	for i, img := range images {
+		vipsImages[i] = img.image
+	}
+	return vipsImages
 }
 
 // convertVipsImagesToImages converts a slice of *C.VipsImage to []*Image
 func convertVipsImagesToImages(vipsImages []*C.VipsImage) []*Image {
-    images := make([]*Image, len(vipsImages))
-    for i, vipsImg := range vipsImages {
-        images[i] = newImageRef(vipsImg, ImageTypeUnknown, nil)
-    }
-    return images
+	images := make([]*Image, len(vipsImages))
+	for i, vipsImg := range vipsImages {
+		images[i] = newImageRef(vipsImg, ImageTypeUnknown, nil)
+	}
+	return images
 }
 
 // vipsInterpolateToC converts a Go Interpolate to a C VipsInterpolate pointer
 func vipsInterpolateToC(interp *Interpolate) *C.VipsInterpolate {
-    if interp == nil {
-        return nil
-    }
-    return interp.interp
+	if interp == nil {
+		return nil
+	}
+	return interp.interp
 }
 
 // vipsInterpolateFromC converts a C VipsInterpolate pointer to a Go Interpolate
 func vipsInterpolateFromC(interp *C.VipsInterpolate) *Interpolate {
-    if interp == nil {
-        return nil
-    }
-    return &Interpolate{interp: interp}
+	if interp == nil {
+		return nil
+	}
+	return &Interpolate{interp: interp}
 }
 
 // convertToDoubleArray converts a Go float64 slice to a C double array and returns the length
@@ -423,12 +423,12 @@ func freeImageArray(array **C.VipsImage) {
 
 // vipsBlobToBytes converts a VipsBlob to a Go byte slice and unrefs the blob
 func vipsBlobToBytes(blob *C.VipsBlob) []byte {
-    if blob == nil {
-        return nil
-    }
-    var size C.size_t
-    ptr := C.vips_blob_get(blob, &size)
-    data := C.GoBytes(ptr, C.int(size))
-    C.vips_area_unref((*C.VipsArea)(unsafe.Pointer(blob)))
-    return data
+	if blob == nil {
+		return nil
+	}
+	var size C.size_t
+	ptr := C.vips_blob_get(blob, &size)
+	data := C.GoBytes(ptr, C.int(size))
+	C.vips_area_unref((*C.VipsArea)(unsafe.Pointer(blob)))
+	return data
 }