gufo-common 2.0.0-alpha

Common features used in gufo crates
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
139
140
141
142
143
144
145
146
147
148

//! Coding-independent code points
//!
//! - [ITU-T H.273: Coding-independent code points for video signal type identification](https://www.itu.int/rec/T-REC-H.273)

use crate::utils;

/// Coding-independent code points
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Cicp {
    pub color_primaries: ColorPrimaries,
    pub transfer_characteristics: TransferCharacteristics,
    pub matrix_coefficients: MatrixCoefficients,
    pub video_full_range_flag: VideoRangeFlag,
}

impl Cicp {
    pub const SRGB: Cicp = Cicp {
        color_primaries: ColorPrimaries::Srgb,
        transfer_characteristics: TransferCharacteristics::Gamma24,
        matrix_coefficients: MatrixCoefficients::Identity,
        video_full_range_flag: VideoRangeFlag::Full,
    };

    pub const REC2020_LINEAR: Cicp = Cicp {
        color_primaries: ColorPrimaries::Rec2020,
        transfer_characteristics: TransferCharacteristics::Linear,
        matrix_coefficients: MatrixCoefficients::Identity,
        video_full_range_flag: VideoRangeFlag::Full,
    };

    /// Get CICP from bytes in the order of struct definition
    ///
    /// ```
    /// # use gufo_common::cicp::*;
    /// let cicp = Cicp::from_bytes(&[0x09, 0x10, 0x00, 0x01]).unwrap();
    ///
    /// assert_eq!(cicp.color_primaries, ColorPrimaries::Rec2020);
    /// assert_eq!(cicp.transfer_characteristics, TransferCharacteristics::Pq);
    /// assert_eq!(cicp.matrix_coefficients, MatrixCoefficients::Identity);
    /// assert_eq!(cicp.video_full_range_flag, VideoRangeFlag::Full);
    /// ```
    pub fn from_bytes(bytes: &[u8; 4]) -> Result<Self, CicpError> {
        let color_primaries = ColorPrimaries::from(bytes[0]);
        let transfer_characteristics = TransferCharacteristics::from(bytes[1]);
        let matrix_coefficients: MatrixCoefficients = MatrixCoefficients::from(bytes[2]);
        let video_full_range_flag = VideoRangeFlag::try_from(bytes[3])
            .map_err(|err| CicpError::InvalidVideoFullRangeFlag(err.0))?;

        Ok(Self {
            color_primaries,
            transfer_characteristics,
            matrix_coefficients,
            video_full_range_flag,
        })
    }

    /// Get CICP values as bytes
    ///
    /// ```
    /// # use gufo_common::cicp::*;
    /// let bytes = [0x09, 0x10, 0x00, 0x01];
    /// let cicp = Cicp::from_bytes(&bytes).unwrap();
    ///
    /// assert_eq!(cicp.to_bytes(), bytes);
    /// ```
    pub fn to_bytes(&self) -> [u8; 4] {
        [
            self.color_primaries.into(),
            self.transfer_characteristics.into(),
            self.matrix_coefficients.into(),
            self.video_full_range_flag.into(),
        ]
    }
}

impl From<Cicp> for Vec<u8> {
    fn from(value: Cicp) -> Self {
        vec![
            value.color_primaries.into(),
            value.transfer_characteristics.into(),
            value.matrix_coefficients.into(),
            value.video_full_range_flag.into(),
        ]
    }
}

utils::convertible_enum!(
    #[repr(u8)]
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    pub enum ColorPrimaries {
        Srgb = 1,
        Unspecified = 2,
        Rec2020 = 9,
        DciP3 = 11,
        DisplayP3 = 12,
    }
);

utils::convertible_enum!(
    #[repr(u8)]
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    pub enum TransferCharacteristics {
        /// Gamma=2.2 curve
        Gamma22 = 1,
        Unspecified = 2,
        /// Gamma=2.2 curve
        Gamma22_ = 6,
        /// Linear
        Linear = 8,
        /// Gamma=2.4 curve per IEC 61966-2-1 sRGB
        Gamma24 = 13,
        /// Gamma=2.2 curve 10 bit
        Gamma22Bit10 = 14,
        /// Gamma=2.2 curve 12 bit
        Gamma22Bit12 = 15,
        /// Perceptual quantization (PQ) system
        Pq = 16,
        /// SMPTE ST 428-1
        Dci = 17,
        /// Hybrid log-gamma (HLG) system
        Hlg = 18,
    }
);

utils::convertible_enum!(
    #[repr(u8)]
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    pub enum MatrixCoefficients {
        Identity = 0,
        Unspecified = 2,
        ICtCp = 14,
    }
);

utils::maybe_convertible_enum!(
    #[repr(u8)]
    #[derive(Debug, PartialEq, Eq, Clone, Copy)]
    pub enum VideoRangeFlag {
        Narrow = 0,
        Full = 1,
    }
);

#[derive(Debug, thiserror::Error)]
pub enum CicpError {
    #[error("Invalid video full range flag '{0}'. Expected '0' or '1'.")]
    InvalidVideoFullRangeFlag(u8),
}