Remove bytemuck dependency

Author: madsmtm

Cargo.toml

@@ -34,7 +34,6 @@ wayland-dlopen = ["wayland-sys/dlopen", "winit/wayland-dlopen"]
 # Enable the X11 backend.
 x11 = [
     "dep:as-raw-xcb-connection",
-    "dep:bytemuck",
     "dep:fastrand",
     "dep:rustix",
     "dep:tiny-xlib",
@@ -45,7 +44,7 @@ x11 = [
 x11-dlopen = ["tiny-xlib/dlopen", "x11rb/dl-libxcb"]
 
 # Enable the KMS/DRM backend.
-kms = ["dep:bytemuck", "dep:drm", "dep:rustix"]
+kms = ["dep:drm", "dep:rustix"]
 
 # Common dependencies.
 [dependencies]
@@ -54,13 +53,11 @@ tracing = { version = "0.1.41", default-features = false }
 
 # Android dependencies.
 [target.'cfg(target_os = "android")'.dependencies]
-bytemuck = "1.12.3"
 ndk = "0.9.0"
 
 # Wayland, X11 and KMS/DRM dependencies.
 [target.'cfg(not(any(target_os = "android", target_vendor = "apple", target_os = "redox", target_family = "wasm", target_os = "windows")))'.dependencies]
 # Common
-bytemuck = { version = "1.12.3", optional = true }
 fastrand = { version = "2.0.0", optional = true }
 rustix = { version = "1.0.1", default-features = false, optional = true, features = [
     "fs",

src/backends/kms.rs

@@ -13,8 +13,10 @@ use raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, Raw
 
 use std::collections::HashSet;
 use std::fmt;
+use std::mem::size_of;
 use std::num::NonZeroU32;
 use std::os::unix::io::{AsFd, BorrowedFd};
+use std::slice;
 use std::sync::Arc;
 
 use crate::backend_interface::*;
@@ -316,7 +318,12 @@ impl BufferInterface for BufferImpl<'_> {
 
     #[inline]
     fn pixels_mut(&mut self) -> &mut [u32] {
-        bytemuck::cast_slice_mut(self.mapping.as_mut())
+        let ptr = self.mapping.as_mut_ptr().cast::<u32>();
+        let len = self.mapping.len() / size_of::<u32>();
+        debug_assert_eq!(self.mapping.len() % size_of::<u32>(), 0);
+        // SAFETY: `&mut [u8]` can be reinterpreted as `&mut [u32]`, assuming that the allocation
+        // is aligned to at least a multiple of 4 bytes.
+        unsafe { slice::from_raw_parts_mut(ptr, len) }
     }
 
     #[inline]

src/backends/x11.rs

@@ -21,7 +21,8 @@ use std::{
     collections::HashSet,
     fmt,
     fs::File,
-    io, mem,
+    io,
+    mem::{self, size_of},
     num::{NonZeroU16, NonZeroU32},
     ptr::{null_mut, NonNull},
     slice,
@@ -383,8 +384,15 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> SurfaceInterface<D, W> fo
             .swbuf_err("Failed to fetch image from window")?;
 
         if reply.depth == self.depth && reply.visual == self.visual_id {
-            let mut out = vec![0u32; reply.data.len() / 4];
-            bytemuck::cast_slice_mut::<u32, u8>(&mut out).copy_from_slice(&reply.data);
+            let mut out = vec![0; reply.data.len() / size_of::<u32>()];
+            // SAFETY: `u32` can be re-interpreted as `[u8; 4]`.
+            let out_u8s = unsafe {
+                slice::from_raw_parts_mut(
+                    out.as_mut_ptr().cast::<u8>(),
+                    out.len() * size_of::<u32>(),
+                )
+            };
+            out_u8s.copy_from_slice(&reply.data);
             Ok(out)
         } else {
             Err(SoftBufferError::PlatformError(
@@ -443,6 +451,11 @@ impl BufferInterface for BufferImpl<'_> {
                 // This is a suboptimal strategy, raise a stink in the debug logs.
                 tracing::debug!("Falling back to non-SHM method for window drawing.");
 
+                // SAFETY: `u32` can be re-interpreted as `[u8; 4]`.
+                let data = unsafe {
+                    slice::from_raw_parts(wire.as_ptr().cast::<u8>(), wire.len() * size_of::<u32>())
+                };
+
                 self.connection
                     .put_image(
                         xproto::ImageFormat::Z_PIXMAP,
@@ -454,7 +467,7 @@ impl BufferInterface for BufferImpl<'_> {
                         0,
                         0,
                         self.depth,
-                        bytemuck::cast_slice(wire),
+                        data,
                     )
                     .map(|c| c.ignore_error())
                     .push_err()
@@ -598,7 +611,14 @@ impl ShmBuffer {
                 let buffer_size = seg.buffer_size();
 
                 // SAFETY: No other code should be able to access the segment.
-                bytemuck::cast_slice_mut(unsafe { &mut seg.as_mut()[..buffer_size] })
+                let segment = unsafe { &mut seg.as_mut()[..buffer_size] };
+
+                let ptr = segment.as_mut_ptr().cast::<u32>();
+                let len = segment.len() / size_of::<u32>();
+                debug_assert_eq!(segment.len() % size_of::<u32>(), 0);
+                // SAFETY: The segment buffer is a multiple of `u32`, and we assume that the
+                // memmap allocation is aligned to at least a multiple of 4 bytes.
+                unsafe { slice::from_raw_parts_mut(ptr, len) }
             }
             None => {
                 // Nothing has been allocated yet.