feat: cleanup

Author: kamiyaa

Cargo.lock

@@ -44,7 +44,6 @@ skim = "^0"
 strfmt = "^0"
 symphonia = { version = "^0", features = ["all"] }
 termion = "^1"
-tokio = { version = "^1", features = [ "macros", "rt", "rt-multi-thread" ] }
 toml = "^0"
 tracing = "^0"
 tracing-subscriber = { version = "^0", features = [ "std", "env-filter" ] }

Cargo.toml

@@ -117,8 +117,8 @@ fn print_entry(
         FileType::File => format::file_size_to_string(entry.metadata.len()),
     };
     let symlink_string = match entry.metadata.link_type() {
-        LinkType::Normal => "",
-        LinkType::Symlink(_, _) => "-> ",
+        LinkType::Normal => String::new(),
+        LinkType::Symlink(path, _) => format!("-> {}", path.as_str()),
     };
     let left_label_original = entry.file_name();
     let right_label_original = format!(" {}{} ", symlink_string, size_string);

src/bin/client/ui/widgets/tui_dirlist_detailed.rs

@@ -1,7 +1,7 @@
 pub fn get_default_host(host_id: cpal::HostId) -> cpal::Host {
     tracing::debug!("Available audio systems:");
     for host in cpal::available_hosts() {
-        tracing::debug!("host: {:?}", host);
+        tracing::debug!(?host, "Audio host");
     }
     cpal::host_from_id(
         cpal::available_hosts()

src/bin/server/audio/device.rs

@@ -2,6 +2,7 @@ use std::time::Duration;
 
 use dizi::song::DiziAudioFile;
 
+/// User requests to the player
 #[derive(Clone, Debug)]
 pub enum PlayerRequest {
     Play { song: DiziAudioFile, volume: f32 },

src/bin/server/audio/request.rs

@@ -1,21 +1,11 @@
 use std::iter::Iterator;
-use std::sync::{mpsc, Arc, RwLock};
-use std::time::Duration;
 
 use symphonia::core::audio::SampleBuffer;
 use symphonia::core::codecs::Decoder;
 use symphonia::core::errors::Error as SymphoniaError;
 use symphonia::core::formats::{FormatReader, Packet};
 
-use cpal::traits::{DeviceTrait, StreamTrait};
-use cpal::{Stream, StreamConfig};
-
 use dizi::error::{DiziError, DiziResult};
-use symphonia::core::units::TimeBase;
-
-use crate::audio::request::PlayerRequest;
-
-use super::stream::StreamEvent;
 
 pub struct PacketReader {
     format: Box<dyn FormatReader>,
@@ -91,135 +81,9 @@ impl PacketDecoder {
             Err(SymphoniaError::IoError(_)) => Ok(vec![]),
             Err(SymphoniaError::DecodeError(_)) => Ok(vec![]),
             Err(err) => {
-                tracing::error!("Unhandled symphonia error: {}", err);
+                tracing::error!(?err, "Symphonia error");
                 Err(DiziError::from(err))
             }
         }
     }
 }
-
-pub fn stream_loop<T>(
-    stream_tx: mpsc::Sender<StreamEvent>,
-    device: &cpal::Device,
-    config: &StreamConfig,
-    samples: Vec<T>,
-    volume: f32,
-    volume_change: fn(T, f32) -> T,
-) -> DiziResult<(Stream, mpsc::Sender<PlayerRequest>)>
-where
-    T: symphonia::core::sample::Sample
-        + cpal::Sample
-        + cpal::SizedSample
-        + std::marker::Send
-        + 'static
-        + symphonia::core::conv::FromSample<i8>
-        + symphonia::core::conv::FromSample<i16>
-        + symphonia::core::conv::FromSample<i32>
-        + symphonia::core::conv::FromSample<u8>
-        + symphonia::core::conv::FromSample<u16>
-        + symphonia::core::conv::FromSample<u32>
-        + symphonia::core::conv::FromSample<f32>
-        + symphonia::core::conv::FromSample<f64>
-        + symphonia::core::conv::FromSample<symphonia::core::sample::i24>
-        + symphonia::core::conv::FromSample<symphonia::core::sample::u24>,
-{
-    let err_fn = |err| {
-        tracing::error!("A playback error has occured! {}", err);
-    };
-
-    let time_base = TimeBase {
-        numer: 1,
-        denom: config.sample_rate.0 * config.channels as u32,
-    };
-
-    let samples_count = samples.len();
-
-    // all vars that the stream will update while its streaming
-    let frame_index = Arc::new(RwLock::new(0_usize));
-    let volume = Arc::new(RwLock::new(volume));
-    let playback_duration = Arc::new(RwLock::new(0));
-
-    let _ = stream_tx.send(StreamEvent::Progress(Duration::from_secs(0)));
-
-    // if stream_tx is None, then we've already sent a StreamEnded message
-    // and we don't need to send another one
-    let mut stream_tx = Some(stream_tx);
-
-    let (playback_loop_tx, playback_loop_rx) = mpsc::channel();
-
-    let stream = device.build_output_stream(
-        config,
-        move |data: &mut [T], _: &cpal::OutputCallbackInfo| {
-            let process_message = |msg: PlayerRequest| match msg {
-                PlayerRequest::SetVolume { volume: new_volume } => {
-                    let mut current_volume = volume.write().unwrap();
-                    *current_volume = new_volume;
-                }
-                PlayerRequest::FastForward { offset } => {
-                    let mut sample_offset = frame_index.write().unwrap();
-                    *sample_offset += time_base.denom as usize * offset.as_secs() as usize;
-                    if *sample_offset >= samples_count {
-                        *sample_offset = samples_count - time_base.denom as usize;
-                    }
-                }
-                PlayerRequest::Rewind { offset } => {
-                    let mut sample_offset = frame_index.write().unwrap();
-                    if *sample_offset < time_base.denom as usize * offset.as_secs() as usize {
-                        *sample_offset = 0;
-                    } else {
-                        *sample_offset -= time_base.denom as usize * offset.as_secs() as usize;
-                    }
-                }
-                _ => {}
-            };
-
-            if let Ok(msg) = playback_loop_rx.try_recv() {
-                process_message(msg);
-            }
-
-            // if sample_offset is greater than samples_count, then we've reached the end
-            let sample_offset = { *frame_index.read().unwrap() };
-            if sample_offset >= samples_count {
-                if let Some(stream_tx) = stream_tx.take() {
-                    let _ = stream_tx.send(StreamEvent::StreamEnded);
-                }
-                return;
-            }
-
-            let current_volume = { *volume.read().unwrap() };
-            let mut i = 0;
-            for d in data.iter_mut() {
-                if sample_offset + i >= samples_count {
-                    let mut offset = frame_index.write().unwrap();
-                    *offset = samples_count + 1;
-                    break;
-                }
-                *d = volume_change(samples[sample_offset + i], current_volume);
-                i += 1;
-            }
-            // new offset
-            let new_sample_offset = {
-                let mut sample_offset = frame_index.write().unwrap();
-                *sample_offset += i;
-                *sample_offset
-            };
-            // new duration
-            let next_duration = time_base.calc_time(new_sample_offset as u64).seconds;
-            let prev_duration = { *playback_duration.read().unwrap() };
-
-            // update duration if seconds changed
-            if prev_duration != next_duration {
-                let new_duration = Duration::from_secs(next_duration);
-                if let Some(stream_tx) = stream_tx.as_ref() {
-                    let _ = stream_tx.send(StreamEvent::Progress(new_duration));
-                }
-                let mut duration = playback_duration.write().unwrap();
-                *duration = new_duration.as_secs();
-            }
-        },
-        err_fn,
-        None,
-    )?;
-    stream.play()?;
-    Ok((stream, playback_loop_tx))
-}

src/bin/server/audio/symphonia/decode.rs

@@ -139,8 +139,8 @@ impl AudioPlayer for SymphoniaPlayer {
                 break;
             };
             tracing::debug!(
-                "Skipping '{}' because we failed to parse it",
-                song_entry.entry.file_name()
+                file_name = song_entry.entry.file_name(),
+                "Failed to parse file, skipping",
             );
         }
         if let Some(entry) = playlist.current_entry() {

src/bin/server/audio/symphonia/player/impl_audio_player.rs

@@ -87,7 +87,7 @@ impl SymphoniaPlayer {
     }
 
     fn play(&mut self, song: &DiziAudioFile) -> DiziResult {
-        tracing::debug!("Song: {:#?}", song);
+        tracing::debug!(?song, "Playing song");
 
         self.player_stream_req().send(PlayerRequest::Play {
             song: song.clone(),

src/bin/server/audio/symphonia/player/mod.rs

@@ -0,0 +1,16 @@
+mod player_stream;
+mod player_stream_state;
+mod stream_listener;
+
+pub use player_stream::*;
+pub use player_stream_state::*;
+pub use stream_listener::*;
+
+use std::time::Duration;
+
+/// Events returned from stream
+#[derive(Clone, Copy, Debug)]
+pub enum StreamEvent {
+    Progress(Duration),
+    StreamEnded,
+}