Compare commits

...
18 Commits
Author SHA1 Message Date
Ansho Rei 768ef0f919 chore: bump the version to 0.9.0 for shuffle 2026-11-05 19:29:17 +01:00
Ansho Rei 26d8bc417c feat: show the shuffle mode beside the queue on the now-playing screen
The hint bar names the mode too, but it can be turned off.
2026-11-05 19:22:54 +01:00
Ansho Rei 0200e73ba3 feat: shuffle the whole library from the Random section
Shuffle all, the first tile of the Random section, plays random tracks
from getRandomSongs and fetches another batch when fewer than five are
left. Played tracks past the last fifty are dropped, so the queue stays
small. Tracks queued meanwhile play after the playing track and after
anything queued before them, ahead of the random ones. Playing anything
else ends it, and it carries on after a restart.
2026-11-05 19:07:01 +01:00
Ansho Rei e11d95daa5 feat: shuffle play an album, artist or playlist with a long press
Holding South on a row, or shift+s on the keyboard, plays its tracks in
random order with track shuffle on, so turning shuffle off goes back to
their own order. On a song row it shuffles the page the song is on. An
artist plays every track of every album, fetched a few albums at a time.

South now acts on release, so a long press can mean something else. A
long press on a row with nothing to shuffle activates as before.
2026-11-05 19:04:08 +01:00
Ansho Rei 3d91739447 feat: cycle the queue through track shuffle, album shuffle and off
North on the now-playing screen, or s anywhere, shuffles what has not
played yet. Off goes back to the order the tracks were queued in and
carries on after the playing track. Tracks queued while shuffled go to
random positions, an album as one block under album shuffle.

The player reorders its own list under its lock and keeps a track it
already handed to playbin next, so playback stays gapless. Each reorder
bumps a queue generation that track and picture events carry, and the
app drops an event sent before the last reorder. The saved queue keeps
the original order and the mode; older files load unshuffled.
2026-11-05 18:57:56 +01:00
Ansho Rei 7b2fe7c84e feat: add track, album and insert shuffle orders
Each function returns positions in the new play order, so the queue,
the original order and the player's URLs can be reordered by the same
list. Nothing calls them yet.
2026-11-05 18:39:03 +01:00
Ansho Rei 10710c1755 feat: read a song's album id and fetch random songs from the server
Album shuffle groups tracks by album id, since the album name alone
merges different albums with the same title. Library shuffle tops up
the queue with getRandomSongs.
2026-11-05 18:39:03 +01:00
Ansho Rei bce0d68442 feat: show a track's own cover on its album page row
A track whose cover is a different picture from the album's now shows
that cover in its row instead of the track number. Pictures are compared
decoded, since Navidrome gives every track its own cover id even when it
is the album's image. The number column is as wide as the cover, so rows
with and without one line up.
2026-11-04 22:09:32 +01:00
Ansho Rei d77316b5b7 fix: delete covers cached before they were kept per server
Since 0.8.0 covers are cached in a directory per server. The files that
earlier versions wrote straight into the cache root were never read
again and never removed. They are now deleted once on start, in the
background; the server directories are left alone.
2026-11-04 21:35:04 +01:00
Ansho Rei 5b678d4f1c docs: say where the version shows while the controls bar is hidden
The README said the version is on every screen. Since the controls bar
can be turned off, it moves to a Version row in Settings instead.
2026-11-04 21:33:46 +01:00
Ansho Rei a005c3207a fix: ignore the controller while another window is in front
remus reads the controller from the device, whichever window has focus,
so presses meant for a game in front also skipped tracks and paused in
remus. It now follows winit's focus events, through slint's
unstable-winit-030 feature since Slint does not expose window activation
itself, and drops controller presses while the window is not in front.
It assumes focus until told otherwise, so a window manager that never
reports focus keeps the controller working.
2026-11-04 20:51:33 +01:00
Ansho Rei 6997e7cd93 fix: show the picture in the playing track's file on the now-playing screen
Nextcloud Music gives every song of an album the album's cover id, so
tracks with their own art all showed the album cover. The player now
reads the picture embedded in each file it decodes and reports it once
per track, or reports that there is none. The now-playing art, backdrop
and palette use it, and wait for that answer so they do not show the
album cover first and then change. Lists and the queue keep the
server's cover.

Pictures are read where each file's decoder hands on its stream:
further down, a file without a picture still carries the previous
file's tags after a gapless switch.
2026-11-04 20:22:03 +01:00
Ansho Rei b5ef9fbb13 fix: centre the play/pause icon and volume bar under the progress
The icon was centred in the space between the two times, so it moved
when their widths differed. The time row is now placed by hand: times
at the edges, icon on the row's midpoint.

The volume row was centred as a whole, and its number label is wider
than the speaker, so the bar sat left of centre. On now playing the
speaker now gets a box as wide as the label, which puts the bar in the
middle. The bottom bar keeps the compact layout.
2026-11-04 19:38:26 +01:00
Ansho Rei 3518462dde feat: show the password on the login screen on request
The password field has an eye at its right end that switches the field
between masked and plain text, struck through while the text shows. From
a controller, the queue button toggles it while the field is selected,
and the hint bar says so. A keyboard types into the field, so it uses
the eye instead. It is hidden again each time the login screen opens.
2026-11-04 19:06:11 +01:00
Ansho Rei d4de15acd8 feat: keep several logins and switch between them
config.toml now holds a list of [[server]] logins and the active one.
The single-login file of earlier versions loads as the only entry.

Settings lists the servers first: confirm switches, the queue button
pressed twice removes, and Add server opens the login form, which can
now be cancelled. Removing the last login returns to the login screen.

A switch saves the queue of the server being left, stops the player and
restores the other server's saved queue paused. Player events sent
before the stop are dropped by an epoch, and cover loads started for the
old server by a generation, so nothing of one server shows on the other.
Covers are cached on disk per server, keyed like the saved queue.

The shoulder triggers wrap around the sections, which puts Settings one
press from the first section.
2026-11-04 18:23:30 +01:00
Ansho Rei 0bcba21f1a feat: control playback through MPRIS
Remus owns org.mpris.MediaPlayer2.remus on the session bus and serves
the root and player interfaces: play, pause, play-pause, stop, next,
previous and quit, with the playback status, track metadata, position
and volume. Desktops route media keys to the active MPRIS player, and
headphone buttons arrive as media keys, so this is how they reach remus.

Reading the headphones' input devices directly was ruled out: keyboard
type devices, AVRCP included, are root:input, and only gamepads are
opened up to the logged-in user. Seeking is not offered (CanSeek false).

The Flatpak gets --own-name for the bus name.
2026-11-04 17:57:32 +01:00
Ansho Rei ab42814302 feat: add a setting to hide the controls bar
Settings has a Show controls bar toggle, on by default and saved as
show_hint_bar. Off, the hint bar goes from the browse and now-playing
screens and the content takes its height. The login screen keeps it,
since the controls are not known yet there and Settings is out of reach.

The bar is where the version shows, so while it is off Settings lists
the version instead.
2026-11-04 17:18:16 +01:00
Ansho Rei a5d51cf044 fix: place the volume level under the progress and in the bottom bar
On now playing it is centred under the progress bar. The bottom bar on
the other screens shows it too, at the right after the time and play
state. Its number has a fixed width: with only a minimum, the row gave
it the spare space and pushed the time into the middle.
2026-11-04 15:44:34 +01:00
20 changed files with 2642 additions and 167 deletions
+76
View File
@@ -2,6 +2,82 @@
One section per version, newest first.
## v0.9.0 (2026-11-05)
### Features
- The queue can be shuffled from the now-playing screen. The queue button, or S on the keyboard, cycles through shuffling by track, shuffling by album and off. Album shuffle finishes the playing album first. Off goes back to the order the tracks were queued in and carries on after the playing track. Tracks queued while shuffled go to random places among those still to play. The mode shows beside the queue and comes back after a restart.
- Holding the activate button on an album, artist or playlist, or pressing Shift+S, plays it shuffled. On a track it shuffles the page the track is on. The activate button now acts when it is released.
- Shuffle all, the first tile in Random, plays random tracks from the whole library and keeps fetching more. Tracks queued meanwhile play next, ahead of the random ones.
## v0.8.7 (2026-11-04)
### Features
- On an album page, a track whose cover is a different picture from the album's shows its cover instead of its track number. Only servers that give tracks their own art, such as Navidrome, can show this; Nextcloud Music gives every track the album's cover.
## v0.8.6 (2026-11-04)
### Bug fixes
- Covers cached by versions before 0.8.0 are deleted on start. They were no longer used but stayed on disk.
## v0.8.5 (2026-11-04)
### Bug fixes
- The README says where the version is shown while the controls bar is hidden: in Settings, as a Version row.
## v0.8.4 (2026-11-04)
### Bug fixes
- While another app or a game is in front, the controller no longer also controls remus. Music keeps playing in the background, and media keys still work.
## v0.8.3 (2026-11-04)
### Bug fixes
- The now-playing cover, its background and the album art colours use the picture embedded in the playing track's file when it has one. Nextcloud Music gives every song of an album the album's cover, so tracks with their own art all showed the same one. Lists and the queue still show the server's cover.
## v0.8.2 (2026-11-04)
### Bug fixes
- On the now-playing screen the play/pause icon and the volume bar sit exactly under the middle of the progress bar. Before, the icon moved with the widths of the two times and the volume bar sat left of centre.
## v0.8.1 (2026-11-04)
### Features
- The password field on the login screen has an eye to show what was typed, and the queue button does the same from a controller while the field is selected. It is hidden again whenever the login screen opens.
## v0.8.0 (2026-11-04)
### Features
- Remus keeps several logins and switches between them from Settings, where the servers are listed first. Add server opens the login form, and Cancel goes back. Each server keeps its own queue: switching away stops it, and switching back brings it back paused where it was. A server is removed by pressing the queue button twice on its row.
- The shoulder triggers wrap around the sidebar, so Settings is one press back from Recently added.
- An existing login is kept as the first of the list, with nothing to re-enter.
## v0.7.0 (2026-11-04)
### Features
- Remus is an MPRIS player, so media keys, headphone buttons and the desktop's media controls can play, pause and skip, and the desktop shows the track that is playing. Headphone buttons work wherever the system passes them to MPRIS, as KDE does in Desktop Mode.
## v0.6.8 (2026-11-04)
### Features
- Settings has a Show controls bar toggle. Turned off, the bar with the button hints and the version is hidden on the browse and now-playing screens, and Settings lists the version instead. The login screen always shows it.
## v0.6.7 (2026-11-04)
### Bug fixes
- The volume level sits centred under the progress bar on the now-playing screen, and at the right of the bar at the bottom of the other screens, next to the time.
## v0.6.6 (2026-11-04)
### Features
Generated
+3 -1
View File
@@ -4385,11 +4385,12 @@ checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
[[package]]
name = "remus"
version = "0.6.6"
version = "0.9.0"
dependencies = [
"anyhow",
"directories",
"env_logger",
"fastrand",
"fontique",
"gilrs",
"gstreamer",
@@ -4907,6 +4908,7 @@ dependencies = [
"const-field-offset",
"i-slint-backend-linuxkms",
"i-slint-backend-selector",
"i-slint-backend-winit",
"i-slint-common",
"i-slint-core",
"i-slint-core-macros",
+3 -2
View File
@@ -1,6 +1,6 @@
[package]
name = "remus"
version = "0.6.6"
version = "0.9.0"
edition = "2024"
license = "MIT"
@@ -8,6 +8,7 @@ license = "MIT"
anyhow = "1.0.104"
directories = "6.0.0"
env_logger = "0.11.11"
fastrand = "2.5.0"
fontique = { version = "0.11", default-features = false, features = ["fontconfig-dlopen"] }
gilrs = "0.11.2"
gstreamer = "0.25.4"
@@ -18,7 +19,7 @@ md5 = "0.8.1"
reqwest = { version = "0.13.5", default-features = false, features = ["json", "rustls"] }
serde = { version = "1.0.229", features = ["derive"] }
serde_json = "1.0.154"
slint = "1.18.1"
slint = { version = "1.18.1", features = ["unstable-winit-030"] }
tokio = { version = "1.54.1", features = ["rt-multi-thread", "sync", "macros", "time"] }
toml = "1.1.8"
zbus = { version = "5.19.0", default-features = false, features = ["tokio"] }
+1 -1
View File
@@ -86,7 +86,7 @@ A scripted run starts fullscreen like a normal one, so it also checks that start
### Versions
Every finished ticket bumps the version, so a build on the Deck can be matched to what it contains. The running version is shown at the bottom left of every screen.
Every finished ticket bumps the version, so a build on the Deck can be matched to what it contains. The running version is shown at the bottom left of the controls bar. With Show controls bar turned off in Settings, it is listed as a Version row in Settings instead. The login screen always shows the bar.
- `make patch` for a bug fix, `make minor` for a feature, `make major` only when a breaking change has been decided.
- Before bumping, add a `## v<new> (<date>)` entry at the top of `CHANGELOG.md`, with `### Features` and `### Bug fixes` subsections (leave out an empty one), and commit it with the change. `make version` prints the current version.
@@ -20,6 +20,18 @@
</supports>
<content_rating type="oars-1.1"/>
<releases>
<release version="0.9.0" date="2026-11-05"/>
<release version="0.8.7" date="2026-11-04"/>
<release version="0.8.6" date="2026-11-04"/>
<release version="0.8.5" date="2026-11-04"/>
<release version="0.8.4" date="2026-11-04"/>
<release version="0.8.3" date="2026-11-04"/>
<release version="0.8.2" date="2026-11-04"/>
<release version="0.8.1" date="2026-11-04"/>
<release version="0.8.0" date="2026-11-04"/>
<release version="0.7.0" date="2026-11-04"/>
<release version="0.6.8" date="2026-11-04"/>
<release version="0.6.7" date="2026-11-04"/>
<release version="0.6.6" date="2026-11-04"/>
<release version="0.6.5" date="2026-11-04"/>
<release version="0.6.4" date="2026-11-04"/>
+3
View File
@@ -18,6 +18,9 @@ finish-args:
# Keeps the screensaver off while music plays, the way Chromium and
# Electron apps do. The XDG portal route needs no permission.
- --talk-name=org.freedesktop.ScreenSaver
# MPRIS, through which the desktop's media keys and headphone buttons
# reach the player.
- --own-name=org.mpris.MediaPlayer2.remus
build-options:
append-path: /usr/lib/sdk/rust-stable/bin
+935 -71
View File
File diff suppressed because it is too large Load Diff
+166 -9
View File
@@ -69,21 +69,104 @@ pub fn state_dir() -> Option<PathBuf> {
dirs().map(|d| d.state_dir().unwrap_or(d.data_dir()).to_path_buf())
}
pub fn load() -> Result<Option<Config>> {
let Some(path) = config_path() else { return Ok(None) };
impl Config {
/// Names the server and user, as the sidebar shows them.
pub fn label(&self) -> String {
let host = self.url.split("://").nth(1).unwrap_or(&self.url);
format!("{} on {}", self.username, host.trim_end_matches('/'))
}
fn same_login(&self, other: &Config) -> bool {
self.url == other.url && self.username == other.username
}
}
/// Every saved login, and which one is browsed.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct Logins {
/// Index into `servers`.
#[serde(default)]
pub active: usize,
/// `[[server]]` tables in the file.
#[serde(rename = "server", default)]
pub servers: Vec<Config>,
}
impl Logins {
pub fn active(&self) -> Option<&Config> {
self.servers.get(self.active)
}
/// Adds a login, or refreshes the saved one for the same server and user,
/// and makes it the active one.
pub fn add(&mut self, cfg: Config) {
match self.servers.iter().position(|s| s.same_login(&cfg)) {
Some(i) => {
self.servers[i] = cfg;
self.active = i;
}
None => {
self.servers.push(cfg);
self.active = self.servers.len() - 1;
}
}
}
/// Removes a login. The active one stays the same server where it can;
/// removing it makes the first remaining login active.
pub fn remove(&mut self, i: usize) {
if i >= self.servers.len() {
return;
}
self.servers.remove(i);
if i < self.active {
self.active -= 1;
} else if i == self.active {
self.active = 0;
}
}
}
/// The single login of earlier versions, or the list. Tried in that order:
/// every field of the list has a default, so it would take an old file as an
/// empty list, while the old shape needs `url` and `username` at the top.
#[derive(Deserialize)]
#[serde(untagged)]
enum Stored {
One(Config),
List(Logins),
}
fn parse_logins(text: &str) -> Result<Logins> {
Ok(match toml::from_str::<Stored>(text)? {
Stored::List(mut l) => {
if l.active >= l.servers.len() {
l.active = 0;
}
l
}
Stored::One(c) => Logins {
active: 0,
servers: vec![c],
},
})
}
pub fn load() -> Result<Logins> {
let Some(path) = config_path() else {
return Ok(Logins::default());
};
match fs::read_to_string(&path) {
Ok(text) => Ok(Some(
toml::from_str(&text).with_context(|| format!("parsing {}", path.display()))?,
)),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
Ok(text) => parse_logins(&text).with_context(|| format!("parsing {}", path.display())),
Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(Logins::default()),
Err(e) => Err(e).with_context(|| format!("reading {}", path.display())),
}
}
pub fn save(cfg: &Config) -> Result<()> {
pub fn save(logins: &Logins) -> Result<()> {
let path = config_path().context("no config directory")?;
write_atomic(&path, &toml::to_string(cfg)?)?;
log::info!("saved login to {}", path.display());
write_atomic(&path, &toml::to_string(logins)?)?;
log::info!("saved {} login(s) to {}", logins.servers.len(), path.display());
Ok(())
}
@@ -99,6 +182,9 @@ pub struct Settings {
pub volume: u8,
/// Muted, keeping `volume` for when it is unmuted.
pub muted: bool,
/// The bar with the button hints and the version. The login screen shows
/// it regardless.
pub show_hint_bar: bool,
}
/// The cover backdrop strength that looks like it did before it was a setting.
@@ -111,6 +197,7 @@ impl Default for Settings {
cover_backdrop: COVER_BACKDROP_DEFAULT,
volume: 100,
muted: false,
show_hint_bar: true,
}
}
}
@@ -208,6 +295,73 @@ mod tests {
assert!(!text.contains("salt") && !text.contains("token"), "{text}");
}
fn login(url: &str, user: &str, auth: Auth) -> Config {
Config::from_client(&Client::new(url, user, auth))
}
#[test]
fn a_single_login_file_loads_as_the_only_login() {
let old = "url = \"https://h\"\nusername = \"u\"\nsalt = \"s\"\ntoken = \"t\"\n";
let l = parse_logins(old).unwrap();
assert_eq!(l.servers.len(), 1);
assert_eq!(l.active, 0);
assert_eq!(l.active().unwrap().username, "u");
let old = "url = \"https://h\"\nusername = \"u\"\npassword = \"p\"\n";
let l = parse_logins(old).unwrap();
assert_eq!(*l.active().unwrap().client().auth(), Auth::Password("p".into()));
}
#[test]
fn the_login_list_round_trips_with_both_auth_methods() {
let mut l = Logins::default();
l.add(login(
"https://a",
"u",
Auth::Token {
salt: "s".into(),
token: "t".into(),
},
));
l.add(login("https://b", "v", Auth::Password("p".into())));
let text = toml::to_string(&l).unwrap();
assert!(text.contains("[[server]]"), "{text}");
let back = parse_logins(&text).unwrap();
assert_eq!(back, l);
assert_eq!(back.active, 1);
}
#[test]
fn adding_the_same_login_again_replaces_it() {
let mut l = Logins::default();
l.add(login("https://a", "u", Auth::Password("old".into())));
l.add(login("https://b", "u", Auth::Password("p".into())));
l.add(login("https://a", "u", Auth::Password("new".into())));
assert_eq!(l.servers.len(), 2);
assert_eq!(l.active, 0);
assert_eq!(*l.servers[0].client().auth(), Auth::Password("new".into()));
}
#[test]
fn removing_keeps_the_active_server_where_it_can() {
let mut l = Logins::default();
for host in ["https://a", "https://b", "https://c"] {
l.add(login(host, "u", Auth::Password("p".into())));
}
l.active = 2;
l.remove(0);
assert_eq!(l.active().unwrap().url, "https://c");
l.remove(1);
assert_eq!(l.active().unwrap().url, "https://b");
l.remove(0);
assert!(l.active().is_none());
}
#[test]
fn an_out_of_range_active_index_falls_back_to_the_first() {
let text = "active = 5\n[[server]]\nurl = \"https://a\"\nusername = \"u\"\npassword = \"p\"\n";
assert_eq!(parse_logins(text).unwrap().active, 0);
}
#[test]
fn settings_default_when_fields_are_missing() {
let s: Settings = toml::from_str("").unwrap();
@@ -216,6 +370,7 @@ mod tests {
assert_eq!(s.cover_backdrop, COVER_BACKDROP_DEFAULT);
assert_eq!(s.volume, 100);
assert!(!s.muted);
assert!(s.show_hint_bar);
}
#[test]
@@ -223,6 +378,7 @@ mod tests {
let s: Settings = toml::from_str("album_art_colours = true\n").unwrap();
assert!(s.album_art_colours);
assert_eq!(s.cover_backdrop, COVER_BACKDROP_DEFAULT);
assert!(s.show_hint_bar);
}
#[test]
@@ -232,6 +388,7 @@ mod tests {
cover_backdrop: 70,
volume: 35,
muted: true,
show_hint_bar: false,
};
let back: Settings = toml::from_str(&toml::to_string(&s).unwrap()).unwrap();
assert_eq!(back, s);
+4
View File
@@ -88,12 +88,16 @@ fn step(ui: slint::Weak<AppWindow>, steps: Vec<String>, i: usize) {
"next" => Action::Next,
"play-pause" => Action::PlayPause,
"section-next" => Action::SectionNext,
"section-prev" => Action::SectionPrev,
"now-playing" => Action::NowPlaying,
"search" => Action::Search,
"quit" => Action::Quit,
"volume-up" => Action::VolumeUp,
"volume-down" => Action::VolumeDown,
"mute" => Action::ToggleMute,
"cycle-shuffle" => Action::CycleShuffle,
"shuffle" => Action::Shuffle,
"hold-activate" => Action::HoldActivate,
other => {
log::warn!("unknown dev script step {other}");
Action::None
+36 -2
View File
@@ -27,6 +27,8 @@ const REPEAT_DELAY: Duration = Duration::from_millis(380);
const REPEAT_SLOW: Duration = Duration::from_millis(110);
const REPEAT_FAST: Duration = Duration::from_millis(45);
const FAST_AFTER: Duration = Duration::from_millis(1500);
/// How long South is held before it counts as a long press.
const LONG_PRESS: Duration = Duration::from_millis(500);
const STICK_ON: f32 = 0.55;
const STICK_OFF: f32 = 0.35;
@@ -37,6 +39,14 @@ enum Source {
RightStick,
}
/// South acts on release, so a long press can mean something else.
struct SouthPress {
family: Family,
since: Instant,
/// Sent as a long press already, so the release sends nothing.
long: bool,
}
struct Held {
source: Source,
action: Action,
@@ -66,6 +76,7 @@ pub fn spawn_gamepad(emit: impl Fn(PadEvent) + Send + 'static) {
}
emit(PadEvent::Present(present(&gilrs, &mut families)));
let mut held: Option<Held> = None;
let mut south: Option<SouthPress> = None;
loop {
while let Some(ev) = gilrs.next_event_blocking(Some(Duration::from_millis(15))) {
if matches!(ev.event, EventType::Connected | EventType::Disconnected) {
@@ -77,6 +88,20 @@ pub fn spawn_gamepad(emit: impl Fn(PadEvent) + Send + 'static) {
}
let family = families.family(&gilrs, ev.id);
match ev.event {
EventType::ButtonPressed(Button::South, _) => {
south = Some(SouthPress {
family,
since: Instant::now(),
long: false,
});
}
EventType::ButtonReleased(Button::South, _) => {
if let Some(p) = south.take()
&& !p.long
{
emit(PadEvent::Action(Action::Activate, p.family));
}
}
EventType::ButtonPressed(b, _) => {
if let Some(a) = dpad_action(b) {
held = Some(start_hold(Source::DPad, a, family));
@@ -108,10 +133,20 @@ pub fn spawn_gamepad(emit: impl Fn(PadEvent) + Send + 'static) {
_ => {}
}
}
EventType::Disconnected => held = None,
EventType::Disconnected => {
held = None;
south = None;
}
_ => {}
}
}
if let Some(p) = south.as_mut()
&& !p.long
&& p.since.elapsed() >= LONG_PRESS
{
p.long = true;
emit(PadEvent::Action(Action::HoldActivate, p.family));
}
if let Some(h) = held.as_mut() {
let now = Instant::now();
if now >= h.next {
@@ -216,7 +251,6 @@ fn dpad_action(b: Button) -> Option<Action> {
fn button_action(b: Button) -> Option<Action> {
Some(match b {
Button::South => Action::Activate,
Button::East => Action::Back,
Button::West => Action::PlayPause,
Button::North => Action::Queue,
+14
View File
@@ -5,10 +5,12 @@ mod config;
mod devscript;
mod inhibit;
mod input;
mod mpris;
mod palette;
mod player;
mod prompts;
mod saved_queue;
mod shuffle;
mod subsonic;
use std::time::Duration;
@@ -27,6 +29,18 @@ fn main() -> anyhow::Result<()> {
let ui = AppWindow::new()?;
ui.set_version(env!("CARGO_PKG_VERSION").into());
app::install(&ui, rt.handle().clone());
// The controller is read from the device, whichever window is in front, so
// the app needs to know when another one is, to leave the presses to it.
{
use slint::winit_030::{EventResult, WinitWindowAccessor, winit::event::WindowEvent};
ui.window().on_winit_window_event(|_, event| {
if let WindowEvent::Focused(focused) = *event {
log::debug!("window focused: {focused}");
app::with_app(move |app| app.set_window_active(focused));
}
EventResult::Propagate
});
}
input::spawn_gamepad(|ev| {
let _ = slint::invoke_from_event_loop(move || {
app::with_app(move |app| match ev {
+368
View File
@@ -0,0 +1,368 @@
//! MPRIS on the session bus, so the desktop's media controls and media keys
//! can drive playback. Headphone buttons arrive this way too: the desktop
//! turns the key events of a headset or a Bluetooth AVRCP device into calls
//! on the active MPRIS player. Reading those devices directly is not an
//! option, since keyboard-like input devices are root:input and only
//! gamepads are opened up to the logged-in user.
//!
//! A bus that cannot be reached, or a name already taken by another remus,
//! is logged once and otherwise ignored.
use std::collections::HashMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicI64, Ordering};
use anyhow::Result;
use tokio::runtime::Handle;
use tokio::sync::watch;
use zbus::interface;
use zbus::zvariant::{ObjectPath, OwnedValue, Value};
const BUS_NAME: &str = "org.mpris.MediaPlayer2.remus";
const PATH: &str = "/org/mpris/MediaPlayer2";
const DESKTOP_ENTRY: &str = "me.anshorei.Fettleshed.Remus";
/// What a client asked for.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Command {
PlayPause,
Play,
Pause,
Stop,
Next,
Previous,
Quit,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum Status {
#[default]
Stopped,
Paused,
Playing,
}
impl Status {
fn as_str(self) -> &'static str {
match self {
Status::Stopped => "Stopped",
Status::Paused => "Paused",
Status::Playing => "Playing",
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Track {
/// Position in the queue, which makes the track id.
pub index: usize,
pub title: String,
pub artist: Option<String>,
pub album: Option<String>,
pub seconds: Option<u32>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct NowPlaying {
pub status: Status,
pub track: Option<Track>,
/// 0 to 1, already muted to 0.
pub volume: f64,
}
pub struct Mpris {
state: watch::Sender<NowPlaying>,
position: Arc<AtomicI64>,
}
impl Mpris {
pub fn spawn(rt: &Handle, on_command: impl Fn(Command) + Send + Sync + 'static) -> Mpris {
let (state, rx) = watch::channel(NowPlaying::default());
let position = Arc::new(AtomicI64::new(0));
let pos = position.clone();
let on_command: Arc<dyn Fn(Command) + Send + Sync> = Arc::new(on_command);
rt.spawn(async move {
if let Err(e) = run(rx, pos, on_command).await {
log::warn!("MPRIS unavailable, media keys will not reach remus: {e:#}");
}
});
Mpris { state, position }
}
/// Publishes what is playing. Clients hear only about what changed.
pub fn update(&self, now: NowPlaying) {
self.state.send_if_modified(|s| {
let changed = *s != now;
*s = now;
changed
});
}
/// Clients read the position when they want it; it sends no signal.
pub fn set_position(&self, seconds: f64) {
self.position.store((seconds * 1e6) as i64, Ordering::Relaxed);
}
}
async fn run(
mut rx: watch::Receiver<NowPlaying>,
position: Arc<AtomicI64>,
on_command: Arc<dyn Fn(Command) + Send + Sync>,
) -> Result<()> {
let player = Player {
now: rx.borrow().clone(),
position,
on_command: on_command.clone(),
};
let conn = zbus::connection::Builder::session()?
.name(BUS_NAME)?
.serve_at(PATH, Root { on_command })?
.serve_at(PATH, player)?
.build()
.await?;
log::info!("MPRIS player registered as {BUS_NAME}");
let iface = conn.object_server().interface::<_, Player>(PATH).await?;
while rx.changed().await.is_ok() {
let now = rx.borrow_and_update().clone();
let mut p = iface.get_mut().await;
let status = p.now.status != now.status;
let track = p.now.track != now.track;
let volume = p.now.volume != now.volume;
p.now = now;
let emitter = iface.signal_emitter();
if status {
p.playback_status_changed(emitter).await?;
}
if track {
p.metadata_changed(emitter).await?;
p.can_play_changed(emitter).await?;
p.can_pause_changed(emitter).await?;
p.can_go_next_changed(emitter).await?;
p.can_go_previous_changed(emitter).await?;
}
if volume {
p.volume_changed(emitter).await?;
}
}
Ok(())
}
struct Root {
on_command: Arc<dyn Fn(Command) + Send + Sync>,
}
#[interface(name = "org.mpris.MediaPlayer2")]
impl Root {
fn raise(&self) {}
fn quit(&self) {
(self.on_command)(Command::Quit);
}
#[zbus(property)]
fn can_quit(&self) -> bool {
true
}
#[zbus(property)]
fn can_raise(&self) -> bool {
false
}
#[zbus(property)]
fn has_track_list(&self) -> bool {
false
}
#[zbus(property)]
fn identity(&self) -> &str {
"Remus"
}
#[zbus(property)]
fn desktop_entry(&self) -> &str {
DESKTOP_ENTRY
}
#[zbus(property)]
fn supported_uri_schemes(&self) -> Vec<String> {
Vec::new()
}
#[zbus(property)]
fn supported_mime_types(&self) -> Vec<String> {
Vec::new()
}
}
struct Player {
now: NowPlaying,
position: Arc<AtomicI64>,
on_command: Arc<dyn Fn(Command) + Send + Sync>,
}
#[interface(name = "org.mpris.MediaPlayer2.Player")]
impl Player {
fn play_pause(&self) {
(self.on_command)(Command::PlayPause);
}
fn play(&self) {
(self.on_command)(Command::Play);
}
fn pause(&self) {
(self.on_command)(Command::Pause);
}
fn stop(&self) {
(self.on_command)(Command::Stop);
}
fn next(&self) {
(self.on_command)(Command::Next);
}
fn previous(&self) {
(self.on_command)(Command::Previous);
}
// CanSeek is false, so clients do not call these; they are part of the
// interface all the same.
fn seek(&self, _offset: i64) {}
fn set_position(&self, _track_id: ObjectPath<'_>, _position: i64) {}
fn open_uri(&self, _uri: &str) {}
#[zbus(property)]
fn playback_status(&self) -> &str {
self.now.status.as_str()
}
#[zbus(property)]
fn rate(&self) -> f64 {
1.0
}
#[zbus(property)]
fn minimum_rate(&self) -> f64 {
1.0
}
#[zbus(property)]
fn maximum_rate(&self) -> f64 {
1.0
}
#[zbus(property)]
fn metadata(&self) -> HashMap<String, OwnedValue> {
metadata(self.now.track.as_ref())
}
#[zbus(property)]
fn volume(&self) -> f64 {
self.now.volume
}
#[zbus(property(emits_changed_signal = "false"))]
fn position(&self) -> i64 {
self.position.load(Ordering::Relaxed)
}
#[zbus(property)]
fn can_go_next(&self) -> bool {
self.now.track.is_some()
}
#[zbus(property)]
fn can_go_previous(&self) -> bool {
self.now.track.is_some()
}
#[zbus(property)]
fn can_play(&self) -> bool {
self.now.track.is_some()
}
#[zbus(property)]
fn can_pause(&self) -> bool {
self.now.track.is_some()
}
#[zbus(property)]
fn can_seek(&self) -> bool {
false
}
#[zbus(property(emits_changed_signal = "const"))]
fn can_control(&self) -> bool {
true
}
}
/// The MPRIS metadata map for a track, empty when nothing is loaded.
fn metadata(track: Option<&Track>) -> HashMap<String, OwnedValue> {
let mut m = HashMap::new();
let Some(t) = track else {
let none = ObjectPath::from_static_str_unchecked("/org/mpris/MediaPlayer2/TrackList/NoTrack");
insert(&mut m, "mpris:trackid", Value::from(none));
return m;
};
// Outside /org/mpris, which the spec reserves.
let id = format!("/me/anshorei/Fettleshed/Remus/track/{}", t.index);
if let Ok(path) = ObjectPath::try_from(id) {
insert(&mut m, "mpris:trackid", Value::from(path));
}
insert(&mut m, "xesam:title", Value::from(t.title.clone()));
if let Some(a) = &t.artist {
insert(&mut m, "xesam:artist", Value::from(vec![a.clone()]));
}
if let Some(a) = &t.album {
insert(&mut m, "xesam:album", Value::from(a.clone()));
}
if let Some(s) = t.seconds {
insert(&mut m, "mpris:length", Value::from(s as i64 * 1_000_000));
}
m
}
fn insert(m: &mut HashMap<String, OwnedValue>, key: &str, value: Value<'_>) {
if let Ok(v) = OwnedValue::try_from(value) {
m.insert(key.to_string(), v);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn metadata_without_a_track_says_so() {
let m = metadata(None);
assert_eq!(m.len(), 1);
let id: ObjectPath = m["mpris:trackid"].clone().try_into().unwrap();
assert_eq!(id.as_str(), "/org/mpris/MediaPlayer2/TrackList/NoTrack");
}
#[test]
fn metadata_carries_the_track() {
let t = Track {
index: 3,
title: "Feijão".into(),
artist: Some("Dr. Quandary".into()),
album: None,
seconds: Some(218),
};
let m = metadata(Some(&t));
let title: String = m["xesam:title"].clone().try_into().unwrap();
assert_eq!(title, "Feijão");
let artists: Vec<String> = m["xesam:artist"].clone().try_into().unwrap();
assert_eq!(artists, ["Dr. Quandary"]);
let length: i64 = m["mpris:length"].clone().try_into().unwrap();
assert_eq!(length, 218_000_000);
assert!(!m.contains_key("xesam:album"));
let id: ObjectPath = m["mpris:trackid"].clone().try_into().unwrap();
assert_eq!(id.as_str(), "/me/anshorei/Fettleshed/Remus/track/3");
}
}
+343 -24
View File
@@ -2,6 +2,7 @@
//! track can be handed to playbin in `about-to-finish`, which keeps playback
//! gapless.
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use std::thread::JoinHandle;
@@ -11,13 +12,35 @@ use anyhow::{Context, Result};
use gstreamer as gst;
use gstreamer::prelude::*;
#[derive(Debug, Clone, Copy)]
#[derive(Debug, Clone)]
pub enum PlayerEvent {
Position(f64),
Duration(f64),
Paused(bool),
/// Index into the queue, None when playback has stopped.
Track(Option<usize>),
/// Index into the queue, None when playback has stopped. An index is
/// only valid for the queue `generation` it was sent from: see `reorder`.
Track {
index: Option<usize>,
generation: u64,
},
/// The picture embedded in the playing track's file, or None once it is
/// clear the file has none. Sent once per track started, after its
/// `Track`. A picture that turns up late is still sent, after the None.
Art {
index: usize,
generation: u64,
picture: Option<Vec<u8>>,
},
}
/// The queue after `reorder`.
#[derive(Debug, Clone, PartialEq)]
pub struct Reordered {
/// The new order, as positions in the old one.
pub perm: Vec<usize>,
pub current: Option<usize>,
pub pending: Option<usize>,
pub generation: u64,
}
#[derive(Default)]
@@ -31,16 +54,25 @@ struct Queue {
hold: bool,
/// Seconds to seek to once the paused track has prerolled.
seek_to: Option<f64>,
/// Bumped by every reorder, so an index sent before one is recognised.
generation: u64,
}
/// Pictures found in the files being decoded, by URI.
type Pictures = Arc<Mutex<HashMap<String, Vec<u8>>>>;
pub struct Player {
playbin: gst::Element,
queue: Arc<Mutex<Queue>>,
pictures: Pictures,
stop: Arc<AtomicBool>,
bus_thread: Option<JoinHandle<()>>,
}
const TICK: Duration = Duration::from_millis(250);
/// How long after a track starts its tags can still bring a picture. Tags
/// come ahead of the audio, so this is mostly a slow server's margin.
const ART_WAIT: Duration = Duration::from_millis(600);
impl Player {
pub fn spawn(on_event: impl Fn(PlayerEvent) + Send + 'static) -> Result<Player> {
@@ -71,15 +103,19 @@ impl Player {
None
});
let pictures = Pictures::default();
watch_pictures(&playbin, &pictures);
let stop = Arc::new(AtomicBool::new(false));
let bus_thread = std::thread::Builder::new().name("gst-bus".into()).spawn({
let (playbin, queue, stop) = (playbin.clone(), queue.clone(), stop.clone());
move || watch_bus(&playbin, &queue, &stop, &on_event)
let (playbin, queue, pictures, stop) = (playbin.clone(), queue.clone(), pictures.clone(), stop.clone());
move || watch_bus(&playbin, &queue, &pictures, &stop, &on_event)
})?;
Ok(Player {
playbin,
queue,
pictures,
stop,
bus_thread: Some(bus_thread),
})
@@ -96,6 +132,28 @@ impl Player {
self.play_index(start);
}
/// Reorders the queue without interrupting the playing track. `arrange`
/// gets the playing position and the one already handed to playbin, and
/// returns the new order as positions in the old one; a position it
/// leaves out is dropped. It runs under the queue lock, so no track
/// starts in between: keep the handed-over track right after the playing
/// one, or the queue jumps to wherever it went once it starts.
pub fn reorder(&self, arrange: impl FnOnce(Option<usize>, Option<usize>) -> Vec<usize>) -> Reordered {
let mut q = lock(&self.queue);
let perm = arrange(q.current, q.pending);
let moved = |i: Option<usize>| i.and_then(|i| perm.iter().position(|&p| p == i));
q.current = moved(q.current);
q.pending = moved(q.pending);
q.urls = perm.iter().filter_map(|&p| q.urls.get(p).cloned()).collect();
q.generation += 1;
Reordered {
current: q.current,
pending: q.pending,
generation: q.generation,
perm,
}
}
/// Adds to the end of the queue, starting playback if it had stopped.
pub fn append(&self, url: &str) {
let start = {
@@ -143,6 +201,19 @@ impl Player {
start(&self.playbin, &url);
}
/// Stops playback and forgets the queue, as when switching server. Going
/// to Null flushes the bus, so nothing from the old track reports later.
pub fn stop(&self) {
let mut q = lock(&self.queue);
*q = Queue {
generation: q.generation,
..Queue::default()
};
drop(q);
lock(&self.pictures).clear();
let _ = self.playbin.set_state(gst::State::Null);
}
pub fn toggle_pause(&self) {
// Toggles where the pipeline is heading, so play pressed while a
// paused track is still loading is not lost.
@@ -206,8 +277,53 @@ impl Drop for Player {
}
}
fn lock(q: &Mutex<Queue>) -> MutexGuard<'_, Queue> {
q.lock().unwrap_or_else(|e| e.into_inner())
fn lock<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
m.lock().unwrap_or_else(|e| e.into_inner())
}
/// Records the picture in each file playbin decodes, keyed by its URI. Read
/// where each file's decoder hands on its stream, because further down the
/// tags of a file without a picture still carry the previous file's, once
/// playback moves on gaplessly.
fn watch_pictures(playbin: &gst::Element, pictures: &Pictures) {
let Some(bin) = playbin.downcast_ref::<gst::Bin>() else {
return;
};
let pictures = pictures.clone();
bin.connect_deep_element_added(move |_, _, element| {
let decoder = element
.factory()
.is_some_and(|f| matches!(f.name().as_str(), "uridecodebin" | "uridecodebin3"));
// playbin adds the same decoder again for later tracks.
// SAFETY: the key is only ever set to a bool, here.
if !decoder || unsafe { element.data::<bool>("remus-pictures") }.is_some() {
return;
}
unsafe { element.set_data("remus-pictures", true) };
let pictures = pictures.clone();
element.connect_pad_added(move |decoder, pad| {
let decoder = decoder.downgrade();
let pictures = pictures.clone();
pad.add_probe(gst::PadProbeType::EVENT_DOWNSTREAM, move |_, info| {
if let Some(gst::PadProbeData::Event(ev)) = &info.data
&& let gst::EventView::Tag(t) = ev.view()
&& let Some(bytes) = embedded_picture(t.tag())
&& let Some(uri) = decoder.upgrade().and_then(|d| d.property::<Option<String>>("uri"))
{
lock(&pictures).entry(uri).or_insert(bytes);
}
gst::PadProbeReturn::Ok
});
});
});
}
/// The track whose picture is still being looked for.
struct ArtWait {
url: String,
since: Instant,
/// Already reported as without a picture; one turning up later is still sent.
told_none: bool,
}
fn start(playbin: &gst::Element, url: &str) {
@@ -239,27 +355,38 @@ fn seek_to(playbin: &gst::Element, seconds: f64) {
}
}
fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, emit: &dyn Fn(PlayerEvent)) {
fn watch_bus(
playbin: &gst::Element,
queue: &Mutex<Queue>,
pictures: &Pictures,
stop: &AtomicBool,
emit: &dyn Fn(PlayerEvent),
) {
let Some(bus) = playbin.bus() else { return };
let mut last_tick = Instant::now();
let mut duration = 0.0;
// playbin can post stream-start more than once for one track, so a repeat
// of the last report is dropped. A track that was just started is always
// reported, even at the same index: a new queue, or the same track again.
let mut last_track: Option<Option<usize>> = None;
let mut report_track = |t: Option<usize>, started: bool| {
if started || last_track != Some(t) {
last_track = Some(t);
emit(PlayerEvent::Track(t));
// reported, even the same one: a new queue, or the same track again. By
// URL, since a reorder moves the track without restarting it.
let mut last_track: Option<Option<String>> = None;
let mut report_track = |index: Option<usize>, url: Option<String>, generation: u64, started: bool| {
if started || last_track.as_ref() != Some(&url) {
last_track = Some(url);
emit(PlayerEvent::Track { index, generation });
emit(PlayerEvent::Position(0.0));
true
} else {
false
}
};
let mut art_wait: Option<ArtWait> = None;
while !stop.load(Ordering::Relaxed) {
if let Some(msg) = bus.timed_pop(gst::ClockTime::from_mseconds(TICK.as_millis() as u64)) {
use gst::MessageView;
match msg.view() {
MessageView::StreamStart(_) => {
let (current, started) = {
let (current, url, generation, started) = {
let mut q = lock(queue);
let started = match q.pending.take() {
Some(p) => {
@@ -268,10 +395,28 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
}
None => false,
};
(q.current, started)
let url = q.current.and_then(|i| q.urls.get(i).cloned());
(q.current, url, q.generation, started)
};
duration = 0.0;
report_track(current, started);
if report_track(current, url.clone(), generation, started) {
art_wait = url.map(|url| ArtWait {
url,
since: Instant::now(),
told_none: false,
});
// Keep only what this track and the next may still need.
let keep: Vec<String> = {
let q = lock(queue);
current
.into_iter()
.flat_map(|i| q.urls.get(i..=i + 1))
.flatten()
.cloned()
.collect()
};
lock(pictures).retain(|uri, _| keep.contains(uri));
}
}
MessageView::StateChanged(s) if s.src() == Some(playbin.upcast_ref()) => match s.current() {
gst::State::Playing => emit(PlayerEvent::Paused(false)),
@@ -294,8 +439,10 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
q.current = None;
q.pending = None;
}
let generation = lock(queue).generation;
let _ = playbin.set_state(gst::State::Ready);
report_track(None, false);
report_track(None, None, generation, false);
art_wait = None;
}
// 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
@@ -327,13 +474,44 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
start(playbin, &url);
}
} else {
let generation = lock(queue).generation;
let _ = playbin.set_state(gst::State::Ready);
report_track(None, false);
report_track(None, None, generation, false);
art_wait = None;
}
}
_ => {}
}
}
if let Some(w) = &mut art_wait {
// Where the track is now, since a reorder may have moved it.
let (index, generation) = {
let q = lock(queue);
let index = q.current.filter(|&i| q.urls.get(i) == Some(&w.url));
(index, q.generation)
};
let picture = lock(pictures).get(&w.url).cloned();
match index {
None => art_wait = None,
Some(index) if picture.is_some() => {
emit(PlayerEvent::Art {
index,
generation,
picture,
});
art_wait = None;
}
Some(index) if !w.told_none && w.since.elapsed() >= ART_WAIT => {
w.told_none = true;
emit(PlayerEvent::Art {
index,
generation,
picture: None,
});
}
Some(_) => {}
}
}
if last_tick.elapsed() >= TICK {
last_tick = Instant::now();
if playbin.current_state() == gst::State::Playing {
@@ -351,6 +529,22 @@ fn watch_bus(playbin: &gst::Element, queue: &Mutex<Queue>, stop: &AtomicBool, em
}
}
/// The front cover among the pictures in `tags`, else the first picture.
fn embedded_picture(tags: &gst::TagListRef) -> Option<Vec<u8>> {
// GST_TAG_IMAGE_TYPE_FRONT_COVER in gst-tag's GstTagImageType.
const FRONT_COVER: i32 = 1;
let is_front = |s: &gst::Sample| {
s.info()
.and_then(|i| i.value("image-type").ok())
.and_then(|v| gst::glib::EnumValue::from_value(v))
.is_some_and(|(_, v)| v.value() == FRONT_COVER)
};
let pictures: Vec<gst::Sample> = tags.iter_tag::<gst::tags::Image>().map(|v| v.get()).collect();
let sample = pictures.iter().find(|s| is_front(s)).or(pictures.first())?;
let map = sample.buffer()?.map_readable().ok()?;
Some(map.as_slice().to_vec())
}
/// Removes the query string from any URL in `text`. Stream URLs carry the
/// Subsonic auth token, and GStreamer's HTTP errors quote the URL.
fn strip_queries(text: &str) -> String {
@@ -418,6 +612,57 @@ mod tests {
format!("file://{}", path.display())
}
/// Puts an ID3v2.3 tag holding `picture` as the front cover before the
/// file at `uri`, as a tagged MP3 would carry it.
fn with_id3_picture(uri: &str, picture: &[u8]) {
let path = uri.strip_prefix("file://").unwrap();
let mut body = vec![0u8]; // Latin-1 text
body.extend_from_slice(b"image/png\0");
body.push(3); // front cover
body.push(0); // empty description
body.extend_from_slice(picture);
let mut frame = b"APIC".to_vec();
frame.extend_from_slice(&(body.len() as u32).to_be_bytes());
frame.extend_from_slice(&[0, 0]);
frame.extend_from_slice(&body);
let n = frame.len() as u32;
let syncsafe = [(n >> 21) & 0x7f, (n >> 14) & 0x7f, (n >> 7) & 0x7f, n & 0x7f].map(|b| b as u8);
let mut tagged = b"ID3\x03\x00\x00".to_vec();
tagged.extend_from_slice(&syncsafe);
tagged.extend_from_slice(&frame);
tagged.extend_from_slice(&std::fs::read(path).unwrap());
std::fs::write(path, tagged).unwrap();
}
#[test]
fn reports_the_picture_in_each_file() {
// 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-art-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let urls = vec![silent_wav(&dir, "a.wav", 1.0), silent_wav(&dir, "b.wav", 1.0)];
let mut png = Vec::new();
image::RgbImage::from_pixel(4, 4, image::Rgb([200, 30, 30]))
.write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png)
.unwrap();
with_id3_picture(&urls[0], &png);
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Art { index, picture, .. } = ev {
let _ = tx.send((index, picture));
}
})
.unwrap();
player.play_list(&urls, 0);
let first = rx.recv_timeout(Duration::from_secs(5));
let second = rx.recv_timeout(Duration::from_secs(5));
drop(player);
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(first, Ok((0, Some(png))), "the tagged file's picture");
assert_eq!(second, Ok((1, None)), "the plain file has none");
}
#[test]
fn plays_a_queue_through_to_the_end() {
// SAFETY: set before any thread reads the environment in this test.
@@ -428,8 +673,8 @@ mod tests {
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Track(t) = ev {
let _ = tx.send(t);
if let PlayerEvent::Track { index, .. } = ev {
let _ = tx.send(index);
}
})
.unwrap();
@@ -459,8 +704,8 @@ mod tests {
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Track(t) = ev {
let _ = tx.send(t);
if let PlayerEvent::Track { index, .. } = ev {
let _ = tx.send(index);
}
})
.unwrap();
@@ -505,7 +750,7 @@ mod tests {
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::Track { index, .. }) => track = index,
Ok(PlayerEvent::Paused(false)) => started = true,
Ok(PlayerEvent::Position(p)) if p > 0.0 => started = true,
Ok(_) => {}
@@ -546,4 +791,78 @@ mod tests {
drop(player);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn a_reorder_keeps_the_track_playing_and_plays_the_new_order() {
// 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-reorder-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let urls = vec![
silent_wav(&dir, "a.wav", 0.8),
silent_wav(&dir, "b.wav", 0.6),
silent_wav(&dir, "c.wav", 0.6),
];
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Track { index, generation } = ev {
let _ = tx.send((index, generation));
}
})
.unwrap();
player.play_list(&urls, 0);
assert_eq!(rx.recv_timeout(Duration::from_secs(5)), Ok((Some(0), 0)));
let r = player.reorder(|current, pending| {
assert_eq!((current, pending), (Some(0), None));
vec![0, 2, 1]
});
assert_eq!((r.current, r.pending, r.generation), (Some(0), None, 1));
let mut tracks = Vec::new();
let mut played = Vec::new();
while let Ok((t, generation)) = rx.recv_timeout(Duration::from_secs(5)) {
assert_eq!(generation, 1);
tracks.push(t);
played.extend(t.map(|i| lock(&player.queue).urls[i].clone()));
if t.is_none() {
break;
}
}
drop(player);
let _ = std::fs::remove_dir_all(&dir);
assert_eq!(tracks, vec![Some(1), Some(2), None], "a did not start again");
assert_eq!(played, vec![urls[2].clone(), urls[1].clone()]);
}
#[test]
fn a_reorder_can_drop_tracks_before_the_playing_one() {
// 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-trim-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let urls: Vec<String> = ["a", "b", "c"]
.iter()
.map(|n| silent_wav(&dir, &format!("{n}.wav"), 10.0))
.collect();
let (tx, rx) = mpsc::channel();
let player = Player::spawn(move |ev| {
if let PlayerEvent::Track { index, .. } = ev {
let _ = tx.send(index);
}
})
.unwrap();
player.play_list(&urls, 1);
assert_eq!(rx.recv_timeout(Duration::from_secs(3)), Ok(Some(1)));
let r = player.reorder(|_, _| vec![1, 2]);
assert_eq!(r.current, Some(0));
player.next();
assert_eq!(rx.recv_timeout(Duration::from_secs(3)), Ok(Some(1)));
assert_eq!(lock(&player.queue).urls, urls[1..]);
drop(player);
let _ = std::fs::remove_dir_all(&dir);
}
}
+18 -1
View File
@@ -35,6 +35,11 @@ pub enum Control {
Seek,
Volume,
Mute,
/// Cycles the shuffle mode on now playing: the queue button on a
/// controller, a key of its own on the keyboard.
Shuffle,
/// Shuffle play on a row: a long press of activate on a controller.
ShufflePlay,
/// Steam + X brings up Steam's on-screen keyboard. Nothing to show for a
/// real keyboard.
OnScreenKeyboard,
@@ -42,7 +47,7 @@ pub enum Control {
#[cfg(test)]
impl Control {
pub const ALL: [Control; 12] = [
pub const ALL: [Control; 14] = [
Control::Activate,
Control::Back,
Control::PlayPause,
@@ -54,6 +59,8 @@ impl Control {
Control::Seek,
Control::Volume,
Control::Mute,
Control::Shuffle,
Control::ShufflePlay,
Control::OnScreenKeyboard,
];
}
@@ -81,13 +88,17 @@ pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
Seek => &[icon!("keyboard", "keyboard_arrows_horizontal")],
Volume => &[icon!("keyboard", "keyboard_minus"), icon!("keyboard", "keyboard_plus")],
Mute => &[icon!("keyboard", "keyboard_m")],
Shuffle => &[icon!("keyboard", "keyboard_s")],
ShufflePlay => &[icon!("keyboard", "keyboard_shift"), icon!("keyboard", "keyboard_s")],
OnScreenKeyboard => &[],
},
Prompts::Pad(Family::Xbox) => match control {
Activate => &[icon!("xbox", "xbox_button_color_a")],
ShufflePlay => &[icon!("xbox", "xbox_button_color_a")],
Back => &[icon!("xbox", "xbox_button_color_b")],
PlayPause => &[icon!("xbox", "xbox_button_color_x")],
Queue => &[icon!("xbox", "xbox_button_color_y")],
Shuffle => &[icon!("xbox", "xbox_button_color_y")],
Skip => &[icon!("xbox", "xbox_lb"), icon!("xbox", "xbox_rb")],
Sections => &[icon!("xbox", "xbox_lt"), icon!("xbox", "xbox_rt")],
Search => &[icon!("xbox", "xbox_button_view")],
@@ -99,9 +110,11 @@ pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
},
Prompts::Pad(Family::PlayStation) => match control {
Activate => &[icon!("playstation", "playstation_button_color_cross")],
ShufflePlay => &[icon!("playstation", "playstation_button_color_cross")],
Back => &[icon!("playstation", "playstation_button_color_circle")],
PlayPause => &[icon!("playstation", "playstation_button_color_square")],
Queue => &[icon!("playstation", "playstation_button_color_triangle")],
Shuffle => &[icon!("playstation", "playstation_button_color_triangle")],
Skip => &[
icon!("playstation", "playstation_trigger_l1"),
icon!("playstation", "playstation_trigger_r1"),
@@ -124,9 +137,11 @@ pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
// By position, as gilrs reports buttons: the bottom face button is B on a Switch.
Prompts::Pad(Family::Switch) => match control {
Activate => &[icon!("switch", "switch_button_b")],
ShufflePlay => &[icon!("switch", "switch_button_b")],
Back => &[icon!("switch", "switch_button_a")],
PlayPause => &[icon!("switch", "switch_button_y")],
Queue => &[icon!("switch", "switch_button_x")],
Shuffle => &[icon!("switch", "switch_button_x")],
Skip => &[icon!("switch", "switch_button_l"), icon!("switch", "switch_button_r")],
Sections => &[icon!("switch", "switch_button_zl"), icon!("switch", "switch_button_zr")],
Search => &[icon!("switch", "switch_button_minus")],
@@ -141,9 +156,11 @@ pub fn icons(prompts: Prompts, control: Control) -> &'static [&'static [u8]] {
},
Prompts::Pad(Family::SteamDeck) => match control {
Activate => &[icon!("steamdeck", "steamdeck_button_a")],
ShufflePlay => &[icon!("steamdeck", "steamdeck_button_a")],
Back => &[icon!("steamdeck", "steamdeck_button_b")],
PlayPause => &[icon!("steamdeck", "steamdeck_button_x")],
Queue => &[icon!("steamdeck", "steamdeck_button_y")],
Shuffle => &[icon!("steamdeck", "steamdeck_button_y")],
Skip => &[
icon!("steamdeck", "steamdeck_button_l1"),
icon!("steamdeck", "steamdeck_button_r1"),
+31
View File
@@ -12,13 +12,23 @@ use anyhow::Result;
use serde::{Deserialize, Serialize};
use crate::config;
use crate::shuffle::{Library, Mode};
use crate::subsonic::{Client, Song};
const VERSION: u32 = 1;
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct SavedQueue {
/// In the order they play.
pub songs: Vec<Song>,
/// Each song's position in the order it was queued. Empty in files from
/// before shuffle, which were saved in that order.
#[serde(default)]
pub order: Vec<usize>,
#[serde(default)]
pub shuffle: Mode,
#[serde(default)]
pub library: Option<Library>,
pub current: Option<usize>,
/// Seconds into the current song.
pub position: f64,
@@ -121,6 +131,9 @@ mod tests {
let mut queues = SavedQueues::default();
let a = SavedQueue {
songs: vec![song("1"), song("2")],
order: vec![1, 0],
shuffle: Mode::Tracks,
library: Some(Library { added_end: 1 }),
current: Some(1),
position: 93.5,
};
@@ -128,6 +141,7 @@ mod tests {
songs: vec![song("9")],
current: None,
position: 0.0,
..SavedQueue::default()
};
queues.set(&home, a.clone());
queues.set(&other, b.clone());
@@ -142,6 +156,23 @@ mod tests {
let _ = fs::remove_dir_all(path.parent().unwrap());
}
#[test]
fn a_queue_saved_before_shuffle_loads_unshuffled() {
let path = temp("before-shuffle");
fs::create_dir_all(path.parent().unwrap()).unwrap();
let client = Client::new("https://h", "u", Auth::Password("p".into()));
let text = r#"{"version": 1, "servers": {"u@https://h": {
"songs": [{"id": "1", "title": "One"}], "current": 0, "position": 12.0}}}"#;
fs::write(&path, text).unwrap();
let q = load(&path).get(&client).cloned().expect("the queue");
assert_eq!(
(q.songs.len(), q.order, q.shuffle, q.library),
(1, vec![], Mode::Off, None)
);
assert_eq!(q.songs[0].album_id, None);
let _ = fs::remove_dir_all(path.parent().unwrap());
}
#[test]
fn an_unreadable_file_loads_as_empty() {
let path = temp("unreadable");
+348
View File
@@ -0,0 +1,348 @@
//! Shuffled play orders. Every function returns a permutation: positions into
//! the queue as it plays now, in the order it should play next. The caller
//! applies the same permutation to the songs, to their original positions and
//! to the player's URLs, so the three never disagree.
//!
//! `fixed` is how many tracks at the head of the queue stay where they are:
//! those played, the one playing and one already handed to playbin.
use std::collections::HashMap;
use fastrand::Rng;
use serde::{Deserialize, Serialize};
use crate::subsonic::Song;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Mode {
#[default]
Off,
Tracks,
Albums,
}
impl Mode {
pub fn next(self) -> Mode {
match self {
Mode::Off => Mode::Tracks,
Mode::Tracks => Mode::Albums,
Mode::Albums => Mode::Off,
}
}
}
/// Library shuffle: the queue is topped up with random tracks from the
/// server as it runs low.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Library {
/// Where the random tracks carry on after those queued by hand, which go
/// after the playing track and after any queued before them.
pub added_end: usize,
}
/// Which album a song belongs to. The album name alone would merge different
/// albums of the same title, so it is only the fallback for songs saved
/// without an album id. A song with neither is an album of its own.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
enum AlbumKey<'a> {
Id(&'a str),
Name(&'a str, Option<&'a str>),
Alone(usize),
}
fn album_key(song: &Song, pos: usize) -> AlbumKey<'_> {
match (&song.album_id, &song.album) {
(Some(id), _) => AlbumKey::Id(id),
(None, Some(name)) if !name.is_empty() => AlbumKey::Name(name, song.artist.as_deref()),
_ => AlbumKey::Alone(pos),
}
}
/// Keeps the first `fixed` tracks and shuffles the rest.
pub fn tracks(rng: &mut Rng, len: usize, fixed: usize) -> Vec<usize> {
let fixed = fixed.min(len);
let mut perm: Vec<usize> = (0..len).collect();
rng.shuffle(&mut perm[fixed..]);
perm
}
/// Keeps the first `fixed` tracks, then plays the rest of the playing track's
/// album, then the other albums in random order. Each album plays in disc and
/// track order, and tracks without numbers keep their original order.
/// `original` holds each track's position in the original order.
pub fn albums(rng: &mut Rng, songs: &[Song], original: &[usize], playing: Option<usize>, fixed: usize) -> Vec<usize> {
let fixed = fixed.min(songs.len());
let mut groups = album_groups(songs, original, fixed..songs.len());
let first = playing
.and_then(|p| songs.get(p).map(|s| album_key(s, p)))
.and_then(|key| groups.iter().position(|(k, _)| *k == key))
.map(|i| groups.remove(i));
rng.shuffle(&mut groups);
(0..fixed)
.chain(first.into_iter().chain(groups).flat_map(|(_, g)| g))
.collect()
}
/// The tracks in `range` grouped by album, in the order each album first
/// appears, each sorted by disc and track.
fn album_groups<'a>(
songs: &'a [Song],
original: &[usize],
range: std::ops::Range<usize>,
) -> Vec<(AlbumKey<'a>, Vec<usize>)> {
let mut groups: Vec<(AlbumKey<'a>, Vec<usize>)> = Vec::new();
let mut index: HashMap<AlbumKey<'a>, usize> = HashMap::new();
for pos in range {
let key = album_key(&songs[pos], pos);
let i = *index.entry(key.clone()).or_insert_with(|| {
groups.push((key, Vec::new()));
groups.len() - 1
});
groups[i].1.push(pos);
}
for (_, g) in &mut groups {
g.sort_by_key(|&p| {
let s = &songs[p];
(
s.disc_number.unwrap_or(0),
s.track.unwrap_or(0),
original.get(p).copied().unwrap_or(p),
)
});
}
groups
}
/// Places the tracks from `added` on (just appended to the queue) at random
/// positions after the first `fixed`. Under album shuffle each added album
/// goes in as one block, and only between albums, never inside one.
pub fn insert(rng: &mut Rng, mode: Mode, songs: &[Song], original: &[usize], fixed: usize, added: usize) -> Vec<usize> {
let added = added.min(songs.len());
let fixed = fixed.min(added);
let mut tail: Vec<usize> = (fixed..added).collect();
if mode == Mode::Albums {
let mut blocks: Vec<Vec<usize>> = Vec::new();
for pos in tail {
let key = album_key(&songs[pos], pos);
match blocks.last_mut() {
Some(b) if album_key(&songs[b[0]], b[0]) == key => b.push(pos),
_ => blocks.push(vec![pos]),
}
}
// The rest of the album playing now still plays first.
let lo = match (fixed.checked_sub(1), blocks.first()) {
(Some(last), Some(b)) if album_key(&songs[last], last) == album_key(&songs[b[0]], b[0]) => 1,
_ => 0,
};
for (_, g) in album_groups(songs, original, added..songs.len()) {
let at = rng.usize(lo..=blocks.len());
blocks.insert(at, g);
}
tail = blocks.concat();
} else {
for pos in added..songs.len() {
let at = rng.usize(..=tail.len());
tail.insert(at, pos);
}
}
(0..fixed).chain(tail).collect()
}
/// Back to the original order, given each track's original position. A
/// `pinned` track (handed to playbin already) is moved to play right after
/// `playing`, so the track that plays next is the one the player expects.
pub fn unshuffle(original: &[usize], playing: Option<usize>, pinned: Option<usize>) -> Vec<usize> {
let mut perm: Vec<usize> = (0..original.len()).collect();
perm.sort_by_key(|&p| original[p]);
if let (Some(playing), Some(pinned)) = (playing, pinned)
&& playing != pinned
&& let Some(from) = perm.iter().position(|&p| p == pinned)
{
perm.remove(from);
let at = perm.iter().position(|&p| p == playing).map_or(perm.len(), |i| i + 1);
perm.insert(at, pinned);
}
perm
}
/// `items` reordered by `perm`.
pub fn apply<T: Clone>(items: &[T], perm: &[usize]) -> Vec<T> {
perm.iter().map(|&p| items[p].clone()).collect()
}
#[cfg(test)]
mod tests {
use super::*;
fn song(id: &str, album: Option<&str>, track: u32) -> Song {
serde_json::from_value(serde_json::json!({
"id": id, "title": id, "album": album.map(|a| format!("Album {a}")),
"albumId": album, "artist": "A", "track": track,
}))
.unwrap()
}
fn is_permutation(perm: &[usize], len: usize) -> bool {
let mut sorted = perm.to_vec();
sorted.sort();
sorted == (0..len).collect::<Vec<_>>()
}
#[test]
fn tracks_keeps_the_fixed_head_and_plays_the_rest_once() {
let mut rng = Rng::with_seed(1);
for fixed in [0, 1, 3, 10, 12] {
let perm = tracks(&mut rng, 10, fixed);
assert!(is_permutation(&perm, 10));
let fixed = fixed.min(10);
assert_eq!(perm[..fixed], (0..fixed).collect::<Vec<_>>()[..]);
}
}
#[test]
fn tracks_actually_shuffles() {
let mut rng = Rng::with_seed(7);
let perm = tracks(&mut rng, 50, 1);
assert_ne!(perm, (0..50).collect::<Vec<_>>());
}
#[test]
fn albums_finish_the_playing_album_then_play_whole_albums_in_track_order() {
// Track shuffled already: b2, a1, b1 | a2, c1, b3, a3, c2.
let songs = vec![
song("b2", Some("b"), 2),
song("a1", Some("a"), 1),
song("b1", Some("b"), 1),
song("a2", Some("a"), 2),
song("c2", Some("c"), 2),
song("b3", Some("b"), 3),
song("a3", Some("a"), 3),
song("c1", Some("c"), 1),
];
let original: Vec<usize> = (0..songs.len()).collect();
for seed in 0..20 {
let mut rng = Rng::with_seed(seed);
let perm = albums(&mut rng, &songs, &original, Some(0), 3);
assert!(is_permutation(&perm, songs.len()));
let ids: Vec<&str> = perm.iter().map(|&p| songs[p].id.as_str()).collect();
assert_eq!(ids[..3], ["b2", "a1", "b1"]);
assert_eq!(ids[3], "b3", "the playing album goes on first");
let rest = &ids[4..];
assert!(
rest == ["a2", "a3", "c1", "c2"] || rest == ["c1", "c2", "a2", "a3"],
"seed {seed}: {rest:?}"
);
}
}
#[test]
fn albums_with_the_same_name_stay_apart_and_saved_songs_fall_back_to_the_name() {
let mut same_name = song("x1", Some("x"), 1);
same_name.album = Some("Album y".into());
let mut saved = song("y2", None, 2);
saved.album = Some("Album y".into());
let mut saved1 = song("y1", None, 1);
saved1.album = Some("Album y".into());
let songs = vec![song("p", Some("p"), 1), saved, same_name, saved1];
let original: Vec<usize> = (0..songs.len()).collect();
let mut rng = Rng::with_seed(3);
let perm = albums(&mut rng, &songs, &original, Some(0), 1);
let ids: Vec<&str> = perm.iter().map(|&p| songs[p].id.as_str()).collect();
let y = ids.iter().position(|&i| i == "y1").unwrap();
assert_eq!(ids[y + 1], "y2", "{ids:?}");
assert!(ids.contains(&"x1"));
}
#[test]
fn tracks_without_numbers_keep_their_original_order() {
let mut songs: Vec<Song> = ["a", "b", "c"].iter().map(|id| song(id, Some("al"), 0)).collect();
for s in &mut songs {
s.track = None;
}
// Played as c, a, b; originally a, b, c.
let songs = vec![songs[2].clone(), songs[0].clone(), songs[1].clone()];
let original = vec![2, 0, 1];
let mut rng = Rng::with_seed(0);
let perm = albums(&mut rng, &songs, &original, None, 0);
let ids: Vec<&str> = perm.iter().map(|&p| songs[p].id.as_str()).collect();
assert_eq!(ids, ["a", "b", "c"]);
}
#[test]
fn insert_scatters_added_tracks_after_the_fixed_head() {
let songs: Vec<Song> = (0..20).map(|i| song(&i.to_string(), None, 0)).collect();
let original: Vec<usize> = (0..20).collect();
let mut rng = Rng::with_seed(5);
let perm = insert(&mut rng, Mode::Tracks, &songs, &original, 2, 15);
assert!(is_permutation(&perm, 20));
assert_eq!(perm[..2], [0, 1]);
let old: Vec<usize> = perm.iter().copied().filter(|&p| p < 15).collect();
assert_eq!(old, (0..15).collect::<Vec<_>>(), "the queued tracks keep their order");
assert_ne!(perm[15..], [15, 16, 17, 18, 19], "added tracks are not all at the end");
}
#[test]
fn insert_under_album_shuffle_adds_whole_albums_between_albums() {
let songs = vec![
song("p1", Some("p"), 1),
song("q1", Some("q"), 1),
song("q2", Some("q"), 2),
song("r1", Some("r"), 1),
song("r2", Some("r"), 2),
song("n2", Some("n"), 2),
song("n1", Some("n"), 1),
];
let original: Vec<usize> = (0..songs.len()).collect();
for seed in 0..20 {
let mut rng = Rng::with_seed(seed);
let perm = insert(&mut rng, Mode::Albums, &songs, &original, 1, 5);
let ids: Vec<&str> = perm.iter().map(|&p| songs[p].id.as_str()).collect();
let n = ids.iter().position(|&i| i == "n1").unwrap();
assert_eq!(ids[n + 1], "n2", "seed {seed}: {ids:?}");
assert!(
n >= 1 && ids[n - 1] != "q1" && ids[n - 1] != "r1",
"seed {seed}: {ids:?}"
);
}
}
#[test]
fn insert_under_album_shuffle_leaves_the_playing_album_first() {
let songs = vec![
song("p1", Some("p"), 1),
song("p2", Some("p"), 2),
song("q1", Some("q"), 1),
song("n1", Some("n"), 1),
];
let original: Vec<usize> = (0..songs.len()).collect();
for seed in 0..20 {
let mut rng = Rng::with_seed(seed);
let perm = insert(&mut rng, Mode::Albums, &songs, &original, 1, 3);
assert_eq!(perm[1], 1, "seed {seed}: {perm:?}");
}
}
#[test]
fn unshuffle_restores_the_original_order() {
let original = vec![3, 0, 4, 1, 2];
let perm = unshuffle(&original, Some(0), None);
assert_eq!(apply(&original, &perm), [0, 1, 2, 3, 4]);
}
#[test]
fn unshuffle_plays_the_pinned_track_next() {
// Playing original 3, playbin already has original 0.
let original = vec![1, 3, 0, 4, 2];
let perm = unshuffle(&original, Some(1), Some(2));
assert_eq!(apply(&original, &perm), [1, 2, 3, 0, 4]);
}
#[test]
fn modes_cycle_off_tracks_albums() {
assert_eq!(Mode::Off.next(), Mode::Tracks);
assert_eq!(Mode::Tracks.next(), Mode::Albums);
assert_eq!(Mode::Albums.next(), Mode::Off);
}
}
+100
View File
@@ -212,6 +212,28 @@ impl Client {
Ok(r.artist)
}
/// Every song on the artist's albums, album by album. A few albums are
/// fetched at a time, so an artist with dozens does not flood the server.
pub async fn artist_songs(&self, id: &str) -> Result<Vec<Song>> {
let albums = self.artist(id).await?.album;
let limit = std::sync::Arc::new(tokio::sync::Semaphore::new(4));
let tasks: Vec<_> = albums
.into_iter()
.map(|a| {
let (client, limit) = (self.clone(), limit.clone());
tokio::spawn(async move {
let _permit = limit.acquire_owned().await?;
anyhow::Ok(client.album(&a.id).await?.song)
})
})
.collect();
let mut songs = Vec::new();
for t in tasks {
songs.extend(t.await??);
}
Ok(songs)
}
pub async fn album(&self, id: &str) -> Result<AlbumDetail> {
#[derive(Deserialize)]
struct R {
@@ -265,6 +287,23 @@ impl Client {
Ok(r.result)
}
/// Up to `size` random songs from the whole library. Servers cap `size`
/// at 500.
pub async fn random_songs(&self, size: u32) -> Result<Vec<Song>> {
#[derive(Deserialize)]
struct R {
#[serde(rename = "randomSongs", default)]
list: Songs,
}
#[derive(Deserialize, Default)]
struct Songs {
#[serde(default)]
song: Vec<Song>,
}
let r: R = self.call("getRandomSongs", &[("size", size.to_string())]).await?;
Ok(r.list.song)
}
pub async fn scrobble(&self, id: &str, submission: bool) -> Result<()> {
let _: serde_json::Value = self
.call("scrobble", &[("id", id.into()), ("submission", submission.to_string())])
@@ -426,6 +465,9 @@ pub struct Song {
pub artist: Option<String>,
#[serde(default)]
pub album: Option<String>,
/// None in queues saved before it was kept, and from servers that leave it out.
#[serde(default, deserialize_with = "de_opt_id")]
pub album_id: Option<String>,
#[serde(default, deserialize_with = "de_opt_id")]
pub cover_art: Option<String>,
#[serde(default)]
@@ -489,6 +531,56 @@ mod tests {
let a: Album = serde_json::from_str(r#"{"id": 42, "name": "X", "coverArt": 7}"#).unwrap();
assert_eq!(a.id, "42");
assert_eq!(a.cover_art.as_deref(), Some("7"));
let s: Song = serde_json::from_str(r#"{"id": 1, "albumId": 42}"#).unwrap();
assert_eq!(s.album_id.as_deref(), Some("42"));
let s: Song = serde_json::from_str(r#"{"id": 1}"#).unwrap();
assert_eq!(s.album_id, None);
}
/// A loopback HTTP server that answers every request with `body` and
/// sends each request line back.
fn fake_server(body: &'static str) -> (String, std::sync::mpsc::Receiver<String>) {
use std::io::{BufRead, BufReader, Write};
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let addr = listener.local_addr().unwrap();
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
for stream in listener.incoming() {
let Ok(mut stream) = stream else { continue };
let mut line = String::new();
let _ = BufReader::new(stream.try_clone().unwrap()).read_line(&mut line);
let _ = tx.send(line);
let _ = write!(
stream,
"HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{body}",
body.len()
);
}
});
(format!("http://{addr}"), rx)
}
#[tokio::test]
async fn random_songs_asks_for_the_size_and_reads_the_songs() {
let (base, requests) = fake_server(
r#"{"subsonic-response":{"status":"ok","randomSongs":{"song":[
{"id":"s1","title":"One","albumId":"al-1"},{"id":"s2","title":"Two"}]}}}"#,
);
let c = Client::new(&base, "u", Auth::Password("sesame".into()));
let songs = c.random_songs(50).await.unwrap();
let ids: Vec<_> = songs.iter().map(|s| s.id.as_str()).collect();
assert_eq!(ids, ["s1", "s2"]);
assert_eq!(songs[0].album_id.as_deref(), Some("al-1"));
let line = requests.recv().unwrap();
assert!(line.contains("/rest/getRandomSongs?"), "{line}");
assert!(line.contains("size=50"), "{line}");
}
#[tokio::test]
async fn random_songs_from_an_empty_library_is_empty() {
let (base, _) = fake_server(r#"{"subsonic-response":{"status":"ok","randomSongs":{}}}"#);
let c = Client::new(&base, "u", Auth::Password("sesame".into()));
assert!(c.random_songs(50).await.unwrap().is_empty());
}
/// Exercises every endpoint against a real server:
@@ -514,6 +606,7 @@ mod tests {
assert!(!albums.is_empty(), "no albums");
let album = c.album(&albums[0].id).await.unwrap();
assert!(!album.song.is_empty(), "album has no songs");
assert_eq!(album.song[0].album_id.as_deref(), Some(albums[0].id.as_str()));
println!(
"album: {} by {:?}, {} songs",
album.name,
@@ -530,6 +623,9 @@ mod tests {
assert!(!artists.is_empty(), "no artists");
let artist = c.artist(&artists[0].id).await.unwrap();
println!("artist: {} with {} albums", artist.name, artist.album.len());
let songs = c.artist_songs(&artists[0].id).await.unwrap();
assert!(!songs.is_empty(), "artist has no songs");
println!("artist songs: {}", songs.len());
let playlists = c.playlists().await.unwrap();
if let Some(p) = playlists.first() {
@@ -537,6 +633,10 @@ mod tests {
println!("playlist: {} with {} entries", p.name, p.entry.len());
}
let random = c.random_songs(20).await.unwrap();
assert!(!random.is_empty(), "no random songs");
println!("random: {} songs", random.len());
let found = c.search(&album.name).await.unwrap();
assert!(!found.album.is_empty(), "search found nothing for {}", album.name);
+163 -56
View File
@@ -9,7 +9,7 @@ export enum Action {
none, up, down, left, right, page-up, page-down, activate, back,
play-pause, next, prev, queue, section-next, section-prev,
now-playing, search, seek-forward, seek-back, toggle-fullscreen, quit,
volume-up, volume-down, toggle-mute,
volume-up, volume-down, toggle-mute, cycle-shuffle, shuffle, hold-activate,
}
export enum Screen { login, browse, now-playing }
@@ -213,8 +213,10 @@ component Row inherits Rectangle {
round: root.item.round;
}
}
// As wide as the art, so a row with a cover and a row with a number
// line up, as on an album where some tracks have their own cover.
if !root.item.show-art: Text {
width: 34px * Theme.s;
width: 46px * Theme.s;
text: root.item.playing ? "▶" : root.item.number;
font-size: 15px * Theme.s;
color: root.item.playing ? Theme.highlight : Theme.faint;
@@ -567,6 +569,55 @@ component Speaker {
}
}
// A quiet speaker, bar and number for the current volume.
component VolumeLevel inherits HorizontalLayout {
in property <int> level;
in property <bool> muted;
in property <length> font-size: 13px * Theme.s;
// The speaker gets a box as wide as the number, so the bar is the middle
// of the whole and centring the row centres the bar.
in property <bool> balanced;
// Fixed, so the bar does not shift as the number changes, and wide enough
// for "Muted".
property <length> label-width: 4.2 * root.font-size;
spacing: 10px * Theme.s;
// Its own width only, so a stretching row does not hand it the slack.
horizontal-stretch: 0;
HorizontalLayout {
width: root.balanced ? root.label-width : 14px * Theme.s;
alignment: end;
Speaker {
muted: root.muted || root.level == 0;
tint: Theme.muted;
size: 14px * Theme.s;
y: (parent.height - self.height) / 2;
}
}
VerticalLayout {
alignment: center;
Rectangle {
width: 90px * Theme.s;
height: 4px * Theme.s;
border-radius: 2px * Theme.s;
background: Theme.raised;
Rectangle {
x: 0;
width: parent.width * (root.muted ? 0 : root.level / 100);
border-radius: 2px * Theme.s;
background: Theme.muted;
}
}
}
Text {
width: root.label-width;
text: root.muted ? "Muted" : root.level;
font-size: root.font-size;
color: Theme.muted;
vertical-alignment: center;
}
}
// The level after a volume change, faded out again by the app after a moment.
component VolumeOverlay inherits Rectangle {
in property <bool> shown;
@@ -633,6 +684,8 @@ component NowBar inherits Rectangle {
in property <float> progress;
in property <string> time;
in property <bool> paused;
in property <int> volume;
in property <bool> muted;
background: Theme.panel;
@@ -699,6 +752,12 @@ component NowBar inherits Rectangle {
size: 15px * Theme.s;
}
}
if root.has-track: Rectangle { width: 6px * Theme.s; }
if root.has-track: VolumeLevel {
level: root.volume;
muted: root.muted;
font-size: 15px * Theme.s;
}
}
}
@@ -750,6 +809,8 @@ component Field inherits VerticalLayout {
in property <string> label;
in-out property <string> text;
in property <bool> password;
// A password field shows its text while this is set, toggled by the eye.
in-out property <bool> shown;
in property <bool> highlighted;
callback accepted;
public function focus-input() {
@@ -770,16 +831,55 @@ component Field inherits VerticalLayout {
border-color: input.has-focus || root.highlighted ? Theme.focus : Theme.line;
input := TextInput {
x: 16px * Theme.s;
width: parent.width - 32px * Theme.s;
// Leaves room for the eye on a password field.
width: parent.width - (root.password ? 64px : 32px) * Theme.s;
height: parent.height;
text <=> root.text;
font-size: 19px * Theme.s;
color: Theme.text;
vertical-alignment: center;
single-line: true;
input-type: root.password ? InputType.password : InputType.text;
input-type: root.password && !root.shown ? InputType.password : InputType.text;
accepted => { root.accepted(); }
}
if root.password: Rectangle {
x: parent.width - self.width - 8px * Theme.s;
width: 40px * Theme.s;
height: parent.height;
// An eye to show the password, struck through to hide it again.
Path {
width: 22px * Theme.s;
height: 22px * Theme.s;
viewbox-width: 24;
viewbox-height: 24;
commands: "M 1.5 12 C 4.5 6.5 8 4.5 12 4.5 C 16 4.5 19.5 6.5 22.5 12 C 19.5 17.5 16 19.5 12 19.5 C 8 19.5 4.5 17.5 1.5 12 Z";
stroke: eye-area.has-hover ? Theme.text : Theme.muted;
stroke-width: 1.6px * Theme.s;
}
Path {
width: 22px * Theme.s;
height: 22px * Theme.s;
viewbox-width: 24;
viewbox-height: 24;
commands: "M 12 8.5 A 3.5 3.5 0 1 1 11.99 8.5 Z";
fill: eye-area.has-hover ? Theme.text : Theme.muted;
}
if root.shown: Path {
width: 22px * Theme.s;
height: 22px * Theme.s;
viewbox-width: 24;
viewbox-height: 24;
commands: "M 3 21 L 21 3";
stroke: eye-area.has-hover ? Theme.text : Theme.muted;
stroke-width: 1.8px * Theme.s;
}
eye-area := TouchArea {
clicked => {
root.shown = !root.shown;
input.focus();
}
}
}
}
}
@@ -787,9 +887,12 @@ component LoginView inherits Rectangle {
in-out property <string> server;
in-out property <string> username;
in-out property <string> password;
in-out property <bool> password-shown;
in property <int> focus-index;
in property <string> error;
in property <bool> busy;
// Adding a server from inside the app: the bottom button goes back.
in property <bool> can-cancel;
callback submit;
callback exit;
callback field-clicked(int);
@@ -845,6 +948,7 @@ component LoginView inherits Rectangle {
label: "Password";
text <=> root.password;
password: true;
shown <=> root.password-shown;
highlighted: root.focus-index == 2;
accepted => { root.submit(); }
}
@@ -869,7 +973,7 @@ component LoginView inherits Rectangle {
border-width: 2px * Theme.s;
border-color: root.focus-index == 4 ? Theme.focus : Theme.line;
Text {
text: "Exit";
text: root.can-cancel ? "Cancel" : "Exit";
font-size: 17px * Theme.s;
color: root.focus-index == 4 ? Theme.text : Theme.muted;
}
@@ -919,6 +1023,8 @@ component NowPlayingView inherits Rectangle {
in property <[Item]> queue;
in property <int> queue-count;
in property <int> queue-selected;
// How the queue is shuffled, empty when it plays in order.
in property <string> shuffle;
callback queue-clicked(int);
callback queue-wheel(int);
// From the scale, not our own size: a layout child sized from its parent loops.
@@ -992,60 +1098,37 @@ component NowPlayingView inherits Rectangle {
background: Theme.highlight;
}
}
HorizontalLayout {
Text {
// Placed by hand: the icon on the bar's midpoint whatever the
// widths of the two times, which a layout would share out.
Rectangle {
height: position-text.preferred-height;
position-text := Text {
x: 0;
width: self.preferred-width;
text: root.position;
font-size: 14px * Theme.s;
color: Theme.muted;
}
// Sized below the time text, so the row keeps the text's height.
HorizontalLayout {
horizontal-stretch: 1;
alignment: center;
if root.has-track: VerticalLayout {
alignment: center;
PlayState {
paused: root.paused;
size: 11px * Theme.s;
}
}
}
Text {
x: parent.width - self.width;
width: self.preferred-width;
text: root.duration;
font-size: 14px * Theme.s;
color: Theme.muted;
}
if root.has-track: PlayState {
x: (parent.width - self.width) / 2;
y: (parent.height - self.height) / 2;
paused: root.paused;
size: 11px * Theme.s;
}
}
HorizontalLayout {
spacing: 10px * Theme.s;
alignment: start;
VerticalLayout {
alignment: center;
Speaker {
muted: root.muted || root.volume == 0;
tint: Theme.muted;
size: 14px * Theme.s;
}
}
VerticalLayout {
alignment: center;
Rectangle {
width: 90px * Theme.s;
height: 4px * Theme.s;
border-radius: 2px * Theme.s;
background: Theme.raised;
Rectangle {
x: 0;
width: parent.width * (root.muted ? 0 : root.volume / 100);
border-radius: 2px * Theme.s;
background: Theme.muted;
}
}
}
Text {
text: root.muted ? "Muted" : root.volume;
font-size: 13px * Theme.s;
color: Theme.muted;
alignment: center;
VolumeLevel {
level: root.volume;
muted: root.muted;
balanced: true;
}
}
}
@@ -1053,12 +1136,23 @@ component NowPlayingView inherits Rectangle {
VerticalLayout {
spacing: 14px * Theme.s;
horizontal-stretch: 1;
Text {
text: "Queue";
font-size: 28px * Theme.s;
font-family: Theme.serif;
font-weight: 600;
color: Theme.text;
HorizontalLayout {
spacing: 16px * Theme.s;
Text {
text: "Queue";
font-size: 28px * Theme.s;
font-family: Theme.serif;
font-weight: 600;
color: Theme.text;
}
Text {
horizontal-stretch: 1;
text: root.shuffle;
font-size: 16px * Theme.s;
color: Theme.muted;
vertical-alignment: center;
overflow: elide;
}
}
ItemView {
vertical-stretch: 1;
@@ -1118,6 +1212,8 @@ export component AppWindow inherits Window {
in property <int> login-focus;
in property <string> login-error;
in property <bool> login-busy;
in property <bool> login-can-cancel;
in-out property <bool> login-password-shown;
// Browse
in property <[string]> sections;
@@ -1149,6 +1245,7 @@ export component AppWindow inherits Window {
in property <string> np-position;
in property <string> np-duration;
in property <bool> np-paused;
in property <string> np-shuffle;
in property <bool> np-flip-out;
in property <float> np-backdrop-opacity: 0.16;
in property <float> np-backdrop-left: 0.67;
@@ -1165,6 +1262,7 @@ export component AppWindow inherits Window {
in property <int> volume;
in property <bool> muted;
in property <string> version;
in property <bool> show-hint-bar: true;
public function focus-main() {
fs.focus();
@@ -1221,6 +1319,8 @@ export component AppWindow inherits Window {
if (e.text == "+" || e.text == "=") { root.action(Action.volume-up); return accept; }
if (e.text == "-") { root.action(Action.volume-down); return accept; }
if (e.text == "m") { root.action(Action.toggle-mute); return accept; }
if (e.text == "s") { root.action(Action.cycle-shuffle); return accept; }
if (e.text == "S") { root.action(Action.shuffle); return accept; }
reject
}
@@ -1236,11 +1336,13 @@ export component AppWindow inherits Window {
server <=> root.login-server;
username <=> root.login-username;
password <=> root.login-password;
password-shown <=> root.login-password-shown;
focus-index: root.login-focus;
error: root.login-error;
busy: root.login-busy;
submit => { root.login-submit(); }
exit => { root.action(Action.quit); }
can-cancel: root.login-can-cancel;
exit => { root.action(root.login-can-cancel ? Action.back : Action.quit); }
field-clicked(i) => { root.login-field-clicked(i); }
}
@@ -1331,6 +1433,7 @@ export component AppWindow inherits Window {
queue: root.queue-items;
queue-count: root.queue-count;
queue-selected: root.queue-selected;
shuffle: root.np-shuffle;
queue-clicked(i) => { root.queue-clicked(i); }
queue-wheel(d) => { root.queue-wheel(d); }
}
@@ -1374,9 +1477,13 @@ export component AppWindow inherits Window {
progress: root.np-progress;
time: root.np-position + " / " + root.np-duration;
paused: root.np-paused;
volume: root.volume;
muted: root.muted;
}
HintBar {
// Optional, except on the login screen, where the controls are
// not known yet and Settings cannot be reached.
if root.show-hint-bar || root.screen == Screen.login: HintBar {
height: 46px * Theme.s;
hints: root.hints;
version: root.version;
+9
View File
@@ -0,0 +1,9 @@
<svg width="64" height="64" xmlns="http://www.w3.org/2000/svg">
<defs>
<mask id="letter">
<rect width="64" height="64" fill="#FFFFFF"/>
<path fill="none" stroke="#000000" stroke-width="4" stroke-linecap="square" d="M38 25.5 Q36.5 24 32 24 Q26 24 26 28 Q26 32 32 32 Q38 32 38 36 Q38 40 32 40 Q27.5 40 26 38.5"/>
</mask>
</defs>
<path stroke="none" fill="#FFFFFF" mask="url(#letter)" d="M16 8 L48 8 Q56 8 56 16 L56 48 Q56 56 48 56 L16 56 Q8 56 8 48 L8 16 Q8 8 16 8"/>
</svg>

After

Width:  |  Height:  |  Size: 499 B

+9
View File
@@ -0,0 +1,9 @@
<svg width="64" height="64" xmlns="http://www.w3.org/2000/svg">
<defs>
<mask id="glyph">
<rect width="64" height="64" fill="#FFFFFF"/>
<path fill="none" stroke="#000000" stroke-width="3.5" stroke-linejoin="round" d="M32 21 L42 32 L36.5 32 L36.5 42 L27.5 42 L27.5 32 L22 32 Z"/>
</mask>
</defs>
<path stroke="none" fill="#FFFFFF" mask="url(#glyph)" d="M16 8 L48 8 Q56 8 56 16 L56 48 Q56 56 48 56 L16 56 Q8 56 8 48 L8 16 Q8 8 16 8"/>
</svg>

After

Width:  |  Height:  |  Size: 465 B