mirror/hugo
1
0
Fork 0
mirror of https://github.com/gohugoio/hugo.git synced 2025-08-28 22:19:59 +02:00
Code Issues Packages Projects Releases Wiki Activity

resources: Cache Exif data to disk

Browse Source 
```bash
name                        old time/op    new time/op    delta
ImageExif/Cold_cache-4         312µs ±28%     355µs ± 7%     ~     (p=0.343 n=4+4)
ImageExif/Cold_cache,_10-4     479µs ± 6%     546µs ± 0%  +13.91%  (p=0.029 n=4+4)
ImageExif/Warm_cache-4         272µs ± 1%      81µs ± 5%  -70.30%  (p=0.029 n=4+4)

name                        old alloc/op   new alloc/op   delta
ImageExif/Cold_cache-4         151kB ± 0%     161kB ± 0%   +6.46%  (p=0.029 n=4+4)
ImageExif/Cold_cache,_10-4     179kB ± 0%     189kB ± 0%   +5.49%  (p=0.029 n=4+4)
ImageExif/Warm_cache-4         151kB ± 0%      13kB ± 0%  -91.52%  (p=0.029 n=4+4)

name                        old allocs/op  new allocs/op  delta
ImageExif/Cold_cache-4         1.03k ± 0%     1.21k ± 0%  +17.78%  (p=0.029 n=4+4)
ImageExif/Cold_cache,_10-4     1.65k ± 0%     1.83k ± 0%  +11.09%  (p=0.029 n=4+4)
ImageExif/Warm_cache-4         1.03k ± 0%     0.28k ± 0%  -72.40%  (p=0.029 n=4+4)
```

Fixes #6291
This commit is contained in:
Bjørn Erik Pedersen
2019-09-01 17:27:21 +02:00
parent de9cbf6195
commit ce47c21a29
7 changed files with 172 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
resources/image.go
View File

@@ -14,15 +14,20 @@
package resources
import (
"encoding/json"
"fmt"
"image"
"image/draw"
_ "image/gif"
_ "image/png"
"io"
"io/ioutil"
"os"
"path"
"strings"
"sync"
"github.com/gohugoio/hugo/cache/filecache"
"github.com/gohugoio/hugo/resources/images/exif"
"github.com/gohugoio/hugo/resources/internal"
@@ -55,43 +60,81 @@ type imageResource struct {
// original (first).
root *imageResource
exifInit sync.Once
exifInitErr error
exif *exif.Exif
metaInit sync.Once
metaInitErr error
meta *imageMeta
baseResource
}
type imageMeta struct {
Exif *exif.Exif
}
func (i *imageResource) Exif() (*exif.Exif, error) {
return i.root.getExif()
}
func (i *imageResource) getExif() (*exif.Exif, error) {
i.exifInit.Do(func() {
i.metaInit.Do(func() {
supportsExif := i.Format == images.JPEG || i.Format == images.TIFF
if !supportsExif {
return
}
f, err := i.root.ReadSeekCloser()
if err != nil {
i.exifInitErr = err
return
}
defer f.Close()
key := i.getImageMetaCacheTargetPath()
x, err := i.getSpec().imaging.DecodeExif(f)
if err != nil {
i.exifInitErr = err
return
read := func(info filecache.ItemInfo, r io.Reader) error {
meta := &imageMeta{}
data, err := ioutil.ReadAll(r)
if err != nil {
return err
}
if err = json.Unmarshal(data, &meta); err != nil {
return err
}
i.meta = meta
return nil
}
i.exif = x
create := func(info filecache.ItemInfo, w io.WriteCloser) (err error) {
f, err := i.root.ReadSeekCloser()
if err != nil {
i.metaInitErr = err
return
}
defer f.Close()
x, err := i.getSpec().imaging.DecodeExif(f)
if err != nil {
i.metaInitErr = err
return
}
i.meta = &imageMeta{Exif: x}
// Also write it to cache
enc := json.NewEncoder(w)
return enc.Encode(i.meta)
}
_, i.metaInitErr = i.getSpec().imageCache.fileCache.ReadOrCreate(key, read, create)
})
return i.exif, i.exifInitErr
if i.metaInitErr != nil {
return nil, i.metaInitErr
}
return i.meta.Exif, nil
}
func (i *imageResource) Clone() resource.Resource {
@@ -271,6 +314,17 @@ func (i *imageResource) setBasePath(conf images.ImageConfig) {
i.getResourcePaths().relTargetDirFile = i.relTargetPathFromConfig(conf)
}
func (i *imageResource) getImageMetaCacheTargetPath() string {
const imageMetaVersionNumber = 1 // Increment to invalidate the meta cache
cfg := i.getSpec().imaging.Cfg
df := i.getResourcePaths().relTargetDirFile
p1, _ := helpers.FileAndExt(df.file)
h, _ := i.hash()
idStr := internal.HashString(h, i.size(), imageMetaVersionNumber, cfg)
return path.Join(df.dir, fmt.Sprintf("%s%s.json", p1, idStr))
}
func (i *imageResource) relTargetPathFromConfig(conf images.ImageConfig) dirFile {
p1, p2 := helpers.FileAndExt(i.getResourcePaths().relTargetDirFile.file)
if conf.Action == "trace" {

50
resources/image_test.go
View File

@@ -15,6 +15,7 @@ package resources
import (
"fmt"
"math/big"
"math/rand"
"os"
"path/filepath"
@@ -22,6 +23,7 @@ import (
"strconv"
"sync"
"testing"
"time"
"github.com/spf13/afero"
@@ -50,6 +52,14 @@ var eq = qt.CmpEquals(
cmp.Comparer(func(m1, m2 media.Type) bool {
return m1.Type() == m2.Type()
}),
cmp.Comparer(
func(v1, v2 *big.Rat) bool {
return v1.RatString() == v2.RatString()
},
),
cmp.Comparer(func(v1, v2 time.Time) bool {
return v1.Unix() == v2.Unix()
}),
)
func TestImageTransformBasic(t *testing.T) {
@@ -336,27 +346,35 @@ func TestSVGImageContent(t *testing.T) {
func TestImageExif(t *testing.T) {
c := qt.New(t)
image := fetchImage(c, "sunset.jpg")
fs := afero.NewMemMapFs()
spec := newTestResourceSpec(specDescriptor{fs: fs, c: c})
image := fetchResourceForSpec(spec, c, "sunset.jpg").(resource.Image)
x, err := image.Exif()
c.Assert(err, qt.IsNil)
c.Assert(x, qt.Not(qt.IsNil))
getAndCheckExif := func(c *qt.C, image resource.Image) {
x, err := image.Exif()
c.Assert(err, qt.IsNil)
c.Assert(x, qt.Not(qt.IsNil))
c.Assert(x.Date.Format("2006-01-02"), qt.Equals, "2017-10-27")
c.Assert(x.Date.Format("2006-01-02"), qt.Equals, "2017-10-27")
// Malaga: https://goo.gl/taazZy
c.Assert(x.Lat, qt.Equals, float64(36.59744166666667))
c.Assert(x.Long, qt.Equals, float64(-4.50846))
// Malaga: https://goo.gl/taazZy
c.Assert(x.Lat, qt.Equals, float64(36.59744166666667))
c.Assert(x.Long, qt.Equals, float64(-4.50846))
v, found := x.Values["LensModel"]
c.Assert(found, qt.Equals, true)
lensModel, ok := v.(string)
c.Assert(ok, qt.Equals, true)
c.Assert(lensModel, qt.Equals, "smc PENTAX-DA* 16-50mm F2.8 ED AL [IF] SDM")
v, found := x.Tags["LensModel"]
c.Assert(found, qt.Equals, true)
lensModel, ok := v.(string)
c.Assert(ok, qt.Equals, true)
c.Assert(lensModel, qt.Equals, "smc PENTAX-DA* 16-50mm F2.8 ED AL [IF] SDM")
resized, _ := image.Resize("300x200")
x2, _ := resized.Exif()
c.Assert(x2, eq, x)
}
resized, _ := image.Resize("300x200")
x2, _ := resized.Exif()
c.Assert(x2, qt.Equals, x)
getAndCheckExif(c, image)
image = fetchResourceForSpec(spec, c, "sunset.jpg").(resource.Image)
// This will read from file cache.
getAndCheckExif(c, image)
}

39
resources/images/exif/exif.go
View File

@@ -24,6 +24,8 @@ import (
"unicode"
"unicode/utf8"
"github.com/bep/tmc"
_exif "github.com/rwcarlsen/goexif/exif"
"github.com/rwcarlsen/goexif/tiff"
)
@@ -31,10 +33,10 @@ import (
const exifTimeLayout = "2006:01:02 15:04:05"
type Exif struct {
Lat float64
Long float64
Date time.Time
Values map[string]interface{}
Lat float64
Long float64
Date time.Time
Tags Tags
}
type Decoder struct {
@@ -139,7 +141,7 @@ func (d *Decoder) Decode(r io.Reader) (ex *Exif, err error) {
return
}
ex = &Exif{Lat: lat, Long: long, Date: tm, Values: walker.vals}
ex = &Exif{Lat: lat, Long: long, Date: tm, Tags: walker.vals}
return
}
@@ -240,3 +242,30 @@ func nullString(in []byte) string {
return ""
}
var tcodec *tmc.Codec
func init() {
var err error
tcodec, err = tmc.New()
if err != nil {
panic(err)
}
}
type Tags map[string]interface{}
func (v *Tags) UnmarshalJSON(b []byte) error {
vv := make(map[string]interface{})
if err := tcodec.Unmarshal(b, &vv); err != nil {
return err
}
*v = vv
return nil
}
func (v Tags) MarshalJSON() ([]byte, error) {
return tcodec.Marshal(v)
}

26
resources/images/exif/exif_test.go
View File

@@ -14,12 +14,15 @@
package exif
import (
"encoding/json"
"math/big"
"os"
"path/filepath"
"testing"
"time"
"github.com/gohugoio/hugo/htesting/hqt"
"github.com/google/go-cmp/cmp"
qt "github.com/frankban/quicktest"
)
@@ -40,16 +43,24 @@ func TestExif(t *testing.T) {
c.Assert(x.Lat, qt.Equals, float64(36.59744166666667))
c.Assert(x.Long, qt.Equals, float64(-4.50846))
v, found := x.Values["LensModel"]
v, found := x.Tags["LensModel"]
c.Assert(found, qt.Equals, true)
lensModel, ok := v.(string)
c.Assert(ok, qt.Equals, true)
c.Assert(lensModel, qt.Equals, "smc PENTAX-DA* 16-50mm F2.8 ED AL [IF] SDM")
v, found = x.Values["DateTime"]
v, found = x.Tags["DateTime"]
c.Assert(found, qt.Equals, true)
c.Assert(v, hqt.IsSameType, time.Time{})
// Verify that it survives a round-trip to JSON and back.
data, err := json.Marshal(x)
c.Assert(err, qt.IsNil)
x2 := &Exif{}
err = json.Unmarshal(data, x2)
c.Assert(x2, eq, x)
}
func TestExifPNG(t *testing.T) {
@@ -81,3 +92,14 @@ func BenchmarkDecodeExif(b *testing.B) {
f.Seek(0, 0)
}
}
var eq = qt.CmpEquals(
cmp.Comparer(
func(v1, v2 *big.Rat) bool {
return v1.RatString() == v2.RatString()
},
),
cmp.Comparer(func(v1, v2 time.Time) bool {
return v1.Unix() == v2.Unix()
}),
)