feat: restore the queue and position after a restart
Quitting, a crash or SteamOS restarting the app lost the queue and how far into the track playback was, which hurts most for long items. The queue is now saved to queue.json in the state directory, one queue per user and server, on a track change, on pause, when songs are queued, every 15 seconds while playing and on quit. It holds song metadata, never a stream URL, since those carry the token or the password. On start the saved track is loaded paused and seeked to once it has prerolled. Nothing plays, and the server is not told about the track, until play is pressed. An unreadable file is logged and ignored. Two player bugs had to go for this. A failing source posts several errors, and the later ones counted against the next track, so one missing song skipped two tracks or stopped the queue. Play pressed while a track was still loading was dropped.
This commit is contained in:
+155
-15
@@ -26,6 +26,11 @@ struct Queue {
|
||||
current: Option<usize>,
|
||||
/// Handed to playbin, becomes `current` at its stream-start.
|
||||
pending: Option<usize>,
|
||||
/// Loaded paused by `load_paused` and not played since: a track that
|
||||
/// fails is skipped without starting playback.
|
||||
hold: bool,
|
||||
/// Seconds to seek to once the paused track has prerolled.
|
||||
seek_to: Option<f64>,
|
||||
}
|
||||
|
||||
pub struct Player {
|
||||
@@ -103,11 +108,34 @@ impl Player {
|
||||
}
|
||||
}
|
||||
|
||||
/// Replaces the queue with `urls` and readies `index` paused at
|
||||
/// `position` seconds, so nothing plays until `toggle_pause`. With no
|
||||
/// index the queue is only stored, as after it played to the end.
|
||||
pub fn load_paused(&self, urls: &[String], index: Option<usize>, position: f64) {
|
||||
let url = {
|
||||
let mut q = lock(&self.queue);
|
||||
q.urls = urls.to_vec();
|
||||
q.current = None;
|
||||
q.pending = None;
|
||||
q.hold = false;
|
||||
q.seek_to = None;
|
||||
let Some(i) = index else { return };
|
||||
let Some(url) = q.urls.get(i).cloned() else { return };
|
||||
q.pending = Some(i);
|
||||
q.hold = true;
|
||||
q.seek_to = (position > 0.0).then_some(position);
|
||||
url
|
||||
};
|
||||
start_paused(&self.playbin, &url);
|
||||
}
|
||||
|
||||
pub fn play_index(&self, index: usize) {
|
||||
let url = {
|
||||
let mut q = lock(&self.queue);
|
||||
let Some(url) = q.urls.get(index).cloned() else { return };
|
||||
q.pending = Some(index);
|
||||
q.hold = false;
|
||||
q.seek_to = None;
|
||||
url
|
||||
};
|
||||
// Not under the lock: a state change waits for the streaming threads,
|
||||
@@ -116,11 +144,22 @@ impl Player {
|
||||
}
|
||||
|
||||
pub fn toggle_pause(&self) {
|
||||
let target = match self.playbin.current_state() {
|
||||
// Toggles where the pipeline is heading, so play pressed while a
|
||||
// paused track is still loading is not lost.
|
||||
let (_, current, pending) = self.playbin.state(gst::ClockTime::ZERO);
|
||||
let heading = if pending == gst::State::VoidPending {
|
||||
current
|
||||
} else {
|
||||
pending
|
||||
};
|
||||
let target = match heading {
|
||||
gst::State::Playing => gst::State::Paused,
|
||||
gst::State::Paused => gst::State::Playing,
|
||||
_ => return,
|
||||
};
|
||||
if target == gst::State::Playing {
|
||||
lock(&self.queue).hold = false;
|
||||
}
|
||||
let _ = self.playbin.set_state(target);
|
||||
}
|
||||
|
||||
@@ -142,17 +181,7 @@ impl Player {
|
||||
let Some(pos) = self.playbin.query_position::<gst::ClockTime>() else {
|
||||
return;
|
||||
};
|
||||
let mut target = (pos.seconds_f64() + seconds).max(0.0);
|
||||
if let Some(dur) = self.playbin.query_duration::<gst::ClockTime>() {
|
||||
target = target.min((dur.seconds_f64() - 1.0).max(0.0));
|
||||
}
|
||||
let flags = gst::SeekFlags::FLUSH | gst::SeekFlags::KEY_UNIT;
|
||||
if let Err(e) = self
|
||||
.playbin
|
||||
.seek_simple(flags, gst::ClockTime::from_seconds_f64(target))
|
||||
{
|
||||
log::debug!("seek failed: {e}");
|
||||
}
|
||||
seek_to(&self.playbin, pos.seconds_f64() + seconds);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -178,6 +207,27 @@ fn start(playbin: &gst::Element, url: &str) {
|
||||
}
|
||||
}
|
||||
|
||||
fn start_paused(playbin: &gst::Element, url: &str) {
|
||||
let _ = playbin.set_state(gst::State::Ready);
|
||||
playbin.set_property("uri", url);
|
||||
if let Err(e) = playbin.set_state(gst::State::Paused) {
|
||||
log::warn!("could not load the track: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
/// Seeks to `seconds`, kept a second short of the end so a stale position
|
||||
/// does not land past a track that has since changed.
|
||||
fn seek_to(playbin: &gst::Element, seconds: f64) {
|
||||
let mut target = seconds.max(0.0);
|
||||
if let Some(dur) = playbin.query_duration::<gst::ClockTime>() {
|
||||
target = target.min((dur.seconds_f64() - 1.0).max(0.0));
|
||||
}
|
||||
let flags = gst::SeekFlags::FLUSH | gst::SeekFlags::KEY_UNIT;
|
||||
if let Err(e) = playbin.seek_simple(flags, gst::ClockTime::from_seconds_f64(target)) {
|
||||
log::debug!("seek failed: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, emit: &dyn Fn(PlayerEvent)) {
|
||||
let Some(bus) = playbin.bus() else { return };
|
||||
let mut last_tick = Instant::now();
|
||||
@@ -217,6 +267,16 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
|
||||
gst::State::Paused if s.pending() == gst::State::VoidPending => emit(PlayerEvent::Paused(true)),
|
||||
_ => {}
|
||||
},
|
||||
// Prerolled: the first moment a paused track can seek, and the
|
||||
// ticks below report no position while paused, so report it here.
|
||||
MessageView::AsyncDone(_) => {
|
||||
let target = lock(queue).seek_to.take();
|
||||
if let Some(s) = target {
|
||||
seek_to(playbin, s);
|
||||
} else if let Some(p) = playbin.query_position::<gst::ClockTime>() {
|
||||
emit(PlayerEvent::Position(p.seconds_f64()));
|
||||
}
|
||||
}
|
||||
MessageView::Eos(_) => {
|
||||
{
|
||||
let mut q = lock(queue);
|
||||
@@ -226,15 +286,23 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
|
||||
let _ = playbin.set_state(gst::State::Ready);
|
||||
report_track(None, false);
|
||||
}
|
||||
// A failing source posts several errors. Once the first has moved
|
||||
// on to the next track, the source is out of playbin and the rest
|
||||
// would count as the next track failing too.
|
||||
MessageView::Error(err) if err.src().is_some_and(|s| !s.has_as_ancestor(playbin)) => {
|
||||
log::debug!("dropping an error from a track already skipped: {}", err.error());
|
||||
}
|
||||
MessageView::Error(err) => {
|
||||
let detail = err.debug().map(|d| d.to_string()).unwrap_or_default();
|
||||
log::warn!("playback error: {} ({})", err.error(), strip_queries(&detail));
|
||||
// Skip the track that failed rather than stopping the queue.
|
||||
let (next, len) = {
|
||||
let (next, len, hold) = {
|
||||
let mut q = lock(queue);
|
||||
let failed = q.pending.take().or(q.current);
|
||||
q.current = None;
|
||||
(failed.map_or(usize::MAX, |i| i + 1), q.urls.len())
|
||||
// The position belonged to the track that failed.
|
||||
q.seek_to = None;
|
||||
(failed.map_or(usize::MAX, |i| i + 1), q.urls.len(), q.hold)
|
||||
};
|
||||
if next < len {
|
||||
let url = {
|
||||
@@ -242,7 +310,11 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
|
||||
q.pending = Some(next);
|
||||
q.urls[next].clone()
|
||||
};
|
||||
start(playbin, &url);
|
||||
if hold {
|
||||
start_paused(playbin, &url);
|
||||
} else {
|
||||
start(playbin, &url);
|
||||
}
|
||||
} else {
|
||||
let _ = playbin.set_state(gst::State::Ready);
|
||||
report_track(None, false);
|
||||
@@ -395,4 +467,72 @@ mod tests {
|
||||
drop(player);
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_paused_load_seeks_and_waits_for_play() {
|
||||
// SAFETY: set before any thread reads the environment in this test.
|
||||
unsafe { std::env::set_var("REMUS_AUDIO_SINK", "fakesink") };
|
||||
let dir = std::env::temp_dir().join(format!("remus-player-paused-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
// The saved track no longer exists, so the next one is readied instead.
|
||||
let missing = format!("file://{}", dir.join("gone.wav").display());
|
||||
let urls = vec![
|
||||
silent_wav(&dir, "a.wav", 10.0),
|
||||
missing,
|
||||
silent_wav(&dir, "c.wav", 10.0),
|
||||
];
|
||||
|
||||
let (tx, rx) = mpsc::channel();
|
||||
let player = Player::spawn(move |ev| {
|
||||
let _ = tx.send(ev);
|
||||
})
|
||||
.unwrap();
|
||||
player.load_paused(&urls, Some(1), 5.0);
|
||||
|
||||
let mut track = None;
|
||||
let mut started = false;
|
||||
let deadline = Instant::now() + Duration::from_secs(2);
|
||||
while let Some(left) = deadline.checked_duration_since(Instant::now()) {
|
||||
match rx.recv_timeout(left) {
|
||||
Ok(PlayerEvent::Track(t)) => track = t,
|
||||
Ok(PlayerEvent::Paused(false)) => started = true,
|
||||
Ok(PlayerEvent::Position(p)) if p > 0.0 => started = true,
|
||||
Ok(_) => {}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
assert_eq!(track, Some(2), "skipped the missing track");
|
||||
assert!(!started, "nothing plays before play is pressed");
|
||||
|
||||
player.toggle_pause();
|
||||
let mut played = false;
|
||||
while let Ok(ev) = rx.recv_timeout(Duration::from_secs(3)) {
|
||||
if let PlayerEvent::Position(p) = ev
|
||||
&& p > 0.0
|
||||
{
|
||||
played = true;
|
||||
// The seek was dropped with the track it belonged to.
|
||||
assert!(p < 4.0, "position {p}");
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert!(played, "plays once play is pressed");
|
||||
|
||||
player.load_paused(&urls, Some(0), 5.0);
|
||||
player.toggle_pause();
|
||||
let mut pos = None;
|
||||
while let Ok(ev) = rx.recv_timeout(Duration::from_secs(3)) {
|
||||
if let PlayerEvent::Position(p) = ev
|
||||
&& p > 0.0
|
||||
{
|
||||
pos = Some(p);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let p = pos.expect("a position once playing");
|
||||
assert!((4.5..7.0).contains(&p), "resumed at {p}");
|
||||
|
||||
drop(player);
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user