wl-shm: add support for more formats

src/gfx_apis/vulkan/bo_allocator.rs

@@ -457,10 +457,7 @@ impl Allocator for VulkanBoAllocator {
 impl VulkanBo {
     fn map(self: &Rc<Self>, write: bool) -> Result<VulkanBoMapping, VulkanError> {
         let format = self.buf.format;
-        let Some(shm_info) = &format.shm_info else {
-            return Err(VulkanError::ShmNotSupported);
-        };
-        let stride = self.buf.width as u32 * shm_info.bpp;
+        let stride = self.buf.width as u32 * format.bpp;
         let size = self.buf.height as u32 * stride;
         let data = &self.allocator;
         let staging =

src/gfx_apis/vulkan/dmabuf_buffer.rs

@@ -1,5 +1,6 @@
 use {
     crate::{
+        format::Format,
         gfx_api::GfxBuffer,
         gfx_apis::vulkan::{VulkanError, device::VulkanDevice},
         utils::on_drop::OnDrop,
@@ -32,8 +33,9 @@ impl VulkanDevice {
         dmabuf: &OwnedFd,
         offset: u64,
         size: u64,
+        format: &'static Format,
     ) -> Result<Rc<VulkanDmabufBuffer>, VulkanError> {
-        if offset % TRANSFER_QUEUE_BUFFER_ALIGNMENT != 0 {
+        if offset % TRANSFER_QUEUE_BUFFER_ALIGNMENT != 0 || offset % format.bpp as u64 != 0 {
             return Err(VulkanError::DmaBufBufferOffsetAlignment);
         }
         let mut memory_fd_properties = MemoryFdPropertiesKHR::default();

src/gfx_apis/vulkan/format.rs

@@ -171,9 +171,6 @@ impl VulkanInstance {
         format: &Format,
         props: &FormatProperties,
     ) -> Result<Option<VulkanInternalFormat>, VulkanError> {
-        if format.shm_info.is_none() {
-            return Ok(None);
-        }
         self.load_internal_format(phy_dev, format, props, SHM_FEATURES, SHM_USAGE)
     }
 

src/gfx_apis/vulkan/renderer.rs

@@ -345,6 +345,7 @@ impl VulkanDevice {
                                 )
                             })
                             .collect(),
+                        supports_shm: vk.shm.is_some(),
                     },
                 )
             })

src/gfx_apis/vulkan/shm_image.rs

@@ -1,7 +1,7 @@
 use {
     crate::{
         cpu_worker::CpuWorker,
-        format::{Format, FormatShmInfo},
+        format::Format,
         gfx_api::SyncFile,
         gfx_apis::vulkan::{
             VulkanError,
@@ -33,7 +33,6 @@ pub struct VulkanShmImage {
     pub(super) size: DeviceSize,
     pub(super) stride: u32,
     pub(super) _allocation: VulkanAllocation,
-    pub(super) shm_info: &'static FormatShmInfo,
     pub(super) async_data: Option<VulkanShmImageAsyncData>,
 }
 
@@ -68,7 +67,7 @@ impl VulkanShmImage {
             if full {
                 builder = builder
                     .buffer_image_height(img.height)
-                    .buffer_row_length(img.stride / self.shm_info.bpp);
+                    .buffer_row_length(img.stride / img.format.bpp);
             }
             builder
         };
@@ -99,7 +98,7 @@ impl VulkanShmImage {
                     damage.width() as u32,
                     damage.height() as u32,
                 ));
-                total_size += damage.width() as u32 * damage.height() as u32 * self.shm_info.bpp;
+                total_size += damage.width() as u32 * damage.height() as u32 * img.format.bpp;
             }
             cpy = &cpy_many[..];
         } else {
@@ -124,7 +123,7 @@ impl VulkanShmImage {
                     let width = cpy.image_extent.width as usize;
                     let height = cpy.image_extent.height as usize;
                     let stride = self.stride as usize;
-                    let bpp = self.shm_info.bpp as usize;
+                    let bpp = img.format.bpp as usize;
                     for dy in 0..height {
                         let lo = (y + dy) * stride + x * bpp;
                         let len = width * bpp;
@@ -367,16 +366,13 @@ impl VulkanRenderer {
         for_download: bool,
         cpu_worker: Option<&Rc<CpuWorker>>,
     ) -> Result<Rc<VulkanImage>, VulkanError> {
-        let Some(shm_info) = &format.shm_info else {
-            return Err(VulkanError::UnsupportedShmFormat(format.name));
-        };
         if width <= 0 || height <= 0 || stride <= 0 {
             return Err(VulkanError::NonPositiveImageSize);
         }
         let width = width as u32;
         let height = height as u32;
         let stride = stride as u32;
-        if stride % shm_info.bpp != 0 || stride / shm_info.bpp < width {
+        if stride % format.bpp != 0 || stride / format.bpp < width {
             return Err(VulkanError::InvalidStride);
         }
         let vk_format = self
@@ -461,7 +457,6 @@ impl VulkanRenderer {
             size,
             stride,
             _allocation: allocation,
-            shm_info,
             async_data,
         };
         destroy_image.forget();

src/gfx_apis/vulkan/transfer.rs

@@ -13,7 +13,7 @@ use {
         gfx_apis::vulkan::{
             VulkanError,
             command::VulkanCommandBuffer,
-            dmabuf_buffer::VulkanDmabufBuffer,
+            dmabuf_buffer::{TRANSFER_QUEUE_BUFFER_ALIGNMENT, VulkanDmabufBuffer},
             fence::VulkanFence,
             image::{QueueFamily, QueueState, QueueTransfer, VulkanImage, VulkanImageMemory},
             renderer::image_barrier,
@@ -227,8 +227,25 @@ impl VulkanShmImage {
         let mut copies_ref = data.regions.borrow_mut();
         let copies = &mut *copies_ref;
         copies.clear();
-        let mut copy = |x, y, width, height| {
-            let buffer_offset = (y as u32 * img.stride + x as u32 * self.shm_info.bpp) as u64;
+        let mut copy = |mut x, mut y, mut width, mut height| {
+            let x_orig = x;
+            let width_orig = width;
+            let mut buffer_offset;
+            loop {
+                buffer_offset = (y as u32 * img.stride + x as u32 * img.format.bpp) as u64;
+                if buffer_offset.is_multiple_of(TRANSFER_QUEUE_BUFFER_ALIGNMENT) {
+                    break;
+                }
+                if x > 0 {
+                    x -= 1;
+                    width += 1;
+                } else {
+                    y -= 1;
+                    height += 1;
+                    x = x_orig;
+                    width = width_orig;
+                }
+            }
             let copy = BufferImageCopy2::default()
                 .buffer_offset(buffer_offset + extra_offset)
                 .image_offset(Offset3D { x, y, z: 0 })
@@ -244,7 +261,7 @@ impl VulkanShmImage {
                     layer_count: 1,
                 })
                 .buffer_image_height(img.height)
-                .buffer_row_length(img.stride / self.shm_info.bpp);
+                .buffer_row_length(img.stride / img.format.bpp);
             copies.push(copy);
         };
         let (width_mask, height_mask) = img.renderer.device.transfer_granularity_mask;
@@ -451,7 +468,7 @@ impl VulkanShmImage {
                 }
                 job.work.width = img.width as _;
                 job.work.stride = img.stride as _;
-                job.work.bpp = self.shm_info.bpp as _;
+                job.work.bpp = img.format.bpp as _;
                 job.work.rects.clear();
                 for copy in copies {
                     job.work.rects.push(
@@ -472,7 +489,7 @@ impl VulkanShmImage {
                 for copy in copies {
                     min_offset = min_offset.min(copy.buffer_offset);
                     let len = img.stride * (copy.image_extent.height - 1)
-                        + copy.image_extent.width * self.shm_info.bpp;
+                        + copy.image_extent.width * img.format.bpp;
                     max_offset = max_offset.max(copy.buffer_offset + len as u64);
                 }
                 let mut job = data.io_job.take().unwrap_or_else(|| {