Enum PlayerCommand 

pub enum PlayerCommand {
    Play(QueueItemId),
    Cue {
        id: QueueItemId,
        position_ms: u64,
        play: bool,
    },
    Pause,
    PauseAndReport(Sender<u64>),
    Resume,
    Stop,
    Seek(u64),
    NextTrack,
    PrevTrack,
    AddToPlaylist(Vec<PlaylistItem>),
    RemoveFromPlaylist(QueueItemId),
    RemoveFromPlaylistBatch(Vec<QueueItemId>),
    MoveInPlaylist {
        id: QueueItemId,
        target: QueueItemId,
        after: bool,
    },
    MoveItemsInPlaylist {
        ids: Vec<QueueItemId>,
        target: QueueItemId,
        after: bool,
    },
    ReorderPlaylist(Vec<QueueItemId>),
    UpdatePaths(Vec<(QueueItemId, PathBuf)>),
    InsertInPlaylist {
        items: Vec<PlaylistItem>,
        after: QueueItemId,
    },
    ClearPlaylist,
    ReplacePlaylist {
        items: Vec<PlaylistItem>,
        start: usize,
        position_ms: u64,
        play: bool,
    },
    TrackReady(QueueItemId),
    TrackStreamReady(QueueItemId),
    StreamProbed {
        id: QueueItemId,
        info: Box<StreamInfo>,
        mode: ProbeMode,
    },
    TrackFailed(QueueItemId),
    CacheTracks(Vec<i64>),
    DecodeFinished(u64),
    TrackQueued,
    Undo,
    Redo,
    BeginUndoBatch,
    EndUndoBatch,
    SetOutputDevice(String),
    ClearOutputDevice,
    ReloadDsp,
    RestartOutput,
    UseRenderer(Option<Box<Connection>>),
    ResumeRenderer(Box<Connection>),
    SetRendererVolume(u8),
    SetShuffle(bool),
    SetRepeat(Repeat),
    RestorePlayMode(PlayMode),
    Renderer {
        session: u64,
        event: Event,
    },
}

Commands from the UI layer to the audio engine.

Variants

Play(QueueItemId)

Set the cursor and start playback.

Cue

Set the cursor and load id at position_ms, playing or paused.

What a restored session does. Play, Seek and Pause in turn would start the track from the top and let a moment of it out before the pause.

Fields

id: QueueItemId

position_ms: u64

play: bool

Pause

PauseAndReport(Sender<u64>)

Pause, and answer with the playhead once the output has gone silent: after the fade, where one runs. What a hand-off resumes from.

Resume

Stop

Seek(u64)

NextTrack

PrevTrack

AddToPlaylist(Vec<PlaylistItem>)

RemoveFromPlaylist(QueueItemId)

RemoveFromPlaylistBatch(Vec<QueueItemId>)

Batch remove: delete multiple items as a single undoable operation.

MoveInPlaylist

Fields

id: QueueItemId

target: QueueItemId

after: bool

MoveItemsInPlaylist

Batch move: extract ids and reinsert them at target position.

Fields

ids: Vec<QueueItemId>

target: QueueItemId

after: bool

ReorderPlaylist(Vec<QueueItemId>)

Put the queue in exactly this order, keeping every item.

A queue locked to a playlist follows it, and following a reorder means moving the items that are already there — rebuilding them would issue new ids and throw away what has played, what is mid-download and where the cursor is. Ids not named keep their relative order at the end.

UpdatePaths(Vec<(QueueItemId, PathBuf)>)

Update file paths for playlist items after an organize operation. On Unix, rename() doesn’t invalidate open FDs so playback continues.

InsertInPlaylist

Insert items after a specific queue item (for drag/drop at cursor position).

Fields

items: Vec<PlaylistItem>

after: QueueItemId

ClearPlaylist

Clear the entire playlist (stop + remove all items).

ReplacePlaylist

Replace the playlist and open the track at start, as one operation: from position_ms, playing or paused.

Doing this as ClearPlaylist + AddToPlaylist + Play sends three commands down a bounded channel, and the player acts on each as it arrives: the first track starts, then the cursor jumps, so clicking track nine of an album shows track one playing first. It is three undo entries for one user action. And between the clear and the add the playlist is empty, which tells the download queue that nothing is wanted.

start past the end starts at the beginning. It opens at position_ms, playing or paused, as Cue does: a hand-off picks up where the source stopped without the top of the track being heard.

Fields

items: Vec<PlaylistItem>

start: usize

position_ms: u64

play: bool

TrackReady(QueueItemId)

Download complete — check if cursor is waiting on this item.

TrackStreamReady(QueueItemId)

Enough data buffered for streaming playback — check if cursor is waiting.

StreamProbed

A partial file has been probed off-thread and can be started.

Probing reads as much of the container as it takes to describe itself, which for Ogg means its last page — the whole remaining download. That cannot happen on this loop, so it happens on its own thread and arrives here as a command like anything else. Stale by the time it lands is the normal case, and simply ignored.

Fields

id: QueueItemId

info: Box<StreamInfo>

mode: ProbeMode

What the probe had to settle for. Decoding has to be opened the same way — given a length, a container that went looking for its tail once will do it again, on the decode thread, where the cost is silence instead of a busy player.

TrackFailed(QueueItemId)

Download failed — a cursor parked on this item must stop waiting.

Without it the player sits on a Pending item forever: Ready is the only thing it listens for, and a track that cannot be fetched never becomes Ready. That is the offline-library stall.

CacheTracks(Vec<i64>)

Fetch these tracks into the cache, with no queue entry to play them.

DecodeFinished(u64)

Decode thread exhausted the playlist — auto-advance or stop. Carries the session it came from, so one sent just before a play or seek is recognised as stale.

TrackQueued

The decoder queued the next track, so when the playhead reaches it is now known.

Undo

Undo the last reversible playlist operation.

Redo

Redo the last undone operation.

BeginUndoBatch

Begin collecting undo entries into a single batch (e.g. drag operations).

EndUndoBatch

End the batch — collapse collected entries into one undo step.

SetOutputDevice(String)

Switch output audio device by name. Restarts engine on current track.

ClearOutputDevice

Clear the configured output device, reverting to system default.

ReloadDsp

The DSP profiles, or the device they key on, changed: load them again and carry on where playback is.

RestartOutput

Build the output again on the same device and carry on from where the current track is, paused if it was. For an output the system stopped underneath us: an iOS interruption (a call, Siri) or a reset of its media services leaves the old unit unable to start again.

UseRenderer(Option<Box<Connection>>)

Play to this renderer from now on, carrying on from where the current track is; None brings the music back to this device’s own output. The session is opened by the caller, off this thread: see upnp::connect.

ResumeRenderer(Box<Connection>)

The renderer last used, found on the network after launch. Taken as UseRenderer would be, unless playback or the output has moved since launch, in which case it is dropped: see upnp::resume.

SetRendererVolume(u8)

Set the volume of the renderer being played to, 0–100.

SetShuffle(bool)

Turn shuffle on or off: the items after the cursor reordered at random, or put back as they were. One undo step.

SetRepeat(Repeat)

What follows a track at its end: the queue’s next, the first again after the last, or the same item.

RestorePlayMode(PlayMode)

Take the mode a saved session had, its queue already restored in the order it was saved. Shuffle reorders nothing here.

Renderer

What the renderer was heard to do, during the session numbered session. Dropped once that session is over, like DecodeFinished.

Fields

session: u64

event: Event

Implementations

impl PlayerCommand

pub fn asks_to_play(&self) -> bool

Whether it asks for something to be heard.

Trait Implementations

impl Debug for PlayerCommand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.