From b73af1f8709658b473fa0ca9a908f9433400491a Mon Sep 17 00:00:00 2001 From: Yuriy Panov Date: Thu, 15 Oct 2026 14:38:33 +0600 Subject: [PATCH] feat: playback of liked tracks with audio engine, queue and player bar - ym-api: Track/Stream models, liked tracks, signed download URLs (full MP3 over AAC over previews, highest bitrate) and in-memory fetch - Audio thread on rodio, driven by commands and reporting through an iced subscription; generation ids drop stale events - Opens the default output with a buffer clamped to the device's range: rodio's 2048-frame default fails on Bluetooth headphones that cap at 1024 - Queue with shuffle, repeat off/all/one, back/advance and jump; player state machine with prefetch of the next track, replay from memory, and skipping unplayable tracks (stops after three in a row) - Working player bar (seek, volume, mute, quality badge), queue drawer, Collection screen with a lazily built liked-tracks list - audio_probe example lists and test-opens output devices --- Cargo.lock | 304 ++++++++++++++ README.md | 5 + crates/musyx/Cargo.toml | 4 +- crates/musyx/examples/audio_probe.rs | 23 + crates/musyx/src/app.rs | 114 ++++- crates/musyx/src/main.rs | 1 + crates/musyx/src/player/engine.rs | 215 ++++++++++ crates/musyx/src/player/mod.rs | 557 +++++++++++++++++++++++++ crates/musyx/src/player/queue.rs | 218 ++++++++++ crates/musyx/src/screens/collection.rs | 157 +++++++ crates/musyx/src/screens/mod.rs | 19 +- crates/musyx/src/snapshot.rs | 22 + crates/musyx/src/widgets/drawer.rs | 81 +++- crates/musyx/src/widgets/mod.rs | 1 + crates/musyx/src/widgets/player_bar.rs | 259 ++++-------- crates/musyx/src/widgets/track_row.rs | 95 +++++ crates/ym-api/Cargo.toml | 2 +- crates/ym-api/src/client.rs | 60 ++- crates/ym-api/src/lib.rs | 2 + crates/ym-api/src/models.rs | 204 +++++++++ 20 files changed, 2141 insertions(+), 202 deletions(-) create mode 100644 crates/musyx/examples/audio_probe.rs create mode 100644 crates/musyx/src/player/engine.rs create mode 100644 crates/musyx/src/player/mod.rs create mode 100644 crates/musyx/src/player/queue.rs create mode 100644 crates/musyx/src/screens/collection.rs create mode 100644 crates/musyx/src/widgets/track_row.rs create mode 100644 crates/ym-api/src/models.rs diff --git a/Cargo.lock b/Cargo.lock index b6ae164..6a5600d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -68,6 +68,12 @@ dependencies = [ "memchr", ] +[[package]] +name = "aliasable" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "250f629c0161ad8107cf89319e990051fae62832fd343083bea452d93e2205fd" + [[package]] name = "aligned" version = "0.4.3" @@ -86,6 +92,28 @@ dependencies = [ "equator", ] +[[package]] +name = "alsa" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "812947049edcd670a82cd5c73c3661d2e58468577ba8489de58e1a73c04cbd5d" +dependencies = [ + "alsa-sys", + "bitflags 2.13.2", + "cfg-if", + "libc", +] + +[[package]] +name = "alsa-sys" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad7569085a265dd3f607ebecce7458eaab2132a84393534c95b18dcbc3f31e04" +dependencies = [ + "libc", + "pkg-config", +] + [[package]] name = "android-activity" version = "0.6.1" @@ -830,6 +858,20 @@ dependencies = [ "libm", ] +[[package]] +name = "coreaudio-rs" +version = "0.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58" +dependencies = [ + "bitflags 2.13.2", + "libc", + "objc2-audio-toolbox", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", +] + [[package]] name = "cosmic-text" version = "0.15.0" @@ -854,6 +896,36 @@ dependencies = [ "unicode-segmentation", ] +[[package]] +name = "cpal" +version = "0.18.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f02e8d0327b42d3e2e4ab2119af397344eb9fc54a34bf0ddeaa1277af8681f1" +dependencies = [ + "alsa", + "block2 0.6.2", + "coreaudio-rs", + "dasp_sample", + "jni", + "js-sys", + "libc", + "mach2", + "ndk", + "ndk-context", + "num-derive", + "num-traits", + "objc2 0.6.5", + "objc2-audio-toolbox", + "objc2-avf-audio", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", + "web-sys", + "windows 0.62.2", + "windows-core 0.62.2", +] + [[package]] name = "cpubits" version = "0.1.1" @@ -983,6 +1055,12 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f27ae1dd37df86211c42e150270f82743308803d90a6f6e6651cd730d5e1732f" +[[package]] +name = "dasp_sample" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f" + [[package]] name = "data-url" version = "0.3.2" @@ -1712,6 +1790,12 @@ version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +[[package]] +name = "heck" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" + [[package]] name = "hermit-abi" version = "0.5.3" @@ -2034,6 +2118,7 @@ dependencies = [ "iced_renderer", "log", "num-traits", + "ouroboros", "qrcode", "rustc-hash 2.1.3", "thiserror 2.0.21", @@ -2436,6 +2521,12 @@ dependencies = [ "smallvec", ] +[[package]] +name = "lazy_static" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb" + [[package]] name = "lebe" version = "0.5.3" @@ -2613,6 +2704,12 @@ dependencies = [ "num-traits", ] +[[package]] +name = "mach2" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b" + [[package]] name = "malloc_buf" version = "0.0.6" @@ -2767,6 +2864,8 @@ dependencies = [ "keyring", "open", "png 0.18.1", + "rand 0.9.5", + "rodio", "serde_json", "tokio", "ym-api", @@ -3042,6 +3141,32 @@ dependencies = [ "objc2-quartz-core 0.3.2", ] +[[package]] +name = "objc2-audio-toolbox" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6948501a91121d6399b79abaa33a8aa4ea7857fe019f341b8c23ad6e81b79b08" +dependencies = [ + "bitflags 2.13.2", + "libc", + "objc2 0.6.5", + "objc2-core-audio", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-avf-audio" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.5", + "objc2-foundation 0.3.2", +] + [[package]] name = "objc2-cloud-kit" version = "0.2.2" @@ -3077,6 +3202,29 @@ dependencies = [ "objc2-foundation 0.2.2", ] +[[package]] +name = "objc2-core-audio" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2" +dependencies = [ + "dispatch2", + "objc2 0.6.5", + "objc2-core-audio-types", + "objc2-core-foundation", + "objc2-foundation 0.3.2", +] + +[[package]] +name = "objc2-core-audio-types" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c" +dependencies = [ + "bitflags 2.13.2", + "objc2 0.6.5", +] + [[package]] name = "objc2-core-data" version = "0.2.2" @@ -3107,7 +3255,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" dependencies = [ "bitflags 2.13.2", + "block2 0.6.2", "dispatch2", + "libc", "objc2 0.6.5", ] @@ -3375,6 +3525,30 @@ dependencies = [ "pin-project-lite", ] +[[package]] +name = "ouroboros" +version = "0.18.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0f050db9c44b97a94723127e6be766ac5c340c48f2c4bb3ffa11713744be59" +dependencies = [ + "aliasable", + "ouroboros_macro", + "static_assertions", +] + +[[package]] +name = "ouroboros_macro" +version = "0.18.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c7028bdd3d43083f6d8d4d5187680d0d3560d54df4cc9d752005268b41e64d0" +dependencies = [ + "heck", + "proc-macro2", + "proc-macro2-diagnostics", + "quote", + "syn 2.0.119", +] + [[package]] name = "owned_ttf_parser" version = "0.25.1" @@ -3589,6 +3763,19 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "proc-macro2-diagnostics" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", + "version_check", + "yansi", +] + [[package]] name = "profiling" version = "1.0.18" @@ -4070,6 +4257,19 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rodio" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36e3ee0a5ca418bac59a15d5506e498ab138359edbb67257a6b8a3b93d411f39" +dependencies = [ + "cpal", + "dasp_sample", + "num-rational", + "symphonia", + "thiserror 2.0.21", +] + [[package]] name = "roxmltree" version = "0.20.0" @@ -4654,6 +4854,104 @@ dependencies = [ "zeno", ] +[[package]] +name = "symphonia" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5773a4c030a19d9bfaa090f49746ff35c75dfddfa700df7a5939d5e076a57039" +dependencies = [ + "lazy_static", + "symphonia-bundle-flac", + "symphonia-bundle-mp3", + "symphonia-codec-aac", + "symphonia-core", + "symphonia-format-isomp4", + "symphonia-metadata", +] + +[[package]] +name = "symphonia-bundle-flac" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c91565e180aea25d9b80a910c546802526ffd0072d0b8974e3ebe59b686c9976" +dependencies = [ + "log", + "symphonia-core", + "symphonia-metadata", + "symphonia-utils-xiph", +] + +[[package]] +name = "symphonia-bundle-mp3" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4872dd6bb56bf5eac799e3e957aa1981086c3e613b27e0ac23b176054f7c57ed" +dependencies = [ + "lazy_static", + "log", + "symphonia-core", + "symphonia-metadata", +] + +[[package]] +name = "symphonia-codec-aac" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c263845aa86881416849c1729a54c7f55164f8b96111dba59de46849e73a790" +dependencies = [ + "lazy_static", + "log", + "symphonia-core", +] + +[[package]] +name = "symphonia-core" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ea00cc4f79b7f6bb7ff87eddc065a1066f3a43fe1875979056672c9ef948c2af" +dependencies = [ + "arrayvec", + "bitflags 1.3.2", + "bytemuck", + "lazy_static", + "log", +] + +[[package]] +name = "symphonia-format-isomp4" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "243739585d11f81daf8dac8d9f3d18cc7898f6c09a259675fc364b382c30e0a5" +dependencies = [ + "encoding_rs", + "log", + "symphonia-core", + "symphonia-metadata", + "symphonia-utils-xiph", +] + +[[package]] +name = "symphonia-metadata" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36306ff42b9ffe6e5afc99d49e121e0bd62fe79b9db7b9681d48e29fa19e6b16" +dependencies = [ + "encoding_rs", + "lazy_static", + "log", + "symphonia-core", +] + +[[package]] +name = "symphonia-utils-xiph" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee27c85ab799a338446b68eec77abf42e1a6f1bb490656e121c6e27bfbab9f16" +dependencies = [ + "symphonia-core", + "symphonia-metadata", +] + [[package]] name = "syn" version = "2.0.119" @@ -6074,6 +6372,12 @@ dependencies = [ "tokio", ] +[[package]] +name = "yansi" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049" + [[package]] name = "yazi" version = "0.2.1" diff --git a/README.md b/README.md index b486979..42a58aa 100644 --- a/README.md +++ b/README.md @@ -48,6 +48,11 @@ MUSYX_SNAPSHOT=design/shots/home.png MUSYX_SNAPSHOT_ROUTE=home MUSYX_SNAPSHOT_TH route except signin renders with a sample signed-in account, so no network or keychain is needed. `MUSYX_SNAPSHOT_DRAWER` takes queue or lyrics. `MUSYX_SNAPSHOT_THEME` takes light or dark. +### Audio + +`cargo run -p musyx --example audio_probe` lists the output devices and checks that each one +opens. Use it when the player bar says no sound output was found. + ## Licences Musyx is MIT. Onest and Unbounded are OFL (`crates/musyx/assets/fonts`), and Lucide icons diff --git a/crates/musyx/Cargo.toml b/crates/musyx/Cargo.toml index 5541c8b..7c4c57a 100644 --- a/crates/musyx/Cargo.toml +++ b/crates/musyx/Cargo.toml @@ -8,8 +8,10 @@ publish.workspace = true [dependencies] ym-api = { path = "../ym-api" } -iced = { version = "0.14.0", features = ["svg", "image", "tokio", "advanced", "qr_code"] } +iced = { version = "0.14.0", features = ["svg", "image", "tokio", "advanced", "qr_code", "lazy"] } keyring = "4.2.0" +rodio = { version = "0.23.0", default-features = false, features = ["playback", "mp3", "mp4", "flac"] } +rand = "0.9" open = "5.4.4" serde_json = "1" tokio = { version = "1", features = ["time", "rt"] } diff --git a/crates/musyx/examples/audio_probe.rs b/crates/musyx/examples/audio_probe.rs new file mode 100644 index 0000000..2d59db7 --- /dev/null +++ b/crates/musyx/examples/audio_probe.rs @@ -0,0 +1,23 @@ +//! Lists output devices and tries to open each one: `cargo run -p musyx --example audio_probe`. +use rodio::DeviceSinkBuilder; +use rodio::cpal::traits::{DeviceTrait, HostTrait}; + +fn main() { + let host = rodio::cpal::default_host(); + let default = host.default_output_device(); + println!("default: {:?}", default.as_ref().and_then(|d| d.description().ok()).map(|d| d.name().to_string())); + for device in host.output_devices().expect("devices") { + let name = device.description().map(|d| d.name().to_string()).unwrap_or_default(); + let config = device.default_output_config(); + println!("\n{name}\n default config: {config:?}"); + match DeviceSinkBuilder::from_device(device.clone()).map(|b| b.open_stream()) { + Ok(Ok(_)) => println!(" open (rodio defaults): ok"), + Ok(Err(e)) => println!(" open (rodio defaults): {e:?}"), + Err(e) => println!(" builder: {e:?}"), + } + if let Ok(config) = config { + let r = DeviceSinkBuilder::default().with_device(device.clone()).with_supported_config(&config).open_stream(); + println!(" open (device default buffer): {:?}", r.map(|_| "ok")); + } + } +} diff --git a/crates/musyx/src/app.rs b/crates/musyx/src/app.rs index fce2d13..c5e4713 100644 --- a/crates/musyx/src/app.rs +++ b/crates/musyx/src/app.rs @@ -6,12 +6,14 @@ use iced::{Element, Fill, Subscription, Task, Theme}; use ym_api::auth::Credentials; use ym_api::{Account, Error, YmClient}; +use crate::player::{self, Audio, Effect, Player}; use crate::route::{Navigator, Route}; +use crate::screens::collection::Liked; use crate::screens::{self, sign_in}; use crate::session::{self, Restored}; use crate::ui::theme::{self, shell}; use crate::widgets::drawer::{self, Panel}; -use crate::widgets::player_bar::{self, PlayerUi}; +use crate::widgets::player_bar; use crate::widgets::{sidebar, topbar}; /// Where sign-in stands. Everything but `SignedIn` takes the whole window. @@ -33,7 +35,8 @@ pub struct App { nav: Navigator, search: String, drawer: Option, - player: PlayerUi, + player: Player, + liked: Liked, } #[derive(Debug, Clone)] @@ -52,7 +55,10 @@ pub enum Message { SearchSubmitted, ToggleDrawer(Panel), CloseDrawer, - Player(player_bar::Action), + Player(player::Msg), + LoadLiked, + LikedLoaded(Result, Error>), + PlayLiked { start: usize, shuffle: bool }, } impl App { @@ -64,7 +70,8 @@ impl App { nav: Navigator::new(Route::Home), search: String::new(), drawer: None, - player: PlayerUi::default(), + player: Player::default(), + liked: Liked::NotLoaded, }; let appearance = iced::system::theme().map(Message::ThemeChanged); @@ -72,6 +79,7 @@ impl App { if let Some(config) = crate::snapshot::Config::from_env() { let mut app = app; app.session = config.session(); + app.liked = Liked::loaded(config.sample_liked(), &Liked::NotLoaded); if let Some(route) = config.route { app.nav = Navigator::new(route); } @@ -101,11 +109,14 @@ impl App { pub fn subscription(&self) -> Subscription { let appearance = iced::system::theme_changes().map(Message::ThemeChanged); + let audio = player::engine::subscription().map(|e| Message::Player(player::Msg::Engine(e))); match &self.session { - Session::SignedOut(sign_in) => { - Subscription::batch([appearance, sign_in.subscription().map(Message::SignIn)]) - } - _ => appearance, + Session::SignedOut(sign_in) => Subscription::batch([ + appearance, + audio, + sign_in.subscription().map(Message::SignIn), + ]), + _ => Subscription::batch([appearance, audio]), } } @@ -124,6 +135,7 @@ impl App { Restored::SignedOut => Session::SignedOut(Box::default()), Restored::Unreachable => Session::Unreachable, }; + return self.update(Message::LoadLiked); } Message::SignIn(msg) => { let Session::SignedOut(sign_in) = &mut self.session else { @@ -141,6 +153,7 @@ impl App { Message::Connected(Ok((client, account))) => { self.nav = Navigator::new(Route::Home); self.session = Session::SignedIn { client, account }; + return self.update(Message::LoadLiked); } Message::Connected(Err(e)) => { eprintln!("sign-in: {e}"); @@ -164,10 +177,14 @@ impl App { self.session = Session::SignedOut(Box::default()); self.nav = Navigator::new(Route::Home); self.drawer = None; - self.player = PlayerUi::default(); + self.player.reset(); + self.liked = Liked::NotLoaded; } Message::Navigate(route) => { self.nav.go(route); + if route == Route::Collection && matches!(self.liked, Liked::Failed(_)) { + return self.update(Message::LoadLiked); + } // Settings shows the subscription, which can change outside the app. if let (Route::Settings, Session::SignedIn { client, .. }) = (route, &self.session) { let client = client.clone(); @@ -192,7 +209,37 @@ impl App { self.drawer = if self.drawer == Some(panel) { None } else { Some(panel) }; } Message::CloseDrawer => self.drawer = None, - Message::Player(action) => self.player.apply(action), + Message::Player(msg) => { + let effects = self.player.update(msg); + return self.run(effects); + } + Message::LoadLiked => { + let Session::SignedIn { client, .. } = &self.session else { return Task::none() }; + if matches!(self.liked, Liked::Loading) { + return Task::none(); + } + self.liked = Liked::Loading; + let client = client.clone(); + return Task::future(async move { client.liked_tracks().await }).map(Message::LikedLoaded); + } + Message::LikedLoaded(Ok(tracks)) => self.liked = Liked::loaded(tracks, &self.liked), + Message::LikedLoaded(Err(Error::Unauthorized(e))) => { + eprintln!("token rejected: {e}"); + return self.update(Message::SignOut); + } + Message::LikedLoaded(Err(e)) => { + eprintln!("liked tracks: {e}"); + self.liked = Liked::Failed(e); + } + Message::PlayLiked { start, shuffle } => { + if let Some(tracks) = self.liked.tracks().cloned() { + return self.update(Message::Player(player::Msg::Play { + tracks, + start, + shuffle: shuffle.then_some(true), + })); + } + } } Task::none() } @@ -214,7 +261,14 @@ impl App { let content = column![ topbar::view(t, self.nav.can_go_back(), &self.search), - scrollable(screens::view(t, route, &self.search, account)) + scrollable(screens::view(screens::Ctx { + t, + route, + query: &self.search, + me: account, + liked: &self.liked, + playing: self.player.track().map(|tr| tr.id.as_str()), + })) .height(Fill) .style(theme::scroll), ] @@ -224,13 +278,18 @@ impl App { let mut body = row![sidebar::view(t, route, account), vline(), content].height(Fill); if let Some(panel) = self.drawer { - body = body.push(vline()).push(drawer::view(t, panel)); + body = body.push(vline()).push(drawer::view(t, panel, &self.player)); } let window = column![ body, hline(), - container(player_bar::view(t, &self.player, self.drawer)) + container(player_bar::view( + t, + &self.player, + self.player.track().is_some_and(|tr| self.liked.contains(&tr.id)), + self.drawer, + )) .height(shell::PLAYER) .style(theme::panel), ]; @@ -239,6 +298,35 @@ impl App { } } +impl App { + /// Runs the player's requests against the API. + fn run(&self, effects: Vec) -> Task { + let Session::SignedIn { client, .. } = &self.session else { return Task::none() }; + Task::batch(effects.into_iter().map(|effect| match effect { + Effect::Fetch { generation, track_id } => { + let client = client.clone(); + Task::future(async move { fetch_audio(&client, &track_id).await }) + .map(move |result| Message::Player(player::Msg::Fetched { generation, result })) + } + Effect::Prefetch { track_id } => { + let client = client.clone(); + Task::future(async move { + let result = fetch_audio(&client, &track_id).await; + (track_id, result) + }) + .map(|(track_id, result)| Message::Player(player::Msg::Prefetched { track_id, result })) + } + Effect::SignedOut => Task::done(Message::SignOut), + })) + } +} + +async fn fetch_audio(client: &YmClient, track_id: &str) -> Result { + let stream = client.stream(track_id).await?; + let bytes = client.fetch(&stream).await?; + Ok(Audio { stream, bytes }) +} + fn restore() -> Task { Task::future(session::restore()).map(Message::Restored) } diff --git a/crates/musyx/src/main.rs b/crates/musyx/src/main.rs index c9746b6..9b5c71e 100644 --- a/crates/musyx/src/main.rs +++ b/crates/musyx/src/main.rs @@ -1,4 +1,5 @@ mod app; +mod player; mod route; mod screens; mod session; diff --git a/crates/musyx/src/player/engine.rs b/crates/musyx/src/player/engine.rs new file mode 100644 index 0000000..8fa2561 --- /dev/null +++ b/crates/musyx/src/player/engine.rs @@ -0,0 +1,215 @@ +//! The audio thread. It owns the output device and a rodio `Player`, takes +//! [`Command`]s over a channel and reports [`Event`]s through an iced subscription. +//! +//! Everything here is about one loaded item at a time; the queue and fetching +//! live in the UI state. Each load carries a `generation` so stale events from a +//! previous track can be told apart. + +use std::io::Cursor; +use std::sync::Arc; +use std::sync::mpsc::{self, RecvTimeoutError}; +use std::time::Duration; + +use iced::Subscription; +use iced::futures::{SinkExt, Stream}; +use rodio::{Decoder, DeviceSinkBuilder, MixerDeviceSink, Player, Source}; + +/// How often position is reported while playing. +const TICK: Duration = Duration::from_millis(250); + +pub enum Command { + Load { generation: u64, bytes: Arc<[u8]>, hint: String, play: bool }, + Play, + Pause, + Seek(Duration), + Volume(f32), + Stop, +} + +/// A cheap handle the UI keeps to send commands. +#[derive(Clone)] +pub struct Handle(mpsc::Sender); + +impl std::fmt::Debug for Handle { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("engine::Handle") + } +} + +impl Handle { + pub fn send(&self, command: Command) { + // The thread only stops with the subscription, i.e. when the app exits. + let _ = self.0.send(command); + } +} + +#[derive(Debug, Clone)] +pub enum Event { + Ready(Handle), + Loaded { generation: u64, duration: Option }, + Position { generation: u64, position: Duration }, + Ended { generation: u64 }, + /// The bytes didn't decode (corrupt download, unsupported codec). + DecodeFailed { generation: u64, reason: String }, + /// No output device, or it went away. + NoOutput(String), +} + +pub fn subscription() -> Subscription { + Subscription::run(events) +} + +fn events() -> impl Stream { + iced::stream::channel(64, async |mut output| { + let (commands, inbox) = mpsc::channel(); + let (events, mut outbox) = tokio::sync::mpsc::unbounded_channel(); + std::thread::Builder::new() + .name("musyx-audio".into()) + .spawn(move || run(inbox, events)) + .expect("spawn audio thread"); + + let _ = output.send(Event::Ready(Handle(commands))).await; + while let Some(event) = outbox.recv().await { + if output.send(event).await.is_err() { + break; + } + } + }) +} + +/// Opens the system's default output device. +/// +/// rodio's own `open_default_sink` asks for a 50 ms buffer (2048 frames at +/// 44.1 kHz), which Bluetooth headphones that cap at 1024 frames reject, and its +/// fallback then filters out every macOS device. So pick the buffer here, +/// clamped to what the device says it supports. +fn open_output() -> Result { + use rodio::cpal::traits::{DeviceTrait, HostTrait}; + use rodio::cpal::{BufferSize, SupportedBufferSize}; + + let device = rodio::cpal::default_host() + .default_output_device() + .ok_or_else(|| "no default output device".to_owned())?; + let config = device.default_output_config().map_err(|e| e.to_string())?; + let buffer = match config.buffer_size() { + SupportedBufferSize::Range { min, max } => { + BufferSize::Fixed(buffer_frames(config.sample_rate(), *min, *max)) + } + SupportedBufferSize::Unknown => BufferSize::Default, + }; + DeviceSinkBuilder::default() + .with_device(device) + .with_supported_config(&config) + .with_buffer_size(buffer) + .open_stream() + .or_else(|first| DeviceSinkBuilder::open_default_sink().map_err(|_| first.to_string())) +} + +/// About 50 ms of audio, rounded to a power of two, within the device's limits. +fn buffer_frames(sample_rate: u32, min: u32, max: u32) -> u32 { + (sample_rate / 20).next_power_of_two().clamp(min, max.max(min)) +} + +fn run(inbox: mpsc::Receiver, events: tokio::sync::mpsc::UnboundedSender) { + let emit = |e: Event| { + let _ = events.send(e); + }; + + // The device sink must outlive the player: dropping it silences everything. + let sink = match open_output() { + Ok(mut sink) => { + sink.log_on_drop(false); + sink + } + Err(e) => { + emit(Event::NoOutput(e)); + // Keep draining so senders never block or error; nothing can play. + while inbox.recv().is_ok() {} + return; + } + }; + let player = Player::connect_new(sink.mixer()); + + let mut loaded: Option = None; + let mut ended_sent = false; + let mut last_reported = None; + + loop { + match inbox.recv_timeout(TICK) { + Ok(Command::Load { generation, bytes, hint, play }) => { + player.clear(); + let len = bytes.len() as u64; + let decoder = Decoder::builder() + .with_data(Cursor::new(bytes)) + .with_byte_len(len) + .with_hint(&hint) + .with_seekable(true) + .with_gapless(true) + .build(); + match decoder { + Ok(source) => { + let duration = source.total_duration(); + player.append(source); + if play { + player.play(); + } + loaded = Some(generation); + ended_sent = false; + last_reported = None; + emit(Event::Loaded { generation, duration }); + } + Err(e) => { + loaded = None; + emit(Event::DecodeFailed { generation, reason: e.to_string() }); + } + } + } + Ok(Command::Play) => player.play(), + Ok(Command::Pause) => player.pause(), + Ok(Command::Seek(to)) => { + if let Some(generation) = loaded { + // A failed seek leaves playback where it was; the next tick reports that. + if player.try_seek(to).is_ok() { + emit(Event::Position { generation, position: player.get_pos() }); + } + } + } + Ok(Command::Volume(v)) => player.set_volume(v.clamp(0.0, 1.0)), + Ok(Command::Stop) => { + player.clear(); + loaded = None; + } + Err(RecvTimeoutError::Timeout) => {} + Err(RecvTimeoutError::Disconnected) => break, + } + + let Some(generation) = loaded else { continue }; + if player.empty() { + if !ended_sent { + ended_sent = true; + emit(Event::Ended { generation }); + } + } else if !player.is_paused() { + let position = player.get_pos(); + // Whole-tick resolution is plenty for a progress bar. + let bucket = position.as_millis() / TICK.as_millis(); + if last_reported != Some(bucket) { + last_reported = Some(bucket); + emit(Event::Position { generation, position }); + } + } + } +} + +#[cfg(test)] +mod tests { + use super::buffer_frames; + + #[test] + fn buffer_fits_bluetooth_limits() { + assert_eq!(buffer_frames(44_100, 14, 1024), 1024); + assert_eq!(buffer_frames(48_000, 15, 4096), 4096); + assert_eq!(buffer_frames(8_000, 512, 4096), 512); + assert_eq!(buffer_frames(44_100, 100, 50), 100, "a bogus range still yields the minimum"); + } +} diff --git a/crates/musyx/src/player/mod.rs b/crates/musyx/src/player/mod.rs new file mode 100644 index 0000000..0cafc4f --- /dev/null +++ b/crates/musyx/src/player/mod.rs @@ -0,0 +1,557 @@ +//! Playback state: the queue, what's loaded, and the rules for moving between +//! tracks. Network work is described as [`Effect`]s for the app to run, so this +//! module stays free of the API client and can be tested on its own. + +pub mod engine; +pub mod queue; + +use std::sync::Arc; +use std::time::Duration; + +use ym_api::{Error, Stream, Track}; + +use engine::{Command, Event}; +pub use queue::{Queue, Repeat}; + +/// Give up after this many unplayable tracks in a row instead of skipping forever. +const MAX_SKIPS: u8 = 3; +/// "Previous" restarts the current track once it has played this long. +const RESTART_AFTER: Duration = Duration::from_secs(3); + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Status { + Loading, + Playing, + Paused, + /// The queue ran out with repeat off. Play starts the last track again. + Ended, +} + +/// Audio for one track, ready to hand to the engine. +#[derive(Debug, Clone)] +pub struct Audio { + pub stream: Stream, + pub bytes: Arc<[u8]>, +} + +#[derive(Debug, Clone)] +pub enum Msg { + Engine(Event), + /// Replace the queue. `shuffle` sets shuffle first; with it on, `start` is ignored. + Play { tracks: Arc<[Track]>, start: usize, shuffle: Option }, + Toggle, + Next, + Previous, + ToggleShuffle, + CycleRepeat, + /// The seek bar is being dragged; only the bar moves. + SeekPreview(f32), + SeekCommit, + SetVolume(f32), + ToggleMute, + JumpTo(usize), + Fetched { generation: u64, result: Result }, + Prefetched { track_id: String, result: Result }, +} + +/// Work the app has to do on the player's behalf. +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum Effect { + Fetch { generation: u64, track_id: String }, + Prefetch { track_id: String }, + /// The token stopped working mid-session. + SignedOut, +} + +pub struct Player { + engine: Option, + queue: Option>, + pub repeat: Repeat, + shuffle: bool, + pub volume: f32, + pub muted: bool, + generation: u64, + status: Status, + position: Duration, + duration: Duration, + current: Option