fix: improve ALSA period configuration for device compatibility

Use time-based period configuration with set_period_time_near for better
device compatibility. Calculate period time based on buffer size and
period count, and fall back to safe defaults if constraints are
unavailable.

Author: roderickvd

src/host/alsa/mod.rs

@@ -31,6 +31,9 @@ mod enumerate;
 const VALID_BUFFER_SIZE: RangeInclusive<alsa::pcm::Frames> =
     1..=FrameCount::MAX as alsa::pcm::Frames;
 
+const FALLBACK_PERIOD_TIME: u32 = 25_000;
+const PREFERRED_PERIOD_COUNT: u32 = 2;
+
 /// The default linux, dragonfly, freebsd and netbsd host type.
 #[derive(Debug)]
 pub struct Host;
@@ -1064,18 +1067,6 @@ fn hw_params_buffer_size_min_max(hw_params: &alsa::pcm::HwParams) -> (FrameCount
     (min_buf, max_buf)
 }
 
-fn hw_params_period_size_min_max(hw_params: &alsa::pcm::HwParams) -> (FrameCount, FrameCount) {
-    let min_buf = hw_params
-        .get_period_size_min()
-        .map(clamp_frame_count)
-        .unwrap_or(1);
-    let max_buf = hw_params
-        .get_period_size_max()
-        .map(clamp_frame_count)
-        .unwrap_or(FrameCount::MAX);
-    (min_buf, max_buf)
-}
-
 fn set_hw_params_from_format(
     pcm_handle: &alsa::pcm::PCM,
     config: &StreamConfig,
@@ -1155,15 +1146,10 @@ fn set_hw_params_from_format(
 /// Returns true if the periods were reasonably set. A false result indicates the device default
 /// configuration is being used.
 fn set_hw_params_periods(hw_params: &alsa::pcm::HwParams, buffer_size: BufferSize) -> bool {
-    const FALLBACK_PERIOD_TIME: u32 = 25_000;
-
     // TODO: When the API is made available, this could rely on snd_pcm_hw_params_get_periods_min
     // and snd_pcm_hw_params_get_periods_max
-    const PERIOD_COUNT: u32 = 2;
-
-    // Restrict the configuration space to contain only one periods count
     hw_params
-        .set_periods(PERIOD_COUNT, alsa::ValueOr::Nearest)
+        .set_periods(PREFERRED_PERIOD_COUNT, alsa::ValueOr::Greater)
         .unwrap_or_default();
 
     let Some(period_count) = hw_params
@@ -1191,27 +1177,58 @@ fn set_hw_params_periods(hw_params: &alsa::pcm::HwParams, buffer_size: BufferSiz
             buffer_size.clamp(min_buffer_size, max_buffer_size)
         };
 
-        // Desired period size
-        let period_size = {
-            let (min_period_size, max_period_size) = hw_params_period_size_min_max(hw_params);
-            (buffer_size / period_count).clamp(min_period_size, max_period_size)
+        // Use time-based period configuration for device compatibility. Some devices have better
+        // compatibility with set_period_time_near() than set_period_size_near(). Calculate a
+        // period time that works with the requested buffer.
+
+        // Calculate desired period time based on buffer size and period count.
+        // We can't yet get period_time constraints from alsa-rs, so we'll use period_size
+        // constraints and convert them to time constraints.
+        let (min_period_size, max_period_size) = match (
+            hw_params.get_period_size_min(),
+            hw_params.get_period_size_max(),
+        ) {
+            (Ok(min), Ok(max)) => (min, max),
+            _ => {
+                // Fall back to a safe default if we can't get constraints
+                let Ok(_) =
+                    hw_params.set_period_time_near(FALLBACK_PERIOD_TIME, alsa::ValueOr::Nearest)
+                else {
+                    return false;
+                };
+                let Ok(actual_buffer_size) = hw_params.set_buffer_size_near(buffer_size as _)
+                else {
+                    return false;
+                };
+                return VALID_BUFFER_SIZE.contains(&actual_buffer_size);
+            }
         };
 
-        // Actual period size
-        let Ok(period_size) =
-            hw_params.set_period_size_near(period_size as _, alsa::ValueOr::Greater)
-        else {
-            return false;
-        };
+        // Calculate desired period size and convert to time
+        // period_time = (period_size_frames / sample_rate) * 1_000_000 microseconds
+        let desired_period_size_frames =
+            (buffer_size / period_count).clamp(min_period_size as u32, max_period_size as u32);
+
+        // Get actual sample rate that was set (don't assume 44100)
+        if let Ok(sample_rate) = hw_params.get_rate() {
+            let desired_period_time_us =
+                (desired_period_size_frames as u64 * 1_000_000) / sample_rate as u64;
+
+            // Set the period time
+            let Ok(_) = hw_params
+                .set_period_time_near(desired_period_time_us as u32, alsa::ValueOr::Nearest)
+            else {
+                return false;
+            };
+        }
 
-        let Ok(buffer_size) =
-            hw_params.set_buffer_size_near(period_size * period_count as alsa::pcm::Frames)
-        else {
+        // Now set the buffer size to the user's requested size
+        let Ok(actual_buffer_size) = hw_params.set_buffer_size_near(buffer_size as _) else {
             return false;
         };
 
         // Double-check the set size is within the CPAL range
-        VALID_BUFFER_SIZE.contains(&buffer_size)
+        VALID_BUFFER_SIZE.contains(&actual_buffer_size)
     }
 
     if let BufferSize::Fixed(val) = buffer_size {