🎧 Your Personal Streaming Service
Go airsonicmadsonicmedia-servermusicmusic-servernavidromeopensubsonicraspberry-piself-hostedstreamerstreaming-apistreaming-audiosubsonicsubsonic-server
feat(artwork): add per-disc cover art support (#5182)
Deluan Quintão49a14d45838f
diff --git a/conf/configuration.go b/conf/configuration.goindex b867e0d56..dc5fd1b59 100644--- a/conf/configuration.go+++ b/conf/configuration.go@@ -71,6 +71,7 @@ type configOptions struct {CoverArtPriority stringCoverArtQuality intArtistArtPriority string+ DiscArtPriority stringLyricsPriority stringEnableGravatar boolEnableFavourites bool@@ -660,6 +661,7 @@ func setViperDefaults() {viper.SetDefault("coverartpriority", "cover.*, folder.*, front.*, embedded, external")viper.SetDefault("coverartquality", 75)viper.SetDefault("artistartpriority", "artist.*, album/artist.*, external")+ viper.SetDefault("discartpriority", "disc*.*, cd*.*, cover.*, folder.*, front.*, discsubtitle, embedded")viper.SetDefault("lyricspriority", ".lrc,.txt,embedded")viper.SetDefault("enablegravatar", false)viper.SetDefault("enablefavourites", true)diff --git a/core/artwork/artwork.go b/core/artwork/artwork.goindex 2e92b24c8..4a0a32afc 100644--- a/core/artwork/artwork.go+++ b/core/artwork/artwork.go@@ -122,6 +122,8 @@ func (a *artwork) getArtworkReader(ctx context.Context, artID model.ArtworkID, sartReader, err = newMediafileArtworkReader(ctx, a, artID)case model.KindPlaylistArtwork:artReader, err = newPlaylistArtworkReader(ctx, a, artID)+ case model.KindDiscArtwork:+ artReader, err = newDiscArtworkReader(ctx, a, artID)default:return nil, ErrUnavailable}diff --git a/core/artwork/reader_disc.go b/core/artwork/reader_disc.gonew file mode 100644index 000000000..7548f76d2--- /dev/null+++ b/core/artwork/reader_disc.go@@ -0,0 +1,268 @@+package artwork++import (+ "context"+ "crypto/md5"+ "fmt"+ "io"+ "os"+ "path/filepath"+ "strconv"+ "strings"+ "time"++ "github.com/Masterminds/squirrel"+ "github.com/navidrome/navidrome/conf"+ "github.com/navidrome/navidrome/core"+ "github.com/navidrome/navidrome/core/ffmpeg"+ "github.com/navidrome/navidrome/log"+ "github.com/navidrome/navidrome/model"+)++type discArtworkReader struct {+ cacheKey+ a *artwork+ album model.Album+ discNumber int+ imgFiles []string+ discFolders map[string]bool+ isMultiFolder bool+ firstTrackPath string+ updatedAt *time.Time+}++func newDiscArtworkReader(ctx context.Context, a *artwork, 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)+ if err != nil {+ return nil, err+ }++ _, imgFiles, imagesUpdatedAt, err := loadAlbumFoldersPaths(ctx, a.ds, *al)+ if err != nil {+ return nil, err+ }++ // Query mediafiles for this album + disc to find folder associations and first track+ mfs, err := a.ds.MediaFile(ctx).GetAll(model.QueryOptions{+ Sort: "track_number",+ Order: "ASC",+ Filters: squirrel.Eq{"album_id": albumID, "disc_number": discNumber},+ })+ if err != nil {+ return nil, err+ }++ // Build disc folder set and find first track+ discFolders := make(map[string]bool)+ var firstTrackPath string+ allFolderIDs := make(map[string]bool)+ for _, mf := range mfs {+ allFolderIDs[mf.FolderID] = true+ if firstTrackPath == "" {+ firstTrackPath = mf.Path+ }+ }++ // Resolve folder IDs to absolute paths+ 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{+ Filters: squirrel.Eq{"folder.id": folderIDs},+ })+ if err != nil {+ return nil, err+ }+ for _, f := range folders {+ discFolders[f.AbsolutePath()] = true+ }+ }++ isMultiFolder := len(al.FolderIDs) > 1++ r := &discArtworkReader{+ a: a,+ album: *al,+ discNumber: discNumber,+ imgFiles: imgFiles,+ discFolders: discFolders,+ isMultiFolder: isMultiFolder,+ firstTrackPath: core.AbsolutePath(ctx, a.ds, al.LibraryID, firstTrackPath),+ updatedAt: imagesUpdatedAt,+ }+ r.cacheKey.artID = artID+ if r.updatedAt != nil && r.updatedAt.After(al.UpdatedAt) {+ r.cacheKey.lastUpdate = *r.updatedAt+ } else {+ r.cacheKey.lastUpdate = al.UpdatedAt+ }+ 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.album.UpdatedAt+}++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...)+}++func (d *discArtworkReader) fromDiscArtPriority(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":+ ff = append(ff, fromTag(ctx, d.firstTrackPath), fromFFmpegTag(ctx, ffmpeg, d.firstTrackPath))+ case pattern == "external":+ // Not supported for disc art, silently ignore+ case pattern == "discsubtitle":+ if subtitle := strings.TrimSpace(d.album.Discs[d.discNumber]); subtitle != "" {+ ff = append(ff, d.fromDiscSubtitle(ctx, subtitle))+ }+ case len(d.imgFiles) > 0:+ ff = append(ff, d.fromExternalFile(ctx, pattern))+ }+ }+ return ff+}++// fromDiscSubtitle returns a sourceFunc that matches image files whose stem+// (filename without extension) equals the disc subtitle (case-insensitive).+func (d *discArtworkReader) fromDiscSubtitle(ctx context.Context, subtitle string) sourceFunc {+ return func() (io.ReadCloser, string, error) {+ for _, file := range d.imgFiles {+ _, name := filepath.Split(file)+ stem := strings.TrimSuffix(name, filepath.Ext(name))+ if !strings.EqualFold(stem, subtitle) {+ continue+ }+ f, err := os.Open(file)+ if err != nil {+ log.Warn(ctx, "Could not open disc art file", "file", file, err)+ continue+ }+ return f, file, nil+ }+ return nil, "", fmt.Errorf("disc %d: no image file matching subtitle %q", d.discNumber, subtitle)+ }+}++// extractDiscNumber extracts a disc number from a filename based on a glob pattern.+// It finds the portion of the filename that the wildcard matched and parses leading+// digits as the disc number. Returns (0, false) if the pattern doesn't match or+// no leading digits are found in the wildcard portion.+func extractDiscNumber(pattern, filename string) (int, bool) {+ filename = strings.ToLower(filename)+ pattern = strings.ToLower(pattern)++ matched, err := filepath.Match(pattern, filename)+ if err != nil || !matched {+ return 0, false+ }++ // Find the prefix before the first '*' in the pattern+ starIdx := strings.IndexByte(pattern, '*')+ if starIdx < 0 {+ return 0, false+ }+ prefix := pattern[:starIdx]++ // Strip the prefix from the filename to get the wildcard-matched portion+ if !strings.HasPrefix(filename, prefix) {+ return 0, false+ }+ remainder := filename[len(prefix):]++ // Extract leading ASCII digits from the remainder+ var digits []byte+ for _, r := range remainder {+ if r >= '0' && r <= '9' {+ digits = append(digits, byte(r))+ } else {+ break+ }+ }++ if len(digits) == 0 {+ return 0, false+ }++ num, err := strconv.Atoi(string(digits))+ if err != nil {+ return 0, false+ }+ return num, true+}++// fromExternalFile returns a sourceFunc that matches image files against a glob+// pattern with disc-number-aware filtering.+//+// Matching rules:+// - If a disc number can be extracted from the filename, the file matches only if+// the number equals the target disc number.+// - If no number is found and this is a multi-folder album, the file matches if+// it's in a folder containing tracks for this disc.+// - If no number is found and this is a single-folder album, the file is skipped+// (ambiguous).+func (d *discArtworkReader) fromExternalFile(ctx context.Context, pattern string) sourceFunc {+ return func() (io.ReadCloser, string, error) {+ for _, file := range d.imgFiles {+ _, name := filepath.Split(file)+ match, err := filepath.Match(pattern, strings.ToLower(name))+ if err != nil {+ log.Warn(ctx, "Error matching disc art file to pattern", "pattern", pattern, "file", file)+ continue+ }+ if !match {+ continue+ }++ // Try to extract disc number from filename+ num, hasNum := extractDiscNumber(pattern, name)+ if hasNum {+ // File has a disc number — must match target disc+ if num != d.discNumber {+ continue+ }+ } else if d.isMultiFolder {+ // No number, multi-folder: match by folder association+ dir := filepath.Dir(file)+ if !d.discFolders[dir] {+ continue+ }+ } else {+ // No number, single-folder: ambiguous, skip+ continue+ }++ f, err := os.Open(file)+ if err != nil {+ log.Warn(ctx, "Could not open disc art file", "file", file, err)+ continue+ }+ return f, file, nil+ }+ return nil, "", fmt.Errorf("disc %d: pattern '%s' not matched by files", d.discNumber, pattern)+ }+}diff --git a/core/artwork/reader_disc_test.go b/core/artwork/reader_disc_test.gonew file mode 100644index 000000000..f8193e24e--- /dev/null+++ b/core/artwork/reader_disc_test.go@@ -0,0 +1,285 @@+package artwork++import (+ "context"+ "os"+ "path/filepath"++ "github.com/navidrome/navidrome/model"+ . "github.com/onsi/ginkgo/v2"+ . "github.com/onsi/gomega"+)++var _ = Describe("Disc Artwork Reader", func() {+ Describe("extractDiscNumber", func() {+ DescribeTable("extracts disc number from filename based on glob pattern",+ func(pattern, filename string, expectedNum int, expectedOk bool) {+ num, ok := extractDiscNumber(pattern, filename)+ Expect(ok).To(Equal(expectedOk))+ if expectedOk {+ Expect(num).To(Equal(expectedNum))+ }+ },+ // Standard disc patterns+ Entry("disc1.jpg", "disc*.*", "disc1.jpg", 1, true),+ Entry("disc2.png", "disc*.*", "disc2.png", 2, true),+ Entry("disc01.jpg", "disc*.*", "disc01.jpg", 1, true),+ Entry("disc02.png", "disc*.*", "disc02.png", 2, true),+ Entry("disc10.jpg", "disc*.*", "disc10.jpg", 10, true),++ // CD patterns+ Entry("cd1.jpg", "cd*.*", "cd1.jpg", 1, true),+ Entry("cd02.png", "cd*.*", "cd02.png", 2, true),++ // No number in filename+ Entry("disc.jpg has no number", "disc*.*", "disc.jpg", 0, false),+ Entry("cd.jpg has no number", "cd*.*", "cd.jpg", 0, false),++ // Extra text after number+ Entry("disc2-bonus.jpg", "disc*.*", "disc2-bonus.jpg", 2, true),+ Entry("disc01_front.png", "disc*.*", "disc01_front.png", 1, true),++ // Case insensitive (filename already lowered by caller)+ Entry("Disc1.jpg lowered", "disc*.*", "disc1.jpg", 1, true),++ // Pattern doesn't match+ Entry("cover.jpg doesn't match disc*.*", "disc*.*", "cover.jpg", 0, false),++ // Pattern with no wildcard before dot+ Entry("front1.jpg with front*.*", "front*.*", "front1.jpg", 1, true),+ )+ })++ Describe("fromExternalFile", func() {+ var (+ ctx context.Context+ tmpDir string+ )++ BeforeEach(func() {+ ctx = context.Background()+ tmpDir = GinkgoT().TempDir()+ })++ createFile := func(path string) string {+ fullPath := filepath.Join(tmpDir, filepath.FromSlash(path))+ Expect(os.MkdirAll(filepath.Dir(fullPath), 0755)).To(Succeed())+ Expect(os.WriteFile(fullPath, []byte("image data"), 0600)).To(Succeed())+ return fullPath+ }++ It("matches file with disc number in single-folder album", func() {+ f1 := createFile("album/disc1.jpg")+ f2 := createFile("album/disc2.jpg")+ reader := &discArtworkReader{+ discNumber: 1,+ imgFiles: []string{f1, f2},+ discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},+ }++ sf := reader.fromExternalFile(ctx, "disc*.*")+ r, path, err := sf()+ Expect(err).ToNot(HaveOccurred())+ Expect(r).ToNot(BeNil())+ r.Close()+ Expect(path).To(Equal(f1))+ })++ It("skips file without number in single-folder album", func() {+ f1 := createFile("album/disc.jpg")+ reader := &discArtworkReader{+ discNumber: 1,+ imgFiles: []string{f1},+ discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},+ }++ sf := reader.fromExternalFile(ctx, "disc*.*")+ r, _, _ := sf()+ Expect(r).To(BeNil())+ })++ It("matches file without number in multi-folder album by folder", func() {+ f1 := createFile("album/cd1/disc.jpg")+ f2 := createFile("album/cd2/disc.jpg")+ reader := &discArtworkReader{+ discNumber: 1,+ imgFiles: []string{f1, f2},+ discFolders: map[string]bool{filepath.Join(tmpDir, "album", "cd1"): true},+ isMultiFolder: true,+ }++ sf := reader.fromExternalFile(ctx, "disc*.*")+ r, path, err := sf()+ Expect(err).ToNot(HaveOccurred())+ Expect(r).ToNot(BeNil())+ r.Close()+ Expect(path).To(Equal(f1))+ })++ It("prefers disc number over folder when number is present", func() {+ // disc2.jpg in cd1 folder should match disc 2, not disc 1+ f1 := createFile("album/cd1/disc2.jpg")+ reader := &discArtworkReader{+ discNumber: 2,+ imgFiles: []string{f1},+ discFolders: map[string]bool{filepath.Join(tmpDir, "album", "cd1"): true},+ isMultiFolder: true,+ }++ sf := reader.fromExternalFile(ctx, "disc*.*")+ r, path, err := sf()+ Expect(err).ToNot(HaveOccurred())+ Expect(r).ToNot(BeNil())+ r.Close()+ Expect(path).To(Equal(f1))+ })++ It("does not match disc2.jpg when looking for disc 1", func() {+ f1 := createFile("album/disc2.jpg")+ reader := &discArtworkReader{+ discNumber: 1,+ imgFiles: []string{f1},+ discFolders: map[string]bool{filepath.Join(tmpDir, "album"): true},+ }++ sf := reader.fromExternalFile(ctx, "disc*.*")+ r, _, _ := sf()+ Expect(r).To(BeNil())+ })+ })++ Describe("fromDiscSubtitle", func() {+ var (+ ctx context.Context+ tmpDir string+ )++ BeforeEach(func() {+ ctx = context.Background()+ tmpDir = GinkgoT().TempDir()+ })++ createFile := func(path string) string {+ fullPath := filepath.Join(tmpDir, filepath.FromSlash(path))+ Expect(os.MkdirAll(filepath.Dir(fullPath), 0755)).To(Succeed())+ Expect(os.WriteFile(fullPath, []byte("image data"), 0600)).To(Succeed())+ return fullPath+ }++ It("matches image file whose stem equals the disc subtitle (case-insensitive)", func() {+ f1 := createFile("album/The Blue Disc.jpg")+ reader := &discArtworkReader{+ discNumber: 1,+ imgFiles: []string{f1},+ }++ sf := reader.fromDiscSubtitle(ctx, "The Blue Disc")+ r, path, err := sf()+ Expect(err).ToNot(HaveOccurred())+ Expect(r).ToNot(BeNil())+ r.Close()+ Expect(path).To(Equal(f1))+ })++ It("matches case-insensitively", func() {+ f1 := createFile("album/bonus tracks.png")+ reader := &discArtworkReader{+ discNumber: 2,+ imgFiles: []string{f1},+ }++ sf := reader.fromDiscSubtitle(ctx, "Bonus Tracks")+ r, path, err := sf()+ Expect(err).ToNot(HaveOccurred())+ Expect(r).ToNot(BeNil())+ r.Close()+ Expect(path).To(Equal(f1))+ })++ It("returns error when no matching file found", func() {+ f1 := createFile("album/cover.jpg")+ reader := &discArtworkReader{+ discNumber: 1,+ imgFiles: []string{f1},+ }++ sf := reader.fromDiscSubtitle(ctx, "The Blue Disc")+ _, _, err := sf()+ Expect(err).To(HaveOccurred())+ })++ It("matches first file when multiple extensions exist", func() {+ f1 := createFile("album/The Blue Disc.jpg")+ f2 := createFile("album/The Blue Disc.png")+ reader := &discArtworkReader{+ discNumber: 1,+ imgFiles: []string{f1, f2},+ }++ sf := reader.fromDiscSubtitle(ctx, "The Blue Disc")+ r, path, err := sf()+ Expect(err).ToNot(HaveOccurred())+ Expect(r).ToNot(BeNil())+ r.Close()+ Expect(path).To(Equal(f1))+ })+ })++ Describe("discArtworkReader", func() {+ Describe("fromDiscArtPriority", func() {+ var reader *discArtworkReader++ BeforeEach(func() {+ reader = &discArtworkReader{+ discNumber: 2,+ isMultiFolder: true,+ discFolders: map[string]bool{"/music/album/cd2": true},+ imgFiles: []string{+ "/music/album/cd1/disc.jpg",+ "/music/album/cd2/disc.jpg",+ "/music/album/cd2/disc2.jpg",+ },+ firstTrackPath: "/music/album/cd2/track1.flac",+ }+ })++ It("returns source funcs for glob patterns", func() {+ ff := reader.fromDiscArtPriority(context.Background(), nil, "disc*.*")+ Expect(ff).To(HaveLen(1))+ })++ It("returns source funcs for embedded pattern", func() {+ ff := reader.fromDiscArtPriority(context.Background(), nil, "embedded")+ Expect(ff).To(HaveLen(2)) // fromTag + fromFFmpegTag+ })++ It("handles multiple comma-separated patterns", func() {+ ff := reader.fromDiscArtPriority(context.Background(), nil, "disc*.*, cd*.*, embedded")+ Expect(ff).To(HaveLen(4)) // disc*.* + cd*.* + fromTag + fromFFmpegTag+ })++ It("ignores 'external' pattern silently", func() {+ ff := reader.fromDiscArtPriority(context.Background(), nil, "external")+ Expect(ff).To(HaveLen(0))+ })++ It("returns no source funcs when imgFiles is empty and pattern is not embedded", func() {+ reader.imgFiles = nil+ ff := reader.fromDiscArtPriority(context.Background(), nil, "disc*.*")+ Expect(ff).To(HaveLen(0))+ })++ It("returns source func for discsubtitle pattern", func() {+ reader.album = model.Album{Discs: model.Discs{2: "Bonus Tracks"}}+ ff := reader.fromDiscArtPriority(context.Background(), nil, "discsubtitle")+ Expect(ff).To(HaveLen(1))+ })++ It("returns no source func for discsubtitle when disc has no subtitle", func() {+ reader.album = model.Album{Discs: model.Discs{2: ""}}+ ff := reader.fromDiscArtPriority(context.Background(), nil, "discsubtitle")+ Expect(ff).To(HaveLen(0))+ })+ })+ })+})diff --git a/model/artwork_id.go b/model/artwork_id.goindex 36026dd03..8d935f427 100644--- a/model/artwork_id.go+++ b/model/artwork_id.go@@ -22,6 +22,7 @@ var (KindArtistArtwork = Kind{"ar", "artist"}KindAlbumArtwork = Kind{"al", "album"}KindPlaylistArtwork = Kind{"pl", "playlist"}+ KindDiscArtwork = Kind{"dc", "disc"})var artworkKindMap = map[string]Kind{@@ -29,6 +30,7 @@ var artworkKindMap = map[string]Kind{KindArtistArtwork.prefix: KindArtistArtwork,KindAlbumArtwork.prefix: KindAlbumArtwork,KindPlaylistArtwork.prefix: KindPlaylistArtwork,+ KindDiscArtwork.prefix: KindDiscArtwork,}type ArtworkID struct {@@ -91,6 +93,22 @@ func MustParseArtworkID(id string) ArtworkID {return artID}+func DiscArtworkID(albumID string, discNumber int) string {+ return fmt.Sprintf("%s:%d", albumID, discNumber)+}++func ParseDiscArtworkID(id string) (albumID string, discNumber int, err error) {+ parts := strings.SplitN(id, ":", 2)+ if len(parts) != 2 || parts[1] == "" {+ return "", 0, errors.New("invalid disc artwork id")+ }+ num, err := strconv.Atoi(parts[1])+ if err != nil {+ return "", 0, fmt.Errorf("invalid disc number in artwork id: %w", err)+ }+ return parts[0], num, nil+}+func artworkIDFromAlbum(al Album) ArtworkID {return ArtworkID{Kind: KindAlbumArtwork,diff --git a/model/artwork_id_test.go b/model/artwork_id_test.goindex 2f42217f9..b634e7cbc 100644--- a/model/artwork_id_test.go+++ b/model/artwork_id_test.go@@ -28,6 +28,40 @@ var _ = Describe("ArtworkID", func() {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)+ 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()))+ })+ })++ Describe("ParseDiscArtworkID", func() {+ DescribeTable("parses composite disc artwork IDs",+ func(id string, expectedAlbum string, expectedDisc int, expectErr bool) {+ albumID, discNumber, err := model.ParseDiscArtworkID(id)+ if expectErr {+ Expect(err).To(HaveOccurred())+ } else {+ Expect(err).ToNot(HaveOccurred())+ Expect(albumID).To(Equal(expectedAlbum))+ Expect(discNumber).To(Equal(expectedDisc))+ }+ },+ Entry("valid id", "albumid123:2", "albumid123", 2, false),+ Entry("disc number 1", "abc:1", "abc", 1, false),+ Entry("large disc number", "abc:10", "abc", 10, false),+ Entry("missing colon", "albumid123", "", 0, true),+ Entry("missing disc number", "albumid123:", "", 0, true),+ Entry("non-numeric disc", "albumid123:abc", "", 0, true),+ Entry("empty string", "", "", 0, true),+ )+ })+Describe("ParseArtworkID()", func() {It("parses album artwork ids", func() {id, err := model.ParseArtworkID("al-1234")diff --git a/server/subsonic/helpers.go b/server/subsonic/helpers.goindex 598346901..e930aa630 100644--- a/server/subsonic/helpers.go+++ b/server/subsonic/helpers.go@@ -392,7 +392,13 @@ func buildDiscSubtitles(a model.Album) []responses.DiscTitle {}var discTitles []responses.DiscTitlefor num, title := range a.Discs {- discTitles = append(discTitles, responses.DiscTitle{Disc: int32(num), Title: title})+ artID := model.NewArtworkID(model.KindDiscArtwork,+ model.DiscArtworkID(a.ID, num), &a.UpdatedAt)+ discTitles = append(discTitles, responses.DiscTitle{+ Disc: int32(num),+ Title: title,+ CoverArt: artID.String(),+ })}if len(discTitles) == 1 && discTitles[0].Title == "" {return nildiff --git a/server/subsonic/helpers_test.go b/server/subsonic/helpers_test.goindex 2099c8f69..d20ca89ad 100644--- a/server/subsonic/helpers_test.go+++ b/server/subsonic/helpers_test.go@@ -3,6 +3,7 @@ package subsonicimport ("context""net/http/httptest"+ "time""github.com/go-chi/jwtauth/v5""github.com/navidrome/navidrome/conf"@@ -103,27 +104,43 @@ var _ = Describe("helpers", func() {Expect(buildDiscSubtitles(album)).To(BeNil())})- It("should return the disc title for a single disc", func() {+ It("should return the disc title with cover art for a single disc", func() {+ updatedAt := time.Now().Truncate(time.Second)album := model.Album{+ ID: "album1",+ UpdatedAt: updatedAt,Discs: map[int]string{1: "Special Edition",},}- Expect(buildDiscSubtitles(album)).To(Equal([]responses.DiscTitle{{Disc: 1, Title: "Special Edition"}}))+ result := buildDiscSubtitles(album)+ Expect(result).To(HaveLen(1))+ Expect(result[0].Disc).To(Equal(int32(1)))+ Expect(result[0].Title).To(Equal("Special Edition"))+ expectedArtID := model.NewArtworkID(model.KindDiscArtwork, "album1:1", &updatedAt)+ Expect(result[0].CoverArt).To(Equal(expectedArtID.String()))})- It("should return correct disc titles when album has discs with valid disc numbers", func() {+ It("should return correct disc titles with cover art when album has multiple discs", func() {+ updatedAt := time.Now().Truncate(time.Second)album := model.Album{+ ID: "album1",+ UpdatedAt: updatedAt,Discs: map[int]string{1: "Disc 1",2: "Disc 2",},}- expected := []responses.DiscTitle{- {Disc: 1, Title: "Disc 1"},- {Disc: 2, Title: "Disc 2"},- }- Expect(buildDiscSubtitles(album)).To(Equal(expected))+ result := buildDiscSubtitles(album)+ Expect(result).To(HaveLen(2))+ Expect(result[0].Disc).To(Equal(int32(1)))+ Expect(result[0].Title).To(Equal("Disc 1"))+ expectedArtID1 := model.NewArtworkID(model.KindDiscArtwork, "album1:1", &updatedAt)+ Expect(result[0].CoverArt).To(Equal(expectedArtID1.String()))+ Expect(result[1].Disc).To(Equal(int32(2)))+ Expect(result[1].Title).To(Equal("Disc 2"))+ expectedArtID2 := model.NewArtworkID(model.KindDiscArtwork, "album1:2", &updatedAt)+ Expect(result[1].CoverArt).To(Equal(expectedArtID2.String()))})})diff --git a/server/subsonic/responses/responses.go b/server/subsonic/responses/responses.goindex be59e5851..c550ce61e 100644--- a/server/subsonic/responses/responses.go+++ b/server/subsonic/responses/responses.go@@ -575,8 +575,9 @@ func (r ReplayGain) MarshalXML(e *xml.Encoder, start xml.StartElement) error {}type DiscTitle struct {- Disc int32 `xml:"disc,attr" json:"disc"`- Title string `xml:"title,attr" json:"title"`+ Disc int32 `xml:"disc,attr" json:"disc"`+ Title string `xml:"title,attr" json:"title"`+ CoverArt string `xml:"coverArt,attr,omitempty" json:"coverArt,omitempty"`}type ItemDate struct {diff --git a/ui/src/common/SongDatagrid.jsx b/ui/src/common/SongDatagrid.jsxindex 3586cf225..fbf2b9e31 100644--- a/ui/src/common/SongDatagrid.jsx+++ b/ui/src/common/SongDatagrid.jsx@@ -1,4 +1,10 @@-import React, { isValidElement, useMemo, useCallback, forwardRef } from 'react'+import React, {+ isValidElement,+ useMemo,+ useCallback,+ useState,+ forwardRef,+} from 'react'import { useDispatch } from 'react-redux'import {Datagrid,@@ -17,7 +23,10 @@ import { makeStyles } from '@material-ui/core/styles'import AlbumIcon from '@material-ui/icons/Album'import clsx from 'clsx'import { useDrag } from 'react-dnd'+import Lightbox from 'react-image-lightbox'+import 'react-image-lightbox/style.css'import { playTracks } from '../actions'+import subsonic from '../subsonic'import { AlbumContextMenu } from '../common'import { DraggableTypes } from '../consts'import { formatFullDate } from '../utils'@@ -28,10 +37,20 @@ const useStyles = makeStyles({overflow: 'hidden',textOverflow: 'ellipsis',verticalAlign: 'middle',+ display: 'flex',+ alignItems: 'center',},discIcon: {- verticalAlign: 'text-top',- marginRight: '4px',+ marginRight: '14px',+ },+ discCoverArt: {+ width: '48px',+ height: '48px',+ marginRight: '14px',+ objectFit: 'cover',+ borderRadius: '4px',+ flexShrink: 0,+ cursor: 'pointer',},row: {cursor: 'pointer',@@ -61,19 +80,45 @@ const useStyles = makeStyles({const DiscSubtitleRow = forwardRef(({ record, onClick, colSpan, contextAlwaysVisible }, ref) => {+ const translate = useTranslate()const isDesktop = useMediaQuery((theme) => theme.breakpoints.up('md'))const classes = useStyles({ isDesktop })+ const [imageError, setImageError] = useState(false)+ const [isLightboxOpen, setLightboxOpen] = useState(false)const handlePlaySubset = (discNumber) => () => {onClick(discNumber)}- let subtitle = []- if (record.discNumber > 0) {- subtitle.push(record.discNumber)- }- if (record.discSubtitle) {- subtitle.push(record.discSubtitle)- }+ const coverArtUrl = subsonic.getDiscCoverArtUrl(+ record.albumId,+ record.discNumber,+ record.updatedAt,+ 96,+ )++ const fullImageUrl = subsonic.getDiscCoverArtUrl(+ record.albumId,+ record.discNumber,+ record.updatedAt,+ )++ const handleOpenLightbox = useCallback(+ (e) => {+ if (!imageError) {+ e.stopPropagation()+ setLightboxOpen(true)+ }+ },+ [imageError],+ )++ const handleCloseLightbox = useCallback(() => setLightboxOpen(false), [])++ const subtitle = record.discSubtitle+ ? record.discSubtitle+ : translate('resources.song.fields.disc', {+ discNumber: record.discNumber,+ })return (<TableRow@@ -84,9 +129,28 @@ const DiscSubtitleRow = forwardRef(><TableCell colSpan={colSpan}><Typography variant="h6" className={classes.subtitle}>- <AlbumIcon className={classes.discIcon} fontSize={'small'} />- {subtitle.join(': ')}+ {!imageError ? (+ <img+ src={coverArtUrl}+ className={classes.discCoverArt}+ alt=""+ onClick={handleOpenLightbox}+ onError={() => setImageError(true)}+ />+ ) : (+ <AlbumIcon className={classes.discIcon} fontSize={'small'} />+ )}+ {subtitle}</Typography>+ {isLightboxOpen && !imageError && (+ <Lightbox+ imagePadding={50}+ animationDuration={200}+ imageTitle={record.album + ' - ' + subtitle}+ mainSrc={fullImageUrl}+ onCloseRequest={handleCloseLightbox}+ />+ )}</TableCell><TableCell><AlbumContextMenudiff --git a/ui/src/i18n/en.json b/ui/src/i18n/en.jsonindex 7c4b8ff09..baf4c9fa3 100644--- a/ui/src/i18n/en.json+++ b/ui/src/i18n/en.json@@ -23,6 +23,7 @@"bitDepth": "Bit depth","sampleRate": "Sample rate","channels": "Channels",+ "disc": "Disc %{discNumber}","discSubtitle": "Disc Subtitle","starred": "Favourite","comment": "Comment",diff --git a/ui/src/subsonic/index.js b/ui/src/subsonic/index.jsindex cfcc01043..65155e8f4 100644--- a/ui/src/subsonic/index.js+++ b/ui/src/subsonic/index.js@@ -91,6 +91,16 @@ const getCoverArtUrl = (record, size, square) => {}}+const getDiscCoverArtUrl = (albumId, discNumber, updatedAt, size) => {+ const options = {+ ...(updatedAt && { _: updatedAt }),+ ...(size && { size }),+ }+ return baseUrl(+ url('getCoverArt', 'dc-' + albumId + ':' + discNumber, options),+ )+}+const getArtistInfo = (id) => {return httpClient(url('getArtistInfo', id))}@@ -129,6 +139,7 @@ export default {getScanStatus,getNowPlaying,getCoverArtUrl,+ getDiscCoverArtUrl,getAvatarUrl,streamUrl,getAlbumInfo,diff --git a/ui/src/subsonic/index.test.js b/ui/src/subsonic/index.test.jsindex 1e0fbeaa6..2544e03f8 100644--- a/ui/src/subsonic/index.test.js+++ b/ui/src/subsonic/index.test.js@@ -105,6 +105,56 @@ describe('getCoverArtUrl', () => {})})+describe('getDiscCoverArtUrl', () => {+ beforeEach(() => {+ const localStorageMock = {+ getItem: vi.fn((key) => {+ const values = {+ username: 'testuser',+ 'subsonic-token': 'testtoken',+ 'subsonic-salt': 'testsalt',+ }+ return values[key] || null+ }),+ }+ Object.defineProperty(window, 'localStorage', { value: localStorageMock })+ })++ it('should construct URL with dc-albumId:discNumber format, size, and cache param', () => {+ const url = subsonic.getDiscCoverArtUrl(+ 'album-123',+ 2,+ '2023-01-01T00:00:00Z',+ 48,+ )++ expect(url).toContain('getCoverArt')+ expect(url).toContain('id=dc-album-123%3A2')+ expect(url).toContain('size=48')+ expect(url).toContain('_=2023-01-01T00%3A00%3A00Z')+ })++ it('should handle missing updatedAt', () => {+ const url = subsonic.getDiscCoverArtUrl('album-123', 1, undefined, 48)++ expect(url).toContain('id=dc-album-123%3A1')+ expect(url).toContain('size=48')+ expect(url).not.toContain('_=')+ })++ it('should handle missing size', () => {+ const url = subsonic.getDiscCoverArtUrl(+ 'album-123',+ 1,+ '2023-01-01T00:00:00Z',+ )++ expect(url).toContain('id=dc-album-123%3A1')+ expect(url).toContain('_=2023-01-01T00%3A00%3A00Z')+ expect(url).not.toContain('size=')+ })+})+describe('getAvatarUrl', () => {beforeEach(() => {// Mock localStorage values required by subsonic