feat: experimental downsampling support

server/subsonic/api.go

@@ -25,15 +25,17 @@ type Router struct {
 	Scrobbler     engine.Scrobbler
 	Search        engine.Search
 	Users         engine.Users
+	Streamer      engine.MediaStreamer
 
 	mux http.Handler
 }
 
 func New(browser engine.Browser, cover engine.Cover, listGenerator engine.ListGenerator, users engine.Users,
-	playlists engine.Playlists, ratings engine.Ratings, scrobbler engine.Scrobbler, search engine.Search) *Router {
+	playlists engine.Playlists, ratings engine.Ratings, scrobbler engine.Scrobbler, search engine.Search,
+	streamer engine.MediaStreamer) *Router {
 
 	r := &Router{Browser: browser, Cover: cover, ListGenerator: listGenerator, Playlists: playlists,
-		Ratings: ratings, Scrobbler: scrobbler, Search: search, Users: users}
+		Ratings: ratings, Scrobbler: scrobbler, Search: search, Users: users, Streamer: streamer}
 	r.mux = r.routes()
 	return r
 }

server/subsonic/stream.go

@@ -2,92 +2,51 @@ package subsonic
 
 import (
 	"net/http"
-	"strconv"
 
 	"github.com/deluan/navidrome/engine"
-	"github.com/deluan/navidrome/log"
-	"github.com/deluan/navidrome/model"
 	"github.com/deluan/navidrome/server/subsonic/responses"
-	"github.com/deluan/navidrome/utils"
 )
 
 type StreamController struct {
-	browser engine.Browser
+	streamer engine.MediaStreamer
 }
 
-func NewStreamController(browser engine.Browser) *StreamController {
-	return &StreamController{browser: browser}
+func NewStreamController(streamer engine.MediaStreamer) *StreamController {
+	return &StreamController{streamer: streamer}
 }
 
-func (c *StreamController) getMediaFile(r *http.Request) (mf *engine.Entry, err error) {
+func (c *StreamController) Stream(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
+	id, err := RequiredParamString(r, "id", "id parameter required")
+	if err != nil {
+		return nil, err
+	}
+	maxBitRate := ParamInt(r, "maxBitRate", 0)
+	format := ParamString(r, "format")
+
+	ms, err := c.streamer.NewStream(r.Context(), id, maxBitRate, format)
+	if err != nil {
+		return nil, err
+	}
+
+	// Override Content-Type detected by http.FileServer
+	w.Header().Set("Content-Type", ms.ContentType())
+	http.ServeContent(w, r, ms.Name(), ms.ModTime(), ms)
+	return nil, nil
+}
+
+func (c *StreamController) Download(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
 	id, err := RequiredParamString(r, "id", "id parameter required")
 	if err != nil {
 		return nil, err
 	}
 
-	mf, err = c.browser.GetSong(r.Context(), id)
-	switch {
-	case err == model.ErrNotFound:
-		log.Error(r, "Mediafile not found", "id", id)
-		return nil, NewError(responses.ErrorDataNotFound)
-	case err != nil:
-		log.Error(r, "Error reading mediafile from DB", "id", id, err)
-		return nil, NewError(responses.ErrorGeneric, "Internal error")
-	}
-	return
-}
-
-// TODO Still getting the "Conn.Write wrote more than the declared Content-Length" error.
-// Don't know if this causes any issues
-func (c *StreamController) Stream(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
-	mf, err := c.getMediaFile(r)
+	ms, err := c.streamer.NewStream(r.Context(), id, 0, "raw")
 	if err != nil {
 		return nil, err
 	}
-	maxBitRate := ParamInt(r, "maxBitRate", 0)
-	maxBitRate = utils.MinInt(mf.BitRate, maxBitRate)
-
-	log.Debug(r, "Streaming file", "id", mf.Id, "path", mf.AbsolutePath, "bitrate", mf.BitRate, "maxBitRate", maxBitRate)
-
-	// TODO Send proper estimated content-length
-	//contentLength := mf.Size
-	//if maxBitRate > 0 {
-	//	contentLength = strconv.Itoa((mf.Duration + 1) * maxBitRate * 1000 / 8)
-	//}
-	h := w.Header()
-	h.Set("Content-Length", strconv.Itoa(mf.Size))
-	h.Set("Content-Type", "audio/mpeg")
-	h.Set("Expires", "0")
-	h.Set("Cache-Control", "must-revalidate")
-	h.Set("Pragma", "public")
-
-	if r.Method == "HEAD" {
-		log.Debug(r, "Just a HEAD. Not streaming", "path", mf.AbsolutePath)
-		return nil, nil
-	}
-
-	err = engine.Stream(r.Context(), mf.AbsolutePath, mf.BitRate, maxBitRate, w)
-	if err != nil {
-		log.Error(r, "Error streaming file", "id", mf.Id, err)
-	}
-
-	log.Debug(r, "Finished streaming", "path", mf.AbsolutePath)
-	return nil, nil
-}
-
-func (c *StreamController) Download(w http.ResponseWriter, r *http.Request) (*responses.Subsonic, error) {
-	mf, err := c.getMediaFile(r)
-	if err != nil {
-		return nil, err
-	}
-	log.Debug(r, "Sending file", "path", mf.AbsolutePath)
-
-	err = engine.Stream(r.Context(), mf.AbsolutePath, 0, 0, w)
-	if err != nil {
-		log.Error(r, "Error downloading file", "path", mf.AbsolutePath, err)
-	}
-
-	log.Debug(r, "Finished sending", "path", mf.AbsolutePath)
 
+	// Override Content-Type detected by http.FileServer
+	w.Header().Set("Content-Type", ms.ContentType())
+	http.ServeContent(w, r, ms.Name(), ms.ModTime(), ms)
 	return nil, nil
 }

server/subsonic/wire_gen.go

@@ -59,8 +59,8 @@ func initMediaRetrievalController(router *Router) *MediaRetrievalController {
 }
 
 func initStreamController(router *Router) *StreamController {
-	browser := router.Browser
-	streamController := NewStreamController(browser)
+	mediaStreamer := router.Streamer
+	streamController := NewStreamController(mediaStreamer)
 	return streamController
 }
 
@@ -75,5 +75,5 @@ var allProviders = wire.NewSet(
 	NewSearchingController,
 	NewUsersController,
 	NewMediaRetrievalController,
-	NewStreamController, wire.FieldsOf(new(*Router), "Browser", "Cover", "ListGenerator", "Playlists", "Ratings", "Scrobbler", "Search"),
+	NewStreamController, wire.FieldsOf(new(*Router), "Browser", "Cover", "ListGenerator", "Playlists", "Ratings", "Scrobbler", "Search", "Streamer"),
 )

server/subsonic/wire_injectors.go

@@ -16,7 +16,7 @@ var allProviders = wire.NewSet(
 	NewUsersController,
 	NewMediaRetrievalController,
 	NewStreamController,
-	wire.FieldsOf(new(*Router), "Browser", "Cover", "ListGenerator", "Playlists", "Ratings", "Scrobbler", "Search"),
+	wire.FieldsOf(new(*Router), "Browser", "Cover", "ListGenerator", "Playlists", "Ratings", "Scrobbler", "Search", "Streamer"),
 )
 
 func initSystemController(router *Router) *SystemController {