style: apply cargo fmt across codebase

Automated formatting pass covering 79 Rust source files.
No logic changes -- only line wrapping, import ordering,
and match/closure reformatting.
This commit is contained in:
vicrodh committed 2026-02-20 00:14:58 -06:00
1 parent f9313c2d80
commit 3a297c0b2b
78 files changed
+4593 -2697

No files matched your search

+1258 -939
View File
File diff suppressed because it is too large. Load diff
+17 -10
View File
@@ -16,26 +16,24 @@ use std::time::Duration;
/// Unified playback engine
pub enum PlaybackEngine {
/// Rodio-based (PipeWire, Pulse, ALSA via CPAL)
Rodio {
sink: Sink,
},
Rodio { sink: Sink },
/// Direct ALSA (hw: devices, bit-perfect)
AlsaDirect {
stream: Arc<AlsaDirectStream>,
is_playing: Arc<AtomicBool>,
should_stop: Arc<AtomicBool>, // Separate flag for full stop vs pause
should_stop: Arc<AtomicBool>, // Separate flag for full stop vs pause
position_frames: Arc<AtomicU64>,
duration_frames: Arc<AtomicU64>,
playback_thread: Option<thread::JoinHandle<()>>,
hardware_volume: bool, // Use ALSA mixer for volume control
hardware_volume: bool, // Use ALSA mixer for volume control
},
}
impl PlaybackEngine {
/// Create Rodio engine
pub fn new_rodio(stream_handle: &OutputStreamHandle) -> Result<Self, String> {
let sink = Sink::try_new(stream_handle)
.map_err(|e| format!("Failed to create Sink: {}", e))?;
let sink =
Sink::try_new(stream_handle).map_err(|e| format!("Failed to create Sink: {}", e))?;
Ok(Self::Rodio { sink })
}
@@ -132,7 +130,10 @@ impl PlaybackEngine {
if buffer_f32.is_empty() {
// End of stream
log::info!("[ALSA Direct Engine] Stream ended (total frames: {})", total_frames);
log::info!(
"[ALSA Direct Engine] Stream ended (total frames: {})",
total_frames
);
natural_end = true;
break 'playback;
}
@@ -229,7 +230,11 @@ impl PlaybackEngine {
pub fn set_volume(&self, volume: f32) {
match self {
Self::Rodio { sink } => sink.set_volume(volume),
Self::AlsaDirect { stream, hardware_volume, .. } => {
Self::AlsaDirect {
stream,
hardware_volume,
..
} => {
if *hardware_volume {
// Try hardware mixer control
#[cfg(target_os = "linux")]
@@ -240,7 +245,9 @@ impl PlaybackEngine {
}
} else {
// Hardware volume disabled - volume control is handled by DAC/amplifier
log::debug!("[ALSA Direct Engine] Hardware volume control disabled (use DAC/amplifier)");
log::debug!(
"[ALSA Direct Engine] Hardware volume control disabled (use DAC/amplifier)"
);
}
}
}
+27 -28
View File
@@ -185,17 +185,17 @@ impl BufferedMediaSource {
/// Returns error if download fails before initial buffer is filled.
pub fn wait_for_initial_buffer(&self) -> IoResult<()> {
let (lock, cvar) = &*self.state;
let mut state = lock.lock().map_err(|_| {
IoError::new(ErrorKind::Other, "Failed to acquire buffer lock")
})?;
let mut state = lock
.lock()
.map_err(|_| IoError::new(ErrorKind::Other, "Failed to acquire buffer lock"))?;
while state.data.len() < self.config.initial_buffer_bytes
&& !state.download_complete
&& state.download_error.is_none()
{
state = cvar.wait(state).map_err(|_| {
IoError::new(ErrorKind::Other, "Condition variable wait failed")
})?;
state = cvar
.wait(state)
.map_err(|_| IoError::new(ErrorKind::Other, "Condition variable wait failed"))?;
}
if let Some(ref err) = state.download_error {
@@ -297,9 +297,9 @@ impl Read for BufferedMediaSource {
use std::sync::atomic::Ordering;
let (lock, cvar) = &*self.state;
let mut state = lock.lock().map_err(|_| {
IoError::new(ErrorKind::Other, "Failed to acquire buffer lock")
})?;
let mut state = lock
.lock()
.map_err(|_| IoError::new(ErrorKind::Other, "Failed to acquire buffer lock"))?;
let read_pos = self.read_pos.load(Ordering::SeqCst) as usize;
@@ -308,9 +308,9 @@ impl Read for BufferedMediaSource {
&& !state.download_complete
&& state.download_error.is_none()
{
state = cvar.wait(state).map_err(|_| {
IoError::new(ErrorKind::Other, "Condition variable wait failed")
})?;
state = cvar
.wait(state)
.map_err(|_| IoError::new(ErrorKind::Other, "Condition variable wait failed"))?;
}
// Check for errors
@@ -327,7 +327,8 @@ impl Read for BufferedMediaSource {
let available = state.data.len() - read_pos;
let to_read = buf.len().min(available);
buf[..to_read].copy_from_slice(&state.data[read_pos..read_pos + to_read]);
self.read_pos.store((read_pos + to_read) as u64, Ordering::SeqCst);
self.read_pos
.store((read_pos + to_read) as u64, Ordering::SeqCst);
Ok(to_read)
}
@@ -338,9 +339,9 @@ impl Seek for BufferedMediaSource {
use std::sync::atomic::Ordering;
let (lock, cvar) = &*self.state;
let mut state = lock.lock().map_err(|_| {
IoError::new(ErrorKind::Other, "Failed to acquire buffer lock")
})?;
let mut state = lock
.lock()
.map_err(|_| IoError::new(ErrorKind::Other, "Failed to acquire buffer lock"))?;
let current_pos = self.read_pos.load(Ordering::SeqCst) as i64;
@@ -377,9 +378,9 @@ impl Seek for BufferedMediaSource {
&& !state.download_complete
&& state.download_error.is_none()
{
state = cvar.wait(state).map_err(|_| {
IoError::new(ErrorKind::Other, "Condition variable wait failed")
})?;
state = cvar
.wait(state)
.map_err(|_| IoError::new(ErrorKind::Other, "Condition variable wait failed"))?;
}
if let Some(ref err) = state.download_error {
@@ -515,9 +516,7 @@ impl IncrementalStreamingSource {
/// The BufferedMediaSource should already have its initial buffer filled.
///
/// Returns the source along with detected sample_rate and channels.
pub fn new(
buffered_source: Arc<BufferedMediaSource>,
) -> Result<Self, String> {
pub fn new(buffered_source: Arc<BufferedMediaSource>) -> Result<Self, String> {
// Create a reader from the buffered source
let reader = buffered_source.create_reader();
let media_source = Box::new(reader) as Box<dyn MediaSource>;
@@ -548,10 +547,7 @@ impl IncrementalStreamingSource {
let sample_rate = codec_params
.sample_rate
.ok_or_else(|| "No sample rate in codec params".to_string())?;
let channels = codec_params
.channels
.map(|c| c.count() as u16)
.unwrap_or(2);
let channels = codec_params.channels.map(|c| c.count() as u16).unwrap_or(2);
let decoder = get_codecs()
.make(&codec_params, &DecoderOptions::default())
@@ -603,7 +599,9 @@ impl IncrementalStreamingSource {
while self.sample_queue.len() < min_samples {
let packet = match self.format.next_packet() {
Ok(packet) => packet,
Err(SymphoniaError::IoError(ref e)) if e.kind() == std::io::ErrorKind::WouldBlock => {
Err(SymphoniaError::IoError(ref e))
if e.kind() == std::io::ErrorKind::WouldBlock =>
{
// Not enough data buffered yet - wait briefly and retry
// This happens when playback catches up with download
std::thread::sleep(Duration::from_millis(5));
@@ -636,7 +634,8 @@ impl IncrementalStreamingSource {
sample_buf.copy_interleaved_ref(audio_buf);
// Add samples to queue
self.sample_queue.extend(sample_buf.samples().iter().copied());
self.sample_queue
.extend(sample_buf.samples().iter().copied());
self.packets_decoded += 1;
}
Err(SymphoniaError::DecodeError(e)) => {