rcms 0.1.0

ICC color management library
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
132
133
134
135
136
137
138

//! Fixed-point types.

use std::convert::TryFrom;
use std::fmt;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ReprError<T>(pub T);

/// Signed 15.16 fixed-point number.
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct s15f16(i32);

impl s15f16 {
    pub const ZERO: s15f16 = s15f16(0);

    pub fn from_bytes(this: i32) -> Self {
        s15f16(this)
    }
    pub fn to_bytes(self) -> i32 {
        self.0
    }
}

impl fmt::Display for s15f16 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let sign = self.0.signum();
        let value = self.0.abs();
        let whole = (value >> 16) & 0x7FFF;
        let fract = value & 0xFFFF;

        write!(f, "{}.", sign * whole)?;

        let mut fract_float = fract as f64 / 65536.;
        fract_float *= 10.;
        while fract_float > 0. {
            write!(f, "{}", fract_float.floor() as u8)?;
            fract_float = 10. * fract_float.fract();
        }
        Ok(())
    }
}

impl fmt::Debug for s15f16 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self)
    }
}

impl From<s15f16> for f64 {
    fn from(this: s15f16) -> f64 {
        let sign = this.0.signum() as f64;
        let value = this.0.abs();

        let whole = (value >> 16) & 0x7FFF;
        let fract = value & 0xFFFF;

        sign * (whole as f64) + (fract as f64 / 65536.)
    }
}

impl TryFrom<f64> for s15f16 {
    type Error = ReprError<f64>;

    fn try_from(this: f64) -> Result<s15f16, ReprError<f64>> {
        let sign = this.signum() as i32;
        let value = this.abs();

        let whole = {
            let value = value.floor();
            if value > 0x7FFF as f64 {
                return Err(ReprError(this));
            }
            value as i32
        };
        let frac_part = value.fract();

        Ok(s15f16(
            sign * (((whole & 0x7FFF) << 16) | (((frac_part * 65536.) as i32) & 0xFFFF)),
        ))
    }
}

/// Unsigned 16.16 fixed-point number.
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct u16f16(u32);

impl u16f16 {
    pub const ZERO: u16f16 = u16f16(0);

    pub fn from_bytes(this: u32) -> Self {
        u16f16(this)
    }
    pub fn to_bytes(self) -> u32 {
        self.0
    }
}

impl fmt::Display for u16f16 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let value = self.0;
        let whole = (value >> 16) & 0xFFFF;
        let fract = value & 0xFFFF;

        write!(f, "{}.", whole)?;

        let mut fract_float = fract as f64 / 65536.;
        fract_float *= 10.;
        while fract_float > 0. {
            write!(f, "{}", fract_float.floor() as u8)?;
            fract_float = 10. * fract_float.fract();
        }
        Ok(())
    }
}

impl fmt::Debug for u16f16 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self)
    }
}

impl From<u16f16> for f64 {
    fn from(this: u16f16) -> f64 {
        this.0 as f64 / 65536.
    }
}

impl TryFrom<f64> for u16f16 {
    type Error = ReprError<f64>;
    fn try_from(this: f64) -> Result<u16f16, ReprError<f64>> {
        if this < 0. || this > 0xFFFF as f64 {
            return Err(ReprError(this));
        }
        Ok(u16f16((this * 65536.) as u32))
    }
}