Struct songbird::tracks::Track

pub struct Track {
    pub events: Option<EventStore>,
    pub handle: TrackHandle,
    pub loops: LoopState,
    // some fields omitted
}

Control object for audio playback.

Accessed by both commands and the playback code – as such, access from user code is almost always guarded via a TrackHandle. You should expect to receive access to a raw object of this type via create_player, for use in Driver::play or Driver::play_only.

Example

use songbird::{driver::Driver, ffmpeg, tracks::create_player};

// A Call is also valid here!
let mut handler: Driver = Default::default();
let source = ffmpeg("../audio/my-favourite-song.mp3")
    .await
    .expect("This might fail: handle this error!");
let (mut audio, audio_handle) = create_player(source);

audio.set_volume(0.5);

handler.play_only(audio);

// Future access occurs via audio_handle.

Fields

events: Option<EventStore>

List of events attached to this audio track.

This may be used to add additional events to a track before it is sent to the audio context for playing.

handle: TrackHandle

Handle for safe control of this audio track from other threads.

Typically, this is used by internal code to supply context information to event handlers, though more may be cloned from this handle.

loops: LoopState

Count of remaining loops.

Implementations

impl Track

pub fn new_raw(
    source: Input,
    commands: Receiver<TrackCommand>,
    handle: TrackHandle
) -> Self

Create a new track directly from an input, command source, and handle.

In general, you should probably use create_player.

pub fn play(&mut self) -> &mut Self

Sets a track to playing if it is paused.

pub fn pause(&mut self) -> &mut Self

Pauses a track if it is playing.

pub fn stop(&mut self) -> &mut Self

Manually stops a track.

This will cause the audio track to be removed, with any relevant events triggered. Stopped/ended tracks cannot be restarted.

pub fn playing(&self) -> PlayMode

Returns the current play status of this track.

pub fn set_volume(&mut self, volume: f32) -> &mut Self

Sets volume in a manner that allows method chaining.

pub fn volume(&self) -> f32

Returns the current playback position.

pub fn position(&self) -> Duration

Returns the current playback position.

pub fn play_time(&self) -> Duration

Returns the total length of time this track has been active.

pub fn set_loops(&mut self, loops: LoopState) -> TrackResult<()>

Set an audio track to loop a set number of times.

If the underlying Input does not support seeking, then all calls will fail with TrackError::SeekUnsupported.

pub fn make_playable(&mut self)

Ready a track for playing if it is lazily initialised.

Currently, only Restartable sources support lazy setup. This call is a no-op for all others.

pub fn state(&self) -> TrackState

Creates a read-only copy of the audio track’s state.

The primary use-case of this is sending information across threads in response to a TrackHandle.

pub fn seek_time(&mut self, pos: Duration) -> TrackResult<Duration>

Seek to a specific point in the track.

If the underlying Input does not support seeking, then all calls will fail with TrackError::SeekUnsupported.

pub fn uuid(&self) -> Uuid

Returns this track’s unique identifier.

Trait Implementations

impl Debug for Track

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

Formats the value using the given formatter.