chore: move fill_with_equilibrium to src/host/mod.rs and use it

use fill_with_equilibrium() to fill equilibrium in output capture

Author: Decodetalkers

src/host/alsa/mod.rs

@@ -20,14 +20,15 @@ use self::alsa::poll::Descriptors;
 pub use self::enumerate::Devices;
 
 use crate::{
+    host::fill_with_equilibrium,
     iter::{SupportedInputConfigs, SupportedOutputConfigs},
     traits::{DeviceTrait, HostTrait, StreamTrait},
     BackendSpecificError, BufferSize, BuildStreamError, ChannelCount, Data,
     DefaultStreamConfigError, DeviceDescription, DeviceDescriptionBuilder, DeviceDirection,
     DeviceId, DeviceIdError, DeviceNameError, DevicesError, FrameCount, InputCallbackInfo,
-    OutputCallbackInfo, PauseStreamError, PlayStreamError, Sample, SampleFormat, SampleRate,
-    StreamConfig, StreamError, SupportedBufferSize, SupportedStreamConfig,
-    SupportedStreamConfigRange, SupportedStreamConfigsError, I24, U24,
+    OutputCallbackInfo, PauseStreamError, PlayStreamError, SampleFormat, SampleRate, StreamConfig,
+    StreamError, SupportedBufferSize, SupportedStreamConfig, SupportedStreamConfigRange,
+    SupportedStreamConfigsError,
 };
 
 mod enumerate;
@@ -1239,59 +1240,6 @@ fn hw_params_buffer_size_min_max(hw_params: &alsa::pcm::HwParams) -> (FrameCount
     (min_buf, max_buf)
 }
 
-// Fill a buffer with equilibrium values for any sample format.
-// Works with any buffer size, even if not perfectly aligned to sample boundaries.
-fn fill_with_equilibrium(buffer: &mut [u8], sample_format: SampleFormat) {
-    macro_rules! fill_typed {
-        ($sample_type:ty) => {{
-            let sample_size = std::mem::size_of::<$sample_type>();
-
-            assert_eq!(
-                buffer.len() % sample_size,
-                0,
-                "Buffer size must be aligned to sample size for format {:?}",
-                sample_format
-            );
-
-            let num_samples = buffer.len() / sample_size;
-            let equilibrium = <$sample_type as Sample>::EQUILIBRIUM;
-
-            // Safety: We verified the buffer size is correctly aligned for the sample type
-            let samples = unsafe {
-                std::slice::from_raw_parts_mut(
-                    buffer.as_mut_ptr() as *mut $sample_type,
-                    num_samples,
-                )
-            };
-
-            for sample in samples {
-                *sample = equilibrium;
-            }
-        }};
-    }
-    const DSD_SILENCE_BYTE: u8 = 0x69;
-
-    match sample_format {
-        SampleFormat::I8 => fill_typed!(i8),
-        SampleFormat::I16 => fill_typed!(i16),
-        SampleFormat::I24 => fill_typed!(I24),
-        SampleFormat::I32 => fill_typed!(i32),
-        // SampleFormat::I48 => fill_typed!(I48),
-        SampleFormat::I64 => fill_typed!(i64),
-        SampleFormat::U8 => fill_typed!(u8),
-        SampleFormat::U16 => fill_typed!(u16),
-        SampleFormat::U24 => fill_typed!(U24),
-        SampleFormat::U32 => fill_typed!(u32),
-        // SampleFormat::U48 => fill_typed!(U48),
-        SampleFormat::U64 => fill_typed!(u64),
-        SampleFormat::F32 => fill_typed!(f32),
-        SampleFormat::F64 => fill_typed!(f64),
-        SampleFormat::DsdU8 | SampleFormat::DsdU16 | SampleFormat::DsdU32 => {
-            buffer.fill(DSD_SILENCE_BYTE)
-        }
-    }
-}
-
 fn init_hw_params<'a>(
     pcm_handle: &'a alsa::pcm::PCM,
     config: &StreamConfig,

src/host/mod.rs

@@ -1,3 +1,5 @@
+use crate::{Sample, SampleFormat, I24, U24};
+
 #[cfg(target_os = "android")]
 pub(crate) mod aaudio;
 #[cfg(any(
@@ -71,3 +73,56 @@ pub(crate) mod custom;
     all(target_arch = "wasm32", feature = "wasm-bindgen"),
 )))]
 pub(crate) mod null;
+
+// Fill a buffer with equilibrium values for any sample format.
+// Works with any buffer size, even if not perfectly aligned to sample boundaries.
+pub(crate) fn fill_with_equilibrium(buffer: &mut [u8], sample_format: SampleFormat) {
+    macro_rules! fill_typed {
+        ($sample_type:ty) => {{
+            let sample_size = std::mem::size_of::<$sample_type>();
+
+            assert_eq!(
+                buffer.len() % sample_size,
+                0,
+                "Buffer size must be aligned to sample size for format {:?}",
+                sample_format
+            );
+
+            let num_samples = buffer.len() / sample_size;
+            let equilibrium = <$sample_type as Sample>::EQUILIBRIUM;
+
+            // Safety: We verified the buffer size is correctly aligned for the sample type
+            let samples = unsafe {
+                std::slice::from_raw_parts_mut(
+                    buffer.as_mut_ptr() as *mut $sample_type,
+                    num_samples,
+                )
+            };
+
+            for sample in samples {
+                *sample = equilibrium;
+            }
+        }};
+    }
+    const DSD_SILENCE_BYTE: u8 = 0x69;
+
+    match sample_format {
+        SampleFormat::I8 => fill_typed!(i8),
+        SampleFormat::I16 => fill_typed!(i16),
+        SampleFormat::I24 => fill_typed!(I24),
+        SampleFormat::I32 => fill_typed!(i32),
+        // SampleFormat::I48 => fill_typed!(I48),
+        SampleFormat::I64 => fill_typed!(i64),
+        SampleFormat::U8 => fill_typed!(u8),
+        SampleFormat::U16 => fill_typed!(u16),
+        SampleFormat::U24 => fill_typed!(U24),
+        SampleFormat::U32 => fill_typed!(u32),
+        // SampleFormat::U48 => fill_typed!(U48),
+        SampleFormat::U64 => fill_typed!(u64),
+        SampleFormat::F32 => fill_typed!(f32),
+        SampleFormat::F64 => fill_typed!(f64),
+        SampleFormat::DsdU8 | SampleFormat::DsdU16 | SampleFormat::DsdU32 => {
+            buffer.fill(DSD_SILENCE_BYTE)
+        }
+    }
+}

src/host/pipewire/stream.rs

@@ -1,8 +1,8 @@
 use std::{thread::JoinHandle, time::Instant};
 
 use crate::{
-    traits::StreamTrait, BackendSpecificError, InputCallbackInfo, OutputCallbackInfo, SampleFormat,
-    StreamConfig, StreamError, StreamInstant,
+    host::fill_with_equilibrium, traits::StreamTrait, BackendSpecificError, InputCallbackInfo,
+    OutputCallbackInfo, SampleFormat, StreamConfig, StreamError, StreamInstant,
 };
 use pipewire::{
     self as pw,
@@ -377,7 +377,7 @@ where
                 };
 
                 // set buffers to zero
-                samples.fill(crate::Sample::EQUILIBRIUM);
+                fill_with_equilibrium(samples, user_data.sample_format);
 
                 // samples = frames * channels or samples = data_len / sample_size
                 let n_samples = frames * n_channels as usize;