diff --git a/core/artwork/artwork.go b/core/artwork/artwork.go
index ba47348e8..a1ca7d2dd 100644
--- a/core/artwork/artwork.go
+++ b/core/artwork/artwork.go
@@ -1,21 +1,13 @@
package artwork
import (
- "bufio"
- "bytes"
"context"
"errors"
"fmt"
- "image"
_ "image/gif"
- "image/jpeg"
- "image/png"
"io"
- "net/http"
- "strings"
"time"
- "github.com/disintegration/imaging"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
"github.com/navidrome/navidrome/core/ffmpeg"
@@ -40,12 +32,17 @@ type artwork struct {
ffmpeg ffmpeg.FFmpeg
}
-func (a *artwork) Get(ctx context.Context, id string, size int) (io.ReadCloser, error) {
+type artworkReader interface {
+ cache.Item
+ LastUpdated() time.Time
+ Reader(ctx context.Context) (io.ReadCloser, string, error)
+}
+
+func (a *artwork) Get(ctx context.Context, id string, size int) (reader io.ReadCloser, err error) {
ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
var artID model.ArtworkID
- var err error
if id != "" {
artID, err = model.ParseArtworkID(id)
if err != nil {
@@ -53,181 +50,49 @@ func (a *artwork) Get(ctx context.Context, id string, size int) (io.ReadCloser,
}
}
- item := &artItem{a: a, artID: artID, size: size}
+ var artReader artworkReader
+ switch artID.Kind {
+ case model.KindAlbumArtwork:
+ artReader, err = newAlbumArtworkReader(ctx, a, artID)
+ case model.KindMediaFileArtwork:
+ artReader, err = newMediafileArtworkReader(ctx, a, artID)
+ default:
+ artReader, err = newEmptyIDReader(ctx, artID)
+ }
+ if err != nil {
+ return nil, err
+ }
+ if size > 0 {
+ artReader = resizedFromOriginal(artReader, artID, size)
+ }
- r, err := a.cache.Get(ctx, item)
+ r, err := a.cache.Get(ctx, artReader)
if err != nil && !errors.Is(err, context.Canceled) {
log.Error(ctx, "Error accessing image cache", "id", id, "size", size, err)
}
return r, err
}
-func (a *artwork) get(ctx context.Context, artID model.ArtworkID, size int) (reader io.ReadCloser, path string, err error) {
- // If requested a resized image, get the original (possibly from cache)
- if size > 0 {
- r, err := a.Get(ctx, artID.String(), 0)
- if err != nil {
- return nil, "", err
- }
- defer r.Close()
- resized, err := a.resizedFromOriginal(ctx, artID, r, size)
- return io.NopCloser(resized), fmt.Sprintf("%s@%d", artID, size), err
- }
-
- switch artID.Kind {
- case model.KindAlbumArtwork:
- reader, path = a.extractAlbumImage(ctx, artID)
- case model.KindMediaFileArtwork:
- reader, path = a.extractMediaFileImage(ctx, artID)
- default:
- reader, path, _ = fromPlaceholder()()
- }
- return reader, path, ctx.Err()
+type cacheItem struct {
+ artID model.ArtworkID
+ size int
+ lastUpdate time.Time
}
-func (a *artwork) extractAlbumImage(ctx context.Context, artID model.ArtworkID) (io.ReadCloser, string) {
- al, err := a.ds.Album(ctx).Get(artID.ID)
- if errors.Is(err, model.ErrNotFound) {
- r, path, _ := fromPlaceholder()()
- return r, path
- }
- if err != nil {
- log.Error(ctx, "Could not retrieve album", "id", artID.ID, err)
- return nil, ""
- }
- var ff = fromCoverArtPriority(ctx, a.ffmpeg, conf.Server.CoverArtPriority, *al)
- ff = append(ff, fromPlaceholder())
- return extractImage(ctx, artID, ff...)
-}
-
-func (a *artwork) extractMediaFileImage(ctx context.Context, artID model.ArtworkID) (reader io.ReadCloser, path string) {
- mf, err := a.ds.MediaFile(ctx).Get(artID.ID)
- if errors.Is(err, model.ErrNotFound) {
- r, path, _ := fromPlaceholder()()
- return r, path
- }
- if err != nil {
- log.Error(ctx, "Could not retrieve mediafile", "id", artID.ID, err)
- return nil, ""
- }
-
- var ff []sourceFunc
- if mf.CoverArtID().Kind == model.KindMediaFileArtwork {
- ff = []sourceFunc{
- fromTag(mf.Path),
- fromFFmpegTag(ctx, a.ffmpeg, mf.Path),
- }
- }
- ff = append(ff, a.fromAlbum(ctx, mf.AlbumCoverArtID()))
- return extractImage(ctx, artID, ff...)
-}
-
-func (a *artwork) resizedFromOriginal(ctx context.Context, artID model.ArtworkID, original io.Reader, size int) (io.Reader, error) {
- // Keep a copy of the original data. In case we can't resize it, send it as is
- buf := new(bytes.Buffer)
- r := io.TeeReader(original, buf)
-
- resized, err := resizeImage(r, size)
- if err != nil {
- log.Warn(ctx, "Could not resize image. Will return image as is", "artID", artID, "size", size, err)
- // Force finish reading any remaining data
- _, _ = io.Copy(io.Discard, r)
- return buf, nil
- }
- return resized, nil
-}
-
-func extractImage(ctx context.Context, artID model.ArtworkID, extractFuncs ...sourceFunc) (io.ReadCloser, string) {
- for _, f := range extractFuncs {
- if ctx.Err() != nil {
- return nil, ""
- }
- r, path, err := f()
- if r != nil {
- log.Trace(ctx, "Found artwork", "artID", artID, "path", path, "source", f)
- return r, path
- }
- log.Trace(ctx, "Tried to extract artwork", "artID", artID, "source", f, err)
- }
- log.Error(ctx, "extractImage should never reach this point!", "artID", artID, "path")
- return nil, ""
-}
-
-func fromCoverArtPriority(ctx context.Context, ffmpeg ffmpeg.FFmpeg, priority string, al model.Album) []sourceFunc {
- var ff []sourceFunc
- for _, pattern := range strings.Split(strings.ToLower(priority), ",") {
- pattern = strings.TrimSpace(pattern)
- if pattern == "embedded" {
- ff = append(ff, fromTag(al.EmbedArtPath), fromFFmpegTag(ctx, ffmpeg, al.EmbedArtPath))
- continue
- }
- if al.ImageFiles != "" {
- ff = append(ff, fromExternalFile(ctx, al.ImageFiles, pattern))
- }
- }
- return ff
-}
-
-func asImageReader(r io.Reader) (io.Reader, string, error) {
- br := bufio.NewReader(r)
- buf, err := br.Peek(512)
- if err != nil {
- return nil, "", err
- }
- return br, http.DetectContentType(buf), nil
-}
-
-func resizeImage(reader io.Reader, size int) (io.Reader, error) {
- r, format, err := asImageReader(reader)
- if err != nil {
- return nil, err
- }
-
- img, _, err := image.Decode(r)
- if err != nil {
- return nil, err
- }
-
- // Preserve the aspect ratio of the image.
- var m *image.NRGBA
- bounds := img.Bounds()
- if bounds.Max.X > bounds.Max.Y {
- m = imaging.Resize(img, size, 0, imaging.Lanczos)
- } else {
- m = imaging.Resize(img, 0, size, imaging.Lanczos)
- }
-
- buf := new(bytes.Buffer)
- buf.Reset()
- if format == "image/png" {
- err = png.Encode(buf, m)
- } else {
- err = jpeg.Encode(buf, m, &jpeg.Options{Quality: conf.Server.CoverJpegQuality})
- }
- return buf, err
+func (i *cacheItem) Key() string {
+ return fmt.Sprintf("%s.%d.%d.%d", i.artID.ID, i.lastUpdate.UnixMilli(), i.size, conf.Server.CoverJpegQuality)
}
type imageCache struct {
cache.FileCache
}
-type artItem struct {
- a *artwork
- artID model.ArtworkID
- size int
-}
-
-func (k *artItem) Key() string {
- return fmt.Sprintf("%s.%d.%d", k.artID, k.size, conf.Server.CoverJpegQuality)
-}
-
func GetImageCache() cache.FileCache {
return singleton.GetInstance(func() *imageCache {
return &imageCache{
FileCache: cache.NewFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems,
func(ctx context.Context, arg cache.Item) (io.Reader, error) {
- info := arg.(*artItem)
- r, _, err := info.a.get(ctx, info.artID, info.size)
+ r, _, err := arg.(artworkReader).Reader(ctx)
return r, err
}),
}
diff --git a/core/artwork/artwork_internal_test.go b/core/artwork/artwork_internal_test.go
index 9a6b4b1e7..6c0a257b0 100644
--- a/core/artwork/artwork_internal_test.go
+++ b/core/artwork/artwork_internal_test.go
@@ -5,6 +5,7 @@ import (
"errors"
"image"
"io"
+ "testing"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
@@ -16,6 +17,13 @@ import (
. "github.com/onsi/gomega"
)
+func TestArtwork(t *testing.T) {
+ tests.Init(t, false)
+ log.SetLevel(log.LevelFatal)
+ RegisterFailHandler(Fail)
+ RunSpecs(t, "Artwork Suite")
+}
+
var _ = Describe("Artwork", func() {
var aw *artwork
var ds model.DataStore
diff --git a/core/artwork/reader_album.go b/core/artwork/reader_album.go
new file mode 100644
index 000000000..e89435af7
--- /dev/null
+++ b/core/artwork/reader_album.go
@@ -0,0 +1,58 @@
+package artwork
+
+import (
+ "context"
+ "io"
+ "strings"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/core/ffmpeg"
+ "github.com/navidrome/navidrome/model"
+)
+
+type albumArtworkReader struct {
+ cacheItem
+ a *artwork
+ album model.Album
+}
+
+func newAlbumArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*albumArtworkReader, error) {
+ al, err := artwork.ds.Album(ctx).Get(artID.ID)
+ if err != nil {
+ return nil, err
+ }
+ a := &albumArtworkReader{
+ a: artwork,
+ album: *al,
+ }
+ a.cacheItem.artID = artID
+ a.cacheItem.lastUpdate = al.UpdatedAt
+ return a, nil
+}
+
+func (a *albumArtworkReader) LastUpdated() time.Time {
+ return a.album.UpdatedAt
+}
+
+func (a *albumArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+ var ff = fromCoverArtPriority(ctx, a.a.ffmpeg, conf.Server.CoverArtPriority, a.album)
+ ff = append(ff, fromPlaceholder())
+ r, source := extractImage(ctx, a.artID, ff...)
+ return r, source, nil
+}
+
+func fromCoverArtPriority(ctx context.Context, ffmpeg ffmpeg.FFmpeg, priority string, al model.Album) []sourceFunc {
+ var ff []sourceFunc
+ for _, pattern := range strings.Split(strings.ToLower(priority), ",") {
+ pattern = strings.TrimSpace(pattern)
+ if pattern == "embedded" {
+ ff = append(ff, fromTag(al.EmbedArtPath), fromFFmpegTag(ctx, ffmpeg, al.EmbedArtPath))
+ continue
+ }
+ if al.ImageFiles != "" {
+ ff = append(ff, fromExternalFile(ctx, al.ImageFiles, pattern))
+ }
+ }
+ return ff
+}
diff --git a/core/artwork/reader_emptyid.go b/core/artwork/reader_emptyid.go
new file mode 100644
index 000000000..951aa46a1
--- /dev/null
+++ b/core/artwork/reader_emptyid.go
@@ -0,0 +1,35 @@
+package artwork
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/model"
+)
+
+type emptyIDReader struct {
+ artID model.ArtworkID
+}
+
+func newEmptyIDReader(_ context.Context, artID model.ArtworkID) (*emptyIDReader, error) {
+ a := &emptyIDReader{
+ artID: artID,
+ }
+ return a, nil
+}
+
+func (a *emptyIDReader) LastUpdated() time.Time {
+ return time.Now() // Basically make it non-cacheable
+}
+
+func (a *emptyIDReader) Key() string {
+ return fmt.Sprintf("0.%d.0.%d", a.LastUpdated().UnixMilli(), conf.Server.CoverJpegQuality)
+}
+
+func (a *emptyIDReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+ r, source := extractImage(ctx, a.artID, fromPlaceholder())
+ return r, source, nil
+}
diff --git a/core/artwork/reader_mediafile.go b/core/artwork/reader_mediafile.go
new file mode 100644
index 000000000..e2a977c11
--- /dev/null
+++ b/core/artwork/reader_mediafile.go
@@ -0,0 +1,65 @@
+package artwork
+
+import (
+ "context"
+ "io"
+ "time"
+
+ "github.com/navidrome/navidrome/model"
+)
+
+type mediafileArtworkReader struct {
+ cacheItem
+ a *artwork
+ mediafile model.MediaFile
+ album model.Album
+}
+
+func newMediafileArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*mediafileArtworkReader, error) {
+ mf, err := artwork.ds.MediaFile(ctx).Get(artID.ID)
+ if err != nil {
+ return nil, err
+ }
+ al, err := artwork.ds.Album(ctx).Get(mf.AlbumID)
+ if err != nil {
+ return nil, err
+ }
+ a := &mediafileArtworkReader{
+ a: artwork,
+ mediafile: *mf,
+ album: *al,
+ }
+ a.cacheItem.artID = artID
+ a.cacheItem.lastUpdate = a.LastUpdated()
+ return a, nil
+}
+
+func (a *mediafileArtworkReader) LastUpdated() time.Time {
+ if a.album.UpdatedAt.After(a.mediafile.UpdatedAt) {
+ return a.album.UpdatedAt
+ }
+ return a.mediafile.UpdatedAt
+}
+
+func (a *mediafileArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+ var ff []sourceFunc
+ if a.mediafile.CoverArtID().Kind == model.KindMediaFileArtwork {
+ ff = []sourceFunc{
+ fromTag(a.mediafile.Path),
+ fromFFmpegTag(ctx, a.a.ffmpeg, a.mediafile.Path),
+ }
+ }
+ ff = append(ff, fromAlbum(ctx, a.a, a.mediafile.AlbumCoverArtID()))
+ r, source := extractImage(ctx, a.artID, ff...)
+ return r, source, nil
+}
+
+func fromAlbum(ctx context.Context, a *artwork, id model.ArtworkID) sourceFunc {
+ return func() (io.ReadCloser, string, error) {
+ r, err := a.Get(ctx, id.String(), 0)
+ if err != nil {
+ return nil, "", err
+ }
+ return r, id.String(), nil
+ }
+}
diff --git a/core/artwork/reader_resized.go b/core/artwork/reader_resized.go
new file mode 100644
index 000000000..9e2afb474
--- /dev/null
+++ b/core/artwork/reader_resized.go
@@ -0,0 +1,96 @@
+package artwork
+
+import (
+ "bufio"
+ "bytes"
+ "context"
+ "fmt"
+ "image"
+ "image/jpeg"
+ "image/png"
+ "io"
+ "net/http"
+ "time"
+
+ "github.com/disintegration/imaging"
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils/number"
+)
+
+type resizedArtworkReader struct {
+ cacheItem
+ original artworkReader
+}
+
+func resizedFromOriginal(original artworkReader, artID model.ArtworkID, size int) *resizedArtworkReader {
+ r := &resizedArtworkReader{original: original}
+ r.cacheItem.artID = artID
+ r.cacheItem.size = size
+ r.cacheItem.lastUpdate = original.LastUpdated()
+ return r
+}
+
+func (a *resizedArtworkReader) LastUpdated() time.Time {
+ return a.lastUpdate
+}
+
+func (a *resizedArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
+ orig, path, err := a.original.Reader(ctx)
+ if err != nil {
+ return nil, "", err
+ }
+ // Keep a copy of the original data. In case we can't resize it, send it as is
+ buf := new(bytes.Buffer)
+ r := io.TeeReader(orig, buf)
+
+ resized, origSize, err := resizeImage(r, a.size)
+ log.Trace(ctx, "Resizing artwork", "artID", a.artID, "original", origSize, "resized", a.size)
+ if err != nil {
+ log.Warn(ctx, "Could not resize image. Will return image as is", "artID", a.artID, "size", a.size, err)
+ // Force finish reading any remaining data
+ _, _ = io.Copy(io.Discard, r)
+ return io.NopCloser(buf), "", nil
+ }
+ return io.NopCloser(resized), fmt.Sprintf("%s@%d", path, a.size), nil
+}
+
+func asImageReader(r io.Reader) (io.Reader, string, error) {
+ br := bufio.NewReader(r)
+ buf, err := br.Peek(512)
+ if err != nil {
+ return nil, "", err
+ }
+ return br, http.DetectContentType(buf), nil
+}
+
+func resizeImage(reader io.Reader, size int) (io.Reader, int, error) {
+ r, format, err := asImageReader(reader)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ img, _, err := image.Decode(r)
+ if err != nil {
+ return nil, 0, err
+ }
+
+ // Preserve the aspect ratio of the image.
+ var m *image.NRGBA
+ bounds := img.Bounds()
+ if bounds.Max.X > bounds.Max.Y {
+ m = imaging.Resize(img, size, 0, imaging.Lanczos)
+ } else {
+ m = imaging.Resize(img, 0, size, imaging.Lanczos)
+ }
+
+ buf := new(bytes.Buffer)
+ buf.Reset()
+ if format == "image/png" {
+ err = png.Encode(buf, m)
+ } else {
+ err = jpeg.Encode(buf, m, &jpeg.Options{Quality: conf.Server.CoverJpegQuality})
+ }
+ return buf, number.Max(bounds.Max.X, bounds.Max.Y), err
+}
diff --git a/core/artwork/sources.go b/core/artwork/sources.go
index 8fcb1d2c6..328f0b994 100644
--- a/core/artwork/sources.go
+++ b/core/artwork/sources.go
@@ -19,26 +19,32 @@ import (
"github.com/navidrome/navidrome/resources"
)
-type sourceFunc func() (io.ReadCloser, string, error)
+func extractImage(ctx context.Context, artID model.ArtworkID, extractFuncs ...sourceFunc) (io.ReadCloser, string) {
+ for _, f := range extractFuncs {
+ if ctx.Err() != nil {
+ return nil, ""
+ }
+ r, path, err := f()
+ if r != nil {
+ log.Trace(ctx, "Found artwork", "artID", artID, "path", path, "source", f)
+ return r, path
+ }
+ log.Trace(ctx, "Tried to extract artwork", "artID", artID, "source", f, err)
+ }
+ log.Error(ctx, "extractImage should never reach this point!", "artID", artID, "path")
+ return nil, ""
+}
+
+type sourceFunc func() (r io.ReadCloser, path string, err error)
func (f sourceFunc) String() string {
name := runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()
- name = strings.TrimPrefix(name, "github.com/navidrome/navidrome/core.")
+ name = strings.TrimPrefix(name, "github.com/navidrome/navidrome/core/artwork.")
name = strings.TrimPrefix(name, "(*artwork).")
name = strings.TrimSuffix(name, ".func1")
return name
}
-func (a *artwork) fromAlbum(ctx context.Context, id model.ArtworkID) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- r, path, err := a.get(ctx, id, 0)
- if err != nil {
- return nil, "", err
- }
- return r, path, nil
- }
-}
-
func fromExternalFile(ctx context.Context, files string, pattern string) sourceFunc {
return func() (io.ReadCloser, string, error) {
for _, file := range filepath.SplitList(files) {
diff --git a/model/artwork_id.go b/model/artwork_id.go
index f44d6d288..8928929c3 100644
--- a/model/artwork_id.go
+++ b/model/artwork_id.go
@@ -3,9 +3,7 @@ package model
import (
"errors"
"fmt"
- "strconv"
"strings"
- "time"
)
type Kind struct{ prefix string }
@@ -16,35 +14,25 @@ var (
)
type ArtworkID struct {
- Kind Kind
- ID string
- LastUpdate time.Time
+ Kind Kind
+ ID string
}
func (id ArtworkID) String() string {
- s := fmt.Sprintf("%s-%s", id.Kind.prefix, id.ID)
- if id.LastUpdate.Unix() < 0 {
- return s + "-0"
- }
- return fmt.Sprintf("%s-%x", s, id.LastUpdate.Unix())
+ return fmt.Sprintf("%s-%s", id.Kind.prefix, id.ID)
}
func ParseArtworkID(id string) (ArtworkID, error) {
parts := strings.Split(id, "-")
- if len(parts) != 3 {
+ if len(parts) != 2 {
return ArtworkID{}, errors.New("invalid artwork id")
}
- lastUpdate, err := strconv.ParseInt(parts[2], 16, 64)
- if err != nil {
- return ArtworkID{}, err
- }
if parts[0] != KindAlbumArtwork.prefix && parts[0] != KindMediaFileArtwork.prefix {
return ArtworkID{}, errors.New("invalid artwork kind")
}
return ArtworkID{
- Kind: Kind{parts[0]},
- ID: parts[1],
- LastUpdate: time.Unix(lastUpdate, 0),
+ Kind: Kind{parts[0]},
+ ID: parts[1],
}, nil
}
@@ -58,16 +46,14 @@ func MustParseArtworkID(id string) ArtworkID {
func artworkIDFromAlbum(al Album) ArtworkID {
return ArtworkID{
- Kind: KindAlbumArtwork,
- ID: al.ID,
- LastUpdate: al.UpdatedAt,
+ Kind: KindAlbumArtwork,
+ ID: al.ID,
}
}
func artworkIDFromMediaFile(mf MediaFile) ArtworkID {
return ArtworkID{
- Kind: KindMediaFileArtwork,
- ID: mf.ID,
- LastUpdate: mf.UpdatedAt,
+ Kind: KindMediaFileArtwork,
+ ID: mf.ID,
}
}
diff --git a/model/mediafile.go b/model/mediafile.go
index e6fce6a03..12120317a 100644
--- a/model/mediafile.go
+++ b/model/mediafile.go
@@ -78,7 +78,7 @@ func (mf MediaFile) CoverArtID() ArtworkID {
}
func (mf MediaFile) AlbumCoverArtID() ArtworkID {
- return artworkIDFromAlbum(Album{ID: mf.AlbumID, UpdatedAt: mf.UpdatedAt})
+ return artworkIDFromAlbum(Album{ID: mf.AlbumID})
}
type MediaFiles []MediaFile
diff --git a/ui/src/subsonic/index.js b/ui/src/subsonic/index.js
index 620646030..90fdf5042 100644
--- a/ui/src/subsonic/index.js
+++ b/ui/src/subsonic/index.js
@@ -51,12 +51,10 @@ const getCoverArtUrl = (record, size) => {
}
// TODO Move this logic to server. `song` and `album` should have a CoverArtID
- const lastUpdate = Math.floor(Date.parse(record.updatedAt) / 1000)
- const id = record.id + '-' + Math.max(lastUpdate, 0).toString(16)
if (record.album) {
- return baseUrl(url('getCoverArt', 'mf-' + id, options))
+ return baseUrl(url('getCoverArt', 'mf-' + record.id, options))
} else {
- return baseUrl(url('getCoverArt', 'al-' + id, options))
+ return baseUrl(url('getCoverArt', 'al-' + record.id, options))
}
}