zarumet 1.5.14

A terminal-based mpd client with album display
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct PipewireConfig {
    /// Enable bit-perfect mode for PipeWire
    #[serde(default = "PipewireConfig::default_bit_perfect_enabled")]
    pub bit_perfect_enabled: bool,
}

impl PipewireConfig {
    fn default_bit_perfect_enabled() -> bool {
        false
    }

    /// Check if bit-perfect mode is available (enabled and on Linux)
    pub fn is_available(&self) -> bool {
        #[cfg(target_os = "linux")]
        {
            self.bit_perfect_enabled
        }
        #[cfg(not(target_os = "linux"))]
        {
            false
        }
    }
}

/// Get the best sample rate to use based on the song's sample rate
/// and the supported rates from PipeWire.
///
/// Logic:
/// 1. If the song rate is directly supported, use it
/// 2. Otherwise, find the highest supported rate that the song's rate is a multiple of
///    (i.e., song_rate % supported_rate == 0, meaning supported_rate divides evenly into song_rate)
///    e.g., for 192000 song with supported [44100, 48000, 96000], pick 96000 since 192000 % 96000 == 0
/// 3. Fallback to 44100 if no compatible rate is found
pub fn resolve_bit_perfect_rate(song_rate: u32, supported_rates: &[u32]) -> u32 {
    // If the song rate is directly supported, use it
    if supported_rates.contains(&song_rate) {
        return song_rate;
    }

    // Find the highest supported rate that divides evenly into the song's rate
    // (i.e., song_rate % supported_rate == 0)
    let best_rate = supported_rates
        .iter()
        .filter(|&&rate| song_rate.is_multiple_of(rate))
        .max()
        .copied();

    if let Some(rate) = best_rate {
        return rate;
    }

    // Fallback: prefer 44100 if available, otherwise first supported rate or 44100
    if supported_rates.contains(&44100) {
        44100
    } else {
        supported_rates.first().copied().unwrap_or(44100)
    }
}

impl Default for PipewireConfig {
    fn default() -> Self {
        Self {
            bit_perfect_enabled: Self::default_bit_perfect_enabled(),
        }
    }
}