mirror of
https://github.com/navidrome/navidrome.git
synced 2025-06-09 20:02:22 +03:00
* 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>
288 lines
7.5 KiB
Go
288 lines
7.5 KiB
Go
package playback
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/navidrome/navidrome/core/playback/mpv"
|
|
"github.com/navidrome/navidrome/log"
|
|
"github.com/navidrome/navidrome/model"
|
|
)
|
|
|
|
type Track interface {
|
|
IsPlaying() bool
|
|
SetVolume(value float32) // Used to control the playback volume. A float value between 0.0 and 1.0.
|
|
Pause()
|
|
Unpause()
|
|
Position() int
|
|
SetPosition(offset int) error
|
|
Close()
|
|
}
|
|
|
|
type PlaybackDevice struct {
|
|
ParentPlaybackServer PlaybackServer
|
|
Default bool
|
|
User string
|
|
Name string
|
|
Method string
|
|
DeviceName string
|
|
PlaybackQueue *Queue
|
|
Gain float32
|
|
PlaybackDone chan bool
|
|
ActiveTrack Track
|
|
TrackSwitcherStarted bool
|
|
}
|
|
|
|
type DeviceStatus struct {
|
|
CurrentIndex int
|
|
Playing bool
|
|
Gain float32
|
|
Position int
|
|
}
|
|
|
|
const DefaultGain float32 = 1.0
|
|
|
|
var EmptyStatus = DeviceStatus{CurrentIndex: -1, Playing: false, Gain: DefaultGain, Position: 0}
|
|
|
|
func (pd *PlaybackDevice) getStatus() DeviceStatus {
|
|
pos := 0
|
|
if pd.ActiveTrack != nil {
|
|
pos = pd.ActiveTrack.Position()
|
|
}
|
|
return DeviceStatus{
|
|
CurrentIndex: pd.PlaybackQueue.Index,
|
|
Playing: pd.isPlaying(),
|
|
Gain: pd.Gain,
|
|
Position: pos,
|
|
}
|
|
}
|
|
|
|
// NewPlaybackDevice creates a new playback device which implements all the basic Jukebox mode commands defined here:
|
|
// http://www.subsonic.org/pages/api.jsp#jukeboxControl
|
|
// Starts the trackSwitcher goroutine for the device.
|
|
func NewPlaybackDevice(playbackServer PlaybackServer, name string, method string, deviceName string) *PlaybackDevice {
|
|
return &PlaybackDevice{
|
|
ParentPlaybackServer: playbackServer,
|
|
User: "",
|
|
Name: name,
|
|
Method: method,
|
|
DeviceName: deviceName,
|
|
Gain: DefaultGain,
|
|
PlaybackQueue: NewQueue(),
|
|
PlaybackDone: make(chan bool),
|
|
TrackSwitcherStarted: false,
|
|
}
|
|
}
|
|
|
|
func (pd *PlaybackDevice) String() string {
|
|
return fmt.Sprintf("Name: %s, Gain: %.4f, Loaded track: %s", pd.Name, pd.Gain, pd.ActiveTrack)
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Get(ctx context.Context) (model.MediaFiles, DeviceStatus, error) {
|
|
log.Debug(ctx, "processing Get action")
|
|
return pd.PlaybackQueue.Get(), pd.getStatus(), nil
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Status(ctx context.Context) (DeviceStatus, error) {
|
|
log.Debug(ctx, fmt.Sprintf("processing Status action on: %s, queue: %s", pd, pd.PlaybackQueue))
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
// set is similar to a clear followed by a add, but will not change the currently playing track.
|
|
func (pd *PlaybackDevice) Set(ctx context.Context, ids []string) (DeviceStatus, error) {
|
|
_, err := pd.Clear(ctx)
|
|
if err != nil {
|
|
log.Error(ctx, "error setting tracks", ids)
|
|
return pd.getStatus(), err
|
|
}
|
|
return pd.Add(ctx, ids)
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Start(ctx context.Context) (DeviceStatus, error) {
|
|
log.Debug(ctx, "processing Start action")
|
|
|
|
if !pd.TrackSwitcherStarted {
|
|
log.Info(ctx, "Starting trackSwitcher goroutine")
|
|
// Start one trackSwitcher goroutine with each device
|
|
go func() {
|
|
pd.trackSwitcherGoroutine()
|
|
}()
|
|
pd.TrackSwitcherStarted = true
|
|
}
|
|
|
|
if pd.ActiveTrack != nil {
|
|
if pd.isPlaying() {
|
|
log.Debug("trying to start an already playing track")
|
|
} else {
|
|
pd.ActiveTrack.Unpause()
|
|
}
|
|
} else {
|
|
if !pd.PlaybackQueue.IsEmpty() {
|
|
err := pd.switchActiveTrackByIndex(pd.PlaybackQueue.Index)
|
|
if err != nil {
|
|
return pd.getStatus(), err
|
|
}
|
|
pd.ActiveTrack.Unpause()
|
|
}
|
|
}
|
|
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Stop(ctx context.Context) (DeviceStatus, error) {
|
|
log.Debug(ctx, "processing Stop action")
|
|
if pd.ActiveTrack != nil {
|
|
pd.ActiveTrack.Pause()
|
|
}
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Skip(ctx context.Context, index int, offset int) (DeviceStatus, error) {
|
|
log.Debug(ctx, "processing Skip action", "index", index, "offset", offset)
|
|
|
|
wasPlaying := pd.isPlaying()
|
|
|
|
if pd.ActiveTrack != nil && wasPlaying {
|
|
pd.ActiveTrack.Pause()
|
|
}
|
|
|
|
if index != pd.PlaybackQueue.Index {
|
|
if pd.ActiveTrack != nil {
|
|
pd.ActiveTrack.Close()
|
|
pd.ActiveTrack = nil
|
|
}
|
|
|
|
err := pd.switchActiveTrackByIndex(index)
|
|
if err != nil {
|
|
return pd.getStatus(), err
|
|
}
|
|
}
|
|
|
|
err := pd.ActiveTrack.SetPosition(offset)
|
|
if err != nil {
|
|
log.Error(ctx, "error setting position", err)
|
|
return pd.getStatus(), err
|
|
}
|
|
|
|
if wasPlaying {
|
|
_, err = pd.Start(ctx)
|
|
if err != nil {
|
|
log.Error(ctx, "error starting new track after skipping")
|
|
return pd.getStatus(), err
|
|
}
|
|
}
|
|
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Add(ctx context.Context, ids []string) (DeviceStatus, error) {
|
|
log.Debug(ctx, "processing Add action")
|
|
|
|
items := model.MediaFiles{}
|
|
|
|
for _, id := range ids {
|
|
mf, err := pd.ParentPlaybackServer.GetMediaFile(id)
|
|
if err != nil {
|
|
return DeviceStatus{}, err
|
|
}
|
|
log.Debug(ctx, "Found mediafile: "+mf.Path)
|
|
items = append(items, *mf)
|
|
}
|
|
pd.PlaybackQueue.Add(items)
|
|
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Clear(ctx context.Context) (DeviceStatus, error) {
|
|
log.Debug(ctx, fmt.Sprintf("processing Clear action on: %s", pd))
|
|
if pd.ActiveTrack != nil {
|
|
pd.ActiveTrack.Pause()
|
|
pd.ActiveTrack.Close()
|
|
pd.ActiveTrack = nil
|
|
}
|
|
pd.PlaybackQueue.Clear()
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Remove(ctx context.Context, index int) (DeviceStatus, error) {
|
|
log.Debug(ctx, "processing Remove action")
|
|
// pausing if attempting to remove running track
|
|
if pd.isPlaying() && pd.PlaybackQueue.Index == index {
|
|
_, err := pd.Stop(ctx)
|
|
if err != nil {
|
|
log.Error(ctx, "error stopping running track")
|
|
return pd.getStatus(), err
|
|
}
|
|
}
|
|
|
|
if index > -1 && index < pd.PlaybackQueue.Size() {
|
|
pd.PlaybackQueue.Remove(index)
|
|
} else {
|
|
log.Error(ctx, "Index to remove out of range: "+fmt.Sprint(index))
|
|
}
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
func (pd *PlaybackDevice) Shuffle(ctx context.Context) (DeviceStatus, error) {
|
|
log.Debug(ctx, "processing Shuffle action")
|
|
if pd.PlaybackQueue.Size() > 1 {
|
|
pd.PlaybackQueue.Shuffle()
|
|
}
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
// Used to control the playback volume. A float value between 0.0 and 1.0.
|
|
func (pd *PlaybackDevice) SetGain(ctx context.Context, gain float32) (DeviceStatus, error) {
|
|
log.Debug(ctx, fmt.Sprintf("processing SetGain action. Actual gain: %f, gain to set: %f", pd.Gain, gain))
|
|
|
|
if pd.ActiveTrack != nil {
|
|
pd.ActiveTrack.SetVolume(gain)
|
|
}
|
|
pd.Gain = gain
|
|
|
|
return pd.getStatus(), nil
|
|
}
|
|
|
|
func (pd *PlaybackDevice) isPlaying() bool {
|
|
return pd.ActiveTrack != nil && pd.ActiveTrack.IsPlaying()
|
|
}
|
|
|
|
func (pd *PlaybackDevice) trackSwitcherGoroutine() {
|
|
log.Info("Starting trackSwitcher goroutine")
|
|
for {
|
|
<-pd.PlaybackDone
|
|
log.Info("track switching detected")
|
|
if pd.ActiveTrack != nil {
|
|
pd.ActiveTrack.Close()
|
|
pd.ActiveTrack = nil
|
|
}
|
|
|
|
if !pd.PlaybackQueue.IsAtLastElement() {
|
|
pd.PlaybackQueue.IncreaseIndex()
|
|
log.Debug("Switching to next song", "queue", pd.PlaybackQueue.String())
|
|
err := pd.switchActiveTrackByIndex(pd.PlaybackQueue.Index)
|
|
if err != nil {
|
|
log.Error("error switching track", "error", err)
|
|
}
|
|
pd.ActiveTrack.Unpause()
|
|
} else {
|
|
log.Debug("There is no song left in the playlist. Finish.")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (pd *PlaybackDevice) switchActiveTrackByIndex(index int) error {
|
|
pd.PlaybackQueue.SetIndex(index)
|
|
currentTrack := pd.PlaybackQueue.Current()
|
|
if currentTrack == nil {
|
|
return fmt.Errorf("could not get current track")
|
|
}
|
|
|
|
track, err := mpv.NewTrack(pd.PlaybackDone, *currentTrack)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pd.ActiveTrack = track
|
|
return nil
|
|
}
|