Compiler Explorer

Source code

pub mod formats {
    pub trait RGBFormat {
        fn to_rgba_format(self) -> crate::formats::RGBA;
        fn to_argb_format(self) -> crate::formats::ARGB;
    }

#[cfg(target_endian = "little")]
    #[repr(C)]
    pub struct RGBA {
        pub a: u8,
        pub b: u8,
        pub g: u8,
        pub r: u8,
    }

#[cfg(target_endian = "big")]
    #[repr(C)]
    pub struct RGBA {
        pub r: u8,
        pub g: u8,
        pub b: u8,
        pub a: u8,
    }

#[cfg(target_endian = "little")]
    #[repr(C)]
    pub struct ARGB {
        pub b: u8,
        pub g: u8,
        pub r: u8,
        pub a: u8,
    }

#[cfg(target_endian = "big")]
    #[repr(C)]
    pub struct ARGB {
        pub a: u8,
        pub r: u8,
        pub g: u8,
        pub b: u8,
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
//NOTE RGBA's are stored as ARGB so converting to ARGB should be free
pub struct RGBA {
    pub b: u8,
    pub g: u8,
    pub r: u8,
    pub a: u8,
}

impl formats::RGBFormat for RGBA {
    fn to_rgba_format(self) -> crate::formats::RGBA {
        crate::formats::RGBA {
            a: self.a,
            b: self.b,
            g: self.g,
            r: self.r,
        }
    }

fn to_argb_format(self) -> formats::ARGB {
        crate::formats::ARGB {
            a: self.a,
            b: self.b,
            g: self.g,
            r: self.r,
        }
    }
}

impl RGBA {
    #[inline]
    pub fn new(r: u8, g: u8, b: u8, a: u8) -> Self {
        Self {
            r: r,
            g: g,
            b: b,
            a: a,
        }
    }
}

fn create_array_of_rgba() -> Vec<RGBA> {
    let mut v = Vec::new();
    for _ in 0..255 {
        v.push(RGBA {
            r: 0xFF,
            g: 0xAA,
            b: 0x99,
            a: 0,
        })
    }
    v
}

#[no_mangle]
#[inline(never)]
pub fn pixel_u32slice_rgba(buffer: &mut [RGBA]) -> &mut [u32] {
    use crate::formats::RGBFormat;
    unsafe {
        let temp: &mut [u32] = std::mem::transmute(buffer);
        for element in temp.iter_mut() {
            let temp_as_concrete_type = std::mem::transmute::<&mut u32, &mut RGBA>(element);
            let temp_as_destination_type = temp_as_concrete_type.to_rgba_format();
            *element = std::mem::transmute(temp_as_destination_type);
        }
        temp
    }
}

#[no_mangle]
#[inline(never)]
pub fn pixel_u32slice_argb(buffer: &mut [RGBA]) -> &mut [u32] {
    use crate::formats::RGBFormat;
    unsafe {
        let temp: &mut [u32] = std::mem::transmute(buffer);
        for element in temp.iter_mut() {
            let temp_as_concrete_type = std::mem::transmute::<&mut u32, &mut RGBA>(element);
            let temp_as_destination_type = temp_as_concrete_type.to_argb_format();
            *element = std::mem::transmute(temp_as_destination_type);
        }
        temp
    }
}

fn print_as_hex(name: &str,buffer: &[u32]){
    print!("{}: ",name);
    for i in &buffer[..10]{
        print!("{:#010x}, ",i);
    }
    println!("");
}

pub fn main() {
    let t1 = &mut create_array_of_rgba()[..];

let argb = pixel_u32slice_argb(t1);
    print_as_hex("argb",&argb);

let t2 = &mut create_array_of_rgba()[..];

let rgba = pixel_u32slice_rgba(t2);
    print_as_hex("rgba",&rgba);

assert!(rgba != argb);
}