Merge pull request #123 from ccgauche/feat/switch-to-rodio

feat: switch to rodio

Author: ccgauche

Cargo.lock

@@ -6,11 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-cpal = { version = "0.13.5" }
-symphonia = { git = "https://github.com/pdeljanov/Symphonia", features = [
-    "aac",
-    "isomp4",
-] }
 flume = "0.11.0"
-tokio = "1.36.0"
-atomic_float = "0.1.0"
+rodio = { version = "0.21.1", default-features = false, features = ["playback", "symphonia-aac", "symphonia-isomp4"] }
+log = "0.4.29"

crates/player/Cargo.toml

@@ -0,0 +1,15 @@
+// Custom Error Enum to handle different failures
+#[derive(Debug)]
+pub enum PlayError {
+    Io(std::io::Error),
+    DecoderError(rodio::decoder::DecoderError),
+    StreamError(rodio::StreamError),
+    PlayError(rodio::PlayError),
+    SeekError(rodio::source::SeekError),
+}
+
+impl From<rodio::PlayError> for PlayError {
+    fn from(err: rodio::PlayError) -> Self {
+        PlayError::PlayError(err)
+    }
+}

crates/player/src/error.rs

@@ -1,3 +1,17 @@
-mod rusty_backend;
+mod error;
 
-pub use rusty_backend::*;
+use std::time::Duration;
+
+pub use error::PlayError;
+
+mod player;
+pub use player::Player;
+
+mod player_options;
+pub use player_options::PlayerOptions;
+
+mod player_data;
+pub(crate) use player_data::PlayerData;
+
+pub(crate) static VOLUME_STEP: u8 = 5;
+pub(crate) static SEEK_STEP: Duration = Duration::from_secs(5);

crates/player/src/lib.rs

@@ -0,0 +1,253 @@
+use flume::Sender;
+use rodio::cpal::traits::HostTrait;
+use rodio::{Decoder, OutputStream, OutputStreamBuilder, Sink, Source};
+
+use std::fs::File;
+use std::path::Path;
+use std::time::Duration;
+
+use crate::{PlayError, PlayerData, PlayerOptions, SEEK_STEP};
+
+pub struct Player {
+    sink: Sink,
+    stream: OutputStream,
+    data: PlayerData,
+    error_sender: Sender<PlayError>,
+    options: PlayerOptions,
+}
+
+impl Player {
+    fn try_from_device(device: rodio::cpal::Device) -> Result<OutputStream, PlayError> {
+        // In rodio 0.21, try_from_device is available on OutputStream
+        OutputStreamBuilder::default()
+            .with_device(device)
+            .open_stream()
+            .map_err(PlayError::StreamError)
+    }
+
+    /// Try to create a stream from the default device, falling back to others
+    fn try_default() -> Result<OutputStream, PlayError> {
+        // Use rodio's internal cpal re-export
+        let host = rodio::cpal::default_host();
+
+        let default_device = host
+            .default_output_device()
+            .ok_or(PlayError::StreamError(rodio::StreamError::NoDevice))?;
+
+        Self::try_from_device(default_device).or_else(|original_err| {
+            let devices = host.output_devices().map_err(|_| original_err)?;
+
+            for d in devices {
+                if let Ok(res) = Self::try_from_device(d) {
+                    return Ok(res);
+                }
+            }
+            Err(PlayError::StreamError(rodio::StreamError::NoDevice))
+        })
+    }
+
+    pub fn new(error_sender: Sender<PlayError>, options: PlayerOptions) -> Result<Self, PlayError> {
+        let stream = Self::try_default()?;
+
+        // sink::try_new requires a reference to the handle
+        let sink = Sink::connect_new(stream.mixer());
+
+        sink.set_volume(options.initial_volume_f32());
+
+        Ok(Self {
+            sink,
+            stream,
+            error_sender,
+            data: PlayerData::new(options.initial_volume()),
+            options,
+        })
+    }
+
+    pub fn update(&self) -> Result<Self, PlayError> {
+        let stream = Self::try_default()?;
+        let sink = Sink::connect_new(stream.mixer());
+
+        sink.set_volume(self.data.volume_f32());
+
+        Ok(Self {
+            sink,
+            stream,
+            error_sender: self.error_sender.clone(),
+            data: self.data.clone(),
+            options: self.options.clone(),
+        })
+    }
+    pub fn change_volume(&mut self, positive: bool) {
+        self.data.change_volume(positive);
+        self.sink.set_volume(self.data.volume_f32());
+    }
+
+    pub fn is_finished(&self) -> bool {
+        self.sink.empty()
+    }
+
+    pub fn play_at(&mut self, path: &Path, time: Duration) -> Result<(), PlayError> {
+        log::info!("Playing file: {:?} at time: {:?}", path, time);
+        self.play(path)?;
+        if let Err(e) = self.sink.try_seek(time) {
+            log::error!("Seek error: {}", e);
+            let _ = self.error_sender.send(PlayError::SeekError(e));
+        }
+
+        Ok(())
+    }
+
+    pub fn play(&mut self, path: &Path) -> Result<(), PlayError> {
+        log::info!("Playing file: {:?}", path);
+        self.data.set_current_file(Some(path.to_path_buf()));
+
+        self.stop();
+
+        let file = File::open(path).map_err(PlayError::Io)?;
+
+        if file.metadata().map(|m| m.len()).unwrap_or(0) == 0 {
+            return Err(PlayError::Io(std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "File is empty",
+            )));
+        }
+
+        let decoder = Decoder::new(file).map_err(PlayError::DecoderError)?;
+
+        self.data.set_total_duration(decoder.total_duration());
+
+        // Check if sink is detached or empty and recreate if necessary
+        if self.sink.empty() {
+            // Using try_new with the stored handle
+            self.sink = Sink::connect_new(self.stream.mixer());
+        }
+
+        self.sink.set_volume(self.data.volume_f32());
+        self.sink.append(decoder);
+
+        Ok(())
+    }
+
+    pub fn stop(&mut self) {
+        // rodio 0.21: To stop, you can clear the sink.
+        if !self.sink.empty() {
+            self.sink.clear();
+        }
+    }
+
+    pub fn elapsed(&self) -> Duration {
+        self.sink.get_pos()
+    }
+
+    pub fn duration(&self) -> Option<f64> {
+        self.data
+            .total_duration()
+            .map(|duration| duration.as_secs_f64())
+    }
+
+    pub fn toggle_playback(&mut self) {
+        if self.sink.is_paused() {
+            self.sink.play();
+        } else {
+            self.sink.pause();
+        }
+    }
+
+    pub fn seek_fw(&mut self) {
+        let current_elapsed = self.elapsed();
+        let new_pos = current_elapsed + SEEK_STEP;
+
+        self.seek_to(new_pos);
+    }
+
+    pub fn seek_bw(&mut self) {
+        let current_elapsed = self.elapsed();
+        let new_pos = current_elapsed.saturating_sub(SEEK_STEP);
+        self.seek_to(new_pos);
+    }
+
+    pub fn seek_to(&mut self, time: Duration) {
+        log::info!("Seek to: {:?}", time);
+        if self.is_finished() {
+            return;
+        }
+        let file = self.data.current_file().expect("Current file not set");
+
+        if let Err(e) = self.sink.try_seek(time) {
+            log::error!("Seek error: {}", e);
+            let _ = self.error_sender.send(PlayError::SeekError(e));
+        } else {
+            // If the sink is finished, we need to reset the music
+            // This happens when the user seeks to the start of the song before the buffer.
+            if self.is_finished() {
+                log::info!("Sink is finished while seeking, resetting the music");
+                if let Err(e) = self.play_at(&file, time) {
+                    log::error!("Error playing file: {:?}", e);
+                    let _ = self.error_sender.send(e);
+                }
+            }
+        }
+    }
+
+    pub fn percentage(&self) -> f64 {
+        self.duration().map_or(0.0, |duration| {
+            let elapsed = self.elapsed().as_secs_f64();
+            elapsed / duration
+        })
+    }
+
+    pub fn volume_percent(&self) -> u8 {
+        self.data.volume()
+    }
+
+    pub fn volume(&self) -> i32 {
+        self.data.volume().into()
+    }
+
+    pub fn volume_up(&mut self) {
+        let volume = self.volume() + 5;
+        self.set_volume(volume);
+    }
+
+    pub fn volume_down(&mut self) {
+        let volume = self.volume() - 5;
+        self.set_volume(volume);
+    }
+
+    pub fn set_volume(&mut self, mut volume: i32) {
+        volume = volume.clamp(0, 100);
+        self.data.set_volume(volume as u8);
+        self.sink.set_volume((volume as f32) / 100.0);
+    }
+
+    pub fn pause(&mut self) {
+        if !self.sink.is_paused() {
+            self.toggle_playback();
+        }
+    }
+
+    pub fn resume(&mut self) {
+        if self.sink.is_paused() {
+            self.toggle_playback();
+        }
+    }
+
+    pub fn is_paused(&self) -> bool {
+        self.sink.is_paused()
+    }
+
+    pub fn seek(&mut self, secs: i64) {
+        if secs.is_positive() {
+            self.seek_fw();
+        } else {
+            self.seek_bw();
+        }
+    }
+
+    pub fn get_progress(&self) -> (f64, u32, u32) {
+        let position = self.elapsed();
+        let duration = self.duration().unwrap_or(99.0) as u32;
+        let percent = self.percentage() * 100.0;
+        (percent.min(100.0), position.as_secs() as u32, duration)
+    }
+}

crates/player/src/player.rs

@@ -0,0 +1,64 @@
+use std::{path::PathBuf, time::Duration};
+
+use crate::VOLUME_STEP;
+
+#[derive(Clone)]
+pub struct PlayerData {
+    total_duration: Option<Duration>,
+    current_file: Option<PathBuf>,
+    volume: u8,
+}
+
+impl PlayerData {
+    pub fn new(volume: u8) -> Self {
+        Self {
+            total_duration: None,
+            current_file: None,
+            volume,
+        }
+    }
+
+    /// Changes the volume by the volume step. If positive is true, the volume is increased, otherwise it is decreased.
+    pub fn change_volume(&mut self, positive: bool) {
+        if positive {
+            self.set_volume(self.volume().saturating_add(VOLUME_STEP).min(100));
+        } else {
+            self.set_volume(self.volume().saturating_sub(VOLUME_STEP));
+        }
+    }
+
+    /// Returns the volume as a f32 between 0.0 and 1.0
+    pub fn volume_f32(&self) -> f32 {
+        f32::from(self.volume()) / 100.0
+    }
+
+    /// Returns the volume as a u8 between 0 and 100
+    pub fn volume(&self) -> u8 {
+        self.volume
+    }
+
+    /// Sets the volume to the given value
+    pub fn set_volume(&mut self, volume: u8) {
+        self.volume = volume;
+    }
+
+    /// Returns the total duration of the current file
+    pub fn total_duration(&self) -> Option<Duration> {
+        self.total_duration
+    }
+
+    /// Sets the total duration of the current file
+    pub fn set_total_duration(&mut self, total_duration: Option<Duration>) {
+        self.total_duration = total_duration;
+    }
+
+    /// Returns the current file
+    pub fn current_file(&self) -> Option<PathBuf> {
+        self.current_file.clone()
+    }
+
+    /// Sets the current file
+    pub fn set_current_file(&mut self, current_file: Option<PathBuf>) {
+        self.current_file = current_file;
+    }
+}

crates/player/src/player_data.rs

@@ -0,0 +1,23 @@
+#[derive(Debug, Clone)]
+pub struct PlayerOptions {
+    initial_volume: u8,
+}
+
+impl PlayerOptions {
+    /// Creates a new PlayerOptions with the given initial volume
+    pub fn new(initial_volume: u8) -> Self {
+        Self {
+            initial_volume: initial_volume.min(100),
+        }
+    }
+
+    /// Returns the initial volume as a u8 between 0 and 100
+    pub fn initial_volume(&self) -> u8 {
+        self.initial_volume
+    }
+
+    /// Returns the initial volume as a f32 between 0.0 and 1.0
+    pub fn initial_volume_f32(&self) -> f32 {
+        f32::from(self.initial_volume()) / 100.0
+    }
+}