monolith

public

Star0

Fork 0

Watch0

200 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `b03e3b32603a`

tarball

atagen <boss@atagen.co>2026-10-19 07:56 UTC

4 files changed+77-3

render-vk: honour Y_INVERT on imported dmabufs

Clients that render with their origin at the bottom flag the dmabuf as y_inverted, and the renderer sampled such buffers upside down. ImageInner keeps the flag from import and draw_texture mirrors the texture coordinates around the texture.

Modified file: crates/render-vk/src/dmabuf.rs+1

@@ -271,6 +271,7 @@ pub(crate) fn import(

271271 size.1,

272272 usage,

273273 true,

274+ dmabuf.y_inverted(),

274275 )

275276 }

276277

Modified file: crates/render-vk/src/frame.rs+6 additions−1 deletions@@ -179,7 +179,12 @@ impl<'frame, 'buffer> VulkanFrame<'frame, 'buffer> {
         if scissors.is_empty() {
             return Ok(());
         }
-        let uvs = texture_uvs(src, dst.size, texture.size(), src_transform);
+        let mut uvs = texture_uvs(src, dst.size, texture.size(), src_transform);
+        if texture.0.y_inverted {
+            for uv in &mut uvs {
+                uv[1] = 1.0 - uv[1];
+            }
+        }
         let (fb, uv) = to_framebuffer(dst, uvs, self.area, self.transform);
         let (clip, radii, ring) = self.clip_push();
         let push = Push {

Modified file: crates/render-vk/src/image.rs+5 additions−1 deletions@@ -26,6 +26,8 @@ pub(crate) struct ImageInner {
     pub width: u32,
     pub height: u32,
     pub usage: vk::ImageUsageFlags,
+    /// The rows are stored bottom to top, as a dmabuf flagged `Y_INVERT`.
+    pub y_inverted: bool,
     pub layout: Mutex<vk::ImageLayout>,
     /// Shared with other devices or processes through a dmabuf. Every use
     /// acquires the image from the foreign queue family and releases it after.
@@ -118,7 +120,7 @@ impl ImageInner {
             Memory::Imported(m) => (*m, 0),
         };
         Self::finish(
-            shared, image, memory, mem, offset, fourcc, width, height, usage, false,
+            shared, image, memory, mem, offset, fourcc, width, height, usage, false, false,
         )
     }
 
@@ -136,6 +138,7 @@ impl ImageInner {
         height: u32,
         usage: vk::ImageUsageFlags,
         external: bool,
+        y_inverted: bool,
     ) -> Result<Arc<Self>, Error> {
         let fmt = vk_format(fourcc).ok_or(Error::UnsupportedFormat(fourcc))?;
         let d = &shared.device.device;
@@ -149,6 +152,7 @@ impl ImageInner {
             width,
             height,
             usage,
+            y_inverted,
             layout: Mutex::new(if external {
                 vk::ImageLayout::GENERAL
             } else {

Modified file: crates/render-vk/tests/dmabuf.rs+65 additions−1 deletions@@ -2,7 +2,7 @@
 //! without dmabuf support, such as lavapipe inside the nix sandbox.
 
 use monolith_render_vk::VulkanRenderer;
-use smithay::backend::allocator::dmabuf::Dmabuf;
+use smithay::backend::allocator::dmabuf::{Dmabuf, DmabufFlags};
 use smithay::backend::allocator::{Allocator, Fourcc, Modifier};
 use smithay::backend::renderer::{
     Bind, Color32F, ExportMem, Frame, ImportDma, Offscreen, Renderer,
@@ -102,3 +102,67 @@ fn frame_fences_export_as_sync_files() {
     sync.wait().unwrap();
     assert!(sync.is_reached());
 }
+
+#[test]
+fn y_inverted_dmabuf_is_sampled_upside_down() {
+    let Some(mut r) = renderer() else { return };
+    let mut buf = dmabuf(&r);
+    {
+        let mut target = r.bind(&mut buf).unwrap();
+        let mut frame = r
+            .render(&mut target, (SIZE, SIZE).into(), Transform::Normal)
+            .unwrap();
+        let half = SIZE / 2;
+        frame
+            .clear(
+                Color32F::from([1.0, 0.0, 0.0, 1.0]),
+                &[Rectangle::from_size((SIZE, SIZE).into())],
+            )
+            .unwrap();
+        frame
+            .clear(
+                Color32F::from([0.0, 1.0, 0.0, 1.0]),
+                &[Rectangle::new((0, half).into(), (SIZE, half).into())],
+            )
+            .unwrap();
+        frame.finish().unwrap().wait().unwrap();
+    }
+    let mut inverted = Dmabuf::builder_from_buffer(&buf, DmabufFlags::Y_INVERT);
+    for ((fd, offset), stride) in buf.handles().zip(buf.offsets()).zip(buf.strides()) {
+        inverted.add_plane(fd.try_clone_to_owned().unwrap(), offset, stride);
+    }
+    let texture = r.import_dmabuf(&inverted.build().unwrap(), None).unwrap();
+    let mut out = r
+        .create_buffer(Fourcc::Argb8888, (SIZE, SIZE).into())
+        .unwrap();
+    let mut target = r.bind(&mut out).unwrap();
+    {
+        let full = Rectangle::from_size((SIZE, SIZE).into());
+        let mut frame = r
+            .render(&mut target, (SIZE, SIZE).into(), Transform::Normal)
+            .unwrap();
+        frame
+            .render_texture_from_to(
+                &texture,
+                Rectangle::from_size((SIZE as f64, SIZE as f64).into()),
+                full,
+                &[full],
+                &[],
+                Transform::Normal,
+                1.0,
+            )
+            .unwrap();
+        frame.finish().unwrap().wait().unwrap();
+    }
+    let mapping = r
+        .copy_framebuffer(
+            &target,
+            Rectangle::from_size((SIZE, SIZE).into()),
+            Fourcc::Abgr8888,
+        )
+        .unwrap();
+    let pixels = r.map_texture(&mapping).unwrap().as_chunks::<4>().0;
+    let at = |y: i32| pixels[(y * SIZE + SIZE / 2) as usize];
+    assert_eq!(at(1), [0, 255, 0, 255]);
+    assert_eq!(at(SIZE - 2), [255, 0, 0, 255]);
+}

monolith

Commit b03e3b32603a

Commit `b03e3b32603a`