fix: playlist cover art, compilation tag, and year

- ripPlaylist/ripTrackCollection: pre-fetch playlist artwork once, embed in all tracks
- ripTrack: skip per-track album cover when playlist embed is provided
- buildTagMetadata: set COMPILATION=1 and year from playlist publish_date
- beatport: normalize playlistMetadata to include date fields for year extraction
- qobuz: normalize playlist image_rectangle to standard image map

internal/app/app.go

@@ -11,6 +11,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"time"
 
 	"streamrip-go/internal/artwork"
 	"streamrip-go/internal/audio/convert"
@@ -58,6 +59,7 @@ type ripTrackOptions struct {
 	forPlaylist     bool
 	playlistName    string
 	playlistPos     int
+	playlistYear    int
 }
 
 type folderAudioValues struct {
@@ -372,14 +374,22 @@ func (m *Main) ripTrackCollection(ctx context.Context, p provider.Client, source
 			ids = append(ids, id)
 		}
 	}
+	var artRes artwork.Result
+	var playlistYear int
+	if playlistLike {
+		artRes, _ = artwork.Prepare(ctx, m.DL, folder, meta, m.Config.Session.Artwork, true)
+		playlistYear = extractYear(meta)
+	}
+
 	m.logf("%s: %s (%d tracks)\n", kind, name, len(ids))
 	failures := 0
 	runOne := func(i int, trackID string) {
-		opts := ripTrackOptions{albumFolder: folder, index: i, total: len(ids)}
+		opts := ripTrackOptions{albumFolder: folder, albumEmbedCover: artRes.EmbedPath, index: i, total: len(ids)}
 		if playlistLike {
 			opts.forPlaylist = true
 			opts.playlistName = name
 			opts.playlistPos = i
+			opts.playlistYear = playlistYear
 		}
 		if err := m.ripTrack(ctx, p, source, trackID, "", opts); err != nil {
 			failures++
@@ -404,11 +414,12 @@ func (m *Main) ripTrackCollection(ctx context.Context, p provider.Client, source
 			go func(pos int, tid string) {
 				defer wg.Done()
 				defer func() { <-sem }()
-				opts := ripTrackOptions{albumFolder: folder, index: pos, total: len(ids)}
+				opts := ripTrackOptions{albumFolder: folder, albumEmbedCover: artRes.EmbedPath, index: pos, total: len(ids)}
 				if playlistLike {
 					opts.forPlaylist = true
 					opts.playlistName = name
 					opts.playlistPos = pos
+					opts.playlistYear = playlistYear
 				}
 				if err := m.ripTrack(ctx, p, source, tid, "", opts); err != nil {
 					mu.Lock()
@@ -648,10 +659,7 @@ func (m *Main) ripAlbum(ctx context.Context, p provider.Client, source, albumID
 	}
 
 	albumTitle := titleFromMetadata(albumMeta, albumID)
-	albumArtist := jsonutil.NestedString(albumMeta, "artist", "name")
-	if albumArtist == "" {
-		albumArtist = "Unknown"
-	}
+	albumArtist := extractAlbumArtist(albumMeta)
 	releaseDate := jsonutil.StringFromAny(albumMeta["release_date_original"])
 	if releaseDate == "" {
 		releaseDate = jsonutil.StringFromAny(albumMeta["release_date"])
@@ -809,18 +817,24 @@ func (m *Main) ripPlaylist(ctx context.Context, p provider.Client, source, playl
 		}
 	}
 
+	artRes, _ := artwork.Prepare(ctx, m.DL, folder, playlistMeta, m.Config.Session.Artwork, true)
+
+	playlistYear := extractYear(playlistMeta)
+
 	total := len(ids)
 	m.logf("Playlist: %s (%d tracks)\n", name, total)
 	failures := 0
 
 	runOne := func(i int, id string) {
 		opts := ripTrackOptions{
-			albumFolder:  folder,
-			index:        i,
-			total:        total,
-			forPlaylist:  true,
-			playlistName: name,
-			playlistPos:  i,
+			albumFolder:     folder,
+			albumEmbedCover: artRes.EmbedPath,
+			index:           i,
+			total:           total,
+			forPlaylist:     true,
+			playlistName:    name,
+			playlistPos:     i,
+			playlistYear:    playlistYear,
 		}
 		if err := m.ripTrack(ctx, p, source, id, "", opts); err != nil {
 			failures++
@@ -846,7 +860,7 @@ func (m *Main) ripPlaylist(ctx context.Context, p provider.Client, source, playl
 			go func(pos int, tid string) {
 				defer wg.Done()
 				defer func() { <-sem }()
-				opts := ripTrackOptions{albumFolder: folder, index: pos, total: total, forPlaylist: true, playlistName: name, playlistPos: pos}
+				opts := ripTrackOptions{albumFolder: folder, albumEmbedCover: artRes.EmbedPath, index: pos, total: total, forPlaylist: true, playlistName: name, playlistPos: pos, playlistYear: playlistYear}
 				if err := m.ripTrack(ctx, p, source, tid, "", opts); err != nil {
 					mu.Lock()
 					failures++
@@ -1013,7 +1027,7 @@ func (m *Main) ripTrack(ctx context.Context, p provider.Client, source, id, fall
 downloaded:
 
 	embedCoverPath := opts.albumEmbedCover
-	if opts.forPlaylist {
+	if opts.forPlaylist && embedCoverPath == "" {
 		parent := opts.albumFolder
 		if parent == "" {
 			parent = filepath.Dir(outPath)
@@ -1023,7 +1037,7 @@ downloaded:
 				embedCoverPath = res.EmbedPath
 			}
 		}
-	} else if embedCoverPath == "" {
+	} else if !opts.forPlaylist && embedCoverPath == "" {
 		parent := opts.albumFolder
 		if parent == "" {
 			parent = filepath.Dir(outPath)
@@ -1224,10 +1238,7 @@ func (m *Main) trackOutputPath(source, id, title, ext string, d *provider.Downlo
 		if albumID == "" {
 			albumID = id
 		}
-		albumArtist := jsonutil.NestedString(trackMeta, "album", "artist", "name")
-		if albumArtist == "" {
-			albumArtist = jsonutil.NestedString(trackMeta, "performer", "name")
-		}
+		albumArtist := extractAlbumArtist(trackMetaAlbum(trackMeta))
 		albumYear := naming.YearFromDate(jsonutil.StringFromAny(trackMeta["release_date_original"]))
 		if albumYear == "Unknown" {
 			albumYear = naming.YearFromDate(jsonutil.StringFromAny(trackMeta["release_date"]))
@@ -1479,7 +1490,9 @@ func buildTagMetadata(trackMeta map[string]any, title, source, trackID string, o
 		Artist:              artist,
 		Artists:             artistNames,
 		AlbumArtist:         albumArtist,
+		Compilation:         opts.forPlaylist,
 		OmitDiscTags:        opts.forPlaylist,
+		Year:                opts.playlistYear,
 		TrackNumber:         trackNumber,
 		DiscNumber:          discNumber,
 		TrackTotal:          trackTotal,
@@ -1613,3 +1626,62 @@ func isFFmpegMissingError(err error) bool {
 	}
 	return strings.Contains(strings.ToLower(err.Error()), "ffmpeg not found")
 }
+
+func extractAlbumArtist(albumMeta map[string]any) string {
+	if artistsRaw, ok := albumMeta["artists"].([]any); ok {
+		names := make([]string, 0, len(artistsRaw))
+		for _, a := range artistsRaw {
+			artist, ok := a.(map[string]any)
+			if !ok {
+				continue
+			}
+			if name := jsonutil.StringFromAny(artist["name"]); name != "" {
+				names = append(names, name)
+			}
+		}
+		if len(names) > 0 {
+			return displayArtistNames(names)
+		}
+	}
+	if names := stringSliceFromAny(albumMeta["artist_names"]); len(names) > 0 {
+		return displayArtistNames(names)
+	}
+	artist := jsonutil.NestedString(albumMeta, "artist", "name")
+	if artist != "" {
+		return artist
+	}
+	return "Unknown"
+}
+
+func displayArtistNames(names []string) string {
+	switch len(names) {
+	case 0:
+		return ""
+	case 1:
+		return names[0]
+	case 2:
+		return names[0] + " & " + names[1]
+	default:
+		return strings.Join(names[:len(names)-1], ", ") + " & " + names[len(names)-1]
+	}
+}
+
+func extractYear(meta map[string]any) int {
+	date := jsonutil.FirstNonEmpty(
+		jsonutil.StringFromAny(meta["publish_date"]),
+		jsonutil.StringFromAny(meta["creation_date"]),
+		jsonutil.StringFromAny(meta["created_at"]),
+		jsonutil.StringFromAny(meta["release_date"]),
+		jsonutil.StringFromAny(meta["new_release_date"]),
+	)
+	if date == "" {
+		return 0
+	}
+	if t, err := time.Parse(time.RFC3339, date); err == nil {
+		return t.Year()
+	}
+	if t, err := time.Parse("2006-01-02", date); err == nil {
+		return t.Year()
+	}
+	return 0
+}

internal/audio/tag/tagger.go

@@ -16,7 +16,9 @@ type Metadata struct {
 	Artist              string
 	Artists             []string
 	AlbumArtist         string
+	Compilation         bool
 	OmitDiscTags        bool
+	Year                int
 	TrackNumber         int
 	DiscNumber          int
 	TrackTotal          int
@@ -197,6 +199,12 @@ func toTags(meta Metadata) map[string]string {
 	if meta.DiscTotal > 0 {
 		tags["disctotal"] = strconv.Itoa(meta.DiscTotal)
 	}
+	if meta.Compilation {
+		tags["COMPILATION"] = "1"
+	}
+	if meta.Year > 0 {
+		tags["year"] = strconv.Itoa(meta.Year)
+	}
 	return tags
 }
 

internal/provider/beatport/client.go

@@ -610,12 +610,15 @@ func (c *Client) releaseCollectionMetadata(raw map[string]any, releases []any) m
 func playlistMetadata(raw map[string]any, tracks []any) map[string]any {
 	name := jsonutil.StringFromAny(raw["name"])
 	return map[string]any{
-		"id":           jsonutil.StringFromAny(raw["id"]),
-		"name":         name,
-		"title":        name,
-		"tracks_count": firstPositiveInt(jsonutil.IntFromAny(raw["track_count"]), len(tracks)),
-		"image":        imageMap(raw["image"]),
-		"tracks":       map[string]any{"items": tracks},
+		"id":               jsonutil.StringFromAny(raw["id"]),
+		"name":             name,
+		"title":            name,
+		"tracks_count":     firstPositiveInt(jsonutil.IntFromAny(raw["track_count"]), len(tracks)),
+		"image":            imageMap(raw["image"]),
+		"publish_date":     jsonutil.StringFromAny(raw["publish_date"]),
+		"new_release_date": jsonutil.StringFromAny(raw["new_release_date"]),
+		"release_date":     jsonutil.StringFromAny(raw["release_date"]),
+		"tracks":           map[string]any{"items": tracks},
 	}
 }
 

internal/provider/qobuz/client.go

@@ -364,40 +364,60 @@ func qobuzDownloadExtension(resp map[string]any, quality int, streamURL string)
 }
 
 func qobuzAudioProfile(resp map[string]any, requestedQuality int, ext string) provider.AudioProfile {
+	exactBitDepth, _ := intValue(firstNonNil(resp["bit_depth"], resp["bits_depth"], resp["maximum_bit_depth"]))
+	exactSampling, _ := floatValue(firstNonNil(resp["sampling_rate"], resp["sample_rate"], resp["maximum_sampling_rate"]))
 	if formatID, ok := intValue(resp["format_id"]); ok {
 		switch formatID {
 		case 5:
+			if exactBitDepth == 0 {
+				exactBitDepth = 16
+			}
+			if exactSampling == 0 {
+				exactSampling = 44.1
+			}
 			return provider.AudioProfile{
 				Container:    "MP3",
 				Codec:        "MP3",
 				Quality:      "HIGH",
-				BitDepth:     16,
-				SamplingRate: "44.1",
+				BitDepth:     exactBitDepth,
+				SamplingRate: formatSamplingRate(exactSampling),
 				BitrateKbps:  320,
 			}
 		case 6:
+			if exactBitDepth == 0 {
+				exactBitDepth = 16
+			}
+			if exactSampling == 0 {
+				exactSampling = 44.1
+			}
 			return provider.AudioProfile{
 				Container:    "FLAC",
 				Codec:        "FLAC",
 				Quality:      "LOSSLESS",
-				BitDepth:     16,
-				SamplingRate: "44.1",
+				BitDepth:     exactBitDepth,
+				SamplingRate: formatSamplingRate(exactSampling),
 			}
 		case 7:
+			if exactBitDepth == 0 {
+				exactBitDepth = 24
+			}
 			return provider.AudioProfile{
 				Container:    "FLAC",
 				Codec:        "FLAC",
 				Quality:      "HI_RES",
-				BitDepth:     24,
-				SamplingRate: "96",
+				BitDepth:     exactBitDepth,
+				SamplingRate: formatSamplingRate(exactSampling),
 			}
 		case 27:
+			if exactBitDepth == 0 {
+				exactBitDepth = 24
+			}
 			return provider.AudioProfile{
 				Container:    "FLAC",
 				Codec:        "FLAC",
 				Quality:      "HI_RES",
-				BitDepth:     24,
-				SamplingRate: "192",
+				BitDepth:     exactBitDepth,
+				SamplingRate: formatSamplingRate(exactSampling),
 			}
 		}
 	}
@@ -438,6 +458,22 @@ func qobuzAudioProfile(resp map[string]any, requestedQuality int, ext string) pr
 	}
 }
 
+func firstNonNil(vals ...any) any {
+	for _, v := range vals {
+		if v != nil {
+			return v
+		}
+	}
+	return nil
+}
+
+func formatSamplingRate(v float64) string {
+	if v <= 0 {
+		return ""
+	}
+	return strconv.FormatFloat(v, 'f', -1, 64)
+}
+
 func (c *Client) Close() error {
 	return nil
 }
@@ -577,11 +613,13 @@ func (c *Client) getPlaylist(ctx context.Context, playlistID string) (map[string
 
 	total, _ := intValue(resp["tracks_count"])
 	if total <= pageLimit {
+		normalizePlaylistImage(resp)
 		return resp, nil
 	}
 
 	tracksObj, ok := mapValue(resp["tracks"])
 	if !ok {
+		normalizePlaylistImage(resp)
 		return resp, nil
 	}
 	items, ok := tracksObj["items"].([]any)
@@ -617,9 +655,25 @@ func (c *Client) getPlaylist(ctx context.Context, playlistID string) (map[string
 
 	tracksObj["items"] = items
 	resp["tracks"] = tracksObj
+	normalizePlaylistImage(resp)
 	return resp, nil
 }
 
+func normalizePlaylistImage(resp map[string]any) {
+	if resp["image"] != nil {
+		return
+	}
+	rect, ok := resp["image_rectangle"].([]any)
+	if !ok || len(rect) == 0 {
+		return
+	}
+	url, ok := rect[0].(string)
+	if !ok || url == "" {
+		return
+	}
+	resp["image"] = map[string]any{"original": url, "large": url}
+}
+
 func (c *Client) getLabel(ctx context.Context, labelID string) (map[string]any, error) {
 	pageLimit := 500
 	params := url.Values{}

internal/provider/qobuz/client_test.go

@@ -371,6 +371,24 @@ func TestGetDownloadableUsesReturnedURLExtension(t *testing.T) {
 	}
 }
 
+func TestQobuzAudioProfileUsesExactReturnedQuality(t *testing.T) {
+	profile := qobuzAudioProfile(map[string]any{
+		"format_id":     float64(7),
+		"bit_depth":     float64(24),
+		"sampling_rate": float64(44.1),
+	}, 4, "flac")
+	if profile.BitDepth != 24 || profile.SamplingRate != "44.1" || profile.Quality != "HI_RES" {
+		t.Fatalf("unexpected profile: %+v", profile)
+	}
+}
+
+func TestQobuzAudioProfileAvoidsGuessingHiResSampleRate(t *testing.T) {
+	profile := qobuzAudioProfile(map[string]any{"format_id": float64(7)}, 4, "flac")
+	if profile.BitDepth != 24 || profile.SamplingRate != "" || profile.Quality != "HI_RES" {
+		t.Fatalf("unexpected profile: %+v", profile)
+	}
+}
+
 func qobuzSecretSig(requestTS, secret string) string {
 	raw := "trackgetFileUrlformat_id27intentstreamtrack_id19512574" + requestTS + secret
 	hash := md5.Sum([]byte(raw))