krun_gtk_display: Support importing and rendering dmabufs

Signed-off-by: Matej Hrica <mhrica@redhat.com>

Author: mtjhrc

examples/krun_gtk_display/src/display_backend.rs

@@ -1,9 +1,11 @@
 use crossbeam_channel::{Receiver, Sender, TrySendError, bounded};
 use gtk::{gdk::MemoryFormat, glib::Bytes};
 use krun_display::{
-    DisplayBackendBasicFramebuffer, DisplayBackendError, DisplayBackendNew, MAX_DISPLAYS, Rect,
-    ResourceFormat,
+    DisplayBackendBasicFramebuffer, DisplayBackendError, DisplayBackendNew,
+    MAX_DISPLAYS, Rect, ResourceFormat,
 };
+#[cfg(target_os = "linux")]
+use krun_display::{DisplayBackendDmabuf, DmabufExport};
 use log::error;
 use std::mem;
 use utils::pollable_channel::PollableChannelSender;
@@ -21,6 +23,15 @@ const _: () = {
 
 #[derive(Debug, Clone)]
 pub enum DisplayEvent {
+    #[cfg(target_os = "linux")]
+    ImportDmabuf {
+        dmabuf_id: u32,
+        dmabuf_export: DmabufExport,
+    },
+    #[cfg(target_os = "linux")]
+    UnrefDmabuf {
+        dmabuf_id: u32,
+    },
     ConfigureScanout {
         scanout_id: u32,
         display_width: u32,
@@ -29,6 +40,14 @@ pub enum DisplayEvent {
         height: u32,
         format: MemoryFormat,
     },
+    #[cfg(target_os = "linux")]
+    ConfigureScanoutDmabuf {
+        scanout_id: u32,
+        display_width: u32,
+        display_height: u32,
+        dmabuf_id: u32,
+        src_rect: Option<Rect>,
+    },
     DisableScanout {
         scanout_id: u32,
     },
@@ -37,24 +56,32 @@ pub enum DisplayEvent {
         buffer: Bytes,
         rect: Option<Rect>,
     },
+    #[cfg(target_os = "linux")]
+    UpdateScanoutDmabuf {
+        scanout_id: u32,
+        rect: Option<Rect>,
+    },
 }
 
 // Implements libkrun traits (callbacks) to provide a display implementation, by forwarding the
 // events to the `DisplayWorker`
 pub struct GtkDisplayBackend {
     channel: PollableChannelSender<DisplayEvent>,
     scanouts: [Option<Scanout>; MAX_DISPLAYS],
+    #[cfg(target_os = "linux")]
+    next_dmabuf_id: u32,
 }
 
 impl DisplayBackendNew<PollableChannelSender<DisplayEvent>> for GtkDisplayBackend {
-    fn new(channel: Option<&PollableChannelSender<DisplayEvent>>) -> Self {
-        let channel = channel
-            .expect("The channel should have been set by GtkDisplayBackend::into_display_backend")
-            .clone();
+    fn new(userdata: Option<&PollableChannelSender<DisplayEvent>>) -> Self {
+        let channel = userdata
+            .expect("The userdata should have been set by GtkDisplayBackend::into_display_backend");
 
         Self {
-            channel,
+            channel: channel.clone(),
             scanouts: Default::default(),
+            #[cfg(target_os = "linux")]
+            next_dmabuf_id: 1,
         }
     }
 }
@@ -89,6 +116,8 @@ impl DisplayBackendBasicFramebuffer for GtkDisplayBackend {
                 buffer_rx,
                 buffer_tx,
                 current_buffer: Vec::new(),
+                #[cfg(target_os = "linux")]
+                has_dmabuf: false,
             });
         }
 
@@ -157,6 +186,76 @@ impl DisplayBackendBasicFramebuffer for GtkDisplayBackend {
     }
 }
 
+#[cfg(target_os = "linux")]
+impl DisplayBackendDmabuf for GtkDisplayBackend {
+    fn import_dmabuf(&mut self, dmabuf_export: &DmabufExport) -> Result<u32, DisplayBackendError> {
+        let dmabuf_id = self.next_dmabuf_id;
+        self.next_dmabuf_id += 1;
+
+        self.channel
+            .send(DisplayEvent::ImportDmabuf {
+                dmabuf_id,
+                dmabuf_export: *dmabuf_export,
+            })
+            .unwrap();
+
+        Ok(dmabuf_id)
+    }
+
+    fn unref_dmabuf(&mut self, dmabuf_id: u32) -> Result<(), DisplayBackendError> {
+        self.channel
+            .send(DisplayEvent::UnrefDmabuf { dmabuf_id })
+            .unwrap();
+
+        Ok(())
+    }
+
+    fn configure_scanout_dmabuf(
+        &mut self,
+        scanout_id: u32,
+        display_width: u32,
+        display_height: u32,
+        dmabuf_id: u32,
+        src_rect: Option<&Rect>,
+    ) -> Result<(), DisplayBackendError> {
+        let Some(scanout) = &mut self.scanouts[scanout_id as usize] else {
+            return Err(DisplayBackendError::InvalidScanoutId);
+        };
+
+        scanout.has_dmabuf = true;
+
+        self.channel
+            .send(DisplayEvent::ConfigureScanoutDmabuf {
+                scanout_id,
+                display_width,
+                display_height,
+                dmabuf_id,
+                src_rect: src_rect.copied(),
+            })
+            .unwrap();
+        Ok(())
+    }
+
+    fn present_dmabuf(
+        &mut self,
+        scanout_id: u32,
+        rect: Option<&Rect>,
+    ) -> Result<(), DisplayBackendError> {
+        if self.scanouts[scanout_id as usize]
+            .as_ref()
+            .is_none_or(|scanout| !scanout.has_dmabuf)
+        {
+            return Err(DisplayBackendError::InvalidScanoutId);
+        };
+
+        let rect = rect.copied();
+        self.channel
+            .send(DisplayEvent::UpdateScanoutDmabuf { scanout_id, rect })
+            .unwrap();
+        Ok(())
+    }
+}
+
 fn resource_format_into_gdk(format: ResourceFormat) -> MemoryFormat {
     match format {
         ResourceFormat::BGRA => MemoryFormat::B8g8r8a8,
@@ -175,6 +274,8 @@ struct Scanout {
     buffer_rx: Receiver<Vec<u8>>,
     required_buffer_size: usize,
     current_buffer: Vec<u8>,
+    #[cfg(target_os = "linux")]
+    has_dmabuf: bool,
 }
 
 impl Scanout {