ezk-image 0.4.3

Convert pixel and color formats such and RGB, YUV (YCbCr), ICtCp
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

use crate::vector::Vector;

mod read_rgb;
mod read_rgba;
mod write_rgb;
mod write_rgba;

pub(crate) type ReadRgba<'a, P> = read_rgba::ReadRgba<'a, SWIZZLE_RGBA, P>;
pub(crate) type ReadBgra<'a, P> = read_rgba::ReadRgba<'a, SWIZZLE_BGRA, P>;
pub(crate) type ReadArgb<'a, P> = read_rgba::ReadRgba<'a, SWIZZLE_ARGB, P>;
pub(crate) type ReadAbgr<'a, P> = read_rgba::ReadRgba<'a, SWIZZLE_ABGR, P>;

pub(crate) type WriteRgba<'a, P, S> = write_rgba::WriteRgba<'a, SWIZZLE_RGBA, P, S>;
pub(crate) type WriteBgra<'a, P, S> = write_rgba::WriteRgba<'a, SWIZZLE_BGRA, P, S>;
pub(crate) type WriteArgb<'a, P, S> = write_rgba::WriteRgba<'a, SWIZZLE_ARGB, P, S>;
pub(crate) type WriteAbgr<'a, P, S> = write_rgba::WriteRgba<'a, SWIZZLE_ABGR, P, S>;

pub(crate) type ReadRgb<'a, P> = read_rgb::ReadRgb<'a, SWIZZLE_RGBA, P>;
pub(crate) type ReadBgr<'a, P> = read_rgb::ReadRgb<'a, SWIZZLE_BGRA, P>;

pub(crate) type WriteRgb<'a, P, S> = write_rgb::WriteRgb<'a, SWIZZLE_RGBA, P, S>;
pub(crate) type WriteBgr<'a, P, S> = write_rgb::WriteRgb<'a, SWIZZLE_BGRA, P, S>;

const SWIZZLE_RGBA: u8 = 0;
const SWIZZLE_BGRA: u8 = 1;
const SWIZZLE_ARGB: u8 = 2;
const SWIZZLE_ABGR: u8 = 3;

#[derive(Debug, Clone, Copy)]
pub(crate) struct RgbaPixel<V> {
    pub(crate) r: V,
    pub(crate) g: V,
    pub(crate) b: V,
    pub(crate) a: V,
}

impl<V: Vector> RgbaPixel<V> {
    #[inline(always)]
    fn new(r: V, g: V, b: V, a: V) -> Self {
        Self { r, g, b, a }
    }

    #[inline(always)]
    pub(crate) unsafe fn from_components<const SWIZZLE: u8>(c0: V, c1: V, c2: V, c3: V) -> Self {
        match SWIZZLE {
            SWIZZLE_RGBA => Self::new(c0, c1, c2, c3),
            SWIZZLE_BGRA => Self::new(c2, c1, c0, c3),
            SWIZZLE_ARGB => Self::new(c1, c2, c3, c0),
            SWIZZLE_ABGR => Self::new(c3, c2, c1, c0),
            _ => unreachable!("unknown swizzle {SWIZZLE}"),
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub(crate) struct RgbaBlock<V> {
    pub(crate) px00: RgbaPixel<V>,
    pub(crate) px01: RgbaPixel<V>,
    pub(crate) px10: RgbaPixel<V>,
    pub(crate) px11: RgbaPixel<V>,
}

pub(crate) trait RgbaSrc {
    unsafe fn read<V: Vector>(&mut self, x: usize, y: usize) -> RgbaBlock<V>;
}