Jukebox mode (#2289)

* Adding cache directory to ignore-list * Adding jukebox-related config options * Adding DevEnableJukebox config option pls. dummy server * Adding types and routers * Now without panic * First draft on parsing the action * Some cleanups * Adding playback server * Verify audio device configuration * Adding debug-build target to have full symbol support * Adding beep sound library pls some example code. Not working yet * Play a fixed mp3 on any interface access for testing purposes * Put action code into separate file, adding stringer, more debug output, prepare structs, validation * Put action parameter parser code where it belongs * Have a single Action transporting all information * User fmt.Errorf for error-generation * Adding wide playback interface * Use action map for parsing, stringer instead switch stmt. * Use but only one switch case and direct dispatch, refactoring * Add error handling and pushing to client * send decent errormessage, no internal server error * Adding playback devices slice and load it from config * Combine config-verification and structure init * Return user-specific device * Separate playback server from device * Use dataStore to retrieve mediafile by id * WIP: Playlist and start/stop handling. Doing start/stop the hard way as of now * WIP: set, start and stop work on one single song. More to come * Dont need to wait for the end * Merge jukebox_action.go into jukebox.go * Remove getParameterAsInt64(). Use existing requiredParamInt() instead * Dont need to call newFailure() explicitly * Remove int64, use int instead. * Add and set action now accept multiple ids * Kickout copy of childFromMediaFile(). It is not needed here. * Refactoring devices and playbackServer * Turn (internal) playback.DeviceStatus into subsonic JukeboxStatus when rendering output. Indexes int64 -> int * Now we have a position and playing status * Switching gain to float32, xs:float is defined as 32 bit. Fixing nasty copy/pointer bug * Now with volume control * Start working the queue * Remove user from device interface * Rename function GetDevice -> GetDeviceForUser to make intention clearer * Have a nice stringer for the queue * User Prepared boolean for now to allow pause/unpause * Skipping works, but without offsets * Make ChildFromMediaFile public to be used in jukebox get() implementation * Return position in seconds and implement offset-skip in seconds * Default offset to 0 * Adding a simple setGain implementation * Prepare for transcoding AAC * WIP: transcode to WAV to use beeps wav decoder. Not done yet. * WIP: out of sheer desparation: convert to MP3 (which works) rather than WAV to troubleshoot issue. * Use FLAC as intermediate format to play Apple AAC * A bit of cleanup * Catching the end-of-stream event for further reactions * Have a trackSwitching goroutine waiting on channel when track ends * Move decoder code into own file. Restructure code a bit * Now with going on to play the next song in the playlist * Adding shuffle feature * Implementing remove action * Cleanup code * Remove templates for ffmpeg mp3 generation. Not needed anymore. * Adding some documentation * Check whether offset into track is in range. Fixing potential remove track bug. Documentation * Make golangci-lint happy: handling return values * Adding test suite and example dummy for playback package * Adding some basic queue tests * Only use Jukebox.Enabled config option * Adding stream closing handling * Pass context.Context to all PlaybackDevice methods * Remove unneeded function * Correct spelling * Reduce visibility of ChildFromMediaFile * Decomplicate action-parsing * Adding simple tempfile-based AAC->FLAC transcoding. No parallel reading and writing yet. * Try to optimize pipe-writing, tempfile-handling and reading. Not done yet. * Do a synchronous copy of the tempfile. Racecondition detected * More debugging statements and fixing the play/pause bug. More work needed * Start the trackSwitcher() with each device once. Return JSON position even if its 0. More debug-output * Moving all track-handling code into own module * Fix typo. Do not pass ctx around when not applicable * WIP: More refactoring, debugging output * Fix nil pointer * Repairing MP3 playback by pinning indirect dependencies: hajimehoshi/go-mp3 and hajimehoshi/oto * Do not forget to cleanup after a skip action * Make resync with master easy * Adding missing mocks * Adding missing error-handling found by linter * Updating github.com/hajimehoshi/oto * Removing duplicate function * Move BEEP-related code into own package * Juggle beep-related code around as preparation for interface access * More refactoring for interface separation * Gather CloseDevice() behind Track interface. * Adding skeleton, draft audio-interface using mpv.io * Adding majority of interface commands using messages to mpv socket. * Adding end-of-stream handling * MPV: start/stop are working * postition is given in float in mpv * Unify Close() and CloseDevice(). Using temp filename for controlling socket * Wait until control-socket shows up. Cleanup socket in Close() * Use canceable command. Rename to Executor * Skipping tracks works now * Now with actually setting the position * Fix regain * Add missing error-handling found by linter * Adding retry mode on time-pos property getter * Remove unneeded code on queue * Putting build-tag beep onto beep files * Remove deprecated call to rand.Seed() "As of Go 1.20 there is no reason to call Seed with a random value. Programs that call Seed with a known value to get a specific sequence of results should use New(NewSource(seed)) to obtain a local random generator." * Using int32 to conform to Subsonic API spec * Fix merge error * Minor style changes * Get username from context --------- Co-authored-by: Deluan <deluan@navidrome.org>
2023-09-10 17:25:22 +02:00
parent f941347cf1
commit 1b16e1140f
19 changed files with 1656 additions and 109 deletions
@@ -179,8 +179,15 @@ func (api *Router) routes() http.Handler {
 		h(r, "getOpenSubsonicExtensions", api.GetOpenSubsonicExtensions)
 	})

+	if conf.Server.Jukebox.Enabled {
+		r.Group(func(r chi.Router) {
+			h(r, "jukeboxControl", api.JukeboxControl)
+		})
+	} else {
+		h501(r, "jukeboxControl")
+	}
+
 	// Not Implemented (yet?)
-	h501(r, "jukeboxControl")
 	h501(r, "getPodcasts", "getNewestPodcasts", "refreshPodcasts", "createPodcastChannel", "deletePodcastChannel",
 		"deletePodcastEpisode", "downloadPodcastEpisode")
 	h501(r, "createUser", "updateUser", "deleteUser", "changePassword")
@@ -0,0 +1,142 @@
+package subsonic
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	"github.com/navidrome/navidrome/core/playback"
+	"github.com/navidrome/navidrome/log"
+	"github.com/navidrome/navidrome/server/subsonic/responses"
+)
+
+const (
+	ActionGet     = "get"
+	ActionStatus  = "status"
+	ActionSet     = "set"
+	ActionStart   = "start"
+	ActionStop    = "stop"
+	ActionSkip    = "skip"
+	ActionAdd     = "add"
+	ActionClear   = "clear"
+	ActionRemove  = "remove"
+	ActionShuffle = "shuffle"
+	ActionSetGain = "setGain"
+)
+
+func (api *Router) JukeboxControl(r *http.Request) (*responses.Subsonic, error) {
+	ctx := r.Context()
+	user := getUser(ctx)
+
+	actionString, err := requiredParamString(r, "action")
+	if err != nil {
+		return nil, err
+	}
+
+	pbServer := playback.GetInstance()
+	pb, err := pbServer.GetDeviceForUser(user.UserName)
+	if err != nil {
+		return nil, err
+	}
+	log.Debug(fmt.Sprintf("processing action: %s", actionString))
+
+	switch actionString {
+	case ActionGet:
+		mediafiles, status, err := pb.Get(ctx)
+		if err != nil {
+			return nil, err
+		}
+
+		playlist := responses.JukeboxPlaylist{
+			JukeboxStatus: *deviceStatusToJukeboxStatus(status),
+			Entry:         childrenFromMediaFiles(ctx, mediafiles),
+		}
+
+		response := newResponse()
+		response.JukeboxPlaylist = &playlist
+		return response, nil
+	case ActionStatus:
+		return createResponse(pb.Status(ctx))
+	case ActionSet:
+		ids, err := requiredParamStrings(r, "id")
+		if err != nil {
+			return nil, newError(responses.ErrorMissingParameter, "missing parameter id, err: %s", err)
+		}
+		status, err := pb.Set(ctx, ids)
+		if err != nil {
+			return nil, err
+		}
+		return statusResponse(status), nil
+	case ActionStart:
+		return createResponse(pb.Start(ctx))
+	case ActionStop:
+		return createResponse(pb.Stop(ctx))
+	case ActionSkip:
+		index, err := requiredParamInt(r, "index")
+		if err != nil {
+			return nil, newError(responses.ErrorMissingParameter, "missing parameter index, err: %s", err)
+		}
+
+		offset, err := requiredParamInt(r, "offset")
+		if err != nil {
+			offset = 0
+		}
+
+		return createResponse(pb.Skip(ctx, index, offset))
+	case ActionAdd:
+		ids, err := requiredParamStrings(r, "id")
+		if err != nil {
+			return nil, newError(responses.ErrorMissingParameter, "missing parameter id, err: %s", err)
+		}
+
+		return createResponse(pb.Add(ctx, ids))
+	case ActionClear:
+		return createResponse(pb.Clear(ctx))
+	case ActionRemove:
+		index, err := requiredParamInt(r, "index")
+		if err != nil {
+			return nil, err
+		}
+
+		return createResponse(pb.Remove(ctx, index))
+	case ActionShuffle:
+		return createResponse(pb.Shuffle(ctx))
+	case ActionSetGain:
+		gainStr, err := requiredParamString(r, "gain")
+		if err != nil {
+			return nil, newError(responses.ErrorMissingParameter, "missing parameter gain, err: %s", err)
+		}
+
+		gain, err := strconv.ParseFloat(gainStr, 32)
+		if err != nil {
+			return nil, newError(responses.ErrorMissingParameter, "error parsing gain integer value, err: %s", err)
+		}
+
+		return createResponse(pb.SetGain(ctx, float32(gain)))
+	default:
+		return nil, newError(responses.ErrorMissingParameter, "Unknown action: %s", actionString)
+	}
+}
+
+// createResponse is to shorten the case-switch in the JukeboxController
+func createResponse(status playback.DeviceStatus, err error) (*responses.Subsonic, error) {
+	if err != nil {
+		return nil, err
+	}
+	return statusResponse(status), nil
+}
+
+func statusResponse(status playback.DeviceStatus) *responses.Subsonic {
+	response := newResponse()
+	response.JukeboxStatus = deviceStatusToJukeboxStatus(status)
+	return response
+}
+
+func deviceStatusToJukeboxStatus(status playback.DeviceStatus) *responses.JukeboxStatus {
+	return &responses.JukeboxStatus{
+		CurrentIndex: int32(status.CurrentIndex),
+		Playing:      status.Playing,
+		Gain:         status.Gain,
+		Position:     int32(status.Position),
+	}
+}
@@ -51,7 +51,11 @@ type Subsonic struct {
 	ScanStatus *ScanStatus `xml:"scanStatus,omitempty"                                    json:"scanStatus,omitempty"`
 	Lyrics     *Lyrics     `xml:"lyrics,omitempty"                                        json:"lyrics,omitempty"`

-	InternetRadioStations  *InternetRadioStations  `xml:"internetRadioStations,omitempty"  json:"internetRadioStations,omitempty"`
+	InternetRadioStations *InternetRadioStations `xml:"internetRadioStations,omitempty"   json:"internetRadioStations,omitempty"`
+
+	JukeboxStatus   *JukeboxStatus   `xml:"jukeboxStatus,omitempty"                       json:"jukeboxStatus,omitempty"`
+	JukeboxPlaylist *JukeboxPlaylist `xml:"jukeboxPlaylist,omitempty"                     json:"jukeboxPlaylist,omitempty"`
+
 	OpenSubsonicExtensions *OpenSubsonicExtensions `xml:"openSubsonicExtensions,omitempty"  json:"openSubsonicExtensions,omitempty"`
 }

@@ -402,4 +406,15 @@ type Radio struct {
 	HomepageUrl string `xml:"homePageUrl,omitempty,attr" json:"homePageUrl,omitempty"`
 }

+type JukeboxStatus struct {
+	CurrentIndex int32   `xml:"currentIndex,attr"       json:"currentIndex"`
+	Playing      bool    `xml:"playing,attr"            json:"playing"`
+	Gain         float32 `xml:"gain,attr"               json:"gain"`
+	Position     int32   `xml:"position,omitempty,attr" json:"position"`
+}
+
+type JukeboxPlaylist struct {
+	JukeboxStatus
+	Entry []Child `xml:"entry,omitempty"         json:"entry,omitempty"`
+}
 type OpenSubsonicExtensions struct{}