Add AVIF, HEIF and HEIC partial support (only metadata for now)

* Add AVIF, HEIF and HEIC partial support

* Add them as media types.
* Support reading metadata (Width, Height, Exif, etc.) from these formats.
* Add a new template function IsImageResourceMeta to check if a resource supports image metadata operations, which will return true for AVIF, HEIF and HEIC resources even if they don't support full image operations yet.

Fixes gohugoio#14549

Author: bep

common/hugio/readers.go

@@ -19,16 +19,10 @@ import (
 	"strings"
 )
 
-// ReadSeeker wraps io.Reader and io.Seeker.
-type ReadSeeker interface {
-	io.Reader
-	io.Seeker
-}
-
 // ReadSeekCloser is implemented by afero.File. We use this as the common type for
 // content in Resource objects, even for strings.
 type ReadSeekCloser interface {
-	ReadSeeker
+	io.ReadSeeker
 	io.Closer
 }
 
@@ -70,7 +64,7 @@ type ReadSeekCloserProvider interface {
 
 // readSeekerNopCloser implements ReadSeekCloser by doing nothing in Close.
 type readSeekerNopCloser struct {
-	ReadSeeker
+	io.ReadSeeker
 }
 
 // Close does nothing.
@@ -79,7 +73,7 @@ func (r readSeekerNopCloser) Close() error {
 }
 
 // NewReadSeekerNoOpCloser creates a new ReadSeekerNoOpCloser with the given ReadSeeker.
-func NewReadSeekerNoOpCloser(r ReadSeeker) ReadSeekCloser {
+func NewReadSeekerNoOpCloser(r io.ReadSeeker) ReadSeekCloser {
 	return readSeekerNopCloser{r}
 }
 
@@ -111,6 +105,22 @@ func NewReadSeekerNoOpCloserFromBytes(content []byte) readSeekerNopCloser {
 	return readSeekerNopCloser{bytes.NewReader(content)}
 }
 
+// NewReadSeekerNoOpCloserFromReader creates a new ReadSeekerNoOpCloser from the given io.Reader.
+// If the given io.Reader is not an io.ReadSeeker, the entire content will be read into memory.
+func NewReadSeekerNoOpCloserFromReader(r io.Reader) (readSeekerNopCloser, error) {
+	var rs io.ReadSeeker
+	if s, ok := r.(io.ReadSeeker); ok {
+		rs = s
+	} else {
+		b, err := io.ReadAll(r)
+		if err != nil {
+			return readSeekerNopCloser{rs}, err
+		}
+		rs = bytes.NewReader(b)
+	}
+	return readSeekerNopCloser{rs}, nil
+}
+
 // NewOpenReadSeekCloser creates a new ReadSeekCloser from the given ReadSeeker.
 // The ReadSeeker will be seeked to the beginning before returned.
 func NewOpenReadSeekCloser(r ReadSeekCloser) OpenReadSeekCloser {

hugolib/integrationtest_builder.go

@@ -506,7 +506,7 @@ func (s *IntegrationTestBuilder) ImageHelper(filename string) *IntegrationTestIm
 	fs := s.fs.WorkingDirReadOnly
 	b, err := afero.ReadFile(fs, filename)
 	s.Assert(err, qt.IsNil)
-	conf, format, err := s.H.ResourceSpec.Imaging.Codec.DecodeConfig(bytes.NewReader(b))
+	conf, format, err := s.H.ResourceSpec.Imaging.Codec.DecodeConfig(0, bytes.NewReader(b))
 	s.Assert(err, qt.IsNil)
 	img, err := s.H.ResourceSpec.Imaging.Codec.Decode(bytes.NewReader(b))
 	s.Assert(err, qt.IsNil)

media/builtin.go

@@ -29,6 +29,9 @@ type BuiltinTypes struct {
 	TIFFType Type
 	BMPType  Type
 	WEBPType Type
+	AVIFType Type
+	HEIFType Type
+	HEICType Type
 
 	// Common font types
 	TrueTypeFontType Type
@@ -85,6 +88,9 @@ var Builtin = BuiltinTypes{
 	TIFFType: Type{Type: "image/tiff"},
 	BMPType:  Type{Type: "image/bmp"},
 	WEBPType: Type{Type: "image/webp"},
+	AVIFType: Type{Type: "image/avif"},
+	HEIFType: Type{Type: "image/heif"},
+	HEICType: Type{Type: "image/heic"},
 
 	// Common font types
 	TrueTypeFontType: Type{Type: "font/ttf"},
@@ -141,6 +147,9 @@ var defaultMediaTypesConfig = map[string]any{
 	"image/tiff": map[string]any{"suffixes": []string{"tif", "tiff"}},
 	"image/bmp":  map[string]any{"suffixes": []string{"bmp"}},
 	"image/webp": map[string]any{"suffixes": []string{"webp"}},
+	"image/avif": map[string]any{"suffixes": []string{"avif"}},
+	"image/heif": map[string]any{"suffixes": []string{"heif"}},
+	"image/heic": map[string]any{"suffixes": []string{"heic"}},
 
 	// Common font types
 	"font/ttf": map[string]any{"suffixes": []string{"ttf"}},

media/config_test.go

@@ -151,5 +151,5 @@ func TestDefaultTypes(t *testing.T) {
 
 	}
 
-	c.Assert(len(DefaultTypes), qt.Equals, 41)
+	c.Assert(len(DefaultTypes), qt.Equals, 44)
 }

resources/images/codec.go

@@ -25,10 +25,12 @@ import (
 	"image/jpeg"
 	"image/png"
 	"io"
+	"strings"
 
 	"github.com/bep/imagemeta"
 	"github.com/bep/logg"
 	"github.com/gohugoio/hugo/common/himage"
+	"github.com/gohugoio/hugo/common/hugio"
 	"golang.org/x/image/bmp"
 	"golang.org/x/image/tiff"
 )
@@ -230,41 +232,44 @@ func (d *Codec) Decode(r io.Reader) (image.Image, error) {
 	return img, err
 }
 
-func (d *Codec) DecodeConfig(r io.Reader) (image.Config, string, error) {
+func (d *Codec) DecodeConfig(f Format, r io.Reader) (image.Config, string, error) {
 	rr := toPeekReader(r)
 	format, err := formatFromImage(rr)
 	if err != nil {
 		return image.Config{}, "", err
 	}
+	if format == 0 {
+		format = f
+	}
 	r = rr
-	if format == WEBP {
-		if rs, ok := r.(io.ReadSeeker); ok {
-			rs.Seek(0, 0)
-			// Avoid spinning up a WASM runtime if we don't have to.
-			res, err := imagemeta.Decode(
-				imagemeta.Options{
-					R:           rs,
-					ImageFormat: imagemeta.WebP,
-					Sources:     imagemeta.CONFIG,
-				},
-			)
-			if err == nil {
-				return image.Config{
-					Width:      res.ImageConfig.Width,
-					Height:     res.ImageConfig.Height,
-					ColorModel: color.RGBAModel,
-				}, "webp", nil
-			}
-			rs.Seek(0, 0)
-			r = rs
+	if format.UseImageMetaConfigDecoder() {
+		rs, err := hugio.NewReadSeekerNoOpCloserFromReader(r)
+		if err != nil {
+			return image.Config{}, "", err
 		}
-		// Fallback to the webp codec config decode.
-		cfg, err := d.webp.DecodeConfig(r)
-		return cfg, "webp", err
+		rs.Seek(0, 0)
+		res, err := imagemeta.Decode(
+			imagemeta.Options{
+				R:           rs,
+				ImageFormat: format.ToImageMetaImageFormatFormat(),
+				Sources:     imagemeta.CONFIG,
+			},
+		)
+		if err == nil {
+			return image.Config{
+				Width:      res.ImageConfig.Width,
+				Height:     res.ImageConfig.Height,
+				ColorModel: color.RGBAModel,
+			}, strings.ToLower(format.String()), nil
+		}
+
+		// Fallback to the standard image.DecodeConfig.
+		rs.Seek(0, 0)
+		r = rs
 	}
 
-	// Fallback to the standard image.DecodeConfig.
-	conf, name, err := image.DecodeConfig(rr)
+	conf, name, err := image.DecodeConfig(r)
+
 	return conf, name, err
 }
 

resources/images/config.go

@@ -58,6 +58,9 @@ var (
 		".bmp":  BMP,
 		".gif":  GIF,
 		".webp": WEBP,
+		".avif": AVIF,
+		".heif": HEIF,
+		".heic": HEIC,
 	}
 
 	// These are the image types we can process.
@@ -70,6 +73,13 @@ var (
 		media.Builtin.WEBPType.SubType: WEBP,
 	}
 
+	// We cannot process these formats, but we can provide metadata support for them (including width/height).
+	metaOnlyImageSubTypes = map[string]Format{
+		media.Builtin.AVIFType.SubType: AVIF,
+		media.Builtin.HEIFType.SubType: HEIF,
+		media.Builtin.HEICType.SubType: HEIC,
+	}
+
 	// Increment to mark all processed images as stale. Only use when absolutely needed.
 	// See the finer grained smartCropVersionNumber.
 	mainImageVersionNumber = 1
@@ -125,9 +135,29 @@ func ImageFormatFromExt(ext string) (Format, bool) {
 	return f, found
 }
 
-func ImageFormatFromMediaSubType(sub string) (Format, bool) {
+type ImageResourceType int
+
+const (
+	// ImageResourceTypeNone means that the resource is not an image, and thus does not support any image operations.
+	ImageResourceTypeNone ImageResourceType = iota
+	// This is an image, but with no support for any image operations.
+	ImageResourceTypeBasic
+	// ImageResourceTypeMetaOnly means that only metadata operations (e.g. getting width/height and other metadata) are supported for this format.
+	ImageResourceTypeMetaOnly
+	// ImageResourceTypeProcessable means that all image operations (resizing, cropping, etc.) are supported for this format.
+	ImageResourceTypeProcessable
+)
+
+// ImageFormatFromMediaSubType returns the image format for the given media subtype, and how much image processing operations are supported for this format.
+func ImageFormatFromMediaSubType(sub string) (Format, ImageResourceType) {
 	f, found := processableImageSubTypes[sub]
-	return f, found
+	if found {
+		return f, ImageResourceTypeProcessable
+	}
+	if f, found = metaOnlyImageSubTypes[sub]; found {
+		return f, ImageResourceTypeMetaOnly
+	}
+	return f, ImageResourceTypeBasic
 }
 
 const (

resources/images/image.go

@@ -94,7 +94,7 @@ func (i Image) WithSpec(s Spec) *Image {
 func (i *Image) InitConfig(r io.Reader) error {
 	var err error
 	i.configInit.Do(func() {
-		i.config, _, err = i.Proc.Codec.DecodeConfig(r)
+		i.config, _, err = i.Proc.Codec.DecodeConfig(i.Format, r)
 	})
 	return err
 }
@@ -114,7 +114,7 @@ func (i *Image) initConfig() error {
 		}
 		defer f.Close()
 
-		i.config, _, err = i.Proc.Codec.DecodeConfig(f)
+		i.config, _, err = i.Proc.Codec.DecodeConfig(i.Format, f)
 	})
 
 	if err != nil {
@@ -342,8 +342,18 @@ const (
 	TIFF
 	BMP
 	WEBP
+
+	// Below: We have no encoder/decoder for these, but we can provide metadata support for them (including width/height).
+	AVIF
+	HEIF
+	HEIC
 )
 
+// Whether to use imagemeta to decode image config (width/height	).
+func (f Format) UseImageMetaConfigDecoder() bool {
+	return f == WEBP || f == AVIF || f == HEIF || f == HEIC
+}
+
 func (f Format) ToImageMetaImageFormatFormat() imagemeta.ImageFormat {
 	switch f {
 	case JPEG:
@@ -354,6 +364,12 @@ func (f Format) ToImageMetaImageFormatFormat() imagemeta.ImageFormat {
 		return imagemeta.TIFF
 	case WEBP:
 		return imagemeta.WebP
+	case AVIF:
+		return imagemeta.AVIF
+	case HEIF:
+		return imagemeta.HEIF
+	case HEIC:
+		return imagemeta.HEIF
 	default:
 		return -1
 	}
@@ -396,6 +412,12 @@ func (f Format) MediaType() media.Type {
 		return media.Builtin.BMPType
 	case WEBP:
 		return media.Builtin.WEBPType
+	case AVIF:
+		return media.Builtin.AVIFType
+	case HEIF:
+		return media.Builtin.HEIFType
+	case HEIC:
+		return media.Builtin.HEICType
 	default:
 		panic(fmt.Sprintf("%d is not a valid image format", f))
 	}
@@ -415,6 +437,12 @@ func (f Format) String() string {
 		return "BMP"
 	case WEBP:
 		return "WEBP"
+	case AVIF:
+		return "AVIF"
+	case HEIF:
+		return "HEIF"
+	case HEIC:
+		return "HEIC"
 	default:
 		return "Unknown"
 	}

resources/images/meta/meta_integration_test.go

@@ -229,3 +229,74 @@ Home.
 	b.Assert(err, qt.IsNotNil)
 	b.Assert(err.Error(), qt.Contains, `invalid metadata source "foo" in imaging.meta.sources config; must be one of [exif iptc xmp]`)
 }
+
+func TestAVIFMetaWidthAndHeight(t *testing.T) {
+	t.Parallel()
+
+	files := `
+-- hugo.toml --
+[imaging.meta]
+fields = ['**']
+sources = ['exif', 'iptc', 'xmp']
+-- assets/sunset.avif --
+sourcefilename: ../../testdata/sunset.avif
+-- assets/sunset.jpg --
+sourcefilename: ../../testdata/sunset.jpg
+-- assets/mytext.txt --
+This is a text file, not an image.
+-- assets/mysvg.svg --
+<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
+  <rect width="100" height="100" fill="blue" />
+</svg>
+-- layouts/home.html --
+{{ $txt := resources.Get "mytext.txt" }}
+{{ $svg := resources.Get "mysvg.svg" }}
+{{ $avif := resources.Get "sunset.avif" }}
+{{ $jpg := resources.Get "sunset.jpg" }}
+{{ $ic := images.Config "/assets/sunset.avif" }}
+$avif.Width/Height: {{ $avif.Width }}x{{ $avif.Height }}
+$ic.Width/Height: {{ $ic.Width }}x{{ $ic.Height }}
+
+{{ template "is-meta-etc" dict "what" "AVIF" "dot" $avif -}}
+{{ template "is-meta-etc" dict "what" "JPG" "dot" $jpg -}}
+{{ template "is-meta-etc" dict "what" "TXT" "dot" $txt -}}
+{{ template "is-meta-etc" dict "what" "SVG" "dot" $svg -}}
+ 
+{{ $meta := $avif.Meta }}
+Num Exif tags: {{ $meta.Exif | len }}|
+{{ define "is-meta-etc"}}
+IsImageResource {{ .what }}: {{ if reflect.IsImageResource .dot }}true{{ else }}false{{ end }}
+IsImageResourceWithMeta {{ .what }}: {{ if reflect.IsImageResourceWithMeta .dot }}true{{ else }}false{{ end }}
+IsImageResourceProcessable {{ .what }}: {{ if reflect.IsImageResourceProcessable .dot }}true{{ else }}false{{ end }}
+{{ end }}
+
+`
+
+	b := hugolib.Test(t, files)
+
+	b.AssertFileContent("public/index.html",
+		`
+$avif.Width/Height: 900x562
+$ic.Width/Height: 900x562
+
+
+IsImageResource AVIF: true
+IsImageResourceWithMeta AVIF: true
+IsImageResourceProcessable AVIF: false
+
+IsImageResource JPG: true
+IsImageResourceWithMeta JPG: true
+IsImageResourceProcessable JPG: true
+
+IsImageResource TXT: false
+IsImageResourceWithMeta TXT: false
+IsImageResourceProcessable TXT: false
+
+IsImageResource SVG: true
+IsImageResourceWithMeta SVG: false
+IsImageResourceProcessable SVG: false
+
+Num Exif tags: 52|
+`,
+	)
+}