#[cfg(feature = "array_from_image")]
use crate::base::immutable::try_from_image_inner;
#[cfg(feature = "array_from_image")]
use image::GenericImageView;
use std::alloc::{Layout, alloc, dealloc, handle_alloc_error};
#[cfg(feature = "array_from_image")]
use std::path::Path;
use std::ptr;
#[derive(Debug)]
pub struct ScreenArrayBase<T: num_traits::Zero + Copy> {
arr_ptr: *mut T,
width: usize,
height: usize,
}
fn alloc_buffer<T>(len: usize) -> *mut T {
if len == 0 {
return ptr::null_mut();
}
let layout = Layout::array::<T>(len).expect("[ScreenArrayBaseBase<T>] layout overflow");
unsafe {
let ptr = alloc(layout);
if ptr.is_null() {
handle_alloc_error(layout);
}
ptr as *mut T
}
}
unsafe fn dealloc_buffer<T>(ptr: *mut T, len: usize) {
if len == 0 || ptr.is_null() {
return;
}
let layout = Layout::array::<T>(len).unwrap();
unsafe {
dealloc(ptr as *mut u8, layout);
}
}
macro_rules! impl_screen_size_methods {
($width:ident, $slice:ident) => {
#[inline]
pub fn width(&self) -> usize {
self.$width
}
#[inline]
pub fn height(&self) -> usize {
if self.$width == 0 {
0
} else {
debug_assert_eq!(self.$slice.len() % self.width(), 0);
self.$slice.len() / self.$width
}
}
};
}
macro_rules! impl_screen_get {
($width:ident, $height:ident, $slice:ident) => {
pub fn get(&self, x: usize, y: usize) -> Option<&T> {
if x < self.$width && y < self.$height() {
Some(&self.$slice[y * self.$width + x])
} else {
None
}
}
};
}
#[derive(Debug, Clone, Copy)]
pub struct ScreenArrayBaseView<'a, T: num_traits::Zero + Copy> {
slice: &'a [T],
width: usize,
}
impl<'a, T: num_traits::Zero + Copy> ScreenArrayBaseView<'a, T> {
impl_screen_size_methods!(width, slice);
impl_screen_get!(width, height, slice);
}
impl<'a, T: num_traits::Zero + Copy> std::ops::Index<usize> for ScreenArrayBaseView<'a, T> {
type Output = [T];
fn index(&self, row: usize) -> &Self::Output {
let start = row
.checked_mul(self.width)
.expect("[ScreenArrayBaseView::index] overflow");
&self.slice[start..start + self.width]
}
}
pub struct ScreenArrayBaseViewMut<'a, T: num_traits::Zero + Copy> {
slice: &'a mut [T],
width: usize,
}
impl<'a, T: num_traits::Zero + Copy> ScreenArrayBaseViewMut<'a, T> {
impl_screen_size_methods!(width, slice);
impl_screen_get!(width, height, slice);
pub fn get_mut(&mut self, x: usize, y: usize) -> Option<&mut T> {
if x < self.width && y < self.height() {
Some(&mut self.slice[y * self.width + x])
} else {
None
}
}
}
impl<'a, T: num_traits::Zero + Copy> std::ops::Index<usize> for ScreenArrayBaseViewMut<'a, T> {
type Output = [T];
fn index(&self, row: usize) -> &Self::Output {
let start = row
.checked_mul(self.width)
.expect("[ScreenArrayBaseViewMut<T>::index] overflow");
&self.slice[start..start + self.width]
}
}
impl<'a, T: num_traits::Zero + Copy> std::ops::IndexMut<usize> for ScreenArrayBaseViewMut<'a, T> {
fn index_mut(&mut self, row: usize) -> &mut Self::Output {
let start = row
.checked_mul(self.width)
.expect("[ScreenArrayBaseViewMut<T>::index_mut] overflow");
&mut self.slice[start..start + self.width]
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ResizeInit {
Uninit,
Zero,
LinearCopy,
AlignCopy,
ZeroLinearCopy,
ZeroAlignCopy,
}
impl<T: num_traits::Zero + Copy> ScreenArrayBase<T> {
pub fn new(data: &[T], width: usize, height: usize) -> Self {
let len = width
.checked_mul(height)
.expect("[ScreenArrayBase<T>::new] width * height overflow");
assert_eq!(
data.len(),
len,
"[ScreenArrayBase<T>::new] data length does not match width * height"
);
let ptr = alloc_buffer::<T>(len);
unsafe {
ptr::copy_nonoverlapping(data.as_ptr(), ptr, len);
}
Self {
arr_ptr: ptr,
width,
height,
}
}
pub fn new_uninit(width: usize, height: usize) -> Self {
let len = width
.checked_mul(height)
.expect("[ScreenArrayBase<T>::new_uninit] width * height overflow");
let ptr = alloc_buffer::<T>(len);
Self {
arr_ptr: ptr,
width,
height,
}
}
pub fn zero(width: usize, height: usize) -> Self {
let len = width
.checked_mul(height)
.expect("[ScreenArrayBase<T>::zero] width * height overflow");
let ptr = alloc_buffer::<T>(len);
if len > 0 {
unsafe {
for i in 0..len {
ptr::write(ptr.add(i), T::zero());
}
}
}
Self {
arr_ptr: ptr,
width,
height,
}
}
pub unsafe fn from_raw(arr_ptr: *mut T, width: usize, height: usize) -> Self {
assert!(
!arr_ptr.is_null(),
"[ScreenArrayBase<T>::from_raw] null pointer"
);
Self {
arr_ptr,
width,
height,
}
}
pub fn drop(&mut self) {
unsafe {
dealloc_buffer(self.arr_ptr, self.width * self.height);
self.arr_ptr = ptr::null_mut();
}
}
pub unsafe fn drop_it(arr_ptr: *mut T, len: usize) {
unsafe {
dealloc_buffer(arr_ptr, len);
}
}
pub const fn size(&self) -> (usize, usize) {
(self.height, self.width)
}
pub const fn width(&self) -> usize {
self.width
}
pub const fn height(&self) -> usize {
self.height
}
pub fn get(&self) -> ScreenArrayBaseView<'_, T> {
ScreenArrayBaseView {
slice: self.as_slice(),
width: self.width,
}
}
pub fn get_mut(&self) -> ScreenArrayBaseViewMut<'_, T> {
ScreenArrayBaseViewMut {
slice: self.as_mut_slice(),
width: self.width,
}
}
pub unsafe fn get_from_index_mut(&self, x: usize, y: usize) -> &mut T {
unsafe { &mut *self.arr_ptr.add(y * self.width + x) }
}
pub unsafe fn get_from_index(&self, x: usize, y: usize) -> &T {
unsafe { &*self.arr_ptr.add(y * self.width + x) }
}
pub fn get_ptr(&self) -> *mut T {
self.arr_ptr
}
pub unsafe fn get_ptr_num(&self) -> usize {
self.arr_ptr as usize
}
pub unsafe fn get_from_index_ptr(&self, x: usize, y: usize) -> *mut T {
unsafe { self.arr_ptr.add(y * self.width + x) }
}
pub unsafe fn get_from_index_ptr_selfless(
self_ptr: usize,
width: usize,
x: usize,
y: usize,
) -> *mut T {
let ptr = self_ptr as *mut T;
unsafe { ptr.add(y * width + x) }
}
pub fn as_slice(&self) -> &[T] {
unsafe {
if self.width * self.height == 0 {
&[]
} else {
std::slice::from_raw_parts(self.arr_ptr, self.width * self.height)
}
}
}
pub fn as_mut_slice(&self) -> &mut [T] {
unsafe {
if self.width * self.height == 0 {
&mut []
} else {
std::slice::from_raw_parts_mut(self.arr_ptr, self.width * self.height)
}
}
}
pub unsafe fn set_size_unchecked(&mut self, new_width: usize, new_height: usize) {
self.width = new_width;
self.height = new_height;
}
pub unsafe fn resize_take_old(
&mut self,
new_width: usize,
new_height: usize,
init: ResizeInit,
) -> usize {
let new_len = new_width
.checked_mul(new_height)
.expect("[ScreenArrayBase::resize_take_old] width * height overflow");
let old_len = self.width * self.height;
let old_ptr = self.arr_ptr;
if new_len == old_len {
self.width = new_width;
self.height = new_height;
return 0;
}
let new_ptr = alloc_buffer::<T>(new_len);
match init {
ResizeInit::Uninit => {
}
ResizeInit::Zero => unsafe {
Self::zero_buf(new_ptr, new_len);
},
ResizeInit::LinearCopy => unsafe {
Self::copy_linear(old_ptr, new_ptr, old_len.min(new_len));
},
ResizeInit::AlignCopy => unsafe {
Self::copy_align(
old_ptr,
new_ptr,
self.width,
new_width,
self.height,
new_height,
);
},
ResizeInit::ZeroLinearCopy => unsafe {
Self::zero_buf(new_ptr, new_len);
Self::copy_linear(old_ptr, new_ptr, old_len.min(new_len));
},
ResizeInit::ZeroAlignCopy => unsafe {
Self::zero_buf(new_ptr, new_len);
Self::copy_align(
old_ptr,
new_ptr,
self.width,
new_width,
self.height,
new_height,
);
},
}
self.arr_ptr = new_ptr;
self.width = new_width;
self.height = new_height;
old_ptr as usize
}
#[inline]
unsafe fn zero_buf(ptr: *mut T, len: usize) {
for i in 0..len {
unsafe {
ptr::write(ptr.add(i), T::zero());
}
}
}
#[inline]
unsafe fn copy_linear(src: *mut T, dst: *mut T, len: usize) {
if len > 0 {
unsafe {
ptr::copy_nonoverlapping(src, dst, len);
}
}
}
#[inline]
unsafe fn copy_align(
src: *mut T,
dst: *mut T,
old_width: usize,
new_width: usize,
old_height: usize,
new_height: usize,
) {
let copy_height = old_height.min(new_height);
let copy_width = old_width.min(new_width);
for y in 0..copy_height {
unsafe {
Self::copy_linear(src.add(y * old_width), dst.add(y * new_width), copy_width);
}
}
}
pub unsafe fn resize(&mut self, new_width: usize, new_height: usize, init: ResizeInit) {
unsafe {
let old_len = self.width * self.height;
let old_ptr = self.resize_take_old(new_width, new_height, init);
if old_ptr != 0 {
dealloc_buffer(old_ptr as *mut T, old_len);
}
}
}
pub fn resize_align(&mut self, new_width: usize, new_height: usize) {
unsafe {
self.resize(new_width, new_height, ResizeInit::ZeroAlignCopy);
}
}
}
#[cfg(feature = "array_from_image")]
impl<T: num_traits::Zero + Copy> ScreenArrayBase<T> {
pub fn set_image<P: AsRef<Path>, F: Fn(u32) -> T>(
&mut self,
path: P,
converter: F,
) -> Result<(), Box<dyn std::error::Error>> {
let img = image::open(path)?;
let (w, h) = img.dimensions();
let w = w as usize;
let h = h as usize;
if w != self.width || h != self.height {
return Err("[ScreenArrayBase<T>::set_image] image dimensions do not match".into());
}
let raw = img.into_rgba8().into_raw();
for y in 0..self.height {
for x in 0..self.width {
let idx = y * self.width + x;
let r = raw[idx * 4] as u32;
let g = raw[idx * 4 + 1] as u32;
let b = raw[idx * 4 + 2] as u32;
let a = raw[idx * 4 + 3] as u32;
let packed = a << 24 | r << 16 | g << 8 | b;
let pixel = converter(packed);
unsafe {
*self.get_from_index_mut(x, y) = pixel;
}
}
}
Ok(())
}
pub fn from_image<P: AsRef<Path> + Clone, F: Fn(u32) -> T>(
path: P,
converter: F,
) -> Result<ScreenArrayBase<T>, Box<dyn std::error::Error>> {
let img = image::open(path.clone())?;
let (w, h) = img.dimensions();
let mut arr = ScreenArrayBase::zero(w as usize, h as usize);
arr.set_image(path, converter)?;
Ok(arr)
}
}
#[cfg(feature = "array_from_image")]
impl<T: num_traits::Zero + Copy + From<u32>> TryFrom<image::DynamicImage> for ScreenArrayBase<T> {
type Error = Box<dyn std::error::Error>;
fn try_from(value: image::DynamicImage) -> Result<Self, Self::Error> {
let (w, h) = value.dimensions();
let raw = value.into_rgba8().into_raw();
let pixels: Vec<T> = try_from_image_inner(raw);
Ok(ScreenArrayBase::new(&pixels, w as usize, h as usize))
}
}
impl<T: num_traits::Zero + Copy> Default for ScreenArrayBase<T> {
fn default() -> Self {
Self::zero(0, 0)
}
}
unsafe impl<T: num_traits::Zero + Copy + Send> Send for ScreenArrayBase<T> {}
unsafe impl<T: num_traits::Zero + Copy + Sync> Sync for ScreenArrayBase<T> {}
#[cfg(test)]
mod tests {
use super::*;
use std::ops::Add;
fn create_test_array() -> ScreenArrayBase<u32> {
let data = vec![1, 2, 3, 4, 5, 6]; ScreenArrayBase::new(&data, 3, 2)
}
#[test]
fn test_new_and_index() {
let mut arr = create_test_array();
assert_eq!(arr.width(), 3);
assert_eq!(arr.height(), 2);
let view = arr.get();
assert_eq!(view[0][0], 1);
assert_eq!(view[0][1], 2);
assert_eq!(view[0][2], 3);
assert_eq!(view[1][0], 4);
assert_eq!(view[1][1], 5);
assert_eq!(view[1][2], 6);
arr.drop();
}
#[test]
fn test_zero_allocation() {
let mut arr = ScreenArrayBase::<u32>::zero(3, 2);
let slice = arr.as_slice();
assert_eq!(slice, &[0, 0, 0, 0, 0, 0]);
arr.drop();
}
#[test]
fn test_new_uninit_and_write() {
let mut arr = ScreenArrayBase::<u32>::new_uninit(4, 1);
let slice = arr.as_mut_slice();
for (i, val) in slice.iter_mut().enumerate() {
*val = i as u32;
}
assert_eq!(arr.as_slice(), &[0, 1, 2, 3]);
arr.drop();
}
#[test]
fn test_get_mut() {
let mut arr = create_test_array();
{
let mut view = arr.get_mut();
view[0][0] = 100;
assert_eq!(view[0][0], 100);
}
assert_eq!(arr.as_slice()[0], 100);
arr.drop();
}
#[test]
#[should_panic]
fn test_view_index_out_of_bounds_panics() {
let mut arr = create_test_array();
let view = arr.get();
let _ = view[2][0]; arr.drop(); }
#[test]
#[should_panic]
fn test_view_index_row_overflow_panics() {
let mut arr = ScreenArrayBase::<u32>::zero(usize::MAX, 1); let view = arr.get();
let _ = view[usize::MAX];
arr.drop();
}
#[test]
fn test_get_from_index_unsafe() {
let mut arr = create_test_array();
unsafe {
assert_eq!(*arr.get_from_index(0, 0), 1);
assert_eq!(*arr.get_from_index_mut(1, 1), 5);
}
arr.drop();
}
#[test]
fn test_resize_align() {
let mut arr = ScreenArrayBase::<u32>::new(&[1, 2, 3, 4, 5, 6], 3, 2);
unsafe {
arr.resize(4, 3, ResizeInit::ZeroAlignCopy);
}
let view = arr.get();
assert_eq!(view[0], [1, 2, 3, 0]);
assert_eq!(view[1], [4, 5, 6, 0]);
assert_eq!(view[2], [0, 0, 0, 0]);
arr.drop();
}
#[test]
fn test_resize_linear_copy() {
let mut arr = ScreenArrayBase::<u32>::new(&[1, 2, 3, 4], 2, 2);
unsafe {
arr.resize(3, 2, ResizeInit::LinearCopy);
}
let view = arr.get();
assert_eq!(view[0][..3], [1, 2, 3]);
assert_eq!(view[1][0], 4);
arr.drop();
}
#[test]
fn test_resize_get_old() {
let mut arr = ScreenArrayBase::<u32>::new(&[1, 2, 3, 4], 2, 2);
let old_len = 4;
let old_ptr = unsafe { arr.resize_take_old(3, 3, ResizeInit::Zero) };
assert_ne!(old_ptr, 0);
assert_eq!(arr.width(), 3);
assert_eq!(arr.height(), 3);
unsafe {
let old_slice = std::slice::from_raw_parts(old_ptr as *mut u32, old_len);
assert_eq!(old_slice, &[1, 2, 3, 4]);
ScreenArrayBase::<u32>::drop_it(old_ptr as *mut u32, old_len);
}
arr.drop();
}
#[test]
fn test_resize_same_size_returns_zero() {
let mut arr = ScreenArrayBase::<u32>::new(&[1, 2, 3, 4], 2, 2);
let old_ptr = unsafe { arr.resize_take_old(4, 1, ResizeInit::Zero) };
assert_eq!(old_ptr, 0);
assert_eq!(arr.width(), 4);
assert_eq!(arr.height(), 1);
arr.drop();
}
#[test]
fn test_set_size_unchecked() {
let mut arr = ScreenArrayBase::<u32>::new(&[1, 2, 3, 4, 5, 6], 3, 2);
unsafe {
arr.set_size_unchecked(2, 3);
}
let view = arr.get();
assert_eq!(view[0], [1, 2]);
assert_eq!(view[1], [3, 4]);
assert_eq!(view[2], [5, 6]);
arr.drop();
}
#[test]
fn test_as_slice_empty() {
let mut arr = ScreenArrayBase::<u32>::zero(0, 0);
assert!(arr.as_slice().is_empty());
arr.drop();
}
#[test]
fn test_drop_it_static() {
let arr = ScreenArrayBase::<u32>::new(&[42; 4], 2, 2);
let ptr = arr.get_ptr();
let len = 4;
std::mem::forget(arr);
unsafe {
ScreenArrayBase::<u32>::drop_it(ptr, len);
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(transparent)]
struct CustomPixel(u16);
impl Add<Self> for CustomPixel {
type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
CustomPixel(self.0 + rhs.0)
}
}
impl num_traits::Zero for CustomPixel {
fn zero() -> Self {
CustomPixel(0)
}
fn is_zero(&self) -> bool {
self.0 == 0
}
}
#[test]
fn test_generic_custom_type() {
let mut arr = ScreenArrayBase::<CustomPixel>::zero(2, 2);
assert_eq!(arr.as_slice(), &[CustomPixel(0); 4]);
arr.drop();
let data = [
CustomPixel(1),
CustomPixel(2),
CustomPixel(3),
CustomPixel(4),
];
let mut arr2 = ScreenArrayBase::<CustomPixel>::new(&data, 2, 2);
let view = arr2.get();
assert_eq!(view[0][1], CustomPixel(2));
assert_eq!(view[1][0], CustomPixel(3));
arr2.drop();
}
}