BADHACK: Add BufferImpl::stride() getter for Android

examples/winit.rs

@@ -63,7 +63,7 @@ pub(crate) fn run(event_loop: EventLoop<()>) {
                                 let red = x % 255;
                                 let green = y % 255;
                                 let blue = (x * y) % 255;
-                                let index = y as usize * width.get() as usize + x as usize;
+                                let index = y as usize * buffer.stride() as usize + x as usize;
                                 buffer[index] = blue | (green << 8) | (red << 16);
                             }
                         }

src/android.rs

@@ -130,6 +130,12 @@ impl<'a, D: HasDisplayHandle + ?Sized, W: HasWindowHandle> BufferImpl<'a, D, W>
         }
     }
 
+    /// The number of _pixels_ that a line in the buffer takes in memory.
+    #[inline]
+    pub fn stride(&self) -> u32 {
+        self.0.stride() as u32
+    }
+
     pub fn age(&self) -> u8 {
         todo!()
     }

src/kms.rs

@@ -107,6 +107,9 @@ pub(crate) struct BufferImpl<'a, D: ?Sized, W: ?Sized> {
     /// The current size.
     size: (NonZeroU32, NonZeroU32),
 
+    /// The current stride/pitch (length of a single row of pixels) in bytes.
+    stride: NonZeroU32,
+
     /// The display implementation.
     display: &'a KmsDisplayImpl<D>,
 
@@ -244,6 +247,7 @@ impl<D: ?Sized, W: HasWindowHandle> KmsImpl<D, W> {
             .expect("Must set size of surface before calling `buffer_mut()`");
 
         let size = set.size();
+        let stride = set.pitch();
 
         let [first_buffer, second_buffer] = &mut set.buffers;
         let (front_buffer, back_buffer) = if set.first_is_front {
@@ -264,6 +268,7 @@ impl<D: ?Sized, W: HasWindowHandle> KmsImpl<D, W> {
         Ok(BufferImpl {
             mapping,
             size,
+            stride,
             first_is_front: &mut set.first_is_front,
             front_fb,
             crtc_handle: self.crtc.handle(),
@@ -304,6 +309,19 @@ impl<D: ?Sized, W: ?Sized> BufferImpl<'_, D, W> {
         bytemuck::cast_slice_mut(self.mapping.as_mut())
     }
 
+    /// The number of _pixels_ that a line in the buffer takes in memory.
+    #[inline]
+    pub fn stride(&self) -> u32 {
+        // TODO Return NonZeroU32?
+        let bpp: u32 = todo!();
+        assert_eq!(self.stride.get() & bpp, 0);
+        // TODO: Since this may not always be a multiple of BPP, this API should return the size in
+        // bytes... And then the user is left to mess around with `fn pixels()`. We'll need a helper
+        // iterator accessor like:
+        // https://docs.rs/ndk/latest/ndk/native_window/struct.NativeWindowBufferLockGuard.html#method.lines
+        self.stride.get() / bpp
+    }
+
     #[inline]
     pub fn age(&self) -> u8 {
         *self.front_age
@@ -403,11 +421,20 @@ impl SharedBuffer {
             .and_then(|width| NonZeroU32::new(height).map(|height| (width, height)))
             .expect("buffer size is zero")
     }
+
+    pub(crate) fn pitch(&self) -> NonZeroU32 {
+        NonZeroU32::new(self.db.pitch()).expect("Pitch (stride in bytes) is zero")
+    }
 }
 
 impl Buffers {
     /// Get the size of this buffer.
     pub(crate) fn size(&self) -> (NonZeroU32, NonZeroU32) {
         self.buffers[0].size()
     }
+
+    /// Get the pitch (stride) of this buffer.
+    pub(crate) fn pitch(&self) -> NonZeroU32 {
+        self.buffers[0].pitch()
+    }
 }

src/lib.rs

@@ -153,6 +153,15 @@ macro_rules! make_dispatch {
                 }
             }
 
+            pub fn stride(&self) -> u32 {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.stride(),
+                    )*
+                }
+            }
+
             pub fn present(self) -> Result<(), SoftBufferError> {
                 match self {
                     $(
@@ -413,6 +422,11 @@ impl<'a, D: HasDisplayHandle, W: HasWindowHandle> Buffer<'a, D, W> {
         self.buffer_impl.age()
     }
 
+    /// Stride in pixels
+    pub fn stride(&self) -> u32 {
+        self.buffer_impl.stride()
+    }
+
     /// Presents buffer to the window.
     ///
     /// # Platform dependent behavior

src/wayland/mod.rs

@@ -168,6 +168,7 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> WaylandImpl<D, W> {
                 Ok(unsafe { buffer.buffers.as_mut().unwrap().1.mapped_mut() })
             })?,
             age,
+            width: width.get() as u32,
         })
     }
 
@@ -238,6 +239,7 @@ impl<D: ?Sized, W: ?Sized> Drop for WaylandImpl<D, W> {
 pub struct BufferImpl<'a, D: ?Sized, W> {
     stack: util::BorrowStack<'a, WaylandImpl<D, W>, [u32]>,
     age: u8,
+    width: u32,
 }
 
 impl<'a, D: HasDisplayHandle + ?Sized, W: HasWindowHandle> BufferImpl<'a, D, W> {
@@ -255,6 +257,11 @@ impl<'a, D: HasDisplayHandle + ?Sized, W: HasWindowHandle> BufferImpl<'a, D, W>
         self.age
     }
 
+    #[inline]
+    pub fn stride(&self) -> u32 {
+        self.width
+    }
+
     pub fn present_with_damage(self, damage: &[Rect]) -> Result<(), SoftBufferError> {
         self.stack.into_container().present_with_damage(damage)
     }

src/x11.rs

@@ -384,6 +384,16 @@ impl<'a, D: HasDisplayHandle + ?Sized, W: HasWindowHandle + ?Sized> BufferImpl<'
         }
     }
 
+    #[inline]
+    pub fn stride(&self) -> u32 {
+        let (surface_width, _surface_height) = self
+            .0
+            .size
+            .expect("Must set size of surface before calling `present_with_damage()`");
+
+        surface_width.get() as u32
+    }
+
     /// Push the buffer to the window.
     pub fn present_with_damage(self, damage: &[Rect]) -> Result<(), SoftBufferError> {
         let imp = self.0;