#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum RgbOrder {
Rgb,
Grb,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum RgbwOrder {
Rgbw,
Grbw,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum Rgb16Order {
Rgb,
Grb,
}
pub trait LedPixel: Copy + Default + private::Sealed {
type Order: Copy + Eq;
const BYTES_PER_PIXEL: usize;
fn encode(self, order: Self::Order, out: &mut [u8]);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Rgb {
pub r: u8,
pub g: u8,
pub b: u8,
}
impl Rgb {
pub const BLACK: Self = Self::new(0, 0, 0);
pub const WHITE: Self = Self::new(u8::MAX, u8::MAX, u8::MAX);
#[must_use]
pub const fn new(r: u8, g: u8, b: u8) -> Self {
Self { r, g, b }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Rgbw {
pub r: u8,
pub g: u8,
pub b: u8,
pub w: u8,
}
impl Rgbw {
pub const BLACK: Self = Self::new(0, 0, 0, 0);
pub const WHITE: Self = Self::new(u8::MAX, u8::MAX, u8::MAX, u8::MAX);
#[must_use]
pub const fn new(r: u8, g: u8, b: u8, w: u8) -> Self {
Self { r, g, b, w }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Rgb16 {
pub r: u16,
pub g: u16,
pub b: u16,
}
impl Rgb16 {
pub const BLACK: Self = Self::new(0, 0, 0);
pub const WHITE: Self = Self::new(u16::MAX, u16::MAX, u16::MAX);
#[must_use]
pub const fn new(r: u16, g: u16, b: u16) -> Self {
Self { r, g, b }
}
}
impl LedPixel for Rgb {
type Order = RgbOrder;
const BYTES_PER_PIXEL: usize = 3;
fn encode(self, order: Self::Order, out: &mut [u8]) {
debug_assert!(out.len() >= Self::BYTES_PER_PIXEL);
match order {
RgbOrder::Rgb => {
out[0] = self.r;
out[1] = self.g;
out[2] = self.b;
}
RgbOrder::Grb => {
out[0] = self.g;
out[1] = self.r;
out[2] = self.b;
}
}
}
}
impl LedPixel for Rgbw {
type Order = RgbwOrder;
const BYTES_PER_PIXEL: usize = 4;
fn encode(self, order: Self::Order, out: &mut [u8]) {
debug_assert!(out.len() >= Self::BYTES_PER_PIXEL);
match order {
RgbwOrder::Rgbw => {
out[0] = self.r;
out[1] = self.g;
out[2] = self.b;
out[3] = self.w;
}
RgbwOrder::Grbw => {
out[0] = self.g;
out[1] = self.r;
out[2] = self.b;
out[3] = self.w;
}
}
}
}
impl LedPixel for Rgb16 {
type Order = Rgb16Order;
const BYTES_PER_PIXEL: usize = 6;
fn encode(self, order: Self::Order, out: &mut [u8]) {
debug_assert!(out.len() >= Self::BYTES_PER_PIXEL);
let [r0, r1] = self.r.to_be_bytes();
let [g0, g1] = self.g.to_be_bytes();
let [b0, b1] = self.b.to_be_bytes();
match order {
Rgb16Order::Rgb => {
out[0] = r0;
out[1] = r1;
out[2] = g0;
out[3] = g1;
out[4] = b0;
out[5] = b1;
}
Rgb16Order::Grb => {
out[0] = g0;
out[1] = g1;
out[2] = r0;
out[3] = r1;
out[4] = b0;
out[5] = b1;
}
}
}
}
mod private {
use super::{Rgb, Rgb16, Rgbw};
pub trait Sealed {}
impl Sealed for Rgb {}
impl Sealed for Rgb16 {}
impl Sealed for Rgbw {}
}
#[cfg(test)]
mod tests {
use super::{LedPixel, Rgb, Rgb16, Rgb16Order, RgbOrder, Rgbw, RgbwOrder};
#[test]
fn rgb_new_stores_channels() {
let p = Rgb::new(0x10, 0x20, 0x30);
assert_eq!(p.r, 0x10);
assert_eq!(p.g, 0x20);
assert_eq!(p.b, 0x30);
}
#[test]
fn rgb_black_is_all_zero() {
assert_eq!(Rgb::BLACK, Rgb::new(0, 0, 0));
}
#[test]
fn rgb_white_is_all_max() {
assert_eq!(Rgb::WHITE, Rgb::new(255, 255, 255));
}
#[test]
fn rgb_default_is_black() {
assert_eq!(Rgb::default(), Rgb::BLACK);
}
#[test]
fn rgbw_new_stores_channels() {
let p = Rgbw::new(0x10, 0x20, 0x30, 0x40);
assert_eq!(p.r, 0x10);
assert_eq!(p.g, 0x20);
assert_eq!(p.b, 0x30);
assert_eq!(p.w, 0x40);
}
#[test]
fn rgbw_black_is_all_zero() {
assert_eq!(Rgbw::BLACK, Rgbw::new(0, 0, 0, 0));
}
#[test]
fn rgbw_white_is_all_max() {
assert_eq!(Rgbw::WHITE, Rgbw::new(255, 255, 255, 255));
}
#[test]
fn rgbw_default_is_black() {
assert_eq!(Rgbw::default(), Rgbw::BLACK);
}
#[test]
fn rgb16_new_stores_channels() {
let p = Rgb16::new(0x1122, 0x3344, 0x5566);
assert_eq!(p.r, 0x1122);
assert_eq!(p.g, 0x3344);
assert_eq!(p.b, 0x5566);
}
#[test]
fn rgb16_black_is_all_zero() {
assert_eq!(Rgb16::BLACK, Rgb16::new(0, 0, 0));
}
#[test]
fn rgb16_white_is_all_max() {
assert_eq!(Rgb16::WHITE, Rgb16::new(65535, 65535, 65535));
}
#[test]
fn rgb16_default_is_black() {
assert_eq!(Rgb16::default(), Rgb16::BLACK);
}
#[test]
fn rgb_encode_respects_rgb_order() {
let mut out = [0_u8; 3];
Rgb::new(0x11, 0x22, 0x33).encode(RgbOrder::Rgb, &mut out);
assert_eq!(out, [0x11, 0x22, 0x33]);
}
#[test]
fn rgb_encode_respects_grb_order() {
let mut out = [0_u8; 3];
Rgb::new(0x11, 0x22, 0x33).encode(RgbOrder::Grb, &mut out);
assert_eq!(out, [0x22, 0x11, 0x33]);
}
#[test]
fn rgbw_encode_respects_rgbw_order() {
let mut out = [0_u8; 4];
Rgbw::new(0x11, 0x22, 0x33, 0x44).encode(RgbwOrder::Rgbw, &mut out);
assert_eq!(out, [0x11, 0x22, 0x33, 0x44]);
}
#[test]
fn rgbw_encode_respects_grbw_order() {
let mut out = [0_u8; 4];
Rgbw::new(0x11, 0x22, 0x33, 0x44).encode(RgbwOrder::Grbw, &mut out);
assert_eq!(out, [0x22, 0x11, 0x33, 0x44]);
}
#[test]
fn rgb16_encode_respects_rgb_order() {
let mut out = [0_u8; 6];
Rgb16::new(0x1122, 0x3344, 0x5566).encode(Rgb16Order::Rgb, &mut out);
assert_eq!(out, [0x11, 0x22, 0x33, 0x44, 0x55, 0x66]);
}
#[test]
fn rgb16_encode_respects_grb_order() {
let mut out = [0_u8; 6];
Rgb16::new(0x1122, 0x3344, 0x5566).encode(Rgb16Order::Grb, &mut out);
assert_eq!(out, [0x33, 0x44, 0x11, 0x22, 0x55, 0x66]);
}
#[test]
fn bytes_per_pixel_values() {
assert_eq!(Rgb::BYTES_PER_PIXEL, 3);
assert_eq!(Rgbw::BYTES_PER_PIXEL, 4);
assert_eq!(Rgb16::BYTES_PER_PIXEL, 6);
}
}