cpvc 0.6.0

A simple crate + wrapper for controlling system audio cross platform
Documentation 
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

use std::process::Command;

#[allow(dead_code)]
pub fn get_system_volume_command() -> u8 {
    #[allow(unused_assignments)]
    let mut vol = 0;
    #[cfg(target_os="macos")] {
        let output = Command::new("osascript").arg("-e").arg("return output volume of (get volume settings)").output().expect("Are you running on MacOS?");
        let out = String::from_utf8_lossy(&output.stdout).to_string().trim().to_owned();
        vol = out.parse::<u8>().unwrap_or(0);
    }
    #[cfg(target_os="windows")]{
        eprintln!("Windows is not supported by cpvc::command. View README.md for details.");
    }
    #[cfg(target_os="linux")] {
        use std::process::Stdio;
        let mixer = Command::new("amixer").arg("sget").arg("Master").stdout(Stdio::piped()).spawn().unwrap();
        let channels = Command::new("grep").arg("-o").arg("[0-9]*%").stdin(mixer.stdout.unwrap()).stdout(Stdio::piped()).spawn().unwrap();
        let channel_vols = Command::new("tr").arg("-d").arg("%").stdin(channels.stdout.unwrap()).output().unwrap();
        let volumes:String = channel_vols.stdout.into_iter().map(|chr| chr as char).collect();
        let volumes:Vec<u8> = volumes.trim().split("\n").map(|num| num.parse().unwrap_or(0)).collect();
        vol = (volumes.iter().map(|x| *x as f32).sum::<f32>() / volumes.len() as f32) as u8;
    }
    vol
    
}


#[allow(dead_code)]
pub fn set_system_volume_command(percent: u8) -> bool {
    
    #[allow(unused_assignments)]
    let mut success = true;
    #[cfg(target_os="macos")]{
        let factor = 14.29;
        let output = Command::new("osascript").arg("-e").arg(format!("set Volume {}",(percent as f32 / factor * 100.0).round() / 100.0)).output().expect("Are you running on MacOS?");
        success = output.status.success();
    }
    #[cfg(target_os="windows")]{
        eprintln!("Windows is not supported by cpvc::command. View README.md for details.");
        let mute = format!(
            "$wsh = New-Object -ComObject WScript.Shell; \
                1..50 | % {{ $wsh.SendKeys([char]174) }};"
        );

        let adjust = format!(
            "$wsh = New-Object -ComObject WScript.Shell; \
                1..{} | % {{ $wsh.SendKeys([char]175) }};",
                percent / 2
        );
    
        let stage_one = Command::new("powershell")
            .arg("-Command")
            .arg(mute)
            .output()
            .expect("Failed to mute device");
        
        if stage_one.status.success() {
            if percent / 2 > 0 {
                let output = Command::new("powershell")
                .arg("-Command")
                .arg(adjust)
                .output()
                .expect("Failed to mute device");
                success = output.status.success();
            } else {
                success = true;
            }
        } else {
            success = stage_one.status.success();
        }
    }
    #[cfg(target_os="linux")] {
        let command = Command::new("amixer").arg("-D").arg("pipewire").arg("sset").arg("Master").arg(format!("{}%", percent)).output().unwrap();
        if command.stderr.len() > 0 {
            let retry = Command::new("amixer").arg("-D").arg("pulse").arg("sset").arg("Master").arg(format!("{}%", percent)).output().unwrap();
            if retry.stderr.len() > 0 {
                success = false;
            }
        }
    }
    success
}

#[allow(dead_code)]
pub fn get_sound_devices_command() -> Vec<String> {
    let mut devices:Vec<String> = Vec::new();
    #[cfg(target_os="macos")] {
        let output = Command::new("system_profiler").arg("SPAudioDataType").output().expect("Are you running on MacOS?");
        let lines:Vec<String> = String::from_utf8_lossy(&output.stdout).to_string().lines().map(|str| str.to_owned()).collect();
        for (num, line) in lines.iter().enumerate() {
            if !line.contains("          ") && num > 3 && line != ""{
                if !lines.get(num + 3).unwrap().contains("Input") {
                    devices.push(line.trim().replace(":", "").to_owned());
                }
            }
        }
    }
    #[cfg(target_os="windows")] {
        eprintln!("Windows is not supported by cpvc::command. View README.md for details.");
    }
    #[cfg(target_os="linux")] {
        let output = Command::new("pw-cli").arg("ls").arg("Node").output().unwrap();
        if output.stderr.len() == 0 {
            let mut contents:String = output.stdout.into_iter().map(|chr| chr as char).collect();
            contents = contents.replace("\t\t", "");
            let contents:Vec<String> = contents.split("\t").map(|x| x.to_owned()).collect();
            let contents:String = contents.into_iter().filter(|item| item.contains("media.class = \"Audio/Sink\"")).collect();
            devices = contents.split("\n").map(|i| i.to_owned()).filter(|x| x.contains("node.description")).map(|dev| dev.replace(" node.description = ", "").replace("\"", "")).collect();
        }
    }
    devices
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test] 
    #[ignore]
    fn sound_devices() {
        assert_eq!(false, true);
    }

    #[test]
    #[ignore]
    fn current_output() {
        dbg!(get_system_volume_command());
        assert!(false);
    }
}