monolith

//! Dmabuf allocation, rendering, import and fence export. Skips on devices

//! without dmabuf support, such as lavapipe inside the nix sandbox.

use monolith_render_vk::VulkanRenderer;

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,

};

use smithay::utils::{Rectangle, Transform};

const SIZE: i32 = 32;

fn renderer() -> Option<VulkanRenderer> {

    let r = VulkanRenderer::new().expect("no usable Vulkan device");

    if !r.supports_dmabuf() {

        eprintln!("skipping, {} cannot share dmabufs", r.device_name());

        return None;

    }

    Some(r)

}

fn dmabuf(r: &VulkanRenderer) -> Dmabuf {

    let modifiers: Vec<Modifier> = r

        .render_formats()

        .iter()

        .filter(|f| f.code == Fourcc::Argb8888)

        .map(|f| f.modifier)

        .collect();

    r.allocator()

        .create_buffer(SIZE as u32, SIZE as u32, Fourcc::Argb8888, &modifiers)

        .unwrap()

}

fn fill(

    r: &mut VulkanRenderer,

    buf: &mut Dmabuf,

    colour: [f32; 4],

) -> smithay::backend::renderer::sync::SyncPoint {

    let mut target = r.bind(buf).unwrap();

    let mut frame = r

        .render(&mut target, (SIZE, SIZE).into(), Transform::Normal)

        .unwrap();

    frame

        .clear(

            Color32F::from(colour),

            &[Rectangle::from_size((SIZE, SIZE).into())],

        )

        .unwrap();

    frame.finish().unwrap()

}

fn all_rgba(bytes: &[u8], want: [u8; 4]) -> bool {

    bytes.as_chunks::<4>().0.iter().all(|p| *p == want)

}

#[test]

fn samples_an_imported_dmabuf() {

    let Some(mut r) = renderer() else { return };

    let mut buf = dmabuf(&r);

    fill(&mut r, &mut buf, [0.0, 0.0, 1.0, 1.0]).wait().unwrap();

    let texture = r.import_dmabuf(&buf, 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();

    assert!(all_rgba(r.map_texture(&mapping).unwrap(), [0, 0, 255, 255]));

}

#[test]

fn frame_fences_export_as_sync_files() {

    let Some(mut r) = renderer() else { return };

    let mut buf = dmabuf(&r);

    let sync = fill(&mut r, &mut buf, [0.0, 1.0, 0.0, 1.0]);

    assert!(sync.is_exportable());

    let _fd = sync.export();

    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]);

}