Skip to content

🎧 Your Personal Streaming Service

feat(artwork): new artwork pipeline with background resolution and Low Quality Image Placeholders (#5847)

Deluan Quintão944ca3100fce
diff --git a/adapters/deezer/deezer.go b/adapters/deezer/deezer.go
index d8e832cf1..742b8b1a5 100644
--- a/adapters/deezer/deezer.go
+++ b/adapters/deezer/deezer.go
@@ -70,16 +70,27 @@ func (s *deezerAgent) GetArtistImages(ctx context.Context, _, name, _ string) ([
{artist.PictureSmall, deezerApiPictureSmallSize},
}
for _, imgData := range possibleImages {
- if imgData.URL != "" {
+ if imgData.URL != "" && !isPlaceholderPicture(imgData.URL) {
res = append(res, agents.ExternalImage{
URL: imgData.URL,
Size: imgData.Size,
})
}
}
+ if len(res) == 0 {
+ return nil, agents.ErrNotFound
+ }
return res, nil
}
+// deezerEmptyPicturePath is Deezer's empty-image-id path shape for artists with no picture
+// (…/images/artist//1000x1000-…), which serves a generic silhouette on any CDN host.
+const deezerEmptyPicturePath = "/images/artist//"
+
+func isPlaceholderPicture(url string) bool {
+ return strings.Contains(url, deezerEmptyPicturePath)
+}
+
func (s *deezerAgent) searchArtist(ctx context.Context, name string) (*Artist, error) {
artists, err := s.client.searchArtists(ctx, name, deezerArtistSearchLimit)
if errors.Is(err, ErrNotFound) || len(artists) == 0 {
diff --git a/adapters/deezer/deezer_test.go b/adapters/deezer/deezer_test.go
index f478af115..360db1f13 100644
--- a/adapters/deezer/deezer_test.go
+++ b/adapters/deezer/deezer_test.go
@@ -94,6 +94,54 @@ var _ = Describe("deezerAgent", func() {
})
})
+ Describe("GetArtistImages", func() {
+ var agent *deezerAgent
+ var httpClient *fakeHttpClient
+
+ BeforeEach(func() {
+ httpClient = &fakeHttpClient{}
+ agent = &deezerAgent{
+ dataStore: &tests.MockDataStore{},
+ client: newClient(httpClient),
+ }
+ })
+
+ It("returns the real images when the artist has a picture", func() {
+ httpClient.mock("https://api.deezer.com/search/artist", http.Response{
+ StatusCode: 200,
+ Body: io.NopCloser(bytes.NewBufferString(`{"data":[
+ {"id":412,"name":"Queen","nb_fan":12744378,
+ "picture_xl":"https://cdn-images.dzcdn.net/images/artist/abc/1000x1000-000000-80-0-0.jpg",
+ "picture_big":"https://cdn-images.dzcdn.net/images/artist/abc/500x500-000000-80-0-0.jpg"}
+ ],"total":1}`)),
+ })
+
+ images, err := agent.GetArtistImages(ctx, "", "Queen", "")
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(images).To(HaveLen(2))
+ Expect(images[0].URL).To(ContainSubstring("1000x1000"))
+ })
+
+ It("returns ErrNotFound when the artist only has empty-id placeholder pictures", func() {
+ httpClient.mock("https://api.deezer.com/search/artist", http.Response{
+ StatusCode: 200,
+ Body: io.NopCloser(bytes.NewBufferString(`{"data":[
+ {"id":412,"name":"Queen","nb_fan":12744378,
+ "picture_xl":"https://cdn-images.dzcdn.net/images/artist//1000x1000-000000-80-0-0.jpg",
+ "picture_big":"https://cdn-images.dzcdn.net/images/artist//500x500-000000-80-0-0.jpg",
+ "picture_medium":"https://cdn-images.dzcdn.net/images/artist//250x250-000000-80-0-0.jpg",
+ "picture_small":"https://cdn-images.dzcdn.net/images/artist//56x56-000000-80-0-0.jpg"}
+ ],"total":1}`)),
+ })
+
+ images, err := agent.GetArtistImages(ctx, "", "Queen", "")
+
+ Expect(err).To(MatchError(agents.ErrNotFound))
+ Expect(images).To(BeEmpty())
+ })
+ })
+
Describe("GetArtistBiography - Language Fallback", func() {
var agent *deezerAgent
var httpClient *langAwareHttpClient
diff --git a/adapters/lastfm/agent.go b/adapters/lastfm/agent.go
index eb8f3d36e..f967595e3 100644
--- a/adapters/lastfm/agent.go
+++ b/adapters/lastfm/agent.go
@@ -93,7 +93,7 @@ func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid strin
var resp agents.AlbumInfo
for _, lang := range l.languages {
var err error
- a, err = l.callAlbumGetInfo(ctx, name, artist, mbid, lang)
+ a, err = l.callAlbumGetInfo(ctx, name, artist, lang)
if err != nil {
return nil, err
}
@@ -114,7 +114,7 @@ func (l *lastfmAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid strin
}
func (l *lastfmAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {
- a, err := l.callAlbumGetInfo(ctx, name, artist, mbid, l.languages[0])
+ a, err := l.callAlbumGetInfo(ctx, name, artist, l.languages[0])
if err != nil {
return nil, err
}
@@ -286,22 +286,18 @@ func (l *lastfmAgent) GetArtistImages(ctx context.Context, _, name, mbid string)
return res, nil
}
-func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, mbid string, lang string) (*Album, error) {
- a, err := l.client.albumGetInfo(ctx, name, artist, mbid, lang)
- var lfErr *lastFMError
- isLastFMError := errors.As(err, &lfErr)
-
- if mbid != "" && (isLastFMError && lfErr.Code == 6) {
- log.Debug(ctx, "LastFM/album.getInfo could not find album by mbid, trying again", "album", name, "mbid", mbid)
- return l.callAlbumGetInfo(ctx, name, artist, "", lang)
- }
-
+// callAlbumGetInfo matches on name+artist only. Last.fm's album.getInfo by MBID is unreliable —
+// a correct MBID can return a different album (or none) — so the MBID is deliberately not passed.
+func (l *lastfmAgent) callAlbumGetInfo(ctx context.Context, name, artist, lang string) (*Album, error) {
+ a, err := l.client.albumGetInfo(ctx, name, artist, "", lang)
if err != nil {
- if isLastFMError && lfErr.Code == 6 {
- log.Debug(ctx, "Album not found", "album", name, "mbid", mbid, err)
- } else {
- log.Error(ctx, "Error calling LastFM/album.getInfo", "album", name, "mbid", mbid, err)
+ if lfErr, ok := errors.AsType[*lastFMError](err); ok && lfErr.Code == 6 {
+ // A not-found is a definitive absence, not a fault: return the shared sentinel so the
+ // artwork worker's breaker/transient checks don't retry it, and log it at Debug.
+ log.Debug(ctx, "Album not found in Last.fm", "album", name, "artist", artist)
+ return nil, agents.ErrNotFound
}
+ log.Error(ctx, "Error calling LastFM/album.getInfo", "album", name, "artist", artist, err)
return nil, err
}
return a, nil
@@ -313,6 +309,12 @@ func (l *lastfmAgent) callArtistGetInfo(ctx context.Context, name string, lang s
a, err := l.client.artistGetInfo(ctx, name, lang)
if err != nil {
+ if lfErr, ok := errors.AsType[*lastFMError](err); ok && lfErr.Code == 6 {
+ // A not-found is a definitive absence, not a fault: return the shared sentinel so it
+ // doesn't trip the artwork worker's breaker, and log at Debug instead of Error.
+ log.Debug(ctx, "Artist not found in Last.fm", "artist", name)
+ return nil, agents.ErrNotFound
+ }
log.Error(ctx, "Error calling LastFM/artist.getInfo", "artist", name, err)
return nil, err
}
diff --git a/adapters/lastfm/agent_test.go b/adapters/lastfm/agent_test.go
index 7e4e29294..94024b9ab 100644
--- a/adapters/lastfm/agent_test.go
+++ b/adapters/lastfm/agent_test.go
@@ -539,7 +539,10 @@ var _ = Describe("lastfmAgent", func() {
URL: "https://www.last.fm/music/Cher/Believe",
}))
Expect(httpClient.RequestCount).To(Equal(1))
- Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("03c91c40-49a6-44a7-90e7-a700edf97a62"))
+ // MBID is deliberately not sent — album.getInfo matches on name+artist only.
+ Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
+ Expect(httpClient.SavedRequest.URL.Query().Get("album")).To(Equal("Believe"))
+ Expect(httpClient.SavedRequest.URL.Query().Get("artist")).To(Equal("Cher"))
})
It("returns empty images if no images are available", func() {
@@ -558,7 +561,7 @@ var _ = Describe("lastfmAgent", func() {
_, err := agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")
Expect(err).To(HaveOccurred())
Expect(httpClient.RequestCount).To(Equal(1))
- Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+ Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
})
It("returns an error if Last.fm call returns an error", func() {
@@ -566,23 +569,17 @@ var _ = Describe("lastfmAgent", func() {
_, err := agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")
Expect(err).To(HaveOccurred())
Expect(httpClient.RequestCount).To(Equal(1))
- Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(Equal("mbid-1234"))
+ Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
})
- It("returns an error if Last.fm call returns an error 6 and mbid is empty", func() {
+ It("returns an error when Last.fm returns an error 6 (album not found)", func() {
httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
- _, err := agent.GetAlbumInfo(ctx, "123", "U2", "")
+ _, err := agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")
Expect(err).To(HaveOccurred())
+ // A definitive not-found must satisfy the sentinel, or the artwork worker retries it.
+ Expect(errors.Is(err, agents.ErrNotFound)).To(BeTrue())
Expect(httpClient.RequestCount).To(Equal(1))
- })
-
- Context("MBID non existent in Last.fm", func() {
- It("calls again when last.fm returns an error 6", func() {
- httpClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
- _, _ = agent.GetAlbumInfo(ctx, "123", "U2", "mbid-1234")
- Expect(httpClient.RequestCount).To(Equal(2))
- Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
- })
+ Expect(httpClient.SavedRequest.URL.Query().Get("mbid")).To(BeEmpty())
})
})
@@ -613,6 +610,13 @@ var _ = Describe("lastfmAgent", func() {
Expect(images[0].URL).To(Equal("https://lastfm.freetls.fastly.net/i/u/ar0/818148bf682d429dc21b59a73ef6f68e.png"))
})
+ It("maps a Last.fm error 6 (artist not found) to the shared not-found sentinel", func() {
+ apiClient.Res = http.Response{Body: io.NopCloser(bytes.NewBufferString(lastfmError6)), StatusCode: 200}
+ _, err := agent.GetArtistImages(ctx, "123", "Nonexistent Artist", "")
+ // Not a fault: runs of missing artists must not trip the worker's circuit breaker.
+ Expect(errors.Is(err, agents.ErrNotFound)).To(BeTrue())
+ })
+
It("returns empty list if image is the ignored default image", func() {
fApi, _ := os.Open("tests/fixtures/lastfm.artist.getinfo.json")
apiClient.Res = http.Response{Body: fApi, StatusCode: 200}
diff --git a/cmd/pls.go b/cmd/pls.go
index 95cbe4eec..184ca6fe7 100644
--- a/cmd/pls.go
+++ b/cmd/pls.go
@@ -12,7 +12,7 @@ import (
"strings"
"github.com/Masterminds/squirrel"
- "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
@@ -260,7 +260,7 @@ func runImport(ctx context.Context, files []string) {
ctx = request.WithUser(ctx, *user)
}
- pls := playlists.NewPlaylists(ds, core.NewImageUploadService())
+ pls := playlists.NewPlaylists(ds, artwork.NewUploader(ds))
for _, file := range files {
absPath, err := filepath.Abs(file)
diff --git a/cmd/root.go b/cmd/root.go
index d9e766c32..ff1641bd3 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -11,6 +11,7 @@ import (
"github.com/go-chi/chi/v5/middleware"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/db"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
@@ -88,6 +89,9 @@ func runNavidrome(ctx context.Context) {
g.Go(startInsightsCollector(ctx))
g.Go(scheduleDBAnalyzer(ctx))
g.Go(startPluginManager(ctx))
+ artworkWorker := CreateArtworkWorker()
+ g.Go(startArtworkWorker(ctx, artworkWorker))
+ g.Go(scheduleArtworkHousekeeping(ctx, artworkWorker))
g.Go(runInitialScan(ctx))
if conf.Server.Scanner.Enabled {
g.Go(startScanWatcher(ctx))
@@ -344,6 +348,68 @@ func startPlaybackServer(ctx context.Context) func() error {
}
}
+// startArtworkWorker starts the background artwork acquisition worker. It always
+// runs; the queue is simply empty until something enqueues work into it.
+func startArtworkWorker(ctx context.Context, worker *artwork.Worker) func() error {
+ return func() error {
+ log.Info(ctx, "Starting artwork worker")
+ return worker.Run(ctx)
+ }
+}
+
+// scheduleArtworkHousekeeping runs the startup fingerprint backfill and registers the
+// recurring stale-absent recheck and prune jobs.
+func scheduleArtworkHousekeeping(ctx context.Context, worker *artwork.Worker) func() error {
+ return func() error {
+ schedulerInstance := scheduler.GetInstance()
+
+ if _, err := schedulerInstance.Add(consts.ArtworkStaleAbsentRecheckSchedule, func() {
+ if err := worker.EnqueueStaleAbsentAll(ctx); err != nil {
+ log.Error(ctx, "Error enqueueing stale artwork rechecks", err)
+ }
+ if err := worker.EnqueueMissingAll(ctx); err != nil {
+ log.Error(ctx, "Error enqueueing missing artwork rechecks", err)
+ }
+ }); err != nil {
+ log.Error(ctx, "Error scheduling artwork stale-absent recheck", err)
+ }
+
+ if _, err := schedulerInstance.Add(consts.ArtworkPruneSchedule, func() {
+ if err := worker.RunPrune(ctx); err != nil {
+ log.Error(ctx, "Error running artwork prune", err)
+ }
+ }); err != nil {
+ log.Error(ctx, "Error scheduling artwork prune", err)
+ }
+
+ // Also run the missing-row recheck once at startup so a never-scanned entity is picked up
+ // immediately, not only on the next hourly tick (e.g. after enabling the feature).
+ if err := worker.EnqueueMissingAll(ctx); err != nil {
+ log.Error(ctx, "Error enqueueing missing artwork rechecks", err)
+ }
+
+ backfilled, err := worker.Backfill(ctx)
+ if err != nil {
+ log.Error(ctx, "Error running artwork backfill", err)
+ return nil
+ }
+ if !backfilled {
+ return nil
+ }
+ log.Info(ctx, "Artwork backfill enqueued, scheduling a follow-up prune")
+ timer := time.NewTimer(consts.ArtworkPostBackfillPruneDelay)
+ defer timer.Stop()
+ select {
+ case <-timer.C:
+ if err := worker.RunPrune(ctx); err != nil {
+ log.Error(ctx, "Error running post-backfill artwork prune", err)
+ }
+ case <-ctx.Done():
+ }
+ return nil
+ }
+}
+
// startPluginManager starts the plugin manager, if configured.
func startPluginManager(ctx context.Context) func() error {
return func() error {
diff --git a/cmd/scan.go b/cmd/scan.go
index 320b401d4..08eccbf2a 100644
--- a/cmd/scan.go
+++ b/cmd/scan.go
@@ -9,7 +9,7 @@ import (
"os"
"strings"
- "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/db"
"github.com/navidrome/navidrome/log"
@@ -82,7 +82,7 @@ func runScanner(ctx context.Context) {
sqlDB := db.Db()
defer db.Db().Close()
ds := persistence.New(sqlDB)
- pls := playlists.NewPlaylists(ds, core.NewImageUploadService())
+ pls := playlists.NewPlaylists(ds, artwork.NewUploader(ds))
// Parse targets from command line or file
var scanTargets []model.ScanTarget
diff --git a/cmd/wire_gen.go b/cmd/wire_gen.go
index c4a797ef4..4bdd48422 100644
--- a/cmd/wire_gen.go
+++ b/cmd/wire_gen.go
@@ -65,25 +65,18 @@ func CreateNativeAPIRouter(ctx context.Context) *nativeapi.Router {
sqlDB := db.Db()
dataStore := persistence.New(sqlDB)
share := core.NewShare(dataStore)
- imageUploadService := core.NewImageUploadService()
- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)
+ uploader := artwork.NewUploader(dataStore)
+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)
insights := metrics.GetInstance(dataStore)
- fileCache := artwork.GetImageCache()
- fFmpeg := ffmpeg.New()
broker := events.GetBroker()
metricsMetrics := metrics.GetPrometheusInstance(dataStore)
- manager := plugins.GetManager(dataStore, broker, metricsMetrics)
- agentsAgents := agents.GetAgents(dataStore, manager)
- matcherMatcher := matcher.New(dataStore)
- provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
- cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
- modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)
+ modelScanner := scanner.New(ctx, dataStore, broker, playlistsPlaylists, metricsMetrics)
watcher := scanner.GetWatcher(dataStore, modelScanner)
+ manager := plugins.GetManager(dataStore, broker, metricsMetrics)
library := core.NewLibrary(dataStore, modelScanner, watcher, broker, manager)
user := core.NewUser(dataStore, manager)
maintenance := core.NewMaintenance(dataStore)
- router := nativeapi.New(dataStore, share, playlistsPlaylists, insights, library, user, maintenance, manager, imageUploadService)
+ router := nativeapi.New(dataStore, share, playlistsPlaylists, insights, library, user, maintenance, manager, uploader)
return router
}
@@ -91,23 +84,23 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
sqlDB := db.Db()
dataStore := persistence.New(sqlDB)
fileCache := artwork.GetImageCache()
+ imageStore := artwork.GetImageStore()
fFmpeg := ffmpeg.New()
+ artworkArtwork := artwork.NewArtwork(dataStore, fileCache, imageStore, fFmpeg)
+ transcodingCache := stream.GetTranscodingCache()
+ mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
+ share := core.NewShare(dataStore)
+ archiver := core.NewArchiver(mediaStreamer, dataStore, share)
+ players := core.NewPlayers(dataStore)
broker := events.GetBroker()
metricsMetrics := metrics.GetPrometheusInstance(dataStore)
manager := plugins.GetManager(dataStore, broker, metricsMetrics)
agentsAgents := agents.GetAgents(dataStore, manager)
matcherMatcher := matcher.New(dataStore)
provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
- transcodingCache := stream.GetTranscodingCache()
- mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
- share := core.NewShare(dataStore)
- archiver := core.NewArchiver(mediaStreamer, dataStore, share)
- players := core.NewPlayers(dataStore)
- cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
- imageUploadService := core.NewImageUploadService()
- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)
- modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)
+ uploader := artwork.NewUploader(dataStore)
+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)
+ modelScanner := scanner.New(ctx, dataStore, broker, playlistsPlaylists, metricsMetrics)
playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
playbackServer := playback.GetInstance(dataStore)
lyricsLyrics := lyrics.NewLyrics(dataStore, manager)
@@ -121,21 +114,22 @@ func CreateJellyfinAPIRouter(ctx context.Context) *jellyfin.Router {
sqlDB := db.Db()
dataStore := persistence.New(sqlDB)
fileCache := artwork.GetImageCache()
+ imageStore := artwork.GetImageStore()
fFmpeg := ffmpeg.New()
+ artworkArtwork := artwork.NewArtwork(dataStore, fileCache, imageStore, fFmpeg)
+ transcodingCache := stream.GetTranscodingCache()
+ mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
+ transcodeDecider := stream.NewTranscodeDecider(dataStore, fFmpeg)
+ players := core.NewPlayers(dataStore)
broker := events.GetBroker()
metricsMetrics := metrics.GetPrometheusInstance(dataStore)
manager := plugins.GetManager(dataStore, broker, metricsMetrics)
+ playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
+ uploader := artwork.NewUploader(dataStore)
+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)
agentsAgents := agents.GetAgents(dataStore, manager)
matcherMatcher := matcher.New(dataStore)
provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
- transcodingCache := stream.GetTranscodingCache()
- mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
- transcodeDecider := stream.NewTranscodeDecider(dataStore, fFmpeg)
- players := core.NewPlayers(dataStore)
- playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
- imageUploadService := core.NewImageUploadService()
- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)
sonicSonic := sonic.New(dataStore, manager, matcherMatcher)
lyricsLyrics := lyrics.NewLyrics(dataStore, manager)
router := jellyfin.New(dataStore, artworkArtwork, mediaStreamer, transcodeDecider, players, playTracker, playlistsPlaylists, provider, sonicSonic, lyricsLyrics, broker)
@@ -146,14 +140,9 @@ func CreatePublicRouter() *public.Router {
sqlDB := db.Db()
dataStore := persistence.New(sqlDB)
fileCache := artwork.GetImageCache()
+ imageStore := artwork.GetImageStore()
fFmpeg := ffmpeg.New()
- broker := events.GetBroker()
- metricsMetrics := metrics.GetPrometheusInstance(dataStore)
- manager := plugins.GetManager(dataStore, broker, metricsMetrics)
- agentsAgents := agents.GetAgents(dataStore, manager)
- matcherMatcher := matcher.New(dataStore)
- provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
+ artworkArtwork := artwork.NewArtwork(dataStore, fileCache, imageStore, fFmpeg)
transcodingCache := stream.GetTranscodingCache()
mediaStreamer := stream.NewMediaStreamer(dataStore, fFmpeg, transcodingCache)
share := core.NewShare(dataStore)
@@ -193,38 +182,22 @@ func CreatePrometheus() metrics.Metrics {
func CreateScanner(ctx context.Context) model.Scanner {
sqlDB := db.Db()
dataStore := persistence.New(sqlDB)
- fileCache := artwork.GetImageCache()
- fFmpeg := ffmpeg.New()
broker := events.GetBroker()
+ uploader := artwork.NewUploader(dataStore)
+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)
metricsMetrics := metrics.GetPrometheusInstance(dataStore)
- manager := plugins.GetManager(dataStore, broker, metricsMetrics)
- agentsAgents := agents.GetAgents(dataStore, manager)
- matcherMatcher := matcher.New(dataStore)
- provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
- cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
- imageUploadService := core.NewImageUploadService()
- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)
- modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)
+ modelScanner := scanner.New(ctx, dataStore, broker, playlistsPlaylists, metricsMetrics)
return modelScanner
}
func CreateScanWatcher(ctx context.Context) scanner.Watcher {
sqlDB := db.Db()
dataStore := persistence.New(sqlDB)
- fileCache := artwork.GetImageCache()
- fFmpeg := ffmpeg.New()
broker := events.GetBroker()
+ uploader := artwork.NewUploader(dataStore)
+ playlistsPlaylists := playlists.NewPlaylists(dataStore, uploader)
metricsMetrics := metrics.GetPrometheusInstance(dataStore)
- manager := plugins.GetManager(dataStore, broker, metricsMetrics)
- agentsAgents := agents.GetAgents(dataStore, manager)
- matcherMatcher := matcher.New(dataStore)
- provider := external.NewProvider(dataStore, agentsAgents, matcherMatcher)
- artworkArtwork := artwork.NewArtwork(dataStore, fileCache, fFmpeg, provider)
- cacheWarmer := artwork.NewCacheWarmer(artworkArtwork, fileCache)
- imageUploadService := core.NewImageUploadService()
- playlistsPlaylists := playlists.NewPlaylists(dataStore, imageUploadService)
- modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlistsPlaylists, metricsMetrics)
+ modelScanner := scanner.New(ctx, dataStore, broker, playlistsPlaylists, metricsMetrics)
watcher := scanner.GetWatcher(dataStore, modelScanner)
return watcher
}
@@ -236,6 +209,20 @@ func GetPlaybackServer() playback.PlaybackServer {
return playbackServer
}
+func CreateArtworkWorker() *artwork.Worker {
+ sqlDB := db.Db()
+ dataStore := persistence.New(sqlDB)
+ imageStore := artwork.GetImageStore()
+ broker := events.GetBroker()
+ metricsMetrics := metrics.GetPrometheusInstance(dataStore)
+ manager := plugins.GetManager(dataStore, broker, metricsMetrics)
+ agentsAgents := agents.GetAgents(dataStore, manager)
+ fFmpeg := ffmpeg.New()
+ fileCache := artwork.GetImageCache()
+ worker := artwork.NewWorker(dataStore, imageStore, agentsAgents, fFmpeg, broker, fileCache)
+ return worker
+}
+
func getPluginManager() *plugins.Manager {
sqlDB := db.Db()
dataStore := persistence.New(sqlDB)
@@ -247,7 +234,7 @@ func getPluginManager() *plugins.Manager {
// wire_injectors.go:
-var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, jellyfin.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, metrics.GetPrometheusInstance, db.Db, plugins.GetManager, sonic.New, wire.Bind(new(agents.PluginLoader), new(*plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(*plugins.Manager)), wire.Bind(new(lyrics.PluginLoader), new(*plugins.Manager)), wire.Bind(new(sonic.PluginLoader), new(*plugins.Manager)), wire.Bind(new(sonic.Engine), new(*sonic.Sonic)), wire.Bind(new(nativeapi.PluginManager), new(*plugins.Manager)), wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)), wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)), wire.Bind(new(core.Watcher), new(scanner.Watcher)))
+var allProviders = wire.NewSet(core.Set, artwork.Set, server.New, subsonic.New, jellyfin.New, nativeapi.New, public.New, persistence.New, lastfm.NewRouter, listenbrainz.NewRouter, events.GetBroker, scanner.New, scanner.GetWatcher, metrics.GetPrometheusInstance, db.Db, plugins.GetManager, sonic.New, wire.Bind(new(agents.PluginLoader), new(*plugins.Manager)), wire.Bind(new(scrobbler.PluginLoader), new(*plugins.Manager)), wire.Bind(new(lyrics.PluginLoader), new(*plugins.Manager)), wire.Bind(new(sonic.PluginLoader), new(*plugins.Manager)), wire.Bind(new(sonic.Engine), new(*sonic.Sonic)), wire.Bind(new(nativeapi.PluginManager), new(*plugins.Manager)), wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)), wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)), wire.Bind(new(core.Watcher), new(scanner.Watcher)), wire.Bind(new(playlists.ImageUploadService), new(artwork.Uploader)))
func GetPluginManager(ctx context.Context) *plugins.Manager {
manager := getPluginManager()
diff --git a/cmd/wire_injectors.go b/cmd/wire_injectors.go
index 94faa5af3..ae24b61fa 100644
--- a/cmd/wire_injectors.go
+++ b/cmd/wire_injectors.go
@@ -14,6 +14,7 @@ import (
"github.com/navidrome/navidrome/core/lyrics"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playback"
+ "github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/core/scrobbler"
"github.com/navidrome/navidrome/core/sonic"
"github.com/navidrome/navidrome/db"
@@ -56,6 +57,7 @@ var allProviders = wire.NewSet(
wire.Bind(new(core.PluginUnloader), new(*plugins.Manager)),
wire.Bind(new(plugins.PluginMetricsRecorder), new(metrics.Metrics)),
wire.Bind(new(core.Watcher), new(scanner.Watcher)),
+ wire.Bind(new(playlists.ImageUploadService), new(artwork.Uploader)),
)
func CreateDataStore() model.DataStore {
@@ -136,6 +138,12 @@ func GetPlaybackServer() playback.PlaybackServer {
))
}
+func CreateArtworkWorker() *artwork.Worker {
+ panic(wire.Build(
+ allProviders,
+ ))
+}
+
func getPluginManager() *plugins.Manager {
panic(wire.Build(
allProviders,
diff --git a/conf/configuration.go b/conf/configuration.go
index 9b49fb264..5122b15eb 100644
--- a/conf/configuration.go
+++ b/conf/configuration.go
@@ -144,6 +144,8 @@ type configOptions struct {
DevArtworkThrottleBacklogLimit int
DevArtworkThrottleBacklogTimeout time.Duration
DevArtworkThrottleBuffered bool
+ DevArtworkWorkerConcurrency int
+ DevArtworkExternalMaxRPS int
DevArtistInfoTimeToLive time.Duration
DevAlbumInfoTimeToLive time.Duration
DevExternalScanner bool
@@ -1071,6 +1073,12 @@ func setViperDefaults() {
viper.SetDefault("devartworkthrottlebackloglimit", consts.RequestThrottleBacklogLimit)
viper.SetDefault("devartworkthrottlebacklogtimeout", consts.RequestThrottleBacklogTimeout)
viper.SetDefault("devartworkthrottlebuffered", true)
+ // Half the CPU count (min 2), so local resolution scales with the host but stays under the
+ // SQLite pool (MaxOpenConns) — leaving connections for the scanner, scrobbles and the UI.
+ viper.SetDefault("devartworkworkerconcurrency", max(2, runtime.NumCPU()/2))
+ // External RPS gates outbound calls to third-party services (per service); it is bounded by
+ // their tolerance, not the host, so it stays a small constant regardless of CPU count.
+ viper.SetDefault("devartworkexternalmaxrps", 2)
viper.SetDefault("devartistinfotimetolive", consts.ArtistInfoTimeToLive)
viper.SetDefault("devalbuminfotimetolive", consts.AlbumInfoTimeToLive)
viper.SetDefault("devexternalscanner", true)
diff --git a/consts/consts.go b/consts/consts.go
index e1a535c79..46906b8b5 100644
--- a/consts/consts.go
+++ b/consts/consts.go
@@ -24,6 +24,9 @@ const (
LastDBAnalyzeAttemptAtKey = "LastDBAnalyzeAttemptAt"
DBAnalyzePendingKey = "DBAnalyzePending"
DBAnalyzeFailureCountKey = "DBAnalyzeFailureCount"
+ // ArtConfFingerprintPropertyKey is the model.PropertyRepository key Backfill compares against
+ // to detect artwork-affecting config changes across restarts.
+ ArtConfFingerprintPropertyKey = "ArtConfFingerprint"
UIAuthorizationHeader = "X-ND-Authorization"
UIClientUniqueIDHeader = "X-ND-Client-Unique-Id"
@@ -36,6 +39,10 @@ const (
DBAnalyzeCheckSchedule = "@every 30m"
DBAnalyzeMaxAge = 24 * time.Hour
+ ArtworkStaleAbsentRecheckSchedule = "@every 1h"
+ ArtworkPruneSchedule = "@daily"
+ ArtworkPostBackfillPruneDelay = 10 * time.Minute
+
// DefaultEncryptionKey This is the encryption key used if none is specified in the `PasswordEncryptionKey` option
// Never ever change this! Or it will break all Navidrome installations that don't set the config option
DefaultEncryptionKey = "just for obfuscation"
@@ -80,6 +87,9 @@ const (
I18nFolder = "i18n"
ScanIgnoreFile = ".ndignore"
ArtworkFolder = "artwork"
+ // HashedArtworkFolder is a subtree of ArtworkFolder, kept apart from the name-addressed
+ // upload folders beside it so Prune's sweep never reaches them.
+ HashedArtworkFolder = "hashed"
PlaceholderArtistArt = "artist-placeholder.webp"
PlaceholderAlbumArt = "album-placeholder.webp"
diff --git a/core/agents/agents.go b/core/agents/agents.go
index ead6dacd0..348f7d4e7 100644
--- a/core/agents/agents.go
+++ b/core/agents/agents.go
@@ -124,6 +124,42 @@ func (a *Agents) AgentName() string {
return "agents"
}
+// ArtistImageAgent pairs an enabled agent's name with its ArtistImageRetriever capability.
+type ArtistImageAgent struct {
+ Name string
+ Retriever ArtistImageRetriever
+}
+
+// AlbumImageAgent pairs an enabled agent's name with its AlbumImageRetriever capability.
+type AlbumImageAgent struct {
+ Name string
+ Retriever AlbumImageRetriever
+}
+
+// ArtistImageAgents returns the enabled agents implementing ArtistImageRetriever,
+// in conf.Server.Agents order (same order the aggregate dispatch uses).
+func (a *Agents) ArtistImageAgents() []ArtistImageAgent {
+ var result []ArtistImageAgent
+ for _, ea := range a.getEnabledAgentNames() {
+ if retriever, ok := a.getAgent(ea).(ArtistImageRetriever); ok {
+ result = append(result, ArtistImageAgent{Name: ea.name, Retriever: retriever})
+ }
+ }
+ return result
+}
+
+// AlbumImageAgents returns the enabled agents implementing AlbumImageRetriever,
+// in conf.Server.Agents order (same order the aggregate dispatch uses).
+func (a *Agents) AlbumImageAgents() []AlbumImageAgent {
+ var result []AlbumImageAgent
+ for _, ea := range a.getEnabledAgentNames() {
+ if retriever, ok := a.getAgent(ea).(AlbumImageRetriever); ok {
+ result = append(result, AlbumImageAgent{Name: ea.name, Retriever: retriever})
+ }
+ }
+ return result
+}
+
func (a *Agents) GetArtistMBID(ctx context.Context, id string, name string) (string, error) {
switch id {
case consts.UnknownArtistID:
diff --git a/core/agents/agents_test.go b/core/agents/agents_test.go
index 50285a084..e3087f995 100644
--- a/core/agents/agents_test.go
+++ b/core/agents/agents_test.go
@@ -362,6 +362,64 @@ var _ = Describe("Agents", func() {
})
})
})
+
+ Describe("Image retriever enumeration", func() {
+ var ag *Agents
+ var artistImg, artistImg2 *testImageAgent
+ var albumImg, albumImg2 *testAlbumImageAgent
+
+ BeforeEach(func() {
+ artistImg = &testImageAgent{Name: "artistImg"}
+ artistImg2 = &testImageAgent{Name: "artistImg2"}
+ albumImg = &testAlbumImageAgent{name: "albumImg"}
+ albumImg2 = &testAlbumImageAgent{name: "albumImg2"}
+ Register("artistImg", func(model.DataStore) Interface { return artistImg })
+ Register("artistImg2", func(model.DataStore) Interface { return artistImg2 })
+ Register("albumImg", func(model.DataStore) Interface { return albumImg })
+ Register("albumImg2", func(model.DataStore) Interface { return albumImg2 })
+ Register("noImages", func(model.DataStore) Interface { return &emptyAgent{} })
+ })
+
+ Describe("ArtistImageAgents", func() {
+ It("returns only ArtistImageRetriever agents, named, in configured order", func() {
+ conf.Server.Agents = "artistImg,noImages,artistImg2"
+ ag = createAgents(ds, nil)
+
+ result := ag.ArtistImageAgents()
+ Expect(result).To(HaveLen(2))
+ Expect(result[0].Name).To(Equal("artistImg"))
+ Expect(result[0].Retriever).To(BeIdenticalTo(artistImg))
+ Expect(result[1].Name).To(Equal("artistImg2"))
+ Expect(result[1].Retriever).To(BeIdenticalTo(artistImg2))
+ })
+
+ It("is empty when external services are disabled", func() {
+ conf.Server.Agents = "" // what disableExternalServices() sets when EnableExternalServices=false
+ ag = createAgents(ds, nil)
+ Expect(ag.ArtistImageAgents()).To(BeEmpty())
+ })
+ })
+
+ Describe("AlbumImageAgents", func() {
+ It("returns only AlbumImageRetriever agents, named, in configured order", func() {
+ conf.Server.Agents = "albumImg,noImages,albumImg2"
+ ag = createAgents(ds, nil)
+
+ result := ag.AlbumImageAgents()
+ Expect(result).To(HaveLen(2))
+ Expect(result[0].Name).To(Equal("albumImg"))
+ Expect(result[0].Retriever).To(BeIdenticalTo(albumImg))
+ Expect(result[1].Name).To(Equal("albumImg2"))
+ Expect(result[1].Retriever).To(BeIdenticalTo(albumImg2))
+ })
+
+ It("is empty when external services are disabled", func() {
+ conf.Server.Agents = "" // what disableExternalServices() sets when EnableExternalServices=false
+ ag = createAgents(ds, nil)
+ Expect(ag.AlbumImageAgents()).To(BeEmpty())
+ })
+ })
+ })
})
type mockAgent struct {
@@ -497,3 +555,17 @@ func (t *testImageAgent) GetArtistImages(_ context.Context, id, name, mbid strin
t.Args = []any{id, name, mbid}
return t.Images, t.Err
}
+
+type testAlbumImageAgent struct {
+ name string
+ Images []ExternalImage
+ Err error
+ Args []any
+}
+
+func (t *testAlbumImageAgent) AgentName() string { return t.name }
+
+func (t *testAlbumImageAgent) GetAlbumImages(_ context.Context, name, artist, mbid string) ([]ExternalImage, error) {
+ t.Args = []any{name, artist, mbid}
+ return t.Images, t.Err
+}
diff --git a/core/artwork/agent_images.go b/core/artwork/agent_images.go
new file mode 100644
index 000000000..c7032b62b
--- /dev/null
+++ b/core/artwork/agent_images.go
@@ -0,0 +1,100 @@
+package artwork
+
+import (
+ "context"
+ "io"
+ "net/url"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils/str"
+)
+
+// externalName mirrors the normalization the aggregate provider applies, so agent searches match.
+func externalName(name string) string {
+ if conf.Server.DevPreserveUnicodeInExternalCalls {
+ return name
+ }
+ return str.Clear(name)
+}
+
+// bestImageURL returns the largest fetchable image URL. Only one is returned and its failure ends
+// the agent's turn, so an unfetchable candidate must never win: url.Parse alone accepts anything.
+func bestImageURL(imgs []agents.ExternalImage) *url.URL {
+ var best *url.URL
+ var bestSize int
+ for i := range imgs {
+ if imgs[i].URL == "" {
+ continue
+ }
+ u, err := url.Parse(imgs[i].URL)
+ if err != nil || !u.IsAbs() || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" {
+ continue
+ }
+ if best == nil || imgs[i].Size > bestSize {
+ best, bestSize = u, imgs[i].Size
+ }
+ }
+ return best
+}
+
+// fetchArtistImage tries each enabled artist-image agent in order. extErr is true only when no
+// agent succeeded and at least one failed transiently.
+func fetchArtistImage(ctx context.Context, ag *agents.Agents, gate gateFunc, ar model.Artist) (r io.ReadCloser, agentName string, extErr bool) {
+ // Synthetic artists would otherwise get an unrelated agent result assigned to them.
+ switch ar.ID {
+ case consts.UnknownArtistID, consts.VariousArtistsID:
+ return nil, "", false
+ }
+ name := externalName(ar.Name)
+ for _, a := range ag.ArtistImageAgents() {
+ reader, _, err := gate(a.Name, func() (io.ReadCloser, string, error) {
+ imgs, err := a.Retriever.GetArtistImages(ctx, ar.ID, name, ar.MbzArtistID)
+ if err != nil {
+ return nil, "", err
+ }
+ u := bestImageURL(imgs)
+ if u == nil {
+ return nil, "", agents.ErrNotFound
+ }
+ return fromURL(ctx, u)
+ })
+ if reader != nil {
+ return reader, a.Name, false
+ }
+ if isTransientExternal(err) {
+ extErr = true
+ log.Debug(ctx, "Artwork: External artist-image lookup failed", "agent", a.Name, "artist", ar.Name, err)
+ }
+ }
+ return nil, "", extErr
+}
+
+// fetchAlbumImage is the album counterpart of fetchArtistImage.
+func fetchAlbumImage(ctx context.Context, ag *agents.Agents, gate gateFunc, al model.Album) (r io.ReadCloser, agentName string, extErr bool) {
+ name, artist := externalName(al.Name), externalName(al.AlbumArtist)
+ for _, a := range ag.AlbumImageAgents() {
+ reader, _, err := gate(a.Name, func() (io.ReadCloser, string, error) {
+ imgs, err := a.Retriever.GetAlbumImages(ctx, name, artist, al.MbzAlbumID)
+ if err != nil {
+ return nil, "", err
+ }
+ u := bestImageURL(imgs)
+ if u == nil {
+ return nil, "", agents.ErrNotFound
+ }
+ return fromURL(ctx, u)
+ })
+ if reader != nil {
+ return reader, a.Name, false
+ }
+ if isTransientExternal(err) {
+ extErr = true
+ log.Debug(ctx, "Artwork: External album-image lookup failed", "agent", a.Name, "album", al.Name, err)
+ }
+ }
+ return nil, "", extErr
+}
diff --git a/core/artwork/agent_images_test.go b/core/artwork/agent_images_test.go
new file mode 100644
index 000000000..716245c93
--- /dev/null
+++ b/core/artwork/agent_images_test.go
@@ -0,0 +1,262 @@
+package artwork
+
+import (
+ "context"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "sync"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ "github.com/navidrome/navidrome/utils/str"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// fakeImageAgent is a built-in agent stub implementing both image retrievers; it
+// records call counts so per-agent ordering and short-circuiting can be asserted.
+type fakeImageAgent struct {
+ name string
+ imgs []agents.ExternalImage
+ err error
+ artistCalls int
+ albumCalls int
+ gotArtistName string
+ gotAlbumName string
+ // block, when set, holds every lookup until closed, standing in for a slow/rate-limited agent.
+ block chan struct{}
+ // mu guards the call counters: the worker resolves several items concurrently.
+ mu sync.Mutex
+}
+
+func (f *fakeImageAgent) AgentName() string { return f.name }
+
+func (f *fakeImageAgent) GetArtistImages(_ context.Context, _, name, _ string) ([]agents.ExternalImage, error) {
+ if f.block != nil {
+ <-f.block
+ }
+ f.mu.Lock()
+ f.artistCalls++
+ f.gotArtistName = name
+ f.mu.Unlock()
+ return f.imgs, f.err
+}
+
+func (f *fakeImageAgent) GetAlbumImages(_ context.Context, name, _, _ string) ([]agents.ExternalImage, error) {
+ f.albumCalls++
+ f.gotAlbumName = name
+ return f.imgs, f.err
+}
+
+// imageAgents registers the fakes as built-in agents and enables them in order. The fakes
+// ignore the DataStore, so reusing the process-wide GetAgents singleton across tests is safe.
+func imageAgents(fakes ...*fakeImageAgent) *agents.Agents {
+ names := make([]string, 0, len(fakes))
+ for _, f := range fakes {
+ fake := f
+ agents.Register(fake.name, func(model.DataStore) agents.Interface { return fake })
+ names = append(names, fake.name)
+ }
+ conf.Server.Agents = strings.Join(names, ",")
+ return agents.GetAgents(&tests.MockDataStore{}, nil)
+}
+
+var _ = Describe("agent images", func() {
+ var (
+ ctx context.Context
+ srv *httptest.Server
+ )
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ ctx = context.Background()
+ srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ _, _ = w.Write([]byte("image-bytes"))
+ }))
+ DeferCleanup(srv.Close)
+ })
+
+ img := func(path string, size int) agents.ExternalImage {
+ return agents.ExternalImage{URL: srv.URL + path, Size: size}
+ }
+
+ Describe("bestImageURL", func() {
+ It("picks the largest-Size URL and skips empty ones", func() {
+ u := bestImageURL([]agents.ExternalImage{
+ {URL: "http://x/small", Size: 10},
+ {URL: "", Size: 9999},
+ {URL: "http://x/big", Size: 100},
+ })
+ Expect(u).ToNot(BeNil())
+ Expect(u.String()).To(Equal("http://x/big"))
+ })
+
+ It("skips a malformed largest URL and falls back to a valid smaller one", func() {
+ u := bestImageURL([]agents.ExternalImage{
+ {URL: "http://x/valid", Size: 10},
+ {URL: "http://x/%zz", Size: 100}, // invalid percent-escape, largest
+ })
+ Expect(u).ToNot(BeNil())
+ Expect(u.String()).To(Equal("http://x/valid"))
+ })
+
+ It("returns nil when there is no non-empty URL", func() {
+ Expect(bestImageURL(nil)).To(BeNil())
+ Expect(bestImageURL([]agents.ExternalImage{{URL: "", Size: 5}})).To(BeNil())
+ })
+
+ // Plugins hand these over as free-form strings, and url.Parse accepts them all. An
+ // unfetchable candidate that wins here ends the agent's turn before its valid images run.
+ DescribeTable("skips a candidate that cannot be fetched",
+ func(badURL string) {
+ u := bestImageURL([]agents.ExternalImage{
+ {URL: badURL, Size: 100}, // largest, and first
+ {URL: "https://cdn.example.com/ok.jpg", Size: 10},
+ })
+ Expect(u).ToNot(BeNil())
+ Expect(u.String()).To(Equal("https://cdn.example.com/ok.jpg"))
+ },
+ Entry("a relative path", "images/big.jpg"),
+ Entry("a root-relative path", "/images/big.jpg"),
+ Entry("a scheme we cannot fetch", "ftp://host/big.jpg"),
+ Entry("a scheme-relative URL", "//host/big.jpg"),
+ Entry("a URL with no host", "http:///big.jpg"),
+ )
+
+ // Size is often 0 for every candidate, and only a strictly larger one replaces the first,
+ // so an unfetchable entry in first position would otherwise stick.
+ It("skips an unfetchable first candidate when every Size is zero", func() {
+ u := bestImageURL([]agents.ExternalImage{
+ {URL: "images/rel.jpg"},
+ {URL: "https://cdn.example.com/ok.jpg"},
+ })
+ Expect(u).ToNot(BeNil())
+ Expect(u.String()).To(Equal("https://cdn.example.com/ok.jpg"))
+ })
+
+ It("returns nil when no candidate is fetchable", func() {
+ Expect(bestImageURL([]agents.ExternalImage{
+ {URL: "images/a.jpg", Size: 10},
+ {URL: "ftp://host/b.jpg", Size: 20},
+ })).To(BeNil())
+ })
+ })
+
+ Describe("fetchArtistImage", func() {
+ It("returns the first agent's image and its name", func() {
+ a := &fakeImageAgent{name: "agentA", imgs: []agents.ExternalImage{img("/a", 100)}}
+ ag := imageAgents(a)
+
+ r, name, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1", Name: "Artist"})
+ Expect(r).ToNot(BeNil())
+ defer r.Close()
+ Expect(name).To(Equal("agentA"))
+ Expect(extErr).To(BeFalse())
+ })
+
+ It("skips the external lookup for synthetic artists", func() {
+ a := &fakeImageAgent{name: "agentA", imgs: []agents.ExternalImage{img("/a", 100)}}
+ ag := imageAgents(a)
+
+ for _, id := range []string{consts.UnknownArtistID, consts.VariousArtistsID} {
+ r, name, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: id, Name: "Various Artists"})
+ Expect(r).To(BeNil())
+ Expect(name).To(BeEmpty())
+ Expect(extErr).To(BeFalse())
+ }
+ Expect(a.artistCalls).To(Equal(0), "synthetic artists never reach the agents")
+ })
+
+ It("clears typographic characters from the query name unless preserving unicode", func() {
+ conf.Server.DevPreserveUnicodeInExternalCalls = false
+ a := &fakeImageAgent{name: "agentA"}
+ ag := imageAgents(a)
+
+ _, _, _ = fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1", Name: "AC’DC"})
+ Expect(a.gotArtistName).To(Equal(str.Clear("AC’DC")))
+ })
+
+ It("falls through to a later agent, and its success beats the earlier error", func() {
+ a := &fakeImageAgent{name: "agentA", err: errBreakerOpen}
+ b := &fakeImageAgent{name: "agentB", imgs: []agents.ExternalImage{img("/b", 50)}}
+ ag := imageAgents(a, b)
+
+ r, name, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1"})
+ Expect(r).ToNot(BeNil())
+ defer r.Close()
+ Expect(name).To(Equal("agentB"))
+ Expect(extErr).To(BeFalse(), "a later hit clears an earlier agent's error")
+ Expect(a.artistCalls).To(Equal(1))
+ Expect(b.artistCalls).To(Equal(1))
+ })
+
+ It("reports a clean miss when every agent finds nothing", func() {
+ a := &fakeImageAgent{name: "agentA"} // no images, no error -> not found
+ b := &fakeImageAgent{name: "agentB", err: agents.ErrNotFound}
+ ag := imageAgents(a, b)
+
+ r, name, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1"})
+ Expect(r).To(BeNil())
+ Expect(name).To(BeEmpty())
+ Expect(extErr).To(BeFalse(), "not-found is definitive, never a transient failure")
+ })
+
+ It("reports extErr when one agent fails transiently and the rest find nothing", func() {
+ a := &fakeImageAgent{name: "agentA", err: agents.ErrNotFound}
+ b := &fakeImageAgent{name: "agentB", err: context.DeadlineExceeded}
+ ag := imageAgents(a, b)
+
+ r, _, extErr := fetchArtistImage(ctx, ag, passthroughGate, model.Artist{ID: "ar1"})
+ Expect(r).To(BeNil())
+ Expect(extErr).To(BeTrue())
+ })
+ })
+
+ Describe("fetchAlbumImage", func() {
+ It("returns the winning agent's image and name", func() {
+ a := &fakeImageAgent{name: "agentA", imgs: []agents.ExternalImage{img("/a", 100)}}
+ ag := imageAgents(a)
+
+ r, name, extErr := fetchAlbumImage(ctx, ag, passthroughGate, model.Album{Name: "Album", AlbumArtist: "Artist"})
+ Expect(r).ToNot(BeNil())
+ defer r.Close()
+ Expect(name).To(Equal("agentA"))
+ Expect(extErr).To(BeFalse())
+ Expect(a.albumCalls).To(Equal(1))
+ })
+
+ It("reports extErr when the only agent fails transiently", func() {
+ a := &fakeImageAgent{name: "agentA", err: context.DeadlineExceeded}
+ ag := imageAgents(a)
+
+ r, _, extErr := fetchAlbumImage(ctx, ag, passthroughGate, model.Album{Name: "Album"})
+ Expect(r).To(BeNil())
+ Expect(extErr).To(BeTrue())
+ })
+ })
+
+ Describe("gate naming", func() {
+ It("invokes the gate once per agent, keyed by agent name", func() {
+ a := &fakeImageAgent{name: "agentA", err: context.DeadlineExceeded}
+ b := &fakeImageAgent{name: "agentB", imgs: []agents.ExternalImage{img("/b", 1)}}
+ ag := imageAgents(a, b)
+
+ var gatedNames []string
+ gate := func(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {
+ gatedNames = append(gatedNames, name)
+ return f()
+ }
+
+ r, _, _ := fetchArtistImage(ctx, ag, gate, model.Artist{ID: "ar1"})
+ Expect(r).ToNot(BeNil())
+ defer r.Close()
+ Expect(gatedNames).To(Equal([]string{"agentA", "agentB"}))
+ })
+ })
+})
diff --git a/core/artwork/artwork.go b/core/artwork/artwork.go
index b8c395c12..8ac8d9c9d 100644
--- a/core/artwork/artwork.go
+++ b/core/artwork/artwork.go
@@ -1,134 +1,394 @@
package artwork
import (
+ "bytes"
"context"
"errors"
- _ "image/gif"
+ "fmt"
"io"
+ "os"
"time"
+ "github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/external"
"github.com/navidrome/navidrome/core/ffmpeg"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/resources"
"github.com/navidrome/navidrome/utils/cache"
- _ "golang.org/x/image/webp"
)
var ErrUnavailable = errors.New("artwork unavailable")
+// errStaleSource means the backing file's mtime no longer matches RefMtime, so the stored hash may be stale.
+var errStaleSource = errors.New("artwork: source file changed since resolution")
+
+// Image is one servable artwork response.
+type Image struct {
+ io.ReadCloser
+ Hash string // pixel identity; "" for placeholders
+ ETag string // representation validator; "" means Hash applies (full-size original)
+ LastUpdated time.Time
+ Placeholder bool
+}
+
+// representationTag varies with dimensions and encode settings, so a config change invalidates
+// a revalidating client's cache even though the pixel hash is unchanged.
+func representationTag(hash string, size int, square bool) string {
+ return fmt.Sprintf("%s.%d.%v.%s", hash, size, square, formatQualityTag())
+}
+
type Artwork interface {
- Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (io.ReadCloser, time.Time, error)
- GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error)
+ // Get returns ErrUnavailable when there is nothing to serve and model.ErrNotFound when
+ // the id resolves to nothing, so the caller can pick placeholder vs 404.
+ Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error)
+ // GetOrPlaceholder accepts an artwork token or a raw entity id, falling back to the
+ // kind's placeholder image (never resized, Placeholder=true).
+ GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (*Image, error)
}
-func NewArtwork(ds model.DataStore, cache cache.FileCache, ffmpeg ffmpeg.FFmpeg, provider external.Provider) Artwork {
- return &artwork{ds: ds, cache: cache, ffmpeg: ffmpeg, provider: provider}
+func NewArtwork(ds model.DataStore, cache cache.FileCache, store *ImageStore, ffm ffmpeg.FFmpeg) Artwork {
+ return &service{ds: ds, cache: cache, store: store, ffmpeg: ffm}
}
-type artwork struct {
- ds model.DataStore
- cache cache.FileCache
- ffmpeg ffmpeg.FFmpeg
- provider external.Provider
+// entityExists reports whether the entity an artwork id points at is still there: state rows
+// outlive a deleted entity until the next prune, so a servable row is not evidence of its owner.
+func entityExists(ctx context.Context, ds model.DataStore, artID model.ArtworkID) bool {
+ var found bool
+ var err error
+ switch artID.Kind {
+ case model.KindArtistArtwork:
+ found, err = ds.Artist(ctx).Exists(artID.ID)
+ case model.KindAlbumArtwork:
+ found, err = ds.Album(ctx).Exists(artID.ID)
+ case model.KindMediaFileArtwork:
+ found, err = ds.MediaFile(ctx).Exists(artID.ID)
+ case model.KindPlaylistArtwork:
+ found, err = ds.Playlist(ctx).Exists(artID.ID)
+ case model.KindRadioArtwork:
+ found, err = ds.Radio(ctx).Exists(artID.ID)
+ case model.KindDiscArtwork:
+ albumID, _, perr := model.ParseDiscArtworkID(artID.ID)
+ if perr != nil {
+ return false
+ }
+ found, err = ds.Album(ctx).Exists(albumID)
+ default:
+ return false
+ }
+ return err == nil && found
}
-type artworkReader interface {
- cache.Item
- LastUpdated() time.Time
- Reader(ctx context.Context) (io.ReadCloser, string, error)
+type service struct {
+ ds model.DataStore
+ cache cache.FileCache
+ store *ImageStore
+ ffmpeg ffmpeg.FFmpeg
}
-func (a *artwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (reader io.ReadCloser, lastUpdate time.Time, err error) {
- artID, err := a.getArtworkId(ctx, id)
+func (s *service) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (*Image, error) {
+ artID, err := s.parseArtworkID(ctx, id)
+ var img *Image
if err == nil {
- reader, lastUpdate, err = a.Get(ctx, artID, size, square)
+ img, err = s.Get(ctx, artID, size, square)
}
+ // Only a resolvable entity with no art gets a placeholder; an unknown id must stay
+ // ErrNotFound so callers can still answer 404 / Subsonic error 70.
if errors.Is(err, ErrUnavailable) {
- if artID.Kind == model.KindArtistArtwork {
- reader, _ = resources.FS().Open(consts.PlaceholderArtistArt)
- } else {
- reader, _ = resources.FS().Open(consts.PlaceholderAlbumArt)
+ return placeholderImage(artID.Kind), nil
+ }
+ return img, err
+}
+
+func (s *service) Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {
+ if artID.ID == "" {
+ return nil, ErrUnavailable
+ }
+ if size < 0 {
+ size = 0 // a negative size means full-size, not a giant (OOM) resize rectangle
+ }
+ switch artID.Kind {
+ case model.KindDiscArtwork:
+ return s.serveDisc(ctx, artID, size, square)
+ case model.KindMediaFileArtwork:
+ return s.serveMediaFile(ctx, artID, size, square)
+ default:
+ return s.serveEntity(ctx, artID, size, square)
+ }
+}
+
+// requestRecheckAge throttles view-triggered rechecks so reopening a genuinely-absent page can't
+// hammer external services; below staleAbsentAge to catch younger absences.
+const requestRecheckAge = time.Hour
+
+func (s *service) serveEntity(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {
+ ia, err := s.ds.Artwork(ctx).GetItemArtwork(artID.Kind, artID.ID, model.ImageTypePrimary)
+ switch {
+ case errors.Is(err, model.ErrNotFound):
+ return s.provisional(ctx, artID, size, square)
+ case err != nil:
+ return nil, err
+ case ia.Hash == "":
+ // Inserts an immediately-eligible recheck for a settled absent row.
+ if time.Since(ia.AttemptedAt) > requestRecheckAge {
+ s.enqueue(ctx, artID, model.ArtworkPriorityBump)
+ }
+ return nil, ErrUnavailable
+ default:
+ return s.serveHash(ctx, artID, ia, size, square)
+ }
+}
+
+// serveSource is the one place bytes become an Image. hash is the pixel identity ("" for disc art)
+// and doubles as the full-size validator, so an ETag is only needed when resized or hash is "".
+func (s *service) serveSource(ctx context.Context, key, hash string, lastUpdate time.Time,
+ size int, square bool, open func() (io.ReadCloser, error),
+) (*Image, error) {
+ if size == 0 && !square {
+ rc, err := open()
+ if err != nil {
+ return nil, err
+ }
+ if rc == nil {
+ return nil, ErrUnavailable
+ }
+ img := &Image{ReadCloser: rc, Hash: hash, LastUpdated: lastUpdate}
+ if hash == "" {
+ img.ETag = representationTag(key, size, square)
+ }
+ return img, nil
+ }
+ stream, err := s.cache.Get(ctx, &resizedItem{
+ hash: key, size: size, square: square, ffmpeg: s.ffmpeg, open: open,
+ })
+ if err != nil {
+ return nil, err
+ }
+ return &Image{ReadCloser: stream, Hash: hash, ETag: representationTag(key, size, square), LastUpdated: lastUpdate}, nil
+}
+
+// serveHash serves the bytes of a found state row. A mismatch/open error is dangling, but a
+// cancelled request is not: it must not enqueue a re-resolution.
+func (s *service) serveHash(ctx context.Context, artID model.ArtworkID, ia *model.ItemArtwork, size int, square bool) (*Image, error) {
+ // Only this path can hand back a deleted entity's bytes; the others load their entity anyway.
+ if !entityExists(ctx, s.ds, artID) {
+ return nil, ErrUnavailable
+ }
+ art, err := s.ds.Artwork(ctx).GetImage(ia.Hash)
+ if err != nil {
+ if errors.Is(err, model.ErrNotFound) {
+ return s.dangling(ctx, artID)
+ }
+ return nil, err
+ }
+ img, err := s.serveSource(ctx, ia.Hash, ia.Hash, ia.UpdatedAt, size, square,
+ func() (io.ReadCloser, error) { return openOriginal(ia, art.Mime, s.store) })
+ if err != nil {
+ if errors.Is(err, context.Canceled) {
+ return nil, err
+ }
+ log.Warn(ctx, "Artwork: Could not serve image", "artID", artID, "size", size, err)
+ return s.dangling(ctx, artID)
+ }
+ return img, nil
+}
+
+// openOriginal enforces the mtime invariant: bytes are never served under a hash they no longer match.
+func openOriginal(ia *model.ItemArtwork, mime string, store *ImageStore) (io.ReadCloser, error) {
+ if isFileBacked(ia.Source) {
+ f, err := os.Open(ia.SourcePath)
+ if err != nil {
+ return nil, err
+ }
+ info, err := f.Stat()
+ if err != nil {
+ f.Close()
+ return nil, err
+ }
+ if ia.RefMtime != 0 && info.ModTime().UnixNano() != ia.RefMtime {
+ f.Close()
+ log.Debug("Artwork: Backing file changed since resolution", "path", ia.SourcePath,
+ "hash", ia.Hash, "resolvedMtime", ia.RefMtime, "currentMtime", info.ModTime().UnixNano())
+ return nil, errStaleSource
+ }
+ return f, nil
+ }
+ // Store-backed bytes still carry the source's mtime, to detect edits to embedded art.
+ if ia.SourcePath != "" && ia.RefMtime != 0 {
+ info, err := os.Stat(ia.SourcePath)
+ if err != nil {
+ return nil, err
+ }
+ if info.ModTime().UnixNano() != ia.RefMtime {
+ log.Debug("Artwork: Source file changed since resolution", "path", ia.SourcePath,
+ "hash", ia.Hash, "resolvedMtime", ia.RefMtime, "currentMtime", info.ModTime().UnixNano())
+ return nil, errStaleSource
}
- return reader, consts.ServerStart, nil
}
- return reader, lastUpdate, err
+ return store.Open(ia.Hash, mime)
+}
+
+// provisional serves local bytes for an entity with no state row, enqueuing the worker but
+// never writing a state row itself.
+func (s *service) provisional(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {
+ item := model.ArtworkQueueItem{ItemKind: artID.Kind.Prefix(), ItemID: artID.ID, ImageType: model.ImageTypePrimary}
+ res, err := newLocalResolver(s.ds, s.ffmpeg).resolve(ctx, item)
+ if err != nil {
+ return nil, err
+ }
+ s.enqueue(ctx, artID, model.ArtworkPriorityBump)
+ log.Debug(ctx, "Artwork: Provisional read-through, no state row yet", "artID", artID,
+ "source", res.source, "hit", res.reader != nil)
+ return s.serveResolution(ctx, res, size, square)
+}
+
+// serveResolution turns a local resolution's bytes into a servable Image (byte-hash only, no decode).
+func (s *service) serveResolution(ctx context.Context, res resolution, size int, square bool) (*Image, error) {
+ if res.reader == nil {
+ return nil, ErrUnavailable
+ }
+ defer res.reader.Close()
+ data, err := readCapped(res.reader)
+ if err != nil {
+ return nil, ErrUnavailable
+ }
+ hash, err := hashImage(bytes.NewReader(data))
+ if err != nil {
+ return nil, ErrUnavailable
+ }
+ // Keyed by the byte-hash, so the entry lines up with the worker's eventual store entry.
+ return s.serveSource(ctx, hash, hash, unixMtime(res.refMtime), size, square,
+ func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(data)), nil })
+}
+
+func (s *service) serveMediaFile(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {
+ // The setting is not in the config fingerprint, so honor it at serve time: a direct mf- URL
+ // must fall back to disc/album instead of serving stale persisted embedded art.
+ if !conf.Server.EnableMediaFileCoverArt {
+ mf, err := s.ds.MediaFile(ctx).Get(artID.ID)
+ if err != nil {
+ return nil, err
+ }
+ return s.Get(ctx, mf.DiscCoverArtID(), size, square)
+ }
+ ia, err := s.ds.Artwork(ctx).GetItemArtwork(model.KindMediaFileArtwork, artID.ID, model.ImageTypePrimary)
+ switch {
+ case err == nil && ia.Hash != "":
+ return s.serveHash(ctx, artID, ia, size, square)
+ case err == nil:
+ // absent row: fall through
+ case errors.Is(err, model.ErrNotFound):
+ // no row: fall through
+ default:
+ return nil, err
+ }
+ noRow := errors.Is(err, model.ErrNotFound)
+
+ mf, err := s.ds.MediaFile(ctx).Get(artID.ID)
+ if err != nil {
+ return nil, err
+ }
+ if noRow && conf.Server.EnableMediaFileCoverArt && mf.HasCoverArt {
+ return s.provisionalEmbedded(ctx, artID, *mf, size, square)
+ }
+ // Mirror MediaFile.CoverArtID: a track defers to its disc art, which falls back to the album.
+ return s.Get(ctx, mf.DiscCoverArtID(), size, square)
}
-func (a *artwork) Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (reader io.ReadCloser, lastUpdate time.Time, err error) {
- artReader, err := a.getArtworkReader(ctx, artID, size, square)
+// provisionalEmbedded serves a track's embedded art immediately, leaving the state row to the worker.
+func (s *service) provisionalEmbedded(ctx context.Context, artID model.ArtworkID, mf model.MediaFile, size int, square bool) (*Image, error) {
+ lib, err := loadLibraryView(ctx, s.ds, mf.LibraryID)
if err != nil {
- return nil, time.Time{}, err
+ return nil, err
+ }
+ res, ok := resolveEmbedded(ctx, lib, s.ffmpeg, mf.Path)
+ s.enqueue(ctx, artID, model.ArtworkPriorityBump)
+ if !ok {
+ // Eligible but unextractable: fall back the way CoverArtID does, not to a placeholder.
+ return s.Get(ctx, mf.DiscCoverArtID(), size, square)
}
+ return s.serveResolution(ctx, res, size, square)
+}
- r, err := a.cache.Get(ctx, artReader)
+// serveDisc reads disc art through with no state row and no enqueue, falling back to the album cover.
+func (s *service) serveDisc(ctx context.Context, artID model.ArtworkID, size int, square bool) (*Image, error) {
+ dr, err := newDiscArtworkReader(ctx, s.ds, artID)
+ if err != nil {
+ return nil, err
+ }
+ // Single-disc albums run the chain too: a disc can carry art distinct from the album cover.
+ selectImage := func() (io.ReadCloser, string, error) {
+ funcs := dr.fromDiscArtPriority(ctx, s.ffmpeg, conf.Server.DiscArtPriority)
+ return selectImageReader(ctx, artID, funcs...)
+ }
+ albumArtID := model.ArtworkID{Kind: model.KindAlbumArtwork, ID: dr.album.ID}
+ // Disc art has no state row, hence no content hash: keying on id, album mtime and
+ // DiscArtPriority lets a warm cache answer without running the chain or touching the disk.
+ key := fmt.Sprintf("%s|%d|%s", artID.ID, dr.cacheTime().UnixNano(), conf.Server.DiscArtPriority)
+ img, err := s.serveSource(ctx, key, "", dr.cacheTime(), size, square,
+ func() (io.ReadCloser, error) { rc, _, err := selectImage(); return rc, err })
if err != nil {
- if !errors.Is(err, context.Canceled) && !errors.Is(err, ErrUnavailable) {
- log.Error(ctx, "Error accessing image cache", "id", artID, "size", size, err)
+ if errors.Is(err, context.Canceled) {
+ return nil, err
}
- return nil, time.Time{}, err
+ return s.Get(ctx, albumArtID, size, square)
}
- return r, artReader.LastUpdated(), nil
+ return img, nil
}
-type coverArtGetter interface {
+// dangling enqueues a re-resolution and reports unavailable, leaving the state row untouched.
+func (s *service) dangling(ctx context.Context, artID model.ArtworkID) (*Image, error) {
+ log.Debug(ctx, "Artwork: State row points at bytes we cannot serve, re-resolving", "artID", artID)
+ s.enqueue(ctx, artID, model.ArtworkPriorityScan)
+ return nil, ErrUnavailable
+}
+
+func (s *service) enqueue(ctx context.Context, artID model.ArtworkID, priority int) {
+ err := s.ds.ArtworkQueue(ctx).EnqueuePreservingBackoff(model.ArtworkQueueItem{
+ ItemKind: artID.Kind.Prefix(),
+ ItemID: artID.ID,
+ ImageType: model.ImageTypePrimary,
+ Priority: priority,
+ })
+ if err != nil {
+ log.Warn(ctx, "Artwork: Could not enqueue re-resolution", "artID", artID, err)
+ }
+}
+
+func placeholderImage(kind model.Kind) *Image {
+ path := consts.PlaceholderAlbumArt
+ if kind == model.KindArtistArtwork {
+ path = consts.PlaceholderArtistArt
+ }
+ r, _ := resources.FS().Open(path)
+ return &Image{ReadCloser: r, Placeholder: true}
+}
+
+type coverArtIDGetter interface {
CoverArtID() model.ArtworkID
}
-func (a *artwork) getArtworkId(ctx context.Context, id string) (model.ArtworkID, error) {
+// parseArtworkID accepts an artwork token or a raw entity id, resolving the latter to its CoverArtID.
+func (s *service) parseArtworkID(ctx context.Context, id string) (model.ArtworkID, error) {
if id == "" {
return model.ArtworkID{}, ErrUnavailable
}
- artID, err := model.ParseArtworkID(id)
- if err == nil {
+ if artID, err := model.ParseArtworkID(id); err == nil {
return artID, nil
}
-
- log.Trace(ctx, "ArtworkID invalid. Trying to figure out kind based on the ID", "id", id)
- entity, err := model.GetEntityByID(ctx, a.ds, id)
+ entity, err := model.GetEntityByID(ctx, s.ds, id)
if err != nil {
return model.ArtworkID{}, err
}
- if e, ok := entity.(coverArtGetter); ok {
- artID = e.CoverArtID()
- }
- switch e := entity.(type) {
- case *model.Artist:
- log.Trace(ctx, "ID is for an Artist", "id", id, "name", e.Name, "artist", e.Name)
- case *model.Album:
- log.Trace(ctx, "ID is for an Album", "id", id, "name", e.Name, "artist", e.AlbumArtist)
- case *model.MediaFile:
- log.Trace(ctx, "ID is for a MediaFile", "id", id, "title", e.Title, "album", e.Album)
- case *model.Playlist:
- log.Trace(ctx, "ID is for a Playlist", "id", id, "name", e.Name)
+ if e, ok := entity.(coverArtIDGetter); ok {
+ return e.CoverArtID(), nil
}
- return artID, nil
+ return model.ArtworkID{}, model.ErrNotFound
}
-func (a *artwork) getArtworkReader(ctx context.Context, artID model.ArtworkID, size int, square bool) (artworkReader, error) {
- var artReader artworkReader
- var err error
- if size > 0 || square {
- artReader, err = resizedFromOriginal(ctx, a, artID, size, square)
- } else {
- switch artID.Kind {
- case model.KindArtistArtwork:
- artReader, err = newArtistArtworkReader(ctx, a, artID, a.provider)
- case model.KindAlbumArtwork:
- artReader, err = newAlbumArtworkReader(ctx, a, artID, a.provider)
- case model.KindMediaFileArtwork:
- artReader, err = newMediafileArtworkReader(ctx, a, artID)
- case model.KindPlaylistArtwork:
- artReader, err = newPlaylistArtworkReader(ctx, a, artID)
- case model.KindDiscArtwork:
- artReader, err = newDiscArtworkReader(ctx, a, artID)
- case model.KindRadioArtwork:
- artReader, err = newRadioArtworkReader(ctx, a, artID)
- default:
- return nil, ErrUnavailable
- }
+func unixMtime(mtime int64) time.Time {
+ if mtime <= 0 {
+ return time.Time{}
}
- return artReader, err
+ return time.Unix(0, mtime) // RefMtime is unix-nanoseconds
}
diff --git a/core/artwork/artwork_internal_test.go b/core/artwork/artwork_internal_test.go
deleted file mode 100644
index 5bcd82f23..000000000
--- a/core/artwork/artwork_internal_test.go
+++ /dev/null
@@ -1,629 +0,0 @@
-package artwork
-
-import (
- "context"
- "errors"
- "image"
- "image/jpeg"
- "image/png"
- "io"
- "os"
- "path/filepath"
- "time"
-
- _ "github.com/gen2brain/webp"
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/log"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/tests"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("Artwork", func() {
- var aw *artwork
- var ds model.DataStore
- var ffmpeg *tests.MockFFmpeg
- var folderRepo *fakeFolderRepo
- ctx := log.NewContext(context.TODO())
- var alOnlyEmbed, alEmbedNotFound, alOnlyExternal, alExternalNotFound, alMultipleCovers, alSingleDisc model.Album
- var arMultipleCovers model.Artist
- var mfWithEmbed, mfAnotherWithEmbed, mfWithoutEmbed, mfCorruptedCover model.MediaFile
-
- BeforeEach(func() {
- DeferCleanup(configtest.SetupConfig())
- conf.Server.ImageCacheSize = "0" // Disable cache
- conf.Server.CoverArtPriority = "folder.*, cover.*, embedded , front.*"
-
- folderRepo = &fakeFolderRepo{}
- libRepo := &tests.MockLibraryRepo{}
- repoRoot, _ := os.Getwd()
- libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})
- ds = &tests.MockDataStore{
- MockedTranscoding: &tests.MockTranscodingRepo{},
- MockedFolder: folderRepo,
- MockedLibrary: libRepo,
- }
- // Paths use forward slashes because the scanner stores fs.FS-relative paths in the DB.
- alOnlyEmbed = model.Album{ID: "222", Name: "Only embed", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}}
- alEmbedNotFound = model.Album{ID: "333", Name: "Embed not found", EmbedArtPath: "tests/fixtures/NON_EXISTENT.mp3", FolderIDs: []string{"f1"}}
- alOnlyExternal = model.Album{ID: "444", Name: "Only external", FolderIDs: []string{"f1"}, Discs: model.Discs{1: "", 2: ""}}
- alExternalNotFound = model.Album{ID: "555", Name: "External not found", FolderIDs: []string{"f2"}}
- alSingleDisc = model.Album{ID: "888", Name: "Single disc", FolderIDs: []string{"f1"}, Discs: model.Discs{1: ""}}
- arMultipleCovers = model.Artist{ID: "777", Name: "All options"}
- alMultipleCovers = model.Album{
- ID: "666",
- Name: "All options",
- EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3",
- FolderIDs: []string{"f1"},
- AlbumArtistID: "777",
- }
- mfWithEmbed = model.MediaFile{ID: "22", Path: "tests/fixtures/test.mp3", HasCoverArt: true, AlbumID: "222"}
- mfAnotherWithEmbed = model.MediaFile{ID: "23", Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true, AlbumID: "666"}
- mfWithoutEmbed = model.MediaFile{ID: "44", Path: "tests/fixtures/test.ogg", AlbumID: "444"}
- mfCorruptedCover = model.MediaFile{ID: "45", Path: "tests/fixtures/test.ogg", HasCoverArt: true, AlbumID: "444"}
-
- cache := GetImageCache()
- ffmpeg = tests.NewMockFFmpeg("content from ffmpeg")
- aw = NewArtwork(ds, cache, ffmpeg, nil).(*artwork)
- })
-
- Describe("albumArtworkReader", func() {
- Context("ID not found", func() {
- It("returns ErrNotFound if album is not in the DB", func() {
- _, err := newAlbumArtworkReader(ctx, aw, model.MustParseArtworkID("al-NOT-FOUND"), nil)
- Expect(err).To(MatchError(model.ErrNotFound))
- })
- })
- Context("Embed images", func() {
- BeforeEach(func() {
- folderRepo.result = nil
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
- alOnlyEmbed,
- alEmbedNotFound,
- })
- })
- It("returns embed cover", func() {
- aw, err := newAlbumArtworkReader(ctx, aw, alOnlyEmbed.CoverArtID(), nil)
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- Expect(path).To(Equal("tests/fixtures/artist/an-album/test.mp3"))
- })
- It("returns ErrUnavailable if embed path is not available", func() {
- ffmpeg.Error = errors.New("not available")
- aw, err := newAlbumArtworkReader(ctx, aw, alEmbedNotFound.CoverArtID(), nil)
- Expect(err).ToNot(HaveOccurred())
- _, _, err = aw.Reader(ctx)
- Expect(err).To(MatchError(ErrUnavailable))
- })
- })
- Context("External images", func() {
- BeforeEach(func() {
- folderRepo.result = []model.Folder{}
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
- alOnlyExternal,
- alExternalNotFound,
- })
- })
- It("returns external cover", func() {
- folderRepo.result = []model.Folder{{
- Path: "tests/fixtures/artist/an-album",
- ImageFiles: []string{"front.png"},
- }}
- aw, err := newAlbumArtworkReader(ctx, aw, alOnlyExternal.CoverArtID(), nil)
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- Expect(path).To(Equal("tests/fixtures/artist/an-album/front.png"))
- })
- It("returns ErrUnavailable if external file is not available", func() {
- folderRepo.result = []model.Folder{}
- aw, err := newAlbumArtworkReader(ctx, aw, alExternalNotFound.CoverArtID(), nil)
- Expect(err).ToNot(HaveOccurred())
- _, _, err = aw.Reader(ctx)
- Expect(err).To(MatchError(ErrUnavailable))
- })
- })
- Context("Multiple covers", func() {
- BeforeEach(func() {
- folderRepo.result = []model.Folder{{
- Path: "tests/fixtures/artist/an-album",
- ImageFiles: []string{"cover.jpg", "front.png", "artist.png"},
- }}
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
- alMultipleCovers,
- })
- })
- DescribeTable("CoverArtPriority",
- func(priority string, expected string) {
- conf.Server.CoverArtPriority = priority
- aw, err := newAlbumArtworkReader(ctx, aw, alMultipleCovers.CoverArtID(), nil)
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- Expect(path).To(Equal(expected))
- },
- Entry(nil, " folder.* , cover.*,embedded,front.*", "tests/fixtures/artist/an-album/cover.jpg"),
- Entry(nil, "front.* , cover.*, embedded ,folder.*", "tests/fixtures/artist/an-album/front.png"),
- Entry(nil, " embedded , front.* , cover.*,folder.*", "tests/fixtures/artist/an-album/test.mp3"),
- )
- })
- Context("LastUpdated", func() {
- // Regression test for #5377: LastUpdated feeds the HTTP Last-Modified header.
- // It must return max(album.UpdatedAt, ImagesUpdatedAt) so browsers revalidate
- // cached cover art when only the image file changes.
- now := time.Now().Truncate(time.Second)
- DescribeTable("returns the max of album.UpdatedAt and ImagesUpdatedAt",
- func(albumUpdatedAt, imagesUpdatedAt, expected time.Time) {
- album := model.Album{ID: "al1", UpdatedAt: albumUpdatedAt}
- folderRepo.result = []model.Folder{{ImagesUpdatedAt: imagesUpdatedAt}}
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{album})
-
- ar, err := newAlbumArtworkReader(ctx, aw, album.CoverArtID(), nil)
- Expect(err).ToNot(HaveOccurred())
- Expect(ar.LastUpdated()).To(Equal(expected))
- },
- Entry("album newer than images", now, now.Add(-1*time.Hour), now),
- Entry("images newer than album", now.Add(-24*time.Hour), now.Add(-1*time.Hour), now.Add(-1*time.Hour)),
- Entry("equal timestamps", now, now, now),
- )
- })
- })
- Describe("discArtworkReader", func() {
- Context("LastUpdated", func() {
- // Regression test for #5377: same bug as albumArtworkReader — disc covers
- // must also revalidate when the image file changes, not only when media files do.
- now := time.Now().Truncate(time.Second)
- DescribeTable("returns the max of album.UpdatedAt and ImagesUpdatedAt",
- func(albumUpdatedAt, imagesUpdatedAt, expected time.Time) {
- album := model.Album{ID: "al1", UpdatedAt: albumUpdatedAt}
- folderRepo.result = []model.Folder{{ImagesUpdatedAt: imagesUpdatedAt}}
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{album})
- ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
- {ID: "mf1", AlbumID: "al1", DiscNumber: 1, Path: "tests/fixtures/test.mp3"},
- })
-
- artID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("al1", 1), nil)
- dr, err := newDiscArtworkReader(ctx, aw, artID)
- Expect(err).ToNot(HaveOccurred())
- Expect(dr.LastUpdated()).To(Equal(expected))
- },
- Entry("album newer than images", now, now.Add(-1*time.Hour), now),
- Entry("images newer than album", now.Add(-24*time.Hour), now.Add(-1*time.Hour), now.Add(-1*time.Hour)),
- Entry("equal timestamps", now, now, now),
- )
- })
- })
- Describe("artistArtworkReader", func() {
- Context("Multiple covers", func() {
- BeforeEach(func() {
- repoRoot, err := os.Getwd()
- Expect(err).ToNot(HaveOccurred())
- folderRepo.result = []model.Folder{{
- ID: "f1",
- LibraryPath: testFileLibPath(repoRoot),
- Path: "tests/fixtures/artist/an-album",
- ImageFiles: []string{"artist.png"},
- }}
- ds.Artist(ctx).(*tests.MockArtistRepo).SetData(model.Artists{
- arMultipleCovers,
- })
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
- alMultipleCovers,
- })
- ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
- mfAnotherWithEmbed,
- })
- })
- DescribeTable("ArtistArtPriority",
- func(priority string, expected string) {
- conf.Server.ArtistArtPriority = priority
- aw, err := newArtistArtworkReader(ctx, aw, arMultipleCovers.CoverArtID(), nil)
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- Expect(filepath.ToSlash(path)).To(HaveSuffix(expected))
- },
- Entry(nil, " folder.* , artist.*,album/artist.*", "tests/fixtures/artist/artist.jpg"),
- Entry(nil, "album/artist.*, folder.*,artist.*", "tests/fixtures/artist/an-album/artist.png"),
- )
- })
- })
- Describe("mediafileArtworkReader", func() {
- Context("ID not found", func() {
- It("returns ErrNotFound if mediafile is not in the DB", func() {
- _, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-NOT-FOUND"))
- Expect(err).To(MatchError(model.ErrNotFound))
- })
- })
- Context("Embed images", func() {
- BeforeEach(func() {
- folderRepo.result = []model.Folder{{
- Path: "tests/fixtures/artist/an-album",
- ImageFiles: []string{"front.png"},
- }}
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
- alOnlyEmbed,
- alOnlyExternal,
- alSingleDisc,
- })
- ds.MediaFile(ctx).(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
- mfWithEmbed,
- mfWithoutEmbed,
- mfCorruptedCover,
- })
- })
- It("returns embed cover", func() {
- aw, err := newMediafileArtworkReader(ctx, aw, mfWithEmbed.CoverArtID())
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- Expect(path).To(Equal("tests/fixtures/test.mp3"))
- })
- It("returns embed cover if successfully extracted by ffmpeg", func() {
- aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())
- Expect(err).ToNot(HaveOccurred())
- r, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- data, _ := io.ReadAll(r)
- Expect(data).ToNot(BeEmpty())
- Expect(path).To(Equal("tests/fixtures/test.ogg"))
- })
- It("returns album cover if cannot read embed artwork", func() {
- // Force fromTag to fail
- mfCorruptedCover.Path = "tests/fixtures/DOES_NOT_EXIST.ogg"
- Expect(ds.MediaFile(ctx).(*tests.MockMediaFileRepo).Put(&mfCorruptedCover)).To(Succeed())
- // Simulate ffmpeg error
- ffmpeg.Error = errors.New("not available")
-
- aw, err := newMediafileArtworkReader(ctx, aw, mfCorruptedCover.CoverArtID())
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- Expect(path).To(Equal("al-444_0"))
- })
- It("returns album cover if media file has no cover art", func() {
- aw, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-"+mfWithoutEmbed.ID))
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- Expect(path).To(Equal("al-444_0"))
- })
- It("falls back to disc cover art when media file has a disc number on a multi-disc album", func() {
- mfWithDisc := model.MediaFile{ID: "46", Path: "tests/fixtures/test.ogg", AlbumID: "444", DiscNumber: 2}
- Expect(ds.MediaFile(ctx).(*tests.MockMediaFileRepo).Put(&mfWithDisc)).To(Succeed())
-
- aw, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-"+mfWithDisc.ID))
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- // Should fall back to disc art, which itself falls back to album art
- Expect(path).To(Equal("dc-444:2_0"))
- })
- It("falls back to album cover art for single-disc albums even with a disc number", func() {
- mfOnSingleDisc := model.MediaFile{ID: "47", Path: "tests/fixtures/test.ogg", AlbumID: "888", DiscNumber: 1}
- Expect(ds.MediaFile(ctx).(*tests.MockMediaFileRepo).Put(&mfOnSingleDisc)).To(Succeed())
-
- aw, err := newMediafileArtworkReader(ctx, aw, model.MustParseArtworkID("mf-"+mfOnSingleDisc.ID))
- Expect(err).ToNot(HaveOccurred())
- _, path, err := aw.Reader(ctx)
- Expect(err).ToNot(HaveOccurred())
- // Single-disc album should skip disc art and go straight to album art
- Expect(path).To(Equal("al-888_0"))
- })
- })
- })
- Describe("playlistArtworkReader", func() {
- Describe("findPlaylistSidecarPath", func() {
- It("discovers sidecar image next to playlist file", func() {
- tmpDir := GinkgoT().TempDir()
- plsPath := filepath.Join(tmpDir, "MyPlaylist.m3u")
- imgPath := filepath.Join(tmpDir, "MyPlaylist.jpg")
- Expect(os.WriteFile(plsPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())
- Expect(os.WriteFile(imgPath, []byte("fake image"), 0600)).To(Succeed())
-
- result := findPlaylistSidecarPath(GinkgoT().Context(), plsPath)
- Expect(result).To(Equal(imgPath))
- })
-
- It("returns empty string when no sidecar image exists", func() {
- tmpDir := GinkgoT().TempDir()
- plsPath := filepath.Join(tmpDir, "MyPlaylist.m3u")
- Expect(os.WriteFile(plsPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())
-
- result := findPlaylistSidecarPath(GinkgoT().Context(), plsPath)
- Expect(result).To(BeEmpty())
- })
-
- It("returns empty string when playlist has no path", func() {
- result := findPlaylistSidecarPath(GinkgoT().Context(), "")
- Expect(result).To(BeEmpty())
- })
-
- It("finds sidecar with different case base name", func() {
- tmpDir := GinkgoT().TempDir()
- plsPath := filepath.Join(tmpDir, "myplaylist.m3u")
- imgPath := filepath.Join(tmpDir, "MyPlaylist.jpg")
- Expect(os.WriteFile(plsPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())
- Expect(os.WriteFile(imgPath, []byte("fake image"), 0600)).To(Succeed())
-
- result := findPlaylistSidecarPath(GinkgoT().Context(), plsPath)
- Expect(result).To(Equal(imgPath))
- })
- })
-
- Describe("fromPlaylistExternalImage", func() {
- It("opens local path from ExternalImageURL", func() {
- tmpDir := GinkgoT().TempDir()
- imgPath := filepath.Join(tmpDir, "cover.jpg")
- Expect(os.WriteFile(imgPath, []byte("external image data"), 0600)).To(Succeed())
-
- reader := &playlistArtworkReader{
- pl: model.Playlist{ExternalImageURL: imgPath},
- }
- r, path, err := reader.fromPlaylistExternalImage(ctx)()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
- data, _ := io.ReadAll(r)
- Expect(string(data)).To(Equal("external image data"))
- r.Close()
- })
-
- It("returns nil when ExternalImageURL is empty", func() {
- reader := &playlistArtworkReader{
- pl: model.Playlist{ExternalImageURL: ""},
- }
- r, path, err := reader.fromPlaylistExternalImage(ctx)()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).To(BeNil())
- Expect(path).To(BeEmpty())
- })
-
- It("returns error when local file does not exist", func() {
- reader := &playlistArtworkReader{
- pl: model.Playlist{ExternalImageURL: "/non/existent/path/cover.jpg"},
- }
- r, _, err := reader.fromPlaylistExternalImage(ctx)()
- Expect(err).To(HaveOccurred())
- Expect(r).To(BeNil())
- })
-
- It("skips HTTP URL when EnableM3UExternalAlbumArt is false", func() {
- conf.Server.EnableM3UExternalAlbumArt = false
-
- reader := &playlistArtworkReader{
- pl: model.Playlist{ExternalImageURL: "https://example.com/cover.jpg"},
- }
- r, path, err := reader.fromPlaylistExternalImage(ctx)()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).To(BeNil())
- Expect(path).To(BeEmpty())
- })
-
- It("still opens local path when EnableM3UExternalAlbumArt is false", func() {
- conf.Server.EnableM3UExternalAlbumArt = false
-
- tmpDir := GinkgoT().TempDir()
- imgPath := filepath.Join(tmpDir, "cover.jpg")
- Expect(os.WriteFile(imgPath, []byte("local image"), 0600)).To(Succeed())
-
- reader := &playlistArtworkReader{
- pl: model.Playlist{ExternalImageURL: imgPath},
- }
- r, path, err := reader.fromPlaylistExternalImage(ctx)()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
- r.Close()
- })
- })
- })
-
- Describe("resizedArtworkReader", func() {
- BeforeEach(func() {
- folderRepo.result = []model.Folder{{
- Path: "tests/fixtures/artist/an-album",
- ImageFiles: []string{"cover.jpg", "front.png"},
- }}
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
- alMultipleCovers,
- })
- })
- When("Square is false", func() {
- It("returns PNG if original image is a PNG", func() {
- conf.Server.CoverArtPriority = "front.png"
- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)
- Expect(err).ToNot(HaveOccurred())
-
- img, format, err := image.Decode(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(format).To(Equal("png"))
- Expect(img.Bounds().Size().X).To(Equal(15))
- Expect(img.Bounds().Size().Y).To(Equal(15))
- })
- It("returns JPEG if original image is not a PNG", func() {
- conf.Server.CoverArtPriority = "cover.jpg"
- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200, false)
- Expect(err).ToNot(HaveOccurred())
-
- img, format, err := image.Decode(r)
- Expect(format).To(Equal("jpeg"))
- Expect(err).ToNot(HaveOccurred())
- Expect(img.Bounds().Size().X).To(Equal(200))
- Expect(img.Bounds().Size().Y).To(Equal(200))
- })
- })
- When("When square is true", func() {
- var alCover model.Album
-
- DescribeTable("resize",
- func(srcFormat string, expectedFormat string, landscape bool, size int) {
- coverFileName := "cover." + srcFormat
- dirName := createImage(srcFormat, landscape, size)
- alCover = model.Album{
- ID: "444",
- Name: "Only external",
- FolderIDs: []string{"tmp"},
- }
- folderRepo.result = []model.Folder{{ImageFiles: []string{coverFileName}}}
- rootLibRepo := &tests.MockLibraryRepo{}
- rootLibRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(dirName)}})
- ds.(*tests.MockDataStore).MockedLibrary = rootLibRepo
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{
- alCover,
- })
-
- conf.Server.CoverArtPriority = coverFileName
- r, _, err := aw.Get(context.Background(), alCover.CoverArtID(), size, true)
- Expect(err).ToNot(HaveOccurred())
-
- img, format, err := image.Decode(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(format).To(Equal(expectedFormat))
- Expect(img.Bounds().Size().X).To(Equal(size))
- Expect(img.Bounds().Size().Y).To(Equal(size))
- },
- Entry("portrait png image", "png", "png", false, 200),
- Entry("landscape png image", "png", "png", true, 200),
- Entry("portrait jpg image", "jpg", "png", false, 200),
- Entry("landscape jpg image", "jpg", "png", true, 200),
- )
- })
- When("EnableWebPEncoding is true and square is false", func() {
- BeforeEach(func() {
- conf.Server.EnableWebPEncoding = true
- })
- It("returns WebP even if original image is a PNG", func() {
- conf.Server.CoverArtPriority = "front.png"
- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)
- Expect(err).ToNot(HaveOccurred())
-
- img, format, err := image.Decode(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(format).To(Equal("webp"))
- Expect(img.Bounds().Size().X).To(Equal(15))
- Expect(img.Bounds().Size().Y).To(Equal(15))
- })
- It("returns WebP if original image is not a PNG", func() {
- conf.Server.CoverArtPriority = "cover.jpg"
- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200, false)
- Expect(err).ToNot(HaveOccurred())
-
- img, format, err := image.Decode(r)
- Expect(format).To(Equal("webp"))
- Expect(err).ToNot(HaveOccurred())
- Expect(img.Bounds().Size().X).To(Equal(200))
- Expect(img.Bounds().Size().Y).To(Equal(200))
- })
- })
- When("EnableWebPEncoding is false and square is false", func() {
- BeforeEach(func() {
- conf.Server.EnableWebPEncoding = false
- })
- It("returns PNG if original image is a PNG", func() {
- conf.Server.CoverArtPriority = "front.png"
- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 15, false)
- Expect(err).ToNot(HaveOccurred())
-
- img, format, err := image.Decode(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(format).To(Equal("png"))
- Expect(img.Bounds().Size().X).To(Equal(15))
- Expect(img.Bounds().Size().Y).To(Equal(15))
- })
- It("returns JPEG if original image is a JPG", func() {
- conf.Server.CoverArtPriority = "cover.jpg"
- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 200, false)
- Expect(err).ToNot(HaveOccurred())
-
- img, format, err := image.Decode(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(format).To(Equal("jpeg"))
- Expect(img.Bounds().Size().X).To(Equal(200))
- Expect(img.Bounds().Size().Y).To(Equal(200))
- })
- })
- When("EnableWebPEncoding is false and square is true", func() {
- var alCover model.Album
-
- BeforeEach(func() {
- conf.Server.EnableWebPEncoding = false
- })
- It("returns PNG for square mode", func() {
- dirName := createImage("png", false, 200)
- alCover = model.Album{
- ID: "444",
- Name: "Only external",
- FolderIDs: []string{"tmp"},
- }
- folderRepo.result = []model.Folder{{ImageFiles: []string{"cover.png"}}}
- rootLibRepo := &tests.MockLibraryRepo{}
- rootLibRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(dirName)}})
- ds.(*tests.MockDataStore).MockedLibrary = rootLibRepo
- ds.Album(ctx).(*tests.MockAlbumRepo).SetData(model.Albums{alCover})
-
- conf.Server.CoverArtPriority = "cover.png"
- r, _, err := aw.Get(context.Background(), alCover.CoverArtID(), 200, true)
- Expect(err).ToNot(HaveOccurred())
-
- img, format, err := image.Decode(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(format).To(Equal("png"))
- Expect(img.Bounds().Size().X).To(Equal(200))
- Expect(img.Bounds().Size().Y).To(Equal(200))
- })
- })
- When("Requested size is larger than original", func() {
- It("clamps size to original dimensions", func() {
- conf.Server.CoverArtPriority = "front.png"
- // front.png is 16x16, requesting 99999 should return at original size
- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 99999, false)
- Expect(err).ToNot(HaveOccurred())
-
- img, _, err := image.Decode(r)
- Expect(err).ToNot(HaveOccurred())
- // Should be clamped to original size (16), not 99999
- Expect(img.Bounds().Size().X).To(Equal(16))
- Expect(img.Bounds().Size().Y).To(Equal(16))
- })
-
- It("clamps square size to original dimensions", func() {
- conf.Server.CoverArtPriority = "front.png"
- // front.png is 16x16, requesting 99999 with square should return 16x16 square
- r, _, err := aw.Get(context.Background(), alMultipleCovers.CoverArtID(), 99999, true)
- Expect(err).ToNot(HaveOccurred())
-
- img, _, err := image.Decode(r)
- Expect(err).ToNot(HaveOccurred())
- // Should be clamped to original size (16), not 99999
- Expect(img.Bounds().Size().X).To(Equal(16))
- Expect(img.Bounds().Size().Y).To(Equal(16))
- })
- })
- })
-})
-
-func createImage(format string, landscape bool, size int) string {
- var img image.Image
-
- if landscape {
- img = image.NewRGBA(image.Rect(0, 0, size, size/2))
- } else {
- img = image.NewRGBA(image.Rect(0, 0, size/2, size))
- }
-
- tmpDir := GinkgoT().TempDir()
- f, _ := os.Create(filepath.Join(tmpDir, "cover."+format))
- defer f.Close()
- switch format {
- case "png":
- _ = png.Encode(f, img)
- case "jpg":
- _ = jpeg.Encode(f, img, &jpeg.Options{Quality: 75})
- }
-
- return tmpDir
-}
diff --git a/core/artwork/artwork_suite_test.go b/core/artwork/artwork_suite_test.go
index d42d7f3e4..1ea82b7fa 100644
--- a/core/artwork/artwork_suite_test.go
+++ b/core/artwork/artwork_suite_test.go
@@ -11,13 +11,26 @@ import (
"github.com/navidrome/navidrome/core/storage"
"github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/metadata"
"github.com/navidrome/navidrome/tests"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
+ "go.uber.org/goleak"
)
func TestArtwork(t *testing.T) {
+ // Runs unconditionally: the two leaks below are pre-existing and out of this
+ // package's control, so they're ignored by exact top-function instead.
+ defer goleak.VerifyNone(t,
+ goleak.IgnoreTopFunction("github.com/onsi/ginkgo/v2/internal/interrupt_handler.(*InterruptHandler).registerForInterrupts.func2"),
+ // notify's own init() starts a singleton tree the moment it's imported (via
+ // core/storage/local or plugins); recursive on darwin, nonrecursive on linux.
+ goleak.IgnoreTopFunction("github.com/rjeczalik/notify.(*recursiveTree).dispatch"),
+ goleak.IgnoreTopFunction("github.com/rjeczalik/notify.(*nonrecursiveTree).dispatch"),
+ goleak.IgnoreTopFunction("github.com/rjeczalik/notify.(*nonrecursiveTree).internal"),
+ )
+
tests.Init(t, false)
log.SetLevel(log.LevelFatal)
RegisterFailHandler(Fail)
@@ -25,7 +38,6 @@ func TestArtwork(t *testing.T) {
}
// osDirFS wraps os.DirFS as a storage.MusicFS for integration tests.
-// ReadTags is not used by albumArtworkReader, so it is left as a stub.
type osDirFS struct{ fs.FS }
func (o osDirFS) ReadTags(...string) (map[string]metadata.Info, error) { return nil, nil }
@@ -69,3 +81,37 @@ func (s *osDirStorage) FS() (storage.MusicFS, error) {
}
return osDirFS{os.DirFS(s.root)}, nil
}
+
+// fakeFolderRepo covers the three FolderRepository methods the resolvers reach for. The zero value
+// answers as an unremarkable library does; the fields drive the album-root lookup and its failures.
+type fakeFolderRepo struct {
+ model.FolderRepository
+ result []model.Folder
+ err error
+ parentResult *model.Folder
+ getErr error
+ getCallCount int
+ // hasOtherAudio is returned by HasAudioOutsideFolders (the album-root check).
+ // False means the parent qualifies as an album root.
+ hasOtherAudio bool
+ otherAudioErr error
+}
+
+func (f *fakeFolderRepo) GetAll(...model.QueryOptions) ([]model.Folder, error) {
+ return f.result, f.err
+}
+
+func (f *fakeFolderRepo) HasAudioOutsideFolders(model.Folder, []string) (bool, error) {
+ return f.hasOtherAudio, f.otherAudioErr
+}
+
+func (f *fakeFolderRepo) Get(string) (*model.Folder, error) {
+ f.getCallCount++
+ if f.getErr != nil {
+ return nil, f.getErr
+ }
+ if f.parentResult != nil {
+ return f.parentResult, nil
+ }
+ return nil, model.ErrNotFound
+}
diff --git a/core/artwork/artwork_test.go b/core/artwork/artwork_test.go
index adddd0dc3..c6b848101 100644
--- a/core/artwork/artwork_test.go
+++ b/core/artwork/artwork_test.go
@@ -1,57 +1,523 @@
-package artwork_test
+package artwork
import (
+ "bytes"
"context"
+ "image"
"io"
+ "os"
+ "path/filepath"
+ "time"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/resources"
"github.com/navidrome/navidrome/tests"
+ "github.com/navidrome/navidrome/utils/cache"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
var _ = Describe("Artwork", func() {
- var aw artwork.Artwork
- var ds model.DataStore
- var ffmpeg *tests.MockFFmpeg
+ var (
+ ctx context.Context
+ ds *tests.MockDataStore
+ artRepo *tests.MockArtworkRepo
+ queueRepo *tests.MockArtworkQueueRepo
+ albumRepo *tests.MockAlbumRepo
+ mfRepo *tests.MockMediaFileRepo
+ folderRepo *fakeFolderRepo
+ libRepo *tests.MockLibraryRepo
+ ffm *tests.MockFFmpeg
+ store *ImageStore
+ imgCache cache.FileCache
+ svc Artwork
+ repoRoot string
+ coverBytes []byte
+ seedEntity func(kind, id string)
+ )
+
+ primaryKey := func(kind, id string) string { return kind + "|" + id + "|" + model.ImageTypePrimary }
+
+ seedFoundStore := func(kind, id string, imgBytes []byte) string {
+ hash, err := hashImage(bytes.NewReader(imgBytes))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(store.Write(hash, "image/jpeg", bytes.NewReader(imgBytes))).To(Succeed())
+ Expect(artRepo.PutImage(&model.Artwork{Hash: hash, Mime: "image/jpeg"})).To(Succeed())
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: kind, ItemID: id, Hash: hash, Source: "external"})).To(Succeed())
+ seedEntity(kind, id)
+ return hash
+ }
+
+ // Without its owning entity, a state row is not served at all.
+ seedEntity = func(kind, id string) {
+ GinkgoHelper()
+ switch kind {
+ case "al":
+ Expect(albumRepo.Put(&model.Album{ID: id, Name: "Album"})).To(Succeed())
+ case "mf":
+ Expect(mfRepo.Put(&model.MediaFile{ID: id})).To(Succeed())
+ }
+ }
+
+ readAll := func(img *Image) []byte {
+ GinkgoHelper()
+ defer img.Close()
+ data, err := io.ReadAll(img)
+ Expect(err).ToNot(HaveOccurred())
+ return data
+ }
BeforeEach(func() {
DeferCleanup(configtest.SetupConfig())
- conf.Server.ImageCacheSize = "0" // Disable cache
- cache := artwork.GetImageCache()
- ffmpeg = tests.NewMockFFmpeg("content from ffmpeg")
- aw = artwork.NewArtwork(ds, cache, ffmpeg, nil)
+ ctx = context.Background()
+ var err error
+ repoRoot, err = os.Getwd()
+ Expect(err).ToNot(HaveOccurred())
+ coverBytes, err = os.ReadFile(filepath.Join(repoRoot, "tests/fixtures/artist/an-album/cover.jpg"))
+ Expect(err).ToNot(HaveOccurred())
+
+ conf.Server.EnableWebPEncoding = false
+ conf.Server.CoverArtQuality = 75
+ conf.Server.CoverArtPriority = "cover.*"
+ conf.Server.DiscArtPriority = "cover.*"
+ conf.Server.CacheFolder = conf.NewDir(GinkgoT().TempDir())
+
+ artRepo = tests.CreateMockArtworkRepo()
+ queueRepo = tests.CreateMockArtworkQueueRepo()
+ albumRepo = tests.CreateMockAlbumRepo()
+ mfRepo = tests.CreateMockMediaFileRepo()
+ folderRepo = &fakeFolderRepo{}
+ libRepo = &tests.MockLibraryRepo{}
+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})
+ ds = &tests.MockDataStore{
+ MockedArtwork: artRepo,
+ MockedArtworkQueue: queueRepo,
+ MockedAlbum: albumRepo,
+ MockedMediaFile: mfRepo,
+ MockedFolder: folderRepo,
+ MockedLibrary: libRepo,
+ }
+ ffm = tests.NewMockFFmpeg("")
+ store = NewImageStore(GinkgoT().TempDir())
+ imgCache = cache.NewFileCache("ServingTest", "100MB", "images", 0,
+ func(ctx context.Context, arg cache.Item) (io.Reader, error) {
+ return arg.(artworkReader).Reader(ctx)
+ })
+ Eventually(func() bool { return imgCache.Available(ctx) }).Should(BeTrue())
+ svc = NewArtwork(ds, imgCache, store, ffm)
})
- Context("GetOrPlaceholder", func() {
- Context("Empty ID", func() {
- It("returns placeholder if album is not in the DB", func() {
- r, _, err := aw.GetOrPlaceholder(context.Background(), "", 0, false)
- Expect(err).ToNot(HaveOccurred())
+ Describe("found state", func() {
+ It("serves a store-backed found image sized (cache miss resizes, second call is a cache hit)", func() {
+ seedFoundStore("al", "al1", coverBytes)
- ph, err := resources.FS().Open(consts.PlaceholderAlbumArt)
- Expect(err).ToNot(HaveOccurred())
- phBytes, err := io.ReadAll(ph)
- Expect(err).ToNot(HaveOccurred())
+ img, err := svc.Get(ctx, model.MustParseArtworkID("al-al1"), 100, false)
+ Expect(err).ToNot(HaveOccurred())
+ // A resized response versions its ETag with the encode settings, not the pixel hash.
+ Expect(img.ETag).To(Equal(representationTag(img.Hash, 100, false)))
+ Expect(img.ETag).ToNot(Equal(img.Hash))
+ resized := readAll(img)
+ cfg, _, err := image.DecodeConfig(bytes.NewReader(resized))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(cfg.Width).To(Equal(100))
- result, err := io.ReadAll(r)
- Expect(err).ToNot(HaveOccurred())
+ // Deleting the store file proves the warm entry serves without touching the original.
+ hash, _ := hashImage(bytes.NewReader(coverBytes))
+ Expect(os.Remove(store.path(hash, "image/jpeg"))).To(Succeed())
+ Eventually(func(g Gomega) {
+ img2, err := svc.Get(ctx, model.MustParseArtworkID("al-al1"), 100, false)
+ g.Expect(err).ToNot(HaveOccurred())
+ g.Expect(readAll(img2)).To(Equal(resized))
+ }).Should(Succeed())
+ })
- Expect(result).To(Equal(phBytes))
- })
+ It("treats a negative size as a full-size request, not a giant resize", func() {
+ seedFoundStore("al", "alneg", coverBytes)
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("al-alneg"), -2000000000, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes), "original bytes, no resize (would OOM)")
+ })
+
+ It("streams a file-backed found image at full size", func() {
+ dir := GinkgoT().TempDir()
+ imgPath := filepath.Join(dir, "cover.jpg")
+ Expect(os.WriteFile(imgPath, coverBytes, 0600)).To(Succeed())
+ mtime := fileMtime(imgPath)
+ Expect(artRepo.PutImage(&model.Artwork{Hash: "aaaaaaaaaaaaaaaa", Mime: "image/jpeg"})).To(Succeed())
+ seedEntity("al", "al2")
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "al2", Hash: "aaaaaaaaaaaaaaaa",
+ Source: "folder", SourcePath: imgPath, RefMtime: mtime,
+ })).To(Succeed())
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("al-al2"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+
+ It("treats a full-size mtime mismatch as dangling: unavailable, re-enqueued at Scan, state untouched", func() {
+ dir := GinkgoT().TempDir()
+ imgPath := filepath.Join(dir, "cover.jpg")
+ Expect(os.WriteFile(imgPath, coverBytes, 0600)).To(Succeed())
+ Expect(artRepo.PutImage(&model.Artwork{Hash: "bbbbbbbbbbbbbbbb", Mime: "image/jpeg"})).To(Succeed())
+ seedEntity("al", "al3")
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "al3", Hash: "bbbbbbbbbbbbbbbb",
+ Source: "folder", SourcePath: imgPath, RefMtime: fileMtime(imgPath) + 999,
+ })).To(Succeed())
+
+ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al3"), 0, false)
+ Expect(err).To(MatchError(ErrUnavailable))
+ Expect(queueRepo.Data[primaryKey("al", "al3")].Priority).To(Equal(model.ArtworkPriorityScan))
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al3", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).To(Equal("bbbbbbbbbbbbbbbb"))
+ })
+
+ It("enforces the mtime rule on the sized (loader) path too", func() {
+ dir := GinkgoT().TempDir()
+ imgPath := filepath.Join(dir, "cover.jpg")
+ Expect(os.WriteFile(imgPath, coverBytes, 0600)).To(Succeed())
+ Expect(artRepo.PutImage(&model.Artwork{Hash: "cccccccccccccccc", Mime: "image/jpeg"})).To(Succeed())
+ seedEntity("al", "al3b")
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "al3b", Hash: "cccccccccccccccc",
+ Source: "folder", SourcePath: imgPath, RefMtime: fileMtime(imgPath) + 999,
+ })).To(Succeed())
+
+ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al3b"), 100, false)
+ Expect(err).To(MatchError(ErrUnavailable))
+ Expect(queueRepo.Data[primaryKey("al", "al3b")].Priority).To(Equal(model.ArtworkPriorityScan))
+ })
+
+ // State rows outlive a deleted entity until the next prune.
+ It("refuses to serve a found row whose entity is gone", func() {
+ hash := seedFoundStore("al", "alzz", coverBytes)
+ Expect(hash).ToNot(BeEmpty())
+ albumRepo.SetData(model.Albums{}) // the album is deleted; its artwork row survives
+
+ _, err := svc.Get(ctx, model.MustParseArtworkID("al-alzz"), 0, false)
+ Expect(err).To(MatchError(ErrUnavailable))
+ })
+
+ It("does not re-enqueue a recently-attempted absent state", func() {
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "al4", AttemptedAt: time.Now(),
+ })).To(Succeed())
+
+ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al4"), 0, false)
+ Expect(err).To(MatchError(ErrUnavailable))
+ Expect(queueRepo.Data).To(BeEmpty())
+ })
+
+ It("promotes a stale absent state at Bump priority on view", func() {
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "al4b", AttemptedAt: time.Now().Add(-2 * requestRecheckAge),
+ })).To(Succeed())
+
+ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al4b"), 0, false)
+ Expect(err).To(MatchError(ErrUnavailable))
+ Expect(queueRepo.Data[primaryKey("al", "al4b")].Priority).To(Equal(model.ArtworkPriorityBump))
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al4b", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).To(BeEmpty())
})
})
- Context("Get", func() {
- Context("Empty ID", func() {
- It("returns an ErrUnavailable error", func() {
- _, _, err := aw.Get(context.Background(), model.ArtworkID{}, 0, false)
- Expect(err).To(MatchError(artwork.ErrUnavailable))
- })
+
+ Describe("provisional read-through", func() {
+ It("serves local folder art, enqueues a Bump, and writes no state row", func() {
+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}
+ albumRepo.SetData(model.Albums{{ID: "al5", Name: "Album", FolderIDs: []string{"f1"}}})
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("al-al5"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes))
+
+ Expect(queueRepo.Data[primaryKey("al", "al5")].Priority).To(Equal(model.ArtworkPriorityBump))
+ _, err = artRepo.GetItemArtwork(model.KindAlbumArtwork, "al5", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+
+ It("returns ErrUnavailable and enqueues a Bump when nothing local resolves", func() {
+ folderRepo.result = nil
+ albumRepo.SetData(model.Albums{{ID: "al6", Name: "Album"}})
+
+ _, err := svc.Get(ctx, model.MustParseArtworkID("al-al6"), 0, false)
+ Expect(err).To(MatchError(ErrUnavailable))
+ Expect(queueRepo.Data[primaryKey("al", "al6")].Priority).To(Equal(model.ArtworkPriorityBump))
+ _, err = artRepo.GetItemArtwork(model.KindAlbumArtwork, "al6", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
})
})
+
+ Describe("media file", func() {
+ It("serves a track's own found art", func() {
+ seedFoundStore("mf", "mf1", coverBytes)
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf1"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+
+ It("ignores a resolved mf row and delegates to the album when per-track art is disabled", func() {
+ conf.Server.EnableMediaFileCoverArt = false
+ seedFoundStore("mf", "mf7", []byte("stale embedded track art"))
+ seedFoundStore("al", "albz", coverBytes)
+ mfRepo.SetData(model.MediaFiles{{ID: "mf7", AlbumID: "albz"}})
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf7"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes), "album art, not the persisted embedded art")
+ })
+
+ It("delegates to the album when the track's state is absent", func() {
+ seedFoundStore("al", "albm", coverBytes)
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: "mf2"})).To(Succeed())
+ mfRepo.SetData(model.MediaFiles{{ID: "mf2", AlbumID: "albm"}})
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf2"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ _, mfEnq := queueRepo.Data[primaryKey("mf", "mf2")]
+ Expect(mfEnq).To(BeFalse())
+ })
+
+ It("delegates to the album (no enqueue) when the track is not embedded-eligible", func() {
+ conf.Server.EnableMediaFileCoverArt = true
+ seedFoundStore("al", "albn", coverBytes)
+ mfRepo.SetData(model.MediaFiles{{ID: "mf3", AlbumID: "albn", HasCoverArt: false}})
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf3"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ _, mfEnq := queueRepo.Data[primaryKey("mf", "mf3")]
+ Expect(mfEnq).To(BeFalse())
+ })
+
+ It("extracts embedded art provisionally and enqueues the track when eligible", func() {
+ conf.Server.EnableMediaFileCoverArt = true
+ mfRepo.SetData(model.MediaFiles{{
+ ID: "mf4", AlbumID: "albo", HasCoverArt: true,
+ Path: "tests/fixtures/artist/an-album/test.mp3", LibraryID: 0,
+ }})
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf4"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(readAll(img))).To(BeNumerically(">", 0))
+ Expect(queueRepo.Data[primaryKey("mf", "mf4")].Priority).To(Equal(model.ArtworkPriorityBump))
+ _, err = artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mf4", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+
+ It("delegates a multi-disc track to its disc art, not straight to the album", func() {
+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}
+ albumRepo.SetData(model.Albums{{ID: "aldd", Name: "Album", FolderIDs: []string{"f1"}, Discs: model.Discs{1: "One", 2: "Two"}}})
+ seedFoundStore("al", "aldd", []byte("album-art-distinct")) // album's own found art differs
+ mfRepo.SetData(model.MediaFiles{{ID: "mf5", AlbumID: "aldd", DiscNumber: 1, HasCoverArt: false}})
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf5"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ // The disc-folder image, not the album's own art: proof it routed through serveDisc.
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+
+ It("falls back to the album when an eligible track's embedded art will not extract", func() {
+ conf.Server.EnableMediaFileCoverArt = true
+ // HasCoverArt is set, but the file is not audio, so nothing extracts.
+ mfRepo.SetData(model.MediaFiles{{
+ ID: "mfbad", AlbumID: "albad", LibraryID: 0, HasCoverArt: true,
+ Path: "tests/fixtures/artist/an-album/front.png",
+ }})
+ albumRepo.SetData(model.Albums{{ID: "albad", Name: "Album"}})
+ seedFoundStore("al", "albad", coverBytes)
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mfbad"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes), "a placeholder here would be worse than the album cover")
+ })
+
+ It("routes a single-disc track through disc resolution too", func() {
+ // DiscArtPriority applies to single-disc albums too, over the album's own found art.
+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}
+ albumRepo.SetData(model.Albums{{ID: "alsd", Name: "Album", FolderIDs: []string{"f1"}, Discs: model.Discs{1: ""}}})
+ seedFoundStore("al", "alsd", []byte("album-art-distinct"))
+ mfRepo.SetData(model.MediaFiles{{ID: "mf6", AlbumID: "alsd", DiscNumber: 1, HasCoverArt: false}})
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf6"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+ })
+
+ Describe("disc", func() {
+ It("serves a local disc-folder image", func() {
+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}
+ albumRepo.SetData(model.Albums{{ID: "aldc", Name: "Album", FolderIDs: []string{"f1"}}})
+
+ img, err := svc.Get(ctx, model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc", 1), nil), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+
+ // The resize cache keys on id + album mtime, not on the bytes, so dropping the source
+ // between the two requests is what shows a warm hit never touches the filesystem.
+ It("serves a sized disc image from cache without re-reading the source", func() {
+ folderRepo.result = []model.Folder{{Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"}}}
+ albumRepo.SetData(model.Albums{{ID: "aldc3", Name: "Album", FolderIDs: []string{"f1"}}})
+ discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc3", 1), nil)
+
+ first, err := svc.Get(ctx, discID, 64, false)
+ Expect(err).ToNot(HaveOccurred())
+ warmed := readAll(first)
+ Expect(warmed).ToNot(BeEmpty())
+
+ folderRepo.result = nil
+
+ second, err := svc.Get(ctx, discID, 64, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(second)).To(Equal(warmed), "a warm sized request must not touch the source")
+ })
+
+ // A disc image can change without the album row changing, so the key folds in ImagesUpdatedAt.
+ It("invalidates the cached image when the folder's images change", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"},
+ ImagesUpdatedAt: time.Now().Add(-time.Hour),
+ }}
+ albumRepo.SetData(model.Albums{{ID: "aldc4", Name: "Album", FolderIDs: []string{"f1"}}})
+ discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc4", 1), nil)
+
+ first, err := svc.Get(ctx, discID, 64, false)
+ Expect(err).ToNot(HaveOccurred())
+ firstKey := first.ETag
+ readAll(first)
+
+ folderRepo.result[0].ImagesUpdatedAt = time.Now()
+ second, err := svc.Get(ctx, discID, 64, false)
+ Expect(err).ToNot(HaveOccurred())
+ readAll(second)
+ Expect(second.ETag).ToNot(Equal(firstKey), "a replaced image must not keep the old cache entry")
+ })
+
+ // Disc art has no content hash, so without an explicit validator every ETag would be empty.
+ It("gives a full-size disc image a validator that tracks the source", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album", ImageFiles: []string{"cover.jpg"},
+ ImagesUpdatedAt: time.Now().Add(-time.Hour),
+ }}
+ albumRepo.SetData(model.Albums{{ID: "aldc5", Name: "Album", FolderIDs: []string{"f1"}}})
+ discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc5", 1), nil)
+
+ first, err := svc.Get(ctx, discID, 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ readAll(first)
+ Expect(first.ETag).ToNot(BeEmpty())
+
+ folderRepo.result[0].ImagesUpdatedAt = time.Now()
+ second, err := svc.Get(ctx, discID, 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ readAll(second)
+ Expect(second.ETag).ToNot(Equal(first.ETag), "a replaced image must not revalidate as unchanged")
+ })
+
+ It("falls back to album art when no disc image matches", func() {
+ folderRepo.result = nil
+ albumRepo.SetData(model.Albums{{ID: "aldc2", Name: "Album"}})
+ seedFoundStore("al", "aldc2", coverBytes)
+
+ img, err := svc.Get(ctx, model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID("aldc2", 1), nil), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+ })
+
+ Describe("GetOrPlaceholder", func() {
+ It("accepts a raw entity id and serves its cover art", func() {
+ albumRepo.SetData(model.Albums{{ID: "rawal", Name: "Album"}})
+ seedFoundStore("al", "rawal", coverBytes)
+
+ img, err := svc.GetOrPlaceholder(ctx, "rawal", 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(img.Placeholder).To(BeFalse())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+
+ It("falls back to the album placeholder ignoring size and square", func() {
+ img, err := svc.GetOrPlaceholder(ctx, "", 300, true)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(img.Placeholder).To(BeTrue())
+ Expect(img.Hash).To(BeEmpty())
+ Expect(img.LastUpdated).To(BeZero())
+
+ ph, err := resources.FS().Open(consts.PlaceholderAlbumArt)
+ Expect(err).ToNot(HaveOccurred())
+ phBytes, _ := io.ReadAll(ph)
+ Expect(readAll(img)).To(Equal(phBytes))
+ })
+
+ It("falls back to the artist placeholder for an absent artist", func() {
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "arph"})).To(Succeed())
+
+ img, err := svc.GetOrPlaceholder(ctx, "ar-arph", 300, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(img.Placeholder).To(BeTrue())
+
+ ph, err := resources.FS().Open(consts.PlaceholderArtistArt)
+ Expect(err).ToNot(HaveOccurred())
+ phBytes, _ := io.ReadAll(ph)
+ Expect(readAll(img)).To(Equal(phBytes))
+ })
+
+ // "No art" and "no such entity" are different answers: clients 404 only on the latter.
+ It("reports not-found rather than a placeholder for an id with no entity", func() {
+ _, err := svc.GetOrPlaceholder(ctx, "al-nosuchalbum", 0, false)
+ Expect(err).To(MatchError(model.ErrNotFound))
+
+ _, err = svc.GetOrPlaceholder(ctx, "nosuchrawid", 0, false)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+ })
+})
+
+func fileMtime(path string) int64 {
+ GinkgoHelper()
+ info, err := os.Stat(path)
+ Expect(err).ToNot(HaveOccurred())
+ return info.ModTime().UnixNano()
+}
+
+var _ = Describe("EntityExists", func() {
+ var ctx context.Context
+ var ds *tests.MockDataStore
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ albumRepo := tests.CreateMockAlbumRepo()
+ albumRepo.SetData(model.Albums{{ID: "al1"}})
+ artistRepo := tests.CreateMockArtistRepo()
+ artistRepo.SetData(model.Artists{{ID: "ar1"}})
+ radioRepo := tests.CreateMockedRadioRepo()
+ Expect(radioRepo.Put(&model.Radio{ID: "ra1", Name: "R"})).To(Succeed())
+ ds = &tests.MockDataStore{MockedAlbum: albumRepo, MockedArtist: artistRepo, MockedRadio: radioRepo}
+ })
+
+ DescribeTable("reports whether the owning entity is still there",
+ func(id string, expected bool) {
+ Expect(entityExists(ctx, ds, model.MustParseArtworkID(id))).To(Equal(expected))
+ },
+ Entry("existing album", "al-al1", true),
+ Entry("deleted album", "al-gone", false),
+ Entry("existing artist", "ar-ar1", true),
+ Entry("deleted artist", "ar-gone", false),
+ Entry("existing radio", "ra-ra1", true),
+ Entry("deleted radio", "ra-gone", false),
+ // Disc art has no entity of its own; it stands or falls with its album.
+ Entry("disc of an existing album", "dc-al1:1", true),
+ Entry("disc of a deleted album", "dc-gone:1", false),
+ Entry("malformed disc id", "dc-nodiscnum", false),
+ )
})
diff --git a/core/artwork/benchmark_e2e_test.go b/core/artwork/benchmark_e2e_test.go
deleted file mode 100644
index bf3d435a8..000000000
--- a/core/artwork/benchmark_e2e_test.go
+++ /dev/null
@@ -1,189 +0,0 @@
-package artwork
-
-import (
- "context"
- "fmt"
- "image/jpeg"
- "io"
- "os"
- "path/filepath"
- "runtime"
- "sync"
- "testing"
- "time"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/tests"
- "github.com/navidrome/navidrome/utils/cache"
-)
-
-// setupE2EBenchmark creates an artwork instance with a real album cover image on disk,
-// backed by either a real file cache or disabled cache depending on cacheSize.
-// Note: This benchmarks artwork.Get() directly (not the full HTTP handler), which covers
-// the critical path (source selection, decode, resize, encode, cache). This is a deliberate
-// spec deviation — the full HTTP round-trip benchmark requires significant infrastructure
-// (DB, scanner, fake filesystem) and can be added later if HTTP overhead proves significant.
-//
-// Depends on fakeFolderRepo defined in reader_artist_test.go (same package, compiled together).
-func setupE2EBenchmark(b *testing.B, cacheSize string) (Artwork, model.ArtworkID, func()) {
- b.Helper()
- cleanup := configtest.SetupConfig()
- b.Cleanup(cleanup)
-
- tmpDir, err := os.MkdirTemp("", "artwork-bench-*")
- if err != nil {
- b.Fatal(err)
- }
-
- // Create a realistic cover image on disk
- coverPath := filepath.Join(tmpDir, "cover.jpg")
- coverImg := generateGradientImage(1000, 1000)
- f, err := os.Create(coverPath)
- if err != nil {
- b.Fatal(err)
- }
- if err := jpeg.Encode(f, coverImg, &jpeg.Options{Quality: 90}); err != nil {
- f.Close()
- b.Fatal(err)
- }
- f.Close()
-
- // Configure cache
- conf.Server.ImageCacheSize = cacheSize
- conf.Server.CacheFolder = conf.NewDir(tmpDir)
- conf.Server.CoverArtQuality = 75
- conf.Server.CoverArtPriority = "cover.*"
-
- // Set up mock data store with album pointing to our cover.
- // Set UpdatedAt so CoverArtID().LastUpdate is consistent across calls.
- album := model.Album{
- ID: "bench-album-1",
- Name: "Benchmark Album",
- FolderIDs: []string{"f1"},
- UpdatedAt: time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),
- }
- folderRepo := &fakeFolderRepo{
- result: []model.Folder{{
- Path: tmpDir,
- ImageFiles: []string{"cover.jpg"},
- }},
- }
- ds := &tests.MockDataStore{
- MockedTranscoding: &tests.MockTranscodingRepo{},
- MockedFolder: folderRepo,
- }
- ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{album})
-
- artID := album.CoverArtID()
-
- imgCache := cache.NewFileCache("BenchImage", cacheSize, "bench-images", 0,
- func(ctx context.Context, arg cache.Item) (io.Reader, error) {
- r, _, err := arg.(artworkReader).Reader(ctx)
- return r, err
- })
-
- // Wait for cache init if enabled
- if cacheSize != "0" {
- for !imgCache.Available(context.Background()) && !imgCache.Disabled(context.Background()) {
- runtime.Gosched() // Yield to allow background init goroutine to run
- }
- }
-
- ffmpeg := tests.NewMockFFmpeg("fallback content")
- aw := NewArtwork(ds, imgCache, ffmpeg, nil)
-
- cleanupAll := func() {
- os.RemoveAll(tmpDir)
- }
- return aw, artID, cleanupAll
-}
-
-func BenchmarkArtworkGetE2E(b *testing.B) {
- cacheConfigs := []struct {
- name string
- cacheSize string
- }{
- {"no_cache", "0"},
- {"with_cache", "100MB"},
- }
- sizes := []int{0, 300}
-
- for _, cc := range cacheConfigs {
- for _, size := range sizes {
- b.Run(fmt.Sprintf("%s/size_%d", cc.name, size), func(b *testing.B) {
- aw, artID, cleanup := setupE2EBenchmark(b, cc.cacheSize)
- defer cleanup()
-
- // Warm the cache on first call if cache is enabled
- if cc.cacheSize != "0" {
- r, _, err := aw.Get(context.Background(), artID, size, size > 0)
- if err != nil {
- b.Fatal(err)
- }
- _, _ = io.ReadAll(r)
- r.Close()
- }
-
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- r, _, err := aw.Get(context.Background(), artID, size, size > 0)
- if err != nil {
- b.Fatal(err)
- }
- _, _ = io.ReadAll(r)
- r.Close()
- }
- })
- }
- }
-}
-
-func BenchmarkArtworkGetE2EConcurrent(b *testing.B) {
- cacheConfigs := []struct {
- name string
- cacheSize string
- }{
- {"no_cache", "0"},
- {"with_cache", "100MB"},
- }
- concurrencyLevels := []int{10, 50}
-
- for _, cc := range cacheConfigs {
- for _, n := range concurrencyLevels {
- b.Run(fmt.Sprintf("%s/goroutines_%d", cc.name, n), func(b *testing.B) {
- aw, artID, cleanup := setupE2EBenchmark(b, cc.cacheSize)
- defer cleanup()
-
- // Warm cache
- if cc.cacheSize != "0" {
- r, _, _ := aw.Get(context.Background(), artID, 300, true)
- if r != nil {
- _, _ = io.ReadAll(r)
- r.Close()
- }
- }
-
- b.ResetTimer()
- for i := 0; i < b.N; i++ {
- var wg sync.WaitGroup
- wg.Add(n)
- for range n {
- go func() {
- defer wg.Done()
- r, _, err := aw.Get(context.Background(), artID, 300, true)
- if err != nil {
- b.Error(err)
- return
- }
- _, _ = io.ReadAll(r)
- r.Close()
- }()
- }
- wg.Wait()
- }
- })
- }
- }
-}
diff --git a/core/artwork/benchmark_helpers_test.go b/core/artwork/benchmark_helpers_test.go
index 0076506f3..f3201d412 100644
--- a/core/artwork/benchmark_helpers_test.go
+++ b/core/artwork/benchmark_helpers_test.go
@@ -4,6 +4,7 @@ import (
"bytes"
"image"
"image/color"
+ "image/draw"
"image/jpeg"
"image/png"
"testing"
@@ -45,3 +46,11 @@ func generateGradientImage(width, height int) *image.RGBA {
}
return img
}
+
+// gradientNRGBA mirrors generateGradientImage in the type makeThumbnail hands the encoders.
+func gradientNRGBA(size int) *image.NRGBA {
+ src := generateGradientImage(size, size)
+ dst := image.NewNRGBA(src.Bounds())
+ draw.Draw(dst, dst.Bounds(), src, src.Bounds().Min, draw.Src)
+ return dst
+}
diff --git a/core/artwork/blurhash/blurhash.go b/core/artwork/blurhash/blurhash.go
new file mode 100644
index 000000000..ca5bf7026
--- /dev/null
+++ b/core/artwork/blurhash/blurhash.go
@@ -0,0 +1,191 @@
+// Package blurhash implements the blurhash encoding (https://github.com/woltapp/blurhash),
+// parameterized to match Jellyfin so clients see equivalent hashes.
+package blurhash
+
+import (
+ "errors"
+ "image"
+ "image/draw"
+ "math"
+ "strings"
+ "sync"
+
+ xdraw "golang.org/x/image/draw"
+)
+
+const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"
+
+// maxInputSize: larger inputs are slower with no visible difference in the result.
+const maxInputSize = 128
+
+// components picks x/y component counts targeting ~16 near-square tiles.
+func components(width, height int) (int, int) {
+ xf := math.Sqrt(16.0 * float64(width) / float64(height))
+ yf := xf * float64(height) / float64(width)
+ return min(int(xf)+1, 9), min(int(yf)+1, 9)
+}
+
+// Encode returns the blurhash of img, deriving the component counts from its aspect ratio.
+func Encode(img image.Image) (string, error) {
+ if img.Bounds().Dx() == 0 || img.Bounds().Dy() == 0 {
+ return "", errors.New("blurhash: empty image")
+ }
+ // Pre-downscale: its rounding can flip a component count, and the hash is a client cache key.
+ xComp, yComp := components(img.Bounds().Dx(), img.Bounds().Dy())
+ src := pixelsOf(downscale(img))
+ w, h := src.w, src.h
+
+ cosX := make([][]float64, xComp)
+ for i := range cosX {
+ cosX[i] = make([]float64, w)
+ for x := range cosX[i] {
+ cosX[i][x] = math.Cos(math.Pi * float64(i) * float64(x) / float64(w))
+ }
+ }
+ cosY := make([][]float64, yComp)
+ for j := range cosY {
+ cosY[j] = make([]float64, h)
+ for y := range cosY[j] {
+ cosY[j][y] = math.Cos(math.Pi * float64(j) * float64(y) / float64(h))
+ }
+ }
+
+ lin := srgbToLinearTable()
+ factors := make([][3]float64, xComp*yComp)
+ for y := range h {
+ row := src.pix[y*src.stride:]
+ for x := range w {
+ p := x * 4
+ r, g, b := row[p], row[p+1], row[p+2]
+ if src.straight {
+ r, g, b = premultiply(r, g, b, row[p+3])
+ }
+ lr, lg, lb := lin[r], lin[g], lin[b]
+ for j := range yComp {
+ for i := range xComp {
+ basis := cosX[i][x] * cosY[j][y]
+ f := &factors[j*xComp+i]
+ f[0] += basis * lr
+ f[1] += basis * lg
+ f[2] += basis * lb
+ }
+ }
+ }
+ }
+ for idx := range factors {
+ norm := 2.0
+ if idx == 0 {
+ norm = 1.0
+ }
+ scale := norm / float64(w*h)
+ factors[idx][0] *= scale
+ factors[idx][1] *= scale
+ factors[idx][2] *= scale
+ }
+
+ var sb strings.Builder
+ sb.WriteString(encode83((xComp-1)+(yComp-1)*9, 1))
+
+ // Derived counts are at least 1x9, so there is always at least one AC factor.
+ ac := factors[1:]
+ actualMax := 0.0
+ for _, f := range ac {
+ actualMax = max(actualMax, math.Abs(f[0]), math.Abs(f[1]), math.Abs(f[2]))
+ }
+ quantMax := int(max(0, min(82, math.Floor(actualMax*166-0.5))))
+ maxVal := float64(quantMax+1) / 166
+ sb.WriteString(encode83(quantMax, 1))
+
+ dc := factors[0]
+ sb.WriteString(encode83(linearToSRGB(dc[0])<<16|linearToSRGB(dc[1])<<8|linearToSRGB(dc[2]), 4))
+ for _, f := range ac {
+ sb.WriteString(encode83(quantAC(f[0], maxVal)*19*19+quantAC(f[1], maxVal)*19+quantAC(f[2], maxVal), 2))
+ }
+ return sb.String(), nil
+}
+
+// pixels is direct Pix access for the pixel loop, avoiding a per-pixel allocation via image.At.
+type pixels struct {
+ pix []uint8
+ stride int
+ w, h int
+ // straight marks non-premultiplied alpha, which the loop premultiplies to keep the hash
+ // identical to the one an equivalent *image.RGBA produces.
+ straight bool
+}
+
+// pixelsOf accepts the two types the artwork pipeline produces without copying, and converts
+// anything else.
+func pixelsOf(img image.Image) pixels {
+ b := img.Bounds()
+ switch src := img.(type) {
+ case *image.RGBA:
+ return pixels{pix: src.Pix, stride: src.Stride, w: b.Dx(), h: b.Dy()}
+ case *image.NRGBA:
+ return pixels{pix: src.Pix, stride: src.Stride, w: b.Dx(), h: b.Dy(), straight: true}
+ }
+ dst := image.NewRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))
+ draw.Draw(dst, dst.Bounds(), img, b.Min, draw.Src)
+ return pixels{pix: dst.Pix, stride: dst.Stride, w: b.Dx(), h: b.Dy()}
+}
+
+func premultiply(r, g, b, a uint8) (uint8, uint8, uint8) {
+ if a == 255 {
+ return r, g, b
+ }
+ return uint8(uint32(r) * uint32(a) / 255), uint8(uint32(g) * uint32(a) / 255), uint8(uint32(b) * uint32(a) / 255)
+}
+
+var srgbToLinearTable = sync.OnceValue(func() *[256]float64 {
+ var t [256]float64
+ for i := range t {
+ t[i] = srgbToLinear(i)
+ }
+ return &t
+})
+
+func downscale(img image.Image) image.Image {
+ b := img.Bounds()
+ w, h := b.Dx(), b.Dy()
+ if w <= maxInputSize && h <= maxInputSize {
+ return img
+ }
+ scale := float64(maxInputSize) / float64(max(w, h))
+ dst := image.NewRGBA(image.Rect(0, 0, max(1, int(float64(w)*scale)), max(1, int(float64(h)*scale))))
+ xdraw.ApproxBiLinear.Scale(dst, dst.Bounds(), img, b, draw.Src, nil)
+ return dst
+}
+
+func quantAC(v, maxVal float64) int {
+ return int(max(0, min(18, math.Floor(signPow(v/maxVal, 0.5)*9+9.5))))
+}
+
+func signPow(v, exp float64) float64 {
+ return math.Copysign(math.Pow(math.Abs(v), exp), v)
+}
+
+func srgbToLinear(v int) float64 {
+ f := float64(v) / 255
+ if f <= 0.04045 {
+ return f / 12.92
+ }
+ return math.Pow((f+0.055)/1.055, 2.4)
+}
+
+func linearToSRGB(v float64) int {
+ v = min(max(0, v), 1)
+ if v <= 0.0031308 {
+ return int(v*12.92*255 + 0.5)
+ }
+ return int((1.055*math.Pow(v, 1/2.4)-0.055)*255 + 0.5)
+}
+
+// encode83 encodes value as a fixed-width, big-endian base83 string of the given length.
+func encode83(value, length int) string {
+ b := make([]byte, length)
+ for i := length - 1; i >= 0; i-- {
+ b[i] = alphabet[value%83]
+ value /= 83
+ }
+ return string(b)
+}
diff --git a/core/artwork/blurhash/blurhash_suite_test.go b/core/artwork/blurhash/blurhash_suite_test.go
new file mode 100644
index 000000000..b0e96d7a7
--- /dev/null
+++ b/core/artwork/blurhash/blurhash_suite_test.go
@@ -0,0 +1,17 @@
+package blurhash_test
+
+import (
+ "testing"
+
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+func TestBlurHash(t *testing.T) {
+ tests.Init(t, false)
+ log.SetLevel(log.LevelFatal)
+ RegisterFailHandler(Fail)
+ RunSpecs(t, "BlurHash Suite")
+}
diff --git a/core/artwork/blurhash/blurhash_test.go b/core/artwork/blurhash/blurhash_test.go
new file mode 100644
index 000000000..91187165e
--- /dev/null
+++ b/core/artwork/blurhash/blurhash_test.go
@@ -0,0 +1,137 @@
+package blurhash_test
+
+import (
+ "image"
+ "image/color"
+ "strings"
+
+ "github.com/navidrome/navidrome/core/artwork/blurhash"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"
+
+func decode83(s string) int {
+ v := 0
+ for _, c := range s {
+ v = v*83 + strings.IndexRune(alphabet, c)
+ }
+ return v
+}
+
+func solidImage(w, h int, c color.NRGBA) image.Image {
+ img := image.NewNRGBA(image.Rect(0, 0, w, h))
+ for y := range h {
+ for x := range w {
+ img.SetNRGBA(x, y, c)
+ }
+ }
+ return img
+}
+
+func gradientImage(w, h int) image.Image {
+ img := image.NewNRGBA(image.Rect(0, 0, w, h))
+ for y := range h {
+ for x := range w {
+ img.SetNRGBA(x, y, color.NRGBA{R: uint8(255 * x / w), G: uint8(255 * y / h), B: 128, A: 255})
+ }
+ }
+ return img
+}
+
+var _ = Describe("Encode input types", func() {
+ // The pipeline hands Encode an *image.NRGBA; reading it must stay equivalent to the
+ // premultiplied *image.RGBA it used to receive, or every hash silently shifts.
+ buildPair := func(alpha uint8) (*image.NRGBA, *image.RGBA) {
+ const size = 40
+ nrgba := image.NewNRGBA(image.Rect(0, 0, size, size))
+ rgba := image.NewRGBA(image.Rect(0, 0, size, size))
+ for y := range size {
+ for x := range size {
+ c := color.NRGBA{
+ R: uint8(255 * x / size), G: uint8(255 * y / size),
+ B: uint8((x + y) * 255 / (2 * size)), A: alpha,
+ }
+ nrgba.SetNRGBA(x, y, c)
+ rgba.Set(x, y, c) // image.RGBA.Set premultiplies
+ }
+ }
+ return nrgba, rgba
+ }
+
+ DescribeTable("gives an NRGBA the same hash as the premultiplied RGBA it replaces",
+ func(alpha uint8) {
+ nrgba, rgba := buildPair(alpha)
+ fromNRGBA, err := blurhash.Encode(nrgba)
+ Expect(err).ToNot(HaveOccurred())
+ fromRGBA, err := blurhash.Encode(rgba)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(fromNRGBA).To(Equal(fromRGBA))
+ },
+ Entry("opaque", uint8(255)),
+ Entry("partly transparent", uint8(128)),
+ Entry("fully transparent, which premultiplication crushes to black", uint8(0)),
+ )
+})
+
+var _ = Describe("Encode", func() {
+ // The size flag encodes (xComp-1) + (yComp-1)*9.
+ DescribeTable("derives component counts from aspect ratio (Jellyfin formula)",
+ func(w, h, expectedX, expectedY int) {
+ hash, err := blurhash.Encode(gradientImage(w, h))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(decode83(hash[:1])).To(Equal((expectedX - 1) + (expectedY-1)*9))
+ },
+ Entry("square album art", 60, 60, 5, 5),
+ Entry("smallest square", 1, 1, 5, 5),
+ Entry("landscape 16:9", 192, 108, 6, 4),
+ Entry("portrait 9:16", 108, 192, 4, 6),
+ Entry("extreme landscape capped at 9", 1000, 10, 9, 1),
+ Entry("extreme portrait capped at 9", 10, 1000, 1, 9),
+ )
+
+ It("rejects an empty image", func() {
+ _, err := blurhash.Encode(image.NewNRGBA(image.Rect(0, 0, 0, 0)))
+ Expect(err).To(HaveOccurred())
+ })
+
+ It("produces the spec-mandated length", func() {
+ // 1 (size flag) + 1 (max AC) + 4 (DC) + 2 per AC component; a square derives 5x5
+ h, err := blurhash.Encode(solidImage(8, 8, color.NRGBA{R: 10, G: 20, B: 30, A: 255}))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(h).To(HaveLen(4 + 2 + 2*(5*5-1)))
+ })
+
+ It("stores the average color in the DC component", func() {
+ h, err := blurhash.Encode(solidImage(16, 16, color.NRGBA{R: 200, G: 100, B: 50, A: 255}))
+ Expect(err).ToNot(HaveOccurred())
+ dc := decode83(h[2:6])
+ Expect(dc >> 16).To(BeNumerically("~", 200, 1))
+ Expect((dc >> 8) & 0xFF).To(BeNumerically("~", 100, 1))
+ Expect(dc & 0xFF).To(BeNumerically("~", 50, 1))
+ })
+
+ It("is deterministic", func() {
+ img := gradientImage(64, 64)
+ h1, err1 := blurhash.Encode(img)
+ h2, err2 := blurhash.Encode(img)
+ Expect(err1).ToNot(HaveOccurred())
+ Expect(err2).ToNot(HaveOccurred())
+ Expect(h1).To(Equal(h2))
+ })
+
+ It("produces different hashes for different images", func() {
+ h1, _ := blurhash.Encode(solidImage(16, 16, color.NRGBA{R: 255, A: 255}))
+ h2, _ := blurhash.Encode(gradientImage(16, 16))
+ Expect(h1).ToNot(Equal(h2))
+ })
+
+ It("downscales large images internally without changing the result materially", func() {
+ big, err := blurhash.Encode(solidImage(1000, 1000, color.NRGBA{R: 60, G: 120, B: 180, A: 255}))
+ Expect(err).ToNot(HaveOccurred())
+ small, err := blurhash.Encode(solidImage(16, 16, color.NRGBA{R: 60, G: 120, B: 180, A: 255}))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(big[2:6]).To(Equal(small[2:6]))
+ })
+})
diff --git a/core/artwork/cache_warmer.go b/core/artwork/cache_warmer.go
deleted file mode 100644
index 5090d638e..000000000
--- a/core/artwork/cache_warmer.go
+++ /dev/null
@@ -1,162 +0,0 @@
-package artwork
-
-import (
- "context"
- "fmt"
- "io"
- "maps"
- "slices"
- "sync"
- "time"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/log"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/model/request"
- "github.com/navidrome/navidrome/utils/cache"
- "github.com/navidrome/navidrome/utils/pl"
-)
-
-type CacheWarmer interface {
- PreCache(artID model.ArtworkID)
-}
-
-// NewCacheWarmer creates a new CacheWarmer instance. The CacheWarmer will pre-cache Artwork images in the background
-// to speed up the response time when the image is requested by the UI. The cache is pre-populated with the original
-// image size, as well as the size defined by the UICoverArtSize config option.
-func NewCacheWarmer(artwork Artwork, cache cache.FileCache) CacheWarmer {
- // If image cache is disabled, return a NOOP implementation
- if conf.Server.ImageCacheSize == "0" || !conf.Server.EnableArtworkPrecache {
- return &noopCacheWarmer{}
- }
-
- // If the file cache is disabled, return a NOOP implementation
- if cache.Disabled(context.Background()) {
- log.Debug("Image cache disabled. Cache warmer will not run")
- return &noopCacheWarmer{}
- }
-
- a := &cacheWarmer{
- artwork: artwork,
- cache: cache,
- buffer: make(map[model.ArtworkID]struct{}),
- wakeSignal: make(chan struct{}, 1),
- coverArtSize: conf.Server.UICoverArtSize,
- }
-
- // Create a context with a fake admin user, to be able to pre-cache Playlist CoverArts
- ctx := request.WithUser(context.TODO(), model.User{IsAdmin: true})
- go a.run(ctx)
- return a
-}
-
-type cacheWarmer struct {
- artwork Artwork
- buffer map[model.ArtworkID]struct{}
- mutex sync.Mutex
- cache cache.FileCache
- wakeSignal chan struct{}
- coverArtSize int
-}
-
-func (a *cacheWarmer) PreCache(artID model.ArtworkID) {
- if a.cache.Disabled(context.Background()) {
- return
- }
- a.mutex.Lock()
- defer a.mutex.Unlock()
- a.buffer[artID] = struct{}{}
- a.sendWakeSignal()
-}
-
-func (a *cacheWarmer) sendWakeSignal() {
- // Don't block if the previous signal was not read yet
- select {
- case a.wakeSignal <- struct{}{}:
- default:
- }
-}
-
-func (a *cacheWarmer) run(ctx context.Context) {
- for {
- a.waitSignal(ctx, 10*time.Second)
- if ctx.Err() != nil {
- break
- }
-
- if a.cache.Disabled(ctx) {
- a.mutex.Lock()
- pending := len(a.buffer)
- a.buffer = make(map[model.ArtworkID]struct{})
- a.mutex.Unlock()
- if pending > 0 {
- log.Trace(ctx, "Cache disabled, discarding precache buffer", "bufferLen", pending)
- }
- return
- }
-
- // If cache not available, keep waiting
- if !a.cache.Available(ctx) {
- a.mutex.Lock()
- bufferLen := len(a.buffer)
- a.mutex.Unlock()
- if bufferLen > 0 {
- log.Trace(ctx, "Cache not available, buffering precache request", "bufferLen", bufferLen)
- }
- continue
- }
-
- a.mutex.Lock()
-
- // If there's nothing to send, keep waiting
- if len(a.buffer) == 0 {
- a.mutex.Unlock()
- continue
- }
-
- batch := slices.Collect(maps.Keys(a.buffer))
- a.buffer = make(map[model.ArtworkID]struct{})
- a.mutex.Unlock()
-
- a.processBatch(ctx, batch)
- }
-}
-
-func (a *cacheWarmer) waitSignal(ctx context.Context, timeout time.Duration) {
- select {
- case <-time.After(timeout):
- case <-a.wakeSignal:
- case <-ctx.Done():
- }
-}
-
-func (a *cacheWarmer) processBatch(ctx context.Context, batch []model.ArtworkID) {
- log.Trace(ctx, "PreCaching a new batch of artwork", "batchSize", len(batch))
- input := pl.FromSlice(ctx, batch)
- errs := pl.Sink(ctx, 4, input, a.doCacheImage)
- for err := range errs {
- log.Debug(ctx, "Error warming cache", err)
- }
-}
-
-func (a *cacheWarmer) doCacheImage(ctx context.Context, id model.ArtworkID) error {
- ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
- defer cancel()
-
- size := a.coverArtSize
- r, _, err := a.artwork.Get(ctx, id, size, true)
- if err != nil {
- return fmt.Errorf("caching id='%s', size=%d: %w", id, size, err)
- }
- _, err = io.Copy(io.Discard, r)
- r.Close()
- return err
-}
-
-func NoopCacheWarmer() CacheWarmer {
- return &noopCacheWarmer{}
-}
-
-type noopCacheWarmer struct{}
-
-func (a *noopCacheWarmer) PreCache(model.ArtworkID) {}
diff --git a/core/artwork/cache_warmer_test.go b/core/artwork/cache_warmer_test.go
deleted file mode 100644
index a5da2004c..000000000
--- a/core/artwork/cache_warmer_test.go
+++ /dev/null
@@ -1,245 +0,0 @@
-package artwork
-
-import (
- "context"
- "errors"
- "fmt"
- "io"
- "strings"
- "sync"
- "sync/atomic"
- "time"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/utils/cache"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("CacheWarmer", func() {
- var (
- fc *mockFileCache
- aw *mockArtwork
- )
-
- BeforeEach(func() {
- DeferCleanup(configtest.SetupConfig())
- fc = &mockFileCache{}
- aw = &mockArtwork{}
- })
-
- Context("initialization", func() {
- It("returns noop when cache is disabled", func() {
- fc.SetDisabled(true)
- cw := NewCacheWarmer(aw, fc)
- _, ok := cw.(*noopCacheWarmer)
- Expect(ok).To(BeTrue())
- })
-
- It("returns noop when ImageCacheSize is 0", func() {
- conf.Server.ImageCacheSize = "0"
- cw := NewCacheWarmer(aw, fc)
- _, ok := cw.(*noopCacheWarmer)
- Expect(ok).To(BeTrue())
- })
-
- It("returns noop when EnableArtworkPrecache is false", func() {
- conf.Server.EnableArtworkPrecache = false
- cw := NewCacheWarmer(aw, fc)
- _, ok := cw.(*noopCacheWarmer)
- Expect(ok).To(BeTrue())
- })
-
- It("returns real implementation when properly configured", func() {
- conf.Server.ImageCacheSize = "100MB"
- conf.Server.EnableArtworkPrecache = true
- fc.SetDisabled(false)
- cw := NewCacheWarmer(aw, fc)
- _, ok := cw.(*cacheWarmer)
- Expect(ok).To(BeTrue())
- })
- })
-
- Context("buffer management", func() {
- BeforeEach(func() {
- conf.Server.ImageCacheSize = "100MB"
- conf.Server.EnableArtworkPrecache = true
- fc.SetDisabled(false)
- })
-
- It("drops buffered items when cache becomes disabled", func() {
- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
- cw.PreCache(model.MustParseArtworkID("al-test"))
- fc.SetDisabled(true)
- Eventually(func() int {
- cw.mutex.Lock()
- defer cw.mutex.Unlock()
- return len(cw.buffer)
- }).Should(Equal(0))
- })
-
- It("adds multiple items to buffer", func() {
- fc.SetReady(false) // Make cache unavailable so items stay in buffer
- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
- cw.PreCache(model.MustParseArtworkID("al-1"))
- cw.PreCache(model.MustParseArtworkID("al-2"))
- cw.mutex.Lock()
- defer cw.mutex.Unlock()
- Expect(len(cw.buffer)).To(Equal(2))
- })
-
- It("deduplicates items in buffer", func() {
- fc.SetReady(false) // Make cache unavailable so items stay in buffer
- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
- cw.PreCache(model.MustParseArtworkID("al-1"))
- cw.PreCache(model.MustParseArtworkID("al-1"))
- cw.mutex.Lock()
- defer cw.mutex.Unlock()
- Expect(len(cw.buffer)).To(Equal(1))
- })
- })
-
- Context("error handling", func() {
- BeforeEach(func() {
- conf.Server.ImageCacheSize = "100MB"
- conf.Server.EnableArtworkPrecache = true
- fc.SetDisabled(false)
- })
-
- It("continues processing after artwork retrieval error", func() {
- aw.err = errors.New("artwork error")
- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
- cw.PreCache(model.MustParseArtworkID("al-error"))
- cw.PreCache(model.MustParseArtworkID("al-1"))
-
- Eventually(func() int {
- cw.mutex.Lock()
- defer cw.mutex.Unlock()
- return len(cw.buffer)
- }).Should(Equal(0))
- })
-
- It("continues processing after cache error", func() {
- fc.err = errors.New("cache error")
- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
- cw.PreCache(model.MustParseArtworkID("al-error"))
- cw.PreCache(model.MustParseArtworkID("al-1"))
-
- Eventually(func() int {
- cw.mutex.Lock()
- defer cw.mutex.Unlock()
- return len(cw.buffer)
- }).Should(Equal(0))
- })
- })
-
- Context("background processing", func() {
- BeforeEach(func() {
- conf.Server.ImageCacheSize = "100MB"
- conf.Server.EnableArtworkPrecache = true
- fc.SetDisabled(false)
- })
-
- It("processes items in batches", func() {
- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
- for i := range 5 {
- cw.PreCache(model.MustParseArtworkID(fmt.Sprintf("al-%d", i)))
- }
-
- Eventually(func() int {
- cw.mutex.Lock()
- defer cw.mutex.Unlock()
- return len(cw.buffer)
- }).Should(Equal(0))
- })
-
- It("wakes up on new items", func() {
- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
-
- // Add first batch
- cw.PreCache(model.MustParseArtworkID("al-1"))
- Eventually(func() int {
- cw.mutex.Lock()
- defer cw.mutex.Unlock()
- return len(cw.buffer)
- }).Should(Equal(0))
-
- // Add second batch
- cw.PreCache(model.MustParseArtworkID("al-2"))
- Eventually(func() int {
- cw.mutex.Lock()
- defer cw.mutex.Unlock()
- return len(cw.buffer)
- }).Should(Equal(0))
- })
-
- It("pre-caches UICoverArtSize", func() {
- cw := NewCacheWarmer(aw, fc).(*cacheWarmer)
- cw.PreCache(model.MustParseArtworkID("al-1"))
-
- Eventually(func() []int {
- return aw.getCachedSizes()
- }).Should(ContainElements(conf.Server.UICoverArtSize))
- })
- })
-})
-
-type mockArtwork struct {
- err error
- mu sync.Mutex
- cachedSizes []int
-}
-
-func (m *mockArtwork) Get(ctx context.Context, artID model.ArtworkID, size int, square bool) (io.ReadCloser, time.Time, error) {
- if m.err != nil {
- return nil, time.Time{}, m.err
- }
- m.mu.Lock()
- m.cachedSizes = append(m.cachedSizes, size)
- m.mu.Unlock()
- return io.NopCloser(strings.NewReader("test")), time.Now(), nil
-}
-
-func (m *mockArtwork) getCachedSizes() []int {
- m.mu.Lock()
- defer m.mu.Unlock()
- result := make([]int, len(m.cachedSizes))
- copy(result, m.cachedSizes)
- return result
-}
-
-func (m *mockArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error) {
- return m.Get(ctx, model.ArtworkID{}, size, square)
-}
-
-type mockFileCache struct {
- disabled atomic.Bool
- ready atomic.Bool
- err error
-}
-
-func (f *mockFileCache) Get(ctx context.Context, item cache.Item) (*cache.CachedStream, error) {
- if f.err != nil {
- return nil, f.err
- }
- return &cache.CachedStream{Reader: io.NopCloser(strings.NewReader("cached"))}, nil
-}
-
-func (f *mockFileCache) Available(ctx context.Context) bool {
- return f.ready.Load() && !f.disabled.Load()
-}
-
-func (f *mockFileCache) Disabled(ctx context.Context) bool {
- return f.disabled.Load()
-}
-
-func (f *mockFileCache) SetDisabled(v bool) {
- f.disabled.Store(v)
- f.ready.Store(true)
-}
-
-func (f *mockFileCache) SetReady(v bool) {
- f.ready.Store(v)
-}
diff --git a/core/artwork/reader_disc.go b/core/artwork/disc.go
similarity index 60%
rename from core/artwork/reader_disc.go
rename to core/artwork/disc.go
index 0f648c987..21f596b60 100644
--- a/core/artwork/reader_disc.go
+++ b/core/artwork/disc.go
@@ -2,7 +2,6 @@ package artwork
import (
"context"
- "crypto/md5"
"fmt"
"io"
"path"
@@ -12,16 +11,16 @@ import (
"time"
"github.com/Masterminds/squirrel"
- "github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/core/ffmpeg"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/utils"
+ "github.com/navidrome/navidrome/utils/slice"
)
+// discArtworkReader resolves disc-level artwork from a library's folder images
+// and embedded tags. It is used by the serving path's provisional disc read-through.
type discArtworkReader struct {
- cacheKey
- a *artwork
album model.Album
discNumber int
imgFiles []string // library-relative, forward-slash, no leading slash
@@ -29,27 +28,40 @@ type discArtworkReader struct {
isMultiFolder bool
firstTrackRel string // library-relative; for fromTag / ffmpeg via lib.Abs
lib libraryView
- updatedAt *time.Time
+ // Newest ImagesUpdatedAt across the album's and this disc's folders: an image can be
+ // replaced without the album row changing, so this is what makes a cache key notice it.
+ imagesUpdatedAt time.Time
}
-func newDiscArtworkReader(ctx context.Context, a *artwork, artID model.ArtworkID) (*discArtworkReader, error) {
+// cacheTime is the disc image's validity stamp: any of these moving means the selection may
+// have changed.
+func (d *discArtworkReader) cacheTime() time.Time {
+ return utils.TimeNewest(d.album.UpdatedAt, d.album.ImportedAt, d.imagesUpdatedAt)
+}
+
+func newDiscArtworkReader(ctx context.Context, ds model.DataStore, artID model.ArtworkID) (*discArtworkReader, error) {
albumID, discNumber, err := model.ParseDiscArtworkID(artID.ID)
if err != nil {
return nil, fmt.Errorf("invalid disc artwork id '%s': %w", artID.ID, err)
}
- al, err := a.ds.Album(ctx).Get(albumID)
+ al, err := ds.Album(ctx).Get(albumID)
if err != nil {
return nil, err
}
- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, a.ds, *al)
+ _, imgFiles, albumImagesAt, err := loadAlbumFoldersPaths(ctx, ds, *al)
if err != nil {
return nil, err
}
+ var imagesUpdatedAt time.Time
+ if albumImagesAt != nil {
+ imagesUpdatedAt = *albumImagesAt
+ }
+
// Query mediafiles for this album + disc to find folder associations and first track
- mfs, err := a.ds.MediaFile(ctx).GetAll(model.QueryOptions{
+ mfs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
Sort: "track_number",
Order: "ASC",
Filters: squirrel.Eq{"album_id": albumID, "disc_number": discNumber},
@@ -58,29 +70,25 @@ func newDiscArtworkReader(ctx context.Context, a *artwork, artID model.ArtworkID
return nil, err
}
- lib, err := loadLibraryView(ctx, a.ds, al.LibraryID)
+ lib, err := loadLibraryView(ctx, ds, al.LibraryID)
if err != nil {
return nil, err
}
// Build disc folder set and find first track. mf.Path is already library-relative.
var firstTrackRel string
- allFolderIDs := make(map[string]bool)
for _, mf := range mfs {
- allFolderIDs[mf.FolderID] = true
- if firstTrackRel == "" {
+ if mf.Path != "" {
firstTrackRel = filepath.ToSlash(mf.Path)
+ break
}
}
+ folderIDs := slice.Unique(slice.Map(mfs, func(mf model.MediaFile) string { return mf.FolderID }))
// Resolve folder IDs to library-relative paths
discFoldersRel := make(map[string]bool)
- if len(allFolderIDs) > 0 {
- folderIDs := make([]string, 0, len(allFolderIDs))
- for id := range allFolderIDs {
- folderIDs = append(folderIDs, id)
- }
- folders, err := a.ds.Folder(ctx).GetAll(model.QueryOptions{
+ if len(folderIDs) > 0 {
+ folders, err := ds.Folder(ctx).GetAll(model.QueryOptions{
Filters: squirrel.Eq{"folder.id": folderIDs},
})
if err != nil {
@@ -89,49 +97,20 @@ func newDiscArtworkReader(ctx context.Context, a *artwork, artID model.ArtworkID
for _, f := range folders {
rel := strings.TrimPrefix(path.Join(f.Path, f.Name), "/")
discFoldersRel[rel] = true
+ imagesUpdatedAt = utils.TimeNewest(imagesUpdatedAt, f.ImagesUpdatedAt)
}
}
- isMultiFolder := len(al.FolderIDs) > 1
-
- r := &discArtworkReader{
- a: a,
- album: *al,
- discNumber: discNumber,
- imgFiles: imgFiles,
- discFoldersRel: discFoldersRel,
- isMultiFolder: isMultiFolder,
- firstTrackRel: firstTrackRel,
- lib: lib,
- updatedAt: imagesUpdatedAt,
- }
- r.cacheKey.artID = artID
- r.cacheKey.lastUpdate = utils.TimeNewest(al.UpdatedAt, al.ImportedAt)
- if imagesUpdatedAt != nil {
- r.cacheKey.lastUpdate = utils.TimeNewest(r.cacheKey.lastUpdate, *imagesUpdatedAt)
- }
- return r, nil
-}
-
-func (d *discArtworkReader) Key() string {
- hash := md5.Sum([]byte(conf.Server.DiscArtPriority))
- return fmt.Sprintf(
- "%s.%x",
- d.cacheKey.Key(),
- hash,
- )
-}
-
-func (d *discArtworkReader) LastUpdated() time.Time {
- return d.lastUpdate
-}
-
-func (d *discArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
- var ff = d.fromDiscArtPriority(ctx, d.a.ffmpeg, conf.Server.DiscArtPriority)
- // Fallback to album cover art
- albumArtID := model.NewArtworkID(model.KindAlbumArtwork, d.album.ID, &d.album.UpdatedAt)
- ff = append(ff, fromAlbum(ctx, d.a, albumArtID))
- return selectImageReader(ctx, d.cacheKey.artID, ff...)
+ return &discArtworkReader{
+ album: *al,
+ discNumber: discNumber,
+ imgFiles: imgFiles,
+ discFoldersRel: discFoldersRel,
+ isMultiFolder: len(al.FolderIDs) > 1,
+ firstTrackRel: firstTrackRel,
+ lib: lib,
+ imagesUpdatedAt: imagesUpdatedAt,
+ }, nil
}
func (d *discArtworkReader) fromDiscArtPriority(ctx context.Context, ffmpeg ffmpeg.FFmpeg, priority string) []sourceFunc {
@@ -162,14 +141,13 @@ func (d *discArtworkReader) fromDiscArtPriority(ctx context.Context, ffmpeg ffmp
func (d *discArtworkReader) fromDiscSubtitle(ctx context.Context, subtitle string) sourceFunc {
return func() (io.ReadCloser, string, error) {
for _, file := range d.imgFiles {
- name := path.Base(file)
- stem := strings.TrimSuffix(name, path.Ext(name))
+ stem := utils.BaseName(file)
if !strings.EqualFold(stem, subtitle) {
continue
}
f, err := d.lib.FS.Open(file)
if err != nil {
- log.Warn(ctx, "Could not open disc art file", "file", file, err)
+ log.Warn(ctx, "Artwork: Could not open disc art file", "file", file, err)
continue
}
return f, file, nil
@@ -178,19 +156,12 @@ func (d *discArtworkReader) fromDiscSubtitle(ctx context.Context, subtitle strin
}
}
-// globMetaChars holds the substitution metacharacters understood by
-// filepath.Match. The '\' escape character is intentionally excluded:
-// disc art patterns come from user config and never include escaped
-// metachars in practice, and treating '\' as a metachar would misalign
-// the literal-prefix extraction in extractDiscNumber.
+// filepath.Match's '\' escape is excluded on purpose: treating it as a metachar
+// would misalign the literal-prefix extraction in extractDiscNumber.
const globMetaChars = "*?["
-// extractDiscNumber parses the disc number from a filename matched by a
-// filepath.Match-style glob pattern.
-//
-// Both pattern and filename must already be lowercased by the caller, which
-// is also expected to have verified that filepath.Match(pattern, filename)
-// is true before calling this function.
+// extractDiscNumber parses the disc number from a filename matched by a filepath.Match-style
+// glob. Caller must lowercase both args and have already verified the match.
func extractDiscNumber(pattern, filename string) (int, bool) {
metaIdx := strings.IndexAny(pattern, globMetaChars)
if metaIdx < 0 {
@@ -216,9 +187,8 @@ func extractDiscNumber(pattern, filename string) (int, bool) {
return num, true
}
-// fromExternalFile returns a sourceFunc that matches image files against a glob
-// pattern. A numbered filename whose number equals the target disc wins over
-// any unnumbered candidate; callers must pass a lowercase pattern.
+// fromExternalFile matches image files against a (lowercase) glob pattern. A numbered
+// filename whose number equals the target disc wins over any unnumbered candidate.
func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string) sourceFunc {
isLiteral := !strings.ContainsAny(pattern, globMetaChars)
return func() (io.ReadCloser, string, error) {
@@ -227,7 +197,7 @@ func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string
name := strings.ToLower(path.Base(file))
match, err := filepath.Match(pattern, name)
if err != nil {
- log.Warn(ctx, "Error matching disc art file to pattern", "pattern", pattern, "file", file)
+ log.Warn(ctx, "Artwork: Error matching disc art file to pattern", "pattern", pattern, "file", file)
continue
}
if !match {
@@ -241,7 +211,7 @@ func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string
}
f, err := d.lib.FS.Open(file)
if err != nil {
- log.Warn(ctx, "Could not open disc art file", "file", file, err)
+ log.Warn(ctx, "Artwork: Could not open disc art file", "file", file, err)
continue
}
return f, file, nil
@@ -257,7 +227,7 @@ func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string
for _, file := range fallbacks {
f, err := d.lib.FS.Open(file)
if err != nil {
- log.Warn(ctx, "Could not open disc art file", "file", file, err)
+ log.Warn(ctx, "Artwork: Could not open disc art file", "file", file, err)
continue
}
return f, file, nil
diff --git a/core/artwork/reader_disc_test.go b/core/artwork/disc_test.go
similarity index 100%
rename from core/artwork/reader_disc_test.go
rename to core/artwork/disc_test.go
diff --git a/core/artwork/dominant/dominant.go b/core/artwork/dominant/dominant.go
new file mode 100644
index 000000000..2bbda8ae9
--- /dev/null
+++ b/core/artwork/dominant/dominant.go
@@ -0,0 +1,127 @@
+// Package dominant extracts an image's dominant colour, for use as a flat placeholder while the
+// real artwork loads.
+package dominant
+
+import (
+ "fmt"
+ "image"
+ "math"
+ "sort"
+)
+
+const (
+ // 4 bits per channel: coarse enough that near-identical pixels land together, fine enough that
+ // distinct colours stay apart.
+ bits = 4
+ nBins = 1 << (3 * bits)
+ // Only the heaviest bins can win, and merging is O(n^2) over whatever survives.
+ maxBins = 64
+ // Oklab distance below which two bins are the same colour to the eye. Merging matters because a
+ // gradient splits across adjacent bins and would otherwise lose to a smaller flat region.
+ mergeDist = 0.10
+)
+
+type bin struct {
+ r, g, b float64
+ n float64
+}
+
+// Color returns the dominant colour as "#rrggbb", or "" when the image has no pixels. It reports
+// presence, not salience: a mostly white sleeve returns white.
+func Color(img image.Image) string {
+ var bins [nBins]bin
+ total := 0
+ eachPixel(img, func(r, g, b uint8) {
+ i := int(r>>(8-bits))<<(2*bits) | int(g>>(8-bits))<<bits | int(b>>(8-bits))
+ bins[i].r += float64(r)
+ bins[i].g += float64(g)
+ bins[i].b += float64(b)
+ bins[i].n++
+ total++
+ })
+ if total == 0 {
+ return ""
+ }
+
+ used := make([]bin, 0, 32)
+ for i := range bins {
+ if bins[i].n > 0 {
+ used = append(used, bins[i])
+ }
+ }
+ sort.Slice(used, func(i, j int) bool { return used[i].n > used[j].n })
+ if len(used) > maxBins {
+ used = used[:maxBins]
+ }
+
+ merged := make([]bin, 0, len(used))
+ for _, b := range used {
+ if i := nearest(merged, b); i >= 0 {
+ merged[i].r += b.r
+ merged[i].g += b.g
+ merged[i].b += b.b
+ merged[i].n += b.n
+ continue
+ }
+ merged = append(merged, b)
+ }
+
+ best := merged[0]
+ for _, m := range merged[1:] {
+ if m.n > best.n {
+ best = m
+ }
+ }
+ return fmt.Sprintf("#%02x%02x%02x",
+ uint8(best.r/best.n+0.5), uint8(best.g/best.n+0.5), uint8(best.b/best.n+0.5))
+}
+
+func nearest(merged []bin, b bin) int {
+ bl, ba, bb := oklab(b.r/b.n, b.g/b.n, b.b/b.n)
+ for i, m := range merged {
+ ml, ma, mb := oklab(m.r/m.n, m.g/m.n, m.b/m.n)
+ if math.Sqrt((bl-ml)*(bl-ml)+(ba-ma)*(ba-ma)+(bb-mb)*(bb-mb)) < mergeDist {
+ return i
+ }
+ }
+ return -1
+}
+
+// eachPixel walks the image, taking the NRGBA fast path the artwork pipeline always hits: both hash
+// encoders already read the shared thumbnail in that form.
+func eachPixel(img image.Image, fn func(r, g, b uint8)) {
+ if p, ok := img.(*image.NRGBA); ok {
+ for y := range p.Rect.Dy() {
+ row := p.Pix[y*p.Stride : y*p.Stride+p.Rect.Dx()*4]
+ for x := 0; x < len(row); x += 4 {
+ fn(row[x], row[x+1], row[x+2])
+ }
+ }
+ return
+ }
+ b := img.Bounds()
+ for y := b.Min.Y; y < b.Max.Y; y++ {
+ for x := b.Min.X; x < b.Max.X; x++ {
+ r, g, bl, _ := img.At(x, y).RGBA()
+ fn(uint8(r>>8), uint8(g>>8), uint8(bl>>8))
+ }
+ }
+}
+
+func srgbToLinear(v float64) float64 {
+ v /= 255
+ if v <= 0.04045 {
+ return v / 12.92
+ }
+ return math.Pow((v+0.055)/1.055, 2.4)
+}
+
+func oklab(r, g, b float64) (float64, float64, float64) {
+ lr, lg, lb := srgbToLinear(r), srgbToLinear(g), srgbToLinear(b)
+ l := math.Cbrt(0.4122214708*lr + 0.5363325363*lg + 0.0514459929*lb)
+ m := math.Cbrt(0.2119034982*lr + 0.6806995451*lg + 0.1073969566*lb)
+ s := math.Cbrt(0.0883024619*lr + 0.2817188376*lg + 0.6299787005*lb)
+ return 0.2104542553*l + 0.7936177850*m - 0.0040720468*s,
+ 1.9779984951*l - 2.4285922050*m + 0.4505937099*s,
+ 0.0259040371*l + 0.7827717662*m - 0.8086757660*s
+}
diff --git a/core/artwork/dominant/dominant_suite_test.go b/core/artwork/dominant/dominant_suite_test.go
new file mode 100644
index 000000000..56dbd6209
--- /dev/null
+++ b/core/artwork/dominant/dominant_suite_test.go
@@ -0,0 +1,17 @@
+package dominant_test
+
+import (
+ "testing"
+
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+func TestDominant(t *testing.T) {
+ tests.Init(t, false)
+ log.SetLevel(log.LevelFatal)
+ RegisterFailHandler(Fail)
+ RunSpecs(t, "Dominant Suite")
+}
diff --git a/core/artwork/dominant/dominant_test.go b/core/artwork/dominant/dominant_test.go
new file mode 100644
index 000000000..da7fed09c
--- /dev/null
+++ b/core/artwork/dominant/dominant_test.go
@@ -0,0 +1,91 @@
+package dominant_test
+
+import (
+ "image"
+ "image/color"
+
+ "github.com/navidrome/navidrome/core/artwork/dominant"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// fill paints rect with c onto img.
+func fill(img *image.NRGBA, r image.Rectangle, c color.NRGBA) {
+ for y := r.Min.Y; y < r.Max.Y; y++ {
+ for x := r.Min.X; x < r.Max.X; x++ {
+ img.SetNRGBA(x, y, c)
+ }
+ }
+}
+
+func newImg(w, h int, c color.NRGBA) *image.NRGBA {
+ img := image.NewNRGBA(image.Rect(0, 0, w, h))
+ fill(img, img.Bounds(), c)
+ return img
+}
+
+var _ = Describe("Color", func() {
+ It("returns a solid image's own colour", func() {
+ Expect(dominant.Color(newImg(20, 20, color.NRGBA{0x33, 0x66, 0x99, 255}))).To(Equal("#336699"))
+ })
+
+ It("returns empty for an image with no pixels", func() {
+ Expect(dominant.Color(image.NewNRGBA(image.Rect(0, 0, 0, 0)))).To(Equal(""))
+ })
+
+ // Presence, not salience: this is a placeholder, so the large field wins even though the small
+ // patch is the more interesting colour.
+ It("picks the largest area, not the most vivid one", func() {
+ img := newImg(20, 20, color.NRGBA{0xfa, 0xfa, 0xfa, 255})
+ fill(img, image.Rect(0, 0, 4, 4), color.NRGBA{0xff, 0x00, 0x00, 255})
+ Expect(dominant.Color(img)).To(Equal("#fafafa"))
+ })
+
+ It("reports a near-black cover as near-black", func() {
+ img := newImg(20, 20, color.NRGBA{0x05, 0x05, 0x05, 255})
+ fill(img, image.Rect(0, 0, 5, 5), color.NRGBA{0x00, 0xff, 0x00, 255})
+ Expect(dominant.Color(img)).To(Equal("#050505"))
+ })
+
+ // A gradient splits across many quantisation bins. Without merging, each slice is smaller than
+ // the flat block and the block would win despite covering far less of the image.
+ It("merges a gradient's bins so it beats a smaller flat block", func() {
+ img := image.NewNRGBA(image.Rect(0, 0, 40, 40))
+ for y := range 40 {
+ for x := range 40 {
+ // 30 columns of blue gradient == 75% of the image
+ if x < 30 {
+ img.SetNRGBA(x, y, color.NRGBA{0x10, 0x20, uint8(0xa0 + x), 255})
+ } else {
+ img.SetNRGBA(x, y, color.NRGBA{0xff, 0xcc, 0x00, 255})
+ }
+ }
+ }
+ got := dominant.Color(img)
+ Expect(got).To(HavePrefix("#1020"), "expected the blue gradient, got "+got)
+ })
+
+ It("is deterministic", func() {
+ img := image.NewNRGBA(image.Rect(0, 0, 30, 30))
+ for y := range 30 {
+ for x := range 30 {
+ img.SetNRGBA(x, y, color.NRGBA{uint8(x * 7), uint8(y * 5), uint8(x + y), 255})
+ }
+ }
+ first := dominant.Color(img)
+ for range 5 {
+ Expect(dominant.Color(img)).To(Equal(first))
+ }
+ })
+
+ It("handles images that are not NRGBA", func() {
+ src := newImg(10, 10, color.NRGBA{0x20, 0x40, 0x60, 255})
+ rgba := image.NewRGBA(src.Bounds())
+ for y := range 10 {
+ for x := range 10 {
+ rgba.Set(x, y, src.At(x, y))
+ }
+ }
+ Expect(dominant.Color(rgba)).To(Equal("#204060"))
+ })
+})
diff --git a/core/artwork/e2e/acquire_serve_test.go b/core/artwork/e2e/acquire_serve_test.go
new file mode 100644
index 000000000..d6c374e39
--- /dev/null
+++ b/core/artwork/e2e/acquire_serve_test.go
@@ -0,0 +1,326 @@
+package e2e
+
+import (
+ "context"
+ "encoding/base64"
+ "errors"
+ "io"
+ "os"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/core/artwork"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/server/events"
+ "github.com/navidrome/navidrome/tests"
+ "github.com/navidrome/navidrome/utils/cache"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// Covers the enqueue → drain → serve chain; per-source resolution rules live in the unit suites.
+var _ = Describe("Acquisition → serve loop", func() {
+ var (
+ ctx context.Context
+ ds *tests.MockDataStore
+ artRepo *tests.MockArtworkRepo
+ queueRepo *tests.MockArtworkQueueRepo
+ albumRepo *tests.MockAlbumRepo
+ artistRepo *tests.MockArtistRepo
+ mfRepo *tests.MockMediaFileRepo
+ plRepo *tests.MockPlaylistRepo
+ radioRepo *tests.MockedRadioRepo
+ folderRepo *fakeFolderRepo
+ libRepo *tests.MockLibraryRepo
+ store *artwork.ImageStore
+ svc artwork.Artwork
+ worker *artwork.Worker
+ coverBytes []byte
+ )
+
+ itemFound := func(kind model.Kind, id string) func() bool {
+ return func() bool {
+ ia, err := artRepo.GetItemArtwork(kind, id, model.ImageTypePrimary)
+ return err == nil && ia.Hash != ""
+ }
+ }
+ itemAbsent := func(kind model.Kind, id string) func() bool {
+ return func() bool {
+ ia, err := artRepo.GetItemArtwork(kind, id, model.ImageTypePrimary)
+ return err == nil && ia.Hash == ""
+ }
+ }
+ // Enqueues the way the serving paths do, so the drain is driven by a plain queue row.
+ bump := func(kind, id string) {
+ GinkgoHelper()
+ Expect(ds.ArtworkQueue(ctx).EnqueuePreservingBackoff(model.ArtworkQueueItem{
+ ItemKind: kind, ItemID: id, ImageType: model.ImageTypePrimary,
+ Priority: model.ArtworkPriorityBump,
+ })).To(Succeed())
+ }
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ ctx = context.Background()
+ repoRoot, err := os.Getwd()
+ Expect(err).ToNot(HaveOccurred())
+ coverBytes = readFixture(coverFixture)
+
+ conf.Server.CacheFolder = conf.NewDir(GinkgoT().TempDir())
+ conf.Server.DataFolder = conf.NewDir(GinkgoT().TempDir())
+ conf.Server.CoverArtPriority = "cover.jpg"
+ conf.Server.ArtistArtPriority = "artist.png" // keeps artist resolution offline
+ conf.Server.EnableMediaFileCoverArt = true
+ conf.Server.DevArtworkWorkerConcurrency = 1
+
+ folderRepo = &fakeFolderRepo{}
+ libRepo = &tests.MockLibraryRepo{}
+ libRepo.SetData(model.Libraries{{ID: 0, Path: repoRoot}})
+ artRepo = tests.CreateMockArtworkRepo()
+ queueRepo = tests.CreateMockArtworkQueueRepo()
+ albumRepo = tests.CreateMockAlbumRepo()
+ artistRepo = tests.CreateMockArtistRepo()
+ mfRepo = tests.CreateMockMediaFileRepo()
+ plRepo = tests.CreateMockPlaylistRepo()
+ radioRepo = tests.CreateMockedRadioRepo()
+ radioRepo.Data = map[string]*model.Radio{}
+ ds = &tests.MockDataStore{
+ MockedArtwork: artRepo,
+ MockedArtworkQueue: queueRepo,
+ MockedAlbum: albumRepo,
+ MockedArtist: artistRepo,
+ MockedMediaFile: mfRepo,
+ MockedPlaylist: plRepo,
+ MockedRadio: radioRepo,
+ MockedFolder: folderRepo,
+ MockedLibrary: libRepo,
+ }
+ ffm := tests.NewMockFFmpeg("")
+ store = artwork.NewImageStore(GinkgoT().TempDir())
+ // size=0 requests stream originals, so this reader is never called (serving_test covers resizing).
+ imgCache := cache.NewFileCache("ArtworkPipelineE2E", "100MB", "images", 0,
+ func(context.Context, cache.Item) (io.Reader, error) {
+ return nil, errors.New("resize not exercised in e2e")
+ })
+ Eventually(func() bool { return imgCache.Available(ctx) }).Should(BeTrue())
+
+ svc = artwork.NewArtwork(ds, imgCache, store, ffm)
+ worker = artwork.NewWorker(ds, store, agents.GetAgents(ds, nil), ffm, events.NoopBroker(), imgCache)
+ })
+
+ seedFolderAlbum := func(albumID string) {
+ folderRepo.result = []model.Folder{{Path: albumFolderPath, ImageFiles: []string{"cover.jpg"}}}
+ albumRepo.SetData(model.Albums{{ID: albumID, Name: "Album", FolderIDs: []string{"f1"}, LibraryID: 0}})
+ }
+
+ It("acquires album folder art and serves the exact bytes under its hash", func() {
+ seedFolderAlbum("al1")
+ bump("al", "al1")
+ runWorkerUntil(ctx, worker, itemFound(model.KindAlbumArtwork, "al1"))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("folder"))
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("al-al1"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(img.Hash).To(Equal(ia.Hash))
+ Expect(img.Placeholder).To(BeFalse())
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+
+ It("acquires an artist's uploaded image and serves it", func() {
+ name := writeUpload(consts.EntityArtist, "artist-e2e.png", artistPngFixture)
+ artistRepo.SetData(model.Artists{{ID: "ar1", Name: "Artist", UploadedImage: name}})
+ bump("ar", "ar1")
+ runWorkerUntil(ctx, worker, itemFound(model.KindArtistArtwork, "ar1"))
+
+ ia, err := artRepo.GetItemArtwork(model.KindArtistArtwork, "ar1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("upload"))
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("ar-ar1"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(img.Hash).To(Equal(ia.Hash))
+ Expect(readAll(img)).To(Equal(readFixture(artistPngFixture)))
+ })
+
+ It("generates a playlist grid from its tracks' album art and serves it from the store", func() {
+ seedFolderAlbum("al1")
+ plRepo.SetData(model.Playlists{{ID: "pl1", Name: "Playlist"}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"al1"}}
+ bump("pl", "pl1")
+ runWorkerUntil(ctx, worker, itemFound(model.KindPlaylistArtwork, "pl1"))
+
+ ia, err := artRepo.GetItemArtwork(model.KindPlaylistArtwork, "pl1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("generated"))
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("pl-pl1"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(img.Hash).To(Equal(ia.Hash))
+ art, err := artRepo.GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(art.Mime).To(Equal("image/png"))
+ Expect(len(readAll(img))).To(BeNumerically(">", 0))
+ })
+
+ It("acquires a radio station's uploaded image and serves it", func() {
+ name := writeUpload(consts.EntityRadio, "radio-e2e.jpg", coverFixture)
+ radioRepo.Data["ra1"] = &model.Radio{ID: "ra1", Name: "Station", UploadedImage: name}
+ bump("ra", "ra1")
+ runWorkerUntil(ctx, worker, itemFound(model.KindRadioArtwork, "ra1"))
+
+ ia, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("upload"))
+
+ img, err := svc.Get(ctx, model.MustParseArtworkID("ra-ra1"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(img.Hash).To(Equal(ia.Hash))
+ Expect(readAll(img)).To(Equal(coverBytes))
+ })
+
+ It("serves an unresolved track provisionally, then upgrades to the worker's state row", func() {
+ mfRepo.SetData(model.MediaFiles{{
+ ID: "mf1", AlbumID: "al1", HasCoverArt: true, LibraryID: 0, Path: mp3Fixture,
+ }})
+
+ provisional, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf1"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(provisional.Placeholder).To(BeFalse())
+ Expect(provisional.Hash).ToNot(BeEmpty())
+ provisionalBytes := readAll(provisional)
+ Expect(len(provisionalBytes)).To(BeNumerically(">", 0))
+
+ _, err = artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mf1", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound), "provisional serving must not write a state row")
+
+ // The provisional read enqueued a Bump; drain it.
+ runWorkerUntil(ctx, worker, itemFound(model.KindMediaFileArtwork, "mf1"))
+ ia, err := artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mf1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("embedded"))
+ Expect(ia.Hash).To(Equal(provisional.Hash))
+
+ resolved, err := svc.Get(ctx, model.MustParseArtworkID("mf-mf1"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(resolved.Hash).To(Equal(ia.Hash))
+ Expect(readAll(resolved)).To(Equal(provisionalBytes))
+ })
+
+ It("stores dimensions, mime and a real blurhash alongside the acquired bytes", func() {
+ seedFolderAlbum("al1")
+ bump("al", "al1")
+ runWorkerUntil(ctx, worker, itemFound(model.KindAlbumArtwork, "al1"))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ art, err := artRepo.GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(art.Mime).To(Equal("image/jpeg"))
+ Expect(art.Width).To(BeNumerically(">", 0))
+ Expect(art.Height).To(BeNumerically(">", 0))
+ Expect(art.SizeBytes).To(BeNumerically("==", len(coverBytes)))
+ // Never a synthesized value: both hashes are encoded from the real pixels.
+ Expect(art.BlurHash).ToNot(BeEmpty())
+ Expect(art.ThumbHash).ToNot(BeEmpty())
+ raw, err := base64.StdEncoding.DecodeString(art.ThumbHash)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(raw)).To(BeNumerically(">=", 5))
+ })
+
+ It("acquires GIF artwork, whose decoder only core/artwork's blank import registers", func() {
+ writeUploadedImage(consts.EntityRadio, "station.gif", gifFixture)
+ radioRepo.Data["ra1"] = &model.Radio{ID: "ra1", Name: "Station", UploadedImage: "station.gif"}
+ bump("ra", "ra1")
+ runWorkerUntil(ctx, worker, itemFound(model.KindRadioArtwork, "ra1"))
+
+ ia, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ art, err := artRepo.GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(art.Mime).To(Equal("image/gif"))
+ Expect(art.Width).To(BeNumerically("==", 4))
+ })
+
+ It("deduplicates byte-identical art across entities onto one image row", func() {
+ folderRepo.result = []model.Folder{{Path: albumFolderPath, ImageFiles: []string{"cover.jpg"}}}
+ albumRepo.SetData(model.Albums{
+ {ID: "al1", Name: "Album", FolderIDs: []string{"f1"}, LibraryID: 0},
+ {ID: "al2", Name: "Same Cover", FolderIDs: []string{"f1"}, LibraryID: 0},
+ })
+ bump("al", "al1")
+ bump("al", "al2")
+ runWorkerUntil(ctx, worker, func() bool {
+ return itemFound(model.KindAlbumArtwork, "al1")() && itemFound(model.KindAlbumArtwork, "al2")()
+ })
+
+ ia1, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ ia2, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al2", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia1.Hash).To(Equal(ia2.Hash), "identical bytes must share one content hash")
+ Expect(readAll(mustGet(svc.Get(ctx, model.MustParseArtworkID("al-al2"), 0, false)))).To(Equal(coverBytes))
+ })
+
+ It("stops serving a file-backed image once its source file changes underneath", func() {
+ name := writeUpload(consts.EntityRadio, "radio-stale.jpg", coverFixture)
+ radioRepo.Data["ra1"] = &model.Radio{ID: "ra1", Name: "Station", UploadedImage: name}
+ bump("ra", "ra1")
+ runWorkerUntil(ctx, worker, itemFound(model.KindRadioArtwork, "ra1"))
+
+ ia, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ staleHash := ia.Hash
+
+ path := model.UploadedImagePath(consts.EntityRadio, name)
+ Expect(os.WriteFile(path, readFixture(artistPngFixture), 0o600)).To(Succeed())
+ newer := time.Now().Add(2 * time.Second)
+ Expect(os.Chtimes(path, newer, newer)).To(Succeed())
+
+ // The mtime no longer matches the state row, so the stale bytes are not served.
+ _, err = svc.Get(ctx, model.MustParseArtworkID("ra-ra1"), 0, false)
+ Expect(err).To(MatchError(artwork.ErrUnavailable))
+
+ // That failed read enqueued a re-resolution.
+ runWorkerUntil(ctx, worker, func() bool {
+ cur, gerr := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)
+ return gerr == nil && cur.Hash != "" && cur.Hash != staleHash
+ })
+ img, err := svc.Get(ctx, model.MustParseArtworkID("ra-ra1"), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(readAll(img)).To(Equal(readFixture(artistPngFixture)))
+ })
+
+ It("records an absent state for an entity with no art and reports it unavailable", func() {
+ albumRepo.SetData(model.Albums{{ID: "alx", Name: "Artless", LibraryID: 0}})
+ bump("al", "alx")
+ runWorkerUntil(ctx, worker, itemAbsent(model.KindAlbumArtwork, "alx"))
+
+ _, err := svc.Get(ctx, model.MustParseArtworkID("al-alx"), 0, false)
+ Expect(err).To(MatchError(artwork.ErrUnavailable))
+
+ img, err := svc.GetOrPlaceholder(ctx, "al-alx", 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(img.Placeholder).To(BeTrue())
+ })
+})
+
+func mustGet(img *artwork.Image, err error) *artwork.Image {
+ GinkgoHelper()
+ Expect(err).ToNot(HaveOccurred())
+ return img
+}
+
+// Raw bytes on purpose: encoding a GIF here would register image/gif in the test binary, masking
+// the production import the spec above guards.
+var gifFixture = []byte{
+ 0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x04, 0x00, 0x04, 0x00, 0x80, 0x00,
+ 0x00, 0x2e, 0x86, 0xc1, 0xf4, 0xd0, 0x3f, 0x2c, 0x00, 0x00, 0x00, 0x00,
+ 0x04, 0x00, 0x04, 0x00, 0x00, 0x02, 0x05, 0x44, 0x7c, 0x67, 0xb8, 0x05,
+ 0x00, 0x3b,
+}
diff --git a/core/artwork/e2e/album_test.go b/core/artwork/e2e/album_test.go
index 5e61684cc..7b5e7b4a3 100644
--- a/core/artwork/e2e/album_test.go
+++ b/core/artwork/e2e/album_test.go
@@ -1,4 +1,4 @@
-package artworke2e_test
+package e2e
import (
"testing/fstest"
@@ -9,14 +9,11 @@ import (
. "github.com/onsi/gomega"
)
-const (
- defaultCoverPriority = "cover.*, folder.*, front.*, embedded, external"
- defaultDiscPriority = "disc*.*, cd*.*, cover.*, folder.*, front.*, discsubtitle, embedded"
-)
-
+// The in-memory library FS cannot satisfy the os.Open(SourcePath) used to serve folder art, so
+// folder scenarios assert on the worker's state row (Source + SourcePath) instead of the bytes.
var _ = Describe("Album artwork resolution", func() {
BeforeEach(func() {
- setupHarness()
+ setupResolutionHarness()
})
When("an album has a single folder with cover.jpg at the album root", func() {
@@ -28,12 +25,10 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.jpg": imageFile("album-root"),
+ "Artist/Album/cover.jpg": smallPNG("album-root"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")
})
})
@@ -55,16 +50,16 @@ var _ = Describe("Album artwork resolution", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "Track CD1"),
"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "Track CD2"),
- "Artist/Album/cover.jpg": imageFile("album-root"),
- "Artist/Album/CD1/cover.jpg": imageFile("disc1"),
- "Artist/Album/CD2/cover.jpg": imageFile("disc2"),
+ "Artist/Album/cover.jpg": smallPNG("album-root"),
+ "Artist/Album/CD1/cover.jpg": smallPNG("disc1"),
+ "Artist/Album/CD2/cover.jpg": smallPNG("disc2"),
})
scan()
al := firstAlbum()
Expect(al.FolderIDs).To(HaveLen(2),
- "sanity check: scanner should treat the two disc subfolders as one multi-disc album")
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))
+ "sanity check: the two disc subfolders should form one multi-disc album")
+ expectAlbumFolderCover(al, "Artist/Album/cover.jpg")
})
})
@@ -86,14 +81,12 @@ var _ = Describe("Album artwork resolution", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "Track CD1"),
"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "Track CD2"),
- "Artist/Album/folder.jpg": imageFile("album-root"),
- "Artist/Album/CD1/folder.jpg": imageFile("disc1"),
- "Artist/Album/CD2/folder.jpg": imageFile("disc2"),
+ "Artist/Album/folder.jpg": smallPNG("album-root"),
+ "Artist/Album/CD1/folder.jpg": smallPNG("disc1"),
+ "Artist/Album/CD2/folder.jpg": smallPNG("disc2"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/folder.jpg")
})
})
@@ -109,12 +102,10 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
"Artist/Album/disc1/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.jpg": imageFile("album-root"),
+ "Artist/Album/cover.jpg": smallPNG("album-root"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")
})
})
@@ -133,14 +124,12 @@ var _ = Describe("Album artwork resolution", func() {
setLayout(fstest.MapFS{
"Album/CD1/01 - Track.mp3": trackFile(1, "Track CD1"),
"Album/CD2/01 - Track.mp3": trackFile(1, "Track CD2"),
- "Album/cover.jpg": imageFile("album-root"),
- "Album/CD1/folder.jpg": imageFile("disc1"),
- "Album/CD2/folder.jpg": imageFile("disc2"),
+ "Album/cover.jpg": smallPNG("album-root"),
+ "Album/CD1/folder.jpg": smallPNG("disc1"),
+ "Album/CD2/folder.jpg": smallPNG("disc2"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root")))
+ expectAlbumFolderCover(firstAlbum(), "Album/cover.jpg")
})
})
@@ -153,14 +142,14 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = "embedded, cover.*, folder.*, front.*, external"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"has_picture": "true"}),
- "Artist/Album/cover.jpg": imageFile("external"),
+ "Artist/Album/cover.jpg": smallPNG("external"),
})
scan()
- // Swap in real MP3 bytes so libFS.Open returns a taglib-readable stream.
replaceWithRealMP3("Artist/Album/01 - Track.mp3")
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(embeddedArtBytes))
+ ia := acquire(model.KindAlbumArtwork, firstAlbum().ID)
+ Expect(ia.Source).To(Equal("embedded"))
+ Expect(storedBytes(ia)).To(Equal(embeddedArtBytes))
})
})
@@ -176,8 +165,9 @@ var _ = Describe("Album artwork resolution", func() {
scan()
replaceWithRealMP3("Artist/Album/01 - Track.mp3")
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(embeddedArtBytes))
+ ia := acquire(model.KindAlbumArtwork, firstAlbum().ID)
+ Expect(ia.Source).To(Equal("embedded"))
+ Expect(storedBytes(ia)).To(Equal(embeddedArtBytes))
})
})
@@ -190,12 +180,10 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = "cover.*, folder.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/Cover.JPG": imageFile("case-insensitive"),
+ "Artist/Album/Cover.JPG": smallPNG("case-insensitive"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("case-insensitive")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/Cover.JPG")
})
})
@@ -209,30 +197,25 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = "cover.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.jpg": imageFile("primary"),
- "Artist/Album/cover.1.jpg": imageFile("secondary"),
+ "Artist/Album/cover.jpg": smallPNG("primary"),
+ "Artist/Album/cover.1.jpg": smallPNG("secondary"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("primary")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")
})
})
When("the album has no cover and CoverArtPriority lists only file patterns", func() {
// Artist/
// └── Album/
- // └── 01 - Track.mp3 (no image files — returns ErrUnavailable)
- It("returns ErrUnavailable", func() {
+ // └── 01 - Track.mp3 (no image files — settles absent)
+ It("settles absent", func() {
conf.Server.CoverArtPriority = "cover.*, folder.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
})
scan()
-
- al := firstAlbum()
- _, err := readArtworkOrErr(model.NewArtworkID(model.KindAlbumArtwork, al.ID, &al.UpdatedAt))
- Expect(err).To(HaveOccurred())
+ expectAlbumAbsent(firstAlbum())
})
})
@@ -248,12 +231,10 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/folder.jpg": imageFile("folder"),
+ "Artist/Album/folder.jpg": smallPNG("folder"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("folder")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/folder.jpg")
})
})
@@ -266,12 +247,10 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/front.jpg": imageFile("front"),
+ "Artist/Album/front.jpg": smallPNG("front"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("front")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/front.jpg")
})
})
@@ -286,14 +265,12 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.jpg": imageFile("cover"),
- "Artist/Album/folder.jpg": imageFile("folder"),
- "Artist/Album/front.jpg": imageFile("front"),
+ "Artist/Album/cover.jpg": smallPNG("cover"),
+ "Artist/Album/folder.jpg": smallPNG("folder"),
+ "Artist/Album/front.jpg": smallPNG("front"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("cover")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")
})
})
@@ -307,13 +284,11 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/folder.jpg": imageFile("folder"),
- "Artist/Album/front.jpg": imageFile("front"),
+ "Artist/Album/folder.jpg": smallPNG("folder"),
+ "Artist/Album/front.jpg": smallPNG("front"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("folder")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/folder.jpg")
})
})
@@ -328,14 +303,12 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = "cover.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.2.jpg": imageFile("second"),
- "Artist/Album/cover.jpg": imageFile("primary"),
- "Artist/Album/cover.1.jpg": imageFile("first"),
+ "Artist/Album/cover.2.jpg": smallPNG("second"),
+ "Artist/Album/cover.jpg": smallPNG("primary"),
+ "Artist/Album/cover.1.jpg": smallPNG("first"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("primary")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")
})
})
@@ -348,12 +321,10 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = "bogus.*, cover.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.jpg": imageFile("cover"),
+ "Artist/Album/cover.jpg": smallPNG("cover"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("cover")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")
})
})
@@ -371,21 +342,16 @@ var _ = Describe("Album artwork resolution", func() {
It("does not use the artist image as album art", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
- "Artist/folder.jpg": imageFile("artist-thumbnail"),
+ "Artist/folder.jpg": smallPNG("artist-thumbnail"),
"Artist/Album A/01 - Track.mp3": trackFile(1, "Track A", map[string]any{"album": "Album A", "albumartist": "Artist"}),
"Artist/Album B/01 - Track.mp3": trackFile(1, "Track B", map[string]any{"album": "Album B", "albumartist": "Artist"}),
- "Artist/Album B/cover.jpg": imageFile("album-b"),
+ "Artist/Album B/cover.jpg": smallPNG("album-b"),
})
scan()
- alA := albumByName("Album A")
- _, err := readArtworkOrErr(alA.CoverArtID())
- Expect(err).To(HaveOccurred(),
- "Album A has no images of its own, so it must fall through to the placeholder "+
- "instead of inheriting the artist folder's folder.jpg")
-
- alB := albumByName("Album B")
- Expect(readArtwork(alB.CoverArtID())).To(Equal(imageBytes("album-b")))
+ // Album B first: the acquire in expectAlbumAbsent would settle Album B too.
+ expectAlbumFolderCover(albumByName("Album B"), "Artist/Album B/cover.jpg")
+ expectAlbumAbsent(albumByName("Album A"))
})
})
@@ -402,21 +368,58 @@ var _ = Describe("Album artwork resolution", func() {
It("does not use the artist image as album art for the spread album", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
- "Artist/folder.jpg": imageFile("artist-thumbnail"),
+ "Artist/folder.jpg": smallPNG("artist-thumbnail"),
"Artist/Album A/01 - Track.mp3": trackFile(1, "Track A1", map[string]any{"album": "Album A", "albumartist": "Artist"}),
"Artist/Album A bonus/02 - Track.mp3": trackFile(2, "Track A2", map[string]any{"album": "Album A", "albumartist": "Artist"}),
"Artist/Album B/01 - Track.mp3": trackFile(1, "Track B", map[string]any{"album": "Album B", "albumartist": "Artist"}),
- "Artist/Album B/cover.jpg": imageFile("album-b"),
+ "Artist/Album B/cover.jpg": smallPNG("album-b"),
})
scan()
alA := albumByName("Album A")
Expect(alA.FolderIDs).To(HaveLen(2),
- "sanity check: scanner should treat the two sibling folders as one spread album")
- _, err := readArtworkOrErr(alA.CoverArtID())
- Expect(err).To(HaveOccurred(),
- "the spread album has no images of its own, so it must fall through to the "+
- "placeholder instead of inheriting the artist folder's folder.jpg")
+ "sanity check: the two sibling folders should form one spread album")
+ expectAlbumAbsent(alA)
+ })
+ })
+
+ // albumRootParent refuses the library root as an album root (parent.ParentID == "").
+ When("a multi-disc album sits directly at the library root with a cover.jpg beside it", func() {
+ // (library root)
+ // ├── cover.jpg ← must NOT be adopted
+ // ├── CD1/
+ // │ └── 01 - Track.mp3
+ // └── CD2/
+ // └── 01 - Track.mp3
+ It("does not adopt the library-root image as album art", func() {
+ conf.Server.CoverArtPriority = defaultCoverPriority
+ setLayout(fstest.MapFS{
+ "cover.jpg": smallPNG("library-root"),
+ "CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"album": "Rootless", "disc": "1"}),
+ "CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"album": "Rootless", "disc": "2"}),
+ })
+ scan()
+ expectAlbumAbsent(firstAlbum())
+ })
+ })
+
+ // The shallower artist-folder cover.jpg would win the basename tie, but albumRootParent skips
+ // the parent folder for a single-folder album that has images of its own.
+ When("a single-folder album has its own cover.jpg and the artist folder has one too", func() {
+ // Artist/
+ // ├── cover.jpg ← shallower, but must NOT win
+ // └── Album/
+ // ├── 01 - Track.mp3
+ // └── cover.jpg ← should win
+ It("prefers the album's own cover over the shallower artist-folder cover", func() {
+ conf.Server.CoverArtPriority = defaultCoverPriority
+ setLayout(fstest.MapFS{
+ "Artist/cover.jpg": smallPNG("artist-image"),
+ "Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),
+ "Artist/Album/cover.jpg": smallPNG("album-own"),
+ })
+ scan()
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")
})
})
@@ -430,13 +433,13 @@ var _ = Describe("Album artwork resolution", func() {
// ├── Album A bonus/
// │ └── 02 - Track.mp3 (album: "Album A")
// └── Album B/
- // └── 01 - Track.mp3
+ // └── 01 - Track.mp3 (other-album audio: rejects the artist folder as a root)
It("prefers the album's own art over the artist image", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
- "Artist/cover.jpg": imageFile("artist-image"),
+ "Artist/cover.jpg": smallPNG("artist-image"),
"Artist/Album A/01 - Track.mp3": trackFile(1, "Track A1", map[string]any{"album": "Album A", "albumartist": "Artist"}),
- "Artist/Album A/front.jpg": imageFile("album-a-front"),
+ "Artist/Album A/front.jpg": smallPNG("album-a-front"),
"Artist/Album A bonus/02 - Track.mp3": trackFile(2, "Track A2", map[string]any{"album": "Album A", "albumartist": "Artist"}),
"Artist/Album B/01 - Track.mp3": trackFile(1, "Track B", map[string]any{"album": "Album B", "albumartist": "Artist"}),
})
@@ -444,8 +447,8 @@ var _ = Describe("Album artwork resolution", func() {
alA := albumByName("Album A")
Expect(alA.FolderIDs).To(HaveLen(2),
- "sanity check: scanner should treat the two sibling folders as one spread album")
- Expect(readArtwork(alA.CoverArtID())).To(Equal(imageBytes("album-a-front")))
+ "sanity check: the two sibling folders should form one spread album")
+ expectAlbumFolderCover(alA, "Artist/Album A/front.jpg")
})
})
@@ -458,12 +461,10 @@ var _ = Describe("Album artwork resolution", func() {
conf.Server.CoverArtPriority = "embedded, cover.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.jpg": imageFile("cover"),
+ "Artist/Album/cover.jpg": smallPNG("cover"),
})
scan()
-
- al := firstAlbum()
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("cover")))
+ expectAlbumFolderCover(firstAlbum(), "Artist/Album/cover.jpg")
})
})
})
diff --git a/core/artwork/e2e/artist_test.go b/core/artwork/e2e/artist_test.go
index 2079d37ce..5a9396cc3 100644
--- a/core/artwork/e2e/artist_test.go
+++ b/core/artwork/e2e/artist_test.go
@@ -1,4 +1,4 @@
-package artworke2e_test
+package e2e
import (
"os"
@@ -8,6 +8,7 @@ import (
"github.com/Masterminds/squirrel"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/model"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
@@ -16,9 +17,11 @@ import (
// Doc reference:
// https://www.navidrome.org/docs/usage/library/artwork/#artists
// Default ArtistArtPriority is "artist.*, album/artist.*, external".
+// Library-folder images are file-backed (asserted on the worker state row); uploaded and
+// image-folder images are real files on disk (asserted byte-for-byte).
var _ = Describe("Artist artwork resolution", func() {
BeforeEach(func() {
- setupHarness()
+ setupResolutionHarness()
})
When("the artist folder contains an artist.jpg", func() {
@@ -30,13 +33,10 @@ var _ = Describe("Artist artwork resolution", func() {
conf.Server.ArtistArtPriority = "artist.*, album/artist.*, external"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),
- "Artist/artist.jpg": imageFile("artist-folder"),
+ "Artist/artist.jpg": smallPNG("artist-folder"),
})
scan()
-
- ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))
+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")
})
})
@@ -49,13 +49,10 @@ var _ = Describe("Artist artwork resolution", func() {
conf.Server.ArtistArtPriority = "artist.*, album/artist.*, external"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),
- "Artist/Album/artist.jpg": imageFile("album-artist"),
+ "Artist/Album/artist.jpg": smallPNG("album-artist"),
})
scan()
-
- ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("album-artist")))
+ expectArtistFolder(soleArtist(), "Artist/Album/artist.jpg")
})
})
@@ -69,14 +66,11 @@ var _ = Describe("Artist artwork resolution", func() {
conf.Server.ArtistArtPriority = "artist.*, album/artist.*, external"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),
- "Artist/artist.jpg": imageFile("artist-folder"),
- "Artist/Album/artist.jpg": imageFile("album-artist"),
+ "Artist/artist.jpg": smallPNG("artist-folder"),
+ "Artist/Album/artist.jpg": smallPNG("album-artist"),
})
scan()
-
- ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))
+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")
})
})
@@ -89,13 +83,10 @@ var _ = Describe("Artist artwork resolution", func() {
conf.Server.ArtistArtPriority = "artist.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),
- "Artist/artist.jpg": imageFile("artist-folder"),
+ "Artist/artist.jpg": smallPNG("artist-folder"),
})
scan()
-
- ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))
+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")
})
})
@@ -111,14 +102,11 @@ var _ = Describe("Artist artwork resolution", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "Track 1", map[string]any{"albumartist": "Artist", "album": "Album"}),
"Artist/Album/CD2/02 - Track.mp3": trackFile(2, "Track 2", map[string]any{"albumartist": "Artist", "album": "Album"}),
- "Artist/artist.jpg": imageFile("artist-folder"),
- "Artist/Album/artist.jpg": imageFile("album-artist"),
+ "Artist/artist.jpg": smallPNG("artist-folder"),
+ "Artist/Album/artist.jpg": smallPNG("album-artist"),
})
scan()
-
- ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))
+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")
})
})
@@ -136,14 +124,11 @@ var _ = Describe("Artist artwork resolution", func() {
"Artist/Album1/CD1/01 - Track.mp3": trackFile(1, "Track 1", map[string]any{"albumartist": "Artist", "album": "Album1"}),
"Artist/Album1/CD2/02 - Track.mp3": trackFile(2, "Track 2", map[string]any{"albumartist": "Artist", "album": "Album1"}),
"Artist/Album2/03 - Track.mp3": trackFile(3, "Track 3", map[string]any{"albumartist": "Artist", "album": "Album2"}),
- "Artist/artist.jpg": imageFile("artist-folder"),
- "Artist/Album1/artist.jpg": imageFile("album-artist"),
+ "Artist/artist.jpg": smallPNG("artist-folder"),
+ "Artist/Album1/artist.jpg": smallPNG("album-artist"),
})
scan()
-
- ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))
+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")
})
})
@@ -164,14 +149,11 @@ var _ = Describe("Artist artwork resolution", func() {
"Artist/Album1/CD2/02 - Track.mp3": trackFile(2, "Track 2", map[string]any{"albumartist": "Artist", "album": "Album1"}),
"Artist/Album2/CD1/03 - Track.mp3": trackFile(3, "Track 3", map[string]any{"albumartist": "Artist", "album": "Album2"}),
"Artist/Album2/CD2/04 - Track.mp3": trackFile(4, "Track 4", map[string]any{"albumartist": "Artist", "album": "Album2"}),
- "Artist/artist.jpg": imageFile("artist-folder"),
- "Artist/Album1/artist.jpg": imageFile("album-artist"),
+ "Artist/artist.jpg": smallPNG("artist-folder"),
+ "Artist/Album1/artist.jpg": smallPNG("album-artist"),
})
scan()
-
- ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-folder")))
+ expectArtistFolder(soleArtist(), "Artist/artist.jpg")
})
})
@@ -189,18 +171,19 @@ var _ = Describe("Artist artwork resolution", func() {
conf.Server.ArtistArtPriority = "artist.*, album/artist.*, external"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),
- "Artist/artist.jpg": imageFile("artist-folder"),
+ "Artist/artist.jpg": smallPNG("artist-folder"),
})
scan()
ar := soleArtist()
uploaded := ar.ID + "_upload.jpg"
- writeUploadedImage(consts.EntityArtist, uploaded, imageBytes("artist-uploaded"))
+ writeUploadedImage(consts.EntityArtist, uploaded, pngBytes("artist-uploaded"))
ar.UploadedImage = uploaded
- Expect(ds.Artist(ctx).Put(&ar)).To(Succeed())
+ Expect(rds.Artist(rctx).Put(&ar)).To(Succeed())
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("artist-uploaded")))
+ ia := acquire(model.KindArtistArtwork, ar.ID)
+ Expect(ia.Source).To(Equal("upload"))
+ Expect(serveBytes(model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil))).To(Equal(pngBytes("artist-uploaded")))
})
})
@@ -213,13 +196,36 @@ var _ = Describe("Artist artwork resolution", func() {
conf.Server.ArtistArtPriority = "album/artist.*, external"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist"}),
- "Artist/Album/artist.jpg": imageFile("album-artist"),
+ "Artist/Album/artist.jpg": smallPNG("album-artist"),
+ })
+ scan()
+ expectArtistFolder(soleArtist(), "Artist/Album/artist.jpg")
+ })
+ })
+
+ // resolveArtist only samples albums where this artist is the SOLE album artist, so a
+ // collaboration or compilation never donates its images as the artist's own.
+ When("the artist's only album is credited to two album artists", func() {
+ // Artist/
+ // └── Collab Album/ (album artists: "Artist" + a collaborator)
+ // ├── 01 - Track.mp3
+ // └── artist.jpg ← must NOT become the artist image
+ It("ignores the album's images and settles absent", func() {
+ conf.Server.ArtistArtPriority = "album/artist.*"
+ // " / " is a default artists split separator, so this single tag yields two album artists.
+ setLayout(fstest.MapFS{
+ "Artist/Collab Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"albumartist": "Artist / Collaborator"}),
+ "Artist/Collab Album/artist.jpg": smallPNG("collab-artist"),
})
scan()
+ Expect(firstAlbum().Participants[model.RoleAlbumArtist]).To(HaveLen(2),
+ "sanity check: the album must be credited to two album artists")
ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("album-artist")))
+ ia := acquire(model.KindArtistArtwork, ar.ID)
+ Expect(ia.Hash).To(BeEmpty())
+ Expect(serveErr(model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil))).
+ To(MatchError(artwork.ErrUnavailable))
})
})
@@ -232,7 +238,7 @@ var _ = Describe("Artist artwork resolution", func() {
// └── 01 - Track.mp3 (no artist.* present in library)
It("returns the image from the configured artist image folder", func() {
imgFolder := GinkgoT().TempDir()
- Expect(os.WriteFile(filepath.Join(imgFolder, "Artist.jpg"), imageBytes("image-folder"), 0600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(imgFolder, "Artist.jpg"), pngBytes("image-folder"), 0o600)).To(Succeed())
conf.Server.ArtistImageFolder = imgFolder
conf.Server.ArtistArtPriority = "image-folder, artist.*, album/artist.*"
@@ -242,15 +248,16 @@ var _ = Describe("Artist artwork resolution", func() {
scan()
ar := soleArtist()
- artID := model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("image-folder")))
+ ia := acquire(model.KindArtistArtwork, ar.ID)
+ Expect(ia.Source).To(Equal("folder"))
+ Expect(serveBytes(model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil))).To(Equal(pngBytes("image-folder")))
})
})
})
func soleArtist() model.Artist {
GinkgoHelper()
- artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{
+ artists, err := rds.Artist(rctx).GetAll(model.QueryOptions{
Filters: squirrel.Eq{"artist.name": "Artist"},
})
Expect(err).ToNot(HaveOccurred())
diff --git a/core/artwork/e2e/disc_test.go b/core/artwork/e2e/disc_test.go
index 667079458..5fdd5f27b 100644
--- a/core/artwork/e2e/disc_test.go
+++ b/core/artwork/e2e/disc_test.go
@@ -1,18 +1,20 @@
-package artworke2e_test
+package e2e
import (
"fmt"
"testing/fstest"
"github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/core/artwork"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
+// Disc art is a serve-time read through the library FS (no worker state row), so per-disc images
+// are asserted byte-for-byte, while album-root covers are asserted on the state row.
var _ = Describe("Disc artwork resolution", func() {
BeforeEach(func() {
- setupHarness()
+ setupResolutionHarness()
})
When("the album is single-disc with a disc1.jpg in the only folder", func() {
@@ -24,32 +26,25 @@ var _ = Describe("Disc artwork resolution", func() {
conf.Server.DiscArtPriority = "disc*.*, cd*.*, cover.*, folder.*, front.*, embedded"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/disc1.jpg": imageFile("disc1-image"),
+ "Artist/Album/disc1.jpg": smallPNG("disc1-image"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("disc1-image")))
+ expectDiscImage(firstAlbum(), 1, "disc1-image")
})
})
When("the album has no per-disc image and no album cover", func() {
// Artist/
// └── Album/
- // └── 01 - Track.mp3 (no disc or album art — returns ErrUnavailable)
- It("returns ErrUnavailable for the disc lookup", func() {
+ // └── 01 - Track.mp3 (no disc or album art — nothing to serve)
+ It("reports the disc lookup as unavailable", func() {
conf.Server.DiscArtPriority = "disc*.*, cd*.*"
conf.Server.CoverArtPriority = "cover.*, folder.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)
- _, err := readArtworkOrErr(discID)
- Expect(err).To(HaveOccurred())
+ Expect(serveErr(discArtID(firstAlbum(), 1))).To(MatchError(artwork.ErrUnavailable))
})
})
@@ -63,13 +58,10 @@ var _ = Describe("Disc artwork resolution", func() {
conf.Server.CoverArtPriority = defaultCoverPriority
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.jpg": imageFile("album-cover"),
+ "Artist/Album/cover.jpg": smallPNG("album-cover"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("album-cover")))
+ expectDiscImage(firstAlbum(), 1, "album-cover")
})
})
@@ -83,14 +75,11 @@ var _ = Describe("Disc artwork resolution", func() {
conf.Server.DiscArtPriority = "disc*.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/disc1.jpg": imageFile("disc-one"),
- "Artist/Album/disc10.jpg": imageFile("disc-ten"),
+ "Artist/Album/disc1.jpg": smallPNG("disc-one"),
+ "Artist/Album/disc10.jpg": smallPNG("disc-ten"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("disc-one")))
+ expectDiscImage(firstAlbum(), 1, "disc-one")
})
})
@@ -108,14 +97,11 @@ var _ = Describe("Disc artwork resolution", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),
"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),
- "Artist/Album/CD1/disc1.jpg": imageFile("disc-1"),
- "Artist/Album/CD2/disc2.jpg": imageFile("disc-2"),
+ "Artist/Album/CD1/disc1.jpg": smallPNG("disc-1"),
+ "Artist/Album/CD2/disc2.jpg": smallPNG("disc-2"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 2), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("disc-2")))
+ expectDiscImage(firstAlbum(), 2, "disc-2")
})
})
@@ -136,14 +122,11 @@ var _ = Describe("Disc artwork resolution", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),
"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),
- "Artist/Album/CD1/disc1.jpg": imageFile("disc-1"),
- "Artist/Album/CD2/cd2.png": imageFile("cd-2"),
+ "Artist/Album/CD1/disc1.jpg": smallPNG("disc-1"),
+ "Artist/Album/CD2/cd2.png": smallPNG("cd-2"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 2), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("cd-2")))
+ expectDiscImage(firstAlbum(), 2, "cd-2")
})
})
@@ -161,14 +144,11 @@ var _ = Describe("Disc artwork resolution", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),
"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),
- "Artist/Album/CD1/cover.jpg": imageFile("disc1-cover"),
- "Artist/Album/CD2/cover.jpg": imageFile("disc2-cover"),
+ "Artist/Album/CD1/cover.jpg": smallPNG("disc1-cover"),
+ "Artist/Album/CD2/cover.jpg": smallPNG("disc2-cover"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("disc1-cover")))
+ expectDiscImage(firstAlbum(), 1, "disc1-cover")
})
})
@@ -188,17 +168,15 @@ var _ = Describe("Disc artwork resolution", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),
"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),
- "Artist/Album/CD1/disc1.jpg": imageFile("disc-1"),
- "Artist/Album/CD2/cd2.png": imageFile("cd-2"),
- "Artist/Album/cover.jpg": imageFile("album-cover"),
+ "Artist/Album/CD1/disc1.jpg": smallPNG("disc-1"),
+ "Artist/Album/CD2/cd2.png": smallPNG("cd-2"),
+ "Artist/Album/cover.jpg": smallPNG("album-cover"),
})
scan()
al := firstAlbum()
for _, n := range []int{1, 2} {
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, n), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("album-cover")),
- "disc %d should use the album cover when DiscArtPriority is empty", n)
+ expectDiscImage(al, n, "album-cover")
}
})
})
@@ -223,17 +201,15 @@ var _ = Describe("Disc artwork resolution", func() {
"Artist/Album/disc1/02 - Track.mp3": trackFile(2, "T2", map[string]any{"disc": "1"}),
"Artist/Album/disc2/01 - Track.mp3": trackFile(1, "T3", map[string]any{"disc": "2"}),
"Artist/Album/disc2/02 - Track.mp3": trackFile(2, "T4", map[string]any{"disc": "2"}),
- "Artist/Album/disc1/disc1.jpg": imageFile("disc-1"),
- "Artist/Album/disc2/cd2.png": imageFile("cd-2"),
- "Artist/Album/cover.jpg": imageFile("album-root"),
+ "Artist/Album/disc1/disc1.jpg": smallPNG("disc-1"),
+ "Artist/Album/disc2/cd2.png": smallPNG("cd-2"),
+ "Artist/Album/cover.jpg": smallPNG("album-root"),
})
scan()
al := firstAlbum()
- disc1ID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)
- disc2ID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 2), &al.UpdatedAt)
- Expect(readArtwork(disc1ID)).To(Equal(imageBytes("disc-1")))
- Expect(readArtwork(disc2ID)).To(Equal(imageBytes("cd-2")))
+ expectDiscImage(al, 1, "disc-1")
+ expectDiscImage(al, 2, "cd-2")
})
})
@@ -246,13 +222,10 @@ var _ = Describe("Disc artwork resolution", func() {
conf.Server.DiscArtPriority = "discsubtitle"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1", "discsubtitle": "Bonus Tracks"}),
- "Artist/Album/Bonus Tracks.jpg": imageFile("bonus-tracks"),
+ "Artist/Album/Bonus Tracks.jpg": smallPNG("bonus-tracks"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("bonus-tracks")))
+ expectDiscImage(firstAlbum(), 1, "bonus-tracks")
})
})
@@ -286,26 +259,22 @@ var _ = Describe("Disc artwork resolution", func() {
"Disc 12 (History of the Grateful Dead, Volume One (Bear's Choice))",
}
layout := fstest.MapFS{
- "Pop; Rock/Grateful Dead/(2001) The Golden Road/cover.jpg": imageFile("album-root-cover"),
+ "Pop; Rock/Grateful Dead/(2001) The Golden Road/cover.jpg": smallPNG("album-root-cover"),
}
for i, name := range discNames {
discNum := i + 1
prefix := fmt.Sprintf("Pop; Rock/Grateful Dead/(2001) The Golden Road/%s/", name)
layout[prefix+"01 - Track.mp3"] = trackFile(1, fmt.Sprintf("T%d", discNum), map[string]any{"disc": fmt.Sprintf("%d", discNum)})
- layout[prefix+"folder.jpg"] = imageFile(fmt.Sprintf("disc-%02d-folder", discNum))
+ layout[prefix+"folder.jpg"] = smallPNG(fmt.Sprintf("disc-%02d-folder", discNum))
}
setLayout(layout)
scan()
al := firstAlbum()
-
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root-cover")))
-
+ expectAlbumFolderCover(al, "(2001) The Golden Road/cover.jpg")
for i := range discNames {
discNum := i + 1
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, discNum), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes(fmt.Sprintf("disc-%02d-folder", discNum))),
- "disc %d should use its own folder.jpg", discNum)
+ expectDiscImage(al, discNum, fmt.Sprintf("disc-%02d-folder", discNum))
}
})
})
@@ -328,24 +297,20 @@ var _ = Describe("Disc artwork resolution", func() {
conf.Server.DiscArtPriority = defaultDiscPriority
conf.Server.CoverArtPriority = defaultCoverPriority
layout := fstest.MapFS{
- "Album/cover.jpg": imageFile("album-root-cover"),
+ "Album/cover.jpg": smallPNG("album-root-cover"),
}
for i := 1; i <= 3; i++ {
prefix := fmt.Sprintf("Album/Disc %02d/", i)
layout[prefix+"01 - Track.mp3"] = trackFile(1, fmt.Sprintf("T%d", i), map[string]any{"disc": fmt.Sprintf("%d", i)})
- layout[prefix+"folder.jpg"] = imageFile(fmt.Sprintf("disc-%02d-folder", i))
+ layout[prefix+"folder.jpg"] = smallPNG(fmt.Sprintf("disc-%02d-folder", i))
}
setLayout(layout)
scan()
al := firstAlbum()
-
- Expect(readArtwork(al.CoverArtID())).To(Equal(imageBytes("album-root-cover")))
-
+ expectAlbumFolderCover(al, "Album/cover.jpg")
for i := 1; i <= 3; i++ {
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, i), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes(fmt.Sprintf("disc-%02d-folder", i))),
- "disc %d should use its own folder.jpg", i)
+ expectDiscImage(al, i, fmt.Sprintf("disc-%02d-folder", i))
}
})
})
@@ -359,13 +324,10 @@ var _ = Describe("Disc artwork resolution", func() {
conf.Server.DiscArtPriority = "discsubtitle, cover.*"
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1", "discsubtitle": "Bonus Tracks"}),
- "Artist/Album/cover.jpg": imageFile("cover"),
+ "Artist/Album/cover.jpg": smallPNG("cover"),
})
scan()
-
- al := firstAlbum()
- discID := model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, 1), &al.UpdatedAt)
- Expect(readArtwork(discID)).To(Equal(imageBytes("cover")))
+ expectDiscImage(firstAlbum(), 1, "cover")
})
})
})
diff --git a/core/artwork/e2e/e2e_suite_test.go b/core/artwork/e2e/e2e_suite_test.go
new file mode 100644
index 000000000..8881da3a6
--- /dev/null
+++ b/core/artwork/e2e/e2e_suite_test.go
@@ -0,0 +1,83 @@
+// Package e2e exercises the artwork pipeline end to end: the real Worker drains the queue and the
+// real Service serves the result, over a real ImageStore and real library files.
+package e2e
+
+import (
+ "context"
+ "io"
+ "os"
+ "path/filepath"
+ "testing"
+ "time"
+
+ _ "github.com/navidrome/navidrome/adapters/gotaglib" // registers the "taglib" local-storage extractor
+ "github.com/navidrome/navidrome/core/artwork"
+ _ "github.com/navidrome/navidrome/core/storage/local"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+func TestArtworkE2E(t *testing.T) {
+ tests.Init(t, false)
+ log.SetLevel(log.LevelFatal)
+ RegisterFailHandler(Fail)
+ RunSpecs(t, "Artwork Pipeline E2E Suite")
+}
+
+// Fixtures relative to the project root (tests.Init chdirs there).
+const (
+ coverFixture = "tests/fixtures/artist/an-album/cover.jpg"
+ mp3Fixture = "tests/fixtures/artist/an-album/test.mp3"
+ artistPngFixture = "tests/fixtures/artist/an-album/artist.png"
+ albumFolderPath = "tests/fixtures/artist/an-album"
+)
+
+func readFixture(rel string) []byte {
+ GinkgoHelper()
+ data, err := os.ReadFile(rel)
+ Expect(err).ToNot(HaveOccurred(), "reading fixture %q", rel)
+ return data
+}
+
+func readAll(img *artwork.Image) []byte {
+ GinkgoHelper()
+ Expect(img).ToNot(BeNil())
+ defer img.Close()
+ data, err := io.ReadAll(img)
+ Expect(err).ToNot(HaveOccurred())
+ return data
+}
+
+func runWorkerUntil(ctx context.Context, worker *artwork.Worker, until func() bool) {
+ GinkgoHelper()
+ runCtx, cancel := context.WithCancel(ctx)
+ done := make(chan error, 1)
+ go func() { done <- worker.Run(runCtx) }()
+ Eventually(until, 5*time.Second, 10*time.Millisecond).Should(BeTrue())
+ cancel()
+ Eventually(done, 2*time.Second).Should(Receive(BeNil()))
+}
+
+type fakeFolderRepo struct {
+ model.FolderRepository
+ result []model.Folder
+}
+
+func (f *fakeFolderRepo) GetAll(...model.QueryOptions) ([]model.Folder, error) { return f.result, nil }
+
+func (f *fakeFolderRepo) HasAudioOutsideFolders(model.Folder, []string) (bool, error) {
+ return false, nil
+}
+
+func (f *fakeFolderRepo) Get(string) (*model.Folder, error) { return nil, model.ErrNotFound }
+
+func writeUpload(entityType, name, srcFixture string) string {
+ GinkgoHelper()
+ dst := model.UploadedImagePath(entityType, name)
+ Expect(os.MkdirAll(filepath.Dir(dst), 0o755)).To(Succeed())
+ Expect(os.WriteFile(dst, readFixture(srcFixture), 0o600)).To(Succeed())
+ return name
+}
diff --git a/core/artwork/e2e/helpers_test.go b/core/artwork/e2e/helpers_test.go
deleted file mode 100644
index ddc926cec..000000000
--- a/core/artwork/e2e/helpers_test.go
+++ /dev/null
@@ -1,184 +0,0 @@
-package artworke2e_test
-
-import (
- "bytes"
- "context"
- _ "embed"
- "errors"
- "hash/fnv"
- "image"
- "image/color"
- "image/png"
- "io"
- "maps"
- "net/url"
- "os"
- "path/filepath"
- "testing/fstest"
-
- "github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/external"
- "github.com/navidrome/navidrome/core/storage/storagetest"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/resources"
- "github.com/navidrome/navidrome/tests"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
- "go.senan.xyz/taglib"
-)
-
-// realMP3WithEmbeddedArt is the bytes of the canonical test fixture that
-// contains a valid MP3 stream with an embedded picture. Used in the
-// embedded-art e2e scenarios where FakeFS's JSON-encoded tag data isn't
-// readable by taglib. Swap this into fakeFS.MapFS *after* scanning so the
-// scanner still populates EmbedArtPath via the JSON-tagged track, and the
-// artwork reader gets real bytes when it calls libFS.Open.
-//
-//go:embed testdata/embedded_art.mp3
-var realMP3WithEmbeddedArt []byte
-
-// embeddedArtBytes is the exact image payload that the artwork reader will
-// extract from realMP3WithEmbeddedArt. Computed once via taglib so tests can
-// assert byte-for-byte equality — if this ever differs it means the reader
-// pulled from a different source.
-var embeddedArtBytes = extractEmbeddedArt(realMP3WithEmbeddedArt)
-
-func extractEmbeddedArt(mp3 []byte) []byte {
- tf, err := taglib.OpenStream(bytes.NewReader(mp3))
- if err != nil {
- panic("embedded-art fixture: taglib.OpenStream failed: " + err.Error())
- }
- defer tf.Close()
- images := tf.Properties().Images
- if len(images) == 0 {
- panic("embedded-art fixture has no embedded images")
- }
- data, err := tf.Image(0)
- if err != nil || len(data) == 0 {
- panic("embedded-art fixture: could not read image 0")
- }
- return data
-}
-
-// replaceWithRealMP3 swaps the FakeFS entry at the given library-relative
-// path so libFS.Open returns an MP3 stream taglib can parse.
-func replaceWithRealMP3(relPath string) {
- GinkgoHelper()
- fakeFS.MapFS[relPath] = &fstest.MapFile{Data: realMP3WithEmbeddedArt}
-}
-
-// placeholderBytes returns the bundled album-placeholder image bytes — the
-// same stream the artwork reader emits when every source falls through.
-func placeholderBytes() []byte {
- GinkgoHelper()
- r, err := resources.FS().Open(consts.PlaceholderAlbumArt)
- Expect(err).ToNot(HaveOccurred())
- defer r.Close()
- data, err := io.ReadAll(r)
- Expect(err).ToNot(HaveOccurred())
- return data
-}
-
-// writeUploadedImage drops `filename` into <DataFolder>/artwork/<entity>/ with
-// the given bytes, matching the on-disk layout expected by
-// model.UploadedImagePath.
-func writeUploadedImage(entity, filename string, data []byte) {
- GinkgoHelper()
- dir := filepath.Dir(model.UploadedImagePath(entity, filename))
- Expect(os.MkdirAll(dir, 0755)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(dir, filename), data, 0600)).To(Succeed())
-}
-
-func newNoopFFmpeg() *tests.MockFFmpeg {
- ff := tests.NewMockFFmpeg("")
- ff.Error = errors.New("noop")
- return ff
-}
-
-// trackFile builds a FakeFS MP3 entry with optional tag overrides.
-func trackFile(num int, title string, extra ...map[string]any) *fstest.MapFile {
- tags := storagetest.Track(num, title)
- for _, e := range extra {
- maps.Copy(tags, e)
- }
- return storagetest.MP3(tags)
-}
-
-// imageFile builds a label-keyed image entry. The bytes are deterministic
-// per-label so tests can assert which file won.
-func imageFile(label string) *fstest.MapFile {
- return &fstest.MapFile{Data: []byte("image:" + label)}
-}
-
-// realPNG builds a minimal 2x2 PNG with a color derived from label. Needed by
-// tests that feed the bytes into image.Decode (e.g. playlist tiled covers).
-func realPNG(label string) *fstest.MapFile {
- img := image.NewRGBA(image.Rect(0, 0, 2, 2))
- // Derive a deterministic color per label.
- h := fnv.New32a()
- _, _ = h.Write([]byte(label))
- sum := h.Sum32()
- c := color.RGBA{R: byte(sum), G: byte(sum >> 8), B: byte(sum >> 16), A: 255}
- for y := range 2 {
- for x := range 2 {
- img.Set(x, y, c)
- }
- }
- var buf bytes.Buffer
- Expect(png.Encode(&buf, img)).To(Succeed())
- return &fstest.MapFile{Data: buf.Bytes()}
-}
-
-// imageBytes returns the bytes that imageFile(label) writes.
-func imageBytes(label string) []byte { return imageFile(label).Data }
-
-// setLayout populates fakeFS with the given map. Call after setupHarness.
-// All paths must be forward-slash and relative (no leading "/").
-func setLayout(files fstest.MapFS) {
- GinkgoHelper()
- fakeFS.SetFiles(files)
-}
-
-func readArtwork(artID model.ArtworkID) []byte {
- GinkgoHelper()
- r, _, err := aw.Get(ctx, artID, 0, false)
- Expect(err).ToNot(HaveOccurred())
- defer r.Close()
- b, err := io.ReadAll(r)
- Expect(err).ToNot(HaveOccurred())
- return b
-}
-
-func readArtworkOrErr(artID model.ArtworkID) ([]byte, error) {
- r, _, err := aw.Get(ctx, artID, 0, false)
- if err != nil {
- return nil, err
- }
- defer r.Close()
- return io.ReadAll(r)
-}
-
-// noopProvider implements external.Provider with not-found returns so the
-// "external" priority entry never produces a result.
-type noopProvider struct{}
-
-func (n *noopProvider) UpdateAlbumInfo(context.Context, string) (*model.Album, error) {
- return nil, model.ErrNotFound
-}
-func (n *noopProvider) UpdateArtistInfo(context.Context, string, int, bool) (*model.Artist, error) {
- return nil, model.ErrNotFound
-}
-func (n *noopProvider) SimilarSongs(context.Context, string, int) (model.MediaFiles, error) {
- return nil, nil
-}
-func (n *noopProvider) TopSongs(context.Context, string, string, int) (model.MediaFiles, error) {
- return nil, nil
-}
-func (n *noopProvider) ArtistImage(context.Context, string) (*url.URL, error) {
- return nil, model.ErrNotFound
-}
-func (n *noopProvider) AlbumImage(context.Context, string) (*url.URL, error) {
- return nil, model.ErrNotFound
-}
-
-var _ external.Provider = (*noopProvider)(nil)
diff --git a/core/artwork/e2e/mediafile_test.go b/core/artwork/e2e/mediafile_test.go
index 1f43a3827..d26756dcd 100644
--- a/core/artwork/e2e/mediafile_test.go
+++ b/core/artwork/e2e/mediafile_test.go
@@ -1,4 +1,4 @@
-package artworke2e_test
+package e2e
import (
"testing/fstest"
@@ -17,13 +17,11 @@ import (
// 2. For multi-disc albums, disc-level artwork
// 3. Album cover art
//
-// FakeFS cannot synthesize taglib-readable embedded JPEGs, so scenario (1)
-// is covered by the existing embedded-art album tests (which currently
-// Skip under FakeFS). The tests below cover (2) and (3): the fallback
-// chain for tracks without embedded art.
-var _ = Describe("MediaFile artwork fallback", func() {
+// Embedded art lands in the content-addressed store (asserted byte-for-byte); disc-level art is a
+// serve-time read through the library FS.
+var _ = Describe("MediaFile artwork resolution", func() {
BeforeEach(func() {
- setupHarness()
+ setupResolutionHarness()
})
When("a multi-disc album track has no embedded art", func() {
@@ -42,14 +40,14 @@ var _ = Describe("MediaFile artwork fallback", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),
"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),
- "Artist/Album/CD1/disc1.jpg": imageFile("disc-1"),
- "Artist/Album/CD2/disc2.jpg": imageFile("disc-2"),
- "Artist/Album/cover.jpg": imageFile("album-root"),
+ "Artist/Album/CD1/disc1.jpg": smallPNG("disc-1"),
+ "Artist/Album/CD2/disc2.jpg": smallPNG("disc-2"),
+ "Artist/Album/cover.jpg": smallPNG("album-root"),
})
scan()
mf := mediafileOn("Artist/Album/CD2/01 - Track.mp3")
- Expect(readArtwork(mf.CoverArtID())).To(Equal(imageBytes("disc-2")))
+ Expect(serveBytes(mf.CoverArtID())).To(Equal(pngBytes("disc-2")))
})
})
@@ -63,12 +61,12 @@ var _ = Describe("MediaFile artwork fallback", func() {
conf.Server.DiscArtPriority = defaultDiscPriority
setLayout(fstest.MapFS{
"Artist/Album/01 - Track.mp3": trackFile(1, "Track"),
- "Artist/Album/cover.jpg": imageFile("album-cover"),
+ "Artist/Album/cover.jpg": smallPNG("album-cover"),
})
scan()
mf := mediafileOn("Artist/Album/01 - Track.mp3")
- Expect(readArtwork(mf.CoverArtID())).To(Equal(imageBytes("album-cover")))
+ Expect(serveBytes(mf.CoverArtID())).To(Equal(pngBytes("album-cover")))
})
})
@@ -86,19 +84,60 @@ var _ = Describe("MediaFile artwork fallback", func() {
setLayout(fstest.MapFS{
"Artist/Album/CD1/01 - Track.mp3": trackFile(1, "T1", map[string]any{"disc": "1"}),
"Artist/Album/CD2/01 - Track.mp3": trackFile(1, "T2", map[string]any{"disc": "2"}),
- "Artist/Album/cover.jpg": imageFile("album-root"),
+ "Artist/Album/cover.jpg": smallPNG("album-root"),
})
scan()
mf := mediafileOn("Artist/Album/CD2/01 - Track.mp3")
- Expect(readArtwork(mf.CoverArtID())).To(Equal(imageBytes("album-root")))
+ Expect(serveBytes(mf.CoverArtID())).To(Equal(pngBytes("album-root")))
+ })
+ })
+
+ When("a track has its own embedded art", func() {
+ // Artist/
+ // └── Album/
+ // └── 01 - Track.mp3 ← has embedded picture (wins over every fallback)
+ It("resolves the track's embedded image into the store", func() {
+ conf.Server.CoverArtPriority = defaultCoverPriority
+ setLayout(fstest.MapFS{
+ "Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"has_picture": "true"}),
+ })
+ scan()
+ replaceWithRealMP3("Artist/Album/01 - Track.mp3")
+
+ mf := mediafileOn("Artist/Album/01 - Track.mp3")
+ ia := acquire(model.KindMediaFileArtwork, mf.ID)
+ Expect(ia.Source).To(Equal("embedded"))
+ Expect(storedBytes(ia)).To(Equal(embeddedArtBytes))
+ })
+ })
+
+ When("EnableMediaFileCoverArt is turned off after the track was scanned", func() {
+ // Artist/
+ // └── Album/
+ // ├── 01 - Track.mp3 ← has embedded picture (must NOT be served)
+ // └── cover.jpg ← wins (per-track art disabled at serve time)
+ It("serves the album cover instead of the track's embedded art", func() {
+ conf.Server.CoverArtPriority = defaultCoverPriority
+ setLayout(fstest.MapFS{
+ "Artist/Album/01 - Track.mp3": trackFile(1, "Track", map[string]any{"has_picture": "true"}),
+ "Artist/Album/cover.jpg": smallPNG("album-cover"),
+ })
+ scan()
+ replaceWithRealMP3("Artist/Album/01 - Track.mp3")
+
+ // The setting is not part of the artwork fingerprint, so it must be honored at serve time.
+ conf.Server.EnableMediaFileCoverArt = false
+ mf := mediafileOn("Artist/Album/01 - Track.mp3")
+ trackArtID := model.NewArtworkID(model.KindMediaFileArtwork, mf.ID, nil)
+ Expect(serveBytes(trackArtID)).To(Equal(pngBytes("album-cover")))
})
})
})
func mediafileOn(relPath string) model.MediaFile {
GinkgoHelper()
- mfs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
+ mfs, err := rds.MediaFile(rctx).GetAll(model.QueryOptions{
Filters: squirrel.Like{"media_file.path": relPath},
})
Expect(err).ToNot(HaveOccurred())
diff --git a/core/artwork/e2e/playlist_test.go b/core/artwork/e2e/playlist_test.go
index d28efca8e..f5ac8a7e3 100644
--- a/core/artwork/e2e/playlist_test.go
+++ b/core/artwork/e2e/playlist_test.go
@@ -1,13 +1,16 @@
-package artworke2e_test
+package e2e
import (
+ "image/color"
"os"
"path/filepath"
"testing/fstest"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils/slice"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -17,14 +20,13 @@ import (
// 2. Sidecar image next to the .m3u file (same basename, any image ext)
// 3. ExternalImageURL (http/https requires EnableM3UExternalAlbumArt; local path always allowed)
// 4. Generated 2x2 tiled cover from the playlist's albums
-// 5. Album placeholder image
+// 5. Absent
//
-// The library FS is FakeFS, but uploaded/sidecar/local-external images are
-// real files on disk — the reader reads them via os.Open, so the tests
-// place them in a real tempdir under DataFolder.
+// The library is an in-memory FS, but uploaded/sidecar/local-external images are real files on
+// disk — the resolver reads them via os.Open, so those tests place them in a real tempdir.
var _ = Describe("Playlist artwork resolution", func() {
BeforeEach(func() {
- setupHarness()
+ setupResolutionHarness()
})
When("a playlist has an uploaded image", func() {
@@ -33,11 +35,12 @@ var _ = Describe("Playlist artwork resolution", func() {
// └── playlist/
// └── pl-1_upload.jpg ← matched by UploadedImagePath() (highest priority)
It("returns the uploaded image bytes", func() {
- writeUploadedImage(consts.EntityPlaylist, "pl-1_upload.jpg", imageBytes("playlist-upload"))
-
+ writeUploadedImage(consts.EntityPlaylist, "pl-1_upload.jpg", pngBytes("playlist-upload"))
pl := putPlaylist(model.Playlist{ID: "pl-1", Name: "Test", UploadedImage: "pl-1_upload.jpg"})
- Expect(readArtwork(pl.CoverArtID())).To(Equal(imageBytes("playlist-upload")))
+ ia := acquire(model.KindPlaylistArtwork, pl.ID)
+ Expect(ia.Source).To(Equal("upload"))
+ Expect(serveBytes(pl.CoverArtID())).To(Equal(pngBytes("playlist-upload")))
})
})
@@ -48,12 +51,14 @@ var _ = Describe("Playlist artwork resolution", func() {
It("returns the sidecar image", func() {
dir := GinkgoT().TempDir()
m3uPath := filepath.Join(dir, "MyList.m3u")
- Expect(os.WriteFile(m3uPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(dir, "MyList.jpg"), imageBytes("sidecar"), 0600)).To(Succeed())
+ Expect(os.WriteFile(m3uPath, []byte("#EXTM3U\n"), 0o600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(dir, "MyList.jpg"), pngBytes("sidecar"), 0o600)).To(Succeed())
pl := putPlaylist(model.Playlist{ID: "pl-2", Name: "MyList", Path: m3uPath})
- Expect(readArtwork(pl.CoverArtID())).To(Equal(imageBytes("sidecar")))
+ ia := acquire(model.KindPlaylistArtwork, pl.ID)
+ Expect(ia.Source).To(Equal("folder"))
+ Expect(serveBytes(pl.CoverArtID())).To(Equal(pngBytes("sidecar")))
})
})
@@ -64,12 +69,12 @@ var _ = Describe("Playlist artwork resolution", func() {
It("matches case-insensitively", func() {
dir := GinkgoT().TempDir()
m3uPath := filepath.Join(dir, "MyList.m3u")
- Expect(os.WriteFile(m3uPath, []byte("#EXTM3U\n"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(dir, "MyList.PNG"), imageBytes("sidecar-png"), 0600)).To(Succeed())
+ Expect(os.WriteFile(m3uPath, []byte("#EXTM3U\n"), 0o600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(dir, "MyList.PNG"), pngBytes("sidecar-png"), 0o600)).To(Succeed())
pl := putPlaylist(model.Playlist{ID: "pl-3", Name: "MyList", Path: m3uPath})
- Expect(readArtwork(pl.CoverArtID())).To(Equal(imageBytes("sidecar-png")))
+ Expect(serveBytes(pl.CoverArtID())).To(Equal(pngBytes("sidecar-png")))
})
})
@@ -80,31 +85,39 @@ var _ = Describe("Playlist artwork resolution", func() {
conf.Server.EnableM3UExternalAlbumArt = false // local paths bypass the toggle
dir := GinkgoT().TempDir()
imgPath := filepath.Join(dir, "cover.jpg")
- Expect(os.WriteFile(imgPath, imageBytes("external-local"), 0600)).To(Succeed())
+ Expect(os.WriteFile(imgPath, pngBytes("external-local"), 0o600)).To(Succeed())
pl := putPlaylist(model.Playlist{ID: "pl-4", Name: "WithExt", ExternalImageURL: imgPath})
- Expect(readArtwork(pl.CoverArtID())).To(Equal(imageBytes("external-local")))
+ Expect(serveBytes(pl.CoverArtID())).To(Equal(pngBytes("external-local")))
})
})
When("a playlist has an http(s) ExternalImageURL and EnableM3UExternalAlbumArt is false", func() {
- // (no local files — http source is gated off, reader falls through to placeholder)
- It("skips the URL and falls through to the bundled placeholder", func() {
+ // (no local files — the http source is gated off, so resolution settles absent)
+ It("skips the URL and settles absent", func() {
conf.Server.EnableM3UExternalAlbumArt = false
-
pl := putPlaylist(model.Playlist{ID: "pl-5", Name: "HttpGated", ExternalImageURL: "https://example.com/cover.jpg"})
- Expect(readArtwork(pl.CoverArtID())).To(Equal(placeholderBytes()))
+ ia := acquire(model.KindPlaylistArtwork, pl.ID)
+ Expect(ia.Hash).To(BeEmpty())
+ Expect(serveErr(pl.CoverArtID())).To(MatchError(artwork.ErrUnavailable))
+
+ img, err := rsvc.GetOrPlaceholder(rctx, pl.CoverArtID().String(), 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ defer img.Close()
+ Expect(img.Placeholder).To(BeTrue())
})
})
When("a playlist has no images and no tracks", func() {
- // (reader falls all the way through to the bundled album placeholder)
- It("returns the album placeholder", func() {
+ // (no uploaded/sidecar/external image and no album art to sample)
+ It("settles absent", func() {
pl := putPlaylist(model.Playlist{ID: "pl-6", Name: "Empty"})
- Expect(readArtwork(pl.CoverArtID())).To(Equal(placeholderBytes()))
+ ia := acquire(model.KindPlaylistArtwork, pl.ID)
+ Expect(ia.Hash).To(BeEmpty())
+ Expect(serveErr(pl.CoverArtID())).To(MatchError(artwork.ErrUnavailable))
})
})
@@ -113,37 +126,79 @@ var _ = Describe("Playlist artwork resolution", func() {
// Artist/
// ├── AlbumA/
// │ ├── 01 - Track.mp3
- // │ └── cover.png (real PNG — wins as tile 1 source)
+ // │ └── cover.png ← tile 1 source
// └── AlbumB/
// ├── 01 - Track.mp3
- // └── cover.png (real PNG — wins as tile 2 source)
- // Playlist "pl-7" references tracks from both albums, so the reader
- // generates a 2x2 tiled cover from 2 distinct album art tiles (the
- // tiled generator mirrors when it has fewer than 4 unique tiles).
+ // └── cover.png ← tile 2 source
+ // Playlist "pl-7" references tracks from both albums, so the worker generates a tiled
+ // cover from 2 distinct album art tiles (mirrored to fill the 2x2 grid).
It("generates a tiled cover from album art", func() {
conf.Server.CoverArtPriority = "cover.*"
setLayout(fstest.MapFS{
"Artist/AlbumA/01 - Track.mp3": trackFile(1, "TA", map[string]any{"album": "AlbumA"}),
- "Artist/AlbumA/cover.png": realPNG("albumA"),
+ "Artist/AlbumA/cover.png": smallPNG("albumA"),
"Artist/AlbumB/01 - Track.mp3": trackFile(1, "TB", map[string]any{"album": "AlbumB"}),
- "Artist/AlbumB/cover.png": realPNG("albumB"),
+ "Artist/AlbumB/cover.png": smallPNG("albumB"),
})
scan()
- // Pull the scanned mediafile IDs so we can attach them to the playlist.
- mfs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{})
+ mfs, err := rds.MediaFile(rctx).GetAll(model.QueryOptions{})
Expect(err).ToNot(HaveOccurred())
Expect(mfs).To(HaveLen(2))
pl := model.Playlist{ID: "pl-7", Name: "Mix", OwnerID: "admin-1"}
pl.AddMediaFilesByID([]string{mfs[0].ID, mfs[1].ID})
- Expect(ds.Playlist(ctx).Put(&pl)).To(Succeed())
+ Expect(rds.Playlist(rctx).Put(&pl)).To(Succeed())
- data := readArtwork(pl.CoverArtID())
- // The tiled cover is a PNG-encoded 600x600 image (tileSize const).
- // Exact bytes vary (random album order), so assert format + non-trivial size.
+ ia := acquire(model.KindPlaylistArtwork, pl.ID)
+ Expect(ia.Source).To(Equal("generated"))
+ data := storedBytes(ia)
+ // The tiled cover is a PNG-encoded image; exact bytes vary (random album order).
Expect(data[:8]).To(Equal([]byte{0x89, 'P', 'N', 'G', 0x0d, 0x0a, 0x1a, 0x0a}))
- Expect(len(data)).To(BeNumerically(">", 1000))
+ // Two tiles are mirrored into the 2x2 grid as [A B B A], so opposite corners match.
+ q := gridQuadrants(data)
+ Expect(q[0]).To(Equal(q[3]))
+ Expect(q[1]).To(Equal(q[2]))
+ Expect(q[0]).ToNot(Equal(q[1]))
+ })
+ })
+
+ When("a playlist has tracks from four albums, each with its own cover", func() {
+ // Library:
+ // Artist/
+ // ├── AlbumA/{01 - Track.mp3, cover.png} ← tile 1
+ // ├── AlbumB/{01 - Track.mp3, cover.png} ← tile 2
+ // ├── AlbumC/{01 - Track.mp3, cover.png} ← tile 3
+ // └── AlbumD/{01 - Track.mp3, cover.png} ← tile 4
+ It("fills all four grid quadrants with distinct album art", func() {
+ conf.Server.CoverArtPriority = "cover.*"
+ layout := fstest.MapFS{}
+ for _, name := range []string{"AlbumA", "AlbumB", "AlbumC", "AlbumD"} {
+ layout["Artist/"+name+"/01 - Track.mp3"] = trackFile(1, "T"+name, map[string]any{"album": name})
+ layout["Artist/"+name+"/cover.png"] = smallPNG(name)
+ }
+ setLayout(layout)
+ scan()
+
+ mfs, err := rds.MediaFile(rctx).GetAll(model.QueryOptions{})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mfs).To(HaveLen(4))
+ ids := slice.Map(mfs, func(mf model.MediaFile) string { return mf.ID })
+
+ pl := model.Playlist{ID: "pl-8", Name: "Four", OwnerID: "admin-1"}
+ pl.AddMediaFilesByID(ids)
+ Expect(rds.Playlist(rctx).Put(&pl)).To(Succeed())
+
+ ia := acquire(model.KindPlaylistArtwork, pl.ID)
+ Expect(ia.Source).To(Equal("generated"))
+ q := gridQuadrants(storedBytes(ia))
+ Expect([]color.RGBA{q[0], q[1], q[2], q[3]}).To(HaveLen(4))
+ Expect(q[0]).ToNot(Equal(q[1]))
+ Expect(q[0]).ToNot(Equal(q[2]))
+ Expect(q[0]).ToNot(Equal(q[3]))
+ Expect(q[1]).ToNot(Equal(q[2]))
+ Expect(q[1]).ToNot(Equal(q[3]))
+ Expect(q[2]).ToNot(Equal(q[3]))
})
})
})
@@ -153,6 +208,6 @@ func putPlaylist(pl model.Playlist) model.Playlist {
if pl.OwnerID == "" {
pl.OwnerID = "admin-1"
}
- Expect(ds.Playlist(ctx).Put(&pl)).To(Succeed())
+ Expect(rds.Playlist(rctx).Put(&pl)).To(Succeed())
return pl
}
diff --git a/core/artwork/e2e/radio_test.go b/core/artwork/e2e/radio_test.go
index 73ee5f377..bba85224a 100644
--- a/core/artwork/e2e/radio_test.go
+++ b/core/artwork/e2e/radio_test.go
@@ -1,15 +1,18 @@
-package artworke2e_test
+package e2e
import (
"github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/model"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
+// Radio art is uploaded-image-only, with no fallback. Uploads are real files on disk, so they
+// serve back byte-for-byte; a radio with no upload settles absent.
var _ = Describe("Radio artwork resolution", func() {
BeforeEach(func() {
- setupHarness()
+ setupResolutionHarness()
})
When("a radio has an uploaded image", func() {
@@ -18,25 +21,25 @@ var _ = Describe("Radio artwork resolution", func() {
// └── radio/
// └── rd-1_logo.jpg ← matched by UploadedImagePath()
It("returns the uploaded image bytes", func() {
- writeUploadedImage(consts.EntityRadio, "rd-1_logo.jpg", imageBytes("radio-logo"))
-
+ writeUploadedImage(consts.EntityRadio, "rd-1_logo.jpg", pngBytes("radio-logo"))
rd := model.Radio{ID: "rd-1", Name: "Test Radio", StreamUrl: "https://example.com/stream", UploadedImage: "rd-1_logo.jpg"}
- Expect(ds.Radio(ctx).Put(&rd)).To(Succeed())
+ Expect(rds.Radio(rctx).Put(&rd)).To(Succeed())
- artID := model.NewArtworkID(model.KindRadioArtwork, rd.ID, nil)
- Expect(readArtwork(artID)).To(Equal(imageBytes("radio-logo")))
+ ia := acquire(model.KindRadioArtwork, rd.ID)
+ Expect(ia.Source).To(Equal("upload"))
+ Expect(serveBytes(model.NewArtworkID(model.KindRadioArtwork, rd.ID, nil))).To(Equal(pngBytes("radio-logo")))
})
})
When("a radio has no uploaded image", func() {
- // (no files on disk — reader has no sources to fall back to)
- It("returns ErrUnavailable", func() {
+ // (no files on disk — the resolver has no sources to fall back to)
+ It("settles absent", func() {
rd := model.Radio{ID: "rd-2", Name: "Bare Radio", StreamUrl: "https://example.com/stream"}
- Expect(ds.Radio(ctx).Put(&rd)).To(Succeed())
+ Expect(rds.Radio(rctx).Put(&rd)).To(Succeed())
- artID := model.NewArtworkID(model.KindRadioArtwork, rd.ID, nil)
- _, err := readArtworkOrErr(artID)
- Expect(err).To(HaveOccurred())
+ ia := acquire(model.KindRadioArtwork, rd.ID)
+ Expect(ia.Hash).To(BeEmpty())
+ Expect(serveErr(model.NewArtworkID(model.KindRadioArtwork, rd.ID, nil))).To(MatchError(artwork.ErrUnavailable))
})
})
})
diff --git a/core/artwork/e2e/resolution_harness_test.go b/core/artwork/e2e/resolution_harness_test.go
new file mode 100644
index 000000000..1168393df
--- /dev/null
+++ b/core/artwork/e2e/resolution_harness_test.go
@@ -0,0 +1,365 @@
+package e2e
+
+import (
+ "bytes"
+ "context"
+ "fmt"
+ "hash/fnv"
+ "image"
+ "image/color"
+ "image/png"
+ "io"
+ "maps"
+ "os"
+ "path/filepath"
+ "strings"
+ "sync"
+ "testing/fstest"
+ "time"
+
+ _ "github.com/navidrome/navidrome/adapters/gotaglib"
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/core/artwork"
+ "github.com/navidrome/navidrome/core/metrics"
+ "github.com/navidrome/navidrome/core/playlists"
+ "github.com/navidrome/navidrome/core/storage/storagetest"
+ "github.com/navidrome/navidrome/db"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/persistence"
+ "github.com/navidrome/navidrome/scanner"
+ "github.com/navidrome/navidrome/server/events"
+ "github.com/navidrome/navidrome/tests"
+ "github.com/navidrome/navidrome/tests/harness"
+ "github.com/navidrome/navidrome/utils/cache"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "go.senan.xyz/taglib"
+)
+
+const fakeLibScheme = "artworkfake"
+const fakeLibPath = fakeLibScheme + ":///music"
+
+const (
+ defaultCoverPriority = "cover.*, folder.*, front.*, embedded, external"
+ defaultDiscPriority = "disc*.*, cd*.*, cover.*, folder.*, front.*, discsubtitle, embedded"
+)
+
+var (
+ rctx context.Context
+ rds *tests.MockDataStore
+ rstore *artwork.ImageStore
+ rsvc artwork.Artwork
+ rworker *artwork.Worker
+ fakeFS *storagetest.FakeFS
+)
+
+// The go-sqlite3 singleton holds the file open for the whole suite, and Windows cannot unlink a
+// file with a live handle, so the DB cannot live in Ginkgo's per-spec TempDir.
+var suiteDBTempDir string
+
+// Migrating the schema costs ~400ms, so it runs once per suite and specs reset by truncating.
+var userTables []string
+
+var _ = BeforeSuite(func() {
+ suiteDBTempDir = GinkgoT().TempDir()
+
+ DeferCleanup(configtest.SetupConfig())
+ conf.Server.DbPath = filepath.Join(suiteDBTempDir, "artwork-resolution-e2e.db") + "?_journal_mode=WAL"
+ conf.Server.DataFolder = conf.NewDir(GinkgoT().TempDir())
+ db.Db().SetMaxOpenConns(1)
+ db.Init(request.WithUser(context.Background(), model.User{ID: "admin-1", IsAdmin: true}))
+
+ userTables = harness.ResettableTables()
+})
+
+var _ = AfterSuite(func() {
+ db.Close(context.Background())
+})
+
+func setupResolutionHarness() {
+ DeferCleanup(configtest.SetupConfig())
+
+ tempDir := GinkgoT().TempDir()
+ conf.Server.DbPath = filepath.Join(suiteDBTempDir, "artwork-resolution-e2e.db") + "?_journal_mode=WAL"
+ conf.Server.DataFolder = conf.NewDir(tempDir)
+ conf.Server.MusicFolder = fakeLibPath
+ conf.Server.DevExternalScanner = false
+ conf.Server.ImageCacheSize = "0"
+ conf.Server.EnableExternalServices = false
+ conf.Server.EnableMediaFileCoverArt = true
+ conf.Server.DevArtworkWorkerConcurrency = 1
+
+ rctx = request.WithUser(GinkgoT().Context(), model.User{ID: "admin-1", UserName: "admin", IsAdmin: true})
+ harness.TruncateDB(userTables)
+
+ rds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}
+
+ adminUser := model.User{ID: "admin-1", UserName: "admin", Name: "Admin", IsAdmin: true, NewPassword: "password"}
+ Expect(rds.User(rctx).Put(&adminUser)).To(Succeed())
+
+ lib := model.Library{ID: 1, Name: "Music", Path: fakeLibPath}
+ Expect(rds.Library(rctx).Put(&lib)).To(Succeed())
+ Expect(rds.User(rctx).SetUserLibraries(adminUser.ID, []int{lib.ID})).To(Succeed())
+
+ loadEmbeddedFixture()
+
+ fakeFS = &storagetest.FakeFS{}
+ storagetest.Register(fakeLibScheme, fakeFS)
+
+ ffm := tests.NewMockFFmpeg("")
+ rstore = artwork.NewImageStore(filepath.Join(tempDir, consts.HashedArtworkFolder))
+ // size=0 requests stream originals, so this reader is never called (serving_test covers resizing).
+ imgCache := cache.NewFileCache("ArtworkResolutionE2E", "100MB", "images", 0,
+ func(context.Context, cache.Item) (io.Reader, error) {
+ return nil, fmt.Errorf("resize not exercised in e2e")
+ })
+ Eventually(func() bool { return imgCache.Available(rctx) }).Should(BeTrue())
+
+ rsvc = artwork.NewArtwork(rds, imgCache, rstore, ffm)
+ rworker = artwork.NewWorker(rds, rstore, agents.GetAgents(rds, nil), ffm, events.NoopBroker(), imgCache)
+}
+
+// setLayout paths must be relative and forward-slash.
+func setLayout(files fstest.MapFS) {
+ GinkgoHelper()
+ fakeFS.SetFiles(files)
+}
+
+func scan() {
+ GinkgoHelper()
+ s := scanner.New(rctx, rds, events.NoopBroker(),
+ playlists.NewPlaylists(rds, artwork.NewUploader(rds)), metrics.NewNoopInstance())
+ _, err := s.ScanAll(rctx, true)
+ Expect(err).ToNot(HaveOccurred())
+}
+
+func acquire(kind model.Kind, id string) model.ItemArtwork {
+ GinkgoHelper()
+ // Enqueues the way the serving paths do, so the drain is driven by a plain queue row.
+ Expect(rds.ArtworkQueue(rctx).EnqueuePreservingBackoff(model.ArtworkQueueItem{
+ ItemKind: kind.Prefix(), ItemID: id, ImageType: model.ImageTypePrimary,
+ Priority: model.ArtworkPriorityBump,
+ })).To(Succeed())
+ var ia *model.ItemArtwork
+ runResolutionWorkerUntil(func() bool {
+ got, err := rds.Artwork(rctx).GetItemArtwork(kind, id, model.ImageTypePrimary)
+ if err != nil {
+ return false
+ }
+ ia = got
+ return true
+ })
+ return *ia
+}
+
+func runResolutionWorkerUntil(until func() bool) {
+ GinkgoHelper()
+ runCtx, cancel := context.WithCancel(rctx)
+ done := make(chan error, 1)
+ go func() { done <- rworker.Run(runCtx) }()
+ Eventually(until, 5*time.Second, 10*time.Millisecond).Should(BeTrue())
+ cancel()
+ Eventually(done, 2*time.Second).Should(Receive(BeNil()))
+}
+
+func serveBytes(artID model.ArtworkID) []byte {
+ GinkgoHelper()
+ img, err := rsvc.Get(rctx, artID, 0, false)
+ Expect(err).ToNot(HaveOccurred())
+ defer img.Close()
+ data, err := io.ReadAll(img)
+ Expect(err).ToNot(HaveOccurred())
+ return data
+}
+
+func serveErr(artID model.ArtworkID) error {
+ img, err := rsvc.Get(rctx, artID, 0, false)
+ if img != nil {
+ img.Close()
+ }
+ return err
+}
+
+func libFileBytes(suffix string) []byte {
+ GinkgoHelper()
+ var match string
+ for name := range fakeFS.MapFS {
+ if strings.HasSuffix(name, suffix) {
+ Expect(match).To(BeEmpty(), "suffix %q is ambiguous: %q and %q", suffix, match, name)
+ match = name
+ }
+ }
+ Expect(match).ToNot(BeEmpty(), "no library file ends with %q", suffix)
+ return fakeFS.MapFS[match].Data
+}
+
+// Serving before acquiring is deliberate: with no state row the request resolves through the
+// library FS, while a settled folder row is read with os.Open, which the in-memory FS cannot serve.
+func expectAlbumFolderCover(al model.Album, suffix string) {
+ GinkgoHelper()
+ requireNoStateRow(model.KindAlbumArtwork, al.ID)
+ Expect(serveBytes(al.CoverArtID())).To(Equal(libFileBytes(suffix)))
+ ia := acquire(model.KindAlbumArtwork, al.ID)
+ Expect(ia.Source).To(Equal("folder"))
+ Expect(filepath.ToSlash(ia.SourcePath)).To(HaveSuffix(suffix))
+}
+
+// A drain settles every ready item, so byte-level folder assertions must precede any acquire.
+func requireNoStateRow(kind model.Kind, id string) {
+ GinkgoHelper()
+ _, err := rds.Artwork(rctx).GetItemArtwork(kind, id, model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound),
+ "assert %s %q before acquiring any other entity in this spec", kind, id)
+}
+
+func expectAlbumAbsent(al model.Album) {
+ GinkgoHelper()
+ ia := acquire(model.KindAlbumArtwork, al.ID)
+ Expect(ia.Hash).To(BeEmpty())
+ Expect(serveErr(al.CoverArtID())).To(MatchError(artwork.ErrUnavailable))
+}
+
+func expectArtistFolder(ar model.Artist, suffix string) {
+ GinkgoHelper()
+ requireNoStateRow(model.KindArtistArtwork, ar.ID)
+ Expect(serveBytes(model.NewArtworkID(model.KindArtistArtwork, ar.ID, nil))).To(Equal(libFileBytes(suffix)))
+ ia := acquire(model.KindArtistArtwork, ar.ID)
+ Expect(ia.Source).To(Equal("folder"))
+ Expect(filepath.ToSlash(ia.SourcePath)).To(HaveSuffix(suffix))
+}
+
+func writeUploadedImage(entity, filename string, data []byte) {
+ GinkgoHelper()
+ dst := model.UploadedImagePath(entity, filename)
+ Expect(os.MkdirAll(filepath.Dir(dst), 0o755)).To(Succeed())
+ Expect(os.WriteFile(dst, data, 0o600)).To(Succeed())
+}
+
+func discArtID(al model.Album, disc int) model.ArtworkID {
+ return model.NewArtworkID(model.KindDiscArtwork, model.DiscArtworkID(al.ID, disc), &al.UpdatedAt)
+}
+
+// Disc art is a pure serve-time read through the library FS: no worker, no state row.
+func expectDiscImage(al model.Album, disc int, label string) {
+ GinkgoHelper()
+ Expect(serveBytes(discArtID(al, disc))).To(Equal(pngBytes(label)))
+}
+
+// Samples in rect() order: top-left, top-right, bottom-left, bottom-right.
+func gridQuadrants(data []byte) [4]color.RGBA {
+ GinkgoHelper()
+ img, _, err := image.Decode(bytes.NewReader(data))
+ Expect(err).ToNot(HaveOccurred())
+ b := img.Bounds()
+ qw, qh := b.Dx()/4, b.Dy()/4
+ at := func(x, y int) color.RGBA {
+ c := color.RGBAModel.Convert(img.At(b.Min.X+x, b.Min.Y+y))
+ return c.(color.RGBA)
+ }
+ return [4]color.RGBA{at(qw, qh), at(3*qw, qh), at(qw, 3*qh), at(3*qw, 3*qh)}
+}
+
+// Store-backed sources only (embedded/generated); file-backed ones assert on ia.SourcePath.
+func storedBytes(ia model.ItemArtwork) []byte {
+ GinkgoHelper()
+ art, err := rds.Artwork(rctx).GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ r, err := rstore.Open(ia.Hash, art.Mime)
+ Expect(err).ToNot(HaveOccurred())
+ defer r.Close()
+ data, err := io.ReadAll(r)
+ Expect(err).ToNot(HaveOccurred())
+ return data
+}
+
+// The pixel color derives from label, so each label yields distinct, still-decodable bytes.
+func smallPNG(label string) *fstest.MapFile {
+ h := fnv.New32a()
+ _, _ = h.Write([]byte(label))
+ sum := h.Sum32()
+ c := color.RGBA{R: byte(sum), G: byte(sum >> 8), B: byte(sum >> 16), A: 255}
+ img := image.NewRGBA(image.Rect(0, 0, 2, 2))
+ for y := range 2 {
+ for x := range 2 {
+ img.Set(x, y, c)
+ }
+ }
+ var buf bytes.Buffer
+ Expect(png.Encode(&buf, img)).To(Succeed())
+ return &fstest.MapFile{Data: buf.Bytes()}
+}
+
+func pngBytes(label string) []byte {
+ GinkgoHelper()
+ return smallPNG(label).Data
+}
+
+func trackFile(num int, title string, extra ...map[string]any) *fstest.MapFile {
+ tags := storagetest.Track(num, title)
+ for _, e := range extra {
+ maps.Copy(tags, e)
+ }
+ return storagetest.MP3(tags)
+}
+
+// FakeFS's JSON-encoded tags aren't taglib-readable, so embedded-art specs swap in these real MP3
+// bytes after scanning. Loaded lazily: tests.Init must chdir to the project root first.
+var (
+ embeddedFixtureOnce sync.Once
+ embeddedArtFixture []byte
+ embeddedArtBytes []byte
+)
+
+func loadEmbeddedFixture() {
+ embeddedFixtureOnce.Do(func() {
+ embeddedArtFixture = readFixture(mp3Fixture)
+ embeddedArtBytes = extractEmbeddedArt(embeddedArtFixture)
+ })
+}
+
+func extractEmbeddedArt(mp3 []byte) []byte {
+ tf, err := taglib.OpenStream(bytes.NewReader(mp3))
+ if err != nil {
+ panic("embedded-art fixture: taglib.OpenStream failed: " + err.Error())
+ }
+ defer tf.Close()
+ images := tf.Properties().Images
+ if len(images) == 0 {
+ panic("embedded-art fixture has no embedded images")
+ }
+ data, err := tf.Image(0)
+ if err != nil || len(data) == 0 {
+ panic("embedded-art fixture: could not read image 0")
+ }
+ return data
+}
+
+func replaceWithRealMP3(relPath string) {
+ GinkgoHelper()
+ fakeFS.MapFS[relPath] = &fstest.MapFile{Data: embeddedArtFixture}
+}
+
+func firstAlbum() model.Album {
+ GinkgoHelper()
+ albums, err := rds.Album(rctx).GetAll(model.QueryOptions{})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(albums).To(HaveLen(1), "expected exactly one album, got %d", len(albums))
+ return albums[0]
+}
+
+func albumByName(name string) model.Album {
+ GinkgoHelper()
+ albums, err := rds.Album(rctx).GetAll(model.QueryOptions{})
+ Expect(err).ToNot(HaveOccurred())
+ for _, al := range albums {
+ if al.Name == name {
+ return al
+ }
+ }
+ Fail(fmt.Sprintf("album %q not found among %d albums", name, len(albums)))
+ return model.Album{}
+}
diff --git a/core/artwork/e2e/suite_test.go b/core/artwork/e2e/suite_test.go
deleted file mode 100644
index 06cc05b6f..000000000
--- a/core/artwork/e2e/suite_test.go
+++ /dev/null
@@ -1,120 +0,0 @@
-package artworke2e_test
-
-import (
- "context"
- "fmt"
- "path/filepath"
- "testing"
-
- _ "github.com/navidrome/navidrome/adapters/gotaglib"
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/core"
- "github.com/navidrome/navidrome/core/artwork"
- "github.com/navidrome/navidrome/core/metrics"
- "github.com/navidrome/navidrome/core/playlists"
- "github.com/navidrome/navidrome/core/storage/storagetest"
- "github.com/navidrome/navidrome/db"
- "github.com/navidrome/navidrome/log"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/model/request"
- "github.com/navidrome/navidrome/persistence"
- "github.com/navidrome/navidrome/scanner"
- "github.com/navidrome/navidrome/server/events"
- "github.com/navidrome/navidrome/tests"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-func TestArtworkE2E(t *testing.T) {
- tests.Init(t, false)
- log.SetLevel(log.LevelFatal)
- RegisterFailHandler(Fail)
- RunSpecs(t, "Artwork E2E Suite")
-}
-
-const fakeLibScheme = "artworkfake"
-const fakeLibPath = fakeLibScheme + ":///music"
-
-var (
- ctx context.Context
- ds *tests.MockDataStore
- aw artwork.Artwork
- fakeFS *storagetest.FakeFS
-)
-
-// The DB file lives in a suite-level tempdir: the go-sqlite3 singleton keeps
-// the file open for the whole suite, and Ginkgo's per-spec TempDir cleanup
-// can't unlink a file with a live handle on Windows. A suite-level tempdir
-// combined with an AfterSuite close avoids the lock conflict.
-var suiteDBTempDir string
-
-var _ = BeforeSuite(func() {
- suiteDBTempDir = GinkgoT().TempDir()
-})
-
-var _ = AfterSuite(func() {
- db.Close(GinkgoT().Context())
-})
-
-func setupHarness() {
- DeferCleanup(configtest.SetupConfig())
-
- tempDir := GinkgoT().TempDir()
- // Reuse the suite-level DB path so the singleton connection keeps working
- // across specs (see suiteDBTempDir comment).
- conf.Server.DbPath = filepath.Join(suiteDBTempDir, "artwork-e2e.db") + "?_journal_mode=WAL"
- conf.Server.DataFolder = conf.NewDir(tempDir)
- conf.Server.MusicFolder = fakeLibPath
- conf.Server.DevExternalScanner = false
- conf.Server.ImageCacheSize = "0" // disabled cache → reader runs on every call
- conf.Server.EnableExternalServices = false
-
- db.Db().SetMaxOpenConns(1)
- ctx = request.WithUser(GinkgoT().Context(), model.User{ID: "admin-1", UserName: "admin", IsAdmin: true})
- db.Init(ctx)
- DeferCleanup(func() { Expect(tests.ClearDB()).To(Succeed()) })
-
- ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}
-
- adminUser := model.User{ID: "admin-1", UserName: "admin", Name: "Admin", IsAdmin: true, NewPassword: "password"}
- Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())
-
- lib := model.Library{ID: 1, Name: "Music", Path: fakeLibPath}
- Expect(ds.Library(ctx).Put(&lib)).To(Succeed())
- Expect(ds.User(ctx).SetUserLibraries(adminUser.ID, []int{lib.ID})).To(Succeed())
-
- fakeFS = &storagetest.FakeFS{}
- storagetest.Register(fakeLibScheme, fakeFS)
-
- aw = artwork.NewArtwork(ds, artwork.GetImageCache(), newNoopFFmpeg(), &noopProvider{})
-}
-
-func scan() {
- GinkgoHelper()
- s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
- _, err := s.ScanAll(ctx, true)
- Expect(err).ToNot(HaveOccurred())
-}
-
-func firstAlbum() model.Album {
- GinkgoHelper()
- albums, err := ds.Album(ctx).GetAll(model.QueryOptions{})
- Expect(err).ToNot(HaveOccurred())
- Expect(albums).To(HaveLen(1), "expected exactly one album, got %d", len(albums))
- return albums[0]
-}
-
-func albumByName(name string) model.Album {
- GinkgoHelper()
- albums, err := ds.Album(ctx).GetAll(model.QueryOptions{})
- Expect(err).ToNot(HaveOccurred())
- for _, al := range albums {
- if al.Name == name {
- return al
- }
- }
- Fail(fmt.Sprintf("album %q not found among %d albums", name, len(albums)))
- return model.Album{}
-}
diff --git a/core/artwork/e2e/testdata/embedded_art.mp3 b/core/artwork/e2e/testdata/embedded_art.mp3
deleted file mode 100644
index 18cb90674..000000000
Binary files a/core/artwork/e2e/testdata/embedded_art.mp3 and /dev/null differ
diff --git a/core/artwork/reader_album.go b/core/artwork/folders_album.go
similarity index 63%
rename from core/artwork/reader_album.go
rename to core/artwork/folders_album.go
index 58a47c8ae..88f0181a3 100644
--- a/core/artwork/reader_album.go
+++ b/core/artwork/folders_album.go
@@ -3,107 +3,19 @@ package artwork
import (
"cmp"
"context"
- "crypto/md5"
"errors"
- "fmt"
- "io"
"path"
"slices"
"strings"
"time"
"github.com/Masterminds/squirrel"
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/core/external"
- "github.com/navidrome/navidrome/core/ffmpeg"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/utils"
"github.com/navidrome/navidrome/utils/natural"
"github.com/navidrome/navidrome/utils/slice"
)
-type albumArtworkReader struct {
- cacheKey
- a *artwork
- provider external.Provider
- album model.Album
- updatedAt *time.Time
- imgFiles []string // library-relative, forward-slash, no leading slash
- lib libraryView
-}
-
-func newAlbumArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, provider external.Provider) (*albumArtworkReader, error) {
- al, err := artwork.ds.Album(ctx).Get(artID.ID)
- if err != nil {
- return nil, err
- }
- _, imgFiles, imagesUpdateAt, err := loadAlbumFoldersPaths(ctx, artwork.ds, *al)
- if err != nil {
- return nil, err
- }
- lib, err := loadLibraryView(ctx, artwork.ds, al.LibraryID)
- if err != nil {
- return nil, err
- }
- a := &albumArtworkReader{
- a: artwork,
- provider: provider,
- album: *al,
- updatedAt: imagesUpdateAt,
- imgFiles: imgFiles,
- lib: lib,
- }
- a.cacheKey.artID = artID
- a.cacheKey.lastUpdate = utils.TimeNewest(al.UpdatedAt, al.ImportedAt)
- if imagesUpdateAt != nil {
- a.cacheKey.lastUpdate = utils.TimeNewest(a.cacheKey.lastUpdate, *imagesUpdateAt)
- }
- return a, nil
-}
-
-func (a *albumArtworkReader) Key() string {
- hashInput := conf.Server.CoverArtPriority
- if conf.Server.EnableExternalServices {
- hashInput = conf.Server.Agents + hashInput
- }
- hash := md5.Sum([]byte(hashInput))
- return fmt.Sprintf(
- "%s.%x.%t",
- a.cacheKey.Key(),
- hash,
- conf.Server.EnableExternalServices,
- )
-}
-func (a *albumArtworkReader) LastUpdated() time.Time {
- return a.lastUpdate
-}
-
-func (a *albumArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
- var ff = a.fromCoverArtPriority(ctx, a.a.ffmpeg, conf.Server.CoverArtPriority)
- return selectImageReader(ctx, a.artID, ff...)
-}
-
-func (a *albumArtworkReader) fromCoverArtPriority(ctx context.Context, ffmpeg ffmpeg.FFmpeg, priority string) []sourceFunc {
- var ff []sourceFunc
- for pattern := range strings.SplitSeq(strings.ToLower(priority), ",") {
- pattern = strings.TrimSpace(pattern)
- switch {
- case pattern == "embedded":
- embedRel := a.album.EmbedArtPath
- ff = append(ff,
- fromTag(ctx, a.lib.FS, embedRel),
- fromFFmpegTag(ctx, ffmpeg, a.lib.Abs(embedRel)),
- )
- case pattern == "external":
- ff = append(ff, fromAlbumExternalSource(ctx, a.album, a.provider))
- case len(a.imgFiles) > 0:
- ff = append(ff, fromExternalFile(ctx, a.lib.FS, a.imgFiles, pattern))
- }
- }
- return ff
-}
-
func loadAlbumFoldersPaths(ctx context.Context, ds model.DataStore, album model.Album) ([]string, []string, *time.Time, error) {
folders, err := loadFolders(ctx, ds, album.FolderIDs)
if err != nil {
@@ -169,7 +81,7 @@ func albumRootParent(ctx context.Context, ds model.DataStore, folders []model.Fo
}
parent, err := ds.Folder(ctx).Get(commonParentID)
if errors.Is(err, model.ErrNotFound) {
- log.Warn(ctx, "Parent folder not found for album cover art lookup", "parentID", commonParentID)
+ log.Warn(ctx, "Artwork: Parent folder not found for album cover art lookup", "parentID", commonParentID)
return nil, nil
}
if err != nil {
diff --git a/core/artwork/folders_album_test.go b/core/artwork/folders_album_test.go
new file mode 100644
index 000000000..a263dbaaf
--- /dev/null
+++ b/core/artwork/folders_album_test.go
@@ -0,0 +1,214 @@
+package artwork
+
+import (
+ "context"
+ "errors"
+ "time"
+
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// The e2e specs cover which image wins for a layout; these pin what a layout cannot reach: that
+// the album-root parent is only fetched when it could qualify, and what happens when that fails.
+var _ = Describe("loadAlbumFoldersPaths", func() {
+ var (
+ ctx context.Context
+ ds *tests.MockDataStore
+ repo *fakeFolderRepo
+ album model.Album
+ now time.Time
+ )
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ now = time.Now().Truncate(time.Second)
+ repo = &fakeFolderRepo{}
+ ds = &tests.MockDataStore{MockedFolder: repo}
+ album = model.Album{
+ ID: "album1",
+ Name: "Album",
+ FolderIDs: []string{"folder1", "folder2", "folder3"},
+ }
+ })
+
+ It("does not query the parent when it is already one of the album's folders", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: "Artist", Name: "Album", ParentID: "folder2",
+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},
+ {ID: "folder2", Path: "", Name: "Artist", ImagesUpdatedAt: now},
+ }
+
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(ConsistOf("Artist/Album/cover.jpg"))
+ Expect(repo.getCallCount).To(BeZero())
+ })
+
+ It("does not query the parent when the album's folders have different parents", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: "Artist1/Album", Name: "part1", ParentID: "parentA",
+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},
+ {ID: "folder2", Path: "Artist2/Album", Name: "part2", ParentID: "parentB",
+ ImagesUpdatedAt: now},
+ }
+
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(ConsistOf("Artist1/Album/part1/cover.jpg"))
+ Expect(repo.getCallCount).To(BeZero())
+ })
+
+ It("does not query the parent for a single-folder album that has images of its own", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: "Artist", Name: "Album", ParentID: "artistFolder",
+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},
+ }
+
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(ConsistOf("Artist/Album/cover.jpg"))
+ Expect(repo.getCallCount).To(BeZero())
+ })
+
+ It("does not promote the library root, so its images never become album art", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: ".", Name: "AlbumPart1", ParentID: "rootFolder",
+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},
+ {ID: "folder2", Path: ".", Name: "AlbumPart2", ParentID: "rootFolder",
+ ImagesUpdatedAt: now},
+ }
+ repo.parentResult = &model.Folder{ID: "rootFolder", Name: ".", ImageFiles: []string{"unrelated.jpg"}}
+
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(ConsistOf("AlbumPart1/cover.jpg"))
+ Expect(repo.getCallCount).To(Equal(1))
+ })
+
+ It("does not promote a parent that holds another album's audio", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: "Artist/Album", Name: "CD1", ParentID: "albumFolder",
+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},
+ {ID: "folder2", Path: "Artist/Album", Name: "CD2", ParentID: "albumFolder",
+ ImagesUpdatedAt: now},
+ }
+ repo.parentResult = &model.Folder{ID: "albumFolder", Path: "Artist", Name: "Album",
+ ParentID: "artistFolder", ImageFiles: []string{"artist.jpg"}}
+ repo.hasOtherAudio = true
+
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(ConsistOf("Artist/Album/CD1/cover.jpg"))
+ })
+
+ It("promotes the album root parent into the returned paths", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: "Artist/Album", Name: "CD1", ParentID: "albumFolder",
+ ImagesUpdatedAt: now},
+ {ID: "folder2", Path: "Artist/Album", Name: "CD2", ParentID: "albumFolder",
+ ImagesUpdatedAt: now},
+ }
+ repo.parentResult = &model.Folder{ID: "albumFolder", Path: "Artist", Name: "Album",
+ ParentID: "artistFolder", ImageFiles: []string{"cover.jpg"}}
+
+ paths, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(ConsistOf("Artist/Album/cover.jpg"))
+ Expect(paths).To(HaveLen(3))
+ })
+
+ It("propagates errors from the album-root check", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: "Artist/Album", Name: "disc1", ParentID: "albumFolder",
+ ImagesUpdatedAt: now},
+ }
+ repo.parentResult = &model.Folder{ID: "albumFolder", Path: "Artist", Name: "Album",
+ ParentID: "artistFolder", ImageFiles: []string{"cover.jpg"}}
+ repo.otherAudioErr = errors.New("db connection failed")
+
+ _, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).To(MatchError("db connection failed"))
+ })
+
+ It("propagates non-ErrNotFound errors from the parent folder lookup", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: "Artist/Album", Name: "CD1", ParentID: "parentFolder",
+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},
+ {ID: "folder2", Path: "Artist/Album", Name: "CD2", ParentID: "parentFolder",
+ ImagesUpdatedAt: now},
+ }
+ repo.getErr = errors.New("db connection failed")
+
+ _, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).To(MatchError("db connection failed"))
+ Expect(repo.getCallCount).To(Equal(1))
+ })
+
+ It("continues when the parent folder has been deleted", func() {
+ repo.result = []model.Folder{
+ {ID: "folder1", Path: "Artist/Album", Name: "CD1", ParentID: "missingParent",
+ ImagesUpdatedAt: now, ImageFiles: []string{"cover.jpg"}},
+ {ID: "folder2", Path: "Artist/Album", Name: "CD2", ParentID: "missingParent",
+ ImagesUpdatedAt: now},
+ }
+
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(imgFiles).To(ConsistOf("Artist/Album/CD1/cover.jpg"))
+ Expect(repo.getCallCount).To(Equal(1))
+ })
+})
+
+// folderImages is the sort that decides which of several same-named images wins, so it is pinned
+// directly rather than through a layout that can only show the winner.
+var _ = Describe("folderImages", func() {
+ It("prefers base filenames over numeric-suffixed ones", func() {
+ imgFiles, _ := folderImages([]model.Folder{
+ {Path: "Artist", Name: "Album", ImageFiles: []string{"cover.1.jpg", "cover.jpg", "cover.2.jpg"}},
+ })
+
+ Expect(imgFiles).To(HaveExactElements(
+ "Artist/Album/cover.jpg", "Artist/Album/cover.1.jpg", "Artist/Album/cover.2.jpg"))
+ })
+
+ It("prefers shallower paths when the base filenames tie", func() {
+ imgFiles, _ := folderImages([]model.Folder{
+ {Path: "Artist/Album", Name: "CD1", ImageFiles: []string{"cover.jpg"}},
+ {Path: "Artist", Name: "Album", ImageFiles: []string{"cover.jpg"}},
+ })
+
+ Expect(imgFiles).To(HaveExactElements("Artist/Album/cover.jpg", "Artist/Album/CD1/cover.jpg"))
+ })
+
+ It("sorts case-insensitively", func() {
+ imgFiles, _ := folderImages([]model.Folder{
+ {Path: "Artist", Name: "Album", ImageFiles: []string{"Cover.jpg", "back.JPG"}},
+ })
+
+ Expect(imgFiles).To(HaveExactElements("Artist/Album/back.JPG", "Artist/Album/Cover.jpg"))
+ })
+
+ It("reports the newest ImagesUpdatedAt across the folders", func() {
+ now := time.Now().Truncate(time.Second)
+ newest := now.Add(5 * time.Minute)
+
+ _, updatedAt := folderImages([]model.Folder{
+ {Path: "Artist", Name: "Album", ImagesUpdatedAt: now},
+ {Path: "Artist/Album", Name: "CD1", ImagesUpdatedAt: newest},
+ })
+
+ Expect(updatedAt).To(Equal(newest))
+ })
+})
diff --git a/core/artwork/folders_artist.go b/core/artwork/folders_artist.go
new file mode 100644
index 000000000..1ca1ce034
--- /dev/null
+++ b/core/artwork/folders_artist.go
@@ -0,0 +1,210 @@
+package artwork
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "io/fs"
+ "os"
+ "path"
+ "path/filepath"
+ "slices"
+ "strings"
+ "time"
+
+ "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils"
+ "github.com/navidrome/navidrome/utils/slice"
+ "github.com/navidrome/navidrome/utils/str"
+)
+
+const (
+ maxArtistFolderTraversalDepth = 3
+)
+
+func fromArtistFolder(ctx context.Context, libFS fs.FS, libPath, artistFolder, pattern string) sourceFunc {
+ return func() (io.ReadCloser, string, error) {
+ if libFS == nil {
+ return nil, "", fmt.Errorf("artist folder lookup unavailable")
+ }
+ rel, err := filepath.Rel(libPath, artistFolder)
+ if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+ return nil, "", fmt.Errorf(`artist folder '%s' is outside library '%s'`, artistFolder, libPath)
+ }
+ // fs.Glob needs forward slashes; filepath.Rel returns backslashes on Windows.
+ rel = filepath.ToSlash(rel)
+ current := artistFolder
+ var unreadable error
+ for range maxArtistFolderTraversalDepth {
+ reader, hit, err := findImageInFolder(ctx, libFS, rel, current, pattern)
+ if err == nil {
+ return reader, hit, nil
+ }
+ if errors.Is(err, errSourceUnreadable) {
+ unreadable = err
+ }
+ if rel == "." {
+ break // reached library root
+ }
+ rel = path.Dir(rel)
+ current = filepath.Dir(current)
+ }
+ if unreadable != nil {
+ return nil, "", unreadable
+ }
+ return nil, "", fmt.Errorf(`no matches for '%s' in '%s' or its parent directories (within library)`, pattern, artistFolder)
+ }
+}
+
+// findImageInFolder returns the first image matching pattern; absFolder is only used for
+// the returned display path and log messages.
+func findImageInFolder(ctx context.Context, libFS fs.FS, relFolder, absFolder, pattern string) (io.ReadCloser, string, error) {
+ log.Trace(ctx, "Artwork: Looking for artist image", "pattern", pattern, "folder", absFolder)
+ globPattern := pattern
+ if relFolder != "." {
+ globPattern = path.Join(escapeGlobLiteral(relFolder), pattern)
+ }
+ matches, err := fs.Glob(libFS, globPattern)
+ if err != nil {
+ log.Warn(ctx, "Artwork: Error matching artist image pattern", "pattern", pattern, "folder", absFolder, err)
+ return nil, "", err
+ }
+
+ imagePaths := slice.Filter(matches, model.IsImageFile)
+
+ // Prefer base filenames over numeric-suffixed ones (artist.jpg before artist.1.jpg)
+ slices.SortFunc(imagePaths, compareImageFiles)
+
+ var openErr error
+ for _, p := range imagePaths {
+ f, err := libFS.Open(p)
+ if err != nil {
+ log.Warn(ctx, "Artwork: Could not open cover art file", "file", p, err)
+ openErr = fmt.Errorf("%w: %s: %w", errSourceUnreadable, p, err)
+ continue
+ }
+ _, name := path.Split(p)
+ return f, filepath.Join(absFolder, name), nil
+ }
+ if openErr != nil {
+ return nil, "", openErr
+ }
+
+ return nil, "", fmt.Errorf(`no matches for '%s' in '%s'`, pattern, absFolder)
+}
+
+func escapeGlobLiteral(s string) string {
+ var b strings.Builder
+ b.Grow(len(s))
+ for _, r := range s {
+ switch r {
+ case '\\', '*', '?', '[', ']':
+ b.WriteByte('\\')
+ }
+ b.WriteRune(r)
+ }
+ return b.String()
+}
+
+// loadArtistAlbumRoots returns one path per album — the deepest folder holding
+// all of that album's tracks — so an album split into disc subfolders can't
+// pull the artist folder's common prefix below the artist level.
+func loadArtistAlbumRoots(ctx context.Context, ds model.DataStore, albums model.Albums) ([]string, []string, *time.Time, error) {
+ var folderIDs []string
+ for _, album := range albums {
+ folderIDs = append(folderIDs, album.FolderIDs...)
+ }
+ folders, err := loadFolders(ctx, ds, folderIDs)
+ if err != nil {
+ return nil, nil, nil, err
+ }
+
+ pathByID := slice.ToMap(folders, func(f model.Folder) (string, string) {
+ return f.ID, f.AbsolutePath()
+ })
+ var roots []string
+ for _, album := range albums {
+ var albumPaths []string
+ for _, fid := range album.FolderIDs {
+ if p, ok := pathByID[fid]; ok {
+ albumPaths = append(albumPaths, p)
+ }
+ }
+ if len(albumPaths) > 0 {
+ roots = append(roots, commonDir(albumPaths))
+ }
+ }
+
+ imgFiles, updatedAt := folderImages(folders)
+ return roots, imgFiles, &updatedAt, nil
+}
+
+// commonDir returns the deepest directory containing all paths. Trailing
+// separators keep the comparison on segment boundaries, so a shared name
+// fragment (".../Album" and ".../Album2") is never read as a shared directory.
+func commonDir(paths []string) string {
+ sep := string(filepath.Separator)
+ common := str.LongestCommonPrefix(slice.Map(paths, func(p string) string { return p + sep }))
+ if !strings.HasSuffix(common, sep) {
+ common, _ = filepath.Split(common)
+ }
+ return filepath.Clean(common)
+}
+
+func loadArtistFolder(ctx context.Context, ds model.DataStore, albums model.Albums, paths []string) (string, time.Time, error) {
+ if len(albums) == 0 {
+ return "", time.Time{}, nil
+ }
+ libID := albums[0].LibraryID // TODO: Support albums spanning multiple libraries
+
+ // paths holds one root per album: two or more distinct roots already meet at
+ // the artist folder, while a single root is an album folder needing a climb.
+ roots := slices.Compact(slices.Sorted(slices.Values(paths)))
+ folderPath := commonDir(roots)
+ if len(roots) < 2 {
+ folderPath = filepath.Dir(folderPath)
+ }
+
+ // TODO: Hacky, but the easiest way to get the folder ID ATM
+ libPath := core.AbsolutePath(ctx, ds, libID, "")
+ folderID := model.FolderID(model.Library{ID: libID, Path: libPath}, folderPath)
+
+ log.Trace(ctx, "Artwork: Calculating artist folder details", "folderPath", folderPath, "folderID", folderID,
+ "libPath", libPath, "libID", libID, "albumPaths", paths)
+
+ folders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"folder.id": folderID, "missing": false}})
+ if err != nil || len(folders) == 0 {
+ log.Warn(ctx, "Artwork: Could not find folder for artist", "folderPath", folderPath, "id", folderID,
+ "libPath", libPath, "libID", libID, err)
+ return "", time.Time{}, err
+ }
+ return folderPath, folders[0].ImagesUpdatedAt, nil
+}
+
+// findImageInArtistFolder matches an image by MBID or artist name (case-insensitive), "" if none.
+func findImageInArtistFolder(folder, mbzArtistID, artistName string) string {
+ entries, err := os.ReadDir(folder)
+ if err != nil {
+ return ""
+ }
+ for _, candidate := range []string{mbzArtistID, artistName} {
+ if candidate == "" {
+ continue
+ }
+ for _, entry := range entries {
+ if entry.IsDir() {
+ continue
+ }
+ name := entry.Name()
+ base := utils.BaseName(name)
+ if strings.EqualFold(base, candidate) && model.IsImageFile(name) {
+ return filepath.Join(folder, name)
+ }
+ }
+ }
+ return ""
+}
diff --git a/core/artwork/folders_artist_paths_test.go b/core/artwork/folders_artist_paths_test.go
new file mode 100644
index 000000000..cc8af3e63
--- /dev/null
+++ b/core/artwork/folders_artist_paths_test.go
@@ -0,0 +1,117 @@
+package artwork
+
+import (
+ "context"
+ "errors"
+ "path/filepath"
+ "time"
+
+ "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// commonDir and loadArtistFolder decide how far above the albums the artist folder sits. A layout
+// can only show the image that won, so the arithmetic is pinned here.
+var _ = Describe("commonDir", func() {
+ It("returns the folder itself for a single path", func() {
+ Expect(commonDir([]string{filepath.FromSlash("/music/artist/album")})).
+ To(Equal(filepath.FromSlash("/music/artist/album")))
+ })
+
+ It("returns the deepest shared folder", func() {
+ Expect(commonDir([]string{
+ filepath.FromSlash("/music/artist/album/cd1"),
+ filepath.FromSlash("/music/artist/album/cd2"),
+ })).To(Equal(filepath.FromSlash("/music/artist/album")))
+ })
+
+ It("does not read a shared name fragment as a shared folder", func() {
+ Expect(commonDir([]string{
+ filepath.FromSlash("/music/artist/Album"),
+ filepath.FromSlash("/music/artist/Album2"),
+ })).To(Equal(filepath.FromSlash("/music/artist")))
+ })
+})
+
+var _ = Describe("loadArtistFolder", func() {
+ var (
+ ctx context.Context
+ ds *tests.MockDataStore
+ repo *fakeFolderRepo
+ albums model.Albums
+ updatedAt time.Time
+ )
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ DeferCleanup(stubCoreAbsolutePath())
+
+ updatedAt = time.Now().Truncate(time.Second).Add(5 * time.Minute)
+ repo = &fakeFolderRepo{result: []model.Folder{{ImagesUpdatedAt: updatedAt}}}
+ ds = &tests.MockDataStore{MockedFolder: repo}
+ albums = model.Albums{{LibraryID: 1, ID: "album1", Name: "Album 1"}}
+ })
+
+ It("returns empty when the artist has no albums", func() {
+ folder, upd, err := loadArtistFolder(ctx, ds, model.Albums{}, []string{"/dummy/path"})
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(folder).To(BeEmpty())
+ Expect(upd).To(BeZero())
+ })
+
+ It("climbs above the album folder when the artist has a single album root", func() {
+ folder, upd, err := loadArtistFolder(ctx, ds, albums,
+ []string{filepath.FromSlash("/music/artist/album1")})
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))
+ Expect(upd).To(Equal(updatedAt))
+ })
+
+ It("climbs above the shared folder when two albums live in the same one", func() {
+ folder, upd, err := loadArtistFolder(ctx, ds, albums, []string{
+ filepath.FromSlash("/music/artist/split"),
+ filepath.FromSlash("/music/artist/split"),
+ })
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))
+ Expect(upd).To(Equal(updatedAt))
+ })
+
+ It("stops at the folder where distinct album roots already meet", func() {
+ folder, upd, err := loadArtistFolder(ctx, ds, albums, []string{
+ filepath.FromSlash("/music/artist/album1"),
+ filepath.FromSlash("/music/artist/album2"),
+ })
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))
+ Expect(upd).To(Equal(updatedAt))
+ })
+
+ It("returns the error when the folder lookup fails", func() {
+ repo.err = errors.New("fake error")
+
+ folder, upd, err := loadArtistFolder(ctx, ds, albums, []string{
+ filepath.FromSlash("/music/artist/album1"),
+ filepath.FromSlash("/music/artist/album2"),
+ })
+
+ Expect(err).To(MatchError(ContainSubstring("fake error")))
+ Expect(folder).To(BeEmpty())
+ Expect(upd).To(BeZero())
+ })
+})
+
+func stubCoreAbsolutePath() func() {
+ original := core.AbsolutePath
+ core.AbsolutePath = func(context.Context, model.DataStore, int, string) string {
+ return filepath.FromSlash("/music")
+ }
+ return func() { core.AbsolutePath = original }
+}
diff --git a/core/artwork/folders_artist_test.go b/core/artwork/folders_artist_test.go
new file mode 100644
index 000000000..a35e40232
--- /dev/null
+++ b/core/artwork/folders_artist_test.go
@@ -0,0 +1,47 @@
+package artwork
+
+import (
+ "context"
+ "errors"
+ "io/fs"
+ "testing/fstest"
+
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// unreadableFS globs like its embedded MapFS but refuses to open anything. Injecting the error
+// keeps this independent of the filesystem: os.Chmod does not restrict read access on Windows.
+type unreadableFS struct{ fstest.MapFS }
+
+func (u unreadableFS) Open(string) (fs.File, error) { return nil, fs.ErrPermission }
+
+var _ = Describe("findImageInFolder", func() {
+ var ctx context.Context
+ var files fstest.MapFS
+
+ BeforeEach(func() {
+ ctx = context.Background()
+ files = fstest.MapFS{"artist.jpg": &fstest.MapFile{Data: []byte("img")}}
+ })
+
+ It("returns the first matching image", func() {
+ r, hit, err := findImageInFolder(ctx, files, ".", "/lib", "artist.*")
+ Expect(err).ToNot(HaveOccurred())
+ defer r.Close()
+ Expect(hit).To(HaveSuffix("artist.jpg"))
+ })
+
+ // The glob matched, so the image exists; failing to open it says nothing about whether the
+ // artist has one, and must not let the resolver settle on absent.
+ It("reports a matched but unreadable image as unreadable, not as a miss", func() {
+ _, _, err := findImageInFolder(ctx, unreadableFS{files}, ".", "/lib", "artist.*")
+ Expect(err).To(MatchError(errSourceUnreadable))
+ })
+
+ It("reports a plain miss when nothing matches", func() {
+ _, _, err := findImageInFolder(ctx, files, ".", "/lib", "nothing.*")
+ Expect(err).To(HaveOccurred())
+ Expect(errors.Is(err, errSourceUnreadable)).To(BeFalse(), "no match is definitive, not transient")
+ })
+})
diff --git a/core/artwork/gate.go b/core/artwork/gate.go
new file mode 100644
index 000000000..a64c11a20
--- /dev/null
+++ b/core/artwork/gate.go
@@ -0,0 +1,120 @@
+package artwork
+
+import (
+ "errors"
+ "io"
+ "sync"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "golang.org/x/time/rate"
+)
+
+const (
+ breakerThreshold = 5
+ breakerProbeAfter = time.Minute
+)
+
+var errBreakerOpen = errors.New("artwork: external circuit breaker open")
+
+// gateFunc gates one named external fetch (rate limit + circuit breaker per name).
+type gateFunc = func(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error)
+
+func passthroughGate(_ string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {
+ return f()
+}
+
+// isTransientExternal reports whether an external failure is worth retrying; a not-found
+// (from either package) is a definitive answer, not a fault.
+func isTransientExternal(err error) bool {
+ return err != nil && !errors.Is(err, agents.ErrNotFound) && !errors.Is(err, model.ErrNotFound)
+}
+
+// extGate is one agent's rate limiter and circuit breaker, so a failing provider backs off
+// in isolation from the others.
+type extGate struct {
+ limiter *rate.Limiter
+ breaker *breaker
+}
+
+// gate runs a named external step through that agent's rate limiter and circuit breaker.
+func (w *Worker) gate(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {
+ g := w.gateFor(name)
+ if !g.breaker.allow() {
+ log.Debug(w.runCtx, "Artwork: Skipping agent, circuit breaker open", "agent", name)
+ return nil, "", errBreakerOpen
+ }
+ // Timed separately so a throttled agent isn't mistaken for a slow provider.
+ waitStart := time.Now()
+ if err := g.limiter.Wait(w.runCtx); err != nil {
+ return nil, "", err
+ }
+ callStart := time.Now()
+ r, path, err := f()
+ g.breaker.record(name, err)
+ log.Trace(w.runCtx, "Artwork: External agent call", "agent", name, "hit", r != nil,
+ "limiterWait", callStart.Sub(waitStart), "elapsed", time.Since(callStart), err)
+ return r, path, err
+}
+
+// gateFor lazily creates the per-name gate on first use.
+func (w *Worker) gateFor(name string) *extGate {
+ w.gatesMu.Lock()
+ defer w.gatesMu.Unlock()
+ if g, ok := w.gates[name]; ok {
+ return g
+ }
+ rps := conf.Server.DevArtworkExternalMaxRPS
+ limit := rate.Inf
+ if rps > 0 {
+ limit = rate.Limit(rps)
+ }
+ g := &extGate{limiter: rate.NewLimiter(limit, max(1, rps)), breaker: newBreaker()}
+ w.gates[name] = g
+ return g
+}
+
+// breaker opens after breakerThreshold consecutive errors and admits a single probe once
+// breakerProbeAfter has elapsed; a success re-closes it.
+type breaker struct {
+ mu sync.Mutex
+ failures int
+ openedAt time.Time
+}
+
+func newBreaker() *breaker { return &breaker{} }
+
+func (b *breaker) allow() bool {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ if b.failures < breakerThreshold {
+ return true
+ }
+ if time.Since(b.openedAt) >= breakerProbeAfter {
+ b.openedAt = time.Now() // start a fresh probe window so only one caller passes
+ return true
+ }
+ return false
+}
+
+func (b *breaker) record(name string, err error) {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ // A not-found is a definitive answer, not a fault; keep in sync with isTransientExternal.
+ if err == nil || errors.Is(err, model.ErrNotFound) || errors.Is(err, agents.ErrNotFound) {
+ if b.failures >= breakerThreshold {
+ log.Info("Artwork: Circuit breaker closed for agent", "agent", name)
+ }
+ b.failures = 0
+ return
+ }
+ b.failures++
+ if b.failures == breakerThreshold {
+ b.openedAt = time.Now()
+ log.Warn("Artwork: Circuit breaker opened for agent", "agent", name,
+ "consecutiveFailures", b.failures, "probeAfter", breakerProbeAfter, err)
+ }
+}
diff --git a/core/artwork/hash_encoder_bench_test.go b/core/artwork/hash_encoder_bench_test.go
new file mode 100644
index 000000000..2bc4b90ba
--- /dev/null
+++ b/core/artwork/hash_encoder_bench_test.go
@@ -0,0 +1,51 @@
+package artwork
+
+import (
+ "fmt"
+ "image"
+ "testing"
+
+ "github.com/navidrome/navidrome/core/artwork/blurhash"
+ "github.com/navidrome/navidrome/core/artwork/thumbhash"
+)
+
+// hashEncoders are the two placeholder hashes decodeArtwork computes from one shared thumbnail.
+var hashEncoders = []struct {
+ name string
+ encode func(image.Image) error
+}{
+ {"blurhash", func(img image.Image) error { _, err := blurhash.Encode(img); return err }},
+ {"thumbhash", func(img image.Image) error { _, err := thumbhash.Encode(img); return err }},
+}
+
+func benchEncoder(b *testing.B, encode func(image.Image) error, img image.Image) {
+ b.Helper()
+ b.ReportAllocs()
+ for b.Loop() {
+ if err := encode(img); err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+// BenchmarkHashEncodersAtInputSize is the bar: both encoders are handed the identical image
+// makeThumbnail produces, so neither is measured with a conversion the other avoids.
+func BenchmarkHashEncodersAtInputSize(b *testing.B) {
+ img := gradientNRGBA(thumbnailSize)
+ for _, e := range hashEncoders {
+ b.Run(e.name, func(b *testing.B) { benchEncoder(b, e.encode, img) })
+ }
+}
+
+// BenchmarkHashEncoders sweeps past the pipeline's input size, where each package's own defensive
+// downscale starts to dominate. thumbnailSize itself is covered by the benchmark above.
+func BenchmarkHashEncoders(b *testing.B) {
+ for _, size := range []int{300, 600, 900, 1200, 1500} {
+ img := gradientNRGBA(size)
+ for _, e := range hashEncoders {
+ b.Run(fmt.Sprintf("%s/%dx%d", e.name, size, size), func(b *testing.B) {
+ benchEncoder(b, e.encode, img)
+ })
+ }
+ }
+}
diff --git a/core/artwork/housekeeping.go b/core/artwork/housekeeping.go
new file mode 100644
index 000000000..ce72a6c8e
--- /dev/null
+++ b/core/artwork/housekeeping.go
@@ -0,0 +1,129 @@
+package artwork
+
+import (
+ "context"
+ "crypto/md5"
+ "encoding/hex"
+ "fmt"
+ "slices"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/auth"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils/slice"
+)
+
+const staleAbsentAge = 24 * time.Hour
+
+// recheckKinds omits media files: they resolve embedded-only, at scan or on view.
+var recheckKinds = []model.Kind{
+ model.KindArtistArtwork, model.KindAlbumArtwork, model.KindPlaylistArtwork, model.KindRadioArtwork,
+}
+
+// hasRecheckPath reports whether a periodic job will revisit this kind, making an absent settle recoverable.
+func hasRecheckPath(prefix string) bool {
+ kind, ok := model.ParseKind(prefix)
+ return ok && slices.Contains(recheckKinds, kind)
+}
+
+// artworkEpoch invalidates all resolution state when bumped; bump it whenever resolution semantics change.
+const artworkEpoch = 1
+
+// fingerprint covers the inputs that affect resolution outcomes; a change invalidates stored state.
+func fingerprint() string {
+ raw := fmt.Sprintf("%s|%s|%s|%s|%t|%t|%d",
+ conf.Server.CoverArtPriority, conf.Server.ArtistArtPriority, conf.Server.ArtistImageFolder,
+ conf.Server.Agents, conf.Server.EnableExternalServices, conf.Server.EnableM3UExternalAlbumArt, artworkEpoch)
+ sum := md5.Sum([]byte(raw)) //nolint:gosec // fingerprint, not security-sensitive
+ return hex.EncodeToString(sum[:])
+}
+
+// backfill enqueues artwork resolution for every entity when the config fingerprint changed.
+func backfill(ctx context.Context, ds model.DataStore) (bool, error) {
+ start := time.Now()
+ ctx = auth.WithAdminUser(ctx, ds)
+ current := fingerprint()
+ props := ds.Property(ctx)
+ stored, err := props.DefaultGet(consts.ArtConfFingerprintPropertyKey, "")
+ if err != nil {
+ return false, err
+ }
+ if stored == current {
+ return false, nil
+ }
+
+ // Artists first: few entities, most external-dependent, so they get a queue headstart.
+ kinds := []struct {
+ kind model.Kind
+ fetch func() ([]string, error)
+ }{
+ {model.KindArtistArtwork, func() ([]string, error) { return ds.Artist(ctx).GetAllIDs() }},
+ {model.KindAlbumArtwork, func() ([]string, error) { return ds.Album(ctx).GetAllIDs() }},
+ {model.KindPlaylistArtwork, func() ([]string, error) { return ds.Playlist(ctx).GetAllIDs() }},
+ {model.KindRadioArtwork, func() ([]string, error) { return ds.Radio(ctx).GetAllIDs() }},
+ }
+ for _, k := range kinds {
+ ids, err := k.fetch()
+ if err != nil {
+ return false, err
+ }
+ if err := enqueueBackfillKind(ctx, ds, k.kind, ids); err != nil {
+ return false, err
+ }
+ }
+
+ if err := props.Put(consts.ArtConfFingerprintPropertyKey, current); err != nil {
+ return false, err
+ }
+ log.Info(ctx, "Artwork: Config fingerprint changed, backfill enqueued", "elapsed", time.Since(start))
+ return true, nil
+}
+
+func enqueueBackfillKind(ctx context.Context, ds model.DataStore, kind model.Kind, ids []string) error {
+ if len(ids) == 0 {
+ return nil
+ }
+ items := slice.Map(ids, func(id string) model.ArtworkQueueItem {
+ return model.ArtworkQueueItem{
+ ItemKind: kind.Prefix(), ItemID: id, ImageType: model.ImageTypePrimary, Priority: model.ArtworkPriorityBackfill,
+ }
+ })
+ return ds.ArtworkQueue(ctx).Enqueue(items...)
+}
+
+func enqueueStaleAbsentAll(ctx context.Context, ds model.DataStore) error {
+ cutoff := time.Now().Add(-staleAbsentAge)
+ queue := ds.ArtworkQueue(ctx)
+ for _, kind := range recheckKinds {
+ if _, err := queue.EnqueueStaleAbsent(kind, cutoff); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// enqueueMissingAll is the safety net for entities a scan never enqueued (added between scans, or scanner off).
+func enqueueMissingAll(ctx context.Context, ds model.DataStore) error {
+ queue := ds.ArtworkQueue(ctx)
+ for _, kind := range recheckKinds {
+ if _, err := queue.EnqueueAllMissing(kind, model.ArtworkPriorityRecheck); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// Refresh drops an item's resolved artwork state and re-queues it at Bump priority.
+func Refresh(ctx context.Context, ds model.DataStore, kind model.Kind, id string) error {
+ if err := ds.Artwork(ctx).DeleteForItems(kind, []string{id}); err != nil {
+ return fmt.Errorf("clearing artwork state: %w", err)
+ }
+ item := model.ArtworkQueueItem{ItemKind: kind.Prefix(), ItemID: id, ImageType: model.ImageTypePrimary, Priority: model.ArtworkPriorityBump}
+ if err := ds.ArtworkQueue(ctx).Enqueue(item); err != nil {
+ return fmt.Errorf("enqueuing artwork refresh: %w", err)
+ }
+ return nil
+}
diff --git a/core/artwork/housekeeping_test.go b/core/artwork/housekeeping_test.go
new file mode 100644
index 000000000..3b75c5186
--- /dev/null
+++ b/core/artwork/housekeeping_test.go
@@ -0,0 +1,261 @@
+package artwork
+
+import (
+ "context"
+ "slices"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// visibilityPlaylistDS models playlist_repository's userFilter: a private playlist is only
+// visible when the ctx carries an admin, so headless work must wrap ctx with one first.
+type visibilityPlaylistDS struct {
+ *tests.MockDataStore
+ private model.Playlist
+ tracks model.PlaylistTrackRepository
+}
+
+func (v *visibilityPlaylistDS) Playlist(ctx context.Context) model.PlaylistRepository {
+ repo := tests.CreateMockPlaylistRepo()
+ repo.TracksRepo = v.tracks
+ if u, ok := request.UserFrom(ctx); ok && u.IsAdmin {
+ repo.SetData(model.Playlists{v.private})
+ }
+ return repo
+}
+
+func adminUserRepo() *tests.MockedUserRepo {
+ repo := tests.CreateMockUserRepo()
+ Expect(repo.Put(&model.User{ID: "admin", UserName: "admin", IsAdmin: true})).To(Succeed())
+ return repo
+}
+
+// orderTrackingQueueRepo records the item kind of each Enqueue call, so tests can
+// assert phase ordering (artists-first) that same-priority timestamps can't guarantee.
+type orderTrackingQueueRepo struct {
+ *tests.MockArtworkQueueRepo
+ callKinds []string
+}
+
+func (o *orderTrackingQueueRepo) Enqueue(items ...model.ArtworkQueueItem) error {
+ if len(items) > 0 {
+ o.callKinds = append(o.callKinds, items[0].ItemKind)
+ }
+ return o.MockArtworkQueueRepo.Enqueue(items...)
+}
+
+var _ = Describe("Housekeeping", func() {
+ var (
+ ctx context.Context
+ ds *tests.MockDataStore
+ queueRepo *orderTrackingQueueRepo
+ propRepo *tests.MockedPropertyRepo
+ )
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ ctx = context.Background()
+ conf.Server.CoverArtPriority = "embedded, folder"
+ conf.Server.ArtistArtPriority = "artist.jpg"
+ conf.Server.Agents = "spotify"
+ conf.Server.EnableExternalServices = true
+
+ queueRepo = &orderTrackingQueueRepo{MockArtworkQueueRepo: tests.CreateMockArtworkQueueRepo()}
+ propRepo = &tests.MockedPropertyRepo{}
+ ds = &tests.MockDataStore{MockedArtworkQueue: queueRepo, MockedProperty: propRepo}
+ })
+
+ seedEntities := func() {
+ artistRepo := tests.CreateMockArtistRepo()
+ artistRepo.SetData(model.Artists{{ID: "ar1"}, {ID: "ar2"}})
+ ds.MockedArtist = artistRepo
+
+ albumRepo := tests.CreateMockAlbumRepo()
+ albumRepo.SetData(model.Albums{{ID: "al1"}})
+ ds.MockedAlbum = albumRepo
+
+ playlistRepo := tests.CreateMockPlaylistRepo()
+ playlistRepo.SetData(model.Playlists{{ID: "pl1"}})
+ ds.MockedPlaylist = playlistRepo
+
+ radioRepo := tests.CreateMockedRadioRepo()
+ radioRepo.All = model.Radios{{ID: "ra1"}}
+ ds.MockedRadio = radioRepo
+ }
+
+ Describe("Fingerprint", func() {
+ It("changes when a fingerprint-affecting config value changes", func() {
+ f1 := fingerprint()
+ conf.Server.CoverArtPriority = "folder, embedded"
+ f2 := fingerprint()
+ Expect(f1).NotTo(Equal(f2))
+ })
+
+ It("changes when ArtistImageFolder changes", func() {
+ conf.Server.ArtistImageFolder = "/before"
+ f1 := fingerprint()
+ conf.Server.ArtistImageFolder = "/after"
+ Expect(fingerprint()).NotTo(Equal(f1))
+ })
+
+ It("changes when EnableM3UExternalAlbumArt is toggled", func() {
+ conf.Server.EnableM3UExternalAlbumArt = false
+ f1 := fingerprint()
+ conf.Server.EnableM3UExternalAlbumArt = true
+ Expect(fingerprint()).NotTo(Equal(f1))
+ })
+
+ It("does not change when the server version changes", func() {
+ original := consts.Version
+ DeferCleanup(func() { consts.Version = original })
+ f1 := fingerprint()
+ consts.Version = original + "-next"
+ Expect(fingerprint()).To(Equal(f1),
+ "the version must not invalidate artwork state: it would re-resolve every entity on every build")
+ })
+ })
+
+ Describe("Backfill", func() {
+ It("enqueues nothing and returns false when the stored fingerprint matches", func() {
+ seedEntities()
+ Expect(propRepo.Put(consts.ArtConfFingerprintPropertyKey, fingerprint())).To(Succeed())
+
+ did, err := backfill(ctx, ds)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(did).To(BeFalse())
+
+ count, err := queueRepo.Count()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(count).To(BeZero())
+ })
+
+ It("runs the backfill when no fingerprint was ever stored", func() {
+ seedEntities()
+
+ did, err := backfill(ctx, ds)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(did).To(BeTrue())
+
+ count, err := queueRepo.Count()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(count).To(Equal(int64(5))) // 2 artists + 1 album + 1 playlist + 1 radio
+
+ stored, err := propRepo.Get(consts.ArtConfFingerprintPropertyKey)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(stored).To(Equal(fingerprint()))
+ })
+
+ It("enqueues a private playlist by resolving it under an admin context", func() {
+ ds.MockedUser = adminUserRepo()
+ vds := &visibilityPlaylistDS{
+ MockDataStore: ds,
+ private: model.Playlist{ID: "plPrivate", OwnerID: "admin"},
+ tracks: &tests.MockPlaylistTrackRepo{},
+ }
+
+ did, err := backfill(ctx, vds)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(did).To(BeTrue())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "pl", "plPrivate")).ToNot(BeNil())
+ })
+
+ It("enqueues artists before albums/playlists/radios, all at Backfill priority", func() {
+ seedEntities()
+ Expect(propRepo.Put(consts.ArtConfFingerprintPropertyKey, "stale-fingerprint")).To(Succeed())
+
+ did, err := backfill(ctx, ds)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(did).To(BeTrue())
+
+ Expect(queueRepo.callKinds).ToNot(BeEmpty())
+ firstOther := slices.IndexFunc(queueRepo.callKinds, func(k string) bool { return k != "ar" })
+ Expect(firstOther).ToNot(Equal(0), "artists must be the first Enqueue call")
+ if firstOther >= 0 {
+ Expect(queueRepo.callKinds[firstOther:]).ToNot(ContainElement("ar"),
+ "no artist Enqueue may follow another kind")
+ }
+
+ for _, it := range queueRepo.Data {
+ Expect(it.Priority).To(Equal(model.ArtworkPriorityBackfill))
+ Expect(it.ItemKind).To(BeElementOf("ar", "al", "pl", "ra"))
+ }
+ })
+ })
+
+ Describe("EnqueueStaleAbsentAll", func() {
+ var artRepo *tests.MockArtworkRepo
+
+ BeforeEach(func() {
+ artRepo = tests.CreateMockArtworkRepo()
+ ds.MockedArtwork = artRepo
+ queueRepo.ItemArtworkSource = artRepo
+ })
+
+ It("enqueues only absent entries older than the recheck window, across all kinds", func() {
+ old := time.Now().Add(-48 * time.Hour)
+ recent := time.Now().Add(-time.Hour)
+
+ artRepo.ItemData["ar-stale"] = model.ItemArtwork{ItemKind: "ar", ItemID: "ar1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old}
+ artRepo.ItemData["al-stale"] = model.ItemArtwork{ItemKind: "al", ItemID: "al1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old}
+ artRepo.ItemData["pl-stale"] = model.ItemArtwork{ItemKind: "pl", ItemID: "pl1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old}
+ artRepo.ItemData["ra-stale"] = model.ItemArtwork{ItemKind: "ra", ItemID: "ra1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old}
+ artRepo.ItemData["ar-recent"] = model.ItemArtwork{ItemKind: "ar", ItemID: "ar2", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: recent}
+ artRepo.ItemData["al-resolved"] = model.ItemArtwork{ItemKind: "al", ItemID: "al2", ImageType: model.ImageTypePrimary, Hash: "somehash", AttemptedAt: old}
+
+ err := enqueueStaleAbsentAll(ctx, ds)
+ Expect(err).ToNot(HaveOccurred())
+
+ Expect(queueRepo.Data).To(HaveLen(4))
+ for _, it := range queueRepo.Data {
+ Expect(it.Priority).To(Equal(model.ArtworkPriorityRecheck))
+ }
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ar", "ar1")).ToNot(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "al", "al1")).ToNot(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "pl", "pl1")).ToNot(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ra", "ra1")).ToNot(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ar", "ar2")).To(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "al", "al2")).To(BeNil())
+ })
+ })
+
+ Describe("EnqueueMissingAll", func() {
+ var artRepo *tests.MockArtworkRepo
+
+ BeforeEach(func() {
+ artRepo = tests.CreateMockArtworkRepo()
+ ds.MockedArtwork = artRepo
+ queueRepo.ItemArtworkSource = artRepo
+ queueRepo.ExistingIDs = map[string]map[string]bool{
+ "al": {"al1": true, "al2": true},
+ "ar": {"ar1": true},
+ "pl": {"pl1": true},
+ "ra": {"ra1": true},
+ }
+ })
+
+ It("enqueues only entities that have no item_artwork row, across all kinds", func() {
+ artRepo.ItemData["al-resolved"] = model.ItemArtwork{ItemKind: "al", ItemID: "al1", ImageType: model.ImageTypePrimary, Hash: "somehash", AttemptedAt: time.Now()}
+ artRepo.ItemData["ar-absent"] = model.ItemArtwork{ItemKind: "ar", ItemID: "ar1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()}
+
+ err := enqueueMissingAll(ctx, ds)
+ Expect(err).ToNot(HaveOccurred())
+
+ for _, it := range queueRepo.Data {
+ Expect(it.Priority).To(Equal(model.ArtworkPriorityRecheck))
+ }
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "al", "al2")).ToNot(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "pl", "pl1")).ToNot(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ra", "ra1")).ToNot(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "al", "al1")).To(BeNil())
+ Expect(findQueued(queueRepo.MockArtworkQueueRepo, "ar", "ar1")).To(BeNil())
+ })
+ })
+})
diff --git a/core/artwork/image_cache.go b/core/artwork/image_cache.go
index ac0f63794..39938a755 100644
--- a/core/artwork/image_cache.go
+++ b/core/artwork/image_cache.go
@@ -1,30 +1,22 @@
package artwork
import (
+ "bytes"
"context"
- "fmt"
"io"
- "time"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/core/ffmpeg"
"github.com/navidrome/navidrome/utils/cache"
"github.com/navidrome/navidrome/utils/singleton"
)
-type cacheKey struct {
- artID model.ArtworkID
- lastUpdate time.Time
-}
-
-func (k *cacheKey) Key() string {
- return fmt.Sprintf(
- "%s-%s.%d",
- k.artID.Kind,
- k.artID.ID,
- k.lastUpdate.UnixMilli(),
- )
+// artworkReader is the cache.Item the image cache loader dispatches on: Reader
+// produces the (possibly resized) bytes to store under Key.
+type artworkReader interface {
+ cache.Item
+ Reader(ctx context.Context) (io.ReadCloser, error)
}
type imageCache struct {
@@ -36,9 +28,45 @@ func GetImageCache() cache.FileCache {
return &imageCache{
FileCache: cache.NewFileCache("Image", conf.Server.ImageCacheSize, consts.ImageCacheDir, consts.DefaultImageCacheMaxItems,
func(ctx context.Context, arg cache.Item) (io.Reader, error) {
- r, _, err := arg.(artworkReader).Reader(ctx)
- return r, err
+ return arg.(artworkReader).Reader(ctx)
}),
}
})
}
+
+// resizedItem is an artworkReader that resizes bytes opened by open() and caches the
+// result under a hash-derived key.
+type resizedItem struct {
+ hash string
+ size int
+ square bool
+ ffmpeg ffmpeg.FFmpeg
+ open func() (io.ReadCloser, error)
+}
+
+// Key is the ETag namespaced for the cache, so the validator a client holds and the entry it
+// validates can never drift apart.
+func (r *resizedItem) Key() string {
+ return "h-" + representationTag(r.hash, r.size, r.square)
+}
+
+func (r *resizedItem) Reader(ctx context.Context) (io.ReadCloser, error) {
+ orig, err := r.open()
+ if err != nil {
+ return nil, err
+ }
+ defer orig.Close()
+ data, err := readCapped(orig)
+ if err != nil {
+ return nil, err
+ }
+ resized, _, err := resizeImageData(ctx, r.ffmpeg, data, r.size, r.square)
+ if err != nil || resized == nil {
+ // Resize failed or image already within bounds: serve the original bytes.
+ return io.NopCloser(bytes.NewReader(data)), nil
+ }
+ if rc, ok := resized.(io.ReadCloser); ok {
+ return rc, nil
+ }
+ return io.NopCloser(resized), nil
+}
diff --git a/core/artwork/image_store.go b/core/artwork/image_store.go
new file mode 100644
index 000000000..5dbe727e4
--- /dev/null
+++ b/core/artwork/image_store.go
@@ -0,0 +1,155 @@
+package artwork
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "io/fs"
+ "os"
+ "path/filepath"
+ "strings"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/log"
+ "github.com/zeebo/xxh3"
+)
+
+// ImageStore is the content-addressed store for artwork images with no library file backing them.
+type ImageStore struct {
+ root string
+}
+
+func NewImageStore(rootDir string) *ImageStore {
+ return &ImageStore{root: rootDir}
+}
+
+func GetImageStore() *ImageStore {
+ return NewImageStore(filepath.Join(conf.Server.DataFolder.String(), consts.ArtworkFolder, consts.HashedArtworkFolder))
+}
+
+// extForMime must stay stable across OSes: extensions are baked into stored paths and re-derived on Open.
+func extForMime(m string) string {
+ switch m {
+ case "image/jpeg":
+ return ".jpg"
+ case "image/png":
+ return ".png"
+ case "image/gif":
+ return ".gif"
+ case "image/webp":
+ return ".webp"
+ }
+ return ".img"
+}
+
+func hashImage(r io.Reader) (string, error) {
+ d := xxh3.New()
+ if _, err := io.Copy(d, r); err != nil {
+ return "", err
+ }
+ return fmt.Sprintf("%016x", d.Sum64()), nil
+}
+
+// validHash guards path sharding: a malformed hash would slice-panic or inject path separators.
+func validHash(hash string) bool {
+ if len(hash) != 16 {
+ return false
+ }
+ for _, c := range []byte(hash) {
+ if (c < '0' || c > '9') && (c < 'a' || c > 'f') {
+ return false
+ }
+ }
+ return true
+}
+
+func (s *ImageStore) path(hash, mimeType string) string {
+ return filepath.Join(s.root, hash[0:2], hash[2:4], hash+extForMime(mimeType))
+}
+
+func (s *ImageStore) Write(hash, mimeType string, r io.Reader) error {
+ if !validHash(hash) {
+ return fmt.Errorf("imagestore: invalid hash %q", hash)
+ }
+ dst := s.path(hash, mimeType)
+ if _, err := os.Stat(dst); err == nil {
+ // A touched mtime marks the file live so a concurrent prune spares it.
+ now := time.Now()
+ if err := os.Chtimes(dst, now, now); err == nil {
+ return nil
+ }
+ // touch failed (likely pruned concurrently) — fall through and rewrite it
+ }
+ if err := os.MkdirAll(filepath.Dir(dst), 0755); err != nil {
+ return err
+ }
+ tmp, err := os.CreateTemp(filepath.Dir(dst), "."+hash+".tmp*")
+ if err != nil {
+ return err
+ }
+ defer os.Remove(tmp.Name())
+ if _, err := io.Copy(tmp, r); err != nil {
+ tmp.Close()
+ return err
+ }
+ if err := tmp.Close(); err != nil {
+ return err
+ }
+ return os.Rename(tmp.Name(), dst)
+}
+
+func (s *ImageStore) Open(hash, mimeType string) (io.ReadCloser, error) {
+ if !validHash(hash) {
+ return nil, fmt.Errorf("imagestore: invalid hash %q", hash)
+ }
+ return os.Open(s.path(hash, mimeType))
+}
+
+// Sweep removes store files not accepted by keep. Files modified after cutoff are always
+// kept: their acquisition row may not be committed yet.
+func (s *ImageStore) Sweep(ctx context.Context, cutoff time.Time, keep func(hash, ext string) bool) (int, error) {
+ removed, failed := 0, 0
+ var lastErr error
+ err := filepath.WalkDir(s.root, func(path string, d fs.DirEntry, err error) error {
+ if err != nil || d.IsDir() {
+ return err
+ }
+ if err := ctx.Err(); err != nil {
+ return err
+ }
+ info, err := d.Info()
+ if err != nil {
+ return err
+ }
+ if info.ModTime().After(cutoff) {
+ return nil
+ }
+ name := d.Name()
+ remove := strings.HasPrefix(name, ".") // abandoned temp file past the grace window
+ if !remove {
+ ext := filepath.Ext(name)
+ remove = !keep(strings.TrimSuffix(name, ext), ext)
+ }
+ if remove {
+ // #nosec G122 -- path comes from WalkDir over our own store root, no attacker-controlled symlinks
+ if err := os.Remove(path); err != nil {
+ // One unremovable file must not strand the rest of the store until the next prune.
+ failed, lastErr = failed+1, err
+ return nil //nolint:nilerr // counted and reported in aggregate below
+ }
+ removed++
+ }
+ return nil
+ })
+ // Aggregated: a store that has gone read-only would otherwise warn once per file, every prune.
+ if failed > 0 {
+ log.Warn(ctx, "Artwork: Could not remove store files", "count", failed, "swept", removed, lastErr)
+ }
+ if errors.Is(err, fs.ErrNotExist) {
+ return removed, nil
+ }
+ return removed, err
+}
diff --git a/core/artwork/image_store_test.go b/core/artwork/image_store_test.go
new file mode 100644
index 000000000..f7b2467ca
--- /dev/null
+++ b/core/artwork/image_store_test.go
@@ -0,0 +1,228 @@
+package artwork
+
+import (
+ "bytes"
+ "context"
+ "io"
+ "os"
+ "path/filepath"
+ "time"
+
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("ImageStore", func() {
+ var store *ImageStore
+ var root string
+ var ctx context.Context
+
+ BeforeEach(func() {
+ root = GinkgoT().TempDir()
+ store = NewImageStore(root)
+ ctx = context.Background()
+ })
+
+ It("hashes deterministically", func() {
+ h1, err := hashImage(bytes.NewReader([]byte("some image bytes")))
+ Expect(err).ToNot(HaveOccurred())
+ h2, _ := hashImage(bytes.NewReader([]byte("some image bytes")))
+ Expect(h1).To(Equal(h2))
+ Expect(h1).To(HaveLen(16))
+ h3, _ := hashImage(bytes.NewReader([]byte("other bytes")))
+ Expect(h3).ToNot(Equal(h1))
+ })
+
+ It("writes sharded and reads back", func() {
+ data := []byte("jpeg-bytes")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())
+
+ Expect(filepath.Join(root, h[0:2], h[2:4], h+".jpg")).To(BeAnExistingFile())
+
+ rc, err := store.Open(h, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ defer rc.Close()
+ got, _ := io.ReadAll(rc)
+ Expect(got).To(Equal(data))
+ })
+
+ It("is idempotent on duplicate writes and preserves the original content", func() {
+ data := []byte("dup")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())
+ // A duplicate write only touches mtime; passing different bytes under the same
+ // hash proves the second reader is never consumed to overwrite the file.
+ Expect(store.Write(h, "image/png", bytes.NewReader([]byte("not-dup")))).To(Succeed())
+
+ rc, err := store.Open(h, "image/png")
+ Expect(err).ToNot(HaveOccurred())
+ defer rc.Close()
+ got, err := io.ReadAll(rc)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(Equal(data))
+ })
+
+ It("refreshes the mtime on a duplicate write", func() {
+ data := []byte("touch-me")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())
+ old := time.Now().Add(-2 * time.Hour)
+ Expect(os.Chtimes(store.path(h, "image/png"), old, old)).To(Succeed())
+
+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())
+
+ info, err := os.Stat(store.path(h, "image/png"))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(info.ModTime()).To(BeTemporally(">", time.Now().Add(-time.Minute)))
+ })
+
+ It("rewrites the bytes when the existing file vanished before the liveness touch", func() {
+ data := []byte("vanishing")
+ h, _ := hashImage(bytes.NewReader(data))
+ for range 10 {
+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())
+ Expect(os.Remove(store.path(h, "image/png"))).To(Succeed())
+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())
+
+ rc, err := store.Open(h, "image/png")
+ Expect(err).ToNot(HaveOccurred())
+ got, _ := io.ReadAll(rc)
+ rc.Close()
+ Expect(got).To(Equal(data))
+ }
+ })
+
+ It("returns fs.ErrNotExist for missing images", func() {
+ _, err := store.Open("beefbeefbeefbeef", "image/jpeg")
+ Expect(os.IsNotExist(err)).To(BeTrue())
+ })
+
+ It("rejects invalid hashes instead of panicking", func() {
+ for _, h := range []string{"", "ab", "BEEFBEEFBEEFBEEF", "../../../../etcpw", "beefbeefbeefbee/"} {
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader([]byte("x")))).To(MatchError(ContainSubstring("invalid hash")))
+ _, err := store.Open(h, "image/jpeg")
+ Expect(err).To(MatchError(ContainSubstring("invalid hash")))
+ }
+ })
+
+ It("sweeps unknown files, keeps known ones", func() {
+ d1 := []byte("keep-me")
+ h1, _ := hashImage(bytes.NewReader(d1))
+ Expect(store.Write(h1, "image/jpeg", bytes.NewReader(d1))).To(Succeed())
+ d2 := []byte("orphan")
+ h2, _ := hashImage(bytes.NewReader(d2))
+ Expect(store.Write(h2, "image/jpeg", bytes.NewReader(d2))).To(Succeed())
+
+ old := time.Now().Add(-2 * time.Hour)
+ Expect(os.Chtimes(store.path(h2, "image/jpeg"), old, old)).To(Succeed())
+
+ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(h, _ string) bool { return h == h1 })
+ Expect(err).ToNot(HaveOccurred())
+ Expect(removed).To(Equal(1))
+ _, err = store.Open(h2, "image/jpeg")
+ Expect(os.IsNotExist(err)).To(BeTrue())
+ rc, err := store.Open(h1, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("sweeps a stale mime variant of a known hash, keeps the current one", func() {
+ data := []byte("same-bytes")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())
+ old := time.Now().Add(-2 * time.Hour)
+ Expect(os.Chtimes(store.path(h, "image/png"), old, old)).To(Succeed())
+ Expect(os.Chtimes(store.path(h, "image/jpeg"), old, old)).To(Succeed())
+
+ // The recorded mime is image/jpeg, so the .png variant is obsolete.
+ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(hash, ext string) bool {
+ return hash == h && ext == ".jpg"
+ })
+ Expect(err).ToNot(HaveOccurred())
+ Expect(removed).To(Equal(1))
+ _, err = store.Open(h, "image/png")
+ Expect(os.IsNotExist(err)).To(BeTrue())
+ rc, err := store.Open(h, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("keeps young unknown files inside the grace window", func() {
+ d := []byte("fresh-orphan")
+ h, _ := hashImage(bytes.NewReader(d))
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(d))).To(Succeed())
+
+ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(string, string) bool { return false })
+ Expect(err).ToNot(HaveOccurred())
+ Expect(removed).To(Equal(0))
+ rc, err := store.Open(h, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("removes abandoned temp files past the grace window, keeps fresh ones", func() {
+ oldTmp := filepath.Join(root, ".old.tmp")
+ Expect(os.WriteFile(oldTmp, []byte("x"), 0600)).To(Succeed())
+ old := time.Now().Add(-2 * time.Hour)
+ Expect(os.Chtimes(oldTmp, old, old)).To(Succeed())
+
+ freshTmp := filepath.Join(root, ".fresh.tmp")
+ Expect(os.WriteFile(freshTmp, []byte("y"), 0600)).To(Succeed())
+
+ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(string, string) bool { return true })
+ Expect(err).ToNot(HaveOccurred())
+ Expect(removed).To(Equal(1))
+ Expect(oldTmp).ToNot(BeAnExistingFile())
+ Expect(freshTmp).To(BeAnExistingFile())
+ })
+
+ It("keeps sweeping past a file it cannot remove", func() {
+ tests.SkipOnWindows("uses Unix file permission bits")
+ if os.Geteuid() == 0 {
+ Skip("read-only dir cannot block root (e.g. tests in a container)")
+ }
+ old := time.Now().Add(-2 * time.Hour)
+ // "blocked" sorts before "ok", so the walk hits the unremovable file first.
+ blockedDir := filepath.Join(root, "blocked")
+ Expect(os.MkdirAll(blockedDir, 0755)).To(Succeed())
+ blocked := filepath.Join(blockedDir, "a.jpg")
+ Expect(os.WriteFile(blocked, []byte("x"), 0600)).To(Succeed())
+ Expect(os.Chtimes(blocked, old, old)).To(Succeed())
+
+ okDir := filepath.Join(root, "ok")
+ Expect(os.MkdirAll(okDir, 0755)).To(Succeed())
+ reachable := filepath.Join(okDir, "b.jpg")
+ Expect(os.WriteFile(reachable, []byte("y"), 0600)).To(Succeed())
+ Expect(os.Chtimes(reachable, old, old)).To(Succeed())
+
+ Expect(os.Chmod(blockedDir, 0500)).To(Succeed())
+ DeferCleanup(func() { _ = os.Chmod(blockedDir, 0755) })
+
+ removed, err := store.Sweep(ctx, time.Now().Add(-time.Hour), func(string, string) bool { return false })
+ Expect(err).ToNot(HaveOccurred())
+ Expect(removed).To(Equal(1))
+ Expect(blocked).To(BeAnExistingFile())
+ Expect(reachable).ToNot(BeAnExistingFile())
+ })
+
+ // Prune holds the worker's write lock for the whole sweep, and shutdown waits on the
+ // worker, so an uncancellable walk over a large store stalls it until SIGKILL.
+ It("abandons the walk when the context is cancelled", func() {
+ old := time.Now().Add(-2 * time.Hour)
+ for _, name := range []string{"a", "b", "c", "d"} {
+ p := filepath.Join(root, name+".jpg")
+ Expect(os.WriteFile(p, []byte("x"), 0600)).To(Succeed())
+ Expect(os.Chtimes(p, old, old)).To(Succeed())
+ }
+ cancelCtx, cancel := context.WithCancel(ctx)
+ cancel()
+
+ _, err := store.Sweep(cancelCtx, time.Now().Add(-time.Hour), func(string, string) bool { return false })
+ Expect(err).To(MatchError(context.Canceled))
+ matches, _ := filepath.Glob(filepath.Join(root, "*.jpg"))
+ Expect(matches).To(HaveLen(4), "a cancelled sweep must not keep deleting")
+ })
+})
diff --git a/core/artwork/library_fs.go b/core/artwork/library_fs.go
index ff557294e..6e6099325 100644
--- a/core/artwork/library_fs.go
+++ b/core/artwork/library_fs.go
@@ -2,7 +2,9 @@ package artwork
import (
"context"
+ "net/url"
"path/filepath"
+ "strings"
"github.com/navidrome/navidrome/core/storage"
"github.com/navidrome/navidrome/model"
@@ -40,5 +42,23 @@ func loadLibraryView(ctx context.Context, ds model.DataStore, libID int) (librar
if err != nil {
return libraryView{}, err
}
- return libraryView{FS: fs, absRoot: lib.Path}, nil
+ return libraryView{FS: fs, absRoot: localOSRoot(lib.Path)}, nil
+}
+
+// localOSRoot maps a library path to its on-disk root so Abs() yields paths os.Open/os.Stat accept:
+// a file:// URL becomes its parsed OS path (bare paths already are; non-local schemes stay unchanged).
+func localOSRoot(libPath string) string {
+ if !strings.Contains(libPath, "://") {
+ return libPath
+ }
+ u, err := url.Parse(libPath)
+ if err != nil || u.Scheme != storage.LocalSchemaID {
+ return libPath
+ }
+ // Windows drive URLs (file://C:/Music) put the volume in Host; rejoin it, matching
+ // core/storage/local's newLocalStorage so os.Open/os.Stat get a valid path.
+ if filepath.VolumeName(u.Host) != "" {
+ return filepath.Join(u.Host, u.Path)
+ }
+ return u.Path
}
diff --git a/core/artwork/library_fs_test.go b/core/artwork/library_fs_test.go
index acf08fda3..22498e7a1 100644
--- a/core/artwork/library_fs_test.go
+++ b/core/artwork/library_fs_test.go
@@ -32,6 +32,13 @@ var _ = Describe("loadLibraryView", Ordered, func() {
Expect(lib.absRoot).To(Equal("fake:///music"))
})
+ It("normalizes a library path to an OS root that Abs can join for os.Open/os.Stat", func() {
+ // file:// URLs become their parsed OS path; bare paths and non-local schemes are unchanged.
+ Expect(localOSRoot("file:///music/library")).To(Equal("/music/library"))
+ Expect(localOSRoot("/music/library")).To(Equal("/music/library"))
+ Expect(localOSRoot("fake:///music")).To(Equal("fake:///music"))
+ })
+
It("returns an error when the library does not exist", func() {
_, err := loadLibraryView(ctx, ds, 999)
Expect(err).To(HaveOccurred())
diff --git a/core/artwork/playlist_cover.go b/core/artwork/playlist_cover.go
new file mode 100644
index 000000000..e74b64808
--- /dev/null
+++ b/core/artwork/playlist_cover.go
@@ -0,0 +1,116 @@
+package artwork
+
+import (
+ "bytes"
+ "context"
+ "image"
+ "image/draw"
+ "image/png"
+ "io"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils"
+ xdraw "golang.org/x/image/draw"
+)
+
+const tileSize = 600
+
+// findPlaylistSidecarPath finds an image beside plsPath with the same base name (case-insensitive).
+func findPlaylistSidecarPath(ctx context.Context, plsPath string) string {
+ if plsPath == "" {
+ return ""
+ }
+ dir := filepath.Dir(plsPath)
+ base := strings.TrimSuffix(filepath.Base(plsPath), filepath.Ext(plsPath))
+
+ entries, err := os.ReadDir(dir)
+ if err != nil {
+ log.Warn(ctx, "Artwork: Could not read directory for playlist sidecar", "dir", dir, err)
+ return ""
+ }
+ for _, entry := range entries {
+ name := entry.Name()
+ nameBase := utils.BaseName(name)
+ if !entry.IsDir() && strings.EqualFold(nameBase, base) && model.IsImageFile(name) {
+ return filepath.Join(dir, name)
+ }
+ }
+ return ""
+}
+
+func rect(pos int) image.Rectangle {
+ r := image.Rectangle{}
+ switch pos {
+ case 1:
+ r.Min.X = tileSize / 2
+ case 2:
+ r.Min.Y = tileSize / 2
+ case 3:
+ r.Min.X = tileSize / 2
+ r.Min.Y = tileSize / 2
+ }
+ r.Max.X = r.Min.X + tileSize/2
+ r.Max.Y = r.Min.Y + tileSize/2
+ return r
+}
+
+// fillCenter center-crops src and scales it to fill dstW x dstH exactly.
+func fillCenter(src image.Image, dstW, dstH int) image.Image {
+ srcBounds := src.Bounds()
+ srcW := srcBounds.Dx()
+ srcH := srcBounds.Dy()
+
+ srcAspect := float64(srcW) / float64(srcH)
+ dstAspect := float64(dstW) / float64(dstH)
+
+ var cropRect image.Rectangle
+ if srcAspect > dstAspect {
+ cropW := int(float64(srcH) * dstAspect)
+ cropX := (srcW - cropW) / 2
+ cropRect = image.Rect(srcBounds.Min.X+cropX, srcBounds.Min.Y, srcBounds.Min.X+cropX+cropW, srcBounds.Max.Y)
+ } else {
+ cropH := int(float64(srcW) / dstAspect)
+ cropY := (srcH - cropH) / 2
+ cropRect = image.Rect(srcBounds.Min.X, srcBounds.Min.Y+cropY, srcBounds.Max.X, srcBounds.Min.Y+cropY+cropH)
+ }
+
+ dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
+ xdraw.CatmullRom.Scale(dst, dst.Bounds(), src, cropRect, draw.Src, nil)
+ return dst
+}
+
+// decodeTile runs before the processor's size guards apply, so it enforces the caps itself.
+func decodeTile(r io.ReadCloser) (image.Image, error) {
+ data, err := readCapped(r)
+ if err != nil {
+ return nil, err
+ }
+ img, _, err := decodeCapped(data)
+ if err != nil {
+ return nil, err
+ }
+ return fillCenter(img, tileSize/2, tileSize/2), nil
+}
+
+func assembleTiles(tiles []image.Image) (io.ReadCloser, error) {
+ buf := new(bytes.Buffer)
+ var err error
+ if len(tiles) == 4 {
+ rgba := image.NewRGBA(image.Rectangle{Max: image.Point{X: tileSize - 1, Y: tileSize - 1}})
+ draw.Draw(rgba, rect(0), tiles[0], image.Point{}, draw.Src)
+ draw.Draw(rgba, rect(1), tiles[1], image.Point{}, draw.Src)
+ draw.Draw(rgba, rect(2), tiles[2], image.Point{}, draw.Src)
+ draw.Draw(rgba, rect(3), tiles[3], image.Point{}, draw.Src)
+ err = png.Encode(buf, rgba)
+ } else {
+ err = png.Encode(buf, tiles[0])
+ }
+ if err != nil {
+ return nil, err
+ }
+ return io.NopCloser(buf), nil
+}
diff --git a/core/artwork/processor.go b/core/artwork/processor.go
new file mode 100644
index 000000000..c3cf15b71
--- /dev/null
+++ b/core/artwork/processor.go
@@ -0,0 +1,311 @@
+package artwork
+
+import (
+ "bytes"
+ "context"
+ "encoding/base64"
+ "errors"
+ "fmt"
+ "image"
+ "image/draw"
+ _ "image/gif" // the only artwork format with no other importer in this package
+ "io"
+ "sync"
+ "time"
+
+ "github.com/navidrome/navidrome/core/artwork/blurhash"
+ "github.com/navidrome/navidrome/core/artwork/dominant"
+ "github.com/navidrome/navidrome/core/artwork/thumbhash"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ xdraw "golang.org/x/image/draw"
+)
+
+// outcome tells the worker whether to delete the queue row (found/absent) or reschedule it.
+type outcome int
+
+const (
+ outcomeFound outcome = iota
+ // outcomeFoundStale: state was written and is served, but a higher-priority external
+ // source failed, so the row must retry to give it another chance.
+ outcomeFoundStale
+ outcomeAbsent
+ outcomeFailed
+)
+
+func (o outcome) String() string {
+ switch o {
+ case outcomeFound:
+ return "found"
+ case outcomeFoundStale:
+ return "foundStale"
+ case outcomeAbsent:
+ return "absent"
+ default:
+ return "failed"
+ }
+}
+
+// thumbnailSize is the max dimension fed to both hash encoders; thumbhash rejects anything larger.
+const thumbnailSize = 100
+
+// maxImageBytes caps a resolved image read: a user-editable ExternalImageURL could point at
+// an arbitrarily large endpoint.
+const maxImageBytes = 20 << 20
+
+// maxImagePixels guards against decompression bombs: a tiny file can declare a canvas that
+// image.Decode would expand into gigabytes.
+const maxImagePixels = 64 << 20
+
+// acquired is what a successful acquire persisted, handed back so the caller can warm the resize
+// cache without re-reading the rows and the file it just wrote.
+type acquired struct {
+ ia *model.ItemArtwork
+ mime string
+ data []byte
+}
+
+// processor turns one queue item into stored artwork; settling the queue row is the Worker's job.
+type processor struct {
+ ds model.DataStore
+ store *ImageStore
+ resolver *resolver
+ pruneLock sync.Locker
+}
+
+// acquire resolves one queue item end to end: find an image, hash/decode/
+// blurhash it, place its bytes, and persist the resulting state.
+func (p *processor) acquire(ctx context.Context, item model.ArtworkQueueItem) (out outcome, got *acquired) {
+ repo := p.ds.Artwork(ctx)
+ start := time.Now()
+ defer func() {
+ log.Debug(ctx, "Artwork: Acquisition finished", "kind", item.ItemKind, "id", item.ItemID,
+ "outcome", out, "elapsed", time.Since(start))
+ }()
+
+ res, err := p.resolver.resolve(ctx, item)
+ if err != nil {
+ log.Warn(ctx, "Artwork: Could not resolve item", "kind", item.ItemKind, "id", item.ItemID, err)
+ return outcomeFailed, nil
+ }
+ if res.reader == nil {
+ if res.extError || res.localError {
+ // A fault is not a definitive "no image": never settle absent, keep serving old state.
+ log.Debug(ctx, "Artwork: No image, but a source faulted; keeping previous state",
+ "kind", item.ItemKind, "id", item.ItemID, "extError", res.extError, "localError", res.localError)
+ return outcomeFailed, nil
+ }
+ return writeAbsent(ctx, repo, item), nil
+ }
+ defer res.reader.Close()
+
+ readStart := time.Now()
+ data, err := readCapped(res.reader)
+ if err != nil {
+ log.Warn(ctx, "Artwork: Failed to read resolved image", "kind", item.ItemKind, "id", item.ItemID, "source", res.source, err)
+ return outcomeFailed, nil
+ }
+ log.Debug(ctx, "Artwork: Read resolved image", "kind", item.ItemKind, "id", item.ItemID,
+ "source", res.source, "bytes", len(data), "elapsed", time.Since(readStart))
+
+ hashStart := time.Now()
+ hash, err := hashImage(bytes.NewReader(data))
+ if err != nil {
+ log.Warn(ctx, "Artwork: Failed to hash image", "kind", item.ItemKind, "id", item.ItemID, err)
+ return outcomeFailed, nil
+ }
+ log.Trace(ctx, "Artwork: Hashed image", "kind", item.ItemKind, "id", item.ItemID,
+ "hash", hash, "bytes", len(data), "elapsed", time.Since(hashStart))
+
+ art, err := repo.GetImage(hash)
+ switch {
+ case err == nil:
+ log.Debug(ctx, "Artwork: Reusing a known image, skipping decode", "kind", item.ItemKind,
+ "id", item.ItemID, "hash", hash)
+ case errors.Is(err, model.ErrNotFound):
+ decodeStart := time.Now()
+ art, err = decodeArtwork(ctx, hash, data)
+ if err != nil {
+ log.Warn(ctx, "Artwork: Failed to decode resolved image", "kind", item.ItemKind, "id", item.ItemID, err)
+ return outcomeFailed, nil
+ }
+ log.Debug(ctx, "Artwork: Decoded new image", "kind", item.ItemKind, "id", item.ItemID, "hash", hash,
+ "width", art.Width, "height", art.Height, "mime", art.Mime, "elapsed", time.Since(decodeStart))
+ default:
+ log.Warn(ctx, "Artwork: Failed to look up image hash", "kind", item.ItemKind, "id", item.ItemID, err)
+ return outcomeFailed, nil
+ }
+ art.SizeBytes = int64(len(data))
+
+ ia, err := p.persist(repo, item, art, res, data)
+ if err != nil {
+ log.Warn(ctx, "Artwork: Failed to persist resolved image", "kind", item.ItemKind, "id", item.ItemID, err)
+ return outcomeFailed, nil
+ }
+ got = &acquired{ia: ia, mime: art.Mime, data: data}
+ if res.extError {
+ log.Debug(ctx, "Artwork: Serving a lower-priority source after an external failure",
+ "kind", item.ItemKind, "id", item.ItemID, "source", res.source)
+ return outcomeFoundStale, got
+ }
+ return outcomeFound, got
+}
+
+// persist places the bytes and commits the rows referencing them, excluding Prune for that
+// window only so a slow resolution can never hold it off.
+func (p *processor) persist(repo model.ArtworkRepository, item model.ArtworkQueueItem,
+ art *model.Artwork, res resolution, data []byte,
+) (*model.ItemArtwork, error) {
+ if p.pruneLock != nil {
+ p.pruneLock.Lock()
+ defer p.pruneLock.Unlock()
+ }
+ sourcePath, refMtime, err := placeBytes(p.store, art, res, data)
+ if err != nil {
+ return nil, fmt.Errorf("writing image store: %w", err)
+ }
+ if err := repo.PutImage(art); err != nil {
+ return nil, fmt.Errorf("persisting artwork image: %w", err)
+ }
+ ia := &model.ItemArtwork{
+ ItemKind: item.ItemKind,
+ ItemID: item.ItemID,
+ ImageType: item.ImageType,
+ Hash: art.Hash,
+ Source: res.source,
+ SourcePath: sourcePath,
+ RefMtime: refMtime,
+ AttemptedAt: time.Now(),
+ }
+ // PutItemArtwork stamps UpdatedAt on ia, so the returned struct matches the persisted row.
+ if err := repo.PutItemArtwork(ia); err != nil {
+ return nil, fmt.Errorf("persisting item artwork state: %w", err)
+ }
+ return ia, nil
+}
+
+// writeAbsent records a known-absent state: every source answered definitively "no".
+func writeAbsent(ctx context.Context, repo model.ArtworkRepository, item model.ArtworkQueueItem) outcome {
+ err := repo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: item.ItemKind,
+ ItemID: item.ItemID,
+ ImageType: item.ImageType,
+ AttemptedAt: time.Now(),
+ })
+ if err != nil {
+ log.Warn(ctx, "Artwork: Failed to persist absent state", "kind", item.ItemKind, "id", item.ItemID, err)
+ return outcomeFailed
+ }
+ log.Debug(ctx, "Artwork: Settled absent, every source answered definitively",
+ "kind", item.ItemKind, "id", item.ItemID)
+ return outcomeAbsent
+}
+
+func readCapped(r io.Reader) ([]byte, error) {
+ data, err := io.ReadAll(io.LimitReader(r, maxImageBytes+1))
+ if err != nil {
+ return nil, err
+ }
+ if len(data) > maxImageBytes {
+ return nil, fmt.Errorf("image exceeds size cap %d", maxImageBytes)
+ }
+ return data, nil
+}
+
+// decodeCapped rejects declared dimensions over maxImagePixels before the full-decode allocation.
+func decodeCapped(data []byte) (image.Image, string, error) {
+ cfg, format, err := image.DecodeConfig(bytes.NewReader(data))
+ if err != nil {
+ return nil, "", fmt.Errorf("decode image config: %w", err)
+ }
+ // Compared by division so the cap cannot be defeated by an int64 overflow.
+ if cfg.Width <= 0 || cfg.Height <= 0 || cfg.Width > maxImagePixels/cfg.Height {
+ return nil, "", fmt.Errorf("image dimensions %dx%d exceed pixel cap %d", cfg.Width, cfg.Height, maxImagePixels)
+ }
+ img, _, err := image.Decode(bytes.NewReader(data))
+ if err != nil {
+ return nil, "", fmt.Errorf("decode image: %w", err)
+ }
+ return img, format, nil
+}
+
+// decodeArtwork builds a new Artwork row from raw bytes: dimensions, mime and the two
+// placeholder hashes, both encoded from one shared downscaled thumbnail.
+func decodeArtwork(ctx context.Context, hash string, data []byte) (*model.Artwork, error) {
+ img, format, err := decodeCapped(data)
+ if err != nil {
+ return nil, err
+ }
+
+ thumb := makeThumbnail(img, thumbnailSize)
+ bh, err := blurhash.Encode(thumb)
+ if err != nil {
+ log.Warn(ctx, "Artwork: Blurhash encoding failed", "hash", hash, err)
+ bh = ""
+ }
+
+ var th string
+ if raw, err := thumbhash.Encode(thumb); err != nil {
+ log.Warn(ctx, "Artwork: Thumbhash encoding failed", "hash", hash, err)
+ } else {
+ th = base64.StdEncoding.EncodeToString(raw)
+ }
+
+ return &model.Artwork{
+ Hash: hash,
+ Mime: mimeForFormat(format),
+ Width: img.Bounds().Dx(),
+ Height: img.Bounds().Dy(),
+ BlurHash: bh,
+ ThumbHash: th,
+ DominantColor: dominant.Color(thumb),
+ }, nil
+}
+
+// makeThumbnail downscales img to fit within maxSize on its longest side; it never upscales.
+func makeThumbnail(img image.Image, maxSize int) image.Image {
+ b := img.Bounds()
+ w, h := b.Dx(), b.Dy()
+ if w <= maxSize && h <= maxSize {
+ return toFastScaleType(img)
+ }
+ scale := float64(maxSize) / float64(max(w, h))
+ // NRGBA, not RGBA: thumbhash requires straight alpha, and blurhash reads this type without
+ // converting, so neither encoder allocates a second copy of the thumbnail.
+ dst := image.NewNRGBA(image.Rect(0, 0, max(1, int(float64(w)*scale)), max(1, int(float64(h)*scale))))
+ xdraw.CatmullRom.Scale(dst, dst.Bounds(), toFastScaleType(img), b, draw.Src, nil)
+ return dst
+}
+
+// isFileBacked reports whether the bytes already live in a library/upload file, so the
+// content-addressed store must not duplicate them.
+func isFileBacked(source string) bool {
+ return source == "folder" || source == "upload"
+}
+
+// placeBytes reports the item's backing-file provenance and writes the bytes into the store
+// for the sources that have none.
+func placeBytes(store *ImageStore, art *model.Artwork, res resolution, data []byte) (sourcePath string, refMtime int64, err error) {
+ if isFileBacked(res.source) {
+ return res.sourcePath, res.refMtime, nil
+ }
+ if res.source == "embedded" {
+ sourcePath, refMtime = res.sourcePath, res.refMtime
+ }
+ return sourcePath, refMtime, store.Write(art.Hash, art.Mime, bytes.NewReader(data))
+}
+
+// mimeForFormat maps an image.Decode format name to its MIME type; extForMime is the inverse.
+func mimeForFormat(format string) string {
+ switch format {
+ case "jpeg":
+ return "image/jpeg"
+ case "png":
+ return "image/png"
+ case "gif":
+ return "image/gif"
+ case "webp":
+ return "image/webp"
+ }
+ return "application/octet-stream"
+}
diff --git a/core/artwork/processor_test.go b/core/artwork/processor_test.go
new file mode 100644
index 000000000..d326dde09
--- /dev/null
+++ b/core/artwork/processor_test.go
@@ -0,0 +1,495 @@
+package artwork
+
+import (
+ "context"
+ "encoding/binary"
+ "errors"
+ "hash/crc32"
+ "image"
+ "image/color"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "runtime"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// DecodeConfig reads only the header, so the pixel data can be omitted entirely.
+func pngHeaderWithDims(w, h uint32) []byte {
+ ihdr := make([]byte, 13)
+ binary.BigEndian.PutUint32(ihdr[0:], w)
+ binary.BigEndian.PutUint32(ihdr[4:], h)
+ ihdr[8] = 8 // bit depth
+ ihdr[9] = 2 // color type: truecolor
+ chunk := append([]byte("IHDR"), ihdr...)
+ out := []byte{0x89, 'P', 'N', 'G', 0x0d, 0x0a, 0x1a, 0x0a}
+ out = binary.BigEndian.AppendUint32(out, uint32(len(ihdr)))
+ out = append(out, chunk...)
+ return binary.BigEndian.AppendUint32(out, crc32.ChecksumIEEE(chunk))
+}
+
+var _ = Describe("processor.acquire", func() {
+ var (
+ ctx context.Context
+ ds *tests.MockDataStore
+ folderRepo *fakeFolderRepo
+ libRepo *tests.MockLibraryRepo
+ ffm *tests.MockFFmpeg
+ ag *agents.Agents
+ store *ImageStore
+ artRepo *tests.MockArtworkRepo
+ repoRoot string
+ proc *processor
+ )
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ ctx = context.Background()
+ var err error
+ repoRoot, err = os.Getwd()
+ Expect(err).ToNot(HaveOccurred())
+
+ folderRepo = &fakeFolderRepo{}
+ libRepo = &tests.MockLibraryRepo{}
+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})
+ ffm = tests.NewMockFFmpeg("")
+ ag = agents.GetAgents(&tests.MockDataStore{}, nil)
+ artRepo = tests.CreateMockArtworkRepo()
+ ds = &tests.MockDataStore{
+ MockedFolder: folderRepo,
+ MockedLibrary: libRepo,
+ MockedArtwork: artRepo,
+ }
+ ds.MockedAlbum = tests.CreateMockAlbumRepo()
+ store = NewImageStore(GinkgoT().TempDir())
+ proc = &processor{ds: ds, store: store, resolver: newResolver(ds, ag, ffm, nil)}
+
+ conf.Server.CoverArtPriority = "cover.jpg, embedded"
+ })
+
+ It("found-folder: persists state from a folder image, writes no store file, keeps sourcePath/refMtime", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al1", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al1"})
+ Expect(out).To(Equal(outcomeFound))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).ToNot(BeEmpty())
+ Expect(ia.Source).To(Equal("folder"))
+ Expect(filepath.ToSlash(ia.SourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/cover.jpg"))
+ Expect(ia.RefMtime).To(BeNumerically(">", 0))
+
+ art, err := artRepo.GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ // Every placeholder is derived from the one shared thumbnail, so all three land together.
+ Expect(art.BlurHash).ToNot(BeEmpty())
+ Expect(art.ThumbHash).ToNot(BeEmpty())
+ Expect(art.DominantColor).To(MatchRegexp(`^#[0-9a-f]{6}$`))
+ _, err = store.Open(ia.Hash, art.Mime)
+ Expect(os.IsNotExist(err)).To(BeTrue(), "folder-backed art must not be duplicated into the store")
+ })
+
+ Describe("prune lock scope", func() {
+ var lock *countingLocker
+
+ BeforeEach(func() {
+ lock = &countingLocker{}
+ proc.pruneLock = lock
+ })
+
+ It("holds it once across the write window", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "alL1", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alL1"})
+ Expect(out).To(Equal(outcomeFound))
+ Expect(lock.locks).To(BeNumerically(">", 0), "the write window must exclude prune")
+ Expect(lock.held()).To(BeFalse(), "the window must close before acquire returns")
+ })
+
+ // Resolution can reach the network, so holding the lock across it would let one slow
+ // provider block prune, and every drain queued behind prune's writer.
+ It("never takes it while only resolving", func() {
+ folderRepo.result = nil
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "alL2", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alL2"})
+ Expect(out).To(Equal(outcomeAbsent))
+ Expect(lock.locks).To(BeZero())
+ })
+ })
+
+ It("found-embedded: writes a store file and computes a non-empty blurhash from a real fixture", func() {
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al2", Name: "Album", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}},
+ })
+ folderRepo.result = nil
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al2"})
+ Expect(out).To(Equal(outcomeFound))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al2", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("embedded"))
+ Expect(filepath.ToSlash(ia.SourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/test.mp3"))
+
+ art, err := artRepo.GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(art.BlurHash).ToNot(BeEmpty())
+
+ rc, err := store.Open(ia.Hash, art.Mime)
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("absent: no local source and no external error persists a known-absent state", func() {
+ folderRepo.result = nil
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al3", Name: "Album"},
+ })
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al3"})
+ Expect(out).To(Equal(outcomeAbsent))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al3", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).To(BeEmpty())
+ Expect(ia.Source).To(BeEmpty())
+ Expect(ia.AttemptedAt).To(BeTemporally("~", time.Now(), time.Second))
+ })
+
+ It("failed-on-unreadable-local: a listed cover that will not open never records absent", func() {
+ conf.Server.CoverArtPriority = "cover.jpg"
+ // A folder listing that names a cover the FS will not hand over: a stale mount.
+ libRoot := GinkgoT().TempDir()
+ Expect(os.MkdirAll(filepath.Join(libRoot, "an-album"), 0o755)).To(Succeed())
+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(libRoot)}})
+ folderRepo.result = []model.Folder{{Path: "an-album", ImageFiles: []string{"cover.jpg"}}}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al-io", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al-io"})
+ Expect(out).To(Equal(outcomeFailed))
+
+ _, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al-io", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound), "an I/O fault must not be recorded as absent")
+ })
+
+ // An upload outranks every source, so an unreadable one must not let a lower one take over.
+ It("failed-on-unreadable-upload: an upload that will not open never records absent", func() {
+ if runtime.GOOS == "windows" {
+ // The file would still open, so the spec would pass on the decode error instead.
+ Skip("chmod does not restrict read access on Windows")
+ }
+ radioRepo := tests.CreateMockedRadioRepo()
+ radioRepo.Data = map[string]*model.Radio{}
+ ds.MockedRadio = radioRepo
+ dir := GinkgoT().TempDir()
+ conf.Server.DataFolder = conf.NewDir(dir)
+ upload := model.UploadedImagePath(consts.EntityRadio, "ra-io.jpg")
+ Expect(os.MkdirAll(filepath.Dir(upload), 0o755)).To(Succeed())
+ Expect(os.WriteFile(upload, []byte("x"), 0o600)).To(Succeed())
+ Expect(os.Chmod(upload, 0o000)).To(Succeed()) // present, but unreadable
+ DeferCleanup(func() { _ = os.Chmod(upload, 0o600) })
+ radioRepo.Data["ra-io"] = &model.Radio{ID: "ra-io", Name: "Station", UploadedImage: "ra-io.jpg"}
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "ra-io"})
+ Expect(out).To(Equal(outcomeFailed))
+
+ _, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra-io", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound), "an unreadable upload must not be recorded as absent")
+ })
+
+ It("failed-on-extError: leaves the item's state untouched", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al4", Name: "Album"},
+ })
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al4"})
+ Expect(out).To(Equal(outcomeFailed))
+
+ _, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al4", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+
+ It("found-stale: a fallback hit after a transient external failure persists state and returns outcomeFoundStale", func() {
+ conf.Server.CoverArtPriority = "external, cover.jpg"
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "alstale", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alstale"})
+ Expect(out).To(Equal(outcomeFoundStale))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alstale", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).ToNot(BeEmpty())
+ Expect(ia.Source).To(Equal("folder"))
+ })
+
+ It("found-external: persists source as external:<agentName> and stores the fetched bytes", func() {
+ conf.Server.CoverArtPriority = "external"
+ imgBytes, err := os.ReadFile(filepath.Join(repoRoot, "tests/fixtures/artist/an-album/cover.jpg"))
+ Expect(err).ToNot(HaveOccurred())
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ _, _ = w.Write(imgBytes)
+ }))
+ DeferCleanup(srv.Close)
+
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "alext", Name: "Album"}})
+ imageAgents(&fakeImageAgent{name: "deezerFake", imgs: []agents.ExternalImage{{URL: srv.URL, Size: 500}}})
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alext"})
+ Expect(out).To(Equal(outcomeFound))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alext", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("external:deezerFake"))
+ Expect(ia.Hash).ToNot(BeEmpty())
+
+ art, err := artRepo.GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ rc, err := store.Open(ia.Hash, art.Mime)
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("dedup: a second item with identical bytes skips decode and reuses the artwork row", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al5", Name: "Album A", FolderIDs: []string{"f1"}},
+ {ID: "al6", Name: "Album B", FolderIDs: []string{"f1"}},
+ })
+
+ out1, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al5"})
+ Expect(out1).To(Equal(outcomeFound))
+ ia1, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al5", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+
+ // A re-decode instead of a hash dedup would overwrite this sentinel.
+ poisoned := artRepo.Data[ia1.Hash]
+ poisoned.BlurHash = "SENTINEL"
+ artRepo.Data[ia1.Hash] = poisoned
+
+ out2, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al6"})
+ Expect(out2).To(Equal(outcomeFound))
+ ia2, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al6", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia2.Hash).To(Equal(ia1.Hash))
+
+ reused, err := artRepo.GetImage(ia1.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(reused.BlurHash).To(Equal("SENTINEL"))
+ })
+
+ It("two items, two files, identical bytes: each item keeps its own provenance; the shared artwork row is written once", func() {
+ // Byte-identical files share one hash, but provenance is per item.
+ libRoot := GinkgoT().TempDir()
+ imgBytes, err := os.ReadFile(filepath.Join(repoRoot, "tests/fixtures/artist/an-album/cover.jpg"))
+ Expect(err).ToNot(HaveOccurred())
+ for sub, mtime := range map[string]int64{"album-a": 1000, "album-b": 2000} {
+ dir := filepath.Join(libRoot, sub)
+ Expect(os.MkdirAll(dir, 0755)).To(Succeed())
+ img := filepath.Join(dir, "cover.jpg")
+ Expect(os.WriteFile(img, imgBytes, 0600)).To(Succeed())
+ Expect(os.Chtimes(img, time.Unix(mtime, 0), time.Unix(mtime, 0))).To(Succeed())
+ }
+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(libRoot)}})
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "alA", Name: "Album A", FolderIDs: []string{"fa"}},
+ {ID: "alB", Name: "Album B", FolderIDs: []string{"fb"}},
+ })
+
+ folderRepo.result = []model.Folder{{Path: "album-a", ImageFiles: []string{"cover.jpg"}}}
+ outN, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alA"})
+ Expect(outN).To(Equal(outcomeFound))
+ iaA, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alA", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(iaA.Source).To(Equal("folder"))
+ Expect(filepath.ToSlash(iaA.SourcePath)).To(HaveSuffix("album-a/cover.jpg"))
+ Expect(iaA.RefMtime).To(Equal(time.Unix(1000, 0).UnixNano()))
+
+ // A re-decode instead of a hash dedup would overwrite this sentinel.
+ poisoned := artRepo.Data[iaA.Hash]
+ poisoned.BlurHash = "SENTINEL"
+ artRepo.Data[iaA.Hash] = poisoned
+
+ folderRepo.result = []model.Folder{{Path: "album-b", ImageFiles: []string{"cover.jpg"}}}
+ outN, _ = proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alB"})
+ Expect(outN).To(Equal(outcomeFound))
+ iaB, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alB", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(iaB.Hash).To(Equal(iaA.Hash))
+ Expect(filepath.ToSlash(iaB.SourcePath)).To(HaveSuffix("album-b/cover.jpg"))
+ Expect(iaB.RefMtime).To(Equal(time.Unix(2000, 0).UnixNano()))
+
+ iaAafter, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alA", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(filepath.ToSlash(iaAafter.SourcePath)).To(HaveSuffix("album-a/cover.jpg"))
+ Expect(iaAafter.RefMtime).To(Equal(time.Unix(1000, 0).UnixNano()))
+
+ Expect(artRepo.Data).To(HaveLen(1))
+ reused, err := artRepo.GetImage(iaA.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(reused.BlurHash).To(Equal("SENTINEL"))
+ })
+
+ It("decode failure on found bytes: fails without writing state", func() {
+ tmpDir := GinkgoT().TempDir()
+ conf.Server.DataFolder = conf.NewDir(tmpDir)
+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "radio"), 0755)).To(Succeed())
+ imgPath := filepath.Join(tmpDir, "artwork", "radio", "ra1_test.jpg")
+ Expect(os.WriteFile(imgPath, []byte("not actually an image"), 0600)).To(Succeed())
+
+ radioRepo := tests.CreateMockedRadioRepo()
+ radioRepo.Data = map[string]*model.Radio{"ra1": {ID: "ra1", Name: "Radio", UploadedImage: "ra1_test.jpg"}}
+ ds.MockedRadio = radioRepo
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "ra1"})
+ Expect(out).To(Equal(outcomeFailed))
+
+ _, err := artRepo.GetItemArtwork(model.KindRadioArtwork, "ra1", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+
+ It("oversized read: a resolved image larger than the cap fails without writing state", func() {
+ tmpDir := GinkgoT().TempDir()
+ conf.Server.DataFolder = conf.NewDir(tmpDir)
+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "radio"), 0755)).To(Succeed())
+ imgPath := filepath.Join(tmpDir, "artwork", "radio", "big_test.jpg")
+ f, err := os.Create(imgPath)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(f.Truncate(maxImageBytes + 1)).To(Succeed())
+ Expect(f.Close()).To(Succeed())
+
+ radioRepo := tests.CreateMockedRadioRepo()
+ radioRepo.Data = map[string]*model.Radio{"big": {ID: "big", Name: "Radio", UploadedImage: "big_test.jpg"}}
+ ds.MockedRadio = radioRepo
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "big"})
+ Expect(out).To(Equal(outcomeFailed))
+
+ _, err = artRepo.GetItemArtwork(model.KindRadioArtwork, "big", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+
+ // The cap is compared by division so an overflowing product cannot slip past it; no supported
+ // format can declare these dimensions, so this pins the arithmetic, not a live hole.
+ DescribeTable("rejects out-of-range declared dimensions",
+ func(w, h uint32) {
+ _, err := decodeArtwork(ctx, "bomb", pngHeaderWithDims(w, h))
+ Expect(err).To(HaveOccurred())
+ },
+ Entry("both dimensions at the 32-bit maximum", uint32(0xffffffff), uint32(0xffffffff)),
+ Entry("both dimensions at the signed 32-bit maximum", uint32(0x7fffffff), uint32(0x7fffffff)),
+ Entry("zero width", uint32(0), uint32(100)),
+ Entry("zero height", uint32(100), uint32(0)),
+ )
+
+ It("decompression bomb: rejects huge declared dimensions before the full decode", func() {
+ data := pngHeaderWithDims(50000, 50000) // 2.5 gigapixels, far above the cap
+ _, err := decodeArtwork(ctx, "bomb", data)
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("dimensions"))
+ })
+
+ It("store write failure: fails without writing state", func() {
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al7", Name: "Album", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}},
+ })
+ folderRepo.result = nil
+
+ // A store root that is a plain file makes every MkdirAll under it fail.
+ blockedRoot := filepath.Join(GinkgoT().TempDir(), "not-a-dir")
+ Expect(os.WriteFile(blockedRoot, []byte("x"), 0600)).To(Succeed())
+ proc.store = NewImageStore(blockedRoot)
+
+ out, _ := proc.acquire(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al7"})
+ Expect(out).To(Equal(outcomeFailed))
+
+ _, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al7", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+})
+
+type countingLocker struct {
+ locks int
+ unlocks int
+}
+
+func (l *countingLocker) Lock() { l.locks++ }
+func (l *countingLocker) Unlock() { l.unlocks++ }
+func (l *countingLocker) held() bool { return l.locks != l.unlocks }
+
+var _ = Describe("makeThumbnail", func() {
+ // Both encoders read Pix directly and thumbhash needs straight alpha, so emitting NRGBA is
+ // what keeps either of them from allocating a converted copy of the thumbnail.
+ It("emits NRGBA when it downscales", func() {
+ src := image.NewRGBA(image.Rect(0, 0, 400, 300))
+ Expect(makeThumbnail(src, 100)).To(BeAssignableToTypeOf(&image.NRGBA{}))
+ })
+
+ It("fits the longest side to maxSize and keeps the aspect ratio", func() {
+ src := image.NewRGBA(image.Rect(0, 0, 400, 300))
+ b := makeThumbnail(src, 100).Bounds()
+ Expect(b.Dx()).To(Equal(100))
+ Expect(b.Dy()).To(Equal(75))
+ })
+
+ It("never upscales an image already within bounds", func() {
+ src := image.NewRGBA(image.Rect(0, 0, 40, 30))
+ Expect(makeThumbnail(src, 100).Bounds()).To(Equal(src.Bounds()))
+ })
+
+ // A fully transparent pixel's colour cannot survive any resample, since the scaler works in
+ // premultiplied space and multiplying by zero is not invertible. Partial alpha is the case
+ // that distinguishes straight storage from premultiplied.
+ It("keeps partly transparent colour straight rather than premultiplied", func() {
+ src := image.NewNRGBA(image.Rect(0, 0, 400, 400))
+ for y := range 400 {
+ for x := range 400 {
+ src.SetNRGBA(x, y, color.NRGBA{R: 200, G: 40, B: 90, A: 128})
+ }
+ }
+ thumb, ok := makeThumbnail(src, 100).(*image.NRGBA)
+ Expect(ok).To(BeTrue())
+ // Premultiplied storage would have halved this to ~100.
+ Expect(thumb.Pix[0]).To(BeNumerically("==", 200))
+ Expect(thumb.Pix[3]).To(BeNumerically("==", 128))
+ })
+})
diff --git a/core/artwork/prune.go b/core/artwork/prune.go
new file mode 100644
index 000000000..c79458b8f
--- /dev/null
+++ b/core/artwork/prune.go
@@ -0,0 +1,63 @@
+package artwork
+
+import (
+ "context"
+ "time"
+
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+)
+
+// pruneMinAge guards the window between artwork insert and item_artwork upsert.
+const pruneMinAge = time.Hour
+
+func prune(ctx context.Context, ds model.DataStore, store *ImageStore) error {
+ start := time.Now()
+ defer func() { log.Debug(ctx, "Artwork: Prune finished", "elapsed", time.Since(start)) }()
+ repo := ds.Artwork(ctx)
+
+ purged, err := repo.PurgeDanglingItems()
+ if err != nil {
+ return err
+ }
+ if purged > 0 {
+ log.Info(ctx, "Artwork: Purged dangling item state", "count", purged)
+ }
+
+ // Queue rows for deleted entities would otherwise retry forever (Get -> not found -> failed).
+ queuePurged, err := ds.ArtworkQueue(ctx).PurgeDangling()
+ if err != nil {
+ return err
+ }
+ if queuePurged > 0 {
+ log.Info(ctx, "Artwork: Purged dangling queue rows", "count", queuePurged)
+ }
+
+ // Files younger than the grace window may belong to acquisitions whose rows aren't committed yet.
+ cutoff := time.Now().Add(-pruneMinAge)
+ orphans, err := repo.PurgeOrphans(cutoff)
+ if err != nil {
+ return err
+ }
+ if orphans > 0 {
+ log.Info(ctx, "Artwork: Removed orphan image rows", "count", orphans)
+ }
+
+ // Read after the delete, so the sweep below reclaims the files of the rows just removed.
+ mimes, err := repo.GetMimeByHash()
+ if err != nil {
+ return err
+ }
+ removed, err := store.Sweep(ctx, cutoff, func(hash, ext string) bool {
+ // A known hash under a stale extension is a superseded mime variant — reclaim it.
+ m, ok := mimes[hash]
+ return ok && ext == extForMime(m)
+ })
+ if err != nil {
+ return err
+ }
+ if removed > 0 {
+ log.Info(ctx, "Artwork: Swept stray files", "count", removed)
+ }
+ return nil
+}
diff --git a/core/artwork/prune_test.go b/core/artwork/prune_test.go
new file mode 100644
index 000000000..8b8504f89
--- /dev/null
+++ b/core/artwork/prune_test.go
@@ -0,0 +1,239 @@
+package artwork
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "os"
+ "path/filepath"
+ "time"
+
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+type flakyGetArtworkRepo struct {
+ *tests.MockArtworkRepo
+}
+
+func (f *flakyGetArtworkRepo) GetMimeByHash() (map[string]string, error) {
+ return nil, errors.New("db locked")
+}
+
+var _ = Describe("Prune", func() {
+ var ds *tests.MockDataStore
+ var store *ImageStore
+ var awRepo *tests.MockArtworkRepo
+
+ BeforeEach(func() {
+ ds = &tests.MockDataStore{}
+ awRepo = ds.Artwork(context.Background()).(*tests.MockArtworkRepo)
+ store = NewImageStore(GinkgoT().TempDir())
+ })
+
+ // PutImage refreshes created_at like the SQL repo, so fixtures are aged directly.
+ ageArtwork := func(h string, t time.Time) {
+ a := awRepo.Data[h]
+ a.CreatedAt = t
+ awRepo.Data[h] = a
+ }
+
+ It("purges dangling item_artwork state for gone entities, summed across kinds", func() {
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "gone-album", ImageType: model.ImageTypePrimary})).To(Succeed())
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "gone-artist", ImageType: model.ImageTypePrimary})).To(Succeed())
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "live-artist", ImageType: model.ImageTypePrimary})).To(Succeed())
+ awRepo.ExistingIDs = map[string]map[string]bool{
+ "al": {},
+ "ar": {"live-artist": true},
+ }
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ _, err := awRepo.GetItemArtwork(model.KindAlbumArtwork, "gone-album", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ _, err = awRepo.GetItemArtwork(model.KindArtistArtwork, "gone-artist", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ _, err = awRepo.GetItemArtwork(model.KindArtistArtwork, "live-artist", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ })
+
+ It("purges dangling artwork_queue rows for gone entities", func() {
+ queueRepo := tests.CreateMockArtworkQueueRepo()
+ Expect(queueRepo.Enqueue(
+ model.ArtworkQueueItem{ItemKind: "al", ItemID: "gone-album", ImageType: model.ImageTypePrimary},
+ model.ArtworkQueueItem{ItemKind: "al", ItemID: "live-album", ImageType: model.ImageTypePrimary},
+ )).To(Succeed())
+ queueRepo.ExistingIDs = map[string]map[string]bool{"al": {"live-album": true}}
+ ds.MockedArtworkQueue = queueRepo
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ Expect(findQueued(queueRepo, "al", "gone-album")).To(BeNil())
+ Expect(findQueued(queueRepo, "al", "live-album")).ToNot(BeNil())
+ })
+
+ It("deletes orphan rows and their store files, keeps referenced ones", func() {
+ data := []byte("orphan-bytes")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())
+ old := time.Now().Add(-2 * time.Hour)
+ Expect(os.Chtimes(store.path(h, "image/jpeg"), old, old)).To(Succeed())
+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())
+ ageArtwork(h, old)
+
+ kept := []byte("kept-bytes")
+ hk, _ := hashImage(bytes.NewReader(kept))
+ Expect(store.Write(hk, "image/jpeg", bytes.NewReader(kept))).To(Succeed())
+ Expect(awRepo.PutImage(&model.Artwork{Hash: hk, Mime: "image/jpeg"})).To(Succeed())
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ _, err := awRepo.GetImage(h)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ _, err = store.Open(h, "image/jpeg")
+ Expect(os.IsNotExist(err)).To(BeTrue())
+ rc, err := store.Open(hk, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("spares an aged row that item_artwork state still references", func() {
+ data := []byte("reacquired-bytes")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())
+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())
+ ageArtwork(h, time.Now().Add(-2*time.Hour))
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "a1",
+ ImageType: model.ImageTypePrimary, Hash: h, Source: "folder"})).To(Succeed())
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ _, err := awRepo.GetImage(h)
+ Expect(err).ToNot(HaveOccurred())
+ rc, err := store.Open(h, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("spares an unreferenced row recreated inside the grace window", func() {
+ data := []byte("fresh-reacquired-bytes")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())
+ // Reacquisition refreshed created_at, so the row is unreferenced but too young to drop.
+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ _, err := awRepo.GetImage(h)
+ Expect(err).ToNot(HaveOccurred())
+ rc, err := store.Open(h, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("spares an orphan file freshly touched by an overlapping acquisition", func() {
+ data := []byte("racing-bytes")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())
+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())
+ ageArtwork(h, time.Now().Add(-2*time.Hour))
+ // The row is orphaned, but a concurrent acquisition just touched the file's mtime.
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ rc, err := store.Open(h, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("sweeps store files that have no artwork row", func() {
+ stray := []byte("no-row-bytes")
+ h, _ := hashImage(bytes.NewReader(stray))
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(stray))).To(Succeed())
+ old := time.Now().Add(-2 * time.Hour)
+ Expect(os.Chtimes(store.path(h, "image/jpeg"), old, old)).To(Succeed())
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ _, err := store.Open(h, "image/jpeg")
+ Expect(os.IsNotExist(err)).To(BeTrue())
+ })
+
+ It("sweeps an obsolete mime variant of a reacquired hash", func() {
+ data := []byte("variant-bytes")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/png", bytes.NewReader(data))).To(Succeed())
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())
+ old := time.Now().Add(-2 * time.Hour)
+ Expect(os.Chtimes(store.path(h, "image/png"), old, old)).To(Succeed())
+ Expect(os.Chtimes(store.path(h, "image/jpeg"), old, old)).To(Succeed())
+ // The row records the current mime; the .png file is a superseded variant.
+ Expect(awRepo.PutImage(&model.Artwork{Hash: h, Mime: "image/jpeg"})).To(Succeed())
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ _, err := store.Open(h, "image/png")
+ Expect(os.IsNotExist(err)).To(BeTrue())
+ rc, err := store.Open(h, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("reclaims the other orphan files when one of them cannot be removed", func() {
+ tests.SkipOnWindows("uses Unix file permission bits")
+ if os.Geteuid() == 0 {
+ Skip("read-only dir cannot block root (e.g. tests in a container)")
+ }
+ old := time.Now().Add(-2 * time.Hour)
+
+ blocked := []byte("blocked-bytes")
+ hb, _ := hashImage(bytes.NewReader(blocked))
+ Expect(store.Write(hb, "image/jpeg", bytes.NewReader(blocked))).To(Succeed())
+ Expect(os.Chtimes(store.path(hb, "image/jpeg"), old, old)).To(Succeed())
+ Expect(awRepo.PutImage(&model.Artwork{Hash: hb, Mime: "image/jpeg"})).To(Succeed())
+ ageArtwork(hb, old)
+
+ good := []byte("good-bytes")
+ hg, _ := hashImage(bytes.NewReader(good))
+ Expect(store.Write(hg, "image/jpeg", bytes.NewReader(good))).To(Succeed())
+ Expect(os.Chtimes(store.path(hg, "image/jpeg"), old, old)).To(Succeed())
+ Expect(awRepo.PutImage(&model.Artwork{Hash: hg, Mime: "image/jpeg"})).To(Succeed())
+ ageArtwork(hg, old)
+
+ // A read-only shard directory makes os.Remove fail (EACCES) for hb's file only.
+ shardDir := filepath.Dir(store.path(hb, "image/jpeg"))
+ Expect(shardDir).ToNot(Equal(filepath.Dir(store.path(hg, "image/jpeg"))), "fixtures must land in different shards")
+ Expect(os.Chmod(shardDir, 0500)).To(Succeed())
+ DeferCleanup(func() { _ = os.Chmod(shardDir, 0755) })
+
+ Expect(prune(context.Background(), ds, store)).To(Succeed())
+
+ _, err := awRepo.GetImage(hg)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ _, err = store.Open(hg, "image/jpeg")
+ Expect(os.IsNotExist(err)).To(BeTrue())
+
+ // The row purge does not depend on file removal, so only the file survives.
+ _, err = awRepo.GetImage(hb)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ rc, err := store.Open(hb, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+
+ It("never sweeps files on a transient DB error", func() {
+ ds.MockedArtwork = &flakyGetArtworkRepo{MockArtworkRepo: tests.CreateMockArtworkRepo()}
+
+ data := []byte("live-bytes")
+ h, _ := hashImage(bytes.NewReader(data))
+ Expect(store.Write(h, "image/jpeg", bytes.NewReader(data))).To(Succeed())
+
+ Expect(prune(context.Background(), ds, store)).ToNot(Succeed())
+
+ rc, err := store.Open(h, "image/jpeg")
+ Expect(err).ToNot(HaveOccurred())
+ rc.Close()
+ })
+})
diff --git a/core/artwork/reader_album_test.go b/core/artwork/reader_album_test.go
deleted file mode 100644
index c95ddedaa..000000000
--- a/core/artwork/reader_album_test.go
+++ /dev/null
@@ -1,481 +0,0 @@
-package artwork
-
-import (
- "context"
- "errors"
- "path/filepath"
- "time"
-
- "github.com/navidrome/navidrome/model"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("Album Artwork Reader", func() {
- Describe("loadAlbumFoldersPaths", func() {
- var (
- ctx context.Context
- ds *fakeDataStore
- repo *fakeFolderRepo
- album model.Album
- now time.Time
- expectedAt time.Time
- )
-
- BeforeEach(func() {
- ctx = context.Background()
- now = time.Now().Truncate(time.Second)
- expectedAt = now.Add(5 * time.Minute)
-
- // Set up the test folders with image files
- repo = &fakeFolderRepo{}
- ds = &fakeDataStore{
- folderRepo: repo,
- }
- album = model.Album{
- ID: "album1",
- Name: "Album",
- FolderIDs: []string{"folder1", "folder2", "folder3"},
- }
- })
-
- It("returns sorted image files", func() {
- repo.result = []model.Folder{
- {
- Path: "Artist/Album/Disc1",
- ImagesUpdatedAt: expectedAt,
- ImageFiles: []string{"cover.jpg", "back.jpg", "cover.1.jpg"},
- },
- {
- Path: "Artist/Album/Disc2",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- {
- Path: "Artist/Album/Disc10",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- }
-
- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(*imagesUpdatedAt).To(Equal(expectedAt))
-
- // Check that image files are sorted by base name (without extension)
- Expect(imgFiles).To(HaveLen(5))
-
- // Files should be sorted by base filename without extension, then by full path
- // "back" < "cover", so back.jpg comes first
- // Then all cover.jpg files, sorted by path
- Expect(imgFiles[0]).To(Equal("Artist/Album/Disc1/back.jpg"))
- Expect(imgFiles[1]).To(Equal("Artist/Album/Disc1/cover.jpg"))
- Expect(imgFiles[2]).To(Equal("Artist/Album/Disc2/cover.jpg"))
- Expect(imgFiles[3]).To(Equal("Artist/Album/Disc10/cover.jpg"))
- Expect(imgFiles[4]).To(Equal("Artist/Album/Disc1/cover.1.jpg"))
- })
-
- It("prioritizes files without numeric suffixes", func() {
- // Test case for issue #4683: cover.jpg should come before cover.1.jpg
- repo.result = []model.Folder{
- {
- Path: "Artist/Album",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.1.jpg", "cover.jpg", "cover.2.jpg"},
- },
- }
-
- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgFiles).To(HaveLen(3))
-
- // cover.jpg should come first because "cover" < "cover.1" < "cover.2"
- Expect(imgFiles[0]).To(Equal("Artist/Album/cover.jpg"))
- Expect(imgFiles[1]).To(Equal("Artist/Album/cover.1.jpg"))
- Expect(imgFiles[2]).To(Equal("Artist/Album/cover.2.jpg"))
- })
-
- It("handles case-insensitive sorting", func() {
- // Test that Cover.jpg and cover.jpg are treated as equivalent
- repo.result = []model.Folder{
- {
- Path: "Artist/Album",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"Folder.jpg", "cover.jpg", "BACK.jpg"},
- },
- }
-
- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgFiles).To(HaveLen(3))
-
- // Files should be sorted case-insensitively: BACK, cover, Folder
- Expect(imgFiles[0]).To(Equal("Artist/Album/BACK.jpg"))
- Expect(imgFiles[1]).To(Equal("Artist/Album/cover.jpg"))
- Expect(imgFiles[2]).To(Equal("Artist/Album/Folder.jpg"))
- })
-
- It("includes images from parent folder for multi-disc albums", func() {
- // Simulates: Artist/Album/cover.jpg with tracks in Artist/Album/CD1/ and Artist/Album/CD2/
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist/Album",
- Name: "CD1",
- ParentID: "parentFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- {
- ID: "folder2",
- Path: "Artist/Album",
- Name: "CD2",
- ParentID: "parentFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
- repo.parentResult = &model.Folder{
- ID: "parentFolder",
- Path: "Artist",
- Name: "Album",
- ParentID: "artistFolder",
- ImagesUpdatedAt: expectedAt,
- ImageFiles: []string{"cover.jpg", "back.jpg"},
- }
-
- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(*imagesUpdatedAt).To(Equal(expectedAt))
- Expect(imgFiles).To(HaveLen(2))
- Expect(imgFiles[0]).To(Equal("Artist/Album/back.jpg"))
- Expect(imgFiles[1]).To(Equal("Artist/Album/cover.jpg"))
- })
-
- It("does not query parent when parent ID is already in album folders", func() {
- // When the parent folder is already one of the album's folders, skip it
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist",
- Name: "Album",
- ParentID: "folder2",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- {
- ID: "folder2",
- Path: "",
- Name: "Artist",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
-
- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgFiles).To(HaveLen(1))
- Expect(imgFiles[0]).To(Equal("Artist/Album/cover.jpg"))
- // Get should not have been called (parent already in folder set)
- Expect(repo.getCallCount).To(Equal(0))
- })
-
- It("does not query parent when folders have different parents", func() {
- // When album folders span different parents, don't search any parent
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist1/Album",
- Name: "part1",
- ParentID: "parentA",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- {
- ID: "folder2",
- Path: "Artist2/Album",
- Name: "part2",
- ParentID: "parentB",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
-
- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgFiles).To(HaveLen(1))
- Expect(imgFiles[0]).To(Equal("Artist1/Album/part1/cover.jpg"))
- // Get should not have been called (different parents)
- Expect(repo.getCallCount).To(Equal(0))
- })
-
- It("does not include library root parent for multi-folder albums", func() {
- // Two album parts directly under the library root — parent is the root itself
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: ".",
- Name: "AlbumPart1",
- ParentID: "rootFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- {
- ID: "folder2",
- Path: ".",
- Name: "AlbumPart2",
- ParentID: "rootFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
- repo.parentResult = &model.Folder{
- ID: "rootFolder",
- Path: "",
- Name: ".",
- ParentID: "",
- ImageFiles: []string{"unrelated.jpg"},
- }
-
- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgFiles).To(HaveLen(1))
- Expect(imgFiles[0]).To(Equal("AlbumPart1/cover.jpg"))
- Expect(repo.getCallCount).To(Equal(1))
- })
-
- It("includes top-level album folder for multi-disc albums", func() {
- // Album folder directly under library root, with disc subfolders
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Album",
- Name: "Disc1",
- ParentID: "albumFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"folder.jpg"},
- },
- {
- ID: "folder2",
- Path: "Album",
- Name: "Disc2",
- ParentID: "albumFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"folder.jpg"},
- },
- }
- repo.parentResult = &model.Folder{
- ID: "albumFolder",
- Path: ".",
- Name: "Album",
- ParentID: "rootFolder",
- ImagesUpdatedAt: expectedAt,
- ImageFiles: []string{"cover.jpg"},
- }
-
- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(*imagesUpdatedAt).To(Equal(expectedAt))
- Expect(imgFiles).To(HaveLen(3))
- Expect(imgFiles[0]).To(Equal("Album/cover.jpg"))
- Expect(imgFiles[1]).To(Equal("Album/Disc1/folder.jpg"))
- Expect(imgFiles[2]).To(Equal("Album/Disc2/folder.jpg"))
- Expect(repo.getCallCount).To(Equal(1))
- })
-
- It("does not query parent for single-folder albums that already have images", func() {
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist",
- Name: "Album",
- ParentID: "artistFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- }
-
- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgFiles).To(HaveLen(1))
- Expect(imgFiles[0]).To(Equal("Artist/Album/cover.jpg"))
- Expect(repo.getCallCount).To(Equal(0))
- })
-
- It("includes parent images for single-disc-subfolder albums", func() {
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist/Album",
- Name: "disc1",
- ParentID: "albumFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
- repo.parentResult = &model.Folder{
- ID: "albumFolder",
- Path: "Artist",
- Name: "Album",
- ParentID: "artistFolder",
- ImagesUpdatedAt: expectedAt,
- ImageFiles: []string{"cover.jpg"},
- }
-
- _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(*imagesUpdatedAt).To(Equal(expectedAt))
- Expect(imgFiles).To(HaveLen(1))
- Expect(imgFiles[0]).To(Equal("Artist/Album/cover.jpg"))
- Expect(repo.getCallCount).To(Equal(1))
- })
-
- It("promotes the album root parent into the returned paths", func() {
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist",
- Name: "Album",
- ParentID: "artistFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
- repo.parentResult = &model.Folder{
- ID: "artistFolder",
- Path: ".",
- Name: "Artist",
- ParentID: "libraryRoot",
- ImagesUpdatedAt: expectedAt,
- ImageFiles: []string{"folder.jpg"},
- }
-
- paths, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(paths).To(Equal([]string{filepath.Join("Artist", "Album"), "Artist"}))
- })
-
- It("does not include parent images when other albums' audio lives under the parent", func() {
- // Simulates: Artist/folder.jpg with Artist/Album (no images) and
- // another album's tracks elsewhere under the artist folder
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist",
- Name: "Album",
- ParentID: "artistFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
- repo.parentResult = &model.Folder{
- ID: "artistFolder",
- Path: ".",
- Name: "Artist",
- ParentID: "libraryRoot",
- ImagesUpdatedAt: expectedAt,
- ImageFiles: []string{"folder.jpg"},
- }
- repo.hasOtherAudio = true
-
- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgFiles).To(BeEmpty())
- })
-
- It("propagates errors from the album-root check", func() {
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist/Album",
- Name: "disc1",
- ParentID: "albumFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
- repo.parentResult = &model.Folder{
- ID: "albumFolder",
- Path: "Artist",
- Name: "Album",
- ParentID: "artistFolder",
- ImagesUpdatedAt: expectedAt,
- ImageFiles: []string{"cover.jpg"},
- }
- repo.otherAudioErr = errors.New("db connection failed")
-
- _, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).To(MatchError("db connection failed"))
- })
-
- It("propagates non-ErrNotFound errors from parent folder lookup", func() {
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist/Album",
- Name: "CD1",
- ParentID: "parentFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- {
- ID: "folder2",
- Path: "Artist/Album",
- Name: "CD2",
- ParentID: "parentFolder",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
- repo.getErr = errors.New("db connection failed")
-
- _, _, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).To(MatchError("db connection failed"))
- Expect(repo.getCallCount).To(Equal(1))
- })
-
- It("continues gracefully when parent folder is not found", func() {
- // Parent folder may have been deleted; should log a warning and continue
- repo.result = []model.Folder{
- {
- ID: "folder1",
- Path: "Artist/Album",
- Name: "CD1",
- ParentID: "missingParent",
- ImagesUpdatedAt: now,
- ImageFiles: []string{"cover.jpg"},
- },
- {
- ID: "folder2",
- Path: "Artist/Album",
- Name: "CD2",
- ParentID: "missingParent",
- ImagesUpdatedAt: now,
- ImageFiles: []string{},
- },
- }
- // parentResult is nil, so Get will return ErrNotFound
-
- _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, ds, album)
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgFiles).To(HaveLen(1))
- Expect(imgFiles[0]).To(Equal("Artist/Album/CD1/cover.jpg"))
- Expect(repo.getCallCount).To(Equal(1))
- })
- })
-})
diff --git a/core/artwork/reader_artist.go b/core/artwork/reader_artist.go
deleted file mode 100644
index fe5bcb196..000000000
--- a/core/artwork/reader_artist.go
+++ /dev/null
@@ -1,359 +0,0 @@
-package artwork
-
-import (
- "context"
- "crypto/md5"
- "fmt"
- "io"
- "io/fs"
- "os"
- "path"
- "path/filepath"
- "slices"
- "strings"
- "time"
-
- "github.com/Masterminds/squirrel"
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/core"
- "github.com/navidrome/navidrome/core/external"
- "github.com/navidrome/navidrome/log"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/utils/slice"
- "github.com/navidrome/navidrome/utils/str"
-)
-
-const (
- // maxArtistFolderTraversalDepth defines how many directory levels to search
- // when looking for artist images (artist folder + parent directories)
- maxArtistFolderTraversalDepth = 3
-)
-
-type artistReader struct {
- cacheKey
- a *artwork
- provider external.Provider
- artist model.Artist
- artistFolder string
- imgFiles []string
- imgFolderImgPath string // cached path from ArtistImageFolder lookup
- lib libraryView
-}
-
-func newArtistArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID, provider external.Provider) (*artistReader, error) {
- ar, err := artwork.ds.Artist(ctx).Get(artID.ID)
- if err != nil {
- return nil, err
- }
- // Only consider albums where the artist is the sole album artist.
- als, err := artwork.ds.Album(ctx).GetAll(model.QueryOptions{
- Filters: squirrel.And{
- squirrel.Eq{"album_artist_id": artID.ID},
- squirrel.Eq{"json_array_length(participants, '$.albumartist')": 1},
- },
- })
- if err != nil {
- return nil, err
- }
- albumPaths, imgFiles, imagesUpdatedAt, err := loadArtistAlbumRoots(ctx, artwork.ds, als)
- if err != nil {
- return nil, err
- }
- artistFolder, artistFolderLastUpdate, err := loadArtistFolder(ctx, artwork.ds, als, albumPaths)
- if err != nil {
- return nil, err
- }
- var lib libraryView
- if len(als) > 0 {
- lib, err = loadLibraryView(ctx, artwork.ds, als[0].LibraryID)
- if err != nil {
- return nil, err
- }
- }
- a := &artistReader{
- a: artwork,
- provider: provider,
- artist: *ar,
- artistFolder: artistFolder,
- imgFiles: imgFiles,
- lib: lib,
- }
- // TODO Find a way to factor in the ExternalUpdateInfoAt in the cache key. Problem is that it can
- // change _after_ retrieving from external sources, making the key invalid
- //a.cacheKey.lastUpdate = ar.ExternalInfoUpdatedAt
-
- a.cacheKey.lastUpdate = *imagesUpdatedAt
- if ar.UpdatedAt != nil && ar.UpdatedAt.After(a.cacheKey.lastUpdate) {
- a.cacheKey.lastUpdate = *ar.UpdatedAt
- }
- if artistFolderLastUpdate.After(a.cacheKey.lastUpdate) {
- a.cacheKey.lastUpdate = artistFolderLastUpdate
- }
- if conf.Server.ArtistImageFolder != "" && strings.Contains(strings.ToLower(conf.Server.ArtistArtPriority), "image-folder") {
- a.imgFolderImgPath = findImageInArtistFolder(conf.Server.ArtistImageFolder, ar.MbzArtistID, ar.Name)
- if a.imgFolderImgPath != "" {
- if info, err := os.Stat(a.imgFolderImgPath); err == nil && info.ModTime().After(a.cacheKey.lastUpdate) {
- a.cacheKey.lastUpdate = info.ModTime()
- }
- }
- }
- a.cacheKey.artID = artID
- return a, nil
-}
-
-func (a *artistReader) Key() string {
- hash := md5.Sum([]byte(conf.Server.Agents))
- return fmt.Sprintf(
- "%s.%t.%x",
- a.cacheKey.Key(),
- conf.Server.EnableExternalServices,
- hash,
- )
-}
-
-func (a *artistReader) LastUpdated() time.Time {
- return a.lastUpdate
-}
-
-func (a *artistReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
- ff := []sourceFunc{a.fromArtistUploadedImage()}
- ff = append(ff, a.fromArtistArtPriority(ctx, conf.Server.ArtistArtPriority)...)
- return selectImageReader(ctx, a.artID, ff...)
-}
-
-func (a *artistReader) fromArtistUploadedImage() sourceFunc {
- return fromLocalFile(a.artist.UploadedImagePath())
-}
-
-func (a *artistReader) fromArtistArtPriority(ctx context.Context, priority string) []sourceFunc {
- var ff []sourceFunc
- for pattern := range strings.SplitSeq(strings.ToLower(priority), ",") {
- pattern = strings.TrimSpace(pattern)
- switch {
- case pattern == "external":
- ff = append(ff, fromArtistExternalSource(ctx, a.artist, a.provider))
- case pattern == "image-folder":
- ff = append(ff, a.fromArtistImageFolder(ctx))
- case strings.HasPrefix(pattern, "album/"):
- if a.lib.FS != nil {
- ff = append(ff, fromExternalFile(ctx, a.lib.FS, a.imgFiles, strings.TrimPrefix(pattern, "album/")))
- }
- default:
- ff = append(ff, fromArtistFolder(ctx, a.lib.FS, a.lib.absRoot, a.artistFolder, pattern))
- }
- }
- return ff
-}
-
-// fromArtistFolder walks up from artistFolder toward libPath looking for a
-// file matching pattern. Traversal is bounded by both maxArtistFolderTraversalDepth
-// and the library root: once we reach libPath (or if artistFolder is outside
-// libPath), the walk stops. All reads go through libFS, which keeps artwork
-// resolution scoped to the configured library.
-func fromArtistFolder(ctx context.Context, libFS fs.FS, libPath, artistFolder, pattern string) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- if libFS == nil {
- return nil, "", fmt.Errorf("artist folder lookup unavailable")
- }
- rel, err := filepath.Rel(libPath, artistFolder)
- if err != nil || rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
- return nil, "", fmt.Errorf(`artist folder '%s' is outside library '%s'`, artistFolder, libPath)
- }
- // fs.Glob / path.Join below expect forward-slash paths; filepath.Rel may
- // return backslash separators on Windows.
- rel = filepath.ToSlash(rel)
- current := artistFolder
- for range maxArtistFolderTraversalDepth {
- reader, hit, err := findImageInFolder(ctx, libFS, rel, current, pattern)
- if err == nil {
- return reader, hit, nil
- }
- if rel == "." {
- break // reached library root; don't traverse above it
- }
- rel = path.Dir(rel)
- current = filepath.Dir(current)
- }
- return nil, "", fmt.Errorf(`no matches for '%s' in '%s' or its parent directories (within library)`, pattern, artistFolder)
- }
-}
-
-// findImageInFolder globs libFS at relFolder for pattern and returns the first
-// matching image. absFolder is used only for the returned display path and log
-// messages so callers see absolute-looking paths consistent with the rest of
-// the artwork pipeline.
-func findImageInFolder(ctx context.Context, libFS fs.FS, relFolder, absFolder, pattern string) (io.ReadCloser, string, error) {
- log.Trace(ctx, "looking for artist image", "pattern", pattern, "folder", absFolder)
- globPattern := pattern
- if relFolder != "." {
- globPattern = path.Join(escapeGlobLiteral(relFolder), pattern)
- }
- matches, err := fs.Glob(libFS, globPattern)
- if err != nil {
- log.Warn(ctx, "Error matching artist image pattern", "pattern", pattern, "folder", absFolder, err)
- return nil, "", err
- }
-
- // Filter to valid image files
- var imagePaths []string
- for _, m := range matches {
- if !model.IsImageFile(m) {
- continue
- }
- imagePaths = append(imagePaths, m)
- }
-
- // Sort image files by prioritizing base filenames without numeric
- // suffixes (e.g., artist.jpg before artist.1.jpg)
- slices.SortFunc(imagePaths, compareImageFiles)
-
- for _, p := range imagePaths {
- f, err := libFS.Open(p)
- if err != nil {
- log.Warn(ctx, "Could not open cover art file", "file", p, err)
- continue
- }
- _, name := path.Split(p)
- return f, filepath.Join(absFolder, name), nil
- }
-
- return nil, "", fmt.Errorf(`no matches for '%s' in '%s'`, pattern, absFolder)
-}
-
-func escapeGlobLiteral(s string) string {
- var b strings.Builder
- b.Grow(len(s))
- for _, r := range s {
- switch r {
- case '\\', '*', '?', '[', ']':
- b.WriteByte('\\')
- }
- b.WriteRune(r)
- }
- return b.String()
-}
-
-// loadArtistAlbumRoots returns one path per album — the deepest folder holding
-// all of that album's tracks — so an album split into disc subfolders can't
-// pull the artist folder's common prefix below the artist level.
-func loadArtistAlbumRoots(ctx context.Context, ds model.DataStore, albums model.Albums) ([]string, []string, *time.Time, error) {
- var folderIDs []string
- for _, album := range albums {
- folderIDs = append(folderIDs, album.FolderIDs...)
- }
- folders, err := loadFolders(ctx, ds, folderIDs)
- if err != nil {
- return nil, nil, nil, err
- }
-
- pathByID := slice.ToMap(folders, func(f model.Folder) (string, string) {
- return f.ID, f.AbsolutePath()
- })
- var roots []string
- for _, album := range albums {
- var albumPaths []string
- for _, fid := range album.FolderIDs {
- if p, ok := pathByID[fid]; ok {
- albumPaths = append(albumPaths, p)
- }
- }
- if len(albumPaths) > 0 {
- roots = append(roots, commonDir(albumPaths))
- }
- }
-
- imgFiles, updatedAt := folderImages(folders)
- return roots, imgFiles, &updatedAt, nil
-}
-
-// commonDir returns the deepest directory containing all paths. Trailing
-// separators keep the comparison on segment boundaries, so a shared name
-// fragment (".../Album" and ".../Album2") is never read as a shared directory.
-func commonDir(paths []string) string {
- sep := string(filepath.Separator)
- common := str.LongestCommonPrefix(slice.Map(paths, func(p string) string { return p + sep }))
- if !strings.HasSuffix(common, sep) {
- common, _ = filepath.Split(common)
- }
- return filepath.Clean(common)
-}
-
-func loadArtistFolder(ctx context.Context, ds model.DataStore, albums model.Albums, paths []string) (string, time.Time, error) {
- if len(albums) == 0 {
- return "", time.Time{}, nil
- }
- libID := albums[0].LibraryID // Just need one of the albums, as they should all be in the same Library - for now! TODO: Support multiple libraries
-
- // paths holds one root per album: two or more distinct roots already meet at
- // the artist folder, while a single root is an album folder needing a climb.
- roots := slices.Compact(slices.Sorted(slices.Values(paths)))
- folderPath := commonDir(roots)
- if len(roots) < 2 {
- folderPath = filepath.Dir(folderPath)
- }
-
- // Manipulate the path to get the folder ID
- // TODO: This is a bit hacky, but it's the easiest way to get the folder ID, ATM
- libPath := core.AbsolutePath(ctx, ds, libID, "")
- folderID := model.FolderID(model.Library{ID: libID, Path: libPath}, folderPath)
-
- log.Trace(ctx, "Calculating artist folder details", "folderPath", folderPath, "folderID", folderID,
- "libPath", libPath, "libID", libID, "albumPaths", paths)
-
- // Get the last update time for the folder
- folders, err := ds.Folder(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"folder.id": folderID, "missing": false}})
- if err != nil || len(folders) == 0 {
- log.Warn(ctx, "Could not find folder for artist", "folderPath", folderPath, "id", folderID,
- "libPath", libPath, "libID", libID, err)
- return "", time.Time{}, err
- }
- return folderPath, folders[0].ImagesUpdatedAt, nil
-}
-
-func (a *artistReader) fromArtistImageFolder(ctx context.Context) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- folder := conf.Server.ArtistImageFolder
- if folder == "" {
- return nil, "", nil
- }
- // Use cached path from newArtistArtworkReader if available,
- // avoiding a second directory scan.
- path := a.imgFolderImgPath
- if path == "" {
- path = findImageInArtistFolder(folder, a.artist.MbzArtistID, a.artist.Name)
- }
- if path == "" {
- return nil, "", fmt.Errorf("no image found for artist %q in %s", a.artist.Name, folder)
- }
- f, err := os.Open(path)
- if err != nil {
- return nil, "", err
- }
- return f, path, nil
- }
-}
-
-// findImageInArtistFolder scans a folder for an image file matching the artist's MBID or name
-// (case-insensitive). Returns the full path, or empty string if not found.
-func findImageInArtistFolder(folder, mbzArtistID, artistName string) string {
- entries, err := os.ReadDir(folder)
- if err != nil {
- return ""
- }
- for _, candidate := range []string{mbzArtistID, artistName} {
- if candidate == "" {
- continue
- }
- for _, entry := range entries {
- if entry.IsDir() {
- continue
- }
- name := entry.Name()
- base := strings.TrimSuffix(name, filepath.Ext(name))
- if strings.EqualFold(base, candidate) && model.IsImageFile(name) {
- return filepath.Join(folder, name)
- }
- }
- }
- return ""
-}
diff --git a/core/artwork/reader_artist_test.go b/core/artwork/reader_artist_test.go
deleted file mode 100644
index c75f8447e..000000000
--- a/core/artwork/reader_artist_test.go
+++ /dev/null
@@ -1,761 +0,0 @@
-package artwork
-
-import (
- "context"
- "errors"
- "io"
- "io/fs"
- "os"
- "path/filepath"
- "time"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/core"
- "github.com/navidrome/navidrome/model"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("artistArtworkReader", func() {
- var _ = Describe("loadArtistFolder", func() {
- var (
- ctx context.Context
- fds *fakeDataStore
- repo *fakeFolderRepo
- albums model.Albums
- paths []string
- now time.Time
- expectedUpdTime time.Time
- )
-
- BeforeEach(func() {
- ctx = context.Background()
- DeferCleanup(stubCoreAbsolutePath())
-
- now = time.Now().Truncate(time.Second)
- expectedUpdTime = now.Add(5 * time.Minute)
- repo = &fakeFolderRepo{
- result: []model.Folder{
- {
- ImagesUpdatedAt: expectedUpdTime,
- },
- },
- err: nil,
- }
- fds = &fakeDataStore{
- folderRepo: repo,
- }
- albums = model.Albums{
- {LibraryID: 1, ID: "album1", Name: "Album 1"},
- }
- })
-
- When("no albums provided", func() {
- It("returns empty and zero time", func() {
- folder, upd, err := loadArtistFolder(ctx, fds, model.Albums{}, []string{"/dummy/path"})
- Expect(err).ToNot(HaveOccurred())
- Expect(folder).To(BeEmpty())
- Expect(upd).To(BeZero())
- })
- })
-
- When("artist has only one album", func() {
- It("returns the parent folder", func() {
- paths = []string{
- filepath.FromSlash("/music/artist/album1"),
- }
- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)
- Expect(err).ToNot(HaveOccurred())
- Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))
- Expect(upd).To(Equal(expectedUpdTime))
- })
- })
-
- When("the artist have multiple albums", func() {
- It("returns the common prefix for the albums paths", func() {
- paths = []string{
- filepath.FromSlash("/music/library/artist/one"),
- filepath.FromSlash("/music/library/artist/two"),
- }
- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)
- Expect(err).ToNot(HaveOccurred())
- Expect(folder).To(Equal(filepath.FromSlash("/music/library/artist")))
- Expect(upd).To(Equal(expectedUpdTime))
- })
- })
-
- When("two albums share the same folder", func() {
- It("climbs above the shared album folder", func() {
- paths = []string{
- filepath.FromSlash("/music/artist/split"),
- filepath.FromSlash("/music/artist/split"),
- }
- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)
- Expect(err).ToNot(HaveOccurred())
- Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))
- Expect(upd).To(Equal(expectedUpdTime))
- })
- })
-
- When("the album paths contain same prefix", func() {
- It("returns the common prefix", func() {
- paths = []string{
- filepath.FromSlash("/music/artist/album1"),
- filepath.FromSlash("/music/artist/album2"),
- }
- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)
- Expect(err).ToNot(HaveOccurred())
- Expect(folder).To(Equal(filepath.FromSlash("/music/artist")))
- Expect(upd).To(Equal(expectedUpdTime))
- })
- })
-
- When("ds.Folder().GetAll returns an error", func() {
- It("returns an error", func() {
- paths = []string{
- filepath.FromSlash("/music/artist/album1"),
- filepath.FromSlash("/music/artist/album2"),
- }
- repo.err = errors.New("fake error")
- folder, upd, err := loadArtistFolder(ctx, fds, albums, paths)
- Expect(err).To(MatchError(ContainSubstring("fake error")))
- // Folder and time are empty on error.
- Expect(folder).To(BeEmpty())
- Expect(upd).To(BeZero())
- })
- })
- })
-
- var _ = Describe("fromArtistFolder", func() {
- var (
- ctx context.Context
- tempDir string
- libFS fs.FS
- testFunc sourceFunc
- )
-
- BeforeEach(func() {
- ctx = context.Background()
- tempDir = GinkgoT().TempDir()
- libFS = os.DirFS(tempDir)
- })
-
- When("artist folder contains matching image", func() {
- BeforeEach(func() {
- // Create test structure: /temp/artist/artist.jpg
- artistDir := filepath.Join(tempDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- artistImagePath := filepath.Join(artistDir, "artist.jpg")
- Expect(os.WriteFile(artistImagePath, []byte("fake image data"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("finds and returns the image", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
- Expect(path).To(ContainSubstring("artist.jpg"))
-
- // Verify we can read the content
- data, err := io.ReadAll(reader)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("fake image data"))
- reader.Close()
- })
- })
-
- When("artist folder name contains glob metacharacters", func() {
- BeforeEach(func() {
- artistDir := filepath.Join(tempDir, "Artist [Live]")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- artistImagePath := filepath.Join(artistDir, "artist.jpg")
- Expect(os.WriteFile(artistImagePath, []byte("bracketed artist image"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("treats the folder path literally when globbing through the library fs", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
- Expect(path).To(ContainSubstring("Artist [Live]" + string(filepath.Separator) + "artist.jpg"))
-
- data, err := io.ReadAll(reader)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("bracketed artist image"))
- reader.Close()
- })
- })
-
- When("artist folder is empty but parent contains image", func() {
- BeforeEach(func() {
- // Create test structure: /temp/parent/artist.jpg and /temp/parent/artist/album/
- parentDir := filepath.Join(tempDir, "parent")
- artistDir := filepath.Join(parentDir, "artist")
- albumDir := filepath.Join(artistDir, "album")
- Expect(os.MkdirAll(albumDir, 0755)).To(Succeed())
-
- // Put artist image in parent directory
- artistImagePath := filepath.Join(parentDir, "artist.jpg")
- Expect(os.WriteFile(artistImagePath, []byte("parent image"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("finds image in parent directory", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
- Expect(path).To(ContainSubstring("parent" + string(filepath.Separator) + "artist.jpg"))
-
- data, err := io.ReadAll(reader)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("parent image"))
- reader.Close()
- })
- })
-
- When("image is two levels up", func() {
- BeforeEach(func() {
- // Create test structure: /temp/grandparent/artist.jpg and /temp/grandparent/parent/artist/
- grandparentDir := filepath.Join(tempDir, "grandparent")
- parentDir := filepath.Join(grandparentDir, "parent")
- artistDir := filepath.Join(parentDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- // Put artist image in grandparent directory
- artistImagePath := filepath.Join(grandparentDir, "artist.jpg")
- Expect(os.WriteFile(artistImagePath, []byte("grandparent image"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("finds image in grandparent directory", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
- Expect(path).To(ContainSubstring("grandparent" + string(filepath.Separator) + "artist.jpg"))
-
- data, err := io.ReadAll(reader)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("grandparent image"))
- reader.Close()
- })
- })
-
- When("images exist at multiple levels", func() {
- BeforeEach(func() {
- // Create test structure with images at multiple levels
- grandparentDir := filepath.Join(tempDir, "grandparent")
- parentDir := filepath.Join(grandparentDir, "parent")
- artistDir := filepath.Join(parentDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- // Put artist images at all levels
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist level"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(parentDir, "artist.jpg"), []byte("parent level"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(grandparentDir, "artist.jpg"), []byte("grandparent level"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("prioritizes the closest (artist folder) image", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
- Expect(path).To(ContainSubstring("artist" + string(filepath.Separator) + "artist.jpg"))
-
- data, err := io.ReadAll(reader)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("artist level"))
- reader.Close()
- })
- })
-
- When("pattern matches multiple files", func() {
- BeforeEach(func() {
- artistDir := filepath.Join(tempDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- // Create multiple matching files
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.abc"), []byte("text file"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.png"), []byte("png image"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("jpg image"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("returns the first valid image file in sorted order", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
-
- // Should return an image file,
- // Files are sorted: jpg comes before png alphabetically.
- // .abc comes first, but it's not an image.
- Expect(path).To(ContainSubstring("artist.jpg"))
- reader.Close()
- })
- })
-
- When("prioritizing files without numeric suffixes", func() {
- BeforeEach(func() {
- // Test case for issue #4683: artist.jpg should come before artist.1.jpg
- artistDir := filepath.Join(tempDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- // Create multiple matches with and without numeric suffixes
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.1.jpg"), []byte("artist 1"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist main"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.2.jpg"), []byte("artist 2"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("returns artist.jpg before artist.1.jpg and artist.2.jpg", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
- Expect(path).To(ContainSubstring("artist.jpg"))
-
- // Verify it's the main file, not a numbered variant
- data, err := io.ReadAll(reader)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("artist main"))
- reader.Close()
- })
- })
-
- When("handling case-insensitive sorting", func() {
- BeforeEach(func() {
- // Test case to ensure case-insensitive natural sorting
- artistDir := filepath.Join(tempDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- // Create files with mixed case names
- Expect(os.WriteFile(filepath.Join(artistDir, "Folder.jpg"), []byte("folder"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(artistDir, "artist.jpg"), []byte("artist"), 0600)).To(Succeed())
- Expect(os.WriteFile(filepath.Join(artistDir, "BACK.jpg"), []byte("back"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "*.*")
- })
-
- It("sorts case-insensitively", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
-
- // Should return artist.jpg first (case-insensitive: "artist" < "back" < "folder")
- Expect(path).To(ContainSubstring("artist.jpg"))
-
- data, err := io.ReadAll(reader)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("artist"))
- reader.Close()
- })
- })
-
- When("no matching files exist anywhere", func() {
- BeforeEach(func() {
- artistDir := filepath.Join(tempDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- // Create non-matching files
- Expect(os.WriteFile(filepath.Join(artistDir, "cover.jpg"), []byte("cover image"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("returns an error", func() {
- reader, path, err := testFunc()
- Expect(err).To(HaveOccurred())
- Expect(reader).To(BeNil())
- Expect(path).To(BeEmpty())
- Expect(err.Error()).To(ContainSubstring("no matches for 'artist.*'"))
- Expect(err.Error()).To(ContainSubstring("parent directories"))
- })
- })
-
- When("directory traversal reaches filesystem root", func() {
- BeforeEach(func() {
- // Start from a shallow directory to test root boundary
- artistDir := filepath.Join(tempDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("handles root boundary gracefully", func() {
- reader, path, err := testFunc()
- Expect(err).To(HaveOccurred())
- Expect(reader).To(BeNil())
- Expect(path).To(BeEmpty())
- // Should not panic or cause infinite loop
- })
- })
-
- When("file exists but cannot be opened", func() {
- BeforeEach(func() {
- artistDir := filepath.Join(tempDir, "artist")
- Expect(os.MkdirAll(artistDir, 0755)).To(Succeed())
-
- // Create a file that cannot be opened (permission denied)
- restrictedFile := filepath.Join(artistDir, "artist.jpg")
- Expect(os.WriteFile(restrictedFile, []byte("restricted"), 0600)).To(Succeed())
-
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("logs warning and continues searching", func() {
- // This test depends on the ability to restrict file permissions
- // For now, we'll just ensure it doesn't panic and returns appropriate error
- reader, _, err := testFunc()
- // The file should be readable in test environment, so this will succeed
- // In a real scenario with permission issues, it would continue searching
- if err == nil {
- Expect(reader).ToNot(BeNil())
- reader.Close()
- }
- })
- })
-
- When("single album artist scenario (original issue)", func() {
- BeforeEach(func() {
- // Simulate the exact folder structure from the issue:
- // /music/artist/album1/ (single album)
- // /music/artist/artist.jpg (artist image that should be found)
- artistDir := filepath.Join(tempDir, "music", "artist")
- albumDir := filepath.Join(artistDir, "album1")
- Expect(os.MkdirAll(albumDir, 0755)).To(Succeed())
-
- // Create artist.jpg in the artist folder (this was not being found before)
- artistImagePath := filepath.Join(artistDir, "artist.jpg")
- Expect(os.WriteFile(artistImagePath, []byte("single album artist image"), 0600)).To(Succeed())
-
- // The fromArtistFolder is called with the artist folder path
- testFunc = fromArtistFolder(ctx, libFS, tempDir, artistDir, "artist.*")
- })
-
- It("finds artist.jpg in artist folder for single album artist", func() {
- reader, path, err := testFunc()
- Expect(err).ToNot(HaveOccurred())
- Expect(reader).ToNot(BeNil())
- Expect(path).To(ContainSubstring("artist.jpg"))
- Expect(path).To(ContainSubstring("artist"))
-
- // Verify the content
- data, err := io.ReadAll(reader)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("single album artist image"))
- reader.Close()
- })
- })
- })
-
- Describe("fromArtistUploadedImage", func() {
- var (
- tempDir string
- reader *artistReader
- )
-
- BeforeEach(func() {
- DeferCleanup(configtest.SetupConfig())
- tempDir = GinkgoT().TempDir()
- conf.Server.DataFolder = conf.NewDir(tempDir)
-
- // Create the artwork/artist directory
- Expect(os.MkdirAll(filepath.Join(tempDir, "artwork", "artist"), 0755)).To(Succeed())
-
- reader = &artistReader{}
- })
-
- When("artist has an uploaded image", func() {
- It("returns the uploaded image", func() {
- imgPath := filepath.Join(tempDir, "artwork", "artist", "ar-1_test.jpg")
- Expect(os.WriteFile(imgPath, []byte("uploaded artist image"), 0600)).To(Succeed())
-
- reader.artist = model.Artist{ID: "ar-1", UploadedImage: "ar-1_test.jpg"}
- sf := reader.fromArtistUploadedImage()
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
-
- data, err := io.ReadAll(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("uploaded artist image"))
- r.Close()
- })
- })
-
- When("artist has no uploaded image", func() {
- It("returns nil reader (falls through)", func() {
- reader.artist = model.Artist{ID: "ar-1"}
- sf := reader.fromArtistUploadedImage()
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).To(BeNil())
- Expect(path).To(BeEmpty())
- })
- })
- })
-
- Describe("fromArtistImageFolder", func() {
- var (
- ctx context.Context
- tempDir string
- ar *artistReader
- )
-
- BeforeEach(func() {
- ctx = context.Background()
- DeferCleanup(configtest.SetupConfig())
- tempDir = GinkgoT().TempDir()
- ar = &artistReader{}
- })
-
- When("ArtistImageFolder is not configured", func() {
- It("returns nil (skips)", func() {
- conf.Server.ArtistImageFolder = ""
- ar.artist = model.Artist{Name: "Test Artist"}
- sf := ar.fromArtistImageFolder(ctx)
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).To(BeNil())
- Expect(path).To(BeEmpty())
- })
- })
-
- When("image exists matching MBID", func() {
- It("finds the image by MBID", func() {
- conf.Server.ArtistImageFolder = tempDir
- mbid := "f27ec8db-af05-4f36-916e-3d57f91ecf5e"
- imgPath := filepath.Join(tempDir, mbid+".jpg")
- Expect(os.WriteFile(imgPath, []byte("mbid image"), 0600)).To(Succeed())
-
- ar.artist = model.Artist{Name: "Test Artist", MbzArtistID: mbid}
- sf := ar.fromArtistImageFolder(ctx)
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
-
- data, err := io.ReadAll(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("mbid image"))
- r.Close()
- })
- })
-
- When("MBID match is case-insensitive", func() {
- It("finds the image regardless of case", func() {
- conf.Server.ArtistImageFolder = tempDir
- mbid := "F27EC8DB-AF05-4F36-916E-3D57F91ECF5E"
- imgPath := filepath.Join(tempDir, "f27ec8db-af05-4f36-916e-3d57f91ecf5e.png")
- Expect(os.WriteFile(imgPath, []byte("mbid case image"), 0600)).To(Succeed())
-
- ar.artist = model.Artist{Name: "Test Artist", MbzArtistID: mbid}
- sf := ar.fromArtistImageFolder(ctx)
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
- r.Close()
- })
- })
-
- When("no MBID file exists but artist name file does", func() {
- It("falls back to artist name match", func() {
- conf.Server.ArtistImageFolder = tempDir
- imgPath := filepath.Join(tempDir, "Test Artist.jpg")
- Expect(os.WriteFile(imgPath, []byte("name image"), 0600)).To(Succeed())
-
- ar.artist = model.Artist{Name: "Test Artist", MbzArtistID: "nonexistent-mbid"}
- sf := ar.fromArtistImageFolder(ctx)
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
-
- data, err := io.ReadAll(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("name image"))
- r.Close()
- })
- })
-
- When("artist name match is case-insensitive", func() {
- It("matches regardless of case", func() {
- conf.Server.ArtistImageFolder = tempDir
- imgPath := filepath.Join(tempDir, "test artist.jpg")
- Expect(os.WriteFile(imgPath, []byte("case insensitive"), 0600)).To(Succeed())
-
- ar.artist = model.Artist{Name: "Test Artist"}
- sf := ar.fromArtistImageFolder(ctx)
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
- r.Close()
- })
- })
-
- When("both MBID and name files exist", func() {
- It("prefers MBID over name match", func() {
- conf.Server.ArtistImageFolder = tempDir
- mbid := "f27ec8db-af05-4f36-916e-3d57f91ecf5e"
- mbidPath := filepath.Join(tempDir, mbid+".jpg")
- namePath := filepath.Join(tempDir, "Test Artist.jpg")
- Expect(os.WriteFile(mbidPath, []byte("mbid image"), 0600)).To(Succeed())
- Expect(os.WriteFile(namePath, []byte("name image"), 0600)).To(Succeed())
-
- ar.artist = model.Artist{Name: "Test Artist", MbzArtistID: mbid}
- sf := ar.fromArtistImageFolder(ctx)
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(mbidPath))
-
- data, err := io.ReadAll(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("mbid image"))
- r.Close()
- })
- })
-
- When("no matching image found", func() {
- It("returns an error", func() {
- conf.Server.ArtistImageFolder = tempDir
- // Create an unrelated file
- Expect(os.WriteFile(filepath.Join(tempDir, "other.jpg"), []byte("other"), 0600)).To(Succeed())
-
- ar.artist = model.Artist{Name: "Test Artist"}
- sf := ar.fromArtistImageFolder(ctx)
- r, _, err := sf()
- Expect(err).To(HaveOccurred())
- Expect(r).To(BeNil())
- Expect(err.Error()).To(ContainSubstring("no image found"))
- })
- })
-
- When("cached imgFolderImgPath is set", func() {
- It("uses cached path instead of scanning", func() {
- conf.Server.ArtistImageFolder = tempDir
- imgPath := filepath.Join(tempDir, "cached.jpg")
- Expect(os.WriteFile(imgPath, []byte("cached image"), 0600)).To(Succeed())
-
- ar.artist = model.Artist{Name: "Test Artist"}
- ar.imgFolderImgPath = imgPath
- sf := ar.fromArtistImageFolder(ctx)
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
-
- data, err := io.ReadAll(r)
- Expect(err).ToNot(HaveOccurred())
- Expect(string(data)).To(Equal("cached image"))
- r.Close()
- })
- })
- })
-
- Describe("findImageInArtistFolder", func() {
- var tempDir string
-
- BeforeEach(func() {
- tempDir = GinkgoT().TempDir()
- })
-
- When("matching file exists by MBID", func() {
- It("returns the file path", func() {
- mbid := "f27ec8db-af05-4f36-916e-3d57f91ecf5e"
- imgPath := filepath.Join(tempDir, mbid+".jpg")
- Expect(os.WriteFile(imgPath, []byte("image"), 0600)).To(Succeed())
-
- path := findImageInArtistFolder(tempDir, mbid, "Test")
- Expect(path).To(Equal(imgPath))
- })
- })
-
- When("matching file exists by name", func() {
- It("returns the file path", func() {
- imgPath := filepath.Join(tempDir, "Test Artist.png")
- Expect(os.WriteFile(imgPath, []byte("image"), 0600)).To(Succeed())
-
- path := findImageInArtistFolder(tempDir, "", "Test Artist")
- Expect(path).To(Equal(imgPath))
- })
- })
-
- When("no matching file exists", func() {
- It("returns empty string", func() {
- path := findImageInArtistFolder(tempDir, "", "Unknown Artist")
- Expect(path).To(BeEmpty())
- })
- })
-
- When("folder does not exist", func() {
- It("returns empty string", func() {
- path := findImageInArtistFolder("/nonexistent/path", "", "Test")
- Expect(path).To(BeEmpty())
- })
- })
- })
-})
-
-type fakeFolderRepo struct {
- model.FolderRepository
- result []model.Folder
- parentResult *model.Folder
- getErr error
- getCallCount int
- err error
- // hasOtherAudio is returned by HasAudioOutsideFolders (the album-root
- // check). False means the parent qualifies as an album root.
- hasOtherAudio bool
- otherAudioErr error
-}
-
-func (f *fakeFolderRepo) GetAll(...model.QueryOptions) ([]model.Folder, error) {
- return f.result, f.err
-}
-
-func (f *fakeFolderRepo) HasAudioOutsideFolders(model.Folder, []string) (bool, error) {
- return f.hasOtherAudio, f.otherAudioErr
-}
-
-func (f *fakeFolderRepo) Get(id string) (*model.Folder, error) {
- f.getCallCount++
- if f.getErr != nil {
- return nil, f.getErr
- }
- if f.parentResult != nil {
- return f.parentResult, nil
- }
- return nil, model.ErrNotFound
-}
-
-type fakeDataStore struct {
- model.DataStore
- folderRepo *fakeFolderRepo
-}
-
-func (fds *fakeDataStore) Folder(_ context.Context) model.FolderRepository {
- return fds.folderRepo
-}
-
-func stubCoreAbsolutePath() func() {
- // Override core.AbsolutePath to return a fixed string during tests.
- original := core.AbsolutePath
- core.AbsolutePath = func(_ context.Context, ds model.DataStore, libID int, p string) string {
- return filepath.FromSlash("/music")
- }
- return func() {
- core.AbsolutePath = original
- }
-}
diff --git a/core/artwork/reader_mediafile.go b/core/artwork/reader_mediafile.go
deleted file mode 100644
index eac3c5e70..000000000
--- a/core/artwork/reader_mediafile.go
+++ /dev/null
@@ -1,82 +0,0 @@
-package artwork
-
-import (
- "context"
- "fmt"
- "io"
- "time"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/model"
-)
-
-type mediafileArtworkReader struct {
- cacheKey
- a *artwork
- mediafile model.MediaFile
- album model.Album
- lib libraryView
-}
-
-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
- }
- _, _, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, artwork.ds, *al)
- if err != nil {
- return nil, err
- }
- lib, err := loadLibraryView(ctx, artwork.ds, mf.LibraryID)
- if err != nil {
- return nil, err
- }
- a := &mediafileArtworkReader{
- a: artwork,
- mediafile: *mf,
- album: *al,
- lib: lib,
- }
- a.cacheKey.artID = artID
- a.cacheKey.lastUpdate = mf.UpdatedAt
- if al.UpdatedAt.After(a.cacheKey.lastUpdate) {
- a.cacheKey.lastUpdate = al.UpdatedAt
- }
- if imagesUpdatedAt != nil && imagesUpdatedAt.After(a.cacheKey.lastUpdate) {
- a.cacheKey.lastUpdate = *imagesUpdatedAt
- }
- return a, nil
-}
-
-func (a *mediafileArtworkReader) Key() string {
- return fmt.Sprintf(
- "%s.%t",
- a.cacheKey.Key(),
- conf.Server.EnableMediaFileCoverArt,
- )
-}
-func (a *mediafileArtworkReader) LastUpdated() time.Time {
- return a.lastUpdate
-}
-
-func (a *mediafileArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
- var ff []sourceFunc
- if a.mediafile.CoverArtID().Kind == model.KindMediaFileArtwork {
- ff = []sourceFunc{
- fromTag(ctx, a.lib.FS, a.mediafile.Path),
- fromFFmpegTag(ctx, a.a.ffmpeg, a.lib.Abs(a.mediafile.Path)),
- }
- }
- // For multi-disc albums, fall back to disc artwork first; for single-disc albums,
- // skip disc resolution (it would just fall through to album art anyway).
- if len(a.album.Discs) > 1 {
- ff = append(ff, fromAlbum(ctx, a.a, a.mediafile.DiscCoverArtID()))
- } else {
- ff = append(ff, fromAlbum(ctx, a.a, a.mediafile.AlbumCoverArtID()))
- }
- return selectImageReader(ctx, a.artID, ff...)
-}
diff --git a/core/artwork/reader_playlist.go b/core/artwork/reader_playlist.go
deleted file mode 100644
index 09707843d..000000000
--- a/core/artwork/reader_playlist.go
+++ /dev/null
@@ -1,269 +0,0 @@
-package artwork
-
-import (
- "bytes"
- "context"
- "errors"
- "image"
- "image/draw"
- "image/png"
- "io"
- "net/url"
- "os"
- "path/filepath"
- "strings"
- "time"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/log"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/utils/slice"
- xdraw "golang.org/x/image/draw"
-)
-
-type playlistArtworkReader struct {
- cacheKey
- a *artwork
- pl model.Playlist
-}
-
-const tileSize = 600
-
-func newPlaylistArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*playlistArtworkReader, error) {
- pl, err := artwork.ds.Playlist(ctx).Get(artID.ID)
- if err != nil {
- return nil, err
- }
- a := &playlistArtworkReader{
- a: artwork,
- pl: *pl,
- }
- a.cacheKey.artID = artID
- a.cacheKey.lastUpdate = pl.UpdatedAt
-
- // Check sidecar and ExternalImageURL local file ModTimes for cache invalidation.
- // If either is newer than the playlist's UpdatedAt, use that instead so the
- // cache is busted when a user replaces a sidecar image or local file reference.
- for _, path := range []string{
- findPlaylistSidecarPath(ctx, pl.Path),
- pl.ExternalImageURL,
- } {
- if path == "" || strings.HasPrefix(path, "http://") || strings.HasPrefix(path, "https://") {
- continue
- }
- if info, err := os.Stat(path); err == nil {
- if info.ModTime().After(a.cacheKey.lastUpdate) {
- a.cacheKey.lastUpdate = info.ModTime()
- }
- }
- }
-
- return a, nil
-}
-
-func (a *playlistArtworkReader) LastUpdated() time.Time {
- return a.lastUpdate
-}
-
-func (a *playlistArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
- return selectImageReader(ctx, a.artID,
- a.fromPlaylistUploadedImage(),
- a.fromPlaylistSidecar(ctx),
- a.fromPlaylistExternalImage(ctx),
- a.fromGeneratedTiledCover(ctx),
- fromAlbumPlaceholder(),
- )
-}
-
-func (a *playlistArtworkReader) fromPlaylistUploadedImage() sourceFunc {
- return fromLocalFile(a.pl.UploadedImagePath())
-}
-
-func (a *playlistArtworkReader) fromPlaylistSidecar(ctx context.Context) sourceFunc {
- return fromLocalFile(findPlaylistSidecarPath(ctx, a.pl.Path))
-}
-
-func (a *playlistArtworkReader) fromPlaylistExternalImage(ctx context.Context) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- imgURL := a.pl.ExternalImageURL
- if imgURL == "" {
- return nil, "", nil
- }
- parsed, err := url.Parse(imgURL)
- if err != nil {
- return nil, "", err
- }
- if parsed.Scheme == "http" || parsed.Scheme == "https" {
- if !conf.Server.EnableM3UExternalAlbumArt {
- return nil, "", nil
- }
- return fromURL(ctx, parsed)
- }
- return fromLocalFile(imgURL)()
- }
-}
-
-// fromLocalFile returns a sourceFunc that opens the given local path.
-// Returns (nil, "", nil) if path is empty — signalling "not found, try next source".
-func fromLocalFile(path string) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- if path == "" {
- return nil, "", nil
- }
- f, err := os.Open(path)
- if err != nil {
- return nil, "", err
- }
- return f, path, nil
- }
-}
-
-// findPlaylistSidecarPath scans the directory of the playlist file for a sidecar
-// image file with the same base name (case-insensitive). Returns empty string if
-// no matching image is found or if plsPath is empty.
-func findPlaylistSidecarPath(ctx context.Context, plsPath string) string {
- if plsPath == "" {
- return ""
- }
- dir := filepath.Dir(plsPath)
- base := strings.TrimSuffix(filepath.Base(plsPath), filepath.Ext(plsPath))
-
- entries, err := os.ReadDir(dir)
- if err != nil {
- log.Warn(ctx, "Could not read directory for playlist sidecar", "dir", dir, err)
- return ""
- }
- for _, entry := range entries {
- name := entry.Name()
- nameBase := strings.TrimSuffix(name, filepath.Ext(name))
- if !entry.IsDir() && strings.EqualFold(nameBase, base) && model.IsImageFile(name) {
- return filepath.Join(dir, name)
- }
- }
- return ""
-}
-
-func (a *playlistArtworkReader) fromGeneratedTiledCover(ctx context.Context) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- tiles, err := a.loadTiles(ctx)
- if err != nil {
- return nil, "", err
- }
- r, err := a.createTiledImage(ctx, tiles)
- return r, "", err
- }
-}
-
-func toAlbumArtworkIDs(albumIDs []string) []model.ArtworkID {
- return slice.Map(albumIDs, func(id string) model.ArtworkID {
- al := model.Album{ID: id}
- return al.CoverArtID()
- })
-}
-
-func (a *playlistArtworkReader) loadTiles(ctx context.Context) ([]image.Image, error) {
- tracksRepo := a.a.ds.Playlist(ctx).Tracks(a.pl.ID, false)
- albumIds, err := tracksRepo.GetAlbumIDs(model.QueryOptions{Max: 4, Sort: "random()"})
- if err != nil {
- log.Error(ctx, "Error getting album IDs for playlist", "id", a.pl.ID, "name", a.pl.Name, err)
- return nil, err
- }
- ids := toAlbumArtworkIDs(albumIds)
-
- var tiles []image.Image
- for _, id := range ids {
- r, _, err := fromAlbum(ctx, a.a, id)()
- if err == nil {
- tile, err := a.createTile(ctx, r)
- if err == nil {
- tiles = append(tiles, tile)
- }
- _ = r.Close()
- }
- if len(tiles) == 4 {
- break
- }
- }
- switch len(tiles) {
- case 0:
- return nil, errors.New("could not find any eligible cover")
- case 2:
- tiles = append(tiles, tiles[1], tiles[0])
- case 3:
- tiles = append(tiles, tiles[0])
- }
- return tiles, nil
-}
-
-func (a *playlistArtworkReader) createTile(_ context.Context, r io.ReadCloser) (image.Image, error) {
- img, _, err := image.Decode(r)
- if err != nil {
- return nil, err
- }
- return fillCenter(img, tileSize/2, tileSize/2), nil
-}
-
-func (a *playlistArtworkReader) createTiledImage(_ context.Context, tiles []image.Image) (io.ReadCloser, error) {
- buf := new(bytes.Buffer)
- var rgba draw.Image
- var err error
- if len(tiles) == 4 {
- rgba = image.NewRGBA(image.Rectangle{Max: image.Point{X: tileSize - 1, Y: tileSize - 1}})
- draw.Draw(rgba, rect(0), tiles[0], image.Point{}, draw.Src)
- draw.Draw(rgba, rect(1), tiles[1], image.Point{}, draw.Src)
- draw.Draw(rgba, rect(2), tiles[2], image.Point{}, draw.Src)
- draw.Draw(rgba, rect(3), tiles[3], image.Point{}, draw.Src)
- err = png.Encode(buf, rgba)
- } else {
- err = png.Encode(buf, tiles[0])
- }
- if err != nil {
- return nil, err
- }
- return io.NopCloser(buf), nil
-}
-
-func rect(pos int) image.Rectangle {
- r := image.Rectangle{}
- switch pos {
- case 1:
- r.Min.X = tileSize / 2
- case 2:
- r.Min.Y = tileSize / 2
- case 3:
- r.Min.X = tileSize / 2
- r.Min.Y = tileSize / 2
- }
- r.Max.X = r.Min.X + tileSize/2
- r.Max.Y = r.Min.Y + tileSize/2
- return r
-}
-
-// fillCenter crops the source image from the center and scales it to fill dstW x dstH exactly,
-// equivalent to imaging.Fill with Center anchor.
-func fillCenter(src image.Image, dstW, dstH int) image.Image {
- srcBounds := src.Bounds()
- srcW := srcBounds.Dx()
- srcH := srcBounds.Dy()
-
- // Calculate crop rectangle (center crop to match destination aspect ratio)
- srcAspect := float64(srcW) / float64(srcH)
- dstAspect := float64(dstW) / float64(dstH)
-
- var cropRect image.Rectangle
- if srcAspect > dstAspect {
- // Source is wider — crop horizontally
- cropW := int(float64(srcH) * dstAspect)
- cropX := (srcW - cropW) / 2
- cropRect = image.Rect(srcBounds.Min.X+cropX, srcBounds.Min.Y, srcBounds.Min.X+cropX+cropW, srcBounds.Max.Y)
- } else {
- // Source is taller — crop vertically
- cropH := int(float64(srcW) / dstAspect)
- cropY := (srcH - cropH) / 2
- cropRect = image.Rect(srcBounds.Min.X, srcBounds.Min.Y+cropY, srcBounds.Max.X, srcBounds.Min.Y+cropY+cropH)
- }
-
- dst := image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
- xdraw.CatmullRom.Scale(dst, dst.Bounds(), src, cropRect, draw.Src, nil)
- return dst
-}
diff --git a/core/artwork/reader_radio.go b/core/artwork/reader_radio.go
deleted file mode 100644
index 22db6e302..000000000
--- a/core/artwork/reader_radio.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package artwork
-
-import (
- "context"
- "io"
- "time"
-
- "github.com/navidrome/navidrome/model"
-)
-
-type radioArtworkReader struct {
- cacheKey
- a *artwork
- radio model.Radio
-}
-
-func newRadioArtworkReader(ctx context.Context, artwork *artwork, artID model.ArtworkID) (*radioArtworkReader, error) {
- r, err := artwork.ds.Radio(ctx).Get(artID.ID)
- if err != nil {
- return nil, err
- }
- a := &radioArtworkReader{a: artwork, radio: *r}
- a.cacheKey.artID = artID
- a.cacheKey.lastUpdate = r.UpdatedAt
- return a, nil
-}
-
-func (a *radioArtworkReader) LastUpdated() time.Time {
- return a.lastUpdate
-}
-
-func (a *radioArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
- return selectImageReader(ctx, a.artID,
- a.fromRadioUploadedImage(),
- )
-}
-
-func (a *radioArtworkReader) fromRadioUploadedImage() sourceFunc {
- return fromLocalFile(a.radio.UploadedImagePath())
-}
diff --git a/core/artwork/reader_radio_test.go b/core/artwork/reader_radio_test.go
deleted file mode 100644
index 37ce1d827..000000000
--- a/core/artwork/reader_radio_test.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package artwork
-
-import (
- "context"
- "os"
- "path/filepath"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/model"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("radioArtworkReader", func() {
- var (
- tempDir string
- reader *radioArtworkReader
- )
-
- BeforeEach(func() {
- DeferCleanup(configtest.SetupConfig())
- tempDir = GinkgoT().TempDir()
- conf.Server.DataFolder = conf.NewDir(tempDir)
-
- Expect(os.MkdirAll(filepath.Join(tempDir, "artwork", "radio"), 0755)).To(Succeed())
-
- reader = &radioArtworkReader{}
- })
-
- Describe("fromRadioUploadedImage", func() {
- When("radio has an uploaded image", func() {
- It("returns the uploaded image", func() {
- imgPath := filepath.Join(tempDir, "artwork", "radio", "rd-1_test.jpg")
- Expect(os.WriteFile(imgPath, []byte("uploaded radio image"), 0600)).To(Succeed())
-
- reader.radio = model.Radio{ID: "rd-1", UploadedImage: "rd-1_test.jpg"}
- sf := reader.fromRadioUploadedImage()
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- Expect(path).To(Equal(imgPath))
- r.Close()
- })
- })
-
- When("radio has no uploaded image", func() {
- It("returns nil reader (falls through)", func() {
- reader.radio = model.Radio{ID: "rd-1"}
- sf := reader.fromRadioUploadedImage()
- r, path, err := sf()
- Expect(err).ToNot(HaveOccurred())
- Expect(r).To(BeNil())
- Expect(path).To(BeEmpty())
- })
- })
- })
-
- Describe("Reader", func() {
- When("radio has an uploaded image", func() {
- It("returns the image reader", func() {
- imgPath := filepath.Join(tempDir, "artwork", "radio", "rd-1_test.jpg")
- Expect(os.WriteFile(imgPath, []byte("uploaded radio image"), 0600)).To(Succeed())
-
- reader.radio = model.Radio{ID: "rd-1", UploadedImage: "rd-1_test.jpg"}
- reader.cacheKey.artID = model.ArtworkID{Kind: model.KindRadioArtwork, ID: "rd-1"}
- r, _, err := reader.Reader(context.Background())
- Expect(err).ToNot(HaveOccurred())
- Expect(r).ToNot(BeNil())
- r.Close()
- })
- })
-
- When("radio has no uploaded image", func() {
- It("returns ErrUnavailable", func() {
- reader.radio = model.Radio{ID: "rd-1"}
- reader.cacheKey.artID = model.ArtworkID{Kind: model.KindRadioArtwork, ID: "rd-1"}
- r, _, err := reader.Reader(context.Background())
- Expect(err).To(MatchError(ErrUnavailable))
- Expect(r).To(BeNil())
- })
- })
- })
-})
diff --git a/core/artwork/reader_resized.go b/core/artwork/reader_resized.go
deleted file mode 100644
index cd16cbada..000000000
--- a/core/artwork/reader_resized.go
+++ /dev/null
@@ -1,209 +0,0 @@
-package artwork
-
-import (
- "bytes"
- "context"
- "fmt"
- "image"
- "image/draw"
- "image/jpeg"
- "image/png"
- "io"
- "sync"
- "time"
-
- "github.com/gen2brain/webp"
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/log"
- "github.com/navidrome/navidrome/model"
- xdraw "golang.org/x/image/draw"
-)
-
-func init() {
- conf.AddHook(func() {
- // gen2brain/webp selects native (purego/libwebp) vs WASM in its own
- // package init() and exposes the result only via webp.Dynamic(); there is
- // no runtime way to switch back. On 32-bit ARM/x86 the purego callback path
- // crashes (issue #5597), so those builds must be compiled with the
- // "nodynamic" tag (see Dockerfile), which makes webp.Dynamic() report an
- // error here and forces the safe WASM path.
- if err := webp.Dynamic(); err != nil {
- log.Debug("Using WASM WebP encoder/decoder", "reason", err)
- } else {
- log.Debug("Using native libwebp for WebP encoding/decoding")
- }
- })
-}
-
-var bufPool = sync.Pool{
- New: func() any {
- return new(bytes.Buffer)
- },
-}
-
-type resizedArtworkReader struct {
- artID model.ArtworkID
- cacheKey string
- lastUpdate time.Time
- size int
- square bool
- a *artwork
-}
-
-func resizedFromOriginal(ctx context.Context, a *artwork, artID model.ArtworkID, size int, square bool) (*resizedArtworkReader, error) {
- r := &resizedArtworkReader{a: a}
- r.artID = artID
- r.size = size
- r.square = square
-
- // Get lastUpdated and cacheKey from original artwork
- original, err := a.getArtworkReader(ctx, artID, 0, false)
- if err != nil {
- return nil, err
- }
- r.cacheKey = original.Key()
- r.lastUpdate = original.LastUpdated()
- return r, nil
-}
-
-func (a *resizedArtworkReader) Key() string {
- baseKey := fmt.Sprintf("%s.%d", a.cacheKey, a.size)
- if a.square {
- return baseKey + ".square"
- }
- return fmt.Sprintf("%s.%d", baseKey, conf.Server.CoverArtQuality)
-}
-
-func (a *resizedArtworkReader) LastUpdated() time.Time {
- return a.lastUpdate
-}
-
-func (a *resizedArtworkReader) Reader(ctx context.Context) (io.ReadCloser, string, error) {
- // Get artwork in original size, possibly from cache
- orig, _, err := a.a.Get(ctx, a.artID, 0, false)
- if err != nil {
- return nil, "", err
- }
- defer orig.Close()
-
- resized, origSize, err := a.resizeImage(ctx, orig)
- if resized == nil {
- log.Trace(ctx, "Image smaller than requested size", "artID", a.artID, "original", origSize, "resized", a.size, "square", a.square)
- } else {
- log.Trace(ctx, "Resizing artwork", "artID", a.artID, "original", origSize, "resized", a.size, "square", a.square)
- }
- if err != nil {
- log.Warn(ctx, "Could not resize image. Will return image as is", "artID", a.artID, "size", a.size, "square", a.square, err)
- }
- if err != nil || resized == nil {
- // if we couldn't resize the image, return the original
- orig, _, err = a.a.Get(ctx, a.artID, 0, false)
- return orig, "", err
- }
- // Preserve ReadCloser semantics if the resized reader already supports Close
- // (e.g., ffmpeg pipe), otherwise wrap with NopCloser
- if rc, ok := resized.(io.ReadCloser); ok {
- return rc, fmt.Sprintf("%s@%d", a.artID, a.size), nil
- }
- return io.NopCloser(resized), fmt.Sprintf("%s@%d", a.artID, a.size), nil
-}
-
-func (a *resizedArtworkReader) resizeImage(ctx context.Context, reader io.Reader) (io.Reader, int, error) {
- data, err := io.ReadAll(reader)
- if err != nil {
- return nil, 0, fmt.Errorf("reading image data: %w", err)
- }
-
- // Preserve animation for animated images
- if isAnimatedGIF(data) {
- if a.a.ffmpeg.IsAvailable() {
- // Animated GIF: convert to animated WebP via ffmpeg (with optional resize)
- r, err := a.a.ffmpeg.ConvertAnimatedImage(ctx, bytes.NewReader(data), a.size, conf.Server.CoverArtQuality)
- if err == nil {
- return r, 0, nil
- }
- log.Warn(ctx, "Could not convert animated GIF, falling back to static", err)
- }
- } else if isAnimatedWebP(data) || isAnimatedPNG(data) {
- // Animated WebP/APNG: return original as-is (ffmpeg can't re-encode these)
- return bytes.NewReader(data), 0, nil
- }
-
- return resizeStaticImage(data, a.size, a.square)
-}
-
-// toFastScaleType converts images whose concrete type has no optimized scaler
-// in x/image/draw (e.g. *image.NYCbCrA from WebP, *image.Paletted from indexed
-// PNGs) into *image.RGBA, which has a fast path. Without this, CatmullRom.Scale
-// falls back to a generic per-pixel At()/RGBA() loop that is several times
-// slower. Fast-path types are returned unchanged.
-func toFastScaleType(img image.Image) image.Image {
- switch img.(type) {
- case *image.RGBA, *image.NRGBA, *image.Gray, *image.YCbCr:
- return img
- default:
- rgba := image.NewRGBA(img.Bounds())
- draw.Draw(rgba, rgba.Bounds(), img, img.Bounds().Min, draw.Src)
- return rgba
- }
-}
-
-func resizeStaticImage(data []byte, size int, square bool) (io.Reader, int, error) {
- original, format, err := image.Decode(bytes.NewReader(data))
- if err != nil {
- return nil, 0, err
- }
-
- bounds := original.Bounds()
- originalSize := max(bounds.Max.X, bounds.Max.Y)
-
- // Clamp size to original dimensions - upscaling wastes resources and adds no information
- if size > originalSize {
- size = originalSize
- }
-
- if originalSize <= size && !square {
- return nil, originalSize, nil
- }
-
- // Calculate aspect-fit dimensions
- srcW, srcH := bounds.Dx(), bounds.Dy()
- scale := float64(size) / float64(max(srcW, srcH))
- dstW := int(float64(srcW) * scale)
- dstH := int(float64(srcH) * scale)
-
- var dst *image.NRGBA
- var dstRect image.Rectangle
- if square {
- // Square canvas with image centered (transparent padding via zero-initialized NRGBA)
- dst = image.NewNRGBA(image.Rect(0, 0, size, size))
- offsetX := (size - dstW) / 2
- offsetY := (size - dstH) / 2
- dstRect = image.Rect(offsetX, offsetY, offsetX+dstW, offsetY+dstH)
- } else {
- // Tight-fit canvas
- dst = image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
- dstRect = dst.Bounds()
- }
- original = toFastScaleType(original)
- xdraw.CatmullRom.Scale(dst, dstRect, original, bounds, draw.Src, nil)
-
- buf := bufPool.Get().(*bytes.Buffer)
- buf.Reset()
- if conf.Server.EnableWebPEncoding {
- err = webp.Encode(buf, dst, webp.Options{Quality: conf.Server.CoverArtQuality})
- } else if format == "png" || square {
- err = png.Encode(buf, dst)
- } else {
- err = jpeg.Encode(buf, dst, &jpeg.Options{Quality: conf.Server.CoverArtQuality})
- }
- if err != nil {
- bufPool.Put(buf)
- return nil, originalSize, err
- }
- // Copy bytes before returning buffer to pool (pool may reuse the buffer)
- encoded := make([]byte, buf.Len())
- copy(encoded, buf.Bytes())
- bufPool.Put(buf)
- return bytes.NewReader(encoded), originalSize, nil
-}
diff --git a/core/artwork/reader_resized_test.go b/core/artwork/reader_resized_test.go
deleted file mode 100644
index 7c14f5e44..000000000
--- a/core/artwork/reader_resized_test.go
+++ /dev/null
@@ -1,176 +0,0 @@
-package artwork
-
-import (
- "bytes"
- "context"
- "errors"
- "io"
-
- "github.com/navidrome/navidrome/core/ffmpeg"
- "github.com/navidrome/navidrome/tests"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("resizeImage", func() {
- var mockFF *tests.MockFFmpeg
- var r *resizedArtworkReader
-
- BeforeEach(func() {
- mockFF = tests.NewMockFFmpeg("converted-animated-data")
- r = &resizedArtworkReader{
- size: 300,
- square: false,
- a: &artwork{ffmpeg: mockFF},
- }
- })
-
- Describe("animated GIF handling", func() {
- It("converts animated GIF via ffmpeg when available", func() {
- data := createAnimatedGIF(3)
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- Expect(err).ToNot(HaveOccurred())
- Expect(result).ToNot(BeNil())
-
- // Should have been processed by ffmpeg (mock returns "converted-animated-data")
- output, err := io.ReadAll(result)
- Expect(err).ToNot(HaveOccurred())
- Expect(output).To(Equal(data)) // MockFFmpeg echoes input back
- })
-
- It("falls back to static resize when ffmpeg fails for animated GIF", func() {
- mockFF.Error = errors.New("ffmpeg failed")
- // Use size smaller than image so static resize actually produces output
- r.size = 1
- data := createAnimatedGIF(3)
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- // Should fall through to static resize successfully (no ffmpeg error propagated)
- Expect(err).ToNot(HaveOccurred())
- Expect(result).ToNot(BeNil())
-
- // Verify it's a static image (WebP encoded), not the ffmpeg error
- output, err := io.ReadAll(result)
- Expect(err).ToNot(HaveOccurred())
- Expect(len(output)).To(BeNumerically(">", 0))
- })
-
- It("preserves animation for square thumbnails with animated GIF", func() {
- r.square = true
- data := createAnimatedGIF(3)
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- Expect(err).ToNot(HaveOccurred())
- Expect(result).ToNot(BeNil())
-
- // Should have been processed by ffmpeg (mock returns input data)
- output, err := io.ReadAll(result)
- Expect(err).ToNot(HaveOccurred())
- Expect(output).To(Equal(data))
- })
- })
-
- Describe("animated WebP handling", func() {
- It("returns animated WebP data as-is when not square", func() {
- data := createAnimatedWebPBytes()
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- Expect(err).ToNot(HaveOccurred())
- Expect(result).ToNot(BeNil())
-
- // Should return original data unchanged
- output, err := io.ReadAll(result)
- Expect(err).ToNot(HaveOccurred())
- Expect(output).To(Equal(data))
- })
-
- It("preserves animated WebP for square thumbnails", func() {
- r.square = true
- data := createAnimatedWebPBytes()
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- Expect(err).ToNot(HaveOccurred())
- Expect(result).ToNot(BeNil())
-
- // Should return original data unchanged
- output, err := io.ReadAll(result)
- Expect(err).ToNot(HaveOccurred())
- Expect(output).To(Equal(data))
- })
- })
-
- Describe("animated PNG handling", func() {
- It("returns animated PNG data as-is when not square", func() {
- data := createAPNGBytes()
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- Expect(err).ToNot(HaveOccurred())
- Expect(result).ToNot(BeNil())
-
- // Should return original data unchanged
- output, err := io.ReadAll(result)
- Expect(err).ToNot(HaveOccurred())
- Expect(output).To(Equal(data))
- })
-
- It("preserves animated PNG for square thumbnails", func() {
- r.square = true
- data := createAPNGBytes()
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- Expect(err).ToNot(HaveOccurred())
- Expect(result).ToNot(BeNil())
-
- // Should return original data unchanged
- output, err := io.ReadAll(result)
- Expect(err).ToNot(HaveOccurred())
- Expect(output).To(Equal(data))
- })
- })
-
- Describe("static image handling", func() {
- It("resizes a static PNG normally", func() {
- data := createStaticPNGBytes()
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- // Static PNG is 2x2, size 300 is larger, so should return nil (no upscale)
- Expect(err).ToNot(HaveOccurred())
- Expect(result).To(BeNil())
- })
- })
-
- Describe("ReadCloser preservation", func() {
- It("preserves Close semantics from ffmpeg ReadCloser", func() {
- // Create a trackable ReadCloser
- tracker := &closeTracker{Reader: bytes.NewReader([]byte("test data"))}
- mockFF2 := &mockFFmpegWithCloser{tracker: tracker}
- r.a = &artwork{ffmpeg: mockFF2}
-
- data := createAnimatedGIF(3)
- result, _, err := r.resizeImage(context.Background(), bytes.NewReader(data))
- Expect(err).ToNot(HaveOccurred())
-
- // The result should be an io.ReadCloser (the tracker)
- rc, ok := result.(io.ReadCloser)
- Expect(ok).To(BeTrue())
- Expect(rc.Close()).ToNot(HaveOccurred())
- Expect(tracker.closed).To(BeTrue())
- })
- })
-})
-
-// closeTracker is an io.ReadCloser that tracks whether Close was called.
-type closeTracker struct {
- io.Reader
- closed bool
-}
-
-func (c *closeTracker) Close() error {
- c.closed = true
- return nil
-}
-
-// mockFFmpegWithCloser is a minimal FFmpeg mock that returns a specific ReadCloser
-// for ConvertAnimatedImage, allowing us to verify Close propagation.
-type mockFFmpegWithCloser struct {
- ffmpeg.FFmpeg
- tracker *closeTracker
-}
-
-func (m *mockFFmpegWithCloser) IsAvailable() bool { return true }
-func (m *mockFFmpegWithCloser) ConvertAnimatedImage(_ context.Context, _ io.Reader, _ int, _ int) (io.ReadCloser, error) {
- return m.tracker, nil
-}
diff --git a/core/artwork/resize.go b/core/artwork/resize.go
new file mode 100644
index 000000000..9536c3bb1
--- /dev/null
+++ b/core/artwork/resize.go
@@ -0,0 +1,144 @@
+package artwork
+
+import (
+ "bytes"
+ "context"
+ "fmt"
+ "image"
+ "image/draw"
+ "image/jpeg"
+ "image/png"
+ "io"
+ "sync"
+ "time"
+
+ "github.com/gen2brain/webp"
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/core/ffmpeg"
+ "github.com/navidrome/navidrome/log"
+ xdraw "golang.org/x/image/draw"
+)
+
+func init() {
+ conf.AddHook(func() {
+ // gen2brain/webp picks native vs WASM in its own init(), with no way to switch at
+ // runtime: 32-bit builds need the "nodynamic" tag (see Dockerfile) to force WASM.
+ if err := webp.Dynamic(); err != nil {
+ log.Debug("Artwork: Using WASM WebP encoder/decoder", "reason", err)
+ } else {
+ log.Debug("Artwork: Using native libwebp for WebP encoding/decoding")
+ }
+ })
+}
+
+var bufPool = sync.Pool{
+ New: func() any {
+ return new(bytes.Buffer)
+ },
+}
+
+// resizeImageData resizes raw image bytes to fit size, preserving animation where
+// possible. A nil reader means the image was already within bounds (no resize needed).
+func resizeImageData(ctx context.Context, ffm ffmpeg.FFmpeg, data []byte, size int, square bool) (io.Reader, int, error) {
+ start := time.Now()
+ defer func() {
+ log.Trace(ctx, "Artwork: Resized image", "bytes", len(data), "size", size, "square", square,
+ "elapsed", time.Since(start))
+ }()
+ if isAnimatedGIF(data) {
+ if ffm.IsAvailable() {
+ // Animated GIF: convert to animated WebP via ffmpeg (with optional resize)
+ r, err := ffm.ConvertAnimatedImage(ctx, bytes.NewReader(data), size, conf.Server.CoverArtQuality)
+ if err == nil {
+ return r, 0, nil
+ }
+ log.Warn(ctx, "Artwork: Could not convert animated GIF, falling back to static", err)
+ }
+ } else if isAnimatedWebP(data) || isAnimatedPNG(data) {
+ // Animated WebP/APNG: return original as-is (ffmpeg can't re-encode these)
+ return bytes.NewReader(data), 0, nil
+ }
+
+ return resizeStaticImage(data, size, square)
+}
+
+// toFastScaleType converts types x/image/draw has no optimized scaler for (e.g. *image.NYCbCrA,
+// *image.Paletted) to *image.RGBA, avoiding CatmullRom.Scale's generic per-pixel fallback.
+func toFastScaleType(img image.Image) image.Image {
+ switch img.(type) {
+ case *image.RGBA, *image.NRGBA, *image.Gray, *image.YCbCr:
+ return img
+ default:
+ rgba := image.NewRGBA(img.Bounds())
+ draw.Draw(rgba, rgba.Bounds(), img, img.Bounds().Min, draw.Src)
+ return rgba
+ }
+}
+
+func resizeStaticImage(data []byte, size int, square bool) (io.Reader, int, error) {
+ original, format, err := image.Decode(bytes.NewReader(data))
+ if err != nil {
+ return nil, 0, err
+ }
+
+ bounds := original.Bounds()
+ originalSize := max(bounds.Max.X, bounds.Max.Y)
+
+ // Clamp size to original dimensions - upscaling wastes resources and adds no information
+ if size > originalSize {
+ size = originalSize
+ }
+
+ if originalSize <= size && !square {
+ return nil, originalSize, nil
+ }
+
+ // Calculate aspect-fit dimensions
+ srcW, srcH := bounds.Dx(), bounds.Dy()
+ scale := float64(size) / float64(max(srcW, srcH))
+ dstW := int(float64(srcW) * scale)
+ dstH := int(float64(srcH) * scale)
+
+ var dst *image.NRGBA
+ var dstRect image.Rectangle
+ if square {
+ // Square canvas with image centered (transparent padding via zero-initialized NRGBA)
+ dst = image.NewNRGBA(image.Rect(0, 0, size, size))
+ offsetX := (size - dstW) / 2
+ offsetY := (size - dstH) / 2
+ dstRect = image.Rect(offsetX, offsetY, offsetX+dstW, offsetY+dstH)
+ } else {
+ // Tight-fit canvas
+ dst = image.NewNRGBA(image.Rect(0, 0, dstW, dstH))
+ dstRect = dst.Bounds()
+ }
+ original = toFastScaleType(original)
+ xdraw.CatmullRom.Scale(dst, dstRect, original, bounds, draw.Src, nil)
+
+ buf := bufPool.Get().(*bytes.Buffer)
+ buf.Reset()
+ if conf.Server.EnableWebPEncoding {
+ err = webp.Encode(buf, dst, webp.Options{Quality: conf.Server.CoverArtQuality})
+ } else if format == "png" || square {
+ err = png.Encode(buf, dst)
+ } else {
+ err = jpeg.Encode(buf, dst, &jpeg.Options{Quality: conf.Server.CoverArtQuality})
+ }
+ if err != nil {
+ bufPool.Put(buf)
+ return nil, originalSize, err
+ }
+ // Copy bytes before returning buffer to pool (pool may reuse the buffer)
+ encoded := bytes.Clone(buf.Bytes())
+ bufPool.Put(buf)
+ return bytes.NewReader(encoded), originalSize, nil
+}
+
+// formatQualityTag folds the encoder config (WebP toggle + quality) into a cache-key
+// fragment, so flipping either setting invalidates previously-encoded sized artwork.
+func formatQualityTag() string {
+ if conf.Server.EnableWebPEncoding {
+ return fmt.Sprintf("webp%d", conf.Server.CoverArtQuality)
+ }
+ return fmt.Sprintf("q%d", conf.Server.CoverArtQuality)
+}
diff --git a/core/artwork/resolve.go b/core/artwork/resolve.go
new file mode 100644
index 000000000..11711469d
--- /dev/null
+++ b/core/artwork/resolve.go
@@ -0,0 +1,452 @@
+package artwork
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "image"
+ "io"
+ "io/fs"
+ "net/url"
+ "os"
+ "strings"
+
+ "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/core/ffmpeg"
+ "github.com/navidrome/navidrome/model"
+)
+
+// resolution is one attempted acquisition outcome for an entity.
+type resolution struct {
+ reader io.ReadCloser // nil when no source yielded an image
+ source string // model.ItemArtwork.Source value: "folder", "embedded", "external", "upload", "generated"
+ sourcePath string // backing library/upload file (folder/upload: the image; embedded: the audio file); "" otherwise
+ refMtime int64 // sourcePath mtime (unix-nanoseconds) at resolution; 0 when no sourcePath
+ // external source errored/timed out. With no reader it forces failed (never absent);
+ // on a hit a higher-priority external step failed—serve this, but retry later.
+ extError bool
+ // a local source that should have been readable wasn't. With no reader it forces failed,
+ // so a transient I/O fault never records absent.
+ localError bool
+}
+
+// chainState carries what a priority walk has seen so far. A hit takes extErr with it so a
+// transient external failure still retries; localErr is dropped, as the scanner re-lists changes.
+type chainState struct{ extErr, localErr bool }
+
+// try stamps the accumulated external failure onto a hit, and records the miss otherwise.
+func (c *chainState) try(res resolution, ok bool) (resolution, bool) {
+ if ok {
+ res.extError = c.extErr
+ return res, true
+ }
+ c.localErr = c.localErr || res.localError
+ return resolution{}, false
+}
+
+// exhausted is the outcome when no source in the chain yielded an image.
+func (c *chainState) exhausted() resolution {
+ return resolution{extError: c.extErr, localError: c.localErr}
+}
+
+// externalSource holds the agents to ask and the rate limiter/circuit breaker to ask them through.
+type externalSource struct {
+ agents *agents.Agents
+ gate gateFunc
+}
+
+// resolver walks a kind's priority chain and returns the first hit; a nil ext means local-only.
+type resolver struct {
+ ds model.DataStore
+ ffmpeg ffmpeg.FFmpeg
+ ext *externalSource
+}
+
+func newResolver(ds model.DataStore, ag *agents.Agents, ffm ffmpeg.FFmpeg, gate gateFunc) *resolver {
+ if gate == nil {
+ gate = passthroughGate
+ }
+ return &resolver{ds: ds, ffmpeg: ffm, ext: &externalSource{agents: ag, gate: gate}}
+}
+
+// newLocalResolver builds a resolver that can neither reach the network nor sample album art
+// for the worker-built grid.
+func newLocalResolver(ds model.DataStore, ffm ffmpeg.FFmpeg) *resolver {
+ return &resolver{ds: ds, ffmpeg: ffm}
+}
+
+func (r *resolver) resolve(ctx context.Context, item model.ArtworkQueueItem) (resolution, error) {
+ kind, _ := model.ParseKind(item.ItemKind)
+ switch kind {
+ case model.KindAlbumArtwork:
+ return r.resolveAlbum(ctx, item.ItemID)
+ case model.KindArtistArtwork:
+ return r.resolveArtist(ctx, item.ItemID)
+ case model.KindPlaylistArtwork:
+ return r.resolvePlaylist(ctx, item.ItemID)
+ case model.KindRadioArtwork:
+ return r.resolveRadio(ctx, item.ItemID)
+ case model.KindMediaFileArtwork:
+ return r.resolveMediaFile(ctx, item.ItemID)
+ default:
+ return resolution{}, fmt.Errorf("artwork: kind %q is not resolvable by the worker", item.ItemKind)
+ }
+}
+
+// fetchExternalAlbum and fetchExternalArtist are the only places resolution touches the network,
+// so a local-only resolver is stopped here rather than at each point in the chain walk.
+func (r *resolver) fetchExternalAlbum(ctx context.Context, al model.Album) (io.ReadCloser, string, bool) {
+ if r.ext == nil {
+ return nil, "", false
+ }
+ return fetchAlbumImage(ctx, r.ext.agents, r.ext.gate, al)
+}
+
+func (r *resolver) fetchExternalArtist(ctx context.Context, ar model.Artist) (io.ReadCloser, string, bool) {
+ if r.ext == nil {
+ return nil, "", false
+ }
+ return fetchArtistImage(ctx, r.ext.agents, r.ext.gate, ar)
+}
+
+// resolveAlbum walks conf.Server.CoverArtPriority over the folder, embedded and external sources.
+func (r *resolver) resolveAlbum(ctx context.Context, albumID string) (resolution, error) {
+ al, err := r.ds.Album(ctx).Get(albumID)
+ if err != nil {
+ return resolution{}, err
+ }
+ _, imgFiles, _, err := loadAlbumFoldersPaths(ctx, r.ds, *al)
+ if err != nil {
+ return resolution{}, err
+ }
+ lib, err := loadLibraryView(ctx, r.ds, al.LibraryID)
+ if err != nil {
+ return resolution{}, err
+ }
+
+ var chain chainState
+ for pattern := range strings.SplitSeq(strings.ToLower(conf.Server.CoverArtPriority), ",") {
+ pattern = strings.TrimSpace(pattern)
+ switch {
+ case pattern == "embedded":
+ if res, ok := chain.try(resolveEmbedded(ctx, lib, r.ffmpeg, al.EmbedArtPath)); ok {
+ return res, nil
+ }
+ case pattern == "external":
+ if rd, name, isErr := r.fetchExternalAlbum(ctx, *al); rd != nil {
+ return resolution{reader: rd, source: "external:" + name}, nil
+ } else if isErr {
+ chain.extErr = true
+ }
+ case len(imgFiles) > 0:
+ if res, ok := chain.try(resolveFolderFile(ctx, lib, imgFiles, pattern)); ok {
+ return res, nil
+ }
+ }
+ }
+ return chain.exhausted(), nil
+}
+
+// resolveArtist tries the uploaded image first, then walks conf.Server.ArtistArtPriority.
+func (r *resolver) resolveArtist(ctx context.Context, artistID string) (resolution, error) {
+ ar, err := r.ds.Artist(ctx).Get(artistID)
+ if err != nil {
+ return resolution{}, err
+ }
+ upload, ok := resolveLocalFile(ar.UploadedImagePath(), "upload")
+ if ok {
+ return upload, nil
+ }
+ if upload.localError {
+ // The upload outranks every other source; falling through would persist a lower-priority
+ // image as if the upload were gone.
+ return upload, nil
+ }
+
+ // Only consider albums where the artist is the sole album artist.
+ als, err := r.ds.Album(ctx).GetAll(model.QueryOptions{
+ Filters: squirrel.And{
+ squirrel.Eq{"album_artist_id": artistID},
+ squirrel.Eq{"json_array_length(participants, '$.albumartist')": 1},
+ },
+ })
+ if err != nil {
+ return resolution{}, err
+ }
+ albumPaths, imgFiles, _, err := loadArtistAlbumRoots(ctx, r.ds, als)
+ if err != nil {
+ return resolution{}, err
+ }
+ artistFolder, _, err := loadArtistFolder(ctx, r.ds, als, albumPaths)
+ if err != nil {
+ return resolution{}, err
+ }
+ var lib libraryView
+ if len(als) > 0 {
+ lib, err = loadLibraryView(ctx, r.ds, als[0].LibraryID)
+ if err != nil {
+ return resolution{}, err
+ }
+ }
+
+ var chain chainState
+ for pattern := range strings.SplitSeq(strings.ToLower(conf.Server.ArtistArtPriority), ",") {
+ pattern = strings.TrimSpace(pattern)
+ switch {
+ case pattern == "external":
+ if rd, name, isErr := r.fetchExternalArtist(ctx, *ar); rd != nil {
+ return resolution{reader: rd, source: "external:" + name}, nil
+ } else if isErr {
+ chain.extErr = true
+ }
+ case pattern == "image-folder":
+ if res, ok := chain.try(resolveArtistImageFolder(ar)); ok {
+ return res, nil
+ }
+ case strings.HasPrefix(pattern, "album/"):
+ if lib.FS == nil {
+ continue
+ }
+ if res, ok := chain.try(resolveFolderFile(ctx, lib, imgFiles, strings.TrimPrefix(pattern, "album/"))); ok {
+ return res, nil
+ }
+ default:
+ if lib.FS == nil || artistFolder == "" {
+ continue
+ }
+ if res, ok := chain.try(resolveArtistFolderPattern(ctx, lib, artistFolder, pattern)); ok {
+ return res, nil
+ }
+ }
+ }
+ return chain.exhausted(), nil
+}
+
+// resolvePlaylist tries the uploaded image, the sidecar and ExternalImageURL, then a generated grid.
+func (r *resolver) resolvePlaylist(ctx context.Context, playlistID string) (resolution, error) {
+ pl, err := r.ds.Playlist(ctx).Get(playlistID)
+ if err != nil {
+ return resolution{}, err
+ }
+
+ var extErr bool
+ for _, src := range []struct{ path, source string }{
+ {pl.UploadedImagePath(), "upload"},
+ {findPlaylistSidecarPath(ctx, pl.Path), "folder"},
+ } {
+ res, ok := resolveLocalFile(src.path, src.source)
+ if ok {
+ return res, nil
+ }
+ if res.localError {
+ // These outrank the generated grid; falling through would replace them with it.
+ return res, nil
+ }
+ }
+ // A local ExternalImageURL is file-backed and served in place; only http(s) needs the gated fetch.
+ localImg, remoteImg := classifyPlaylistImage(pl.ExternalImageURL)
+ if localImg != "" {
+ res, ok := resolveLocalFile(localImg, "folder")
+ if ok {
+ return res, nil
+ }
+ if res.localError {
+ return res, nil
+ }
+ }
+ if r.ext == nil {
+ // The remote fetch and the generated grid are worker-only; a request must do neither.
+ return resolution{}, nil
+ }
+ if remoteImg != nil && conf.Server.EnableM3UExternalAlbumArt {
+ sf := func() (io.ReadCloser, string, error) { return fromURL(ctx, remoteImg) }
+ if res, ok, isErr := resolveExternalStep(r.ext.gate, "m3u", sf); ok {
+ return res, nil
+ } else if isErr {
+ extErr = true
+ }
+ }
+
+ albumIDs, err := r.ds.Playlist(ctx).Tracks(pl.ID, false).GetAlbumIDs(model.QueryOptions{Max: 4, Sort: "random()"})
+ if err != nil {
+ return resolution{}, err
+ }
+
+ var tiles []image.Image
+ var tileErr error // first internal (non-external) tile failure, e.g. album deleted mid-flight
+ for _, albumID := range albumIDs {
+ res, err := r.resolveAlbum(ctx, albumID)
+ if err != nil {
+ if tileErr == nil {
+ tileErr = err
+ }
+ continue
+ }
+ if res.extError {
+ extErr = true
+ }
+ if res.reader == nil {
+ continue
+ }
+ tile, decErr := decodeTile(res.reader)
+ res.reader.Close()
+ if decErr == nil {
+ tiles = append(tiles, tile)
+ }
+ if len(tiles) == 4 {
+ break
+ }
+ }
+ if len(tiles) == 0 {
+ // A tile-level failure must never resolve as a clean absent.
+ if tileErr != nil {
+ return resolution{}, fmt.Errorf("resolvePlaylist: sampled album art failed: %w", tileErr)
+ }
+ return resolution{extError: extErr}, nil
+ }
+ // Grow to 4 tiles by repeating what we have.
+ switch len(tiles) {
+ case 2:
+ tiles = append(tiles, tiles[1], tiles[0])
+ case 3:
+ tiles = append(tiles, tiles[0])
+ }
+ grid, err := assembleTiles(tiles)
+ if err != nil {
+ return resolution{extError: extErr}, nil //nolint:nilerr // encode failure is a soft "no image", not a resolution error
+ }
+ return resolution{reader: grid, source: "generated", extError: extErr}, nil
+}
+
+// resolveRadio serves only an uploaded image; there is no fallback.
+func (r *resolver) resolveRadio(ctx context.Context, radioID string) (resolution, error) {
+ radio, err := r.ds.Radio(ctx).Get(radioID)
+ if err != nil {
+ return resolution{}, err
+ }
+ res, _ := resolveLocalFile(radio.UploadedImagePath(), "upload")
+ return res, nil
+}
+
+// resolveMediaFile resolves a track's own embedded art only, so disabled or missing cover art
+// is a definitive absent.
+func (r *resolver) resolveMediaFile(ctx context.Context, id string) (resolution, error) {
+ mf, err := r.ds.MediaFile(ctx).Get(id)
+ if err != nil {
+ return resolution{}, err
+ }
+ if !conf.Server.EnableMediaFileCoverArt || !mf.HasCoverArt {
+ return resolution{}, nil
+ }
+ lib, err := loadLibraryView(ctx, r.ds, mf.LibraryID)
+ if err != nil {
+ return resolution{}, err
+ }
+ res, _ := resolveEmbedded(ctx, lib, r.ffmpeg, mf.Path)
+ return res, nil
+}
+
+// resolveExternalStep runs a single external sourceFunc through the named gate. extErr excludes
+// a not-found, which is a definitive "no" rather than a failure.
+func resolveExternalStep(gate gateFunc, name string, sf sourceFunc) (res resolution, ok bool, extErr bool) {
+ r, path, err := gate(name, sf)
+ if r != nil {
+ return resolution{reader: r, source: "external", sourcePath: path}, true, false
+ }
+ return resolution{}, false, err != nil && !errors.Is(err, model.ErrNotFound)
+}
+
+// classifyPlaylistImage splits a playlist ExternalImageURL into a local filesystem path or a
+// remote http(s) URL; at most one is set.
+func classifyPlaylistImage(imageURL string) (localPath string, remote *url.URL) {
+ if imageURL == "" {
+ return "", nil
+ }
+ u, err := url.Parse(imageURL)
+ if err != nil {
+ return imageURL, nil // unparseable → treat as a local path
+ }
+ switch u.Scheme {
+ case "http", "https":
+ return "", u
+ case "file":
+ return u.Path, nil
+ default:
+ return imageURL, nil
+ }
+}
+
+func resolveEmbedded(ctx context.Context, lib libraryView, ffm ffmpeg.FFmpeg, embedRel string) (resolution, bool) {
+ if embedRel == "" {
+ return resolution{}, false
+ }
+ abs := lib.Abs(embedRel)
+ var unreadable bool
+ for _, sf := range []sourceFunc{fromTag(ctx, lib.FS, embedRel), fromFFmpegTag(ctx, ffm, abs)} {
+ r, _, err := sf()
+ if r != nil {
+ return resolution{reader: r, source: "embedded", sourcePath: abs, refMtime: mtimeViaFS(lib.FS, embedRel)}, true
+ }
+ unreadable = unreadable || errors.Is(err, errSourceUnreadable)
+ }
+ return resolution{localError: unreadable}, false
+}
+
+func resolveFolderFile(ctx context.Context, lib libraryView, imgFiles []string, pattern string) (resolution, bool) {
+ r, path, err := fromExternalFile(ctx, lib.FS, imgFiles, pattern)()
+ if r == nil {
+ return resolution{localError: errors.Is(err, errSourceUnreadable)}, false
+ }
+ return resolution{reader: r, source: "folder", sourcePath: lib.Abs(path), refMtime: mtimeViaFS(lib.FS, path)}, true
+}
+
+func resolveArtistImageFolder(ar *model.Artist) (resolution, bool) {
+ folder := conf.Server.ArtistImageFolder
+ if folder == "" {
+ return resolution{}, false
+ }
+ return resolveLocalFile(findImageInArtistFolder(folder, ar.MbzArtistID, ar.Name), "folder")
+}
+
+func resolveArtistFolderPattern(ctx context.Context, lib libraryView, artistFolder, pattern string) (resolution, bool) {
+ r, path, err := fromArtistFolder(ctx, lib.FS, lib.absRoot, artistFolder, pattern)()
+ if r == nil {
+ return resolution{localError: errors.Is(err, errSourceUnreadable)}, false
+ }
+ return resolution{reader: r, source: "folder", sourcePath: path, refMtime: mtimeOf(path)}, true
+}
+
+// resolveLocalFile opens an absolute path directly. A missing path is "no source"; any other
+// open failure says nothing about whether the image exists.
+func resolveLocalFile(path, source string) (resolution, bool) {
+ if path == "" {
+ return resolution{}, false
+ }
+ f, err := os.Open(path)
+ if err != nil {
+ return resolution{localError: !errors.Is(err, fs.ErrNotExist)}, false
+ }
+ return resolution{reader: f, source: source, sourcePath: path, refMtime: mtimeOf(path)}, true
+}
+
+func mtimeOf(path string) int64 {
+ info, err := os.Stat(path)
+ if err != nil {
+ return 0
+ }
+ return info.ModTime().UnixNano()
+}
+
+// mtimeViaFS stats through the library FS, since library roots in tests may not be real OS paths.
+func mtimeViaFS(fsys fs.FS, name string) int64 {
+ if fsys == nil || name == "" {
+ return 0
+ }
+ info, err := fs.Stat(fsys, name)
+ if err != nil {
+ return 0
+ }
+ return info.ModTime().UnixNano()
+}
diff --git a/core/artwork/resolve_test.go b/core/artwork/resolve_test.go
new file mode 100644
index 000000000..fc1a6a3ff
--- /dev/null
+++ b/core/artwork/resolve_test.go
@@ -0,0 +1,632 @@
+package artwork
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "image"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "sync/atomic"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("resolveItem", func() {
+ var (
+ ctx context.Context
+ ds *tests.MockDataStore
+ folderRepo *fakeFolderRepo
+ libRepo *tests.MockLibraryRepo
+ ffm *tests.MockFFmpeg
+ ag *agents.Agents
+ repoRoot string
+ )
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ ctx = context.Background()
+ var err error
+ repoRoot, err = os.Getwd()
+ Expect(err).ToNot(HaveOccurred())
+
+ folderRepo = &fakeFolderRepo{}
+ libRepo = &tests.MockLibraryRepo{}
+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})
+ ffm = tests.NewMockFFmpeg("")
+ ag = agents.GetAgents(&tests.MockDataStore{}, nil)
+ ds = &tests.MockDataStore{
+ MockedFolder: folderRepo,
+ MockedLibrary: libRepo,
+ }
+ })
+
+ Describe("kind dispatch", func() {
+ It("returns an error for kinds the worker never enqueues", func() {
+ _, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "zz", ItemID: "x"})
+ Expect(err).To(HaveOccurred())
+ })
+ })
+
+ Describe("media file", func() {
+ BeforeEach(func() {
+ conf.Server.EnableMediaFileCoverArt = true
+ ds.MockedMediaFile = tests.CreateMockMediaFileRepo()
+ })
+
+ It("resolves embedded art from the track file", func() {
+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+ {ID: "mf1", LibraryID: 0, Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true},
+ })
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "mf", ItemID: "mf1"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("embedded"))
+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/test.mp3"))
+ Expect(res.refMtime).To(BeNumerically(">", 0))
+ Expect(res.extError).To(BeFalse())
+ })
+
+ It("resolves absent when the track has no cover art", func() {
+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+ {ID: "mf2", LibraryID: 0, Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: false},
+ })
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "mf", ItemID: "mf2"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeFalse())
+ })
+
+ It("resolves absent when media file cover art is disabled", func() {
+ conf.Server.EnableMediaFileCoverArt = false
+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+ {ID: "mf3", LibraryID: 0, Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true},
+ })
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "mf", ItemID: "mf3"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ })
+
+ It("returns the error when the track is not in the DB", func() {
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "mf", ItemID: "missing"})
+ Expect(err).To(MatchError(model.ErrNotFound))
+ Expect(res.reader).To(BeNil())
+ })
+ })
+
+ Describe("album", func() {
+ BeforeEach(func() {
+ conf.Server.CoverArtPriority = "cover.jpg, embedded"
+ ds.MockedAlbum = tests.CreateMockAlbumRepo()
+ })
+
+ It("resolves folder art from the library FS", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al1", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al1"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("folder"))
+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/cover.jpg"))
+ Expect(res.refMtime).To(BeNumerically(">", 0))
+ Expect(res.extError).To(BeFalse())
+ })
+
+ It("falls back to embedded art when no folder image matches", func() {
+ folderRepo.result = nil
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al2", Name: "Album", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}},
+ })
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al2"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("embedded"))
+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/test.mp3"))
+ Expect(res.refMtime).To(BeNumerically(">", 0))
+ })
+
+ It("sets extError when the external source errors without being not-found", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al3", Name: "Album"},
+ })
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al3"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeTrue())
+ })
+
+ It("does not set extError when the external source reports not-found", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al4", Name: "Album"},
+ })
+ // no image agents enabled -> the external step is a definitive not-found
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al4"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeFalse())
+ })
+
+ It("carries extError onto a fallback folder hit after a transient external failure", func() {
+ conf.Server.CoverArtPriority = "external, cover.jpg"
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al6", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al6"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("folder"))
+ Expect(res.extError).To(BeTrue())
+ })
+
+ It("does not carry extError onto a fallback folder hit after a definitive external not-found", func() {
+ conf.Server.CoverArtPriority = "external, cover.jpg"
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al7", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+ // no image agents enabled -> the external step is a definitive not-found
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al7"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("folder"))
+ Expect(res.extError).To(BeFalse())
+ })
+
+ It("routes the external step through the injected gate, keyed by agent name", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al5", Name: "Album"},
+ })
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("boom")})
+ var gatedNames []string
+ gate := func(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {
+ gatedNames = append(gatedNames, name)
+ return f()
+ }
+
+ res, err := newResolver(ds, ag, ffm, gate).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "al5"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.extError).To(BeTrue())
+ Expect(gatedNames).To(Equal([]string{"failAgent"}))
+ })
+ })
+
+ Describe("artist", func() {
+ It("resolves the uploaded image before any priority chain lookup", func() {
+ tmpDir := GinkgoT().TempDir()
+ conf.Server.DataFolder = conf.NewDir(tmpDir)
+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "artist"), 0755)).To(Succeed())
+ imgPath := filepath.Join(tmpDir, "artwork", "artist", "ar1_test.jpg")
+ Expect(os.WriteFile(imgPath, []byte("uploaded artist image"), 0600)).To(Succeed())
+
+ artistRepo := tests.CreateMockArtistRepo()
+ artistRepo.SetData(model.Artists{{ID: "ar1", Name: "Artist", UploadedImage: "ar1_test.jpg"}})
+ ds.MockedArtist = artistRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar1"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("upload"))
+ Expect(res.sourcePath).To(Equal(imgPath))
+ })
+
+ It("falls through to the ArtistArtPriority chain when there is no upload", func() {
+ conf.Server.ArtistArtPriority = "album/artist.*"
+ folderRepo.result = []model.Folder{{
+ LibraryPath: testFileLibPath(repoRoot),
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"artist.png"},
+ }}
+ artistRepo := tests.CreateMockArtistRepo()
+ artistRepo.SetData(model.Artists{{ID: "ar2", Name: "Artist"}})
+ ds.MockedArtist = artistRepo
+ ds.MockedAlbum = tests.CreateMockAlbumRepo()
+ ds.MockedAlbum.(*tests.MockAlbumRepo).All = model.Albums{
+ {ID: "al9", Name: "Album", LibraryID: 0, FolderIDs: []string{"f1"}},
+ }
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar2"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("folder"))
+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("tests/fixtures/artist/an-album/artist.png"))
+ })
+
+ It("sets extError when the external source errors without being not-found", func() {
+ conf.Server.ArtistArtPriority = "external"
+ artistRepo := tests.CreateMockArtistRepo()
+ artistRepo.SetData(model.Artists{{ID: "ar3", Name: "Artist"}})
+ ds.MockedArtist = artistRepo
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar3"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeTrue())
+ })
+
+ It("does not set extError when the external source reports not-found", func() {
+ conf.Server.ArtistArtPriority = "external"
+ artistRepo := tests.CreateMockArtistRepo()
+ artistRepo.SetData(model.Artists{{ID: "ar4", Name: "Artist"}})
+ ds.MockedArtist = artistRepo
+ // no image agents enabled -> the external step is a definitive not-found
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar4"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeFalse())
+ })
+
+ It("routes the external step through the injected gate, keyed by agent name", func() {
+ conf.Server.ArtistArtPriority = "external"
+ artistRepo := tests.CreateMockArtistRepo()
+ artistRepo.SetData(model.Artists{{ID: "ar5", Name: "Artist"}})
+ ds.MockedArtist = artistRepo
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("boom")})
+ var gatedNames []string
+ gate := func(name string, f func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {
+ gatedNames = append(gatedNames, name)
+ return f()
+ }
+
+ res, err := newResolver(ds, ag, ffm, gate).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar5"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.extError).To(BeTrue())
+ Expect(gatedNames).To(Equal([]string{"failAgent"}))
+ })
+ })
+
+ Describe("radio", func() {
+ It("yields an empty resolution when there is no uploaded image", func() {
+ tmpDir := GinkgoT().TempDir()
+ conf.Server.DataFolder = conf.NewDir(tmpDir)
+
+ radioRepo := tests.CreateMockedRadioRepo()
+ radioRepo.Data = map[string]*model.Radio{"ra1": {ID: "ra1", Name: "Radio"}}
+ ds.MockedRadio = radioRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "ra1"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res).To(Equal(resolution{}))
+ })
+
+ It("resolves the uploaded image when set", func() {
+ tmpDir := GinkgoT().TempDir()
+ conf.Server.DataFolder = conf.NewDir(tmpDir)
+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "radio"), 0755)).To(Succeed())
+ imgPath := filepath.Join(tmpDir, "artwork", "radio", "ra2_test.jpg")
+ Expect(os.WriteFile(imgPath, []byte("uploaded radio image"), 0600)).To(Succeed())
+
+ radioRepo := tests.CreateMockedRadioRepo()
+ radioRepo.Data = map[string]*model.Radio{"ra2": {ID: "ra2", Name: "Radio", UploadedImage: "ra2_test.jpg"}}
+ ds.MockedRadio = radioRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "ra", ItemID: "ra2"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("upload"))
+ Expect(res.sourcePath).To(Equal(imgPath))
+ })
+ })
+
+ Describe("playlist", func() {
+ BeforeEach(func() {
+ conf.Server.CoverArtPriority = "cover.jpg"
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum = tests.CreateMockAlbumRepo()
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "t1", Name: "T1", FolderIDs: []string{"f1"}},
+ {ID: "t2", Name: "T2", FolderIDs: []string{"f1"}},
+ {ID: "t3", Name: "T3", FolderIDs: []string{"f1"}},
+ {ID: "t4", Name: "T4", FolderIDs: []string{"f1"}},
+ })
+ })
+
+ DescribeTable("yields a generated grid from up to 4 album tiles",
+ func(albumIDs []string, expectedSize int) {
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "pl1", Name: "Playlist"}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: albumIDs}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl1"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("generated"))
+
+ img, format, err := image.Decode(res.reader)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(format).To(Equal("png"))
+ Expect(img.Bounds().Dx()).To(Equal(expectedSize))
+ Expect(img.Bounds().Dy()).To(Equal(expectedSize))
+ },
+ // tileSize-1: the 4-tile canvas is built as [0, tileSize-1].
+ Entry("1 album -> single tile", []string{"t1"}, tileSize/2),
+ Entry("2 albums -> duplicated to 4 tiles", []string{"t1", "t2"}, tileSize-1),
+ Entry("3 albums -> duplicated to 4 tiles", []string{"t1", "t2", "t3"}, tileSize-1),
+ Entry("4 albums -> full grid", []string{"t1", "t2", "t3", "t4"}, tileSize-1),
+ )
+
+ It("resolves the uploaded image before the generated grid", func() {
+ tmpDir := GinkgoT().TempDir()
+ conf.Server.DataFolder = conf.NewDir(tmpDir)
+ Expect(os.MkdirAll(filepath.Join(tmpDir, "artwork", "playlist"), 0755)).To(Succeed())
+ imgPath := filepath.Join(tmpDir, "artwork", "playlist", "plu_test.jpg")
+ Expect(os.WriteFile(imgPath, []byte("uploaded playlist image"), 0600)).To(Succeed())
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "plu", Name: "Playlist", UploadedImage: "plu_test.jpg"}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1", "t2"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plu"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("upload"))
+ Expect(res.sourcePath).To(Equal(imgPath))
+ })
+
+ It("resolves a sidecar image next to the playlist file before the grid", func() {
+ plDir := GinkgoT().TempDir()
+ Expect(os.WriteFile(filepath.Join(plDir, "list.m3u"), []byte("#EXTM3U"), 0600)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(plDir, "list.jpg"), []byte("sidecar image"), 0600)).To(Succeed())
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "pls", Name: "Playlist", Path: filepath.Join(plDir, "list.m3u")}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1", "t2"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pls"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("folder"))
+ Expect(filepath.ToSlash(res.sourcePath)).To(HaveSuffix("list.jpg"))
+ })
+
+ It("serves a local ExternalImageURL as a file-backed reference (staleness-checked)", func() {
+ dir := GinkgoT().TempDir()
+ imgPath := filepath.Join(dir, "cover.png")
+ Expect(os.WriteFile(imgPath, []byte("local external image"), 0600)).To(Succeed())
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "pll", Name: "Playlist", ExternalImageURL: imgPath}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pll"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("folder"))
+ Expect(res.sourcePath).To(Equal(imgPath))
+ Expect(res.refMtime).To(BeNumerically(">", 0))
+ })
+
+ It("routes ExternalImageURL through extGate and sets extError on transient failure", func() {
+ conf.Server.EnableM3UExternalAlbumArt = true
+ folderRepo.result = nil // no grid tiles, so the external failure is what surfaces
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "ple", Name: "Playlist", ExternalImageURL: "http://example.com/cover.jpg"}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}
+ ds.MockedPlaylist = plRepo
+
+ var gatedNames []string
+ gate := func(name string, _ func() (io.ReadCloser, string, error)) (io.ReadCloser, string, error) {
+ gatedNames = append(gatedNames, name)
+ return nil, "", errors.New("network down")
+ }
+
+ res, err := newResolver(ds, ag, ffm, gate).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "ple"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeTrue())
+ Expect(gatedNames).To(Equal([]string{"m3u"}), "the playlist URL fetch is gated under \"m3u\"")
+ })
+
+ It("treats a missing local ExternalImageURL as a definitive miss, not extError", func() {
+ folderRepo.result = nil // no grid tiles, so the local-file miss is what surfaces
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "plm", Name: "Playlist", ExternalImageURL: "/nonexistent/path/cover.jpg"}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plm"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeFalse())
+ })
+
+ It("treats an ExternalImageURL 404 as a definitive miss and falls through to the grid", func() {
+ conf.Server.EnableM3UExternalAlbumArt = true
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer srv.Close()
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "pl404", Name: "Playlist", ExternalImageURL: srv.URL}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl404"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).ToNot(BeNil())
+ defer res.reader.Close()
+ Expect(res.source).To(Equal("generated"))
+ Expect(res.extError).To(BeFalse())
+ })
+
+ // A local resolver holds no agents: reaching the external branch would panic, not degrade.
+ It("skips the external step instead of dereferencing absent agents", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum = tests.CreateMockAlbumRepo()
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "alx", Name: "Album"}})
+
+ res, err := newLocalResolver(ds, ffm).resolve(ctx, model.ArtworkQueueItem{ItemKind: "al", ItemID: "alx"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeFalse(), "a skipped step is not a failed one")
+ })
+
+ // The worker resolving the same playlist is asserted alongside, so this cannot pass vacuously.
+ It("resolves a playlist locally without fetching remotely or building the grid", func() {
+ conf.Server.EnableM3UExternalAlbumArt = true
+ var hits atomic.Int32
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ hits.Add(1)
+ w.WriteHeader(http.StatusNotFound)
+ }))
+ defer srv.Close()
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "pllocal", Name: "Playlist", ExternalImageURL: srv.URL}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}
+ ds.MockedPlaylist = plRepo
+ item := model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pllocal"}
+
+ res, err := newLocalResolver(ds, ffm).resolve(ctx, item)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil(), "no local source, and the grid is worker-only")
+ Expect(hits.Load()).To(BeZero(), "a request must never reach the network")
+
+ worker, err := newResolver(ds, ag, ffm, nil).resolve(ctx, item)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(worker.reader).ToNot(BeNil())
+ defer worker.reader.Close()
+ Expect(worker.source).To(Equal("generated"), "the worker does build the grid")
+ Expect(hits.Load()).To(Equal(int32(1)), "and the worker does fetch")
+ })
+
+ It("treats an ExternalImageURL 500 as a transient failure and sets extError", func() {
+ conf.Server.EnableM3UExternalAlbumArt = true
+ folderRepo.result = nil // no grid tiles, so the external failure is what surfaces
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+ w.WriteHeader(http.StatusInternalServerError)
+ }))
+ defer srv.Close()
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "pl500", Name: "Playlist", ExternalImageURL: srv.URL}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl500"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.extError).To(BeTrue())
+ })
+
+ It("yields an empty resolution when no album has art", func() {
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "empty1", Name: "Empty"},
+ })
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "pl2", Name: "Playlist"}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"empty1"}}
+ ds.MockedPlaylist = plRepo
+ folderRepo.result = nil
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl2"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.source).To(BeEmpty())
+ })
+
+ It("skips a grid tile whose declared dimensions are a decompression bomb", func() {
+ libRoot := GinkgoT().TempDir()
+ Expect(os.MkdirAll(filepath.Join(libRoot, "bomb"), 0755)).To(Succeed())
+ Expect(os.WriteFile(filepath.Join(libRoot, "bomb", "cover.jpg"), pngHeaderWithDims(50000, 50000), 0600)).To(Succeed())
+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(libRoot)}})
+ folderRepo.result = []model.Folder{{Path: "bomb", ImageFiles: []string{"cover.jpg"}}}
+
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "plbomb", Name: "Playlist"}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"t1"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plbomb"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res.reader).To(BeNil())
+ Expect(res.source).To(BeEmpty())
+ })
+
+ It("does not resolve as absent when every sampled album fails to resolve", func() {
+ // The album ids are absent from MockAlbumRepo, so every tile fails non-externally.
+ plRepo := tests.CreateMockPlaylistRepo()
+ plRepo.SetData(model.Playlists{{ID: "pl3", Name: "Playlist"}})
+ plRepo.TracksRepo = &tests.MockPlaylistTrackRepo{AlbumIDs: []string{"missing1", "missing2"}}
+ ds.MockedPlaylist = plRepo
+
+ res, err := newResolver(ds, ag, ffm, nil).resolve(ctx, model.ArtworkQueueItem{ItemKind: "pl", ItemID: "pl3"})
+ Expect(err).To(HaveOccurred())
+ Expect(res).To(Equal(resolution{}))
+ })
+ })
+})
+
+// decodeTile runs before the processor's own guards, so it must enforce the caps itself.
+var _ = Describe("decodeTile", func() {
+ It("rejects a decompression bomb before the full decode", func() {
+ data := pngHeaderWithDims(50000, 50000) // 2.5 gigapixels, far above the cap
+ _, err := decodeTile(io.NopCloser(bytes.NewReader(data)))
+ Expect(err).To(HaveOccurred())
+ Expect(err.Error()).To(ContainSubstring("dimensions"))
+ })
+
+ It("rejects a tile larger than the size cap", func() {
+ data := bytes.Repeat([]byte{0}, maxImageBytes+1)
+ _, err := decodeTile(io.NopCloser(bytes.NewReader(data)))
+ Expect(err).To(HaveOccurred())
+ })
+})
diff --git a/core/artwork/sources.go b/core/artwork/sources.go
index 04a9257fb..885ca03cf 100644
--- a/core/artwork/sources.go
+++ b/core/artwork/sources.go
@@ -3,6 +3,7 @@ package artwork
import (
"bytes"
"context"
+ "errors"
"fmt"
"io"
"io/fs"
@@ -16,14 +17,16 @@ import (
"time"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/external"
"github.com/navidrome/navidrome/core/ffmpeg"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/resources"
"go.senan.xyz/taglib"
)
+// errSourceUnreadable marks a candidate the resolver knows exists but could not read. Failing
+// to open it is not evidence the entity has no artwork, so callers must not settle on absent.
+var errSourceUnreadable = errors.New("artwork source unreadable")
+
func selectImageReader(ctx context.Context, artID model.ArtworkID, extractFuncs ...sourceFunc) (io.ReadCloser, string, error) {
for _, f := range extractFuncs {
if ctx.Err() != nil {
@@ -32,11 +35,11 @@ func selectImageReader(ctx context.Context, artID model.ArtworkID, extractFuncs
start := time.Now()
r, path, err := f()
if r != nil {
- msg := fmt.Sprintf("Found %s artwork", artID.Kind)
+ msg := fmt.Sprintf("Artwork: Found %s artwork", artID.Kind)
log.Debug(ctx, msg, "artID", artID, "path", path, "source", f, "elapsed", time.Since(start))
return r, path, nil
}
- log.Trace(ctx, "Failed trying to extract artwork", "artID", artID, "source", f, "elapsed", time.Since(start), err)
+ log.Trace(ctx, "Artwork: Failed trying to extract artwork", "artID", artID, "source", f, "elapsed", time.Since(start), err)
}
return nil, "", fmt.Errorf("could not get `%s` cover art for %s: %w", artID.Kind, artID, ErrUnavailable)
}
@@ -55,11 +58,12 @@ func (f sourceFunc) String() string {
func fromExternalFile(ctx context.Context, libFS fs.FS, files []string, pattern string) sourceFunc {
return func() (io.ReadCloser, string, error) {
+ var openErr error
for _, file := range files {
_, name := filepath.Split(file)
match, err := filepath.Match(pattern, strings.ToLower(name))
if err != nil {
- log.Warn(ctx, "Error matching cover art file to pattern", "pattern", pattern, "file", file)
+ log.Warn(ctx, "Artwork: Error matching cover art file to pattern", "pattern", pattern, "file", file)
continue
}
if !match {
@@ -67,11 +71,15 @@ func fromExternalFile(ctx context.Context, libFS fs.FS, files []string, pattern
}
f, err := libFS.Open(file)
if err != nil {
- log.Warn(ctx, "Could not open cover art file", "file", file, err)
+ log.Warn(ctx, "Artwork: Could not open cover art file", "file", file, err)
+ openErr = fmt.Errorf("%w: %s: %w", errSourceUnreadable, file, err)
continue
}
return f, file, nil
}
+ if openErr != nil {
+ return nil, "", openErr
+ }
return nil, "", fmt.Errorf("pattern '%s' not matched by files %v", pattern, files)
}
}
@@ -90,7 +98,7 @@ func fromTag(ctx context.Context, libFS fs.FS, relPath string) sourceFunc {
}
f, err := libFS.Open(relPath)
if err != nil {
- return nil, "", err
+ return nil, "", fmt.Errorf("%w: %s: %w", errSourceUnreadable, relPath, err)
}
rs, ok := f.(io.ReadSeeker)
if !ok {
@@ -103,7 +111,7 @@ func fromTag(ctx context.Context, libFS fs.FS, relPath string) sourceFunc {
)
if err != nil {
f.Close()
- return nil, "", err
+ return nil, "", fmt.Errorf("%w: %s: %w", errSourceUnreadable, relPath, err)
}
// Close in LIFO order: tf first (it holds rs internally), then f.
defer f.Close()
@@ -127,12 +135,12 @@ func findBestImageIndex(ctx context.Context, images []taglib.ImageDesc, path str
for _, regex := range picTypeRegexes {
for i, img := range images {
if regex.MatchString(img.Type) {
- log.Trace(ctx, "Found embedded image", "type", img.Type, "path", path)
+ log.Trace(ctx, "Artwork: Found embedded image", "type", img.Type, "path", path)
return i
}
}
}
- log.Trace(ctx, "Could not find a front image. Getting the first one", "type", images[0].Type, "path", path)
+ log.Trace(ctx, "Artwork: Could not find a front image. Getting the first one", "type", images[0].Type, "path", path)
return 0
}
@@ -171,44 +179,6 @@ type readCloser struct {
io.Closer
}
-func fromAlbum(ctx context.Context, a *artwork, id model.ArtworkID) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- r, _, err := a.Get(ctx, id, 0, false)
- if err != nil {
- return nil, "", err
- }
- return r, id.String(), nil
- }
-}
-
-func fromAlbumPlaceholder() sourceFunc {
- return func() (io.ReadCloser, string, error) {
- r, _ := resources.FS().Open(consts.PlaceholderAlbumArt)
- return r, consts.PlaceholderAlbumArt, nil
- }
-}
-func fromArtistExternalSource(ctx context.Context, ar model.Artist, provider external.Provider) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- imageUrl, err := provider.ArtistImage(ctx, ar.ID)
- if err != nil {
- return nil, "", err
- }
-
- return fromURL(ctx, imageUrl)
- }
-}
-
-func fromAlbumExternalSource(ctx context.Context, al model.Album, provider external.Provider) sourceFunc {
- return func() (io.ReadCloser, string, error) {
- imageUrl, err := provider.AlbumImage(ctx, al.ID)
- if err != nil {
- return nil, "", err
- }
-
- return fromURL(ctx, imageUrl)
- }
-}
-
func fromURL(ctx context.Context, imageUrl *url.URL) (io.ReadCloser, string, error) {
hc := http.Client{Timeout: 5 * time.Second}
req, _ := http.NewRequestWithContext(ctx, http.MethodGet, imageUrl.String(), nil)
@@ -217,6 +187,12 @@ func fromURL(ctx context.Context, imageUrl *url.URL) (io.ReadCloser, string, err
if err != nil {
return nil, "", err
}
+ // An agent-advertised URL that 404s is a definitive miss, not a fault: settle absent
+ // instead of retrying forever and tripping the artwork breaker.
+ if resp.StatusCode == http.StatusNotFound || resp.StatusCode == http.StatusGone {
+ resp.Body.Close()
+ return nil, "", model.ErrNotFound
+ }
if resp.StatusCode != http.StatusOK {
resp.Body.Close()
return nil, "", fmt.Errorf("error retrieving artwork from %s: %s", imageUrl, resp.Status)
diff --git a/core/artwork/thumbhash/testdata/alpha.png b/core/artwork/thumbhash/testdata/alpha.png
new file mode 100644
index 000000000..6ac85943a
Binary files /dev/null and b/core/artwork/thumbhash/testdata/alpha.png differ
diff --git a/core/artwork/thumbhash/testdata/gen_fixtures.mjs b/core/artwork/thumbhash/testdata/gen_fixtures.mjs
new file mode 100644
index 000000000..b2e488b51
--- /dev/null
+++ b/core/artwork/thumbhash/testdata/gen_fixtures.mjs
@@ -0,0 +1,90 @@
+// Generates lossless PNG fixtures <=100px. Run: node gen_fixtures.mjs
+import { writeFileSync } from 'fs'
+import { deflateSync } from 'zlib'
+
+const crcTable = Array.from({ length: 256 }, (_, n) => {
+ let c = n
+ for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1
+ return c >>> 0
+})
+const crc32 = (buf) => {
+ let c = 0xffffffff
+ for (const b of buf) c = crcTable[(c ^ b) & 0xff] ^ (c >>> 8)
+ return (c ^ 0xffffffff) >>> 0
+}
+const chunk = (type, data) => {
+ const len = Buffer.alloc(4)
+ len.writeUInt32BE(data.length)
+ const body = Buffer.concat([Buffer.from(type, 'ascii'), data])
+ const crc = Buffer.alloc(4)
+ crc.writeUInt32BE(crc32(body))
+ return Buffer.concat([len, body, crc])
+}
+const png = (w, h, rgba) => {
+ const ihdr = Buffer.alloc(13)
+ ihdr.writeUInt32BE(w, 0)
+ ihdr.writeUInt32BE(h, 4)
+ ihdr[8] = 8 // bit depth
+ ihdr[9] = 6 // truecolor + alpha
+ const raw = Buffer.alloc(h * (w * 4 + 1))
+ for (let y = 0; y < h; y++) {
+ raw[y * (w * 4 + 1)] = 0 // filter: none
+ for (let x = 0; x < w * 4; x++) raw[y * (w * 4 + 1) + 1 + x] = rgba[y * w * 4 + x]
+ }
+ return Buffer.concat([
+ Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+ chunk('IHDR', ihdr),
+ chunk('IDAT', deflateSync(raw)),
+ chunk('IEND', Buffer.alloc(0)),
+ ])
+}
+
+// A ramp has exactly-zero DCT coefficients, and a zero coefficient's nibble is decided by float
+// rounding noise, so no two summation orders agree on it. Dither gives every coefficient signal.
+let seed = 0
+const dither = () => {
+ seed ^= seed << 13
+ seed ^= seed >>> 17
+ seed ^= seed << 5
+ seed >>>= 0
+ return (seed % 9) - 4
+}
+const shade = (v) => Math.max(0, Math.min(255, v + dither()))
+
+const make = (w, h, fn) => {
+ seed = 0x9e3779b9
+ const rgba = new Uint8Array(w * h * 4)
+ for (let y = 0; y < h; y++)
+ for (let x = 0; x < w; x++) fn(rgba, (y * w + x) * 4, x, y, w, h)
+ return png(w, h, rgba)
+}
+
+const gradient = (rgba, i, x, y, w, h) => {
+ rgba[i] = shade(Math.floor((255 * x) / w))
+ rgba[i + 1] = shade(Math.floor((255 * y) / h))
+ rgba[i + 2] = shade(Math.floor((255 * (x + y)) / (w + h)))
+ rgba[i + 3] = 255
+}
+const solid = (rgba, i) => {
+ rgba[i] = 60
+ rgba[i + 1] = 120
+ rgba[i + 2] = 180
+ rgba[i + 3] = 255
+}
+// RGB must vary with position too: a constant color composited over its own average cancels to a
+// flat L/P/Q (the bug this fixture exists to catch), so pair a color gradient with the alpha ramp.
+const alphaRamp = (rgba, i, x, y, w, h) => {
+ rgba[i] = shade(Math.floor((255 * x) / w))
+ rgba[i + 1] = shade(Math.floor((255 * y) / h))
+ rgba[i + 2] = shade(Math.floor((255 * (x + y)) / (w + h)))
+ rgba[i + 3] = shade(Math.floor((255 * (x + 2 * y)) / (w + 2 * h)))
+}
+
+const out = new URL('.', import.meta.url).pathname
+writeFileSync(out + 'square.png', make(100, 100, gradient))
+writeFileSync(out + 'landscape.png', make(100, 60, gradient))
+writeFileSync(out + 'portrait.png', make(60, 100, gradient))
+writeFileSync(out + 'alpha.png', make(80, 80, alphaRamp))
+writeFileSync(out + 'solid.png', make(64, 64, solid))
+writeFileSync(out + 'tiny.png', make(1, 1, solid))
+console.log('fixtures written')
diff --git a/core/artwork/thumbhash/testdata/gen_generated.mjs b/core/artwork/thumbhash/testdata/gen_generated.mjs
new file mode 100644
index 000000000..e8eae585e
--- /dev/null
+++ b/core/artwork/thumbhash/testdata/gen_generated.mjs
@@ -0,0 +1,28 @@
+// Produces generated.json: ThumbHashes of synthetic images, from the vendored reference.
+// The pixels are a pure function of their index, so Go rebuilds them byte-for-byte from the same
+// formula and only the hashes need committing. Run: node gen_generated.mjs
+import { writeFileSync } from 'fs'
+import { rgbaToThumbHash } from './thumbhash.js'
+
+const COUNT = 300
+
+// mix is a stateless 32-bit finaliser; Go's mix in thumbhash_test.go must match it exactly.
+const mix = (n) => {
+ n = Math.imul(n ^ (n >>> 16), 2246822507) >>> 0
+ n = Math.imul(n ^ (n >>> 13), 3266489909) >>> 0
+ return (n ^ (n >>> 16)) >>> 0
+}
+
+const out = []
+for (let i = 0; i < COUNT; i++) {
+ const w = 1 + (mix(i * 3 + 1) % 100)
+ const h = 1 + (mix(i * 3 + 2) % 100)
+ const rgba = new Uint8Array(w * h * 4)
+ for (let k = 0; k < rgba.length; k++) rgba[k] = mix(i * 1000003 + k) & 255
+ // Random alpha is opaque essentially never, so half are forced opaque to exercise the 7x7
+ // no-alpha layout as often as the 5x5-plus-alpha one.
+ if (i % 2 === 0) for (let k = 3; k < rgba.length; k += 4) rgba[k] = 255
+ out.push({ w, h, hash: Buffer.from(rgbaToThumbHash(w, h, rgba)).toString('base64') })
+}
+writeFileSync(new URL('.', import.meta.url).pathname + 'generated.json', JSON.stringify(out) + '\n')
+console.log(`${out.length} vectors; first ${out[0].w}x${out[0].h} ${out[0].hash}`)
diff --git a/core/artwork/thumbhash/testdata/gen_golden.mjs b/core/artwork/thumbhash/testdata/gen_golden.mjs
new file mode 100644
index 000000000..2825e0709
--- /dev/null
+++ b/core/artwork/thumbhash/testdata/gen_golden.mjs
@@ -0,0 +1,37 @@
+// Produces golden.json from the vendored reference. Run: node gen_golden.mjs
+import { readFileSync, writeFileSync, readdirSync } from 'fs'
+import { inflateSync } from 'zlib'
+import { rgbaToThumbHash } from './thumbhash.js'
+
+// Minimal reader for the exact PNGs gen_fixtures.mjs writes: 8-bit RGBA, filter 0, single IDAT.
+const readPNG = (buf) => {
+ let w = 0, h = 0
+ const idat = []
+ for (let off = 8; off < buf.length; ) {
+ const len = buf.readUInt32BE(off)
+ const type = buf.toString('ascii', off + 4, off + 8)
+ const data = buf.subarray(off + 8, off + 8 + len)
+ if (type === 'IHDR') {
+ w = data.readUInt32BE(0)
+ h = data.readUInt32BE(4)
+ if (data[8] !== 8 || data[9] !== 6) throw new Error('expected 8-bit RGBA')
+ } else if (type === 'IDAT') idat.push(data)
+ off += 12 + len
+ }
+ const raw = inflateSync(Buffer.concat(idat))
+ const rgba = new Uint8Array(w * h * 4)
+ for (let y = 0; y < h; y++) {
+ if (raw[y * (w * 4 + 1)] !== 0) throw new Error('expected filter 0')
+ for (let x = 0; x < w * 4; x++) rgba[y * w * 4 + x] = raw[y * (w * 4 + 1) + 1 + x]
+ }
+ return { w, h, rgba }
+}
+
+const dir = new URL('.', import.meta.url).pathname
+const golden = {}
+for (const name of readdirSync(dir).filter((f) => f.endsWith('.png')).sort()) {
+ const { w, h, rgba } = readPNG(readFileSync(dir + name))
+ golden[name] = Buffer.from(rgbaToThumbHash(w, h, rgba)).toString('base64')
+}
+writeFileSync(dir + 'golden.json', JSON.stringify(golden, null, 2) + '\n')
+console.log(golden)
diff --git a/core/artwork/thumbhash/testdata/generated.json b/core/artwork/thumbhash/testdata/generated.json
new file mode 100644
index 000000000..1b49bbb03
--- /dev/null
+++ b/core/artwork/thumbhash/testdata/generated.json
@@ -0,0 +1 @@
+[{"w":28,"h":79,"hash":"4AcCCgBFgGVnc6OLh2u/b7Y="},{"w":94,"h":86,"hash":"4PeBBYAIBZlXeaVKmwl6Zx+i9EeEUqdlGA=="},{"w":61,"h":88,"hash":"3/cBBQCxf6l3ioV1WadpmG+B7Pm4"},{"w":29,"h":41,"hash":"H/iBDAIHX5Chbnyqawdo8otij7N3a0qJBA=="},{"w":63,"h":74,"hash":"3wcCBgB0x884dZeDiopMhclYDUpUAm4="},{"w":29,"h":25,"hash":"HwiCBIIHF79zi6+Gg2fAhk/4fEtnapaYDQ=="},{"w":57,"h":98,"hash":"H/gBBABIejmXynwHHoVAnvdXSw=="},{"w":71,"h":69,"hash":"IPiBBYAHmD2KUW/lQQyLaLCDh0KklFn32g=="},{"w":71,"h":50,"hash":"3/cBBYBohqhLaJpwZoZUd011gBCJ"},{"w":89,"h":83,"hash":"4PeBBYAHkBp+Q/bXx0CSiZ+sT4Z4fIyYZg=="},{"w":92,"h":57,"hash":"IPgBBICgJdaPlJqBnUfQcGbwdA=="},{"w":39,"h":95,"hash":"3/eBAgAIymeYlAuWDQ9RUidjZat7jxk="},{"w":100,"h":82,"hash":"4AcCBoDiuKh2N+TrR6fh9nFm+5lp8Kc="},{"w":92,"h":93,"hash":"HwiCBQAIuI2JaEYDVRA6gU/q5PxIULPapw=="},{"w":67,"h":90,"hash":"IPgBBQC1bGaGk47Hl3+nddp6vwuY"},{"w":78,"h":71,"hash":"HwiCBYAHmZZIYn9JhXCLjZaQSWV2ZUGrfw=="},{"w":85,"h":42,"hash":"4AcCA4KeKZCAlcZzkAz7i6k="},{"w":8,"h":50,"hash":"3/eBCQAH+IVwSkj7IiZPL/h0dYpCSEg="},{"w":13,"h":78,"hash":"HwgCCQJGjqtkmUowdno/3fY="},{"w":66,"h":95,"hash":"HwiCAwAHCjuAqh2Fn/H9K5loYGiYmJU="},{"w":2,"h":84,"hash":"nvcFEQJ7c7iHmKwJj5iHCGA="},{"w":37,"h":32,"hash":"IAiCBIIIldBHeXKZ6f3EA2DV0K2GZkvDBA=="},{"w":41,"h":25,"hash":"3wcCDII7Jst5c0WFhga8cEnTBg=="},{"w":57,"h":26,"hash":"IPiBAoAIuvRneZfgjPSmAhZrl9W8SPU="},{"w":31,"h":40,"hash":"IPgBDQK6o7REKkCxJ1cXRlNqsK+B"},{"w":7,"h":69,"hash":"3veBCQIHdoKrFgYOxqU5cAVYqapmgjQ="},{"w":82,"h":59,"hash":"3/cBBYD4M6tIe6iJenZX0jv3i6QF"},{"w":85,"h":48,"hash":"IAiCA4AHyKR2lgvPG0TFBnXQWGkydzw="},{"w":53,"h":67,"hash":"HwgCBgKbVol5V393ersDOea29bSlZPk="},{"w":79,"h":26,"hash":"IAiCAoAI6QZtSGnvJmnwcJiHZquG+Hc="},{"w":14,"h":28,"hash":"3/cBDAJIhLeYi1+pu1owyIVvMg=="},{"w":85,"h":78,"hash":"4AeCBYAHXPhldaZ2ibVPVQmKh/iJlZQrig=="},{"w":26,"h":67,"hash":"H/gBCwI4T6OnR3GPhq81kGo="},{"w":51,"h":13,"hash":"IPiBCYII24eGC4VNfYAJR/S6V8WLeyg="},{"w":57,"h":81,"hash":"4AcCBQCoojSIY0qYe3f3UQGuawz+"},{"w":8,"h":72,"hash":"4PeBCQIHSUVYVn8ANrQoB3UWWYiXWbA="},{"w":89,"h":40,"hash":"IAgCA4LDe0AG5hb2aM8bcEM="},{"w":55,"h":94,"hash":"3/eBAwAHpIVmT7VvjwahW2NPhkiaDok="},{"w":59,"h":81,"hash":"H/gBDQBERoZIo4nKhqgKaJYvSkVA"},{"w":41,"h":45,"hash":"3/eBBQAHdeyYm3UGRR99adcGQ0RwRZpGmA=="},{"w":11,"h":28,"hash":"HxgCCwLHZnhGlGVggoAJ6GU="},{"w":8,"h":36,"hash":"4PeBCQIIbWHpldBF78rO/EKZaaiAqHo="},{"w":40,"h":100,"hash":"IAgCAwAIT2uoiESGs1BDrxw="},{"w":63,"h":33,"hash":"3weCA4IHmrEpmk9KVK92+LOxI+sLqfs="},{"w":72,"h":63,"hash":"HwgCBoCYlQZkaHeXaeabRJit12VwH7Y="},{"w":29,"h":90,"hash":"3/eBAgAIzqlo+KRtoAl1qh2KO7ZwWWo="},{"w":81,"h":26,"hash":"IPgBAoJVdauz6giWSnhgCYk="},{"w":92,"h":76,"hash":"IPiBBIAHrET8bFvpCZQdZQubVvO0vEV5DQ=="},{"w":85,"h":99,"hash":"3wcCBgB4L9nVxUhpWUyqb76n4LjPOfw="},{"w":79,"h":72,"hash":"4AeCBYAHWneox5/01wN7aHnvSAZscNB3qA=="},{"w":76,"h":18,"hash":"4PcBCoL6mZdmelSFz5UU9EQ="},{"w":78,"h":90,"hash":"4PeBBAAIDnhKoKRQpgBqMJy+iar8L4pZDg=="},{"w":72,"h":13,"hash":"3+cBCYKsdkJZyx6/lICO+8I="},{"w":78,"h":19,"hash":"H/iBAYAImX9hwHSeDXImENV3UIN1hMc="},{"w":29,"h":34,"hash":"IAgCDgB+WIp4KreKyhKJX6mqKKCvEI0="},{"w":63,"h":43,"hash":"H/iBA4AI++eiSIlZkLl/ZwKZhrlnSqg="},{"w":19,"h":79,"hash":"3wcCCgD1k3t0hnYqBHm6Di4="},{"w":82,"h":44,"hash":"3/eBA4AIqi2AjW6pr5YLmwF+OlNou7s="},{"w":70,"h":24,"hash":"3wcCCoAyRWCKl2Z3kHa6A1o="},{"w":28,"h":93,"hash":"4PeBCgAHwrsHVqZgqIePdy6kkJh4RRY="},{"w":44,"h":28,"hash":"H/gBBIJ2xMevRKKpZ4bnUTD6hQ=="},{"w":77,"h":9,"hash":"HwiCCYIIxixdZgmgw/m6OIcDrDM6WZ0="},{"w":59,"h":39,"hash":"H/gBBYKlW6qoh11be/NmovTQCbYc"},{"w":9,"h":93,"hash":"4PeBAQIHFVn4p5mIv/DH95KWbUXgUOk="},{"w":9,"h":96,"hash":"3wcCAQKKqluVczewLNPP0G8="},{"w":54,"h":83,"hash":"IPiBAwAIZVRaj5dvnH4NiFfGpfFPxjg="},{"w":75,"h":3,"hash":"3/cFEYR4iPWKmIiV99OsmPc="},{"w":96,"h":42,"hash":"4PeBAoAHcJqRe3qfQ6f3THWIkFi2ivY="},{"w":74,"h":8,"hash":"4PcBCYJ8JYC0NJh5+a5HnaA="},{"w":2,"h":95,"hash":"oPeBCQR3f82Im7eL3/dIdXgHiHiHiHc="},{"w":40,"h":25,"hash":"3/cBDIJGPXu1PFWvGyI2SH8JWA=="},{"w":48,"h":56,"hash":"H/iBDAAHU4OHDHmKpoT1qngAiHZWl2d4CQ=="},{"w":71,"h":18,"hash":"3/cBCoBFzceDtlBaL20Z8Ok="},{"w":60,"h":44,"hash":"3/eBBIAHqreoZmb9ePMT+YS4hIZZmncHCg=="},{"w":42,"h":25,"hash":"3/cBDIKPdrNMd9eNmFlSn7SZCw=="},{"w":64,"h":67,"hash":"IPiBBQAHbSpXaJBWxEgLybIIa6jFdgxmsw=="},{"w":74,"h":85,"hash":"4AcCBgCVe0R0W1l7eTSq0/dH+zScBSU="},{"w":42,"h":71,"hash":"4AeCAwAIZyCedbhPdZlPiaKXHQRSNeA="},{"w":61,"h":34,"hash":"H/gBBII/nL94LK58lLTVCUz9Jw=="},{"w":26,"h":66,"hash":"4AeCCgAISob0BHp4m1BvNhVnCiiFAtM="},{"w":17,"h":62,"hash":"IAgCCgI8jI9nEofooGprka8="},{"w":58,"h":90,"hash":"IAiCAwAI+Rt0bsP6o/o02aef81rcY4g="},{"w":41,"h":96,"hash":"H/gBAwDLuolgvElQHQppYPY="},{"w":57,"h":6,"hash":"IPiBCYIIh0q8dn/PhQBnd8ApWKNbdKo="},{"w":38,"h":47,"hash":"4PcBDgI6lpeRR2aABrhXvWW0UNaEIHg="},{"w":76,"h":6,"hash":"3xeCCYAISIuiIk91a6CpEKQVvUdsBYc="},{"w":85,"h":66,"hash":"H/gBBYDvamWWd5h1Vo2YlvdTB6/w"},{"w":7,"h":52,"hash":"4AeCCQII+ZuGYmj6XPaXdqa3B0a2dNA="},{"w":1,"h":4,"hash":"Hhk+UjgIh2iYh4iYGIuPh/g="},{"w":19,"h":26,"hash":"3weCDAIHY2JJumCmuqb1ToC4Yy94dxtUBw=="},{"w":63,"h":98,"hash":"3/cBBQBSUpp6Kn2Gnn+ikgXX5EBM"},{"w":36,"h":27,"hash":"IPiBBIAHh6xAemiM6Of5b5+q+XOJtpUwBg=="},{"w":69,"h":50,"hash":"IAgCBYK2ilWImIhgd8ikFPeoVvSn"},{"w":17,"h":100,"hash":"HwiCAQAI8el0tLUJG2OAFon6I0mAZ8U="},{"w":59,"h":24,"hash":"4AcCC4Inv4c4e2OIYDUGV7g="},{"w":57,"h":48,"hash":"3/eBBIAHBXh6Y4qllpB1ryKBqvqpSomhDA=="},{"w":90,"h":41,"hash":"IAgCC4CidBWGNweJm6+coBY="},{"w":68,"h":3,"hash":"oBiCCYII8hsmqlAgxcXwJHh2mAVZhWc="},{"w":77,"h":25,"hash":"4PcBCoL0iEqFdXO2zo+n9Eo="},{"w":50,"h":41,"hash":"HwiCBIAHSK9XhZbW6qiAX4j+o1Yn5JPmBA=="},{"w":95,"h":87,"hash":"3/cBBoBbqfUutpKElbmKm4B0C4I0ePA="},{"w":19,"h":7,"hash":"H/iBCoIYmUl/V1VESZ+mA6eLeHenBnY="},{"w":62,"h":28,"hash":"3wcCC4JqV4G1jAeTn3ttsvs="},{"w":80,"h":84,"hash":"HwiCBQAItaKauK+3WPxqSRf6TQlTiYgs1w=="},{"w":58,"h":11,"hash":"IPgBCYJWdVboUvKJ+nc6wI4="},{"w":62,"h":1,"hash":"oRjCKYZ3iIiIiHCXiJCLCIeIiIiAd/g="},{"w":83,"h":84,"hash":"IAgCBwCXsHOreqRrykpmV4t8lq9nsqEP"},{"w":38,"h":50,"hash":"HwiCBAAIMJSGqHiF+EsGGyZ/MLJmynBjAA=="},{"w":90,"h":25,"hash":"4AcCAoAmQEenlsuKgE4WyvY="},{"w":44,"h":34,"hash":"4AeCDIAIlUgqYFOZB1WIemC1gMKUhIq2Bg=="},{"w":44,"h":58,"hash":"4AcCDQJ1xMubx4YIEjhy2ct7H/IW"},{"w":53,"h":97,"hash":"3/eBAwAIfvkuWL5QdinGj6Tb3EAkpKk="},{"w":46,"h":78,"hash":"3wcCBAD69gtnSeOmSQvGoFC4QA=="},{"w":1,"h":91,"hash":"Xui9GQR3CIiHeIgIiXhfqAj3h4iHiHg="},{"w":62,"h":53,"hash":"HwgCBoDPnGynWGlHeHhaWbZ4ymtwP7k="},{"w":31,"h":16,"hash":"HwiCC4IHYMrnVnx9T5138ke3RXBlSHs="},{"w":79,"h":89,"hash":"3wcCBgCwS65nmVZ1Z3pFOze0G4xfP4U="},{"w":88,"h":46,"hash":"HwiCA4AIeft1qUicgPivQEqYkHp7hEY="},{"w":42,"h":42,"hash":"IAgCBwJd0ybqWZCUd6pdbkhHCZnq9ZoE"},{"w":33,"h":75,"hash":"4AeCAgAIin9mWYoCq51AulUCcmlfBB0="},{"w":74,"h":1,"hash":"3ic+AYp4h4eIiAiHD4hcjQg="},{"w":55,"h":35,"hash":"4AeCA4AIeIClN5NyENOgNZyaiIljBmw="},{"w":2,"h":11,"hash":"HlgKIQZwiHh0aZdocCUKd0w="},{"w":29,"h":33,"hash":"IPiBDAIH9lRItpqqd6CWmKAo+ad49JdoCg=="},{"w":63,"h":40,"hash":"HwgCBIBmUIs2Vol2OVgfOEvSHw=="},{"w":77,"h":90,"hash":"4PeBBAAINniEP5lGAIykwV9XCmS5VmjHCg=="},{"w":78,"h":14,"hash":"3wcCCYBGGoFHx5agj3xrR+8="},{"w":37,"h":40,"hash":"4PeBBQAHy1gEeihmdftWmwDn5DhniHAnSA=="},{"w":79,"h":27,"hash":"H/gBCoCc92ZmanaKgGcGl5k="},{"w":32,"h":86,"hash":"3weCAgAHW6NocGpT+AjOVShetbR/aso="},{"w":14,"h":30,"hash":"H/gBCwLNrIeFxaZPd6YvX1o="},{"w":33,"h":30,"hash":"oAeCBYIHarRwplZVhZj915j1dwd5Y352aQ=="},{"w":62,"h":95,"hash":"H/gBBQB5kGdZ1udkd3lJiV2PbAVc"},{"w":38,"h":93,"hash":"3weCAgAH5D7FRwOFXbAZ+fVpeYk0iHY="},{"w":47,"h":32,"hash":"3/cBDYJ0r1iqSJRkd6p3V3s/a9B/"},{"w":24,"h":9,"hash":"3weCCoIXijxlaV+Eb3RI9odfWVeFVEo="},{"w":17,"h":54,"hash":"4PcBAgSYZHWYgGhbIwMCqHU="},{"w":8,"h":78,"hash":"X/iBAQIIiFJTAjdPiZYEl2PU18bU8nQ="},{"w":8,"h":29,"hash":"HvgBCgYccKvOOXhJ20mAnyg="},{"w":90,"h":54,"hash":"H/iBA4AIb+2Md4RWn/Kfe/FJlyZ1jaQ="},{"w":88,"h":16,"hash":"H/gBCYBnc+aN1jVQYFe1Ov4="},{"w":38,"h":43,"hash":"IAiCBAAHzaaMBvyTQkB3gJ94bziEt4h4AQ=="},{"w":45,"h":33,"hash":"H/gBDYLClnt/2qJ5pLuZZpLzfW+Z"},{"w":9,"h":54,"hash":"3weCAQIIGp+aj3Wd9/GWhYjzxmlbRNg="},{"w":97,"h":47,"hash":"HwgCC4DRtDd8iLn5CHJ3Dnc="},{"w":69,"h":50,"hash":"HwiCBIAHyWepeKMEBzTqh8/5k21oaT90Bw=="},{"w":13,"h":65,"hash":"3/cBCQJpo8dpn410PLfAMvg="},{"w":25,"h":30,"hash":"IPiBBAIHqzf2RJS69XfSTG8Ld2qHiYe2Bw=="},{"w":35,"h":77,"hash":"IPgBAwC/xkaVdZYoy6K/wGU="},{"w":71,"h":99,"hash":"3/eBBAAI8jHjH4eYVgrLOHcQSAdCRrQ3Cw=="},{"w":51,"h":61,"hash":"HwgCDgB4ioRm1K+IiVmHolm68zhYANY="},{"w":99,"h":81,"hash":"4AeCBIAH/JSLl4h51voehr91sfZoWH5pBw=="},{"w":58,"h":89,"hash":"4AcCBQAN9jWNunlhuGOXV/qTrGQG"},{"w":92,"h":16,"hash":"H/iBAYAHzWadOEC11RAUXzefbZKQ2lw="},{"w":20,"h":9,"hash":"3vcBC4R6lm+5cB20+YmS1Ag="},{"w":87,"h":10,"hash":"3+eBAYII7ZVjl0/0dZfQebdwhKU8pfo="},{"w":59,"h":3,"hash":"nwcCCYIU+4fttp4sIM3/v4Y="},{"w":13,"h":39,"hash":"H/iBCgII915YU3MIrA+InAykfK6VeHk="},{"w":22,"h":87,"hash":"3/cBCgJ3MMpXK6a/3GXAf2Y="},{"w":20,"h":61,"hash":"H/iBCgIHcMhmxIC4f1uGBYYJhDl0p9c="},{"w":66,"h":33,"hash":"HwgCBIIVdWCYY5inCWn6Zwzbhg=="},{"w":24,"h":56,"hash":"HwiCAgAIV60ZefWzRA93WHxypWdW1wc="},{"w":36,"h":4,"hash":"HvgBGYaQohaH1cJad41gsFs="},{"w":93,"h":76,"hash":"IPiBBIAIcF8CZi2l97tl7aDCr7ubuXQ4Bg=="},{"w":50,"h":49,"hash":"IAgCB4K8Q4h4hHd5l/iUSzW62DWwG5AE"},{"w":89,"h":33,"hash":"H/iBAoAItPphyoZ4+FLXCCappHhPZLM="},{"w":88,"h":38,"hash":"4PcBA4Dgi0XjhoOT8obwtio="},{"w":92,"h":5,"hash":"4PeBAYII9+Mpe4oUCPQYNXqZtjd56L8="},{"w":16,"h":43,"hash":"HwgCCwLaREjvVTaWYGcna/o="},{"w":43,"h":25,"hash":"H/iBC4IIh7kDmbD1XptgRBwqiJg/xcs="},{"w":23,"h":15,"hash":"IAgCFYLE742XWmeuhhpXpJRT8NAa"},{"w":81,"h":7,"hash":"IPiBAYII/XuJaMxPhJlP16ewLUeXWQQ="},{"w":43,"h":10,"hash":"4PcBCoLS3wRpnEkUcvkwb3Q="},{"w":40,"h":31,"hash":"4PeBBIAHbvoid+O8vCBou5CEhcBWSHukBg=="},{"w":2,"h":54,"hash":"XggCGQh2P1eHhUhzil+FCIM="},{"w":81,"h":51,"hash":"HwiCA4AIXq5fhicHMAp5mmqAO6paeLQ="},{"w":66,"h":34,"hash":"3wcCBIKiaF02Rp91WXV/yMDyNw=="},{"w":82,"h":74,"hash":"4PeBBYAIuB98SKHF1VCErjT2iqiJh49Jlw=="},{"w":68,"h":37,"hash":"H/gBBICMWJmAh1d2Z4isj9tQYw=="},{"w":97,"h":1,"hash":"nxe+GYR3d3iIiIBYh8+FCId4iIiAd/g="},{"w":35,"h":74,"hash":"IAgCAwJaeHZYpGRvC0sBaJg="},{"w":84,"h":16,"hash":"4AeCAYIHtlwCmBe5QIZI/dVrfKfVQJM="},{"w":25,"h":39,"hash":"HwgCDAJR+5x4R7xqGLm9dQAwSA=="},{"w":7,"h":89,"hash":"3weCAQIH71t0jh3R8bisB2CGlqVZa/w="},{"w":11,"h":93,"hash":"4PcBEQIIiUqUVniGpkCGDmY="},{"w":28,"h":16,"hash":"3/eBC4AHZgaLiVrzW/ntHXFCuDtPelc="},{"w":47,"h":1,"hash":"4OdBGYaHiHiIiAh4+ojcfPg="},{"w":83,"h":79,"hash":"4PeBBYAHWU/JlHJmlyqL8DdUi9V3hwhJZQ=="},{"w":31,"h":58,"hash":"3/cBDACMjykH1lXXk4f1m1lXwA=="},{"w":87,"h":27,"hash":"3/eBAoAIWAuadHnSkGf6ZDCpWDbDVHk="},{"w":16,"h":25,"hash":"HxgCDALVgxjVRLTpv0gXoIL7lg=="},{"w":95,"h":6,"hash":"3/eBAYAHNhipdw3ol29wPIUrqUSnB0Y="},{"w":40,"h":79,"hash":"3/cBBACXn5bth4n5V0ifeYb4CA=="},{"w":37,"h":88,"hash":"3/eBAgAHatYMrGagPXqAUTT0aZlkV6k="},{"w":7,"h":64,"hash":"H/gBCQI1U92VyEzQtwv3UiI="},{"w":73,"h":44,"hash":"4AeCA4AI27s6T2uqZi+wyMCreGFnrNs="},{"w":13,"h":53,"hash":"H/gBCgKVPabFiVmfjzmJPgc="},{"w":26,"h":88,"hash":"4AeCAQAH+JrYmobr0Ntl9nJ0DUiHpaU="},{"w":92,"h":96,"hash":"H/gBBwDjZwxVe4qVdpSGh3maxpnPRPAB"},{"w":22,"h":93,"hash":"IPiBAQAIem4GeFLLT5awR4mPYXKA5Tc="},{"w":11,"h":63,"hash":"3/cBCQIEtyd3dmiLRl8zsW8="},{"w":1,"h":16,"hash":"IUbCgRB3CIiHeHj3iIhgOAj3homHiJg="},{"w":86,"h":54,"hash":"3wcCBIBmpUU+NtE5BapGT91XLw=="},{"w":45,"h":45,"hash":"3/eBBQAIjRSWIMBjFweKEy/f4ohbs78Dtw=="},{"w":86,"h":72,"hash":"IPgBBoDpdbynqIevhmp4hEio9NP2gBk="},{"w":56,"h":61,"hash":"HwiCBQAH/ErFesNrqQBrC8foSKc/e7px+A=="},{"w":36,"h":82,"hash":"IPgBAwDXSB9klzdqJkDSCJM="},{"w":19,"h":26,"hash":"IPiBBAIHimHC+WqsTSHQA8CFXPR1aWR7Bw=="},{"w":63,"h":30,"hash":"4AcCC4I3YoJa+ltaWY+Hed8="},{"w":22,"h":67,"hash":"H/iBCgAIdFg69+dzCKkNMJDF6aaPSyc="},{"w":7,"h":4,"hash":"XggGJIgRdYiZWVxIaK+wffh5Sg=="},{"w":65,"h":44,"hash":"H/iBA4AI2jgH3cmnUEkHdX5wtrmFaHQ="},{"w":97,"h":19,"hash":"HwgCCYBPdSVmN45n94dKaAM="},{"w":67,"h":11,"hash":"HwiCCYIImJywpza6bza/d0WndXmo+Dc="},{"w":83,"h":76,"hash":"3wcCBoAIXnqYdVekp+pHk3pn3blfP2g="},{"w":80,"h":98,"hash":"IAiCBAAI39GbiZdfdejP/6+SXIhJSPW3BA=="},{"w":72,"h":86,"hash":"3/cBBgKS+2i4h4h1a46YhnlKwb9G+qc="},{"w":78,"h":29,"hash":"3weCAoAIY2hKCQcA2gp4mpvrhouJX2c="},{"w":91,"h":1,"hash":"IfhBEYZ3iIeIiAiIB4j1i4g="},{"w":68,"h":99,"hash":"IAiCAwAIvewBFkMMqfxbLHqvcVbUZms="},{"w":79,"h":4,"hash":"4AcCCYSbW4Z9nYBL6TpgcE0="},{"w":80,"h":44,"hash":"IAiCA4IHxb+flWn5zAqJiPi0z6Vxk5g="},{"w":43,"h":36,"hash":"4PcBDoC6Qb9xjJWgeX5rc6hoklAaxH8="},{"w":61,"h":21,"hash":"4PeBAoAHoJ2KVFQu/C75JX+S/veGdqI="},{"w":23,"h":93,"hash":"4AcCCgKo/IiJRxNo2ZmfDd0="},{"w":96,"h":65,"hash":"HwiCA4AIgHXGaTw2+itpEHn4d5dxd6c="},{"w":90,"h":27,"hash":"IPgBCoBhgm/V6idYX+m39Sg="},{"w":81,"h":31,"hash":"3weCAoAHn6dXpYipr98KiLRmcGlrmIc="},{"w":73,"h":41,"hash":"3/cBBIA25bcwaFfYQdYCSqbxlg=="},{"w":91,"h":68,"hash":"3/eBBIAI0Jd2OHJIevfJgHx8NNZGpwl/CA=="},{"w":94,"h":74,"hash":"IPgBBoBvTGmIeYhay4x3Z3U3pn8gD0I="},{"w":72,"h":34,"hash":"3weCAoAHQIe83bnPpAqzRjjYpIKvlzc="},{"w":51,"h":34,"hash":"HwgCBYA6fzbdPH26bIaJuMpavwGt"},{"w":55,"h":33,"hash":"H/iBA4AHNLA1nUbPzZ4NNVOQpXiZ11k="},{"w":92,"h":20,"hash":"4PcBAoL2t02KyoishKT/vWc="},{"w":1,"h":94,"hash":"Hvi9CQKICId4iIgYj3tPOAj3h4iHiHg="},{"w":46,"h":34,"hash":"HwgCDYCYTefPhieK2bw3PMCa2Lrw"},{"w":64,"h":30,"hash":"IAiCAoAHTDx/WamEcJBD9saIKnufjmc="},{"w":36,"h":19,"hash":"HwgCDIKHuMmduHeamoBgk/PTeg=="},{"w":90,"h":94,"hash":"IAiCBQAHZy+dmah1KFYwiwVXfURlxoBptQ=="},{"w":89,"h":49,"hash":"H/gBBIBpkIl5rJU5yJrcT/x9UQ=="},{"w":34,"h":2,"hash":"Y8iBCYSIVbsJgXeT+wc2iYeHh4eHiAc="},{"w":25,"h":40,"hash":"3wcCDAKkNHd3x4wKpngw3Pa3Cw=="},{"w":47,"h":32,"hash":"IPiBA4AHl3CHY4VS/WGvOem9n4xZNiY="},{"w":53,"h":96,"hash":"4PcBBAB4zFkHVnZ5Vnb+cQoyqA=="},{"w":47,"h":93,"hash":"4PeBAwAHovPYd5nJhr9y84volUge9qQ="},{"w":86,"h":89,"hash":"4AcCBwIxnclaVpZmhwuXeIqsOUOABWQF"},{"w":40,"h":90,"hash":"IPiBAgAIzWDGoI4lL8cOkpTyeDiGmHY="},{"w":38,"h":66,"hash":"H/gBBAK5wb10WqSEx3BqgHasQA=="},{"w":12,"h":21,"hash":"4AeCAwIHU5iHp/TaqbBfi7ypznOSRIA="},{"w":54,"h":29,"hash":"3/cBBILTCdd3yod7eIVwrqfOnw=="},{"w":78,"h":77,"hash":"3weCBYAIfO9WhGEMTcBzWAd3QJc6hLVohw=="},{"w":88,"h":96,"hash":"3/cBBgCfiF9LQRun2ME2UJ5yuGC1Dgg="},{"w":49,"h":89,"hash":"4PeBAwAIKc/XsRei+QLKXFcyRHdFSvM="},{"w":19,"h":41,"hash":"3wcCCwKIj4pZgGhJXAfKXfQ="},{"w":70,"h":53,"hash":"IPiBBIII2CpoSAcGTfhW94S4b3aFdlqmBQ=="},{"w":55,"h":57,"hash":"4PcBBwAGraR0aVs6blrol9aYrApGsBgG"},{"w":54,"h":29,"hash":"3/eBC4AHyLBqhpD4VxQX9hqwzY9DuVg="},{"w":15,"h":75,"hash":"HwgCCQKJ9qeHapW2EDvPhPc="},{"w":93,"h":81,"hash":"H/iBBIAHC2WedpVnfngIVnX/YBI7RopLBw=="},{"w":64,"h":96,"hash":"4AcCBQCMiJ5GnFu6rDv1yHqfSLQP"},{"w":76,"h":44,"hash":"IPiBA4AHqQeWWI2puG+/SsVZfH+EKFc="},{"w":88,"h":33,"hash":"IAgCA4L4N5JQnp1odH8Id50="},{"w":1,"h":34,"hash":"Xue9MQaICIh3iHj3h3WfiAj3h4iId4g="},{"w":30,"h":4,"hash":"IOgFGYa2AneplIqU+YGncKc="},{"w":92,"h":76,"hash":"HwiCBIAHKrOomZBJlckKC2XFT54JnMSLCA=="},{"w":91,"h":16,"hash":"IPgBCYLldw2ryLmLYHjxVkk="},{"w":3,"h":26,"hash":"3yeGCQIYiY/WpUpL9DmJ/2WYd4anCrk="},{"w":2,"h":14,"hash":"YNcFCQ56SgeK1ld+hvp2+FY="},{"w":93,"h":90,"hash":"IPiBBYAHlR+Hm5gJyPdlAqqImTuPWXlFeA=="},{"w":47,"h":88,"hash":"3/cBBAALd4h3lHZpeIlfs6NTDQ=="},{"w":35,"h":32,"hash":"4AeCBYIHdgJPGVxze8rQrvpIvplllljXBw=="},{"w":38,"h":5,"hash":"4AcCCYRTKNxEawW3UJsl/5Y="},{"w":8,"h":78,"hash":"H/iBCQIHjIUIg8cEM2XQxWp6oKdah5A="},{"w":39,"h":36,"hash":"3/cBDoJQZreZx2RPmKWGpxpkSXA6/EM="},{"w":55,"h":13,"hash":"HwiCAYAHfuUceQxcnO/ZMFE234F3aZY="},{"w":13,"h":56,"hash":"IAgCCgJ7gviHc4ur2H4A1gI="},{"w":26,"h":22,"hash":"3weCBIIHx2iLhiCf+OrZYBToaS9I6Zd1BA=="},{"w":83,"h":19,"hash":"3wcCCoL5dJtjKLdzdZvA/G0="},{"w":7,"h":9,"hash":"IRiCDAQXc8cFtlkd8SmVQIVf+rcJWDm7BA=="},{"w":90,"h":43,"hash":"4PcBA4BWXGyC3oWPkJfDrgo="},{"w":43,"h":77,"hash":"IPiBAwAHhT8asHZ/VIr3tMogVkNnm1g="},{"w":36,"h":27,"hash":"IPgBBYKokWWJhMqLlilFBLsGpL/F"},{"w":86,"h":62,"hash":"3weCBIAHsSsGVZlmSOT8f6tyeRCPwHh6DA=="},{"w":63,"h":89,"hash":"IAgCBQC69pVJd3nafFOo1Xr893oE"},{"w":69,"h":98,"hash":"4AeCBAAHidVTQLuXiQbeVJ9H32iHhUaHAg=="},{"w":12,"h":58,"hash":"HwgCCQKZX0iHh3rGb6X1Nec="},{"w":7,"h":7,"hash":"YPeFFQYXh8baRainTwmCfET7/Km5ia0jxw=="},{"w":40,"h":12,"hash":"IPgBEoSX8Ul3WeSbcLd1Zfg="},{"w":93,"h":47,"hash":"4PeBA4AHY4N7pPu7oJO5AnmeQLYcRLk="},{"w":15,"h":42,"hash":"4AcCCwJ0D/zATmOWM/r3xXM="},{"w":67,"h":45,"hash":"3/eBA4AHVbr4h517mv+eZprFsJioaoQ="},{"w":67,"h":74,"hash":"IAgCBgBqmUc1R2d6iqtrigl4lSf/VXQ="},{"w":29,"h":67,"hash":"3weCAgAHYJRmaGqgmaOAV5q0AZR2akk="},{"w":43,"h":10,"hash":"4AcCCoL8SVDXdVsyiECVaK8="},{"w":75,"h":40,"hash":"IAiCA4AHw2mXw6/AoA5Eo8onAwY4s2o="},{"w":73,"h":91,"hash":"3wcCBgDFhsbJlnmDaYxwRZZUl5GAfzY="},{"w":21,"h":54,"hash":"4AeCAgIHWamZCKf0fNZpTyw6aHxHXzM="},{"w":98,"h":52,"hash":"H/gBBICZZsltiKuMUHewoYEI5g=="},{"w":2,"h":29,"hash":"XwiCCQR3cpuYwKqODEIHWXgHiHiIiIc="}]
diff --git a/core/artwork/thumbhash/testdata/golden.json b/core/artwork/thumbhash/testdata/golden.json
new file mode 100644
index 000000000..578986e75
--- /dev/null
+++ b/core/artwork/thumbhash/testdata/golden.json
@@ -0,0 +1,8 @@
+{
+ "alpha.png": "JOiFBQ4nkIexh3p4iA8uB+lYhIeAh3d4dw==",
+ "landscape.png": "3wcOFJpwh4eBh3d4iIePgAj3hw==",
+ "portrait.png": "3/cNFBqBB4iId4d3d4iAjwj4hw==",
+ "solid.png": "HoUBBwB4eHeHd3hweId3h3h4B2+Ih4gA",
+ "square.png": "H/gNBxpwh4dwd3eIiHd3iHeHeJ+dcH8I",
+ "tiny.png": "HoU9tx4I9wiIh4hwj3CI+AiIcH/494cP"
+}
diff --git a/core/artwork/thumbhash/testdata/landscape.png b/core/artwork/thumbhash/testdata/landscape.png
new file mode 100644
index 000000000..413851f47
Binary files /dev/null and b/core/artwork/thumbhash/testdata/landscape.png differ
diff --git a/core/artwork/thumbhash/testdata/portrait.png b/core/artwork/thumbhash/testdata/portrait.png
new file mode 100644
index 000000000..bc6e5f0de
Binary files /dev/null and b/core/artwork/thumbhash/testdata/portrait.png differ
diff --git a/core/artwork/thumbhash/testdata/solid.png b/core/artwork/thumbhash/testdata/solid.png
new file mode 100644
index 000000000..3c53a36bf
Binary files /dev/null and b/core/artwork/thumbhash/testdata/solid.png differ
diff --git a/core/artwork/thumbhash/testdata/square.png b/core/artwork/thumbhash/testdata/square.png
new file mode 100644
index 000000000..a81000cbc
Binary files /dev/null and b/core/artwork/thumbhash/testdata/square.png differ
diff --git a/core/artwork/thumbhash/testdata/thumbhash.js b/core/artwork/thumbhash/testdata/thumbhash.js
new file mode 100644
index 000000000..369b118ec
--- /dev/null
+++ b/core/artwork/thumbhash/testdata/thumbhash.js
@@ -0,0 +1,288 @@
+/**
+ * Encodes an RGBA image to a ThumbHash. RGB should not be premultiplied by A.
+ *
+ * @param w The width of the input image. Must be ≤100px.
+ * @param h The height of the input image. Must be ≤100px.
+ * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.
+ * @returns The ThumbHash as a Uint8Array.
+ */
+export function rgbaToThumbHash(w, h, rgba) {
+ // Encoding an image larger than 100x100 is slow with no benefit
+ if (w > 100 || h > 100) throw new Error(`${w}x${h} doesn't fit in 100x100`)
+ let { PI, round, max, cos, abs } = Math
+
+ // Determine the average color
+ let avg_r = 0, avg_g = 0, avg_b = 0, avg_a = 0
+ for (let i = 0, j = 0; i < w * h; i++, j += 4) {
+ let alpha = rgba[j + 3] / 255
+ avg_r += alpha / 255 * rgba[j]
+ avg_g += alpha / 255 * rgba[j + 1]
+ avg_b += alpha / 255 * rgba[j + 2]
+ avg_a += alpha
+ }
+ if (avg_a) {
+ avg_r /= avg_a
+ avg_g /= avg_a
+ avg_b /= avg_a
+ }
+
+ let hasAlpha = avg_a < w * h
+ let l_limit = hasAlpha ? 5 : 7 // Use fewer luminance bits if there's alpha
+ let lx = max(1, round(l_limit * w / max(w, h)))
+ let ly = max(1, round(l_limit * h / max(w, h)))
+ let l = [] // luminance
+ let p = [] // yellow - blue
+ let q = [] // red - green
+ let a = [] // alpha
+
+ // Convert the image from RGBA to LPQA (composite atop the average color)
+ for (let i = 0, j = 0; i < w * h; i++, j += 4) {
+ let alpha = rgba[j + 3] / 255
+ let r = avg_r * (1 - alpha) + alpha / 255 * rgba[j]
+ let g = avg_g * (1 - alpha) + alpha / 255 * rgba[j + 1]
+ let b = avg_b * (1 - alpha) + alpha / 255 * rgba[j + 2]
+ l[i] = (r + g + b) / 3
+ p[i] = (r + g) / 2 - b
+ q[i] = r - g
+ a[i] = alpha
+ }
+
+ // Encode using the DCT into DC (constant) and normalized AC (varying) terms
+ let encodeChannel = (channel, nx, ny) => {
+ let dc = 0, ac = [], scale = 0, fx = []
+ for (let cy = 0; cy < ny; cy++) {
+ for (let cx = 0; cx * ny < nx * (ny - cy); cx++) {
+ let f = 0
+ for (let x = 0; x < w; x++)
+ fx[x] = cos(PI / w * cx * (x + 0.5))
+ for (let y = 0; y < h; y++)
+ for (let x = 0, fy = cos(PI / h * cy * (y + 0.5)); x < w; x++)
+ f += channel[x + y * w] * fx[x] * fy
+ f /= w * h
+ if (cx || cy) {
+ ac.push(f)
+ scale = max(scale, abs(f))
+ } else {
+ dc = f
+ }
+ }
+ }
+ if (scale)
+ for (let i = 0; i < ac.length; i++)
+ ac[i] = 0.5 + 0.5 / scale * ac[i]
+ return [dc, ac, scale]
+ }
+ let [l_dc, l_ac, l_scale] = encodeChannel(l, max(3, lx), max(3, ly))
+ let [p_dc, p_ac, p_scale] = encodeChannel(p, 3, 3)
+ let [q_dc, q_ac, q_scale] = encodeChannel(q, 3, 3)
+ let [a_dc, a_ac, a_scale] = hasAlpha ? encodeChannel(a, 5, 5) : []
+
+ // Write the constants
+ let isLandscape = w > h
+ let header24 = round(63 * l_dc) | (round(31.5 + 31.5 * p_dc) << 6) | (round(31.5 + 31.5 * q_dc) << 12) | (round(31 * l_scale) << 18) | (hasAlpha << 23)
+ let header16 = (isLandscape ? ly : lx) | (round(63 * p_scale) << 3) | (round(63 * q_scale) << 9) | (isLandscape << 15)
+ let hash = [header24 & 255, (header24 >> 8) & 255, header24 >> 16, header16 & 255, header16 >> 8]
+ let ac_start = hasAlpha ? 6 : 5
+ let ac_index = 0
+ if (hasAlpha) hash.push(round(15 * a_dc) | (round(15 * a_scale) << 4))
+
+ // Write the varying factors
+ for (let ac of hasAlpha ? [l_ac, p_ac, q_ac, a_ac] : [l_ac, p_ac, q_ac])
+ for (let f of ac)
+ hash[ac_start + (ac_index >> 1)] |= round(15 * f) << ((ac_index++ & 1) << 2)
+ return new Uint8Array(hash)
+}
+
+/**
+ * Decodes a ThumbHash to an RGBA image. RGB is not be premultiplied by A.
+ *
+ * @param hash The bytes of the ThumbHash.
+ * @returns The width, height, and pixels of the rendered placeholder image.
+ */
+export function thumbHashToRGBA(hash) {
+ let { PI, min, max, cos, round } = Math
+
+ // Read the constants
+ let header24 = hash[0] | (hash[1] << 8) | (hash[2] << 16)
+ let header16 = hash[3] | (hash[4] << 8)
+ let l_dc = (header24 & 63) / 63
+ let p_dc = ((header24 >> 6) & 63) / 31.5 - 1
+ let q_dc = ((header24 >> 12) & 63) / 31.5 - 1
+ let l_scale = ((header24 >> 18) & 31) / 31
+ let hasAlpha = header24 >> 23
+ let p_scale = ((header16 >> 3) & 63) / 63
+ let q_scale = ((header16 >> 9) & 63) / 63
+ let isLandscape = header16 >> 15
+ let lx = max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7)
+ let ly = max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7)
+ let a_dc = hasAlpha ? (hash[5] & 15) / 15 : 1
+ let a_scale = (hash[5] >> 4) / 15
+
+ // Read the varying factors (boost saturation by 1.25x to compensate for quantization)
+ let ac_start = hasAlpha ? 6 : 5
+ let ac_index = 0
+ let decodeChannel = (nx, ny, scale) => {
+ let ac = []
+ for (let cy = 0; cy < ny; cy++)
+ for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++)
+ ac.push((((hash[ac_start + (ac_index >> 1)] >> ((ac_index++ & 1) << 2)) & 15) / 7.5 - 1) * scale)
+ return ac
+ }
+ let l_ac = decodeChannel(lx, ly, l_scale)
+ let p_ac = decodeChannel(3, 3, p_scale * 1.25)
+ let q_ac = decodeChannel(3, 3, q_scale * 1.25)
+ let a_ac = hasAlpha && decodeChannel(5, 5, a_scale)
+
+ // Decode using the DCT into RGB
+ let ratio = thumbHashToApproximateAspectRatio(hash)
+ let w = round(ratio > 1 ? 32 : 32 * ratio)
+ let h = round(ratio > 1 ? 32 / ratio : 32)
+ let rgba = new Uint8Array(w * h * 4), fx = [], fy = []
+ for (let y = 0, i = 0; y < h; y++) {
+ for (let x = 0; x < w; x++, i += 4) {
+ let l = l_dc, p = p_dc, q = q_dc, a = a_dc
+
+ // Precompute the coefficients
+ for (let cx = 0, n = max(lx, hasAlpha ? 5 : 3); cx < n; cx++)
+ fx[cx] = cos(PI / w * (x + 0.5) * cx)
+ for (let cy = 0, n = max(ly, hasAlpha ? 5 : 3); cy < n; cy++)
+ fy[cy] = cos(PI / h * (y + 0.5) * cy)
+
+ // Decode L
+ for (let cy = 0, j = 0; cy < ly; cy++)
+ for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx * ly < lx * (ly - cy); cx++, j++)
+ l += l_ac[j] * fx[cx] * fy2
+
+ // Decode P and Q
+ for (let cy = 0, j = 0; cy < 3; cy++) {
+ for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 3 - cy; cx++, j++) {
+ let f = fx[cx] * fy2
+ p += p_ac[j] * f
+ q += q_ac[j] * f
+ }
+ }
+
+ // Decode A
+ if (hasAlpha)
+ for (let cy = 0, j = 0; cy < 5; cy++)
+ for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 5 - cy; cx++, j++)
+ a += a_ac[j] * fx[cx] * fy2
+
+ // Convert to RGB
+ let b = l - 2 / 3 * p
+ let r = (3 * l - b + q) / 2
+ let g = r - q
+ rgba[i] = max(0, 255 * min(1, r))
+ rgba[i + 1] = max(0, 255 * min(1, g))
+ rgba[i + 2] = max(0, 255 * min(1, b))
+ rgba[i + 3] = max(0, 255 * min(1, a))
+ }
+ }
+ return { w, h, rgba }
+}
+
+/**
+ * Extracts the average color from a ThumbHash. RGB is not be premultiplied by A.
+ *
+ * @param hash The bytes of the ThumbHash.
+ * @returns The RGBA values for the average color. Each value ranges from 0 to 1.
+ */
+export function thumbHashToAverageRGBA(hash) {
+ let { min, max } = Math
+ let header = hash[0] | (hash[1] << 8) | (hash[2] << 16)
+ let l = (header & 63) / 63
+ let p = ((header >> 6) & 63) / 31.5 - 1
+ let q = ((header >> 12) & 63) / 31.5 - 1
+ let hasAlpha = header >> 23
+ let a = hasAlpha ? (hash[5] & 15) / 15 : 1
+ let b = l - 2 / 3 * p
+ let r = (3 * l - b + q) / 2
+ let g = r - q
+ return {
+ r: max(0, min(1, r)),
+ g: max(0, min(1, g)),
+ b: max(0, min(1, b)),
+ a
+ }
+}
+
+/**
+ * Extracts the approximate aspect ratio of the original image.
+ *
+ * @param hash The bytes of the ThumbHash.
+ * @returns The approximate aspect ratio (i.e. width / height).
+ */
+export function thumbHashToApproximateAspectRatio(hash) {
+ let header = hash[3]
+ let hasAlpha = hash[2] & 0x80
+ let isLandscape = hash[4] & 0x80
+ let lx = isLandscape ? hasAlpha ? 5 : 7 : header & 7
+ let ly = isLandscape ? header & 7 : hasAlpha ? 5 : 7
+ return lx / ly
+}
+
+/**
+ * Encodes an RGBA image to a PNG data URL. RGB should not be premultiplied by
+ * A. This is optimized for speed and simplicity and does not optimize for size
+ * at all. This doesn't do any compression (all values are stored uncompressed).
+ *
+ * @param w The width of the input image. Must be ≤100px.
+ * @param h The height of the input image. Must be ≤100px.
+ * @param rgba The pixels in the input image, row-by-row. Must have w*h*4 elements.
+ * @returns A data URL containing a PNG for the input image.
+ */
+export function rgbaToDataURL(w, h, rgba) {
+ let row = w * 4 + 1
+ let idat = 6 + h * (5 + row)
+ let bytes = [
+ 137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0,
+ w >> 8, w & 255, 0, 0, h >> 8, h & 255, 8, 6, 0, 0, 0, 0, 0, 0, 0,
+ idat >>> 24, (idat >> 16) & 255, (idat >> 8) & 255, idat & 255,
+ 73, 68, 65, 84, 120, 1
+ ]
+ let table = [
+ 0, 498536548, 997073096, 651767980, 1994146192, 1802195444, 1303535960,
+ 1342533948, -306674912, -267414716, -690576408, -882789492, -1687895376,
+ -2032938284, -1609899400, -1111625188
+ ]
+ let a = 1, b = 0
+ for (let y = 0, i = 0, end = row - 1; y < h; y++, end += row - 1) {
+ bytes.push(y + 1 < h ? 0 : 1, row & 255, row >> 8, ~row & 255, (row >> 8) ^ 255, 0)
+ for (b = (b + a) % 65521; i < end; i++) {
+ let u = rgba[i] & 255
+ bytes.push(u)
+ a = (a + u) % 65521
+ b = (b + a) % 65521
+ }
+ }
+ bytes.push(
+ b >> 8, b & 255, a >> 8, a & 255, 0, 0, 0, 0,
+ 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130
+ )
+ for (let [start, end] of [[12, 29], [37, 41 + idat]]) {
+ let c = ~0
+ for (let i = start; i < end; i++) {
+ c ^= bytes[i]
+ c = (c >>> 4) ^ table[c & 15]
+ c = (c >>> 4) ^ table[c & 15]
+ }
+ c = ~c
+ bytes[end++] = c >>> 24
+ bytes[end++] = (c >> 16) & 255
+ bytes[end++] = (c >> 8) & 255
+ bytes[end++] = c & 255
+ }
+ return 'data:image/png;base64,' + btoa(String.fromCharCode(...bytes))
+}
+
+/**
+ * Decodes a ThumbHash to a PNG data URL. This is a convenience function that
+ * just calls "thumbHashToRGBA" followed by "rgbaToDataURL".
+ *
+ * @param hash The bytes of the ThumbHash.
+ * @returns A data URL containing a PNG for the rendered ThumbHash.
+ */
+export function thumbHashToDataURL(hash) {
+ let image = thumbHashToRGBA(hash)
+ return rgbaToDataURL(image.w, image.h, image.rgba)
+}
diff --git a/core/artwork/thumbhash/testdata/tiny.png b/core/artwork/thumbhash/testdata/tiny.png
new file mode 100644
index 000000000..ab635e11a
Binary files /dev/null and b/core/artwork/thumbhash/testdata/tiny.png differ
diff --git a/core/artwork/thumbhash/thumbhash.go b/core/artwork/thumbhash/thumbhash.go
new file mode 100644
index 000000000..a255bec42
--- /dev/null
+++ b/core/artwork/thumbhash/thumbhash.go
@@ -0,0 +1,257 @@
+// Package thumbhash implements the ThumbHash encoding algorithm (https://github.com/evanw/thumbhash).
+package thumbhash
+
+import (
+ "errors"
+ "image"
+ "image/draw"
+ "math"
+
+ xdraw "golang.org/x/image/draw"
+)
+
+// maxInputSize is the algorithm's hard limit: larger inputs are rejected by every implementation.
+const maxInputSize = 100
+
+// term is one DCT coefficient's frequency pair, in the reference's triangular scan order.
+type term struct{ cx, cy int }
+
+// Encode returns the ThumbHash of img: 24 bytes when opaque, 25 with alpha. Output matches
+// evanw/thumbhash except where a coefficient lands on a quantization tie, where a nibble may differ by 1.
+func Encode(img image.Image) ([]byte, error) {
+ rgba := toNRGBA(downscale(img))
+ b := rgba.Bounds()
+ w, h := b.Dx(), b.Dy()
+ if w == 0 || h == 0 {
+ return nil, errors.New("thumbhash: empty image")
+ }
+
+ avgR, avgG, avgB, avgA := averageColor(rgba, w, h)
+ hasAlpha := avgA < float64(w*h)
+ if avgA > 0 {
+ avgR /= avgA
+ avgG /= avgA
+ avgB /= avgA
+ }
+
+ lLimit := 7.0
+ if hasAlpha {
+ lLimit = 5.0
+ }
+ maxWH := float64(max(w, h))
+ lx := max(1, int(math.Round(lLimit*float64(w)/maxWH)))
+ ly := max(1, int(math.Round(lLimit*float64(h)/maxWH)))
+
+ lTerms := terms(max(3, lx), max(3, ly))
+ pTerms := terms(3, 3)
+ qTerms := terms(3, 3)
+ var aTerms []term
+ if hasAlpha {
+ aTerms = terms(5, 5)
+ }
+
+ // The widest coefficient region wins: 3x3 chroma, 5x5 alpha, and luma's own lx by ly.
+ chan5 := 3
+ if hasAlpha {
+ chan5 = 5
+ }
+ nx := max(max(3, lx), chan5)
+ cosX := cosTable(nx, w)
+ cosY := cosTable(max(max(3, ly), chan5), h)
+
+ lAcc := make([]float64, len(lTerms))
+ pAcc := make([]float64, len(pTerms))
+ qAcc := make([]float64, len(qTerms))
+ aAcc := make([]float64, len(aTerms))
+ rowL := make([]float64, nx)
+ rowP := make([]float64, nx)
+ rowQ := make([]float64, nx)
+ rowA := make([]float64, nx)
+
+ for y := range h {
+ clear(rowL)
+ clear(rowP)
+ clear(rowQ)
+ clear(rowA)
+ row := rgba.Pix[y*rgba.Stride:]
+ for x := range w {
+ j := x * 4
+ alpha := float64(row[j+3]) / 255
+ r := avgR*(1-alpha) + alpha/255*float64(row[j])
+ g := avgG*(1-alpha) + alpha/255*float64(row[j+1])
+ bl := avgB*(1-alpha) + alpha/255*float64(row[j+2])
+ lv := (r + g + bl) / 3
+ pv := (r+g)/2 - bl
+ qv := r - g
+ for cx := range nx {
+ f := cosX[cx][x]
+ rowL[cx] += lv * f
+ rowP[cx] += pv * f
+ rowQ[cx] += qv * f
+ }
+ // hasAlpha is loop-invariant, so this costs a predicted branch rather than a quarter
+ // of the inner loop that opaque images never need.
+ if hasAlpha {
+ for cx := range nx {
+ rowA[cx] += alpha * cosX[cx][x]
+ }
+ }
+ }
+ accumulate(lAcc, lTerms, rowL, cosY, y)
+ accumulate(pAcc, pTerms, rowP, cosY, y)
+ accumulate(qAcc, qTerms, rowQ, cosY, y)
+ accumulate(aAcc, aTerms, rowA, cosY, y)
+ }
+
+ n := float64(w * h)
+ lDC, lAC, lScale := normalize(lAcc, n)
+ pDC, pAC, pScale := normalize(pAcc, n)
+ qDC, qAC, qScale := normalize(qAcc, n)
+ aDC, aAC, aScale := normalize(aAcc, n)
+
+ return pack(w, h, hasAlpha, lx, ly,
+ lDC, pDC, qDC, aDC, lScale, pScale, qScale, aScale, lAC, pAC, qAC, aAC), nil
+}
+
+// terms lists the (cx, cy) pairs of the reference's triangular coefficient region, in write order.
+func terms(nx, ny int) []term {
+ var ts []term
+ for cy := range ny {
+ for cx := 0; cx*ny < nx*(ny-cy); cx++ {
+ ts = append(ts, term{cx, cy})
+ }
+ }
+ return ts
+}
+
+// cosTable precomputes cos(pi/size * c * (i+0.5)) with the reference's exact expression, so the
+// table values are bit-identical to recomputing them per coefficient.
+func cosTable(n, size int) [][]float64 {
+ t := make([][]float64, n)
+ for c := range n {
+ t[c] = make([]float64, size)
+ for i := range size {
+ t[c][i] = math.Cos(math.Pi / float64(size) * float64(c) * (float64(i) + 0.5))
+ }
+ }
+ return t
+}
+
+func averageColor(rgba *image.NRGBA, w, h int) (r, g, b, a float64) {
+ for y := range h {
+ row := rgba.Pix[y*rgba.Stride:]
+ for x := range w {
+ j := x * 4
+ alpha := float64(row[j+3]) / 255
+ r += alpha / 255 * float64(row[j])
+ g += alpha / 255 * float64(row[j+1])
+ b += alpha / 255 * float64(row[j+2])
+ a += alpha
+ }
+ }
+ return r, g, b, a
+}
+
+// accumulate folds one row's per-cx sums into the term accumulators, so the pixel loop costs
+// nx multiplies per pixel instead of one per coefficient.
+func accumulate(acc []float64, ts []term, row []float64, cosY [][]float64, y int) {
+ for k, t := range ts {
+ acc[k] += row[t.cx] * cosY[t.cy][y]
+ }
+}
+
+// normalize splits the accumulators into DC and scaled AC terms, matching the reference: a constant
+// image leaves scale at 0, which skips normalization rather than mapping the terms to the midpoint.
+func normalize(acc []float64, n float64) (dc float64, ac []float64, scale float64) {
+ if len(acc) == 0 {
+ return 0, nil, 0
+ }
+ dc = acc[0] / n
+ ac = make([]float64, len(acc)-1)
+ for i, v := range acc[1:] {
+ ac[i] = v / n
+ scale = max(scale, math.Abs(ac[i]))
+ }
+ if scale > 0 {
+ for i := range ac {
+ ac[i] = 0.5 + 0.5/scale*ac[i]
+ }
+ }
+ return dc, ac, scale
+}
+
+func pack(w, h int, hasAlpha bool, lx, ly int,
+ lDC, pDC, qDC, aDC, lScale, pScale, qScale, aScale float64,
+ lAC, pAC, qAC, aAC []float64,
+) []byte {
+ isLandscape := 0
+ if w > h {
+ isLandscape = 1
+ }
+ alphaBit := 0
+ if hasAlpha {
+ alphaBit = 1
+ }
+ header24 := int(math.Round(63*lDC)) | int(math.Round(31.5+31.5*pDC))<<6 |
+ int(math.Round(31.5+31.5*qDC))<<12 | int(math.Round(31*lScale))<<18 | alphaBit<<23
+ lead := lx
+ if isLandscape == 1 {
+ lead = ly
+ }
+ header16 := lead | int(math.Round(63*pScale))<<3 | int(math.Round(63*qScale))<<9 | isLandscape<<15
+
+ acs := [][]float64{lAC, pAC, qAC}
+ acStart := 5
+ if hasAlpha {
+ acs = append(acs, aAC)
+ acStart = 6
+ }
+ acCount := 0
+ for _, ac := range acs {
+ acCount += len(ac)
+ }
+
+ hash := make([]byte, acStart+(acCount+1)/2)
+ hash[0] = byte(header24 & 255)
+ hash[1] = byte((header24 >> 8) & 255)
+ hash[2] = byte(header24 >> 16)
+ hash[3] = byte(header16 & 255)
+ hash[4] = byte(header16 >> 8)
+ if hasAlpha {
+ hash[5] = byte(int(math.Round(15*aDC)) | int(math.Round(15*aScale))<<4)
+ }
+ acIndex := 0
+ for _, ac := range acs {
+ for _, f := range ac {
+ hash[acStart+(acIndex>>1)] |= byte(int(math.Round(15*f)) << ((acIndex & 1) << 2))
+ acIndex++
+ }
+ }
+ return hash
+}
+
+// NRGBA, not RGBA: ThumbHash requires non-premultiplied RGB and the pipeline hands us a
+// premultiplied *image.RGBA, which draw.Draw un-premultiplies on the way in.
+func toNRGBA(img image.Image) *image.NRGBA {
+ // Conservative: a sub-image re-slices Pix so the loops would read it correctly too, but the
+ // copy costs nothing on the origin-anchored images the pipeline actually produces.
+ if nrgba, ok := img.(*image.NRGBA); ok && nrgba.Rect.Min == (image.Point{}) {
+ return nrgba
+ }
+ b := img.Bounds()
+ dst := image.NewNRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))
+ draw.Draw(dst, dst.Bounds(), img, b.Min, draw.Src)
+ return dst
+}
+
+func downscale(img image.Image) image.Image {
+ b := img.Bounds()
+ w, h := b.Dx(), b.Dy()
+ if w <= maxInputSize && h <= maxInputSize {
+ return img
+ }
+ scale := float64(maxInputSize) / float64(max(w, h))
+ dst := image.NewNRGBA(image.Rect(0, 0, max(1, int(float64(w)*scale)), max(1, int(float64(h)*scale))))
+ xdraw.ApproxBiLinear.Scale(dst, dst.Bounds(), img, b, draw.Src, nil)
+ return dst
+}
diff --git a/core/artwork/thumbhash/thumbhash_suite_test.go b/core/artwork/thumbhash/thumbhash_suite_test.go
new file mode 100644
index 000000000..11a6f0e25
--- /dev/null
+++ b/core/artwork/thumbhash/thumbhash_suite_test.go
@@ -0,0 +1,17 @@
+package thumbhash_test
+
+import (
+ "testing"
+
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+func TestThumbHash(t *testing.T) {
+ tests.Init(t, false)
+ log.SetLevel(log.LevelFatal)
+ RegisterFailHandler(Fail)
+ RunSpecs(t, "ThumbHash Suite")
+}
diff --git a/core/artwork/thumbhash/thumbhash_test.go b/core/artwork/thumbhash/thumbhash_test.go
new file mode 100644
index 000000000..4832c25bc
--- /dev/null
+++ b/core/artwork/thumbhash/thumbhash_test.go
@@ -0,0 +1,194 @@
+package thumbhash_test
+
+import (
+ "encoding/base64"
+ "encoding/json"
+ "image"
+ "image/color"
+ "image/draw"
+ _ "image/png"
+ "os"
+ "path/filepath"
+ "runtime"
+ "slices"
+
+ "github.com/navidrome/navidrome/core/artwork/thumbhash"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// testdataDir is resolved via runtime.Caller because tests.Init (thumbhash_suite_test.go) chdirs
+// the process to the repo root, which would break a plain relative "testdata" path.
+var testdataDir = func() string {
+ _, file, _, _ := runtime.Caller(0)
+ return filepath.Join(filepath.Dir(file), "testdata")
+}()
+
+// fixtureImage decodes a testdata PNG. NRGBA, not RGBA: ThumbHash needs non-premultiplied pixels,
+// and RGBA would silently premultiply every fixture that has alpha.
+func fixtureImage(name string) *image.NRGBA {
+ GinkgoHelper()
+ f, err := os.Open(filepath.Join(testdataDir, name))
+ Expect(err).ToNot(HaveOccurred())
+ defer f.Close()
+ src, _, err := image.Decode(f)
+ Expect(err).ToNot(HaveOccurred())
+ b := src.Bounds()
+ dst := image.NewNRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))
+ draw.Draw(dst, dst.Bounds(), src, b.Min, draw.Src)
+ return dst
+}
+
+// headerOnlyFixtures have mathematically-zero AC content, so every AC nibble is float rounding
+// noise sitting on a quantization tie; only the header bytes carry signal.
+var headerOnlyFixtures = []string{"solid.png", "tiny.png"}
+
+func loadJSON[T any](name string) T {
+ GinkgoHelper()
+ data, err := os.ReadFile(filepath.Join(testdataDir, name))
+ Expect(err).ToNot(HaveOccurred())
+ var out T
+ Expect(json.Unmarshal(data, &out)).To(Succeed())
+ return out
+}
+
+func loadGoldens() map[string]string {
+ GinkgoHelper()
+ golden := loadJSON[map[string]string]("golden.json")
+ Expect(golden).ToNot(BeEmpty())
+ return golden
+}
+
+// mix is a stateless 32-bit finaliser matching gen_generated.mjs, so both languages build the
+// same synthetic pixels and only the reference's hashes need committing.
+func mix(n uint32) uint32 {
+ n = (n ^ (n >> 16)) * 2246822507
+ n = (n ^ (n >> 13)) * 3266489909
+ return n ^ (n >> 16)
+}
+
+func generatedImage(i int) *image.NRGBA {
+ w := 1 + int(mix(uint32(i)*3+1)%100)
+ h := 1 + int(mix(uint32(i)*3+2)%100)
+ img := image.NewNRGBA(image.Rect(0, 0, w, h))
+ for k := range img.Pix {
+ img.Pix[k] = byte(mix(uint32(i)*1000003 + uint32(k)))
+ }
+ if i%2 == 0 {
+ for k := 3; k < len(img.Pix); k += 4 {
+ img.Pix[k] = 255
+ }
+ }
+ return img
+}
+
+var _ = Describe("Encode", func() {
+ It("matches every golden vector", func() {
+ for name, want := range loadGoldens() {
+ if slices.Contains(headerOnlyFixtures, name) {
+ continue // see the dedicated header-only spec below
+ }
+ got, err := thumbhash.Encode(fixtureImage(name))
+ Expect(err).ToNot(HaveOccurred(), "fixture %s", name)
+ Expect(base64.StdEncoding.EncodeToString(got)).To(Equal(want), "fixture %s", name)
+ }
+ })
+
+ It("reproduces the well-conditioned header of the ill-conditioned fixtures", func() {
+ for _, name := range headerOnlyFixtures {
+ want, err := base64.StdEncoding.DecodeString(loadGoldens()[name])
+ Expect(err).ToNot(HaveOccurred(), "fixture %s", name)
+ got, err := thumbhash.Encode(fixtureImage(name))
+ Expect(err).ToNot(HaveOccurred(), "fixture %s", name)
+ Expect(got[:5]).To(Equal(want[:5]), "fixture %s header bytes", name)
+ }
+ })
+
+ // The PNG fixtures cannot reach every layout; these sweep random sizes, aspects and both the
+ // 7x7 no-alpha and 5x5-plus-alpha coefficient regions against the same reference.
+ It("matches the reference on 300 generated images", func() {
+ vectors := loadJSON[[]struct {
+ W, H int
+ Hash string
+ }]("generated.json")
+ Expect(vectors).ToNot(BeEmpty())
+ for i, want := range vectors {
+ img := generatedImage(i)
+ Expect(img.Bounds().Dx()).To(Equal(want.W), "vector %d width", i)
+ Expect(img.Bounds().Dy()).To(Equal(want.H), "vector %d height", i)
+ got, err := thumbhash.Encode(img)
+ Expect(err).ToNot(HaveOccurred(), "vector %d", i)
+ Expect(base64.StdEncoding.EncodeToString(got)).To(Equal(want.Hash), "vector %d (%dx%d)", i, want.W, want.H)
+ }
+ })
+
+ It("quantizes a uniform image's scales to zero", func() {
+ got, err := thumbhash.Encode(fixtureImage("solid.png"))
+ Expect(err).ToNot(HaveOccurred())
+ header24 := int(got[0]) | int(got[1])<<8 | int(got[2])<<16
+ header16 := int(got[3]) | int(got[4])<<8
+ Expect((header24>>18)&31).To(Equal(0), "lScale")
+ Expect((header16>>3)&63).To(Equal(0), "pScale")
+ Expect((header16>>9)&63).To(Equal(0), "qScale")
+ })
+
+ It("produces 24 bytes for a square opaque image", func() {
+ got, err := thumbhash.Encode(fixtureImage("square.png"))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(HaveLen(24))
+ })
+
+ It("produces 25 bytes when the image has alpha", func() {
+ got, err := thumbhash.Encode(fixtureImage("alpha.png"))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(HaveLen(25))
+ })
+
+ It("downscales an oversized image rather than failing", func() {
+ img := image.NewNRGBA(image.Rect(0, 0, 500, 300))
+ for i := range img.Pix {
+ img.Pix[i] = byte(i)
+ }
+ got, err := thumbhash.Encode(img)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(len(got)).To(BeNumerically(">=", 5))
+ })
+
+ It("encodes a 1x1 image", func() {
+ img := image.NewNRGBA(image.Rect(0, 0, 1, 1))
+ img.Set(0, 0, color.NRGBA{R: 60, G: 120, B: 180, A: 255})
+ got, err := thumbhash.Encode(img)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).ToNot(BeEmpty())
+ })
+
+ It("encodes a sub-image like an origin-anchored copy of the same region", func() {
+ parent := image.NewNRGBA(image.Rect(0, 0, 60, 50))
+ for i := range parent.Pix {
+ parent.Pix[i] = byte(i * 7 % 251)
+ }
+ region := image.Rect(10, 7, 40, 30)
+ cropped := image.NewNRGBA(image.Rect(0, 0, region.Dx(), region.Dy()))
+ draw.Draw(cropped, cropped.Bounds(), parent, region.Min, draw.Src)
+
+ got, err := thumbhash.Encode(parent.SubImage(region))
+ Expect(err).ToNot(HaveOccurred())
+ want, err := thumbhash.Encode(cropped)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(Equal(want))
+ })
+
+ It("rejects an empty image", func() {
+ _, err := thumbhash.Encode(image.NewRGBA(image.Rect(0, 0, 0, 0)))
+ Expect(err).To(HaveOccurred())
+ })
+
+ It("is deterministic", func() {
+ img := fixtureImage("square.png")
+ first, err := thumbhash.Encode(img)
+ Expect(err).ToNot(HaveOccurred())
+ second, err := thumbhash.Encode(img)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(first).To(Equal(second))
+ })
+})
diff --git a/core/image_upload.go b/core/artwork/uploader.go
similarity index 55%
rename from core/image_upload.go
rename to core/artwork/uploader.go
index eb61b225a..9c38ae2e5 100644
--- a/core/image_upload.go
+++ b/core/artwork/uploader.go
@@ -1,4 +1,4 @@
-package core
+package artwork
import (
"context"
@@ -15,13 +15,7 @@ import (
"github.com/navidrome/navidrome/utils"
)
-type ImageUploadService interface {
- SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (filename string, err error)
- RemoveImage(ctx context.Context, path string) error
-}
-
-// MaxImageUploadSize returns the configured MaxImageUploadSize in bytes, or the built-in default
-// when it's unset/invalid. Shared by every API that accepts image uploads.
+// MaxImageUploadSize returns the configured max upload size in bytes, or the built-in default.
func MaxImageUploadSize() int64 {
if size, err := humanize.ParseBytes(conf.Server.MaxImageUploadSize); err == nil && size > 0 {
return int64(size)
@@ -30,13 +24,30 @@ func MaxImageUploadSize() int64 {
return int64(size)
}
-type imageUploadService struct{}
+// Uploader stores a user-uploaded entity image and invalidates that entity's artwork state.
+type Uploader interface {
+ SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (filename string, err error)
+ RemoveImage(ctx context.Context, path string) error
+ // EnqueueArtwork re-resolves the item's artwork. Call it AFTER persisting the new
+ // filename, or the worker resolves the old one.
+ EnqueueArtwork(ctx context.Context, entityType, entityID string)
+}
+
+var uploadEntityKind = map[string]model.Kind{
+ consts.EntityArtist: model.KindArtistArtwork,
+ consts.EntityPlaylist: model.KindPlaylistArtwork,
+ consts.EntityRadio: model.KindRadioArtwork,
+}
+
+type uploader struct {
+ ds model.DataStore
+}
-func NewImageUploadService() ImageUploadService {
- return &imageUploadService{}
+func NewUploader(ds model.DataStore) Uploader {
+ return &uploader{ds: ds}
}
-func (s *imageUploadService) SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (string, error) {
+func (s *uploader) SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (string, error) {
filename := imageFilename(entityID, name, ext)
absPath := model.UploadedImagePath(entityType, filename)
@@ -44,14 +55,12 @@ func (s *imageUploadService) SetImage(ctx context.Context, entityType string, en
return "", fmt.Errorf("creating image directory: %w", err)
}
- // Remove old image if it exists
if oldPath != "" {
if err := os.Remove(oldPath); err != nil && !os.IsNotExist(err) {
- log.Warn(ctx, "Failed to remove old image", "path", oldPath, err)
+ log.Warn(ctx, "Artwork: Failed to remove old image", "path", oldPath, err)
}
}
- // Save new image
f, err := os.Create(absPath)
if err != nil {
return "", fmt.Errorf("creating image file: %w", err)
@@ -61,11 +70,20 @@ func (s *imageUploadService) SetImage(ctx context.Context, entityType string, en
if _, err := io.Copy(f, reader); err != nil {
return "", fmt.Errorf("writing image file: %w", err)
}
-
return filename, nil
}
-func (s *imageUploadService) RemoveImage(ctx context.Context, path string) error {
+func (s *uploader) EnqueueArtwork(ctx context.Context, entityType, id string) {
+ kind, ok := uploadEntityKind[entityType]
+ if !ok {
+ return
+ }
+ if err := Refresh(ctx, s.ds, kind, id); err != nil {
+ log.Warn(ctx, "Artwork: Could not refresh artwork after upload", "kind", kind, "id", id, err)
+ }
+}
+
+func (s *uploader) RemoveImage(ctx context.Context, path string) error {
if path == "" {
return nil
}
diff --git a/core/image_upload_test.go b/core/artwork/uploader_test.go
similarity index 60%
rename from core/image_upload_test.go
rename to core/artwork/uploader_test.go
index e7648df34..44f5ede26 100644
--- a/core/image_upload_test.go
+++ b/core/artwork/uploader_test.go
@@ -1,4 +1,4 @@
-package core_test
+package artwork
import (
"context"
@@ -9,20 +9,26 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
-var _ = Describe("ImageUploadService", func() {
- var svc core.ImageUploadService
+var _ = Describe("Uploader", func() {
+ var svc Uploader
var tmpDir string
+ var artRepo *tests.MockArtworkRepo
+ var queueRepo *tests.MockArtworkQueueRepo
BeforeEach(func() {
DeferCleanup(configtest.SetupConfig())
tmpDir = GinkgoT().TempDir()
conf.Server.DataFolder = conf.NewDir(tmpDir)
- svc = core.NewImageUploadService()
+ artRepo = tests.CreateMockArtworkRepo()
+ queueRepo = tests.CreateMockArtworkQueueRepo()
+ ds := &tests.MockDataStore{MockedArtwork: artRepo, MockedArtworkQueue: queueRepo}
+ svc = NewUploader(ds)
})
Describe("SetImage", func() {
@@ -69,6 +75,49 @@ var _ = Describe("ImageUploadService", func() {
_, err := svc.SetImage(ctx, consts.EntityArtist, "ar-1", "Name", "/nonexistent/path.jpg", reader, ".jpg")
Expect(err).ToNot(HaveOccurred())
})
+
+ It("does not touch artwork state or the queue (that is EnqueueArtwork's job, post-Put)", func() {
+ ctx := context.Background()
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "ar", ItemID: "ar-1", Hash: "oldhash", Source: "external",
+ })).To(Succeed())
+
+ _, err := svc.SetImage(ctx, consts.EntityArtist, "ar-1", "Pink Floyd", "", strings.NewReader("img"), ".jpg")
+ Expect(err).ToNot(HaveOccurred())
+
+ // SetImage only writes the file; the state row survives and nothing is queued until
+ // the caller has persisted the new filename and called EnqueueArtwork.
+ _, err = artRepo.GetItemArtwork(model.KindArtistArtwork, "ar-1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(queueRepo.DequeueBatch(1000)).To(BeEmpty())
+ })
+ })
+
+ Describe("EnqueueArtwork", func() {
+ It("clears artwork state and enqueues a Bump", func() {
+ ctx := context.Background()
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "ar", ItemID: "ar-1", Hash: "oldhash", Source: "external",
+ })).To(Succeed())
+
+ svc.EnqueueArtwork(ctx, consts.EntityArtist, "ar-1")
+
+ _, err := artRepo.GetItemArtwork(model.KindArtistArtwork, "ar-1", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+
+ queued, err := queueRepo.DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(queued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "ar"),
+ HaveField("ItemID", "ar-1"),
+ HaveField("Priority", model.ArtworkPriorityBump),
+ )))
+ })
+
+ It("is a no-op for an unknown entity type", func() {
+ svc.EnqueueArtwork(context.Background(), "unknown", "x-1")
+ Expect(queueRepo.DequeueBatch(1000)).To(BeEmpty())
+ })
})
Describe("RemoveImage", func() {
@@ -105,21 +154,21 @@ var _ = Describe("MaxImageUploadSize", func() {
It("returns the configured size when valid", func() {
conf.Server.MaxImageUploadSize = "20MB"
- Expect(core.MaxImageUploadSize()).To(Equal(int64(20_000_000)))
+ Expect(MaxImageUploadSize()).To(Equal(int64(20_000_000)))
})
It("returns the default size when config is empty", func() {
conf.Server.MaxImageUploadSize = ""
- Expect(core.MaxImageUploadSize()).To(Equal(int64(10_000_000)))
+ Expect(MaxImageUploadSize()).To(Equal(int64(10_000_000)))
})
It("returns the default size when config is invalid", func() {
conf.Server.MaxImageUploadSize = "not-a-size"
- Expect(core.MaxImageUploadSize()).To(Equal(int64(10_000_000)))
+ Expect(MaxImageUploadSize()).To(Equal(int64(10_000_000)))
})
It("parses raw byte values", func() {
conf.Server.MaxImageUploadSize = "52428800"
- Expect(core.MaxImageUploadSize()).To(Equal(int64(52_428_800)))
+ Expect(MaxImageUploadSize()).To(Equal(int64(52_428_800)))
})
})
diff --git a/core/artwork/wire_providers.go b/core/artwork/wire_providers.go
index 63231b54a..54c2ad397 100644
--- a/core/artwork/wire_providers.go
+++ b/core/artwork/wire_providers.go
@@ -7,5 +7,7 @@ import (
var Set = wire.NewSet(
NewArtwork,
GetImageCache,
- NewCacheWarmer,
+ NewWorker,
+ GetImageStore,
+ NewUploader,
)
diff --git a/core/artwork/worker.go b/core/artwork/worker.go
new file mode 100644
index 000000000..3042c47b0
--- /dev/null
+++ b/core/artwork/worker.go
@@ -0,0 +1,318 @@
+package artwork
+
+import (
+ "bytes"
+ "cmp"
+ "context"
+ "io"
+ "math"
+ "math/rand/v2"
+ "sync"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/core/auth"
+ "github.com/navidrome/navidrome/core/ffmpeg"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/server/events"
+ "github.com/navidrome/navidrome/utils/cache"
+)
+
+const (
+ workerPollInterval = 5 * time.Second
+ backoffBase = 5 * time.Second
+ // giveUpAfter bounds the retry budget from enqueue; past it the item falls to the
+ // periodic stale-absent recheck.
+ giveUpAfter = 12 * time.Hour
+)
+
+// drainPool drains one class of work with its own slot budget, so a blocking kind cannot
+// occupy slots another kind needs.
+type drainPool struct {
+ name string
+ kinds []string
+ concurrency int
+}
+
+// Worker drains the artwork queue: each external agent is rate-limited and circuit-broken
+// independently, and pruneMu serializes prune against the store-write window.
+type Worker struct {
+ proc *processor
+ cache cache.FileCache
+ ffmpeg ffmpeg.FFmpeg
+ broker events.Broker
+ pruneMu sync.RWMutex
+ pools []*drainPool
+ runCtx context.Context
+
+ gatesMu sync.Mutex
+ gates map[string]*extGate
+}
+
+func NewWorker(ds model.DataStore, store *ImageStore, ag *agents.Agents, ffmpeg ffmpeg.FFmpeg, broker events.Broker, imgCache cache.FileCache) *Worker {
+ w := &Worker{
+ proc: &processor{ds: ds, store: store},
+ cache: imgCache,
+ ffmpeg: ffmpeg,
+ broker: broker,
+ pools: newDrainPools(),
+ runCtx: context.Background(),
+ gates: map[string]*extGate{},
+ }
+ w.proc.resolver = newResolver(ds, ag, ffmpeg, w.gate)
+ w.proc.pruneLock = w.pruneMu.RLocker()
+ return w
+}
+
+// newDrainPools splits the drain by what bounds it: gate() holds a slot while waiting for its
+// rate-limit permit, so a sleeping lookup would crowd out a cover sitting on disk.
+func newDrainPools() []*drainPool {
+ budget := conf.MaxOpenConns() // floored at 4, so both remainders below stay positive
+ local := min(max(1, conf.Server.DevArtworkWorkerConcurrency), budget-1)
+ // More external slots than the rate allows would only sleep in the limiter.
+ external := min(max(2, 2*conf.Server.DevArtworkExternalMaxRPS), budget-local)
+ return []*drainPool{
+ {name: "local", kinds: localDrainKinds, concurrency: local},
+ {name: "external", kinds: externalDrainKinds, concurrency: external},
+ }
+}
+
+// Kind is a proxy for cost: an album that reaches an external agent still costs a local slot.
+var (
+ externalDrainKinds = []string{model.KindArtistArtwork.Prefix()}
+ localDrainKinds = []string{
+ model.KindAlbumArtwork.Prefix(),
+ model.KindPlaylistArtwork.Prefix(),
+ model.KindRadioArtwork.Prefix(),
+ model.KindMediaFileArtwork.Prefix(),
+ }
+)
+
+// Run blocks draining the queue until ctx is cancelled.
+func (w *Worker) Run(ctx context.Context) error {
+ w.runCtx = ctx
+ var wg sync.WaitGroup
+ for _, p := range w.pools {
+ wg.Go(func() { w.runPool(ctx, p) })
+ }
+ wg.Wait()
+ return nil
+}
+
+func (w *Worker) runPool(ctx context.Context, p *drainPool) {
+ ticker := time.NewTicker(workerPollInterval)
+ defer ticker.Stop()
+ for {
+ n, err := w.drain(ctx, p.concurrency, p.kinds...)
+ if err != nil && ctx.Err() == nil {
+ log.Warn(ctx, "Artwork: Worker drain failed", "pool", p.name, err)
+ }
+ if ctx.Err() != nil {
+ return
+ }
+ if n > 0 {
+ continue
+ }
+ select {
+ case <-ctx.Done():
+ return
+ case <-ticker.C:
+ }
+ }
+}
+
+// RunPrune runs prune under the worker's write lock, so no acquisition can place
+// a file while orphans are being reclaimed. This is the only sanctioned prune path.
+func (w *Worker) RunPrune(ctx context.Context) error {
+ w.pruneMu.Lock()
+ defer w.pruneMu.Unlock()
+ return prune(ctx, w.proc.ds, w.proc.store)
+}
+
+// Backfill enqueues every entity for re-resolution when the artwork config fingerprint changed,
+// artists first. It reports whether anything was enqueued.
+func (w *Worker) Backfill(ctx context.Context) (bool, error) {
+ return backfill(ctx, w.proc.ds)
+}
+
+// EnqueueStaleAbsentAll requeues known-absent entries older than staleAbsentAge.
+func (w *Worker) EnqueueStaleAbsentAll(ctx context.Context) error {
+ return enqueueStaleAbsentAll(ctx, w.proc.ds)
+}
+
+// EnqueueMissingAll requeues entities with no artwork state row: the safety net for anything
+// a scan never enqueued.
+func (w *Worker) EnqueueMissingAll(ctx context.Context) error {
+ return enqueueMissingAll(ctx, w.proc.ds)
+}
+
+func (w *Worker) drain(ctx context.Context, concurrency int, kinds ...string) (int, error) {
+ // Dequeue well past the pool size so a slow external lookup never idles the other slots.
+ // DequeueBatch does not mark rows taken, so this is one query per pass, not per slot.
+ items, err := w.proc.ds.ArtworkQueue(ctx).DequeueBatch(max(16, 4*concurrency), kinds...)
+ if err != nil {
+ return 0, err
+ }
+ if len(items) == 0 {
+ return 0, nil
+ }
+ drainStart := time.Now()
+ // Private playlists need an admin identity; resolved per drain because the worker can
+ // start before any admin exists.
+ ctx = auth.WithAdminUser(ctx, w.proc.ds)
+ sem := make(chan struct{}, concurrency)
+ var wg sync.WaitGroup
+ var refreshMu sync.Mutex
+ var refresh []model.ArtworkQueueItem
+ for _, item := range items {
+ select {
+ case sem <- struct{}{}:
+ case <-ctx.Done():
+ wg.Wait()
+ return len(items), nil
+ }
+ wg.Go(func() {
+ defer func() { <-sem }()
+ out, got := w.process(ctx, item)
+ // Absent counts as a visible change too: clients must drop a previously-served
+ // immutable cover.
+ if out == outcomeFound || out == outcomeFoundStale || out == outcomeAbsent {
+ refreshMu.Lock()
+ refresh = append(refresh, item)
+ refreshMu.Unlock()
+ }
+ // Post-outcome: the queue row is already settled, so warming the cache can't
+ // block or alter queue ops.
+ if got != nil {
+ w.precache(ctx, got)
+ }
+ })
+ }
+ wg.Wait()
+ w.broadcastRefresh(ctx, refresh)
+ log.Debug(ctx, "Artwork: Drained a batch", "kinds", kinds, "items", len(items),
+ "refreshed", len(refresh), "concurrency", concurrency, "elapsed", time.Since(drainStart))
+ return len(items), nil
+}
+
+// artworkKindToResource maps a kind to its UI resource name; media_file maps to "song", so
+// this can't derive from Kind.String().
+var artworkKindToResource = map[model.Kind]string{
+ model.KindAlbumArtwork: "album",
+ model.KindArtistArtwork: "artist",
+ model.KindPlaylistArtwork: "playlist",
+ model.KindRadioArtwork: "radio",
+ model.KindMediaFileArtwork: "song",
+}
+
+// broadcastRefresh emits one coalesced RefreshResource for the batch, so UIs re-fetch the
+// affected records and pick up the new coverArt id.
+func (w *Worker) broadcastRefresh(ctx context.Context, found []model.ArtworkQueueItem) {
+ if len(found) == 0 {
+ return
+ }
+ event := &events.RefreshResource{}
+ byResource := map[string][]string{}
+ for _, it := range found {
+ kind, _ := model.ParseKind(it.ItemKind)
+ if res, ok := artworkKindToResource[kind]; ok {
+ byResource[res] = append(byResource[res], it.ItemID)
+ }
+ }
+ if len(byResource) == 0 {
+ return
+ }
+ for res, ids := range byResource {
+ event = event.With(res, ids...)
+ }
+ w.broker.SendBroadcastMessage(ctx, event)
+}
+
+func (w *Worker) process(ctx context.Context, item model.ArtworkQueueItem) (outcome, *acquired) {
+ item.ImageType = cmp.Or(item.ImageType, model.ImageTypePrimary)
+ out, got := w.proc.acquire(ctx, item)
+
+ queue := w.proc.ds.ArtworkQueue(ctx)
+ switch out {
+ case outcomeFound, outcomeAbsent:
+ // A scan that re-enqueued this row mid-flight reset its retry_at, so the row survives
+ // here and the next drain re-resolves it.
+ if err := queue.DeleteIfUnchanged(item.ItemKind, item.ItemID, item.ImageType, item.RetryAt); err != nil {
+ log.Warn(ctx, "Artwork: Could not delete processed queue item", "kind", item.ItemKind, "id", item.ItemID, err)
+ }
+ case outcomeFoundStale, outcomeFailed:
+ retryAt := time.Now().Add(backoff(item.Attempts))
+ if retryAt.Before(item.EnqueuedAt.Add(giveUpAfter)) {
+ // A mid-flight re-enqueue reset retry_at; stale backoff must not stomp its
+ // fresh, immediate eligibility.
+ if err := queue.MarkFailedIfUnchanged(item.ItemKind, item.ItemID, item.ImageType, item.RetryAt, retryAt); err != nil {
+ log.Warn(ctx, "Artwork: Could not reschedule failed queue item", "kind", item.ItemKind, "id", item.ItemID, err)
+ }
+ log.Debug(ctx, "Artwork: Rescheduled item", "kind", item.ItemKind, "id", item.ItemID,
+ "outcome", out, "attempts", item.Attempts+1, "retryIn", time.Until(retryAt),
+ "budgetLeft", time.Until(item.EnqueuedAt.Add(giveUpAfter)))
+ break
+ }
+ // Absent is only recoverable where a periodic recheck revisits it, so other kinds keep
+ // no row; art already being served is kept, as exhaustion means unreachable, not removed.
+ settled := "kept previous state"
+ if out == outcomeFailed && hasRecheckPath(item.ItemKind) && !w.hasResolvedArtwork(ctx, item) {
+ writeAbsent(ctx, w.proc.ds.Artwork(ctx), item)
+ settled = "recorded absent"
+ }
+ log.Info(ctx, "Artwork: Retry budget exhausted, giving up", "kind", item.ItemKind, "id", item.ItemID,
+ "outcome", out, "attempts", item.Attempts+1, "budget", giveUpAfter, "settled", settled)
+ if err := queue.DeleteIfUnchanged(item.ItemKind, item.ItemID, item.ImageType, item.RetryAt); err != nil {
+ log.Warn(ctx, "Artwork: Could not remove exhausted queue item", "kind", item.ItemKind, "id", item.ItemID, err)
+ }
+ }
+ return out, got
+}
+
+func (w *Worker) hasResolvedArtwork(ctx context.Context, item model.ArtworkQueueItem) bool {
+ kind, ok := model.ParseKind(item.ItemKind)
+ if !ok {
+ return false
+ }
+ ia, err := w.proc.ds.Artwork(ctx).GetItemArtwork(kind, item.ItemID, item.ImageType)
+ return err == nil && ia.Hash != ""
+}
+
+// precache warms the resize cache at the UI cover size from the bytes just acquired, so the
+// first UI request hits without re-reading the rows or the file.
+func (w *Worker) precache(ctx context.Context, got *acquired) {
+ if !conf.Server.EnableArtworkPrecache || w.cache == nil || w.cache.Disabled(ctx) {
+ return
+ }
+ precacheStart := time.Now()
+ // Same key as the serving path: square must match what the list surfaces request, or this
+ // warms a key nothing reads.
+ item := &resizedItem{
+ hash: got.ia.Hash,
+ size: conf.Server.UICoverArtSize,
+ square: true,
+ ffmpeg: w.ffmpeg,
+ open: func() (io.ReadCloser, error) { return io.NopCloser(bytes.NewReader(got.data)), nil },
+ }
+ stream, err := w.cache.Get(ctx, item)
+ if err != nil {
+ log.Debug(ctx, "Artwork: Precache failed", "kind", got.ia.ItemKind, "id", got.ia.ItemID, err)
+ return
+ }
+ _, _ = io.Copy(io.Discard, stream)
+ _ = stream.Close()
+ log.Trace(ctx, "Artwork: Precached UI size", "kind", got.ia.ItemKind, "id", got.ia.ItemID,
+ "size", conf.Server.UICoverArtSize, "elapsed", time.Since(precacheStart))
+}
+
+// backoffFor returns min(5s×4^n, giveUpAfter) scaled by (1+jitter), with jitter in [-0.4, 0.4].
+func backoffFor(attempts int, jitter float64) time.Duration {
+ d := min(float64(backoffBase)*math.Pow(4, float64(attempts)), float64(giveUpAfter))
+ return time.Duration(d * (1 + jitter))
+}
+
+func backoff(attempts int) time.Duration {
+ return backoffFor(attempts, rand.Float64()*0.8-0.4) //nolint:gosec // retry jitter, not security-sensitive
+}
diff --git a/core/artwork/worker_soak_test.go b/core/artwork/worker_soak_test.go
new file mode 100644
index 000000000..eb7346102
--- /dev/null
+++ b/core/artwork/worker_soak_test.go
@@ -0,0 +1,146 @@
+package artwork
+
+import (
+ "context"
+ "io"
+ "os"
+ "runtime"
+ "testing"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+// Deliberately >2000: a leak guard favors a stable signal over speed.
+const soakCycles = 2200
+
+var _ = Describe("Worker soak", func() {
+ It("does not leak goroutines, heap, or fds over many acquisition cycles", func() {
+ if testing.Short() {
+ Skip("skipping soak test in short mode")
+ }
+ DeferCleanup(configtest.SetupConfig())
+
+ repoRoot, err := os.Getwd()
+ Expect(err).ToNot(HaveOccurred())
+
+ libRepo := &tests.MockLibraryRepo{}
+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})
+ folderRepo := &fakeFolderRepo{result: []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}}
+ ffm := tests.NewMockFFmpeg("")
+ ag := agents.GetAgents(&tests.MockDataStore{}, nil)
+ artRepo := tests.CreateMockArtworkRepo()
+ albumRepo := tests.CreateMockAlbumRepo()
+ albumRepo.SetData(model.Albums{
+ {ID: "al-folder", Name: "Folder Album", FolderIDs: []string{"f1"}},
+ {ID: "al-embed", Name: "Embedded Album", EmbedArtPath: "tests/fixtures/artist/an-album/test.mp3", FolderIDs: []string{"f1"}},
+ })
+ ds := &tests.MockDataStore{
+ MockedFolder: folderRepo,
+ MockedLibrary: libRepo,
+ MockedArtwork: artRepo,
+ MockedAlbum: albumRepo,
+ }
+ store := NewImageStore(GinkgoT().TempDir())
+ proc := &processor{ds: ds, store: store, resolver: newResolver(ds, ag, ffm, nil)}
+ conf.Server.CoverArtPriority = "cover.jpg, embedded"
+
+ // Dangling refs mirror an entity deleted after being enqueued.
+ items := []model.ArtworkQueueItem{
+ {ItemKind: "al", ItemID: "al-folder"},
+ {ItemKind: "al", ItemID: "al-embed"},
+ {ItemKind: "al", ItemID: "al-does-not-exist"},
+ {ItemKind: "ra", ItemID: "ra-does-not-exist"},
+ }
+
+ fdCount := func() int {
+ if runtime.GOOS != "linux" {
+ return -1
+ }
+ entries, err := os.ReadDir("/proc/self/fd")
+ if err != nil {
+ return -1
+ }
+ return len(entries)
+ }
+
+ settleGoroutines := func() int {
+ // Background goroutines wind down late, so poll for two consecutive equal samples.
+ prev := -1
+ for range 100 {
+ runtime.GC()
+ n := runtime.NumGoroutine()
+ if n == prev {
+ return n
+ }
+ prev = n
+ time.Sleep(10 * time.Millisecond)
+ }
+ return prev
+ }
+
+ baselineGoroutines := settleGoroutines()
+ baselineFDs := fdCount()
+
+ var heapAt10Pct uint64
+ start := time.Now()
+ for i := range soakCycles {
+ it := items[i%len(items)]
+ out, _ := proc.acquire(context.Background(), it)
+
+ // Read-back exercises the surfaces a caller would use after acquisition.
+ if out == outcomeFound {
+ kind, _ := model.ParseKind(it.ItemKind)
+ ia, err := artRepo.GetItemArtwork(kind, it.ItemID, model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred(), "cycle %d: GetItemArtwork", i)
+ art, err := artRepo.GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred(), "cycle %d: GetImage", i)
+ rc, err := store.Open(ia.Hash, art.Mime)
+ switch {
+ case err == nil:
+ _, _ = io.Copy(io.Discard, rc)
+ rc.Close()
+ case os.IsNotExist(err):
+ // Folder-backed art has no store file; that's expected.
+ default:
+ Expect(err).ToNot(HaveOccurred(), "cycle %d: store.Open", i)
+ }
+ }
+
+ if i == soakCycles/10 {
+ runtime.GC()
+ var ms runtime.MemStats
+ runtime.ReadMemStats(&ms)
+ heapAt10Pct = ms.HeapAlloc
+ }
+ }
+ elapsed := time.Since(start)
+
+ finalGoroutines := settleGoroutines()
+ finalFDs := fdCount()
+
+ runtime.GC()
+ var ms runtime.MemStats
+ runtime.ReadMemStats(&ms)
+
+ GinkgoWriter.Printf("soak: cycles=%d elapsed=%s goroutines(baseline=%d final=%d) heap(10%%-mark=%d final=%d) fds(baseline=%d final=%d)\n",
+ soakCycles, elapsed, baselineGoroutines, finalGoroutines, heapAt10Pct, ms.HeapAlloc, baselineFDs, finalFDs)
+
+ Expect(finalGoroutines).To(BeNumerically("<=", baselineGoroutines), "goroutine count grew: baseline=%d final=%d", baselineGoroutines, finalGoroutines)
+ if heapAt10Pct > 0 {
+ Expect(ms.HeapAlloc).To(BeNumerically("<=", 2*heapAt10Pct), "heap did not plateau: 10%%-mark=%d final=%d (final > 2x 10%%-mark)", heapAt10Pct, ms.HeapAlloc)
+ }
+ if runtime.GOOS == "linux" && baselineFDs >= 0 {
+ Expect(finalFDs).To(BeNumerically("<=", baselineFDs), "fd count grew: baseline=%d final=%d", baselineFDs, finalFDs)
+ }
+ })
+})
diff --git a/core/artwork/worker_test.go b/core/artwork/worker_test.go
new file mode 100644
index 000000000..1f3b52840
--- /dev/null
+++ b/core/artwork/worker_test.go
@@ -0,0 +1,813 @@
+package artwork
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "io"
+ "net/http"
+ "os"
+ "slices"
+ "sync"
+ "time"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/server/events"
+ "github.com/navidrome/navidrome/tests"
+ "github.com/navidrome/navidrome/utils/cache"
+ "github.com/navidrome/navidrome/utils/slice"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "go.uber.org/goleak"
+)
+
+type recordingCache struct {
+ cache.FileCache
+ mu sync.Mutex
+ keys []string
+ disabled bool
+}
+
+func (c *recordingCache) Disabled(ctx context.Context) bool {
+ return c.disabled || c.FileCache.Disabled(ctx)
+}
+
+func (c *recordingCache) Get(ctx context.Context, arg cache.Item) (*cache.CachedStream, error) {
+ c.mu.Lock()
+ c.keys = append(c.keys, arg.Key())
+ c.mu.Unlock()
+ return c.FileCache.Get(ctx, arg)
+}
+
+func (c *recordingCache) getKeys() []string {
+ c.mu.Lock()
+ defer c.mu.Unlock()
+ return slices.Clone(c.keys)
+}
+
+// Simulates a concurrent Enqueue between DequeueBatch and the worker's delete, so
+// DeleteIfUnchanged on the dequeued value no-ops.
+type reenqueueOnDequeue struct {
+ *tests.MockArtworkQueueRepo
+ done bool
+}
+
+func (r *reenqueueOnDequeue) DequeueBatch(n int, kinds ...string) ([]model.ArtworkQueueItem, error) {
+ items, err := r.MockArtworkQueueRepo.DequeueBatch(n, kinds...)
+ if !r.done && len(items) > 0 {
+ r.done = true
+ for k, it := range r.Data {
+ if it.ItemKind == items[0].ItemKind && it.ItemID == items[0].ItemID {
+ it.RetryAt = items[0].RetryAt.Add(time.Minute)
+ r.Data[k] = it
+ }
+ }
+ }
+ return items, err
+}
+
+type fakeEventBroker struct {
+ http.Handler
+ mu sync.Mutex
+ events []events.Event
+}
+
+func (f *fakeEventBroker) SendMessage(_ context.Context, event events.Event) {
+ f.mu.Lock()
+ defer f.mu.Unlock()
+ f.events = append(f.events, event)
+}
+
+func (f *fakeEventBroker) SendBroadcastMessage(_ context.Context, event events.Event) {
+ f.mu.Lock()
+ defer f.mu.Unlock()
+ f.events = append(f.events, event)
+}
+
+func (f *fakeEventBroker) getEvents() []events.Event {
+ f.mu.Lock()
+ defer f.mu.Unlock()
+ return slices.Clone(f.events)
+}
+
+var _ events.Broker = (*fakeEventBroker)(nil)
+
+func findQueued(q *tests.MockArtworkQueueRepo, kind, id string) *model.ArtworkQueueItem {
+ for _, it := range q.Data {
+ if it.ItemKind == kind && it.ItemID == id {
+ return &it
+ }
+ }
+ return nil
+}
+
+var _ = Describe("Worker", func() {
+ var (
+ ctx context.Context
+ ds *tests.MockDataStore
+ folderRepo *fakeFolderRepo
+ libRepo *tests.MockLibraryRepo
+ ffm *tests.MockFFmpeg
+ ag *agents.Agents
+ store *ImageStore
+ artRepo *tests.MockArtworkRepo
+ queueRepo *tests.MockArtworkQueueRepo
+ broker *fakeEventBroker
+ imgCache *recordingCache
+ repoRoot string
+ w *Worker
+ )
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ ctx = context.Background()
+ var err error
+ repoRoot, err = os.Getwd()
+ Expect(err).ToNot(HaveOccurred())
+ conf.Server.CacheFolder = conf.NewDir(GinkgoT().TempDir())
+
+ folderRepo = &fakeFolderRepo{}
+ libRepo = &tests.MockLibraryRepo{}
+ libRepo.SetData(model.Libraries{{ID: 0, Path: testFileLibPath(repoRoot)}})
+ ffm = tests.NewMockFFmpeg("")
+ ag = agents.GetAgents(&tests.MockDataStore{}, nil)
+ artRepo = tests.CreateMockArtworkRepo()
+ queueRepo = tests.CreateMockArtworkQueueRepo()
+ ds = &tests.MockDataStore{
+ MockedFolder: folderRepo,
+ MockedLibrary: libRepo,
+ MockedArtwork: artRepo,
+ MockedArtworkQueue: queueRepo,
+ }
+ ds.MockedAlbum = tests.CreateMockAlbumRepo()
+ store = NewImageStore(GinkgoT().TempDir())
+ conf.Server.CoverArtPriority = "cover.jpg, embedded"
+ conf.Server.DevArtworkExternalMaxRPS = 1000 // keep the limiter out of the way of behavior tests
+ broker = &fakeEventBroker{}
+ imgCache = &recordingCache{FileCache: cache.NewFileCache("WorkerTest", "100MB", "images", 0,
+ func(ctx context.Context, arg cache.Item) (io.Reader, error) {
+ return arg.(artworkReader).Reader(ctx)
+ })}
+ Eventually(func() bool { return imgCache.Available(ctx) }).Should(BeTrue())
+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)
+ })
+
+ Describe("drain", func() {
+ It("processes a seeded queue item and removes it from the queue", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al1", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{
+ ItemKind: "al", ItemID: "al1", Priority: model.ArtworkPriorityScan,
+ })).To(Succeed())
+
+ n, err := w.drain(ctx, 2)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("folder"))
+
+ count, err := queueRepo.Count()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(count).To(BeZero(), "a found item must be deleted from the queue")
+ })
+
+ It("processes an mf queue item, writing state and storing embedded bytes", func() {
+ conf.Server.EnableMediaFileCoverArt = true
+ ds.MockedMediaFile = tests.CreateMockMediaFileRepo()
+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+ {ID: "mf1", LibraryID: 0, Path: "tests/fixtures/artist/an-album/test.mp3", HasCoverArt: true},
+ })
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{
+ ItemKind: "mf", ItemID: "mf1", Priority: model.ArtworkPriorityBump,
+ })).To(Succeed())
+
+ n, err := w.drain(ctx, 2)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ ia, err := artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mf1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("embedded"))
+ Expect(ia.Hash).ToNot(BeEmpty())
+
+ art, err := artRepo.GetImage(ia.Hash)
+ Expect(err).ToNot(HaveOccurred())
+ r, err := store.Open(ia.Hash, art.Mime)
+ Expect(err).ToNot(HaveOccurred())
+ defer r.Close()
+ data, err := io.ReadAll(r)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(data).ToNot(BeEmpty(), "embedded bytes must be written to the store")
+
+ count, err := queueRepo.Count()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(count).To(BeZero())
+ })
+
+ It("reschedules a failed item via MarkFailed with a backed-off retry_at", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al4", Name: "Album"}})
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al4"})).To(Succeed())
+
+ n, err := w.drain(ctx, 2)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ it := findQueued(queueRepo, "al", "al4")
+ Expect(it).ToNot(BeNil())
+ Expect(it.Attempts).To(Equal(1))
+ Expect(it.RetryAt).To(BeTemporally(">", time.Now()))
+
+ _, err = artRepo.GetItemArtwork(model.KindAlbumArtwork, "al4", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound), "a timeout must never settle on absent")
+ })
+
+ It("reschedules a found-stale item via MarkFailed while keeping its served state", func() {
+ conf.Server.CoverArtPriority = "external, cover.jpg"
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "alstale", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "alstale"})).To(Succeed())
+
+ n, err := w.drain(ctx, 2)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ it := findQueued(queueRepo, "al", "alstale")
+ Expect(it).ToNot(BeNil(), "a found-stale row must survive for a higher-priority retry")
+ Expect(it.Attempts).To(Equal(1))
+ Expect(it.RetryAt).To(BeTemporally(">", time.Now()))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alstale", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("folder"), "the fallback art is served meanwhile")
+
+ evts := broker.getEvents()
+ Expect(evts).To(HaveLen(1), "the served fallback art must live-refresh the UI")
+ Expect(evts[0].(*events.RefreshResource).Data(evts[0])).To(ContainSubstring("alstale"))
+ })
+
+ It("keeps a row re-enqueued between dequeue and delete", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al7", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+ racing := &reenqueueOnDequeue{MockArtworkQueueRepo: queueRepo}
+ ds.MockedArtworkQueue = racing
+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{
+ ItemKind: "al", ItemID: "al7", Priority: model.ArtworkPriorityScan,
+ })).To(Succeed())
+
+ n, err := w.drain(ctx, 1)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ // The concurrent re-enqueue changed retry_at, so the found-path delete was a no-op.
+ Expect(findQueued(queueRepo, "al", "al7")).ToNot(BeNil())
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al7", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("folder"))
+ })
+
+ It("keeps a fresh re-enqueue ahead of a stale failure backoff", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al8", Name: "Album"}})
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+ racing := &reenqueueOnDequeue{MockArtworkQueueRepo: queueRepo}
+ ds.MockedArtworkQueue = racing
+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al8"})).To(Succeed())
+ dequeued := findQueued(queueRepo, "al", "al8").RetryAt
+
+ n, err := w.drain(ctx, 1)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ // The re-enqueue reset retry_at; the failure path must not stomp it nor bump attempts.
+ it := findQueued(queueRepo, "al", "al8")
+ Expect(it).ToNot(BeNil())
+ Expect(it.Attempts).To(BeZero())
+ Expect(it.RetryAt).To(BeTemporally("==", dequeued.Add(time.Minute)))
+ })
+
+ It("gives up and settles absent once the retry budget is exhausted", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al9", Name: "Album"}})
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al9"})).To(Succeed())
+ // Age the row past the retry budget.
+ for k, v := range queueRepo.Data {
+ if v.ItemID == "al9" {
+ v.EnqueuedAt = time.Now().Add(-(giveUpAfter + time.Hour))
+ queueRepo.Data[k] = v
+ }
+ }
+
+ n, err := w.drain(ctx, 1)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ Expect(findQueued(queueRepo, "al", "al9")).To(BeNil())
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al9", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).To(BeEmpty())
+ })
+
+ It("keeps already-served art when the retry budget is exhausted", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al10", Name: "Album"}})
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "al10", ImageType: model.ImageTypePrimary,
+ Hash: "cafebabe", Source: "external:lastfm",
+ })).To(Succeed())
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+ w = NewWorker(ds, store, ag, ffm, broker, imgCache)
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al10"})).To(Succeed())
+ for k, v := range queueRepo.Data {
+ if v.ItemID == "al10" {
+ v.EnqueuedAt = time.Now().Add(-(giveUpAfter + time.Hour))
+ queueRepo.Data[k] = v
+ }
+ }
+
+ n, err := w.drain(ctx, 1)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ Expect(findQueued(queueRepo, "al", "al10")).To(BeNil())
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al10", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).To(Equal("cafebabe"), "a persistent outage must not discard served art")
+ })
+
+ // Media files are excluded from recheckKinds, so an absent row here would never be
+ // revisited: a transient read error would look permanent.
+ It("does not settle absent on exhaustion for a kind with no recheck path", func() {
+ conf.Server.EnableMediaFileCoverArt = true
+ ds.MockedMediaFile = tests.CreateMockMediaFileRepo()
+ ds.MockedMediaFile.(*tests.MockMediaFileRepo).SetData(model.MediaFiles{
+ {ID: "mfX", LibraryID: 0, Path: "tests/fixtures/artist/an-album/gone.mp3", HasCoverArt: true},
+ })
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "mf", ItemID: "mfX"})).To(Succeed())
+ for k, v := range queueRepo.Data {
+ if v.ItemID == "mfX" {
+ v.EnqueuedAt = time.Now().Add(-(giveUpAfter + time.Hour))
+ queueRepo.Data[k] = v
+ }
+ }
+
+ n, err := w.drain(ctx, 1)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ Expect(findQueued(queueRepo, "mf", "mfX")).To(BeNil(), "the row must stop retrying")
+ _, err = artRepo.GetItemArtwork(model.KindMediaFileArtwork, "mfX", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound),
+ "no row leaves the track unresolved, so a later view can still recover it")
+ })
+
+ It("resolves a private playlist under an admin context instead of failing forever", func() {
+ ds.MockedUser = adminUserRepo()
+ vds := &visibilityPlaylistDS{
+ MockDataStore: ds,
+ private: model.Playlist{ID: "plPriv", OwnerID: "admin"},
+ tracks: &tests.MockPlaylistTrackRepo{},
+ }
+ w = NewWorker(vds, store, ag, ffm, broker, imgCache)
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "pl", ItemID: "plPriv"})).To(Succeed())
+
+ n, err := w.drain(ctx, 1)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ Expect(findQueued(queueRepo, "pl", "plPriv")).To(BeNil())
+ ia, err := artRepo.GetItemArtwork(model.KindPlaylistArtwork, "plPriv", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).To(BeEmpty())
+ })
+
+ It("returns zero when the queue is empty", func() {
+ n, err := w.drain(ctx, 2)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(BeZero())
+ })
+
+ It("broadcasts a single refresh event for the found items in a batch", func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "al1", Name: "Album 1", FolderIDs: []string{"f1"}},
+ {ID: "al2", Name: "Album 2", FolderIDs: []string{"f1"}},
+ })
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al1", Priority: model.ArtworkPriorityScan})).To(Succeed())
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al2", Priority: model.ArtworkPriorityScan})).To(Succeed())
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "ar", ItemID: "ar1", Priority: model.ArtworkPriorityScan})).To(Succeed())
+
+ n, err := w.drain(ctx, 3)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(3))
+
+ evts := broker.getEvents()
+ Expect(evts).To(HaveLen(1), "exactly one coalesced event per drain batch")
+ rr, ok := evts[0].(*events.RefreshResource)
+ Expect(ok).To(BeTrue())
+ data := rr.Data(rr)
+ Expect(data).To(ContainSubstring(`"album"`))
+ Expect(data).To(ContainSubstring("al1"))
+ Expect(data).To(ContainSubstring("al2"))
+ Expect(data).ToNot(ContainSubstring("artist"), "a failed (unresolved) artist must not be refreshed")
+ Expect(data).ToNot(ContainSubstring("ar1"))
+ })
+
+ DescribeTable("only lists the kinds it actually resolved",
+ func(kinds []string, wantSong bool) {
+ items := slice.Map(kinds, func(k string) model.ArtworkQueueItem {
+ return model.ArtworkQueueItem{ItemKind: k, ItemID: k + "1"}
+ })
+ w.broadcastRefresh(ctx, items)
+
+ evts := broker.getEvents()
+ Expect(evts).To(HaveLen(1))
+ data := evts[0].(*events.RefreshResource).Data(evts[0])
+ if wantSong {
+ Expect(data).To(ContainSubstring(`"song"`))
+ } else {
+ Expect(data).ToNot(ContainSubstring(`"song"`))
+ }
+ },
+ // An album's tracks inherit its art, but the dependent ids are unbounded: the client
+ // fans an album refresh out to the tracks it has loaded.
+ Entry("album alone does not name songs", []string{"al"}, false),
+ Entry("artist alone does not", []string{"ar"}, false),
+ Entry("playlist alone does not", []string{"pl"}, false),
+ Entry("album mixed with others still does not", []string{"ar", "al"}, false),
+ Entry("songs resolving on their own are listed by id", []string{"mf"}, true),
+ )
+
+ It("broadcasts a refresh when an item resolves to absent (removed cover)", func() {
+ conf.Server.CoverArtPriority = "cover.*" // local-only; no folder image → absent
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "al3", Name: "Artless"}})
+ folderRepo.result = nil
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "al3", Priority: model.ArtworkPriorityScan})).To(Succeed())
+
+ n, err := w.drain(ctx, 2)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ evts := broker.getEvents()
+ Expect(evts).To(HaveLen(1), "a removed cover must live-refresh clients so they drop it")
+ Expect(evts[0].(*events.RefreshResource).Data(evts[0])).To(ContainSubstring("al3"))
+
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al3", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Hash).To(BeEmpty(), "the outcome was absent, not found")
+ })
+
+ It("does not broadcast when no item is found", func() {
+ conf.Server.CoverArtPriority = "external"
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "alx", Name: "Album"}})
+ imageAgents(&fakeImageAgent{name: "failAgent", err: errors.New("agent timed out")})
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{ItemKind: "al", ItemID: "alx"})).To(Succeed())
+
+ n, err := w.drain(ctx, 2)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ Expect(broker.getEvents()).To(BeEmpty(), "a drain with no found items sends no event")
+ })
+ })
+
+ Describe("gate/breaker", func() {
+ It("opens after 5 consecutive external errors and short-circuits the step", func() {
+ var calls int
+ failing := func() (io.ReadCloser, string, error) {
+ calls++
+ return nil, "", errors.New("boom")
+ }
+ for range 5 {
+ _, _, err := w.gate("A", failing)
+ Expect(err).To(HaveOccurred())
+ }
+ Expect(calls).To(Equal(5))
+
+ _, _, err := w.gate("A", failing)
+ Expect(err).To(MatchError(errBreakerOpen))
+ Expect(calls).To(Equal(5), "an open breaker must not call the external step")
+ })
+
+ It("resets the failure count on a successful call", func() {
+ failing := func() (io.ReadCloser, string, error) { return nil, "", errors.New("boom") }
+ ok := func() (io.ReadCloser, string, error) { return io.NopCloser(nil), "p", nil }
+ for range 4 {
+ _, _, _ = w.gate("A", failing)
+ }
+ _, _, err := w.gate("A", ok)
+ Expect(err).ToNot(HaveOccurred())
+
+ var calls int
+ counting := func() (io.ReadCloser, string, error) {
+ calls++
+ return nil, "", errors.New("boom")
+ }
+ for range 5 {
+ _, _, _ = w.gate("A", counting)
+ }
+ Expect(calls).To(Equal(5), "the breaker should have re-closed after the success")
+ })
+
+ It("does not open the breaker on a run of agent not-found misses", func() {
+ // agents.ErrNotFound is a definitive miss, not a fault: artless items must not
+ // trip the breaker, or they would loop in retry instead of settling absent.
+ notFound := func() (io.ReadCloser, string, error) { return nil, "", agents.ErrNotFound }
+ for range breakerThreshold + 3 {
+ _, _, err := w.gate("A", notFound)
+ Expect(err).To(MatchError(agents.ErrNotFound), "a miss passes through, never errBreakerOpen")
+ }
+
+ var calls int
+ counting := func() (io.ReadCloser, string, error) {
+ calls++
+ return nil, "", errors.New("boom")
+ }
+ _, _, _ = w.gate("A", counting)
+ Expect(calls).To(Equal(1), "the breaker stayed closed, so the step still runs")
+ })
+
+ It("isolates each agent's breaker: one open gate does not block another", func() {
+ failing := func() (io.ReadCloser, string, error) { return nil, "", errors.New("boom") }
+ for range breakerThreshold {
+ _, _, _ = w.gate("A", failing)
+ }
+ _, _, err := w.gate("A", failing)
+ Expect(err).To(MatchError(errBreakerOpen), "agent A's breaker is open")
+
+ var bCalls int
+ bStep := func() (io.ReadCloser, string, error) {
+ bCalls++
+ return io.NopCloser(nil), "p", nil
+ }
+ for range breakerThreshold + 2 {
+ _, _, err := w.gate("B", bStep)
+ Expect(err).ToNot(HaveOccurred(), "agent B keeps being called while A is open")
+ }
+ Expect(bCalls).To(Equal(breakerThreshold + 2))
+ })
+ })
+
+ Describe("precache", func() {
+ BeforeEach(func() {
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{
+ {ID: "alpc", Name: "Album", FolderIDs: []string{"f1"}},
+ })
+ conf.Server.UICoverArtSize = 300
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{
+ ItemKind: "al", ItemID: "alpc", Priority: model.ArtworkPriorityScan,
+ })).To(Succeed())
+ })
+
+ It("warms the resize cache at the UI cover size after a found acquisition", func() {
+ conf.Server.EnableArtworkPrecache = true
+
+ n, err := w.drain(ctx, 1)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ // The list surfaces request square covers, so warming any other key is wasted work.
+ Expect(imgCache.getKeys()).To(ContainElement(ContainSubstring(".300.true.")))
+ })
+
+ It("skips warming when precache is disabled", func() {
+ conf.Server.EnableArtworkPrecache = false
+
+ n, err := w.drain(ctx, 1)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(1))
+
+ Expect(imgCache.getKeys()).To(BeEmpty())
+ })
+
+ // It warms from the bytes acquisition already held, so no state row or store file is needed.
+ It("warms from the acquired bytes without reading them back", func() {
+ conf.Server.EnableArtworkPrecache = true
+ ia := &model.ItemArtwork{
+ ItemKind: "al", ItemID: "unpersisted", ImageType: model.ImageTypePrimary,
+ Hash: "abcdef0123456789", UpdatedAt: time.Now(),
+ }
+
+ data, err := os.ReadFile("tests/fixtures/artist/an-album/cover.jpg")
+ Expect(err).ToNot(HaveOccurred())
+
+ w.precache(ctx, &acquired{ia: ia, mime: "image/jpeg", data: data})
+
+ // Nothing backs that hash on disk, so a hit can only come from the bytes handed in;
+ // the probe refuses to open, proving nothing is re-read.
+ probe := &resizedItem{
+ hash: ia.Hash, size: 300, square: true, ffmpeg: ffm,
+ open: func() (io.ReadCloser, error) { return nil, errors.New("precache must not re-read the source") },
+ }
+ stream, err := imgCache.Get(ctx, probe)
+ Expect(err).ToNot(HaveOccurred())
+ defer stream.Close()
+ Expect(io.ReadAll(stream)).ToNot(BeEmpty())
+ })
+ })
+
+ Describe("drain pools", func() {
+ // A kind in neither pool is never dequeued, with nothing to catch it at compile time.
+ It("covers every kind the worker can process, exactly once", func() {
+ var pooled []string
+ for _, p := range newDrainPools() {
+ pooled = append(pooled, p.kinds...)
+ }
+ for kind := range artworkKindToResource {
+ Expect(pooled).To(ContainElement(kind.Prefix()), "kind %q belongs to no drain pool", kind.Prefix())
+ }
+ Expect(pooled).To(HaveLen(len(artworkKindToResource)), "a kind is claimed by more than one pool")
+ })
+
+ // Artists resolve through a rate-limited agent that holds its slot while waiting, so one
+ // shared pool would park every album behind them.
+ It("resolves albums while artists are stuck on a slow agent", func() {
+ conf.Server.CoverArtPriority = "cover.jpg"
+ conf.Server.ArtistArtPriority = "external"
+ folderRepo.result = []model.Folder{{
+ Path: "tests/fixtures/artist/an-album",
+ ImageFiles: []string{"cover.jpg"},
+ }}
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "alx", Name: "Album", FolderIDs: []string{"f1"}}})
+ ds.MockedArtist = tests.CreateMockArtistRepo()
+
+ // Every artist lookup blocks until released, standing in for the rate limiter.
+ block := make(chan struct{})
+ artists := model.Artists{}
+ for i := range 8 {
+ artists = append(artists, model.Artist{ID: fmt.Sprintf("arx%d", i), Name: "A"})
+ }
+ ds.MockedArtist.(*tests.MockArtistRepo).SetData(artists)
+ imageAgents(&fakeImageAgent{name: "slowAgent", block: block})
+
+ // Artists first, exactly as Backfill orders them.
+ for _, a := range artists {
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{
+ ItemKind: "ar", ItemID: a.ID, Priority: model.ArtworkPriorityBackfill,
+ })).To(Succeed())
+ }
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{
+ ItemKind: "al", ItemID: "alx", Priority: model.ArtworkPriorityBackfill,
+ })).To(Succeed())
+
+ runCtx, cancel := context.WithCancel(ctx)
+ done := make(chan struct{})
+ go func() { defer close(done); _ = w.Run(runCtx) }()
+ // Join Run: a leaked pool goroutine would race the config snapshot Ginkgo restores.
+ DeferCleanup(func() {
+ cancel()
+ close(block) // unpark the blocked lookups so the pools can unwind
+ <-done
+ })
+
+ Eventually(func() bool {
+ ia, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "alx", model.ImageTypePrimary)
+ return err == nil && ia.Hash != ""
+ }, 5*time.Second, 50*time.Millisecond).Should(BeTrue(),
+ "a blocked external pool must not hold up local artwork")
+
+ _, err := artRepo.GetItemArtwork(model.KindArtistArtwork, "arx0", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound), "artists are still blocked, as intended")
+ })
+ })
+
+ Describe("batching", func() {
+ It("leaves undispatched items queued when cancelled mid-batch", func() {
+ for i := range 8 {
+ id := fmt.Sprintf("alc%d", i)
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: id, Name: "Album"}})
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{
+ ItemKind: "al", ItemID: id, Priority: model.ArtworkPriorityScan,
+ })).To(Succeed())
+ }
+ cancelledCtx, cancel := context.WithCancel(ctx)
+ cancel()
+
+ _, err := w.drain(cancelledCtx, 1)
+ Expect(err).ToNot(HaveOccurred())
+
+ for i := range 8 {
+ id := fmt.Sprintf("alc%d", i)
+ Expect(findQueued(queueRepo, "al", id)).ToNot(BeNil(), "row "+id+" must survive a cancelled drain")
+ }
+ })
+
+ It("dequeues past the worker pool so one drain covers many items", func() {
+ for i := range 16 {
+ ds.MockedAlbum.(*tests.MockAlbumRepo).SetData(model.Albums{{ID: fmt.Sprintf("alb%d", i), Name: "Album"}})
+ Expect(queueRepo.Enqueue(model.ArtworkQueueItem{
+ ItemKind: "al", ItemID: fmt.Sprintf("alb%d", i), Priority: model.ArtworkPriorityScan,
+ })).To(Succeed())
+ }
+
+ n, err := w.drain(ctx, 2)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(16), "a batch sized to the pool would have stopped at 4")
+ })
+ })
+
+ Describe("RunPrune", func() {
+ It("runs a prune under the worker mutex", func() {
+ Expect(w.RunPrune(ctx)).To(Succeed())
+ })
+ })
+
+ Describe("Run", func() {
+ It("exits cleanly when the context is cancelled", func() {
+ runCtx, cancel := context.WithCancel(ctx)
+ done := make(chan error, 1)
+ go func() { done <- w.Run(runCtx) }()
+
+ cancel()
+ Eventually(done, time.Second).Should(Receive(BeNil()))
+ })
+
+ It("does not leak goroutines after Run exits", func() {
+ DeferCleanup(configtest.SetupConfig())
+
+ ignore := goleak.IgnoreCurrent()
+ DeferCleanup(func() { goleak.VerifyNone(GinkgoT(), ignore) })
+
+ localDS := &tests.MockDataStore{MockedArtworkQueue: tests.CreateMockArtworkQueueRepo()}
+ lw := NewWorker(localDS, NewImageStore(GinkgoT().TempDir()), agents.GetAgents(localDS, nil), tests.NewMockFFmpeg(""), &fakeEventBroker{}, imgCache)
+
+ runCtx, cancel := context.WithCancel(ctx)
+ done := make(chan error, 1)
+ go func() { done <- lw.Run(runCtx) }()
+
+ time.Sleep(20 * time.Millisecond) // let the loop settle on the idle select
+ cancel()
+ Eventually(done, 2*time.Second).Should(Receive(BeNil()))
+ })
+ })
+})
+
+var _ = Describe("backoff", func() {
+ It("returns the expected schedule with no jitter", func() {
+ for _, c := range []struct {
+ attempts int
+ want time.Duration
+ }{
+ {0, 5 * time.Second},
+ {1, 20 * time.Second},
+ {2, 80 * time.Second},
+ {3, 320 * time.Second},
+ {4, 1280 * time.Second},
+ {5, 5120 * time.Second},
+ {6, 20480 * time.Second},
+ {7, 12 * time.Hour},
+ {8, 12 * time.Hour},
+ } {
+ Expect(backoffFor(c.attempts, 0)).To(Equal(c.want), "attempt %d", c.attempts)
+ }
+ })
+
+ It("applies jitter proportionally", func() {
+ base := backoffFor(2, 0)
+ Expect(backoffFor(2, 0.2)).To(Equal(time.Duration(float64(base) * 1.2)))
+ Expect(backoffFor(2, -0.2)).To(Equal(time.Duration(float64(base) * 0.8)))
+ })
+
+ It("keeps random jitter within +/-40%", func() {
+ lo := time.Duration(float64(320*time.Second) * 0.6)
+ hi := time.Duration(float64(320*time.Second) * 1.4)
+ for range 200 {
+ d := backoff(3)
+ Expect(d).To(BeNumerically(">=", lo))
+ Expect(d).To(BeNumerically("<=", hi))
+ }
+ })
+})
diff --git a/core/artwork/worker_timing_test.go b/core/artwork/worker_timing_test.go
new file mode 100644
index 000000000..f7315b20a
--- /dev/null
+++ b/core/artwork/worker_timing_test.go
@@ -0,0 +1,76 @@
+package artwork
+
+import (
+ "errors"
+ "io"
+ "testing"
+ "testing/synctest"
+ "time"
+
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/gomega"
+)
+
+// Drives the real breaker state machine with the fake clock. Plain test: testing/synctest
+// needs a *testing.T, which Ginkgo doesn't give.
+func TestArtworkBreakerHalfOpen(t *testing.T) {
+ synctest.Test(t, func(t *testing.T) {
+ g := NewWithT(t)
+ b := newBreaker()
+
+ for range breakerThreshold {
+ b.record("agentA", errors.New("boom"))
+ }
+ g.Expect(b.allow()).To(BeFalse(), "breaker opens after consecutive errors")
+
+ time.Sleep(breakerProbeAfter - time.Nanosecond)
+ g.Expect(b.allow()).To(BeFalse(), "still open before the probe interval")
+
+ time.Sleep(time.Nanosecond)
+ g.Expect(b.allow()).To(BeTrue(), "half-open: one probe is granted")
+ g.Expect(b.allow()).To(BeFalse(), "only a single probe per interval")
+
+ b.record("agentA", errors.New("boom")) // probe fails -> stay open
+ time.Sleep(breakerProbeAfter)
+ g.Expect(b.allow()).To(BeTrue(), "another probe after the next interval")
+
+ b.record("agentA", nil) // probe succeeds -> close
+ g.Expect(b.allow()).To(BeTrue(), "closed breaker admits freely")
+ g.Expect(b.allow()).To(BeTrue())
+ })
+}
+
+func TestArtworkGatePerAgentBreakerIsolation(t *testing.T) {
+ synctest.Test(t, func(t *testing.T) {
+ g := NewWithT(t)
+ w := NewWorker(&tests.MockDataStore{}, NewImageStore(t.TempDir()),
+ agents.GetAgents(&tests.MockDataStore{}, nil), tests.NewMockFFmpeg(""), &fakeEventBroker{}, nil)
+
+ fail := func() (io.ReadCloser, string, error) { return nil, "", errors.New("boom") }
+ for range breakerThreshold {
+ _, _, _ = w.gate("A", fail)
+ }
+ _, _, err := w.gate("A", fail)
+ g.Expect(err).To(MatchError(errBreakerOpen), "A opens after consecutive errors")
+
+ // B has its own breaker, untouched by A being open.
+ var bCalls int
+ bStep := func() (io.ReadCloser, string, error) { bCalls++; return nil, "", errors.New("boom") }
+ for range breakerThreshold - 1 {
+ _, _, err := w.gate("B", bStep)
+ g.Expect(err).To(MatchError("boom"))
+ }
+ g.Expect(bCalls).To(Equal(breakerThreshold-1), "B keeps being called while A is open")
+
+ // After the probe window, A admits exactly one probe again.
+ time.Sleep(breakerProbeAfter)
+ var aCalls int
+ aFail := func() (io.ReadCloser, string, error) { aCalls++; return nil, "", errors.New("boom") }
+ _, _, _ = w.gate("A", aFail)
+ g.Expect(aCalls).To(Equal(1), "A grants a single probe after the interval")
+ _, _, err = w.gate("A", aFail)
+ g.Expect(err).To(MatchError(errBreakerOpen), "the probe failed, so A stays open")
+ g.Expect(aCalls).To(Equal(1))
+ })
+}
diff --git a/core/external/provider.go b/core/external/provider.go
index 869841e06..efd061c0c 100644
--- a/core/external/provider.go
+++ b/core/external/provider.go
@@ -4,7 +4,6 @@ import (
"context"
"errors"
"fmt"
- "net/url"
"sort"
"strings"
"time"
@@ -35,8 +34,6 @@ type Provider interface {
UpdateArtistInfo(ctx context.Context, id string, count int, includeNotPresent bool) (*model.Artist, error)
SimilarSongs(ctx context.Context, id string, count int) (model.MediaFiles, error)
TopSongs(ctx context.Context, artist, artistId string, count int) (model.MediaFiles, error)
- ArtistImage(ctx context.Context, id string) (*url.URL, error)
- AlbumImage(ctx context.Context, id string) (*url.URL, error)
}
type provider struct {
@@ -258,7 +255,7 @@ func (e *provider) populateArtistInfo(ctx context.Context, artist auxArtist) (au
// Call all registered agents and collect information
g := errgroup.Group{}
g.SetLimit(2)
- g.Go(func() error { e.callGetImage(ctx, e.ag, &artist); return nil })
+ g.Go(func() error { _ = e.callGetImage(ctx, e.ag, &artist); return nil })
g.Go(func() error { e.callGetBiography(ctx, e.ag, &artist); return nil })
g.Go(func() error { e.callGetURL(ctx, e.ag, &artist); return nil })
g.Go(func() error { e.callGetSimilarArtists(ctx, e.ag, &artist, maxSimilarArtists, true); return nil })
@@ -370,76 +367,6 @@ func (e *provider) similarSongsFallback(ctx context.Context, id string, count in
return similarSongs, nil
}
-func (e *provider) ArtistImage(ctx context.Context, id string) (*url.URL, error) {
- artist, err := e.getArtist(ctx, id)
- if err != nil {
- return nil, err
- }
-
- imageUrl := artist.ArtistImageUrl()
- if imageUrl == "" {
- // No cached URL — must fetch from external source synchronously
- e.callGetImage(ctx, e.ag, &artist)
- if utils.IsCtxDone(ctx) {
- log.Warn(ctx, "ArtistImage call canceled", ctx.Err())
- return nil, ctx.Err()
- }
- imageUrl = artist.ArtistImageUrl()
- } else {
- // If cached info is expired, enqueue a background refresh so that config changes
- // (e.g. disabling an agent) take effect without waiting for a full artist info refresh.
- updatedAt := V(artist.ExternalInfoUpdatedAt)
- if !updatedAt.IsZero() && time.Since(updatedAt) > conf.Server.DevArtistInfoTimeToLive {
- log.Debug(ctx, "Artist image info expired, enqueuing background refresh", "artist", artist.Name(), "updatedAt", updatedAt)
- e.artistQueue.enqueue(&artist)
- }
- }
-
- if imageUrl == "" {
- return nil, model.ErrNotFound
- }
- return url.Parse(imageUrl)
-}
-
-func (e *provider) AlbumImage(ctx context.Context, id string) (*url.URL, error) {
- album, err := e.getAlbum(ctx, id)
- if err != nil {
- return nil, err
- }
-
- albumName := album.Name()
- images, err := e.ag.GetAlbumImages(ctx, albumName, album.AlbumArtist, album.MbzAlbumID)
- if err != nil {
- switch {
- case errors.Is(err, agents.ErrNotFound):
- log.Trace(ctx, "Album not found in agent", "albumID", id, "name", albumName, "artist", album.AlbumArtist)
- return nil, model.ErrNotFound
- case errors.Is(err, context.Canceled):
- log.Debug(ctx, "GetAlbumImages call canceled", err)
- default:
- log.Warn(ctx, "Error getting album images from agent", "albumID", id, "name", albumName, "artist", album.AlbumArtist, err)
- }
- return nil, err
- }
-
- if len(images) == 0 {
- log.Warn(ctx, "Agent returned no images without error", "albumID", id, "name", albumName, "artist", album.AlbumArtist)
- return nil, model.ErrNotFound
- }
-
- // Return the biggest image
- var img agents.ExternalImage
- for _, i := range images {
- if img.Size <= i.Size {
- img = i
- }
- }
- if img.URL == "" {
- return nil, model.ErrNotFound
- }
- return url.Parse(img.URL)
-}
-
func (e *provider) TopSongs(ctx context.Context, artistName, id string, count int) (model.MediaFiles, error) {
artist, err := e.findArtist(ctx, artistName, id)
if err != nil {
@@ -524,10 +451,15 @@ func (e *provider) callGetBiography(ctx context.Context, agent agents.ArtistBiog
artist.Biography = strings.ReplaceAll(bio, "<a ", "<a target='_blank' ")
}
-func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRetriever, artist *auxArtist) {
+// callGetImage populates artist's image URLs. A transient agent failure is
+// returned as-is; a definitive "no image" is normalized to model.ErrNotFound.
+func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRetriever, artist *auxArtist) error {
images, err := agent.GetArtistImages(ctx, artist.ID, artist.Name(), artist.MbzArtistID)
if err != nil {
- return
+ if errors.Is(err, agents.ErrNotFound) {
+ return model.ErrNotFound
+ }
+ return err
}
sort.Slice(images, func(i, j int) bool { return images[i].Size > images[j].Size })
@@ -540,6 +472,7 @@ func (e *provider) callGetImage(ctx context.Context, agent agents.ArtistImageRet
if len(images) >= 3 {
artist.SmallImageUrl = images[2].URL
}
+ return nil
}
func (e *provider) callGetSimilarArtists(ctx context.Context, agent agents.ArtistSimilarRetriever, artist *auxArtist,
diff --git a/core/external/provider_albumimage_test.go b/core/external/provider_albumimage_test.go
deleted file mode 100644
index e801b7cce..000000000
--- a/core/external/provider_albumimage_test.go
+++ /dev/null
@@ -1,365 +0,0 @@
-package external_test
-
-import (
- "context"
- "errors"
- "net/url"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/core/agents"
- . "github.com/navidrome/navidrome/core/external"
- "github.com/navidrome/navidrome/core/matcher"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/tests"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
- "github.com/stretchr/testify/mock"
-)
-
-var _ = Describe("Provider - AlbumImage", func() {
- var ds *tests.MockDataStore
- var provider Provider
- var mockArtistRepo *mockArtistRepo
- var mockAlbumRepo *mockAlbumRepo
- var mockMediaFileRepo *mockMediaFileRepo
- var mockAlbumAgent *mockAlbumInfoAgent
- var ctx context.Context
-
- BeforeEach(func() {
- ctx = GinkgoT().Context()
- DeferCleanup(configtest.SetupConfig())
- conf.Server.Agents = "mockAlbum" // Configure mock agent
-
- mockArtistRepo = newMockArtistRepo()
- mockAlbumRepo = newMockAlbumRepo()
- mockMediaFileRepo = newMockMediaFileRepo()
-
- ds = &tests.MockDataStore{
- MockedArtist: mockArtistRepo,
- MockedAlbum: mockAlbumRepo,
- MockedMediaFile: mockMediaFileRepo,
- }
-
- mockAlbumAgent = newMockAlbumInfoAgent()
-
- agentsCombined := &mockAgents{albumInfoAgent: mockAlbumAgent}
- provider = NewProvider(ds, agentsCombined, matcher.New(ds))
-
- // Default mocks
- // Mocks for GetEntityByID sequence (initial failed lookups)
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
- mockArtistRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()
-
- // Default mock for non-existent entities - Use Maybe() for flexibility
- mockArtistRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()
- mockAlbumRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()
- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()
- })
-
- It("returns the largest image URL when successful", func() {
- // Arrange
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
- // Explicitly mock agent call for this test
- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/large.jpg", Size: 1000},
- {URL: "http://example.com/medium.jpg", Size: 500},
- {URL: "http://example.com/small.jpg", Size: 200},
- }, nil).Once()
-
- expectedURL, _ := url.Parse("http://example.com/large.jpg")
- imgURL, err := provider.AlbumImage(ctx, "album-1")
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1") // From GetEntityByID
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1") // Artist lookup no longer happens in getAlbum
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist name
- })
-
- It("returns ErrNotFound if the album is not found in the DB", func() {
- // Arrange: Explicitly expect the full GetEntityByID sequence for "not-found"
- mockArtistRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()
- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()
-
- imgURL, err := provider.AlbumImage(ctx, "not-found")
-
- Expect(err).To(MatchError("data not found"))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "not-found")
- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "not-found")
- mockAlbumAgent.AssertNotCalled(GinkgoT(), "GetAlbumImages", mock.Anything, mock.Anything, mock.Anything)
- })
-
- It("returns the agent error if the agent fails", func() {
- // Arrange
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
-
- agentErr := errors.New("agent failure")
- // Explicitly mock agent call for this test
- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").Return(nil, agentErr).Once() // Expect empty artist
-
- imgURL, err := provider.AlbumImage(ctx, "album-1")
-
- Expect(err).To(MatchError("agent failure"))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1")
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist
- })
-
- It("returns ErrNotFound if the agent returns ErrNotFound", func() {
- // Arrange
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
-
- // Explicitly mock agent call for this test
- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").Return(nil, agents.ErrNotFound).Once() // Expect empty artist
-
- imgURL, err := provider.AlbumImage(ctx, "album-1")
-
- Expect(err).To(MatchError("data not found"))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist
- })
-
- It("returns ErrNotFound if the agent returns no images", func() {
- // Arrange
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
-
- // Explicitly mock agent call for this test
- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
- Return([]agents.ExternalImage{}, nil).Once() // Expect empty artist
-
- imgURL, err := provider.AlbumImage(ctx, "album-1")
-
- Expect(err).To(MatchError("data not found"))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "") // Expect empty artist
- })
-
- It("returns context error if context is canceled", func() {
- // Arrange
- cctx, cancelCtx := context.WithCancel(ctx)
- // Mock the necessary DB calls *before* canceling the context
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
- // Expect the agent call even if context is cancelled, returning the context error
- mockAlbumAgent.On("GetAlbumImages", cctx, "Album One", "", "").Return(nil, context.Canceled).Once()
- // Cancel the context *before* calling the function under test
- cancelCtx()
-
- imgURL, err := provider.AlbumImage(cctx, "album-1")
-
- Expect(err).To(MatchError("context canceled"))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- // Agent should now be called, verify this expectation
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", cctx, "Album One", "", "")
- })
-
- It("derives album ID from MediaFile ID", func() {
- // Arrange: Mock full GetEntityByID for "mf-1" and recursive "album-1"
- mockArtistRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()
- mockMediaFileRepo.On("Get", "mf-1").Return(&model.MediaFile{ID: "mf-1", Title: "Track One", ArtistID: "artist-1", AlbumID: "album-1"}, nil).Once()
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
-
- // Explicitly mock agent call for this test
- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/large.jpg", Size: 1000},
- {URL: "http://example.com/medium.jpg", Size: 500},
- {URL: "http://example.com/small.jpg", Size: 200},
- }, nil).Once()
-
- expectedURL, _ := url.Parse("http://example.com/large.jpg")
- imgURL, err := provider.AlbumImage(ctx, "mf-1")
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "mf-1")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "mf-1")
- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "mf-1")
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockArtistRepo.AssertNotCalled(GinkgoT(), "Get", "artist-1")
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")
- })
-
- It("handles different image orders from agent", func() {
- // Arrange
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
- // Explicitly mock agent call for this test
- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/small.jpg", Size: 200},
- {URL: "http://example.com/large.jpg", Size: 1000},
- {URL: "http://example.com/medium.jpg", Size: 500},
- }, nil).Once()
-
- expectedURL, _ := url.Parse("http://example.com/large.jpg")
- imgURL, err := provider.AlbumImage(ctx, "album-1")
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL)) // Should still pick the largest
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")
- })
-
- It("handles agent returning only one image", func() {
- // Arrange
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once() // Expect GetEntityByID sequence
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Once()
- // Explicitly mock agent call for this test
- mockAlbumAgent.On("GetAlbumImages", ctx, "Album One", "", "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/single.jpg", Size: 700},
- }, nil).Once()
-
- expectedURL, _ := url.Parse("http://example.com/single.jpg")
- imgURL, err := provider.AlbumImage(ctx, "album-1")
-
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, "Album One", "", "")
- })
-
- It("returns ErrNotFound if deriving album ID fails", func() {
- // Arrange: Mock full GetEntityByID for "mf-no-album" and recursive "not-found"
- mockArtistRepo.On("Get", "mf-no-album").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "mf-no-album").Return(nil, model.ErrNotFound).Once()
- mockMediaFileRepo.On("Get", "mf-no-album").Return(&model.MediaFile{ID: "mf-no-album", Title: "Track No Album", ArtistID: "artist-1", AlbumID: "not-found"}, nil).Once()
- mockArtistRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()
- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Once()
-
- imgURL, err := provider.AlbumImage(ctx, "mf-no-album")
-
- Expect(err).To(MatchError("data not found"))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "mf-no-album")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "mf-no-album")
- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "mf-no-album")
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "not-found")
- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "not-found")
- mockAlbumAgent.AssertNotCalled(GinkgoT(), "GetAlbumImages", mock.Anything, mock.Anything, mock.Anything)
- })
-
- Context("Unicode handling in album names", func() {
- var albumWithEnDash *model.Album
- var expectedURL *url.URL
-
- const (
- originalAlbumName = "Raising Hell–Deluxe" // Album name with en dash
- normalizedAlbumName = "Raising Hell-Deluxe" // Normalized version with hyphen
- )
-
- BeforeEach(func() {
- // Test with en dash (–) in album name
- albumWithEnDash = &model.Album{ID: "album-endash", Name: originalAlbumName, AlbumArtistID: "artist-1"}
- mockArtistRepo.Mock = mock.Mock{} // Reset default expectations
- mockAlbumRepo.Mock = mock.Mock{} // Reset default expectations
- mockArtistRepo.On("Get", "album-endash").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "album-endash").Return(albumWithEnDash, nil).Once()
-
- expectedURL, _ = url.Parse("http://example.com/album.jpg")
-
- // Mock the album agent to return an image for the album
- mockAlbumAgent.On("GetAlbumImages", ctx, mock.AnythingOfType("string"), "", "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/album.jpg", Size: 1000},
- }, nil).Once()
- })
-
- When("DevPreserveUnicodeInExternalCalls is true", func() {
- BeforeEach(func() {
- conf.Server.DevPreserveUnicodeInExternalCalls = true
- })
-
- It("preserves Unicode characters in album names", func() {
- // Act
- imgURL, err := provider.AlbumImage(ctx, "album-endash")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-endash")
- // This is the key assertion: ensure the original Unicode name is used
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, originalAlbumName, "", "")
- })
- })
-
- When("DevPreserveUnicodeInExternalCalls is false", func() {
- BeforeEach(func() {
- conf.Server.DevPreserveUnicodeInExternalCalls = false
- })
-
- It("normalizes Unicode characters", func() {
- // Act
- imgURL, err := provider.AlbumImage(ctx, "album-endash")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-endash")
- // This assertion ensures the normalized name is used (en dash → hyphen)
- mockAlbumAgent.AssertCalled(GinkgoT(), "GetAlbumImages", ctx, normalizedAlbumName, "", "")
- })
- })
- })
-})
-
-// mockAlbumInfoAgent implementation
-type mockAlbumInfoAgent struct {
- mock.Mock
- agents.AlbumInfoRetriever
- agents.AlbumImageRetriever
-}
-
-func newMockAlbumInfoAgent() *mockAlbumInfoAgent {
- m := new(mockAlbumInfoAgent)
- m.On("AgentName").Return("mockAlbum").Maybe()
- return m
-}
-
-func (m *mockAlbumInfoAgent) AgentName() string {
- args := m.Called()
- return args.String(0)
-}
-
-func (m *mockAlbumInfoAgent) GetAlbumInfo(ctx context.Context, name, artist, mbid string) (*agents.AlbumInfo, error) {
- args := m.Called(ctx, name, artist, mbid)
- if args.Get(0) == nil {
- return nil, args.Error(1)
- }
- return args.Get(0).(*agents.AlbumInfo), args.Error(1)
-}
-
-func (m *mockAlbumInfoAgent) GetAlbumImages(ctx context.Context, name, artist, mbid string) ([]agents.ExternalImage, error) {
- args := m.Called(ctx, name, artist, mbid)
- if args.Get(0) == nil {
- return nil, args.Error(1)
- }
- return args.Get(0).([]agents.ExternalImage), args.Error(1)
-}
-
-// Ensure mockAgent implements the interfaces
-var _ agents.AlbumInfoRetriever = (*mockAlbumInfoAgent)(nil)
-var _ agents.AlbumImageRetriever = (*mockAlbumInfoAgent)(nil)
diff --git a/core/external/provider_artistimage_test.go b/core/external/provider_artistimage_test.go
deleted file mode 100644
index 79612d651..000000000
--- a/core/external/provider_artistimage_test.go
+++ /dev/null
@@ -1,426 +0,0 @@
-package external_test
-
-import (
- "bytes"
- "context"
- "errors"
- "net/url"
- "time"
-
- "github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/core/agents"
- . "github.com/navidrome/navidrome/core/external"
- "github.com/navidrome/navidrome/core/matcher"
- "github.com/navidrome/navidrome/log"
- "github.com/navidrome/navidrome/model"
- "github.com/navidrome/navidrome/tests"
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
- "github.com/stretchr/testify/mock"
-)
-
-var _ = Describe("Provider - ArtistImage", func() {
- var ds *tests.MockDataStore
- var provider Provider
- var mockArtistRepo *mockArtistRepo
- var mockAlbumRepo *mockAlbumRepo
- var mockMediaFileRepo *mockMediaFileRepo
- var mockImageAgent *mockArtistImageAgent
- var agentsCombined *mockAgents
- var ctx context.Context
-
- BeforeEach(func() {
- DeferCleanup(configtest.SetupConfig())
- conf.Server.Agents = "mockImage" // Configure only the mock agent
- ctx = GinkgoT().Context()
-
- mockArtistRepo = newMockArtistRepo()
- mockAlbumRepo = newMockAlbumRepo()
- mockMediaFileRepo = newMockMediaFileRepo()
-
- ds = &tests.MockDataStore{
- MockedArtist: mockArtistRepo,
- MockedAlbum: mockAlbumRepo,
- MockedMediaFile: mockMediaFileRepo,
- }
-
- mockImageAgent = newMockArtistImageAgent()
-
- // Use the mockAgents from helper, setting the specific agent
- agentsCombined = &mockAgents{
- imageAgent: mockImageAgent,
- }
-
- provider = NewProvider(ds, agentsCombined, matcher.New(ds))
-
- // Default mocks for successful Get calls
- mockArtistRepo.On("Get", "artist-1").Return(&model.Artist{ID: "artist-1", Name: "Artist One"}, nil).Maybe()
- mockAlbumRepo.On("Get", "album-1").Return(&model.Album{ID: "album-1", Name: "Album One", AlbumArtistID: "artist-1"}, nil).Maybe()
- mockMediaFileRepo.On("Get", "mf-1").Return(&model.MediaFile{ID: "mf-1", Title: "Track One", ArtistID: "artist-1"}, nil).Maybe()
- // Default mock for non-existent entities
- mockArtistRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()
- mockAlbumRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()
- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()
-
- // Default successful image agent response
- mockImageAgent.On("GetArtistImages", mock.Anything, "artist-1", "Artist One", "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/large.jpg", Size: 1000},
- {URL: "http://example.com/medium.jpg", Size: 500},
- {URL: "http://example.com/small.jpg", Size: 200},
- }, nil).Maybe()
- })
-
- AfterEach(func() {
- mockArtistRepo.AssertExpectations(GinkgoT())
- mockAlbumRepo.AssertExpectations(GinkgoT())
- mockMediaFileRepo.AssertExpectations(GinkgoT())
- mockImageAgent.AssertExpectations(GinkgoT())
- })
-
- It("returns the largest image URL when successful", func() {
- // Arrange
- expectedURL, _ := url.Parse("http://example.com/large.jpg")
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-1")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
- })
-
- It("returns ErrNotFound if the artist is not found in the DB", func() {
- // Arrange
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "not-found")
-
- // Assert
- Expect(err).To(MatchError(model.ErrNotFound))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")
- mockImageAgent.AssertNotCalled(GinkgoT(), "GetArtistImages", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
- })
-
- It("returns the agent error if the agent fails", func() {
- // Arrange
- agentErr := errors.New("agent failure")
- mockImageAgent.Mock = mock.Mock{} // Reset default expectation
- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").Return(nil, agentErr).Once()
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-1")
-
- // Assert
- Expect(err).To(MatchError(model.ErrNotFound)) // Corrected Expectation: The provider maps agent errors (other than canceled) to ErrNotFound if no image was found/populated
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
- })
-
- It("returns ErrNotFound if the agent returns ErrNotFound", func() {
- // Arrange
- mockImageAgent.Mock = mock.Mock{} // Reset default expectation
- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").Return(nil, agents.ErrNotFound).Once()
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-1")
-
- // Assert
- Expect(err).To(MatchError(model.ErrNotFound))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
- })
-
- It("returns ErrNotFound if the agent returns no images", func() {
- // Arrange
- mockImageAgent.Mock = mock.Mock{} // Reset default expectation
- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").Return([]agents.ExternalImage{}, nil).Once()
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-1")
-
- // Assert
- Expect(err).To(MatchError(model.ErrNotFound)) // Implementation maps empty result to ErrNotFound
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
- })
-
- It("returns context error if context is canceled before agent call", func() {
- // Arrange
- cctx, cancelCtx := context.WithCancel(context.Background())
- mockArtistRepo.Mock = mock.Mock{} // Reset default expectation for artist repo as well
- mockArtistRepo.On("Get", "artist-1").Return(&model.Artist{ID: "artist-1", Name: "Artist One"}, nil).Run(func(args mock.Arguments) {
- cancelCtx() // Cancel context *during* the DB call simulation
- }).Once()
-
- // Act
- imgURL, err := provider.ArtistImage(cctx, "artist-1")
-
- // Assert
- Expect(err).To(MatchError(context.Canceled))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")
- })
-
- It("derives artist ID from MediaFile ID", func() {
- // Arrange: Add mocks for the initial GetEntityByID lookups
- mockArtistRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "mf-1").Return(nil, model.ErrNotFound).Once()
- // Default mocks for MediaFileRepo.Get("mf-1") and ArtistRepo.Get("artist-1") handle the rest
- expectedURL, _ := url.Parse("http://example.com/large.jpg")
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "mf-1")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "mf-1") // GetEntityByID sequence
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "mf-1") // GetEntityByID sequence
- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "mf-1")
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1") // Should be called after getting MF
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
- })
-
- It("derives artist ID from Album ID", func() {
- // Arrange: Add mock for the initial GetEntityByID lookup
- mockArtistRepo.On("Get", "album-1").Return(nil, model.ErrNotFound).Once()
- // Default mocks for AlbumRepo.Get("album-1") and ArtistRepo.Get("artist-1") handle the rest
- expectedURL, _ := url.Parse("http://example.com/large.jpg")
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "album-1")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "album-1") // GetEntityByID sequence
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "album-1")
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1") // Should be called after getting Album
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
- })
-
- It("returns ErrNotFound if derived artist is not found", func() {
- // Arrange
- // Add mocks for the initial GetEntityByID lookups
- mockArtistRepo.On("Get", "mf-bad-artist").Return(nil, model.ErrNotFound).Once()
- mockAlbumRepo.On("Get", "mf-bad-artist").Return(nil, model.ErrNotFound).Once()
- mockMediaFileRepo.On("Get", "mf-bad-artist").Return(&model.MediaFile{ID: "mf-bad-artist", ArtistID: "not-found"}, nil).Once()
- // Add expectation for the recursive GetEntityByID call for the MediaFileRepo
- mockMediaFileRepo.On("Get", "not-found").Return(nil, model.ErrNotFound).Maybe()
- // The default mocks for ArtistRepo/AlbumRepo handle the final "not-found" lookups
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "mf-bad-artist")
-
- // Assert
- Expect(err).To(MatchError(model.ErrNotFound))
- Expect(imgURL).To(BeNil())
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "mf-bad-artist") // GetEntityByID sequence
- mockAlbumRepo.AssertCalled(GinkgoT(), "Get", "mf-bad-artist") // GetEntityByID sequence
- mockMediaFileRepo.AssertCalled(GinkgoT(), "Get", "mf-bad-artist")
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "not-found")
- mockImageAgent.AssertNotCalled(GinkgoT(), "GetArtistImages", mock.Anything, mock.Anything, mock.Anything, mock.Anything)
- })
-
- It("handles different image orders from agent", func() {
- // Arrange
- mockImageAgent.Mock = mock.Mock{} // Reset default expectation
- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/small.jpg", Size: 200},
- {URL: "http://example.com/large.jpg", Size: 1000},
- {URL: "http://example.com/medium.jpg", Size: 500},
- }, nil).Once()
- expectedURL, _ := url.Parse("http://example.com/large.jpg")
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-1")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL)) // Still picks the largest
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
- })
-
- It("handles agent returning only one image", func() {
- // Arrange
- mockImageAgent.Mock = mock.Mock{} // Reset default expectation
- mockImageAgent.On("GetArtistImages", ctx, "artist-1", "Artist One", "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/medium.jpg", Size: 500},
- }, nil).Once()
- expectedURL, _ := url.Parse("http://example.com/medium.jpg")
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-1")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-1")
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-1", "Artist One", "")
- })
-
- It("returns cached URL and does not call agent when info is not expired", func() {
- // Arrange: artist has a cached image URL with recent ExternalInfoUpdatedAt
- cachedArtist := &model.Artist{
- ID: "artist-cached",
- Name: "Cached Artist",
- LargeImageUrl: "http://example.com/cached-large.jpg",
- ExternalInfoUpdatedAt: new(time.Now().Add(-1 * time.Minute)),
- }
- mockArtistRepo.On("Get", "artist-cached").Return(cachedArtist, nil).Maybe()
- expectedURL, _ := url.Parse("http://example.com/cached-large.jpg")
-
- // Capture log output
- var logBuf bytes.Buffer
- log.SetOutput(&logBuf)
- defer log.SetOutput(GinkgoWriter)
- log.SetLevel(log.LevelDebug)
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-cached")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockImageAgent.AssertNotCalled(GinkgoT(), "GetArtistImages", mock.Anything, "artist-cached", mock.Anything, mock.Anything)
-
- // Assert: background refresh was NOT enqueued
- Expect(logBuf.String()).ToNot(ContainSubstring("Artist image info expired, enqueuing background refresh"))
-
- })
-
- It("returns stale URL and enqueues refresh when info is expired", func() {
- // Arrange
- conf.Server.DevArtistInfoTimeToLive = 1 * time.Nanosecond
- staleArtist := &model.Artist{
- ID: "artist-expired",
- Name: "Expired Artist",
- LargeImageUrl: "http://example.com/expired-large.jpg",
- ExternalInfoUpdatedAt: new(time.Now().Add(-1 * time.Hour)),
- }
- mockArtistRepo.On("Get", "artist-expired").Return(staleArtist, nil).Maybe()
- expectedURL, _ := url.Parse("http://example.com/expired-large.jpg")
-
- // Capture log output
- var logBuf bytes.Buffer
- log.SetOutput(&logBuf)
- defer log.SetOutput(GinkgoWriter)
- log.SetLevel(log.LevelDebug)
-
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-expired")
-
- // Assert: returns stale URL immediately, no agent call
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockImageAgent.AssertNotCalled(GinkgoT(), "GetArtistImages", mock.Anything, "artist-expired", mock.Anything, mock.Anything)
-
- // Assert: background refresh was enqueued
- Expect(logBuf.String()).To(ContainSubstring("Artist image info expired, enqueuing background refresh"))
- })
-
- Context("Unicode handling in artist names", func() {
- var artistWithEnDash *model.Artist
- var expectedURL *url.URL
-
- const (
- originalArtistName = "Run–D.M.C." // Artist name with en dash
- normalizedArtistName = "Run-D.M.C." // Normalized version with hyphen
- )
-
- BeforeEach(func() {
- // Test with en dash (–) in artist name like "Run–D.M.C."
- artistWithEnDash = &model.Artist{ID: "artist-endash", Name: originalArtistName}
- mockArtistRepo.Mock = mock.Mock{} // Reset default expectations
- mockArtistRepo.On("Get", "artist-endash").Return(artistWithEnDash, nil).Once()
-
- expectedURL, _ = url.Parse("http://example.com/rundmc.jpg")
-
- // Mock the image agent to return an image for the artist
- mockImageAgent.On("GetArtistImages", ctx, "artist-endash", mock.AnythingOfType("string"), "").
- Return([]agents.ExternalImage{
- {URL: "http://example.com/rundmc.jpg", Size: 1000},
- }, nil).Once()
-
- })
-
- When("DevPreserveUnicodeInExternalCalls is true", func() {
- BeforeEach(func() {
- conf.Server.DevPreserveUnicodeInExternalCalls = true
- })
- It("preserves Unicode characters in artist names", func() {
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-endash")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-endash")
- // This is the key assertion: ensure the original Unicode name is used
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-endash", originalArtistName, "")
- })
- })
-
- When("DevPreserveUnicodeInExternalCalls is false", func() {
- BeforeEach(func() {
- conf.Server.DevPreserveUnicodeInExternalCalls = false
- })
-
- It("normalizes Unicode characters", func() {
- // Act
- imgURL, err := provider.ArtistImage(ctx, "artist-endash")
-
- // Assert
- Expect(err).ToNot(HaveOccurred())
- Expect(imgURL).To(Equal(expectedURL))
- mockArtistRepo.AssertCalled(GinkgoT(), "Get", "artist-endash")
- // This assertion ensures the normalized name is used (en dash → hyphen)
- mockImageAgent.AssertCalled(GinkgoT(), "GetArtistImages", ctx, "artist-endash", normalizedArtistName, "")
- })
- })
- })
-})
-
-// mockArtistImageAgent implementation using testify/mock
-// This remains local as it's specific to testing the ArtistImage functionality
-type mockArtistImageAgent struct {
- mock.Mock
- agents.ArtistImageRetriever // Embed interface
-}
-
-// Constructor for the mock agent
-func newMockArtistImageAgent() *mockArtistImageAgent {
- mock := new(mockArtistImageAgent)
- // Set default AgentName if needed, although usually called via mockAgents
- mock.On("AgentName").Return("mockImage").Maybe()
- return mock
-}
-
-func (m *mockArtistImageAgent) AgentName() string {
- args := m.Called()
- return args.String(0)
-}
-
-func (m *mockArtistImageAgent) GetArtistImages(ctx context.Context, id, artistName, mbid string) ([]agents.ExternalImage, error) {
- args := m.Called(ctx, id, artistName, mbid)
- // Need careful type assertion for potentially nil slice
- var res []agents.ExternalImage
- if args.Get(0) != nil {
- res = args.Get(0).([]agents.ExternalImage)
- }
- return res, args.Error(1)
-}
-
-// Ensure mockAgent implements the interface
-var _ agents.ArtistImageRetriever = (*mockArtistImageAgent)(nil)
diff --git a/core/playlists/import_test.go b/core/playlists/import_test.go
index f2866fb60..2a84d56b2 100644
--- a/core/playlists/import_test.go
+++ b/core/playlists/import_test.go
@@ -11,7 +11,7 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/criteria"
@@ -43,7 +43,7 @@ var _ = Describe("Playlists - Import", func() {
var folder *model.Folder
BeforeEach(func() {
DeferCleanup(configtest.SetupConfig())
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
ds.MockedMediaFile = &mockedMediaFileRepo{}
libPath, _ := os.Getwd()
// Set up library with the actual library path that matches the folder
@@ -118,7 +118,7 @@ var _ = Describe("Playlists - Import", func() {
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3", "test.ogg"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
@@ -136,7 +136,7 @@ var _ = Describe("Playlists - Import", func() {
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
@@ -155,7 +155,7 @@ var _ = Describe("Playlists - Import", func() {
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
@@ -174,7 +174,7 @@ var _ = Describe("Playlists - Import", func() {
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
@@ -192,7 +192,7 @@ var _ = Describe("Playlists - Import", func() {
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
@@ -209,7 +209,7 @@ var _ = Describe("Playlists - Import", func() {
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
@@ -226,7 +226,7 @@ var _ = Describe("Playlists - Import", func() {
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
@@ -244,7 +244,7 @@ var _ = Describe("Playlists - Import", func() {
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFolder := &model.Folder{ID: "1", LibraryID: 1, LibraryPath: tmpDir, Path: "", Name: ""}
pls, err := ps.ImportFromFolder(ctx, plsFolder, "test.m3u")
@@ -258,7 +258,7 @@ var _ = Describe("Playlists - Import", func() {
tmpDir := GinkgoT().TempDir()
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
m3u := "#EXTALBUMARTURL:https://example.com/new-cover.jpg\ntest.mp3\n"
plsFile := filepath.Join(tmpDir, "test.m3u")
@@ -285,7 +285,7 @@ var _ = Describe("Playlists - Import", func() {
tmpDir := GinkgoT().TempDir()
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFile := filepath.Join(tmpDir, "test.m3u")
Expect(os.WriteFile(plsFile, []byte("test.mp3\n"), 0600)).To(Succeed())
@@ -311,7 +311,7 @@ var _ = Describe("Playlists - Import", func() {
tmpDir := GinkgoT().TempDir()
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{"test.mp3"}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
m3u := "test.mp3\n"
plsFile := filepath.Join(tmpDir, "test.m3u")
@@ -388,7 +388,7 @@ var _ = Describe("Playlists - Import", func() {
tmpDir := GinkgoT().TempDir()
mockLibRepo.SetData([]model.Library{{ID: 1, Path: tmpDir}})
ds.MockedMediaFile = &mockedMediaFileFromListRepo{data: []string{}}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
// Create the playlist file on disk with the filesystem's normalization form
plsFile := tmpDir + "/" + filesystemName + ".m3u"
@@ -448,7 +448,7 @@ var _ = Describe("Playlists - Import", func() {
"def.mp3", // This is playlists/def.mp3 relative to plsDir
},
}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("handles relative paths that reference files in other libraries", func() {
@@ -604,7 +604,7 @@ var _ = Describe("Playlists - Import", func() {
},
}
// Recreate playlists service to pick up new mock
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
// Create playlist in music library that references both tracks
plsContent := "#PLAYLIST:Same Path Test\nalbum/track.mp3\n../classical/album/track.mp3"
@@ -662,7 +662,7 @@ var _ = Describe("Playlists - Import", func() {
},
}
ds.MockedFolder = mockFolderRepo
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsContent := "#PLAYLIST:My Playlist\ntest.mp3\ntest.ogg\n"
plsFile := filepath.Join(tmpDir, "my-playlist.m3u")
@@ -681,7 +681,7 @@ var _ = Describe("Playlists - Import", func() {
libDir := filepath.Join(tmpDir, "music")
Expect(os.Mkdir(libDir, 0755)).To(Succeed())
mockLibRepo.SetData([]model.Library{{ID: 1, Path: libDir}})
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsContent := "#PLAYLIST:External Playlist\n" + libDir + "/test.mp3\n"
plsFile := filepath.Join(tmpDir, "external.m3u")
@@ -704,7 +704,7 @@ var _ = Describe("Playlists - Import", func() {
},
}
ds.MockedFolder = mockFolderRepo
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFile := filepath.Join(tmpDir, "test.m3u")
Expect(os.WriteFile(plsFile, []byte("test.mp3\n"), 0600)).To(Succeed())
@@ -724,7 +724,7 @@ var _ = Describe("Playlists - Import", func() {
},
}
ds.MockedFolder = mockFolderRepo
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFile := filepath.Join(tmpDir, "test.m3u")
Expect(os.WriteFile(plsFile, []byte("test.mp3\n"), 0600)).To(Succeed())
@@ -744,7 +744,7 @@ var _ = Describe("Playlists - Import", func() {
},
}
ds.MockedFolder = mockFolderRepo
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
plsFile := filepath.Join(tmpDir, "test.m3u")
Expect(os.WriteFile(plsFile, []byte("test.mp3\n"), 0600)).To(Succeed())
@@ -767,7 +767,7 @@ var _ = Describe("Playlists - Import", func() {
BeforeEach(func() {
repo = &mockedMediaFileFromListRepo{}
ds.MockedMediaFile = repo
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
mockLibRepo.SetData([]model.Library{{ID: 1, Path: "/music"}, {ID: 2, Path: "/new"}})
ctx = request.WithUser(ctx, model.User{ID: "123"})
})
diff --git a/core/playlists/playlists.go b/core/playlists/playlists.go
index 1ef083bbb..656bde05e 100644
--- a/core/playlists/playlists.go
+++ b/core/playlists/playlists.go
@@ -52,11 +52,12 @@ type Playlists interface {
TracksRepository(ctx context.Context, playlistId string, refreshSmartPlaylist bool) rest.Repository
}
-// ImageUploadService is a local interface satisfied by core.ImageUploadService.
-// Defined here to avoid an import cycle between core and core/playlists.
+// ImageUploadService is a local interface satisfied by artwork.Uploader.
+// Defined here to avoid an import cycle between core/artwork and core/playlists.
type ImageUploadService interface {
SetImage(ctx context.Context, entityType string, entityID string, name string, oldPath string, reader io.Reader, ext string) (filename string, err error)
RemoveImage(ctx context.Context, path string) error
+ EnqueueArtwork(ctx context.Context, entityType, entityID string)
}
type playlists struct {
@@ -320,7 +321,11 @@ func (s *playlists) SetImage(ctx context.Context, playlistID string, reader io.R
}
pls.UploadedImage = filename
- return s.ds.Playlist(ctx).Put(pls)
+ if err := s.ds.Playlist(ctx).Put(pls); err != nil {
+ return err
+ }
+ s.imgUpload.EnqueueArtwork(ctx, consts.EntityPlaylist, pls.ID)
+ return nil
}
func (s *playlists) RemoveImage(ctx context.Context, playlistID string) error {
@@ -334,5 +339,9 @@ func (s *playlists) RemoveImage(ctx context.Context, playlistID string) error {
}
pls.UploadedImage = ""
- return s.ds.Playlist(ctx).Put(pls)
+ if err := s.ds.Playlist(ctx).Put(pls); err != nil {
+ return err
+ }
+ s.imgUpload.EnqueueArtwork(ctx, consts.EntityPlaylist, pls.ID)
+ return nil
}
diff --git a/core/playlists/playlists_test.go b/core/playlists/playlists_test.go
index 0c9674bed..e8134b2ef 100644
--- a/core/playlists/playlists_test.go
+++ b/core/playlists/playlists_test.go
@@ -8,7 +8,7 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/criteria"
@@ -42,7 +42,7 @@ var _ = Describe("Playlists", func() {
"pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},
}
mockPlsRepo.TracksRepo = mockTracks
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("allows owner to delete their playlist", func() {
@@ -82,7 +82,7 @@ var _ = Describe("Playlists", func() {
"pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},
}
mockPlsRepo.TracksRepo = mockTracks
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("returns the playlist's track repository", func() {
@@ -103,7 +103,7 @@ var _ = Describe("Playlists", func() {
"pls-smart": {ID: "pls-smart", Name: "Smart", OwnerID: "user-1",
Rules: &criteria.Criteria{Expression: criteria.Contains{"title": "test"}}},
}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("creates a new playlist with owner set from context", func() {
@@ -161,7 +161,7 @@ var _ = Describe("Playlists", func() {
Rules: &criteria.Criteria{Expression: criteria.Contains{"title": "test"}}},
}
mockPlsRepo.TracksRepo = mockTracks
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("allows owner to update their playlist", func() {
@@ -219,7 +219,7 @@ var _ = Describe("Playlists", func() {
"pls-other": {ID: "pls-other", Name: "Other's", OwnerID: "other-user"},
}
mockPlsRepo.TracksRepo = mockTracks
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("allows owner to add tracks", func() {
@@ -267,7 +267,7 @@ var _ = Describe("Playlists", func() {
Rules: &criteria.Criteria{Expression: criteria.Contains{"title": "test"}}},
}
mockPlsRepo.TracksRepo = mockTracks
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("allows owner to remove tracks", func() {
@@ -301,7 +301,7 @@ var _ = Describe("Playlists", func() {
Rules: &criteria.Criteria{Expression: criteria.Contains{"title": "test"}}},
}
mockPlsRepo.TracksRepo = mockTracks
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("allows owner to reorder", func() {
@@ -330,7 +330,7 @@ var _ = Describe("Playlists", func() {
"pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},
"pls-other": {ID: "pls-other", Name: "Other's", OwnerID: "other-user"},
}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("saves image file and updates UploadedImage", func() {
@@ -400,7 +400,7 @@ var _ = Describe("Playlists", func() {
"pls-empty": {ID: "pls-empty", Name: "No Cover", OwnerID: "user-1"},
"pls-other": {ID: "pls-other", Name: "Other's", OwnerID: "other-user"},
}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
It("removes file and clears UploadedImage", func() {
@@ -420,6 +420,24 @@ var _ = Describe("Playlists", func() {
Expect(mockPlsRepo.Last.UploadedImage).To(BeEmpty())
})
+ It("clears the resolved artwork state and re-queues after removing an upload", func() {
+ ctx = request.WithUser(ctx, model.User{ID: "user-1", IsAdmin: false})
+ Expect(ds.Artwork(ctx).PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "pl", ItemID: "pls-1", Hash: "oldhash", Source: "upload",
+ })).To(Succeed())
+
+ Expect(ps.RemoveImage(ctx, "pls-1")).To(Succeed())
+
+ _, err := ds.Artwork(ctx).GetItemArtwork(model.KindPlaylistArtwork, "pls-1", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ queued, _ := ds.ArtworkQueue(ctx).DequeueBatch(100)
+ Expect(queued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "pl"),
+ HaveField("ItemID", "pls-1"),
+ HaveField("Priority", model.ArtworkPriorityBump),
+ )))
+ })
+
It("denies non-owner", func() {
ctx = request.WithUser(ctx, model.User{ID: "other-user", IsAdmin: false})
err := ps.RemoveImage(ctx, "pls-1")
diff --git a/core/playlists/rest_adapter_test.go b/core/playlists/rest_adapter_test.go
index 58a327bde..7ae376b07 100644
--- a/core/playlists/rest_adapter_test.go
+++ b/core/playlists/rest_adapter_test.go
@@ -5,7 +5,7 @@ import (
"time"
"github.com/deluan/rest"
- "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/criteria"
@@ -37,7 +37,7 @@ var _ = Describe("REST Adapter", func() {
mockPlsRepo.Data = map[string]*model.Playlist{
"pls-1": {ID: "pls-1", Name: "My Playlist", OwnerID: "user-1"},
}
- ps = playlists.NewPlaylists(ds, core.NewImageUploadService())
+ ps = playlists.NewPlaylists(ds, artwork.NewUploader(ds))
})
Describe("Save", func() {
diff --git a/core/wire_providers.go b/core/wire_providers.go
index a2fffa34f..a09fcc108 100644
--- a/core/wire_providers.go
+++ b/core/wire_providers.go
@@ -24,8 +24,6 @@ var Set = wire.NewSet(
NewLibrary,
NewUser,
NewMaintenance,
- NewImageUploadService,
- wire.Bind(new(playlists.ImageUploadService), new(ImageUploadService)),
stream.NewTranscodeDecider,
agents.GetAgents,
external.NewProvider,
diff --git a/db/db.go b/db/db.go
index 4ca996fe5..11a05b456 100644
--- a/db/db.go
+++ b/db/db.go
@@ -4,6 +4,7 @@ import (
"context"
"database/sql"
"embed"
+ "errors"
"fmt"
"time"
@@ -106,6 +107,17 @@ func Init(ctx context.Context) func() {
}
}
+// ErrorCodes reports the SQLite result code and extended result code carried by err.
+// The extended code is what distinguishes errors that share a message: "database is locked"
+// is both SQLITE_BUSY, which busy_timeout retries, and SQLITE_BUSY_SNAPSHOT, which it never can.
+func ErrorCodes(err error) (code, extended int, ok bool) {
+ var se sqlite3.Error
+ if !errors.As(err, &se) {
+ return 0, 0, false
+ }
+ return int(se.Code), int(se.ExtendedCode), true
+}
+
type statusLogger struct{ numPending int }
func (*statusLogger) Fatalf(format string, v ...any) { log.Fatal(fmt.Sprintf(format, v...)) }
diff --git a/db/migrations/20260722023032_add_artwork_tables.sql b/db/migrations/20260722023032_add_artwork_tables.sql
new file mode 100644
index 000000000..e307d13e8
--- /dev/null
+++ b/db/migrations/20260722023032_add_artwork_tables.sql
@@ -0,0 +1,46 @@
+-- +goose Up
+CREATE TABLE artwork (
+ hash TEXT PRIMARY KEY,
+ mime TEXT NOT NULL,
+ width INTEGER NOT NULL DEFAULT 0,
+ height INTEGER NOT NULL DEFAULT 0,
+ size_bytes INTEGER NOT NULL DEFAULT 0,
+ blur_hash TEXT NOT NULL DEFAULT '',
+ thumb_hash TEXT NOT NULL DEFAULT '',
+ dominant_color TEXT NOT NULL DEFAULT '',
+ created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE item_artwork (
+ item_kind TEXT NOT NULL,
+ item_id TEXT NOT NULL,
+ image_type TEXT NOT NULL DEFAULT 'primary',
+ hash TEXT NOT NULL DEFAULT '',
+ source TEXT NOT NULL DEFAULT '',
+ source_path TEXT NOT NULL DEFAULT '',
+ ref_mtime INTEGER NOT NULL DEFAULT 0,
+ attempted_at TIMESTAMP,
+ updated_at TIMESTAMP,
+ PRIMARY KEY (item_kind, item_id, image_type)
+) WITHOUT ROWID;
+CREATE INDEX ix_item_artwork_hash ON item_artwork(hash);
+
+CREATE TABLE artwork_queue (
+ item_kind TEXT NOT NULL,
+ item_id TEXT NOT NULL,
+ image_type TEXT NOT NULL DEFAULT 'primary',
+ priority INTEGER NOT NULL DEFAULT 0,
+ attempts INTEGER NOT NULL DEFAULT 0,
+ retry_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ enqueued_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (item_kind, item_id, image_type)
+) WITHOUT ROWID;
+-- Ordered to match DequeueBatch (priority DESC, enqueued_at) so drains stop after n rows; retry_at makes it covering.
+-- item_kind leads: each drain pool dequeues only its own kinds, so it must seek straight to
+-- them rather than scan past another pool's backlog.
+CREATE INDEX ix_artwork_queue_drain ON artwork_queue(item_kind, priority DESC, enqueued_at, retry_at);
+
+-- +goose Down
+DROP TABLE artwork_queue;
+DROP TABLE item_artwork;
+DROP TABLE artwork;
diff --git a/go.mod b/go.mod
index 5488b41e4..b72f4035c 100644
--- a/go.mod
+++ b/go.mod
@@ -57,6 +57,7 @@ require (
github.com/tetratelabs/wazero v1.12.0
github.com/unrolled/secure v1.17.0
github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342
+ github.com/zeebo/xxh3 v1.1.0
go.senan.xyz/taglib v0.11.1
go.uber.org/goleak v1.3.0
golang.org/x/image v0.44.0
@@ -128,7 +129,6 @@ require (
github.com/subosito/gotenv v1.6.0 // indirect
github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834 // indirect
github.com/valyala/fastjson v1.6.10 // indirect
- github.com/zeebo/xxh3 v1.1.0 // indirect
go.opentelemetry.io/proto/otlp v1.10.0 // indirect
go.uber.org/multierr v1.11.0 // indirect
go.yaml.in/yaml/v2 v2.4.3 // indirect
diff --git a/log/formatters.go b/log/formatters.go
index 0b27f3a43..5d864dae4 100644
--- a/log/formatters.go
+++ b/log/formatters.go
@@ -26,8 +26,15 @@ func ShortDur(d time.Duration) string {
default:
s = d.String()
}
- s = strings.TrimSuffix(s, "0s")
- return strings.TrimSuffix(s, "0m")
+ // Drop whole zero-valued trailing components ("4h0m0s" -> "4h"). The suffix has to include
+ // the preceding unit, or a value that merely ends in a zero digit loses it: "10s" -> "1".
+ if strings.HasSuffix(s, "m0s") {
+ s = strings.TrimSuffix(s, "0s")
+ }
+ if strings.HasSuffix(s, "h0m") {
+ s = strings.TrimSuffix(s, "0m")
+ }
+ return s
}
func StringerValue(s fmt.Stringer) string {
diff --git a/log/formatters_test.go b/log/formatters_test.go
index 6ed43a094..64d72bdbd 100644
--- a/log/formatters_test.go
+++ b/log/formatters_test.go
@@ -25,6 +25,12 @@ var _ = DescribeTable("ShortDur",
Entry("4m3s", 4*time.Minute+3*time.Second, "4m3s"),
Entry("4h", 4*time.Hour, "4h"),
Entry("4h", 4*time.Hour+2*time.Second, "4h"),
+ // A trailing zero digit is significant: only a whole zero-valued component may be dropped.
+ Entry("zero", time.Duration(0), "0s"),
+ Entry("10s", 10*time.Second, "10s"),
+ Entry("20s", 20*time.Second, "20s"),
+ Entry("1m30s", time.Minute+30*time.Second, "1m30s"),
+ Entry("2h30m", 2*time.Hour+30*time.Minute, "2h30m"),
Entry("4h2m", 4*time.Hour+2*time.Minute+5*time.Second+200*time.Millisecond, "4h2m"),
)
diff --git a/model/album.go b/model/album.go
index 55df8c63c..f27ca12c0 100644
--- a/model/album.go
+++ b/model/album.go
@@ -13,6 +13,7 @@ import (
type Album struct {
Annotations `structs:"-" hash:"ignore"`
+ ItemImage `structs:"-" hash:"ignore"`
ID string `structs:"id" json:"id"`
LibraryID int `structs:"library_id" json:"libraryId"`
@@ -142,6 +143,7 @@ type AlbumRepository interface {
UpdateExternalInfo(*Album) error
Get(id string) (*Album, error)
GetAll(...QueryOptions) (Albums, error)
+ GetAllIDs(...QueryOptions) ([]string, error)
GetCursor(...QueryOptions) (AlbumCursor, error)
GetYears(libraryIDs ...int) ([]int, error)
diff --git a/model/artist.go b/model/artist.go
index f9c4bffd5..f3704b669 100644
--- a/model/artist.go
+++ b/model/artist.go
@@ -11,6 +11,7 @@ import (
type Artist struct {
Annotations `structs:"-"`
+ ItemImage `structs:"-"`
ID string `structs:"id" json:"id"`
@@ -89,6 +90,7 @@ type ArtistRepository interface {
UpdateExternalInfo(a *Artist) error
Get(id string) (*Artist, error)
GetAll(options ...QueryOptions) (Artists, error)
+ GetAllIDs(options ...QueryOptions) ([]string, error)
GetCursor(options ...QueryOptions) (ArtistCursor, error)
GetIndex(includeMissing bool, libraryIds []int, roles ...Role) (ArtistIndexes, error)
diff --git a/model/artwork.go b/model/artwork.go
new file mode 100644
index 000000000..87b424f33
--- /dev/null
+++ b/model/artwork.go
@@ -0,0 +1,144 @@
+package model
+
+import "time"
+
+// Artwork is one unique image, identified by the XXH3-64 hash of its bytes.
+type Artwork struct {
+ Hash string `structs:"hash"`
+ Mime string `structs:"mime"`
+ Width int `structs:"width"`
+ Height int `structs:"height"`
+ SizeBytes int64 `structs:"size_bytes"`
+ BlurHash string `structs:"blur_hash"`
+ ThumbHash string `structs:"thumb_hash"`
+ // DominantColor is "#rrggbb": a flat placeholder clients can paint before any decode.
+ DominantColor string `structs:"dominant_color"`
+ CreatedAt time.Time `structs:"created_at"`
+}
+
+const ImageTypePrimary = "primary"
+
+// ItemImage is per-entity artwork state hydrated at query time; never persisted.
+type ItemImage struct {
+ ImageHash string `structs:"-" json:"imageHash,omitempty"`
+ ImageAbsent bool `structs:"-" json:"imageAbsent,omitempty"`
+ // BlurHash is Jellyfin's; its mappers read this field directly, so it stays off native JSON.
+ BlurHash string `structs:"-" json:"-"`
+ ThumbHash string `structs:"-" json:"thumbHash,omitempty"`
+ // DominantColor is the only placeholder needing no decode, so it can paint on the first frame.
+ DominantColor string `structs:"-" json:"dominantColor,omitempty"`
+ // A thumbhash's own aspect is quantised, so clients need these to shape the placeholder exactly.
+ ImageWidth int `structs:"-" json:"imageWidth,omitempty"`
+ ImageHeight int `structs:"-" json:"imageHeight,omitempty"`
+}
+
+// AspectRatio is the image's width/height, or nil when the image or its dimensions are unknown.
+func (i ItemImage) AspectRatio() *float64 {
+ if i.ImageAbsent || i.ImageWidth <= 0 || i.ImageHeight <= 0 {
+ return nil
+ }
+ return new(float64(i.ImageWidth) / float64(i.ImageHeight))
+}
+
+// ItemArtwork is an entity's resolved artwork state. Hash=="" means known absent.
+type ItemArtwork struct {
+ ItemKind string `structs:"item_kind"`
+ ItemID string `structs:"item_id"`
+ ImageType string `structs:"image_type"`
+ Hash string `structs:"hash"`
+ Source string `structs:"source"`
+ // SourcePath is the backing file (folder/upload: the image; embedded: the audio file); "" otherwise.
+ SourcePath string `structs:"source_path"`
+ // RefMtime is SourcePath's mtime (unix-nanoseconds) at resolution; 0 when there is no SourcePath.
+ RefMtime int64 `structs:"ref_mtime"`
+ // Nullable in the schema, but every insert must set them: these non-pointer fields cannot scan NULL.
+ AttemptedAt time.Time `structs:"attempted_at"`
+ UpdatedAt time.Time `structs:"updated_at"`
+}
+
+// ItemArtworkInfo is the list-hydration projection (item_artwork joined with artwork).
+type ItemArtworkInfo struct {
+ ItemID string
+ Hash string
+ BlurHash string
+ ThumbHash string
+ DominantColor string
+ Width int
+ Height int
+}
+
+// Absent reports a known-absent artwork state (resolved, no image).
+func (i ItemArtworkInfo) Absent() bool { return i.Hash == "" }
+
+// Image projects the hydration entry onto the entity-facing struct.
+func (i ItemArtworkInfo) Image() ItemImage {
+ return ItemImage{
+ ImageHash: i.Hash,
+ ImageAbsent: i.Absent(),
+ BlurHash: i.BlurHash,
+ ThumbHash: i.ThumbHash,
+ DominantColor: i.DominantColor,
+ ImageWidth: i.Width,
+ ImageHeight: i.Height,
+ }
+}
+
+type ArtworkQueueItem struct {
+ ItemKind string `structs:"item_kind"`
+ ItemID string `structs:"item_id"`
+ ImageType string `structs:"image_type"`
+ Priority int `structs:"priority"`
+ Attempts int `structs:"attempts"`
+ RetryAt time.Time `structs:"retry_at"`
+ EnqueuedAt time.Time `structs:"enqueued_at"`
+}
+
+// Queue priorities: higher drains first.
+const (
+ ArtworkPriorityRecheck = 0
+ ArtworkPriorityBackfill = 10
+ ArtworkPriorityScan = 50
+ ArtworkPriorityBump = 100
+)
+
+// Delete* takes the rows to remove; Purge* finds them itself and reports how many went.
+type ArtworkRepository interface {
+ GetImage(hash string) (*Artwork, error)
+ PutImage(a *Artwork) error
+ // PurgeOrphans deletes rows referenced by no item_artwork row and older than cutoff.
+ PurgeOrphans(createdBefore time.Time) (int64, error)
+ GetItemArtwork(kind Kind, id, imageType string) (*ItemArtwork, error)
+ PutItemArtwork(ia *ItemArtwork) error
+ DeleteForItems(kind Kind, ids []string) error
+ // GetInfoForItems hydrates a page in one batched query.
+ GetInfoForItems(kind Kind, ids []string) (map[string]ItemArtworkInfo, error)
+ // GetMimeByHash returns hash -> current mime for every stored artwork.
+ GetMimeByHash() (map[string]string, error)
+ // PurgeDanglingItems removes state rows whose entity no longer exists.
+ PurgeDanglingItems() (int64, error)
+}
+
+type ArtworkQueueRepository interface {
+ // Enqueue upserts; an existing row keeps the higher priority and has its retry_at reset.
+ Enqueue(items ...ArtworkQueueItem) error
+ // EnqueuePreservingBackoff upserts like Enqueue but preserves an existing row's retry_at, so a
+ // request-triggered read-through never resets a failed resolution's backoff.
+ EnqueuePreservingBackoff(items ...ArtworkQueueItem) error
+ // EnqueueStaleAbsent inserts queue rows (priority Recheck) for absent states older than cutoff.
+ EnqueueStaleAbsent(kind Kind, attemptedBefore time.Time) (int64, error)
+ // EnqueueAllMissing inserts queue rows for all entities with no item_artwork row, at the given priority.
+ EnqueueAllMissing(kind Kind, priority int) (int64, error)
+ // EnqueueIfMissing inserts only for items with no item_artwork row yet.
+ EnqueueIfMissing(items ...ArtworkQueueItem) error
+ // DequeueBatch returns up to n items with retry_at <= now, priority desc, enqueued_at asc.
+ // Restricted to the given kinds when any are passed, so one kind cannot block another's drain.
+ DequeueBatch(n int, kinds ...string) ([]ArtworkQueueItem, error)
+ // MarkFailedIfUnchanged applies the failure backoff only while retry_at still matches
+ // seenRetryAt, so a concurrent re-enqueue keeps its fresh eligibility.
+ MarkFailedIfUnchanged(kind, id, imageType string, seenRetryAt, retryAt time.Time) error
+ // DeleteIfUnchanged deletes only while retry_at still matches, sparing a concurrent re-enqueue.
+ DeleteIfUnchanged(kind, id, imageType string, retryAt time.Time) error
+ Count() (int64, error)
+ // PurgeDangling removes queue rows whose entity no longer exists.
+ PurgeDangling() (int64, error)
+}
diff --git a/model/artwork_id.go b/model/artwork_id.go
index 1bd146c1f..634a6442f 100644
--- a/model/artwork_id.go
+++ b/model/artwork_id.go
@@ -17,6 +17,11 @@ func (k Kind) String() string {
return k.name
}
+// Prefix is the short token used in artwork ids and the item_artwork.item_kind column.
+func (k Kind) Prefix() string {
+ return k.prefix
+}
+
var (
KindMediaFileArtwork = Kind{"mf", "media_file"}
KindArtistArtwork = Kind{"ar", "artist"}
@@ -35,10 +40,18 @@ var artworkKindMap = map[string]Kind{
KindRadioArtwork.prefix: KindRadioArtwork,
}
+// ParseKind resolves an item_kind prefix (e.g. "al") to its Kind, reporting whether it was known.
+// Use it at string boundaries — URL params, the item_kind column — to enter the typed Kind domain.
+func ParseKind(prefix string) (Kind, bool) {
+ k, ok := artworkKindMap[prefix]
+ return k, ok
+}
+
type ArtworkID struct {
Kind Kind
ID string
- LastUpdate time.Time
+ Hash string // content-hash suffix; "" = unknown/none
+ LastUpdate time.Time // legacy: populated only when parsing old _<hexTimestamp> tokens
}
func (id ArtworkID) String() string {
@@ -46,14 +59,14 @@ func (id ArtworkID) String() string {
return ""
}
s := fmt.Sprintf("%s-%s", id.Kind.prefix, id.ID)
- if lu := id.LastUpdate.Unix(); lu > 0 {
- return fmt.Sprintf("%s_%x", s, lu)
+ if id.Hash != "" {
+ return s + "_" + id.Hash
}
- return s + "_0"
+ return s
}
func NewArtworkID(kind Kind, id string, lastUpdate *time.Time) ArtworkID {
- artID := ArtworkID{kind, id, time.Time{}}
+ artID := ArtworkID{Kind: kind, ID: id}
if lastUpdate != nil {
artID.LastUpdate = *lastUpdate
}
@@ -75,18 +88,34 @@ func ParseArtworkID(id string) (ArtworkID, error) {
}
parts = strings.SplitN(parts[1], "_", 2)
if len(parts) == 2 {
- if parts[1] != "0" {
- lastUpdate, err := strconv.ParseInt(parts[1], 16, 64)
- if err != nil {
- return ArtworkID{}, err
+ parsedID.ID = parts[0]
+ suffix := parts[1]
+ switch {
+ // Hash detection must come first: a 16-hex value with the high bit set overflows int64.
+ case isImageHash(suffix):
+ parsedID.Hash = suffix
+ case suffix != "0":
+ if lastUpdate, err := strconv.ParseInt(suffix, 16, 64); err == nil {
+ parsedID.LastUpdate = time.Unix(lastUpdate, 0)
}
- parsedID.LastUpdate = time.Unix(lastUpdate, 0)
}
- parsedID.ID = parts[0]
}
return parsedID, nil
}
+// isImageHash reports whether s is a 16-char lowercase-hex XXH3-64 content hash.
+func isImageHash(s string) bool {
+ if len(s) != 16 {
+ return false
+ }
+ for _, c := range s {
+ if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
+ return false
+ }
+ }
+ return true
+}
+
func MustParseArtworkID(id string) ArtworkID {
artID, err := ParseArtworkID(id)
if err != nil {
@@ -112,40 +141,21 @@ func ParseDiscArtworkID(id string) (albumID string, discNumber int, err error) {
}
func artworkIDFromAlbum(al Album) ArtworkID {
- return ArtworkID{
- Kind: KindAlbumArtwork,
- ID: al.ID,
- LastUpdate: al.UpdatedAt,
- }
+ return ArtworkID{Kind: KindAlbumArtwork, ID: al.ID, Hash: al.ImageHash}
}
func artworkIDFromMediaFile(mf MediaFile) ArtworkID {
- return ArtworkID{
- Kind: KindMediaFileArtwork,
- ID: mf.ID,
- LastUpdate: mf.UpdatedAt,
- }
+ return ArtworkID{Kind: KindMediaFileArtwork, ID: mf.ID, Hash: mf.ImageHash}
}
func artworkIDFromPlaylist(pls Playlist) ArtworkID {
- return ArtworkID{
- Kind: KindPlaylistArtwork,
- ID: pls.ID,
- LastUpdate: pls.UpdatedAt,
- }
+ return ArtworkID{Kind: KindPlaylistArtwork, ID: pls.ID, Hash: pls.ImageHash}
}
func artworkIDFromArtist(ar Artist) ArtworkID {
- return ArtworkID{
- Kind: KindArtistArtwork,
- ID: ar.ID,
- }
+ return ArtworkID{Kind: KindArtistArtwork, ID: ar.ID, Hash: ar.ImageHash}
}
func artworkIDFromRadio(r Radio) ArtworkID {
- return ArtworkID{
- Kind: KindRadioArtwork,
- ID: r.ID,
- LastUpdate: r.UpdatedAt,
- }
+ return ArtworkID{Kind: KindRadioArtwork, ID: r.ID, Hash: r.ImageHash}
}
diff --git a/model/artwork_id_test.go b/model/artwork_id_test.go
index ad66f7bb5..af6a12ffb 100644
--- a/model/artwork_id_test.go
+++ b/model/artwork_id_test.go
@@ -9,14 +9,31 @@ import (
)
var _ = Describe("ArtworkID", func() {
+ Describe("String()", func() {
+ It("returns a bare id when there is no hash", func() {
+ id := model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1234"}
+ Expect(id.String()).To(Equal("al-1234"))
+ })
+ It("appends the hash suffix when set", func() {
+ id := model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1234", Hash: "abcdef0123456789"}
+ Expect(id.String()).To(Equal("al-1234_abcdef0123456789"))
+ })
+ It("never emits a legacy timestamp/_0 suffix", func() {
+ id := model.NewArtworkID(model.KindAlbumArtwork, "1234", new(time.Now()))
+ Expect(id.String()).To(Equal("al-1234"))
+ })
+ It("returns empty string for an empty id", func() {
+ Expect(model.ArtworkID{Kind: model.KindAlbumArtwork}.String()).To(BeEmpty())
+ })
+ })
+
Describe("NewArtworkID()", func() {
- It("creates a valid parseable ArtworkID", func() {
+ It("round-trips Kind and ID through String()", func() {
id := model.NewArtworkID(model.KindAlbumArtwork, "1234", new(time.Now()))
parsedId, err := model.ParseArtworkID(id.String())
Expect(err).ToNot(HaveOccurred())
Expect(parsedId.Kind).To(Equal(id.Kind))
Expect(parsedId.ID).To(Equal(id.ID))
- Expect(parsedId.LastUpdate.Unix()).To(Equal(id.LastUpdate.Unix()))
})
It("creates a valid ArtworkID without lastUpdate info", func() {
id := model.NewArtworkID(model.KindPlaylistArtwork, "1234", nil)
@@ -24,18 +41,16 @@ var _ = Describe("ArtworkID", func() {
Expect(err).ToNot(HaveOccurred())
Expect(parsedId.Kind).To(Equal(id.Kind))
Expect(parsedId.ID).To(Equal(id.ID))
- Expect(parsedId.LastUpdate.Unix()).To(Equal(id.LastUpdate.Unix()))
})
})
+
Describe("ParseArtworkID - disc kind", func() {
It("parses a disc artwork ID with dc prefix", func() {
- now := time.Now()
- id := model.NewArtworkID(model.KindDiscArtwork, "albumid123:2", &now)
+ id := model.NewArtworkID(model.KindDiscArtwork, "albumid123:2", nil)
parsedId, err := model.ParseArtworkID(id.String())
Expect(err).ToNot(HaveOccurred())
Expect(parsedId.Kind).To(Equal(model.KindDiscArtwork))
Expect(parsedId.ID).To(Equal("albumid123:2"))
- Expect(parsedId.LastUpdate.Unix()).To(Equal(now.Unix()))
})
})
@@ -67,6 +82,7 @@ var _ = Describe("ArtworkID", func() {
Expect(err).ToNot(HaveOccurred())
Expect(id.Kind).To(Equal(model.KindAlbumArtwork))
Expect(id.ID).To(Equal("1234"))
+ Expect(id.Hash).To(BeEmpty())
})
It("parses media file artwork ids", func() {
id, err := model.ParseArtworkID("mf-a6f8d2b1")
@@ -74,12 +90,45 @@ var _ = Describe("ArtworkID", func() {
Expect(id.Kind).To(Equal(model.KindMediaFileArtwork))
Expect(id.ID).To(Equal("a6f8d2b1"))
})
- It("parses playlists artwork ids", func() {
+ It("parses playlist artwork ids with dashed UUID", func() {
id, err := model.ParseArtworkID("pl-18690de0-151b-4d86-81cb-f418a907315a")
Expect(err).ToNot(HaveOccurred())
Expect(id.Kind).To(Equal(model.KindPlaylistArtwork))
Expect(id.ID).To(Equal("18690de0-151b-4d86-81cb-f418a907315a"))
})
+ It("captures a 16-hex suffix as Hash", func() {
+ id, err := model.ParseArtworkID("al-1234_abcdef0123456789")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(id.ID).To(Equal("1234"))
+ Expect(id.Hash).To(Equal("abcdef0123456789"))
+ Expect(id.LastUpdate.IsZero()).To(BeTrue())
+ })
+ It("captures a high-bit 16-hex suffix as Hash without error", func() {
+ id, err := model.ParseArtworkID("al-1234_ffffffffffffffff")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(id.ID).To(Equal("1234"))
+ Expect(id.Hash).To(Equal("ffffffffffffffff"))
+ })
+ It("parses a legacy hex-timestamp suffix as LastUpdate", func() {
+ id, err := model.ParseArtworkID("al-123_688a1b2c")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(id.ID).To(Equal("123"))
+ Expect(id.Hash).To(BeEmpty())
+ Expect(id.LastUpdate.Unix()).To(Equal(int64(0x688a1b2c)))
+ })
+ It("parses a legacy _0 suffix", func() {
+ id, err := model.ParseArtworkID("al-123_0")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(id.ID).To(Equal("123"))
+ Expect(id.Hash).To(BeEmpty())
+ Expect(id.LastUpdate.IsZero()).To(BeTrue())
+ })
+ It("silently drops a garbage suffix", func() {
+ id, err := model.ParseArtworkID("al-123_zz")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(id.ID).To(Equal("123"))
+ Expect(id.Hash).To(BeEmpty())
+ })
It("fails to parse malformed ids", func() {
_, err := model.ParseArtworkID("a6f8d2b1")
Expect(err).To(MatchError("invalid artwork id"))
diff --git a/model/artwork_test.go b/model/artwork_test.go
new file mode 100644
index 000000000..baf741e68
--- /dev/null
+++ b/model/artwork_test.go
@@ -0,0 +1,73 @@
+package model_test
+
+import (
+ "encoding/json"
+
+ "github.com/navidrome/navidrome/model"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+func jsonOf(v any) map[string]any {
+ GinkgoHelper()
+ data, err := json.Marshal(v)
+ Expect(err).ToNot(HaveOccurred())
+ var out map[string]any
+ Expect(json.Unmarshal(data, &out)).To(Succeed())
+ return out
+}
+
+var _ = Describe("ItemImage JSON", func() {
+ It("exposes the artwork state a client needs to render a placeholder", func() {
+ al := model.Album{ID: "al-1", Name: "Album"}
+ al.ImageHash = "0123456789abcdef"
+ al.ThumbHash = "1QcSHQRn"
+ al.ImageWidth, al.ImageHeight = 1200, 800
+
+ Expect(jsonOf(al)).To(SatisfyAll(
+ HaveKeyWithValue("imageHash", "0123456789abcdef"),
+ HaveKeyWithValue("thumbHash", "1QcSHQRn"),
+ HaveKeyWithValue("imageWidth", BeNumerically("==", 1200)),
+ HaveKeyWithValue("imageHeight", BeNumerically("==", 800)),
+ ))
+ })
+
+ It("keeps the blurhash off the native API, where nothing consumes it", func() {
+ al := model.Album{ID: "al-1", Name: "Album"}
+ al.BlurHash = "LEHV6nWB2yk8"
+ Expect(jsonOf(al)).ToNot(HaveKey("blurHash"))
+ })
+
+ It("omits every artwork field when the entity has none", func() {
+ out := jsonOf(model.Album{ID: "al-2", Name: "Album"})
+ for _, key := range []string{
+ "imageHash", "blurHash", "thumbHash", "imageAbsent", "imageWidth", "imageHeight",
+ } {
+ Expect(out).ToNot(HaveKey(key))
+ }
+ })
+
+ It("exposes known-absent artwork so clients can skip the request", func() {
+ ar := model.Artist{ID: "ar-1", Name: "Artist"}
+ ar.ImageAbsent = true
+ Expect(jsonOf(ar)).To(HaveKeyWithValue("imageAbsent", true))
+ })
+
+ Describe("AspectRatio", func() {
+ It("returns width/height", func() {
+ img := model.ItemImage{ImageHash: "abc", ImageWidth: 1200, ImageHeight: 800}
+ Expect(*img.AspectRatio()).To(BeNumerically("~", 1.5, 0.0001))
+ })
+
+ It("returns nil when a dimension is missing, so callers never guess a ratio", func() {
+ Expect(model.ItemImage{ImageHash: "abc"}.AspectRatio()).To(BeNil())
+ Expect(model.ItemImage{ImageHash: "abc", ImageWidth: 1200}.AspectRatio()).To(BeNil())
+ Expect(model.ItemImage{ImageHash: "abc", ImageHeight: 800}.AspectRatio()).To(BeNil())
+ })
+
+ It("returns nil for a known-absent image, whatever the dimensions say", func() {
+ img := model.ItemImage{ImageAbsent: true, ImageWidth: 1200, ImageHeight: 800}
+ Expect(img.AspectRatio()).To(BeNil())
+ })
+ })
+})
diff --git a/model/datastore.go b/model/datastore.go
index 94c3c3622..273ca714b 100644
--- a/model/datastore.go
+++ b/model/datastore.go
@@ -40,6 +40,8 @@ type DataStore interface {
ScrobbleBuffer(ctx context.Context) ScrobbleBufferRepository
Scrobble(ctx context.Context) ScrobbleRepository
Plugin(ctx context.Context) PluginRepository
+ Artwork(ctx context.Context) ArtworkRepository
+ ArtworkQueue(ctx context.Context) ArtworkQueueRepository
Resource(ctx context.Context, model any) ResourceRepository
diff --git a/model/mediafile.go b/model/mediafile.go
index 22ab7fbbe..ac1fad67b 100644
--- a/model/mediafile.go
+++ b/model/mediafile.go
@@ -24,6 +24,11 @@ import (
type MediaFile struct {
Annotations `structs:"-" hash:"ignore"`
Bookmarkable `structs:"-" hash:"ignore"`
+ ItemImage `structs:"-" hash:"ignore"`
+
+ // AlbumImage is the parent album's artwork state, hydrated alongside the track's own so a
+ // song's Jellyfin album-art tag can be pixel-versioned without a second query.
+ AlbumImage ItemImage `structs:"-" json:"-" hash:"ignore"`
ID string `structs:"id" json:"id" hash:"ignore"`
PID string `structs:"pid" json:"-" hash:"ignore"`
@@ -139,13 +144,15 @@ func (mf MediaFile) CoverArtID() ArtworkID {
// otherwise it returns the album artwork ID.
func (mf MediaFile) DiscCoverArtID() ArtworkID {
if mf.DiscNumber > 0 {
- return NewArtworkID(KindDiscArtwork, DiscArtworkID(mf.AlbumID, mf.DiscNumber), nil)
+ return ArtworkID{Kind: KindDiscArtwork, ID: DiscArtworkID(mf.AlbumID, mf.DiscNumber), Hash: mf.ImageHash}
}
return mf.AlbumCoverArtID()
}
+// AlbumCoverArtID uses AlbumImage, not the track's own ItemImage: an album id must carry the
+// album's content hash even when the track resolved art of its own.
func (mf MediaFile) AlbumCoverArtID() ArtworkID {
- return artworkIDFromAlbum(Album{ID: mf.AlbumID})
+ return artworkIDFromAlbum(Album{ID: mf.AlbumID, ItemImage: mf.AlbumImage})
}
func (mf MediaFile) StructuredLyrics() (LyricList, error) {
@@ -542,6 +549,11 @@ type MediaFileRepository interface {
GetRandom(options ...QueryOptions) (MediaFiles, error)
GetAllByTags(tag TagName, values []string, options ...QueryOptions) (MediaFiles, error)
GetCursor(options ...QueryOptions) (MediaFileCursor, error)
+ // GetAllIDs returns just the media_file IDs for the same row set as GetAll.
+ GetAllIDs(options ...QueryOptions) ([]string, error)
+ // GetCursorWithArtwork streams like GetCursor, hydrated, so callers that render images don't
+ // pay the scanner's per-row cost; it uses the same id pre-pass as the other cursors.
+ GetCursorWithArtwork(options ...QueryOptions) (MediaFileCursor, error)
Delete(id string) error
DeleteMissing(ids []string) error
DeleteAllMissing() (int64, error)
diff --git a/model/playlist.go b/model/playlist.go
index 185f6f942..9aa54bf13 100644
--- a/model/playlist.go
+++ b/model/playlist.go
@@ -13,6 +13,7 @@ import (
type Playlist struct {
Annotations `structs:"-"`
+ ItemImage `structs:"-"`
ID string `structs:"id" json:"id"`
Name string `structs:"name" json:"name"`
@@ -143,6 +144,7 @@ type PlaylistRepository interface {
Get(id string) (*Playlist, error)
GetWithTracks(id string, refreshSmartPlaylist, includeMissing bool) (*Playlist, error)
GetAll(options ...QueryOptions) (Playlists, error)
+ GetAllIDs(options ...QueryOptions) ([]string, error)
GetCursor(options ...QueryOptions) (PlaylistCursor, error)
FindByPath(path string) (*Playlist, error)
Delete(id string) error
diff --git a/model/radio.go b/model/radio.go
index 86f27c24c..466ff48b0 100644
--- a/model/radio.go
+++ b/model/radio.go
@@ -7,6 +7,8 @@ import (
)
type Radio struct {
+ ItemImage `structs:"-"`
+
ID string `structs:"id" json:"id"`
StreamUrl string `structs:"stream_url" json:"streamUrl"`
Name string `structs:"name" json:"name"`
@@ -30,7 +32,9 @@ type RadioRepository interface {
ResourceRepository
CountAll(options ...QueryOptions) (int64, error)
Delete(id string) error
+ Exists(id string) (bool, error)
Get(id string) (*Radio, error)
GetAll(options ...QueryOptions) (Radios, error)
+ GetAllIDs(options ...QueryOptions) ([]string, error)
Put(u *Radio, colsToUpdate ...string) error
}
diff --git a/model/radio_test.go b/model/radio_test.go
index 860331f17..6ae74c3f4 100644
--- a/model/radio_test.go
+++ b/model/radio_test.go
@@ -14,12 +14,11 @@ import (
var _ = Describe("Radio", func() {
Describe("CoverArtID", func() {
It("returns a radio artwork ID", func() {
- now := time.Now()
- r := model.Radio{ID: "rd-1", UpdatedAt: now}
+ r := model.Radio{ID: "rd-1", UpdatedAt: time.Now()}
artID := r.CoverArtID()
Expect(artID.Kind).To(Equal(model.KindRadioArtwork))
Expect(artID.ID).To(Equal("rd-1"))
- Expect(artID.LastUpdate).To(Equal(now))
+ Expect(artID.LastUpdate.IsZero()).To(BeTrue())
})
})
diff --git a/persistence/album_repository.go b/persistence/album_repository.go
index 2bb541003..1ebb09751 100644
--- a/persistence/album_repository.go
+++ b/persistence/album_repository.go
@@ -202,7 +202,9 @@ func (r *albumRepository) CountAll(options ...model.QueryOptions) (int64, error)
}
func (r *albumRepository) Exists(id string) (bool, error) {
- return r.exists(Eq{"album.id": id})
+ // The exists() helper applies no library filter, so it would report rows the caller cannot see.
+ c, err := r.count(r.applyLibraryFilter(r.newSelect().Where(Eq{"album.id": id})))
+ return c > 0, err
}
func (r *albumRepository) Put(al *model.Album) error {
@@ -251,16 +253,36 @@ func (r *albumRepository) GetAll(options ...model.QueryOptions) (model.Albums, e
if err != nil {
return nil, err
}
- return res.toModels(), nil
+ albums := res.toModels()
+ r.hydrateArtwork(albums)
+ return albums, nil
+}
+
+func (r *albumRepository) hydrateArtwork(albums model.Albums) {
+ hydrateItems(r.ctx, r.db, model.KindAlbumArtwork, albums,
+ func(a *model.Album) (string, *model.ItemImage) { return a.ID, &a.ItemImage })
+}
+
+// GetAllIDs returns the IDs of GetAll's row set, skipping its column projection and JSON decoding.
+func (r *albumRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {
+ sq := r.applyLibraryFilter(r.newSelect(options...).Columns("album.id"))
+ if filtersNeedAnnotation(sq) {
+ sq = r.withAnnotation(sq, "album.id")
+ }
+ ids := []string{}
+ err := r.queryAllSlice(sq, &ids)
+ return ids, err
}
func (r *albumRepository) GetCursor(options ...model.QueryOptions) (model.AlbumCursor, error) {
- sq := r.selectAlbum(options...)
- cursor, err := queryWithStableResults[dbAlbum](r.sqlRepository, sq)
+ ids, err := r.GetAllIDs(options...)
if err != nil {
return nil, err
}
- return wrapAlbumCursor(cursor), nil
+ opts := chunkOptions(options, "album.id")
+ return model.AlbumCursor(streamByIDs(ids, func(chunk []string) (model.Albums, error) {
+ return r.GetAll(opts(chunk))
+ })), nil
}
func (r *albumRepository) GetYears(libraryIDs ...int) ([]int, error) {
@@ -405,7 +427,9 @@ func (r *albumRepository) Search(q string, options ...model.QueryOptions) (model
if err != nil {
return nil, fmt.Errorf("searching album %q: %w", q, err)
}
- return res.toModels(), nil
+ albums := res.toModels()
+ r.hydrateArtwork(albums)
+ return albums, nil
}
func (r *albumRepository) Count(options ...rest.QueryOptions) (int64, error) {
diff --git a/persistence/album_repository_test.go b/persistence/album_repository_test.go
index 465617b10..1ead89529 100644
--- a/persistence/album_repository_test.go
+++ b/persistence/album_repository_test.go
@@ -13,6 +13,7 @@ import (
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/id"
"github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/utils/slice"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -84,6 +85,17 @@ var _ = Describe("AlbumRepository", func() {
})
})
+ Describe("GetAllIDs", func() {
+ It("returns the same id set as GetAll", func() {
+ want, err := albumRepo.GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).ToNot(BeEmpty())
+ ids, err := albumRepo.GetAllIDs()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ids).To(ConsistOf(slice.Map(want, func(a model.Album) string { return a.ID })))
+ })
+ })
+
Describe("GetAll", func() {
var GetAll = func(opts ...model.QueryOptions) (model.Albums, error) {
albums, err := albumRepo.GetAll(opts...)
@@ -977,6 +989,22 @@ var _ = Describe("AlbumRepository", func() {
Expect(got.RGAlbumPeak).To(BeNil())
})
})
+
+ // Exists must apply the same library filter as Get/GetAll/CountAll.
+ Describe("Exists library visibility", func() {
+ It("hides an album the user has no library access to", func() {
+ Expect(albumRepo.Put(&model.Album{ID: "vis-album", Name: "Vis", LibraryID: 1})).To(Succeed())
+ DeferCleanup(func() {
+ _, _ = albumRepo.executeSQL(squirrel.Delete("album").Where(squirrel.Eq{"id": "vis-album"}))
+ })
+
+ Expect(albumRepo.Exists("vis-album")).To(BeTrue(), "admin sees it")
+
+ restricted := model.User{ID: "restricted_album_user", UserName: "ra", Name: "RA", Email: "[email protected]"}
+ rctx := request.WithUser(GinkgoT().Context(), restricted)
+ Expect(NewAlbumRepository(rctx, GetDBXBuilder()).Exists("vis-album")).To(BeFalse())
+ })
+ })
})
func _p(id, name string, sortName ...string) model.Participant {
diff --git a/persistence/artist_repository.go b/persistence/artist_repository.go
index b542dedb4..67d0df448 100644
--- a/persistence/artist_repository.go
+++ b/persistence/artist_repository.go
@@ -6,7 +6,6 @@ import (
"encoding/json"
"errors"
"fmt"
- "iter"
"os"
"slices"
"strings"
@@ -250,6 +249,7 @@ func (r *artistRepository) Get(id string) (*model.Artist, error) {
return nil, model.ErrNotFound
}
res := dba.toModels()
+ r.hydrateArtwork(res)
return &res[0], nil
}
@@ -261,20 +261,37 @@ func (r *artistRepository) GetAll(options ...model.QueryOptions) (model.Artists,
return nil, err
}
res := dba.toModels()
+ r.hydrateArtwork(res)
return res, err
}
+// GetAllIDs returns just the artist IDs for the same row set as GetAll, skipping the
+// heavy stats columns and JSON post-processing.
+func (r *artistRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {
+ sq := r.applyLibraryFilterToArtistQuery(r.newSelect(options...).Columns("artist.id")).GroupBy("artist.id")
+ if filtersNeedAnnotation(sq) {
+ sq = r.withAnnotation(sq, "artist.id")
+ }
+ ids := []string{}
+ err := r.queryAllSlice(sq, &ids)
+ return ids, err
+}
+
+// hydrateArtwork fills each artist's ImageHash/ImageAbsent from one batched item_artwork lookup.
+func (r *artistRepository) hydrateArtwork(artists model.Artists) {
+ hydrateItems(r.ctx, r.db, model.KindArtistArtwork, artists,
+ func(a *model.Artist) (string, *model.ItemImage) { return a.ID, &a.ItemImage })
+}
+
func (r *artistRepository) GetCursor(options ...model.QueryOptions) (model.ArtistCursor, error) {
- sel := r.selectArtist(options...)
- cursor, err := queryWithStableResults[dbArtist](r.sqlRepository, sel)
+ ids, err := r.GetAllIDs(options...)
if err != nil {
return nil, err
}
- return wrapArtistCursor(cursor), nil
-}
-
-func wrapArtistCursor(cursor iter.Seq2[dbArtist, error]) model.ArtistCursor {
- return model.ArtistCursor(wrapCursor(cursor, func(a dbArtist) *model.Artist { return a.Artist }))
+ opts := chunkOptions(options, "artist.id")
+ return model.ArtistCursor(streamByIDs(ids, func(chunk []string) (model.Artists, error) {
+ return r.GetAll(opts(chunk))
+ })), nil
}
func (r *artistRepository) getIndexKey(a model.Artist) string {
@@ -635,7 +652,9 @@ func (r *artistRepository) Search(q string, options ...model.QueryOptions) (mode
if err != nil {
return nil, fmt.Errorf("searching artist %q: %w", q, err)
}
- return res.toModels(), nil
+ artists := res.toModels()
+ r.hydrateArtwork(artists)
+ return artists, nil
}
// searchScope returns the library IDs the search must be restricted to, or nil to skip the filter
diff --git a/persistence/artist_repository_test.go b/persistence/artist_repository_test.go
index dc11ede36..25472ffe1 100644
--- a/persistence/artist_repository_test.go
+++ b/persistence/artist_repository_test.go
@@ -15,6 +15,7 @@ import (
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/request"
"github.com/navidrome/navidrome/utils"
+ "github.com/navidrome/navidrome/utils/slice"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -284,6 +285,17 @@ var _ = Describe("ArtistRepository", func() {
})
})
+ Describe("GetAllIDs", func() {
+ It("returns the same id set as GetAll", func() {
+ want, err := repo.GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).ToNot(BeEmpty())
+ ids, err := repo.GetAllIDs()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ids).To(ConsistOf(slice.Map(want, func(a model.Artist) string { return a.ID })))
+ })
+ })
+
Describe("Basic Operations", func() {
Describe("Count", func() {
It("returns the number of artists in the DB", func() {
diff --git a/persistence/artwork_hydration.go b/persistence/artwork_hydration.go
new file mode 100644
index 000000000..fa9920f27
--- /dev/null
+++ b/persistence/artwork_hydration.go
@@ -0,0 +1,181 @@
+package persistence
+
+import (
+ "context"
+ "iter"
+ "slices"
+
+ . "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/pocketbase/dbx"
+)
+
+// Keeps the id IN-list under SQLite's bound-parameter limit; a whole multiple of artworkBatchSize
+// so a page re-chunks into even hydration batches.
+const artworkChunkSize = artworkBatchSize * 3
+
+// streamByIDs yields rows in id chunks through the caller's hydrating fetch. Resolving ids first
+// keeps OFFSET out of the joined query.
+func streamByIDs[S ~[]T, T any](ids []string, fetch func(chunk []string) (S, error)) iter.Seq2[T, error] {
+ return func(yield func(T, error) bool) {
+ for chunk := range slices.Chunk(ids, artworkChunkSize) {
+ rows, err := fetch(chunk)
+ if err != nil {
+ var zero T
+ yield(zero, err)
+ return
+ }
+ for _, row := range rows {
+ if !yield(row, nil) {
+ return
+ }
+ }
+ }
+ }
+}
+
+// chunkOptions narrows options to a chunk of ids, dropping Max/Offset (the id pre-pass already
+// consumed them) and reusing Sort, which may be a seeded random expression by now.
+func chunkOptions(options []model.QueryOptions, idField string) func([]string) model.QueryOptions {
+ var base model.QueryOptions
+ if len(options) > 0 {
+ base = model.QueryOptions{Sort: options[0].Sort, Order: options[0].Order, Filters: options[0].Filters}
+ }
+ return func(chunk []string) model.QueryOptions {
+ opts := base
+ opts.Filters = Eq{idField: chunk}
+ if base.Filters != nil {
+ opts.Filters = And{base.Filters, opts.Filters}
+ }
+ return opts
+ }
+}
+
+// hydrateItemImages returns per-item artwork info in one batched query per kind. On error it logs
+// and returns an empty map, so the page still renders.
+func hydrateItemImages(ctx context.Context, db dbx.Builder, kind model.Kind, ids []string) map[string]model.ItemArtworkInfo {
+ if len(ids) == 0 {
+ return map[string]model.ItemArtworkInfo{}
+ }
+ infos, err := NewArtworkRepository(ctx, db).GetInfoForItems(kind, ids)
+ if err != nil {
+ log.Error(ctx, "Failed to hydrate artwork info onto page", "kind", kind, err)
+ return map[string]model.ItemArtworkInfo{}
+ }
+ return infos
+}
+
+// applyItemImage copies a hydration entry onto img; a missing entry leaves it zero (unresolved).
+func applyItemImage(infos map[string]model.ItemArtworkInfo, id string, img *model.ItemImage) {
+ if info, ok := infos[id]; ok {
+ *img = info.Image()
+ }
+}
+
+// hydrateItems fills every item's embedded ItemImage from one batched lookup. ref yields an
+// item's id and the ItemImage to fill, which is all that differs between the entity kinds.
+func hydrateItems[T any](ctx context.Context, db dbx.Builder, kind model.Kind, items []T,
+ ref func(*T) (string, *model.ItemImage)) {
+ ids := make([]string, len(items))
+ for i := range items {
+ ids[i], _ = ref(&items[i])
+ }
+ infos := hydrateItemImages(ctx, db, kind, ids)
+ for i := range items {
+ id, img := ref(&items[i])
+ applyItemImage(infos, id, img)
+ }
+}
+
+// hydrateMediaFileArtwork mirrors MediaFile.CoverArtID: an embedded-eligible file with resolved own
+// art uses it, else it falls back to the album's.
+func hydrateMediaFileArtwork(ctx context.Context, db dbx.Builder, mfs model.MediaFiles) {
+ if len(mfs) == 0 {
+ return
+ }
+ albumIDs := make([]string, len(mfs))
+ var eligibleIDs []string
+ for i := range mfs {
+ albumIDs[i] = mfs[i].AlbumID
+ if mfs[i].HasCoverArt && conf.Server.EnableMediaFileCoverArt {
+ eligibleIDs = append(eligibleIDs, mfs[i].ID)
+ }
+ }
+ albumInfos := hydrateItemImages(ctx, db, model.KindAlbumArtwork, albumIDs)
+ mfInfos := hydrateItemImages(ctx, db, model.KindMediaFileArtwork, eligibleIDs)
+ for i := range mfs {
+ mf := &mfs[i]
+ applyItemImage(albumInfos, mf.AlbumID, &mf.AlbumImage)
+ eligible := mf.HasCoverArt && conf.Server.EnableMediaFileCoverArt
+ ownInfo, ownResolved := mfInfos[mf.ID]
+ if eligible && ownResolved && !ownInfo.Absent() {
+ mf.ItemImage = ownInfo.Image()
+ continue
+ }
+ ownWontResolve := !eligible || (ownResolved && ownInfo.Absent())
+ // Inherit the album hash only when serving returns those exact bytes: a multi-disc track is
+ // served disc art, and an eligible-but-unresolved one still extracts its own embedded image.
+ if album, ok := albumInfos[mf.AlbumID]; ok && !album.Absent() {
+ if mf.DiscNumber == 0 && ownWontResolve {
+ mf.ItemImage = album.Image()
+ }
+ continue
+ }
+ // Mark absent only when serving would definitively yield a placeholder; disc art and
+ // still-extractable embedded art both keep a track requestable.
+ if mf.DiscNumber > 0 {
+ continue
+ }
+ if album, ok := albumInfos[mf.AlbumID]; ok && album.Absent() && ownWontResolve {
+ mf.ImageAbsent = true
+ }
+ }
+}
+
+// hydrateCursor hydrates a streamed cursor in batches, avoiding a per-row query.
+func hydrateCursor[T any](cursor iter.Seq2[T, error], hydrate func([]T)) iter.Seq2[T, error] {
+ return func(yield func(T, error) bool) {
+ buf := make([]T, 0, artworkBatchSize)
+ flush := func() bool {
+ hydrate(buf)
+ for i := range buf {
+ if !yield(buf[i], nil) {
+ return false
+ }
+ }
+ buf = buf[:0]
+ return true
+ }
+ for row, err := range cursor {
+ if err != nil {
+ var zero T
+ yield(zero, err)
+ return
+ }
+ buf = append(buf, row)
+ if len(buf) == artworkBatchSize && !flush() {
+ return
+ }
+ }
+ if len(buf) > 0 {
+ flush()
+ }
+ }
+}
+
+// hydratePlaylistTrackArtwork hydrates the MediaFile embedded in each playlist track.
+func hydratePlaylistTrackArtwork(ctx context.Context, db dbx.Builder, tracks model.PlaylistTracks) {
+ if len(tracks) == 0 {
+ return
+ }
+ mfs := make(model.MediaFiles, len(tracks))
+ for i := range tracks {
+ mfs[i] = tracks[i].MediaFile
+ }
+ hydrateMediaFileArtwork(ctx, db, mfs)
+ for i := range tracks {
+ tracks[i].MediaFile = mfs[i]
+ }
+}
diff --git a/persistence/artwork_hydration_test.go b/persistence/artwork_hydration_test.go
new file mode 100644
index 000000000..2b52d7d82
--- /dev/null
+++ b/persistence/artwork_hydration_test.go
@@ -0,0 +1,773 @@
+package persistence
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "time"
+
+ "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/utils/slice"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "github.com/pocketbase/dbx"
+)
+
+// seedAnnotations gives each id distinct annotation values, writing them directly so that
+// SetRating's average_rating update does not outlive the cleanup.
+func seedAnnotations(itemType string, ids ...string) {
+ GinkgoHelper()
+ when := time.Date(2024, 3, 1, 12, 0, 0, 0, time.UTC)
+ for i, id := range ids {
+ _, err := GetDBXBuilder().NewQuery(`insert or replace into annotation
+ (user_id, item_id, item_type, play_count, play_date, rating, rated_at, starred, starred_at)
+ values ({:u}, {:id}, {:t}, {:pc}, {:d}, {:r}, {:d}, 1, {:d})`).
+ Bind(dbx.Params{"u": adminUser.ID, "id": id, "t": itemType,
+ "pc": i + 1, "r": 4 + i, "d": when.Add(time.Duration(i) * time.Hour)}).Execute()
+ Expect(err).ToNot(HaveOccurred())
+ }
+ DeferCleanup(func() {
+ for _, id := range ids {
+ _, err := GetDBXBuilder().NewQuery("delete from annotation where user_id={:u} and item_type={:t} and item_id={:id}").
+ Bind(dbx.Params{"u": adminUser.ID, "t": itemType, "id": id}).Execute()
+ Expect(err).ToNot(HaveOccurred())
+ }
+ })
+}
+
+var _ = Describe("Artwork hydration", func() {
+ var ctx context.Context
+ var aw model.ArtworkRepository
+
+ putInfo := func(kind, id, hash string) {
+ Expect(aw.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: kind, ItemID: id, ImageType: model.ImageTypePrimary, Hash: hash,
+ })).To(Succeed())
+ }
+
+ BeforeEach(func() {
+ clearArtworkTables()
+ DeferCleanup(clearArtworkTables)
+ ctx = request.WithUser(log.NewContext(context.Background()), adminUser)
+ aw = NewArtworkRepository(ctx, GetDBXBuilder())
+ })
+
+ Describe("albums", func() {
+ var repo model.AlbumRepository
+ BeforeEach(func() { repo = NewAlbumRepository(ctx, GetDBXBuilder()) })
+
+ It("hydrates the found / known-absent / unresolved states", func() {
+ putInfo("al", albumSgtPeppers.ID, "althash11111111")
+ putInfo("al", albumAbbeyRoad.ID, "")
+ // albumRadioactivity: no row -> unresolved
+
+ all, err := repo.GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ byID := slice.ToMap(all, func(a model.Album) (string, model.Album) { return a.ID, a })
+
+ Expect(byID[albumSgtPeppers.ID].ImageHash).To(Equal("althash11111111"))
+ Expect(byID[albumSgtPeppers.ID].ImageAbsent).To(BeFalse())
+ Expect(byID[albumAbbeyRoad.ID].ImageHash).To(BeEmpty())
+ Expect(byID[albumAbbeyRoad.ID].ImageAbsent).To(BeTrue())
+ Expect(byID[albumRadioactivity.ID].ImageHash).To(BeEmpty())
+ Expect(byID[albumRadioactivity.ID].ImageAbsent).To(BeFalse())
+ })
+
+ It("hydrates Get", func() {
+ putInfo("al", albumSgtPeppers.ID, "gethash22222222")
+ got, err := repo.Get(albumSgtPeppers.ID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.ImageHash).To(Equal("gethash22222222"))
+ })
+
+ It("hydrates Search", func() {
+ putInfo("al", albumSgtPeppers.ID, "srchash33333333")
+ res, err := repo.Search("Peppers", model.QueryOptions{})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res).ToNot(BeEmpty())
+ Expect(res[0].ImageHash).To(Equal("srchash33333333"))
+ })
+
+ It("does not persist ImageHash/ImageAbsent on Put", func() {
+ al := albumSgtPeppers
+ al.ImageHash = "shouldnotpersist"
+ al.ImageAbsent = true
+ Expect(repo.(*albumRepository).Put(&al)).To(Succeed())
+
+ got, err := repo.Get(al.ID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.ImageHash).To(BeEmpty())
+ Expect(got.ImageAbsent).To(BeFalse())
+ })
+ })
+
+ Describe("artists", func() {
+ var repo model.ArtistRepository
+ BeforeEach(func() { repo = NewArtistRepository(ctx, GetDBXBuilder()) })
+
+ It("hydrates the found / known-absent / unresolved states", func() {
+ putInfo("ar", artistBeatles.ID, "arhash444444444")
+ putInfo("ar", artistKraftwerk.ID, "")
+ // artistCJK: no row -> unresolved
+
+ all, err := repo.GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ byID := slice.ToMap(all, func(a model.Artist) (string, model.Artist) { return a.ID, a })
+
+ Expect(byID[artistBeatles.ID].ImageHash).To(Equal("arhash444444444"))
+ Expect(byID[artistBeatles.ID].ImageAbsent).To(BeFalse())
+ Expect(byID[artistKraftwerk.ID].ImageHash).To(BeEmpty())
+ Expect(byID[artistKraftwerk.ID].ImageAbsent).To(BeTrue())
+ Expect(byID[artistCJK.ID].ImageHash).To(BeEmpty())
+ Expect(byID[artistCJK.ID].ImageAbsent).To(BeFalse())
+ })
+
+ It("hydrates Get", func() {
+ putInfo("ar", artistBeatles.ID, "arget5555555555")
+ got, err := repo.Get(artistBeatles.ID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.ImageHash).To(Equal("arget5555555555"))
+ })
+
+ It("hydrates Search", func() {
+ putInfo("ar", artistBeatles.ID, "arsrch666666666")
+ res, err := repo.Search("Beatles", model.QueryOptions{})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res).ToNot(BeEmpty())
+ Expect(res[0].ImageHash).To(Equal("arsrch666666666"))
+ })
+ })
+
+ Describe("playlists", func() {
+ var repo model.PlaylistRepository
+ BeforeEach(func() { repo = NewPlaylistRepository(ctx, GetDBXBuilder()) })
+
+ It("hydrates the found / known-absent states", func() {
+ putInfo("pl", plsBest.ID, "plhash777777777")
+ putInfo("pl", plsCool.ID, "")
+
+ all, err := repo.GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ byID := slice.ToMap(all, func(p model.Playlist) (string, model.Playlist) { return p.ID, p })
+
+ Expect(byID[plsBest.ID].ImageHash).To(Equal("plhash777777777"))
+ Expect(byID[plsBest.ID].ImageAbsent).To(BeFalse())
+ Expect(byID[plsCool.ID].ImageHash).To(BeEmpty())
+ Expect(byID[plsCool.ID].ImageAbsent).To(BeTrue())
+ })
+
+ It("hydrates Get", func() {
+ putInfo("pl", plsBest.ID, "plget8888888888")
+ got, err := repo.Get(plsBest.ID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.ImageHash).To(Equal("plget8888888888"))
+ })
+
+ It("hydrates the tracks reached through a playlist", func() {
+ Expect(aw.PutImage(&model.Artwork{Hash: "pltrackhash1234", Mime: "image/jpeg", BlurHash: "LPLBLURhash"})).To(Succeed())
+ putInfo("al", songDayInALife.AlbumID, "pltrackhash1234")
+
+ pls, err := repo.GetWithTracks(plsBest.ID, true, false)
+ Expect(err).ToNot(HaveOccurred())
+ tracks := pls.Tracks
+ Expect(tracks).ToNot(BeEmpty())
+ byID := slice.ToMap(tracks, func(t model.PlaylistTrack) (string, model.PlaylistTrack) { return t.MediaFile.ID, t })
+ Expect(byID).To(HaveKey(songDayInALife.ID))
+ Expect(byID[songDayInALife.ID].AlbumImage.ImageHash).To(Equal("pltrackhash1234"))
+ Expect(byID[songDayInALife.ID].BlurHash).To(Equal("LPLBLURhash"))
+
+ cursor, err := repo.Tracks(plsBest.ID, true).GetCursor()
+ Expect(err).ToNot(HaveOccurred())
+ var streamed *model.PlaylistTrack
+ for t, err := range cursor {
+ Expect(err).ToNot(HaveOccurred())
+ if t.MediaFile.ID == songDayInALife.ID {
+ streamed = &t
+ }
+ }
+ Expect(streamed).ToNot(BeNil())
+ Expect(streamed.AlbumImage.ImageHash).To(Equal("pltrackhash1234"),
+ "the streamed cursor Jellyfin uses must hydrate too")
+ })
+ })
+
+ Describe("radios", func() {
+ var repo model.RadioRepository
+ BeforeEach(func() { repo = NewRadioRepository(ctx, GetDBXBuilder()) })
+
+ It("hydrates the found / known-absent states", func() {
+ putInfo("ra", radioWithHomePage.ID, "rahash999999999")
+ putInfo("ra", radioWithoutHomePage.ID, "")
+
+ all, err := repo.GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ byID := slice.ToMap(all, func(rd model.Radio) (string, model.Radio) { return rd.ID, rd })
+
+ Expect(byID[radioWithHomePage.ID].ImageHash).To(Equal("rahash999999999"))
+ Expect(byID[radioWithHomePage.ID].ImageAbsent).To(BeFalse())
+ Expect(byID[radioWithoutHomePage.ID].ImageHash).To(BeEmpty())
+ Expect(byID[radioWithoutHomePage.ID].ImageAbsent).To(BeTrue())
+ })
+
+ It("hydrates Get", func() {
+ putInfo("ra", radioWithHomePage.ID, "ragetaaaaaaaaaa")
+ got, err := repo.Get(radioWithHomePage.ID)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.ImageHash).To(Equal("ragetaaaaaaaaaa"))
+ })
+ })
+
+ Describe("mediafiles", func() {
+ var repo model.MediaFileRepository
+
+ setCover := func(id string, v bool) {
+ _, err := GetDBXBuilder().NewQuery("UPDATE media_file SET has_cover_art={:v} WHERE id={:id}").
+ Bind(dbx.Params{"v": v, "id": id}).Execute()
+ Expect(err).ToNot(HaveOccurred())
+ }
+
+ getByID := func() map[string]model.MediaFile {
+ all, err := repo.GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ return slice.ToMap(all, func(mf model.MediaFile) (string, model.MediaFile) { return mf.ID, mf })
+ }
+
+ BeforeEach(func() {
+ repo = NewMediaFileRepository(ctx, GetDBXBuilder())
+ DeferCleanup(configtest.SetupConfig())
+ conf.Server.EnableMediaFileCoverArt = true
+ })
+
+ It("resolves the embedded-eligible fallback matrix", func() {
+ setCover("1001", true) // eligible, own hash
+ setCover("1002", true) // eligible, but embedded art absent -> album
+ DeferCleanup(func() { setCover("1001", false); setCover("1002", false) })
+
+ putInfo("al", "101", "alh101xxxxxxxxxx") // song 1001's album (found)
+ putInfo("al", "102", "alh102xxxxxxxxxx") // song 1002's album (found)
+ putInfo("al", "103", "") // songs 1003/1004 album known-absent
+ putInfo("mf", "1001", "mfh1001xxxxxxxx")
+ putInfo("mf", "1002", "") // embedded resolved absent
+
+ byID := getByID()
+
+ Expect(byID["1001"].ImageHash).To(Equal("mfh1001xxxxxxxx"))
+ Expect(byID["1001"].ImageAbsent).To(BeFalse())
+ Expect(byID["1002"].ImageHash).To(Equal("alh102xxxxxxxxxx"))
+ Expect(byID["1002"].ImageAbsent).To(BeFalse())
+ Expect(byID["1003"].ImageHash).To(BeEmpty())
+ Expect(byID["1003"].ImageAbsent).To(BeTrue())
+ // 2002: not eligible, and its album has no row at all -> unresolved
+ Expect(byID["2002"].ImageHash).To(BeEmpty())
+ Expect(byID["2002"].ImageAbsent).To(BeFalse())
+ })
+
+ It("populates AlbumImage from hydrateArtwork regardless of which continue branch a track takes", func() {
+ setCover("1001", true) // eligible, resolves its own art -> own-art-wins continue
+ DeferCleanup(func() { setCover("1001", false) })
+
+ putInfo("al", "101", "alh101albimgxxxx") // 1001's album: own-art-wins branch
+ putInfo("al", "102", "alh102albimgxxxx") // 1002's album: single-disc inheritance branch
+ putInfo("al", "104", "") // 2002's album: known-absent, multi-disc branch
+ putInfo("mf", "1001", "mfh1001albimgxxx")
+
+ byID := getByID()
+
+ Expect(byID["1001"].ImageHash).To(Equal("mfh1001albimgxxx"))
+ Expect(byID["1001"].AlbumImage.ImageHash).To(Equal("alh101albimgxxxx"))
+
+ Expect(byID["1002"].ImageHash).To(Equal("alh102albimgxxxx"))
+ Expect(byID["1002"].AlbumImage.ImageHash).To(Equal("alh102albimgxxxx"))
+
+ Expect(byID["2002"].ImageHash).To(BeEmpty())
+ Expect(byID["2002"].ImageAbsent).To(BeFalse())
+ Expect(byID["2002"].AlbumImage.ImageAbsent).To(BeTrue())
+ })
+
+ It("carries both hashes and the dimensions alongside the hash in the own-art and inherited branches", func() {
+ setCover("1001", true) // eligible, resolves its own art -> own-art-wins branch
+ DeferCleanup(func() { setCover("1001", false) })
+
+ Expect(aw.PutImage(&model.Artwork{Hash: "mfh1001blurxxxxx", Mime: "image/jpeg", BlurHash: "LTRACKblur", ThumbHash: "THtrack", Width: 640, Height: 480})).To(Succeed())
+ Expect(aw.PutImage(&model.Artwork{Hash: "alh102blurxxxxxx", Mime: "image/jpeg", BlurHash: "LALBUMblur", ThumbHash: "THalbum", Width: 1200, Height: 800})).To(Succeed())
+ putInfo("mf", "1001", "mfh1001blurxxxxx")
+ putInfo("al", "102", "alh102blurxxxxxx") // 1002's album: single-disc inheritance branch
+
+ byID := getByID()
+
+ Expect(byID["1001"].ImageHash).To(Equal("mfh1001blurxxxxx"))
+ Expect(byID["1001"].BlurHash).To(Equal("LTRACKblur"))
+ Expect(byID["1001"].ThumbHash).To(Equal("THtrack"))
+ Expect(byID["1001"].ImageWidth).To(Equal(640))
+ Expect(byID["1001"].ImageHeight).To(Equal(480))
+
+ Expect(byID["1002"].ImageHash).To(Equal("alh102blurxxxxxx"))
+ Expect(byID["1002"].BlurHash).To(Equal("LALBUMblur"))
+ Expect(byID["1002"].ThumbHash).To(Equal("THalbum"))
+ Expect(byID["1002"].ImageWidth).To(Equal(1200))
+ Expect(byID["1002"].ImageHeight).To(Equal(800))
+ })
+
+ It("keeps an eligible file optimistic when its own art is unresolved, even if the album is absent", func() {
+ setCover("1004", true)
+ DeferCleanup(func() { setCover("1004", false) })
+ putInfo("al", "103", "") // album known-absent
+
+ byID := getByID()
+
+ // 1004's own embedded art is still unresolved, so coverArt must stay requestable.
+ Expect(byID["1004"].ImageAbsent).To(BeFalse())
+ Expect(byID["1004"].ImageHash).To(BeEmpty())
+ // 1003 is not eligible, so it still inherits the album's absence.
+ Expect(byID["1003"].ImageAbsent).To(BeTrue())
+ })
+
+ It("does not stamp a found album hash onto a multi-disc track (its dc- id is disc-served)", func() {
+ putInfo("al", "104", "alh104foundxxxxx") // songs 2002/2004 album is found
+
+ byID := getByID()
+
+ Expect(byID["2002"].ImageHash).To(BeEmpty())
+ Expect(byID["2002"].ImageAbsent).To(BeFalse())
+ })
+
+ It("keeps a multi-disc track requestable when its album is absent (disc art may resolve)", func() {
+ putInfo("al", "104", "") // songs 2002/2004 album known-absent
+
+ byID := getByID()
+
+ Expect(byID["2002"].ImageAbsent).To(BeFalse())
+ Expect(byID["2002"].ImageHash).To(BeEmpty())
+ })
+
+ // serveMediaFile serves this track's own embedded art, so the album's hash would
+ // advertise a content-version for bytes nobody will serve.
+ It("leaves the hash bare for an eligible file whose own art is unresolved", func() {
+ setCover("1004", true)
+ DeferCleanup(func() { setCover("1004", false) })
+ putInfo("al", "103", "alh103found11111")
+
+ byID := getByID()
+ Expect(byID["1004"].ImageAbsent).To(BeFalse())
+ Expect(byID["1004"].ImageHash).To(BeEmpty())
+ Expect(byID["1004"].AlbumImage.ImageHash).To(Equal("alh103found11111"),
+ "the album's own hash still hydrates, for AlbumCoverArtID")
+ })
+
+ It("uses album info for an eligible file when EnableMediaFileCoverArt is off", func() {
+ conf.Server.EnableMediaFileCoverArt = false
+ setCover("1001", true)
+ DeferCleanup(func() { setCover("1001", false) })
+
+ putInfo("al", "101", "alh101offxxxxxxx")
+ putInfo("mf", "1001", "mfh1001offxxxxx")
+
+ byID := getByID()
+ Expect(byID["1001"].ImageHash).To(Equal("alh101offxxxxxxx"))
+ Expect(byID["1001"].ImageAbsent).To(BeFalse())
+ })
+
+ It("hydrates Search", func() {
+ putInfo("al", "101", "alsrchhhhhhhhhhh")
+ res, err := repo.Search("A Day In A Life", model.QueryOptions{})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(res).ToNot(BeEmpty())
+ Expect(res[0].ImageHash).To(Equal("alsrchhhhhhhhhhh"))
+ })
+ })
+
+ Describe("GetCursor", func() {
+ var albumRepo model.AlbumRepository
+ var artistRepo model.ArtistRepository
+ var playlistRepo model.PlaylistRepository
+ var onlyAlbums, onlyArtists, onlyPlaylists squirrel.Eq
+
+ scoped := func(opts model.QueryOptions, only squirrel.Eq) model.QueryOptions {
+ if opts.Filters == nil {
+ opts.Filters = only
+ } else {
+ opts.Filters = squirrel.And{only, opts.Filters}
+ }
+ return opts
+ }
+
+ BeforeEach(func() {
+ albumRepo = NewAlbumRepository(ctx, GetDBXBuilder())
+ artistRepo = NewArtistRepository(ctx, GetDBXBuilder())
+ playlistRepo = NewPlaylistRepository(ctx, GetDBXBuilder())
+ // Other specs leave rows behind, so scope every cursor spec to the fixtures.
+ onlyAlbums = squirrel.Eq{"album.id": []string{albumSgtPeppers.ID, albumAbbeyRoad.ID,
+ albumRadioactivity.ID, albumMultiDisc.ID, albumCJK.ID, albumPunctuation.ID}}
+ onlyArtists = squirrel.Eq{"artist.id": []string{artistKraftwerk.ID, artistBeatles.ID,
+ artistCJK.ID, artistPunctuation.ID}}
+ // Both fixture playlists share an owner, leaving the owner_name sort a single value to
+ // order by; this one is also private, which the non-admin visibility spec needs.
+ foreign := model.Playlist{Name: "Foreign", OwnerID: thirdUser.ID, OwnerName: thirdUser.UserName}
+ Expect(playlistRepo.Put(&foreign)).To(Succeed())
+ DeferCleanup(func() { Expect(playlistRepo.Delete(foreign.ID)).To(Succeed()) })
+ onlyPlaylists = squirrel.Eq{"playlist.id": []string{plsBest.ID, plsCool.ID, foreign.ID}}
+
+ // The suite annotates a single album and artist, leaving the annotation-backed sorts
+ // nothing to order.
+ seedAnnotations("album", albumSgtPeppers.ID, albumAbbeyRoad.ID)
+ seedAnnotations("artist", artistKraftwerk.ID, artistCJK.ID)
+
+ Expect(aw.PutImage(&model.Artwork{
+ Hash: "curhash11111111", Mime: "image/jpeg", BlurHash: "LEHV6nWB2yk8",
+ })).To(Succeed())
+ putInfo("al", albumSgtPeppers.ID, "curhash11111111")
+ putInfo("al", albumAbbeyRoad.ID, "")
+ putInfo("ar", artistBeatles.ID, "curhash11111111")
+ putInfo("pl", plsBest.ID, "curhash11111111")
+ })
+
+ It("hydrates every streamed album, like GetAll", func() {
+ opts := model.QueryOptions{Sort: "name", Filters: onlyAlbums}
+ want, err := albumRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+
+ got := collectCursor(albumRepo.GetCursor(opts))
+
+ Expect(got).To(ConsistOf(want))
+ byID := map[string]model.Album{}
+ for _, al := range got {
+ byID[al.ID] = al
+ }
+ Expect(byID[albumSgtPeppers.ID].ImageHash).To(Equal("curhash11111111"))
+ Expect(byID[albumSgtPeppers.ID].BlurHash).To(Equal("LEHV6nWB2yk8"))
+ Expect(byID[albumAbbeyRoad.ID].ImageAbsent).To(BeTrue())
+ Expect(byID[albumRadioactivity.ID].ImageHash).To(BeEmpty())
+ Expect(byID[albumRadioactivity.ID].ImageAbsent).To(BeFalse())
+ })
+
+ It("hydrates every streamed artist, like GetAll", func() {
+ opts := model.QueryOptions{Sort: "name", Filters: onlyArtists}
+ want, err := artistRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+
+ got := collectCursor(artistRepo.GetCursor(opts))
+
+ Expect(got).To(ConsistOf(want))
+ Expect(slice.Map(got, func(a model.Artist) string { return a.ImageHash })).
+ To(ContainElement("curhash11111111"))
+ })
+
+ It("hydrates every streamed playlist, like GetAll", func() {
+ opts := model.QueryOptions{Sort: "name", Filters: onlyPlaylists}
+ want, err := playlistRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+
+ got := collectCursor(playlistRepo.GetCursor(opts))
+
+ Expect(got).To(ConsistOf(want))
+ Expect(slice.Map(got, func(p model.Playlist) string { return p.ImageHash })).
+ To(ContainElement("curhash11111111"))
+ })
+
+ It("honors Max and Offset exactly once", func() {
+ opts := model.QueryOptions{Sort: "name", Filters: onlyAlbums, Max: 2, Offset: 1}
+ want, err := albumRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).To(HaveLen(2))
+
+ got := collectCursor(albumRepo.GetCursor(opts))
+
+ Expect(slice.Map(got, func(a model.Album) string { return a.ID })).
+ To(Equal(slice.Map(want, func(a model.Album) string { return a.ID })))
+ })
+
+ // The sorts the Jellyfin list endpoints issue; comparing sort keys, not ids, keeps ties out.
+ DescribeTable("orders albums like GetAll",
+ func(opts model.QueryOptions, key func(model.Album) string) {
+ opts = scoped(opts, onlyAlbums)
+ want, err := albumRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).ToNot(BeEmpty())
+
+ got := collectCursor(albumRepo.GetCursor(opts))
+
+ Expect(slice.Map(got, key)).To(Equal(slice.Map(want, key)))
+ Expect(slice.Map(got, func(a model.Album) string { return a.ID })).
+ To(ConsistOf(slice.Map(want, func(a model.Album) string { return a.ID })))
+ },
+ Entry("by name", model.QueryOptions{Sort: "name"},
+ func(a model.Album) string { return a.OrderAlbumName }),
+ Entry("by artist", model.QueryOptions{Sort: "artist"},
+ func(a model.Album) string { return a.OrderAlbumArtistName }),
+ Entry("by recently added", model.QueryOptions{Sort: "recently_added", Order: "desc"},
+ func(a model.Album) string { return fmt.Sprint(a.CreatedAt) }),
+ Entry("by year", model.QueryOptions{Sort: "max_year"},
+ func(a model.Album) string { return fmt.Sprint(a.MaxYear) }),
+ Entry("by play count", model.QueryOptions{Sort: "play_count", Order: "desc"},
+ func(a model.Album) string { return fmt.Sprint(a.PlayCount) }),
+ Entry("by last played", model.QueryOptions{Sort: "play_date", Order: "desc"},
+ func(a model.Album) string { return fmt.Sprint(a.PlayDate) }),
+ Entry("by rating", model.QueryOptions{Sort: "rating", Order: "desc"},
+ func(a model.Album) string { return fmt.Sprint(a.Rating) }),
+ Entry("starred only", model.QueryOptions{Sort: "starred_at", Order: "desc",
+ Filters: squirrel.Eq{"starred": true}},
+ func(a model.Album) string { return fmt.Sprint(a.StarredAt) }),
+ )
+
+ DescribeTable("orders artists like GetAll",
+ func(opts model.QueryOptions, key func(model.Artist) string) {
+ opts = scoped(opts, onlyArtists)
+ want, err := artistRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).ToNot(BeEmpty())
+
+ got := collectCursor(artistRepo.GetCursor(opts))
+
+ Expect(slice.Map(got, key)).To(Equal(slice.Map(want, key)))
+ Expect(slice.Map(got, func(a model.Artist) string { return a.ID })).
+ To(ConsistOf(slice.Map(want, func(a model.Artist) string { return a.ID })))
+ },
+ Entry("by name", model.QueryOptions{Sort: "name"},
+ func(a model.Artist) string { return a.OrderArtistName }),
+ Entry("by album count", model.QueryOptions{Sort: "album_count", Order: "desc"},
+ func(a model.Artist) string { return fmt.Sprint(a.AlbumCount) }),
+ Entry("by song count", model.QueryOptions{Sort: "song_count", Order: "desc"},
+ func(a model.Artist) string { return fmt.Sprint(a.SongCount) }),
+ Entry("by play count", model.QueryOptions{Sort: "play_count", Order: "desc"},
+ func(a model.Artist) string { return fmt.Sprint(a.PlayCount) }),
+ Entry("starred only", model.QueryOptions{Sort: "starred_at", Order: "desc",
+ Filters: squirrel.Eq{"starred": true}},
+ func(a model.Artist) string { return fmt.Sprint(a.StarredAt) }),
+ )
+
+ DescribeTable("orders playlists like GetAll",
+ func(opts model.QueryOptions, key func(model.Playlist) string) {
+ opts = scoped(opts, onlyPlaylists)
+ want, err := playlistRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).ToNot(BeEmpty())
+
+ got := collectCursor(playlistRepo.GetCursor(opts))
+
+ Expect(slice.Map(got, key)).To(Equal(slice.Map(want, key)))
+ Expect(slice.Map(got, func(p model.Playlist) string { return p.ID })).
+ To(ConsistOf(slice.Map(want, func(p model.Playlist) string { return p.ID })))
+ },
+ Entry("by name", model.QueryOptions{Sort: "name"},
+ func(p model.Playlist) string { return p.Name }),
+ Entry("by creation date", model.QueryOptions{Sort: "created_at", Order: "desc"},
+ func(p model.Playlist) string { return fmt.Sprint(p.CreatedAt) }),
+ Entry("by owner", model.QueryOptions{Sort: "owner_name"},
+ func(p model.Playlist) string { return p.OwnerName }),
+ )
+
+ It("streams every album exactly once when sorted randomly", func() {
+ opts := model.QueryOptions{Sort: "random", Filters: onlyAlbums}
+ want, err := albumRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+
+ got := collectCursor(albumRepo.GetCursor(opts))
+
+ Expect(slice.Map(got, func(a model.Album) string { return a.ID })).
+ To(ConsistOf(slice.Map(want, func(a model.Album) string { return a.ID })))
+ })
+
+ It("keeps a non-admin from streaming another user's private playlists", func() {
+ otherCtx := request.WithUser(log.NewContext(context.Background()), regularUser)
+ repo := NewPlaylistRepository(otherCtx, GetDBXBuilder())
+ opts := model.QueryOptions{Sort: "name", Filters: onlyPlaylists}
+
+ // Both phases must filter on their own: the id pre-pass and the chunk fetch.
+ Expect(repo.GetAllIDs(opts)).To(ConsistOf(plsBest.ID))
+ all, err := repo.GetAll(model.QueryOptions{Filters: onlyPlaylists})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(slice.Map(all, func(p model.Playlist) string { return p.ID })).To(ConsistOf(plsBest.ID))
+
+ got := collectCursor(repo.GetCursor(opts))
+
+ Expect(slice.Map(got, func(p model.Playlist) string { return p.Name })).
+ To(ConsistOf(plsBest.Name))
+ })
+ })
+
+ Describe("GetCursorWithArtwork", func() {
+ var mfRepo model.MediaFileRepository
+ var onlySongs squirrel.Eq
+
+ BeforeEach(func() {
+ mfRepo = NewMediaFileRepository(ctx, GetDBXBuilder())
+ putInfo("al", albumSgtPeppers.ID, "curhash11111111")
+ // Distinct titles only: other fixture songs share titles (e.g. "Antenna" x3), which
+ // would make the positional comparisons against GetAll pass by tie-order coincidence.
+ onlySongs = squirrel.Eq{"media_file.id": []string{songDayInALife.ID, songComeTogether.ID,
+ songRadioactivity.ID, songAntenna.ID, songDisc1Track01.ID, songCJK.ID, songPunctuation.ID}}
+ })
+
+ It("hydrates artwork onto every streamed track, unlike GetCursor", func() {
+ opts := model.QueryOptions{Sort: "title", Filters: onlySongs}
+ want, err := mfRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).ToNot(BeEmpty())
+
+ cursor, err := mfRepo.GetCursorWithArtwork(opts)
+ Expect(err).ToNot(HaveOccurred())
+ var got model.MediaFiles
+ cursor(func(mf model.MediaFile, err error) bool {
+ Expect(err).ToNot(HaveOccurred())
+ got = append(got, mf)
+ return true
+ })
+
+ Expect(got).To(HaveLen(len(want)))
+ for i := range want {
+ Expect(got[i].ID).To(Equal(want[i].ID))
+ Expect(got[i].ImageHash).To(Equal(want[i].ImageHash))
+ Expect(got[i].ImageAbsent).To(Equal(want[i].ImageAbsent))
+ Expect(got[i].AlbumImage.ImageHash).To(Equal(want[i].AlbumImage.ImageHash))
+ Expect(got[i].AlbumImage.BlurHash).To(Equal(want[i].AlbumImage.BlurHash))
+ }
+ Expect(want).To(ContainElement(HaveField("AlbumImage.ImageHash", Not(BeEmpty()))),
+ "fixture must include at least one track with album artwork, or this proves nothing")
+ })
+
+ It("leaves the scanner's GetCursor unhydrated", func() {
+ cursor, err := mfRepo.GetCursor(model.QueryOptions{Sort: "title"})
+ Expect(err).ToNot(HaveOccurred())
+ var seen int
+ cursor(func(mf model.MediaFile, err error) bool {
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mf.AlbumImage.ImageHash).To(BeEmpty(), "GetCursor must stay unhydrated for the scanner")
+ seen++
+ return true
+ })
+ Expect(seen).To(BeNumerically(">", 0))
+ })
+
+ It("streams the same ids in the same order as GetAll", func() {
+ opts := model.QueryOptions{Sort: "title", Filters: onlySongs}
+ want, err := mfRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).ToNot(BeEmpty())
+
+ got := collectCursor(mfRepo.GetCursorWithArtwork(opts))
+
+ Expect(slice.Map(got, func(mf model.MediaFile) string { return mf.ID })).
+ To(Equal(slice.Map(want, func(mf model.MediaFile) string { return mf.ID })))
+ })
+
+ It("honors Max and Offset exactly once", func() {
+ opts := model.QueryOptions{Sort: "title", Filters: onlySongs, Max: 2, Offset: 1}
+ want, err := mfRepo.GetAll(opts)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).To(HaveLen(2))
+
+ got := collectCursor(mfRepo.GetCursorWithArtwork(opts))
+
+ Expect(slice.Map(got, func(mf model.MediaFile) string { return mf.ID })).
+ To(Equal(slice.Map(want, func(mf model.MediaFile) string { return mf.ID })))
+ })
+ })
+
+ Describe("chunkOptions", func() {
+ It("carries Sort, Order and the caller's filters, but never Max/Offset", func() {
+ base := model.QueryOptions{Sort: "name", Order: "desc", Max: 10, Offset: 20,
+ Filters: squirrel.Eq{"missing": false}}
+
+ got := chunkOptions([]model.QueryOptions{base}, "album.id")([]string{"al-1", "al-2"})
+
+ Expect(got.Max).To(BeZero())
+ Expect(got.Offset).To(BeZero())
+ Expect(got.Sort).To(Equal("name"))
+ Expect(got.Order).To(Equal("desc"))
+ Expect(got.Filters).To(Equal(squirrel.And{
+ base.Filters, squirrel.Eq{"album.id": []string{"al-1", "al-2"}},
+ }))
+ })
+
+ It("filters by ids alone when the caller passed no filters", func() {
+ got := chunkOptions(nil, "artist.id")([]string{"ar-1"})
+ Expect(got.Filters).To(Equal(squirrel.Eq{"artist.id": []string{"ar-1"}}))
+ })
+ })
+
+ Describe("streamByIDs", func() {
+ It("fetches in chunks and yields every row in order", func() {
+ ids := make([]string, artworkChunkSize+3)
+ for i := range ids {
+ ids[i] = fmt.Sprintf("id-%d", i)
+ }
+ var chunks [][]string
+ got := collectCursor(streamByIDs(ids, func(chunk []string) ([]string, error) {
+ chunks = append(chunks, chunk)
+ return chunk, nil
+ }), nil)
+
+ Expect(chunks).To(HaveLen(2))
+ Expect(chunks[0]).To(HaveLen(artworkChunkSize))
+ Expect(chunks[1]).To(HaveLen(3))
+ Expect(got).To(Equal(ids))
+ })
+
+ It("yields the fetch error and stops", func() {
+ ids := make([]string, artworkChunkSize+1)
+ calls := 0
+ var errs []error
+ for _, err := range streamByIDs(ids, func(chunk []string) ([]string, error) {
+ calls++
+ return nil, errors.New("boom")
+ }) {
+ errs = append(errs, err)
+ }
+
+ Expect(calls).To(Equal(1))
+ Expect(errs).To(HaveLen(1))
+ Expect(errs[0]).To(MatchError("boom"))
+ })
+
+ It("stops fetching when the consumer breaks", func() {
+ ids := make([]string, artworkChunkSize+1)
+ calls := 0
+ for range streamByIDs(ids, func(chunk []string) ([]string, error) {
+ calls++
+ return chunk, nil
+ }) {
+ break
+ }
+
+ Expect(calls).To(Equal(1))
+ })
+ })
+
+ Describe("applyItemImage", func() {
+ It("copies hash, absence, blurhash and dimensions onto the item", func() {
+ infos := map[string]model.ItemArtworkInfo{
+ "al-1": {ItemID: "al-1", Hash: "0123456789abcdef", BlurHash: "LEHV6nWB2yk8", ThumbHash: "1QcSHQRn", Width: 1200, Height: 800},
+ }
+ var img model.ItemImage
+ applyItemImage(infos, "al-1", &img)
+ Expect(img.ImageHash).To(Equal("0123456789abcdef"))
+ Expect(img.ImageAbsent).To(BeFalse())
+ Expect(img.BlurHash).To(Equal("LEHV6nWB2yk8"))
+ Expect(img.ThumbHash).To(Equal("1QcSHQRn"))
+ Expect(img.ImageWidth).To(Equal(1200))
+ Expect(img.ImageHeight).To(Equal(800))
+ })
+
+ It("marks a hashless entry absent and carries no blurhash", func() {
+ infos := map[string]model.ItemArtworkInfo{"al-2": {ItemID: "al-2"}}
+ var img model.ItemImage
+ applyItemImage(infos, "al-2", &img)
+ Expect(img.ImageAbsent).To(BeTrue())
+ Expect(img.BlurHash).To(BeEmpty())
+ Expect(img.ThumbHash).To(BeEmpty())
+ })
+
+ It("leaves an unresolved item zero-valued", func() {
+ var img model.ItemImage
+ applyItemImage(map[string]model.ItemArtworkInfo{}, "al-3", &img)
+ Expect(img.ImageHash).To(BeEmpty())
+ Expect(img.ImageAbsent).To(BeFalse())
+ Expect(img.BlurHash).To(BeEmpty())
+ })
+ })
+})
diff --git a/persistence/artwork_queue_repository.go b/persistence/artwork_queue_repository.go
new file mode 100644
index 000000000..e5469fbea
--- /dev/null
+++ b/persistence/artwork_queue_repository.go
@@ -0,0 +1,149 @@
+package persistence
+
+import (
+ "cmp"
+ "context"
+ "fmt"
+ "slices"
+ "strings"
+ "time"
+
+ . "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/model"
+ "github.com/pocketbase/dbx"
+)
+
+// Keeps each multi-row insert under SQLite's bind-variable limit (at most 7 vars per row).
+const enqueueChunkSize = 100
+
+// Every insert writes these, in this order; the INSERT..SELECT forms must project them to match.
+var enqueueColumns = []string{"item_kind", "item_id", "image_type", "priority", "attempts", "retry_at", "enqueued_at"}
+
+type artworkQueueRepository struct {
+ sqlRepository
+}
+
+func NewArtworkQueueRepository(ctx context.Context, db dbx.Builder) model.ArtworkQueueRepository {
+ r := &artworkQueueRepository{}
+ r.ctx = ctx
+ r.db = db
+ r.tableName = "artwork_queue"
+ return r
+}
+
+// Enqueue also resets enqueued_at, so a fresh request does not inherit an old row's spent retry budget.
+func (r *artworkQueueRepository) Enqueue(items ...model.ArtworkQueueItem) error {
+ return r.enqueue(`ON CONFLICT (item_kind, item_id, image_type) DO UPDATE SET
+ priority = MAX(priority, excluded.priority), retry_at = excluded.retry_at,
+ attempts = 0, enqueued_at = excluded.enqueued_at`, items)
+}
+
+func (r *artworkQueueRepository) EnqueuePreservingBackoff(items ...model.ArtworkQueueItem) error {
+ return r.enqueue(`ON CONFLICT (item_kind, item_id, image_type) DO UPDATE SET
+ priority = MAX(priority, excluded.priority)`, items)
+}
+
+func (r *artworkQueueRepository) EnqueueStaleAbsent(kind model.Kind, attemptedBefore time.Time) (int64, error) {
+ now := time.Now()
+ return r.insertIfNotQueued("", `SELECT item_kind, item_id, image_type, ?, 0, ?, ?
+ FROM `+itemArtworkTable+` WHERE item_kind = ? AND hash = '' AND attempted_at < ?`,
+ model.ArtworkPriorityRecheck, now, now, kind.Prefix(), attemptedBefore)
+}
+
+func (r *artworkQueueRepository) EnqueueAllMissing(kind model.Kind, priority int) (int64, error) {
+ entityTable, ok := artworkOwnerTables[kind]
+ if !ok {
+ return 0, fmt.Errorf("artwork queue: no entity table for kind %q", kind.Prefix())
+ }
+ now := time.Now()
+ return r.insertIfNotQueued("", `SELECT ?, id, ?, ?, 0, ?, ?
+ FROM `+entityTable+`
+ WHERE id NOT IN (SELECT item_id FROM `+itemArtworkTable+` WHERE item_kind = ?)`,
+ kind.Prefix(), model.ImageTypePrimary, priority, now, now, kind.Prefix())
+}
+
+func (r *artworkQueueRepository) EnqueueIfMissing(items ...model.ArtworkQueueItem) error {
+ now := time.Now()
+ for chunk := range slices.Chunk(items, enqueueChunkSize) {
+ rows := make([]string, 0, len(chunk))
+ args := make([]any, 0, len(chunk)*4+2)
+ for _, it := range chunk {
+ rows = append(rows, "(?,?,?,?)")
+ args = append(args, it.ItemKind, it.ItemID, cmp.Or(it.ImageType, model.ImageTypePrimary), it.Priority)
+ }
+ args = append(args, now, now)
+ _, err := r.insertIfNotQueued(
+ `WITH new_items(item_kind, item_id, image_type, priority) AS (VALUES `+strings.Join(rows, ",")+`) `,
+ `SELECT n.item_kind, n.item_id, n.image_type, n.priority, 0, ?, ?
+ FROM new_items n
+ WHERE NOT EXISTS (
+ SELECT 1 FROM `+itemArtworkTable+` ia
+ WHERE ia.item_kind = n.item_kind AND ia.item_id = n.item_id AND ia.image_type = n.image_type)`,
+ args...)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// insertIfNotQueued inserts the rows selected by the given SQL, optionally prefixed by a CTE. DO NOTHING is
+// deliberate: a recheck must not bump the priority or retry_at of an already-queued item.
+func (r *artworkQueueRepository) insertIfNotQueued(with, sql string, args ...any) (int64, error) {
+ return r.executeSQL(Expr(with+`INSERT INTO `+r.tableName+
+ ` (`+strings.Join(enqueueColumns, ", ")+`) `+sql+
+ ` ON CONFLICT (item_kind, item_id, image_type) DO NOTHING`, args...))
+}
+
+func (r *artworkQueueRepository) enqueue(conflict string, items []model.ArtworkQueueItem) error {
+ now := time.Now()
+ for chunk := range slices.Chunk(items, enqueueChunkSize) {
+ ins := Insert(r.tableName).Columns(enqueueColumns...)
+ for _, it := range chunk {
+ ins = ins.Values(it.ItemKind, it.ItemID, cmp.Or(it.ImageType, model.ImageTypePrimary), it.Priority, 0, now, now)
+ }
+ ins = ins.Suffix(conflict)
+ if _, err := r.executeSQL(ins); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (r *artworkQueueRepository) DequeueBatch(n int, kinds ...string) ([]model.ArtworkQueueItem, error) {
+ sel := Select("*").From(r.tableName).
+ Where(LtOrEq{"retry_at": time.Now()}).
+ OrderBy("priority DESC", "enqueued_at ASC").
+ Limit(uint64(n))
+ if len(kinds) > 0 {
+ sel = sel.Where(Eq{"item_kind": kinds})
+ }
+ var res []model.ArtworkQueueItem
+ err := r.queryAll(sel, &res)
+ return res, err
+}
+
+func (r *artworkQueueRepository) MarkFailedIfUnchanged(kind, id, imageType string, seenRetryAt, retryAt time.Time) error {
+ upd := Update(r.tableName).
+ Set("attempts", Expr("attempts + 1")).
+ Set("retry_at", retryAt).
+ Where(Eq{"item_kind": kind, "item_id": id, "image_type": imageType, "retry_at": seenRetryAt})
+ _, err := r.executeSQL(upd)
+ return err
+}
+
+func (r *artworkQueueRepository) DeleteIfUnchanged(kind, id, imageType string, retryAt time.Time) error {
+ return r.delete(Eq{"item_kind": kind, "item_id": id, "image_type": imageType, "retry_at": retryAt})
+}
+
+func (r *artworkQueueRepository) PurgeDangling() (int64, error) {
+ return purgeDangling(r.sqlRepository)
+}
+
+func (r *artworkQueueRepository) Count() (int64, error) {
+ var res struct{ Count int64 }
+ err := r.queryOne(Select("count(*) as count").From(r.tableName), &res)
+ return res.Count, err
+}
+
+var _ model.ArtworkQueueRepository = (*artworkQueueRepository)(nil)
diff --git a/persistence/artwork_queue_repository_test.go b/persistence/artwork_queue_repository_test.go
new file mode 100644
index 000000000..6638a204e
--- /dev/null
+++ b/persistence/artwork_queue_repository_test.go
@@ -0,0 +1,284 @@
+package persistence
+
+import (
+ "context"
+ "time"
+
+ "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils/slice"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "github.com/pocketbase/dbx"
+)
+
+var _ = Describe("ArtworkQueueRepository", func() {
+ var repo model.ArtworkQueueRepository
+
+ item := func(kind, id string, prio int) model.ArtworkQueueItem {
+ return model.ArtworkQueueItem{ItemKind: kind, ItemID: id,
+ ImageType: model.ImageTypePrimary, Priority: prio}
+ }
+
+ // Writes the post-failure state directly: the production path, MarkFailedIfUnchanged, needs
+ // a retry_at only a dequeue can hand it.
+ backOff := func(kind, id string, retryAt time.Time) {
+ GinkgoHelper()
+ r := repo.(*artworkQueueRepository)
+ _, err := r.executeSQL(squirrel.Update(r.tableName).
+ Set("attempts", squirrel.Expr("attempts + 1")).
+ Set("retry_at", retryAt).
+ Where(squirrel.Eq{"item_kind": kind, "item_id": id, "image_type": model.ImageTypePrimary}))
+ Expect(err).ToNot(HaveOccurred())
+ }
+
+ remove := func(kind, id string) {
+ GinkgoHelper()
+ r := repo.(*artworkQueueRepository)
+ Expect(r.delete(squirrel.Eq{"item_kind": kind, "item_id": id, "image_type": model.ImageTypePrimary})).To(Succeed())
+ }
+
+ BeforeEach(func() {
+ clearArtworkTables()
+ DeferCleanup(clearArtworkTables)
+ repo = NewArtworkQueueRepository(context.Background(), GetDBXBuilder())
+ })
+
+ It("enqueues and dequeues by priority then FIFO", func() {
+ Expect(repo.Enqueue(item("al", "low", model.ArtworkPriorityBackfill))).To(Succeed())
+ Expect(repo.Enqueue(item("ar", "high", model.ArtworkPriorityBump))).To(Succeed())
+
+ got, err := repo.DequeueBatch(10)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(HaveLen(2))
+ Expect(got[0].ItemID).To(Equal("high"))
+ })
+
+ It("keeps the higher priority on duplicate enqueue", func() {
+ Expect(repo.Enqueue(item("al", "a1", model.ArtworkPriorityBump))).To(Succeed())
+ Expect(repo.Enqueue(item("al", "a1", model.ArtworkPriorityBackfill))).To(Succeed())
+ got, _ := repo.DequeueBatch(10)
+ Expect(got).To(HaveLen(1))
+ Expect(got[0].Priority).To(Equal(model.ArtworkPriorityBump))
+ })
+
+ It("EnqueuePreservingBackoff raises priority without resetting a backing-off row's retry_at", func() {
+ Expect(repo.Enqueue(item("al", "b1", model.ArtworkPriorityScan))).To(Succeed())
+ backOff("al", "b1", time.Now().Add(time.Hour))
+ Expect(repo.DequeueBatch(10)).To(BeEmpty())
+
+ Expect(repo.EnqueuePreservingBackoff(item("al", "b1", model.ArtworkPriorityBump))).To(Succeed())
+ Expect(repo.DequeueBatch(10)).To(BeEmpty(), "bump must not reset retry_at")
+
+ // Enqueue (scan/manual), by contrast, resets retry_at and makes it eligible now.
+ Expect(repo.Enqueue(item("al", "b1", model.ArtworkPriorityScan))).To(Succeed())
+ got, _ := repo.DequeueBatch(10)
+ Expect(got).To(HaveLen(1))
+ Expect(got[0].Priority).To(Equal(model.ArtworkPriorityBump), "bump's higher priority is preserved")
+ })
+
+ It("EnqueuePreservingBackoff inserts a brand-new row eligible immediately", func() {
+ Expect(repo.EnqueuePreservingBackoff(item("ar", "n1", model.ArtworkPriorityBump))).To(Succeed())
+ got, _ := repo.DequeueBatch(10)
+ Expect(got).To(HaveLen(1))
+ Expect(got[0].ItemID).To(Equal("n1"))
+ })
+
+ It("hides failed items until retry_at", func() {
+ Expect(repo.Enqueue(item("al", "f1", model.ArtworkPriorityScan))).To(Succeed())
+ backOff("al", "f1", time.Now().Add(time.Hour))
+
+ got, err := repo.DequeueBatch(10)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(BeEmpty())
+
+ backOff("al", "f1", time.Now().Add(-time.Minute))
+ got, _ = repo.DequeueBatch(10)
+ Expect(got).To(HaveLen(1))
+ Expect(got[0].Attempts).To(Equal(2))
+ })
+
+ It("MarkFailedIfUnchanged applies backoff only while retry_at is unchanged", func() {
+ Expect(repo.Enqueue(item("al", "m1", model.ArtworkPriorityScan))).To(Succeed())
+ // Anchor retry_at in the past so it can never collide with the re-enqueue's now.
+ backOff("al", "m1", time.Now().Add(-time.Hour))
+ got, err := repo.DequeueBatch(10)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(HaveLen(1))
+ original := got[0].RetryAt
+
+ // A concurrent scan re-enqueues, resetting retry_at to now.
+ Expect(repo.Enqueue(item("al", "m1", model.ArtworkPriorityScan))).To(Succeed())
+
+ future := time.Now().Add(48 * time.Hour)
+ Expect(repo.MarkFailedIfUnchanged("al", "m1", model.ImageTypePrimary, original, future)).To(Succeed())
+ got, _ = repo.DequeueBatch(10)
+ Expect(got).To(HaveLen(1), "the fresh re-enqueue stays immediately eligible")
+ Expect(got[0].Attempts).To(BeZero(), "re-enqueue clears attempts, and the stale failure must not bump them")
+ current := got[0].RetryAt
+
+ Expect(repo.MarkFailedIfUnchanged("al", "m1", model.ImageTypePrimary, current, future)).To(Succeed())
+ got, _ = repo.DequeueBatch(10)
+ Expect(got).To(BeEmpty(), "backed-off row is hidden until the future retry_at")
+ all, _ := repo.Count()
+ Expect(all).To(Equal(int64(1)))
+ })
+
+ It("Enqueue restarts the retry budget an existing row had spent", func() {
+ Expect(repo.Enqueue(item("al", "e1", model.ArtworkPriorityScan))).To(Succeed())
+ backOff("al", "e1", time.Now().Add(-time.Hour))
+ stale := time.Now().Add(-48 * time.Hour)
+ _, err := GetDBXBuilder().NewQuery("UPDATE artwork_queue SET enqueued_at = {:t} WHERE item_id = 'e1'").
+ Bind(dbx.Params{"t": stale}).Execute()
+ Expect(err).ToNot(HaveOccurred())
+
+ Expect(repo.Enqueue(item("al", "e1", model.ArtworkPriorityScan))).To(Succeed())
+
+ got, err := repo.DequeueBatch(10)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(HaveLen(1))
+ Expect(got[0].EnqueuedAt).To(BeTemporally("~", time.Now(), time.Minute),
+ "a re-request must not inherit a spent 12h window and give up on its first attempt")
+ Expect(got[0].Attempts).To(BeZero())
+ })
+
+ It("deletes on completion and counts", func() {
+ Expect(repo.Enqueue(item("al", "c1", 0))).To(Succeed())
+ n, _ := repo.Count()
+ Expect(n).To(Equal(int64(1)))
+ remove("al", "c1")
+ n, _ = repo.Count()
+ Expect(n).To(BeZero())
+ })
+
+ It("DeleteIfUnchanged deletes only while retry_at is unchanged", func() {
+ Expect(repo.Enqueue(item("al", "d1", model.ArtworkPriorityScan))).To(Succeed())
+ // Anchor retry_at in the past so it can never collide with the re-enqueue's now.
+ backOff("al", "d1", time.Now().Add(-time.Hour))
+ got, err := repo.DequeueBatch(10)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got).To(HaveLen(1))
+ original := got[0].RetryAt
+
+ // A concurrent scan re-enqueues, resetting retry_at to now.
+ Expect(repo.Enqueue(item("al", "d1", model.ArtworkPriorityScan))).To(Succeed())
+
+ // Deleting with the stale retry_at is a no-op: the re-enqueued row survives.
+ Expect(repo.DeleteIfUnchanged("al", "d1", model.ImageTypePrimary, original)).To(Succeed())
+ n, _ := repo.Count()
+ Expect(n).To(Equal(int64(1)))
+
+ got, _ = repo.DequeueBatch(10)
+ Expect(got).To(HaveLen(1))
+ Expect(repo.DeleteIfUnchanged("al", "d1", model.ImageTypePrimary, got[0].RetryAt)).To(Succeed())
+ n, _ = repo.Count()
+ Expect(n).To(BeZero())
+ })
+
+ It("purges queue rows whose entity no longer exists, per kind", func() {
+ Expect(repo.Enqueue(
+ item("al", albumSgtPeppers.ID, model.ArtworkPriorityScan),
+ item("al", "no-such-album", model.ArtworkPriorityScan),
+ item("ar", artistKraftwerk.ID, model.ArtworkPriorityScan),
+ item("ar", "no-such-artist", model.ArtworkPriorityScan),
+ item("pl", plsBest.ID, model.ArtworkPriorityScan),
+ item("pl", "no-such-playlist", model.ArtworkPriorityScan),
+ item("ra", radioWithHomePage.ID, model.ArtworkPriorityScan),
+ item("ra", "no-such-radio", model.ArtworkPriorityScan),
+ item("mf", songDayInALife.ID, model.ArtworkPriorityScan),
+ item("mf", "no-such-mediafile", model.ArtworkPriorityScan),
+ )).To(Succeed())
+
+ purged, err := repo.PurgeDangling()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(purged).To(Equal(int64(5)))
+
+ got, _ := repo.DequeueBatch(100)
+ ids := slice.Map(got, func(it model.ArtworkQueueItem) string { return it.ItemID })
+ Expect(ids).To(ConsistOf(albumSgtPeppers.ID, artistKraftwerk.ID, plsBest.ID, radioWithHomePage.ID, songDayInALife.ID))
+ })
+
+ It("enqueues stale absent states for recheck", func() {
+ awRepo := NewArtworkRepository(context.Background(), GetDBXBuilder())
+ old := time.Now().Add(-48 * time.Hour)
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "stale1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: old})).To(Succeed())
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "fresh1", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()})).To(Succeed())
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "found1", ImageType: model.ImageTypePrimary, Hash: "hX", AttemptedAt: old})).To(Succeed())
+
+ n, err := repo.EnqueueStaleAbsent(model.KindArtistArtwork, time.Now().Add(-24*time.Hour))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(Equal(int64(1)))
+
+ items, err := repo.DequeueBatch(10)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(items).To(HaveLen(1))
+ Expect(items[0].ItemID).To(Equal("stale1"))
+ Expect(items[0].Priority).To(Equal(model.ArtworkPriorityRecheck))
+ })
+
+ It("enqueues entities that have no item_artwork row at all", func() {
+ awRepo := NewArtworkRepository(context.Background(), GetDBXBuilder())
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: albumSgtPeppers.ID, ImageType: model.ImageTypePrimary, Hash: "hX", AttemptedAt: time.Now()})).To(Succeed())
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: albumAbbeyRoad.ID, ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()})).To(Succeed())
+
+ n, err := repo.EnqueueAllMissing(model.KindAlbumArtwork, model.ArtworkPriorityRecheck)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(n).To(BeNumerically(">=", 1))
+
+ got, err := repo.DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ ids := make([]string, 0, len(got))
+ for _, it := range got {
+ Expect(it.ItemKind).To(Equal("al"))
+ Expect(it.Priority).To(Equal(model.ArtworkPriorityRecheck))
+ ids = append(ids, it.ItemID)
+ }
+ Expect(ids).To(ContainElement(albumRadioactivity.ID), "an album with no row must be enqueued")
+ Expect(ids).ToNot(ContainElement(albumSgtPeppers.ID), "a resolved album must not be re-enqueued")
+ Expect(ids).ToNot(ContainElement(albumAbbeyRoad.ID), "an absent-state album must not be enqueued as missing")
+ })
+
+ It("EnqueueIfMissing skips items that already have an item_artwork row", func() {
+ awRepo := NewArtworkRepository(context.Background(), GetDBXBuilder())
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "resolved", ImageType: model.ImageTypePrimary, Hash: "hX", AttemptedAt: time.Now()})).To(Succeed())
+ Expect(awRepo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "absent", ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()})).To(Succeed())
+
+ Expect(repo.EnqueueIfMissing(
+ item("al", "resolved", model.ArtworkPriorityScan),
+ item("al", "absent", model.ArtworkPriorityScan),
+ item("al", "brandnew", model.ArtworkPriorityScan),
+ )).To(Succeed())
+
+ got, err := repo.DequeueBatch(100)
+ Expect(err).ToNot(HaveOccurred())
+ ids := slice.Map(got, func(it model.ArtworkQueueItem) string { return it.ItemID })
+ Expect(ids).To(ConsistOf("brandnew"), "only an item with no state row may be enqueued")
+ })
+
+ It("EnqueueIfMissing leaves an already-queued row untouched", func() {
+ Expect(repo.Enqueue(item("al", "queued", model.ArtworkPriorityBump))).To(Succeed())
+
+ Expect(repo.EnqueueIfMissing(item("al", "queued", model.ArtworkPriorityScan))).To(Succeed())
+
+ got, _ := repo.DequeueBatch(100)
+ Expect(got).To(HaveLen(1))
+ Expect(got[0].Priority).To(Equal(model.ArtworkPriorityBump), "the existing priority must survive")
+ })
+
+ It("does not disturb an already-queued entity when enqueueing missing rows", func() {
+ Expect(repo.Enqueue(item("al", albumRadioactivity.ID, model.ArtworkPriorityBump))).To(Succeed())
+
+ _, err := repo.EnqueueAllMissing(model.KindAlbumArtwork, model.ArtworkPriorityRecheck)
+ Expect(err).ToNot(HaveOccurred())
+
+ got, _ := repo.DequeueBatch(1000)
+ var count int
+ for _, it := range got {
+ if it.ItemID == albumRadioactivity.ID {
+ count++
+ Expect(it.Priority).To(Equal(model.ArtworkPriorityBump), "existing bump priority must survive")
+ }
+ }
+ Expect(count).To(Equal(1), "the already-queued row must not be duplicated")
+ })
+})
diff --git a/persistence/artwork_repository.go b/persistence/artwork_repository.go
new file mode 100644
index 000000000..22662b575
--- /dev/null
+++ b/persistence/artwork_repository.go
@@ -0,0 +1,176 @@
+package persistence
+
+import (
+ "cmp"
+ "context"
+ "slices"
+ "time"
+
+ . "github.com/Masterminds/squirrel"
+ "github.com/navidrome/navidrome/model"
+ "github.com/pocketbase/dbx"
+)
+
+const (
+ itemArtworkTable = "item_artwork"
+ artworkBatchSize = 200
+)
+
+type artworkRepository struct {
+ sqlRepository
+ items sqlRepository
+}
+
+func NewArtworkRepository(ctx context.Context, db dbx.Builder) model.ArtworkRepository {
+ r := &artworkRepository{}
+ r.ctx = ctx
+ r.db = db
+ r.tableName = "artwork"
+ r.items.ctx = ctx
+ r.items.db = db
+ r.items.tableName = itemArtworkTable
+ return r
+}
+
+func (r *artworkRepository) GetImage(hash string) (*model.Artwork, error) {
+ sel := Select("*").From(r.tableName).Where(Eq{"hash": hash})
+ var res model.Artwork
+ if err := r.queryOne(sel, &res); err != nil {
+ return nil, err
+ }
+ return &res, nil
+}
+
+func (r *artworkRepository) PutImage(a *model.Artwork) error {
+ // created_at is the last-acquisition-write time the prune grace window keys on.
+ a.CreatedAt = time.Now()
+ values, err := toSQLArgs(*a)
+ if err != nil {
+ return err
+ }
+ // created_at=excluded.created_at: reacquiring an orphan must reset the prune grace window.
+ ins := Insert(r.tableName).SetMap(values).Suffix(`ON CONFLICT (hash) DO UPDATE SET mime=excluded.mime, width=excluded.width,
+ height=excluded.height, size_bytes=excluded.size_bytes, blur_hash=excluded.blur_hash,
+ thumb_hash=excluded.thumb_hash, dominant_color=excluded.dominant_color,
+ created_at=excluded.created_at`)
+ _, err = r.executeSQL(ins)
+ return err
+}
+
+func (r *artworkRepository) GetMimeByHash() (map[string]string, error) {
+ sel := Select("hash", "mime").From(r.tableName)
+ var rows []struct {
+ Hash string
+ Mime string
+ }
+ if err := r.queryAll(sel, &rows); err != nil {
+ return nil, err
+ }
+ res := make(map[string]string, len(rows))
+ for _, row := range rows {
+ res[row.Hash] = row.Mime
+ }
+ return res, nil
+}
+
+func (r *artworkRepository) PurgeOrphans(createdBefore time.Time) (int64, error) {
+ del := Delete(r.tableName).Where(And{
+ Lt{"created_at": createdBefore},
+ Expr("hash NOT IN (SELECT hash FROM " + itemArtworkTable + " WHERE hash <> '')"),
+ })
+ return r.executeSQL(del)
+}
+
+// artworkOwnerTables maps an artwork kind to the table that owns the entity.
+var artworkOwnerTables = map[model.Kind]string{
+ model.KindAlbumArtwork: "album",
+ model.KindArtistArtwork: "artist",
+ model.KindPlaylistArtwork: "playlist",
+ model.KindRadioArtwork: "radio",
+ model.KindMediaFileArtwork: "media_file",
+}
+
+// purgeDangling deletes rows in r's table whose owning entity is gone, one statement per kind.
+func purgeDangling(r sqlRepository) (int64, error) {
+ var total int64
+ for kind, entityTable := range artworkOwnerTables {
+ del := Delete(r.tableName).Where(And{
+ Eq{"item_kind": kind.Prefix()},
+ Expr("item_id NOT IN (SELECT id FROM " + entityTable + ")"),
+ })
+ c, err := r.executeSQL(del)
+ if err != nil {
+ return total, err
+ }
+ total += c
+ }
+ return total, nil
+}
+
+func (r *artworkRepository) PurgeDanglingItems() (int64, error) {
+ return purgeDangling(r.items)
+}
+
+func (r *artworkRepository) GetItemArtwork(kind model.Kind, id, imageType string) (*model.ItemArtwork, error) {
+ sel := Select("*").From(itemArtworkTable).
+ Where(Eq{"item_kind": kind.Prefix(), "item_id": id, "image_type": imageType})
+ var res model.ItemArtwork
+ if err := r.items.queryOne(sel, &res); err != nil {
+ return nil, err
+ }
+ return &res, nil
+}
+
+func (r *artworkRepository) PutItemArtwork(ia *model.ItemArtwork) error {
+ ia.ImageType = cmp.Or(ia.ImageType, model.ImageTypePrimary)
+ ia.UpdatedAt = time.Now()
+ // PutItemArtwork records the outcome of an attempt, so an unset attempted_at is now.
+ if ia.AttemptedAt.IsZero() {
+ ia.AttemptedAt = ia.UpdatedAt
+ }
+ values, err := toSQLArgs(*ia)
+ if err != nil {
+ return err
+ }
+ ins := Insert(itemArtworkTable).SetMap(values).Suffix(`ON CONFLICT (item_kind, item_id, image_type) DO UPDATE SET
+ hash=excluded.hash, source=excluded.source, source_path=excluded.source_path, ref_mtime=excluded.ref_mtime,
+ attempted_at=excluded.attempted_at, updated_at=excluded.updated_at`)
+ _, err = r.items.executeSQL(ins)
+ return err
+}
+
+func (r *artworkRepository) DeleteForItems(kind model.Kind, ids []string) error {
+ for chunk := range slices.Chunk(ids, artworkBatchSize) {
+ if err := r.items.delete(Eq{"item_kind": kind.Prefix(), "item_id": chunk}); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (r *artworkRepository) GetInfoForItems(kind model.Kind, ids []string) (map[string]model.ItemArtworkInfo, error) {
+ res := map[string]model.ItemArtworkInfo{}
+ for chunk := range slices.Chunk(ids, artworkBatchSize) {
+ sel := Select("ia.item_id", "ia.hash", "COALESCE(a.blur_hash, '') as blur_hash",
+ "COALESCE(a.thumb_hash, '') as thumb_hash",
+ "COALESCE(a.dominant_color, '') as dominant_color",
+ "COALESCE(a.width, 0) as width", "COALESCE(a.height, 0) as height").
+ From(itemArtworkTable + " ia").
+ LeftJoin("artwork a ON a.hash = ia.hash").
+ Where(And{
+ Eq{"ia.item_kind": kind.Prefix()},
+ Eq{"ia.image_type": model.ImageTypePrimary},
+ Eq{"ia.item_id": chunk},
+ })
+ var rows []model.ItemArtworkInfo
+ if err := r.items.queryAll(sel, &rows); err != nil {
+ return nil, err
+ }
+ for _, row := range rows {
+ res[row.ItemID] = row
+ }
+ }
+ return res, nil
+}
+
+var _ model.ArtworkRepository = (*artworkRepository)(nil)
diff --git a/persistence/artwork_repository_test.go b/persistence/artwork_repository_test.go
new file mode 100644
index 000000000..683dc2d0f
--- /dev/null
+++ b/persistence/artwork_repository_test.go
@@ -0,0 +1,248 @@
+package persistence
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ "github.com/navidrome/navidrome/model"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "github.com/pocketbase/dbx"
+)
+
+func clearArtworkTables() {
+ db := GetDBXBuilder()
+ for _, t := range []string{"artwork_queue", "item_artwork", "artwork"} {
+ _, err := db.NewQuery("DELETE FROM " + t).Execute()
+ Expect(err).ToNot(HaveOccurred())
+ }
+}
+
+var _ = Describe("ArtworkRepository", func() {
+ var repo model.ArtworkRepository
+
+ BeforeEach(func() {
+ clearArtworkTables()
+ DeferCleanup(clearArtworkTables)
+ repo = NewArtworkRepository(context.Background(), GetDBXBuilder())
+ })
+
+ Context("image identity", func() {
+ It("stores and retrieves an artwork by hash", func() {
+ a := &model.Artwork{Hash: "abc123", Mime: "image/jpeg", Width: 500, Height: 500, SizeBytes: 1234, BlurHash: "LKO2?U%2Tw=w"}
+ Expect(repo.PutImage(a)).To(Succeed())
+
+ got, err := repo.GetImage("abc123")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.Mime).To(Equal("image/jpeg"))
+ Expect(got.BlurHash).To(Equal("LKO2?U%2Tw=w"))
+ Expect(got.CreatedAt).ToNot(BeZero())
+ })
+
+ It("round-trips the thumbhash alongside the blurhash", func() {
+ a := &model.Artwork{Hash: "both1", Mime: "image/jpeg", BlurHash: "LKO2?U%2Tw=w",
+ ThumbHash: "1QcSHQRnh493V4dIh4eXh1h4kJUI", DominantColor: "#336699"}
+ Expect(repo.PutImage(a)).To(Succeed())
+
+ got, err := repo.GetImage("both1")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.BlurHash).To(Equal("LKO2?U%2Tw=w"))
+ Expect(got.ThumbHash).To(Equal("1QcSHQRnh493V4dIh4eXh1h4kJUI"))
+ Expect(got.DominantColor).To(Equal("#336699"))
+ })
+
+ It("overwrites the thumbhash on re-acquisition", func() {
+ Expect(repo.PutImage(&model.Artwork{Hash: "th2", Mime: "image/png", ThumbHash: "first", DominantColor: "#111111"})).To(Succeed())
+ Expect(repo.PutImage(&model.Artwork{Hash: "th2", Mime: "image/png", ThumbHash: "second", DominantColor: "#222222"})).To(Succeed())
+
+ got, err := repo.GetImage("th2")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.ThumbHash).To(Equal("second"))
+ Expect(got.DominantColor).To(Equal("#222222"))
+ })
+
+ It("is idempotent on Put (upsert by hash)", func() {
+ a := &model.Artwork{Hash: "dup1", Mime: "image/png"}
+ Expect(repo.PutImage(a)).To(Succeed())
+ a.BlurHash = "XYZ"
+ Expect(repo.PutImage(a)).To(Succeed())
+ got, _ := repo.GetImage("dup1")
+ Expect(got.BlurHash).To(Equal("XYZ"))
+ })
+
+ It("refreshes created_at when reacquiring an existing hash", func() {
+ Expect(repo.PutImage(&model.Artwork{Hash: "reacq", Mime: "image/jpeg"})).To(Succeed())
+ _, err := GetDBXBuilder().NewQuery("UPDATE artwork SET created_at={:t} WHERE hash='reacq'").
+ Bind(dbx.Params{"t": "2000-01-01 00:00:00"}).Execute()
+ Expect(err).ToNot(HaveOccurred())
+
+ Expect(repo.PutImage(&model.Artwork{Hash: "reacq", Mime: "image/png"})).To(Succeed())
+
+ got, err := repo.GetImage("reacq")
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.CreatedAt).To(BeTemporally(">", time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)))
+ })
+
+ It("returns ErrNotFound for a missing hash", func() {
+ _, err := repo.GetImage("nope")
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+
+ It("returns every stored hash with its current mime", func() {
+ Expect(repo.PutImage(&model.Artwork{Hash: "all1", Mime: "image/jpeg"})).To(Succeed())
+ Expect(repo.PutImage(&model.Artwork{Hash: "all2", Mime: "image/png"})).To(Succeed())
+ mimes, err := repo.GetMimeByHash()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mimes).To(HaveKeyWithValue("all1", "image/jpeg"))
+ Expect(mimes).To(HaveKeyWithValue("all2", "image/png"))
+ })
+
+ It("deletes only unreferenced rows older than the cutoff, reporting the count", func() {
+ Expect(repo.PutImage(&model.Artwork{Hash: "d1", Mime: "image/jpeg"})).To(Succeed())
+ Expect(repo.PutImage(&model.Artwork{Hash: "dref", Mime: "image/jpeg"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "a1",
+ ImageType: model.ImageTypePrimary, Hash: "dref", Source: "folder"})).To(Succeed())
+
+ Expect(repo.PurgeOrphans(time.Now().Add(time.Minute))).To(BeNumerically("==", 1))
+
+ _, err := repo.GetImage("d1")
+ Expect(err).To(MatchError(model.ErrNotFound))
+ _, err = repo.GetImage("dref")
+ Expect(err).ToNot(HaveOccurred())
+ })
+
+ It("spares an unreferenced row younger than the cutoff", func() {
+ Expect(repo.PutImage(&model.Artwork{Hash: "young", Mime: "image/jpeg"})).To(Succeed())
+ Expect(repo.PurgeOrphans(time.Now().Add(-time.Hour))).To(BeNumerically("==", 0))
+ _, err := repo.GetImage("young")
+ Expect(err).ToNot(HaveOccurred())
+ })
+ })
+
+ Context("dangling state cleanup", func() {
+ It("purges item_artwork rows per kind whose entity no longer exists, summing counts", func() {
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: albumSgtPeppers.ID, ImageType: model.ImageTypePrimary, Hash: "keepAl"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "no-such-album", ImageType: model.ImageTypePrimary, Hash: "danglingAl"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: artistKraftwerk.ID, ImageType: model.ImageTypePrimary, Hash: "keepAr"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "no-such-artist", ImageType: model.ImageTypePrimary, Hash: "danglingAr"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "pl", ItemID: plsBest.ID, ImageType: model.ImageTypePrimary, Hash: "keepPl"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "pl", ItemID: "no-such-playlist", ImageType: model.ImageTypePrimary, Hash: "danglingPl"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ra", ItemID: radioWithHomePage.ID, ImageType: model.ImageTypePrimary, Hash: "keepRa"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ra", ItemID: "no-such-radio", ImageType: model.ImageTypePrimary, Hash: "danglingRa"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: songDayInALife.ID, ImageType: model.ImageTypePrimary, Hash: "keepMf"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: "no-such-mediafile", ImageType: model.ImageTypePrimary, Hash: "danglingMf"})).To(Succeed())
+
+ purged, err := repo.PurgeDanglingItems()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(purged).To(Equal(int64(5)))
+
+ for _, kept := range []model.ItemArtwork{
+ {ItemKind: "al", ItemID: albumSgtPeppers.ID},
+ {ItemKind: "ar", ItemID: artistKraftwerk.ID},
+ {ItemKind: "pl", ItemID: plsBest.ID},
+ {ItemKind: "ra", ItemID: radioWithHomePage.ID},
+ {ItemKind: "mf", ItemID: songDayInALife.ID},
+ } {
+ k, _ := model.ParseKind(kept.ItemKind)
+ _, err := repo.GetItemArtwork(k, kept.ItemID, model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ }
+ for _, gone := range []model.ItemArtwork{
+ {ItemKind: "al", ItemID: "no-such-album"},
+ {ItemKind: "ar", ItemID: "no-such-artist"},
+ {ItemKind: "pl", ItemID: "no-such-playlist"},
+ {ItemKind: "ra", ItemID: "no-such-radio"},
+ {ItemKind: "mf", ItemID: "no-such-mediafile"},
+ } {
+ k, _ := model.ParseKind(gone.ItemKind)
+ _, err := repo.GetItemArtwork(k, gone.ItemID, model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ }
+ })
+ })
+
+ Context("item state", func() {
+ It("upserts and reads state, including per-item provenance", func() {
+ ia := &model.ItemArtwork{ItemKind: "al", ItemID: "al1", ImageType: model.ImageTypePrimary,
+ Hash: "h1", Source: "folder", SourcePath: "/music/a/cover.jpg", RefMtime: 111, AttemptedAt: time.Now()}
+ Expect(repo.PutItemArtwork(ia)).To(Succeed())
+ ia.Source = "embedded"
+ ia.SourcePath = "/music/a/track.mp3"
+ ia.RefMtime = 222
+ Expect(repo.PutItemArtwork(ia)).To(Succeed())
+
+ got, err := repo.GetItemArtwork(model.KindAlbumArtwork, "al1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.Source).To(Equal("embedded"))
+ Expect(got.SourcePath).To(Equal("/music/a/track.mp3"))
+ Expect(got.RefMtime).To(Equal(int64(222)))
+ Expect(got.UpdatedAt).ToNot(BeZero())
+ })
+
+ It("defaults attempted_at to now when unset", func() {
+ before := time.Now().Add(-time.Second)
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "noattempt",
+ ImageType: model.ImageTypePrimary, Hash: ""})).To(Succeed())
+ got, err := repo.GetItemArtwork(model.KindArtistArtwork, "noattempt", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.AttemptedAt).To(BeTemporally(">", before))
+ })
+
+ It("represents known-absent as empty hash", func() {
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "ar", ItemID: "ar1",
+ ImageType: model.ImageTypePrimary, Hash: "", AttemptedAt: time.Now()})).To(Succeed())
+ got, err := repo.GetItemArtwork(model.KindArtistArtwork, "ar1", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(got.Hash).To(BeEmpty())
+ })
+
+ It("hydrates a page in one batch, including blurhash, dimensions and absence", func() {
+ Expect(repo.PutImage(&model.Artwork{Hash: "h9", Mime: "image/jpeg", BlurHash: "BH9",
+ DominantColor: "#abcdef", Width: 1200, Height: 800})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "x1", ImageType: model.ImageTypePrimary, Hash: "h9", Source: "folder"})).To(Succeed())
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "al", ItemID: "x2", ImageType: model.ImageTypePrimary, Hash: "", Source: ""})).To(Succeed())
+
+ info, err := repo.GetInfoForItems(model.KindAlbumArtwork, []string{"x1", "x2", "x3"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(info).To(HaveLen(2))
+ Expect(info["x1"].Hash).To(Equal("h9"))
+ Expect(info["x1"].BlurHash).To(Equal("BH9"))
+ Expect(info["x1"].DominantColor).To(Equal("#abcdef"))
+ Expect(info["x1"].Width).To(Equal(1200))
+ Expect(info["x1"].Height).To(Equal(800))
+ Expect(info["x1"].Absent()).To(BeFalse())
+ Expect(info["x2"].Absent()).To(BeTrue())
+ _, unresolved := info["x3"]
+ Expect(unresolved).To(BeFalse())
+ })
+
+ It("deletes all rows for a single item", func() {
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "pl", ItemID: "p1", ImageType: model.ImageTypePrimary, Hash: "h1"})).To(Succeed())
+ Expect(repo.DeleteForItems(model.KindPlaylistArtwork, []string{"p1"})).To(Succeed())
+ _, err := repo.GetItemArtwork(model.KindPlaylistArtwork, "p1", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
+
+ It("deletes rows for many items in chunks, leaving others untouched", func() {
+ const n = artworkBatchSize + 5
+ ids := make([]string, n)
+ for i := range n {
+ id := fmt.Sprintf("mf-%d", i)
+ ids[i] = id
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: id, ImageType: model.ImageTypePrimary, Hash: "h1"})).To(Succeed())
+ }
+ Expect(repo.PutItemArtwork(&model.ItemArtwork{ItemKind: "mf", ItemID: "keep", ImageType: model.ImageTypePrimary, Hash: "h1"})).To(Succeed())
+
+ Expect(repo.DeleteForItems(model.KindMediaFileArtwork, ids)).To(Succeed())
+
+ for _, id := range ids {
+ _, err := repo.GetItemArtwork(model.KindMediaFileArtwork, id, model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ }
+ kept, err := repo.GetItemArtwork(model.KindMediaFileArtwork, "keep", model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(kept.ItemID).To(Equal("keep"))
+ })
+ })
+})
diff --git a/persistence/e2e/e2e_suite_test.go b/persistence/e2e/e2e_suite_test.go
index 1ff2139e6..2b617f5b0 100644
--- a/persistence/e2e/e2e_suite_test.go
+++ b/persistence/e2e/e2e_suite_test.go
@@ -13,7 +13,6 @@ import (
"github.com/Masterminds/squirrel"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
- "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playlists"
@@ -275,8 +274,8 @@ var _ = BeforeSuite(func() {
ctx = request.WithUser(GinkgoT().Context(), adminUser)
buildTestFS()
- s := scanner.New(ctx, initDS, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(initDS, core.NewImageUploadService()), metrics.NewNoopInstance())
+ s := scanner.New(ctx, initDS, events.NoopBroker(),
+ playlists.NewPlaylists(initDS, artwork.NewUploader(initDS)), metrics.NewNoopInstance())
_, err = s.ScanAll(ctx, true)
Expect(err).ToNot(HaveOccurred())
diff --git a/persistence/mediafile_repository.go b/persistence/mediafile_repository.go
index ace61610c..df1472c2a 100644
--- a/persistence/mediafile_repository.go
+++ b/persistence/mediafile_repository.go
@@ -163,7 +163,9 @@ func (r *mediaFileRepository) CountBySuffix(options ...model.QueryOptions) (map[
}
func (r *mediaFileRepository) Exists(id string) (bool, error) {
- return r.exists(Eq{"media_file.id": id})
+ // The exists() helper applies no library filter, so it would report rows the caller cannot see.
+ c, err := r.count(r.applyLibraryFilter(r.newSelect().Where(Eq{"media_file.id": id})))
+ return c > 0, err
}
func (r *mediaFileRepository) Put(m *model.MediaFile) error {
@@ -218,7 +220,13 @@ func (r *mediaFileRepository) GetAll(options ...model.QueryOptions) (model.Media
if err != nil {
return nil, err
}
- return res.toModels(), nil
+ mfs := res.toModels()
+ r.hydrateArtwork(mfs)
+ return mfs, nil
+}
+
+func (r *mediaFileRepository) hydrateArtwork(mfs model.MediaFiles) {
+ hydrateMediaFileArtwork(r.ctx, r.db, mfs)
}
// GetRandom uses two passes so the random sort runs over a narrow rowid index instead of the
@@ -252,7 +260,9 @@ func (r *mediaFileRepository) GetRandom(options ...model.QueryOptions) (model.Me
if err := r.queryAll(sq, &res); err != nil {
return nil, err
}
- return res.toModels(), nil
+ mfs := res.toModels()
+ r.hydrateArtwork(mfs)
+ return mfs, nil
}
func (r *mediaFileRepository) GetAllByTags(tag model.TagName, values []string, options ...model.QueryOptions) (model.MediaFiles, error) {
@@ -289,6 +299,29 @@ func (r *mediaFileRepository) GetCursor(options ...model.QueryOptions) (model.Me
return wrapMediaFileCursor(cursor), nil
}
+// GetAllIDs returns the IDs of GetAll's row set, skipping its wide column projection.
+func (r *mediaFileRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {
+ sq := r.applyLibraryFilter(r.newSelect(options...).Columns("media_file.id"))
+ if filtersNeedAnnotation(sq) {
+ sq = r.withAnnotation(sq, "media_file.id")
+ }
+ ids := []string{}
+ err := r.queryAllSlice(sq, &ids)
+ return ids, err
+}
+
+// GetCursorWithArtwork streams the same rows as GetCursor, hydrated, via an id pre-pass.
+func (r *mediaFileRepository) GetCursorWithArtwork(options ...model.QueryOptions) (model.MediaFileCursor, error) {
+ ids, err := r.GetAllIDs(options...)
+ if err != nil {
+ return nil, err
+ }
+ opts := chunkOptions(options, "media_file.id")
+ return model.MediaFileCursor(streamByIDs(ids, func(chunk []string) (model.MediaFiles, error) {
+ return r.GetAll(opts(chunk))
+ })), nil
+}
+
// FindByPaths finds media files by their paths.
// The paths can be library-qualified (format: "libraryID:path") or unqualified ("path").
// Library-qualified paths search within the specified library, while unqualified paths
@@ -487,7 +520,9 @@ func (r *mediaFileRepository) Search(q string, options ...model.QueryOptions) (m
if err != nil {
return nil, fmt.Errorf("searching media_file %q: %w", q, err)
}
- return res.toModels(), nil
+ mfs := res.toModels()
+ r.hydrateArtwork(mfs)
+ return mfs, nil
}
func (r *mediaFileRepository) Count(options ...rest.QueryOptions) (int64, error) {
diff --git a/persistence/mediafile_repository_test.go b/persistence/mediafile_repository_test.go
index f6a744d8d..b9cba03ff 100644
--- a/persistence/mediafile_repository_test.go
+++ b/persistence/mediafile_repository_test.go
@@ -1093,4 +1093,40 @@ var _ = Describe("MediaRepository", func() {
_ = mr.Delete(newID)
})
})
+
+ Describe("AlbumImage hydration", func() {
+ It("carries the parent album's artwork state onto each track", func() {
+ mfs := model.MediaFiles{{ID: "mf-1", AlbumID: "al-1"}}
+ infos := map[string]model.ItemArtworkInfo{
+ "al-1": {ItemID: "al-1", Hash: "0123456789abcdef", BlurHash: "LEHV6nWB2yk8"},
+ }
+ applyItemImage(infos, mfs[0].AlbumID, &mfs[0].AlbumImage)
+
+ Expect(mfs[0].AlbumImage.ImageHash).To(Equal("0123456789abcdef"))
+ Expect(mfs[0].AlbumImage.BlurHash).To(Equal("LEHV6nWB2yk8"))
+ Expect(mfs[0].AlbumImage.ImageAbsent).To(BeFalse())
+ })
+
+ It("keeps the album state independent of the track's own art", func() {
+ mf := model.MediaFile{ID: "mf-2", AlbumID: "al-2"}
+ mf.ImageHash = "aaaaaaaaaaaaaaaa" // the track's own art
+ applyItemImage(
+ map[string]model.ItemArtworkInfo{"al-2": {ItemID: "al-2", Hash: "bbbbbbbbbbbbbbbb"}},
+ mf.AlbumID, &mf.AlbumImage,
+ )
+ Expect(mf.ImageHash).To(Equal("aaaaaaaaaaaaaaaa"))
+ Expect(mf.AlbumImage.ImageHash).To(Equal("bbbbbbbbbbbbbbbb"))
+ })
+ })
+
+ // Exists must apply the same library filter as Get/GetAll/CountAll.
+ Describe("Exists library visibility", func() {
+ It("hides a track the user has no library access to", func() {
+ restricted := model.User{ID: "restricted_mf_user", UserName: "rm", Name: "RM", Email: "[email protected]"}
+ rctx := request.WithUser(GinkgoT().Context(), restricted)
+
+ Expect(mr.Exists(songAntenna.ID)).To(BeTrue(), "admin sees it")
+ Expect(NewMediaFileRepository(rctx, GetDBXBuilder()).Exists(songAntenna.ID)).To(BeFalse())
+ })
+ })
})
diff --git a/persistence/persistence.go b/persistence/persistence.go
index 93f0e3e71..9d3a33cfc 100644
--- a/persistence/persistence.go
+++ b/persistence/persistence.go
@@ -97,6 +97,14 @@ func (s *SQLStore) Plugin(ctx context.Context) model.PluginRepository {
return NewPluginRepository(ctx, s.getDBXBuilder())
}
+func (s *SQLStore) Artwork(ctx context.Context) model.ArtworkRepository {
+ return NewArtworkRepository(ctx, s.getDBXBuilder())
+}
+
+func (s *SQLStore) ArtworkQueue(ctx context.Context) model.ArtworkQueueRepository {
+ return NewArtworkQueueRepository(ctx, s.getDBXBuilder())
+}
+
func (s *SQLStore) Resource(ctx context.Context, m any) model.ResourceRepository {
switch m.(type) {
case model.User:
diff --git a/persistence/playlist_repository.go b/persistence/playlist_repository.go
index c78e0df1e..081dab3fa 100644
--- a/persistence/playlist_repository.go
+++ b/persistence/playlist_repository.go
@@ -6,7 +6,6 @@ import (
"encoding/json"
"errors"
"fmt"
- "iter"
"slices"
"time"
@@ -112,7 +111,8 @@ func (r *playlistRepository) Put(p *model.Playlist, cols ...string) error {
_, err := r.put(pls.ID, pls, cols...)
return err
}
- if pls.ID == "" {
+ isNew := pls.ID == ""
+ if isNew {
pls.CreatedAt = time.Now()
}
pls.UpdatedAt = time.Now()
@@ -131,6 +131,12 @@ func (r *playlistRepository) Put(p *model.Playlist, cols ...string) error {
if len(pls.Tracks) > 0 {
return r.updateTracks(id, p.MediaFiles())
}
+ pls.ID = id // r.put assigns the generated id to p, not to this copy
+ if isNew {
+ // Even a trackless new playlist has art to find (an imported m3u can carry an
+ // ExternalImageURL); an update landing here changed only metadata, so leave its cover be.
+ r.enqueueCoverRebuild(id)
+ }
return r.refreshCounters(&pls.Playlist)
}
@@ -172,7 +178,14 @@ func (r *playlistRepository) findBy(sql Sqlizer) (*model.Playlist, error) {
return nil, model.ErrNotFound
}
- return &pls[0].Playlist, nil
+ list := model.Playlists{pls[0].Playlist}
+ r.hydrateArtwork(list)
+ return &list[0], nil
+}
+
+func (r *playlistRepository) hydrateArtwork(playlists model.Playlists) {
+ hydrateItems(r.ctx, r.db, model.KindPlaylistArtwork, playlists,
+ func(p *model.Playlist) (string, *model.ItemImage) { return p.ID, &p.ItemImage })
}
func (r *playlistRepository) GetAll(options ...model.QueryOptions) (model.Playlists, error) {
@@ -186,22 +199,34 @@ func (r *playlistRepository) GetAll(options ...model.QueryOptions) (model.Playli
for i, p := range res {
playlists[i] = p.Playlist
}
+ r.hydrateArtwork(playlists)
return playlists, err
}
+// GetAllIDs returns the IDs of GetAll's row set, skipping its per-row processing.
+func (r *playlistRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {
+ // Joins a projection of user, not the table: its name/created_at columns would make an ORDER BY
+ // on the playlist's own ambiguous.
+ sq := r.newSelect(options...).Columns("playlist.id", "user.user_name as owner_name").
+ Join("(select id, user_name from user) user on user.id = owner_id").Where(r.userFilter())
+ if filtersNeedAnnotation(sq) {
+ sq = r.withAnnotation(sq, "playlist.id")
+ }
+ ids := []string{}
+ err := r.queryAllSlice(sq, &ids)
+ return ids, err
+}
+
func (r *playlistRepository) GetCursor(options ...model.QueryOptions) (model.PlaylistCursor, error) {
- // Same userFilter as GetAll: a cursor must not widen visibility beyond public/owned playlists.
- sel := r.selectPlaylist(options...).Where(r.userFilter())
- cursor, err := queryWithStableResults[dbPlaylist](r.sqlRepository, sel)
+ // Both passes apply userFilter, so a visibility change between them cannot widen the cursor.
+ ids, err := r.GetAllIDs(options...)
if err != nil {
return nil, err
}
- return wrapPlaylistCursor(cursor), nil
-}
-
-// dbPlaylist embeds a value, not a pointer, so its model is never nil.
-func wrapPlaylistCursor(cursor iter.Seq2[dbPlaylist, error]) model.PlaylistCursor {
- return model.PlaylistCursor(wrapCursor(cursor, func(p dbPlaylist) *model.Playlist { return &p.Playlist }))
+ opts := chunkOptions(options, "playlist.id")
+ return model.PlaylistCursor(streamByIDs(ids, func(chunk []string) (model.Playlists, error) {
+ return r.GetAll(opts(chunk))
+ })), nil
}
func (r *playlistRepository) GetPlaylists(mediaFileId string) (model.Playlists, error) {
@@ -220,6 +245,7 @@ func (r *playlistRepository) GetPlaylists(mediaFileId string) (model.Playlists,
for i, p := range res {
playlists[i] = p.Playlist
}
+ r.hydrateArtwork(playlists)
return playlists, nil
}
@@ -264,6 +290,7 @@ func (r *playlistRepository) addTracks(playlistId string, startingPos int, media
}
}
+ r.enqueueCoverRebuild(playlistId)
return r.refreshCounters(&model.Playlist{ID: playlistId})
}
@@ -300,6 +327,16 @@ func (r *playlistRepository) refreshCounters(pls *model.Playlist) error {
return nil
}
+// enqueueCoverRebuild re-resolves the generated 2x2 grid. Call it only when the track set changes:
+// the grid samples albums at random, so rebuilding after a mere rename would change the cover.
+func (r *playlistRepository) enqueueCoverRebuild(id string) {
+ item := model.ArtworkQueueItem{ItemKind: model.KindPlaylistArtwork.Prefix(), ItemID: id,
+ ImageType: model.ImageTypePrimary, Priority: model.ArtworkPriorityScan}
+ if err := NewArtworkQueueRepository(r.ctx, r.db).Enqueue(item); err != nil {
+ log.Warn(r.ctx, "could not enqueue playlist artwork after content change", "id", id, err)
+ }
+}
+
// tracksQuery is shared by loadTracks and GetCursor, so both hydrate rows identically.
func (r *playlistRepository) tracksQuery(query SelectBuilder, id string) SelectBuilder {
query = r.applyLibraryFilter(query, "f")
@@ -332,7 +369,9 @@ func (r *playlistRepository) loadTracks(query SelectBuilder, id string) (model.P
if err != nil {
return nil, err
}
- return tracks.toModels(), err
+ res := tracks.toModels()
+ hydratePlaylistTrackArtwork(r.ctx, r.db, res)
+ return res, err
}
func (r *playlistRepository) Count(options ...rest.QueryOptions) (int64, error) {
@@ -433,6 +472,7 @@ func (r *playlistRepository) renumber(id string) error {
if err != nil {
return err
}
+ r.enqueueCoverRebuild(id)
return r.refreshCounters(&model.Playlist{ID: id})
}
diff --git a/persistence/playlist_repository_test.go b/persistence/playlist_repository_test.go
index 00d4ff9f2..fc2d4ae3f 100644
--- a/persistence/playlist_repository_test.go
+++ b/persistence/playlist_repository_test.go
@@ -8,6 +8,7 @@ import (
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/utils/slice"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
"github.com/pocketbase/dbx"
@@ -37,6 +38,17 @@ var _ = Describe("PlaylistRepository", func() {
})
})
+ Describe("GetAllIDs", func() {
+ It("returns the same id set as GetAll", func() {
+ want, err := repo.GetAll()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(want).ToNot(BeEmpty())
+ ids, err := repo.GetAllIDs()
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ids).To(ConsistOf(slice.Map(want, func(p model.Playlist) string { return p.ID })))
+ })
+ })
+
Describe("Exists", func() {
It("returns true for an existing playlist", func() {
Expect(repo.Exists(plsCool.ID)).To(BeTrue())
@@ -245,6 +257,59 @@ var _ = Describe("PlaylistRepository", func() {
Expect(repo.Exists(newPls.ID)).To(BeFalse())
})
+ It("enqueues a new empty playlist's artwork under its generated id, not an empty id", func() {
+ ctx := request.WithUser(log.NewContext(GinkgoT().Context()), model.User{ID: "userid", UserName: "userid", IsAdmin: true})
+ newPls := model.Playlist{Name: "Empty PL", OwnerID: "userid"} // no tracks → refreshCounters path
+ Expect(repo.Put(&newPls)).To(Succeed())
+ Expect(newPls.ID).ToNot(BeEmpty())
+ DeferCleanup(func() { _ = repo.Delete(newPls.ID) })
+
+ queued, err := NewArtworkQueueRepository(ctx, GetDBXBuilder()).DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(queued).To(ContainElement(SatisfyAll(HaveField("ItemKind", "pl"), HaveField("ItemID", newPls.ID))))
+ Expect(queued).ToNot(ContainElement(HaveField("ItemID", "")), "must not enqueue an empty playlist id")
+ })
+
+ // The grid samples albums at random, so re-resolving after a rename would change the cover.
+ It("does not enqueue artwork when only metadata changes", func() {
+ ctx := request.WithUser(log.NewContext(GinkgoT().Context()), model.User{ID: "userid", UserName: "userid", IsAdmin: true})
+ newPls := model.Playlist{Name: "Rename Me", OwnerID: "userid"}
+ Expect(repo.Put(&newPls)).To(Succeed())
+ DeferCleanup(func() { _ = repo.Delete(newPls.ID) })
+ // Clear the row creation just enqueued, so anything present afterwards came from the update.
+ queueRepo := NewArtworkQueueRepository(ctx, GetDBXBuilder())
+ queued, err := queueRepo.DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ for _, q := range queued {
+ if q.ItemID == newPls.ID {
+ Expect(queueRepo.DeleteIfUnchanged(q.ItemKind, q.ItemID, q.ImageType, q.RetryAt)).To(Succeed())
+ }
+ }
+
+ newPls.Name = "Renamed"
+ newPls.Comment = "edited"
+ Expect(repo.Put(&newPls)).To(Succeed())
+
+ queued, err = queueRepo.DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(queued).ToNot(ContainElement(HaveField("ItemID", newPls.ID)))
+ })
+
+ It("enqueues the playlist's artwork when its track set changes", func() {
+ ctx := request.WithUser(log.NewContext(GinkgoT().Context()), model.User{ID: "userid", UserName: "userid", IsAdmin: true})
+ newPls := model.Playlist{Name: "Grid PL", OwnerID: "userid"}
+ newPls.AddMediaFilesByID([]string{"1001", "1002"})
+ Expect(repo.Put(&newPls)).To(Succeed())
+ DeferCleanup(func() { _ = repo.Delete(newPls.ID) })
+
+ queued, err := NewArtworkQueueRepository(ctx, GetDBXBuilder()).DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(queued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "pl"),
+ HaveField("ItemID", newPls.ID),
+ )))
+ })
+
Describe("GetAll", func() {
It("returns all playlists from DB", func() {
all, err := repo.GetAll()
@@ -341,4 +406,27 @@ var _ = Describe("PlaylistRepository", func() {
Expect(mediaFileIDs).To(Equal([]string{"1001", "1002"}))
})
})
+
+ // Exists is ctx-sensitive through userFilter, so callers that only want "does it still exist"
+ // -- the public image route serving a share -- must elevate, or a private playlist looks gone.
+ Describe("Exists visibility", func() {
+ It("hides a private playlist from an unauthenticated context", func() {
+ // "userid" is the fixture user; playlist.owner_id has a FK to user(id).
+ owner := model.User{ID: "userid", UserName: "userid"}
+ octx := request.WithUser(GinkgoT().Context(), owner)
+ ownerRepo := NewPlaylistRepository(octx, GetDBXBuilder())
+ pls := model.Playlist{Name: "Private One", OwnerID: owner.ID, Public: false}
+ Expect(ownerRepo.Put(&pls)).To(Succeed())
+ DeferCleanup(func() { _ = ownerRepo.Delete(pls.ID) })
+
+ Expect(ownerRepo.Exists(pls.ID)).To(BeTrue(), "the owner sees it")
+
+ anon := NewPlaylistRepository(GinkgoT().Context(), GetDBXBuilder())
+ Expect(anon.Exists(pls.ID)).To(BeFalse(), "no user: userFilter hides it")
+
+ admin := request.WithUser(GinkgoT().Context(), model.User{ID: "userid", IsAdmin: true})
+ Expect(NewPlaylistRepository(admin, GetDBXBuilder()).Exists(pls.ID)).To(BeTrue(),
+ "elevating is what the public image route relies on")
+ })
+ })
})
diff --git a/persistence/playlist_track_repository.go b/persistence/playlist_track_repository.go
index e51ff8ea6..1a64efa20 100644
--- a/persistence/playlist_track_repository.go
+++ b/persistence/playlist_track_repository.go
@@ -130,8 +130,11 @@ func (r *playlistTrackRepository) GetCursor(options ...model.QueryOptions) (mode
if err != nil {
return nil, err
}
- return model.PlaylistTrackCursor(wrapCursor(cursor, func(t dbPlaylistTrack) *model.PlaylistTrack {
+ tracks := wrapCursor(cursor, func(t dbPlaylistTrack) *model.PlaylistTrack {
return t.PlaylistTrack
+ })
+ return model.PlaylistTrackCursor(hydrateCursor(tracks, func(batch []model.PlaylistTrack) {
+ hydratePlaylistTrackArtwork(r.ctx, r.db, batch)
})), nil
}
diff --git a/persistence/radio_repository.go b/persistence/radio_repository.go
index a073643db..b73487e40 100644
--- a/persistence/radio_repository.go
+++ b/persistence/radio_repository.go
@@ -7,6 +7,7 @@ import (
. "github.com/Masterminds/squirrel"
"github.com/deluan/rest"
+ "github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/id"
"github.com/pocketbase/dbx"
@@ -36,6 +37,11 @@ func (r *radioRepository) CountAll(options ...model.QueryOptions) (int64, error)
return r.count(sql, options...)
}
+// Exists needs no library or ownership filter: radios are visible to every user.
+func (r *radioRepository) Exists(id string) (bool, error) {
+ return r.exists(Eq{"id": id})
+}
+
func (r *radioRepository) Delete(id string) error {
if !r.isPermitted() {
return rest.ErrPermissionDenied
@@ -48,14 +54,37 @@ func (r *radioRepository) Get(id string) (*model.Radio, error) {
sel := r.newSelect().Where(Eq{"id": id}).Columns("*")
res := model.Radio{}
err := r.queryOne(sel, &res)
- return &res, err
+ if err != nil {
+ return &res, err
+ }
+ list := model.Radios{res}
+ r.hydrateArtwork(list)
+ return &list[0], nil
}
func (r *radioRepository) GetAll(options ...model.QueryOptions) (model.Radios, error) {
sel := r.newSelect(options...).Columns("*")
res := model.Radios{}
err := r.queryAll(sel, &res)
- return res, err
+ if err != nil {
+ return res, err
+ }
+ r.hydrateArtwork(res)
+ return res, nil
+}
+
+// hydrateArtwork fills each radio's ImageHash/ImageAbsent from one batched item_artwork lookup.
+func (r *radioRepository) hydrateArtwork(radios model.Radios) {
+ hydrateItems(r.ctx, r.db, model.KindRadioArtwork, radios,
+ func(rd *model.Radio) (string, *model.ItemImage) { return rd.ID, &rd.ItemImage })
+}
+
+// GetAllIDs returns just the radio IDs. Used by bulk enumeration (artwork backfill).
+func (r *radioRepository) GetAllIDs(options ...model.QueryOptions) ([]string, error) {
+ sel := r.newSelect(options...).Columns("id")
+ ids := []string{}
+ err := r.queryAllSlice(sel, &ids)
+ return ids, err
}
func (r *radioRepository) Put(radio *model.Radio, colsToUpdate ...string) error {
@@ -72,7 +101,17 @@ func (r *radioRepository) Put(radio *model.Radio, colsToUpdate ...string) error
colsToUpdate = append(colsToUpdate, "UpdatedAt")
}
_, err := r.put(radio.ID, radio, colsToUpdate...)
- return err
+ if err != nil {
+ return err
+ }
+ // Enqueue artwork resolution for the created/updated radio at Bump priority so a new
+ // radio's cover resolves proactively. Never fails the save.
+ item := model.ArtworkQueueItem{ItemKind: model.KindRadioArtwork.Prefix(), ItemID: radio.ID, ImageType: model.ImageTypePrimary,
+ Priority: model.ArtworkPriorityBump}
+ if err := NewArtworkQueueRepository(r.ctx, r.db).Enqueue(item); err != nil {
+ log.Warn(r.ctx, "could not enqueue radio artwork", "id", radio.ID, err)
+ }
+ return nil
}
func (r *radioRepository) Count(options ...rest.QueryOptions) (int64, error) {
diff --git a/persistence/radio_repository_test.go b/persistence/radio_repository_test.go
index 05628ca41..e2564455d 100644
--- a/persistence/radio_repository_test.go
+++ b/persistence/radio_repository_test.go
@@ -7,6 +7,7 @@ import (
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/utils/slice"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -78,6 +79,17 @@ var _ = Describe("RadioRepository", func() {
})
})
+ Describe("GetAllIDs", func() {
+ It("returns the same id set as GetAll", func() {
+ want, err := repo.GetAll()
+ Expect(err).To(BeNil())
+ Expect(want).ToNot(BeEmpty())
+ ids, err := repo.GetAllIDs()
+ Expect(err).To(BeNil())
+ Expect(ids).To(ConsistOf(slice.Map(want, func(r model.Radio) string { return r.ID })))
+ })
+ })
+
Describe("Put", func() {
It("successfully updates item", func() {
err := repo.Put(&model.Radio{
@@ -107,6 +119,27 @@ var _ = Describe("RadioRepository", func() {
Expect(err).To(BeNil())
Expect(all[2].StreamUrl).To(Equal("https://example.com:4533/app"))
})
+
+ It("enqueues artwork resolution for the saved radio", func() {
+ err := repo.Put(&model.Radio{
+ Name: "Artwork radio",
+ StreamUrl: "https://example.com:4533/artwork",
+ })
+ Expect(err).To(BeNil())
+
+ all, err := repo.GetAll()
+ Expect(err).To(BeNil())
+ created := all[len(all)-1]
+
+ queueRepo := NewArtworkQueueRepository(context.Background(), GetDBXBuilder())
+ queued, err := queueRepo.DequeueBatch(1000)
+ Expect(err).To(BeNil())
+ Expect(queued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "ra"),
+ HaveField("ItemID", created.ID),
+ HaveField("Priority", model.ArtworkPriorityBump),
+ )))
+ })
})
})
diff --git a/persistence/sql_base_repository.go b/persistence/sql_base_repository.go
index d0cbb2946..33450fe9f 100644
--- a/persistence/sql_base_repository.go
+++ b/persistence/sql_base_repository.go
@@ -15,6 +15,7 @@ import (
. "github.com/Masterminds/squirrel"
"github.com/deluan/rest"
"github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/db"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
id2 "github.com/navidrome/navidrome/model/id"
@@ -597,9 +598,15 @@ func (r sqlRepository) delete(cond Sqlizer) error {
func (r sqlRepository) logSQL(sql string, args dbx.Params, err error, rowsAffected int64, start time.Time) {
elapsed := time.Since(start)
+ fields := []any{r.ctx, "SQL: `" + sql + "`", "args", args, "rowsAffected", rowsAffected, "elapsedTime", elapsed}
if err == nil || errors.Is(err, context.Canceled) {
- log.Trace(r.ctx, "SQL: `"+sql+"`", "args", args, "rowsAffected", rowsAffected, "elapsedTime", elapsed, err)
- } else {
- log.Error(r.ctx, "SQL: `"+sql+"`", "args", args, "rowsAffected", rowsAffected, "elapsedTime", elapsed, err)
+ log.Trace(append(fields, err)...)
+ return
+ }
+ // The result codes separate errors that share a message, notably SQLITE_BUSY from
+ // SQLITE_BUSY_SNAPSHOT, which no busy_timeout can retry.
+ if code, extended, ok := db.ErrorCodes(err); ok {
+ fields = append(fields, "sqliteCode", code, "sqliteExtended", extended)
}
+ log.Error(append(fields, err)...)
}
diff --git a/scanner/controller.go b/scanner/controller.go
index 463718ba3..df5aeb6f9 100644
--- a/scanner/controller.go
+++ b/scanner/controller.go
@@ -11,7 +11,6 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/auth"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playlists"
@@ -28,12 +27,11 @@ var (
ErrAlreadyScanning = errors.New("already scanning")
)
-func New(rootCtx context.Context, ds model.DataStore, cw artwork.CacheWarmer, broker events.Broker,
+func New(rootCtx context.Context, ds model.DataStore, broker events.Broker,
pls playlists.Playlists, m metrics.Metrics) model.Scanner {
c := &controller{
rootCtx: rootCtx,
ds: ds,
- cw: cw,
broker: broker,
pls: pls,
metrics: m,
@@ -49,7 +47,7 @@ func (s *controller) getScanner() scanner {
if s.devExternalScanner {
return &scannerExternal{}
}
- return &scannerImpl{ds: s.ds, cw: s.cw, pls: s.pls}
+ return &scannerImpl{ds: s.ds, pls: s.pls}
}
// CallScan starts an in-process scan of specific library/folder pairs.
@@ -66,7 +64,7 @@ func CallScan(ctx context.Context, ds model.DataStore, pls playlists.Playlists,
progress := make(chan *ProgressInfo, 100)
go func() {
defer close(progress)
- scanner := &scannerImpl{ds: ds, cw: artwork.NoopCacheWarmer(), pls: pls}
+ scanner := &scannerImpl{ds: ds, pls: pls}
scanner.scanFolders(ctx, fullScan, targets, progress)
}()
return progress, nil
@@ -97,7 +95,6 @@ type scanner interface {
type controller struct {
rootCtx context.Context
ds model.DataStore
- cw artwork.CacheWarmer
broker events.Broker
metrics metrics.Metrics
pls playlists.Playlists
diff --git a/scanner/controller_test.go b/scanner/controller_test.go
index e4814da64..7ffdd69d4 100644
--- a/scanner/controller_test.go
+++ b/scanner/controller_test.go
@@ -5,7 +5,6 @@ import (
"github.com/navidrome/navidrome/conf/configtest"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playlists"
@@ -32,7 +31,7 @@ var _ = Describe("Controller", func() {
DeferCleanup(configtest.SetupConfig())
ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}
ds.MockedProperty = &tests.MockedPropertyRepo{}
- ctrl = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(), playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
+ ctrl = scanner.New(ctx, ds, events.NoopBroker(), playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
})
It("includes last scan error", func() {
diff --git a/scanner/phase_1_folders.go b/scanner/phase_1_folders.go
index 5e898590b..e853948e6 100644
--- a/scanner/phase_1_folders.go
+++ b/scanner/phase_1_folders.go
@@ -16,7 +16,6 @@ import (
ppl "github.com/google/go-pipeline/pkg/pipeline"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/storage"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
@@ -26,7 +25,7 @@ import (
"github.com/navidrome/navidrome/utils/slice"
)
-func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStore, cw artwork.CacheWarmer) *phaseFolders {
+func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStore) *phaseFolders {
var jobs []*scanJob
// Create scan jobs for all libraries
@@ -37,7 +36,7 @@ func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStor
targetFolders = state.targets[lib.ID]
}
- job, err := newScanJob(ctx, ds, cw, lib, state.fullScan, targetFolders)
+ job, err := newScanJob(ctx, ds, lib, state.fullScan, targetFolders)
if err != nil {
log.Error(ctx, "Scanner: Error creating scan context", "lib", lib.Name, err)
state.sendError(err)
@@ -52,14 +51,13 @@ func createPhaseFolders(ctx context.Context, state *scanState, ds model.DataStor
type scanJob struct {
lib model.Library
fs storage.MusicFS
- cw artwork.CacheWarmer
lastUpdates map[string]model.FolderUpdateInfo // Holds last update info for all (DB) folders in this library
targetFolders []string // Specific folders to scan (including all descendants)
lock sync.Mutex
numFolders atomic.Int64
}
-func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer, lib model.Library, fullScan bool, targetFolders []string) (*scanJob, error) {
+func newScanJob(ctx context.Context, ds model.DataStore, lib model.Library, fullScan bool, targetFolders []string) (*scanJob, error) {
// Get folder updates, optionally filtered to specific target folders
lastUpdates, err := ds.Folder(ctx).GetFolderUpdateInfo(lib, targetFolders...)
if err != nil {
@@ -85,7 +83,6 @@ func newScanJob(ctx context.Context, ds model.DataStore, cw artwork.CacheWarmer,
return &scanJob{
lib: lib,
fs: fsys,
- cw: cw,
lastUpdates: lastUpdates,
targetFolders: targetFolders,
}, nil
@@ -330,8 +327,8 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)
defer p.measure(entry)()
p.state.changesDetected.Store(true)
- // Collect artwork IDs to pre-cache after the transaction commits
- var artworkIDs []model.ArtworkID
+ // Collect artwork queue items for changed albums/artists, enqueued in the same transaction
+ var queueItems []model.ArtworkQueueItem
err := p.ds.WithTx(func(tx model.DataStore) error {
// Instantiate all repositories just once per folder
@@ -371,7 +368,10 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)
return err
}
if entry.artists[i].Name != consts.UnknownArtist && entry.artists[i].Name != consts.VariousArtists {
- artworkIDs = append(artworkIDs, entry.artists[i].CoverArtID())
+ queueItems = append(queueItems, model.ArtworkQueueItem{
+ ItemKind: model.KindArtistArtwork.Prefix(), ItemID: entry.artists[i].ID, ImageType: model.ImageTypePrimary,
+ Priority: model.ArtworkPriorityScan,
+ })
}
}
@@ -383,7 +383,10 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)
return err
}
if entry.albums[i].Name != consts.UnknownAlbum {
- artworkIDs = append(artworkIDs, entry.albums[i].CoverArtID())
+ queueItems = append(queueItems, model.ArtworkQueueItem{
+ ItemKind: model.KindAlbumArtwork.Prefix(), ItemID: entry.albums[i].ID, ImageType: model.ImageTypePrimary,
+ Priority: model.ArtworkPriorityScan,
+ })
}
}
@@ -396,6 +399,14 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)
}
}
+ // A re-imported track returns to unresolved so new embedded art is picked up lazily.
+ if len(entry.tracks) > 0 {
+ trackIDs := slice.Map(entry.tracks, func(t model.MediaFile) string { return t.ID })
+ if err := tx.Artwork(p.ctx).DeleteForItems(model.KindMediaFileArtwork, trackIDs); err != nil {
+ log.Warn(p.ctx, "Scanner: could not invalidate media_file artwork", "folder", entry.path, err)
+ }
+ }
+
// Mark all missing tracks as not available
if len(entry.missingTracks) > 0 {
err = mfRepo.MarkMissing(true, entry.missingTracks...)
@@ -415,19 +426,25 @@ func (p *phaseFolders) persistChanges(entry *folderEntry) (*folderEntry, error)
return err
}
}
+
+ // Enqueue artwork resolution for changed albums/artists. Never fails the scan.
+ // A full scan re-imports every track, so a re-import is no evidence the art changed.
+ if len(queueItems) > 0 {
+ queue := tx.ArtworkQueue(p.ctx)
+ enqueue := queue.Enqueue
+ if p.state.fullScan {
+ enqueue = queue.EnqueueIfMissing
+ }
+ if err := enqueue(queueItems...); err != nil {
+ log.Warn(p.ctx, "Scanner: could not enqueue artwork resolution", "folder", entry.path, err)
+ }
+ }
return nil
}, "scanner: persist changes")
if err != nil {
log.Error(p.ctx, "Scanner: Error persisting changes to DB", "folder", entry.path, err)
}
- // Pre-cache artwork after the transaction commits successfully
- if err == nil {
- for _, artID := range artworkIDs {
- entry.job.cw.PreCache(artID)
- }
- }
-
return entry, err
}
diff --git a/scanner/phase_4_playlists.go b/scanner/phase_4_playlists.go
index 8ba014235..baa8b749a 100644
--- a/scanner/phase_4_playlists.go
+++ b/scanner/phase_4_playlists.go
@@ -12,7 +12,6 @@ import (
ppl "github.com/google/go-pipeline/pkg/pipeline"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
@@ -24,18 +23,16 @@ type phasePlaylists struct {
scanState *scanState
ds model.DataStore
pls playlists.Playlists
- cw artwork.CacheWarmer
refreshed atomic.Uint32
pendingImport bool
}
-func createPhasePlaylists(ctx context.Context, scanState *scanState, ds model.DataStore, pls playlists.Playlists, cw artwork.CacheWarmer) *phasePlaylists {
+func createPhasePlaylists(ctx context.Context, scanState *scanState, ds model.DataStore, pls playlists.Playlists) *phasePlaylists {
return &phasePlaylists{
ctx: ctx,
scanState: scanState,
ds: ds,
pls: pls,
- cw: cw,
}
}
@@ -148,7 +145,11 @@ func (p *phasePlaylists) processPlaylistsInFolder(folder *model.Folder) (*model.
} else {
log.Debug("Scanner: Imported playlist", "name", pls.Name, "lastUpdated", pls.UpdatedAt, "path", pls.Path, "numTracks", len(pls.Tracks), "elapsed", time.Since(started))
}
- p.cw.PreCache(pls.CoverArtID())
+ item := model.ArtworkQueueItem{ItemKind: model.KindPlaylistArtwork.Prefix(), ItemID: pls.ID, ImageType: model.ImageTypePrimary,
+ Priority: model.ArtworkPriorityScan}
+ if err := p.ds.ArtworkQueue(p.ctx).Enqueue(item); err != nil {
+ log.Warn(p.ctx, "Scanner: could not enqueue playlist artwork", "id", pls.ID, err)
+ }
p.refreshed.Add(1)
}
return folder, nil
diff --git a/scanner/phase_4_playlists_test.go b/scanner/phase_4_playlists_test.go
index 49ffc7fb7..93ec1a36d 100644
--- a/scanner/phase_4_playlists_test.go
+++ b/scanner/phase_4_playlists_test.go
@@ -10,7 +10,6 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/tests"
@@ -27,7 +26,6 @@ var _ = Describe("phasePlaylists", func() {
folderRepo *mockFolderRepository
ds *tests.MockDataStore
pls *mockPlaylists
- cw artwork.CacheWarmer
)
var userRepo *tests.MockedUserRepo
@@ -48,9 +46,8 @@ var _ = Describe("phasePlaylists", func() {
MockedProperty: propRepo,
}
pls = &mockPlaylists{}
- cw = artwork.NoopCacheWarmer()
state = &scanState{}
- phase = createPhasePlaylists(ctx, state, ds, pls, cw)
+ phase = createPhasePlaylists(ctx, state, ds, pls)
})
Describe("description", func() {
@@ -193,6 +190,29 @@ var _ = Describe("phasePlaylists", func() {
Expect(phase.refreshed.Load()).To(Equal(uint32(2)))
})
+ It("enqueues artwork resolution for the imported playlist", func() {
+ libPath := GinkgoT().TempDir()
+ folder := &model.Folder{LibraryPath: libPath, Path: "path/to", Name: "folder"}
+ _ = os.MkdirAll(folder.AbsolutePath(), 0755)
+
+ file1 := filepath.Join(folder.AbsolutePath(), "playlist1.m3u")
+ _ = os.WriteFile(file1, []byte{}, 0600)
+
+ pls.On("ImportFromFolder", mock.Anything, folder, "playlist1.m3u").
+ Return(&model.Playlist{ID: "pl1"}, nil)
+
+ _, err := phase.processPlaylistsInFolder(folder)
+ Expect(err).ToNot(HaveOccurred())
+
+ queued, err := ds.ArtworkQueue(ctx).DequeueBatch(10)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(queued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "pl"),
+ HaveField("ItemID", "pl1"),
+ HaveField("Priority", model.ArtworkPriorityScan),
+ )))
+ })
+
It("reports an error if there is an error reading files", func() {
tests.SkipOnWindows("relies on Unix /etc filesystem")
progress := make(chan *ProgressInfo)
diff --git a/scanner/scanner.go b/scanner/scanner.go
index 27e2b19d2..29a1f9b4e 100644
--- a/scanner/scanner.go
+++ b/scanner/scanner.go
@@ -11,7 +11,6 @@ import (
ppl "github.com/google/go-pipeline/pkg/pipeline"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
@@ -21,7 +20,6 @@ import (
type scannerImpl struct {
ds model.DataStore
- cw artwork.CacheWarmer
pls playlists.Playlists
}
@@ -136,7 +134,7 @@ func (s *scannerImpl) scanFolders(ctx context.Context, fullScan bool, targets []
err = run.Sequentially(
// Phase 1: Scan all libraries and import new/updated files
- runPhase[*folderEntry](ctx, 1, createPhaseFolders(ctx, &state, s.ds, s.cw)),
+ runPhase[*folderEntry](ctx, 1, createPhaseFolders(ctx, &state, s.ds)),
// Phase 2: Process missing files, checking for moves
runPhase[*missingTracks](ctx, 2, createPhaseMissingTracks(ctx, &state, s.ds)),
@@ -147,7 +145,7 @@ func (s *scannerImpl) scanFolders(ctx context.Context, fullScan bool, targets []
runPhase[*model.Album](ctx, 3, createPhaseRefreshAlbums(ctx, &state, s.ds)),
// Phase 4: Import/update playlists
- runPhase[*model.Folder](ctx, 4, createPhasePlaylists(ctx, &state, s.ds, s.pls, s.cw)),
+ runPhase[*model.Folder](ctx, 4, createPhasePlaylists(ctx, &state, s.ds, s.pls)),
),
// Final Steps (cannot be parallelized):
@@ -155,6 +153,9 @@ func (s *scannerImpl) scanFolders(ctx context.Context, fullScan bool, targets []
// Run GC if there were any changes (Remove dangling tracks, empty albums and artists, and orphan annotations)
s.runGC(ctx, &state),
+ // Queue artwork for entities that never resolved (after GC, so nothing dangling is queued)
+ s.runEnqueueMissingArtwork(ctx, &state),
+
// Refresh artist and tags stats
s.runRefreshStats(ctx, &state),
@@ -251,6 +252,29 @@ func (s *scannerImpl) runGC(ctx context.Context, state *scanState) func() error
}
}
+// runEnqueueMissingArtwork is the safety net for entities phase 1 never enqueued.
+func (s *scannerImpl) runEnqueueMissingArtwork(ctx context.Context, state *scanState) func() error {
+ return func() error {
+ if !state.changesDetected.Load() {
+ log.Debug(ctx, "Scanner: No changes detected, skipping artwork enqueue")
+ return nil
+ }
+ start := time.Now()
+ queue := s.ds.ArtworkQueue(ctx)
+ var total int64
+ for _, kind := range []model.Kind{model.KindAlbumArtwork, model.KindArtistArtwork} {
+ n, err := queue.EnqueueAllMissing(kind, model.ArtworkPriorityScan)
+ if err != nil {
+ log.Error(ctx, "Scanner: Error enqueueing missing artwork", "kind", kind, err)
+ return fmt.Errorf("enqueueing missing artwork: %w", err)
+ }
+ total += n
+ }
+ log.Debug(ctx, "Scanner: Enqueued missing artwork", "items", total, "elapsed", time.Since(start))
+ return nil
+ }
+}
+
func (s *scannerImpl) runRefreshStats(ctx context.Context, state *scanState) func() error {
return func() error {
if !state.changesDetected.Load() {
diff --git a/scanner/scanner_benchmark_test.go b/scanner/scanner_benchmark_test.go
index 8f0dcd340..ca1064631 100644
--- a/scanner/scanner_benchmark_test.go
+++ b/scanner/scanner_benchmark_test.go
@@ -12,7 +12,6 @@ import (
"github.com/dustin/go-humanize"
"github.com/google/uuid"
"github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playlists"
@@ -40,8 +39,8 @@ func BenchmarkScan(b *testing.B) {
ds := persistence.New(db.Db())
conf.Server.DevExternalScanner = false
- s := scanner.New(context.Background(), ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
+ s := scanner.New(context.Background(), ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
fs := storagetest.FakeFS{}
storagetest.Register("fake", &fs)
diff --git a/scanner/scanner_multilibrary_test.go b/scanner/scanner_multilibrary_test.go
index 3ae50933c..c0d5d4ece 100644
--- a/scanner/scanner_multilibrary_test.go
+++ b/scanner/scanner_multilibrary_test.go
@@ -11,7 +11,6 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playlists"
@@ -78,8 +77,8 @@ var _ = Describe("Scanner - Multi-Library", Ordered, func() {
}
Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())
- s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
+ s = scanner.New(ctx, ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
// Create two test libraries (let DB auto-assign IDs)
lib1 = model.Library{Name: "Rock Collection", Path: "rock:///music"}
diff --git a/scanner/scanner_selective_test.go b/scanner/scanner_selective_test.go
index 17772bf9d..acaa8f850 100644
--- a/scanner/scanner_selective_test.go
+++ b/scanner/scanner_selective_test.go
@@ -10,7 +10,6 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playlists"
@@ -66,8 +65,8 @@ var _ = Describe("ScanFolders", Ordered, func() {
}
Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())
- s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
+ s = scanner.New(ctx, ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
lib = model.Library{ID: 1, Name: "Fake Library", Path: "fake:///music"}
Expect(ds.Library(ctx).Put(&lib)).To(Succeed())
diff --git a/scanner/scanner_test.go b/scanner/scanner_test.go
index cc3720717..6098cbd66 100644
--- a/scanner/scanner_test.go
+++ b/scanner/scanner_test.go
@@ -13,7 +13,6 @@ import (
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
"github.com/navidrome/navidrome/consts"
- "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playlists"
@@ -86,8 +85,8 @@ var _ = Describe("Scanner", Ordered, func() {
}
Expect(ds.User(ctx).Put(&adminUser)).To(Succeed())
- s = scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
+ s = scanner.New(ctx, ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
lib = model.Library{ID: 1, Name: "Fake Library", Path: "fake:///music"}
Expect(ds.Library(ctx).Put(&lib)).To(Succeed())
@@ -98,6 +97,22 @@ var _ = Describe("Scanner", Ordered, func() {
return err
}
+ // Stands in for the artwork worker: drains the queue and records every item as resolved,
+ // so a later scan can only queue genuine reprocessing.
+ resolveQueuedArtwork := func() []model.ArtworkQueueItem {
+ GinkgoHelper()
+ queued, err := ds.ArtworkQueue(ctx).DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ for _, it := range queued {
+ Expect(ds.Artwork(ctx).PutItemArtwork(&model.ItemArtwork{
+ ItemKind: it.ItemKind, ItemID: it.ItemID, ImageType: it.ImageType,
+ Hash: "resolved", Source: "embedded", UpdatedAt: time.Now(),
+ })).To(Succeed())
+ Expect(ds.ArtworkQueue(ctx).DeleteIfUnchanged(it.ItemKind, it.ItemID, it.ImageType, it.RetryAt)).To(Succeed())
+ }
+ return queued
+ }
+
Context("Simple library, 'artis/album/track - title.mp3'", func() {
var help, revolver func(...map[string]any) *fstest.MapFile
var fsys storagetest.FakeFS
@@ -152,6 +167,40 @@ var _ = Describe("Scanner", Ordered, func() {
HaveField("SongCount", Equal(4)),
))
})
+ It("should enqueue artwork resolution for the scanned albums and artists", func() {
+ Expect(runScanner(ctx, true)).To(Succeed())
+
+ albums, _ := ds.Album(ctx).GetAll()
+ artists, _ := ds.Artist(ctx).GetAll(model.QueryOptions{Filters: squirrel.NotEq{"name": consts.UnknownArtist}})
+ queued, err := ds.ArtworkQueue(ctx).DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+
+ for _, al := range albums {
+ Expect(queued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "al"),
+ HaveField("ItemID", al.ID),
+ HaveField("Priority", model.ArtworkPriorityScan),
+ )))
+ }
+ for _, ar := range artists {
+ Expect(queued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "ar"),
+ HaveField("ItemID", ar.ID),
+ HaveField("Priority", model.ArtworkPriorityScan),
+ )))
+ }
+ })
+ It("should not re-enqueue already resolved artwork on a repeat full scan", func() {
+ Expect(runScanner(ctx, true)).To(Succeed())
+
+ Expect(resolveQueuedArtwork()).ToNot(BeEmpty())
+
+ Expect(runScanner(ctx, true)).To(Succeed())
+
+ requeued, err := ds.ArtworkQueue(ctx).DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(requeued).To(BeEmpty())
+ })
})
When("a file was changed", func() {
It("should update the media_file", func() {
@@ -169,6 +218,25 @@ var _ = Describe("Scanner", Ordered, func() {
Expect(mf[0].Tags).To(HaveKeyWithValue(model.TagName("barcode"), []string{"123"}))
})
+ It("should re-enqueue the album artwork even though it already resolved", func() {
+ tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")
+ Expect(runScanner(ctx, true)).To(Succeed())
+
+ resolveQueuedArtwork()
+
+ fsys.UpdateTags("The Beatles/Help!/01 - Help!.mp3", _t{"producer": "George Martin"})
+ Expect(runScanner(ctx, false)).To(Succeed())
+
+ albums, err := ds.Album(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"album.name": "Help!"}})
+ Expect(err).ToNot(HaveOccurred())
+ requeued, err := ds.ArtworkQueue(ctx).DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(requeued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "al"),
+ HaveField("ItemID", albums[0].ID),
+ )))
+ })
+
It("should update the album", func() {
tests.SkipOnWindows("path separator bug (#TBD-path-sep-scanner)")
Expect(runScanner(ctx, true)).To(Succeed())
@@ -187,6 +255,26 @@ var _ = Describe("Scanner", Ordered, func() {
Expect(albums[0].Participants.First(model.RoleProducer).Name).To(Equal("George Martin"))
Expect(albums[0].SongCount).To(Equal(3))
})
+
+ It("invalidates the media_file artwork state so new embedded art is picked up lazily", func() {
+ Expect(runScanner(ctx, true)).To(Succeed())
+
+ mf, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"title": "Help!"}})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(mf).ToNot(BeEmpty())
+ trackID := mf[0].ID
+
+ Expect(ds.Artwork(ctx).PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "mf", ItemID: trackID, ImageType: model.ImageTypePrimary,
+ Source: "embedded", Hash: "stalehash",
+ })).To(Succeed())
+
+ fsys.UpdateTags("The Beatles/Help!/01 - Help!.mp3", _t{"comment": "reimport"})
+ Expect(runScanner(ctx, true)).To(Succeed())
+
+ _, err = ds.Artwork(ctx).GetItemArtwork(model.KindMediaFileArtwork, trackID, model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+ })
})
})
diff --git a/server/imghttp/headers.go b/server/imghttp/headers.go
new file mode 100644
index 000000000..9308bcdab
--- /dev/null
+++ b/server/imghttp/headers.go
@@ -0,0 +1,67 @@
+// Package imghttp holds the HTTP caching contract shared by the subsonic, public, and jellyfin
+// image handlers, so they apply identical headers without importing each other.
+package imghttp
+
+import (
+ "net/http"
+ "strings"
+
+ "github.com/navidrome/navidrome/core/artwork"
+)
+
+// WriteImageHeaders applies the artwork caching contract and reports whether a 304 was written
+// (the caller must then not write a body). requestedHash is the hash the client asserted, or "".
+func WriteImageHeaders(w http.ResponseWriter, r *http.Request, img *artwork.Image, requestedHash string) (wrote304 bool) {
+ h := w.Header()
+ // Placeholders are transient stand-ins for unresolved art: never cached, no validators.
+ if img.Placeholder {
+ h.Set("Cache-Control", "no-store")
+ return false
+ }
+
+ // The ETag versions the served representation, so a re-encoding config change invalidates a
+ // revalidating client's cache; full-size originals are their own pixel hash.
+ etag := img.ETag
+ if etag == "" {
+ etag = img.Hash
+ }
+ // An empty validator would be shared by every such response, 304ing clients that echo it back.
+ if etag != "" {
+ h.Set("ETag", `"`+etag+`"`)
+ }
+ if !img.LastUpdated.IsZero() {
+ h.Set("Last-Modified", img.LastUpdated.UTC().Format(http.TimeFormat))
+ }
+ // Immutable only when the client asked for the current pixel hash; anything else revalidates,
+ // so art that gets re-resolved is never pinned.
+ if requestedHash != "" && requestedHash == img.Hash {
+ h.Set("Cache-Control", "public, max-age=31536000, immutable")
+ } else {
+ h.Set("Cache-Control", "public, no-cache")
+ }
+
+ if etag != "" && ifNoneMatch(r.Header.Get("If-None-Match"), etag) {
+ w.WriteHeader(http.StatusNotModified)
+ return true
+ }
+ return false
+}
+
+// ifNoneMatch reports whether If-None-Match asserts hash, using RFC 9110 weak comparison.
+func ifNoneMatch(header, hash string) bool {
+ header = strings.TrimSpace(header)
+ if header == "" {
+ return false
+ }
+ if header == "*" {
+ return true
+ }
+ for tag := range strings.SplitSeq(header, ",") {
+ tag = strings.TrimSpace(tag)
+ tag = strings.TrimPrefix(tag, "W/")
+ if strings.Trim(tag, `"`) == hash {
+ return true
+ }
+ }
+ return false
+}
diff --git a/server/imghttp/headers_test.go b/server/imghttp/headers_test.go
new file mode 100644
index 000000000..2e8313faf
--- /dev/null
+++ b/server/imghttp/headers_test.go
@@ -0,0 +1,117 @@
+package imghttp_test
+
+import (
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "time"
+
+ "github.com/navidrome/navidrome/core/artwork"
+ "github.com/navidrome/navidrome/server/imghttp"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+const testHash = "0123456789abcdef"
+const testRepTag = testHash + ".300.false.q75"
+
+var lastMod = time.Date(2024, 1, 2, 3, 4, 5, 0, time.UTC)
+
+func found() *artwork.Image {
+ return &artwork.Image{
+ ReadCloser: io.NopCloser(strings.NewReader("IMG")),
+ Hash: testHash,
+ LastUpdated: lastMod,
+ }
+}
+
+func placeholder() *artwork.Image {
+ return &artwork.Image{ReadCloser: io.NopCloser(strings.NewReader("PH")), Placeholder: true}
+}
+
+// A re-encoded response carries a representation ETag distinct from the pixel hash, so the
+// validator versions with the encode settings.
+func resized() *artwork.Image {
+ return &artwork.Image{
+ ReadCloser: io.NopCloser(strings.NewReader("IMG")),
+ Hash: testHash,
+ ETag: testRepTag,
+ LastUpdated: lastMod,
+ }
+}
+
+func unvalidated() *artwork.Image {
+ return &artwork.Image{ReadCloser: io.NopCloser(strings.NewReader("IMG")), LastUpdated: lastMod}
+}
+
+var _ = Describe("WriteImageHeaders", func() {
+ type testCase struct {
+ img *artwork.Image
+ requestedHash string
+ ifNoneMatch string
+ want304 bool
+ wantCache string
+ wantETag string
+ wantLastMod bool
+ }
+
+ DescribeTable("applies the artwork caching contract",
+ func(c testCase) {
+ w := httptest.NewRecorder()
+ r := httptest.NewRequest("GET", "/img", nil)
+ if c.ifNoneMatch != "" {
+ r.Header.Set("If-None-Match", c.ifNoneMatch)
+ }
+
+ Expect(imghttp.WriteImageHeaders(w, r, c.img, c.requestedHash)).To(Equal(c.want304))
+
+ h := w.Header()
+ Expect(h.Get("Cache-Control")).To(Equal(c.wantCache))
+ Expect(h.Get("ETag")).To(Equal(c.wantETag))
+ if c.img.Placeholder {
+ Expect(h.Get("ETag")).To(BeEmpty(), "placeholder must not set an ETag")
+ Expect(h.Get("Last-Modified")).To(BeEmpty(), "placeholder must not set Last-Modified")
+ }
+ Expect(h.Get("Last-Modified") != "").To(Equal(c.wantLastMod))
+ if c.want304 {
+ Expect(w.Code).To(Equal(http.StatusNotModified))
+ Expect(w.Body.Len()).To(BeZero(), "a 304 must have an empty body")
+ }
+ },
+ Entry("placeholder is never cached and carries no validators",
+ testCase{img: placeholder(), wantCache: "no-store"}),
+ Entry("found with matching requested hash is immutable",
+ testCase{img: found(), requestedHash: testHash, wantCache: "public, max-age=31536000, immutable", wantETag: `"` + testHash + `"`, wantLastMod: true}),
+ Entry("found with bare id revalidates via no-cache",
+ testCase{img: found(), wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),
+ Entry("found with mismatched requested hash revalidates",
+ testCase{img: found(), requestedHash: "ffffffffffffffff", wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),
+ Entry("resized keeps pixel-hash immutable but serves the representation ETag",
+ testCase{img: resized(), requestedHash: testHash, wantCache: "public, max-age=31536000, immutable", wantETag: `"` + testRepTag + `"`, wantLastMod: true}),
+ Entry("resized 304s on the representation ETag, not the pixel hash",
+ testCase{img: resized(), ifNoneMatch: `"` + testRepTag + `"`, want304: true, wantCache: "public, no-cache", wantETag: `"` + testRepTag + `"`, wantLastMod: true}),
+ Entry("resized does not 304 on a stale pixel-hash validator (config changed)",
+ testCase{img: resized(), ifNoneMatch: `"` + testHash + `"`, want304: false, wantCache: "public, no-cache", wantETag: `"` + testRepTag + `"`, wantLastMod: true}),
+ Entry("If-None-Match matching the hash yields 304",
+ testCase{img: found(), requestedHash: testHash, ifNoneMatch: `"` + testHash + `"`, want304: true, wantCache: "public, max-age=31536000, immutable", wantETag: `"` + testHash + `"`, wantLastMod: true}),
+ Entry("weak If-None-Match matches (weak comparison)",
+ testCase{img: found(), ifNoneMatch: `W/"` + testHash + `"`, want304: true, wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),
+ Entry("If-None-Match with multiple values matches one",
+ testCase{img: found(), ifNoneMatch: `"deadbeefdeadbeef", W/"` + testHash + `", "cafecafecafecafe"`, want304: true, wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),
+ Entry("If-None-Match star matches any current representation",
+ testCase{img: found(), ifNoneMatch: "*", want304: true, wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),
+ Entry("non-matching If-None-Match serves body",
+ testCase{img: found(), ifNoneMatch: `"deadbeefdeadbeef"`, want304: false, wantCache: "public, no-cache", wantETag: `"` + testHash + `"`, wantLastMod: true}),
+ Entry("placeholder ignores If-None-Match and never 304s",
+ testCase{img: placeholder(), ifNoneMatch: "*", want304: false, wantCache: "no-store"}),
+
+ // With no validator, an emitted ETag would be the same empty tag on every such response,
+ // and matching it would 304 changed bytes.
+ Entry("omits the ETag entirely when there is no validator",
+ testCase{img: unvalidated(), wantCache: "public, no-cache", wantLastMod: true}),
+ Entry("never 304s an empty validator echoed back by the client",
+ testCase{img: unvalidated(), ifNoneMatch: `""`, want304: false,
+ wantCache: "public, no-cache", wantLastMod: true}),
+ )
+})
diff --git a/server/imghttp/imghttp_suite_test.go b/server/imghttp/imghttp_suite_test.go
new file mode 100644
index 000000000..7a747db5b
--- /dev/null
+++ b/server/imghttp/imghttp_suite_test.go
@@ -0,0 +1,17 @@
+package imghttp_test
+
+import (
+ "testing"
+
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+func TestImgHTTP(t *testing.T) {
+ tests.Init(t, false)
+ log.SetLevel(log.LevelFatal)
+ RegisterFailHandler(Fail)
+ RunSpecs(t, "ImgHTTP Suite")
+}
diff --git a/server/jellyfin/dto/blurhash.go b/server/jellyfin/dto/blurhash.go
deleted file mode 100644
index aaf6ff2af..000000000
--- a/server/jellyfin/dto/blurhash.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package dto
-
-import "hash/fnv"
-
-// base83Alphabet is the blurhash spec's base83 encoding alphabet; order is part of the spec.
-const base83Alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~"
-
-// base83 encodes value as a fixed-width, big-endian base83 string of the given length.
-func base83(value, length int) string {
- b := make([]byte, length)
- for i := 1; i <= length; i++ {
- digit := (value / pow83(length-i)) % 83
- b[i-1] = base83Alphabet[digit]
- }
- return string(b)
-}
-
-func pow83(n int) int {
- result := 1
- for range n {
- result *= 83
- }
- return result
-}
-
-// blurHash returns a valid 6-char blurhash for a solid color derived from seed. Finamp only needs a
-// well-formed, per-tag-stable value (it uses this as a download de-dup key and blur placeholder), so
-// a solid color unique to the tag satisfies both without decoding cover art.
-func blurHash(seed string) string {
- h := fnv.New32a()
- _, _ = h.Write([]byte(seed))
- sum := h.Sum(nil)
- r, g, b := int(sum[0]), int(sum[1]), int(sum[2])
- dc := (r << 16) | (g << 8) | b
- return "00" + base83(dc, 4)
-}
diff --git a/server/jellyfin/dto/blurhash_test.go b/server/jellyfin/dto/blurhash_test.go
deleted file mode 100644
index a6e36131d..000000000
--- a/server/jellyfin/dto/blurhash_test.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package dto
-
-import (
- "strings"
-
- . "github.com/onsi/ginkgo/v2"
- . "github.com/onsi/gomega"
-)
-
-var _ = Describe("blurHash", func() {
- It("returns a 6-char valid blurhash starting with the 1x1 component prefix", func() {
- h := blurHash("x")
- Expect(h).To(HaveLen(6))
- Expect(h).To(HavePrefix("00"))
- for _, c := range h {
- Expect(strings.ContainsRune(base83Alphabet, c)).To(BeTrue(), "unexpected char %q", c)
- }
- })
-
- It("is deterministic for the same seed", func() {
- Expect(blurHash("cover-tag-1")).To(Equal(blurHash("cover-tag-1")))
- })
-
- It("differs for different seeds", func() {
- Expect(blurHash("cover-tag-1")).ToNot(Equal(blurHash("cover-tag-2")))
- })
-})
diff --git a/server/jellyfin/dto/dto.go b/server/jellyfin/dto/dto.go
index 9b2c35c69..5a2a4c2b1 100644
--- a/server/jellyfin/dto/dto.go
+++ b/server/jellyfin/dto/dto.go
@@ -81,12 +81,15 @@ type BaseItemDto struct {
// ImageBlurHashes is keyed by image type (e.g. "Primary") then image tag. Finamp uses it as a
// de-dup key for image downloads (and a placeholder); absent, it warns the server isn't
// calculating blurhashes.
- ImageBlurHashes map[string]map[string]string `json:"ImageBlurHashes,omitempty"`
- BackdropImageTags []string `json:"BackdropImageTags"`
- UserData *UserItemDataDto `json:"UserData,omitempty"`
- MediaSources []MediaSourceInfo `json:"MediaSources,omitempty"`
- Container string `json:"Container,omitempty"`
- CanDownload bool `json:"CanDownload"`
+ ImageBlurHashes map[string]map[string]string `json:"ImageBlurHashes,omitempty"`
+ // PrimaryImageAspectRatio is width/height of the Primary image, attached only when the request's
+ // Fields asks for it; omitted rather than guessed, since a wrong ratio mis-shapes a placeholder.
+ PrimaryImageAspectRatio *float64 `json:"PrimaryImageAspectRatio,omitempty"`
+ BackdropImageTags []string `json:"BackdropImageTags"`
+ UserData *UserItemDataDto `json:"UserData,omitempty"`
+ MediaSources []MediaSourceInfo `json:"MediaSources,omitempty"`
+ Container string `json:"Container,omitempty"`
+ CanDownload bool `json:"CanDownload"`
}
// PlaylistUserPermissions is the response shape for GET /Playlists/{id}/Users(/{userId}), which
diff --git a/server/jellyfin/dto/mappers.go b/server/jellyfin/dto/mappers.go
index 444a25cac..352fce11d 100644
--- a/server/jellyfin/dto/mappers.go
+++ b/server/jellyfin/dto/mappers.go
@@ -5,6 +5,7 @@ import (
"fmt"
"time"
+ "github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/utils/slice"
)
@@ -192,31 +193,68 @@ func SongToBaseItem(mf model.MediaFile, fields Fields) BaseItemDto {
} else if mf.Genre != "" {
item.Genres = []string{mf.Genre}
}
- // Finamp resolves song art via AlbumId + a non-empty AlbumPrimaryImageTag.
- if mf.AlbumID != "" {
- item.AlbumPrimaryImageTag = mf.AlbumID
- item.ImageBlurHashes = map[string]map[string]string{"Primary": {mf.AlbumID: blurHash(mf.AlbumID)}}
+ // Clients prefer ImageTags.Primary over AlbumId, so a track's own cover must win here.
+ if mf.ImageHash != "" && mf.ImageHash != mf.AlbumImage.ImageHash {
+ tag, blurs, ratio := primaryImage(mf.ItemImage, mf.ID, fields)
+ item.ImageTags = map[string]string{"Primary": tag}
+ item.ImageBlurHashes = blurs
+ item.PrimaryImageAspectRatio = ratio
+ } else if embeddedArtPending(mf) {
+ // Nothing enqueues media files: advertising the id is what makes a client ask, and that
+ // request is what extracts the embedded art and queues the track.
+ item.ImageTags = map[string]string{"Primary": mf.ID}
+ } else if mf.AlbumID != "" {
+ if tag, blurs, ratio := primaryImage(mf.AlbumImage, mf.AlbumID, fields); tag != "" {
+ item.AlbumPrimaryImageTag = tag
+ item.ImageBlurHashes = blurs
+ item.PrimaryImageAspectRatio = ratio
+ }
}
return item
}
+func embeddedArtPending(mf model.MediaFile) bool {
+ return mf.HasCoverArt && conf.Server.EnableMediaFileCoverArt &&
+ mf.ImageHash == "" && !mf.ItemImage.ImageAbsent
+}
+
+// primaryImage never fakes a blurhash: clients key their cover cache on the value, which would
+// pin a stale cover forever.
+func primaryImage(img model.ItemImage, fallback string, fields Fields) (tag string, blurs map[string]map[string]string, ratio *float64) {
+ if img.ImageAbsent {
+ return "", nil, nil
+ }
+ tag = cmp.Or(img.ImageHash, fallback)
+ if img.BlurHash != "" {
+ blurs = map[string]map[string]string{"Primary": {tag: img.BlurHash}}
+ }
+ if fields.Has("PrimaryImageAspectRatio") {
+ ratio = img.AspectRatio()
+ }
+ return tag, blurs, ratio
+}
+
func AlbumToBaseItem(al model.Album, fields Fields) BaseItemDto {
+ tag, blurs, ratio := primaryImage(al.ItemImage, al.ID, fields)
item := BaseItemDto{
- Name: al.Name,
- Id: EncodeID(al.ID),
- Type: "MusicAlbum",
- IsFolder: true,
- ParentId: EncodeID(al.AlbumArtistID),
- AlbumArtist: al.AlbumArtist,
- Album: al.Name,
- ChildCount: new(al.SongCount),
- SongCount: new(al.SongCount),
- RunTimeTicks: TicksFromSeconds(al.Duration),
- DateCreated: jellyfinDate(&al.CreatedAt),
- ImageTags: map[string]string{"Primary": al.ID},
- ImageBlurHashes: map[string]map[string]string{"Primary": {al.ID: blurHash(al.ID)}},
- BackdropImageTags: []string{},
- UserData: UserData(al.Annotations, al.ID),
+ Name: al.Name,
+ Id: EncodeID(al.ID),
+ Type: "MusicAlbum",
+ IsFolder: true,
+ ParentId: EncodeID(al.AlbumArtistID),
+ AlbumArtist: al.AlbumArtist,
+ Album: al.Name,
+ ChildCount: new(al.SongCount),
+ SongCount: new(al.SongCount),
+ RunTimeTicks: TicksFromSeconds(al.Duration),
+ DateCreated: jellyfinDate(&al.CreatedAt),
+ ImageBlurHashes: blurs,
+ PrimaryImageAspectRatio: ratio,
+ BackdropImageTags: []string{},
+ UserData: UserData(al.Annotations, al.ID),
+ }
+ if tag != "" {
+ item.ImageTags = map[string]string{"Primary": tag}
}
if al.AlbumArtistID != "" {
item.AlbumArtists = []NameGuidPair{{Name: al.AlbumArtist, Id: EncodeID(al.AlbumArtistID)}}
@@ -246,20 +284,25 @@ func AlbumToBaseItem(al model.Album, fields Fields) BaseItemDto {
return item
}
-func ArtistToBaseItem(ar model.Artist) BaseItemDto {
- return BaseItemDto{
- Name: ar.Name,
- Id: EncodeID(ar.ID),
- Type: "MusicArtist",
- IsFolder: true,
- AlbumCount: new(ar.AlbumCount),
- SongCount: new(ar.SongCount),
- DateCreated: jellyfinDate(ar.CreatedAt),
- ImageTags: map[string]string{"Primary": ar.ID},
- ImageBlurHashes: map[string]map[string]string{"Primary": {ar.ID: blurHash(ar.ID)}},
- BackdropImageTags: []string{},
- UserData: UserData(ar.Annotations, ar.ID),
+func ArtistToBaseItem(ar model.Artist, fields Fields) BaseItemDto {
+ tag, blurs, ratio := primaryImage(ar.ItemImage, ar.ID, fields)
+ item := BaseItemDto{
+ Name: ar.Name,
+ Id: EncodeID(ar.ID),
+ Type: "MusicArtist",
+ IsFolder: true,
+ AlbumCount: new(ar.AlbumCount),
+ SongCount: new(ar.SongCount),
+ DateCreated: jellyfinDate(ar.CreatedAt),
+ ImageBlurHashes: blurs,
+ PrimaryImageAspectRatio: ratio,
+ BackdropImageTags: []string{},
+ UserData: UserData(ar.Annotations, ar.ID),
}
+ if tag != "" {
+ item.ImageTags = map[string]string{"Primary": tag}
+ }
+ return item
}
func GenreToBaseItem(g model.Genre) BaseItemDto {
@@ -282,26 +325,28 @@ func StudioToBaseItem(t model.Tag) BaseItemDto {
}
// PlaylistToBaseItem maps a playlist to a Playlist BaseItemDto.
-func PlaylistToBaseItem(p model.Playlist) BaseItemDto {
- // Finamp caches covers keyed by blurHash, so the tag (and blurhash) must change with the cover.
- // UpdatedAt versions it (Put bumps it on upload); over-invalidation only costs a refetch.
- tag := fmt.Sprintf("%s-%x", p.ID, p.UpdatedAt.UnixMilli())
- return BaseItemDto{
+func PlaylistToBaseItem(p model.Playlist, fields Fields) BaseItemDto {
+ tag, blurs, ratio := primaryImage(p.ItemImage, p.ID, fields)
+ item := BaseItemDto{
Name: p.Name,
Id: EncodeID(p.ID),
Type: "Playlist",
// Synthetic path: Jellify only surfaces playlists whose Path contains "data" (real Jellyfin
// stores them under its data folder), so without this its Playlists tab hides them all.
- Path: "/data/playlists/" + p.ID,
- IsFolder: true,
- MediaType: "Audio",
- ChildCount: new(p.SongCount),
- RunTimeTicks: TicksFromSeconds(p.Duration),
- ImageTags: map[string]string{"Primary": tag},
- ImageBlurHashes: map[string]map[string]string{"Primary": {tag: blurHash(tag)}},
- BackdropImageTags: []string{},
- UserData: UserData(p.Annotations, p.ID),
+ Path: "/data/playlists/" + p.ID,
+ IsFolder: true,
+ MediaType: "Audio",
+ ChildCount: new(p.SongCount),
+ RunTimeTicks: TicksFromSeconds(p.Duration),
+ ImageBlurHashes: blurs,
+ PrimaryImageAspectRatio: ratio,
+ BackdropImageTags: []string{},
+ UserData: UserData(p.Annotations, p.ID),
+ }
+ if tag != "" {
+ item.ImageTags = map[string]string{"Primary": tag}
}
+ return item
}
// LyricDtoFromLyrics maps one lyric track to Jellyfin's LyricDto. Clients infer synced-vs-plain
diff --git a/server/jellyfin/dto/mappers_test.go b/server/jellyfin/dto/mappers_test.go
index c11f38eaf..a7b381c5c 100644
--- a/server/jellyfin/dto/mappers_test.go
+++ b/server/jellyfin/dto/mappers_test.go
@@ -4,6 +4,8 @@ import (
"encoding/json"
"time"
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
"github.com/navidrome/navidrome/model"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
@@ -34,8 +36,8 @@ var _ = Describe("mappers", func() {
Expect(item.UserData.Played).To(BeTrue())
Expect(item.UserData.Key).To(Equal(EncodeID("song-1")))
Expect(item.UserData.ItemId).To(Equal(EncodeID("song-1")))
- Expect(item.ImageBlurHashes["Primary"]).To(HaveKey(item.AlbumPrimaryImageTag))
- Expect(item.ImageBlurHashes["Primary"][item.AlbumPrimaryImageTag]).To(HaveLen(6))
+ Expect(item.AlbumPrimaryImageTag).To(Equal("alb-1"))
+ Expect(item.ImageBlurHashes).To(BeNil())
Expect(item.Genres).To(Equal([]string{"genre 1", "genre 2"}))
Expect(item.GenreItems).To(Equal([]NameGuidPair{{Id: EncodeID("1"), Name: "genre 1"}, {Id: EncodeID("2"), Name: "genre 2"}}))
})
@@ -254,8 +256,8 @@ var _ = Describe("mappers", func() {
Expect(item.ArtistItems).To(Equal(item.AlbumArtists))
Expect(*item.ProductionYear).To(Equal(1999))
Expect(*item.ChildCount).To(Equal(10))
- Expect(item.ImageBlurHashes["Primary"]).To(HaveKey(item.ImageTags["Primary"]))
- Expect(item.ImageBlurHashes["Primary"][item.ImageTags["Primary"]]).To(HaveLen(6))
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "alb-1"))
+ Expect(item.ImageBlurHashes).To(BeNil())
Expect(item.Genres).To(Equal([]string{"genre 1", "genre 2"}))
Expect(item.GenreItems).To(Equal([]NameGuidPair{{Id: EncodeID("1"), Name: "genre 1"}, {Id: EncodeID("2"), Name: "genre 2"}}))
})
@@ -288,9 +290,74 @@ var _ = Describe("mappers", func() {
Expect(string(b)).ToNot(ContainSubstring("NormalizationGain"))
})
+ Describe("PrimaryImageAspectRatio", func() {
+ nonSquare := func() model.Album {
+ al := model.Album{ID: "al1", Name: "Album"}
+ al.ImageHash, al.ImageWidth, al.ImageHeight = "abc", 1200, 800
+ return al
+ }
+
+ It("is omitted unless the request asks for it", func() {
+ Expect(AlbumToBaseItem(nonSquare(), nil).PrimaryImageAspectRatio).To(BeNil())
+ b, err := json.Marshal(AlbumToBaseItem(nonSquare(), nil))
+ Expect(err).ToNot(HaveOccurred())
+ Expect(string(b)).ToNot(ContainSubstring("PrimaryImageAspectRatio"))
+ })
+
+ It("carries the real ratio when asked", func() {
+ item := AlbumToBaseItem(nonSquare(), ParseFields("PrimaryImageAspectRatio"))
+ Expect(*item.PrimaryImageAspectRatio).To(BeNumerically("~", 1.5, 0.0001))
+ })
+
+ It("is omitted when the dimensions are unknown, rather than guessing square", func() {
+ al := model.Album{ID: "al1", Name: "Album"}
+ al.ImageHash = "abc"
+ item := AlbumToBaseItem(al, ParseFields("PrimaryImageAspectRatio"))
+ Expect(item.PrimaryImageAspectRatio).To(BeNil())
+ })
+
+ It("is omitted when the item has no image at all", func() {
+ al := model.Album{ID: "al1", Name: "Album"}
+ al.ImageAbsent = true
+ al.ImageWidth, al.ImageHeight = 1200, 800
+ item := AlbumToBaseItem(al, ParseFields("PrimaryImageAspectRatio"))
+ Expect(item.PrimaryImageAspectRatio).To(BeNil())
+ })
+
+ It("carries the ratio for an artist", func() {
+ ar := model.Artist{ID: "ar1", Name: "Artist"}
+ ar.ImageHash, ar.ImageWidth, ar.ImageHeight = "abc", 1000, 500
+ Expect(*ArtistToBaseItem(ar, ParseFields("PrimaryImageAspectRatio")).PrimaryImageAspectRatio).
+ To(BeNumerically("~", 2.0, 0.0001))
+ })
+
+ It("carries the ratio for a playlist", func() {
+ pl := model.Playlist{ID: "pl1", Name: "Playlist"}
+ pl.ImageHash, pl.ImageWidth, pl.ImageHeight = "abc", 400, 800
+ Expect(*PlaylistToBaseItem(pl, ParseFields("PrimaryImageAspectRatio")).PrimaryImageAspectRatio).
+ To(BeNumerically("~", 0.5, 0.0001))
+ })
+
+ It("carries the ratio for a song with its own art", func() {
+ mf := model.MediaFile{ID: "mf1", Title: "Song"}
+ mf.ImageHash, mf.ImageWidth, mf.ImageHeight = "abc", 300, 600
+ Expect(*SongToBaseItem(mf, ParseFields("PrimaryImageAspectRatio")).PrimaryImageAspectRatio).
+ To(BeNumerically("~", 0.5, 0.0001))
+ })
+
+ // A track without its own art shows the album's, so the ratio has to describe that image.
+ It("uses the album's dimensions for a track falling back to album art", func() {
+ mf := model.MediaFile{ID: "mf1", Title: "Song", AlbumID: "al1"}
+ mf.AlbumImage.ImageHash, mf.AlbumImage.ImageWidth, mf.AlbumImage.ImageHeight = "abc", 1200, 800
+ item := SongToBaseItem(mf, ParseFields("PrimaryImageAspectRatio"))
+ Expect(item.AlbumPrimaryImageTag).To(Equal("abc"))
+ Expect(*item.PrimaryImageAspectRatio).To(BeNumerically("~", 1.5, 0.0001))
+ })
+ })
+
It("maps an artist to a MusicArtist folder item", func() {
ar := model.Artist{ID: "art-1", Name: "AA", AlbumCount: 2, SongCount: 20}
- item := ArtistToBaseItem(ar)
+ item := ArtistToBaseItem(ar, nil)
Expect(item.Type).To(Equal("MusicArtist"))
Expect(item.IsFolder).To(BeTrue())
Expect(item.Id).To(Equal(EncodeID("art-1")))
@@ -352,7 +419,7 @@ var _ = Describe("mappers", func() {
ID: "pl-1", Name: "Chill", SongCount: 7, Duration: 120,
Annotations: model.Annotations{Starred: true, Rating: 4, PlayCount: 2},
}
- item := PlaylistToBaseItem(p)
+ item := PlaylistToBaseItem(p, nil)
Expect(item.Type).To(Equal("Playlist"))
Expect(item.IsFolder).To(BeTrue())
Expect(item.Id).To(Equal(EncodeID("pl-1")))
@@ -363,26 +430,202 @@ var _ = Describe("mappers", func() {
Expect(item.UserData.IsFavorite).To(BeTrue())
Expect(item.UserData.PlayCount).To(Equal(2))
Expect(*item.UserData.Rating).To(Equal(8.0))
- tag := item.ImageTags["Primary"]
- Expect(tag).ToNot(BeEmpty())
- Expect(item.ImageBlurHashes["Primary"]).To(HaveKey(tag))
- Expect(item.ImageBlurHashes["Primary"][tag]).To(HaveLen(6))
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "pl-1"))
+ Expect(item.ImageBlurHashes).To(BeNil())
})
- It("changes the playlist image tag and blurhash when the playlist is updated (cover upload)", func() {
- p := model.Playlist{ID: "pl-1", Name: "Chill", UpdatedAt: time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)}
- before := PlaylistToBaseItem(p)
- p.UpdatedAt = time.Date(2026, 7, 2, 0, 0, 0, 0, time.UTC)
- after := PlaylistToBaseItem(p)
+ It("changes the playlist image tag when the cover content changes", func() {
+ p := model.Playlist{ID: "pl-1", Name: "Chill"}
+ p.ImageHash = "1111111111111111"
+ before := PlaylistToBaseItem(p, nil)
+ p.ImageHash = "2222222222222222"
+ after := PlaylistToBaseItem(p, nil)
- // Finamp caches covers keyed by blurHash, so tag and blurhash must change with the cover.
- Expect(after.ImageTags["Primary"]).ToNot(Equal(before.ImageTags["Primary"]))
- Expect(after.ImageBlurHashes["Primary"]).ToNot(Equal(before.ImageBlurHashes["Primary"]))
+ Expect(before.ImageTags["Primary"]).To(Equal("1111111111111111"))
+ Expect(after.ImageTags["Primary"]).To(Equal("2222222222222222"))
})
- It("keeps the playlist image tag stable when nothing changed", func() {
+ It("keeps the playlist image tag stable across a metadata-only edit", func() {
p := model.Playlist{ID: "pl-1", UpdatedAt: time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)}
- Expect(PlaylistToBaseItem(p).ImageTags).To(Equal(PlaylistToBaseItem(p).ImageTags))
+ p.ImageHash = "1111111111111111"
+ before := PlaylistToBaseItem(p, nil)
+ p.UpdatedAt = time.Date(2026, 7, 2, 0, 0, 0, 0, time.UTC)
+ after := PlaylistToBaseItem(p, nil)
+
+ Expect(after.ImageTags["Primary"]).To(Equal(before.ImageTags["Primary"]))
+ })
+
+ // Nothing enqueues media files, so a track's own art only resolves when a client requests it;
+ // advertising just the album image would leave that cover unreachable.
+ Describe("unresolved embedded art", func() {
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ conf.Server.EnableMediaFileCoverArt = true
+ })
+
+ It("advertises the track id so the client triggers the read-through", func() {
+ mf := model.MediaFile{ID: "mf-1", AlbumID: "alb-1", HasCoverArt: true}
+ mf.AlbumImage.ImageHash = "0123456789abcdef"
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "mf-1"))
+ Expect(item.ImageBlurHashes).To(BeNil(), "no resolved image means no blurhash to send")
+ Expect(item.AlbumPrimaryImageTag).To(BeEmpty())
+ })
+
+ It("falls back to the album when the track has no art of its own", func() {
+ mf := model.MediaFile{ID: "mf-2", AlbumID: "alb-1", HasCoverArt: false}
+ mf.AlbumImage.ImageHash = "0123456789abcdef"
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.ImageTags).To(BeEmpty())
+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))
+ })
+
+ It("falls back to the album once the track's art is known absent", func() {
+ mf := model.MediaFile{ID: "mf-3", AlbumID: "alb-1", HasCoverArt: true}
+ mf.ItemImage.ImageAbsent = true
+ mf.AlbumImage.ImageHash = "0123456789abcdef"
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.ImageTags).To(BeEmpty())
+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))
+ })
+
+ It("falls back to the album when per-track art is disabled", func() {
+ conf.Server.EnableMediaFileCoverArt = false
+ mf := model.MediaFile{ID: "mf-4", AlbumID: "alb-1", HasCoverArt: true}
+ mf.AlbumImage.ImageHash = "0123456789abcdef"
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.ImageTags).To(BeEmpty())
+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))
+ })
+ })
+
+ Describe("primary image tags", func() {
+ It("uses the content hash as the tag and emits the real blurhash", func() {
+ al := model.Album{ID: "alb-1", Name: "Album"}
+ al.ImageHash = "0123456789abcdef"
+ al.BlurHash = "LEHV6nWB2yk8"
+
+ item := AlbumToBaseItem(al, nil)
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "0123456789abcdef"))
+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("0123456789abcdef", "LEHV6nWB2yk8"))
+ })
+
+ It("omits the blurhash entirely when none was computed", func() {
+ al := model.Album{ID: "alb-2", Name: "Album"}
+ al.ImageHash = "0123456789abcdef"
+
+ item := AlbumToBaseItem(al, nil)
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "0123456789abcdef"))
+ Expect(item.ImageBlurHashes).To(BeNil(), "a synthesized blurhash pins stale covers in Finamp")
+ })
+
+ It("omits tags for known-absent artwork", func() {
+ al := model.Album{ID: "alb-3", Name: "Album"}
+ al.ImageAbsent = true
+
+ item := AlbumToBaseItem(al, nil)
+ Expect(item.ImageTags).To(BeEmpty())
+ Expect(item.ImageBlurHashes).To(BeNil())
+ })
+
+ It("falls back to the entity id while artwork is still unresolved", func() {
+ item := AlbumToBaseItem(model.Album{ID: "alb-4", Name: "Album"}, nil)
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "alb-4"))
+ Expect(item.ImageBlurHashes).To(BeNil())
+ })
+
+ It("versions an artist's tag by content hash", func() {
+ ar := model.Artist{ID: "art-1", Name: "Artist"}
+ ar.ImageHash = "fedcba9876543210"
+ ar.BlurHash = "L6PZfSi_.AyE"
+
+ item := ArtistToBaseItem(ar, nil)
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "fedcba9876543210"))
+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("fedcba9876543210", "L6PZfSi_.AyE"))
+ })
+ })
+
+ Describe("song and playlist image tags", func() {
+ It("versions a song's album tag by the album's content hash", func() {
+ mf := model.MediaFile{ID: "song-1", Title: "Song", AlbumID: "alb-1"}
+ mf.AlbumImage.ImageHash = "0123456789abcdef"
+ mf.AlbumImage.BlurHash = "LEHV6nWB2yk8"
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))
+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("0123456789abcdef", "LEHV6nWB2yk8"))
+ })
+
+ It("never synthesizes a song blurhash when the album has none", func() {
+ mf := model.MediaFile{ID: "song-2", Title: "Song", AlbumID: "alb-2"}
+ mf.AlbumImage.ImageHash = "0123456789abcdef"
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.AlbumPrimaryImageTag).To(Equal("0123456789abcdef"))
+ Expect(item.ImageBlurHashes).To(BeNil())
+ })
+
+ It("omits a song's album tag when the album art is known absent", func() {
+ mf := model.MediaFile{ID: "song-3", Title: "Song", AlbumID: "alb-3"}
+ mf.AlbumImage.ImageAbsent = true
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.AlbumPrimaryImageTag).To(BeEmpty())
+ Expect(item.ImageBlurHashes).To(BeNil())
+ })
+
+ It("versions a playlist tag by content hash instead of UpdatedAt", func() {
+ pl := model.Playlist{ID: "pl-1", Name: "Playlist"}
+ pl.ImageHash = "abcdef0123456789"
+
+ item := PlaylistToBaseItem(pl, nil)
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "abcdef0123456789"))
+ })
+ })
+
+ Describe("per-song artwork", func() {
+ It("emits the track's own Primary tag when it has distinct art", func() {
+ mf := model.MediaFile{ID: "song-own", Title: "Song", AlbumID: "alb-1"}
+ mf.ImageHash = "aaaaaaaaaaaaaaaa"
+ mf.BlurHash = "LTRACKblur"
+ mf.AlbumImage.ImageHash = "bbbbbbbbbbbbbbbb"
+ mf.AlbumImage.BlurHash = "LALBUMblur"
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.ImageTags).To(HaveKeyWithValue("Primary", "aaaaaaaaaaaaaaaa"))
+ Expect(item.ImageBlurHashes["Primary"]).To(HaveLen(1),
+ "exactly one Primary entry: Go sorts map keys, so a second entry could pair the wrong blurhash with imageId")
+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("aaaaaaaaaaaaaaaa", "LTRACKblur"))
+ })
+
+ It("falls back to the album tag when the track has no distinct art", func() {
+ mf := model.MediaFile{ID: "song-inherit", Title: "Song", AlbumID: "alb-1"}
+ mf.ImageHash = "bbbbbbbbbbbbbbbb"
+ mf.BlurHash = "LALBUMblur"
+ mf.AlbumImage.ImageHash = "bbbbbbbbbbbbbbbb"
+ mf.AlbumImage.BlurHash = "LALBUMblur"
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.ImageTags).To(BeEmpty(), "an inherited cover is the album's image, not the track's")
+ Expect(item.AlbumPrimaryImageTag).To(Equal("bbbbbbbbbbbbbbbb"))
+ Expect(item.ImageBlurHashes["Primary"]).To(HaveLen(1))
+ Expect(item.ImageBlurHashes["Primary"]).To(HaveKeyWithValue("bbbbbbbbbbbbbbbb", "LALBUMblur"))
+ })
+
+ It("omits the track tag when its own art is known absent", func() {
+ mf := model.MediaFile{ID: "song-absent", Title: "Song", AlbumID: "alb-1"}
+ mf.ImageAbsent = true
+ mf.AlbumImage.ImageAbsent = true
+
+ item := SongToBaseItem(mf, nil)
+ Expect(item.ImageTags).To(BeEmpty())
+ Expect(item.AlbumPrimaryImageTag).To(BeEmpty())
+ Expect(item.ImageBlurHashes).To(BeNil())
+ })
})
})
diff --git a/server/jellyfin/e2e/e2e_suite_test.go b/server/jellyfin/e2e/e2e_suite_test.go
index 31d98d1d9..ca1308e9e 100644
--- a/server/jellyfin/e2e/e2e_suite_test.go
+++ b/server/jellyfin/e2e/e2e_suite_test.go
@@ -33,7 +33,6 @@ import (
"strings"
"testing"
"testing/fstest"
- "time"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
@@ -327,7 +326,7 @@ func setupTestDB() {
decider,
core.NewPlayers(ds),
scrobbler.NewPlayTracker(ds, events.NoopBroker(), nil),
- playlists.NewPlaylists(ds, core.NewImageUploadService()),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)),
providerFake,
sonicSvc,
lyrics.NewLyrics(ds, nil),
@@ -406,18 +405,18 @@ type spyArtwork struct {
data []byte
}
-func (s *spyArtwork) Get(context.Context, model.ArtworkID, int, bool) (io.ReadCloser, time.Time, error) {
- return nil, time.Time{}, model.ErrNotFound
+func (s *spyArtwork) Get(context.Context, model.ArtworkID, int, bool) (*artwork.Image, error) {
+ return nil, model.ErrNotFound
}
-func (s *spyArtwork) GetOrPlaceholder(c context.Context, id string, _ int, _ bool) (io.ReadCloser, time.Time, error) {
+func (s *spyArtwork) GetOrPlaceholder(c context.Context, id string, _ int, _ bool) (*artwork.Image, error) {
s.lastID = id
s.lastCtx = c
d := s.data
if d == nil {
d = []byte("IMG")
}
- return io.NopCloser(bytes.NewReader(d)), time.Time{}, nil
+ return &artwork.Image{ReadCloser: io.NopCloser(bytes.NewReader(d))}, nil
}
var _ artwork.Artwork = &spyArtwork{}
diff --git a/server/jellyfin/e2e/playlists_test.go b/server/jellyfin/e2e/playlists_test.go
index d2ff49db9..08d6f4f6f 100644
--- a/server/jellyfin/e2e/playlists_test.go
+++ b/server/jellyfin/e2e/playlists_test.go
@@ -6,8 +6,8 @@ import (
jpeglib "image/jpeg"
"net/http"
"os"
- "time"
+ "github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/server/jellyfin/dto"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
@@ -215,26 +215,26 @@ var _ = Describe("Playlists", func() {
To(Equal(http.StatusNotImplemented))
})
- // Guards the whole chain: SetImage must go through a full Put (which bumps UpdatedAt), and the
- // tag must be versioned by it, or clients keep their blurhash-keyed cover cache forever.
- It("rotates the playlist's image tag and blurhash after a cover upload", func() {
+ // An upload must clear the resolved artwork state, or clients keep serving the stale cover
+ // from their tag-keyed cache until the next scan.
+ It("clears the resolved image tag after a cover upload", func() {
plID := createPlaylist("Cover Tag", nil)
+ Expect(ds.Artwork(ctx).PutItemArtwork(&model.ItemArtwork{
+ ItemKind: model.KindPlaylistArtwork.Prefix(), ItemID: plID, Hash: "1111111111111111",
+ })).To(Succeed())
+
imageTag := func() string {
q := queryResult(get("/Items?ids=" + enc(plID)))
Expect(q.Items).To(HaveLen(1))
return q.Items[0].ImageTags["Primary"]
}
- before := imageTag()
- Expect(before).ToNot(BeEmpty())
+ Expect(imageTag()).To(Equal("1111111111111111"))
- time.Sleep(2 * time.Millisecond) // UpdatedAt has millisecond resolution in the tag
Expect(upload(adminUser, "/Items/"+enc(plID)+"/Images/Primary", "image/jpeg", jpeg).Code).
To(Equal(http.StatusNoContent))
- after := imageTag()
- Expect(after).ToNot(Equal(before))
- q := queryResult(get("/Items?ids=" + enc(plID)))
- Expect(q.Items[0].ImageBlurHashes["Primary"]).To(HaveKey(after))
+ // The upload re-queues resolution instead of resolving inline, so the tag goes bare.
+ Expect(imageTag()).ToNot(Equal("1111111111111111"))
})
})
diff --git a/server/jellyfin/images.go b/server/jellyfin/images.go
index 0ec34f491..b844e7c74 100644
--- a/server/jellyfin/images.go
+++ b/server/jellyfin/images.go
@@ -16,10 +16,11 @@ import (
"github.com/dustin/go-humanize"
"github.com/go-chi/chi/v5"
"github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/server/imghttp"
"github.com/navidrome/navidrome/server/jellyfin/dto"
_ "golang.org/x/image/webp"
)
@@ -32,7 +33,7 @@ func (api *Router) getItemImage(w http.ResponseWriter, r *http.Request) {
size, _ := strconv.Atoi(r.URL.Query().Get("maxwidth"))
artID := api.resolveArtworkID(ctx, itemId)
- reader, _, err := api.artwork.GetOrPlaceholder(ctx, artID, size, false)
+ img, err := api.artwork.GetOrPlaceholder(ctx, artID, size, false)
switch {
case errors.Is(err, context.Canceled):
return
@@ -41,9 +42,27 @@ func (api *Router) getItemImage(w http.ResponseWriter, r *http.Request) {
http.Error(w, "Not Found", http.StatusNotFound)
return
}
- defer reader.Close()
+ defer img.Close()
+ if imghttp.WriteImageHeaders(w, r, img, hashFromTag(r)) {
+ return
+ }
// Leave Content-Type unset so net/http sniffs it (covers may be PNG/WebP/JPEG).
- _, _ = io.Copy(w, reader)
+ _, _ = io.Copy(w, img)
+}
+
+// hashFromTag returns the ?tag query param when it is exactly a 16-char lowercase-hex content
+// hash (what Finamp/Jellyfin clients append), so a matching request can be served immutable.
+func hashFromTag(r *http.Request) string {
+ tag := r.URL.Query().Get("tag")
+ if len(tag) != 16 {
+ return ""
+ }
+ for _, c := range tag {
+ if !(c >= '0' && c <= '9' || c >= 'a' && c <= 'f') {
+ return ""
+ }
+ }
+ return tag
}
// resolveArtworkID maps a Jellyfin item id to a Navidrome ArtworkID, probing
@@ -79,7 +98,7 @@ func (api *Router) postItemImage(w http.ResponseWriter, r *http.Request) {
}
// The limit caps the decoded image (native endpoint semantics); Jellyfin clients base64-encode
// the wire body (4/3 bigger), so the read cap allows for inflation.
- limit := core.MaxImageUploadSize()
+ limit := artwork.MaxImageUploadSize()
body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, limit*4/3+4))
if err != nil {
log.Warn(ctx, "Jellyfin API: cover upload rejected: body exceeds MaxImageUploadSize",
diff --git a/server/jellyfin/images_test.go b/server/jellyfin/images_test.go
index e435b99fd..bdd47e956 100644
--- a/server/jellyfin/images_test.go
+++ b/server/jellyfin/images_test.go
@@ -33,16 +33,21 @@ type fakeArtwork struct {
recvId string
recvCtx context.Context
data []byte
+ hash string
}
-func (f *fakeArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error) {
+func (f *fakeArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (*artwork.Image, error) {
f.recvId = id
f.recvCtx = ctx
data := f.data
if data == nil {
data = []byte("IMG")
}
- return io.NopCloser(bytes.NewReader(data)), time.Now(), nil
+ return &artwork.Image{
+ ReadCloser: io.NopCloser(bytes.NewReader(data)),
+ Hash: f.hash,
+ LastUpdated: time.Now(),
+ }, nil
}
func newImageRequest(itemId string) (*httptest.ResponseRecorder, *http.Request) {
@@ -70,6 +75,19 @@ var _ = Describe("Images", func() {
Expect(fa.recvId).To(ContainSubstring("a1"))
})
+ // resolveArtworkID probes the entity tables, so a deleted item yields no artwork id at all.
+ It("asks for no artwork once the item is deleted, rather than its lingering state", func() {
+ ds := &tests.MockDataStore{} // no albums/artists/tracks/playlists at all
+ fa := &fakeArtwork{}
+ api := &Router{ds: ds, artwork: fa}
+
+ w, r := newImageRequest(dto.EncodeID("deleted-item"))
+ api.getItemImage(w, r)
+
+ Expect(fa.recvId).To(BeEmpty(), "an empty artwork id can only yield a placeholder")
+ Expect(w.Body.String()).ToNot(ContainSubstring("deleted-item"))
+ })
+
It("sniffs the Content-Type instead of hardcoding it", func() {
ds := &tests.MockDataStore{}
ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})
@@ -115,6 +133,38 @@ var _ = Describe("Images", func() {
Expect(ok).To(BeTrue())
Expect(u.IsAdmin).To(BeTrue())
})
+
+ It("serves immutable when the tag param asserts the current hash", func() {
+ const hash = "0123456789abcdef"
+ ds := &tests.MockDataStore{}
+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})
+ fa := &fakeArtwork{hash: hash}
+ api := &Router{ds: ds, artwork: fa}
+
+ w, r := newImageRequest(dto.EncodeID("a1"))
+ q := r.URL.Query()
+ q.Set("tag", hash)
+ r.URL.RawQuery = q.Encode()
+ api.getItemImage(w, r)
+
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))
+ Expect(w.Header().Get("ETag")).To(Equal(`"` + hash + `"`))
+ })
+
+ It("revalidates via no-cache when no tag is provided", func() {
+ const hash = "0123456789abcdef"
+ ds := &tests.MockDataStore{}
+ ds.Album(context.Background()).(*tests.MockAlbumRepo).SetData(model.Albums{{ID: "a1", Name: "One"}})
+ fa := &fakeArtwork{hash: hash}
+ api := &Router{ds: ds, artwork: fa}
+
+ w, r := newImageRequest(dto.EncodeID("a1"))
+ api.getItemImage(w, r)
+
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, no-cache"))
+ })
})
// Real image fixtures: postItemImage validates uploads by decoding them.
diff --git a/server/jellyfin/items.go b/server/jellyfin/items.go
index 7cf2a17ba..631530b6d 100644
--- a/server/jellyfin/items.go
+++ b/server/jellyfin/items.go
@@ -588,7 +588,7 @@ func (api *Router) listSongs(ctx context.Context, opts model.QueryOptions, q ite
// A full-library request (Finamp's sync, with MediaSources) is tens of thousands of fat rows.
total, _ := repo.CountAll(model.QueryOptions{Filters: opts.Filters})
open := streamCursor(func() (func(func(model.MediaFile, error) bool), error) {
- return repo.GetCursor(opts)
+ return repo.GetCursorWithArtwork(opts)
}, toItem)
return streamed(open, int(total), opts.Offset), nil
}
@@ -598,6 +598,7 @@ func (api *Router) listSongs(ctx context.Context, opts model.QueryOptions, q ite
// genreIds isn't applied to search — a name lookup, like role (see below).
func (api *Router) listArtists(ctx context.Context, opts model.QueryOptions, q itemsQuery, role model.Role) (itemsResult, error) {
repo := api.ds.Artist(ctx)
+ toItem := func(ar model.Artist) dto.BaseItemDto { return dto.ArtistToBaseItem(ar, q.fields) }
// Artist Search does its own library scoping: it consumes a sole Eq{"library_id": ...} filter as a
// search scope (artists have no library_id column). A compound or join-based filter
@@ -613,7 +614,7 @@ func (api *Router) listArtists(ctx context.Context, opts model.QueryOptions, q i
if err != nil {
return itemsResult{}, err
}
- return materialized(result(slice.Map(artists, dto.ArtistToBaseItem), total, opts.Offset)), nil
+ return materialized(result(slice.Map(artists, toItem), total, opts.Offset)), nil
}
if q.favOnly {
@@ -629,7 +630,7 @@ func (api *Router) listArtists(ctx context.Context, opts model.QueryOptions, q i
total, _ := repo.CountAll(model.QueryOptions{Filters: opts.Filters})
open := streamCursor(func() (func(func(model.Artist, error) bool), error) {
return repo.GetCursor(opts)
- }, dto.ArtistToBaseItem)
+ }, toItem)
return streamed(open, int(total), opts.Offset), nil
}
@@ -663,7 +664,7 @@ func (api *Router) listPlaylists(ctx context.Context, opts model.QueryOptions, q
}
open := streamCursor(func() (func(func(model.Playlist, error) bool), error) {
return repo.GetCursor(opts)
- }, dto.PlaylistToBaseItem)
+ }, func(p model.Playlist) dto.BaseItemDto { return dto.PlaylistToBaseItem(p, q.fields) })
return streamed(open, int(total), opts.Offset), nil
}
@@ -698,7 +699,7 @@ func (api *Router) resolveItemByID(ctx context.Context, id string, fields dto.Fi
if ar, err := api.ds.Artist(ctx).Get(id); err == nil {
// TODO: an artist spans multiple libraries (library_artist), so there's no single
// LibraryID to gate here; artist access relies on list-time scoping and persistence.
- return dto.ArtistToBaseItem(*ar), true
+ return dto.ArtistToBaseItem(*ar, fields), true
}
if mf, err := api.ds.MediaFile(ctx).Get(id); err == nil {
if !u.HasLibraryAccess(mf.LibraryID) {
@@ -708,7 +709,7 @@ func (api *Router) resolveItemByID(ctx context.Context, id string, fields dto.Fi
}
// api.playlists.Get enforces ownership/visibility, so a non-owned or missing id falls through.
if pl, err := api.playlists.Get(ctx, id); err == nil {
- return dto.PlaylistToBaseItem(*pl), true
+ return dto.PlaylistToBaseItem(*pl, fields), true
}
return dto.BaseItemDto{}, false
}
diff --git a/server/jellyfin/similar.go b/server/jellyfin/similar.go
index 661fb95cc..2698073bf 100644
--- a/server/jellyfin/similar.go
+++ b/server/jellyfin/similar.go
@@ -138,7 +138,7 @@ func (api *Router) similarArtists(ctx context.Context, id string, limit int) dto
return result(nil, 0, 0)
}
present := slice.Filter(artist.SimilarArtists, func(a model.Artist) bool { return a.ID != "" })
- items := slice.Map(present, dto.ArtistToBaseItem)
+ items := slice.Map(present, func(a model.Artist) dto.BaseItemDto { return dto.ArtistToBaseItem(a, nil) })
return result(items, len(items), 0)
}
diff --git a/server/nativeapi/artists.go b/server/nativeapi/artists.go
index daa918d00..193f88eda 100644
--- a/server/nativeapi/artists.go
+++ b/server/nativeapi/artists.go
@@ -46,7 +46,11 @@ func (api *Router) uploadArtistImage() http.HandlerFunc {
}
ar.UploadedImage = filename
ar.UpdatedAt = new(time.Now())
- return api.ds.Artist(ctx).Put(ar, "uploaded_image", "updated_at")
+ if err := api.ds.Artist(ctx).Put(ar, "uploaded_image", "updated_at"); err != nil {
+ return err
+ }
+ api.imgUpload.EnqueueArtwork(ctx, consts.EntityArtist, ar.ID)
+ return nil
})
}
@@ -65,6 +69,10 @@ func (api *Router) deleteArtistImage() http.HandlerFunc {
}
ar.UploadedImage = ""
ar.UpdatedAt = new(time.Now())
- return api.ds.Artist(ctx).Put(ar, "uploaded_image", "updated_at")
+ if err := api.ds.Artist(ctx).Put(ar, "uploaded_image", "updated_at"); err != nil {
+ return err
+ }
+ api.imgUpload.EnqueueArtwork(ctx, consts.EntityArtist, ar.ID)
+ return nil
})
}
diff --git a/server/nativeapi/artwork.go b/server/nativeapi/artwork.go
new file mode 100644
index 000000000..3583c2db7
--- /dev/null
+++ b/server/nativeapi/artwork.go
@@ -0,0 +1,42 @@
+package nativeapi
+
+import (
+ "net/http"
+ "slices"
+
+ "github.com/go-chi/chi/v5"
+ "github.com/navidrome/navidrome/core/artwork"
+ "github.com/navidrome/navidrome/log"
+ "github.com/navidrome/navidrome/model"
+)
+
+var refreshableArtworkKinds = []model.Kind{
+ model.KindAlbumArtwork,
+ model.KindArtistArtwork,
+ model.KindPlaylistArtwork,
+ model.KindRadioArtwork,
+ model.KindMediaFileArtwork,
+}
+
+func (api *Router) addArtworkRoute(r chi.Router) {
+ r.Post("/artwork/{kind}/{id}/refresh", api.refreshArtwork())
+}
+
+// State is deliberately cleared so a wrong pick disappears immediately (placeholder until re-resolved).
+func (api *Router) refreshArtwork() http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+ kind, _ := model.ParseKind(chi.URLParam(r, "kind"))
+ id := chi.URLParam(r, "id")
+ if !slices.Contains(refreshableArtworkKinds, kind) {
+ http.Error(w, "invalid artwork kind", http.StatusBadRequest)
+ return
+ }
+ if err := artwork.Refresh(ctx, api.ds, kind, id); err != nil {
+ log.Error(ctx, "Error refreshing artwork", "kind", kind, "id", id, err)
+ http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+ return
+ }
+ w.WriteHeader(http.StatusNoContent)
+ }
+}
diff --git a/server/nativeapi/artwork_test.go b/server/nativeapi/artwork_test.go
new file mode 100644
index 000000000..b26a94e6a
--- /dev/null
+++ b/server/nativeapi/artwork_test.go
@@ -0,0 +1,95 @@
+package nativeapi
+
+import (
+ "context"
+ "net/http"
+ "net/http/httptest"
+
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/core/auth"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/server"
+ "github.com/navidrome/navidrome/tests"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+)
+
+var _ = Describe("Artwork API", func() {
+ var ds *tests.MockDataStore
+ var artRepo *tests.MockArtworkRepo
+ var queueRepo *tests.MockArtworkQueueRepo
+ var router http.Handler
+ var adminToken, userToken string
+
+ BeforeEach(func() {
+ DeferCleanup(configtest.SetupConfig())
+ conf.Server.EnableSharing = false
+ artRepo = tests.CreateMockArtworkRepo()
+ queueRepo = tests.CreateMockArtworkQueueRepo()
+ ds = &tests.MockDataStore{MockedArtwork: artRepo, MockedArtworkQueue: queueRepo}
+ auth.Init(ds)
+ nativeRouter := New(ds, nil, nil, nil, tests.NewMockLibraryService(), tests.NewMockUserService(), nil, nil, nil)
+ router = server.JWTVerifier(nativeRouter)
+
+ adminUser := model.User{ID: "admin-1", UserName: "admin", IsAdmin: true, NewPassword: "adminpass"}
+ regularUser := model.User{ID: "user-1", UserName: "regular", IsAdmin: false, NewPassword: "userpass"}
+ Expect(ds.User(context.TODO()).Put(&adminUser)).To(Succeed())
+ Expect(ds.User(context.TODO()).Put(&regularUser)).To(Succeed())
+
+ var err error
+ adminToken, err = auth.CreateToken(&adminUser)
+ Expect(err).ToNot(HaveOccurred())
+ userToken, err = auth.CreateToken(&regularUser)
+ Expect(err).ToNot(HaveOccurred())
+ })
+
+ Describe("POST /api/artwork/{kind}/{id}/refresh", func() {
+ It("clears state and enqueues a Bump for admins", func() {
+ Expect(artRepo.PutItemArtwork(&model.ItemArtwork{
+ ItemKind: "al", ItemID: "al-1", Hash: "oldhash", Source: "external",
+ })).To(Succeed())
+
+ req := createAuthenticatedRequest("POST", "/artwork/al/al-1/refresh", nil, adminToken)
+ w := httptest.NewRecorder()
+ router.ServeHTTP(w, req)
+
+ Expect(w.Code).To(Equal(http.StatusNoContent))
+
+ _, err := artRepo.GetItemArtwork(model.KindAlbumArtwork, "al-1", model.ImageTypePrimary)
+ Expect(err).To(MatchError(model.ErrNotFound))
+
+ queued, err := queueRepo.DequeueBatch(1000)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(queued).To(ContainElement(SatisfyAll(
+ HaveField("ItemKind", "al"),
+ HaveField("ItemID", "al-1"),
+ HaveField("Priority", model.ArtworkPriorityBump),
+ )))
+ })
+
+ It("returns 400 for an invalid kind", func() {
+ req := createAuthenticatedRequest("POST", "/artwork/xx/id-1/refresh", nil, adminToken)
+ w := httptest.NewRecorder()
+ router.ServeHTTP(w, req)
+
+ Expect(w.Code).To(Equal(http.StatusBadRequest))
+ })
+
+ It("denies access to regular users", func() {
+ req := createAuthenticatedRequest("POST", "/artwork/al/al-1/refresh", nil, userToken)
+ w := httptest.NewRecorder()
+ router.ServeHTTP(w, req)
+
+ Expect(w.Code).To(Equal(http.StatusForbidden))
+ })
+
+ It("denies access without authentication", func() {
+ req := createUnauthenticatedRequest("POST", "/artwork/al/al-1/refresh", nil)
+ w := httptest.NewRecorder()
+ router.ServeHTTP(w, req)
+
+ Expect(w.Code).To(Equal(http.StatusUnauthorized))
+ })
+ })
+})
diff --git a/server/nativeapi/image_upload.go b/server/nativeapi/image_upload.go
index 077eac35e..c4ff62e42 100644
--- a/server/nativeapi/image_upload.go
+++ b/server/nativeapi/image_upload.go
@@ -14,7 +14,7 @@ import (
"strings"
"github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/request"
@@ -31,7 +31,7 @@ func checkImageUploadPermission(w http.ResponseWriter, r *http.Request) bool {
}
func handleImageUpload(saveFn func(ctx context.Context, reader io.Reader, ext string) error) http.HandlerFunc {
- maxImageSize := core.MaxImageUploadSize()
+ maxImageSize := artwork.MaxImageUploadSize()
return func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if !checkImageUploadPermission(w, r) {
diff --git a/server/nativeapi/native_api.go b/server/nativeapi/native_api.go
index 5a7023eb6..f97bd26b2 100644
--- a/server/nativeapi/native_api.go
+++ b/server/nativeapi/native_api.go
@@ -13,6 +13,7 @@ import (
"github.com/go-chi/chi/v5/middleware"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
playlistsvc "github.com/navidrome/navidrome/core/playlists"
"github.com/navidrome/navidrome/log"
@@ -44,10 +45,10 @@ type Router struct {
users core.User
maintenance core.Maintenance
pluginManager PluginManager
- imgUpload core.ImageUploadService
+ imgUpload artwork.Uploader
}
-func New(ds model.DataStore, share core.Share, playlists playlistsvc.Playlists, insights metrics.Insights, libraryService core.Library, userService core.User, maintenance core.Maintenance, pluginManager PluginManager, imgUpload core.ImageUploadService) *Router {
+func New(ds model.DataStore, share core.Share, playlists playlistsvc.Playlists, insights metrics.Insights, libraryService core.Library, userService core.User, maintenance core.Maintenance, pluginManager PluginManager, imgUpload artwork.Uploader) *Router {
r := &Router{ds: ds, share: share, playlists: playlists, insights: insights, libs: libraryService, users: userService, maintenance: maintenance, pluginManager: pluginManager, imgUpload: imgUpload}
r.Handler = r.routes()
return r
@@ -91,6 +92,7 @@ func (api *Router) routes() http.Handler {
api.addConfigRoute(r)
api.addUserLibraryRoute(r)
api.addPluginRoute(r)
+ api.addArtworkRoute(r)
api.RX(r, "/library", api.libs.NewRepository, true)
})
})
diff --git a/server/nativeapi/radios.go b/server/nativeapi/radios.go
index 701c6c926..3e88af287 100644
--- a/server/nativeapi/radios.go
+++ b/server/nativeapi/radios.go
@@ -47,7 +47,11 @@ func (api *Router) uploadRadioImage() http.HandlerFunc {
return err
}
radio.UploadedImage = filename
- return api.ds.Radio(ctx).Put(radio, "UploadedImage")
+ if err := api.ds.Radio(ctx).Put(radio, "UploadedImage"); err != nil {
+ return err
+ }
+ api.imgUpload.EnqueueArtwork(ctx, consts.EntityRadio, radio.ID)
+ return nil
})
}
@@ -65,6 +69,10 @@ func (api *Router) deleteRadioImage() http.HandlerFunc {
return err
}
radio.UploadedImage = ""
- return api.ds.Radio(ctx).Put(radio, "UploadedImage")
+ if err := api.ds.Radio(ctx).Put(radio, "UploadedImage"); err != nil {
+ return err
+ }
+ api.imgUpload.EnqueueArtwork(ctx, consts.EntityRadio, radio.ID)
+ return nil
})
}
diff --git a/server/public/handle_images.go b/server/public/handle_images.go
index 633665e0f..6416190bd 100644
--- a/server/public/handle_images.go
+++ b/server/public/handle_images.go
@@ -11,6 +11,8 @@ import (
"github.com/navidrome/navidrome/core/auth"
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/server/imghttp"
"github.com/navidrome/navidrome/utils/req"
)
@@ -37,10 +39,13 @@ func (pub *Router) handleImages(w http.ResponseWriter, r *http.Request) {
http.Error(w, "invalid request", http.StatusBadRequest)
return
}
+ // The token is the authorization, so the entity check must ask "is it still there", not
+ // "may this user see it" -- the latter would hide a shared private playlist.
+ ctx = request.WithUser(ctx, model.User{IsAdmin: true})
size := p.IntOr("size", 0)
square := p.BoolOr("square", false)
- imgReader, lastUpdate, err := pub.artwork.Get(ctx, artId, size, square)
+ img, err := pub.artwork.Get(ctx, artId, size, square)
switch {
case errors.Is(err, context.Canceled):
return
@@ -58,10 +63,11 @@ func (pub *Router) handleImages(w http.ResponseWriter, r *http.Request) {
return
}
- defer imgReader.Close()
- w.Header().Set("Cache-Control", "public, max-age=315360000")
- w.Header().Set("Last-Modified", lastUpdate.Format(http.TimeFormat))
- cnt, err := io.Copy(w, imgReader)
+ defer img.Close()
+ if imghttp.WriteImageHeaders(w, r, img, artId.Hash) {
+ return
+ }
+ cnt, err := io.Copy(w, img)
if err != nil {
log.Warn(ctx, "Error sending image", "count", cnt, err)
}
diff --git a/server/public/handle_images_test.go b/server/public/handle_images_test.go
index 669f879a6..d77b6f427 100644
--- a/server/public/handle_images_test.go
+++ b/server/public/handle_images_test.go
@@ -1,8 +1,18 @@
package public
import (
+ "bytes"
+ "context"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+
"github.com/go-chi/jwtauth/v5"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/auth"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/tests"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -23,3 +33,56 @@ var _ = Describe("decodeArtworkID", func() {
Expect(err).To(HaveOccurred())
})
})
+
+type fakeArtwork struct {
+ artwork.Artwork
+ img *artwork.Image
+ err error
+}
+
+func (f *fakeArtwork) Get(context.Context, model.ArtworkID, int, bool) (*artwork.Image, error) {
+ return f.img, f.err
+}
+
+var _ = Describe("handleImages", func() {
+ var w *httptest.ResponseRecorder
+
+ newImageRequest := func(claimID string) *http.Request {
+ auth.PublicTokenAuth = jwtauth.New("HS256", []byte("super secret"), nil)
+ token, _ := auth.CreatePublicToken(auth.Claims{ID: claimID})
+ return httptest.NewRequest("GET", "/img?:id="+url.QueryEscape(token), nil)
+ }
+
+ // The handler re-checks that the entity behind the token still exists, so "1" must be live.
+ var ds *tests.MockDataStore
+
+ BeforeEach(func() {
+ w = httptest.NewRecorder()
+ albumRepo := tests.CreateMockAlbumRepo()
+ albumRepo.SetData(model.Albums{{ID: "1"}})
+ ds = &tests.MockDataStore{MockedAlbum: albumRepo}
+ })
+
+ It("returns 404 when the artwork is unavailable", func() {
+ pub := &Router{ds: ds, artwork: &fakeArtwork{err: artwork.ErrUnavailable}}
+ pub.handleImages(w, newImageRequest("al-1"))
+ Expect(w.Code).To(Equal(http.StatusNotFound))
+ })
+
+ It("returns 404 when the artwork is not found", func() {
+ pub := &Router{ds: ds, artwork: &fakeArtwork{err: model.ErrNotFound}}
+ pub.handleImages(w, newImageRequest("al-1"))
+ Expect(w.Code).To(Equal(http.StatusNotFound))
+ })
+
+ It("serves the image immutable when the token asserts the current hash", func() {
+ const hash = "0123456789abcdef"
+ img := &artwork.Image{ReadCloser: io.NopCloser(bytes.NewReader([]byte("IMG"))), Hash: hash}
+ pub := &Router{ds: ds, artwork: &fakeArtwork{img: img}}
+ pub.handleImages(w, newImageRequest("al-1_"+hash))
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))
+ Expect(w.Header().Get("ETag")).To(Equal(`"` + hash + `"`))
+ })
+
+})
diff --git a/server/subsonic/browsing.go b/server/subsonic/browsing.go
index 59d267321..d32a5c857 100644
--- a/server/subsonic/browsing.go
+++ b/server/subsonic/browsing.go
@@ -230,9 +230,11 @@ func (api *Router) GetAlbumInfo(r *http.Request) (*responses.Subsonic, error) {
response := newResponse()
response.AlbumInfo = &responses.AlbumInfo{}
response.AlbumInfo.Notes = album.Description
- response.AlbumInfo.SmallImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 300)
- response.AlbumInfo.MediumImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 600)
- response.AlbumInfo.LargeImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 1200)
+ if !album.ImageAbsent {
+ response.AlbumInfo.SmallImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 300)
+ response.AlbumInfo.MediumImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 600)
+ response.AlbumInfo.LargeImageUrl = publicurl.ImageURL(r, album.CoverArtID(), 1200)
+ }
response.AlbumInfo.LastFmUrl = album.ExternalUrl
response.AlbumInfo.MusicBrainzID = album.MbzAlbumID
@@ -295,9 +297,11 @@ func (api *Router) getArtistInfo(r *http.Request) (*responses.ArtistInfoBase, *m
base := responses.ArtistInfoBase{}
base.Biography = artist.Biography
- base.SmallImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 300)
- base.MediumImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 600)
- base.LargeImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 1200)
+ if !artist.ImageAbsent {
+ base.SmallImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 300)
+ base.MediumImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 600)
+ base.LargeImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 1200)
+ }
base.LastFmUrl = artist.ExternalUrl
base.MusicBrainzID = artist.MbzArtistID
@@ -454,7 +458,7 @@ func (api *Router) buildAlbumDirectory(ctx context.Context, album *model.Album)
dir.AverageRating = album.AverageRating
}
dir.SongCount = int32(album.SongCount)
- dir.CoverArt = album.CoverArtID().String()
+ dir.CoverArt = coverArtOrEmpty(album.CoverArtID(), album.ImageAbsent)
if album.Starred {
dir.Starred = album.StarredAt
}
diff --git a/server/subsonic/browsing_test.go b/server/subsonic/browsing_test.go
index b8f510aed..d34da2f37 100644
--- a/server/subsonic/browsing_test.go
+++ b/server/subsonic/browsing_test.go
@@ -6,6 +6,7 @@ import (
"net/http/httptest"
"github.com/navidrome/navidrome/core/auth"
+ "github.com/navidrome/navidrome/core/external"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/request"
"github.com/navidrome/navidrome/tests"
@@ -157,4 +158,57 @@ var _ = Describe("Browsing", func() {
Expect(response.Artist).ToNot(BeNil())
})
})
+
+ Describe("GetAlbumInfo", func() {
+ It("emits image URLs when the album artwork is unresolved", func() {
+ api.provider = &fakeInfoProvider{album: &model.Album{ID: "al-1"}}
+ r := httptest.NewRequest("GET", "/rest/getAlbumInfo?id=al-1", nil)
+ resp, err := api.GetAlbumInfo(r)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(resp.AlbumInfo.SmallImageUrl).ToNot(BeEmpty())
+ Expect(resp.AlbumInfo.LargeImageUrl).ToNot(BeEmpty())
+ })
+ It("omits image URLs when the album artwork is known absent", func() {
+ api.provider = &fakeInfoProvider{album: &model.Album{ID: "al-1", ItemImage: model.ItemImage{ImageAbsent: true}}}
+ r := httptest.NewRequest("GET", "/rest/getAlbumInfo?id=al-1", nil)
+ resp, err := api.GetAlbumInfo(r)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(resp.AlbumInfo.SmallImageUrl).To(BeEmpty())
+ Expect(resp.AlbumInfo.MediumImageUrl).To(BeEmpty())
+ Expect(resp.AlbumInfo.LargeImageUrl).To(BeEmpty())
+ })
+ })
+
+ Describe("GetArtistInfo", func() {
+ It("emits image URLs when the artist artwork is unresolved", func() {
+ api.provider = &fakeInfoProvider{artist: &model.Artist{ID: "ar-1"}}
+ r := httptest.NewRequest("GET", "/rest/getArtistInfo?id=ar-1", nil)
+ resp, err := api.GetArtistInfo(r)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(resp.ArtistInfo.SmallImageUrl).ToNot(BeEmpty())
+ })
+ It("omits image URLs when the artist artwork is known absent", func() {
+ api.provider = &fakeInfoProvider{artist: &model.Artist{ID: "ar-1", ItemImage: model.ItemImage{ImageAbsent: true}}}
+ r := httptest.NewRequest("GET", "/rest/getArtistInfo?id=ar-1", nil)
+ resp, err := api.GetArtistInfo(r)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(resp.ArtistInfo.SmallImageUrl).To(BeEmpty())
+ Expect(resp.ArtistInfo.MediumImageUrl).To(BeEmpty())
+ Expect(resp.ArtistInfo.LargeImageUrl).To(BeEmpty())
+ })
+ })
})
+
+type fakeInfoProvider struct {
+ external.Provider
+ album *model.Album
+ artist *model.Artist
+}
+
+func (f *fakeInfoProvider) UpdateAlbumInfo(context.Context, string) (*model.Album, error) {
+ return f.album, nil
+}
+
+func (f *fakeInfoProvider) UpdateArtistInfo(context.Context, string, int, bool) (*model.Artist, error) {
+ return f.artist, nil
+}
diff --git a/server/subsonic/e2e/e2e_suite_test.go b/server/subsonic/e2e/e2e_suite_test.go
index 97d7fb40a..8998731a4 100644
--- a/server/subsonic/e2e/e2e_suite_test.go
+++ b/server/subsonic/e2e/e2e_suite_test.go
@@ -311,12 +311,12 @@ func parseJSONResponse(w *httptest.ResponseRecorder) *responses.Subsonic {
// noopArtwork implements artwork.Artwork
type noopArtwork struct{}
-func (n noopArtwork) Get(context.Context, model.ArtworkID, int, bool) (io.ReadCloser, time.Time, error) {
- return nil, time.Time{}, model.ErrNotFound
+func (n noopArtwork) Get(context.Context, model.ArtworkID, int, bool) (*artwork.Image, error) {
+ return nil, model.ErrNotFound
}
-func (n noopArtwork) GetOrPlaceholder(_ context.Context, _ string, _ int, _ bool) (io.ReadCloser, time.Time, error) {
- return io.NopCloser(io.LimitReader(nil, 0)), time.Time{}, nil
+func (n noopArtwork) GetOrPlaceholder(_ context.Context, _ string, _ int, _ bool) (*artwork.Image, error) {
+ return &artwork.Image{ReadCloser: io.NopCloser(io.LimitReader(nil, 0))}, nil
}
// noopArchiver implements core.Archiver
@@ -357,14 +357,6 @@ func (n noopProvider) TopSongs(context.Context, string, string, int) (model.Medi
return nil, nil
}
-func (n noopProvider) ArtistImage(context.Context, string) (*url.URL, error) {
- return nil, model.ErrNotFound
-}
-
-func (n noopProvider) AlbumImage(context.Context, string) (*url.URL, error) {
- return nil, model.ErrNotFound
-}
-
// Compile-time interface checks
var (
_ artwork.Artwork = noopArtwork{}
@@ -416,8 +408,8 @@ func setupTestDB() {
// Create the Subsonic Router with real DS, streamer spy, and real Decider
streamerSpy = &harness.SpyStreamer{}
decider := stream.NewTranscodeDecider(ds, harness.NoopFFmpeg{})
- s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
+ s := scanner.New(ctx, ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
router = subsonic.New(
ds,
noopArtwork{},
@@ -427,7 +419,7 @@ func setupTestDB() {
noopProvider{},
s,
events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)),
scrobbler.NewPlayTracker(ds, events.NoopBroker(), nil),
core.NewShare(ds),
playback.PlaybackServer(nil),
diff --git a/server/subsonic/e2e/subsonic_artwork_test.go b/server/subsonic/e2e/subsonic_artwork_test.go
new file mode 100644
index 000000000..619619810
--- /dev/null
+++ b/server/subsonic/e2e/subsonic_artwork_test.go
@@ -0,0 +1,328 @@
+package e2e
+
+import (
+ "context"
+ "errors"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "time"
+
+ "github.com/Masterminds/squirrel"
+ _ "github.com/navidrome/navidrome/adapters/gotaglib" // registers the "taglib" local-storage extractor
+ "github.com/navidrome/navidrome/conf"
+ "github.com/navidrome/navidrome/conf/configtest"
+ "github.com/navidrome/navidrome/consts"
+ "github.com/navidrome/navidrome/core"
+ "github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/core/artwork"
+ "github.com/navidrome/navidrome/core/auth"
+ "github.com/navidrome/navidrome/core/lyrics"
+ "github.com/navidrome/navidrome/core/metrics"
+ "github.com/navidrome/navidrome/core/playback"
+ "github.com/navidrome/navidrome/core/playlists"
+ "github.com/navidrome/navidrome/core/scrobbler"
+ _ "github.com/navidrome/navidrome/core/storage/local" // registers the "file" storage scheme
+ "github.com/navidrome/navidrome/core/stream"
+ "github.com/navidrome/navidrome/db"
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
+ "github.com/navidrome/navidrome/persistence"
+ "github.com/navidrome/navidrome/resources"
+ "github.com/navidrome/navidrome/scanner"
+ "github.com/navidrome/navidrome/server/events"
+ "github.com/navidrome/navidrome/server/public"
+ "github.com/navidrome/navidrome/server/subsonic"
+ "github.com/navidrome/navidrome/tests"
+ "github.com/navidrome/navidrome/tests/harness"
+ "github.com/navidrome/navidrome/utils/cache"
+ . "github.com/onsi/ginkgo/v2"
+ . "github.com/onsi/gomega"
+ "go.senan.xyz/taglib"
+)
+
+// The serving path streams folder-backed originals via os.Open, which a fake FS cannot back, so
+// this suite scans a small REAL on-disk library and drives the real worker and artwork.Artwork.
+var _ = Describe("Artwork Serving", Ordered, func() {
+ var (
+ artRouter *subsonic.Router
+ pubRouter *public.Router
+ artSvc artwork.Artwork
+ worker *artwork.Worker
+ artfulID string
+ artlessID string
+ artfulHash string
+ placeholder []byte
+ )
+
+ albumCoverInList := func(albumID string) string {
+ GinkgoHelper()
+ resp := doReq("getAlbumList2", "type", "alphabeticalByName", "size", "500")
+ Expect(resp.AlbumList2).ToNot(BeNil())
+ for _, al := range resp.AlbumList2.Album {
+ if al.Id == albumID {
+ return al.CoverArt
+ }
+ }
+ Fail("album " + albumID + " not found in getAlbumList2")
+ return ""
+ }
+
+ getCover := func(params ...string) *httptest.ResponseRecorder {
+ GinkgoHelper()
+ w := httptest.NewRecorder()
+ r := buildReq(adminUser, "getCoverArt", params...)
+ artRouter.ServeHTTP(w, r)
+ return w
+ }
+
+ BeforeAll(func() {
+ DeferCleanup(configtest.SetupConfig())
+ DeferCleanup(func() { Eventually(scanner.IsScanning).Should(BeFalse()) })
+ ctx = request.WithUser(GinkgoT().Context(), adminUser)
+
+ musicDir := GinkgoT().TempDir()
+ writeArtworkTrack(musicDir, "Artful Artist", "Artful Album", "01 - Come Together", true)
+ writeArtworkTrack(musicDir, "Artless Artist", "Artless Album", "01 - Lonely", false)
+
+ conf.Server.MusicFolder = musicDir
+ conf.Server.DevExternalScanner = false
+ conf.Server.DevEnableMediaFileProbe = false
+ conf.Server.CoverArtPriority = "cover.jpg"
+ conf.Server.ArtistArtPriority = "artist.png" // offline: artists resolve absent, out of scope here
+ conf.Server.EnableMediaFileCoverArt = false
+ conf.Server.DevArtworkWorkerConcurrency = 1
+ conf.Server.CacheFolder = conf.NewDir(GinkgoT().TempDir())
+ conf.Server.EnableSharing = true
+ conf.Server.DevArtworkMaxRequests = 100
+ conf.Server.DevArtworkThrottleBacklogLimit = 100
+ conf.Server.DevArtworkThrottleBacklogTimeout = time.Minute
+
+ goldenDB.Restore()
+ ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}
+ auth.Init(ds)
+
+ // Re-scanning already-populated data deadlocks the parallel album-refresh phase at the
+ // harness's MaxOpenConns=1, so wipe the golden content and import this library fresh.
+ wipeScannedContent()
+ artLib := model.Library{Name: "Artwork Library", Path: musicDir}
+ Expect(ds.Library(ctx).Put(&artLib)).To(Succeed())
+ Expect(ds.User(ctx).SetUserLibraries(adminUser.ID, []int{artLib.ID})).To(Succeed())
+
+ s := scanner.New(ctx, ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
+ _, err := s.ScanAll(ctx, true)
+ Expect(err).ToNot(HaveOccurred())
+
+ // Focus the worker on the entities under test.
+ _, err = db.Db().Exec("DELETE FROM artwork_queue")
+ Expect(err).ToNot(HaveOccurred())
+
+ artfulID = albumIDByName("Artful Album")
+ artlessID = albumIDByName("Artless Album")
+
+ ph, err := resources.FS().Open(consts.PlaceholderAlbumArt)
+ Expect(err).ToNot(HaveOccurred())
+ placeholder, err = io.ReadAll(ph)
+ Expect(err).ToNot(HaveOccurred())
+ _ = ph.Close()
+
+ store := artwork.NewImageStore(GinkgoT().TempDir())
+ imgCache := newDummyImageCache(ctx)
+ ffm := harness.NoopFFmpeg{}
+ artSvc = artwork.NewArtwork(ds, imgCache, store, ffm)
+ worker = artwork.NewWorker(ds, store, agents.GetAgents(ds, nil), ffm, events.NoopBroker(), imgCache)
+
+ artRouter = buildArtworkRouter(artSvc)
+ router = artRouter // so the shared doReq/doRawReq helpers hit the artwork-wired router
+ pubRouter = public.New(ds, artSvc, streamerSpy, core.NewShare(ds), noopArchiver{})
+ })
+
+ It("emits a bare optimistic coverArt id before the queue is drained", func() {
+ Expect(albumCoverInList(artfulID)).To(Equal("al-" + artfulID))
+ Expect(albumCoverInList(artlessID)).To(Equal("al-" + artlessID))
+ })
+
+ It("drains the queue: folder art is acquired, the artless album settles absent", func() {
+ // Enqueues the way the serving paths do, so the drain is driven by a plain queue row.
+ for _, id := range []string{artfulID, artlessID} {
+ Expect(ds.ArtworkQueue(ctx).EnqueuePreservingBackoff(model.ArtworkQueueItem{
+ ItemKind: model.KindAlbumArtwork.Prefix(), ItemID: id,
+ ImageType: model.ImageTypePrimary, Priority: model.ArtworkPriorityBump,
+ })).To(Succeed())
+ }
+ runWorkerUntil(ctx, worker, func() bool {
+ found, err := ds.Artwork(ctx).GetItemArtwork(model.KindAlbumArtwork, artfulID, model.ImageTypePrimary)
+ if err != nil || found.Hash == "" {
+ return false
+ }
+ absent, err := ds.Artwork(ctx).GetItemArtwork(model.KindAlbumArtwork, artlessID, model.ImageTypePrimary)
+ return err == nil && absent.Hash == ""
+ })
+ ia, err := ds.Artwork(ctx).GetItemArtwork(model.KindAlbumArtwork, artfulID, model.ImageTypePrimary)
+ Expect(err).ToNot(HaveOccurred())
+ Expect(ia.Source).To(Equal("folder"))
+ artfulHash = ia.Hash
+ Expect(artfulHash).ToNot(BeEmpty())
+ })
+
+ It("promotes the list id to the hash suffix and omits the absent album's coverArt", func() {
+ Expect(albumCoverInList(artfulID)).To(Equal("al-" + artfulID + "_" + artfulHash))
+ Expect(albumCoverInList(artlessID)).To(BeEmpty())
+ })
+
+ It("serves the found album's bytes with revalidation headers for a bare id", func() {
+ w := getCover("id", "al-"+artfulID)
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Body.Bytes()).To(Equal(readArtworkFixture("cover.jpg")))
+ Expect(w.Header().Get("ETag")).To(Equal(`"` + artfulHash + `"`))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, no-cache"))
+ })
+
+ It("serves the found album immutably when the exact hash is requested", func() {
+ w := getCover("id", "al-"+artfulID+"_"+artfulHash)
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Body.Bytes()).To(Equal(readArtworkFixture("cover.jpg")))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))
+ })
+
+ It("returns 304 with an empty body when the client already holds the hash", func() {
+ w := httptest.NewRecorder()
+ r := buildReq(adminUser, "getCoverArt", "id", "al-"+artfulID)
+ r.Header.Set("If-None-Match", `"`+artfulHash+`"`)
+ artRouter.ServeHTTP(w, r)
+ Expect(w.Code).To(Equal(http.StatusNotModified))
+ Expect(w.Body.Bytes()).To(BeEmpty())
+ })
+
+ It("serves the placeholder with no-store for an absent album", func() {
+ w := getCover("id", "al-"+artlessID)
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Body.Bytes()).To(Equal(placeholder))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("no-store"))
+ })
+
+ // Only adminUser was granted this library, so regularUser must get the placeholder even
+ // though the artwork state and bytes are perfectly servable by id.
+ It("serves the placeholder for an album in a library the caller cannot see", func() {
+ w := httptest.NewRecorder()
+ artRouter.ServeHTTP(w, buildReq(regularUser, "getCoverArt", "id", "al-"+artfulID))
+
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Body.Bytes()).To(Equal(placeholder), "must not leak the real cover")
+ Expect(w.Header().Get("Cache-Control")).To(Equal("no-store"))
+
+ Expect(getCover("id", "al-"+artfulID).Body.Bytes()).ToNot(Equal(placeholder))
+ })
+
+ // An id naming no entity is a different answer from an album with no art: no placeholder.
+ It("answers error 70 for an id that matches no entity", func() {
+ w := getCover("id", "al-nosuchalbum")
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Body.String()).To(ContainSubstring(`"code":70`))
+ Expect(w.Body.Bytes()).ToNot(Equal(placeholder))
+ })
+
+ It("serves /share/img immutably for a JWT whose payload carries the hash", func() {
+ token, err := auth.CreateExpiringPublicToken(time.Now().Add(time.Hour),
+ auth.Claims{ID: "al-" + artfulID + "_" + artfulHash})
+ Expect(err).ToNot(HaveOccurred())
+
+ w := httptest.NewRecorder()
+ pubRouter.ServeHTTP(w, httptest.NewRequest("GET", "/img/"+token, nil))
+ Expect(w.Code).To(Equal(http.StatusOK))
+ Expect(w.Body.Bytes()).To(Equal(readArtworkFixture("cover.jpg")))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))
+ })
+
+ It("returns 404 from /share/img for an absent entity", func() {
+ token, err := auth.CreateExpiringPublicToken(time.Now().Add(time.Hour),
+ auth.Claims{ID: "al-" + artlessID})
+ Expect(err).ToNot(HaveOccurred())
+
+ w := httptest.NewRecorder()
+ pubRouter.ServeHTTP(w, httptest.NewRequest("GET", "/img/"+token, nil))
+ Expect(w.Code).To(Equal(http.StatusNotFound))
+ })
+})
+
+// buildArtworkRouter mirrors setupTestDB's Subsonic wiring but with the real artwork.Artwork.
+func buildArtworkRouter(art artwork.Artwork) *subsonic.Router {
+ decider := stream.NewTranscodeDecider(ds, harness.NoopFFmpeg{})
+ s := scanner.New(ctx, ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
+ return subsonic.New(
+ ds, art, streamerSpy, noopArchiver{}, core.NewPlayers(ds), noopProvider{}, s,
+ events.NoopBroker(), playlists.NewPlaylists(ds, artwork.NewUploader(ds)),
+ scrobbler.NewPlayTracker(ds, events.NoopBroker(), nil), core.NewShare(ds),
+ playback.PlaybackServer(nil), metrics.NewNoopInstance(), lyrics.NewLyrics(ds, nil), decider, nil,
+ )
+}
+
+// wipeScannedContent clears all scanned content so the next scan is a clean import. FKs are
+// disabled for the bulk delete, mirroring harness.Restore.
+func wipeScannedContent() {
+ GinkgoHelper()
+ _, err := db.Db().Exec("PRAGMA foreign_keys = OFF")
+ Expect(err).ToNot(HaveOccurred())
+ for _, t := range []string{"media_file", "album", "artist", "folder", "item_artwork", "artwork_queue", "artwork", "library"} {
+ _, err = db.Db().Exec(`DELETE FROM "` + t + `"`)
+ Expect(err).ToNot(HaveOccurred(), "wiping %s", t)
+ }
+ _, err = db.Db().Exec("PRAGMA foreign_keys = ON")
+ Expect(err).ToNot(HaveOccurred())
+}
+
+func albumIDByName(name string) string {
+ GinkgoHelper()
+ albums, err := ds.Album(ctx).GetAll(model.QueryOptions{Filters: squirrel.Eq{"album.name": name}})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(albums).To(HaveLen(1), "expected exactly one album named %q", name)
+ return albums[0].ID
+}
+
+// Distinct ALBUM/ALBUMARTIST tags keep the generated albums from merging into one.
+func writeArtworkTrack(root, artist, album, title string, withCover bool) {
+ GinkgoHelper()
+ dir := filepath.Join(root, artist, album)
+ Expect(os.MkdirAll(dir, 0o755)).To(Succeed())
+ mp3 := filepath.Join(dir, title+".mp3")
+ Expect(os.WriteFile(mp3, readArtworkFixture("test.mp3"), 0o600)).To(Succeed())
+ Expect(taglib.WriteTags(mp3, map[string][]string{
+ "ALBUM": {album}, "ALBUMARTIST": {artist}, "ARTIST": {artist}, "TITLE": {title},
+ }, taglib.Clear)).To(Succeed())
+ if withCover {
+ Expect(os.WriteFile(filepath.Join(dir, "cover.jpg"), readArtworkFixture("cover.jpg"), 0o600)).To(Succeed())
+ }
+}
+
+func readArtworkFixture(name string) []byte {
+ GinkgoHelper()
+ data, err := os.ReadFile(filepath.Join("tests", "fixtures", "artist", "an-album", name))
+ Expect(err).ToNot(HaveOccurred())
+ return data
+}
+
+// size=0 requests stream originals and never invoke the reader, so this resize cache only has
+// to satisfy the constructor.
+func newDummyImageCache(ctx context.Context) cache.FileCache {
+ GinkgoHelper()
+ c := cache.NewFileCache("SubsonicArtworkE2E", "100MB", "images", 0,
+ func(context.Context, cache.Item) (io.Reader, error) {
+ return nil, errors.New("resize not exercised in subsonic artwork e2e")
+ })
+ Eventually(func() bool { return c.Available(ctx) }).Should(BeTrue())
+ return c
+}
+
+func runWorkerUntil(ctx context.Context, worker *artwork.Worker, until func() bool) {
+ GinkgoHelper()
+ runCtx, cancel := context.WithCancel(ctx)
+ done := make(chan error, 1)
+ go func() { done <- worker.Run(runCtx) }()
+ Eventually(until, 10*time.Second, 20*time.Millisecond).Should(BeTrue())
+ cancel()
+ Eventually(done, 2*time.Second).Should(Receive(BeNil()))
+}
diff --git a/server/subsonic/e2e/subsonic_multilibrary_test.go b/server/subsonic/e2e/subsonic_multilibrary_test.go
index e652cf492..98f87ca17 100644
--- a/server/subsonic/e2e/subsonic_multilibrary_test.go
+++ b/server/subsonic/e2e/subsonic_multilibrary_test.go
@@ -6,7 +6,6 @@ import (
"github.com/Masterminds/squirrel"
"github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/metrics"
"github.com/navidrome/navidrome/core/playlists"
@@ -53,8 +52,8 @@ var _ = Describe("Multi-Library Support", Ordered, func() {
adminWithLibs = *loadedAdmin
// Run incremental scan to import lib2 content (lib1 files unchanged → skipped)
- s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
+ s := scanner.New(ctx, ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
_, err = s.ScanAll(ctx, false)
Expect(err).ToNot(HaveOccurred())
diff --git a/server/subsonic/e2e/subsonic_sonic_similarity_test.go b/server/subsonic/e2e/subsonic_sonic_similarity_test.go
index 775fefe89..c0cb1d359 100644
--- a/server/subsonic/e2e/subsonic_sonic_similarity_test.go
+++ b/server/subsonic/e2e/subsonic_sonic_similarity_test.go
@@ -9,6 +9,7 @@ import (
"github.com/Masterminds/squirrel"
"github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/agents"
+ "github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/lyrics"
"github.com/navidrome/navidrome/core/matcher"
"github.com/navidrome/navidrome/core/metrics"
@@ -43,7 +44,7 @@ func buildSonicRouter(provider sonic.Provider) *subsonic.Router {
noopProvider{},
nil, // scanner
events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)),
scrobbler.NewPlayTracker(ds, events.NoopBroker(), nil),
core.NewShare(ds),
playback.PlaybackServer(nil),
diff --git a/server/subsonic/helpers.go b/server/subsonic/helpers.go
index b986200ae..e367cdee5 100644
--- a/server/subsonic/helpers.go
+++ b/server/subsonic/helpers.go
@@ -95,13 +95,24 @@ func getArtistAlbumCount(a *model.Artist) int32 {
}
}
+// coverArtOrEmpty stamps the (hash-suffixed) coverArt id, or omits it (empty
+// string + the field's omitempty tag) when artwork is known absent.
+func coverArtOrEmpty(id model.ArtworkID, absent bool) string {
+ if absent {
+ return ""
+ }
+ return id.String()
+}
+
func toArtist(r *http.Request, a model.Artist) responses.Artist {
artist := responses.Artist{
- Id: a.ID,
- Name: a.Name,
- UserRating: int32(a.Rating),
- CoverArt: a.CoverArtID().String(),
- ArtistImageUrl: publicurl.ImageURL(r, a.CoverArtID(), 600),
+ Id: a.ID,
+ Name: a.Name,
+ UserRating: int32(a.Rating),
+ CoverArt: coverArtOrEmpty(a.CoverArtID(), a.ImageAbsent),
+ }
+ if !a.ImageAbsent {
+ artist.ArtistImageUrl = publicurl.ImageURL(r, a.CoverArtID(), 600)
}
if conf.Server.Subsonic.EnableAverageRating {
artist.AverageRating = a.AverageRating
@@ -114,12 +125,14 @@ func toArtist(r *http.Request, a model.Artist) responses.Artist {
func toArtistID3(r *http.Request, a model.Artist) responses.ArtistID3 {
artist := responses.ArtistID3{
- Id: a.ID,
- Name: a.Name,
- AlbumCount: getArtistAlbumCount(&a),
- CoverArt: a.CoverArtID().String(),
- ArtistImageUrl: publicurl.ImageURL(r, a.CoverArtID(), 600),
- UserRating: int32(a.Rating),
+ Id: a.ID,
+ Name: a.Name,
+ AlbumCount: getArtistAlbumCount(&a),
+ CoverArt: coverArtOrEmpty(a.CoverArtID(), a.ImageAbsent),
+ UserRating: int32(a.Rating),
+ }
+ if !a.ImageAbsent {
+ artist.ArtistImageUrl = publicurl.ImageURL(r, a.CoverArtID(), 600)
}
if conf.Server.Subsonic.EnableAverageRating {
artist.AverageRating = a.AverageRating
@@ -208,7 +221,7 @@ func childFromMediaFile(ctx context.Context, mf model.MediaFile) responses.Child
child.Size = mf.Size
child.Suffix = mf.Suffix
child.BitRate = int32(mf.BitRate)
- child.CoverArt = mf.CoverArtID().String()
+ child.CoverArt = coverArtOrEmpty(mf.CoverArtID(), mf.ImageAbsent)
child.ContentType = mf.ContentType()
if ok && player.ReportRealPath {
@@ -369,7 +382,7 @@ func childFromAlbum(ctx context.Context, al model.Album) responses.Child {
child.Artist = al.AlbumArtist
child.Year = int32(cmp.Or(al.MaxOriginalYear, al.MaxYear))
child.Genre = al.Genre
- child.CoverArt = al.CoverArtID().String()
+ child.CoverArt = coverArtOrEmpty(al.CoverArtID(), al.ImageAbsent)
child.Created = new(albumCreatedAt(al))
child.Parent = al.AlbumArtistID
child.ArtistId = al.AlbumArtistID
@@ -460,7 +473,7 @@ func buildAlbumID3(ctx context.Context, album model.Album) responses.AlbumID3 {
dir.Name = album.FullName()
dir.Artist = album.AlbumArtist
dir.ArtistId = album.AlbumArtistID
- dir.CoverArt = album.CoverArtID().String()
+ dir.CoverArt = coverArtOrEmpty(album.CoverArtID(), album.ImageAbsent)
dir.SongCount = int32(album.SongCount)
dir.Duration = int32(album.Duration)
dir.PlayCount = album.PlayCount
diff --git a/server/subsonic/helpers_test.go b/server/subsonic/helpers_test.go
index 8db624649..69fda4681 100644
--- a/server/subsonic/helpers_test.go
+++ b/server/subsonic/helpers_test.go
@@ -321,6 +321,82 @@ var _ = Describe("helpers", func() {
})
})
+ Describe("artwork coverArt emission", func() {
+ const hash = "0123456789abcdef"
+ ctx := context.Background()
+
+ DescribeTable("coverArtOrEmpty",
+ func(id model.ArtworkID, absent bool, expected string) {
+ Expect(coverArtOrEmpty(id, absent)).To(Equal(expected))
+ },
+ Entry("emits the bare id when unresolved", model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1"}, false, "al-1"),
+ Entry("emits the hash-suffixed id when resolved", model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1", Hash: hash}, false, "al-1_"+hash),
+ Entry("omits (empty) when known absent", model.ArtworkID{Kind: model.KindAlbumArtwork, ID: "1", Hash: hash}, true, ""),
+ )
+
+ Describe("childFromAlbum", func() {
+ It("suffixes coverArt with the content hash when resolved", func() {
+ al := model.Album{ID: "al-1", ItemImage: model.ItemImage{ImageHash: hash}}
+ Expect(childFromAlbum(ctx, al).CoverArt).To(Equal("al-al-1_" + hash))
+ })
+ It("omits coverArt when known absent", func() {
+ al := model.Album{ID: "al-1", ItemImage: model.ItemImage{ImageAbsent: true}}
+ Expect(childFromAlbum(ctx, al).CoverArt).To(BeEmpty())
+ })
+ It("emits the bare id when unresolved", func() {
+ al := model.Album{ID: "al-1"}
+ Expect(childFromAlbum(ctx, al).CoverArt).To(Equal("al-al-1"))
+ })
+ })
+
+ Describe("childFromMediaFile", func() {
+ // An al- id must carry the album's hash (AlbumImage), never the track's own.
+ It("suffixes coverArt with the album's content hash when resolved", func() {
+ mf := model.MediaFile{ID: "mf-1", AlbumID: "al-1", AlbumImage: model.ItemImage{ImageHash: hash}}
+ Expect(childFromMediaFile(ctx, mf).CoverArt).To(Equal("al-al-1_" + hash))
+ })
+
+ It("does not stamp a track's own art hash onto the album id", func() {
+ mf := model.MediaFile{ID: "mf-1", AlbumID: "al-1",
+ ItemImage: model.ItemImage{ImageHash: "0000ownarthash00"},
+ AlbumImage: model.ItemImage{ImageHash: hash}}
+ Expect(childFromMediaFile(ctx, mf).CoverArt).To(Equal("al-al-1_" + hash))
+ })
+ It("omits coverArt when known absent", func() {
+ mf := model.MediaFile{ID: "mf-1", AlbumID: "al-1", ItemImage: model.ItemImage{ImageAbsent: true}}
+ Expect(childFromMediaFile(ctx, mf).CoverArt).To(BeEmpty())
+ })
+ It("emits the bare id when unresolved", func() {
+ mf := model.MediaFile{ID: "mf-1", AlbumID: "al-1"}
+ Expect(childFromMediaFile(ctx, mf).CoverArt).To(Equal("al-al-1"))
+ })
+ })
+
+ Describe("toArtist / toArtistID3", func() {
+ r := httptest.NewRequest("GET", "/test", nil)
+ It("emits both coverArt and imageUrl when resolved", func() {
+ a := model.Artist{ID: "ar-1", ItemImage: model.ItemImage{ImageHash: hash}}
+ artist := toArtist(r, a)
+ Expect(artist.CoverArt).To(Equal("ar-ar-1_" + hash))
+ Expect(artist.ArtistImageUrl).ToNot(BeEmpty())
+ })
+ It("omits coverArt and imageUrl when known absent", func() {
+ a := model.Artist{ID: "ar-1", ItemImage: model.ItemImage{ImageAbsent: true}}
+ artist := toArtist(r, a)
+ Expect(artist.CoverArt).To(BeEmpty())
+ Expect(artist.ArtistImageUrl).To(BeEmpty())
+
+ id3 := toArtistID3(r, a)
+ Expect(id3.CoverArt).To(BeEmpty())
+ Expect(id3.ArtistImageUrl).To(BeEmpty())
+ })
+ It("emits an imageUrl when unresolved", func() {
+ a := model.Artist{ID: "ar-1"}
+ Expect(toArtist(r, a).ArtistImageUrl).ToNot(BeEmpty())
+ })
+ })
+ })
+
Describe("osChildFromMediaFile", func() {
var mf model.MediaFile
var ctx context.Context
diff --git a/server/subsonic/media_retrieval.go b/server/subsonic/media_retrieval.go
index 089a1fdda..8a5152a9d 100644
--- a/server/subsonic/media_retrieval.go
+++ b/server/subsonic/media_retrieval.go
@@ -13,6 +13,7 @@ import (
"github.com/navidrome/navidrome/log"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/resources"
+ "github.com/navidrome/navidrome/server/imghttp"
"github.com/navidrome/navidrome/server/subsonic/responses"
"github.com/navidrome/navidrome/utils/gravatar"
"github.com/navidrome/navidrome/utils/req"
@@ -66,7 +67,7 @@ func (api *Router) GetCoverArt(w http.ResponseWriter, r *http.Request) (*respons
size := p.IntOr("size", 0)
square := p.BoolOr("square", false)
- imgReader, lastUpdate, err := api.artwork.GetOrPlaceholder(ctx, id, size, square)
+ img, err := api.artwork.GetOrPlaceholder(ctx, id, size, square)
switch {
case errors.Is(err, context.Canceled):
return nil, nil
@@ -78,11 +79,13 @@ func (api *Router) GetCoverArt(w http.ResponseWriter, r *http.Request) (*respons
return nil, err
}
- defer imgReader.Close()
- w.Header().Set("cache-control", "public, max-age=315360000")
- w.Header().Set("last-modified", lastUpdate.Format(http.TimeFormat))
+ defer img.Close()
- cnt, err := io.Copy(w, imgReader)
+ artID, _ := model.ParseArtworkID(id)
+ if imghttp.WriteImageHeaders(w, r, img, artID.Hash) {
+ return nil, nil
+ }
+ cnt, err := io.Copy(w, img)
if err != nil {
log.Warn(ctx, "Error sending image", "count", cnt, err)
}
diff --git a/server/subsonic/media_retrieval_test.go b/server/subsonic/media_retrieval_test.go
index 9331dfbe4..7610c866a 100644
--- a/server/subsonic/media_retrieval_test.go
+++ b/server/subsonic/media_retrieval_test.go
@@ -17,6 +17,7 @@ import (
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/lyrics"
"github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/model/request"
"github.com/navidrome/navidrome/tests"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
@@ -30,8 +31,14 @@ var _ = Describe("MediaRetrievalController", func() {
var w *httptest.ResponseRecorder
BeforeEach(func() {
+ albumRepo := &tests.MockAlbumRepo{}
+ albumRepo.SetData(model.Albums{{ID: "34"}}) // the id the specs request, made accessible
+ radioRepo := tests.CreateMockedRadioRepo()
+ Expect(radioRepo.Put(&model.Radio{ID: "rd1", Name: "Radio"})).To(Succeed())
ds = &tests.MockDataStore{
MockedMediaFile: mockRepo,
+ MockedAlbum: albumRepo,
+ MockedRadio: radioRepo,
}
artwork = &fakeArtwork{data: "image data"}
router = New(ds, artwork, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, lyrics.NewLyrics(ds, nil), nil, nil)
@@ -60,6 +67,22 @@ var _ = Describe("MediaRetrievalController", func() {
Expect(w.Body.String()).To(Equal(artwork.data))
})
+ // The service applies the library filter from the caller's context, so elevating here
+ // would bypass it.
+ It("passes the caller's context to the service rather than elevating", func() {
+ r := newGetRequest("id=al-34")
+ usr := model.User{ID: "u1", UserName: "u1"}
+ r = r.WithContext(request.WithUser(r.Context(), usr))
+
+ _, err := router.GetCoverArt(w, r)
+
+ Expect(err).ToNot(HaveOccurred())
+ got, ok := request.UserFrom(artwork.recvCtx)
+ Expect(ok).To(BeTrue(), "the service must see who is asking")
+ Expect(got.ID).To(Equal("u1"))
+ Expect(got.IsAdmin).To(BeFalse(), "the handler must not elevate")
+ })
+
It("should fail when the file is not found", func() {
artwork.err = model.ErrNotFound
r := newGetRequest("id=34", "size=128", "square=true")
@@ -108,6 +131,53 @@ var _ = Describe("MediaRetrievalController", func() {
Expect(w.Body.String()).To(BeEmpty())
})
})
+
+ Describe("caching headers", func() {
+ const hash = "0123456789abcdef"
+
+ It("sets an ETag and no-cache for a bare id", func() {
+ artwork.hash = hash
+ r := newGetRequest("id=al-34")
+ _, err := router.GetCoverArt(w, r)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(w.Header().Get("ETag")).To(Equal(`"` + hash + `"`))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, no-cache"))
+ Expect(w.Body.String()).To(Equal(artwork.data))
+ })
+
+ It("marks the response immutable when the id asserts the current hash", func() {
+ artwork.hash = hash
+ r := newGetRequest("id=al-34_" + hash)
+ _, err := router.GetCoverArt(w, r)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(w.Header().Get("Cache-Control")).To(Equal("public, max-age=31536000, immutable"))
+ })
+
+ It("returns 304 with no body when If-None-Match matches", func() {
+ artwork.hash = hash
+ r := newGetRequest("id=al-34")
+ r.Header.Set("If-None-Match", `"`+hash+`"`)
+ _, err := router.GetCoverArt(w, r)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(w.Code).To(Equal(304))
+ Expect(w.Body.Len()).To(BeZero())
+ })
+
+ It("never caches a placeholder", func() {
+ artwork.placeholder = true
+ r := newGetRequest("id=al-missing")
+ _, err := router.GetCoverArt(w, r)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(w.Code).To(Equal(200))
+ Expect(w.Header().Get("Cache-Control")).To(Equal("no-store"))
+ Expect(w.Header().Get("ETag")).To(BeEmpty())
+ Expect(w.Body.String()).To(Equal(artwork.data))
+ })
+ })
})
Describe("GetLyrics", func() {
@@ -188,25 +258,35 @@ var _ = Describe("MediaRetrievalController", func() {
type fakeArtwork struct {
artwork.Artwork
data string
+ hash string
+ lastUpdated time.Time
+ placeholder bool
err error
ctxCancelFunc func()
recvId string
recvSize int
recvSquare bool
+ recvCtx context.Context
}
-func (c *fakeArtwork) GetOrPlaceholder(_ context.Context, id string, size int, square bool) (io.ReadCloser, time.Time, error) {
+func (c *fakeArtwork) GetOrPlaceholder(ctx context.Context, id string, size int, square bool) (*artwork.Image, error) {
+ c.recvCtx = ctx
if c.err != nil {
- return nil, time.Time{}, c.err
+ return nil, c.err
}
c.recvId = id
c.recvSize = size
c.recvSquare = square
if c.ctxCancelFunc != nil {
c.ctxCancelFunc()
- return nil, time.Time{}, context.Canceled
+ return nil, context.Canceled
}
- return io.NopCloser(bytes.NewReader([]byte(c.data))), time.Time{}, nil
+ return &artwork.Image{
+ ReadCloser: io.NopCloser(bytes.NewReader([]byte(c.data))),
+ Hash: c.hash,
+ LastUpdated: c.lastUpdated,
+ Placeholder: c.placeholder,
+ }, nil
}
type mockedMediaFile struct {
diff --git a/server/subsonic/playlists.go b/server/subsonic/playlists.go
index 17ba1b2c9..bd53528d9 100644
--- a/server/subsonic/playlists.go
+++ b/server/subsonic/playlists.go
@@ -151,7 +151,7 @@ func (api *Router) buildPlaylist(ctx context.Context, p model.Playlist) response
pls.Comment = p.Comment
pls.Owner = p.OwnerName
pls.Public = p.Public
- pls.CoverArt = p.CoverArtID().String()
+ pls.CoverArt = coverArtOrEmpty(p.CoverArtID(), p.ImageAbsent)
pls.OpenSubsonicPlaylist = buildOSPlaylist(ctx, p)
return pls
diff --git a/server/subsonic/playlists_test.go b/server/subsonic/playlists_test.go
index f0a2f8ac5..a7c9e2ec7 100644
--- a/server/subsonic/playlists_test.go
+++ b/server/subsonic/playlists_test.go
@@ -129,6 +129,19 @@ var _ = Describe("buildPlaylist", func() {
})
})
+ Context("artwork emission", func() {
+ It("suffixes coverArt with the content hash when resolved", func() {
+ playlist.ImageHash = "0123456789abcdef"
+ result := router.buildPlaylist(ctx, playlist)
+ Expect(result.CoverArt).To(Equal("pl-pls-1_0123456789abcdef"))
+ })
+ It("omits coverArt when known absent", func() {
+ playlist.ImageAbsent = true
+ result := router.buildPlaylist(ctx, playlist)
+ Expect(result.CoverArt).To(BeEmpty())
+ })
+ })
+
Context("with legacy client", func() {
BeforeEach(func() {
conf.Server.Subsonic.LegacyClients = "legacy-client"
diff --git a/server/subsonic/radio.go b/server/subsonic/radio.go
index 4fbd6a53d..1fb266f1d 100644
--- a/server/subsonic/radio.go
+++ b/server/subsonic/radio.go
@@ -74,10 +74,10 @@ func (api *Router) GetInternetRadios(r *http.Request) (*responses.Subsonic, erro
if strings.Contains(conf.Server.Subsonic.LegacyClients, player.Client) {
continue
}
- // Add coverArt if not legacy client
+ // Add coverArt if not legacy client; only radios have an uploaded image as their sole art source
var coverArt string
if g.UploadedImage != "" {
- coverArt = g.CoverArtID().String()
+ coverArt = coverArtOrEmpty(g.CoverArtID(), g.ImageAbsent)
}
res[i].OpenSubsonicRadio = &responses.OpenSubsonicRadio{
CoverArt: coverArt,
diff --git a/server/subsonic/radio_test.go b/server/subsonic/radio_test.go
index e959ebe29..aa805abbf 100644
--- a/server/subsonic/radio_test.go
+++ b/server/subsonic/radio_test.go
@@ -71,10 +71,25 @@ var _ = Describe("Radio", func() {
Expect(err).ToNot(HaveOccurred())
Expect(response.InternetRadioStations.Radios).To(HaveLen(2))
Expect(response.InternetRadioStations.Radios[0].OpenSubsonicRadio).ToNot(BeNil())
- Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1_0"))
+ Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1"))
Expect(response.InternetRadioStations.Radios[1].OpenSubsonicRadio).ToNot(BeNil())
Expect(response.InternetRadioStations.Radios[1].CoverArt).To(BeEmpty())
})
+
+ It("suffixes coverArt with the content hash when resolved and omits it when known absent", func() {
+ radioRepo.All = model.Radios{
+ {ID: "rd-1", Name: "Radio 1", UploadedImage: "rd-1_cover.jpg", ItemImage: model.ItemImage{ImageHash: "0123456789abcdef"}},
+ {ID: "rd-2", Name: "Radio 2", UploadedImage: "rd-2_cover.jpg", ItemImage: model.ItemImage{ImageAbsent: true}},
+ }
+ r := httptest.NewRequest("GET", "/rest/getInternetRadios", nil)
+ r = r.WithContext(ctx)
+
+ response, err := api.GetInternetRadios(r)
+
+ Expect(err).ToNot(HaveOccurred())
+ Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1_0123456789abcdef"))
+ Expect(response.InternetRadioStations.Radios[1].CoverArt).To(BeEmpty())
+ })
})
Context("with a legacy client", func() {
@@ -129,7 +144,7 @@ var _ = Describe("Radio", func() {
Expect(err).ToNot(HaveOccurred())
Expect(response.InternetRadioStations.Radios[0].OpenSubsonicRadio).ToNot(BeNil())
- Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1_0"))
+ Expect(response.InternetRadioStations.Radios[0].CoverArt).To(Equal("ra-rd-1"))
})
})
diff --git a/server/subsonic/searching.go b/server/subsonic/searching.go
index 5d4989ae5..cc787f041 100644
--- a/server/subsonic/searching.go
+++ b/server/subsonic/searching.go
@@ -110,11 +110,13 @@ func (api *Router) Search2(r *http.Request) (*responses.Subsonic, error) {
searchResult2 := &responses.SearchResult2{}
searchResult2.Artist = slice.Map(as, func(artist model.Artist) responses.Artist {
a := responses.Artist{
- Id: artist.ID,
- Name: artist.Name,
- UserRating: int32(artist.Rating),
- CoverArt: artist.CoverArtID().String(),
- ArtistImageUrl: publicurl.ImageURL(r, artist.CoverArtID(), 600),
+ Id: artist.ID,
+ Name: artist.Name,
+ UserRating: int32(artist.Rating),
+ CoverArt: coverArtOrEmpty(artist.CoverArtID(), artist.ImageAbsent),
+ }
+ if !artist.ImageAbsent {
+ a.ArtistImageUrl = publicurl.ImageURL(r, artist.CoverArtID(), 600)
}
if artist.Starred {
a.Starred = artist.StarredAt
diff --git a/server/subsonic/searching_test.go b/server/subsonic/searching_test.go
index 4e72bd2e6..d31a50cfa 100644
--- a/server/subsonic/searching_test.go
+++ b/server/subsonic/searching_test.go
@@ -1,6 +1,8 @@
package subsonic
import (
+ "net/http"
+
"github.com/Masterminds/squirrel"
"github.com/navidrome/navidrome/core/auth"
"github.com/navidrome/navidrome/model"
@@ -209,4 +211,32 @@ var _ = Describe("Search", func() {
})
})
})
+
+ Describe("artwork emission", func() {
+ newSearchRequest := func() *http.Request {
+ r := newGetRequest("query=test")
+ ctx := request.WithUser(r.Context(), model.User{ID: "user1", Libraries: []model.Library{{ID: 1}}})
+ return r.WithContext(ctx)
+ }
+
+ It("omits coverArt and imageUrl for a known-absent artist", func() {
+ mockArtistRepo.SetData(model.Artists{
+ {ID: "ar-1", Name: "Absent Artist", ItemImage: model.ItemImage{ImageAbsent: true}},
+ })
+ resp, err := router.Search2(newSearchRequest())
+ Expect(err).ToNot(HaveOccurred())
+ Expect(resp.SearchResult2.Artist).To(HaveLen(1))
+ Expect(resp.SearchResult2.Artist[0].CoverArt).To(BeEmpty())
+ Expect(resp.SearchResult2.Artist[0].ArtistImageUrl).To(BeEmpty())
+ })
+
+ It("emits coverArt and imageUrl for an unresolved artist", func() {
+ mockArtistRepo.SetData(model.Artists{{ID: "ar-1", Name: "Unresolved Artist"}})
+ resp, err := router.Search2(newSearchRequest())
+ Expect(err).ToNot(HaveOccurred())
+ Expect(resp.SearchResult2.Artist).To(HaveLen(1))
+ Expect(resp.SearchResult2.Artist[0].CoverArt).To(Equal("ar-ar-1"))
+ Expect(resp.SearchResult2.Artist[0].ArtistImageUrl).ToNot(BeEmpty())
+ })
+ })
})
diff --git a/tests/harness/harness.go b/tests/harness/harness.go
index ff5ce8919..5949c4fae 100644
--- a/tests/harness/harness.go
+++ b/tests/harness/harness.go
@@ -13,7 +13,6 @@ import (
"testing/fstest"
"github.com/navidrome/navidrome/conf"
- "github.com/navidrome/navidrome/core"
"github.com/navidrome/navidrome/core/artwork"
"github.com/navidrome/navidrome/core/auth"
"github.com/navidrome/navidrome/core/ffmpeg"
@@ -74,8 +73,8 @@ func SetupDB(ctx context.Context, users ...*model.User) *DB {
u.Libraries = loaded.Libraries
}
- s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
- playlists.NewPlaylists(ds, core.NewImageUploadService()), metrics.NewNoopInstance())
+ s := scanner.New(ctx, ds, events.NoopBroker(),
+ playlists.NewPlaylists(ds, artwork.NewUploader(ds)), metrics.NewNoopInstance())
_, err := s.ScanAll(ctx, true)
Expect(err).ToNot(HaveOccurred())
@@ -87,17 +86,12 @@ func SetupDB(ctx context.Context, users ...*model.User) *DB {
return h
}
-// Restore reloads every table from the golden snapshot via ATTACH DATABASE — much faster than a
-// rescan. FTS shadow tables are skipped; they are kept in sync by their content tables' triggers.
-func (h *DB) Restore() {
- sqlDB := db.Db()
- _, err := sqlDB.Exec("PRAGMA foreign_keys = OFF")
- Expect(err).ToNot(HaveOccurred())
- _, err = sqlDB.Exec("ATTACH DATABASE ? AS snapshot", h.SnapshotPath)
- Expect(err).ToNot(HaveOccurred())
-
- rows, err := sqlDB.Query("SELECT name FROM main.sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts' AND name NOT LIKE '%_fts_%'")
+// ResettableTables lists the tables a per-spec reset may write. FTS shadow tables are excluded:
+// their content tables' triggers keep them in sync, and writing them directly corrupts the index.
+func ResettableTables() []string {
+ rows, err := db.Db().Query("SELECT name FROM main.sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '%_fts' AND name NOT LIKE '%_fts_%'")
Expect(err).ToNot(HaveOccurred())
+ defer rows.Close()
var tables []string
for rows.Next() {
var name string
@@ -105,12 +99,37 @@ func (h *DB) Restore() {
tables = append(tables, name)
}
Expect(rows.Err()).ToNot(HaveOccurred())
- rows.Close()
+ return tables
+}
+
+// TruncateDB empties every resettable table, leaving the migrated schema in place — for suites
+// whose specs each build their own library, so the schema is not re-migrated per spec.
+func TruncateDB(tables []string) {
+ sqlDB := db.Db()
+ _, err := sqlDB.Exec("PRAGMA foreign_keys = OFF")
+ Expect(err).ToNot(HaveOccurred())
+ defer func() { _, _ = sqlDB.Exec("PRAGMA foreign_keys = ON") }()
for _, table := range tables {
// Table names come from sqlite_master, not user input.
_, err = sqlDB.Exec(`DELETE FROM main."` + table + `"`) //nolint:gosec
Expect(err).ToNot(HaveOccurred())
+ }
+}
+
+// Restore reloads every table from the golden snapshot via ATTACH DATABASE — much faster than a
+// rescan.
+func (h *DB) Restore() {
+ sqlDB := db.Db()
+ _, err := sqlDB.Exec("PRAGMA foreign_keys = OFF")
+ Expect(err).ToNot(HaveOccurred())
+ _, err = sqlDB.Exec("ATTACH DATABASE ? AS snapshot", h.SnapshotPath)
+ Expect(err).ToNot(HaveOccurred())
+
+ for _, table := range ResettableTables() {
+ // Table names come from sqlite_master, not user input.
+ _, err = sqlDB.Exec(`DELETE FROM main."` + table + `"`) //nolint:gosec
+ Expect(err).ToNot(HaveOccurred())
_, err = sqlDB.Exec(`INSERT INTO main."` + table + `" SELECT * FROM snapshot."` + table + `"`) //nolint:gosec
Expect(err).ToNot(HaveOccurred())
}
diff --git a/tests/mock_album_repo.go b/tests/mock_album_repo.go
index cc7d66b4d..ff6f9cff6 100644
--- a/tests/mock_album_repo.go
+++ b/tests/mock_album_repo.go
@@ -2,10 +2,12 @@ package tests
import (
"errors"
+ "sync"
"time"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/id"
+ "github.com/navidrome/navidrome/utils/slice"
)
func CreateMockAlbumRepo() *MockAlbumRepo {
@@ -20,6 +22,7 @@ type MockAlbumRepo struct {
All model.Albums
Err bool
Options model.QueryOptions
+ optionsMu sync.Mutex
SearchQuery string // last query passed to Search
ReassignAnnotationCalls map[string]string // prevID -> newID
CopyAttributesCalls map[string]string // fromID -> toID
@@ -68,7 +71,10 @@ func (m *MockAlbumRepo) Put(al *model.Album) error {
func (m *MockAlbumRepo) GetAll(qo ...model.QueryOptions) (model.Albums, error) {
if len(qo) > 0 {
+ // Recording the last options is a read-path write, and callers resolve concurrently.
+ m.optionsMu.Lock()
m.Options = qo[0]
+ m.optionsMu.Unlock()
}
if m.Err {
return nil, errors.New("unexpected error")
@@ -76,6 +82,14 @@ func (m *MockAlbumRepo) GetAll(qo ...model.QueryOptions) (model.Albums, error) {
return m.All, nil
}
+func (m *MockAlbumRepo) GetAllIDs(qo ...model.QueryOptions) ([]string, error) {
+ all, err := m.GetAll(qo...)
+ if err != nil {
+ return nil, err
+ }
+ return slice.Map(all, func(a model.Album) string { return a.ID }), nil
+}
+
func (m *MockAlbumRepo) GetCursor(qo ...model.QueryOptions) (model.AlbumCursor, error) {
res, err := m.GetAll(qo...)
if err != nil {
diff --git a/tests/mock_artist_repo.go b/tests/mock_artist_repo.go
index e6ea7aea4..9691a6584 100644
--- a/tests/mock_artist_repo.go
+++ b/tests/mock_artist_repo.go
@@ -6,6 +6,7 @@ import (
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/id"
+ "github.com/navidrome/navidrome/utils/slice"
)
func CreateMockArtistRepo() *MockArtistRepo {
@@ -113,6 +114,14 @@ func (m *MockArtistRepo) GetAll(options ...model.QueryOptions) (model.Artists, e
return allArtists, nil
}
+func (m *MockArtistRepo) GetAllIDs(options ...model.QueryOptions) ([]string, error) {
+ all, err := m.GetAll(options...)
+ if err != nil {
+ return nil, err
+ }
+ return slice.Map(all, func(a model.Artist) string { return a.ID }), nil
+}
+
func (m *MockArtistRepo) GetCursor(options ...model.QueryOptions) (model.ArtistCursor, error) {
res, err := m.GetAll(options...)
if err != nil {
diff --git a/tests/mock_artwork_queue_repo.go b/tests/mock_artwork_queue_repo.go
new file mode 100644
index 000000000..1b097ca32
--- /dev/null
+++ b/tests/mock_artwork_queue_repo.go
@@ -0,0 +1,258 @@
+package tests
+
+import (
+ "cmp"
+ "slices"
+ "sync"
+ "time"
+
+ "github.com/navidrome/navidrome/model"
+)
+
+type MockArtworkQueueRepo struct {
+ model.ArtworkQueueRepository
+ // mu guards Data: the worker drains this mock concurrently.
+ mu sync.Mutex
+ Data map[string]model.ArtworkQueueItem // keyed by iaKey(kind, id, imageType)
+ Err error
+ // ItemArtworkSource, when set, backs EnqueueStaleAbsent with real item_artwork state.
+ ItemArtworkSource *MockArtworkRepo
+ // ExistingIDs is keyed by item_kind; a nil per-kind map means PurgeDangling keeps that kind.
+ ExistingIDs map[string]map[string]bool
+}
+
+func CreateMockArtworkQueueRepo() *MockArtworkQueueRepo {
+ return &MockArtworkQueueRepo{Data: map[string]model.ArtworkQueueItem{}}
+}
+
+func (m *MockArtworkQueueRepo) Enqueue(items ...model.ArtworkQueueItem) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return m.Err
+ }
+ m.enqueueLocked(items)
+ return nil
+}
+
+func (m *MockArtworkQueueRepo) enqueueLocked(items []model.ArtworkQueueItem) {
+ now := time.Now()
+ for _, it := range items {
+ if it.ImageType == "" {
+ it.ImageType = model.ImageTypePrimary
+ }
+ k := iaKey(it.ItemKind, it.ItemID, it.ImageType)
+ // Mirror the SQL: retry_at/enqueued_at are server-set, never taken from the caller.
+ if prev, ok := m.Data[k]; ok {
+ prev.Priority = max(prev.Priority, it.Priority)
+ prev.RetryAt = now
+ prev.Attempts = 0
+ prev.EnqueuedAt = now
+ m.Data[k] = prev
+ continue
+ }
+ it.Attempts = 0
+ it.RetryAt = now
+ it.EnqueuedAt = now
+ m.Data[k] = it
+ }
+}
+
+// EnqueueIfMissing mirrors the SQL anti-join: skip anything that already has an item_artwork row.
+func (m *MockArtworkQueueRepo) EnqueueIfMissing(items ...model.ArtworkQueueItem) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return m.Err
+ }
+ var fresh []model.ArtworkQueueItem
+ for _, it := range items {
+ k := iaKey(it.ItemKind, it.ItemID, cmp.Or(it.ImageType, model.ImageTypePrimary))
+ if m.ItemArtworkSource != nil {
+ if _, ok := m.ItemArtworkSource.ItemData[k]; ok {
+ continue
+ }
+ }
+ if _, ok := m.Data[k]; ok { // DO NOTHING
+ continue
+ }
+ fresh = append(fresh, it)
+ }
+ m.enqueueLocked(fresh)
+ return nil
+}
+
+func (m *MockArtworkQueueRepo) DequeueBatch(n int, kinds ...string) ([]model.ArtworkQueueItem, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return nil, m.Err
+ }
+ var res []model.ArtworkQueueItem
+ now := time.Now()
+ for _, it := range m.Data {
+ if !it.RetryAt.After(now) && (len(kinds) == 0 || slices.Contains(kinds, it.ItemKind)) {
+ res = append(res, it)
+ }
+ }
+ slices.SortFunc(res, func(a, b model.ArtworkQueueItem) int {
+ return cmp.Or(cmp.Compare(b.Priority, a.Priority), a.EnqueuedAt.Compare(b.EnqueuedAt))
+ })
+ if len(res) > n {
+ res = res[:n]
+ }
+ return res, nil
+}
+
+func (m *MockArtworkQueueRepo) MarkFailedIfUnchanged(kind, id, imageType string, seenRetryAt, retryAt time.Time) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return m.Err
+ }
+ k := iaKey(kind, id, imageType)
+ if it, ok := m.Data[k]; ok && it.RetryAt.Equal(seenRetryAt) {
+ it.Attempts++
+ it.RetryAt = retryAt
+ m.Data[k] = it
+ }
+ return nil
+}
+
+func (m *MockArtworkQueueRepo) DeleteIfUnchanged(kind, id, imageType string, retryAt time.Time) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return m.Err
+ }
+ k := iaKey(kind, id, imageType)
+ if it, ok := m.Data[k]; ok && it.RetryAt.Equal(retryAt) {
+ delete(m.Data, k)
+ }
+ return nil
+}
+
+func (m *MockArtworkQueueRepo) PurgeDangling() (int64, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return 0, m.Err
+ }
+ var purged int64
+ for k, it := range m.Data {
+ existing := m.ExistingIDs[it.ItemKind]
+ if existing == nil {
+ continue
+ }
+ if !existing[it.ItemID] {
+ delete(m.Data, k)
+ purged++
+ }
+ }
+ return purged, nil
+}
+
+func (m *MockArtworkQueueRepo) Count() (int64, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return 0, m.Err
+ }
+ return int64(len(m.Data)), nil
+}
+
+func (m *MockArtworkQueueRepo) EnqueuePreservingBackoff(items ...model.ArtworkQueueItem) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return m.Err
+ }
+ now := time.Now()
+ for _, it := range items {
+ if it.ImageType == "" {
+ it.ImageType = model.ImageTypePrimary
+ }
+ k := iaKey(it.ItemKind, it.ItemID, it.ImageType)
+ // Preserve an existing row's retry_at: a bump raises priority without resetting backoff.
+ if prev, ok := m.Data[k]; ok {
+ prev.Priority = max(prev.Priority, it.Priority)
+ m.Data[k] = prev
+ continue
+ }
+ it.Attempts = 0
+ it.RetryAt = now
+ it.EnqueuedAt = now
+ m.Data[k] = it
+ }
+ return nil
+}
+
+func (m *MockArtworkQueueRepo) EnqueueStaleAbsent(kind model.Kind, attemptedBefore time.Time) (int64, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil || m.ItemArtworkSource == nil {
+ return 0, m.Err
+ }
+ now := time.Now()
+ var inserted int64
+ for _, ia := range m.ItemArtworkSource.ItemData {
+ if ia.ItemKind != kind.Prefix() || ia.Hash != "" || !ia.AttemptedAt.Before(attemptedBefore) {
+ continue
+ }
+ k := iaKey(ia.ItemKind, ia.ItemID, ia.ImageType)
+ if _, ok := m.Data[k]; ok { // DO NOTHING: never touch existing queue rows
+ continue
+ }
+ m.Data[k] = model.ArtworkQueueItem{
+ ItemKind: ia.ItemKind,
+ ItemID: ia.ItemID,
+ ImageType: ia.ImageType,
+ Priority: model.ArtworkPriorityRecheck,
+ RetryAt: now,
+ EnqueuedAt: now,
+ }
+ inserted++
+ }
+ return inserted, nil
+}
+
+// EnqueueMissing mirrors the SQL set-difference insert: ExistingIDs[kind] minus ItemArtworkSource.
+func (m *MockArtworkQueueRepo) EnqueueAllMissing(kind model.Kind, priority int) (int64, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return 0, m.Err
+ }
+ hasRow := func(id string) bool {
+ if m.ItemArtworkSource == nil {
+ return false
+ }
+ for _, ia := range m.ItemArtworkSource.ItemData {
+ if ia.ItemKind == kind.Prefix() && ia.ItemID == id {
+ return true
+ }
+ }
+ return false
+ }
+ now := time.Now()
+ var inserted int64
+ for id := range m.ExistingIDs[kind.Prefix()] {
+ if hasRow(id) {
+ continue
+ }
+ k := iaKey(kind.Prefix(), id, model.ImageTypePrimary)
+ if _, ok := m.Data[k]; ok { // DO NOTHING: never touch existing queue rows
+ continue
+ }
+ m.Data[k] = model.ArtworkQueueItem{
+ ItemKind: kind.Prefix(),
+ ItemID: id,
+ ImageType: model.ImageTypePrimary,
+ Priority: priority,
+ RetryAt: now,
+ EnqueuedAt: now,
+ }
+ inserted++
+ }
+ return inserted, nil
+}
diff --git a/tests/mock_artwork_repo.go b/tests/mock_artwork_repo.go
new file mode 100644
index 000000000..2ace0daba
--- /dev/null
+++ b/tests/mock_artwork_repo.go
@@ -0,0 +1,175 @@
+package tests
+
+import (
+ "maps"
+ "sync"
+ "time"
+
+ "github.com/navidrome/navidrome/model"
+ "github.com/navidrome/navidrome/utils/slice"
+)
+
+type MockArtworkRepo struct {
+ model.ArtworkRepository
+ // mu guards the maps so the worker's concurrent drain can hit this mock race-free.
+ mu sync.Mutex
+ Data map[string]model.Artwork
+ ItemData map[string]model.ItemArtwork // keyed by iaKey(kind, id, imageType)
+ Err error
+ // ExistingIDs, keyed by item_kind, backs PurgeDanglingItems; nil map keeps everything.
+ ExistingIDs map[string]map[string]bool
+}
+
+func CreateMockArtworkRepo() *MockArtworkRepo {
+ return &MockArtworkRepo{Data: map[string]model.Artwork{}, ItemData: map[string]model.ItemArtwork{}}
+}
+
+func iaKey(kind, id, imageType string) string { return kind + "|" + id + "|" + imageType }
+
+func (m *MockArtworkRepo) GetImage(hash string) (*model.Artwork, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return nil, m.Err
+ }
+ if a, ok := m.Data[hash]; ok {
+ return &a, nil
+ }
+ return nil, model.ErrNotFound
+}
+
+func (m *MockArtworkRepo) PutImage(a *model.Artwork) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return m.Err
+ }
+ // Mirrors the SQL repository: every upsert refreshes created_at. Age fixtures via Data directly.
+ a.CreatedAt = time.Now()
+ m.Data[a.Hash] = *a
+ return nil
+}
+
+func (m *MockArtworkRepo) GetMimeByHash() (map[string]string, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return nil, m.Err
+ }
+ mimes := make(map[string]string, len(m.Data))
+ for h, a := range m.Data {
+ mimes[h] = a.Mime
+ }
+ return mimes, nil
+}
+
+func (m *MockArtworkRepo) PurgeDanglingItems() (int64, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return 0, m.Err
+ }
+ var purged int64
+ for k, ia := range m.ItemData {
+ // A nil per-kind map means that kind isn't tracked by the test, so keep it.
+ existing := m.ExistingIDs[ia.ItemKind]
+ if existing == nil {
+ continue
+ }
+ if !existing[ia.ItemID] {
+ delete(m.ItemData, k)
+ purged++
+ }
+ }
+ return purged, nil
+}
+
+func (m *MockArtworkRepo) PurgeOrphans(createdBefore time.Time) (int64, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return 0, m.Err
+ }
+ var deleted int64
+ for h, a := range m.Data {
+ if m.referenced(h) || !a.CreatedAt.Before(createdBefore) {
+ continue
+ }
+ delete(m.Data, h)
+ deleted++
+ }
+ return deleted, nil
+}
+
+func (m *MockArtworkRepo) referenced(hash string) bool {
+ for _, ia := range m.ItemData {
+ if ia.Hash == hash {
+ return true
+ }
+ }
+ return false
+}
+
+func (m *MockArtworkRepo) GetItemArtwork(kind model.Kind, id, imageType string) (*model.ItemArtwork, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return nil, m.Err
+ }
+ if ia, ok := m.ItemData[iaKey(kind.Prefix(), id, imageType)]; ok {
+ return &ia, nil
+ }
+ return nil, model.ErrNotFound
+}
+
+func (m *MockArtworkRepo) PutItemArtwork(ia *model.ItemArtwork) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return m.Err
+ }
+ if ia.ImageType == "" {
+ ia.ImageType = model.ImageTypePrimary
+ }
+ ia.UpdatedAt = time.Now()
+ if ia.AttemptedAt.IsZero() {
+ ia.AttemptedAt = ia.UpdatedAt
+ }
+ m.ItemData[iaKey(ia.ItemKind, ia.ItemID, ia.ImageType)] = *ia
+ return nil
+}
+
+func (m *MockArtworkRepo) DeleteForItems(kind model.Kind, ids []string) error {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return m.Err
+ }
+ idSet := slice.ToSet(ids)
+ maps.DeleteFunc(m.ItemData, func(_ string, ia model.ItemArtwork) bool {
+ _, ok := idSet[ia.ItemID]
+ return ok && ia.ItemKind == kind.Prefix()
+ })
+ return nil
+}
+
+func (m *MockArtworkRepo) GetInfoForItems(kind model.Kind, ids []string) (map[string]model.ItemArtworkInfo, error) {
+ m.mu.Lock()
+ defer m.mu.Unlock()
+ if m.Err != nil {
+ return nil, m.Err
+ }
+ res := map[string]model.ItemArtworkInfo{}
+ for _, id := range ids {
+ if ia, ok := m.ItemData[iaKey(kind.Prefix(), id, model.ImageTypePrimary)]; ok {
+ info := model.ItemArtworkInfo{ItemID: id, Hash: ia.Hash}
+ if a, ok := m.Data[ia.Hash]; ok {
+ info.BlurHash, info.ThumbHash = a.BlurHash, a.ThumbHash
+ info.DominantColor = a.DominantColor
+ info.Width, info.Height = a.Width, a.Height
+ }
+ res[id] = info
+ }
+ }
+ return res, nil
+}
diff --git a/tests/mock_data_store.go b/tests/mock_data_store.go
index e016a28de..32f56a4f0 100644
--- a/tests/mock_data_store.go
+++ b/tests/mock_data_store.go
@@ -28,6 +28,8 @@ type MockDataStore struct {
MockedScrobble model.ScrobbleRepository
MockedRadio model.RadioRepository
MockedPlugin model.PluginRepository
+ MockedArtwork model.ArtworkRepository
+ MockedArtworkQueue model.ArtworkQueueRepository
scrobbleBufferMu sync.Mutex
repoMu sync.Mutex
@@ -37,6 +39,8 @@ type MockDataStore struct {
}
func (db *MockDataStore) Library(ctx context.Context) model.LibraryRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedLibrary != nil {
return db.MockedLibrary
}
@@ -48,6 +52,8 @@ func (db *MockDataStore) Library(ctx context.Context) model.LibraryRepository {
}
func (db *MockDataStore) Folder(ctx context.Context) model.FolderRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedFolder != nil {
return db.MockedFolder
}
@@ -59,6 +65,8 @@ func (db *MockDataStore) Folder(ctx context.Context) model.FolderRepository {
}
func (db *MockDataStore) Tag(ctx context.Context) model.TagRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedTag != nil {
return db.MockedTag
}
@@ -70,6 +78,8 @@ func (db *MockDataStore) Tag(ctx context.Context) model.TagRepository {
}
func (db *MockDataStore) Album(ctx context.Context) model.AlbumRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedAlbum != nil {
return db.MockedAlbum
}
@@ -81,6 +91,8 @@ func (db *MockDataStore) Album(ctx context.Context) model.AlbumRepository {
}
func (db *MockDataStore) Artist(ctx context.Context) model.ArtistRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedArtist != nil {
return db.MockedArtist
}
@@ -92,11 +104,11 @@ func (db *MockDataStore) Artist(ctx context.Context) model.ArtistRepository {
}
func (db *MockDataStore) MediaFile(ctx context.Context) model.MediaFileRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.RealDS != nil && db.MockedMediaFile == nil {
return db.RealDS.MediaFile(ctx)
}
- db.repoMu.Lock()
- defer db.repoMu.Unlock()
if db.MockedMediaFile == nil {
db.MockedMediaFile = CreateMockMediaFileRepo()
}
@@ -104,6 +116,8 @@ func (db *MockDataStore) MediaFile(ctx context.Context) model.MediaFileRepositor
}
func (db *MockDataStore) Genre(ctx context.Context) model.GenreRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedGenre != nil {
return db.MockedGenre
}
@@ -115,6 +129,8 @@ func (db *MockDataStore) Genre(ctx context.Context) model.GenreRepository {
}
func (db *MockDataStore) Playlist(ctx context.Context) model.PlaylistRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedPlaylist != nil {
return db.MockedPlaylist
}
@@ -126,6 +142,8 @@ func (db *MockDataStore) Playlist(ctx context.Context) model.PlaylistRepository
}
func (db *MockDataStore) PlayQueue(ctx context.Context) model.PlayQueueRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedPlayQueue != nil {
return db.MockedPlayQueue
}
@@ -137,6 +155,8 @@ func (db *MockDataStore) PlayQueue(ctx context.Context) model.PlayQueueRepositor
}
func (db *MockDataStore) UserProps(ctx context.Context) model.UserPropsRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedUserProps != nil {
return db.MockedUserProps
}
@@ -148,6 +168,8 @@ func (db *MockDataStore) UserProps(ctx context.Context) model.UserPropsRepositor
}
func (db *MockDataStore) Property(ctx context.Context) model.PropertyRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedProperty != nil {
return db.MockedProperty
}
@@ -159,6 +181,8 @@ func (db *MockDataStore) Property(ctx context.Context) model.PropertyRepository
}
func (db *MockDataStore) Share(ctx context.Context) model.ShareRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedShare != nil {
return db.MockedShare
}
@@ -170,6 +194,8 @@ func (db *MockDataStore) Share(ctx context.Context) model.ShareRepository {
}
func (db *MockDataStore) User(ctx context.Context) model.UserRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedUser != nil {
return db.MockedUser
}
@@ -181,6 +207,8 @@ func (db *MockDataStore) User(ctx context.Context) model.UserRepository {
}
func (db *MockDataStore) Transcoding(ctx context.Context) model.TranscodingRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedTranscoding != nil {
return db.MockedTranscoding
}
@@ -192,6 +220,8 @@ func (db *MockDataStore) Transcoding(ctx context.Context) model.TranscodingRepos
}
func (db *MockDataStore) Player(ctx context.Context) model.PlayerRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedPlayer != nil {
return db.MockedPlayer
}
@@ -203,6 +233,8 @@ func (db *MockDataStore) Player(ctx context.Context) model.PlayerRepository {
}
func (db *MockDataStore) ScrobbleBuffer(ctx context.Context) model.ScrobbleBufferRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.RealDS != nil && db.MockedScrobbleBuffer == nil {
return db.RealDS.ScrobbleBuffer(ctx)
}
@@ -215,6 +247,8 @@ func (db *MockDataStore) ScrobbleBuffer(ctx context.Context) model.ScrobbleBuffe
}
func (db *MockDataStore) Scrobble(ctx context.Context) model.ScrobbleRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedScrobble != nil {
return db.MockedScrobble
}
@@ -226,6 +260,8 @@ func (db *MockDataStore) Scrobble(ctx context.Context) model.ScrobbleRepository
}
func (db *MockDataStore) Radio(ctx context.Context) model.RadioRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedRadio != nil {
return db.MockedRadio
}
@@ -237,6 +273,8 @@ func (db *MockDataStore) Radio(ctx context.Context) model.RadioRepository {
}
func (db *MockDataStore) Plugin(ctx context.Context) model.PluginRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
if db.MockedPlugin != nil {
return db.MockedPlugin
}
@@ -247,6 +285,42 @@ func (db *MockDataStore) Plugin(ctx context.Context) model.PluginRepository {
return db.MockedPlugin
}
+func (db *MockDataStore) Artwork(ctx context.Context) model.ArtworkRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
+ return db.artworkLocked(ctx)
+}
+
+// artworkLocked is the body of Artwork for callers already holding repoMu; repoMu is a plain
+// Mutex, so re-entering through the exported method would deadlock.
+func (db *MockDataStore) artworkLocked(ctx context.Context) model.ArtworkRepository {
+ if db.MockedArtwork != nil {
+ return db.MockedArtwork
+ }
+ if db.RealDS != nil {
+ return db.RealDS.Artwork(ctx)
+ }
+ db.MockedArtwork = CreateMockArtworkRepo()
+ return db.MockedArtwork
+}
+
+func (db *MockDataStore) ArtworkQueue(ctx context.Context) model.ArtworkQueueRepository {
+ db.repoMu.Lock()
+ defer db.repoMu.Unlock()
+ if db.MockedArtworkQueue != nil {
+ return db.MockedArtworkQueue
+ }
+ if db.RealDS != nil {
+ return db.RealDS.ArtworkQueue(ctx)
+ }
+ q := CreateMockArtworkQueueRepo()
+ if aw, ok := db.artworkLocked(ctx).(*MockArtworkRepo); ok {
+ q.ItemArtworkSource = aw
+ }
+ db.MockedArtworkQueue = q
+ return db.MockedArtworkQueue
+}
+
func (db *MockDataStore) WithTx(block func(tx model.DataStore) error, label ...string) error {
return block(db)
}
diff --git a/tests/mock_mediafile_repo.go b/tests/mock_mediafile_repo.go
index 990b91d7c..d993af1a8 100644
--- a/tests/mock_mediafile_repo.go
+++ b/tests/mock_mediafile_repo.go
@@ -123,6 +123,18 @@ func (m *MockMediaFileRepo) GetCursor(qo ...model.QueryOptions) (model.MediaFile
}, nil
}
+func (m *MockMediaFileRepo) GetCursorWithArtwork(qo ...model.QueryOptions) (model.MediaFileCursor, error) {
+ return m.GetCursor(qo...)
+}
+
+func (m *MockMediaFileRepo) GetAllIDs(qo ...model.QueryOptions) ([]string, error) {
+ all, err := m.GetAll(qo...)
+ if err != nil {
+ return nil, err
+ }
+ return slice.Map(all, func(mf model.MediaFile) string { return mf.ID }), nil
+}
+
func (m *MockMediaFileRepo) Put(mf *model.MediaFile) error {
if m.Err {
return errors.New("error")
diff --git a/tests/mock_playlist_repo.go b/tests/mock_playlist_repo.go
index 8f8842c8e..ee645e984 100644
--- a/tests/mock_playlist_repo.go
+++ b/tests/mock_playlist_repo.go
@@ -7,6 +7,7 @@ import (
"github.com/deluan/rest"
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/id"
+ "github.com/navidrome/navidrome/utils/slice"
)
func CreateMockPlaylistRepo() *MockPlaylistRepo {
@@ -52,6 +53,14 @@ func (m *MockPlaylistRepo) GetAll(options ...model.QueryOptions) (model.Playlist
return m.All, nil
}
+func (m *MockPlaylistRepo) GetAllIDs(options ...model.QueryOptions) ([]string, error) {
+ all, err := m.GetAll(options...)
+ if err != nil {
+ return nil, err
+ }
+ return slice.Map(all, func(p model.Playlist) string { return p.ID }), nil
+}
+
func (m *MockPlaylistRepo) GetCursor(options ...model.QueryOptions) (model.PlaylistCursor, error) {
res, err := m.GetAll(options...)
if err != nil {
diff --git a/tests/mock_playlist_track_repo.go b/tests/mock_playlist_track_repo.go
index 2835baadd..83751bb28 100644
--- a/tests/mock_playlist_track_repo.go
+++ b/tests/mock_playlist_track_repo.go
@@ -14,6 +14,7 @@ type MockPlaylistTrackRepo struct {
Reordered bool
AddCount int
Err error
+ AlbumIDs []string // stubbed result for GetAlbumIDs, ignoring options
}
func (m *MockPlaylistTrackRepo) SetData(tracks model.PlaylistTracks) {
@@ -66,6 +67,13 @@ func (m *MockPlaylistTrackRepo) GetCursor(options ...model.QueryOptions) (model.
}, nil
}
+func (m *MockPlaylistTrackRepo) GetAlbumIDs(...model.QueryOptions) ([]string, error) {
+ if m.Err != nil {
+ return nil, m.Err
+ }
+ return m.AlbumIDs, nil
+}
+
func (m *MockPlaylistTrackRepo) GetMediaFileIDs(options ...model.QueryOptions) ([]string, error) {
if m.Err != nil {
return nil, m.Err
diff --git a/tests/mock_radio_repository.go b/tests/mock_radio_repository.go
index c50a529e5..2baeadc5c 100644
--- a/tests/mock_radio_repository.go
+++ b/tests/mock_radio_repository.go
@@ -5,6 +5,7 @@ import (
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/model/id"
+ "github.com/navidrome/navidrome/utils/slice"
)
type MockedRadioRepo struct {
@@ -16,7 +17,7 @@ type MockedRadioRepo struct {
}
func CreateMockedRadioRepo() *MockedRadioRepo {
- return &MockedRadioRepo{}
+ return &MockedRadioRepo{Data: map[string]*model.Radio{}}
}
func (m *MockedRadioRepo) SetError(err bool) {
@@ -73,6 +74,14 @@ func (m *MockedRadioRepo) GetAll(qo ...model.QueryOptions) (model.Radios, error)
return m.All, nil
}
+func (m *MockedRadioRepo) GetAllIDs(qo ...model.QueryOptions) ([]string, error) {
+ all, err := m.GetAll(qo...)
+ if err != nil {
+ return nil, err
+ }
+ return slice.Map(all, func(r model.Radio) string { return r.ID }), nil
+}
+
func (m *MockedRadioRepo) Put(radio *model.Radio, _ ...string) error {
if m.Err {
return errors.New("error")
diff --git a/ui/src/album/AlbumDetails.jsx b/ui/src/album/AlbumDetails.jsx
index cec66eb8b..f55d94ffc 100644
--- a/ui/src/album/AlbumDetails.jsx
+++ b/ui/src/album/AlbumDetails.jsx
@@ -2,7 +2,6 @@ import { useEffect, useState } from 'react'
import {
Card,
CardContent,
- CardMedia,
Collapse,
makeStyles,
Typography,
@@ -21,6 +20,7 @@ import Lightbox from 'react-image-lightbox'
import config from '../config'
import 'react-image-lightbox/style.css'
import subsonic from '../subsonic'
+import { Artwork } from '../common/Artwork'
import {
ArtistLinkField,
CollapsibleComment,
@@ -30,7 +30,6 @@ import {
RatingField,
SizeField,
useAlbumsPerPage,
- useImageLoadingState,
} from '../common'
import { formatFullDate, intersperse } from '../utils'
import AlbumExternalLinks from './AlbumExternalLinks'
@@ -88,9 +87,6 @@ const useStyles = makeStyles(
backgroundColor: 'transparent',
transition: 'opacity 0.3s ease-in-out',
},
- coverLoading: {
- opacity: 0.5,
- },
loveButton: {
top: theme.spacing(-0.2),
left: theme.spacing(0.5),
@@ -223,15 +219,7 @@ const AlbumDetails = (props) => {
const classes = useStyles()
const [expanded, setExpanded] = useState(false)
const [albumInfo, setAlbumInfo] = useState()
- const {
- imageLoading,
- imageError,
- isLightboxOpen,
- handleImageLoad,
- handleImageError,
- handleOpenLightbox,
- handleCloseLightbox,
- } = useImageLoadingState(record.id)
+ const [isLightboxOpen, setLightboxOpen] = useState(false)
let notes = albumInfo?.notes || record.notes
@@ -254,27 +242,18 @@ const AlbumDetails = (props) => {
})
}, [record])
- const imageUrl = subsonic.getCoverArtUrl(record, config.uiCoverArtSize)
const fullImageUrl = subsonic.getCoverArtUrl(record)
return (
<Card className={classes.root}>
<div className={classes.cardContents}>
<div className={classes.coverParent}>
- <CardMedia
- key={record.id}
- component={'img'}
- src={imageUrl}
- width="400"
- height="400"
- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}
- onClick={handleOpenLightbox}
- onLoad={handleImageLoad}
- onError={handleImageError}
+ <Artwork
+ record={record}
+ fit="contain"
+ className={classes.cover}
title={record.name}
- style={{
- cursor: imageError ? 'default' : 'pointer',
- }}
+ onClick={() => setLightboxOpen(true)}
/>
</div>
<div className={classes.details}>
@@ -363,13 +342,13 @@ const AlbumDetails = (props) => {
</Collapse>
</div>
)}
- {isLightboxOpen && !imageError && (
+ {isLightboxOpen && (
<Lightbox
imagePadding={50}
animationDuration={200}
imageTitle={record.name}
mainSrc={fullImageUrl}
- onCloseRequest={handleCloseLightbox}
+ onCloseRequest={() => setLightboxOpen(false)}
/>
)}
</Card>
diff --git a/ui/src/album/AlbumGridView.jsx b/ui/src/album/AlbumGridView.jsx
index 33db9e40f..2e4cb10ba 100644
--- a/ui/src/album/AlbumGridView.jsx
+++ b/ui/src/album/AlbumGridView.jsx
@@ -1,4 +1,4 @@
-import React from 'react'
+import React, { useRef } from 'react'
import {
GridList,
GridListTile,
@@ -11,19 +11,18 @@ import withWidth from '@material-ui/core/withWidth'
import { Link } from 'react-router-dom'
import { linkToRecord, useListContext, Loading } from 'react-admin'
import { withContentRect } from 'react-measure'
+import { useRollChanged } from './useRollChanged'
import { useDrag } from 'react-dnd'
-import subsonic from '../subsonic'
import {
AlbumContextMenu,
PlayButton,
ArtistLinkField,
OverflowTooltip,
- useImageUrl,
} from '../common'
-import config from '../config'
import { DraggableTypes } from '../consts'
import clsx from 'clsx'
import { AlbumDatesField } from './AlbumDatesField.jsx'
+import { Artwork } from '../common/Artwork'
const useStyles = makeStyles(
(theme) => ({
@@ -105,12 +104,12 @@ const useCoverStyles = makeStyles({
display: 'inline-block',
width: '100%',
objectFit: 'contain',
+ // The image fills this box absolutely, so it lends no height: a remount that has not been
+ // re-measured yet would collapse the tile and blank the cover for a frame.
+ aspectRatio: '1',
height: (props) => props.height,
transition: 'opacity 0.3s ease-in-out',
},
- coverLoading: {
- opacity: 0,
- },
})
const getColsForWidth = (width) => {
@@ -138,16 +137,14 @@ const Cover = withContentRect('bounds')(({
[record],
)
- const url = subsonic.getCoverArtUrl(record, config.uiCoverArtSize, true)
- const { imgUrl, loading: imageLoading } = useImageUrl(url)
-
return (
<div ref={measureRef} className={classes.coverContainer}>
<div ref={dragAlbumRef}>
- <img
- src={imgUrl || undefined}
- alt={record.name}
- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}
+ <Artwork
+ record={record}
+ square
+ className={classes.cover}
+ title={record.name}
/>
</div>
</div>
@@ -237,9 +234,21 @@ const LoadedAlbumGrid = ({ ids, data, basePath, width }) => {
)
}
-const AlbumGridView = ({ albumListType, loaded, loading, ...props }) => {
- const hide =
- (loading && albumListType === 'random') || !props.data || !props.ids
+const AlbumGridView = ({
+ albumListType,
+ loaded,
+ loading,
+ seed,
+ shownSeed,
+ ...props
+}) => {
+ // ArtistShow renders this grid too, with no roll to track, so own a ref when none is passed.
+ const ownSeed = useRef(null)
+ // A re-roll replaces every album, so the previous roll must not linger while it loads.
+ const rerolling =
+ useRollChanged(shownSeed ?? ownSeed, seed, loading) &&
+ albumListType === 'random'
+ const hide = rerolling || !props.data || !props.ids
return hide ? <Loading /> : <LoadedAlbumGrid {...props} />
}
diff --git a/ui/src/album/AlbumGridView.test.jsx b/ui/src/album/AlbumGridView.test.jsx
new file mode 100644
index 000000000..1f06c3fd7
--- /dev/null
+++ b/ui/src/album/AlbumGridView.test.jsx
@@ -0,0 +1,18 @@
+import { render } from '@testing-library/react'
+import { describe, it, expect, vi } from 'vitest'
+import AlbumGridView from './AlbumGridView'
+
+// react-admin's Link/useListContext need a router and a store; the grid body is not under test here.
+vi.mock('react-admin', () => ({
+ linkToRecord: () => '/album/1',
+ useListContext: () => ({}),
+ Loading: () => <div data-testid="loading" />,
+}))
+describe('AlbumGridView', () => {
+ // ArtistShow renders the grid through ReferenceManyField, which passes no seed tracking.
+ it('renders without a shownSeed ref', () => {
+ expect(() =>
+ render(<AlbumGridView data={{}} ids={[]} basePath="/album" width="md" />),
+ ).not.toThrow()
+ })
+})
diff --git a/ui/src/album/AlbumList.jsx b/ui/src/album/AlbumList.jsx
index cd73fa0c3..3cb8a648e 100644
--- a/ui/src/album/AlbumList.jsx
+++ b/ui/src/album/AlbumList.jsx
@@ -1,4 +1,4 @@
-import { cloneElement } from 'react'
+import { cloneElement, useRef } from 'react'
import { useSelector } from 'react-redux'
import { Redirect, useLocation } from 'react-router-dom'
import {
@@ -30,6 +30,7 @@ import {
import AlbumListActions from './AlbumListActions'
import AlbumTableView from './AlbumTableView'
import AlbumGridView from './AlbumGridView'
+import { useRollChanged } from './useRollChanged'
import albumLists from './albumLists'
import {
getStoredDefaultView,
@@ -186,9 +187,10 @@ const AlbumListTitle = ({ albumListType }) => {
return <Title subTitle={title} args={{ smart_count: 2 }} />
}
-const AlbumListPagination = ({ albumListType, ...rest }) => {
+const AlbumListPagination = ({ albumListType, seed, shownSeed, ...rest }) => {
const { loading } = useListContext()
- if (loading && albumListType === 'random') {
+ const rerolling = useRollChanged(shownSeed, seed, loading)
+ if (rerolling && albumListType === 'random') {
return null
}
return <Pagination {...rest} />
@@ -198,6 +200,7 @@ const randomStartingSeed = Math.random().toString()
const AlbumList = (props) => {
const { width } = props
+ const shownSeed = useRef(null)
const albumView = useSelector((state) => state.albumView)
const [perPage, perPageOptions] = useAlbumsPerPage(width)
const location = useLocation()
@@ -260,13 +263,20 @@ const AlbumList = (props) => {
<AlbumListPagination
rowsPerPageOptions={perPageOptions}
albumListType={albumListType}
+ seed={seed}
+ shownSeed={shownSeed}
/>
}
title={<AlbumListTitle albumListType={albumListType} />}
>
<ScrollRestorer>
{albumView.grid ? (
- <AlbumGridView albumListType={albumListType} {...props} />
+ <AlbumGridView
+ albumListType={albumListType}
+ seed={seed}
+ shownSeed={shownSeed}
+ {...props}
+ />
) : (
<AlbumTableView {...props} />
)}
diff --git a/ui/src/album/AlbumTableView.jsx b/ui/src/album/AlbumTableView.jsx
index d1a89d512..051d5988e 100644
--- a/ui/src/album/AlbumTableView.jsx
+++ b/ui/src/album/AlbumTableView.jsx
@@ -14,7 +14,7 @@ import { makeStyles } from '@material-ui/core/styles'
import { useDrag } from 'react-dnd'
import {
ArtistLinkField,
- CoverArtAvatar,
+ ArtworkAvatar,
DurationField,
RangeField,
SimpleList,
@@ -164,7 +164,7 @@ const AlbumTableView = ({
)}
leftIcon={(r) => (
<span style={{ marginRight: '8px' }}>
- <CoverArtAvatar record={r} variant="square" />
+ <ArtworkAvatar record={r} variant="square" />
</span>
)}
linkType={'show'}
@@ -173,7 +173,7 @@ const AlbumTableView = ({
/>
) : (
<AlbumDatagrid rowClick={'show'} classes={{ row: classes.row }} {...rest}>
- <CoverArtAvatar source="id" variant="square" />
+ <ArtworkAvatar source="id" variant="square" />
<TextField source="name" />
{columns}
<AlbumContextMenu
diff --git a/ui/src/album/useRollChanged.jsx b/ui/src/album/useRollChanged.jsx
new file mode 100644
index 000000000..b364bdc6b
--- /dev/null
+++ b/ui/src/album/useRollChanged.jsx
@@ -0,0 +1,13 @@
+import { useRef } from 'react'
+
+// Reports that the albums on screen belong to a different roll than the one loading: only a seed
+// change is a re-roll. `shown` is owned above the grid, which a refresh remounts under the new seed.
+export const useRollChanged = (shown, seed, loading) => {
+ const wasLoading = useRef(loading)
+
+ if (!loading && (shown.current === null || wasLoading.current)) {
+ shown.current = seed
+ }
+ wasLoading.current = loading
+ return shown.current !== seed
+}
diff --git a/ui/src/album/useRollChanged.test.jsx b/ui/src/album/useRollChanged.test.jsx
new file mode 100644
index 000000000..0745efb08
--- /dev/null
+++ b/ui/src/album/useRollChanged.test.jsx
@@ -0,0 +1,73 @@
+import { renderHook } from '@testing-library/react-hooks'
+import { describe, it, expect } from 'vitest'
+import { useRollChanged } from './useRollChanged'
+
+describe('useRollChanged', () => {
+ // Passing `shown` in mimics AlbumList owning it across a remount.
+ const setup = (props, shown = { current: null }) => ({
+ shown,
+ ...renderHook(({ seed, loading }) => useRollChanged(shown, seed, loading), {
+ initialProps: props,
+ }),
+ })
+
+ it('reports a change while a load is in flight on a fresh mount', () => {
+ const { result } = setup({ seed: 's1', loading: true })
+ expect(result.current).toBe(true)
+ })
+
+ it('reports no change when mounted with data already in hand', () => {
+ const { result } = setup({ seed: 's1', loading: false })
+ expect(result.current).toBe(false)
+ })
+
+ it('stays false while loading a filter change on the same roll', () => {
+ const { result, rerender } = setup({ seed: 's1', loading: false })
+ rerender({ seed: 's1', loading: true })
+ expect(result.current).toBe(false)
+ })
+
+ it('goes true while loading after the seed changes', () => {
+ const { result, rerender } = setup({ seed: 's1', loading: false })
+ rerender({ seed: 's2', loading: true })
+ expect(result.current).toBe(true)
+ })
+
+ it('clears once the new roll has loaded', () => {
+ const { result, rerender } = setup({ seed: 's1', loading: false })
+ rerender({ seed: 's2', loading: true })
+ expect(result.current).toBe(true)
+ rerender({ seed: 's2', loading: false })
+ expect(result.current).toBe(false)
+ })
+
+ // The seed can land a render before loading flips; the new roll must not be recorded as shown.
+ it('still reports a change when the seed arrives before loading starts', () => {
+ const { result, rerender } = setup({ seed: 's1', loading: false })
+ rerender({ seed: 's2', loading: false })
+ expect(result.current).toBe(true)
+ })
+
+ // Refresh remounts the grid under the new seed a render before the refetch starts.
+ it('reports a change when a refresh remounts the grid before loading starts', () => {
+ const { shown, unmount } = setup({ seed: 's1', loading: false })
+ expect(shown.current).toBe('s1')
+ unmount()
+
+ const remounted = setup({ seed: 's2', loading: false }, shown)
+ expect(remounted.result.current).toBe(true)
+
+ remounted.rerender({ seed: 's2', loading: true })
+ expect(remounted.result.current).toBe(true)
+ remounted.rerender({ seed: 's2', loading: false })
+ expect(remounted.result.current).toBe(false)
+ })
+
+ it('reports no change when a remount keeps the same roll', () => {
+ const { shown, unmount } = setup({ seed: 's1', loading: false })
+ unmount()
+
+ const remounted = setup({ seed: 's1', loading: false }, shown)
+ expect(remounted.result.current).toBe(false)
+ })
+})
diff --git a/ui/src/artist/ArtistList.jsx b/ui/src/artist/ArtistList.jsx
index 4559aa8e6..f4147221e 100644
--- a/ui/src/artist/ArtistList.jsx
+++ b/ui/src/artist/ArtistList.jsx
@@ -22,7 +22,7 @@ import { useDrag } from 'react-dnd'
import clsx from 'clsx'
import {
ArtistContextMenu,
- CoverArtAvatar,
+ ArtworkAvatar,
List,
useGetHandleArtistClick,
RatingField,
@@ -173,7 +173,7 @@ const ArtistListView = ({ hasShow, hasEdit, hasList, width, ...rest }) => {
/>
) : (
<ArtistDatagrid rowClick={handleArtistLink} classes={{ row: classes.row }}>
- <CoverArtAvatar source="id" />
+ <ArtworkAvatar source="id" />
<TextField source="name" />
<FunctionField
source="albumCount"
diff --git a/ui/src/artist/ArtistSimpleList.jsx b/ui/src/artist/ArtistSimpleList.jsx
index 55b6b1a0b..9dcae0470 100644
--- a/ui/src/artist/ArtistSimpleList.jsx
+++ b/ui/src/artist/ArtistSimpleList.jsx
@@ -8,7 +8,7 @@ import ListItemSecondaryAction from '@material-ui/core/ListItemSecondaryAction'
import ListItemText from '@material-ui/core/ListItemText'
import { makeStyles } from '@material-ui/core/styles'
import { sanitizeListRestProps } from 'react-admin'
-import { ArtistContextMenu, CoverArtAvatar, RatingField } from '../common'
+import { ArtistContextMenu, ArtworkAvatar, RatingField } from '../common'
import config from '../config'
const useStyles = makeStyles(
@@ -49,7 +49,7 @@ const ArtistSimpleList = ({
<span key={id} onClick={() => linkType(id)}>
<ListItem className={classes.listItem} button={true}>
<ListItemAvatar>
- <CoverArtAvatar record={data[id]} />
+ <ArtworkAvatar record={data[id]} />
</ListItemAvatar>
<ListItemText
style={{ marginLeft: '8px' }}
diff --git a/ui/src/artist/DesktopArtistDetails.jsx b/ui/src/artist/DesktopArtistDetails.jsx
index dda761097..9269dc8d7 100644
--- a/ui/src/artist/DesktopArtistDetails.jsx
+++ b/ui/src/artist/DesktopArtistDetails.jsx
@@ -3,20 +3,15 @@ import { Typography, Collapse } from '@material-ui/core'
import { makeStyles } from '@material-ui/core'
import Card from '@material-ui/core/Card'
import CardContent from '@material-ui/core/CardContent'
-import CardMedia from '@material-ui/core/CardMedia'
import ArtistExternalLinks from './ArtistExternalLink'
import config from '../config'
-import {
- LoveButton,
- RatingField,
- ImageUploadOverlay,
- useImageLoadingState,
-} from '../common'
+import { LoveButton, RatingField, ImageUploadOverlay } from '../common'
import Lightbox from 'react-image-lightbox'
import ExpandInfoDialog from '../dialogs/ExpandInfoDialog'
import AlbumInfo from '../album/AlbumInfo'
import subsonic from '../subsonic'
import { SafeHTML } from '../common/SafeHTML'
+import { Artwork } from '../common/Artwork'
const useStyles = makeStyles(
(theme) => ({
@@ -49,9 +44,6 @@ const useStyles = makeStyles(
transition: 'opacity 0.3s ease-in-out',
objectFit: 'cover',
},
- coverLoading: {
- opacity: 0.5,
- },
artistImage: {
maxHeight: '12rem',
minHeight: '12rem',
@@ -91,35 +83,18 @@ const DesktopArtistDetails = ({ artistInfo, record, biography }) => {
const [expanded, setExpanded] = useState(false)
const classes = useStyles()
const title = record.name
- const {
- imageLoading,
- imageError,
- isLightboxOpen,
- handleImageLoad,
- handleImageError,
- handleOpenLightbox,
- handleCloseLightbox,
- } = useImageLoadingState(record.id)
+ const [isLightboxOpen, setLightboxOpen] = useState(false)
return (
<div className={classes.root}>
<Card className={classes.artistDetail}>
<Card className={classes.artistImage}>
- {artistInfo && (
- <CardMedia
- key={record.id}
- component="img"
- src={subsonic.getCoverArtUrl(record, config.uiCoverArtSize)}
- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}
- onClick={handleOpenLightbox}
- onLoad={handleImageLoad}
- onError={handleImageError}
- title={title}
- style={{
- cursor: imageError ? 'default' : 'pointer',
- }}
- />
- )}
+ <Artwork
+ record={record}
+ className={classes.cover}
+ title={title}
+ onClick={() => setLightboxOpen(true)}
+ />
<ImageUploadOverlay
entityType="artist"
entityId={record.id}
@@ -175,13 +150,13 @@ const DesktopArtistDetails = ({ artistInfo, record, biography }) => {
)}
</Typography>
</div>
- {isLightboxOpen && !imageError && (
+ {isLightboxOpen && (
<Lightbox
imagePadding={50}
animationDuration={200}
imageTitle={record.name}
mainSrc={subsonic.getCoverArtUrl(record)}
- onCloseRequest={handleCloseLightbox}
+ onCloseRequest={() => setLightboxOpen(false)}
/>
)}
</Card>
diff --git a/ui/src/artist/MobileArtistDetails.jsx b/ui/src/artist/MobileArtistDetails.jsx
index e82d4c28a..0925b6f10 100644
--- a/ui/src/artist/MobileArtistDetails.jsx
+++ b/ui/src/artist/MobileArtistDetails.jsx
@@ -2,17 +2,12 @@ import React, { useState } from 'react'
import { Typography, Collapse } from '@material-ui/core'
import { makeStyles } from '@material-ui/core/styles'
import Card from '@material-ui/core/Card'
-import CardMedia from '@material-ui/core/CardMedia'
import config from '../config'
-import {
- LoveButton,
- RatingField,
- ImageUploadOverlay,
- useImageLoadingState,
-} from '../common'
+import { LoveButton, RatingField, ImageUploadOverlay } from '../common'
import Lightbox from 'react-image-lightbox'
import subsonic from '../subsonic'
import { SafeHTML } from '../common/SafeHTML'
+import { Artwork } from '../common/Artwork'
const useStyles = makeStyles(
(theme) => ({
@@ -60,9 +55,6 @@ const useStyles = makeStyles(
transition: 'opacity 0.3s ease-in-out',
objectFit: 'cover',
},
- coverLoading: {
- opacity: 0.5,
- },
artistImage: {
marginLeft: '1em',
maxHeight: '7rem',
@@ -88,41 +80,24 @@ const useStyles = makeStyles(
{ name: 'NDMobileArtistDetails' },
)
-const MobileArtistDetails = ({ artistInfo, biography, record }) => {
+const MobileArtistDetails = ({ biography, record }) => {
const img = subsonic.getCoverArtUrl(record, 800)
const [expanded, setExpanded] = useState(false)
const classes = useStyles({ img, expanded })
const title = record.name
- const {
- imageLoading,
- imageError,
- isLightboxOpen,
- handleImageLoad,
- handleImageError,
- handleOpenLightbox,
- handleCloseLightbox,
- } = useImageLoadingState(record.id)
+ const [isLightboxOpen, setLightboxOpen] = useState(false)
return (
<>
<div className={classes.root}>
<div className={classes.bgContainer}>
<Card className={classes.artistImage}>
- {artistInfo && (
- <CardMedia
- key={record.id}
- component="img"
- src={subsonic.getCoverArtUrl(record, config.uiCoverArtSize)}
- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}
- onClick={handleOpenLightbox}
- onLoad={handleImageLoad}
- onError={handleImageError}
- title={title}
- style={{
- cursor: imageError ? 'default' : 'pointer',
- }}
- />
- )}
+ <Artwork
+ record={record}
+ className={classes.cover}
+ title={title}
+ onClick={() => setLightboxOpen(true)}
+ />
<ImageUploadOverlay
entityType="artist"
entityId={record.id}
@@ -165,13 +140,13 @@ const MobileArtistDetails = ({ artistInfo, biography, record }) => {
</Typography>
</Collapse>
</div>
- {isLightboxOpen && !imageError && (
+ {isLightboxOpen && (
<Lightbox
imagePadding={50}
animationDuration={200}
imageTitle={record.name}
mainSrc={img}
- onCloseRequest={handleCloseLightbox}
+ onCloseRequest={() => setLightboxOpen(false)}
/>
)}
</>
diff --git a/ui/src/common/Artwork.jsx b/ui/src/common/Artwork.jsx
new file mode 100644
index 000000000..21ac5e07b
--- /dev/null
+++ b/ui/src/common/Artwork.jsx
@@ -0,0 +1,127 @@
+import { useEffect, useRef, useState } from 'react'
+import PropTypes from 'prop-types'
+import clsx from 'clsx'
+import { makeStyles } from '@material-ui/core/styles'
+import config from '../config'
+import subsonic from '../subsonic'
+import { useImageUrl } from './useImageUrl'
+import { ThumbHashCanvas } from './ThumbHashCanvas'
+
+// Drives both the CSS transition and the timer that retires the placeholder, so they cannot drift.
+const fadeMs = 150
+
+const useStyles = makeStyles({
+ // className supplies the size and shape; overflow:hidden clips the fills to it.
+ root: {
+ position: 'relative',
+ display: 'inline-flex',
+ overflow: 'hidden',
+ },
+ fill: {
+ position: 'absolute',
+ top: 0,
+ left: 0,
+ width: '100%',
+ height: '100%',
+ },
+ img: {
+ opacity: 0,
+ transition: `opacity ${fadeMs}ms ease-out`,
+ '@media (prefers-reduced-motion: reduce)': { transition: 'none' },
+ },
+ imgVisible: { opacity: 1 },
+ // Already-decoded blobs appear at once: fading them in would re-animate on every remount.
+ imgInstant: { opacity: 1, transition: 'none' },
+})
+
+// Renders a cover through the shared useImageUrl blob cache, so it survives remounts without
+// re-fetching. The image mounts only once its blob is ready, so it never renders broken.
+export const Artwork = ({
+ record,
+ size = config.uiCoverArtSize,
+ square = false,
+ fit = 'cover',
+ className,
+ title,
+ onClick,
+}) => {
+ const classes = useStyles()
+ const url = record ? subsonic.getCoverArtUrl(record, size, square) : ''
+ const { imgUrl, fromCache } = useImageUrl(url)
+
+ const [decoded, setDecoded] = useState(false)
+ const [faded, setFaded] = useState(false)
+ const frame = useRef(0)
+ useEffect(() => {
+ setDecoded(false)
+ setFaded(false)
+ return () => cancelAnimationFrame(frame.current)
+ }, [url])
+
+ // Two frames: a blob decodes from memory, so onLoad can beat the first paint of opacity 0,
+ // leaving the transition no start value and popping some tiles in while others fade.
+ const handleLoad = () => {
+ frame.current = requestAnimationFrame(() => {
+ frame.current = requestAnimationFrame(() => setDecoded(true))
+ })
+ }
+
+ // Timer, not transitionend: under prefers-reduced-motion there is no transition to end.
+ useEffect(() => {
+ if (!decoded || faded) return undefined
+ const timer = setTimeout(() => setFaded(true), fadeMs)
+ return () => clearTimeout(timer)
+ }, [decoded, faded])
+
+ if (!record) return null
+
+ // A blob already cached paints on the first frame, so it skips the fade.
+ const instant = fromCache
+ // Kept mounted until the fade ends; swapping on blob arrival would flash an empty container.
+ const showPlaceholder = !!record.thumbHash && !instant && !faded
+ // A square request is padded, not cropped, so `contain` keeps placeholder and image aligned.
+ const effectiveFit = square ? 'contain' : fit
+ const ratio = record.imageWidth / record.imageHeight
+ const handleClick = imgUrl && onClick ? onClick : undefined
+ return (
+ <div
+ className={clsx(classes.root, className)}
+ onClick={handleClick}
+ style={{ cursor: handleClick ? 'pointer' : 'default' }}
+ >
+ {showPlaceholder && (
+ <ThumbHashCanvas
+ hash={record.thumbHash}
+ ratio={ratio}
+ fit={effectiveFit}
+ className={classes.fill}
+ />
+ )}
+ {imgUrl && (
+ <img
+ src={imgUrl}
+ alt={title}
+ title={title}
+ className={clsx(
+ classes.fill,
+ classes.img,
+ instant && classes.imgInstant,
+ decoded && classes.imgVisible,
+ )}
+ style={{ objectFit: effectiveFit }}
+ onLoad={handleLoad}
+ />
+ )}
+ </div>
+ )
+}
+
+Artwork.propTypes = {
+ record: PropTypes.object,
+ size: PropTypes.number,
+ square: PropTypes.bool,
+ fit: PropTypes.oneOf(['cover', 'contain']),
+ className: PropTypes.string,
+ title: PropTypes.string,
+ onClick: PropTypes.func,
+}
diff --git a/ui/src/common/Artwork.test.jsx b/ui/src/common/Artwork.test.jsx
new file mode 100644
index 000000000..18b3c916f
--- /dev/null
+++ b/ui/src/common/Artwork.test.jsx
@@ -0,0 +1,232 @@
+import { render, fireEvent, act } from '@testing-library/react'
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+vi.mock('./useImageUrl', () => ({ useImageUrl: vi.fn() }))
+vi.mock('../subsonic', () => ({
+ default: {
+ // Mirrors the real hash suffix, so a refreshed record yields a different URL.
+ getCoverArtUrl: (record) =>
+ '/rest/getCoverArt?id=al-1' +
+ (record.imageHash ? `_${record.imageHash}` : ''),
+ },
+}))
+vi.mock('../config', () => ({ default: { uiCoverArtSize: 300 } }))
+
+import { useImageUrl } from './useImageUrl'
+import { Artwork } from './Artwork'
+
+const withArt = {
+ id: 'al-1',
+ name: 'Album',
+ thumbHash: 'H/gNBxpwh4dwd3eIiHd3iHeHeJ+dcH8I',
+}
+
+describe('Artwork', () => {
+ beforeEach(() => {
+ vi.clearAllMocks()
+ // jsdom has no 2D context; stub it so ThumbHashCanvas bails cleanly without console noise
+ HTMLCanvasElement.prototype.getContext = vi.fn(() => null)
+ })
+
+ it('renders nothing without a record', () => {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: false })
+ const { container } = render(<Artwork record={null} />)
+ expect(container.firstChild).toBeNull()
+ })
+
+ it('shows the placeholder and no <img> while loading', () => {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const { container } = render(<Artwork record={withArt} title="Album" />)
+ expect(container.querySelector('canvas')).not.toBeNull()
+ expect(container.querySelector('img')).toBeNull()
+ })
+
+ it('shows neither a broken <img> nor a canvas while loading a record with no thumbhash', () => {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const { container } = render(<Artwork record={{ id: 'al-2', name: 'X' }} />)
+ expect(container.querySelector('img')).toBeNull()
+ expect(container.querySelector('canvas')).toBeNull()
+ })
+
+ // The placeholder has to land exactly where the image will, or it jumps when the image swaps in.
+ it('shapes the placeholder like the artwork and fits it like the image', () => {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const nonSquare = { ...withArt, imageWidth: 1200, imageHeight: 800 }
+ const { container } = render(
+ <Artwork record={nonSquare} fit="contain" title="Album" />,
+ )
+ const canvas = container.querySelector('canvas')
+ expect(canvas.width).toBe(32)
+ expect(canvas.height).toBe(21)
+ expect(canvas.style.objectFit).toBe('contain')
+ })
+
+ // A square request is padded, not cropped, so the placeholder has to letterbox with it.
+ it('letterboxes the placeholder when the server pads a non-square image to a square', () => {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const nonSquare = { ...withArt, imageWidth: 1200, imageHeight: 800 }
+ const { container } = render(<Artwork record={nonSquare} square />)
+ const canvas = container.querySelector('canvas')
+ expect(canvas.width).toBe(32)
+ expect(canvas.height).toBe(21)
+ expect(canvas.style.objectFit).toBe('contain')
+ })
+
+ // The padded square is aspect-fit, so `square` overrides fit="cover" as it does for the canvas.
+ it('fits the image itself with contain when the server padded to a square', () => {
+ useImageUrl.mockReturnValue({
+ imgUrl: 'blob:abc',
+ loading: false,
+ fromCache: true,
+ })
+ const { container } = render(
+ <Artwork record={withArt} square fit="cover" title="Album" />,
+ )
+ expect(container.querySelector('img').style.objectFit).toBe('contain')
+ })
+
+ it('fills the box for square artwork, the overwhelmingly common case', () => {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const sq = { ...withArt, imageWidth: 600, imageHeight: 600 }
+ const { container } = render(<Artwork record={sq} square />)
+ const canvas = container.querySelector('canvas')
+ expect(canvas.width).toBe(32)
+ expect(canvas.height).toBe(32)
+ })
+
+ // Without dimensions the placeholder falls back to the aspect the hash itself carries.
+ it('falls back to the hash own aspect when the record has no dimensions', () => {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const { container } = render(<Artwork record={withArt} />)
+ const canvas = container.querySelector('canvas')
+ expect(canvas.width).toBe(32)
+ expect(canvas.height).toBe(32)
+ })
+
+ it('mounts the image only once its blob is ready', () => {
+ useImageUrl.mockReturnValue({
+ imgUrl: 'blob:abc',
+ loading: false,
+ fromCache: true,
+ })
+ const { container } = render(<Artwork record={withArt} title="Album" />)
+ const img = container.querySelector('img')
+ expect(img).not.toBeNull()
+ expect(img.getAttribute('src')).toBe('blob:abc')
+ })
+
+ it('keeps the placeholder under the image until the fade ends', () => {
+ vi.useFakeTimers()
+ try {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const { container, rerender } = render(<Artwork record={withArt} />)
+
+ useImageUrl.mockReturnValue({
+ imgUrl: 'blob:abc',
+ loading: false,
+ fromCache: false,
+ })
+ rerender(<Artwork record={withArt} />)
+ const img = container.querySelector('img')
+ expect(img).not.toBeNull()
+ expect(container.querySelector('canvas')).not.toBeNull()
+
+ // The clock ends the fade, not transitionend, which never fires under reduced-motion.
+ act(() => {
+ fireEvent.load(img)
+ })
+ expect(container.querySelector('canvas')).not.toBeNull()
+ act(() => {
+ fireEvent.transitionEnd(img)
+ })
+ expect(container.querySelector('canvas')).not.toBeNull()
+ // Two frames pass before the fade starts, so opacity 0 gets painted first.
+ act(() => {
+ vi.advanceTimersByTime(32)
+ })
+ expect(container.querySelector('canvas')).not.toBeNull()
+ act(() => {
+ vi.advanceTimersByTime(150)
+ })
+ expect(container.querySelector('canvas')).toBeNull()
+ } finally {
+ vi.useRealTimers()
+ }
+ })
+
+ it('does not fade an image that was already cached on mount', () => {
+ useImageUrl.mockReturnValue({
+ imgUrl: 'blob:abc',
+ loading: false,
+ fromCache: true,
+ })
+ const { container } = render(<Artwork record={withArt} />)
+ expect(container.querySelector('canvas')).toBeNull()
+ expect(container.querySelector('img').className).toContain('imgInstant')
+ })
+
+ it('keeps the placeholder visible when the image never decodes', () => {
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const { container, rerender } = render(<Artwork record={withArt} />)
+ useImageUrl.mockReturnValue({
+ imgUrl: 'blob:abc',
+ loading: false,
+ fromCache: false,
+ })
+ rerender(<Artwork record={withArt} />)
+
+ expect(container.querySelector('canvas')).not.toBeNull()
+ })
+
+ it('fires onClick only when the image is loaded', () => {
+ const onClick = vi.fn()
+ useImageUrl.mockReturnValue({ imgUrl: null, loading: true })
+ const { container, rerender } = render(
+ <Artwork record={withArt} onClick={onClick} />,
+ )
+ container.firstChild.click()
+ expect(onClick).not.toHaveBeenCalled()
+
+ useImageUrl.mockReturnValue({
+ imgUrl: 'blob:abc',
+ loading: false,
+ fromCache: false,
+ })
+ rerender(<Artwork record={withArt} onClick={onClick} />)
+ container.firstChild.click()
+ expect(onClick).toHaveBeenCalledTimes(1)
+ })
+
+ it('shows the placeholder for a cached fetch failure, which has no blob', () => {
+ useImageUrl.mockReturnValue({
+ imgUrl: null,
+ loading: false,
+ error: true,
+ fromCache: false,
+ })
+ const { container } = render(<Artwork record={withArt} />)
+ expect(container.querySelector('img')).toBeNull()
+ expect(container.querySelector('canvas')).not.toBeNull()
+ })
+
+ it('falls back to the placeholder when a refresh swaps in an uncached hash', () => {
+ useImageUrl.mockReturnValue({
+ imgUrl: 'blob:old',
+ loading: false,
+ fromCache: true,
+ })
+ const cached = { ...withArt, imageHash: 'aaaa' }
+ const { container, rerender } = render(<Artwork record={cached} />)
+ expect(container.querySelector('canvas')).toBeNull()
+
+ useImageUrl.mockReturnValue({
+ imgUrl: null,
+ loading: true,
+ fromCache: false,
+ })
+ rerender(<Artwork record={{ ...withArt, imageHash: 'bbbb' }} />)
+
+ expect(container.querySelector('img')).toBeNull()
+ expect(container.querySelector('canvas')).not.toBeNull()
+ })
+})
diff --git a/ui/src/common/ArtworkAvatar.jsx b/ui/src/common/ArtworkAvatar.jsx
new file mode 100644
index 000000000..7691050c6
--- /dev/null
+++ b/ui/src/common/ArtworkAvatar.jsx
@@ -0,0 +1,40 @@
+import { useRecordContext } from 'react-admin'
+import { makeStyles } from '@material-ui/core/styles'
+import clsx from 'clsx'
+import config from '../config'
+import { Artwork } from './Artwork'
+
+const useStyles = makeStyles({
+ avatar: {
+ width: '55px',
+ height: '55px',
+ },
+ square: {
+ borderRadius: '4px',
+ },
+ circular: {
+ borderRadius: '50%',
+ },
+})
+
+export const ArtworkAvatar = ({ record: recordProp, variant = 'circular' }) => {
+ const classes = useStyles()
+ const recordContext = useRecordContext()
+ const record = recordProp || recordContext
+ if (!record) return null
+ const square = variant !== 'circular'
+ return (
+ <Artwork
+ record={record}
+ size={config.uiCoverArtSize}
+ square={square}
+ className={clsx(
+ classes.avatar,
+ square ? classes.square : classes.circular,
+ )}
+ title={record.name}
+ />
+ )
+}
+
+ArtworkAvatar.defaultProps = { label: '', sortable: false }
diff --git a/ui/src/common/CoverArtAvatar.jsx b/ui/src/common/CoverArtAvatar.jsx
deleted file mode 100644
index f70403774..000000000
--- a/ui/src/common/CoverArtAvatar.jsx
+++ /dev/null
@@ -1,52 +0,0 @@
-import { useRecordContext } from 'react-admin'
-import { Avatar } from '@material-ui/core'
-import { makeStyles } from '@material-ui/core/styles'
-import clsx from 'clsx'
-import config from '../config'
-import subsonic from '../subsonic'
-import { useImageUrl } from './useImageUrl'
-
-const useStyles = makeStyles({
- avatar: {
- width: '55px',
- height: '55px',
- },
- avatarEmpty: {
- backgroundColor: 'transparent',
- },
- square: {
- borderRadius: '4px',
- },
-})
-
-export const CoverArtAvatar = ({
- record: recordProp,
- variant = 'circular',
-}) => {
- const classes = useStyles()
- const recordContext = useRecordContext()
- const record = recordProp || recordContext
- const square = variant !== 'circular'
- const url = record
- ? subsonic.getCoverArtUrl(record, config.uiCoverArtSize, square)
- : null
- const { imgUrl } = useImageUrl(url)
- if (!record) return null
- return (
- <Avatar
- src={imgUrl || undefined}
- variant={variant}
- className={clsx(
- classes.avatar,
- square && classes.square,
- !imgUrl && classes.avatarEmpty,
- )}
- alt={record.name}
- >
- {/* Empty child prevents default person icon while loading */}
- {!imgUrl && <span />}
- </Avatar>
- )
-}
-
-CoverArtAvatar.defaultProps = { label: '', sortable: false }
diff --git a/ui/src/common/ThumbHashCanvas.jsx b/ui/src/common/ThumbHashCanvas.jsx
new file mode 100644
index 000000000..03d349313
--- /dev/null
+++ b/ui/src/common/ThumbHashCanvas.jsx
@@ -0,0 +1,75 @@
+import { useEffect, useRef } from 'react'
+import PropTypes from 'prop-types'
+import { decode, naturalSize } from '../utils/thumbhash'
+
+// A thumbhash carries no detail beyond a few dozen pixels; CSS upscales the canvas.
+const DECODE_SIZE = 32
+
+// bitmapSize prefers the artwork's true ratio, falling back to the aspect the hash itself carries,
+// which is quantised to a ratio of small integers and so only approximates the image.
+const bitmapSize = (hash, ratio) => {
+ if (!(ratio > 0) || !Number.isFinite(ratio)) {
+ try {
+ return naturalSize(hash)
+ } catch {
+ return { width: DECODE_SIZE, height: DECODE_SIZE }
+ }
+ }
+ return ratio >= 1
+ ? {
+ width: DECODE_SIZE,
+ height: Math.max(1, Math.round(DECODE_SIZE / ratio)),
+ }
+ : {
+ width: Math.max(1, Math.round(DECODE_SIZE * ratio)),
+ height: DECODE_SIZE,
+ }
+}
+
+export const ThumbHashCanvas = ({ hash, ratio, fit, className, style }) => {
+ const canvasRef = useRef(null)
+ const { width, height } = bitmapSize(hash, ratio)
+
+ useEffect(() => {
+ if (!hash || !canvasRef.current) {
+ return
+ }
+ const ctx = canvasRef.current.getContext('2d')
+ if (!ctx) {
+ return
+ }
+ // Clear first so a hash change that fails to decode never leaves a stale frame.
+ ctx.clearRect(0, 0, width, height)
+ try {
+ const pixels = decode(hash, width, height)
+ const imageData = ctx.createImageData(width, height)
+ imageData.data.set(pixels)
+ ctx.putImageData(imageData, 0, 0)
+ } catch {
+ // A malformed hash simply leaves the canvas blank.
+ }
+ }, [hash, width, height])
+
+ if (!hash) {
+ return null
+ }
+ return (
+ <canvas
+ ref={canvasRef}
+ width={width}
+ height={height}
+ className={className}
+ style={{ ...style, objectFit: fit }}
+ aria-hidden="true"
+ />
+ )
+}
+
+ThumbHashCanvas.propTypes = {
+ hash: PropTypes.string,
+ // Aspect ratio (width / height) of the image this stands in for; the hash's own when omitted.
+ ratio: PropTypes.number,
+ fit: PropTypes.oneOf(['cover', 'contain']),
+ className: PropTypes.string,
+ style: PropTypes.object,
+}
diff --git a/ui/src/common/ThumbHashCanvas.test.jsx b/ui/src/common/ThumbHashCanvas.test.jsx
new file mode 100644
index 000000000..b1f53fe5c
--- /dev/null
+++ b/ui/src/common/ThumbHashCanvas.test.jsx
@@ -0,0 +1,95 @@
+import { render } from '@testing-library/react'
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { ThumbHashCanvas } from './ThumbHashCanvas'
+
+// Golden hashes from core/artwork/thumbhash/testdata/golden.json.
+const SQUARE = 'H/gNBxpwh4dwd3eIiHd3iHeHeJ+dcH8I'
+const LANDSCAPE = '3wcOFJpwh4eBh3d4iIePgAj3hw=='
+
+describe('ThumbHashCanvas', () => {
+ // jsdom has no real 2D context; stub it (tracked) so specs can assert the draw path ran.
+ let ctxMock
+ let getContextSpy
+ beforeEach(() => {
+ ctxMock = {
+ clearRect: vi.fn(),
+ createImageData: vi.fn((w, h) => ({
+ data: new Uint8ClampedArray(w * h * 4),
+ })),
+ putImageData: vi.fn(),
+ }
+ getContextSpy = vi
+ .spyOn(HTMLCanvasElement.prototype, 'getContext')
+ .mockReturnValue(ctxMock)
+ })
+ afterEach(() => {
+ getContextSpy.mockRestore()
+ })
+
+ it('renders nothing without a hash', () => {
+ const { container } = render(<ThumbHashCanvas hash="" />)
+ expect(container.querySelector('canvas')).toBeNull()
+ })
+
+ it('decodes a valid hash and draws non-trivial pixel data', () => {
+ const { container } = render(<ThumbHashCanvas hash={SQUARE} />)
+ expect(container.querySelector('canvas')).not.toBeNull()
+ expect(ctxMock.putImageData).toHaveBeenCalledTimes(1)
+ const [imageData] = ctxMock.putImageData.mock.calls[0]
+ expect(imageData.data.some((byte) => byte !== 0)).toBe(true)
+ })
+
+ it('decodes into a bitmap shaped like the image, so the blur is not distorted', () => {
+ const { container } = render(
+ <ThumbHashCanvas hash={SQUARE} ratio={1200 / 800} />,
+ )
+ expect(ctxMock.createImageData).toHaveBeenCalledWith(32, 21)
+ const canvas = container.querySelector('canvas')
+ expect(canvas.width).toBe(32)
+ expect(canvas.height).toBe(21)
+ })
+
+ it('shapes a portrait ratio the other way round', () => {
+ render(<ThumbHashCanvas hash={SQUARE} ratio={0.5} />)
+ expect(ctxMock.createImageData).toHaveBeenCalledWith(16, 32)
+ })
+
+ it('never collapses an extreme ratio to a zero-sized bitmap', () => {
+ render(<ThumbHashCanvas hash={SQUARE} ratio={200} />)
+ expect(ctxMock.createImageData).toHaveBeenCalledWith(32, 1)
+ })
+
+ // Unlike a blurhash, a thumbhash carries its own approximate aspect, so an unknown ratio
+ // falls back to that rather than to a square.
+ it('falls back to the hash own aspect when the ratio is unknown', () => {
+ render(<ThumbHashCanvas hash={LANDSCAPE} ratio={0} />)
+ expect(ctxMock.createImageData).toHaveBeenCalledWith(32, 18)
+ })
+
+ it('applies the object-fit it is given, so it lands where the image will', () => {
+ const { container } = render(
+ <ThumbHashCanvas hash={SQUARE} ratio={1.5} fit="contain" />,
+ )
+ expect(container.querySelector('canvas').style.objectFit).toBe('contain')
+ })
+
+ it('renders a canvas without throwing on a malformed hash, and draws nothing', () => {
+ const spy = vi.spyOn(console, 'error').mockImplementation(() => {})
+ const { container } = render(
+ <ThumbHashCanvas hash="!!!not-a-thumbhash!!!" />,
+ )
+ expect(container.querySelector('canvas')).not.toBeNull()
+ expect(ctxMock.putImageData).not.toHaveBeenCalled()
+ spy.mockRestore()
+ })
+
+ it('clears the canvas when a hash change fails to decode', () => {
+ const { rerender } = render(<ThumbHashCanvas hash={SQUARE} />)
+ expect(ctxMock.putImageData).toHaveBeenCalledTimes(1)
+
+ rerender(<ThumbHashCanvas hash="!!!not-a-thumbhash!!!" />)
+
+ expect(ctxMock.clearRect).toHaveBeenCalledTimes(2)
+ expect(ctxMock.putImageData).toHaveBeenCalledTimes(1)
+ })
+})
diff --git a/ui/src/common/index.js b/ui/src/common/index.js
index c88ea3e9c..7b5b376f3 100644
--- a/ui/src/common/index.js
+++ b/ui/src/common/index.js
@@ -46,6 +46,6 @@ export * from './ParticipantsInfo'
export * from './OverflowTooltip'
export * from './useSearchRefocus'
export * from './ImageUploadOverlay'
-export * from './CoverArtAvatar'
+export * from './ArtworkAvatar'
export * from './useImageLoadingState'
export * from './useImageUrl'
diff --git a/ui/src/common/useImageUrl.js b/ui/src/common/useImageUrl.js
index 9bcc70d74..8a7f2bcc7 100644
--- a/ui/src/common/useImageUrl.js
+++ b/ui/src/common/useImageUrl.js
@@ -43,6 +43,18 @@ export const useImageUrl = (url) => {
const [error, setError] = useState(cached?.error || false)
const abortedRef = useRef(false)
+ // Resync during render: otherwise imgUrl holds the previous url's blob for one render, so only
+ // fromCache can answer "already cached" - and a remembered failure has no blob to paint.
+ const [fromCache, setFromCache] = useState(!!cached?.blobUrl)
+ const [trackedUrl, setTrackedUrl] = useState(url)
+ if (trackedUrl !== url) {
+ setTrackedUrl(url)
+ setImgUrl(cached?.blobUrl || null)
+ setLoading(!!url && !cached)
+ setError(cached?.error || false)
+ setFromCache(!!cached?.blobUrl)
+ }
+
useEffect(() => {
abortedRef.current = false
@@ -140,5 +152,5 @@ export const useImageUrl = (url) => {
}
}, [url])
- return { imgUrl, loading, error }
+ return { imgUrl, loading, error, fromCache }
}
diff --git a/ui/src/common/useImageUrl.test.js b/ui/src/common/useImageUrl.test.js
index 976317105..818732d06 100644
--- a/ui/src/common/useImageUrl.test.js
+++ b/ui/src/common/useImageUrl.test.js
@@ -200,6 +200,7 @@ describe('useImageUrl', () => {
expect(global.fetch).toHaveBeenCalledTimes(1)
expect(result2.current.imgUrl).toBe('blob:mock-url')
expect(result2.current.loading).toBe(false)
+ expect(result2.current.fromCache).toBe(true)
})
it('should cache errors and not re-fetch broken URLs', async () => {
@@ -230,5 +231,7 @@ describe('useImageUrl', () => {
expect(result2.current.error).toBe(true)
expect(result2.current.imgUrl).toBeNull()
expect(result2.current.loading).toBe(false)
+ // A remembered failure has no blob, so callers must not treat it as instantly painted.
+ expect(result2.current.fromCache).toBe(false)
})
})
diff --git a/ui/src/common/useResourceRefresh.jsx b/ui/src/common/useResourceRefresh.jsx
index eabff6f92..b59ae8e88 100644
--- a/ui/src/common/useResourceRefresh.jsx
+++ b/ui/src/common/useResourceRefresh.jsx
@@ -63,6 +63,9 @@ import { useRefresh, useDataProvider } from 'react-admin'
* - Global refresh: { '*': '*' } or { someResource: ['*'] }
* - Specific resources: { album: ['id1', 'id2'], song: ['id3'] }
*/
+// Resources whose records are media files, and so inherit their album's artwork.
+const trackResources = ['song', 'playlistTrack']
+
export const useResourceRefresh = (...visibleResources) => {
const [lastTime, setLastTime] = useState(Date.now())
const refresh = useRefresh()
@@ -70,6 +73,7 @@ export const useResourceRefresh = (...visibleResources) => {
const refreshData = useSelector(
(state) => state.activity?.refresh || { lastReceived: lastTime },
)
+ const loadedResources = useSelector((state) => state.admin?.resources)
const { resources, lastReceived } = refreshData
if (lastReceived <= lastTime) {
@@ -77,21 +81,49 @@ export const useResourceRefresh = (...visibleResources) => {
}
setLastTime(lastReceived)
- if (
+ const isWatched = (r) =>
+ visibleResources.length === 0 || visibleResources.includes(r)
+ // A wildcard on a resource this component does not show is somebody else's business: reloading
+ // the page for it throws away the list the user is looking at.
+ const hasWildcard =
resources &&
(resources['*'] === '*' ||
- Object.values(resources).find((v) => v.find((v2) => v2 === '*')))
- ) {
+ Object.entries(resources).some(
+ ([r, ids]) => isWatched(r) && ids.includes?.('*'),
+ ))
+
+ if (hasWildcard) {
refresh()
return
}
- if (resources) {
- Object.keys(resources).forEach((r) => {
- if (visibleResources.length === 0 || visibleResources?.includes(r)) {
- if (resources[r]?.length > 0) {
- dataProvider.getMany(r, { ids: resources[r] })
+ if (!resources) {
+ return
+ }
+ Object.keys(resources).forEach((r) => {
+ if (isWatched(r)) {
+ if (resources[r]?.length > 0) {
+ // Only refetch records already in the store; ones the UI never loaded will
+ // arrive fresh (with the new artwork) when navigated to, so fetching them is wasteful.
+ const loaded = loadedResources?.[r]?.data || {}
+ const ids = resources[r].filter((id) => loaded[id] !== undefined)
+ if (ids.length > 0) {
+ dataProvider.getMany(r, { ids })
}
}
+ }
+ })
+
+ // A track with no art of its own is served its album's, so an album's new coverArt id moves its
+ // tracks' too. The dependent ids are unbounded server-side, but the store knows which are loaded.
+ if (resources.album?.length > 0) {
+ const albumIds = new Set(resources.album)
+ trackResources.filter(isWatched).forEach((r) => {
+ const ids = Object.values(loadedResources?.[r]?.data || {})
+ .filter((t) => albumIds.has(t?.albumId))
+ .map((t) => t.id)
+ if (ids.length > 0) {
+ dataProvider.getMany(r, { ids })
+ }
})
}
}
diff --git a/ui/src/common/useResourceRefresh.test.js b/ui/src/common/useResourceRefresh.test.js
index eabd478db..ccd729836 100644
--- a/ui/src/common/useResourceRefresh.test.js
+++ b/ui/src/common/useResourceRefresh.test.js
@@ -38,6 +38,27 @@ describe('useResourceRefresh', () => {
const useDataProviderMock = () => ({ getMany })
let lastTime
+ // Applies each real selector against a constructed store, so both useSelector
+ // calls in the hook (refresh payload + loaded records) resolve correctly.
+ const mockStore = ({ refresh: refreshPayload, loaded = {} }) => {
+ const state = {
+ activity: { refresh: refreshPayload },
+ admin: { resources: loaded },
+ }
+ vi.spyOn(Redux, 'useSelector').mockImplementation((selector) =>
+ selector(state),
+ )
+ }
+
+ // Turns id lists into the react-admin store shape: { album: { data: { 'al-1': {...} } } }
+ const asStore = (byResource) =>
+ Object.fromEntries(
+ Object.entries(byResource).map(([r, ids]) => [
+ r,
+ { data: Object.fromEntries(ids.map((id) => [id, { id }])) },
+ ]),
+ )
+
beforeEach(() => {
vi.spyOn(React, 'useState').mockImplementation(useStateMock)
vi.spyOn(RA, 'useRefresh').mockImplementation(useRefreshMock)
@@ -50,8 +71,7 @@ describe('useResourceRefresh', () => {
})
it('stores last time checked, to avoid redundant runs', () => {
- const useSelectorMock = () => ({ lastReceived: lastTime })
- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)
+ mockStore({ refresh: { lastReceived: lastTime } })
useResourceRefresh()
@@ -60,8 +80,7 @@ describe('useResourceRefresh', () => {
it("does not run again if lastTime didn't change", () => {
vi.spyOn(React, 'useState').mockImplementation(() => [lastTime, setState])
- const useSelectorMock = () => ({ lastReceived: lastTime })
- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)
+ mockStore({ refresh: { lastReceived: lastTime } })
useResourceRefresh()
@@ -70,11 +89,9 @@ describe('useResourceRefresh', () => {
describe('No visible resources specified', () => {
it('triggers a UI refresh when received a "any" resource refresh', () => {
- const useSelectorMock = () => ({
- lastReceived: lastTime,
- resources: { '*': '*' },
+ mockStore({
+ refresh: { lastReceived: lastTime, resources: { '*': '*' } },
})
- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)
useResourceRefresh()
@@ -83,11 +100,9 @@ describe('useResourceRefresh', () => {
})
it('triggers a UI refresh when received an "any" id', () => {
- const useSelectorMock = () => ({
- lastReceived: lastTime,
- resources: { album: ['*'] },
+ mockStore({
+ refresh: { lastReceived: lastTime, resources: { album: ['*'] } },
})
- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)
useResourceRefresh()
@@ -95,12 +110,14 @@ describe('useResourceRefresh', () => {
expect(getMany).not.toHaveBeenCalled()
})
- it('triggers a refetch of the resources received', () => {
- const useSelectorMock = () => ({
- lastReceived: lastTime,
- resources: { album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] },
+ it('refetches only the received resources already loaded in the store', () => {
+ mockStore({
+ refresh: {
+ lastReceived: lastTime,
+ resources: { album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] },
+ },
+ loaded: asStore({ album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] }),
})
- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)
useResourceRefresh()
@@ -109,15 +126,42 @@ describe('useResourceRefresh', () => {
expect(getMany).toHaveBeenCalledWith('album', { ids: ['al-1', 'al-2'] })
expect(getMany).toHaveBeenCalledWith('song', { ids: ['sg-1', 'sg-2'] })
})
+
+ it('skips ids that are not loaded in the store', () => {
+ mockStore({
+ refresh: {
+ lastReceived: lastTime,
+ resources: { album: ['al-1', 'al-2', 'al-3'] },
+ },
+ loaded: asStore({ album: ['al-2'] }),
+ })
+
+ useResourceRefresh()
+
+ expect(getMany).toHaveBeenCalledTimes(1)
+ expect(getMany).toHaveBeenCalledWith('album', { ids: ['al-2'] })
+ })
+
+ it('does not fetch when none of the received ids are loaded', () => {
+ mockStore({
+ refresh: {
+ lastReceived: lastTime,
+ resources: { artist: ['ar-1', 'ar-2'] },
+ },
+ loaded: asStore({ artist: ['ar-9'] }),
+ })
+
+ useResourceRefresh()
+
+ expect(getMany).not.toHaveBeenCalled()
+ })
})
describe('Visible resources specified', () => {
it('triggers a UI refresh when received a "any" resource refresh', () => {
- const useSelectorMock = () => ({
- lastReceived: lastTime,
- resources: { '*': '*' },
+ mockStore({
+ refresh: { lastReceived: lastTime, resources: { '*': '*' } },
})
- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)
useResourceRefresh('album')
@@ -125,12 +169,101 @@ describe('useResourceRefresh', () => {
expect(getMany).not.toHaveBeenCalled()
})
- it('triggers a refetch of the resources received if they are visible', () => {
- const useSelectorMock = () => ({
- lastReceived: lastTime,
- resources: { album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] },
+ it('does not refresh the page when the wildcard is on a resource it does not watch', () => {
+ // Guards other senders: a wildcard on an unwatched resource must not reload this list.
+ mockStore({
+ refresh: {
+ lastReceived: lastTime,
+ resources: { album: ['al-1', 'al-2'], song: ['*'] },
+ },
+ loaded: asStore({ album: ['al-1', 'al-2'] }),
+ })
+
+ useResourceRefresh('album')
+
+ expect(refresh).not.toHaveBeenCalled()
+ expect(getMany).toHaveBeenCalledWith('album', { ids: ['al-1', 'al-2'] })
+ })
+
+ it('refetches the loaded songs of a refreshed album', () => {
+ // A track with no art of its own is served its album's, so its coverArt id moves with the
+ // album's. The backend cannot know which tracks are loaded; the store can.
+ mockStore({
+ refresh: { lastReceived: lastTime, resources: { album: ['al-1'] } },
+ loaded: {
+ album: { data: { 'al-1': { id: 'al-1' } } },
+ song: {
+ data: {
+ 'sg-1': { id: 'sg-1', albumId: 'al-1' },
+ 'sg-2': { id: 'sg-2', albumId: 'al-2' },
+ },
+ },
+ },
+ })
+
+ useResourceRefresh('song')
+
+ expect(refresh).not.toHaveBeenCalled()
+ expect(getMany).toHaveBeenCalledWith('song', { ids: ['sg-1'] })
+ })
+
+ it('fans an album refresh out to loaded playlist tracks, which have their own ids', () => {
+ mockStore({
+ refresh: { lastReceived: lastTime, resources: { album: ['al-1'] } },
+ loaded: {
+ playlistTrack: {
+ data: {
+ 'pt-1': { id: 'pt-1', albumId: 'al-1' },
+ 'pt-2': { id: 'pt-2', albumId: 'al-2' },
+ },
+ },
+ },
+ })
+
+ useResourceRefresh('playlistTrack', 'song', 'playlist')
+
+ expect(refresh).not.toHaveBeenCalled()
+ expect(getMany).toHaveBeenCalledWith('playlistTrack', { ids: ['pt-1'] })
+ })
+
+ it('does not fan out to track resources the component does not show', () => {
+ mockStore({
+ refresh: { lastReceived: lastTime, resources: { album: ['al-1'] } },
+ loaded: {
+ album: { data: { 'al-1': { id: 'al-1' } } },
+ song: { data: { 'sg-1': { id: 'sg-1', albumId: 'al-1' } } },
+ },
+ })
+
+ useResourceRefresh('album')
+
+ expect(refresh).not.toHaveBeenCalled()
+ expect(getMany).toHaveBeenCalledTimes(1)
+ expect(getMany).toHaveBeenCalledWith('album', { ids: ['al-1'] })
+ })
+
+ it('does not refetch songs when no loaded song belongs to the refreshed album', () => {
+ mockStore({
+ refresh: { lastReceived: lastTime, resources: { album: ['al-9'] } },
+ loaded: {
+ song: { data: { 'sg-1': { id: 'sg-1', albumId: 'al-1' } } },
+ },
+ })
+
+ useResourceRefresh('song')
+
+ expect(refresh).not.toHaveBeenCalled()
+ expect(getMany).not.toHaveBeenCalled()
+ })
+
+ it('refetches the received resources if they are visible and loaded', () => {
+ mockStore({
+ refresh: {
+ lastReceived: lastTime,
+ resources: { album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] },
+ },
+ loaded: asStore({ album: ['al-1', 'al-2'], song: ['sg-1', 'sg-2'] }),
})
- vi.spyOn(Redux, 'useSelector').mockImplementation(useSelectorMock)
useResourceRefresh('song')
diff --git a/ui/src/playlist/PlaylistDetails.jsx b/ui/src/playlist/PlaylistDetails.jsx
index 894809ce0..5d0f6631e 100644
--- a/ui/src/playlist/PlaylistDetails.jsx
+++ b/ui/src/playlist/PlaylistDetails.jsx
@@ -1,10 +1,5 @@
-import {
- Card,
- CardContent,
- CardMedia,
- Typography,
- useMediaQuery,
-} from '@material-ui/core'
+import { useState } from 'react'
+import { Card, CardContent, Typography, useMediaQuery } from '@material-ui/core'
import { makeStyles } from '@material-ui/core/styles'
import { useTranslate } from 'react-admin'
import Lightbox from 'react-image-lightbox'
@@ -17,10 +12,9 @@ import {
SizeField,
isWritable,
OverflowTooltip,
- useImageLoadingState,
} from '../common'
-import config from '../config'
import subsonic from '../subsonic'
+import { Artwork } from '../common/Artwork'
const useStyles = makeStyles(
(theme) => ({
@@ -75,9 +69,6 @@ const useStyles = makeStyles(
backgroundColor: 'transparent',
transition: 'opacity 0.3s ease-in-out',
},
- coverLoading: {
- opacity: 0.5,
- },
title: {
overflow: 'hidden',
textOverflow: 'ellipsis',
@@ -107,37 +98,21 @@ const PlaylistDetails = (props) => {
const translate = useTranslate()
const classes = useStyles()
const isDesktop = useMediaQuery((theme) => theme.breakpoints.up('lg'))
- const {
- imageLoading,
- imageError,
- isLightboxOpen,
- handleImageLoad,
- handleImageError,
- handleOpenLightbox,
- handleCloseLightbox,
- } = useImageLoadingState(record.id)
+ const [isLightboxOpen, setLightboxOpen] = useState(false)
- const imageUrl = subsonic.getCoverArtUrl(record, config.uiCoverArtSize, true)
const fullImageUrl = subsonic.getCoverArtUrl(record)
return (
<Card className={classes.root}>
<div className={classes.cardContents}>
<div className={classes.coverParent}>
- <CardMedia
- key={record.id} // Force re-render when playlist changes
- component={'img'}
- src={imageUrl}
- width="400"
- height="400"
- className={`${classes.cover} ${imageLoading ? classes.coverLoading : ''}`}
- onClick={handleOpenLightbox}
- onLoad={handleImageLoad}
- onError={handleImageError}
+ <Artwork
+ record={record}
+ square
+ fit="contain"
+ className={classes.cover}
title={record.name}
- style={{
- cursor: imageError ? 'default' : 'pointer',
- }}
+ onClick={() => setLightboxOpen(true)}
/>
{isWritable(record.ownerId) && (
<ImageUploadOverlay
@@ -187,13 +162,13 @@ const PlaylistDetails = (props) => {
</CardContent>
</div>
</div>
- {isLightboxOpen && !imageError && (
+ {isLightboxOpen && (
<Lightbox
imagePadding={50}
animationDuration={200}
imageTitle={record.name}
mainSrc={fullImageUrl}
- onCloseRequest={handleCloseLightbox}
+ onCloseRequest={() => setLightboxOpen(false)}
/>
)}
</Card>
diff --git a/ui/src/playlist/PlaylistList.jsx b/ui/src/playlist/PlaylistList.jsx
index 642d90dd5..d2b17b108 100644
--- a/ui/src/playlist/PlaylistList.jsx
+++ b/ui/src/playlist/PlaylistList.jsx
@@ -20,7 +20,7 @@ import Switch from '@material-ui/core/Switch'
import { makeStyles } from '@material-ui/core/styles'
import { useMediaQuery } from '@material-ui/core'
import {
- CoverArtAvatar,
+ ArtworkAvatar,
DurationField,
List,
LoveButton,
@@ -197,7 +197,7 @@ const PlaylistList = (props) => {
bulkActionButtons={!isXsmall && <PlaylistListBulkActions />}
>
<Datagrid rowClick="show" isRowSelectable={(r) => isWritable(r?.ownerId)}>
- <CoverArtAvatar source="id" variant="square" />
+ <ArtworkAvatar source="id" variant="square" />
<TextField source="name" />
{columns}
<Writable>
diff --git a/ui/src/playlist/PlaylistShow.jsx b/ui/src/playlist/PlaylistShow.jsx
index 4e269be18..4c2fea315 100644
--- a/ui/src/playlist/PlaylistShow.jsx
+++ b/ui/src/playlist/PlaylistShow.jsx
@@ -35,7 +35,7 @@ const PlaylistShowLayout = (props) => {
const { loading, ...context } = useShowContext(props)
const { record } = context
const classes = useStyles()
- useResourceRefresh('song')
+ useResourceRefresh('playlistTrack', 'song')
return (
<>
diff --git a/ui/src/playlist/PlaylistSongs.jsx b/ui/src/playlist/PlaylistSongs.jsx
index bbe38b4d5..4718a7cf4 100644
--- a/ui/src/playlist/PlaylistSongs.jsx
+++ b/ui/src/playlist/PlaylistSongs.jsx
@@ -100,7 +100,8 @@ const PlaylistSongs = ({ playlistId, readOnly, actions, ...props }) => {
const dataProvider = useDataProvider()
const notify = useNotify()
const version = useVersion()
- useResourceRefresh('song', 'playlist')
+ // The rows are stored as playlistTrack, not song: their ids are playlist entries.
+ useResourceRefresh('playlistTrack', 'song', 'playlist')
useEffect(() => {
setPage(1)
diff --git a/ui/src/radio/RadioList.jsx b/ui/src/radio/RadioList.jsx
index ccdb9f1ef..0cfb2cd68 100644
--- a/ui/src/radio/RadioList.jsx
+++ b/ui/src/radio/RadioList.jsx
@@ -18,11 +18,10 @@ import {
List,
defaultRowsPerPageOptions,
getStoredPerPage,
- useImageUrl,
ToggleFieldsMenu,
useSelectedFields,
} from '../common'
-import subsonic from '../subsonic'
+import { Artwork } from '../common/Artwork'
import { StreamField } from './StreamField'
import { setTrack } from '../actions'
import { songFromRadio } from './helper'
@@ -83,15 +82,32 @@ const RadioListActions = ({
const avatarStyle = { width: 40, height: 40 }
+const useCoverStyles = makeStyles({
+ cover: { width: 40, height: 40, borderRadius: '4px' },
+})
+
const CoverArtField = ({ record }) => {
- const directUrl = record?.uploadedImage
- ? subsonic.getCoverArtUrl(record, 40, true)
- : null
- const { imgUrl } = useImageUrl(directUrl)
+ const classes = useCoverStyles()
if (!record) return null
- const src = imgUrl || RADIO_PLACEHOLDER_IMAGE
+ // Radios resolve art only from an uploaded image; otherwise show the generic radio icon.
+ if (record.uploadedImage) {
+ return (
+ <Artwork
+ record={record}
+ size={40}
+ square
+ className={classes.cover}
+ title={record.name}
+ />
+ )
+ }
return (
- <Avatar src={src} variant="rounded" style={avatarStyle} alt={record.name} />
+ <Avatar
+ src={RADIO_PLACEHOLDER_IMAGE}
+ variant="rounded"
+ style={avatarStyle}
+ alt={record.name}
+ />
)
}
CoverArtField.defaultProps = { label: '' }
diff --git a/ui/src/subsonic/index.js b/ui/src/subsonic/index.js
index 7d93972e0..9f0ad28d7 100644
--- a/ui/src/subsonic/index.js
+++ b/ui/src/subsonic/index.js
@@ -81,25 +81,27 @@ const getAvatarUrl = (username, size) =>
)
const getCoverArtUrl = (record, size, square) => {
+ const suffix = record.imageHash ? '_' + record.imageHash : ''
const options = {
- ...(record.updatedAt && { _: record.updatedAt }),
+ // A hash-suffixed url is already pixel-versioned; the buster would defeat immutable caching.
+ ...(!record.imageHash && record.updatedAt && { _: record.updatedAt }),
...(size && { size }),
...(square && { square }),
}
// TODO Move this logic to server
if (record.album) {
- return baseUrl(url('getCoverArt', 'mf-' + record.id, options))
+ return baseUrl(url('getCoverArt', 'mf-' + record.id + suffix, options))
} else if (record.albumArtist) {
- return baseUrl(url('getCoverArt', 'al-' + record.id, options))
+ return baseUrl(url('getCoverArt', 'al-' + record.id + suffix, options))
} else if (record.sync !== undefined) {
// This is a playlist
- return baseUrl(url('getCoverArt', 'pl-' + record.id, options))
+ return baseUrl(url('getCoverArt', 'pl-' + record.id + suffix, options))
} else if (record.streamUrl !== undefined) {
// This is a radio station
- return baseUrl(url('getCoverArt', 'ra-' + record.id, options))
+ return baseUrl(url('getCoverArt', 'ra-' + record.id + suffix, options))
} else {
- return baseUrl(url('getCoverArt', 'ar-' + record.id, options))
+ return baseUrl(url('getCoverArt', 'ar-' + record.id + suffix, options))
}
}
diff --git a/ui/src/subsonic/index.test.js b/ui/src/subsonic/index.test.js
index ad4764c24..32c699a41 100644
--- a/ui/src/subsonic/index.test.js
+++ b/ui/src/subsonic/index.test.js
@@ -120,6 +120,47 @@ describe('getCoverArtUrl', () => {
expect(url).toContain('ar-test-123')
expect(url).not.toContain('_=')
})
+
+ it('appends the content hash to the artwork id', () => {
+ const url = subsonic.getCoverArtUrl({
+ id: 'album-123',
+ albumArtist: 'AA',
+ imageHash: '0123456789abcdef',
+ })
+ expect(url).toContain('al-album-123_0123456789abcdef')
+ })
+
+ it('drops the updatedAt buster once the url is hash-versioned', () => {
+ const url = subsonic.getCoverArtUrl({
+ id: 'album-123',
+ albumArtist: 'AA',
+ updatedAt: '2023-01-01T00:00:00Z',
+ imageHash: '0123456789abcdef',
+ })
+ expect(url).toContain('al-album-123_0123456789abcdef')
+ expect(url).not.toContain('_=')
+ })
+
+ it('keeps the updatedAt buster while artwork is unresolved', () => {
+ const url = subsonic.getCoverArtUrl({
+ id: 'album-123',
+ albumArtist: 'AA',
+ updatedAt: '2023-01-01T00:00:00Z',
+ })
+ expect(url).toContain('al-album-123')
+ expect(url).toContain('_=')
+ })
+
+ it('still builds a url for known-absent artwork so the server placeholder renders', () => {
+ // Returning '' here made <img src=undefined> render as a broken icon; the server serves a
+ // proper placeholder for absent art, so the client must still request it.
+ const url = subsonic.getCoverArtUrl({
+ id: 'album-123',
+ albumArtist: 'AA',
+ imageAbsent: true,
+ })
+ expect(url).toContain('al-album-123')
+ })
})
describe('getDiscCoverArtUrl', () => {
diff --git a/ui/src/utils/thumbhash.js b/ui/src/utils/thumbhash.js
new file mode 100644
index 000000000..f4ec673d2
--- /dev/null
+++ b/ui/src/utils/thumbhash.js
@@ -0,0 +1,138 @@
+// ThumbHash decoder (https://github.com/evanw/thumbhash), kept byte-compatible with the reference:
+// core/artwork/thumbhash/testdata/thumbhash.js pins the pixels the specs assert on.
+
+const toBytes = (hash) => {
+ if (typeof hash !== 'string' || hash === '') {
+ throw new Error('thumbhash: empty hash')
+ }
+ const binary = atob(hash)
+ const bytes = new Uint8Array(binary.length)
+ for (let i = 0; i < binary.length; i++) {
+ bytes[i] = binary.charCodeAt(i)
+ }
+ if (bytes.length < 5) {
+ throw new Error('thumbhash: hash too short')
+ }
+ return bytes
+}
+
+// header unpacks the fixed 5-byte prefix plus the optional alpha byte.
+const header = (bytes) => {
+ const header24 = bytes[0] | (bytes[1] << 8) | (bytes[2] << 16)
+ const header16 = bytes[3] | (bytes[4] << 8)
+ const hasAlpha = header24 >> 23 !== 0
+ if (hasAlpha && bytes.length < 6) {
+ throw new Error('thumbhash: hash too short for alpha')
+ }
+ const isLandscape = header16 >> 15 !== 0
+ const alphaLimit = hasAlpha ? 5 : 7
+ return {
+ lDC: (header24 & 63) / 63,
+ pDC: ((header24 >> 6) & 63) / 31.5 - 1,
+ qDC: ((header24 >> 12) & 63) / 31.5 - 1,
+ lScale: ((header24 >> 18) & 31) / 31,
+ hasAlpha,
+ pScale: ((header16 >> 3) & 63) / 63,
+ qScale: ((header16 >> 9) & 63) / 63,
+ lx: Math.max(3, isLandscape ? alphaLimit : header16 & 7),
+ ly: Math.max(3, isLandscape ? header16 & 7 : alphaLimit),
+ aDC: hasAlpha ? (bytes[5] & 15) / 15 : 1,
+ aScale: hasAlpha ? (bytes[5] >> 4) / 15 : 0,
+ }
+}
+
+// naturalSize is the reference decoder's own output size: 32 on the long edge, at the aspect the
+// hash approximates. Callers with the true dimensions should decode at those instead.
+export const naturalSize = (hash) => {
+ const { lx, ly } = header(toBytes(hash))
+ const ratio = lx / ly
+ return ratio > 1
+ ? { width: 32, height: Math.round(32 / ratio) }
+ : { width: Math.round(32 * ratio), height: 32 }
+}
+
+const cosTable = (n, size) => {
+ const table = new Float64Array(n * size)
+ for (let c = 0; c < n; c++) {
+ for (let i = 0; i < size; i++) {
+ table[c * size + i] = Math.cos((Math.PI / size) * (i + 0.5) * c)
+ }
+ }
+ return table
+}
+
+export const decode = (hash, width, height) => {
+ const bytes = toBytes(hash)
+ const h = header(bytes)
+ if (!(width > 0) || !(height > 0)) {
+ throw new Error('thumbhash: width and height must be positive')
+ }
+
+ const acStart = h.hasAlpha ? 6 : 5
+ let acIndex = 0
+ const channel = (nx, ny, scale) => {
+ const ac = []
+ for (let cy = 0; cy < ny; cy++) {
+ for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++) {
+ const byte = bytes[acStart + (acIndex >> 1)] ?? 0
+ ac.push((((byte >> ((acIndex++ & 1) << 2)) & 15) / 7.5 - 1) * scale)
+ }
+ }
+ return ac
+ }
+ // The 1.25x chroma boost is the reference's quantisation compensation, not a free parameter.
+ const lAC = channel(h.lx, h.ly, h.lScale)
+ const pAC = channel(3, 3, h.pScale * 1.25)
+ const qAC = channel(3, 3, h.qScale * 1.25)
+ const aAC = h.hasAlpha ? channel(5, 5, h.aScale) : []
+
+ const nx = Math.max(h.lx, h.hasAlpha ? 5 : 3)
+ const ny = Math.max(h.ly, h.hasAlpha ? 5 : 3)
+ const fx = cosTable(nx, width)
+ const fy = cosTable(ny, height)
+
+ const pixels = new Uint8ClampedArray(width * height * 4)
+ for (let y = 0; y < height; y++) {
+ for (let x = 0; x < width; x++) {
+ let l = h.lDC
+ let p = h.pDC
+ let q = h.qDC
+ let a = h.aDC
+
+ for (let cy = 0, j = 0; cy < h.ly; cy++) {
+ const fy2 = fy[cy * height + y] * 2
+ for (let cx = cy ? 0 : 1; cx * h.ly < h.lx * (h.ly - cy); cx++, j++) {
+ l += lAC[j] * fx[cx * width + x] * fy2
+ }
+ }
+ for (let cy = 0, j = 0; cy < 3; cy++) {
+ const fy2 = fy[cy * height + y] * 2
+ for (let cx = cy ? 0 : 1; cx < 3 - cy; cx++, j++) {
+ const f = fx[cx * width + x] * fy2
+ p += pAC[j] * f
+ q += qAC[j] * f
+ }
+ }
+ if (h.hasAlpha) {
+ for (let cy = 0, j = 0; cy < 5; cy++) {
+ const fy2 = fy[cy * height + y] * 2
+ for (let cx = cy ? 0 : 1; cx < 5 - cy; cx++, j++) {
+ a += aAC[j] * fx[cx * width + x] * fy2
+ }
+ }
+ }
+
+ const b = l - (2 / 3) * p
+ const r = (3 * l - b + q) / 2
+ const g = r - q
+ const idx = 4 * x + y * width * 4
+ // Explicit floor: the reference writes into a Uint8Array, which truncates, while the
+ // Uint8ClampedArray that createImageData needs would round.
+ pixels[idx] = Math.floor(Math.max(0, 255 * Math.min(1, r)))
+ pixels[idx + 1] = Math.floor(Math.max(0, 255 * Math.min(1, g)))
+ pixels[idx + 2] = Math.floor(Math.max(0, 255 * Math.min(1, b)))
+ pixels[idx + 3] = Math.floor(Math.max(0, 255 * Math.min(1, a)))
+ }
+ }
+ return pixels
+}
diff --git a/ui/src/utils/thumbhash.test.js b/ui/src/utils/thumbhash.test.js
new file mode 100644
index 000000000..6abb4d7e4
--- /dev/null
+++ b/ui/src/utils/thumbhash.test.js
@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest'
+import { decode, naturalSize } from './thumbhash'
+
+// Digests pinned from evanw/thumbhash's reference decoder (vendored at
+// core/artwork/thumbhash/testdata/thumbhash.js), so any drift from it fails here.
+const fnv = (bytes) => {
+ let h = 2166136261 >>> 0
+ for (const b of bytes) {
+ h ^= b
+ h = Math.imul(h, 16777619) >>> 0
+ }
+ return h.toString(16)
+}
+
+const REFERENCE = [
+ ['alpha', 'JOiFBQ4nkIexh3p4iA8uB+lYhIeAh3d4dw==', 32, 32, '500141bc'],
+ ['landscape', '3wcOFJpwh4eBh3d4iIePgAj3hw==', 32, 18, '18465aed'],
+ ['portrait', '3/cNFBqBB4iId4d3d4iAjwj4hw==', 18, 32, '56500cc1'],
+ ['solid', 'HoUBBwB4eHeHd3hweId3h3h4B2+Ih4gA', 32, 32, '39cc5c5'],
+ ['square', 'H/gNBxpwh4dwd3eIiHd3iHeHeJ+dcH8I', 32, 32, '740d8afc'],
+ ['tiny', 'HoU9tx4I9wiIh4hwj3CI+AiIcH/494cP', 32, 32, 'f2555987'],
+]
+
+describe('thumbhash decode', () => {
+ it.each(REFERENCE)(
+ 'reproduces the reference pixels for %s',
+ (_name, hash, w, h, digest) => {
+ expect(fnv(decode(hash, w, h))).toEqual(digest)
+ },
+ )
+
+ it.each(REFERENCE)(
+ 'reports the reference natural size for %s',
+ (_name, hash, w, h) => {
+ expect(naturalSize(hash)).toEqual({ width: w, height: h })
+ },
+ )
+
+ it('decodes to any requested grid, not just the natural one', () => {
+ const [, hash] = REFERENCE[4]
+ const pixels = decode(hash, 8, 5)
+ expect(pixels).toHaveLength(8 * 5 * 4)
+ // Opaque hash: every alpha byte is saturated.
+ for (let i = 3; i < pixels.length; i += 4) {
+ expect(pixels[i]).toBe(255)
+ }
+ })
+
+ it('carries alpha through for a hash that has it', () => {
+ const [, hash, w, h] = REFERENCE[0]
+ const pixels = decode(hash, w, h)
+ const alphas = new Set()
+ for (let i = 3; i < pixels.length; i += 4) {
+ alphas.add(pixels[i])
+ }
+ expect(alphas.size).toBeGreaterThan(1)
+ })
+
+ it.each([
+ ['empty', ''],
+ ['too short to hold a header', 'AAAA'],
+ ['not base64', '!!!not-a-thumbhash!!!'],
+ ])('throws on a hash that is %s', (_name, hash) => {
+ expect(() => decode(hash, 32, 32)).toThrow()
+ })
+})
diff --git a/utils/cache/file_caches.go b/utils/cache/file_caches.go
index ed2374696..33fa046df 100644
--- a/utils/cache/file_caches.go
+++ b/utils/cache/file_caches.go
@@ -2,8 +2,10 @@ package cache
import (
"context"
+ "errors"
"fmt"
"io"
+ "io/fs"
"path/filepath"
"sync"
"sync/atomic"
@@ -158,6 +160,13 @@ func (fc *fileCache) Get(ctx context.Context, arg Item) (*CachedStream, error) {
key := arg.Key()
r, w, err := fc.cache.Get(key)
+ if errors.Is(err, fs.ErrNotExist) {
+ // The entry outlived its data file. Drop it and retry, or every future Get
+ // for this key fails for the rest of the process's life.
+ log.Debug(ctx, "Cache entry lost its data file. Re-fetching", "cache", fc.name, "key", key)
+ _ = fc.invalidate(ctx, key)
+ r, w, err = fc.cache.Get(key)
+ }
if err != nil {
return nil, err
}
diff --git a/utils/cache/file_caches_test.go b/utils/cache/file_caches_test.go
index edcfbc6b9..7ce1b0393 100644
--- a/utils/cache/file_caches_test.go
+++ b/utils/cache/file_caches_test.go
@@ -7,6 +7,7 @@ import (
"os"
"path/filepath"
"strings"
+ "sync/atomic"
"github.com/navidrome/navidrome/conf"
"github.com/navidrome/navidrome/conf/configtest"
@@ -278,6 +279,92 @@ var _ = Describe("File Caches", func() {
}).Should(BeTrue())
})
})
+
+ Context("entry outliving its data file", func() {
+ It("re-fetches when the data file vanished behind the cache's back", func() {
+ var calls atomic.Int32
+ fc := callNewFileCache("test", "10MB", "test", 0, func(ctx context.Context, arg Item) (io.Reader, error) {
+ calls.Add(1)
+ return strings.NewReader("payload"), nil
+ })
+
+ s, err := fc.Get(context.Background(), &testArg{"vanish"})
+ Expect(err).To(BeNil())
+ Expect(io.ReadAll(s)).To(Equal([]byte("payload")))
+ Expect(s.Close()).To(Succeed())
+
+ dataPath := fcSpreadFS(fc).KeyMapper((&testArg{"vanish"}).Key())
+ Eventually(func() error { _, e := os.Stat(dataPath); return e }).Should(Succeed())
+ Expect(os.Remove(dataPath)).To(Succeed())
+
+ s2, err := fc.Get(context.Background(), &testArg{"vanish"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(io.ReadAll(s2)).To(Equal([]byte("payload")))
+ _ = s2.Close()
+ Expect(calls.Load()).To(BeNumerically("==", 2))
+ })
+
+ It("survives an invalidated entry's deferred file removal", func() {
+ // invalidate() drops the map entry but defers the unlink until readers close;
+ // a Get in that window re-creates the file, which the deferred unlink then eats.
+ var n atomic.Int32
+ fc := callNewFileCache("test", "10MB", "test", 0, func(ctx context.Context, arg Item) (io.Reader, error) {
+ if n.Add(1) == 1 {
+ return &partialThenErrReader{data: []byte("PARTIAL"), err: errors.New("died")}, nil
+ }
+ return strings.NewReader("GOOD"), nil
+ })
+
+ key := (&testArg{"deferred"}).Key()
+ s1, err := fc.Get(context.Background(), &testArg{"deferred"})
+ Expect(err).To(BeNil())
+
+ // The failed write invalidates the entry; the removal now waits on s1.
+ Eventually(func() bool { return fc.cache.Exists(key) }).Should(BeFalse())
+
+ s2, err := fc.Get(context.Background(), &testArg{"deferred"})
+ Expect(err).To(BeNil())
+ Expect(io.ReadAll(s2)).To(Equal([]byte("GOOD")))
+ Expect(s2.Close()).To(Succeed())
+
+ Expect(s1.Close()).To(Succeed())
+
+ dataPath := fcSpreadFS(fc).KeyMapper(key)
+ Eventually(func() bool {
+ _, e := os.Stat(dataPath)
+ return os.IsNotExist(e)
+ }).Should(BeTrue(), "expected the deferred removal to take the re-created file")
+
+ s3, err := fc.Get(context.Background(), &testArg{"deferred"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(io.ReadAll(s3)).To(Equal([]byte("GOOD")))
+ _ = s3.Close()
+ })
+
+ It("re-fetches when an adopted entry's data file vanished", func() {
+ // Entries adopted on startup take a different code path than in-process ones.
+ var calls atomic.Int32
+ fc := callNewFileCache("test", "10MB", "test", 0, func(ctx context.Context, arg Item) (io.Reader, error) {
+ calls.Add(1)
+ return strings.NewReader("payload"), nil
+ })
+ dataPath := fcSpreadFS(fc).KeyMapper((&testArg{"adopted"}).Key())
+ Expect(os.MkdirAll(filepath.Dir(dataPath), 0755)).To(Succeed())
+ Expect(os.WriteFile(dataPath, []byte("payload"), 0600)).To(Succeed())
+ Expect(fcSpreadFS(fc).MarkComplete(dataPath)).To(Succeed())
+
+ adopted := callNewFileCache("test2", "10MB", "test", 0, func(ctx context.Context, arg Item) (io.Reader, error) {
+ calls.Add(1)
+ return strings.NewReader("payload"), nil
+ })
+ Expect(os.Remove(dataPath)).To(Succeed())
+
+ s, err := adopted.Get(context.Background(), &testArg{"adopted"})
+ Expect(err).ToNot(HaveOccurred())
+ Expect(io.ReadAll(s)).To(Equal([]byte("payload")))
+ _ = s.Close()
+ })
+ })
})
})
diff --git a/utils/cache/spread_fs.go b/utils/cache/spread_fs.go
index 647439790..11801b324 100644
--- a/utils/cache/spread_fs.go
+++ b/utils/cache/spread_fs.go
@@ -128,7 +128,7 @@ func (sfs *spreadFS) Create(name string) (stream.File, error) {
if err != nil {
return nil, err
}
- return os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+ return createDataFile(name)
}
func (sfs *spreadFS) Open(name string) (stream.File, error) {
diff --git a/utils/cache/spread_fs_test.go b/utils/cache/spread_fs_test.go
index 0f88d3a58..d0b54567d 100644
--- a/utils/cache/spread_fs_test.go
+++ b/utils/cache/spread_fs_test.go
@@ -1,10 +1,13 @@
package cache
import (
+ "io"
"os"
"path/filepath"
+ "runtime"
"strings"
+ "github.com/djherbis/stream"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
@@ -39,6 +42,39 @@ var _ = Describe("Spread FS", func() {
})
})
+ Describe("Create", func() {
+ It("leaves an already-open reader's bytes intact", func() {
+ // Shrinking a file an older stream still serves spins its reader at a premature EOF.
+ if runtime.GOOS == "windows" {
+ Skip("Windows cannot unlink a file with open handles, so Create reuses the inode")
+ }
+ name := filepath.Join(rootDir, "aa", "bb", "data")
+ s, err := stream.NewStream(name, fs)
+ Expect(err).To(BeNil())
+ _, err = s.Write([]byte("PARTIAL"))
+ Expect(err).To(BeNil())
+ r, err := s.NextReader()
+ Expect(err).To(BeNil())
+ Expect(s.Close()).To(Succeed())
+
+ f, err := fs.Create(name)
+ Expect(err).To(BeNil())
+ _, err = f.Write([]byte("GOOD"))
+ Expect(err).To(BeNil())
+ Expect(f.Close()).To(Succeed())
+
+ done := make(chan []byte, 1)
+ go func() {
+ b, _ := io.ReadAll(r)
+ done <- b
+ }()
+ Eventually(done).Should(Receive(Equal([]byte("PARTIAL"))))
+ Expect(r.Close()).To(Succeed())
+
+ Expect(os.ReadFile(name)).To(Equal([]byte("GOOD")))
+ })
+ })
+
Describe("MarkComplete / Remove markers", func() {
It("creates a .complete marker for a data file", func() {
data := fs.KeyMapper("song1")
diff --git a/utils/cache/spread_fs_unix.go b/utils/cache/spread_fs_unix.go
new file mode 100644
index 000000000..c7cb19cf8
--- /dev/null
+++ b/utils/cache/spread_fs_unix.go
@@ -0,0 +1,18 @@
+//go:build !windows
+
+package cache
+
+import (
+ "os"
+
+ "github.com/djherbis/stream"
+)
+
+// createDataFile unlinks instead of truncating, so a re-created entry gets a fresh
+// inode and readers still holding the old one see its full contents.
+func createDataFile(name string) (stream.File, error) {
+ if err := os.Remove(name); err != nil && !os.IsNotExist(err) {
+ return nil, err
+ }
+ return os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
+}
diff --git a/utils/cache/spread_fs_windows.go b/utils/cache/spread_fs_windows.go
new file mode 100644
index 000000000..ca4186d65
--- /dev/null
+++ b/utils/cache/spread_fs_windows.go
@@ -0,0 +1,15 @@
+//go:build windows
+
+package cache
+
+import (
+ "os"
+
+ "github.com/djherbis/stream"
+)
+
+// createDataFile truncates in place: Windows refuses to unlink a file another handle
+// has open, and failing the create would break every miss on a path with a live reader.
+func createDataFile(name string) (stream.File, error) {
+ return os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+}