Initial commit (working well already for DDC devices)

Author: ShellCode33

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["backlightd", "backlightctl", "backlight_ipc"]
+resolver = "2"

backlight_ipc/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "backlight_ipc"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+bincode = "1.3.3"

backlight_ipc/src/lib.rs

@@ -0,0 +1,27 @@
+use std::{
+    error::Error,
+    io::{Read, Write},
+};
+
+use serde::{Deserialize, Serialize};
+
+pub const DEFAULT_UNIX_SOCKET_PATH: &str = "/run/backlightd.sock";
+
+#[derive(Serialize, Deserialize, Debug)]
+pub enum BacklightCommand {
+    SetBrightness(u8),
+    IncreaseBrightness(u8),
+    DecreaseBrightness(u8),
+    Refresh,
+}
+
+// The following abstraction allow us to easily change the protocol if need be.
+// Crates that use the BacklightCommand enum don't need to know that bincode is used under the hood.
+impl BacklightCommand {
+    pub fn serialize_into(&self, writer: impl Write) -> Result<(), Box<dyn Error>> {
+        Ok(bincode::serialize_into(writer, self)?)
+    }
+    pub fn deserialize_from(reader: impl Read) -> Result<Self, Box<dyn Error>> {
+        Ok(bincode::deserialize_from(reader)?)
+    }
+}

backlightctl/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "backlightctl"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+clap = { version = "4.5.21", features = ["derive"] }
+backlight_ipc = { path = "../backlight_ipc" }

backlightctl/src/main.rs

@@ -0,0 +1,122 @@
+use std::{os::unix::net::UnixStream, path::PathBuf, process::exit};
+
+use backlight_ipc::{BacklightCommand, DEFAULT_UNIX_SOCKET_PATH};
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(version, about, long_about = None)]
+struct BacklightctlCli {
+    /// Set the brightness of all monitors (valid values examples: 50% +10% -10%)
+    #[clap(short, long)]
+    #[structopt(allow_hyphen_values = true)]
+    brightness: Option<String>,
+
+    /// Refresh the list of known monitors (called by the udev rule)
+    #[clap(short, long, default_value_t = false)]
+    refresh: bool,
+
+    /// UNIX socket path (for test purposes)
+    #[clap(short, long, default_value = DEFAULT_UNIX_SOCKET_PATH)]
+    unix_socket_path: PathBuf,
+}
+
+fn main() {
+    let cli = BacklightctlCli::parse();
+
+    let brightness_cmd = if let Some(brightness) = cli.brightness {
+        if brightness.chars().last().is_some_and(|c| c != '%') {
+            eprintln!("Brightness value is missing a % sign at the end");
+            exit(1);
+        }
+
+        let potential_brightness_modifier = brightness.chars().next();
+
+        if potential_brightness_modifier.is_some_and(|c| c == '+') {
+            let brightness = brightness
+                .chars()
+                .skip(1)
+                .take_while(|&c| c != '%')
+                .collect::<String>();
+
+            let brightness = match brightness.parse::<u8>() {
+                Ok(percent) => percent,
+                Err(err) => {
+                    eprintln!("Unable to parse brightness value {brightness}: {err}");
+                    exit(1);
+                }
+            };
+
+            if brightness > 100 {
+                eprintln!("Brightness value must be a percentage between -100% and 100%");
+                exit(1);
+            }
+
+            Some(BacklightCommand::IncreaseBrightness(brightness))
+        } else if potential_brightness_modifier.is_some_and(|c| c == '-') {
+            let brightness = brightness
+                .chars()
+                .skip(1)
+                .take_while(|&c| c != '%')
+                .collect::<String>();
+
+            let brightness = match brightness.parse::<usize>() {
+                Ok(percent) => percent,
+                Err(err) => {
+                    eprintln!("Unable to parse brightness value {brightness}: {err}");
+                    exit(1);
+                }
+            };
+
+            if brightness > 100 {
+                eprintln!("Brightness value must be a percentage between -100% and +100%");
+                exit(1);
+            }
+
+            Some(BacklightCommand::DecreaseBrightness(brightness as u8))
+        } else {
+            let brightness = brightness
+                .chars()
+                .take_while(|&c| c != '%')
+                .collect::<String>();
+
+            let brightness = match brightness.parse::<usize>() {
+                Ok(percent) => percent,
+                Err(err) => {
+                    eprintln!("Unable to parse brightness value {brightness}: {err}");
+                    exit(1);
+                }
+            };
+
+            if brightness > 100 {
+                eprintln!("Brightness value must be a percentage between -100% and +100%");
+                exit(1);
+            }
+
+            Some(BacklightCommand::SetBrightness(brightness as u8))
+        }
+    } else {
+        None
+    };
+
+    let stream = match UnixStream::connect(&cli.unix_socket_path) {
+        Ok(stream) => stream,
+        Err(err) => {
+            eprintln!("{}: {err}", cli.unix_socket_path.display());
+            exit(1);
+        }
+    };
+
+    if cli.refresh {
+        if let Err(err) = BacklightCommand::Refresh.serialize_into(&stream) {
+            eprintln!("{err}");
+            exit(1);
+        }
+    }
+
+    if let Some(brightness_cmd) = brightness_cmd {
+        if let Err(err) = brightness_cmd.serialize_into(&stream) {
+            eprintln!("{err}");
+            exit(1);
+        }
+    }
+}

backlightd/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "backlightd"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ddc-hi = "0.4.1"
+backlight_ipc = { path = "../backlight_ipc" }
+anyhow = "1.0.93"

backlightd/src/acpi.rs

@@ -0,0 +1,68 @@
+use std::{fs, path::PathBuf};
+
+use anyhow::bail;
+
+use crate::BacklightDevice;
+
+pub(crate) const ACPI_DEVICES_PATH: &str = "/sys/class/backlight";
+
+pub(crate) struct BacklightAcpiDevice {
+    path: PathBuf,
+    max_brightness_raw: u16,
+    current_brightness_raw: u16,
+    current_brightness_percent: u8,
+}
+
+impl BacklightAcpiDevice {
+    pub(crate) fn new(path: PathBuf) -> anyhow::Result<Self> {
+        let max_brightness_path = path.join("max_brightness");
+        let current_brightness_path = path.join("brightness");
+
+        let max_brightness_raw = match fs::read_to_string(&max_brightness_path) {
+            Ok(max_brightness) => max_brightness.parse::<u16>()?,
+            Err(err) => {
+                bail!("{}: {err}", max_brightness_path.display());
+            }
+        };
+
+        let current_brightness_raw = match fs::read_to_string(&current_brightness_path) {
+            Ok(current_brightness) => current_brightness.parse::<u16>()?,
+            Err(err) => {
+                bail!("{}: {err}", current_brightness_path.display());
+            }
+        };
+
+        Ok(Self {
+            path,
+            max_brightness_raw,
+            current_brightness_raw,
+            current_brightness_percent: (current_brightness_raw * 100 / max_brightness_raw) as u8,
+        })
+    }
+}
+
+impl BacklightDevice for BacklightAcpiDevice {
+    fn set_brightness(&mut self, percent: u8) -> anyhow::Result<()> {
+        assert!(percent <= 100);
+
+        let current_brightness_path = self.path.join("brightness");
+        let new_brightness = (percent as f64 / 100. * self.max_brightness_raw as f64) as u16;
+
+        if let Err(err) = fs::write(&current_brightness_path, new_brightness.to_string()) {
+            bail!("{}: {err}", current_brightness_path.display());
+        }
+
+        self.current_brightness_raw = new_brightness;
+        self.current_brightness_percent = percent;
+        Ok(())
+    }
+
+    fn get_brightness(&self) -> u8 {
+        self.current_brightness_percent
+    }
+
+    fn name(&self) -> String {
+        // It's ok to unwrap here, if there is no filename it means the developer did something wrong.
+        self.path.file_name().unwrap().to_string_lossy().to_string()
+    }
+}

backlightd/src/ddc.rs

@@ -0,0 +1,60 @@
+use std::error::Error;
+
+use anyhow::bail;
+use ddc_hi::{Ddc, Display, FeatureCode};
+
+use crate::BacklightDevice;
+
+const VCP_FEATURE_BRIGHTNESS: FeatureCode = 0x10;
+
+pub(crate) struct BacklightDdcDevice {
+    display: Display,
+    max_brightness_raw: u16,
+    current_brightness_raw: u16,
+    current_brightness_percent: u8,
+}
+
+impl BacklightDdcDevice {
+    pub(crate) fn new(mut ddc_device: ddc_hi::Display) -> Result<Self, Box<dyn Error>> {
+        let brightness = ddc_device.handle.get_vcp_feature(VCP_FEATURE_BRIGHTNESS)?;
+
+        Ok(Self {
+            display: ddc_device,
+            max_brightness_raw: brightness.maximum(),
+            current_brightness_raw: brightness.value(),
+            current_brightness_percent: (brightness.value() * 100 / brightness.maximum()) as u8,
+        })
+    }
+}
+
+impl BacklightDevice for BacklightDdcDevice {
+    fn set_brightness(&mut self, percent: u8) -> anyhow::Result<()> {
+        assert!(percent <= 100);
+
+        let new_brightness = (percent as f64 / 100. * self.max_brightness_raw as f64) as u16;
+
+        if let Err(err) = self
+            .display
+            .handle
+            .set_vcp_feature(VCP_FEATURE_BRIGHTNESS, new_brightness)
+        {
+            bail!("{}: {err}", self.name());
+        }
+
+        self.current_brightness_raw = new_brightness;
+        self.current_brightness_percent = percent;
+        Ok(())
+    }
+
+    fn get_brightness(&self) -> u8 {
+        self.current_brightness_percent
+    }
+
+    fn name(&self) -> String {
+        self.display
+            .info
+            .model_name
+            .clone()
+            .unwrap_or(String::from("Unknown"))
+    }
+}