ddc-i2c 0.2.2

DDC/CI monitor control over I2C
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

extern crate ddc;
extern crate ddc_i2c;
extern crate edid;

use {
    ddc::Edid,
    std::{env::args, io, path::Path},
};

#[cfg(feature = "i2c-linux")]
fn edid<P: AsRef<Path>>(path: P) -> io::Result<()> {
    let path = path.as_ref();

    println!("Opening {}", path.display());

    ddc(ddc_i2c::from_i2c_device(path)?)
}

#[cfg(not(feature = "i2c-linux"))]
fn edid<P: AsRef<Path>>(_path: P) -> io::Result<()> {
    unimplemented!()
}

fn ddc<D: Edid>(mut ddc: D) -> Result<(), D::EdidError>
where
    D::EdidError: ::std::fmt::Debug,
    D::EdidError: From<io::Error>,
{
    let mut edid = [0u8; 0x80];
    let len = ddc.read_edid(0, &mut edid)?;

    let edid = edid::parse(&edid[..len])
        .to_result()
        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?;
    println!("EDID: {:#?}", edid);

    Ok(())
}

fn main() {
    //::env_logger::init();

    let path = args().nth(1);

    match path {
        Some(path) => edid(path).expect("failed to get EDID"),
        #[cfg(feature = "with-linux-enumerate")]
        None => ddc_i2c::I2cDeviceEnumerator::new()
            .expect("failed to enumerate DDC devices")
            .for_each(|i2c| match ddc(i2c) {
                Ok(()) => (),
                Err(e) => println!("Failure: {:?}", e),
            }),
        #[cfg(not(feature = "with-linux-enumerate"))]
        None => panic!("argument: i2c device path"),
    }
}