refactor(transcoding): update default command handling and add codec support for transcoding

Signed-off-by: Deluan <deluan@navidrome.org>

adapters/gotaglib/gotaglib.go

@@ -65,6 +65,7 @@ func (e extractor) extractMetadata(filePath string) (*metadata.Info, error) {
 		Channels:   int(props.Channels),
 		SampleRate: int(props.SampleRate),
 		BitDepth:   int(props.BitsPerSample),
+		Codec:      props.Codec,
 	}
 
 	// Convert normalized tags to lowercase keys (go-taglib returns UPPERCASE keys)

cmd/wire_gen.go

@@ -19,6 +19,7 @@ import (
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
 	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/core/transcode"
 	"github.com/navidrome/navidrome/db"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/persistence"
@@ -102,7 +103,8 @@ func CreateSubsonicAPIRouter(ctx context.Context) *subsonic.Router {
 	modelScanner := scanner.New(ctx, dataStore, cacheWarmer, broker, playlists, metricsMetrics)
 	playTracker := scrobbler.GetPlayTracker(dataStore, broker, manager)
 	playbackServer := playback.GetInstance(dataStore)
-	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics)
+	decider := transcode.NewDecider(dataStore)
+	router := subsonic.New(dataStore, artworkArtwork, mediaStreamer, archiver, players, provider, modelScanner, broker, playlists, playTracker, share, playbackServer, metricsMetrics, decider)
 	return router
 }
 

consts/consts.go

@@ -151,7 +151,13 @@ var (
 			Name:           "aac audio",
 			TargetFormat:   "aac",
 			DefaultBitRate: 256,
-			Command:        "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a aac -f adts -",
+			Command:        "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a aac -f ipod -movflags frag_keyframe+empty_moov -",
+		},
+		{
+			Name:           "flac audio",
+			TargetFormat:   "flac",
+			DefaultBitRate: 0,
+			Command:        "ffmpeg -i %s -ss %t -map 0:a:0 -v 0 -c:a flac -f flac -",
 		},
 	}
 )

core/archiver.go

@@ -176,7 +176,7 @@ func (a *archiver) addFileToZip(ctx context.Context, z *zip.Writer, mf model.Med
 
 	var r io.ReadCloser
 	if format != "raw" && format != "" {
-		r, err = a.ms.DoStream(ctx, &mf, format, bitrate, 0)
+		r, err = a.ms.DoStream(ctx, &mf, StreamRequest{Format: format, BitRate: bitrate})
 	} else {
 		r, err = os.Open(path)
 	}

core/archiver_test.go

@@ -44,7 +44,7 @@ var _ = Describe("Archiver", func() {
 			}}).Return(mfs, nil)
 
 			ds.On("MediaFile", mock.Anything).Return(mfRepo)
-			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128, 0).Return(io.NopCloser(strings.NewReader("test")), nil).Times(3)
+			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128, 0, 0, 0, 0).Return(io.NopCloser(strings.NewReader("test")), nil).Times(3)
 
 			out := new(bytes.Buffer)
 			err := arch.ZipAlbum(context.Background(), "1", "mp3", 128, out)
@@ -73,7 +73,7 @@ var _ = Describe("Archiver", func() {
 			}}).Return(mfs, nil)
 
 			ds.On("MediaFile", mock.Anything).Return(mfRepo)
-			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128, 0).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
+			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128, 0, 0, 0, 0).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
 
 			out := new(bytes.Buffer)
 			err := arch.ZipArtist(context.Background(), "1", "mp3", 128, out)
@@ -104,7 +104,7 @@ var _ = Describe("Archiver", func() {
 			}
 
 			sh.On("Load", mock.Anything, "1").Return(share, nil)
-			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128, 0).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
+			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128, 0, 0, 0, 0).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
 
 			out := new(bytes.Buffer)
 			err := arch.ZipShare(context.Background(), "1", out)
@@ -136,7 +136,7 @@ var _ = Describe("Archiver", func() {
 			plRepo := &mockPlaylistRepository{}
 			plRepo.On("GetWithTracks", "1", true, false).Return(pls, nil)
 			ds.On("Playlist", mock.Anything).Return(plRepo)
-			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128, 0).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
+			ms.On("DoStream", mock.Anything, mock.Anything, "mp3", 128, 0, 0, 0, 0).Return(io.NopCloser(strings.NewReader("test")), nil).Times(2)
 
 			out := new(bytes.Buffer)
 			err := arch.ZipPlaylist(context.Background(), "1", "mp3", 128, out)
@@ -217,8 +217,8 @@ type mockMediaStreamer struct {
 	core.MediaStreamer
 }
 
-func (m *mockMediaStreamer) DoStream(ctx context.Context, mf *model.MediaFile, reqFormat string, reqBitRate int, reqOffset int) (*core.Stream, error) {
-	args := m.Called(ctx, mf, reqFormat, reqBitRate, reqOffset)
+func (m *mockMediaStreamer) DoStream(ctx context.Context, mf *model.MediaFile, req core.StreamRequest) (*core.Stream, error) {
+	args := m.Called(ctx, mf, req.Format, req.BitRate, req.SampleRate, req.BitDepth, req.Channels, req.Offset)
 	if args.Error(1) != nil {
 		return nil, args.Error(1)
 	}

core/ffmpeg/ffmpeg.go

@@ -12,11 +12,24 @@ import (
 	"sync"
 
 	"github.com/navidrome/navidrome/conf"
+	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/log"
 )
 
+// TranscodeOptions contains all parameters for a transcoding operation.
+type TranscodeOptions struct {
+	Command    string // DB command template (used to detect custom vs default)
+	Format     string // Target format (mp3, opus, aac, flac)
+	FilePath   string
+	BitRate    int // kbps, 0 = codec default
+	SampleRate int // 0 = no constraint
+	Channels   int // 0 = no constraint
+	BitDepth   int // 0 = no constraint; valid values: 16, 24, 32
+	Offset     int // seconds
+}
+
 type FFmpeg interface {
-	Transcode(ctx context.Context, command, path string, maxBitRate, offset int) (io.ReadCloser, error)
+	Transcode(ctx context.Context, opts TranscodeOptions) (io.ReadCloser, error)
 	ExtractImage(ctx context.Context, path string) (io.ReadCloser, error)
 	Probe(ctx context.Context, files []string) (string, error)
 	CmdPath() (string, error)
@@ -35,15 +48,19 @@ const (
 
 type ffmpeg struct{}
 
-func (e *ffmpeg) Transcode(ctx context.Context, command, path string, maxBitRate, offset int) (io.ReadCloser, error) {
+func (e *ffmpeg) Transcode(ctx context.Context, opts TranscodeOptions) (io.ReadCloser, error) {
 	if _, err := ffmpegCmd(); err != nil {
 		return nil, err
 	}
-	// First make sure the file exists
-	if err := fileExists(path); err != nil {
+	if err := fileExists(opts.FilePath); err != nil {
 		return nil, err
 	}
-	args := createFFmpegCommand(command, path, maxBitRate, offset)
+	var args []string
+	if isDefaultCommand(opts.Format, opts.Command) {
+		args = buildDynamicArgs(opts)
+	} else {
+		args = buildTemplateArgs(opts)
+	}
 	return e.start(ctx, args)
 }
 
@@ -51,7 +68,6 @@ func (e *ffmpeg) ExtractImage(ctx context.Context, path string) (io.ReadCloser,
 	if _, err := ffmpegCmd(); err != nil {
 		return nil, err
 	}
-	// First make sure the file exists
 	if err := fileExists(path); err != nil {
 		return nil, err
 	}
@@ -156,6 +172,139 @@ func (j *ffCmd) wait() {
 	_ = j.out.Close()
 }
 
+// formatCodecMap maps target format to ffmpeg codec flag.
+var formatCodecMap = map[string]string{
+	"mp3":  "libmp3lame",
+	"opus": "libopus",
+	"aac":  "aac",
+	"flac": "flac",
+}
+
+// formatOutputMap maps target format to ffmpeg output format flag (-f).
+var formatOutputMap = map[string]string{
+	"mp3":  "mp3",
+	"opus": "opus",
+	"aac":  "ipod",
+	"flac": "flac",
+}
+
+// defaultCommands is used to detect whether a user has customized their transcoding command.
+var defaultCommands = func() map[string]string {
+	m := make(map[string]string, len(consts.DefaultTranscodings))
+	for _, t := range consts.DefaultTranscodings {
+		m[t.TargetFormat] = t.Command
+	}
+	return m
+}()
+
+// isDefaultCommand returns true if the command matches the known default for this format.
+func isDefaultCommand(format, command string) bool {
+	return defaultCommands[format] == command
+}
+
+// buildDynamicArgs programmatically constructs ffmpeg arguments for known formats,
+// including all transcoding parameters (bitrate, sample rate, channels).
+func buildDynamicArgs(opts TranscodeOptions) []string {
+	cmdPath, _ := ffmpegCmd()
+	args := []string{cmdPath, "-i", opts.FilePath}
+
+	if opts.Offset > 0 {
+		args = append(args, "-ss", strconv.Itoa(opts.Offset))
+	}
+
+	args = append(args, "-map", "0:a:0")
+
+	if codec, ok := formatCodecMap[opts.Format]; ok {
+		args = append(args, "-c:a", codec)
+	}
+
+	if opts.BitRate > 0 {
+		args = append(args, "-b:a", strconv.Itoa(opts.BitRate)+"k")
+	}
+	if opts.SampleRate > 0 {
+		args = append(args, "-ar", strconv.Itoa(opts.SampleRate))
+	}
+	if opts.Channels > 0 {
+		args = append(args, "-ac", strconv.Itoa(opts.Channels))
+	}
+	// Only pass -sample_fmt for lossless output formats where bit depth matters.
+	// Lossy codecs (mp3, aac, opus) handle sample format conversion internally,
+	// and passing interleaved formats like "s16" causes silent failures.
+	if opts.BitDepth >= 16 && isLosslessOutputFormat(opts.Format) {
+		args = append(args, "-sample_fmt", bitDepthToSampleFmt(opts.BitDepth))
+	}
+
+	args = append(args, "-v", "0")
+
+	if outputFmt, ok := formatOutputMap[opts.Format]; ok {
+		args = append(args, "-f", outputFmt)
+	}
+
+	// For AAC in MP4 container, enable fragmented MP4 for pipe-safe streaming
+	if opts.Format == "aac" {
+		args = append(args, "-movflags", "frag_keyframe+empty_moov")
+	}
+
+	args = append(args, "-")
+	return args
+}
+
+// buildTemplateArgs handles user-customized command templates, with dynamic injection
+// of sample rate and channels when the template doesn't already include them.
+func buildTemplateArgs(opts TranscodeOptions) []string {
+	args := createFFmpegCommand(opts.Command, opts.FilePath, opts.BitRate, opts.Offset)
+
+	// Dynamically inject -ar, -ac, and -sample_fmt for custom templates that don't include them
+	if opts.SampleRate > 0 {
+		args = injectBeforeOutput(args, "-ar", strconv.Itoa(opts.SampleRate))
+	}
+	if opts.Channels > 0 {
+		args = injectBeforeOutput(args, "-ac", strconv.Itoa(opts.Channels))
+	}
+	if opts.BitDepth >= 16 && isLosslessOutputFormat(opts.Format) {
+		args = injectBeforeOutput(args, "-sample_fmt", bitDepthToSampleFmt(opts.BitDepth))
+	}
+	return args
+}
+
+// injectBeforeOutput inserts a flag and value before the trailing "-" (stdout output).
+func injectBeforeOutput(args []string, flag, value string) []string {
+	if len(args) > 0 && args[len(args)-1] == "-" {
+		result := make([]string, 0, len(args)+2)
+		result = append(result, args[:len(args)-1]...)
+		result = append(result, flag, value, "-")
+		return result
+	}
+	return append(args, flag, value)
+}
+
+// isLosslessOutputFormat returns true if the format is a lossless audio format
+// where preserving bit depth via -sample_fmt is meaningful.
+// Note: this covers only formats ffmpeg can produce as output. For the full set of
+// lossless formats used in transcoding decisions, see core/transcode/codec.go:isLosslessFormat.
+func isLosslessOutputFormat(format string) bool {
+	switch strings.ToLower(format) {
+	case "flac", "alac", "wav", "aiff":
+		return true
+	}
+	return false
+}
+
+// bitDepthToSampleFmt converts a bit depth value to the ffmpeg sample_fmt string.
+// FLAC only supports s16 and s32; for 24-bit sources, s32 is the correct format
+// (ffmpeg packs 24-bit samples into 32-bit containers).
+func bitDepthToSampleFmt(bitDepth int) string {
+	switch bitDepth {
+	case 16:
+		return "s16"
+	case 32:
+		return "s32"
+	default:
+		// 24-bit and other depths: use s32 (the next valid container size)
+		return "s32"
+	}
+}
+
 // Path will always be an absolute path
 func createFFmpegCommand(cmd, path string, maxBitRate, offset int) []string {
 	var args []string

core/ffmpeg/ffmpeg_test.go

@@ -2,19 +2,27 @@ package ffmpeg
 
 import (
 	"context"
+	"os"
+	"path/filepath"
 	"runtime"
 	sync "sync"
 	"testing"
 	"time"
 
+	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/log"
-	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 )
 
 func TestFFmpeg(t *testing.T) {
-	tests.Init(t, false)
+	// Inline test init to avoid import cycle with tests package
+	//nolint:dogsled
+	_, file, _, _ := runtime.Caller(0)
+	appPath, _ := filepath.Abs(filepath.Join(filepath.Dir(file), "..", ".."))
+	confPath := filepath.Join(appPath, "tests", "navidrome-test.toml")
+	_ = os.Chdir(appPath)
+	conf.LoadFromFile(confPath)
 	log.SetLevel(log.LevelFatal)
 	RegisterFailHandler(Fail)
 	RunSpecs(t, "FFmpeg Suite")
@@ -70,6 +78,286 @@ var _ = Describe("ffmpeg", func() {
 		})
 	})
 
+	Describe("isDefaultCommand", func() {
+		It("returns true for known default mp3 command", func() {
+			Expect(isDefaultCommand("mp3", "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -f mp3 -")).To(BeTrue())
+		})
+		It("returns true for known default opus command", func() {
+			Expect(isDefaultCommand("opus", "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a libopus -f opus -")).To(BeTrue())
+		})
+		It("returns true for known default aac command", func() {
+			Expect(isDefaultCommand("aac", "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a aac -f ipod -movflags frag_keyframe+empty_moov -")).To(BeTrue())
+		})
+		It("returns true for known default flac command", func() {
+			Expect(isDefaultCommand("flac", "ffmpeg -i %s -ss %t -map 0:a:0 -v 0 -c:a flac -f flac -")).To(BeTrue())
+		})
+		It("returns false for a custom command", func() {
+			Expect(isDefaultCommand("mp3", "ffmpeg -i %s -b:a %bk -custom-flag -f mp3 -")).To(BeFalse())
+		})
+		It("returns false for unknown format", func() {
+			Expect(isDefaultCommand("wav", "ffmpeg -i %s -f wav -")).To(BeFalse())
+		})
+	})
+
+	Describe("buildDynamicArgs", func() {
+		It("builds mp3 args with bitrate, samplerate, and channels", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:     "mp3",
+				FilePath:   "/music/file.flac",
+				BitRate:    256,
+				SampleRate: 48000,
+				Channels:   2,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.flac",
+				"-map", "0:a:0",
+				"-c:a", "libmp3lame",
+				"-b:a", "256k",
+				"-ar", "48000",
+				"-ac", "2",
+				"-v", "0",
+				"-f", "mp3",
+				"-",
+			}))
+		})
+
+		It("builds flac args without bitrate", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:     "flac",
+				FilePath:   "/music/file.dsf",
+				SampleRate: 48000,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.dsf",
+				"-map", "0:a:0",
+				"-c:a", "flac",
+				"-ar", "48000",
+				"-v", "0",
+				"-f", "flac",
+				"-",
+			}))
+		})
+
+		It("builds opus args with bitrate only", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "opus",
+				FilePath: "/music/file.flac",
+				BitRate:  128,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.flac",
+				"-map", "0:a:0",
+				"-c:a", "libopus",
+				"-b:a", "128k",
+				"-v", "0",
+				"-f", "opus",
+				"-",
+			}))
+		})
+
+		It("includes offset when specified", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "mp3",
+				FilePath: "/music/file.mp3",
+				BitRate:  192,
+				Offset:   30,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.mp3",
+				"-ss", "30",
+				"-map", "0:a:0",
+				"-c:a", "libmp3lame",
+				"-b:a", "192k",
+				"-v", "0",
+				"-f", "mp3",
+				"-",
+			}))
+		})
+
+		It("builds aac args with fragmented MP4 container", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "aac",
+				FilePath: "/music/file.flac",
+				BitRate:  256,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.flac",
+				"-map", "0:a:0",
+				"-c:a", "aac",
+				"-b:a", "256k",
+				"-v", "0",
+				"-f", "ipod",
+				"-movflags", "frag_keyframe+empty_moov",
+				"-",
+			}))
+		})
+
+		It("builds flac args with bit depth", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "flac",
+				FilePath: "/music/file.dsf",
+				BitDepth: 24,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.dsf",
+				"-map", "0:a:0",
+				"-c:a", "flac",
+				"-sample_fmt", "s32",
+				"-v", "0",
+				"-f", "flac",
+				"-",
+			}))
+		})
+
+		It("omits -sample_fmt when bit depth is 0", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "flac",
+				FilePath: "/music/file.flac",
+				BitDepth: 0,
+			})
+			Expect(args).ToNot(ContainElement("-sample_fmt"))
+		})
+
+		It("omits -sample_fmt when bit depth is too low (DSD)", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "flac",
+				FilePath: "/music/file.dsf",
+				BitDepth: 1,
+			})
+			Expect(args).ToNot(ContainElement("-sample_fmt"))
+		})
+
+		It("omits -sample_fmt for mp3 even when bit depth >= 16", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "mp3",
+				FilePath: "/music/file.flac",
+				BitRate:  256,
+				BitDepth: 16,
+			})
+			Expect(args).ToNot(ContainElement("-sample_fmt"))
+		})
+
+		It("omits -sample_fmt for aac even when bit depth >= 16", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "aac",
+				FilePath: "/music/file.flac",
+				BitRate:  256,
+				BitDepth: 16,
+			})
+			Expect(args).ToNot(ContainElement("-sample_fmt"))
+		})
+
+		It("omits -sample_fmt for opus even when bit depth >= 16", func() {
+			args := buildDynamicArgs(TranscodeOptions{
+				Format:   "opus",
+				FilePath: "/music/file.flac",
+				BitRate:  128,
+				BitDepth: 16,
+			})
+			Expect(args).ToNot(ContainElement("-sample_fmt"))
+		})
+	})
+
+	Describe("bitDepthToSampleFmt", func() {
+		It("converts 16-bit", func() {
+			Expect(bitDepthToSampleFmt(16)).To(Equal("s16"))
+		})
+		It("converts 24-bit to s32 (FLAC only supports s16/s32)", func() {
+			Expect(bitDepthToSampleFmt(24)).To(Equal("s32"))
+		})
+		It("converts 32-bit", func() {
+			Expect(bitDepthToSampleFmt(32)).To(Equal("s32"))
+		})
+	})
+
+	Describe("buildTemplateArgs", func() {
+		It("injects -ar and -ac into custom template", func() {
+			args := buildTemplateArgs(TranscodeOptions{
+				Command:    "ffmpeg -i %s -b:a %bk -v 0 -f mp3 -",
+				FilePath:   "/music/file.flac",
+				BitRate:    192,
+				SampleRate: 44100,
+				Channels:   2,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.flac",
+				"-b:a", "192k", "-v", "0", "-f", "mp3",
+				"-ar", "44100", "-ac", "2",
+				"-",
+			}))
+		})
+
+		It("injects only -ar when channels is 0", func() {
+			args := buildTemplateArgs(TranscodeOptions{
+				Command:    "ffmpeg -i %s -b:a %bk -v 0 -f mp3 -",
+				FilePath:   "/music/file.flac",
+				BitRate:    192,
+				SampleRate: 48000,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.flac",
+				"-b:a", "192k", "-v", "0", "-f", "mp3",
+				"-ar", "48000",
+				"-",
+			}))
+		})
+
+		It("does not inject anything when sample rate and channels are 0", func() {
+			args := buildTemplateArgs(TranscodeOptions{
+				Command:  "ffmpeg -i %s -b:a %bk -v 0 -f mp3 -",
+				FilePath: "/music/file.flac",
+				BitRate:  192,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.flac",
+				"-b:a", "192k", "-v", "0", "-f", "mp3",
+				"-",
+			}))
+		})
+
+		It("injects -sample_fmt for lossless output format with bit depth", func() {
+			args := buildTemplateArgs(TranscodeOptions{
+				Command:  "ffmpeg -i %s -v 0 -c:a flac -f flac -",
+				Format:   "flac",
+				FilePath: "/music/file.dsf",
+				BitDepth: 24,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.dsf",
+				"-v", "0", "-c:a", "flac", "-f", "flac",
+				"-sample_fmt", "s32",
+				"-",
+			}))
+		})
+
+		It("does not inject -sample_fmt for lossy output format even with bit depth", func() {
+			args := buildTemplateArgs(TranscodeOptions{
+				Command:  "ffmpeg -i %s -b:a %bk -v 0 -f mp3 -",
+				Format:   "mp3",
+				FilePath: "/music/file.flac",
+				BitRate:  192,
+				BitDepth: 16,
+			})
+			Expect(args).To(Equal([]string{
+				"ffmpeg", "-i", "/music/file.flac",
+				"-b:a", "192k", "-v", "0", "-f", "mp3",
+				"-",
+			}))
+		})
+	})
+
+	Describe("injectBeforeOutput", func() {
+		It("inserts flag before trailing dash", func() {
+			args := injectBeforeOutput([]string{"ffmpeg", "-i", "file.mp3", "-f", "mp3", "-"}, "-ar", "48000")
+			Expect(args).To(Equal([]string{"ffmpeg", "-i", "file.mp3", "-f", "mp3", "-ar", "48000", "-"}))
+		})
+
+		It("appends when no trailing dash", func() {
+			args := injectBeforeOutput([]string{"ffmpeg", "-i", "file.mp3"}, "-ar", "48000")
+			Expect(args).To(Equal([]string{"ffmpeg", "-i", "file.mp3", "-ar", "48000"}))
+		})
+	})
+
 	Describe("FFmpeg", func() {
 		Context("when FFmpeg is available", func() {
 			var ff FFmpeg
@@ -93,7 +381,12 @@ var _ = Describe("ffmpeg", func() {
 				command := "ffmpeg -f lavfi -i sine=frequency=1000:duration=0 -f mp3 -"
 
 				// The input file is not used here, but we need to provide a valid path to the Transcode function
-				stream, err := ff.Transcode(ctx, command, "tests/fixtures/test.mp3", 128, 0)
+				stream, err := ff.Transcode(ctx, TranscodeOptions{
+					Command:  command,
+					Format:   "mp3",
+					FilePath: "tests/fixtures/test.mp3",
+					BitRate:  128,
+				})
 				Expect(err).ToNot(HaveOccurred())
 				defer stream.Close()
 
@@ -115,7 +408,12 @@ var _ = Describe("ffmpeg", func() {
 				cancel() // Cancel immediately
 
 				// This should fail immediately
-				_, err := ff.Transcode(ctx, "ffmpeg -i %s -f mp3 -", "tests/fixtures/test.mp3", 128, 0)
+				_, err := ff.Transcode(ctx, TranscodeOptions{
+					Command:  "ffmpeg -i %s -f mp3 -",
+					Format:   "mp3",
+					FilePath: "tests/fixtures/test.mp3",
+					BitRate:  128,
+				})
 				Expect(err).To(MatchError(context.Canceled))
 			})
 		})
@@ -142,7 +440,10 @@ var _ = Describe("ffmpeg", func() {
 				defer cancel()
 
 				// Start a process that will run for a while
-				stream, err := ff.Transcode(ctx, longRunningCmd, "tests/fixtures/test.mp3", 0, 0)
+				stream, err := ff.Transcode(ctx, TranscodeOptions{
+					Command:  longRunningCmd,
+					FilePath: "tests/fixtures/test.mp3",
+				})
 				Expect(err).ToNot(HaveOccurred())
 				defer stream.Close()
 

core/media_streamer.go

@@ -18,9 +18,20 @@ import (
 	"github.com/navidrome/navidrome/utils/cache"
 )
 
+// StreamRequest contains all parameters for creating a media stream.
+type StreamRequest struct {
+	ID         string
+	Format     string
+	BitRate    int // kbps
+	SampleRate int
+	BitDepth   int
+	Channels   int
+	Offset     int // seconds
+}
+
 type MediaStreamer interface {
-	NewStream(ctx context.Context, id string, reqFormat string, reqBitRate int, offset int) (*Stream, error)
-	DoStream(ctx context.Context, mf *model.MediaFile, reqFormat string, reqBitRate int, reqOffset int) (*Stream, error)
+	NewStream(ctx context.Context, req StreamRequest) (*Stream, error)
+	DoStream(ctx context.Context, mf *model.MediaFile, req StreamRequest) (*Stream, error)
 }
 
 type TranscodingCache cache.FileCache
@@ -36,28 +47,31 @@ type mediaStreamer struct {
 }
 
 type streamJob struct {
-	ms       *mediaStreamer
-	mf       *model.MediaFile
-	filePath string
-	format   string
-	bitRate  int
-	offset   int
+	ms         *mediaStreamer
+	mf         *model.MediaFile
+	filePath   string
+	format     string
+	bitRate    int
+	sampleRate int
+	bitDepth   int
+	channels   int
+	offset     int
 }
 
 func (j *streamJob) Key() string {
-	return fmt.Sprintf("%s.%s.%d.%s.%d", j.mf.ID, j.mf.UpdatedAt.Format(time.RFC3339Nano), j.bitRate, j.format, j.offset)
+	return fmt.Sprintf("%s.%s.%d.%d.%d.%d.%s.%d", j.mf.ID, j.mf.UpdatedAt.Format(time.RFC3339Nano), j.bitRate, j.sampleRate, j.bitDepth, j.channels, j.format, j.offset)
 }
 
-func (ms *mediaStreamer) NewStream(ctx context.Context, id string, reqFormat string, reqBitRate int, reqOffset int) (*Stream, error) {
-	mf, err := ms.ds.MediaFile(ctx).Get(id)
+func (ms *mediaStreamer) NewStream(ctx context.Context, req StreamRequest) (*Stream, error) {
+	mf, err := ms.ds.MediaFile(ctx).Get(req.ID)
 	if err != nil {
 		return nil, err
 	}
 
-	return ms.DoStream(ctx, mf, reqFormat, reqBitRate, reqOffset)
+	return ms.DoStream(ctx, mf, req)
 }
 
-func (ms *mediaStreamer) DoStream(ctx context.Context, mf *model.MediaFile, reqFormat string, reqBitRate int, reqOffset int) (*Stream, error) {
+func (ms *mediaStreamer) DoStream(ctx context.Context, mf *model.MediaFile, req StreamRequest) (*Stream, error) {
 	var format string
 	var bitRate int
 	var cached bool
@@ -67,13 +81,13 @@ func (ms *mediaStreamer) DoStream(ctx context.Context, mf *model.MediaFile, reqF
 			"originalFormat", mf.Suffix, "originalBitRate", mf.BitRate)
 	}()
 
-	format, bitRate = selectTranscodingOptions(ctx, ms.ds, mf, reqFormat, reqBitRate)
+	format, bitRate = selectTranscodingOptions(ctx, ms.ds, mf, req.Format, req.BitRate, req.SampleRate)
 	s := &Stream{ctx: ctx, mf: mf, format: format, bitRate: bitRate}
 	filePath := mf.AbsolutePath()
 
 	if format == "raw" {
 		log.Debug(ctx, "Streaming RAW file", "id", mf.ID, "path", filePath,
-			"requestBitrate", reqBitRate, "requestFormat", reqFormat, "requestOffset", reqOffset,
+			"requestBitrate", req.BitRate, "requestFormat", req.Format, "requestOffset", req.Offset,
 			"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix,
 			"selectedBitrate", bitRate, "selectedFormat", format)
 		f, err := os.Open(filePath)
@@ -87,12 +101,15 @@ func (ms *mediaStreamer) DoStream(ctx context.Context, mf *model.MediaFile, reqF
 	}
 
 	job := &streamJob{
-		ms:       ms,
-		mf:       mf,
-		filePath: filePath,
-		format:   format,
-		bitRate:  bitRate,
-		offset:   reqOffset,
+		ms:         ms,
+		mf:         mf,
+		filePath:   filePath,
+		format:     format,
+		bitRate:    bitRate,
+		sampleRate: req.SampleRate,
+		bitDepth:   req.BitDepth,
+		channels:   req.Channels,
+		offset:     req.Offset,
 	}
 	r, err := ms.cache.Get(ctx, job)
 	if err != nil {
@@ -105,7 +122,7 @@ func (ms *mediaStreamer) DoStream(ctx context.Context, mf *model.MediaFile, reqF
 	s.Seeker = r.Seeker
 
 	log.Debug(ctx, "Streaming TRANSCODED file", "id", mf.ID, "path", filePath,
-		"requestBitrate", reqBitRate, "requestFormat", reqFormat, "requestOffset", reqOffset,
+		"requestBitrate", req.BitRate, "requestFormat", req.Format, "requestOffset", req.Offset,
 		"originalBitrate", mf.BitRate, "originalFormat", mf.Suffix,
 		"selectedBitrate", bitRate, "selectedFormat", format, "cached", cached, "seekable", s.Seekable())
 
@@ -131,12 +148,13 @@ func (s *Stream) EstimatedContentLength() int {
 }
 
 // TODO This function deserves some love (refactoring)
-func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model.MediaFile, reqFormat string, reqBitRate int) (format string, bitRate int) {
+func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model.MediaFile, reqFormat string, reqBitRate int, reqSampleRate int) (format string, bitRate int) {
 	format = "raw"
 	if reqFormat == "raw" {
 		return format, 0
 	}
-	if reqFormat == mf.Suffix && reqBitRate == 0 {
+	needsResample := reqSampleRate > 0 && reqSampleRate < mf.SampleRate
+	if reqFormat == mf.Suffix && reqBitRate == 0 && !needsResample {
 		bitRate = mf.BitRate
 		return format, bitRate
 	}
@@ -175,7 +193,7 @@ func selectTranscodingOptions(ctx context.Context, ds model.DataStore, mf *model
 			bitRate = t.DefaultBitRate
 		}
 	}
-	if format == mf.Suffix && bitRate >= mf.BitRate {
+	if format == mf.Suffix && bitRate >= mf.BitRate && !needsResample {
 		format = "raw"
 		bitRate = 0
 	}
@@ -217,7 +235,16 @@ func NewTranscodingCache() TranscodingCache {
 				transcodingCtx = request.AddValues(context.Background(), ctx)
 			}
 
-			out, err := job.ms.transcoder.Transcode(transcodingCtx, t.Command, job.filePath, job.bitRate, job.offset)
+			out, err := job.ms.transcoder.Transcode(transcodingCtx, ffmpeg.TranscodeOptions{
+				Command:    t.Command,
+				Format:     job.format,
+				FilePath:   job.filePath,
+				BitRate:    job.bitRate,
+				SampleRate: job.sampleRate,
+				BitDepth:   job.bitDepth,
+				Channels:   job.channels,
+				Offset:     job.offset,
+			})
 			if err != nil {
 				log.Error(ctx, "Error starting transcoder", "id", job.mf.ID, err)
 				return nil, os.ErrInvalid

core/media_streamer_Internal_test.go

@@ -26,42 +26,64 @@ var _ = Describe("MediaStreamer", func() {
 			It("returns raw if raw is requested", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0)
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0, 0)
 				Expect(format).To(Equal("raw"))
 			})
 			It("returns raw if a transcoder does not exists", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, _ := selectTranscodingOptions(ctx, ds, mf, "m4a", 0)
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "m4a", 0, 0)
 				Expect(format).To(Equal("raw"))
 			})
 			It("returns the requested format if a transcoder exists", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0, 0)
 				Expect(format).To(Equal("mp3"))
 				Expect(bitRate).To(Equal(160)) // Default Bit Rate
 			})
 			It("returns raw if requested format is the same as the original and it is not necessary to downsample", func() {
 				mf.Suffix = "mp3"
 				mf.BitRate = 112
-				format, _ := selectTranscodingOptions(ctx, ds, mf, "mp3", 128)
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "mp3", 128, 0)
 				Expect(format).To(Equal("raw"))
 			})
 			It("returns the requested format if requested BitRate is lower than original", func() {
 				mf.Suffix = "mp3"
 				mf.BitRate = 320
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 192)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 192, 0)
 				Expect(format).To(Equal("mp3"))
 				Expect(bitRate).To(Equal(192))
 			})
 			It("returns raw if requested format is the same as the original, but requested BitRate is 0", func() {
 				mf.Suffix = "mp3"
 				mf.BitRate = 320
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0, 0)
 				Expect(format).To(Equal("raw"))
 				Expect(bitRate).To(Equal(320))
 			})
+			It("returns the format when same format is requested but with a lower sample rate", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 2118
+				mf.SampleRate = 96000
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "flac", 0, 48000)
+				Expect(format).To(Equal("flac"))
+				Expect(bitRate).To(Equal(0))
+			})
+			It("returns raw when same format is requested with same sample rate", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				mf.SampleRate = 48000
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "flac", 0, 48000)
+				Expect(format).To(Equal("raw"))
+			})
+			It("returns raw when same format is requested with no sample rate constraint", func() {
+				mf.Suffix = "flac"
+				mf.BitRate = 1000
+				mf.SampleRate = 96000
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "flac", 0, 0)
+				Expect(format).To(Equal("raw"))
+			})
 			Context("Downsampling", func() {
 				BeforeEach(func() {
 					conf.Server.DefaultDownsamplingFormat = "opus"
@@ -69,13 +91,13 @@ var _ = Describe("MediaStreamer", func() {
 					mf.BitRate = 960
 				})
 				It("returns the DefaultDownsamplingFormat if a maxBitrate is requested but not the format", func() {
-					format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 128)
+					format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 128, 0)
 					Expect(format).To(Equal("opus"))
 					Expect(bitRate).To(Equal(128))
 				})
 				It("returns raw if maxBitrate is equal or greater than original", func() {
 					// This happens with DSub (and maybe other clients?). See https://github.com/navidrome/navidrome/issues/2066
-					format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 960)
+					format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 960, 0)
 					Expect(format).To(Equal("raw"))
 					Expect(bitRate).To(Equal(0))
 				})
@@ -90,34 +112,34 @@ var _ = Describe("MediaStreamer", func() {
 			It("returns raw if raw is requested", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0)
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0, 0)
 				Expect(format).To(Equal("raw"))
 			})
 			It("returns configured format/bitrate as default", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 0)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 0, 0)
 				Expect(format).To(Equal("oga"))
 				Expect(bitRate).To(Equal(96))
 			})
 			It("returns requested format", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0, 0)
 				Expect(format).To(Equal("mp3"))
 				Expect(bitRate).To(Equal(160)) // Default Bit Rate
 			})
 			It("returns requested bitrate", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 80)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 80, 0)
 				Expect(format).To(Equal("oga"))
 				Expect(bitRate).To(Equal(80))
 			})
 			It("returns raw if selected bitrate and format is the same as original", func() {
 				mf.Suffix = "mp3"
 				mf.BitRate = 192
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 192)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 192, 0)
 				Expect(format).To(Equal("raw"))
 				Expect(bitRate).To(Equal(0))
 			})
@@ -133,27 +155,27 @@ var _ = Describe("MediaStreamer", func() {
 			It("returns raw if raw is requested", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0)
+				format, _ := selectTranscodingOptions(ctx, ds, mf, "raw", 0, 0)
 				Expect(format).To(Equal("raw"))
 			})
 			It("returns configured format/bitrate as default", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 0)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 0, 0)
 				Expect(format).To(Equal("oga"))
 				Expect(bitRate).To(Equal(192))
 			})
 			It("returns requested format", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "mp3", 0, 0)
 				Expect(format).To(Equal("mp3"))
 				Expect(bitRate).To(Equal(160)) // Default Bit Rate
 			})
 			It("returns requested bitrate", func() {
 				mf.Suffix = "flac"
 				mf.BitRate = 1000
-				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 160)
+				format, bitRate := selectTranscodingOptions(ctx, ds, mf, "", 160, 0)
 				Expect(format).To(Equal("oga"))
 				Expect(bitRate).To(Equal(160))
 			})

core/media_streamer_test.go

@@ -39,34 +39,34 @@ var _ = Describe("MediaStreamer", func() {
 
 	Context("NewStream", func() {
 		It("returns a seekable stream if format is 'raw'", func() {
-			s, err := streamer.NewStream(ctx, "123", "raw", 0, 0)
+			s, err := streamer.NewStream(ctx, core.StreamRequest{ID: "123", Format: "raw"})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(s.Seekable()).To(BeTrue())
 		})
 		It("returns a seekable stream if maxBitRate is 0", func() {
-			s, err := streamer.NewStream(ctx, "123", "mp3", 0, 0)
+			s, err := streamer.NewStream(ctx, core.StreamRequest{ID: "123", Format: "mp3"})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(s.Seekable()).To(BeTrue())
 		})
 		It("returns a seekable stream if maxBitRate is higher than file bitRate", func() {
-			s, err := streamer.NewStream(ctx, "123", "mp3", 320, 0)
+			s, err := streamer.NewStream(ctx, core.StreamRequest{ID: "123", Format: "mp3", BitRate: 320})
 			Expect(err).ToNot(HaveOccurred())
 			Expect(s.Seekable()).To(BeTrue())
 		})
 		It("returns a NON seekable stream if transcode is required", func() {
-			s, err := streamer.NewStream(ctx, "123", "mp3", 64, 0)
+			s, err := streamer.NewStream(ctx, core.StreamRequest{ID: "123", Format: "mp3", BitRate: 64})
 			Expect(err).To(BeNil())
 			Expect(s.Seekable()).To(BeFalse())
 			Expect(s.Duration()).To(Equal(float32(257.0)))
 		})
 		It("returns a seekable stream if the file is complete in the cache", func() {
-			s, err := streamer.NewStream(ctx, "123", "mp3", 32, 0)
+			s, err := streamer.NewStream(ctx, core.StreamRequest{ID: "123", Format: "mp3", BitRate: 32})
 			Expect(err).To(BeNil())
 			_, _ = io.ReadAll(s)
 			_ = s.Close()
 			Eventually(func() bool { return ffmpeg.IsClosed() }, "3s").Should(BeTrue())
 
-			s, err = streamer.NewStream(ctx, "123", "mp3", 32, 0)
+			s, err = streamer.NewStream(ctx, core.StreamRequest{ID: "123", Format: "mp3", BitRate: 32})
 			Expect(err).To(BeNil())
 			Expect(s.Seekable()).To(BeTrue())
 		})

core/transcode/aliases.go

@@ -0,0 +1,87 @@
+package transcode
+
+import (
+	"slices"
+	"strings"
+)
+
+// containerAliasGroups maps each container alias to a canonical group name.
+var containerAliasGroups = func() map[string]string {
+	groups := [][]string{
+		{"aac", "adts", "m4a", "mp4", "m4b", "m4p"},
+		{"mpeg", "mp3", "mp2"},
+		{"ogg", "oga"},
+		{"aif", "aiff"},
+		{"asf", "wma"},
+		{"mpc", "mpp"},
+		{"wv"},
+	}
+	m := make(map[string]string)
+	for _, g := range groups {
+		canonical := g[0]
+		for _, name := range g {
+			m[name] = canonical
+		}
+	}
+	return m
+}()
+
+// codecAliasGroups maps each codec alias to a canonical group name.
+// Codecs within the same group are considered equivalent.
+var codecAliasGroups = func() map[string]string {
+	groups := [][]string{
+		{"aac", "adts"},
+		{"ac3", "ac-3"},
+		{"eac3", "e-ac3", "e-ac-3", "eac-3"},
+		{"mpc7", "musepack7"},
+		{"mpc8", "musepack8"},
+		{"wma1", "wmav1"},
+		{"wma2", "wmav2"},
+		{"wmalossless", "wma9lossless"},
+		{"wmapro", "wma9pro"},
+		{"shn", "shorten"},
+		{"mp4als", "als"},
+	}
+	m := make(map[string]string)
+	for _, g := range groups {
+		for _, name := range g {
+			m[name] = g[0] // canonical = first entry
+		}
+	}
+	return m
+}()
+
+// matchesWithAliases checks if a value matches any entry in candidates,
+// consulting the alias map for equivalent names.
+func matchesWithAliases(value string, candidates []string, aliases map[string]string) bool {
+	value = strings.ToLower(value)
+	canonical := aliases[value]
+	for _, c := range candidates {
+		c = strings.ToLower(c)
+		if c == value {
+			return true
+		}
+		if canonical != "" && aliases[c] == canonical {
+			return true
+		}
+	}
+	return false
+}
+
+// matchesContainer checks if a file suffix matches any of the container names,
+// including common aliases.
+func matchesContainer(suffix string, containers []string) bool {
+	return matchesWithAliases(suffix, containers, containerAliasGroups)
+}
+
+// matchesCodec checks if a codec matches any of the codec names,
+// including common aliases.
+func matchesCodec(codec string, codecs []string) bool {
+	return matchesWithAliases(codec, codecs, codecAliasGroups)
+}
+
+func containsIgnoreCase(slice []string, s string) bool {
+	return slices.ContainsFunc(slice, func(item string) bool {
+		return strings.EqualFold(item, s)
+	})
+}

core/transcode/codec.go

@@ -0,0 +1,59 @@
+package transcode
+
+import "strings"
+
+// isLosslessFormat returns true if the format is a lossless audio codec/format.
+// Note: core/ffmpeg has a separate isLosslessOutputFormat that covers only formats
+// ffmpeg can produce as output (a smaller set). This function covers all known lossless formats
+// for transcoding decision purposes.
+func isLosslessFormat(format string) bool {
+	switch strings.ToLower(format) {
+	case "flac", "alac", "wav", "aiff", "ape", "wv", "tta", "tak", "shn", "dsd":
+		return true
+	}
+	return false
+}
+
+// normalizeSourceSampleRate adjusts the source sample rate for codecs that store
+// it differently than PCM. Currently handles DSD (÷8):
+// DSD64=2822400→352800, DSD128=5644800→705600, etc.
+// For other codecs, returns the rate unchanged.
+func normalizeSourceSampleRate(sampleRate int, codec string) int {
+	if strings.EqualFold(codec, "dsd") && sampleRate > 0 {
+		return sampleRate / 8
+	}
+	return sampleRate
+}
+
+// normalizeSourceBitDepth adjusts the source bit depth for codecs that use
+// non-standard bit depths. Currently handles DSD (1-bit → 24-bit PCM, which is
+// what ffmpeg produces). For other codecs, returns the depth unchanged.
+func normalizeSourceBitDepth(bitDepth int, codec string) int {
+	if strings.EqualFold(codec, "dsd") && bitDepth == 1 {
+		return 24
+	}
+	return bitDepth
+}
+
+// codecFixedOutputSampleRate returns the mandatory output sample rate for codecs
+// that always resample regardless of input (e.g., Opus always outputs 48000Hz).
+// Returns 0 if the codec has no fixed output rate.
+func codecFixedOutputSampleRate(codec string) int {
+	switch strings.ToLower(codec) {
+	case "opus":
+		return 48000
+	}
+	return 0
+}
+
+// codecMaxSampleRate returns the hard maximum output sample rate for a codec.
+// Returns 0 if the codec has no hard limit.
+func codecMaxSampleRate(codec string) int {
+	switch strings.ToLower(codec) {
+	case "mp3":
+		return 48000
+	case "aac":
+		return 96000
+	}
+	return 0
+}

core/transcode/limitations.go

@@ -0,0 +1,206 @@
+package transcode
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+// adjustResult represents the outcome of applying a limitation to a transcoded stream value
+type adjustResult int
+
+const (
+	adjustNone      adjustResult = iota // Value already satisfies the limitation
+	adjustAdjusted                      // Value was changed to fit the limitation
+	adjustCannotFit                     // Cannot satisfy the limitation (reject this profile)
+)
+
+// checkLimitations checks codec profile limitations against source media.
+// Returns "" if all limitations pass, or a typed reason string for the first failure.
+func checkLimitations(mf *model.MediaFile, sourceBitrate int, limitations []Limitation) string {
+	for _, lim := range limitations {
+		var ok bool
+		var reason string
+
+		switch lim.Name {
+		case LimitationAudioChannels:
+			ok = checkIntLimitation(mf.Channels, lim.Comparison, lim.Values)
+			reason = "audio channels not supported"
+		case LimitationAudioSamplerate:
+			ok = checkIntLimitation(mf.SampleRate, lim.Comparison, lim.Values)
+			reason = "audio samplerate not supported"
+		case LimitationAudioBitrate:
+			ok = checkIntLimitation(sourceBitrate, lim.Comparison, lim.Values)
+			reason = "audio bitrate not supported"
+		case LimitationAudioBitdepth:
+			ok = checkIntLimitation(mf.BitDepth, lim.Comparison, lim.Values)
+			reason = "audio bitdepth not supported"
+		case LimitationAudioProfile:
+			// TODO: populate source profile when MediaFile has audio profile info
+			ok = checkStringLimitation("", lim.Comparison, lim.Values)
+			reason = "audio profile not supported"
+		default:
+			continue
+		}
+
+		if !ok && lim.Required {
+			return reason
+		}
+	}
+	return ""
+}
+
+// applyLimitation adjusts a transcoded stream parameter to satisfy the limitation.
+// Returns the adjustment result.
+func applyLimitation(sourceBitrate int, lim *Limitation, ts *StreamDetails) adjustResult {
+	switch lim.Name {
+	case LimitationAudioChannels:
+		return applyIntLimitation(lim.Comparison, lim.Values, ts.Channels, func(v int) { ts.Channels = v })
+	case LimitationAudioBitrate:
+		current := ts.Bitrate
+		if current == 0 {
+			current = sourceBitrate
+		}
+		return applyIntLimitation(lim.Comparison, lim.Values, current, func(v int) { ts.Bitrate = v })
+	case LimitationAudioSamplerate:
+		return applyIntLimitation(lim.Comparison, lim.Values, ts.SampleRate, func(v int) { ts.SampleRate = v })
+	case LimitationAudioBitdepth:
+		if ts.BitDepth > 0 {
+			return applyIntLimitation(lim.Comparison, lim.Values, ts.BitDepth, func(v int) { ts.BitDepth = v })
+		}
+	case LimitationAudioProfile:
+		// TODO: implement when audio profile data is available
+	}
+	return adjustNone
+}
+
+// applyIntLimitation applies a limitation comparison to a value.
+// If the value needs adjusting, calls the setter and returns the result.
+func applyIntLimitation(comparison string, values []string, current int, setter func(int)) adjustResult {
+	if len(values) == 0 {
+		return adjustNone
+	}
+
+	switch comparison {
+	case ComparisonLessThanEqual:
+		limit, ok := parseInt(values[0])
+		if !ok {
+			return adjustNone
+		}
+		if current <= limit {
+			return adjustNone
+		}
+		setter(limit)
+		return adjustAdjusted
+	case ComparisonGreaterThanEqual:
+		limit, ok := parseInt(values[0])
+		if !ok {
+			return adjustNone
+		}
+		if current >= limit {
+			return adjustNone
+		}
+		// Cannot upscale
+		return adjustCannotFit
+	case ComparisonEquals:
+		// Check if current value matches any allowed value
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && current == limit {
+				return adjustNone
+			}
+		}
+		// Find the closest allowed value below current (don't upscale)
+		var closest int
+		found := false
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && limit < current {
+				if !found || limit > closest {
+					closest = limit
+					found = true
+				}
+			}
+		}
+		if found {
+			setter(closest)
+			return adjustAdjusted
+		}
+		return adjustCannotFit
+	case ComparisonNotEquals:
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && current == limit {
+				return adjustCannotFit
+			}
+		}
+		return adjustNone
+	}
+
+	return adjustNone
+}
+
+func checkIntLimitation(value int, comparison string, values []string) bool {
+	if len(values) == 0 {
+		return true
+	}
+
+	switch comparison {
+	case ComparisonLessThanEqual:
+		limit, ok := parseInt(values[0])
+		if !ok {
+			return true
+		}
+		return value <= limit
+	case ComparisonGreaterThanEqual:
+		limit, ok := parseInt(values[0])
+		if !ok {
+			return true
+		}
+		return value >= limit
+	case ComparisonEquals:
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && value == limit {
+				return true
+			}
+		}
+		return false
+	case ComparisonNotEquals:
+		for _, v := range values {
+			if limit, ok := parseInt(v); ok && value == limit {
+				return false
+			}
+		}
+		return true
+	}
+	return true
+}
+
+// checkStringLimitation checks a string value against a limitation.
+// Only Equals and NotEquals comparisons are meaningful for strings.
+// LessThanEqual/GreaterThanEqual are not applicable and always pass.
+func checkStringLimitation(value string, comparison string, values []string) bool {
+	switch comparison {
+	case ComparisonEquals:
+		for _, v := range values {
+			if strings.EqualFold(value, v) {
+				return true
+			}
+		}
+		return false
+	case ComparisonNotEquals:
+		for _, v := range values {
+			if strings.EqualFold(value, v) {
+				return false
+			}
+		}
+		return true
+	}
+	return true
+}
+
+func parseInt(s string) (int, bool) {
+	v, err := strconv.Atoi(s)
+	if err != nil || v < 0 {
+		return 0, false
+	}
+	return v, true
+}

core/transcode/transcode.go

@@ -0,0 +1,359 @@
+package transcode
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/navidrome/navidrome/core/auth"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/model"
+)
+
+const (
+	tokenTTL       = 12 * time.Hour
+	defaultBitrate = 256 // kbps
+)
+
+func NewDecider(ds model.DataStore) Decider {
+	return &deciderService{
+		ds: ds,
+	}
+}
+
+type deciderService struct {
+	ds model.DataStore
+}
+
+func (s *deciderService) MakeDecision(ctx context.Context, mf *model.MediaFile, clientInfo *ClientInfo) (*Decision, error) {
+	decision := &Decision{
+		MediaID: mf.ID,
+	}
+
+	sourceBitrate := mf.BitRate // kbps
+
+	log.Trace(ctx, "Making transcode decision", "mediaID", mf.ID, "container", mf.Suffix,
+		"codec", mf.AudioCodec(), "bitrate", sourceBitrate, "channels", mf.Channels,
+		"sampleRate", mf.SampleRate, "lossless", mf.IsLossless(), "client", clientInfo.Name)
+
+	// Build source stream details
+	decision.SourceStream = buildSourceStream(mf)
+
+	// Check global bitrate constraint first.
+	if clientInfo.MaxAudioBitrate > 0 && sourceBitrate > clientInfo.MaxAudioBitrate {
+		log.Trace(ctx, "Global bitrate constraint exceeded, skipping direct play",
+			"sourceBitrate", sourceBitrate, "maxAudioBitrate", clientInfo.MaxAudioBitrate)
+		decision.TranscodeReasons = append(decision.TranscodeReasons, "audio bitrate not supported")
+		// Skip direct play profiles entirely — global constraint fails
+	} else {
+		// Try direct play profiles, collecting reasons for each failure
+		for _, profile := range clientInfo.DirectPlayProfiles {
+			if reason := s.checkDirectPlayProfile(mf, sourceBitrate, &profile, clientInfo); reason == "" {
+				decision.CanDirectPlay = true
+				decision.TranscodeReasons = nil // Clear any previously collected reasons
+				break
+			} else {
+				decision.TranscodeReasons = append(decision.TranscodeReasons, reason)
+			}
+		}
+	}
+
+	// If direct play is possible, we're done
+	if decision.CanDirectPlay {
+		log.Debug(ctx, "Transcode decision: direct play", "mediaID", mf.ID, "container", mf.Suffix, "codec", mf.AudioCodec())
+		return decision, nil
+	}
+
+	// Try transcoding profiles (in order of preference)
+	for _, profile := range clientInfo.TranscodingProfiles {
+		if ts, transcodeFormat := s.computeTranscodedStream(ctx, mf, sourceBitrate, &profile, clientInfo); ts != nil {
+			decision.CanTranscode = true
+			decision.TargetFormat = transcodeFormat
+			decision.TargetBitrate = ts.Bitrate
+			decision.TargetChannels = ts.Channels
+			decision.TargetSampleRate = ts.SampleRate
+			decision.TargetBitDepth = ts.BitDepth
+			decision.TranscodeStream = ts
+			break
+		}
+	}
+
+	if decision.CanTranscode {
+		log.Debug(ctx, "Transcode decision: transcode", "mediaID", mf.ID,
+			"targetFormat", decision.TargetFormat, "targetBitrate", decision.TargetBitrate,
+			"targetChannels", decision.TargetChannels, "reasons", decision.TranscodeReasons)
+	}
+
+	// If neither direct play nor transcode is possible
+	if !decision.CanDirectPlay && !decision.CanTranscode {
+		decision.ErrorReason = "no compatible playback profile found"
+		log.Warn(ctx, "Transcode decision: no compatible profile", "mediaID", mf.ID,
+			"container", mf.Suffix, "codec", mf.AudioCodec(), "reasons", decision.TranscodeReasons)
+	}
+
+	return decision, nil
+}
+
+func buildSourceStream(mf *model.MediaFile) StreamDetails {
+	return StreamDetails{
+		Container:  mf.Suffix,
+		Codec:      mf.AudioCodec(),
+		Bitrate:    mf.BitRate,
+		SampleRate: mf.SampleRate,
+		BitDepth:   mf.BitDepth,
+		Channels:   mf.Channels,
+		Duration:   mf.Duration,
+		Size:       mf.Size,
+		IsLossless: mf.IsLossless(),
+	}
+}
+
+// checkDirectPlayProfile returns "" if the profile matches (direct play OK),
+// or a typed reason string if it doesn't match.
+func (s *deciderService) checkDirectPlayProfile(mf *model.MediaFile, sourceBitrate int, profile *DirectPlayProfile, clientInfo *ClientInfo) string {
+	// Check protocol (only http for now)
+	if len(profile.Protocols) > 0 && !containsIgnoreCase(profile.Protocols, ProtocolHTTP) {
+		return "protocol not supported"
+	}
+
+	// Check container
+	if len(profile.Containers) > 0 && !matchesContainer(mf.Suffix, profile.Containers) {
+		return "container not supported"
+	}
+
+	// Check codec
+	if len(profile.AudioCodecs) > 0 && !matchesCodec(mf.AudioCodec(), profile.AudioCodecs) {
+		return "audio codec not supported"
+	}
+
+	// Check channels
+	if profile.MaxAudioChannels > 0 && mf.Channels > profile.MaxAudioChannels {
+		return "audio channels not supported"
+	}
+
+	// Check codec-specific limitations
+	for _, codecProfile := range clientInfo.CodecProfiles {
+		if strings.EqualFold(codecProfile.Type, CodecProfileTypeAudio) && matchesCodec(mf.AudioCodec(), []string{codecProfile.Name}) {
+			if reason := checkLimitations(mf, sourceBitrate, codecProfile.Limitations); reason != "" {
+				return reason
+			}
+		}
+	}
+
+	return ""
+}
+
+// computeTranscodedStream attempts to build a valid transcoded stream for the given profile.
+// Returns the stream details and the internal transcoding format (which may differ from the
+// response container when a codec fallback occurs, e.g., "mp4"→"aac").
+// Returns nil, "" if the profile cannot produce a valid output.
+func (s *deciderService) computeTranscodedStream(ctx context.Context, mf *model.MediaFile, sourceBitrate int, profile *Profile, clientInfo *ClientInfo) (*StreamDetails, string) {
+	// Check protocol (only http for now)
+	if profile.Protocol != "" && !strings.EqualFold(profile.Protocol, ProtocolHTTP) {
+		log.Trace(ctx, "Skipping transcoding profile: unsupported protocol", "protocol", profile.Protocol)
+		return nil, ""
+	}
+
+	responseContainer, targetFormat := s.resolveTargetFormat(ctx, profile)
+	if targetFormat == "" {
+		return nil, ""
+	}
+
+	targetIsLossless := isLosslessFormat(targetFormat)
+
+	// Reject lossy to lossless conversion
+	if !mf.IsLossless() && targetIsLossless {
+		log.Trace(ctx, "Skipping transcoding profile: lossy to lossless not allowed", "targetFormat", targetFormat)
+		return nil, ""
+	}
+
+	ts := &StreamDetails{
+		Container:  responseContainer,
+		Codec:      strings.ToLower(profile.AudioCodec),
+		SampleRate: normalizeSourceSampleRate(mf.SampleRate, mf.AudioCodec()),
+		Channels:   mf.Channels,
+		BitDepth:   normalizeSourceBitDepth(mf.BitDepth, mf.AudioCodec()),
+		IsLossless: targetIsLossless,
+	}
+	if ts.Codec == "" {
+		ts.Codec = targetFormat
+	}
+
+	// Apply codec-intrinsic sample rate adjustments before codec profile limitations
+	if fixedRate := codecFixedOutputSampleRate(ts.Codec); fixedRate > 0 {
+		ts.SampleRate = fixedRate
+	}
+	if maxRate := codecMaxSampleRate(ts.Codec); maxRate > 0 && ts.SampleRate > maxRate {
+		ts.SampleRate = maxRate
+	}
+
+	// Determine target bitrate (all in kbps)
+	if ok := s.computeBitrate(ctx, mf, sourceBitrate, targetFormat, targetIsLossless, clientInfo, ts); !ok {
+		return nil, ""
+	}
+
+	// Apply MaxAudioChannels from the transcoding profile
+	if profile.MaxAudioChannels > 0 && mf.Channels > profile.MaxAudioChannels {
+		ts.Channels = profile.MaxAudioChannels
+	}
+
+	// Apply codec profile limitations to the TARGET codec
+	if ok := s.applyCodecLimitations(ctx, sourceBitrate, targetFormat, targetIsLossless, clientInfo, ts); !ok {
+		return nil, ""
+	}
+
+	return ts, targetFormat
+}
+
+// resolveTargetFormat determines the response container and internal target format
+// by looking up transcoding configs. Returns ("", "") if no config found.
+func (s *deciderService) resolveTargetFormat(ctx context.Context, profile *Profile) (responseContainer, targetFormat string) {
+	responseContainer = strings.ToLower(profile.Container)
+	targetFormat = responseContainer
+	if targetFormat == "" {
+		targetFormat = strings.ToLower(profile.AudioCodec)
+		responseContainer = targetFormat
+	}
+
+	// Try the container first, then fall back to the audioCodec (e.g. "ogg" → "opus", "mp4" → "aac").
+	_, err := s.ds.Transcoding(ctx).FindByFormat(targetFormat)
+	if errors.Is(err, model.ErrNotFound) && profile.AudioCodec != "" && !strings.EqualFold(targetFormat, profile.AudioCodec) {
+		codec := strings.ToLower(profile.AudioCodec)
+		log.Trace(ctx, "No transcoding config for container, trying audioCodec", "container", targetFormat, "audioCodec", codec)
+		_, err = s.ds.Transcoding(ctx).FindByFormat(codec)
+		if err == nil {
+			targetFormat = codec
+		}
+	}
+	if err != nil {
+		if !errors.Is(err, model.ErrNotFound) {
+			log.Error(ctx, "Error looking up transcoding config", "format", targetFormat, err)
+		} else {
+			log.Trace(ctx, "Skipping transcoding profile: no transcoding config", "targetFormat", targetFormat)
+		}
+		return "", ""
+	}
+	return responseContainer, targetFormat
+}
+
+// computeBitrate determines the target bitrate for the transcoded stream.
+// Returns false if the profile should be rejected.
+func (s *deciderService) computeBitrate(ctx context.Context, mf *model.MediaFile, sourceBitrate int, targetFormat string, targetIsLossless bool, clientInfo *ClientInfo, ts *StreamDetails) bool {
+	if mf.IsLossless() {
+		if !targetIsLossless {
+			if clientInfo.MaxTranscodingAudioBitrate > 0 {
+				ts.Bitrate = clientInfo.MaxTranscodingAudioBitrate
+			} else {
+				ts.Bitrate = defaultBitrate
+			}
+		} else {
+			if clientInfo.MaxAudioBitrate > 0 && sourceBitrate > clientInfo.MaxAudioBitrate {
+				log.Trace(ctx, "Skipping transcoding profile: lossless target exceeds bitrate limit",
+					"targetFormat", targetFormat, "sourceBitrate", sourceBitrate, "maxAudioBitrate", clientInfo.MaxAudioBitrate)
+				return false
+			}
+		}
+	} else {
+		ts.Bitrate = sourceBitrate
+	}
+
+	// Apply maxAudioBitrate as final cap
+	if clientInfo.MaxAudioBitrate > 0 && ts.Bitrate > 0 && ts.Bitrate > clientInfo.MaxAudioBitrate {
+		ts.Bitrate = clientInfo.MaxAudioBitrate
+	}
+	return true
+}
+
+// applyCodecLimitations applies codec profile limitations to the transcoded stream.
+// Returns false if the profile should be rejected.
+func (s *deciderService) applyCodecLimitations(ctx context.Context, sourceBitrate int, targetFormat string, targetIsLossless bool, clientInfo *ClientInfo, ts *StreamDetails) bool {
+	targetCodec := ts.Codec
+	for _, codecProfile := range clientInfo.CodecProfiles {
+		if !strings.EqualFold(codecProfile.Type, CodecProfileTypeAudio) {
+			continue
+		}
+		if !matchesCodec(targetCodec, []string{codecProfile.Name}) {
+			continue
+		}
+		for _, lim := range codecProfile.Limitations {
+			result := applyLimitation(sourceBitrate, &lim, ts)
+			if strings.EqualFold(lim.Name, LimitationAudioBitrate) && targetIsLossless && result == adjustAdjusted {
+				log.Trace(ctx, "Skipping transcoding profile: cannot adjust bitrate for lossless target",
+					"targetFormat", targetFormat, "codec", targetCodec, "limitation", lim.Name)
+				return false
+			}
+			if result == adjustCannotFit {
+				log.Trace(ctx, "Skipping transcoding profile: codec limitation cannot be satisfied",
+					"targetFormat", targetFormat, "codec", targetCodec, "limitation", lim.Name,
+					"comparison", lim.Comparison, "values", lim.Values)
+				return false
+			}
+		}
+	}
+	return true
+}
+
+func (s *deciderService) CreateTranscodeParams(decision *Decision) (string, error) {
+	exp := time.Now().Add(tokenTTL)
+	claims := map[string]any{
+		"mid": decision.MediaID,
+		"dp":  decision.CanDirectPlay,
+	}
+	if decision.CanTranscode && decision.TargetFormat != "" {
+		claims["fmt"] = decision.TargetFormat
+		claims["br"] = decision.TargetBitrate
+		if decision.TargetChannels > 0 {
+			claims["ch"] = decision.TargetChannels
+		}
+		if decision.TargetSampleRate > 0 {
+			claims["sr"] = decision.TargetSampleRate
+		}
+		if decision.TargetBitDepth > 0 {
+			claims["bd"] = decision.TargetBitDepth
+		}
+	}
+	return auth.CreateExpiringPublicToken(exp, claims)
+}
+
+func (s *deciderService) ParseTranscodeParams(token string) (*Params, error) {
+	claims, err := auth.Validate(token)
+	if err != nil {
+		return nil, err
+	}
+
+	params := &Params{}
+
+	// Required claims
+	mid, ok := claims["mid"].(string)
+	if !ok || mid == "" {
+		return nil, fmt.Errorf("invalid transcode token: missing media ID")
+	}
+	params.MediaID = mid
+
+	dp, ok := claims["dp"].(bool)
+	if !ok {
+		return nil, fmt.Errorf("invalid transcode token: missing direct play flag")
+	}
+	params.DirectPlay = dp
+
+	// Optional claims (legitimately absent for direct-play tokens)
+	if f, ok := claims["fmt"].(string); ok {
+		params.TargetFormat = f
+	}
+	if br, ok := claims["br"].(float64); ok {
+		params.TargetBitrate = int(br)
+	}
+	if ch, ok := claims["ch"].(float64); ok {
+		params.TargetChannels = int(ch)
+	}
+	if sr, ok := claims["sr"].(float64); ok {
+		params.TargetSampleRate = int(sr)
+	}
+	if bd, ok := claims["bd"].(float64); ok {
+		params.TargetBitDepth = int(bd)
+	}
+
+	return params, nil
+}

core/transcode/transcode_suite_test.go

@@ -0,0 +1,17 @@
+package transcode
+
+import (
+	"testing"
+
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestTranscode(t *testing.T) {
+	tests.Init(t, false)
+	log.SetLevel(log.LevelFatal)
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Transcode Suite")
+}

core/transcode/transcode_test.go

@@ -0,0 +1,976 @@
+package transcode
+
+import (
+	"context"
+
+	"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"
+)
+
+var _ = Describe("Decider", func() {
+	var (
+		ds  *tests.MockDataStore
+		svc Decider
+		ctx context.Context
+	)
+
+	BeforeEach(func() {
+		ctx = context.Background()
+		ds = &tests.MockDataStore{
+			MockedProperty:    &tests.MockedPropertyRepo{},
+			MockedTranscoding: &tests.MockTranscodingRepo{},
+		}
+		auth.Init(ds)
+		svc = NewDecider(ds)
+	})
+
+	Describe("MakeDecision", func() {
+		Context("Direct Play", func() {
+			It("allows direct play when profile matches", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}, MaxAudioChannels: 2},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+				Expect(decision.CanTranscode).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(BeEmpty())
+			})
+
+			It("rejects direct play when container doesn't match", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("container not supported"))
+			})
+
+			It("rejects direct play when codec doesn't match", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "ALAC", BitRate: 1000, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio codec not supported"))
+			})
+
+			It("rejects direct play when channels exceed limit", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}, MaxAudioChannels: 2},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio channels not supported"))
+			})
+
+			It("handles container aliases (aac -> m4a)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"aac"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("handles container aliases (mp4 -> m4a)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp4"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("handles codec aliases (adts -> aac)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"m4a"}, AudioCodecs: []string{"adts"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("allows when protocol list is empty (any protocol)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, AudioCodecs: []string{"flac"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("allows when both container and codec lists are empty (wildcard)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 128, Channels: 2}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{}, AudioCodecs: []string{}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+		})
+
+		Context("MaxAudioBitrate constraint", func() {
+			It("revokes direct play when bitrate exceeds maxAudioBitrate", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1500, Channels: 2}
+				ci := &ClientInfo{
+					MaxAudioBitrate: 500, // kbps
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio bitrate not supported"))
+			})
+		})
+
+		Context("Transcoding", func() {
+			It("selects transcoding when direct play isn't possible", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 256, // kbps
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http", MaxAudioChannels: 2},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("mp3"))
+				Expect(decision.TargetBitrate).To(Equal(256)) // kbps
+				Expect(decision.TranscodeReasons).To(ContainElement("container not supported"))
+			})
+
+			It("rejects lossy to lossless transcoding", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2}
+				ci := &ClientInfo{
+					TranscodingProfiles: []Profile{
+						{Container: "flac", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeFalse())
+			})
+
+			It("uses default bitrate when client doesn't specify", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, BitDepth: 16}
+				ci := &ClientInfo{
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetBitrate).To(Equal(defaultBitrate)) // 256 kbps
+			})
+
+			It("preserves lossy bitrate when under max", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "ogg", BitRate: 192, Channels: 2}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 256, // kbps
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetBitrate).To(Equal(192)) // source bitrate in kbps
+			})
+
+			It("rejects unsupported transcoding format", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2}
+				ci := &ClientInfo{
+					TranscodingProfiles: []Profile{
+						{Container: "wav", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeFalse())
+			})
+
+			It("applies maxAudioBitrate as final cap on transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2}
+				ci := &ClientInfo{
+					MaxAudioBitrate: 96, // kbps
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetBitrate).To(Equal(96)) // capped by maxAudioBitrate
+			})
+
+			It("selects first valid transcoding profile in order", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 48000, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []Profile{
+						{Container: "opus", AudioCodec: "opus", Protocol: "http"},
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http", MaxAudioChannels: 2},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("opus"))
+			})
+		})
+
+		Context("Lossless to lossless transcoding", func() {
+			It("allows lossless to lossless when samplerate needs downsampling", func() {
+				// MockTranscodingRepo doesn't support "flac" format, so this would fail to find a config.
+				// This test documents the behavior: lossless→lossless requires server transcoding config.
+				mf := &model.MediaFile{ID: "1", Suffix: "dsf", Codec: "DSD", BitRate: 5644, Channels: 2, SampleRate: 176400, BitDepth: 1}
+				ci := &ClientInfo{
+					MaxAudioBitrate: 1000,
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("mp3"))
+			})
+
+			It("sets IsLossless=true on transcoded stream when target is lossless", func() {
+				// Simulate DSD→FLAC transcoding by using a mock that supports "flac"
+				mockTranscoding := &tests.MockTranscodingRepo{}
+				ds.MockedTranscoding = mockTranscoding
+				svc = NewDecider(ds)
+
+				// MockTranscodingRepo doesn't support flac, so this will skip lossless profile.
+				// Use mp3 which is supported as the fallback.
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.IsLossless).To(BeFalse()) // mp3 is lossy
+			})
+		})
+
+		Context("No compatible profile", func() {
+			It("returns error when nothing matches", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6}
+				ci := &ClientInfo{}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.CanTranscode).To(BeFalse())
+				Expect(decision.ErrorReason).To(Equal("no compatible playback profile found"))
+			})
+		})
+
+		Context("Codec limitations on direct play", func() {
+			It("rejects direct play when codec limitation fails (required)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 512, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"320"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio bitrate not supported"))
+			})
+
+			It("allows direct play when optional limitation fails", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 512, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"320"}, Required: false},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("handles Equals comparison with multiple values", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioChannels, Comparison: ComparisonEquals, Values: []string{"1", "2"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("rejects when Equals comparison doesn't match any value", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioChannels, Comparison: ComparisonEquals, Values: []string{"1", "2"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+			})
+
+			It("rejects direct play when audioProfile limitation fails (required)", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "aac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioProfile, Comparison: ComparisonEquals, Values: []string{"LC"}, Required: true},
+							},
+						},
+					},
+				}
+				// Source profile is empty (not yet populated from scanner), so Equals("LC") fails
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio profile not supported"))
+			})
+
+			It("allows direct play when audioProfile limitation is optional", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "m4a", Codec: "AAC", BitRate: 256, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"m4a"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "aac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioProfile, Comparison: ComparisonEquals, Values: []string{"LC"}, Required: false},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeTrue())
+			})
+
+			It("rejects direct play due to samplerate limitation", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioSamplerate, Comparison: ComparisonLessThanEqual, Values: []string{"48000"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(ContainElement("audio samplerate not supported"))
+			})
+		})
+
+		Context("Codec limitations on transcoded output", func() {
+			It("applies bitrate limitation to transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "mp3", Codec: "MP3", BitRate: 192, Channels: 2, SampleRate: 44100}
+				ci := &ClientInfo{
+					MaxAudioBitrate: 96, // force transcode
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioBitrate, Comparison: ComparisonLessThanEqual, Values: []string{"96"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.Bitrate).To(Equal(96))
+			})
+
+			It("applies channel limitation to transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 6, SampleRate: 48000, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioChannels, Comparison: ComparisonLessThanEqual, Values: []string{"2"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.Channels).To(Equal(2))
+			})
+
+			It("applies samplerate limitation to transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioSamplerate, Comparison: ComparisonLessThanEqual, Values: []string{"48000"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(48000))
+			})
+
+			It("applies bitdepth limitation to transcoded stream", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					TranscodingProfiles: []Profile{
+						{Container: "flac", AudioCodec: "flac", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioBitdepth, Comparison: ComparisonLessThanEqual, Values: []string{"16"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.BitDepth).To(Equal(16))
+				Expect(decision.TargetBitDepth).To(Equal(16))
+			})
+
+			It("preserves source bit depth when no limitation applies", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 24}
+				ci := &ClientInfo{
+					TranscodingProfiles: []Profile{
+						{Container: "flac", AudioCodec: "flac", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.BitDepth).To(Equal(24))
+				Expect(decision.TargetBitDepth).To(Equal(24))
+			})
+
+			It("rejects transcoding profile when GreaterThanEqual cannot be satisfied", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "mp3",
+							Limitations: []Limitation{
+								{Name: LimitationAudioSamplerate, Comparison: ComparisonGreaterThanEqual, Values: []string{"96000"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeFalse())
+			})
+		})
+
+		Context("DSD sample rate conversion", func() {
+			It("converts DSD sample rate to PCM-equivalent in decision", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "dsf", Codec: "DSD", BitRate: 5644, Channels: 2, SampleRate: 2822400, BitDepth: 1}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("mp3"))
+				// DSD64 2822400 / 8 = 352800, capped by MP3 max of 48000
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(48000))
+				Expect(decision.TargetSampleRate).To(Equal(48000))
+				// DSD 1-bit → 24-bit PCM
+				Expect(decision.TranscodeStream.BitDepth).To(Equal(24))
+				Expect(decision.TargetBitDepth).To(Equal(24))
+			})
+
+			It("converts DSD sample rate for FLAC target without codec limit", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "dsf", Codec: "DSD", BitRate: 5644, Channels: 2, SampleRate: 2822400, BitDepth: 1}
+				ci := &ClientInfo{
+					TranscodingProfiles: []Profile{
+						{Container: "flac", AudioCodec: "flac", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("flac"))
+				// DSD64 2822400 / 8 = 352800, FLAC has no hard max
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(352800))
+				Expect(decision.TargetSampleRate).To(Equal(352800))
+				// DSD 1-bit → 24-bit PCM
+				Expect(decision.TranscodeStream.BitDepth).To(Equal(24))
+				Expect(decision.TargetBitDepth).To(Equal(24))
+			})
+
+			It("applies codec profile limit to DSD-converted FLAC sample rate", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "dsf", Codec: "DSD", BitRate: 5644, Channels: 2, SampleRate: 2822400, BitDepth: 1}
+				ci := &ClientInfo{
+					TranscodingProfiles: []Profile{
+						{Container: "flac", AudioCodec: "flac", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioSamplerate, Comparison: ComparisonLessThanEqual, Values: []string{"48000"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				// DSD64 2822400 / 8 = 352800, capped by codec profile limit of 48000
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(48000))
+				Expect(decision.TargetSampleRate).To(Equal(48000))
+				// DSD 1-bit → 24-bit PCM
+				Expect(decision.TranscodeStream.BitDepth).To(Equal(24))
+				Expect(decision.TargetBitDepth).To(Equal(24))
+			})
+
+			It("applies audioBitdepth limitation to DSD-converted bit depth", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "dsf", Codec: "DSD", BitRate: 5644, Channels: 2, SampleRate: 2822400, BitDepth: 1}
+				ci := &ClientInfo{
+					TranscodingProfiles: []Profile{
+						{Container: "flac", AudioCodec: "flac", Protocol: "http"},
+					},
+					CodecProfiles: []CodecProfile{
+						{
+							Type: CodecProfileTypeAudio,
+							Name: "flac",
+							Limitations: []Limitation{
+								{Name: LimitationAudioBitdepth, Comparison: ComparisonLessThanEqual, Values: []string{"16"}, Required: true},
+							},
+						},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				// DSD 1-bit → 24-bit PCM, then capped by codec profile limit to 16-bit
+				Expect(decision.TranscodeStream.BitDepth).To(Equal(16))
+				Expect(decision.TargetBitDepth).To(Equal(16))
+			})
+		})
+
+		Context("Opus fixed sample rate", func() {
+			It("sets Opus output to 48000Hz regardless of input", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 128,
+					TranscodingProfiles: []Profile{
+						{Container: "opus", AudioCodec: "opus", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("opus"))
+				// Opus always outputs 48000Hz
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(48000))
+				Expect(decision.TargetSampleRate).To(Equal(48000))
+			})
+
+			It("sets Opus output to 48000Hz even for 96kHz input", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1500, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 128,
+					TranscodingProfiles: []Profile{
+						{Container: "opus", AudioCodec: "opus", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(48000))
+			})
+		})
+
+		Context("Container vs format separation", func() {
+			It("preserves mp4 container when falling back to aac format", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 256,
+					TranscodingProfiles: []Profile{
+						{Container: "mp4", AudioCodec: "aac", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				// TargetFormat is the internal format used for DB lookup ("aac")
+				Expect(decision.TargetFormat).To(Equal("aac"))
+				// Container in the response preserves what the client asked ("mp4")
+				Expect(decision.TranscodeStream.Container).To(Equal("mp4"))
+				Expect(decision.TranscodeStream.Codec).To(Equal("aac"))
+			})
+
+			It("uses container as format when container matches transcoding config", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 256,
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TargetFormat).To(Equal("mp3"))
+				Expect(decision.TranscodeStream.Container).To(Equal("mp3"))
+			})
+		})
+
+		Context("MP3 max sample rate", func() {
+			It("caps sample rate at 48000 for MP3", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1500, Channels: 2, SampleRate: 96000, BitDepth: 24}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(48000))
+			})
+
+			It("preserves sample rate at 44100 for MP3", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 44100, BitDepth: 16}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(44100))
+			})
+		})
+
+		Context("AAC max sample rate", func() {
+			It("caps sample rate at 96000 for AAC", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "dsf", Codec: "DSD", BitRate: 5644, Channels: 2, SampleRate: 2822400, BitDepth: 1}
+				ci := &ClientInfo{
+					MaxTranscodingAudioBitrate: 320,
+					TranscodingProfiles: []Profile{
+						{Container: "aac", AudioCodec: "aac", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanTranscode).To(BeTrue())
+				// DSD64 2822400 / 8 = 352800, capped by AAC max of 96000
+				Expect(decision.TranscodeStream.SampleRate).To(Equal(96000))
+			})
+		})
+
+		Context("Typed transcode reasons from multiple profiles", func() {
+			It("collects reasons from each failed direct play profile", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "ogg", Codec: "Vorbis", BitRate: 128, Channels: 2, SampleRate: 48000}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+						{Containers: []string{"mp3"}, AudioCodecs: []string{"mp3"}, Protocols: []string{"http"}},
+						{Containers: []string{"m4a", "mp4"}, AudioCodecs: []string{"aac"}, Protocols: []string{"http"}},
+					},
+					TranscodingProfiles: []Profile{
+						{Container: "mp3", AudioCodec: "mp3", Protocol: "http"},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.CanDirectPlay).To(BeFalse())
+				Expect(decision.TranscodeReasons).To(HaveLen(3))
+				Expect(decision.TranscodeReasons[0]).To(Equal("container not supported"))
+				Expect(decision.TranscodeReasons[1]).To(Equal("container not supported"))
+				Expect(decision.TranscodeReasons[2]).To(Equal("container not supported"))
+			})
+		})
+
+		Context("Source stream details", func() {
+			It("populates source stream correctly with kbps bitrate", func() {
+				mf := &model.MediaFile{ID: "1", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24, Duration: 300.5, Size: 50000000}
+				ci := &ClientInfo{
+					DirectPlayProfiles: []DirectPlayProfile{
+						{Containers: []string{"flac"}, Protocols: []string{"http"}},
+					},
+				}
+				decision, err := svc.MakeDecision(ctx, mf, ci)
+				Expect(err).ToNot(HaveOccurred())
+				Expect(decision.SourceStream.Container).To(Equal("flac"))
+				Expect(decision.SourceStream.Codec).To(Equal("flac"))
+				Expect(decision.SourceStream.Bitrate).To(Equal(1000)) // kbps
+				Expect(decision.SourceStream.SampleRate).To(Equal(96000))
+				Expect(decision.SourceStream.BitDepth).To(Equal(24))
+				Expect(decision.SourceStream.Channels).To(Equal(2))
+			})
+		})
+	})
+
+	Describe("Token round-trip", func() {
+		It("creates and parses a direct play token", func() {
+			decision := &Decision{
+				MediaID:       "media-123",
+				CanDirectPlay: true,
+			}
+			token, err := svc.CreateTranscodeParams(decision)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(token).ToNot(BeEmpty())
+
+			params, err := svc.ParseTranscodeParams(token)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(params.MediaID).To(Equal("media-123"))
+			Expect(params.DirectPlay).To(BeTrue())
+			Expect(params.TargetFormat).To(BeEmpty())
+		})
+
+		It("creates and parses a transcode token with kbps bitrate", func() {
+			decision := &Decision{
+				MediaID:        "media-456",
+				CanDirectPlay:  false,
+				CanTranscode:   true,
+				TargetFormat:   "mp3",
+				TargetBitrate:  256, // kbps
+				TargetChannels: 2,
+			}
+			token, err := svc.CreateTranscodeParams(decision)
+			Expect(err).ToNot(HaveOccurred())
+
+			params, err := svc.ParseTranscodeParams(token)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(params.MediaID).To(Equal("media-456"))
+			Expect(params.DirectPlay).To(BeFalse())
+			Expect(params.TargetFormat).To(Equal("mp3"))
+			Expect(params.TargetBitrate).To(Equal(256)) // kbps
+			Expect(params.TargetChannels).To(Equal(2))
+		})
+
+		It("creates and parses a transcode token with sample rate", func() {
+			decision := &Decision{
+				MediaID:          "media-789",
+				CanDirectPlay:    false,
+				CanTranscode:     true,
+				TargetFormat:     "flac",
+				TargetBitrate:    0,
+				TargetChannels:   2,
+				TargetSampleRate: 48000,
+			}
+			token, err := svc.CreateTranscodeParams(decision)
+			Expect(err).ToNot(HaveOccurred())
+
+			params, err := svc.ParseTranscodeParams(token)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(params.MediaID).To(Equal("media-789"))
+			Expect(params.DirectPlay).To(BeFalse())
+			Expect(params.TargetFormat).To(Equal("flac"))
+			Expect(params.TargetSampleRate).To(Equal(48000))
+			Expect(params.TargetChannels).To(Equal(2))
+		})
+
+		It("creates and parses a transcode token with bit depth", func() {
+			decision := &Decision{
+				MediaID:        "media-bd",
+				CanDirectPlay:  false,
+				CanTranscode:   true,
+				TargetFormat:   "flac",
+				TargetBitrate:  0,
+				TargetChannels: 2,
+				TargetBitDepth: 24,
+			}
+			token, err := svc.CreateTranscodeParams(decision)
+			Expect(err).ToNot(HaveOccurred())
+
+			params, err := svc.ParseTranscodeParams(token)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(params.MediaID).To(Equal("media-bd"))
+			Expect(params.TargetBitDepth).To(Equal(24))
+		})
+
+		It("omits bit depth from token when 0", func() {
+			decision := &Decision{
+				MediaID:        "media-nobd",
+				CanDirectPlay:  false,
+				CanTranscode:   true,
+				TargetFormat:   "mp3",
+				TargetBitrate:  256,
+				TargetBitDepth: 0,
+			}
+			token, err := svc.CreateTranscodeParams(decision)
+			Expect(err).ToNot(HaveOccurred())
+
+			params, err := svc.ParseTranscodeParams(token)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(params.TargetBitDepth).To(Equal(0))
+		})
+
+		It("omits sample rate from token when 0", func() {
+			decision := &Decision{
+				MediaID:          "media-100",
+				CanDirectPlay:    false,
+				CanTranscode:     true,
+				TargetFormat:     "mp3",
+				TargetBitrate:    256,
+				TargetSampleRate: 0,
+			}
+			token, err := svc.CreateTranscodeParams(decision)
+			Expect(err).ToNot(HaveOccurred())
+
+			params, err := svc.ParseTranscodeParams(token)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(params.TargetSampleRate).To(Equal(0))
+		})
+
+		It("rejects an invalid token", func() {
+			_, err := svc.ParseTranscodeParams("invalid-token")
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

core/transcode/types.go

@@ -0,0 +1,129 @@
+package transcode
+
+import (
+	"context"
+
+	"github.com/navidrome/navidrome/model"
+)
+
+// Decider is the core service interface for making transcoding decisions
+type Decider interface {
+	MakeDecision(ctx context.Context, mf *model.MediaFile, clientInfo *ClientInfo) (*Decision, error)
+	CreateTranscodeParams(decision *Decision) (string, error)
+	ParseTranscodeParams(token string) (*Params, error)
+}
+
+// ClientInfo represents client playback capabilities.
+// All bitrate values are in kilobits per second (kbps)
+type ClientInfo struct {
+	Name                       string
+	Platform                   string
+	MaxAudioBitrate            int
+	MaxTranscodingAudioBitrate int
+	DirectPlayProfiles         []DirectPlayProfile
+	TranscodingProfiles        []Profile
+	CodecProfiles              []CodecProfile
+}
+
+// DirectPlayProfile describes a format the client can play directly
+type DirectPlayProfile struct {
+	Containers       []string
+	AudioCodecs      []string
+	Protocols        []string
+	MaxAudioChannels int
+}
+
+// Profile describes a transcoding target the client supports
+type Profile struct {
+	Container        string
+	AudioCodec       string
+	Protocol         string
+	MaxAudioChannels int
+}
+
+// CodecProfile describes codec-specific limitations
+type CodecProfile struct {
+	Type        string
+	Name        string
+	Limitations []Limitation
+}
+
+// Limitation describes a specific codec limitation
+type Limitation struct {
+	Name       string
+	Comparison string
+	Values     []string
+	Required   bool
+}
+
+// Protocol values (OpenSubsonic spec enum)
+const (
+	ProtocolHTTP = "http"
+	ProtocolHLS  = "hls"
+)
+
+// Comparison operators (OpenSubsonic spec enum)
+const (
+	ComparisonEquals           = "Equals"
+	ComparisonNotEquals        = "NotEquals"
+	ComparisonLessThanEqual    = "LessThanEqual"
+	ComparisonGreaterThanEqual = "GreaterThanEqual"
+)
+
+// Limitation names (OpenSubsonic spec enum)
+const (
+	LimitationAudioChannels   = "audioChannels"
+	LimitationAudioBitrate    = "audioBitrate"
+	LimitationAudioProfile    = "audioProfile"
+	LimitationAudioSamplerate = "audioSamplerate"
+	LimitationAudioBitdepth   = "audioBitdepth"
+)
+
+// Codec profile types (OpenSubsonic spec enum)
+const (
+	CodecProfileTypeAudio = "AudioCodec"
+)
+
+// Decision represents the internal decision result.
+// All bitrate values are in kilobits per second (kbps).
+type Decision struct {
+	MediaID          string
+	CanDirectPlay    bool
+	CanTranscode     bool
+	TranscodeReasons []string
+	ErrorReason      string
+	TargetFormat     string
+	TargetBitrate    int
+	TargetChannels   int
+	TargetSampleRate int
+	TargetBitDepth   int
+	SourceStream     StreamDetails
+	TranscodeStream  *StreamDetails
+}
+
+// StreamDetails describes audio stream properties.
+// Bitrate is in kilobits per second (kbps).
+type StreamDetails struct {
+	Container  string
+	Codec      string
+	Profile    string // Audio profile (e.g., "LC", "HE-AAC"). Empty until scanner support is added.
+	Bitrate    int
+	SampleRate int
+	BitDepth   int
+	Channels   int
+	Duration   float32
+	Size       int64
+	IsLossless bool
+}
+
+// Params contains the parameters extracted from a transcode token.
+// TargetBitrate is in kilobits per second (kbps).
+type Params struct {
+	MediaID          string
+	DirectPlay       bool
+	TargetFormat     string
+	TargetBitrate    int
+	TargetChannels   int
+	TargetSampleRate int
+	TargetBitDepth   int
+}

core/wire_providers.go

@@ -8,6 +8,7 @@ import (
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
 	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/core/transcode"
 )
 
 var Set = wire.NewSet(
@@ -20,6 +21,7 @@ var Set = wire.NewSet(
 	NewLibrary,
 	NewUser,
 	NewMaintenance,
+	transcode.NewDecider,
 	agents.GetAgents,
 	external.NewProvider,
 	wire.Bind(new(external.Agents), new(*agents.Agents)),

db/migrations/20260205120000_add_codec_and_update_transcodings.go

@@ -0,0 +1,63 @@
+package migrations
+
+import (
+	"context"
+	"database/sql"
+
+	"github.com/navidrome/navidrome/model/id"
+	"github.com/pressly/goose/v3"
+)
+
+func init() {
+	goose.AddMigrationContext(upAddCodecAndUpdateTranscodings, downAddCodecAndUpdateTranscodings)
+}
+
+func upAddCodecAndUpdateTranscodings(_ context.Context, tx *sql.Tx) error {
+	// Add codec column to media_file.
+	_, err := tx.Exec(`ALTER TABLE media_file ADD COLUMN codec VARCHAR(255) DEFAULT '' NOT NULL`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`CREATE INDEX IF NOT EXISTS media_file_codec ON media_file(codec)`)
+	if err != nil {
+		return err
+	}
+
+	// Update old AAC default (adts) to new default (ipod with fragmented MP4).
+	// Only affects users who still have the unmodified old default command.
+	_, err = tx.Exec(
+		`UPDATE transcoding SET command = ? WHERE target_format = 'aac' AND command = ?`,
+		"ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a aac -f ipod -movflags frag_keyframe+empty_moov -",
+		"ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a aac -f adts -",
+	)
+	if err != nil {
+		return err
+	}
+
+	// Add FLAC transcoding for existing installations that were seeded before FLAC was added.
+	var count int
+	err = tx.QueryRow("SELECT COUNT(*) FROM transcoding WHERE target_format = 'flac'").Scan(&count)
+	if err != nil {
+		return err
+	}
+	if count == 0 {
+		_, err = tx.Exec(
+			"INSERT INTO transcoding (id, name, target_format, default_bit_rate, command) VALUES (?, ?, ?, ?, ?)",
+			id.NewRandom(), "flac audio", "flac", 0,
+			"ffmpeg -i %s -ss %t -map 0:a:0 -v 0 -c:a flac -f flac -",
+		)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func downAddCodecAndUpdateTranscodings(_ context.Context, tx *sql.Tx) error {
+	_, err := tx.Exec(`DROP INDEX IF EXISTS media_file_codec`)
+	if err != nil {
+		return err
+	}
+	_, err = tx.Exec(`ALTER TABLE media_file DROP COLUMN codec`)
+	return err
+}

go.mod

@@ -7,7 +7,7 @@ replace (
 	github.com/dhowden/tag v0.0.0-20240417053706-3d75831295e8 => github.com/deluan/tag v0.0.0-20241002021117-dfe5e6ea396d
 
 	// Fork to implement raw tags support
-	go.senan.xyz/taglib => github.com/deluan/go-taglib v0.0.0-20260119020817-8753c7531798
+	go.senan.xyz/taglib => github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57
 )
 
 require (

go.sum

@@ -36,8 +36,8 @@ github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=
 github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=
-github.com/deluan/go-taglib v0.0.0-20260119020817-8753c7531798 h1:q4fvcIK/LxElpyQILCejG6WPYjVb2F/4P93+k017ANk=
-github.com/deluan/go-taglib v0.0.0-20260119020817-8753c7531798/go.mod h1:sKDN0U4qXDlq6LFK+aOAkDH4Me5nDV1V/A4B+B69xBA=
+github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57 h1:SXIwfjzTv0UzoUWpFREl8p3AxXVLmbcto1/ISih11a0=
+github.com/deluan/go-taglib v0.0.0-20260205042457-5d80806aee57/go.mod h1:sKDN0U4qXDlq6LFK+aOAkDH4Me5nDV1V/A4B+B69xBA=
 github.com/deluan/rest v0.0.0-20211102003136-6260bc399cbf h1:tb246l2Zmpt/GpF9EcHCKTtwzrd0HGfEmoODFA/qnk4=
 github.com/deluan/rest v0.0.0-20211102003136-6260bc399cbf/go.mod h1:tSgDythFsl0QgS/PFWfIZqcJKnkADWneY80jaVRlqK8=
 github.com/deluan/sanitize v0.0.0-20241120162836-fdfd8fdfaa55 h1:wSCnggTs2f2ji6nFwQmfwgINcmSMj0xF0oHnoyRSPe4=

model/mediafile.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/gohugoio/hashstructure"
 	"github.com/navidrome/navidrome/conf"
+	confmime "github.com/navidrome/navidrome/conf/mime"
 	"github.com/navidrome/navidrome/consts"
 	"github.com/navidrome/navidrome/utils"
 	"github.com/navidrome/navidrome/utils/slice"
@@ -56,6 +57,7 @@ type MediaFile struct {
 	SampleRate           int      `structs:"sample_rate" json:"sampleRate"`
 	BitDepth             int      `structs:"bit_depth" json:"bitDepth"`
 	Channels             int      `structs:"channels" json:"channels"`
+	Codec                string   `structs:"codec" json:"codec"`
 	Genre                string   `structs:"genre" json:"genre"`
 	Genres               Genres   `structs:"-" json:"genres,omitempty"`
 	SortTitle            string   `structs:"sort_title" json:"sortTitle,omitempty"`
@@ -161,6 +163,79 @@ func (mf MediaFile) AbsolutePath() string {
 	return filepath.Join(mf.LibraryPath, mf.Path)
 }
 
+// AudioCodec returns the audio codec for this file.
+// Uses the stored Codec field if available, otherwise infers from Suffix and audio properties.
+func (mf MediaFile) AudioCodec() string {
+	// If we have a stored codec from scanning, normalize and return it
+	if mf.Codec != "" {
+		return strings.ToLower(mf.Codec)
+	}
+	// Fallback: infer from Suffix + BitDepth
+	return mf.inferCodecFromSuffix()
+}
+
+// inferCodecFromSuffix infers the codec from the file extension when Codec field is empty.
+func (mf MediaFile) inferCodecFromSuffix() string {
+	switch strings.ToLower(mf.Suffix) {
+	case "mp3", "mpga":
+		return "mp3"
+	case "mp2":
+		return "mp2"
+	case "ogg", "oga":
+		return "vorbis"
+	case "opus":
+		return "opus"
+	case "mpc":
+		return "mpc"
+	case "wma":
+		return "wma"
+	case "flac":
+		return "flac"
+	case "wav":
+		return "pcm"
+	case "aif", "aiff", "aifc":
+		return "pcm"
+	case "ape":
+		return "ape"
+	case "wv", "wvp":
+		return "wv"
+	case "tta":
+		return "tta"
+	case "tak":
+		return "tak"
+	case "shn":
+		return "shn"
+	case "dsf", "dff":
+		return "dsd"
+	case "m4a":
+		// AAC if BitDepth==0, ALAC if BitDepth>0
+		if mf.BitDepth > 0 {
+			return "alac"
+		}
+		return "aac"
+	case "m4b", "m4p", "m4r":
+		return "aac"
+	default:
+		return ""
+	}
+}
+
+// IsLossless returns true if this file uses a lossless codec.
+func (mf MediaFile) IsLossless() bool {
+	codec := mf.AudioCodec()
+	// Primary: codec-based check (most accurate for containers like M4A)
+	switch codec {
+	case "flac", "alac", "pcm", "ape", "wv", "tta", "tak", "shn", "dsd":
+		return true
+	}
+	// Secondary: suffix-based check using configurable list from YAML
+	if slices.Contains(confmime.LosslessFormats, mf.Suffix) {
+		return true
+	}
+	// Fallback heuristic: if BitDepth is set, it's likely lossless
+	return mf.BitDepth > 0
+}
+
 type MediaFiles []MediaFile
 
 // ToAlbum creates an Album object based on the attributes of this MediaFiles collection.

model/mediafile_test.go

@@ -475,7 +475,7 @@ var _ = Describe("MediaFile", func() {
 		DeferCleanup(configtest.SetupConfig())
 		conf.Server.EnableMediaFileCoverArt = true
 	})
-	Describe(".CoverArtId()", func() {
+	Describe("CoverArtId", func() {
 		It("returns its own id if it HasCoverArt", func() {
 			mf := MediaFile{ID: "111", AlbumID: "1", HasCoverArt: true}
 			id := mf.CoverArtID()
@@ -496,6 +496,94 @@ var _ = Describe("MediaFile", func() {
 			Expect(id.ID).To(Equal(mf.AlbumID))
 		})
 	})
+
+	Describe("AudioCodec", func() {
+		It("returns normalized stored codec when available", func() {
+			mf := MediaFile{Codec: "AAC", Suffix: "m4a"}
+			Expect(mf.AudioCodec()).To(Equal("aac"))
+		})
+
+		It("returns stored codec lowercased", func() {
+			mf := MediaFile{Codec: "ALAC", Suffix: "m4a"}
+			Expect(mf.AudioCodec()).To(Equal("alac"))
+		})
+
+		DescribeTable("infers codec from suffix when Codec field is empty",
+			func(suffix string, bitDepth int, expected string) {
+				mf := MediaFile{Suffix: suffix, BitDepth: bitDepth}
+				Expect(mf.AudioCodec()).To(Equal(expected))
+			},
+			Entry("mp3", "mp3", 0, "mp3"),
+			Entry("mpga", "mpga", 0, "mp3"),
+			Entry("mp2", "mp2", 0, "mp2"),
+			Entry("ogg", "ogg", 0, "vorbis"),
+			Entry("oga", "oga", 0, "vorbis"),
+			Entry("opus", "opus", 0, "opus"),
+			Entry("mpc", "mpc", 0, "mpc"),
+			Entry("wma", "wma", 0, "wma"),
+			Entry("flac", "flac", 0, "flac"),
+			Entry("wav", "wav", 0, "pcm"),
+			Entry("aif", "aif", 0, "pcm"),
+			Entry("aiff", "aiff", 0, "pcm"),
+			Entry("aifc", "aifc", 0, "pcm"),
+			Entry("ape", "ape", 0, "ape"),
+			Entry("wv", "wv", 0, "wv"),
+			Entry("wvp", "wvp", 0, "wv"),
+			Entry("tta", "tta", 0, "tta"),
+			Entry("tak", "tak", 0, "tak"),
+			Entry("shn", "shn", 0, "shn"),
+			Entry("dsf", "dsf", 0, "dsd"),
+			Entry("dff", "dff", 0, "dsd"),
+			Entry("m4a with BitDepth=0 (AAC)", "m4a", 0, "aac"),
+			Entry("m4a with BitDepth>0 (ALAC)", "m4a", 16, "alac"),
+			Entry("m4b", "m4b", 0, "aac"),
+			Entry("m4p", "m4p", 0, "aac"),
+			Entry("m4r", "m4r", 0, "aac"),
+			Entry("unknown suffix", "xyz", 0, ""),
+		)
+
+		It("prefers stored codec over suffix inference", func() {
+			mf := MediaFile{Codec: "ALAC", Suffix: "m4a", BitDepth: 0}
+			Expect(mf.AudioCodec()).To(Equal("alac"))
+		})
+	})
+
+	Describe("IsLossless", func() {
+		BeforeEach(func() {
+			DeferCleanup(configtest.SetupConfig())
+		})
+
+		DescribeTable("detects lossless codecs",
+			func(codec string, suffix string, bitDepth int, expected bool) {
+				mf := MediaFile{Codec: codec, Suffix: suffix, BitDepth: bitDepth}
+				Expect(mf.IsLossless()).To(Equal(expected))
+			},
+			Entry("flac", "FLAC", "flac", 16, true),
+			Entry("alac", "ALAC", "m4a", 24, true),
+			Entry("pcm via wav", "", "wav", 16, true),
+			Entry("pcm via aiff", "", "aiff", 24, true),
+			Entry("ape", "", "ape", 16, true),
+			Entry("wv", "", "wv", 0, true),
+			Entry("tta", "", "tta", 0, true),
+			Entry("tak", "", "tak", 0, true),
+			Entry("shn", "", "shn", 0, true),
+			Entry("dsd", "", "dsf", 0, true),
+			Entry("mp3 is lossy", "MP3", "mp3", 0, false),
+			Entry("aac is lossy", "AAC", "m4a", 0, false),
+			Entry("vorbis is lossy", "", "ogg", 0, false),
+			Entry("opus is lossy", "", "opus", 0, false),
+		)
+
+		It("detects lossless via BitDepth fallback when codec is unknown", func() {
+			mf := MediaFile{Suffix: "xyz", BitDepth: 24}
+			Expect(mf.IsLossless()).To(BeTrue())
+		})
+
+		It("returns false for unknown with no BitDepth", func() {
+			mf := MediaFile{Suffix: "xyz", BitDepth: 0}
+			Expect(mf.IsLossless()).To(BeFalse())
+		})
+	})
 })
 
 func t(v string) time.Time {

model/metadata/map_mediafile.go

@@ -65,6 +65,7 @@ func (md Metadata) ToMediaFile(libID int, folderID string) model.MediaFile {
 	mf.SampleRate = md.AudioProperties().SampleRate
 	mf.BitDepth = md.AudioProperties().BitDepth
 	mf.Channels = md.AudioProperties().Channels
+	mf.Codec = md.AudioProperties().Codec
 	mf.Path = md.FilePath()
 	mf.Suffix = md.Suffix()
 	mf.Size = md.Size()

model/metadata/metadata.go

@@ -35,6 +35,7 @@ type AudioProperties struct {
 	BitDepth   int
 	SampleRate int
 	Channels   int
+	Codec      string
 }
 
 type Date string

reflex.conf

@@ -1 +1 @@
--s -r "(\.go$$|\.cpp$$|\.h$$|navidrome.toml|resources|token_received.html)" -R "(^ui|^data|^db/migrations)" -- go run -race -tags netgo .
+-s -r "(\.go$$|\.cpp$$|\.h$$|navidrome.toml|resources|token_received.html)" -R "(^ui|^data|^db/migrations|_test\.go$$)" -- go run -race -tags netgo .

server/e2e/e2e_suite_test.go

@@ -1,354 +0,0 @@
-package e2e
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	"path/filepath"
-	"testing"
-	"testing/fstest"
-	"time"
-
-	"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/auth"
-	"github.com/navidrome/navidrome/core/external"
-	"github.com/navidrome/navidrome/core/metrics"
-	"github.com/navidrome/navidrome/core/playback"
-	"github.com/navidrome/navidrome/core/scrobbler"
-	"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/server/subsonic"
-	"github.com/navidrome/navidrome/tests"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestSubsonicE2E(t *testing.T) {
-	tests.Init(t, false)
-	defer db.Close(t.Context())
-	log.SetLevel(log.LevelFatal)
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Subsonic API E2E Suite")
-}
-
-// Easy aliases for the storagetest package
-type _t = map[string]any
-
-var template = storagetest.Template
-var track = storagetest.Track
-
-// Shared test state
-var (
-	ctx    context.Context
-	ds     *tests.MockDataStore
-	router *subsonic.Router
-	lib    model.Library
-
-	// Snapshot paths for fast DB restore
-	dbFilePath   string
-	snapshotPath string
-
-	// Admin user used for most tests
-	adminUser = model.User{
-		ID:       "admin-1",
-		UserName: "admin",
-		Name:     "Admin User",
-		IsAdmin:  true,
-	}
-)
-
-func createFS(files fstest.MapFS) storagetest.FakeFS {
-	fs := storagetest.FakeFS{}
-	fs.SetFiles(files)
-	storagetest.Register("fake", &fs)
-	return fs
-}
-
-// buildTestFS creates the full test filesystem matching the plan
-func buildTestFS() storagetest.FakeFS {
-	abbeyRoad := template(_t{"albumartist": "The Beatles", "artist": "The Beatles", "album": "Abbey Road", "year": 1969, "genre": "Rock"})
-	help := template(_t{"albumartist": "The Beatles", "artist": "The Beatles", "album": "Help!", "year": 1965, "genre": "Rock"})
-	ledZepIV := template(_t{"albumartist": "Led Zeppelin", "artist": "Led Zeppelin", "album": "IV", "year": 1971, "genre": "Rock"})
-	kindOfBlue := template(_t{"albumartist": "Miles Davis", "artist": "Miles Davis", "album": "Kind of Blue", "year": 1959, "genre": "Jazz"})
-	popTrack := template(_t{"albumartist": "Various", "artist": "Various", "album": "Pop", "year": 2020, "genre": "Pop"})
-
-	return createFS(fstest.MapFS{
-		// Rock / The Beatles / Abbey Road
-		"Rock/The Beatles/Abbey Road/01 - Come Together.mp3": abbeyRoad(track(1, "Come Together")),
-		"Rock/The Beatles/Abbey Road/02 - Something.mp3":     abbeyRoad(track(2, "Something")),
-		// Rock / The Beatles / Help!
-		"Rock/The Beatles/Help!/01 - Help.mp3": help(track(1, "Help!")),
-		// Rock / Led Zeppelin / IV
-		"Rock/Led Zeppelin/IV/01 - Stairway To Heaven.mp3": ledZepIV(track(1, "Stairway To Heaven")),
-		// Jazz / Miles Davis / Kind of Blue
-		"Jazz/Miles Davis/Kind of Blue/01 - So What.mp3": kindOfBlue(track(1, "So What")),
-		// Pop (standalone track)
-		"Pop/01 - Standalone Track.mp3": popTrack(track(1, "Standalone Track")),
-		// _empty folder (directory with no audio)
-		"_empty/.keep": &fstest.MapFile{Data: []byte{}, ModTime: time.Now()},
-	})
-}
-
-// newReq creates an authenticated GET request for the given endpoint with optional query parameters.
-// Parameters are provided as key-value pairs: newReq("getAlbum", "id", "123")
-func newReq(endpoint string, params ...string) *http.Request {
-	return newReqWithUser(adminUser, endpoint, params...)
-}
-
-// newReqWithUser creates an authenticated GET request for the given user.
-func newReqWithUser(user model.User, endpoint string, params ...string) *http.Request {
-	u := "/rest/" + endpoint
-	if len(params) > 0 {
-		q := url.Values{}
-		for i := 0; i < len(params)-1; i += 2 {
-			q.Add(params[i], params[i+1])
-		}
-		u += "?" + q.Encode()
-	}
-	r := httptest.NewRequest("GET", u, nil)
-	userCtx := request.WithUser(r.Context(), user)
-	userCtx = request.WithUsername(userCtx, user.UserName)
-	userCtx = request.WithClient(userCtx, "test-client")
-	userCtx = request.WithPlayer(userCtx, model.Player{ID: "player-1", Name: "Test Player", Client: "test-client"})
-	return r.WithContext(userCtx)
-}
-
-// newRawReq creates a ResponseRecorder + authenticated request for raw handlers (stream, download, getCoverArt).
-func newRawReq(endpoint string, params ...string) (*httptest.ResponseRecorder, *http.Request) {
-	return httptest.NewRecorder(), newReq(endpoint, params...)
-}
-
-// newRawReqWithUser creates a ResponseRecorder + authenticated request for the given user.
-func newRawReqWithUser(user model.User, endpoint string, params ...string) (*httptest.ResponseRecorder, *http.Request) {
-	return httptest.NewRecorder(), newReqWithUser(user, endpoint, params...)
-}
-
-// --- Noop stub implementations for Router dependencies ---
-
-// 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) GetOrPlaceholder(_ context.Context, _ string, _ int, _ bool) (io.ReadCloser, time.Time, error) {
-	return io.NopCloser(io.LimitReader(nil, 0)), time.Time{}, nil
-}
-
-// noopStreamer implements core.MediaStreamer
-type noopStreamer struct{}
-
-func (n noopStreamer) NewStream(context.Context, string, string, int, int) (*core.Stream, error) {
-	return nil, model.ErrNotFound
-}
-
-func (n noopStreamer) DoStream(context.Context, *model.MediaFile, string, int, int) (*core.Stream, error) {
-	return nil, model.ErrNotFound
-}
-
-// noopArchiver implements core.Archiver
-type noopArchiver struct{}
-
-func (n noopArchiver) ZipAlbum(context.Context, string, string, int, io.Writer) error {
-	return model.ErrNotFound
-}
-
-func (n noopArchiver) ZipArtist(context.Context, string, string, int, io.Writer) error {
-	return model.ErrNotFound
-}
-
-func (n noopArchiver) ZipShare(context.Context, string, io.Writer) error {
-	return model.ErrNotFound
-}
-
-func (n noopArchiver) ZipPlaylist(context.Context, string, string, int, io.Writer) error {
-	return model.ErrNotFound
-}
-
-// noopProvider implements external.Provider
-type noopProvider struct{}
-
-func (n noopProvider) UpdateAlbumInfo(_ context.Context, _ string) (*model.Album, error) {
-	return &model.Album{}, nil
-}
-
-func (n noopProvider) UpdateArtistInfo(_ context.Context, _ string, _ int, _ bool) (*model.Artist, error) {
-	return &model.Artist{}, nil
-}
-
-func (n noopProvider) SimilarSongs(context.Context, string, int) (model.MediaFiles, error) {
-	return nil, nil
-}
-
-func (n noopProvider) TopSongs(context.Context, 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
-}
-
-// noopPlayTracker implements scrobbler.PlayTracker
-type noopPlayTracker struct{}
-
-func (n noopPlayTracker) NowPlaying(context.Context, string, string, string, int) error {
-	return nil
-}
-
-func (n noopPlayTracker) GetNowPlaying(context.Context) ([]scrobbler.NowPlayingInfo, error) {
-	return nil, nil
-}
-
-func (n noopPlayTracker) Submit(context.Context, []scrobbler.Submission) error {
-	return nil
-}
-
-// Compile-time interface checks
-var (
-	_ artwork.Artwork       = noopArtwork{}
-	_ core.MediaStreamer    = noopStreamer{}
-	_ core.Archiver         = noopArchiver{}
-	_ external.Provider     = noopProvider{}
-	_ scrobbler.PlayTracker = noopPlayTracker{}
-)
-
-var _ = BeforeSuite(func() {
-	ctx = request.WithUser(GinkgoT().Context(), adminUser)
-	tmpDir := GinkgoT().TempDir()
-	dbFilePath = filepath.Join(tmpDir, "test-e2e.db")
-	snapshotPath = filepath.Join(tmpDir, "test-e2e.db.snapshot")
-	conf.Server.DbPath = dbFilePath + "?_journal_mode=WAL"
-	db.Db().SetMaxOpenConns(1)
-
-	// Initial setup: schema, user, library, and full scan (runs once for the entire suite)
-	conf.Server.MusicFolder = "fake:///music"
-	conf.Server.DevExternalScanner = false
-
-	db.Init(ctx)
-
-	initDS := &tests.MockDataStore{RealDS: persistence.New(db.Db())}
-	auth.Init(initDS)
-
-	adminUserWithPass := adminUser
-	adminUserWithPass.NewPassword = "password"
-	Expect(initDS.User(ctx).Put(&adminUserWithPass)).To(Succeed())
-
-	lib = model.Library{ID: 1, Name: "Music Library", Path: "fake:///music"}
-	Expect(initDS.Library(ctx).Put(&lib)).To(Succeed())
-
-	Expect(initDS.User(ctx).SetUserLibraries(adminUser.ID, []int{lib.ID})).To(Succeed())
-
-	loadedUser, err := initDS.User(ctx).FindByUsername(adminUser.UserName)
-	Expect(err).ToNot(HaveOccurred())
-	adminUser.Libraries = loadedUser.Libraries
-	ctx = request.WithUser(GinkgoT().Context(), adminUser)
-
-	buildTestFS()
-	s := scanner.New(ctx, initDS, artwork.NoopCacheWarmer(), events.NoopBroker(),
-		core.NewPlaylists(initDS), metrics.NewNoopInstance())
-	_, err = s.ScanAll(ctx, true)
-	Expect(err).ToNot(HaveOccurred())
-
-	// Checkpoint WAL and snapshot the golden DB state
-	_, err = db.Db().Exec("PRAGMA wal_checkpoint(TRUNCATE)")
-	Expect(err).ToNot(HaveOccurred())
-	data, err := os.ReadFile(dbFilePath)
-	Expect(err).ToNot(HaveOccurred())
-	Expect(os.WriteFile(snapshotPath, data, 0600)).To(Succeed())
-})
-
-// setupTestDB restores the database from the golden snapshot and creates the
-// Subsonic Router. Call this from BeforeEach/BeforeAll in each test container.
-func setupTestDB() {
-	ctx = request.WithUser(GinkgoT().Context(), adminUser)
-
-	DeferCleanup(configtest.SetupConfig())
-	conf.Server.MusicFolder = "fake:///music"
-	conf.Server.DevExternalScanner = false
-
-	// Restore DB to golden state (no scan needed)
-	restoreDB()
-
-	ds = &tests.MockDataStore{RealDS: persistence.New(db.Db())}
-	auth.Init(ds)
-
-	// Pre-populate repository cache with a valid context. The MockDataStore caches
-	// repositories on first access; without this, the first access may happen inside
-	// an errgroup (e.g., searchAll) whose context is canceled after Wait(), causing
-	// subsequent calls to silently fail.
-	ds.MediaFile(ctx)
-	ds.Album(ctx)
-	ds.Artist(ctx)
-
-	// Create the Subsonic Router with real DS + noop stubs
-	s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
-		core.NewPlaylists(ds), metrics.NewNoopInstance())
-	router = subsonic.New(
-		ds,
-		noopArtwork{},
-		noopStreamer{},
-		noopArchiver{},
-		core.NewPlayers(ds),
-		noopProvider{},
-		s,
-		events.NoopBroker(),
-		core.NewPlaylists(ds),
-		noopPlayTracker{},
-		core.NewShare(ds),
-		playback.PlaybackServer(nil),
-		metrics.NewNoopInstance(),
-	)
-}
-
-// restoreDB restores all table data from the snapshot using ATTACH DATABASE.
-// This is much faster than re-running the scanner for each test.
-func restoreDB() {
-	sqlDB := db.Db()
-
-	_, err := sqlDB.Exec("PRAGMA foreign_keys = OFF")
-	Expect(err).ToNot(HaveOccurred())
-
-	_, err = sqlDB.Exec("ATTACH DATABASE ? AS snapshot", snapshotPath)
-	Expect(err).ToNot(HaveOccurred())
-
-	rows, err := sqlDB.Query("SELECT name FROM main.sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
-	Expect(err).ToNot(HaveOccurred())
-	var tables []string
-	for rows.Next() {
-		var name string
-		Expect(rows.Scan(&name)).To(Succeed())
-		tables = append(tables, name)
-	}
-	Expect(rows.Err()).ToNot(HaveOccurred())
-	rows.Close()
-
-	for _, table := range tables {
-		// Table names come from sqlite_master, not user input, so concatenation is safe here
-		_, 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())
-	}
-
-	_, err = sqlDB.Exec("DETACH DATABASE snapshot")
-	Expect(err).ToNot(HaveOccurred())
-	_, err = sqlDB.Exec("PRAGMA foreign_keys = ON")
-	Expect(err).ToNot(HaveOccurred())
-}

server/e2e/subsonic_album_lists_test.go

@@ -1,350 +0,0 @@
-package e2e
-
-import (
-	"net/http/httptest"
-
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	"github.com/navidrome/navidrome/utils/req"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Album List Endpoints", func() {
-	BeforeEach(func() {
-		setupTestDB()
-	})
-
-	Describe("GetAlbumList", func() {
-		It("type=newest returns albums sorted by creation date", func() {
-			w, r := newRawReq("getAlbumList", "type", "newest")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(HaveLen(5))
-		})
-
-		It("type=alphabeticalByName sorts albums by name", func() {
-			w, r := newRawReq("getAlbumList", "type", "alphabeticalByName")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			albums := resp.AlbumList.Album
-			Expect(albums).To(HaveLen(5))
-			// Verify alphabetical order: Abbey Road, Help!, IV, Kind of Blue, Pop
-			Expect(albums[0].Title).To(Equal("Abbey Road"))
-			Expect(albums[1].Title).To(Equal("Help!"))
-			Expect(albums[2].Title).To(Equal("IV"))
-			Expect(albums[3].Title).To(Equal("Kind of Blue"))
-			Expect(albums[4].Title).To(Equal("Pop"))
-		})
-
-		It("type=alphabeticalByArtist sorts albums by artist name", func() {
-			w, r := newRawReq("getAlbumList", "type", "alphabeticalByArtist")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			albums := resp.AlbumList.Album
-			Expect(albums).To(HaveLen(5))
-			// Articles like "The" are stripped for sorting, so "The Beatles" sorts as "Beatles"
-			// Non-compilations first: Beatles (x2), Led Zeppelin, Miles Davis, then compilations: Various
-			Expect(albums[0].Artist).To(Equal("The Beatles"))
-			Expect(albums[2].Artist).To(Equal("Led Zeppelin"))
-			Expect(albums[3].Artist).To(Equal("Miles Davis"))
-		})
-
-		It("type=random returns albums", func() {
-			w, r := newRawReq("getAlbumList", "type", "random")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(HaveLen(5))
-		})
-
-		It("type=byGenre filters by genre parameter", func() {
-			w, r := newRawReq("getAlbumList", "type", "byGenre", "genre", "Jazz")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(HaveLen(1))
-			Expect(resp.AlbumList.Album[0].Title).To(Equal("Kind of Blue"))
-		})
-
-		It("type=byYear filters by fromYear/toYear range", func() {
-			w, r := newRawReq("getAlbumList", "type", "byYear", "fromYear", "1965", "toYear", "1970")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			// Should include Abbey Road (1969) and Help! (1965)
-			Expect(resp.AlbumList.Album).To(HaveLen(2))
-			years := make([]int32, len(resp.AlbumList.Album))
-			for i, a := range resp.AlbumList.Album {
-				years[i] = a.Year
-			}
-			Expect(years).To(ConsistOf(int32(1965), int32(1969)))
-		})
-
-		It("respects size parameter", func() {
-			w, r := newRawReq("getAlbumList", "type", "newest", "size", "2")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(HaveLen(2))
-		})
-
-		It("supports offset for pagination", func() {
-			// First get all albums sorted by name to know the expected order
-			w1, r1 := newRawReq("getAlbumList", "type", "alphabeticalByName", "size", "5")
-			resp1, err := router.GetAlbumList(w1, r1)
-			Expect(err).ToNot(HaveOccurred())
-			allAlbums := resp1.AlbumList.Album
-
-			// Now get with offset=2, size=2
-			w2, r2 := newRawReq("getAlbumList", "type", "alphabeticalByName", "size", "2", "offset", "2")
-			resp2, err := router.GetAlbumList(w2, r2)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp2.AlbumList).ToNot(BeNil())
-			Expect(resp2.AlbumList.Album).To(HaveLen(2))
-			Expect(resp2.AlbumList.Album[0].Title).To(Equal(allAlbums[2].Title))
-			Expect(resp2.AlbumList.Album[1].Title).To(Equal(allAlbums[3].Title))
-		})
-
-		It("returns error when type parameter is missing", func() {
-			w := httptest.NewRecorder()
-			r := newReq("getAlbumList")
-			_, err := router.GetAlbumList(w, r)
-
-			Expect(err).To(HaveOccurred())
-			Expect(err).To(MatchError(req.ErrMissingParam))
-		})
-
-		It("returns error for unknown type", func() {
-			w, r := newRawReq("getAlbumList", "type", "invalid_type")
-			_, err := router.GetAlbumList(w, r)
-
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("type=frequent returns empty when no albums have been played", func() {
-			w, r := newRawReq("getAlbumList", "type", "frequent")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(BeEmpty())
-		})
-
-		It("type=recent returns empty when no albums have been played", func() {
-			w, r := newRawReq("getAlbumList", "type", "recent")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(BeEmpty())
-		})
-	})
-
-	Describe("GetAlbumList - starred type", Ordered, func() {
-		BeforeAll(func() {
-			setupTestDB()
-
-			// Star an album so the starred filter returns results
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.name": "Abbey Road"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-
-			r := newReq("star", "albumId", albums[0].ID)
-			_, err = router.Star(r)
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("type=starred returns only starred albums", func() {
-			w, r := newRawReq("getAlbumList", "type", "starred")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(HaveLen(1))
-			Expect(resp.AlbumList.Album[0].Title).To(Equal("Abbey Road"))
-		})
-	})
-
-	Describe("GetAlbumList - highest type", Ordered, func() {
-		BeforeAll(func() {
-			setupTestDB()
-
-			// Rate an album so the highest filter returns results
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.name": "Kind of Blue"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-
-			r := newReq("setRating", "id", albums[0].ID, "rating", "5")
-			_, err = router.SetRating(r)
-			Expect(err).ToNot(HaveOccurred())
-		})
-
-		It("type=highest returns only rated albums", func() {
-			w, r := newRawReq("getAlbumList", "type", "highest")
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(HaveLen(1))
-			Expect(resp.AlbumList.Album[0].Title).To(Equal("Kind of Blue"))
-		})
-	})
-
-	Describe("GetAlbumList2", func() {
-		It("returns albums in AlbumID3 format", func() {
-			w, r := newRawReq("getAlbumList2", "type", "alphabeticalByName")
-			resp, err := router.GetAlbumList2(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.AlbumList2).ToNot(BeNil())
-			albums := resp.AlbumList2.Album
-			Expect(albums).To(HaveLen(5))
-			// Verify AlbumID3 format fields
-			Expect(albums[0].Name).To(Equal("Abbey Road"))
-			Expect(albums[0].Id).ToNot(BeEmpty())
-			Expect(albums[0].Artist).ToNot(BeEmpty())
-		})
-
-		It("type=newest works correctly", func() {
-			w, r := newRawReq("getAlbumList2", "type", "newest")
-			resp, err := router.GetAlbumList2(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList2).ToNot(BeNil())
-			Expect(resp.AlbumList2.Album).To(HaveLen(5))
-		})
-	})
-
-	Describe("GetStarred", func() {
-		It("returns empty lists when nothing is starred", func() {
-			r := newReq("getStarred")
-			resp, err := router.GetStarred(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Starred).ToNot(BeNil())
-			Expect(resp.Starred.Artist).To(BeEmpty())
-			Expect(resp.Starred.Album).To(BeEmpty())
-			Expect(resp.Starred.Song).To(BeEmpty())
-		})
-	})
-
-	Describe("GetStarred2", func() {
-		It("returns empty lists when nothing is starred", func() {
-			r := newReq("getStarred2")
-			resp, err := router.GetStarred2(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Starred2).ToNot(BeNil())
-			Expect(resp.Starred2.Artist).To(BeEmpty())
-			Expect(resp.Starred2.Album).To(BeEmpty())
-			Expect(resp.Starred2.Song).To(BeEmpty())
-		})
-	})
-
-	Describe("GetNowPlaying", func() {
-		It("returns empty list when nobody is playing", func() {
-			r := newReq("getNowPlaying")
-			resp, err := router.GetNowPlaying(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.NowPlaying).ToNot(BeNil())
-			Expect(resp.NowPlaying.Entry).To(BeEmpty())
-		})
-	})
-
-	Describe("GetRandomSongs", func() {
-		It("returns random songs from library", func() {
-			r := newReq("getRandomSongs")
-			resp, err := router.GetRandomSongs(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.RandomSongs).ToNot(BeNil())
-			Expect(resp.RandomSongs.Songs).ToNot(BeEmpty())
-			Expect(len(resp.RandomSongs.Songs)).To(BeNumerically("<=", 6))
-		})
-
-		It("respects size parameter", func() {
-			r := newReq("getRandomSongs", "size", "2")
-			resp, err := router.GetRandomSongs(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.RandomSongs).ToNot(BeNil())
-			Expect(resp.RandomSongs.Songs).To(HaveLen(2))
-		})
-
-		It("filters by genre when specified", func() {
-			r := newReq("getRandomSongs", "size", "500", "genre", "Jazz")
-			resp, err := router.GetRandomSongs(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.RandomSongs).ToNot(BeNil())
-			Expect(resp.RandomSongs.Songs).To(HaveLen(1))
-			Expect(resp.RandomSongs.Songs[0].Genre).To(Equal("Jazz"))
-		})
-	})
-
-	Describe("GetSongsByGenre", func() {
-		It("returns songs matching the genre", func() {
-			r := newReq("getSongsByGenre", "genre", "Rock")
-			resp, err := router.GetSongsByGenre(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.SongsByGenre).ToNot(BeNil())
-			// 4 Rock songs: Come Together, Something, Help!, Stairway To Heaven
-			Expect(resp.SongsByGenre.Songs).To(HaveLen(4))
-			for _, song := range resp.SongsByGenre.Songs {
-				Expect(song.Genre).To(Equal("Rock"))
-			}
-		})
-
-		It("supports count and offset parameters", func() {
-			// First get all Rock songs
-			r1 := newReq("getSongsByGenre", "genre", "Rock", "count", "500")
-			resp1, err := router.GetSongsByGenre(r1)
-			Expect(err).ToNot(HaveOccurred())
-			allSongs := resp1.SongsByGenre.Songs
-
-			// Now get with count=2, offset=1
-			r2 := newReq("getSongsByGenre", "genre", "Rock", "count", "2", "offset", "1")
-			resp2, err := router.GetSongsByGenre(r2)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp2.SongsByGenre).ToNot(BeNil())
-			Expect(resp2.SongsByGenre.Songs).To(HaveLen(2))
-			Expect(resp2.SongsByGenre.Songs[0].Id).To(Equal(allSongs[1].Id))
-		})
-
-		It("returns empty for non-existent genre", func() {
-			r := newReq("getSongsByGenre", "genre", "NonExistentGenre")
-			resp, err := router.GetSongsByGenre(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.SongsByGenre).ToNot(BeNil())
-			Expect(resp.SongsByGenre.Songs).To(BeEmpty())
-		})
-	})
-})

server/e2e/subsonic_bookmarks_test.go

@@ -1,164 +0,0 @@
-package e2e
-
-import (
-	"fmt"
-
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Bookmark and PlayQueue Endpoints", Ordered, func() {
-	BeforeAll(func() {
-		setupTestDB()
-	})
-
-	Describe("Bookmark Endpoints", Ordered, func() {
-		var trackID string
-
-		BeforeAll(func() {
-			// Get a media file ID from the database to use for bookmarks
-			mfs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Max: 1})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(mfs).ToNot(BeEmpty())
-			trackID = mfs[0].ID
-		})
-
-		It("getBookmarks returns empty initially", func() {
-			r := newReq("getBookmarks")
-			resp, err := router.GetBookmarks(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Bookmarks).ToNot(BeNil())
-			Expect(resp.Bookmarks.Bookmark).To(BeEmpty())
-		})
-
-		It("createBookmark creates a bookmark with position", func() {
-			r := newReq("createBookmark", "id", trackID, "position", "12345", "comment", "test bookmark")
-			resp, err := router.CreateBookmark(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-		})
-
-		It("getBookmarks shows the created bookmark", func() {
-			r := newReq("getBookmarks")
-			resp, err := router.GetBookmarks(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Bookmarks).ToNot(BeNil())
-			Expect(resp.Bookmarks.Bookmark).To(HaveLen(1))
-
-			bmk := resp.Bookmarks.Bookmark[0]
-			Expect(bmk.Entry.Id).To(Equal(trackID))
-			Expect(bmk.Position).To(Equal(int64(12345)))
-			Expect(bmk.Comment).To(Equal("test bookmark"))
-			Expect(bmk.Username).To(Equal(adminUser.UserName))
-		})
-
-		It("deleteBookmark removes the bookmark", func() {
-			r := newReq("deleteBookmark", "id", trackID)
-			resp, err := router.DeleteBookmark(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-
-			// Verify it's gone
-			r = newReq("getBookmarks")
-			resp, err = router.GetBookmarks(r)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Bookmarks.Bookmark).To(BeEmpty())
-		})
-	})
-
-	Describe("PlayQueue Endpoints", Ordered, func() {
-		var trackIDs []string
-
-		BeforeAll(func() {
-			// Get multiple media file IDs from the database
-			mfs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Max: 3, Sort: "title"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(len(mfs)).To(BeNumerically(">=", 2))
-			for _, mf := range mfs {
-				trackIDs = append(trackIDs, mf.ID)
-			}
-		})
-
-		It("getPlayQueue returns empty when nothing saved", func() {
-			r := newReq("getPlayQueue")
-			resp, err := router.GetPlayQueue(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			// When no play queue exists, PlayQueue should be nil (no entry returned)
-			Expect(resp.PlayQueue).To(BeNil())
-		})
-
-		It("savePlayQueue stores current play queue", func() {
-			r := newReq("savePlayQueue",
-				"id", trackIDs[0],
-				"id", trackIDs[1],
-				"current", trackIDs[1],
-				"position", "5000",
-			)
-			resp, err := router.SavePlayQueue(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-		})
-
-		It("getPlayQueue returns saved queue with tracks", func() {
-			r := newReq("getPlayQueue")
-			resp, err := router.GetPlayQueue(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.PlayQueue).ToNot(BeNil())
-			Expect(resp.PlayQueue.Entry).To(HaveLen(2))
-			Expect(resp.PlayQueue.Current).To(Equal(trackIDs[1]))
-			Expect(resp.PlayQueue.Position).To(Equal(int64(5000)))
-			Expect(resp.PlayQueue.Username).To(Equal(adminUser.UserName))
-			Expect(resp.PlayQueue.ChangedBy).To(Equal("test-client"))
-		})
-
-		It("getPlayQueueByIndex returns data with current index", func() {
-			r := newReq("getPlayQueueByIndex")
-			resp, err := router.GetPlayQueueByIndex(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.PlayQueueByIndex).ToNot(BeNil())
-			Expect(resp.PlayQueueByIndex.Entry).To(HaveLen(2))
-			Expect(resp.PlayQueueByIndex.CurrentIndex).ToNot(BeNil())
-			Expect(*resp.PlayQueueByIndex.CurrentIndex).To(Equal(1))
-			Expect(resp.PlayQueueByIndex.Position).To(Equal(int64(5000)))
-		})
-
-		It("savePlayQueueByIndex stores queue by index", func() {
-			r := newReq("savePlayQueueByIndex",
-				"id", trackIDs[0],
-				"id", trackIDs[1],
-				"id", trackIDs[2],
-				"currentIndex", fmt.Sprintf("%d", 0),
-				"position", "9999",
-			)
-			resp, err := router.SavePlayQueueByIndex(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-
-			// Verify with getPlayQueueByIndex
-			r = newReq("getPlayQueueByIndex")
-			resp, err = router.GetPlayQueueByIndex(r)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.PlayQueueByIndex).ToNot(BeNil())
-			Expect(resp.PlayQueueByIndex.Entry).To(HaveLen(3))
-			Expect(resp.PlayQueueByIndex.CurrentIndex).ToNot(BeNil())
-			Expect(*resp.PlayQueueByIndex.CurrentIndex).To(Equal(0))
-			Expect(resp.PlayQueueByIndex.Position).To(Equal(int64(9999)))
-		})
-	})
-})

server/e2e/subsonic_browsing_test.go

@@ -1,522 +0,0 @@
-package e2e
-
-import (
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Browsing Endpoints", func() {
-	BeforeEach(func() {
-		setupTestDB()
-	})
-
-	Describe("getMusicFolders", func() {
-		It("returns the configured music library", func() {
-			r := newReq("getMusicFolders")
-			resp, err := router.GetMusicFolders(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.MusicFolders).ToNot(BeNil())
-			Expect(resp.MusicFolders.Folders).To(HaveLen(1))
-			Expect(resp.MusicFolders.Folders[0].Name).To(Equal("Music Library"))
-			Expect(resp.MusicFolders.Folders[0].Id).To(Equal(int32(lib.ID)))
-		})
-	})
-
-	Describe("getIndexes", func() {
-		It("returns artist indexes", func() {
-			r := newReq("getIndexes")
-			resp, err := router.GetIndexes(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Indexes).ToNot(BeNil())
-			Expect(resp.Indexes.Index).ToNot(BeEmpty())
-		})
-
-		It("includes all artists across indexes", func() {
-			r := newReq("getIndexes")
-			resp, err := router.GetIndexes(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var allArtistNames []string
-			for _, idx := range resp.Indexes.Index {
-				for _, a := range idx.Artists {
-					allArtistNames = append(allArtistNames, a.Name)
-				}
-			}
-			Expect(allArtistNames).To(ContainElements("The Beatles", "Led Zeppelin", "Miles Davis", "Various"))
-		})
-	})
-
-	Describe("getArtists", func() {
-		It("returns artist indexes in ID3 format", func() {
-			r := newReq("getArtists")
-			resp, err := router.GetArtists(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Artist).ToNot(BeNil())
-			Expect(resp.Artist.Index).ToNot(BeEmpty())
-		})
-
-		It("includes all artists across ID3 indexes", func() {
-			r := newReq("getArtists")
-			resp, err := router.GetArtists(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var allArtistNames []string
-			for _, idx := range resp.Artist.Index {
-				for _, a := range idx.Artists {
-					allArtistNames = append(allArtistNames, a.Name)
-				}
-			}
-			Expect(allArtistNames).To(ContainElements("The Beatles", "Led Zeppelin", "Miles Davis", "Various"))
-		})
-
-		It("reports correct album counts for artists", func() {
-			r := newReq("getArtists")
-			resp, err := router.GetArtists(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var beatlesAlbumCount int32
-			for _, idx := range resp.Artist.Index {
-				for _, a := range idx.Artists {
-					if a.Name == "The Beatles" {
-						beatlesAlbumCount = a.AlbumCount
-					}
-				}
-			}
-			Expect(beatlesAlbumCount).To(Equal(int32(2)))
-		})
-	})
-
-	Describe("getMusicDirectory", func() {
-		It("returns an artist directory with its albums as children", func() {
-			artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"name": "The Beatles"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(artists).ToNot(BeEmpty())
-			beatlesID := artists[0].ID
-
-			r := newReq("getMusicDirectory", "id", beatlesID)
-			resp, err := router.GetMusicDirectory(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Directory).ToNot(BeNil())
-			Expect(resp.Directory.Name).To(Equal("The Beatles"))
-			Expect(resp.Directory.Child).To(HaveLen(2)) // Abbey Road, Help!
-		})
-
-		It("returns an album directory with its tracks as children", func() {
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.name": "Abbey Road"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-			abbeyRoadID := albums[0].ID
-
-			r := newReq("getMusicDirectory", "id", abbeyRoadID)
-			resp, err := router.GetMusicDirectory(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Directory).ToNot(BeNil())
-			Expect(resp.Directory.Name).To(Equal("Abbey Road"))
-			Expect(resp.Directory.Child).To(HaveLen(2)) // Come Together, Something
-		})
-
-		It("returns an error for a non-existent ID", func() {
-			r := newReq("getMusicDirectory", "id", "non-existent-id")
-			_, err := router.GetMusicDirectory(r)
-
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Describe("getArtist", func() {
-		It("returns artist with albums in ID3 format", func() {
-			artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"name": "The Beatles"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(artists).ToNot(BeEmpty())
-			beatlesID := artists[0].ID
-
-			r := newReq("getArtist", "id", beatlesID)
-			resp, err := router.GetArtist(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.ArtistWithAlbumsID3).ToNot(BeNil())
-			Expect(resp.ArtistWithAlbumsID3.Name).To(Equal("The Beatles"))
-			Expect(resp.ArtistWithAlbumsID3.Album).To(HaveLen(2))
-		})
-
-		It("returns album names for the artist", func() {
-			artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"name": "The Beatles"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(artists).ToNot(BeEmpty())
-			beatlesID := artists[0].ID
-
-			r := newReq("getArtist", "id", beatlesID)
-			resp, err := router.GetArtist(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var albumNames []string
-			for _, a := range resp.ArtistWithAlbumsID3.Album {
-				albumNames = append(albumNames, a.Name)
-			}
-			Expect(albumNames).To(ContainElements("Abbey Road", "Help!"))
-		})
-
-		It("returns an error for a non-existent artist", func() {
-			r := newReq("getArtist", "id", "non-existent-id")
-			_, err := router.GetArtist(r)
-
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("returns artist with a single album", func() {
-			artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"name": "Led Zeppelin"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(artists).ToNot(BeEmpty())
-			ledZepID := artists[0].ID
-
-			r := newReq("getArtist", "id", ledZepID)
-			resp, err := router.GetArtist(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.ArtistWithAlbumsID3).ToNot(BeNil())
-			Expect(resp.ArtistWithAlbumsID3.Name).To(Equal("Led Zeppelin"))
-			Expect(resp.ArtistWithAlbumsID3.Album).To(HaveLen(1))
-			Expect(resp.ArtistWithAlbumsID3.Album[0].Name).To(Equal("IV"))
-		})
-	})
-
-	Describe("getAlbum", func() {
-		It("returns album with its tracks", func() {
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.name": "Abbey Road"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-			abbeyRoadID := albums[0].ID
-
-			r := newReq("getAlbum", "id", abbeyRoadID)
-			resp, err := router.GetAlbum(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.AlbumWithSongsID3).ToNot(BeNil())
-			Expect(resp.AlbumWithSongsID3.Name).To(Equal("Abbey Road"))
-			Expect(resp.AlbumWithSongsID3.Song).To(HaveLen(2))
-		})
-
-		It("includes correct track metadata", func() {
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.name": "Abbey Road"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-			abbeyRoadID := albums[0].ID
-
-			r := newReq("getAlbum", "id", abbeyRoadID)
-			resp, err := router.GetAlbum(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var trackTitles []string
-			for _, s := range resp.AlbumWithSongsID3.Song {
-				trackTitles = append(trackTitles, s.Title)
-			}
-			Expect(trackTitles).To(ContainElements("Come Together", "Something"))
-		})
-
-		It("returns album with correct artist and year", func() {
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.name": "Kind of Blue"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-			kindOfBlueID := albums[0].ID
-
-			r := newReq("getAlbum", "id", kindOfBlueID)
-			resp, err := router.GetAlbum(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumWithSongsID3).ToNot(BeNil())
-			Expect(resp.AlbumWithSongsID3.Name).To(Equal("Kind of Blue"))
-			Expect(resp.AlbumWithSongsID3.Artist).To(Equal("Miles Davis"))
-			Expect(resp.AlbumWithSongsID3.Year).To(Equal(int32(1959)))
-			Expect(resp.AlbumWithSongsID3.Song).To(HaveLen(1))
-		})
-
-		It("returns an error for a non-existent album", func() {
-			r := newReq("getAlbum", "id", "non-existent-id")
-			_, err := router.GetAlbum(r)
-
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Describe("getSong", func() {
-		It("returns a song by its ID", func() {
-			songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"title": "Come Together"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).ToNot(BeEmpty())
-			songID := songs[0].ID
-
-			r := newReq("getSong", "id", songID)
-			resp, err := router.GetSong(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Song).ToNot(BeNil())
-			Expect(resp.Song.Title).To(Equal("Come Together"))
-			Expect(resp.Song.Album).To(Equal("Abbey Road"))
-			Expect(resp.Song.Artist).To(Equal("The Beatles"))
-		})
-
-		It("returns an error for a non-existent song", func() {
-			r := newReq("getSong", "id", "non-existent-id")
-			_, err := router.GetSong(r)
-
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("returns correct metadata for a jazz track", func() {
-			songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"title": "So What"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).ToNot(BeEmpty())
-			songID := songs[0].ID
-
-			r := newReq("getSong", "id", songID)
-			resp, err := router.GetSong(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Song).ToNot(BeNil())
-			Expect(resp.Song.Title).To(Equal("So What"))
-			Expect(resp.Song.Album).To(Equal("Kind of Blue"))
-			Expect(resp.Song.Artist).To(Equal("Miles Davis"))
-		})
-	})
-
-	Describe("getGenres", func() {
-		It("returns all genres", func() {
-			r := newReq("getGenres")
-			resp, err := router.GetGenres(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Genres).ToNot(BeNil())
-			Expect(resp.Genres.Genre).To(HaveLen(3))
-		})
-
-		It("includes correct genre names", func() {
-			r := newReq("getGenres")
-			resp, err := router.GetGenres(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var genreNames []string
-			for _, g := range resp.Genres.Genre {
-				genreNames = append(genreNames, g.Name)
-			}
-			Expect(genreNames).To(ContainElements("Rock", "Jazz", "Pop"))
-		})
-
-		It("reports correct song and album counts for Rock", func() {
-			r := newReq("getGenres")
-			resp, err := router.GetGenres(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var rockGenre *responses.Genre
-			for i, g := range resp.Genres.Genre {
-				if g.Name == "Rock" {
-					rockGenre = &resp.Genres.Genre[i]
-					break
-				}
-			}
-			Expect(rockGenre).ToNot(BeNil())
-			Expect(rockGenre.SongCount).To(Equal(int32(4)))
-			Expect(rockGenre.AlbumCount).To(Equal(int32(3)))
-		})
-
-		It("reports correct song and album counts for Jazz", func() {
-			r := newReq("getGenres")
-			resp, err := router.GetGenres(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var jazzGenre *responses.Genre
-			for i, g := range resp.Genres.Genre {
-				if g.Name == "Jazz" {
-					jazzGenre = &resp.Genres.Genre[i]
-					break
-				}
-			}
-			Expect(jazzGenre).ToNot(BeNil())
-			Expect(jazzGenre.SongCount).To(Equal(int32(1)))
-			Expect(jazzGenre.AlbumCount).To(Equal(int32(1)))
-		})
-
-		It("reports correct song and album counts for Pop", func() {
-			r := newReq("getGenres")
-			resp, err := router.GetGenres(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			var popGenre *responses.Genre
-			for i, g := range resp.Genres.Genre {
-				if g.Name == "Pop" {
-					popGenre = &resp.Genres.Genre[i]
-					break
-				}
-			}
-			Expect(popGenre).ToNot(BeNil())
-			Expect(popGenre.SongCount).To(Equal(int32(1)))
-			Expect(popGenre.AlbumCount).To(Equal(int32(1)))
-		})
-	})
-
-	Describe("getAlbumInfo", func() {
-		It("returns album info for a valid album", func() {
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.name": "Abbey Road"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-			abbeyRoadID := albums[0].ID
-
-			r := newReq("getAlbumInfo", "id", abbeyRoadID)
-			resp, err := router.GetAlbumInfo(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.AlbumInfo).ToNot(BeNil())
-		})
-	})
-
-	Describe("getAlbumInfo2", func() {
-		It("returns album info for a valid album", func() {
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.name": "Abbey Road"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-			abbeyRoadID := albums[0].ID
-
-			r := newReq("getAlbumInfo2", "id", abbeyRoadID)
-			resp, err := router.GetAlbumInfo(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.AlbumInfo).ToNot(BeNil())
-		})
-	})
-
-	Describe("getArtistInfo", func() {
-		It("returns artist info for a valid artist", func() {
-			artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"name": "The Beatles"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(artists).ToNot(BeEmpty())
-			beatlesID := artists[0].ID
-
-			r := newReq("getArtistInfo", "id", beatlesID)
-			resp, err := router.GetArtistInfo(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.ArtistInfo).ToNot(BeNil())
-		})
-	})
-
-	Describe("getArtistInfo2", func() {
-		It("returns artist info2 for a valid artist", func() {
-			artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"name": "The Beatles"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(artists).ToNot(BeEmpty())
-			beatlesID := artists[0].ID
-
-			r := newReq("getArtistInfo2", "id", beatlesID)
-			resp, err := router.GetArtistInfo2(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.ArtistInfo2).ToNot(BeNil())
-		})
-	})
-
-	Describe("getTopSongs", func() {
-		It("returns a response for a known artist name", func() {
-			r := newReq("getTopSongs", "artist", "The Beatles")
-			resp, err := router.GetTopSongs(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.TopSongs).ToNot(BeNil())
-			// noopProvider returns empty list, so Songs may be empty
-		})
-
-		It("returns an empty list for an unknown artist", func() {
-			r := newReq("getTopSongs", "artist", "Unknown Artist")
-			resp, err := router.GetTopSongs(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.TopSongs).ToNot(BeNil())
-			Expect(resp.TopSongs.Song).To(BeEmpty())
-		})
-	})
-
-	Describe("getSimilarSongs", func() {
-		It("returns a response for a valid song ID", func() {
-			songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"title": "Come Together"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).ToNot(BeEmpty())
-			songID := songs[0].ID
-
-			r := newReq("getSimilarSongs", "id", songID)
-			resp, err := router.GetSimilarSongs(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.SimilarSongs).ToNot(BeNil())
-			// noopProvider returns empty list
-		})
-	})
-
-	Describe("getSimilarSongs2", func() {
-		It("returns a response for a valid song ID", func() {
-			songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"title": "Come Together"},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).ToNot(BeEmpty())
-			songID := songs[0].ID
-
-			r := newReq("getSimilarSongs2", "id", songID)
-			resp, err := router.GetSimilarSongs2(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.SimilarSongs2).ToNot(BeNil())
-			// noopProvider returns empty list
-		})
-	})
-})

server/e2e/subsonic_media_annotation_test.go

@@ -1,186 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Media Annotation Endpoints", Ordered, func() {
-	BeforeAll(func() {
-		setupTestDB()
-	})
-
-	Describe("Star/Unstar", Ordered, func() {
-		var songID, albumID, artistID string
-
-		BeforeAll(func() {
-			// Look up a song from the scanned data
-			songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Max: 1, Sort: "title"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).ToNot(BeEmpty())
-			songID = songs[0].ID
-
-			// Look up an album
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{Max: 1, Sort: "name"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-			albumID = albums[0].ID
-
-			// Look up an artist
-			artists, err := ds.Artist(ctx).GetAll(model.QueryOptions{Max: 1, Sort: "name"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(artists).ToNot(BeEmpty())
-			artistID = artists[0].ID
-		})
-
-		It("stars a song by id", func() {
-			r := newReq("star", "id", songID)
-			resp, err := router.Star(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-		})
-
-		It("starred song appears in getStarred response", func() {
-			r := newReq("getStarred")
-			resp, err := router.GetStarred(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Starred).ToNot(BeNil())
-			Expect(resp.Starred.Song).To(HaveLen(1))
-			Expect(resp.Starred.Song[0].Id).To(Equal(songID))
-		})
-
-		It("unstars a previously starred song", func() {
-			r := newReq("unstar", "id", songID)
-			resp, err := router.Unstar(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-
-			// Verify song no longer appears in starred
-			r = newReq("getStarred")
-			resp, err = router.GetStarred(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Starred.Song).To(BeEmpty())
-		})
-
-		It("stars an album by albumId", func() {
-			r := newReq("star", "albumId", albumID)
-			resp, err := router.Star(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-
-			// Verify album appears in starred
-			r = newReq("getStarred")
-			resp, err = router.GetStarred(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Starred.Album).To(HaveLen(1))
-			Expect(resp.Starred.Album[0].Id).To(Equal(albumID))
-		})
-
-		It("stars an artist by artistId", func() {
-			r := newReq("star", "artistId", artistID)
-			resp, err := router.Star(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-
-			// Verify artist appears in starred
-			r = newReq("getStarred")
-			resp, err = router.GetStarred(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Starred.Artist).To(HaveLen(1))
-			Expect(resp.Starred.Artist[0].Id).To(Equal(artistID))
-		})
-
-		It("returns error when no id provided", func() {
-			r := newReq("star")
-			_, err := router.Star(r)
-
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Describe("SetRating", Ordered, func() {
-		var songID, albumID string
-
-		BeforeAll(func() {
-			songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Max: 1, Sort: "title"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).ToNot(BeEmpty())
-			songID = songs[0].ID
-
-			albums, err := ds.Album(ctx).GetAll(model.QueryOptions{Max: 1, Sort: "name"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(albums).ToNot(BeEmpty())
-			albumID = albums[0].ID
-		})
-
-		It("sets rating on a song", func() {
-			r := newReq("setRating", "id", songID, "rating", "4")
-			resp, err := router.SetRating(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-		})
-
-		It("rated song has correct userRating in getSong", func() {
-			r := newReq("getSong", "id", songID)
-			resp, err := router.GetSong(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Song).ToNot(BeNil())
-			Expect(resp.Song.UserRating).To(Equal(int32(4)))
-		})
-
-		It("sets rating on an album", func() {
-			r := newReq("setRating", "id", albumID, "rating", "3")
-			resp, err := router.SetRating(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-		})
-
-		It("returns error for missing parameters", func() {
-			// Missing both id and rating
-			r := newReq("setRating")
-			_, err := router.SetRating(r)
-			Expect(err).To(HaveOccurred())
-
-			// Missing rating
-			r = newReq("setRating", "id", songID)
-			_, err = router.SetRating(r)
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Describe("Scrobble", func() {
-		It("submits a scrobble for a song", func() {
-			songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Max: 1, Sort: "title"})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(songs).ToNot(BeEmpty())
-
-			r := newReq("scrobble", "id", songs[0].ID, "submission", "true")
-			resp, err := router.Scrobble(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-		})
-
-		It("returns error when id is missing", func() {
-			r := newReq("scrobble")
-			_, err := router.Scrobble(r)
-
-			Expect(err).To(HaveOccurred())
-		})
-	})
-})

server/e2e/subsonic_media_retrieval_test.go

@@ -1,79 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Media Retrieval Endpoints", Ordered, func() {
-	BeforeAll(func() {
-		setupTestDB()
-	})
-
-	Describe("Stream", func() {
-		It("returns error when id parameter is missing", func() {
-			w, r := newRawReq("stream")
-			_, err := router.Stream(w, r)
-
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Describe("Download", func() {
-		It("returns error when id parameter is missing", func() {
-			w, r := newRawReq("download")
-			_, err := router.Download(w, r)
-
-			Expect(err).To(HaveOccurred())
-		})
-	})
-
-	Describe("GetCoverArt", func() {
-		It("handles request without error", func() {
-			w, r := newRawReq("getCoverArt")
-			_, err := router.GetCoverArt(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-		})
-	})
-
-	Describe("GetAvatar", func() {
-		It("returns placeholder avatar when gravatar disabled", func() {
-			w, r := newRawReq("getAvatar", "username", "admin")
-			resp, err := router.GetAvatar(w, r)
-
-			// When gravatar is disabled, it returns nil response (writes directly to w)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp).To(BeNil())
-		})
-	})
-
-	Describe("GetLyrics", func() {
-		It("returns empty lyrics when no match found", func() {
-			r := newReq("getLyrics", "artist", "NonExistentArtist", "title", "NonExistentTitle")
-			resp, err := router.GetLyrics(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Lyrics).ToNot(BeNil())
-			Expect(resp.Lyrics.Value).To(BeEmpty())
-		})
-	})
-
-	Describe("GetLyricsBySongId", func() {
-		It("returns error when id parameter is missing", func() {
-			r := newReq("getLyricsBySongId")
-			_, err := router.GetLyricsBySongId(r)
-
-			Expect(err).To(HaveOccurred())
-		})
-
-		It("returns error for non-existent song id", func() {
-			r := newReq("getLyricsBySongId", "id", "non-existent-id")
-			_, err := router.GetLyricsBySongId(r)
-
-			Expect(err).To(HaveOccurred())
-		})
-	})
-})

server/e2e/subsonic_multilibrary_test.go

@@ -1,312 +0,0 @@
-package e2e
-
-import (
-	"fmt"
-	"testing/fstest"
-
-	"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/storage/storagetest"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/scanner"
-	"github.com/navidrome/navidrome/server/events"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Multi-Library Support", Ordered, func() {
-	var lib2 model.Library
-	var adminWithLibs model.User // admin reloaded with both libraries
-	var userLib1Only model.User  // non-admin with lib1 access only
-
-	BeforeAll(func() {
-		setupTestDB()
-
-		// Create a second FakeFS with Classical music content
-		classical := template(_t{
-			"albumartist": "Ludwig van Beethoven",
-			"artist":      "Ludwig van Beethoven",
-			"album":       "Symphony No. 9",
-			"year":        1824,
-			"genre":       "Classical",
-		})
-		classicalFS := storagetest.FakeFS{}
-		classicalFS.SetFiles(fstest.MapFS{
-			"Classical/Beethoven/Symphony No. 9/01 - Allegro ma non troppo.mp3": classical(track(1, "Allegro ma non troppo")),
-			"Classical/Beethoven/Symphony No. 9/02 - Ode to Joy.mp3":            classical(track(2, "Ode to Joy")),
-		})
-		storagetest.Register("fake2", &classicalFS)
-
-		// Create the second library in the DB (Put auto-assigns admin users)
-		lib2 = model.Library{ID: 2, Name: "Classical Library", Path: "fake2:///classical"}
-		Expect(ds.Library(ctx).Put(&lib2)).To(Succeed())
-
-		// Reload admin user to get both libraries in the Libraries field
-		loadedAdmin, err := ds.User(ctx).FindByUsername(adminUser.UserName)
-		Expect(err).ToNot(HaveOccurred())
-		adminWithLibs = *loadedAdmin
-
-		// Run incremental scan to import lib2 content (lib1 files unchanged → skipped)
-		s := scanner.New(ctx, ds, artwork.NoopCacheWarmer(), events.NoopBroker(),
-			core.NewPlaylists(ds), metrics.NewNoopInstance())
-		_, err = s.ScanAll(ctx, false)
-		Expect(err).ToNot(HaveOccurred())
-
-		// Create a non-admin user with access only to lib1
-		userLib1Only = model.User{
-			ID:          "multilib-user-1",
-			UserName:    "lib1user",
-			Name:        "Lib1 User",
-			IsAdmin:     false,
-			NewPassword: "password",
-		}
-		Expect(ds.User(ctx).Put(&userLib1Only)).To(Succeed())
-		Expect(ds.User(ctx).SetUserLibraries(userLib1Only.ID, []int{lib.ID})).To(Succeed())
-
-		loadedUser, err := ds.User(ctx).FindByUsername(userLib1Only.UserName)
-		Expect(err).ToNot(HaveOccurred())
-		userLib1Only.Libraries = loadedUser.Libraries
-	})
-
-	Describe("getMusicFolders", func() {
-		It("returns both libraries for admin user", func() {
-			r := newReqWithUser(adminWithLibs, "getMusicFolders")
-			resp, err := router.GetMusicFolders(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.MusicFolders.Folders).To(HaveLen(2))
-
-			names := make([]string, len(resp.MusicFolders.Folders))
-			for i, f := range resp.MusicFolders.Folders {
-				names[i] = f.Name
-			}
-			Expect(names).To(ConsistOf("Music Library", "Classical Library"))
-		})
-	})
-
-	Describe("getArtists - library filtering", func() {
-		It("returns only lib1 artists when musicFolderId=1", func() {
-			r := newReqWithUser(adminWithLibs, "getArtists", "musicFolderId", fmt.Sprintf("%d", lib.ID))
-			resp, err := router.GetArtists(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Artist).ToNot(BeNil())
-
-			var artistNames []string
-			for _, idx := range resp.Artist.Index {
-				for _, a := range idx.Artists {
-					artistNames = append(artistNames, a.Name)
-				}
-			}
-			Expect(artistNames).To(ContainElements("The Beatles", "Led Zeppelin", "Miles Davis"))
-			Expect(artistNames).ToNot(ContainElement("Ludwig van Beethoven"))
-		})
-
-		It("returns only lib2 artists when musicFolderId=2", func() {
-			r := newReqWithUser(adminWithLibs, "getArtists", "musicFolderId", fmt.Sprintf("%d", lib2.ID))
-			resp, err := router.GetArtists(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Artist).ToNot(BeNil())
-
-			var artistNames []string
-			for _, idx := range resp.Artist.Index {
-				for _, a := range idx.Artists {
-					artistNames = append(artistNames, a.Name)
-				}
-			}
-			Expect(artistNames).To(ContainElement("Ludwig van Beethoven"))
-			Expect(artistNames).ToNot(ContainElements("The Beatles", "Led Zeppelin", "Miles Davis"))
-		})
-
-		It("returns artists from all libraries when no musicFolderId is specified", func() {
-			r := newReqWithUser(adminWithLibs, "getArtists")
-			resp, err := router.GetArtists(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-
-			var artistNames []string
-			for _, idx := range resp.Artist.Index {
-				for _, a := range idx.Artists {
-					artistNames = append(artistNames, a.Name)
-				}
-			}
-			Expect(artistNames).To(ContainElements("The Beatles", "Led Zeppelin", "Miles Davis", "Ludwig van Beethoven"))
-		})
-	})
-
-	Describe("getAlbumList - library filtering", func() {
-		It("returns only lib1 albums when musicFolderId=1", func() {
-			w, r := newRawReqWithUser(adminWithLibs, "getAlbumList", "type", "alphabeticalByName", "musicFolderId", fmt.Sprintf("%d", lib.ID))
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(HaveLen(5))
-			for _, a := range resp.AlbumList.Album {
-				Expect(a.Title).ToNot(Equal("Symphony No. 9"))
-			}
-		})
-
-		It("returns only lib2 albums when musicFolderId=2", func() {
-			w, r := newRawReqWithUser(adminWithLibs, "getAlbumList", "type", "alphabeticalByName", "musicFolderId", fmt.Sprintf("%d", lib2.ID))
-			resp, err := router.GetAlbumList(w, r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.AlbumList).ToNot(BeNil())
-			Expect(resp.AlbumList.Album).To(HaveLen(1))
-			Expect(resp.AlbumList.Album[0].Title).To(Equal("Symphony No. 9"))
-		})
-	})
-
-	Describe("search3 - library filtering", func() {
-		It("does not find lib1 content when searching in lib2 only", func() {
-			r := newReqWithUser(adminWithLibs, "search3", "query", "Beatles", "musicFolderId", fmt.Sprintf("%d", lib2.ID))
-			resp, err := router.Search3(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.SearchResult3).ToNot(BeNil())
-			Expect(resp.SearchResult3.Artist).To(BeEmpty())
-			Expect(resp.SearchResult3.Album).To(BeEmpty())
-			Expect(resp.SearchResult3.Song).To(BeEmpty())
-		})
-
-		It("finds lib2 content when searching in lib2", func() {
-			r := newReqWithUser(adminWithLibs, "search3", "query", "Beethoven", "musicFolderId", fmt.Sprintf("%d", lib2.ID))
-			resp, err := router.Search3(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.SearchResult3).ToNot(BeNil())
-			Expect(resp.SearchResult3.Artist).ToNot(BeEmpty())
-			Expect(resp.SearchResult3.Artist[0].Name).To(Equal("Ludwig van Beethoven"))
-		})
-	})
-
-	Describe("Cross-library playlists", Ordered, func() {
-		var playlistID string
-		var lib1SongID, lib2SongID string
-
-		BeforeAll(func() {
-			// Look up one song from each library
-			lib1Songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"media_file.library_id": lib.ID},
-				Max:     1, Sort: "title",
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(lib1Songs).ToNot(BeEmpty())
-			lib1SongID = lib1Songs[0].ID
-
-			lib2Songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"media_file.library_id": lib2.ID},
-				Max:     1, Sort: "title",
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(lib2Songs).ToNot(BeEmpty())
-			lib2SongID = lib2Songs[0].ID
-		})
-
-		It("admin creates a playlist with songs from both libraries", func() {
-			r := newReqWithUser(adminWithLibs, "createPlaylist",
-				"name", "Cross-Library Playlist", "songId", lib1SongID, "songId", lib2SongID)
-			resp, err := router.CreatePlaylist(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Playlist).ToNot(BeNil())
-			Expect(resp.Playlist.SongCount).To(Equal(int32(2)))
-			Expect(resp.Playlist.Entry).To(HaveLen(2))
-			playlistID = resp.Playlist.Id
-		})
-
-		It("admin makes the playlist public", func() {
-			r := newReqWithUser(adminWithLibs, "updatePlaylist",
-				"playlistId", playlistID, "public", "true")
-			resp, err := router.UpdatePlaylist(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-		})
-
-		It("non-admin user with lib1 only sees only lib1 tracks in the playlist", func() {
-			// Reset the cached playlist repo so it's recreated with the non-admin user's context.
-			// The MockDataStore caches repos on first access; resetting forces a new repo
-			// whose applyLibraryFilter uses the non-admin user's library access.
-			ds.MockedPlaylist = nil
-
-			r := newReqWithUser(userLib1Only, "getPlaylist", "id", playlistID)
-			resp, err := router.GetPlaylist(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Playlist).ToNot(BeNil())
-			// The playlist has 2 songs total, but the non-admin user only has access to lib1
-			Expect(resp.Playlist.Entry).To(HaveLen(1))
-			Expect(resp.Playlist.Entry[0].Id).To(Equal(lib1SongID))
-		})
-	})
-
-	Describe("Cross-library shares", Ordered, func() {
-		var lib2AlbumID string
-
-		BeforeAll(func() {
-			conf.Server.EnableSharing = true
-
-			lib2Albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-				Filters: squirrel.Eq{"album.library_id": lib2.ID},
-			})
-			Expect(err).ToNot(HaveOccurred())
-			Expect(lib2Albums).ToNot(BeEmpty())
-			lib2AlbumID = lib2Albums[0].ID
-		})
-
-		It("admin creates a share for a lib2 album", func() {
-			r := newReqWithUser(adminWithLibs, "createShare",
-				"id", lib2AlbumID, "description", "Classical album share")
-			resp, err := router.CreateShare(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Shares).ToNot(BeNil())
-			Expect(resp.Shares.Share).To(HaveLen(1))
-
-			share := resp.Shares.Share[0]
-			Expect(share.Description).To(Equal("Classical album share"))
-			Expect(share.Entry).ToNot(BeEmpty())
-			Expect(share.Entry[0].Title).To(Equal("Symphony No. 9"))
-		})
-	})
-
-	Describe("Library access control", func() {
-		It("returns error when non-admin user requests inaccessible library", func() {
-			r := newReqWithUser(userLib1Only, "getArtists", "musicFolderId", fmt.Sprintf("%d", lib2.ID))
-			_, err := router.GetArtists(r)
-
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("not found"))
-		})
-
-		It("non-admin user sees only their library's content without musicFolderId", func() {
-			r := newReqWithUser(userLib1Only, "getArtists")
-			resp, err := router.GetArtists(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-
-			var artistNames []string
-			for _, idx := range resp.Artist.Index {
-				for _, a := range idx.Artists {
-					artistNames = append(artistNames, a.Name)
-				}
-			}
-			Expect(artistNames).To(ContainElements("The Beatles", "Led Zeppelin", "Miles Davis"))
-			Expect(artistNames).ToNot(ContainElement("Ludwig van Beethoven"))
-		})
-	})
-})

server/e2e/subsonic_multiuser_test.go

@@ -1,97 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Multi-User Isolation", Ordered, func() {
-	var regularUser model.User
-
-	BeforeAll(func() {
-		setupTestDB()
-
-		// Create a regular (non-admin) user
-		regularUser = model.User{
-			ID:          "regular-1",
-			UserName:    "regular",
-			Name:        "Regular User",
-			IsAdmin:     false,
-			NewPassword: "password",
-		}
-		Expect(ds.User(ctx).Put(&regularUser)).To(Succeed())
-		Expect(ds.User(ctx).SetUserLibraries(regularUser.ID, []int{lib.ID})).To(Succeed())
-
-		loadedUser, err := ds.User(ctx).FindByUsername(regularUser.UserName)
-		Expect(err).ToNot(HaveOccurred())
-		regularUser.Libraries = loadedUser.Libraries
-	})
-
-	Describe("Admin-only endpoint restrictions", func() {
-		It("startScan fails for regular user", func() {
-			r := newReqWithUser(regularUser, "startScan")
-			_, err := router.StartScan(r)
-
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("not authorized"))
-		})
-	})
-
-	Describe("Browsing as regular user", func() {
-		It("regular user can browse the library", func() {
-			r := newReqWithUser(regularUser, "getArtists")
-			resp, err := router.GetArtists(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Artist).ToNot(BeNil())
-			Expect(resp.Artist.Index).ToNot(BeEmpty())
-		})
-
-		It("regular user can search", func() {
-			r := newReqWithUser(regularUser, "search3", "query", "Beatles")
-			resp, err := router.Search3(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.SearchResult3).ToNot(BeNil())
-			Expect(resp.SearchResult3.Artist).ToNot(BeEmpty())
-		})
-	})
-
-	Describe("getUser authorization", func() {
-		It("regular user can get their own info", func() {
-			r := newReqWithUser(regularUser, "getUser", "username", "regular")
-			resp, err := router.GetUser(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.User.Username).To(Equal("regular"))
-			Expect(resp.User.AdminRole).To(BeFalse())
-		})
-
-		It("regular user cannot get another user's info", func() {
-			r := newReqWithUser(regularUser, "getUser", "username", "admin")
-			_, err := router.GetUser(r)
-
-			Expect(err).To(HaveOccurred())
-			Expect(err.Error()).To(ContainSubstring("not authorized"))
-		})
-	})
-
-	Describe("getUsers for regular user", func() {
-		It("returns only the requesting user's info", func() {
-			r := newReqWithUser(regularUser, "getUsers")
-			resp, err := router.GetUsers(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.Users).ToNot(BeNil())
-			Expect(resp.Users.User).To(HaveLen(1))
-			Expect(resp.Users.User[0].Username).To(Equal("regular"))
-			Expect(resp.Users.User[0].AdminRole).To(BeFalse())
-		})
-	})
-})

server/e2e/subsonic_playlists_test.go

@@ -1,130 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Playlist Endpoints", Ordered, func() {
-	var playlistID string
-	var songIDs []string
-
-	BeforeAll(func() {
-		setupTestDB()
-
-		// Look up song IDs from scanned data for playlist operations
-		songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{Sort: "title", Max: 3})
-		Expect(err).ToNot(HaveOccurred())
-		Expect(len(songs)).To(BeNumerically(">=", 3))
-		for _, s := range songs {
-			songIDs = append(songIDs, s.ID)
-		}
-	})
-
-	It("getPlaylists returns empty list initially", func() {
-		r := newReq("getPlaylists")
-		resp, err := router.GetPlaylists(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Playlists).ToNot(BeNil())
-		Expect(resp.Playlists.Playlist).To(BeEmpty())
-	})
-
-	It("createPlaylist creates a new playlist with songs", func() {
-		r := newReq("createPlaylist", "name", "Test Playlist", "songId", songIDs[0], "songId", songIDs[1])
-		resp, err := router.CreatePlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Playlist).ToNot(BeNil())
-		Expect(resp.Playlist.Name).To(Equal("Test Playlist"))
-		Expect(resp.Playlist.SongCount).To(Equal(int32(2)))
-		playlistID = resp.Playlist.Id
-	})
-
-	It("getPlaylist returns playlist with tracks", func() {
-		r := newReq("getPlaylist", "id", playlistID)
-		resp, err := router.GetPlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Playlist).ToNot(BeNil())
-		Expect(resp.Playlist.Name).To(Equal("Test Playlist"))
-		Expect(resp.Playlist.Entry).To(HaveLen(2))
-		Expect(resp.Playlist.Entry[0].Id).To(Equal(songIDs[0]))
-		Expect(resp.Playlist.Entry[1].Id).To(Equal(songIDs[1]))
-	})
-
-	It("createPlaylist without name or playlistId returns error", func() {
-		r := newReq("createPlaylist", "songId", songIDs[0])
-		_, err := router.CreatePlaylist(r)
-
-		Expect(err).To(HaveOccurred())
-	})
-
-	It("updatePlaylist can rename the playlist", func() {
-		r := newReq("updatePlaylist", "playlistId", playlistID, "name", "Renamed Playlist")
-		resp, err := router.UpdatePlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-
-		// Verify the rename
-		r = newReq("getPlaylist", "id", playlistID)
-		resp, err = router.GetPlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Playlist.Name).To(Equal("Renamed Playlist"))
-	})
-
-	It("updatePlaylist can add songs", func() {
-		r := newReq("updatePlaylist", "playlistId", playlistID, "songIdToAdd", songIDs[2])
-		resp, err := router.UpdatePlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-
-		// Verify the song was added
-		r = newReq("getPlaylist", "id", playlistID)
-		resp, err = router.GetPlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Playlist.SongCount).To(Equal(int32(3)))
-		Expect(resp.Playlist.Entry).To(HaveLen(3))
-	})
-
-	It("updatePlaylist can remove songs by index", func() {
-		// Remove the first song (index 0)
-		r := newReq("updatePlaylist", "playlistId", playlistID, "songIndexToRemove", "0")
-		resp, err := router.UpdatePlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-
-		// Verify the song was removed
-		r = newReq("getPlaylist", "id", playlistID)
-		resp, err = router.GetPlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Playlist.SongCount).To(Equal(int32(2)))
-		Expect(resp.Playlist.Entry).To(HaveLen(2))
-	})
-
-	It("deletePlaylist removes the playlist", func() {
-		r := newReq("deletePlaylist", "id", playlistID)
-		resp, err := router.DeletePlaylist(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-	})
-
-	It("getPlaylist on deleted playlist returns error", func() {
-		r := newReq("getPlaylist", "id", playlistID)
-		_, err := router.GetPlaylist(r)
-
-		Expect(err).To(HaveOccurred())
-	})
-})

server/e2e/subsonic_radio_test.go

@@ -1,94 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Internet Radio Endpoints", Ordered, func() {
-	var radioID string
-
-	BeforeAll(func() {
-		setupTestDB()
-	})
-
-	It("getInternetRadioStations returns empty initially", func() {
-		r := newReq("getInternetRadioStations")
-		resp, err := router.GetInternetRadios(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.InternetRadioStations).ToNot(BeNil())
-		Expect(resp.InternetRadioStations.Radios).To(BeEmpty())
-	})
-
-	It("createInternetRadioStation adds a station", func() {
-		r := newReq("createInternetRadioStation",
-			"streamUrl", "https://stream.example.com/radio",
-			"name", "Test Radio",
-			"homepageUrl", "https://example.com",
-		)
-		resp, err := router.CreateInternetRadio(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-	})
-
-	It("getInternetRadioStations returns the created station", func() {
-		r := newReq("getInternetRadioStations")
-		resp, err := router.GetInternetRadios(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.InternetRadioStations).ToNot(BeNil())
-		Expect(resp.InternetRadioStations.Radios).To(HaveLen(1))
-
-		radio := resp.InternetRadioStations.Radios[0]
-		Expect(radio.Name).To(Equal("Test Radio"))
-		Expect(radio.StreamUrl).To(Equal("https://stream.example.com/radio"))
-		Expect(radio.HomepageUrl).To(Equal("https://example.com"))
-		radioID = radio.ID
-		Expect(radioID).ToNot(BeEmpty())
-	})
-
-	It("updateInternetRadioStation modifies the station", func() {
-		r := newReq("updateInternetRadioStation",
-			"id", radioID,
-			"streamUrl", "https://stream.example.com/radio-v2",
-			"name", "Updated Radio",
-			"homepageUrl", "https://updated.example.com",
-		)
-		resp, err := router.UpdateInternetRadio(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-
-		// Verify update
-		r = newReq("getInternetRadioStations")
-		resp, err = router.GetInternetRadios(r)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.InternetRadioStations.Radios).To(HaveLen(1))
-		Expect(resp.InternetRadioStations.Radios[0].Name).To(Equal("Updated Radio"))
-		Expect(resp.InternetRadioStations.Radios[0].StreamUrl).To(Equal("https://stream.example.com/radio-v2"))
-		Expect(resp.InternetRadioStations.Radios[0].HomepageUrl).To(Equal("https://updated.example.com"))
-	})
-
-	It("deleteInternetRadioStation removes it", func() {
-		r := newReq("deleteInternetRadioStation", "id", radioID)
-		resp, err := router.DeleteInternetRadio(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-	})
-
-	It("getInternetRadioStations returns empty after deletion", func() {
-		r := newReq("getInternetRadioStations")
-		resp, err := router.GetInternetRadios(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.InternetRadioStations).ToNot(BeNil())
-		Expect(resp.InternetRadioStations.Radios).To(BeEmpty())
-	})
-})

server/e2e/subsonic_scan_test.go

@@ -1,60 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Scan Endpoints", func() {
-	BeforeEach(func() {
-		setupTestDB()
-	})
-
-	It("getScanStatus returns status", func() {
-		r := newReq("getScanStatus")
-		resp, err := router.GetScanStatus(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.ScanStatus).ToNot(BeNil())
-		Expect(resp.ScanStatus.Scanning).To(BeFalse())
-		Expect(resp.ScanStatus.Count).To(BeNumerically(">", 0))
-		Expect(resp.ScanStatus.LastScan).ToNot(BeNil())
-	})
-
-	It("startScan requires admin user", func() {
-		regularUser := model.User{
-			ID:       "user-2",
-			UserName: "regular",
-			Name:     "Regular User",
-			IsAdmin:  false,
-		}
-		// Store the regular user in the database
-		regularUserWithPass := regularUser
-		regularUserWithPass.NewPassword = "password"
-		Expect(ds.User(ctx).Put(&regularUserWithPass)).To(Succeed())
-		Expect(ds.User(ctx).SetUserLibraries(regularUser.ID, []int{lib.ID})).To(Succeed())
-
-		// Reload user with libraries
-		loadedUser, err := ds.User(ctx).FindByUsername(regularUser.UserName)
-		Expect(err).ToNot(HaveOccurred())
-		regularUser.Libraries = loadedUser.Libraries
-
-		r := newReqWithUser(regularUser, "startScan")
-		_, err = router.StartScan(r)
-
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring("not authorized"))
-	})
-
-	It("startScan returns scan status response", func() {
-		r := newReq("startScan")
-		resp, err := router.StartScan(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.ScanStatus).ToNot(BeNil())
-	})
-})

server/e2e/subsonic_searching_test.go

@@ -1,158 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Search Endpoints", func() {
-	BeforeEach(func() {
-		setupTestDB()
-	})
-
-	Describe("Search2", func() {
-		It("finds artists by name", func() {
-			r := newReq("search2", "query", "Beatles")
-			resp, err := router.Search2(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.SearchResult2).ToNot(BeNil())
-			Expect(resp.SearchResult2.Artist).ToNot(BeEmpty())
-
-			found := false
-			for _, a := range resp.SearchResult2.Artist {
-				if a.Name == "The Beatles" {
-					found = true
-					break
-				}
-			}
-			Expect(found).To(BeTrue(), "expected to find artist 'The Beatles'")
-		})
-
-		It("finds albums by name", func() {
-			r := newReq("search2", "query", "Abbey Road")
-			resp, err := router.Search2(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.SearchResult2).ToNot(BeNil())
-			Expect(resp.SearchResult2.Album).ToNot(BeEmpty())
-
-			found := false
-			for _, a := range resp.SearchResult2.Album {
-				if a.Title == "Abbey Road" {
-					found = true
-					break
-				}
-			}
-			Expect(found).To(BeTrue(), "expected to find album 'Abbey Road'")
-		})
-
-		It("finds songs by title", func() {
-			r := newReq("search2", "query", "Come Together")
-			resp, err := router.Search2(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.SearchResult2).ToNot(BeNil())
-			Expect(resp.SearchResult2.Song).ToNot(BeEmpty())
-
-			found := false
-			for _, s := range resp.SearchResult2.Song {
-				if s.Title == "Come Together" {
-					found = true
-					break
-				}
-			}
-			Expect(found).To(BeTrue(), "expected to find song 'Come Together'")
-		})
-
-		It("respects artistCount/albumCount/songCount limits", func() {
-			r := newReq("search2", "query", "Beatles",
-				"artistCount", "1", "albumCount", "1", "songCount", "1")
-			resp, err := router.Search2(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.SearchResult2).ToNot(BeNil())
-			Expect(len(resp.SearchResult2.Artist)).To(BeNumerically("<=", 1))
-			Expect(len(resp.SearchResult2.Album)).To(BeNumerically("<=", 1))
-			Expect(len(resp.SearchResult2.Song)).To(BeNumerically("<=", 1))
-		})
-
-		It("supports offset parameters", func() {
-			// First get all results for Beatles
-			r1 := newReq("search2", "query", "Beatles", "songCount", "500")
-			resp1, err := router.Search2(r1)
-			Expect(err).ToNot(HaveOccurred())
-			allSongs := resp1.SearchResult2.Song
-
-			if len(allSongs) > 1 {
-				// Get with offset to skip the first song
-				r2 := newReq("search2", "query", "Beatles", "songOffset", "1", "songCount", "500")
-				resp2, err := router.Search2(r2)
-
-				Expect(err).ToNot(HaveOccurred())
-				Expect(resp2.SearchResult2).ToNot(BeNil())
-				Expect(len(resp2.SearchResult2.Song)).To(Equal(len(allSongs) - 1))
-			}
-		})
-
-		It("returns empty results for non-matching query", func() {
-			r := newReq("search2", "query", "ZZZZNONEXISTENT99999")
-			resp, err := router.Search2(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.SearchResult2).ToNot(BeNil())
-			Expect(resp.SearchResult2.Artist).To(BeEmpty())
-			Expect(resp.SearchResult2.Album).To(BeEmpty())
-			Expect(resp.SearchResult2.Song).To(BeEmpty())
-		})
-	})
-
-	Describe("Search3", func() {
-		It("returns results in ID3 format", func() {
-			r := newReq("search3", "query", "Beatles")
-			resp, err := router.Search3(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.SearchResult3).ToNot(BeNil())
-			// Verify ID3 format: Artist should be ArtistID3 with Name and AlbumCount
-			Expect(resp.SearchResult3.Artist).ToNot(BeEmpty())
-			Expect(resp.SearchResult3.Artist[0].Name).ToNot(BeEmpty())
-			Expect(resp.SearchResult3.Artist[0].Id).ToNot(BeEmpty())
-		})
-
-		It("finds across all entity types simultaneously", func() {
-			// "Beatles" should match artist, albums, and songs by The Beatles
-			r := newReq("search3", "query", "Beatles")
-			resp, err := router.Search3(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.SearchResult3).ToNot(BeNil())
-
-			// Should find at least the artist "The Beatles"
-			artistFound := false
-			for _, a := range resp.SearchResult3.Artist {
-				if a.Name == "The Beatles" {
-					artistFound = true
-					break
-				}
-			}
-			Expect(artistFound).To(BeTrue(), "expected to find artist 'The Beatles'")
-
-			// Should find albums by The Beatles (albums contain "Beatles" in artist field)
-			// Albums are returned as AlbumID3 type
-			for _, a := range resp.SearchResult3.Album {
-				Expect(a.Id).ToNot(BeEmpty())
-				Expect(a.Name).ToNot(BeEmpty())
-			}
-
-			// Songs are returned as Child type
-			for _, s := range resp.SearchResult3.Song {
-				Expect(s.Id).ToNot(BeEmpty())
-				Expect(s.Title).ToNot(BeEmpty())
-			}
-		})
-	})
-})

server/e2e/subsonic_sharing_test.go

@@ -1,143 +0,0 @@
-package e2e
-
-import (
-	"github.com/Masterminds/squirrel"
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/model"
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Sharing Endpoints", Ordered, func() {
-	var shareID string
-	var albumID string
-	var songID string
-
-	BeforeAll(func() {
-		setupTestDB()
-		conf.Server.EnableSharing = true
-
-		albums, err := ds.Album(ctx).GetAll(model.QueryOptions{
-			Filters: squirrel.Eq{"album.name": "Abbey Road"},
-		})
-		Expect(err).ToNot(HaveOccurred())
-		Expect(albums).ToNot(BeEmpty())
-		albumID = albums[0].ID
-
-		songs, err := ds.MediaFile(ctx).GetAll(model.QueryOptions{
-			Filters: squirrel.Eq{"title": "Come Together"},
-		})
-		Expect(err).ToNot(HaveOccurred())
-		Expect(songs).ToNot(BeEmpty())
-		songID = songs[0].ID
-	})
-
-	It("getShares returns empty initially", func() {
-		r := newReq("getShares")
-		resp, err := router.GetShares(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Shares).ToNot(BeNil())
-		Expect(resp.Shares.Share).To(BeEmpty())
-	})
-
-	It("createShare creates a share for an album", func() {
-		r := newReq("createShare", "id", albumID, "description", "Check out this album")
-		resp, err := router.CreateShare(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Shares).ToNot(BeNil())
-		Expect(resp.Shares.Share).To(HaveLen(1))
-
-		share := resp.Shares.Share[0]
-		Expect(share.ID).ToNot(BeEmpty())
-		Expect(share.Description).To(Equal("Check out this album"))
-		Expect(share.Username).To(Equal(adminUser.UserName))
-		shareID = share.ID
-	})
-
-	It("getShares returns the created share", func() {
-		r := newReq("getShares")
-		resp, err := router.GetShares(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Shares).ToNot(BeNil())
-		Expect(resp.Shares.Share).To(HaveLen(1))
-
-		share := resp.Shares.Share[0]
-		Expect(share.ID).To(Equal(shareID))
-		Expect(share.Description).To(Equal("Check out this album"))
-		Expect(share.Username).To(Equal(adminUser.UserName))
-		Expect(share.Entry).ToNot(BeEmpty())
-	})
-
-	It("updateShare modifies the description", func() {
-		r := newReq("updateShare", "id", shareID, "description", "Updated description")
-		resp, err := router.UpdateShare(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-
-		// Verify update
-		r = newReq("getShares")
-		resp, err = router.GetShares(r)
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Shares.Share).To(HaveLen(1))
-		Expect(resp.Shares.Share[0].Description).To(Equal("Updated description"))
-	})
-
-	It("deleteShare removes it", func() {
-		r := newReq("deleteShare", "id", shareID)
-		resp, err := router.DeleteShare(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-	})
-
-	It("getShares returns empty after deletion", func() {
-		r := newReq("getShares")
-		resp, err := router.GetShares(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Shares).ToNot(BeNil())
-		Expect(resp.Shares.Share).To(BeEmpty())
-	})
-
-	It("createShare works with a song ID", func() {
-		r := newReq("createShare", "id", songID, "description", "Great song")
-		resp, err := router.CreateShare(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Shares).ToNot(BeNil())
-		Expect(resp.Shares.Share).To(HaveLen(1))
-		Expect(resp.Shares.Share[0].Description).To(Equal("Great song"))
-		Expect(resp.Shares.Share[0].Entry).To(HaveLen(1))
-	})
-
-	It("createShare returns error when id parameter is missing", func() {
-		r := newReq("createShare")
-		_, err := router.CreateShare(r)
-
-		Expect(err).To(HaveOccurred())
-	})
-
-	It("updateShare returns error when id parameter is missing", func() {
-		r := newReq("updateShare")
-		_, err := router.UpdateShare(r)
-
-		Expect(err).To(HaveOccurred())
-	})
-
-	It("deleteShare returns error when id parameter is missing", func() {
-		r := newReq("deleteShare")
-		_, err := router.DeleteShare(r)
-
-		Expect(err).To(HaveOccurred())
-	})
-})

server/e2e/subsonic_system_test.go

@@ -1,86 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("System Endpoints", func() {
-	BeforeEach(func() {
-		setupTestDB()
-	})
-
-	Describe("ping", func() {
-		It("returns a successful response", func() {
-			r := newReq("ping")
-			resp, err := router.Ping(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-		})
-	})
-
-	Describe("getLicense", func() {
-		It("returns a valid license", func() {
-			r := newReq("getLicense")
-			resp, err := router.GetLicense(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.License).ToNot(BeNil())
-			Expect(resp.License.Valid).To(BeTrue())
-		})
-	})
-
-	Describe("getOpenSubsonicExtensions", func() {
-		It("returns a list of supported extensions", func() {
-			r := newReq("getOpenSubsonicExtensions")
-			resp, err := router.GetOpenSubsonicExtensions(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			Expect(resp.Status).To(Equal(responses.StatusOK))
-			Expect(resp.OpenSubsonicExtensions).ToNot(BeNil())
-			Expect(*resp.OpenSubsonicExtensions).ToNot(BeEmpty())
-		})
-
-		It("includes the transcodeOffset extension", func() {
-			r := newReq("getOpenSubsonicExtensions")
-			resp, err := router.GetOpenSubsonicExtensions(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			extensions := *resp.OpenSubsonicExtensions
-			var names []string
-			for _, ext := range extensions {
-				names = append(names, ext.Name)
-			}
-			Expect(names).To(ContainElement("transcodeOffset"))
-		})
-
-		It("includes the formPost extension", func() {
-			r := newReq("getOpenSubsonicExtensions")
-			resp, err := router.GetOpenSubsonicExtensions(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			extensions := *resp.OpenSubsonicExtensions
-			var names []string
-			for _, ext := range extensions {
-				names = append(names, ext.Name)
-			}
-			Expect(names).To(ContainElement("formPost"))
-		})
-
-		It("includes the songLyrics extension", func() {
-			r := newReq("getOpenSubsonicExtensions")
-			resp, err := router.GetOpenSubsonicExtensions(r)
-
-			Expect(err).ToNot(HaveOccurred())
-			extensions := *resp.OpenSubsonicExtensions
-			var names []string
-			for _, ext := range extensions {
-				names = append(names, ext.Name)
-			}
-			Expect(names).To(ContainElement("songLyrics"))
-		})
-	})
-})

server/e2e/subsonic_users_test.go

@@ -1,56 +0,0 @@
-package e2e
-
-import (
-	"github.com/navidrome/navidrome/server/subsonic/responses"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("User Endpoints", func() {
-	BeforeEach(func() {
-		setupTestDB()
-	})
-
-	It("getUser returns current user info", func() {
-		r := newReq("getUser", "username", adminUser.UserName)
-		resp, err := router.GetUser(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.User).ToNot(BeNil())
-		Expect(resp.User.Username).To(Equal(adminUser.UserName))
-		Expect(resp.User.AdminRole).To(BeTrue())
-		Expect(resp.User.StreamRole).To(BeTrue())
-		Expect(resp.User.Folder).ToNot(BeEmpty())
-	})
-
-	It("getUser with matching username case-insensitive succeeds", func() {
-		r := newReq("getUser", "username", "Admin")
-		resp, err := router.GetUser(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.User).ToNot(BeNil())
-		Expect(resp.User.Username).To(Equal(adminUser.UserName))
-	})
-
-	It("getUser with different username returns authorization error", func() {
-		r := newReq("getUser", "username", "otheruser")
-		_, err := router.GetUser(r)
-
-		Expect(err).To(HaveOccurred())
-		Expect(err.Error()).To(ContainSubstring("not authorized"))
-	})
-
-	It("getUsers returns list with current user only", func() {
-		r := newReq("getUsers")
-		resp, err := router.GetUsers(r)
-
-		Expect(err).ToNot(HaveOccurred())
-		Expect(resp.Status).To(Equal(responses.StatusOK))
-		Expect(resp.Users).ToNot(BeNil())
-		Expect(resp.Users.User).To(HaveLen(1))
-		Expect(resp.Users.User[0].Username).To(Equal(adminUser.UserName))
-		Expect(resp.Users.User[0].AdminRole).To(BeTrue())
-	})
-})

server/public/handle_streams.go

@@ -8,6 +8,7 @@ import (
 	"strconv"
 
 	"github.com/lestrrat-go/jwx/v2/jwt"
+	"github.com/navidrome/navidrome/core"
 	"github.com/navidrome/navidrome/core/auth"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/utils/req"
@@ -24,7 +25,9 @@ func (pub *Router) handleStream(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	stream, err := pub.streamer.NewStream(ctx, info.id, info.format, info.bitrate, 0)
+	stream, err := pub.streamer.NewStream(ctx, core.StreamRequest{
+		ID: info.id, Format: info.format, BitRate: info.bitrate,
+	})
 	if err != nil {
 		log.Error(ctx, "Error starting shared stream", err)
 		http.Error(w, "invalid request", http.StatusInternalServerError)

server/subsonic/album_lists_test.go

@@ -27,7 +27,7 @@ var _ = Describe("Album Lists", func() {
 		ds = &tests.MockDataStore{}
 		auth.Init(ds)
 		mockRepo = ds.Album(ctx).(*tests.MockAlbumRepo)
-		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		w = httptest.NewRecorder()
 	})
 

server/subsonic/api.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"regexp"
 
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
@@ -16,6 +17,7 @@ import (
 	"github.com/navidrome/navidrome/core/metrics"
 	"github.com/navidrome/navidrome/core/playback"
 	"github.com/navidrome/navidrome/core/scrobbler"
+	"github.com/navidrome/navidrome/core/transcode"
 	"github.com/navidrome/navidrome/log"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/server"
@@ -26,45 +28,49 @@ import (
 
 const Version = "1.16.1"
 
+var validJSIdentifier = regexp.MustCompile(`^[a-zA-Z_$][a-zA-Z0-9_$.]*$`)
+
 type handler = func(*http.Request) (*responses.Subsonic, error)
 type handlerRaw = func(http.ResponseWriter, *http.Request) (*responses.Subsonic, error)
 
 type Router struct {
 	http.Handler
-	ds        model.DataStore
-	artwork   artwork.Artwork
-	streamer  core.MediaStreamer
-	archiver  core.Archiver
-	players   core.Players
-	provider  external.Provider
-	playlists core.Playlists
-	scanner   model.Scanner
-	broker    events.Broker
-	scrobbler scrobbler.PlayTracker
-	share     core.Share
-	playback  playback.PlaybackServer
-	metrics   metrics.Metrics
+	ds                model.DataStore
+	artwork           artwork.Artwork
+	streamer          core.MediaStreamer
+	archiver          core.Archiver
+	players           core.Players
+	provider          external.Provider
+	playlists         core.Playlists
+	scanner           model.Scanner
+	broker            events.Broker
+	scrobbler         scrobbler.PlayTracker
+	share             core.Share
+	playback          playback.PlaybackServer
+	metrics           metrics.Metrics
+	transcodeDecision transcode.Decider
 }
 
 func New(ds model.DataStore, artwork artwork.Artwork, streamer core.MediaStreamer, archiver core.Archiver,
 	players core.Players, provider external.Provider, scanner model.Scanner, broker events.Broker,
 	playlists core.Playlists, scrobbler scrobbler.PlayTracker, share core.Share, playback playback.PlaybackServer,
-	metrics metrics.Metrics,
+	metrics metrics.Metrics, transcodeDecision transcode.Decider,
 ) *Router {
 	r := &Router{
-		ds:        ds,
-		artwork:   artwork,
-		streamer:  streamer,
-		archiver:  archiver,
-		players:   players,
-		provider:  provider,
-		playlists: playlists,
-		scanner:   scanner,
-		broker:    broker,
-		scrobbler: scrobbler,
-		share:     share,
-		playback:  playback,
-		metrics:   metrics,
+		ds:                ds,
+		artwork:           artwork,
+		streamer:          streamer,
+		archiver:          archiver,
+		players:           players,
+		provider:          provider,
+		playlists:         playlists,
+		scanner:           scanner,
+		broker:            broker,
+		scrobbler:         scrobbler,
+		share:             share,
+		playback:          playback,
+		metrics:           metrics,
+		transcodeDecision: transcodeDecision,
 	}
 	r.Handler = r.routes()
 	return r
@@ -169,6 +175,8 @@ func (api *Router) routes() http.Handler {
 			h(r, "getLyricsBySongId", api.GetLyricsBySongId)
 			hr(r, "stream", api.Stream)
 			hr(r, "download", api.Download)
+			hr(r, "getTranscodeDecision", api.GetTranscodeDecision)
+			hr(r, "getTranscodeStream", api.GetTranscodeStream)
 		})
 		r.Group(func(r chi.Router) {
 			// configure request throttling
@@ -315,8 +323,17 @@ func sendResponse(w http.ResponseWriter, r *http.Request, payload *responses.Sub
 		wrapper := &responses.JsonWrapper{Subsonic: *payload}
 		response, err = json.Marshal(wrapper)
 	case "jsonp":
-		w.Header().Set("Content-Type", "application/javascript")
 		callback, _ := p.String("callback")
+		if !validJSIdentifier.MatchString(callback) {
+			log.Warn(r.Context(), "Invalid JSONP callback parameter", "callback", callback)
+			w.Header().Set("Content-Type", "application/json")
+			errResp := newResponse()
+			errResp.Status = responses.StatusFailed
+			errResp.Error = &responses.Error{Code: responses.ErrorGeneric, Message: "invalid callback parameter"}
+			response, _ = json.Marshal(responses.JsonWrapper{Subsonic: *errResp})
+			break
+		}
+		w.Header().Set("Content-Type", "application/javascript")
 		wrapper := &responses.JsonWrapper{Subsonic: *payload}
 		response, err = json.Marshal(wrapper)
 		response = fmt.Appendf(nil, "%s(%s)", callback, response)

server/subsonic/api_test.go

@@ -73,6 +73,49 @@ var _ = Describe("sendResponse", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(wrapper.Subsonic.Status).To(Equal(payload.Status))
 		})
+
+		It("should accept valid callback names with dots", func() {
+			q := r.URL.Query()
+			q.Add("f", "jsonp")
+			q.Add("callback", "jQuery.callback_123")
+			r.URL.RawQuery = q.Encode()
+
+			sendResponse(w, r, payload)
+
+			body := w.Body.String()
+			Expect(body).To(HavePrefix("jQuery.callback_123("))
+		})
+
+		It("should reject callback with invalid characters", func() {
+			q := r.URL.Query()
+			q.Add("f", "jsonp")
+			q.Add("callback", "alert(1)//")
+			r.URL.RawQuery = q.Encode()
+
+			sendResponse(w, r, payload)
+
+			Expect(w.Header().Get("Content-Type")).To(Equal("application/json"))
+			var wrapper responses.JsonWrapper
+			err := json.Unmarshal(w.Body.Bytes(), &wrapper)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(wrapper.Subsonic.Status).To(Equal(responses.StatusFailed))
+			Expect(wrapper.Subsonic.Error.Message).To(ContainSubstring("invalid callback parameter"))
+		})
+
+		It("should reject empty callback parameter", func() {
+			q := r.URL.Query()
+			q.Add("f", "jsonp")
+			q.Add("callback", "")
+			r.URL.RawQuery = q.Encode()
+
+			sendResponse(w, r, payload)
+
+			Expect(w.Header().Get("Content-Type")).To(Equal("application/json"))
+			var wrapper responses.JsonWrapper
+			err := json.Unmarshal(w.Body.Bytes(), &wrapper)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(wrapper.Subsonic.Status).To(Equal(responses.StatusFailed))
+		})
 	})
 
 	When("format is XML or unspecified", func() {

server/subsonic/media_annotation_test.go

@@ -27,7 +27,7 @@ var _ = Describe("MediaAnnotationController", func() {
 		ds = &tests.MockDataStore{}
 		playTracker = &fakePlayTracker{}
 		eventBroker = &fakeEventBroker{}
-		router = New(ds, nil, nil, nil, nil, nil, nil, eventBroker, nil, playTracker, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, eventBroker, nil, playTracker, nil, nil, nil, nil)
 	})
 
 	Describe("Scrobble", func() {

server/subsonic/media_retrieval_test.go

@@ -33,7 +33,7 @@ var _ = Describe("MediaRetrievalController", func() {
 			MockedMediaFile: mockRepo,
 		}
 		artwork = &fakeArtwork{data: "image data"}
-		router = New(ds, artwork, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = New(ds, artwork, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		w = httptest.NewRecorder()
 		DeferCleanup(configtest.SetupConfig())
 		conf.Server.LyricsPriority = "embedded,.lrc"

server/subsonic/opensubsonic.go

@@ -13,6 +13,7 @@ func (api *Router) GetOpenSubsonicExtensions(_ *http.Request) (*responses.Subson
 		{Name: "formPost", Versions: []int32{1}},
 		{Name: "songLyrics", Versions: []int32{1}},
 		{Name: "indexBasedQueue", Versions: []int32{1}},
+		{Name: "transcoding", Versions: []int32{1}},
 	}
 	return response, nil
 }

server/subsonic/opensubsonic_test.go

@@ -19,7 +19,7 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {
 	)
 
 	BeforeEach(func() {
-		router = subsonic.New(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = subsonic.New(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		w = httptest.NewRecorder()
 		r = httptest.NewRequest("GET", "/getOpenSubsonicExtensions?f=json", nil)
 	})
@@ -35,11 +35,12 @@ var _ = Describe("GetOpenSubsonicExtensions", func() {
 		err := json.Unmarshal(w.Body.Bytes(), &response)
 		Expect(err).NotTo(HaveOccurred())
 		Expect(*response.Subsonic.OpenSubsonicExtensions).To(SatisfyAll(
-			HaveLen(4),
+			HaveLen(5),
 			ContainElement(responses.OpenSubsonicExtension{Name: "transcodeOffset", Versions: []int32{1}}),
 			ContainElement(responses.OpenSubsonicExtension{Name: "formPost", Versions: []int32{1}}),
 			ContainElement(responses.OpenSubsonicExtension{Name: "songLyrics", Versions: []int32{1}}),
 			ContainElement(responses.OpenSubsonicExtension{Name: "indexBasedQueue", Versions: []int32{1}}),
+			ContainElement(responses.OpenSubsonicExtension{Name: "transcoding", Versions: []int32{1}}),
 		))
 	})
 })

server/subsonic/playlists_test.go

@@ -24,7 +24,7 @@ var _ = Describe("buildPlaylist", func() {
 
 	BeforeEach(func() {
 		ds = &tests.MockDataStore{}
-		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 		ctx = context.Background()
 	})
 
@@ -224,7 +224,7 @@ var _ = Describe("UpdatePlaylist", func() {
 	BeforeEach(func() {
 		ds = &tests.MockDataStore{}
 		playlists = &fakePlaylists{}
-		router = New(ds, nil, nil, nil, nil, nil, nil, nil, playlists, nil, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, playlists, nil, nil, nil, nil, nil)
 	})
 
 	It("clears the comment when parameter is empty", func() {

server/subsonic/responses/responses.go

@@ -61,6 +61,7 @@ type Subsonic struct {
 	OpenSubsonicExtensions *OpenSubsonicExtensions `xml:"openSubsonicExtensions,omitempty"  json:"openSubsonicExtensions,omitempty"`
 	LyricsList             *LyricsList             `xml:"lyricsList,omitempty"              json:"lyricsList,omitempty"`
 	PlayQueueByIndex       *PlayQueueByIndex       `xml:"playQueueByIndex,omitempty" json:"playQueueByIndex,omitempty"`
+	TranscodeDecision      *TranscodeDecision      `xml:"transcodeDecision,omitempty"       json:"transcodeDecision,omitempty"`
 }
 
 const (
@@ -617,3 +618,26 @@ func marshalJSONArray[T any](v []T) ([]byte, error) {
 	}
 	return json.Marshal(v)
 }
+
+// TranscodeDecision represents the response for getTranscodeDecision (OpenSubsonic transcoding extension)
+type TranscodeDecision struct {
+	CanDirectPlay    bool           `xml:"canDirectPlay,attr"               json:"canDirectPlay"`
+	CanTranscode     bool           `xml:"canTranscode,attr"                json:"canTranscode"`
+	TranscodeReasons []string       `xml:"transcodeReason,omitempty"        json:"transcodeReason,omitempty"`
+	ErrorReason      string         `xml:"errorReason,attr,omitempty"       json:"errorReason,omitempty"`
+	TranscodeParams  string         `xml:"transcodeParams,attr,omitempty"   json:"transcodeParams,omitempty"`
+	SourceStream     *StreamDetails `xml:"sourceStream,omitempty"           json:"sourceStream,omitempty"`
+	TranscodeStream  *StreamDetails `xml:"transcodeStream,omitempty"        json:"transcodeStream,omitempty"`
+}
+
+// StreamDetails describes audio stream properties for transcoding decisions
+type StreamDetails struct {
+	Protocol        string `xml:"protocol,attr,omitempty"        json:"protocol,omitempty"`
+	Container       string `xml:"container,attr,omitempty"       json:"container,omitempty"`
+	Codec           string `xml:"codec,attr,omitempty"           json:"codec,omitempty"`
+	AudioChannels   int32  `xml:"audioChannels,attr,omitempty"   json:"audioChannels,omitempty"`
+	AudioBitrate    int32  `xml:"audioBitrate,attr,omitempty"     json:"audioBitrate,omitempty"`
+	AudioProfile    string `xml:"audioProfile,attr,omitempty"    json:"audioProfile,omitempty"`
+	AudioSamplerate int32  `xml:"audioSamplerate,attr,omitempty" json:"audioSamplerate,omitempty"`
+	AudioBitdepth   int32  `xml:"audioBitdepth,attr,omitempty"   json:"audioBitdepth,omitempty"`
+}

server/subsonic/searching_test.go

@@ -21,7 +21,7 @@ var _ = Describe("Search", func() {
 		ds = &tests.MockDataStore{}
 		auth.Init(ds)
 
-		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
 
 		// Get references to the mock repositories so we can inspect their Options
 		mockAlbumRepo = ds.Album(nil).(*tests.MockAlbumRepo)

server/subsonic/stream.go

@@ -60,7 +60,9 @@ func (api *Router) Stream(w http.ResponseWriter, r *http.Request) (*responses.Su
 	format, _ := p.String("format")
 	timeOffset := p.IntOr("timeOffset", 0)
 
-	stream, err := api.streamer.NewStream(ctx, id, format, maxBitRate, timeOffset)
+	stream, err := api.streamer.NewStream(ctx, core.StreamRequest{
+		ID: id, Format: format, BitRate: maxBitRate, Offset: timeOffset,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -129,7 +131,9 @@ func (api *Router) Download(w http.ResponseWriter, r *http.Request) (*responses.
 
 	switch v := entity.(type) {
 	case *model.MediaFile:
-		stream, err := api.streamer.NewStream(ctx, id, format, maxBitRate, 0)
+		stream, err := api.streamer.NewStream(ctx, core.StreamRequest{
+			ID: id, Format: format, BitRate: maxBitRate,
+		})
 		if err != nil {
 			return nil, err
 		}

server/subsonic/transcode.go

@@ -0,0 +1,370 @@
+package subsonic
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"slices"
+	"strconv"
+
+	"github.com/navidrome/navidrome/core"
+	"github.com/navidrome/navidrome/core/transcode"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/server/subsonic/responses"
+	"github.com/navidrome/navidrome/utils/req"
+)
+
+// API-layer request structs for JSON unmarshaling (decoupled from core structs)
+
+// clientInfoRequest represents client playback capabilities from the request body
+type clientInfoRequest struct {
+	Name                       string                      `json:"name,omitempty"`
+	Platform                   string                      `json:"platform,omitempty"`
+	MaxAudioBitrate            int                         `json:"maxAudioBitrate,omitempty"`
+	MaxTranscodingAudioBitrate int                         `json:"maxTranscodingAudioBitrate,omitempty"`
+	DirectPlayProfiles         []directPlayProfileRequest  `json:"directPlayProfiles,omitempty"`
+	TranscodingProfiles        []transcodingProfileRequest `json:"transcodingProfiles,omitempty"`
+	CodecProfiles              []codecProfileRequest       `json:"codecProfiles,omitempty"`
+}
+
+// directPlayProfileRequest describes a format the client can play directly
+type directPlayProfileRequest struct {
+	Containers       []string `json:"containers,omitempty"`
+	AudioCodecs      []string `json:"audioCodecs,omitempty"`
+	Protocols        []string `json:"protocols,omitempty"`
+	MaxAudioChannels int      `json:"maxAudioChannels,omitempty"`
+}
+
+// transcodingProfileRequest describes a transcoding target the client supports
+type transcodingProfileRequest struct {
+	Container        string `json:"container,omitempty"`
+	AudioCodec       string `json:"audioCodec,omitempty"`
+	Protocol         string `json:"protocol,omitempty"`
+	MaxAudioChannels int    `json:"maxAudioChannels,omitempty"`
+}
+
+// codecProfileRequest describes codec-specific limitations
+type codecProfileRequest struct {
+	Type        string              `json:"type,omitempty"`
+	Name        string              `json:"name,omitempty"`
+	Limitations []limitationRequest `json:"limitations,omitempty"`
+}
+
+// limitationRequest describes a specific codec limitation
+type limitationRequest struct {
+	Name       string   `json:"name,omitempty"`
+	Comparison string   `json:"comparison,omitempty"`
+	Values     []string `json:"values,omitempty"`
+	Required   bool     `json:"required,omitempty"`
+}
+
+// toCoreClientInfo converts the API request struct to the transcode.ClientInfo struct.
+// The OpenSubsonic spec uses bps for bitrate values; core uses kbps.
+func (r *clientInfoRequest) toCoreClientInfo() *transcode.ClientInfo {
+	ci := &transcode.ClientInfo{
+		Name:                       r.Name,
+		Platform:                   r.Platform,
+		MaxAudioBitrate:            bpsToKbps(r.MaxAudioBitrate),
+		MaxTranscodingAudioBitrate: bpsToKbps(r.MaxTranscodingAudioBitrate),
+	}
+
+	for _, dp := range r.DirectPlayProfiles {
+		ci.DirectPlayProfiles = append(ci.DirectPlayProfiles, transcode.DirectPlayProfile{
+			Containers:       dp.Containers,
+			AudioCodecs:      dp.AudioCodecs,
+			Protocols:        dp.Protocols,
+			MaxAudioChannels: dp.MaxAudioChannels,
+		})
+	}
+
+	for _, tp := range r.TranscodingProfiles {
+		ci.TranscodingProfiles = append(ci.TranscodingProfiles, transcode.Profile{
+			Container:        tp.Container,
+			AudioCodec:       tp.AudioCodec,
+			Protocol:         tp.Protocol,
+			MaxAudioChannels: tp.MaxAudioChannels,
+		})
+	}
+
+	for _, cp := range r.CodecProfiles {
+		coreCP := transcode.CodecProfile{
+			Type: cp.Type,
+			Name: cp.Name,
+		}
+		for _, lim := range cp.Limitations {
+			coreLim := transcode.Limitation{
+				Name:       lim.Name,
+				Comparison: lim.Comparison,
+				Values:     lim.Values,
+				Required:   lim.Required,
+			}
+			// Convert audioBitrate limitation values from bps to kbps
+			if lim.Name == transcode.LimitationAudioBitrate {
+				coreLim.Values = convertBitrateValues(lim.Values)
+			}
+			coreCP.Limitations = append(coreCP.Limitations, coreLim)
+		}
+		ci.CodecProfiles = append(ci.CodecProfiles, coreCP)
+	}
+
+	return ci
+}
+
+// bpsToKbps converts bits per second to kilobits per second.
+func bpsToKbps(bps int) int {
+	return bps / 1000
+}
+
+// kbpsToBps converts kilobits per second to bits per second.
+func kbpsToBps(kbps int) int {
+	return kbps * 1000
+}
+
+// convertBitrateValues converts a slice of bps string values to kbps string values.
+func convertBitrateValues(bpsValues []string) []string {
+	result := make([]string, len(bpsValues))
+	for i, v := range bpsValues {
+		n, err := strconv.Atoi(v)
+		if err == nil {
+			result[i] = strconv.Itoa(bpsToKbps(n))
+		} else {
+			result[i] = v // preserve unparseable values as-is
+		}
+	}
+	return result
+}
+
+// validate checks that all enum fields in the request contain valid values per the OpenSubsonic spec.
+func (r *clientInfoRequest) validate() error {
+	for _, dp := range r.DirectPlayProfiles {
+		for _, p := range dp.Protocols {
+			if !isValidProtocol(p) {
+				return fmt.Errorf("invalid protocol: %s", p)
+			}
+		}
+	}
+	for _, tp := range r.TranscodingProfiles {
+		if tp.Protocol != "" && !isValidProtocol(tp.Protocol) {
+			return fmt.Errorf("invalid protocol: %s", tp.Protocol)
+		}
+	}
+	for _, cp := range r.CodecProfiles {
+		if !isValidCodecProfileType(cp.Type) {
+			return fmt.Errorf("invalid codec profile type: %s", cp.Type)
+		}
+		for _, lim := range cp.Limitations {
+			if !isValidLimitationName(lim.Name) {
+				return fmt.Errorf("invalid limitation name: %s", lim.Name)
+			}
+			if !isValidComparison(lim.Comparison) {
+				return fmt.Errorf("invalid comparison: %s", lim.Comparison)
+			}
+		}
+	}
+	return nil
+}
+
+var validProtocols = []string{
+	transcode.ProtocolHTTP,
+	transcode.ProtocolHLS,
+}
+
+func isValidProtocol(p string) bool {
+	return slices.Contains(validProtocols, p)
+}
+
+var validCodecProfileTypes = []string{
+	transcode.CodecProfileTypeAudio,
+}
+
+func isValidCodecProfileType(t string) bool {
+	return slices.Contains(validCodecProfileTypes, t)
+}
+
+var validLimitationNames = []string{
+	transcode.LimitationAudioChannels,
+	transcode.LimitationAudioBitrate,
+	transcode.LimitationAudioProfile,
+	transcode.LimitationAudioSamplerate,
+	transcode.LimitationAudioBitdepth,
+}
+
+func isValidLimitationName(n string) bool {
+	return slices.Contains(validLimitationNames, n)
+}
+
+var validComparisons = []string{
+	transcode.ComparisonEquals,
+	transcode.ComparisonNotEquals,
+	transcode.ComparisonLessThanEqual,
+	transcode.ComparisonGreaterThanEqual,
+}
+
+func isValidComparison(c string) bool {
+	return slices.Contains(validComparisons, c)
+}
+
+// GetTranscodeDecision handles the OpenSubsonic getTranscodeDecision endpoint.
+// It receives client capabilities and returns a decision on whether to direct play or transcode.
+func (api *Router) GetTranscodeDecision(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
+	if r.Method != http.MethodPost {
+		w.Header().Set("Allow", "POST")
+		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
+		return nil, nil
+	}
+
+	ctx := r.Context()
+	p := req.Params(r)
+
+	mediaID, err := p.String("mediaId")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: mediaId")
+	}
+
+	mediaType, err := p.String("mediaType")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: mediaType")
+	}
+
+	// Only support songs for now
+	if mediaType != "song" {
+		return nil, newError(responses.ErrorGeneric, "mediaType '%s' is not yet supported", mediaType)
+	}
+
+	// Parse and validate ClientInfo from request body (required per OpenSubsonic spec)
+	var clientInfoReq clientInfoRequest
+	if r.Body == nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required JSON request body")
+	}
+	if err := json.NewDecoder(r.Body).Decode(&clientInfoReq); err != nil {
+		return nil, newError(responses.ErrorGeneric, "invalid JSON request body")
+	}
+	if err := clientInfoReq.validate(); err != nil {
+		return nil, newError(responses.ErrorGeneric, "%v", err)
+	}
+	clientInfo := clientInfoReq.toCoreClientInfo()
+
+	// Get media file
+	mf, err := api.ds.MediaFile(ctx).Get(mediaID)
+	if err != nil {
+		return nil, newError(responses.ErrorDataNotFound, "media file not found: %s", mediaID)
+	}
+
+	// Make the decision
+	decision, err := api.transcodeDecision.MakeDecision(ctx, mf, clientInfo)
+	if err != nil {
+		return nil, newError(responses.ErrorGeneric, "failed to make transcode decision: %v", err)
+	}
+
+	// Only create a token when there is a valid playback path
+	var transcodeParams string
+	if decision.CanDirectPlay || decision.CanTranscode {
+		transcodeParams, err = api.transcodeDecision.CreateTranscodeParams(decision)
+		if err != nil {
+			return nil, newError(responses.ErrorGeneric, "failed to create transcode token: %v", err)
+		}
+	}
+
+	// Build response (convert kbps from core to bps for the API)
+	response := newResponse()
+	response.TranscodeDecision = &responses.TranscodeDecision{
+		CanDirectPlay:    decision.CanDirectPlay,
+		CanTranscode:     decision.CanTranscode,
+		TranscodeReasons: decision.TranscodeReasons,
+		ErrorReason:      decision.ErrorReason,
+		TranscodeParams:  transcodeParams,
+		SourceStream: &responses.StreamDetails{
+			Protocol:        "http",
+			Container:       decision.SourceStream.Container,
+			Codec:           decision.SourceStream.Codec,
+			AudioBitrate:    int32(kbpsToBps(decision.SourceStream.Bitrate)),
+			AudioProfile:    decision.SourceStream.Profile,
+			AudioSamplerate: int32(decision.SourceStream.SampleRate),
+			AudioBitdepth:   int32(decision.SourceStream.BitDepth),
+			AudioChannels:   int32(decision.SourceStream.Channels),
+		},
+	}
+
+	if decision.TranscodeStream != nil {
+		response.TranscodeDecision.TranscodeStream = &responses.StreamDetails{
+			Protocol:        "http",
+			Container:       decision.TranscodeStream.Container,
+			Codec:           decision.TranscodeStream.Codec,
+			AudioBitrate:    int32(kbpsToBps(decision.TranscodeStream.Bitrate)),
+			AudioProfile:    decision.TranscodeStream.Profile,
+			AudioSamplerate: int32(decision.TranscodeStream.SampleRate),
+			AudioBitdepth:   int32(decision.TranscodeStream.BitDepth),
+			AudioChannels:   int32(decision.TranscodeStream.Channels),
+		}
+	}
+
+	return response, nil
+}
+
+// GetTranscodeStream handles the OpenSubsonic getTranscodeStream endpoint.
+// It streams media using the decision encoded in the transcodeParams JWT token.
+func (api *Router) GetTranscodeStream(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
+	ctx := r.Context()
+	p := req.Params(r)
+
+	mediaID, err := p.String("mediaId")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: mediaId")
+	}
+
+	mediaType, err := p.String("mediaType")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: mediaType")
+	}
+
+	transcodeParams, err := p.String("transcodeParams")
+	if err != nil {
+		return nil, newError(responses.ErrorMissingParameter, "missing required parameter: transcodeParams")
+	}
+
+	// Only support songs for now
+	if mediaType != "song" {
+		return nil, newError(responses.ErrorGeneric, "mediaType '%s' is not yet supported", mediaType)
+	}
+
+	// Parse and validate the token
+	params, err := api.transcodeDecision.ParseTranscodeParams(transcodeParams)
+	if err != nil {
+		log.Warn(ctx, "Failed to parse transcode token", err)
+		return nil, newError(responses.ErrorDataNotFound, "invalid or expired transcodeParams token")
+	}
+
+	// Verify mediaId matches token
+	if params.MediaID != mediaID {
+		return nil, newError(responses.ErrorDataNotFound, "mediaId does not match token")
+	}
+
+	// Build streaming parameters from the token
+	streamReq := core.StreamRequest{ID: mediaID, Offset: p.IntOr("offset", 0)}
+	if !params.DirectPlay && params.TargetFormat != "" {
+		streamReq.Format = params.TargetFormat
+		streamReq.BitRate = params.TargetBitrate // Already in kbps, matching the streamer
+		streamReq.SampleRate = params.TargetSampleRate
+		streamReq.BitDepth = params.TargetBitDepth
+		streamReq.Channels = params.TargetChannels
+	}
+
+	// Create stream
+	stream, err := api.streamer.NewStream(ctx, streamReq)
+	if err != nil {
+		return nil, err
+	}
+
+	// Make sure the stream will be closed at the end
+	defer func() {
+		if err := stream.Close(); err != nil && log.IsGreaterOrEqualTo(log.LevelDebug) {
+			log.Error("Error closing stream", "id", mediaID, "file", stream.Name(), err)
+		}
+	}()
+
+	w.Header().Set("X-Content-Type-Options", "nosniff")
+
+	api.serveStream(ctx, w, r, stream, mediaID)
+
+	return nil, nil
+}

server/subsonic/transcode_test.go

@@ -0,0 +1,268 @@
+package subsonic
+
+import (
+	"bytes"
+	"context"
+	"net/http"
+	"net/http/httptest"
+
+	"github.com/navidrome/navidrome/core/transcode"
+	"github.com/navidrome/navidrome/model"
+	"github.com/navidrome/navidrome/tests"
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Transcode endpoints", func() {
+	var (
+		router     *Router
+		ds         *tests.MockDataStore
+		mockTD     *mockTranscodeDecision
+		w          *httptest.ResponseRecorder
+		mockMFRepo *tests.MockMediaFileRepo
+	)
+
+	BeforeEach(func() {
+		mockMFRepo = &tests.MockMediaFileRepo{}
+		ds = &tests.MockDataStore{MockedMediaFile: mockMFRepo}
+		mockTD = &mockTranscodeDecision{}
+		router = New(ds, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, mockTD)
+		w = httptest.NewRecorder()
+	})
+
+	Describe("GetTranscodeDecision", func() {
+		It("returns 405 for non-POST requests", func() {
+			r := newGetRequest("mediaId=123", "mediaType=song")
+			resp, err := router.GetTranscodeDecision(w, r)
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp).To(BeNil())
+			Expect(w.Code).To(Equal(http.StatusMethodNotAllowed))
+			Expect(w.Header().Get("Allow")).To(Equal("POST"))
+		})
+
+		It("returns error when mediaId is missing", func() {
+			r := newJSONPostRequest("mediaType=song", "{}")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when mediaType is missing", func() {
+			r := newJSONPostRequest("mediaId=123", "{}")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error for unsupported mediaType", func() {
+			r := newJSONPostRequest("mediaId=123&mediaType=podcast", "{}")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("not yet supported"))
+		})
+
+		It("returns error when media file not found", func() {
+			mockMFRepo.SetError(true)
+			r := newJSONPostRequest("mediaId=notfound&mediaType=song", "{}")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when body is empty", func() {
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", "")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when body contains invalid JSON", func() {
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", "not-json{{{")
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error for invalid protocol in direct play profile", func() {
+			body := `{"directPlayProfiles":[{"containers":["mp3"],"audioCodecs":["mp3"],"protocols":["ftp"]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid protocol"))
+		})
+
+		It("returns error for invalid comparison operator", func() {
+			body := `{"codecProfiles":[{"type":"AudioCodec","name":"mp3","limitations":[{"name":"audioBitrate","comparison":"InvalidOp","values":["320"]}]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid comparison"))
+		})
+
+		It("returns error for invalid limitation name", func() {
+			body := `{"codecProfiles":[{"type":"AudioCodec","name":"mp3","limitations":[{"name":"unknownField","comparison":"Equals","values":["320"]}]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid limitation name"))
+		})
+
+		It("returns error for invalid codec profile type", func() {
+			body := `{"codecProfiles":[{"type":"VideoCodec","name":"mp3"}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid codec profile type"))
+		})
+
+		It("rejects wrong-case protocol", func() {
+			body := `{"directPlayProfiles":[{"containers":["mp3"],"audioCodecs":["mp3"],"protocols":["HTTP"]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid protocol"))
+		})
+
+		It("rejects wrong-case codec profile type", func() {
+			body := `{"codecProfiles":[{"type":"audiocodec","name":"mp3"}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid codec profile type"))
+		})
+
+		It("rejects wrong-case comparison operator", func() {
+			body := `{"codecProfiles":[{"type":"AudioCodec","name":"mp3","limitations":[{"name":"audioBitrate","comparison":"lessthanequal","values":["320"]}]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid comparison"))
+		})
+
+		It("rejects wrong-case limitation name", func() {
+			body := `{"codecProfiles":[{"type":"AudioCodec","name":"mp3","limitations":[{"name":"AudioBitrate","comparison":"Equals","values":["320"]}]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			_, err := router.GetTranscodeDecision(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("invalid limitation name"))
+		})
+
+		It("returns a valid decision response", func() {
+			mockMFRepo.SetData(model.MediaFiles{
+				{ID: "song-1", Suffix: "mp3", Codec: "MP3", BitRate: 320, Channels: 2, SampleRate: 44100},
+			})
+			mockTD.decision = &transcode.Decision{
+				MediaID:       "song-1",
+				CanDirectPlay: true,
+				SourceStream: transcode.StreamDetails{
+					Container: "mp3", Codec: "mp3", Bitrate: 320,
+					SampleRate: 44100, Channels: 2,
+				},
+			}
+			mockTD.token = "test-jwt-token"
+
+			body := `{"directPlayProfiles":[{"containers":["mp3"],"protocols":["http"]}]}`
+			r := newJSONPostRequest("mediaId=song-1&mediaType=song", body)
+			resp, err := router.GetTranscodeDecision(w, r)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp.TranscodeDecision).ToNot(BeNil())
+			Expect(resp.TranscodeDecision.CanDirectPlay).To(BeTrue())
+			Expect(resp.TranscodeDecision.TranscodeParams).To(Equal("test-jwt-token"))
+			Expect(resp.TranscodeDecision.SourceStream).ToNot(BeNil())
+			Expect(resp.TranscodeDecision.SourceStream.Protocol).To(Equal("http"))
+			Expect(resp.TranscodeDecision.SourceStream.Container).To(Equal("mp3"))
+			Expect(resp.TranscodeDecision.SourceStream.AudioBitrate).To(Equal(int32(320_000)))
+		})
+
+		It("includes transcode stream when transcoding", func() {
+			mockMFRepo.SetData(model.MediaFiles{
+				{ID: "song-2", Suffix: "flac", Codec: "FLAC", BitRate: 1000, Channels: 2, SampleRate: 96000, BitDepth: 24},
+			})
+			mockTD.decision = &transcode.Decision{
+				MediaID:          "song-2",
+				CanDirectPlay:    false,
+				CanTranscode:     true,
+				TargetFormat:     "mp3",
+				TargetBitrate:    256,
+				TranscodeReasons: []string{"container not supported"},
+				SourceStream: transcode.StreamDetails{
+					Container: "flac", Codec: "flac", Bitrate: 1000,
+					SampleRate: 96000, BitDepth: 24, Channels: 2,
+				},
+				TranscodeStream: &transcode.StreamDetails{
+					Container: "mp3", Codec: "mp3", Bitrate: 256,
+					SampleRate: 96000, Channels: 2,
+				},
+			}
+			mockTD.token = "transcode-token"
+
+			r := newJSONPostRequest("mediaId=song-2&mediaType=song", "{}")
+			resp, err := router.GetTranscodeDecision(w, r)
+
+			Expect(err).ToNot(HaveOccurred())
+			Expect(resp.TranscodeDecision.CanTranscode).To(BeTrue())
+			Expect(resp.TranscodeDecision.TranscodeReasons).To(ConsistOf("container not supported"))
+			Expect(resp.TranscodeDecision.TranscodeStream).ToNot(BeNil())
+			Expect(resp.TranscodeDecision.TranscodeStream.Container).To(Equal("mp3"))
+		})
+	})
+
+	Describe("GetTranscodeStream", func() {
+		It("returns error when mediaId is missing", func() {
+			r := newGetRequest("mediaType=song", "transcodeParams=abc")
+			_, err := router.GetTranscodeStream(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when transcodeParams is missing", func() {
+			r := newGetRequest("mediaId=123", "mediaType=song")
+			_, err := router.GetTranscodeStream(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error for invalid token", func() {
+			mockTD.parseErr = model.ErrNotFound
+			r := newGetRequest("mediaId=123", "mediaType=song", "transcodeParams=bad-token")
+			_, err := router.GetTranscodeStream(w, r)
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("returns error when mediaId doesn't match token", func() {
+			mockTD.params = &transcode.Params{MediaID: "other-id", DirectPlay: true}
+			r := newGetRequest("mediaId=wrong-id", "mediaType=song", "transcodeParams=valid-token")
+			_, err := router.GetTranscodeStream(w, r)
+			Expect(err).To(HaveOccurred())
+			Expect(err.Error()).To(ContainSubstring("does not match"))
+		})
+	})
+})
+
+// newJSONPostRequest creates an HTTP POST request with JSON body and query params
+func newJSONPostRequest(queryParams string, jsonBody string) *http.Request {
+	r := httptest.NewRequest("POST", "/getTranscodeDecision?"+queryParams, bytes.NewBufferString(jsonBody))
+	r.Header.Set("Content-Type", "application/json")
+	return r
+}
+
+// mockTranscodeDecision is a test double for core.TranscodeDecision
+type mockTranscodeDecision struct {
+	decision *transcode.Decision
+	token    string
+	tokenErr error
+	params   *transcode.Params
+	parseErr error
+}
+
+func (m *mockTranscodeDecision) MakeDecision(_ context.Context, _ *model.MediaFile, _ *transcode.ClientInfo) (*transcode.Decision, error) {
+	if m.decision != nil {
+		return m.decision, nil
+	}
+	return &transcode.Decision{}, nil
+}
+
+func (m *mockTranscodeDecision) CreateTranscodeParams(_ *transcode.Decision) (string, error) {
+	return m.token, m.tokenErr
+}
+
+func (m *mockTranscodeDecision) ParseTranscodeParams(_ string) (*transcode.Params, error) {
+	if m.parseErr != nil {
+		return nil, m.parseErr
+	}
+	return m.params, nil
+}

tests/mock_ffmpeg.go

@@ -6,6 +6,8 @@ import (
 	"strings"
 	"sync"
 	"sync/atomic"
+
+	"github.com/navidrome/navidrome/core/ffmpeg"
 )
 
 func NewMockFFmpeg(data string) *MockFFmpeg {
@@ -23,7 +25,7 @@ func (ff *MockFFmpeg) IsAvailable() bool {
 	return true
 }
 
-func (ff *MockFFmpeg) Transcode(context.Context, string, string, int, int) (io.ReadCloser, error) {
+func (ff *MockFFmpeg) Transcode(_ context.Context, _ ffmpeg.TranscodeOptions) (io.ReadCloser, error) {
 	if ff.Error != nil {
 		return nil, ff.Error
 	}

tests/mock_transcoding_repo.go

@@ -18,6 +18,10 @@ func (m *MockTranscodingRepo) FindByFormat(format string) (*model.Transcoding, e
 		return &model.Transcoding{ID: "oga1", TargetFormat: "oga", DefaultBitRate: 128}, nil
 	case "opus":
 		return &model.Transcoding{ID: "opus1", TargetFormat: "opus", DefaultBitRate: 96}, nil
+	case "flac":
+		return &model.Transcoding{ID: "flac1", TargetFormat: "flac", DefaultBitRate: 0, Command: "ffmpeg -i %s -ss %t -map 0:a:0 -v 0 -c:a flac -f flac -"}, nil
+	case "aac":
+		return &model.Transcoding{ID: "aac1", TargetFormat: "aac", DefaultBitRate: 256, Command: "ffmpeg -i %s -ss %t -map 0:a:0 -b:a %bk -v 0 -c:a aac -f adts -"}, nil
 	default:
 		return nil, model.ErrNotFound
 	}