Merge pull request #5 from SmilyOrg/embedded

Support embedded jpeg thumbs + fix debug modes

defaults.yaml

@@ -88,7 +88,26 @@ media:
       # width
       # height: Predefined thumbnail dimensions used to pick the most
       #         appropriately-sized thumbnail for the zoom level. 
+      # 
+      # extra_cost: Additional weight to add when picking the closest thumbnail.
+      #             Higher number means that other thumbnails will be preferred
+      #             if they exist.
+
+      #
+      # Embedded JPEG thumbnail
+      #
+      - name: exif-thumb
+        exif: ThumbnailImage
+        fit: INSIDE
+        width: 120
+        height: 120
+        # It's expensive to extract, so this makes it more of a last resort, but
+        # still a lot better than loading the original photo.
+        extra_cost: 10
 
+      #
+      # Synology Moments / Photo Station thumbnails
+      #
       - name: S
         path: "{{.Dir}}@eaDir/{{.Filename}}/SYNOPHOTO_THUMB_S.jpg"
         fit: INSIDE
@@ -122,6 +141,9 @@ media:
   videos:
     extensions: [".mp4"]
     thumbnails:
+      #
+      # Synology Moments / Photo Station video variants
+      #
       - name: M
         path: "{{.Dir}}@eaDir/{{.Filename}}/SYNOPHOTO_FILM_M.mp4"
         fit: OUTSIDE

internal/image/cache.go

@@ -5,6 +5,7 @@ import (
 	"image"
 	"photofield/internal/metrics"
 	"reflect"
+	"time"
 	"unsafe"
 
 	"github.com/dgraph-io/ristretto"
@@ -47,7 +48,16 @@ func newInfoCache() InfoCache {
 	}
 }
 
-func newImageCache(caches Caches) *ristretto.Cache {
+type ImageCache struct {
+	cache *ristretto.Cache
+}
+
+type ImageLoader interface {
+	Acquire(key string, path string, thumbnail *Thumbnail) (image.Image, Info, error)
+	Release(key string)
+}
+
+func newImageCache(caches Caches) ImageCache {
 	cache, err := ristretto.NewCache(&ristretto.Config{
 		NumCounters: 1e6,                         // number of keys to track frequency of
 		MaxCost:     caches.Image.MaxSizeBytes(), // maximum cost of cache
@@ -59,7 +69,7 @@ func newImageCache(caches Caches) *ristretto.Cache {
 			if img == nil {
 				return 1
 			}
-			switch img := (*img).(type) {
+			switch img := img.(type) {
 
 			case *image.YCbCr:
 				return int64(unsafe.Sizeof(*img)) +
@@ -95,7 +105,39 @@ func newImageCache(caches Caches) *ristretto.Cache {
 		panic(err)
 	}
 	metrics.AddRistretto("image_cache", cache)
-	return cache
+	return ImageCache{
+		cache: cache,
+	}
+}
+
+func (c *ImageCache) GetOrLoad(path string, thumbnail *Thumbnail, loader ImageLoader) (image.Image, Info, error) {
+	tries := 10
+	key := path
+	if thumbnail != nil {
+		key += "|thumbnail|" + thumbnail.Name
+	}
+	for try := 0; try < tries; try++ {
+		value, found := c.cache.Get(key)
+		if found {
+			imageRef := value.(imageRef)
+			return imageRef.image, imageRef.info, imageRef.err
+		} else {
+			image, info, err := loader.Acquire(key, path, thumbnail)
+			imageRef := imageRef{
+				image: image,
+				info:  info,
+				err:   err,
+			}
+			c.cache.SetWithTTL(key, imageRef, 0, 10*time.Minute)
+			loader.Release(key)
+			return image, info, err
+		}
+	}
+	return nil, Info{}, fmt.Errorf("unable to get image after %v tries", tries)
+}
+
+func (c *ImageCache) Delete(path string) {
+	c.cache.Del(path)
 }
 
 func newFileExistsCache() *ristretto.Cache {

internal/image/decoder.go

@@ -1,31 +1,38 @@
 package image
 
 import (
+	"bytes"
+	goimage "image"
+	"image/jpeg"
+	"io"
 	"log"
 	"strconv"
 	"time"
 )
 
 type Decoder struct {
-	loader metadataLoader
+	loader       metadataLoader
+	goexifLoader *GoExifRwcarlsenLoader
 }
 
 type metadataLoader interface {
 	DecodeInfo(path string, info *Info) error
+	DecodeBytes(path string, tagName string) ([]byte, error)
 	Close()
 }
 
 func NewDecoder(exifToolCount int) *Decoder {
 	decoder := Decoder{}
+	decoder.goexifLoader = NewGoExifRwcarlsenLoader()
 	if exifToolCount > 0 {
 		var err error
 		decoder.loader, err = NewExifToolMostlyGeekLoader(exifToolCount)
 		if err != nil {
 			log.Printf("unable to use exiftool, defaulting to goexif - no video metadata support (%v)\n", err.Error())
-			decoder.loader = NewGoExifRwcarlsenLoader()
+			decoder.loader = decoder.goexifLoader
 		}
 	} else {
-		decoder.loader = NewGoExifRwcarlsenLoader()
+		decoder.loader = decoder.goexifLoader
 	}
 	return &decoder
 }
@@ -55,6 +62,20 @@ func (decoder *Decoder) DecodeInfo(path string, info *Info) error {
 	return err
 }
 
+func (decoder *Decoder) DecodeImage(path string, tagName string) (goimage.Image, Info, error) {
+	imageBytes, err := decoder.loader.DecodeBytes(path, tagName)
+	if err != nil {
+		return nil, Info{}, err
+	}
+	info := Info{}
+	r := bytes.NewReader(imageBytes)
+	decoder.goexifLoader.DecodeInfoReader(r, &info)
+
+	r.Seek(0, io.SeekStart)
+	img, err := jpeg.Decode(r)
+	return img, info, err
+}
+
 func parseOrientation(orientation string) Orientation {
 	n, err := strconv.Atoi(orientation)
 	if err != nil || n < 1 || n > 8 {

internal/image/exiftool-mostlygeek.go

@@ -3,12 +3,15 @@ package image
 import (
 	"bufio"
 	"errors"
+	"regexp"
 	"strconv"
 	"strings"
 
 	"github.com/mostlygeek/go-exiftool"
 )
 
+var previewValueMatcher = regexp.MustCompile(`Binary data (\d+) bytes`)
+
 type ExifToolMostlyGeekLoader struct {
 	exifTool *exiftool.Pool
 }
@@ -21,6 +24,19 @@ func NewExifToolMostlyGeekLoader(exifToolCount int) (*ExifToolMostlyGeekLoader,
 	decoder := &ExifToolMostlyGeekLoader{}
 	decoder.exifTool, err = exiftool.NewPool(
 		"exiftool", exifToolCount,
+		"-n", // Machine-readable values
+		"-S", // Short tag names with no padding
+	)
+	return decoder, err
+}
+
+func (decoder *ExifToolMostlyGeekLoader) DecodeInfo(path string, info *Info) error {
+
+	if decoder == nil {
+		return errors.New("unable to decode, exiftool missing")
+	}
+
+	bytes, err := decoder.exifTool.ExtractFlags(path,
 		"-Orientation",
 		"-Rotation",
 		"-ImageWidth",
@@ -37,19 +53,7 @@ func NewExifToolMostlyGeekLoader(exifToolCount int) (*ExifToolMostlyGeekLoader,
 		"-TimeStamp",
 		"-FileModifyDate",
 		"-FileCreateDate",
-		"-n", // Machine-readable values
-		"-S", // Short tag names with no padding
 	)
-	return decoder, err
-}
-
-func (decoder *ExifToolMostlyGeekLoader) DecodeInfo(path string, info *Info) error {
-
-	if decoder == nil {
-		return errors.New("unable to decode, exiftool missing")
-	}
-
-	bytes, err := decoder.exifTool.Extract(path)
 	if err != nil {
 		return err
 	}
@@ -87,6 +91,11 @@ func (decoder *ExifToolMostlyGeekLoader) DecodeInfo(path string, info *Info) err
 			if info.DateTime.IsZero() &&
 				(strings.Contains(name, "Date") || strings.Contains(name, "Time")) {
 				info.DateTime, _ = parseDateTime(value)
+			} else if strings.HasSuffix(name, "Image") {
+				match := previewValueMatcher.FindStringSubmatch(value)
+				if len(match) >= 2 {
+					println(name, match[1])
+				}
 			}
 		}
 	}
@@ -129,6 +138,18 @@ func (decoder *ExifToolMostlyGeekLoader) DecodeInfo(path string, info *Info) err
 	return nil
 }
 
+func (decoder *ExifToolMostlyGeekLoader) DecodeBytes(path string, tagName string) ([]byte, error) {
+
+	bytes, err := decoder.exifTool.ExtractFlags(path, "-b", "-"+tagName)
+
+	if err != nil {
+		println(path, tagName, err.Error())
+		return nil, err
+	}
+
+	return bytes, nil
+}
+
 func (decoder *ExifToolMostlyGeekLoader) Close() {
 	if decoder.exifTool != nil {
 		decoder.exifTool.Stop()

internal/image/goexif-rwcarlsen.go

@@ -34,16 +34,19 @@ func (decoder *GoExifRwcarlsenLoader) DecodeInfo(path string, info *Info) error
 		return err
 	}
 	defer file.Close()
+	return decoder.DecodeInfoReader(file, info)
+}
 
-	x, err := exif.Decode(file)
+func (decoder *GoExifRwcarlsenLoader) DecodeInfoReader(r io.ReadSeeker, info *Info) error {
+	x, err := exif.Decode(r)
 	if err == nil {
 		info.DateTime, _ = x.DateTime()
 	}
 
 	orientation := parseOrientation(getOrientationFromExif(x))
 
-	file.Seek(0, io.SeekStart)
-	conf, _, err := image.DecodeConfig(file)
+	r.Seek(0, io.SeekStart)
+	conf, _, err := image.DecodeConfig(r)
 	if err != nil {
 		return err
 	}
@@ -58,4 +61,24 @@ func (decoder *GoExifRwcarlsenLoader) DecodeInfo(path string, info *Info) error
 	return nil
 }
 
+func (decoder *GoExifRwcarlsenLoader) DecodeBytes(path string, tagName string) ([]byte, error) {
+	file, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	x, err := exif.Decode(file)
+	if err != nil {
+		return nil, err
+	}
+
+	tag, err := x.Get(exif.FieldName(tagName))
+	if err != nil {
+		return nil, err
+	}
+
+	return tag.Val, nil
+}
+
 func (decoder *GoExifRwcarlsenLoader) Close() {}