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;

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 renders_into_an_allocated_dmabuf_and_reads_it_back() {

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

    let mut buf = dmabuf(&r);

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

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

    let mapping = r

        .copy_framebuffer(

            &target,

            Rectangle::from_size((SIZE, SIZE).into()),

            Fourcc::Abgr8888,

        )

        .unwrap();

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

}

#[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 imports_are_cached_per_buffer() {

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

    let buf = dmabuf(&r);

    let a = r.import_dmabuf(&buf, None).unwrap();

    let b = r.import_dmabuf(&buf, None).unwrap();

    assert_eq!(format!("{a:?}"), format!("{b:?}"));

}

#[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());

}