ferrosonic 0.8.1

A terminal-based Subsonic music client with bit-perfect audio playback
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

//! PipeWire sample rate control

use std::process::Command;
use tokio::task;
use tracing::{debug, error, info};

use crate::error::AudioError;

/// PipeWire sample rate controller
pub struct PipeWireController {
    /// Original sample rate before ferrosonic started
    original_rate: Option<u32>,
    /// Current forced sample rate
    current_rate: Option<u32>,
}

impl PipeWireController {
    /// Create a new PipeWire controller
    pub fn new() -> Self {
        let original_rate = task::block_in_place(|| Self::get_current_rate_blocking().ok());
        debug!("Original PipeWire sample rate: {:?}", original_rate);

        Self {
            original_rate,
            current_rate: None,
        }
    }

    /// Blocking helper to get current sample rate from PipeWire
    fn get_current_rate_blocking() -> Result<u32, AudioError> {
        let output = Command::new("pw-metadata")
            .arg("-n")
            .arg("settings")
            .arg("0")
            .arg("clock.force-rate")
            .output()
            .map_err(|e| AudioError::PipeWire(format!("Failed to run pw-metadata: {}", e)))?;

        let stdout = String::from_utf8_lossy(&output.stdout);

        // Parse output like: "update: id:0 key:'clock.force-rate' value:'48000' type:''"
        for line in stdout.lines() {
            if line.contains("clock.force-rate") && line.contains("value:") {
                if let Some(start) = line.find("value:'") {
                    let rest = &line[start + 7..];
                    if let Some(end) = rest.find('\'') {
                        let rate_str = &rest[..end];
                        if let Ok(rate) = rate_str.parse::<u32>() {
                            return Ok(rate);
                        }
                    }
                }
            }
        }

        // No forced rate, return default
        Ok(0)
    }

    /// Get the current forced sample rate
    pub fn get_current_rate(&self) -> Option<u32> {
        self.current_rate
    }

    /// Blocking helper to set the sample rate
    fn set_rate_blocking(rate: u32) -> Result<(), AudioError> {
        info!("Setting PipeWire sample rate to {} Hz", rate);

        let output = Command::new("pw-metadata")
            .arg("-n")
            .arg("settings")
            .arg("0")
            .arg("clock.force-rate")
            .arg(rate.to_string())
            .output()
            .map_err(|e| AudioError::PipeWire(format!("Failed to run pw-metadata: {}", e)))?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Err(AudioError::PipeWire(format!(
                "pw-metadata failed: {}",
                stderr
            )));
        }

        Ok(())
    }

    /// Set the sample rate
    pub fn set_rate(&mut self, rate: u32) -> Result<(), AudioError> {
        if self.current_rate == Some(rate) {
            debug!("Sample rate already set to {}", rate);
            return Ok(());
        }

        task::block_in_place(|| Self::set_rate_blocking(rate))?;
        self.current_rate = Some(rate);
        Ok(())
    }

    /// Restore original sample rate
    pub fn restore_original(&mut self) -> Result<(), AudioError> {
        if let Some(rate) = self.original_rate {
            if rate > 0 {
                info!("Restoring original sample rate: {} Hz", rate);
                self.set_rate(rate)?;
            } else {
                info!("Clearing forced sample rate");
                self.clear_forced_rate()?;
            }
        }
        Ok(())
    }

    /// Blocking helper to clear the forced sample rate
    fn clear_forced_rate_blocking() -> Result<(), AudioError> {
        info!("Clearing PipeWire forced sample rate");

        let output = Command::new("pw-metadata")
            .arg("-n")
            .arg("settings")
            .arg("0")
            .arg("clock.force-rate")
            .arg("0")
            .output()
            .map_err(|e| AudioError::PipeWire(format!("Failed to run pw-metadata: {}", e)))?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Err(AudioError::PipeWire(format!(
                "pw-metadata failed: {}",
                stderr
            )));
        }

        Ok(())
    }

    /// Clear the forced sample rate (let PipeWire use default)
    pub fn clear_forced_rate(&mut self) -> Result<(), AudioError> {
        task::block_in_place(|| Self::clear_forced_rate_blocking())?;
        self.current_rate = None;
        Ok(())
    }

}

impl Default for PipeWireController {
    fn default() -> Self {
        Self::new()
    }
}

impl Drop for PipeWireController {
    fn drop(&mut self) {
        if let Some(rate) = self.original_rate {
            std::thread::spawn(move || {
                if rate > 0 {
                    if let Err(e) = Self::set_rate_blocking(rate) {
                        error!("Failed to restore sample rate: {}", e);
                    }
                } else if let Err(e) = Self::clear_forced_rate_blocking() {
                    error!("Failed to clear forced sample rate: {}", e);
                }
            });
        }
    }
}