refactor(transcoding): rename TranscodeDecision to Decider and update related methods for clarity

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

.github/workflows/create-release.yml

@@ -1,52 +0,0 @@
-name: Create Release
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "Release version (e.g. 0.53.0)"
-        required: true
-        type: string
-
-jobs:
-  create-release:
-    name: Create Release
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Validate version format
-        run: |
-          if [[ ! "${{ inputs.version }}" =~ ^[0-9]+\.[0-9]+\.[0-9]+.*$ ]]; then
-            echo "::error::Invalid version format '${{ inputs.version }}'. Expected X.X.X"
-            exit 1
-          fi
-
-      - name: Check if tag already exists
-        run: |
-          if git rev-parse "v${{ inputs.version }}" >/dev/null 2>&1; then
-            echo "::error::Tag v${{ inputs.version }} already exists"
-            exit 1
-          fi
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version-file: go.mod
-
-      - name: Run go mod tidy
-        run: go mod tidy
-
-      - name: Check for pending changes
-        run: |
-          if [ -n "$(git status -s)" ]; then
-            echo "::error::There are pending changes after 'go mod tidy'. Please commit them first."
-            git status -s
-            exit 1
-          fi
-
-      - name: Create and push tag
-        run: |
-          git tag v${{ inputs.version }}
-          git push origin v${{ inputs.version }}

Makefile

@@ -242,7 +242,11 @@ clean:
 
 release:
 	@if [[ ! "${V}" =~ ^[0-9]+\.[0-9]+\.[0-9]+.*$$ ]]; then echo "Usage: make release V=X.X.X"; exit 1; fi
-	gh workflow run create-release.yml -f version=${V}
+	go mod tidy
+	@if [ -n "`git status -s`" ]; then echo "\n\nThere are pending changes. Please commit or stash first"; exit 1; fi
+	make pre-push
+	git tag v${V}
+	git push origin v${V} --no-verify
 .PHONY: release
 
 download-deps:

adapters/gotaglib/gotaglib.go

@@ -64,6 +64,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)

adapters/listenbrainz/agent.go

@@ -118,129 +118,12 @@ func (l *listenBrainzAgent) IsAuthorized(ctx context.Context, userId string) boo
 	return err == nil && sk != ""
 }
 
-func (l *listenBrainzAgent) GetArtistURL(ctx context.Context, id, name, mbid string) (string, error) {
-	if mbid == "" {
-		return "", agents.ErrNotFound
-	}
-
-	url, err := l.client.getArtistUrl(ctx, mbid)
-	if err != nil {
-		return "", err
-	}
-	return url, nil
-}
-
-func (l *listenBrainzAgent) GetArtistTopSongs(ctx context.Context, id, artistName, mbid string, count int) ([]agents.Song, error) {
-	resp, err := l.client.getArtistTopSongs(ctx, mbid, count)
-	if err != nil {
-		return nil, err
-	}
-	if len(resp) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	res := make([]agents.Song, len(resp))
-	for i, t := range resp {
-		mbid := ""
-		if len(t.ArtistMBIDs) > 0 {
-			mbid = t.ArtistMBIDs[0]
-		}
-
-		res[i] = agents.Song{
-			Album:      t.ReleaseName,
-			AlbumMBID:  t.ReleaseMBID,
-			Artist:     t.ArtistName,
-			ArtistMBID: mbid,
-			Duration:   t.DurationMs,
-			Name:       t.RecordingName,
-			MBID:       t.RecordingMbid,
-		}
-	}
-	return res, nil
-}
-
-func (l *listenBrainzAgent) GetSimilarArtists(ctx context.Context, id string, name string, mbid string, limit int) ([]agents.Artist, error) {
-	if mbid == "" {
-		return nil, agents.ErrNotFound
-	}
-
-	resp, err := l.client.getSimilarArtists(ctx, mbid, limit)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(resp) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	artists := make([]agents.Artist, len(resp))
-	for i, artist := range resp {
-		artists[i] = agents.Artist{
-			MBID: artist.MBID,
-			Name: artist.Name,
-		}
-	}
-
-	return artists, nil
-}
-
-func (l *listenBrainzAgent) GetSimilarSongsByTrack(ctx context.Context, id string, name string, artist string, mbid string, limit int) ([]agents.Song, error) {
-	if mbid == "" {
-		return nil, agents.ErrNotFound
-	}
-
-	resp, err := l.client.getSimilarRecordings(ctx, mbid, limit)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(resp) == 0 {
-		return nil, agents.ErrNotFound
-	}
-
-	songs := make([]agents.Song, len(resp))
-	for i, song := range resp {
-		songs[i] = agents.Song{
-			Album:     song.ReleaseName,
-			AlbumMBID: song.ReleaseMBID,
-			Artist:    song.Artist,
-			MBID:      song.MBID,
-			Name:      song.Name,
-		}
-	}
-
-	return songs, nil
-}
-
 func init() {
 	conf.AddHook(func() {
 		if conf.Server.ListenBrainz.Enabled {
 			scrobbler.Register(listenBrainzAgentName, func(ds model.DataStore) scrobbler.Scrobbler {
-				// This is a workaround for the fact that a (Interface)(nil) is not the same as a (*listenBrainzAgent)(nil)
-				// See https://go.dev/doc/faq#nil_error
-				a := listenBrainzConstructor(ds)
-				if a != nil {
-					return a
-				}
-				return nil
-			})
-
-			agents.Register(listenBrainzAgentName, func(ds model.DataStore) agents.Interface {
-				// This is a workaround for the fact that a (Interface)(nil) is not the same as a (*listenBrainzAgent)(nil)
-				// See https://go.dev/doc/faq#nil_error
-				a := listenBrainzConstructor(ds)
-				if a != nil {
-					return a
-				}
-				return nil
+				return listenBrainzConstructor(ds)
 			})
 		}
 	})
 }
-
-var (
-	_ agents.ArtistTopSongsRetriever      = (*listenBrainzAgent)(nil)
-	_ agents.ArtistURLRetriever           = (*listenBrainzAgent)(nil)
-	_ agents.ArtistSimilarRetriever       = (*listenBrainzAgent)(nil)
-	_ agents.SimilarSongsByTrackRetriever = (*listenBrainzAgent)(nil)
-)

adapters/listenbrainz/agent_test.go

@@ -4,14 +4,11 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"io"
 	"net/http"
-	"os"
 	"time"
 
 	"github.com/navidrome/navidrome/consts"
-	"github.com/navidrome/navidrome/core/agents"
 	"github.com/navidrome/navidrome/core/scrobbler"
 	"github.com/navidrome/navidrome/model"
 	"github.com/navidrome/navidrome/tests"
@@ -165,279 +162,4 @@ var _ = Describe("listenBrainzAgent", func() {
 			Expect(err).To(MatchError(scrobbler.ErrUnrecoverable))
 		})
 	})
-
-	Describe("GetArtistUrl", func() {
-		var agent *listenBrainzAgent
-		var httpClient *tests.FakeHttpClient
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("BASE_URL", httpClient)
-			agent = listenBrainzConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns artist url when MBID present", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.artist.metadata.homepage.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			Expect(agent.GetArtistURL(ctx, "", "", "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56")).To(Equal("http://projectmili.com/"))
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist_mbids")).To(Equal("d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-		})
-
-		It("returns error when url not present", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.artist.metadata.no_homepage.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			_, err := agent.GetArtistURL(ctx, "", "", "7c2cc610-f998-43ef-a08f-dae3344b8973")
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist_mbids")).To(Equal("7c2cc610-f998-43ef-a08f-dae3344b8973"))
-		})
-
-		It("returns error when fetch calls fails", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetArtistURL(ctx, "", "", "7c2cc610-f998-43ef-a08f-dae3344b8973")
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist_mbids")).To(Equal("7c2cc610-f998-43ef-a08f-dae3344b8973"))
-		})
-
-		It("returns error when ListenBrainz returns an error", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 400,"error": "artist mbid 1 is not valid."}`)),
-				StatusCode: 400,
-			}
-			_, err := agent.GetArtistURL(ctx, "", "", "7c2cc610-f998-43ef-a08f-dae3344b8973")
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Query().Get("artist_mbids")).To(Equal("7c2cc610-f998-43ef-a08f-dae3344b8973"))
-		})
-	})
-
-	Describe("GetTopSongs", func() {
-		var agent *listenBrainzAgent
-		var httpClient *tests.FakeHttpClient
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("BASE_URL", httpClient)
-			agent = listenBrainzConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns error when fetch calls", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetArtistTopSongs(ctx, "", "", "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Path).To(Equal("/1/popularity/top-recordings-for-artist/d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-		})
-
-		It("returns an error on listenbrainz error", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code":400,"error":"artist_mbid: '1' is not a valid uuid"}`)),
-				StatusCode: 400,
-			}
-			_, err := agent.GetArtistTopSongs(ctx, "", "", "1", 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.Path).To(Equal("/1/popularity/top-recordings-for-artist/1"))
-		})
-
-		It("returns all tracks when asked", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.popularity.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			data, err := agent.GetArtistTopSongs(ctx, "", "", "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal([]agents.Song{
-				{
-					ID:         "",
-					Name:       "world.execute(me);",
-					MBID:       "9980309d-3480-4e7e-89ce-fce971a452be",
-					Artist:     "Mili",
-					ArtistMBID: "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-					Album:      "Miracle Milk",
-					AlbumMBID:  "38a8f6e1-0e34-4418-a89d-78240a367408",
-					Duration:   211912,
-				},
-				{
-					ID:         "",
-					Name:       "String Theocracy",
-					MBID:       "afa2c83d-b17f-4029-b9da-790ea9250cf9",
-					Artist:     "Mili",
-					ArtistMBID: "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-					Album:      "String Theocracy",
-					AlbumMBID:  "d79a38e3-7016-4f39-a31a-f495ce914b8e",
-					Duration:   174000,
-				},
-			}))
-		})
-
-		It("returns only one track when prompted", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.popularity.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			data, err := agent.GetArtistTopSongs(ctx, "", "", "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal([]agents.Song{
-				{
-					ID:         "",
-					Name:       "world.execute(me);",
-					MBID:       "9980309d-3480-4e7e-89ce-fce971a452be",
-					Artist:     "Mili",
-					ArtistMBID: "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-					Album:      "Miracle Milk",
-					AlbumMBID:  "38a8f6e1-0e34-4418-a89d-78240a367408",
-					Duration:   211912,
-				},
-			}))
-		})
-	})
-
-	Describe("GetSimilarArtists", func() {
-		var agent *listenBrainzAgent
-		var httpClient *tests.FakeHttpClient
-		baseUrl := "https://labs.api.listenbrainz.org/similar-artists/json?algorithm=session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30&artist_mbids="
-		mbid := "db92a151-1ac2-438b-bc43-b82e149ddd50"
-
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("BASE_URL", httpClient)
-			agent = listenBrainzConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns error when fetch calls", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetSimilarArtists(ctx, "", "", mbid, 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-		})
-
-		It("returns an error on listenbrainz error", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad request`)),
-				StatusCode: 400,
-			}
-			_, err := agent.GetSimilarArtists(ctx, "", "", "1", 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "1"))
-		})
-
-		It("returns all data on call", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			resp, err := agent.GetSimilarArtists(ctx, "", "", "db92a151-1ac2-438b-bc43-b82e149ddd50", 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-			Expect(resp).To(Equal([]agents.Artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson"},
-				{MBID: "7364dea6-ca9a-48e3-be01-b44ad0d19897", Name: "a-ha"},
-			}))
-		})
-
-		It("returns subset of data on call", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			resp, err := agent.GetSimilarArtists(ctx, "", "", "db92a151-1ac2-438b-bc43-b82e149ddd50", 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-			Expect(resp).To(Equal([]agents.Artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson"},
-			}))
-		})
-	})
-
-	Describe("GetSimilarTracks", func() {
-		var agent *listenBrainzAgent
-		var httpClient *tests.FakeHttpClient
-		mbid := "8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"
-		baseUrl := "https://labs.api.listenbrainz.org/similar-recordings/json?algorithm=session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30&recording_mbids="
-
-		BeforeEach(func() {
-			httpClient = &tests.FakeHttpClient{}
-			client := newClient("BASE_URL", httpClient)
-			agent = listenBrainzConstructor(ds)
-			agent.client = client
-		})
-
-		It("returns error when fetch calls", func() {
-			httpClient.Err = errors.New("error")
-			_, err := agent.GetSimilarSongsByTrack(ctx, "", "", "", mbid, 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-		})
-
-		It("returns an error on listenbrainz error", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad request`)),
-				StatusCode: 400,
-			}
-			_, err := agent.GetSimilarSongsByTrack(ctx, "", "", "", "1", 1)
-			Expect(err).To(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "1"))
-		})
-
-		It("returns all data on call", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			resp, err := agent.GetSimilarSongsByTrack(ctx, "", "", "", mbid, 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-			Expect(resp).To(Equal([]agents.Song{
-				{
-					ID:         "",
-					Name:       "Take On Me",
-					MBID:       "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					ISRC:       "",
-					Artist:     "a‐ha",
-					ArtistMBID: "",
-					Album:      "Hunting High and Low",
-					AlbumMBID:  "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Duration:   0,
-				},
-				{
-					ID:         "",
-					Name:       "Wake Me Up Before You Go‐Go",
-					MBID:       "80033c72-aa19-4ba8-9227-afb075fec46e",
-					ISRC:       "",
-					Artist:     "Wham!",
-					ArtistMBID: "",
-					Album:      "Make It Big",
-					AlbumMBID:  "c143d542-48dc-446b-b523-1762da721638",
-					Duration:   0,
-				},
-			}))
-		})
-
-		It("returns subset of data on call", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-
-			resp, err := agent.GetSimilarSongsByTrack(ctx, "", "", "", mbid, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.RequestCount).To(Equal(1))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + mbid))
-			Expect(resp).To(Equal([]agents.Song{
-				{
-					ID:         "",
-					Name:       "Take On Me",
-					MBID:       "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					ISRC:       "",
-					Artist:     "a‐ha",
-					ArtistMBID: "",
-					Album:      "Hunting High and Low",
-					AlbumMBID:  "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Duration:   0,
-				},
-			}))
-		})
-	})
 })

adapters/listenbrainz/client.go

@@ -2,29 +2,16 @@ package listenbrainz
 
 import (
 	"bytes"
-	"cmp"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"net/http"
 	"net/url"
 	"path"
-	"slices"
 
-	"github.com/navidrome/navidrome/conf"
 	"github.com/navidrome/navidrome/log"
 )
 
-const (
-	lbzApiUrl = "https://api.listenbrainz.org/1/"
-	labsBase  = "https://labs.api.listenbrainz.org/"
-)
-
-var (
-	ErrorNotFound = errors.New("listenbrainz: not found")
-)
-
 type listenBrainzError struct {
 	Code    int
 	Message string
@@ -101,7 +88,7 @@ func (c *client) validateToken(ctx context.Context, apiKey string) (*listenBrain
 	r := &listenBrainzRequest{
 		ApiKey: apiKey,
 	}
-	response, err := c.makeAuthenticatedRequest(ctx, http.MethodGet, "validate-token", r)
+	response, err := c.makeRequest(ctx, http.MethodGet, "validate-token", r)
 	if err != nil {
 		return nil, err
 	}
@@ -117,7 +104,7 @@ func (c *client) updateNowPlaying(ctx context.Context, apiKey string, li listenI
 		},
 	}
 
-	resp, err := c.makeAuthenticatedRequest(ctx, http.MethodPost, "submit-listens", r)
+	resp, err := c.makeRequest(ctx, http.MethodPost, "submit-listens", r)
 	if err != nil {
 		return err
 	}
@@ -135,7 +122,7 @@ func (c *client) scrobble(ctx context.Context, apiKey string, li listenInfo) err
 			Payload:    []listenInfo{li},
 		},
 	}
-	resp, err := c.makeAuthenticatedRequest(ctx, http.MethodPost, "submit-listens", r)
+	resp, err := c.makeRequest(ctx, http.MethodPost, "submit-listens", r)
 	if err != nil {
 		return err
 	}
@@ -154,7 +141,7 @@ func (c *client) path(endpoint string) (string, error) {
 	return u.String(), nil
 }
 
-func (c *client) makeAuthenticatedRequest(ctx context.Context, method string, endpoint string, r *listenBrainzRequest) (*listenBrainzResponse, error) {
+func (c *client) makeRequest(ctx context.Context, method string, endpoint string, r *listenBrainzRequest) (*listenBrainzResponse, error) {
 	b, _ := json.Marshal(r.Body)
 	uri, err := c.path(endpoint)
 	if err != nil {
@@ -190,189 +177,3 @@ func (c *client) makeAuthenticatedRequest(ctx context.Context, method string, en
 
 	return &response, nil
 }
-
-type lbzHttpError struct {
-	Code  int    `json:"code"`
-	Error string `json:"error"`
-}
-
-func (c *client) makeGenericRequest(ctx context.Context, method string, endpoint string, params url.Values) (*http.Response, error) {
-	req, _ := http.NewRequestWithContext(ctx, method, lbzApiUrl+endpoint, nil)
-	req.Header.Add("Content-Type", "application/json; charset=UTF-8")
-	req.URL.RawQuery = params.Encode()
-
-	log.Trace(ctx, fmt.Sprintf("Sending ListenBrainz %s request", req.Method), "url", req.URL)
-	resp, err := c.hc.Do(req)
-
-	if err != nil {
-		return nil, err
-	}
-
-	// On a 200 code, there is no code. Decode using using error message if it exists
-	if resp.StatusCode != 200 {
-		defer resp.Body.Close()
-		decoder := json.NewDecoder(resp.Body)
-
-		var lbzError lbzHttpError
-		jsonErr := decoder.Decode(&lbzError)
-
-		if jsonErr != nil {
-			return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-		}
-
-		return nil, &listenBrainzError{Code: lbzError.Code, Message: lbzError.Error}
-	}
-
-	return resp, err
-}
-
-type artistMetadataResult struct {
-	Rels struct {
-		OfficialHomepage string `json:"official homepage,omitempty"`
-	} `json:"rels,omitzero"`
-}
-
-func (c *client) getArtistUrl(ctx context.Context, mbid string) (string, error) {
-	params := url.Values{}
-	params.Add("artist_mbids", mbid)
-	resp, err := c.makeGenericRequest(ctx, http.MethodGet, "metadata/artist", params)
-	if err != nil {
-		return "", err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var response []artistMetadataResult
-	jsonErr := decoder.Decode(&response)
-	if jsonErr != nil {
-		return "", fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-
-	if len(response) == 0 || response[0].Rels.OfficialHomepage == "" {
-		return "", ErrorNotFound
-	}
-
-	return response[0].Rels.OfficialHomepage, nil
-}
-
-type trackInfo struct {
-	ArtistName    string   `json:"artist_name"`
-	ArtistMBIDs   []string `json:"artist_mbids"`
-	DurationMs    uint32   `json:"length"`
-	RecordingName string   `json:"recording_name"`
-	RecordingMbid string   `json:"recording_mbid"`
-	ReleaseName   string   `json:"release_name"`
-	ReleaseMBID   string   `json:"release_mbid"`
-}
-
-func (c *client) getArtistTopSongs(ctx context.Context, mbid string, count int) ([]trackInfo, error) {
-	resp, err := c.makeGenericRequest(ctx, http.MethodGet, "popularity/top-recordings-for-artist/"+mbid, url.Values{})
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var response []trackInfo
-	jsonErr := decoder.Decode(&response)
-	if jsonErr != nil {
-		return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-
-	if len(response) > count {
-		return response[0:count], nil
-	}
-
-	return response, nil
-}
-
-type artist struct {
-	MBID  string `json:"artist_mbid"`
-	Name  string `json:"name"`
-	Score int    `json:"score"`
-}
-
-func (c *client) getSimilarArtists(ctx context.Context, mbid string, limit int) ([]artist, error) {
-	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, labsBase+"similar-artists/json", nil)
-	req.Header.Add("Content-Type", "application/json; charset=UTF-8")
-	req.URL.RawQuery = url.Values{
-		"artist_mbids": []string{mbid}, "algorithm": []string{conf.Server.ListenBrainz.ArtistAlgorithm},
-	}.Encode()
-
-	log.Trace(ctx, fmt.Sprintf("Sending ListenBrainz Labs %s request", req.Method), "url", req.URL)
-	resp, err := c.hc.Do(req)
-
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var artists []artist
-	jsonErr := decoder.Decode(&artists)
-	if jsonErr != nil {
-		return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-
-	if len(artists) > limit {
-		return artists[:limit], nil
-	}
-
-	return artists, nil
-}
-
-type recording struct {
-	MBID        string `json:"recording_mbid"`
-	Name        string `json:"recording_name"`
-	Artist      string `json:"artist_credit_name"`
-	ReleaseName string `json:"release_name"`
-	ReleaseMBID string `json:"release_mbid"`
-	Score       int    `json:"score"`
-}
-
-func (c *client) getSimilarRecordings(ctx context.Context, mbid string, limit int) ([]recording, error) {
-	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, labsBase+"similar-recordings/json", nil)
-	req.Header.Add("Content-Type", "application/json; charset=UTF-8")
-	req.URL.RawQuery = url.Values{
-		"recording_mbids": []string{mbid}, "algorithm": []string{conf.Server.ListenBrainz.TrackAlgorithm},
-	}.Encode()
-
-	log.Trace(ctx, fmt.Sprintf("Sending ListenBrainz Labs %s request", req.Method), "url", req.URL)
-	resp, err := c.hc.Do(req)
-
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	decoder := json.NewDecoder(resp.Body)
-
-	var recordings []recording
-	jsonErr := decoder.Decode(&recordings)
-	if jsonErr != nil {
-		return nil, fmt.Errorf("ListenBrainz: HTTP Error, Status: (%d)", resp.StatusCode)
-	}
-
-	// For whatever reason, labs API isn't guaranteed to give results in the proper order
-	// and may also provide duplicates. See listenbrainz.labs.similar-recordings-real-out-of-order.json
-	// generated from https://labs.api.listenbrainz.org/similar-recordings/json?recording_mbids=8f3471b5-7e6a-48da-86a9-c1c07a0f47ae&algorithm=session_based_days_180_session_300_contribution_5_threshold_15_limit_50_skip_30
-	slices.SortFunc(recordings, func(a, b recording) int {
-		return cmp.Or(
-			cmp.Compare(b.Score, a.Score), // Sort by score descending
-			cmp.Compare(a.MBID, b.MBID),   // Then by MBID ascending to ensure deterministic order for duplicates
-		)
-	})
-
-	recordings = slices.CompactFunc(recordings, func(a, b recording) bool {
-		return a.MBID == b.MBID
-	})
-
-	if len(recordings) > limit {
-		return recordings[:limit], nil
-	}
-
-	return recordings, nil
-}

adapters/listenbrainz/client_test.go

@@ -4,13 +4,10 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"io"
 	"net/http"
 	"os"
 
-	"github.com/navidrome/navidrome/conf"
-	"github.com/navidrome/navidrome/conf/configtest"
 	"github.com/navidrome/navidrome/tests"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
@@ -120,345 +117,4 @@ var _ = Describe("client", func() {
 			})
 		})
 	})
-
-	Context("getArtistUrl", func() {
-		baseUrl := "https://api.listenbrainz.org/1/metadata/artist?"
-		It("handles a malformed request with status code", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code": 400,"error": "artist mbid 1 is not valid."}`)),
-				StatusCode: 400,
-			}
-			_, err := client.getArtistUrl(context.Background(), "1")
-			Expect(err.Error()).To(Equal("ListenBrainz error(400): artist mbid 1 is not valid."))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "artist_mbids=1"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("handles a malformed request without meaningful body", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(``)),
-				StatusCode: 501,
-			}
-			_, err := client.getArtistUrl(context.Background(), "1")
-			Expect(err.Error()).To(Equal("ListenBrainz: HTTP Error, Status: (501)"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "artist_mbids=1"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("It returns not found when the artist has no official homepage", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.artist.metadata.no_homepage.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			_, err := client.getArtistUrl(context.Background(), "7c2cc610-f998-43ef-a08f-dae3344b8973")
-			Expect(err.Error()).To(Equal("listenbrainz: not found"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "artist_mbids=7c2cc610-f998-43ef-a08f-dae3344b8973"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("It returns data when the artist has a homepage", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.artist.metadata.homepage.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			url, err := client.getArtistUrl(context.Background(), "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56")
-			Expect(err).ToNot(HaveOccurred())
-			Expect(url).To(Equal("http://projectmili.com/"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "artist_mbids=d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-	})
-
-	Context("getArtistTopSongs", func() {
-		baseUrl := "https://api.listenbrainz.org/1/popularity/top-recordings-for-artist/"
-
-		It("handles a malformed request with status code", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`{"code":400,"error":"artist_mbid: '1' is not a valid uuid"}`)),
-				StatusCode: 400,
-			}
-			_, err := client.getArtistTopSongs(context.Background(), "1", 50)
-			Expect(err.Error()).To(Equal("ListenBrainz error(400): artist_mbid: '1' is not a valid uuid"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "1"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("handles a malformed request without standard body", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(``)),
-				StatusCode: 500,
-			}
-			_, err := client.getArtistTopSongs(context.Background(), "1", 1)
-			Expect(err.Error()).To(Equal("ListenBrainz: HTTP Error, Status: (500)"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "1"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("It returns all tracks when given the opportunity", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.popularity.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			data, err := client.getArtistTopSongs(context.Background(), "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 5)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal([]trackInfo{
-				{
-					ArtistName:    "Mili",
-					ArtistMBIDs:   []string{"d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"},
-					DurationMs:    211912,
-					RecordingName: "world.execute(me);",
-					RecordingMbid: "9980309d-3480-4e7e-89ce-fce971a452be",
-					ReleaseName:   "Miracle Milk",
-					ReleaseMBID:   "38a8f6e1-0e34-4418-a89d-78240a367408",
-				},
-				{
-					ArtistName:    "Mili",
-					ArtistMBIDs:   []string{"d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"},
-					DurationMs:    174000,
-					RecordingName: "String Theocracy",
-					RecordingMbid: "afa2c83d-b17f-4029-b9da-790ea9250cf9",
-					ReleaseName:   "String Theocracy",
-					ReleaseMBID:   "d79a38e3-7016-4f39-a31a-f495ce914b8e",
-				},
-			}))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("It returns a subset of tracks when allowed", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.popularity.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			data, err := client.getArtistTopSongs(context.Background(), "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56", 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(data).To(Equal([]trackInfo{
-				{
-					ArtistName:    "Mili",
-					ArtistMBIDs:   []string{"d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"},
-					DurationMs:    211912,
-					RecordingName: "world.execute(me);",
-					RecordingMbid: "9980309d-3480-4e7e-89ce-fce971a452be",
-					ReleaseName:   "Miracle Milk",
-					ReleaseMBID:   "38a8f6e1-0e34-4418-a89d-78240a367408",
-				},
-			}))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(baseUrl + "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-	})
-
-	Context("getSimilarArtists", func() {
-		var algorithm string
-
-		BeforeEach(func() {
-			algorithm = "session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30"
-			DeferCleanup(configtest.SetupConfig())
-		})
-
-		getUrl := func(mbid string) string {
-			return fmt.Sprintf("https://labs.api.listenbrainz.org/similar-artists/json?algorithm=%s&artist_mbids=%s", algorithm, mbid)
-		}
-
-		mbid := "db92a151-1ac2-438b-bc43-b82e149ddd50"
-
-		It("handles a malformed request with status code", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad request`)),
-				StatusCode: 400,
-			}
-			_, err := client.getSimilarArtists(context.Background(), "1", 2)
-			Expect(err.Error()).To(Equal("ListenBrainz: HTTP Error, Status: (400)"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl("1")))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("handles real data properly", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarArtists(context.Background(), mbid, 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson", Score: 800},
-				{MBID: "7364dea6-ca9a-48e3-be01-b44ad0d19897", Name: "a-ha", Score: 792},
-			}))
-		})
-
-		It("truncates data when requested", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarArtists(context.Background(), "db92a151-1ac2-438b-bc43-b82e149ddd50", 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson", Score: 800},
-			}))
-		})
-
-		It("fetches a different endpoint when algorithm changes", func() {
-			algorithm = "session_based_days_1825_session_300_contribution_3_threshold_10_limit_100_filter_True_skip_30"
-			conf.Server.ListenBrainz.ArtistAlgorithm = algorithm
-
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-artists.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarArtists(context.Background(), mbid, 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]artist{
-				{MBID: "f27ec8db-af05-4f36-916e-3d57f91ecf5e", Name: "Michael Jackson", Score: 800},
-				{MBID: "7364dea6-ca9a-48e3-be01-b44ad0d19897", Name: "a-ha", Score: 792},
-			}))
-		})
-	})
-
-	Context("getSimilarRecordings", func() {
-		var algorithm string
-
-		BeforeEach(func() {
-			algorithm = "session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30"
-			DeferCleanup(configtest.SetupConfig())
-		})
-
-		getUrl := func(mbid string) string {
-			return fmt.Sprintf("https://labs.api.listenbrainz.org/similar-recordings/json?algorithm=%s&recording_mbids=%s", algorithm, mbid)
-		}
-
-		mbid := "8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"
-
-		It("handles a malformed request with status code", func() {
-			httpClient.Res = http.Response{
-				Body:       io.NopCloser(bytes.NewBufferString(`Bad request`)),
-				StatusCode: 400,
-			}
-			_, err := client.getSimilarRecordings(context.Background(), "1", 2)
-			Expect(err.Error()).To(Equal("ListenBrainz: HTTP Error, Status: (400)"))
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl("1")))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-		})
-
-		It("handles real data properly", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarRecordings(context.Background(), mbid, 2)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]recording{
-				{
-					MBID:        "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					Name:        "Take On Me",
-					Artist:      "a‐ha",
-					ReleaseName: "Hunting High and Low",
-					ReleaseMBID: "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Score:       124,
-				},
-				{
-					MBID:        "80033c72-aa19-4ba8-9227-afb075fec46e",
-					Name:        "Wake Me Up Before You Go‐Go",
-					Artist:      "Wham!",
-					ReleaseName: "Make It Big",
-					ReleaseMBID: "c143d542-48dc-446b-b523-1762da721638",
-					Score:       65,
-				},
-			}))
-		})
-
-		It("truncates data when requested", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarRecordings(context.Background(), mbid, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]recording{
-				{
-					MBID:        "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					Name:        "Take On Me",
-					Artist:      "a‐ha",
-					ReleaseName: "Hunting High and Low",
-					ReleaseMBID: "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Score:       124,
-				},
-			}))
-		})
-
-		It("properly sorts by score and truncates duplicates", func() {
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings-real-out-of-order.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			// There are actually 5 items. The dedup should happen FIRST
-			resp, err := client.getSimilarRecordings(context.Background(), mbid, 4)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]recording{
-				{
-					MBID:        "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					Name:        "Take On Me",
-					Artist:      "a‐ha",
-					ReleaseName: "Hunting High and Low",
-					ReleaseMBID: "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Score:       124,
-				},
-				{
-					MBID:        "e4b347be-ecb2-44ff-aaa8-3d4c517d7ea5",
-					Name:        "Everybody Wants to Rule the World",
-					Artist:      "Tears for Fears",
-					ReleaseName: "Songs From the Big Chair",
-					ReleaseMBID: "21f19b06-81f1-347a-add5-5d0c77696597",
-					Score:       68,
-				},
-				{
-					MBID:        "80033c72-aa19-4ba8-9227-afb075fec46e",
-					Name:        "Wake Me Up Before You Go‐Go",
-					Artist:      "Wham!",
-					ReleaseName: "Make It Big",
-					ReleaseMBID: "c143d542-48dc-446b-b523-1762da721638",
-					Score:       65,
-				},
-				{
-					MBID:        "ef4c6855-949e-4e22-b41e-8e0a2d372d5f",
-					Name:        "Tainted Love",
-					Artist:      "Soft Cell",
-					ReleaseName: "Non-Stop Erotic Cabaret",
-					ReleaseMBID: "1acaa870-6e0c-4b6e-9e91-fdec4e5ea4b1",
-					Score:       61,
-				},
-			}))
-		})
-
-		It("uses a different algorithm when configured", func() {
-			algorithm = "session_based_days_180_session_300_contribution_5_threshold_15_limit_50_skip_30"
-			conf.Server.ListenBrainz.TrackAlgorithm = algorithm
-
-			f, _ := os.Open("tests/fixtures/listenbrainz.labs.similar-recordings.json")
-			httpClient.Res = http.Response{Body: f, StatusCode: 200}
-			resp, err := client.getSimilarRecordings(context.Background(), mbid, 1)
-			Expect(err).ToNot(HaveOccurred())
-			Expect(httpClient.SavedRequest.Method).To(Equal(http.MethodGet))
-			Expect(httpClient.SavedRequest.URL.String()).To(Equal(getUrl(mbid)))
-			Expect(httpClient.SavedRequest.Header.Get("Content-Type")).To(Equal("application/json; charset=UTF-8"))
-			Expect(resp).To(Equal([]recording{
-				{
-					MBID:        "12f65dca-de8f-43fe-a65d-f12a02aaadf3",
-					Name:        "Take On Me",
-					Artist:      "a‐ha",
-					ReleaseName: "Hunting High and Low",
-					ReleaseMBID: "4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc",
-					Score:       124,
-				},
-			}))
-		})
-	})
 })

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
 }
 

conf/configuration.go

@@ -194,10 +194,8 @@ type deezerOptions struct {
 }
 
 type listenBrainzOptions struct {
-	Enabled         bool
-	BaseURL         string
-	ArtistAlgorithm string
-	TrackAlgorithm  string
+	Enabled bool
+	BaseURL string
 }
 
 type httpHeaderOptions struct {
@@ -658,9 +656,7 @@ func setViperDefaults() {
 	viper.SetDefault("deezer.enabled", true)
 	viper.SetDefault("deezer.language", consts.DefaultInfoLanguage)
 	viper.SetDefault("listenbrainz.enabled", true)
-	viper.SetDefault("listenbrainz.baseurl", consts.DefaultListenBrainzBaseURL)
-	viper.SetDefault("listenbrainz.artistalgorithm", consts.DefaultListenBrainzArtistAlgorithm)
-	viper.SetDefault("listenbrainz.trackalgorithm", consts.DefaultListenBrainzTrackAlgorithm)
+	viper.SetDefault("listenbrainz.baseurl", "https://api.listenbrainz.org/1/")
 	viper.SetDefault("enablescrobblehistory", true)
 	viper.SetDefault("httpheaders.frameoptions", "DENY")
 	viper.SetDefault("backup.path", "")

consts/consts.go

@@ -74,10 +74,6 @@ const (
 
 	DefaultHttpClientTimeOut = 10 * time.Second
 
-	DefaultListenBrainzBaseURL         = "https://api.listenbrainz.org/1/"
-	DefaultListenBrainzArtistAlgorithm = "session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30"
-	DefaultListenBrainzTrackAlgorithm  = "session_based_days_9000_session_300_contribution_5_threshold_15_limit_50_skip_30"
-
 	DefaultScannerExtractor = "taglib"
 	DefaultWatcherWait      = 5 * time.Second
 	Zwsp                    = string('\u200b')

core/transcode/transcode.go

@@ -0,0 +1,689 @@
+package transcode
+
+import (
+	"context"
+	"slices"
+	"strconv"
+	"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
+)
+
+// 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
+	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
+}
+
+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 = StreamDetails{
+		Container:  mf.Suffix,
+		Codec:      mf.AudioCodec(),
+		Bitrate:    sourceBitrate,
+		SampleRate: mf.SampleRate,
+		BitDepth:   mf.BitDepth,
+		Channels:   mf.Channels,
+		Duration:   mf.Duration,
+		Size:       mf.Size,
+		IsLossless: mf.IsLossless(),
+	}
+
+	// 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 := s.computeTranscodedStream(ctx, mf, sourceBitrate, &profile, clientInfo); ts != nil {
+			decision.CanTranscode = true
+			decision.TargetFormat = ts.Container
+			decision.TargetBitrate = ts.Bitrate
+			decision.TargetChannels = ts.Channels
+			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
+}
+
+// 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 ""
+}
+
+// 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 ""
+}
+
+// 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)
+)
+
+// computeTranscodedStream attempts to build a valid transcoded stream for the given profile.
+// 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 {
+	// 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
+	}
+
+	targetFormat := strings.ToLower(profile.Container)
+	if targetFormat == "" {
+		targetFormat = strings.ToLower(profile.AudioCodec)
+	}
+
+	// Verify we have a transcoding config for this format
+	tc, err := s.ds.Transcoding(ctx).FindByFormat(targetFormat)
+	if err != nil || tc == nil {
+		log.Trace(ctx, "Skipping transcoding profile: no transcoding config", "targetFormat", 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:  targetFormat,
+		Codec:      strings.ToLower(profile.AudioCodec),
+		SampleRate: mf.SampleRate,
+		Channels:   mf.Channels,
+		IsLossless: targetIsLossless,
+	}
+	if ts.Codec == "" {
+		ts.Codec = targetFormat
+	}
+
+	// Determine target bitrate (all in kbps)
+	if mf.IsLossless() {
+		if !targetIsLossless {
+			// Lossless to lossy: use client's max transcoding bitrate or default
+			if clientInfo.MaxTranscodingAudioBitrate > 0 {
+				ts.Bitrate = clientInfo.MaxTranscodingAudioBitrate
+			} else {
+				ts.Bitrate = defaultBitrate
+			}
+		} else {
+			// Lossless to lossless: check if bitrate is under the global max
+			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 nil
+			}
+			// No explicit bitrate for lossless target (leave 0)
+		}
+	} else {
+		// Lossy to lossy: preserve source bitrate
+		ts.Bitrate = sourceBitrate
+	}
+
+	// Apply maxAudioBitrate as final cap on transcoded stream (#5)
+	if clientInfo.MaxAudioBitrate > 0 && ts.Bitrate > 0 && ts.Bitrate > clientInfo.MaxAudioBitrate {
+		ts.Bitrate = clientInfo.MaxAudioBitrate
+	}
+
+	// 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 (#4)
+	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)
+			// For lossless codecs, adjusting bitrate is not valid
+			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 nil
+			}
+			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 nil
+			}
+		}
+	}
+
+	return ts
+}
+
+// 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 (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
+		}
+	}
+	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{}
+	if mid, ok := claims["mid"].(string); ok {
+		params.MediaID = mid
+	}
+	if dp, ok := claims["dp"].(bool); ok {
+		params.DirectPlay = dp
+	}
+	if fmt, ok := claims["fmt"].(string); ok {
+		params.TargetFormat = fmt
+	}
+	if br, ok := claims["br"].(float64); ok {
+		params.TargetBitrate = int(br)
+	}
+	if ch, ok := claims["ch"].(float64); ok {
+		params.TargetChannels = int(ch)
+	}
+
+	return params, nil
+}
+
+func containsIgnoreCase(slice []string, s string) bool {
+	return slices.ContainsFunc(slice, func(item string) bool {
+		return strings.EqualFold(item, s)
+	})
+}
+
+// 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
+}()
+
+// 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)
+}
+
+// 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
+}()
+
+// 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 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
+}
+
+func isLosslessFormat(format string) bool {
+	switch strings.ToLower(format) {
+	case "flac", "alac", "wav", "aiff", "ape", "wv", "tta", "tak", "shn", "dsd":
+		return true
+	}
+	return false
+}

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,657 @@
+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: "aac", 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("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("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("rejects an invalid token", func() {
+			_, err := svc.ParseTranscodeParams("invalid-token")
+			Expect(err).To(HaveOccurred())
+		})
+	})
+})

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_to_media_file.sql

@@ -0,0 +1,11 @@
+-- +goose Up
+-- +goose StatementBegin
+ALTER TABLE media_file ADD COLUMN codec VARCHAR(255) DEFAULT '' NOT NULL;
+CREATE INDEX IF NOT EXISTS media_file_codec ON media_file(codec);
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+DROP INDEX IF EXISTS media_file_codec;
+ALTER TABLE media_file DROP COLUMN codec;
+-- +goose StatementEnd

go.mod

@@ -7,14 +7,14 @@ 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 (
 	github.com/Masterminds/squirrel v1.5.4
 	github.com/RaveNoX/go-jsoncommentstrip v1.0.0
 	github.com/andybalholm/cascadia v1.3.3
-	github.com/bmatcuk/doublestar/v4 v4.10.0
+	github.com/bmatcuk/doublestar/v4 v4.9.2
 	github.com/bradleyjkemp/cupaloy/v2 v2.8.0
 	github.com/deluan/rest v0.0.0-20211102003136-6260bc399cbf
 	github.com/deluan/sanitize v0.0.0-20241120162836-fdfd8fdfaa55
@@ -28,7 +28,7 @@ require (
 	github.com/dustin/go-humanize v1.0.1
 	github.com/extism/go-sdk v1.7.1
 	github.com/fatih/structs v1.1.0
-	github.com/go-chi/chi/v5 v5.2.5
+	github.com/go-chi/chi/v5 v5.2.4
 	github.com/go-chi/cors v1.2.2
 	github.com/go-chi/httprate v0.15.0
 	github.com/go-chi/jwtauth/v5 v5.3.3
@@ -49,8 +49,8 @@ require (
 	github.com/mattn/go-sqlite3 v1.14.33
 	github.com/microcosm-cc/bluemonday v1.0.27
 	github.com/mileusna/useragent v1.3.5
-	github.com/onsi/ginkgo/v2 v2.28.1
-	github.com/onsi/gomega v1.39.1
+	github.com/onsi/ginkgo/v2 v2.27.5
+	github.com/onsi/gomega v1.39.0
 	github.com/pelletier/go-toml/v2 v2.2.4
 	github.com/pocketbase/dbx v1.11.0
 	github.com/pressly/goose/v3 v3.26.0
@@ -98,7 +98,7 @@ require (
 	github.com/goccy/go-json v0.10.5 // indirect
 	github.com/goccy/go-yaml v1.19.2 // indirect
 	github.com/google/go-cmp v0.7.0 // indirect
-	github.com/google/pprof v0.0.0-20260202012954-cb029daf43ef // indirect
+	github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83 // indirect
 	github.com/google/subcommands v1.2.0 // indirect
 	github.com/gorilla/css v1.0.1 // indirect
 	github.com/hashicorp/errwrap v1.1.0 // indirect
@@ -134,7 +134,7 @@ require (
 	github.com/stretchr/objx v0.5.3 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/tetratelabs/wabin v0.0.0-20230304001439-f6f874872834 // indirect
-	github.com/zeebo/xxh3 v1.1.0 // indirect
+	github.com/zeebo/xxh3 v1.0.2 // indirect
 	go.opentelemetry.io/proto/otlp v1.9.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.3 // indirect

go.sum

@@ -16,8 +16,8 @@ github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuP
 github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bmatcuk/doublestar/v4 v4.10.0 h1:zU9WiOla1YA122oLM6i4EXvGW62DvKZVxIe6TYWexEs=
-github.com/bmatcuk/doublestar/v4 v4.10.0/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
+github.com/bmatcuk/doublestar/v4 v4.9.2 h1:b0mc6WyRSYLjzofB2v/0cuDUZ+MqoGyH3r0dVij35GI=
+github.com/bmatcuk/doublestar/v4 v4.9.2/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc=
 github.com/bradleyjkemp/cupaloy/v2 v2.8.0 h1:any4BmKE+jGIaMpnU8YgH/I2LPiLBufr6oMMlVBbn9M=
 github.com/bradleyjkemp/cupaloy/v2 v2.8.0/go.mod h1:bm7JXdkRd4BHJk9HpwqAI8BoAY1lps46Enkdqw6aRX0=
 github.com/cespare/reflex v0.3.1 h1:N4Y/UmRrjwOkNT0oQQnYsdr6YBxvHqtSfPB4mqOyAKk=
@@ -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=
@@ -77,8 +77,8 @@ github.com/gkampitakis/go-diff v1.3.2 h1:Qyn0J9XJSDTgnsgHRdz9Zp24RaJeKMUHg2+PDZZ
 github.com/gkampitakis/go-diff v1.3.2/go.mod h1:LLgOrpqleQe26cte8s36HTWcTmMEur6OPYerdAAS9tk=
 github.com/gkampitakis/go-snaps v0.5.15 h1:amyJrvM1D33cPHwVrjo9jQxX8g/7E2wYdZ+01KS3zGE=
 github.com/gkampitakis/go-snaps v0.5.15/go.mod h1:HNpx/9GoKisdhw9AFOBT1N7DBs9DiHo/hGheFGBZ+mc=
-github.com/go-chi/chi/v5 v5.2.5 h1:Eg4myHZBjyvJmAFjFvWgrqDTXFyOzjj7YIm3L3mu6Ug=
-github.com/go-chi/chi/v5 v5.2.5/go.mod h1:X7Gx4mteadT3eDOMTsXzmI4/rwUpOwBHLpAfupzFJP0=
+github.com/go-chi/chi/v5 v5.2.4 h1:WtFKPHwlywe8Srng8j2BhOD9312j9cGUxG1SP4V2cR4=
+github.com/go-chi/chi/v5 v5.2.4/go.mod h1:X7Gx4mteadT3eDOMTsXzmI4/rwUpOwBHLpAfupzFJP0=
 github.com/go-chi/cors v1.2.2 h1:Jmey33TE+b+rB7fT8MUy1u0I4L+NARQlK6LhzKPSyQE=
 github.com/go-chi/cors v1.2.2/go.mod h1:sSbTewc+6wYHBBCW7ytsFSn836hqM7JxpglAy2Vzc58=
 github.com/go-chi/httprate v0.15.0 h1:j54xcWV9KGmPf/X4H32/aTH+wBlrvxL7P+SdnRqxh5g=
@@ -110,8 +110,8 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/go-pipeline v0.0.0-20230411140531-6cbedfc1d3fc h1:hd+uUVsB1vdxohPneMrhGH2YfQuH5hRIK9u4/XCeUtw=
 github.com/google/go-pipeline v0.0.0-20230411140531-6cbedfc1d3fc/go.mod h1:SL66SJVysrh7YbDCP9tH30b8a9o/N2HeiQNUm85EKhc=
-github.com/google/pprof v0.0.0-20260202012954-cb029daf43ef h1:xpF9fUHpoIrrjX24DURVKiwHcFpw19ndIs+FwTSMbno=
-github.com/google/pprof v0.0.0-20260202012954-cb029daf43ef/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
+github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83 h1:z2ogiKUYzX5Is6zr/vP9vJGqPwcdqsWjOt+V8J7+bTc=
+github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI=
 github.com/google/subcommands v1.2.0 h1:vWQspBTo2nEqTUFita5/KeEWlUL8kQObDFbub/EN9oE=
 github.com/google/subcommands v1.2.0/go.mod h1:ZjhPrFU+Olkh9WazFPsl27BQ4UPiG37m3yTrtFlrHVk=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
@@ -197,10 +197,10 @@ github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdh
 github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
 github.com/ogier/pflag v0.0.1 h1:RW6JSWSu/RkSatfcLtogGfFgpim5p7ARQ10ECk5O750=
 github.com/ogier/pflag v0.0.1/go.mod h1:zkFki7tvTa0tafRvTBIZTvzYyAu6kQhPZFnshFFPE+g=
-github.com/onsi/ginkgo/v2 v2.28.1 h1:S4hj+HbZp40fNKuLUQOYLDgZLwNUVn19N3Atb98NCyI=
-github.com/onsi/ginkgo/v2 v2.28.1/go.mod h1:CLtbVInNckU3/+gC8LzkGUb9oF+e8W8TdUsxPwvdOgE=
-github.com/onsi/gomega v1.39.1 h1:1IJLAad4zjPn2PsnhH70V4DKRFlrCzGBNrNaru+Vf28=
-github.com/onsi/gomega v1.39.1/go.mod h1:hL6yVALoTOxeWudERyfppUcZXjMwIMLnuSfruD2lcfg=
+github.com/onsi/ginkgo/v2 v2.27.5 h1:ZeVgZMx2PDMdJm/+w5fE/OyG6ILo1Y3e+QX4zSR0zTE=
+github.com/onsi/ginkgo/v2 v2.27.5/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo=
+github.com/onsi/gomega v1.39.0 h1:y2ROC3hKFmQZJNFeGAMeHZKkjBL65mIZcvrLQBF9k6Q=
+github.com/onsi/gomega v1.39.0/go.mod h1:ZCU1pkQcXDO5Sl9/VVEGlDyp+zm0m1cmeG5TOzLgdh4=
 github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
 github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
@@ -301,8 +301,8 @@ github.com/xrash/smetrics v0.0.0-20250705151800-55b8f293f342/go.mod h1:Ohn+xnUBi
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
 github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
-github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
-github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=
+github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=
 go.opentelemetry.io/proto/otlp v1.9.0 h1:l706jCMITVouPOqEnii2fIAuO3IVGBRPV5ICjceRb/A=
 go.opentelemetry.io/proto/otlp v1.9.0/go.mod h1:xE+Cx5E/eEHw+ISFkwPLwCZefwVjY+pqKg1qcK03+/4=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=

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

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

@@ -16,6 +16,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"
@@ -31,40 +32,42 @@ type handlerRaw = func(http.ResponseWriter, *http.Request) (*responses.Subsonic,
 
 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 +172,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

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/transcode.go

@@ -0,0 +1,349 @@
+package subsonic
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"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         []directPlayProfileReq  `json:"directPlayProfiles,omitempty"`
+	TranscodingProfiles        []transcodingProfileReq `json:"transcodingProfiles,omitempty"`
+	CodecProfiles              []codecProfileReq       `json:"codecProfiles,omitempty"`
+}
+
+// directPlayProfileReq describes a format the client can play directly
+type directPlayProfileReq struct {
+	Containers       []string `json:"containers,omitempty"`
+	AudioCodecs      []string `json:"audioCodecs,omitempty"`
+	Protocols        []string `json:"protocols,omitempty"`
+	MaxAudioChannels int      `json:"maxAudioChannels,omitempty"`
+}
+
+// transcodingProfileReq describes a transcoding target the client supports
+type transcodingProfileReq struct {
+	Container        string `json:"container,omitempty"`
+	AudioCodec       string `json:"audioCodec,omitempty"`
+	Protocol         string `json:"protocol,omitempty"`
+	MaxAudioChannels int    `json:"maxAudioChannels,omitempty"`
+}
+
+// codecProfileReq describes codec-specific limitations
+type codecProfileReq struct {
+	Type        string          `json:"type,omitempty"`
+	Name        string          `json:"name,omitempty"`
+	Limitations []limitationReq `json:"limitations,omitempty"`
+}
+
+// limitationReq describes a specific codec limitation
+type limitationReq 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(n / 1000)
+		} 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
+}
+
+func isValidProtocol(p string) bool {
+	return p == transcode.ProtocolHTTP || p == transcode.ProtocolHLS
+}
+
+func isValidCodecProfileType(t string) bool {
+	return t == transcode.CodecProfileTypeAudio
+}
+
+func isValidLimitationName(n string) bool {
+	return n == transcode.LimitationAudioChannels ||
+		n == transcode.LimitationAudioBitrate ||
+		n == transcode.LimitationAudioProfile ||
+		n == transcode.LimitationAudioSamplerate ||
+		n == transcode.LimitationAudioBitdepth
+}
+
+func isValidComparison(c string) bool {
+	return c == transcode.ComparisonEquals ||
+		c == transcode.ComparisonNotEquals ||
+		c == transcode.ComparisonLessThanEqual ||
+		c == transcode.ComparisonGreaterThanEqual
+}
+
+// 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)
+	}
+
+	// Create transcode params token
+	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")
+	}
+
+	// Determine streaming parameters
+	format := ""
+	maxBitRate := 0
+	if !params.DirectPlay && params.TargetFormat != "" {
+		format = params.TargetFormat
+		maxBitRate = params.TargetBitrate // Already in kbps, matching the streamer
+	}
+
+	// Get offset parameter
+	offset := p.IntOr("offset", 0)
+
+	// Create stream
+	stream, err := api.streamer.NewStream(ctx, mediaID, format, maxBitRate, offset)
+	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/fixtures/listenbrainz.artist.metadata.homepage.json

@@ -1,19 +0,0 @@
-[
-	{
-		"area": "Japan",
-		"artist_mbid": "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-		"begin_year": 2012,
-		"mbid": "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-		"name": "Mili",
-		"rels": {
-			"free streaming": "https://www.deezer.com/artist/56563392",
-			"official homepage": "http://projectmili.com/",
-			"purchase for download": "https://recochoku.jp/artist/2000285803/",
-			"social network": "https://www.instagram.com/projectmili/",
-			"streaming": "https://tidal.com/artist/3848902",
-			"wikidata": "https://www.wikidata.org/wiki/Q27309228",
-			"youtube": "https://www.youtube.com/channel/UCVh47EKH9VLresRqiYi9txw"
-		},
-		"type": "Group"
-	}
-]

tests/fixtures/listenbrainz.artist.metadata.no_homepage.json

@@ -1,15 +0,0 @@
-[
-	{
-		"area": "Japan",
-		"artist_mbid": "7c2cc610-f998-43ef-a08f-dae3344b8973",
-		"mbid": "7c2cc610-f998-43ef-a08f-dae3344b8973",
-		"name": "Feryquitous",
-		"rels": {
-			"free streaming": "https://www.deezer.com/artist/9841008",
-			"purchase for download": "https://itunes.apple.com/jp/artist/id1083544578",
-			"social network": "https://twitter.com/Feryquitous_",
-			"youtube": "https://www.youtube.com/channel/UCj2nw_9puY3sJoDbkE-FCQA"
-		},
-		"type": "Person"
-	}
-]

tests/fixtures/listenbrainz.labs.similar-artists.json

@@ -1 +0,0 @@
-[{"artist_mbid": "f27ec8db-af05-4f36-916e-3d57f91ecf5e", "name": "Michael Jackson", "comment": "\u201cKing of Pop\u201d", "type": "Person", "gender": "Male", "score": 800, "reference_mbid": "db92a151-1ac2-438b-bc43-b82e149ddd50"}, {"artist_mbid": "7364dea6-ca9a-48e3-be01-b44ad0d19897", "name": "a-ha", "comment": "Norwegian synth\u2010pop band", "type": "Group", "gender": null, "score": 792, "reference_mbid": "db92a151-1ac2-438b-bc43-b82e149ddd50"}]

tests/fixtures/listenbrainz.labs.similar-recordings-real-out-of-order.json

@@ -1 +0,0 @@
-[{"recording_mbid":"12f65dca-de8f-43fe-a65d-f12a02aaadf3","recording_name":"Take On Me","artist_credit_name":"a‐ha","artist_credit_mbids":null,"release_name":"Hunting High and Low","release_mbid":"4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc","caa_id":13015069966,"caa_release_mbid":"181b9a01-0446-4601-99be-b011ab615631","score":124,"reference_mbid":"8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"},{"recording_mbid":"12f65dca-de8f-43fe-a65d-f12a02aaadf3","recording_name":"Take On Me","artist_credit_name":"a‐ha","artist_credit_mbids":null,"release_name":"Hunting High and Low","release_mbid":"4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc","caa_id":13015069966,"caa_release_mbid":"181b9a01-0446-4601-99be-b011ab615631","score":124,"reference_mbid":"8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"},{"recording_mbid":"80033c72-aa19-4ba8-9227-afb075fec46e","recording_name":"Wake Me Up Before You Go‐Go","artist_credit_name":"Wham!","artist_credit_mbids":null,"release_name":"Make It Big","release_mbid":"c143d542-48dc-446b-b523-1762da721638","caa_id":2622532701,"caa_release_mbid":"ec01ad0c-a28f-4d45-bed7-d73014161c38","score":65,"reference_mbid":"8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"},{"recording_mbid":"ef4c6855-949e-4e22-b41e-8e0a2d372d5f","recording_name":"Tainted Love","artist_credit_name":"Soft Cell","artist_credit_mbids":null,"release_name":"Non-Stop Erotic Cabaret","release_mbid":"1acaa870-6e0c-4b6e-9e91-fdec4e5ea4b1","caa_id":1031647403,"caa_release_mbid":"c3367d3a-2f6c-48d1-95c5-c1ee7a49c479","score":61,"reference_mbid":"8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"},{"recording_mbid":"e4b347be-ecb2-44ff-aaa8-3d4c517d7ea5","recording_name":"Everybody Wants to Rule the World","artist_credit_name":"Tears for Fears","artist_credit_mbids":null,"release_name":"Songs From the Big Chair","release_mbid":"21f19b06-81f1-347a-add5-5d0c77696597","caa_id":19682986993,"caa_release_mbid":"9aefc6dd-216a-4271-ada1-d9cf67956f39","score":68,"reference_mbid":"8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"}]

tests/fixtures/listenbrainz.labs.similar-recordings.json

@@ -1 +0,0 @@
-[{"recording_mbid":"12f65dca-de8f-43fe-a65d-f12a02aaadf3","recording_name":"Take On Me","artist_credit_name":"a‐ha","artist_credit_mbids":null,"release_name":"Hunting High and Low","release_mbid":"4ec07fe8-e7c6-3106-a0aa-fdf92f13f7fc","caa_id":13015069966,"caa_release_mbid":"181b9a01-0446-4601-99be-b011ab615631","score":124,"reference_mbid":"8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"},{"recording_mbid":"80033c72-aa19-4ba8-9227-afb075fec46e","recording_name":"Wake Me Up Before You Go‐Go","artist_credit_name":"Wham!","artist_credit_mbids":null,"release_name":"Make It Big","release_mbid":"c143d542-48dc-446b-b523-1762da721638","caa_id":2622532701,"caa_release_mbid":"ec01ad0c-a28f-4d45-bed7-d73014161c38","score":65,"reference_mbid":"8f3471b5-7e6a-48da-86a9-c1c07a0f47ae"}]

tests/fixtures/listenbrainz.popularity.json

@@ -1,81 +0,0 @@
-[
-  {
-    "artist_mbids": ["d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"],
-    "artist_name": "Mili",
-    "artists": [
-      {
-        "artist_credit_name": "Mili",
-        "artist_mbid": "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-        "join_phrase": ""
-      }
-    ],
-    "caa_id": 14987576054,
-    "caa_release_mbid": "38a8f6e1-0e34-4418-a89d-78240a367408",
-    "length": 211912,
-    "recording_mbid": "9980309d-3480-4e7e-89ce-fce971a452be",
-    "recording_name": "world.execute(me);",
-    "release_color": { "blue": 109, "green": 94, "red": 95 },
-    "release_mbid": "38a8f6e1-0e34-4418-a89d-78240a367408",
-    "release_name": "Miracle Milk",
-    "tags": [
-      {
-        "count": 1,
-        "genre_mbid": "911c7bbb-172d-4df8-9478-dbff4296e791",
-        "tag": "pop"
-      },
-      {
-        "count": 1,
-        "genre_mbid": "b739a895-85ed-4ad3-8717-4e9ef5387dd8",
-        "tag": "dance-pop"
-      },
-      {
-        "count": 1,
-        "genre_mbid": "9c8ba153-740e-4b88-b7ff-31d004944c95",
-        "tag": "nerdcore"
-      },
-      {
-        "count": 1,
-        "genre_mbid": "c4a69842-f891-4569-9506-1882aa5db433",
-        "tag": "electronic rock"
-      },
-      { "count": 1, "tag": "hackercore" },
-      { "count": 1, "tag": "meter:4/4" },
-      { "count": 1, "tag": "vocal:true" },
-      { "count": 1, "tag": "bpm:130" },
-      {
-        "count": 1,
-        "genre_mbid": "e5bba957-8c91-496a-a675-c6d0c6b51c33",
-        "tag": "dance"
-      },
-      {
-        "count": 1,
-        "genre_mbid": "89255676-1f14-4dd8-bbad-fca839d6aff4",
-        "tag": "electronic"
-      }
-    ],
-    "total_listen_count": 19440,
-    "total_user_count": 1102
-  },
-  {
-    "artist_mbids": ["d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56"],
-    "artist_name": "Mili",
-    "artists": [
-      {
-        "artist_credit_name": "Mili",
-        "artist_mbid": "d2a92ee2-27ce-4e71-bfc5-12e34fe8ef56",
-        "join_phrase": ""
-      }
-    ],
-    "caa_id": 31388973421,
-    "caa_release_mbid": "e58ed9ef-2bc1-4480-9d6d-2d799beb5ba9",
-    "length": 174000,
-    "recording_mbid": "afa2c83d-b17f-4029-b9da-790ea9250cf9",
-    "recording_name": "String Theocracy",
-    "release_color": { "blue": 92, "green": 147, "red": 164 },
-    "release_mbid": "d79a38e3-7016-4f39-a31a-f495ce914b8e",
-    "release_name": "String Theocracy",
-    "tags": [],
-    "total_listen_count": 8986,
-    "total_user_count": 712
-  }
-]