new workspace

wlx-capture/src/frame.rs

@@ -0,0 +1,184 @@
+use std::{fmt::Display, os::fd::RawFd};
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct FourCC {
+    pub value: u32,
+}
+
+impl PartialEq for FourCC {
+    fn eq(&self, other: &Self) -> bool {
+        self.value == other.value
+    }
+}
+
+impl From<u32> for FourCC {
+    fn from(value: u32) -> Self {
+        Self { value }
+    }
+}
+
+impl From<FourCC> for u32 {
+    fn from(fourcc: FourCC) -> Self {
+        fourcc.value
+    }
+}
+
+impl Display for FourCC {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for i in 0..4 {
+            if let Some(c) = char::from_u32((self.value >> (i * 8)) & 0xFF) {
+                write!(f, "{}", c)?
+            } else {
+                write!(f, "?")?
+            }
+        }
+        Ok(())
+    }
+}
+
+pub const DRM_FORMAT_ARGB8888: u32 = 0x34325241; // AR24
+pub const DRM_FORMAT_ABGR8888: u32 = 0x34324241; // AB24
+pub const DRM_FORMAT_XRGB8888: u32 = 0x34325258; // XR24
+pub const DRM_FORMAT_XBGR8888: u32 = 0x34324258; // XB24
+pub const DRM_FORMAT_ABGR2101010: u32 = 0x30334241; // AB30
+pub const DRM_FORMAT_XBGR2101010: u32 = 0x30334258; // XB30
+
+#[cfg(feature = "egl")]
+#[rustfmt::skip]
+const EGL_DMABUF_PLANE_ATTRS: [isize; 20] = [
+//  FD     Offset Stride ModLo  ModHi
+    0x3272,0x3273,0x3274,0x3443,0x3444,
+    0x3275,0x3276,0x3277,0x3445,0x3446,
+    0x3278,0x3279,0x327A,0x3447,0x3448,
+    0x3440,0x3441,0x3442,0x3449,0x344A,
+];
+
+pub enum WlxFrame {
+    Dmabuf(DmabufFrame),
+    MemFd(MemFdFrame),
+    MemPtr(MemPtrFrame),
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub enum Transform {
+    #[default]
+    Undefined,
+    Normal,
+    Rotated90,
+    Rotated180,
+    Rotated270,
+    Flipped,
+    Flipped90,
+    Flipped180,
+    Flipped270,
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct FrameFormat {
+    pub width: u32,
+    pub height: u32,
+    pub fourcc: FourCC,
+    pub modifier: u64,
+    pub transform: Transform,
+}
+
+impl FrameFormat {
+    pub fn get_mod_hi(&self) -> u32 {
+        (self.modifier >> 32) as _
+    }
+    pub fn get_mod_lo(&self) -> u32 {
+        (self.modifier & 0xFFFFFFFF) as _
+    }
+    pub fn set_mod(&mut self, mod_hi: u32, mod_low: u32) {
+        self.modifier = ((mod_hi as u64) << 32) + mod_low as u64;
+    }
+}
+
+#[derive(Clone, Copy, Default)]
+pub struct FramePlane {
+    pub fd: Option<RawFd>,
+    pub offset: u32,
+    pub stride: i32,
+}
+
+#[derive(Default, Clone)]
+pub struct DrmFormat {
+    pub fourcc: FourCC,
+    pub modifiers: Vec<u64>,
+}
+
+#[derive(Default)]
+pub struct DmabufFrame {
+    pub format: FrameFormat,
+    pub num_planes: usize,
+    pub planes: [FramePlane; 4],
+    pub mouse: Option<MouseMeta>,
+}
+
+impl DmabufFrame {
+    #[cfg(feature = "egl")]
+    /// Get the attributes for creating an EGLImage.
+    /// Pacics if fd is None; check using `is_valid` first.
+    pub fn get_egl_image_attribs(&self) -> Vec<isize> {
+        let mut vec: Vec<isize> = vec![
+            0x3057, // WIDTH
+            self.format.width as _,
+            0x3056, // HEIGHT
+            self.format.height as _,
+            0x3271, // LINUX_DRM_FOURCC_EXT,
+            self.format.fourcc.value as _,
+        ];
+
+        for i in 0..self.num_planes {
+            let mut a = i * 5usize;
+            vec.push(EGL_DMABUF_PLANE_ATTRS[a]);
+            vec.push(self.planes[i].fd.unwrap() as _); // safe to unwrap due to contract
+            a += 1;
+            vec.push(EGL_DMABUF_PLANE_ATTRS[a]);
+            vec.push(self.planes[i].offset as _);
+            a += 1;
+            vec.push(EGL_DMABUF_PLANE_ATTRS[a]);
+            vec.push(self.planes[i].stride as _);
+            a += 1;
+            vec.push(EGL_DMABUF_PLANE_ATTRS[a]);
+            vec.push(self.format.get_mod_lo() as _);
+            a += 1;
+            vec.push(EGL_DMABUF_PLANE_ATTRS[a]);
+            vec.push(self.format.get_mod_hi() as _);
+        }
+        vec.push(0x3038); // NONE
+
+        vec
+    }
+
+    /// Returns true if all planes have a valid file descriptor.
+    pub fn is_valid(&self) -> bool {
+        for i in 0..self.num_planes {
+            if self.planes[i].fd.is_none() {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+#[derive(Default)]
+pub struct MemFdFrame {
+    pub format: FrameFormat,
+    pub plane: FramePlane,
+    pub mouse: Option<MouseMeta>,
+}
+
+#[derive(Default)]
+pub struct MemPtrFrame {
+    pub format: FrameFormat,
+    pub ptr: usize,
+    pub size: usize,
+    pub mouse: Option<MouseMeta>,
+}
+
+#[derive(Default, Clone)]
+pub struct MouseMeta {
+    pub x: f32,
+    pub y: f32,
+}

wlx-capture/src/lib.rs

@@ -0,0 +1,35 @@
+#![allow(dead_code)]
+
+use frame::{DrmFormat, WlxFrame};
+
+pub mod frame;
+
+#[cfg(feature = "wayland")]
+pub mod wayland;
+
+#[cfg(feature = "wlr")]
+pub mod wlr_dmabuf;
+
+#[cfg(feature = "wlr")]
+pub mod wlr_screencopy;
+
+#[cfg(feature = "pipewire")]
+pub mod pipewire;
+
+#[cfg(feature = "xshm")]
+pub mod xshm;
+
+pub trait WlxCapture<U, R> {
+    fn init(
+        &mut self,
+        dmabuf_formats: &[DrmFormat],
+        user_data: U,
+        callback: fn(&U, WlxFrame) -> Option<R>,
+    );
+    fn is_ready(&self) -> bool;
+    fn supports_dmbuf(&self) -> bool;
+    fn receive(&mut self) -> Option<R>;
+    fn pause(&mut self);
+    fn resume(&mut self);
+    fn request_new_frame(&mut self);
+}

wlx-capture/src/pipewire.rs

@@ -0,0 +1,699 @@
+use std::any::Any;
+use std::sync::atomic::AtomicU32;
+use std::sync::atomic::Ordering;
+use std::sync::mpsc;
+use std::sync::Arc;
+use std::thread::JoinHandle;
+
+use ashpd::desktop::{
+    screencast::{CursorMode, Screencast, SourceType},
+    PersistMode,
+};
+
+pub use ashpd::Error as AshpdError;
+
+use pipewire as pw;
+use pw::spa;
+
+use pw::properties::properties;
+use pw::stream::{Stream, StreamFlags};
+use pw::{context::Context, main_loop::MainLoop, Error};
+use spa::buffer::DataType;
+use spa::buffer::MetaData;
+use spa::buffer::MetaType;
+use spa::param::video::VideoFormat;
+use spa::param::video::VideoInfoRaw;
+use spa::param::ParamType;
+use spa::pod::serialize::GenError;
+use spa::pod::ChoiceValue;
+use spa::pod::Pod;
+use spa::pod::{Object, Property, PropertyFlags, Value};
+use spa::utils::Choice;
+use spa::utils::ChoiceEnum;
+use spa::utils::ChoiceFlags;
+
+use crate::frame::DrmFormat;
+use crate::frame::FourCC;
+use crate::frame::FrameFormat;
+use crate::frame::MouseMeta;
+use crate::frame::Transform;
+use crate::frame::WlxFrame;
+use crate::frame::DRM_FORMAT_ABGR2101010;
+use crate::frame::DRM_FORMAT_ABGR8888;
+use crate::frame::DRM_FORMAT_ARGB8888;
+use crate::frame::DRM_FORMAT_XBGR2101010;
+use crate::frame::DRM_FORMAT_XBGR8888;
+use crate::frame::DRM_FORMAT_XRGB8888;
+use crate::frame::{DmabufFrame, FramePlane, MemFdFrame, MemPtrFrame};
+use crate::WlxCapture;
+
+pub struct PipewireStream {
+    pub node_id: u32,
+    pub position: Option<(i32, i32)>,
+    pub size: Option<(i32, i32)>,
+}
+
+pub struct PipewireSelectScreenResult {
+    pub streams: Vec<PipewireStream>,
+    pub restore_token: Option<String>,
+}
+
+pub async fn pipewire_select_screen(
+    token: Option<&str>,
+    embed_mouse: bool,
+    screens_only: bool,
+    persist: bool,
+    multiple: bool,
+) -> Result<PipewireSelectScreenResult, AshpdError> {
+    static CURSOR_MODES: AtomicU32 = AtomicU32::new(0);
+
+    let proxy = Screencast::new().await?;
+    let session = proxy.create_session().await?;
+
+    let mut cursor_modes = CURSOR_MODES.load(Ordering::Relaxed);
+    if cursor_modes == 0 {
+        cursor_modes = proxy.get_property::<u32>("AvailableCursorModes").await?;
+
+        log::debug!("Available cursor modes: {cursor_modes:#x}");
+
+        // propery will be same system-wide, so race condition not a concern
+        CURSOR_MODES.store(cursor_modes, Ordering::Relaxed);
+    }
+
+    let cursor_mode = match embed_mouse {
+        true if cursor_modes & (CursorMode::Embedded as u32) != 0 => CursorMode::Embedded,
+        _ if cursor_modes & (CursorMode::Metadata as u32) != 0 => CursorMode::Metadata,
+        _ => CursorMode::Hidden,
+    };
+
+    log::debug!("Selected cursor mode: {cursor_mode:?}");
+
+    let source_type = if screens_only {
+        SourceType::Monitor.into()
+    } else {
+        SourceType::Monitor | SourceType::Window | SourceType::Virtual
+    };
+
+    let persist_mode = if persist {
+        PersistMode::ExplicitlyRevoked
+    } else {
+        PersistMode::DoNot
+    };
+
+    proxy
+        .select_sources(
+            &session,
+            cursor_mode,
+            source_type,
+            multiple,
+            token,
+            persist_mode,
+        )
+        .await?;
+
+    let response = proxy.start(&session, None).await?.response()?;
+
+    let streams: Vec<_> = response
+        .streams()
+        .iter()
+        .map(|stream| PipewireStream {
+            node_id: stream.pipe_wire_node_id(),
+            position: stream.position(),
+            size: stream.size(),
+        })
+        .collect();
+    if !streams.is_empty() {
+        return Ok(PipewireSelectScreenResult {
+            streams,
+            restore_token: response.restore_token().map(String::from),
+        });
+    }
+
+    Err(ashpd::Error::NoResponse)
+}
+
+#[derive(Default)]
+struct StreamData {
+    format: Option<FrameFormat>,
+    stream: Option<Stream>,
+}
+
+pub enum PwChangeRequest {
+    Pause,
+    Resume,
+    Stop,
+}
+
+struct CaptureData<R>
+where
+    R: Any + Send,
+{
+    tx_ctrl: pw::channel::Sender<PwChangeRequest>,
+    rx_frame: mpsc::Receiver<R>,
+}
+
+pub struct PipewireCapture<R>
+where
+    R: Any + Send,
+{
+    name: Arc<str>,
+    data: Option<CaptureData<R>>,
+    node_id: u32,
+    handle: Option<JoinHandle<Result<(), Error>>>,
+}
+
+impl<R> PipewireCapture<R>
+where
+    R: Any + Send,
+{
+    pub fn new(name: Arc<str>, node_id: u32) -> Self {
+        PipewireCapture {
+            name,
+            data: None,
+            node_id,
+            handle: None,
+        }
+    }
+}
+
+impl<R> Drop for PipewireCapture<R>
+where
+    R: Any + Send,
+{
+    fn drop(&mut self) {
+        if let Some(data) = &self.data {
+            let _ = data.tx_ctrl.send(PwChangeRequest::Stop);
+        }
+        if let Some(handle) = self.handle.take() {
+            let _ = handle.join();
+        }
+    }
+}
+
+impl<U, R> WlxCapture<U, R> for PipewireCapture<R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    fn init(
+        &mut self,
+        dmabuf_formats: &[DrmFormat],
+        user_data: U,
+        receive_callback: fn(&U, WlxFrame) -> Option<R>,
+    ) {
+        let (tx_frame, rx_frame) = mpsc::sync_channel(2);
+        let (tx_ctrl, rx_ctrl) = pw::channel::channel();
+
+        self.data = Some(CaptureData { tx_ctrl, rx_frame });
+
+        self.handle = Some(std::thread::spawn({
+            let name = self.name.clone();
+            let node_id = self.node_id;
+            let formats = dmabuf_formats.to_vec();
+
+            move || {
+                main_loop::<U, R>(
+                    name,
+                    node_id,
+                    formats,
+                    tx_frame,
+                    rx_ctrl,
+                    user_data,
+                    receive_callback,
+                )
+            }
+        }));
+    }
+    fn is_ready(&self) -> bool {
+        self.data.is_some()
+    }
+    fn supports_dmbuf(&self) -> bool {
+        true
+    }
+    fn receive(&mut self) -> Option<R> {
+        if let Some(data) = self.data.as_ref() {
+            return data.rx_frame.try_iter().last();
+        }
+        None
+    }
+    fn pause(&mut self) {
+        if let Some(data) = &self.data {
+            match data.tx_ctrl.send(PwChangeRequest::Pause) {
+                Ok(_) => (),
+                Err(_) => {
+                    log::warn!("{}: disconnected, stopping stream", &self.name);
+                }
+            }
+        }
+    }
+    fn resume(&mut self) {
+        if let Some(data) = &self.data {
+            match data.tx_ctrl.send(PwChangeRequest::Resume) {
+                Ok(_) => {
+                    log::debug!(
+                        "{}: dropped {} old frames before resuming",
+                        &self.name,
+                        data.rx_frame.try_iter().count()
+                    );
+                }
+                Err(_) => {
+                    log::warn!("{}: disconnected, stopping stream", &self.name);
+                }
+            }
+        }
+    }
+    fn request_new_frame(&mut self) {}
+}
+
+fn main_loop<U, R>(
+    name: Arc<str>,
+    node_id: u32,
+    dmabuf_formats: Vec<DrmFormat>,
+    sender: mpsc::SyncSender<R>,
+    receiver: pw::channel::Receiver<PwChangeRequest>,
+    user_data: U,
+    receive_callback: fn(&U, WlxFrame) -> Option<R>,
+) -> Result<(), Error>
+where
+    U: Any,
+    R: Any,
+{
+    let main_loop = MainLoop::new(None)?;
+    let context = Context::new(&main_loop)?;
+    let core = context.connect(None)?;
+
+    let stream = Stream::new(
+        &core,
+        &name,
+        properties! {
+            *pw::keys::MEDIA_TYPE => "Video",
+            *pw::keys::MEDIA_CATEGORY => "Capture",
+            *pw::keys::MEDIA_ROLE => "Screen",
+        },
+    )?;
+
+    let _listener = stream
+        .add_local_listener_with_user_data(FrameFormat::default())
+        .state_changed({
+            let name = name.clone();
+            move |_, _, old, new| {
+                log::info!("{}: stream state changed: {:?} -> {:?}", &name, old, new);
+            }
+        })
+        .param_changed({
+            let name = name.clone();
+            move |stream, format, id, param| {
+                let Some(param) = param else {
+                    return;
+                };
+                if id != ParamType::Format.as_raw() {
+                    return;
+                }
+
+                let mut info = VideoInfoRaw::default();
+                info.parse(param)
+                    .expect("Failed to parse param changed to VideoInfoRaw");
+
+                format.width = info.size().width;
+                format.height = info.size().height;
+                format.fourcc = spa_to_fourcc(info.format());
+                format.modifier = info.modifier();
+
+                let kind = if format.modifier != 0 {
+                    "DMA-buf"
+                } else {
+                    "SHM"
+                };
+
+                log::info!("{}: got {} video format:", &name, &kind);
+                log::info!("  format: {} ({:?})", info.format().as_raw(), info.format());
+                log::info!("  size: {}x{}", info.size().width, info.size().height);
+                log::info!("  modifier: {}", info.modifier());
+                let Ok(params_bytes) = obj_to_bytes(get_buffer_params()) else {
+                    log::warn!("{}: failed to serialize buffer params", &name);
+                    return;
+                };
+                let Some(params_pod) = Pod::from_bytes(&params_bytes) else {
+                    log::warn!("{}: failed to deserialize buffer params", &name);
+                    return;
+                };
+
+                let header_bytes = obj_to_bytes(get_meta_object(
+                    spa::sys::SPA_META_Header,
+                    std::mem::size_of::<spa::sys::spa_meta_header>(),
+                ))
+                .unwrap(); // want panic
+                let header_pod = Pod::from_bytes(&header_bytes).unwrap(); // want panic
+
+                let xform_bytes = obj_to_bytes(get_meta_object(
+                    spa::sys::SPA_META_VideoTransform,
+                    std::mem::size_of::<spa::sys::spa_meta_videotransform>(),
+                ))
+                .unwrap(); // want panic
+                let xform_pod = Pod::from_bytes(&xform_bytes).unwrap(); // want panic
+
+                let mut pods = [params_pod, header_pod, xform_pod];
+                if let Err(e) = stream.update_params(&mut pods) {
+                    log::error!("{}: failed to update params: {}", &name, e);
+                }
+            }
+        })
+        .process({
+            let name = name.clone();
+            let u = user_data;
+            move |stream, format| {
+                let mut maybe_buffer = None;
+                // discard all but the newest frame
+                while let Some(buffer) = stream.dequeue_buffer() {
+                    maybe_buffer = Some(buffer);
+                }
+
+                if let Some(mut buffer) = maybe_buffer {
+                    if let MetaData::Header(header) = buffer.find_meta_data(MetaType::Header) {
+                        if header.flags & spa::sys::SPA_META_HEADER_FLAG_CORRUPTED != 0 {
+                            log::warn!("{}: PipeWire buffer is corrupt.", &name);
+                            return;
+                        }
+                    }
+
+                    if let MetaData::VideoTransform(transform) =
+                        buffer.find_meta_data(MetaType::VideoTransform)
+                    {
+                        format.transform = match transform.transform {
+                            spa::sys::SPA_META_TRANSFORMATION_None => Transform::Normal,
+                            spa::sys::SPA_META_TRANSFORMATION_90 => Transform::Rotated90,
+                            spa::sys::SPA_META_TRANSFORMATION_180 => Transform::Rotated180,
+                            spa::sys::SPA_META_TRANSFORMATION_270 => Transform::Rotated270,
+                            spa::sys::SPA_META_TRANSFORMATION_Flipped => Transform::Flipped,
+                            spa::sys::SPA_META_TRANSFORMATION_Flipped90 => Transform::Flipped90,
+                            spa::sys::SPA_META_TRANSFORMATION_Flipped180 => Transform::Flipped180,
+                            spa::sys::SPA_META_TRANSFORMATION_Flipped270 => Transform::Flipped270,
+                            _ => Transform::Undefined,
+                        };
+                        log::debug!("{}: Transform: {:?}", &name, &format.transform);
+                    }
+
+                    let mouse_meta = match buffer.find_meta_data(MetaType::Cursor) {
+                        MetaData::Cursor(cursor) if cursor.id != 0 => Some(MouseMeta {
+                            x: cursor.position.x as f32 / format.width as f32,
+                            y: cursor.position.y as f32 / format.height as f32,
+                        }),
+                        _ => None,
+                    };
+
+                    let datas = buffer.datas_mut();
+                    if datas.is_empty() {
+                        log::debug!("{}: no data", &name);
+                        return;
+                    }
+
+                    let planes: Vec<FramePlane> = datas
+                        .iter()
+                        .map(|p| FramePlane {
+                            fd: Some(p.as_raw().fd as _),
+                            offset: p.chunk().offset(),
+                            stride: p.chunk().stride(),
+                        })
+                        .collect();
+
+                    match datas[0].type_() {
+                        DataType::DmaBuf => {
+                            let mut dmabuf = DmabufFrame {
+                                format: *format,
+                                num_planes: planes.len(),
+                                mouse: mouse_meta,
+                                ..Default::default()
+                            };
+                            dmabuf.planes[..planes.len()].copy_from_slice(&planes[..planes.len()]);
+
+                            let frame = WlxFrame::Dmabuf(dmabuf);
+
+                            if let Some(r) = receive_callback(&u, frame) {
+                                match sender.try_send(r) {
+                                    Ok(_) => (),
+                                    Err(mpsc::TrySendError::Full(_)) => (),
+                                    Err(mpsc::TrySendError::Disconnected(_)) => {
+                                        log::warn!("{}: disconnected, stopping stream", &name);
+                                        let _ = stream.disconnect();
+                                    }
+                                }
+                            }
+                        }
+                        DataType::MemFd => {
+                            let memfd = MemFdFrame {
+                                format: *format,
+                                plane: FramePlane {
+                                    fd: Some(datas[0].as_raw().fd as _),
+                                    offset: datas[0].chunk().offset(),
+                                    stride: datas[0].chunk().stride(),
+                                },
+                                mouse: mouse_meta,
+                            };
+
+                            let frame = WlxFrame::MemFd(memfd);
+                            if let Some(r) = receive_callback(&u, frame) {
+                                match sender.try_send(r) {
+                                    Ok(_) => (),
+                                    Err(mpsc::TrySendError::Full(_)) => (),
+                                    Err(mpsc::TrySendError::Disconnected(_)) => {
+                                        log::warn!("{}: disconnected, stopping stream", &name);
+                                        let _ = stream.disconnect();
+                                    }
+                                }
+                            }
+                        }
+                        DataType::MemPtr => {
+                            let memptr = MemPtrFrame {
+                                format: *format,
+                                ptr: datas[0].as_raw().data as _,
+                                size: datas[0].chunk().size() as _,
+                                mouse: mouse_meta,
+                            };
+
+                            let frame = WlxFrame::MemPtr(memptr);
+                            if let Some(r) = receive_callback(&u, frame) {
+                                match sender.try_send(r) {
+                                    Ok(_) => (),
+                                    Err(mpsc::TrySendError::Full(_)) => (),
+                                    Err(mpsc::TrySendError::Disconnected(_)) => {
+                                        log::warn!("{}: disconnected, stopping stream", &name);
+                                        let _ = stream.disconnect();
+                                    }
+                                }
+                            }
+                        }
+                        _ => {
+                            log::error!("Received invalid frame data type ({:?})", datas[0].type_())
+                        }
+                    }
+                }
+            }
+        })
+        .register()?;
+
+    let mut format_params: Vec<Vec<u8>> = dmabuf_formats
+        .iter()
+        .filter_map(|f| obj_to_bytes(get_format_params(Some(f))).ok())
+        .collect();
+
+    format_params.push(obj_to_bytes(get_format_params(None)).unwrap()); // safe unwrap: known
+                                                                        // good values
+
+    let mut params: Vec<&Pod> = format_params
+        .iter()
+        .filter_map(|bytes| Pod::from_bytes(bytes))
+        .collect();
+
+    stream.connect(
+        spa::utils::Direction::Input,
+        Some(node_id),
+        StreamFlags::AUTOCONNECT | StreamFlags::MAP_BUFFERS,
+        params.as_mut_slice(),
+    )?;
+
+    let _receiver = receiver.attach(main_loop.loop_(), {
+        let name = name.clone();
+        let main_loop = main_loop.clone();
+        move |req| match req {
+            PwChangeRequest::Pause => {
+                let _ = stream.set_active(false);
+            }
+            PwChangeRequest::Resume => {
+                let _ = stream.set_active(true);
+            }
+            PwChangeRequest::Stop => {
+                main_loop.quit();
+                log::info!("{}: stopping pipewire loop", &name);
+            }
+        }
+    });
+
+    main_loop.run();
+    log::info!("{}: pipewire loop exited", &name);
+    Ok::<(), Error>(())
+}
+
+fn obj_to_bytes(obj: spa::pod::Object) -> Result<Vec<u8>, GenError> {
+    Ok(spa::pod::serialize::PodSerializer::serialize(
+        std::io::Cursor::new(Vec::new()),
+        &spa::pod::Value::Object(obj),
+    )?
+    .0
+    .into_inner())
+}
+
+fn get_buffer_params() -> Object {
+    let data_types = (1 << DataType::MemFd.as_raw())
+        | (1 << DataType::MemPtr.as_raw())
+        | (1 << DataType::DmaBuf.as_raw());
+
+    let property = Property {
+        key: spa::sys::SPA_PARAM_BUFFERS_dataType,
+        flags: PropertyFlags::empty(),
+        value: Value::Int(data_types),
+    };
+
+    spa::pod::object!(
+        spa::utils::SpaTypes::ObjectParamBuffers,
+        spa::param::ParamType::Buffers,
+        property,
+    )
+}
+
+fn get_meta_object(key: u32, size: usize) -> Object {
+    let meta_type_property = Property {
+        key: spa::sys::SPA_PARAM_META_type,
+        flags: PropertyFlags::empty(),
+        value: Value::Id(spa::utils::Id(key)),
+    };
+
+    let meta_size_property = Property {
+        key: spa::sys::SPA_PARAM_META_size,
+        flags: PropertyFlags::empty(),
+        value: Value::Int(size as i32),
+    };
+
+    spa::pod::object!(
+        spa::utils::SpaTypes::ObjectParamMeta,
+        spa::param::ParamType::Meta,
+        meta_type_property,
+        meta_size_property,
+    )
+}
+
+fn get_format_params(fmt: Option<&DrmFormat>) -> Object {
+    let mut obj = spa::pod::object!(
+        spa::utils::SpaTypes::ObjectParamFormat,
+        spa::param::ParamType::EnumFormat,
+        spa::pod::property!(
+            spa::param::format::FormatProperties::MediaType,
+            Id,
+            spa::param::format::MediaType::Video
+        ),
+        spa::pod::property!(
+            spa::param::format::FormatProperties::MediaSubtype,
+            Id,
+            spa::param::format::MediaSubtype::Raw
+        ),
+        spa::pod::property!(
+            spa::param::format::FormatProperties::VideoSize,
+            Choice,
+            Range,
+            Rectangle,
+            spa::utils::Rectangle {
+                width: 256,
+                height: 256,
+            },
+            spa::utils::Rectangle {
+                width: 1,
+                height: 1,
+            },
+            spa::utils::Rectangle {
+                width: 8192,
+                height: 8192,
+            }
+        ),
+        spa::pod::property!(
+            spa::param::format::FormatProperties::VideoFramerate,
+            Choice,
+            Range,
+            Fraction,
+            spa::utils::Fraction { num: 0, denom: 1 },
+            spa::utils::Fraction { num: 0, denom: 1 },
+            spa::utils::Fraction {
+                num: 1000,
+                denom: 1
+            }
+        ),
+    );
+
+    if let Some(fmt) = fmt {
+        let spa_fmt = fourcc_to_spa(fmt.fourcc);
+
+        let prop = spa::pod::property!(
+            spa::param::format::FormatProperties::VideoFormat,
+            Choice,
+            Enum,
+            Id,
+            spa_fmt,
+            spa_fmt,
+        );
+        obj.properties.push(prop);
+
+        // TODO rewrite when property macro supports Long
+        let prop = Property {
+            key: spa::param::format::FormatProperties::VideoModifier.as_raw(),
+            flags: PropertyFlags::MANDATORY | PropertyFlags::DONT_FIXATE,
+            value: Value::Choice(ChoiceValue::Long(Choice(
+                ChoiceFlags::empty(),
+                ChoiceEnum::Enum {
+                    default: fmt.modifiers[0] as _,
+                    alternatives: fmt.modifiers.iter().map(|m| *m as _).collect(),
+                },
+            ))),
+        };
+        obj.properties.push(prop);
+    } else {
+        let prop = spa::pod::property!(
+            spa::param::format::FormatProperties::VideoFormat,
+            Choice,
+            Enum,
+            Id,
+            spa::param::video::VideoFormat::RGBA,
+            spa::param::video::VideoFormat::RGBA,
+            spa::param::video::VideoFormat::BGRA,
+            spa::param::video::VideoFormat::RGBx,
+            spa::param::video::VideoFormat::BGRx,
+            spa::param::video::VideoFormat::ABGR_210LE,
+            spa::param::video::VideoFormat::xBGR_210LE,
+        );
+        obj.properties.push(prop);
+    }
+
+    obj
+}
+
+fn fourcc_to_spa(fourcc: FourCC) -> VideoFormat {
+    match fourcc.value {
+        DRM_FORMAT_ARGB8888 => VideoFormat::BGRA,
+        DRM_FORMAT_ABGR8888 => VideoFormat::RGBA,
+        DRM_FORMAT_XRGB8888 => VideoFormat::BGRx,
+        DRM_FORMAT_XBGR8888 => VideoFormat::RGBx,
+        DRM_FORMAT_ABGR2101010 => VideoFormat::ABGR_210LE,
+        DRM_FORMAT_XBGR2101010 => VideoFormat::xBGR_210LE,
+        _ => panic!("Unsupported format"),
+    }
+}
+
+#[allow(non_upper_case_globals)]
+fn spa_to_fourcc(spa: VideoFormat) -> FourCC {
+    match spa {
+        VideoFormat::BGRA => DRM_FORMAT_ARGB8888.into(),
+        VideoFormat::RGBA => DRM_FORMAT_ABGR8888.into(),
+        VideoFormat::BGRx => DRM_FORMAT_XRGB8888.into(),
+        VideoFormat::RGBx => DRM_FORMAT_XBGR8888.into(),
+        VideoFormat::ABGR_210LE => DRM_FORMAT_ABGR2101010.into(),
+        VideoFormat::xBGR_210LE => DRM_FORMAT_XBGR2101010.into(),
+        _ => panic!("Unsupported format"),
+    }
+}

wlx-capture/src/wayland.rs

@@ -0,0 +1,428 @@
+use std::{
+    collections::VecDeque,
+    sync::{Arc, Mutex},
+};
+
+use idmap::IdMap;
+use log::debug;
+
+use smithay_client_toolkit::reexports::{
+    protocols::xdg::xdg_output::zv1::client::{
+        zxdg_output_manager_v1::ZxdgOutputManagerV1,
+        zxdg_output_v1::{self, ZxdgOutputV1},
+    },
+    protocols_wlr::{
+        export_dmabuf::v1::client::zwlr_export_dmabuf_manager_v1::ZwlrExportDmabufManagerV1,
+        screencopy::v1::client::zwlr_screencopy_manager_v1::ZwlrScreencopyManagerV1,
+    },
+};
+
+pub use wayland_client;
+use wayland_client::{
+    backend::WaylandError,
+    globals::{registry_queue_init, GlobalList, GlobalListContents},
+    protocol::{
+        wl_output::{self, Transform, WlOutput},
+        wl_registry::{self, WlRegistry},
+        wl_seat::WlSeat,
+        wl_shm::WlShm,
+    },
+    Connection, Dispatch, EventQueue, Proxy, QueueHandle,
+};
+
+pub enum OutputChangeEvent {
+    /// New output has been created.
+    Create(u32),
+    /// Logical position or size has changed, but no changes required in terms of rendering.
+    Logical(u32),
+    /// Resolution or transform has changed, textures need to be recreated.
+    Physical(u32),
+    /// Output has been destroyed.
+    Destroy(u32),
+}
+
+pub struct WlxOutput {
+    pub wl_output: WlOutput,
+    pub id: u32,
+    pub name: Arc<str>,
+    pub make: Arc<str>,
+    pub model: Arc<str>,
+    pub size: (i32, i32),
+    pub logical_pos: (i32, i32),
+    pub logical_size: (i32, i32),
+    pub transform: Transform,
+    done: bool,
+}
+
+pub struct WlxClient {
+    pub connection: Arc<Connection>,
+    pub xdg_output_mgr: ZxdgOutputManagerV1,
+    pub maybe_wlr_dmabuf_mgr: Option<ZwlrExportDmabufManagerV1>,
+    pub maybe_wlr_screencopy_mgr: Option<ZwlrScreencopyManagerV1>,
+    pub wl_seat: WlSeat,
+    pub wl_shm: WlShm,
+    pub outputs: IdMap<u32, WlxOutput>,
+    pub queue: Arc<Mutex<EventQueue<Self>>>,
+    pub globals: GlobalList,
+    pub queue_handle: QueueHandle<Self>,
+    default_output_name: Arc<str>,
+    events: VecDeque<OutputChangeEvent>,
+}
+
+impl WlxClient {
+    pub fn new() -> Option<Self> {
+        let connection = Connection::connect_to_env()
+            .inspect_err(|e| log::info!("Wayland connection: {e:?}"))
+            .ok()?;
+        let (globals, queue) = registry_queue_init::<Self>(&connection)
+            .inspect_err(|e| log::info!("Wayland queue init: {e:?}"))
+            .ok()?;
+        let qh = queue.handle();
+
+        let mut state = Self {
+            connection: Arc::new(connection),
+            xdg_output_mgr: globals
+                .bind(&qh, 2..=3, ())
+                .expect(ZxdgOutputManagerV1::interface().name),
+            wl_seat: globals
+                .bind(&qh, 4..=9, ())
+                .expect(WlSeat::interface().name),
+            wl_shm: globals.bind(&qh, 1..=1, ()).expect(WlShm::interface().name),
+            maybe_wlr_dmabuf_mgr: globals.bind(&qh, 1..=1, ()).ok(),
+            maybe_wlr_screencopy_mgr: globals.bind(&qh, 2..=2, ()).ok(),
+            outputs: IdMap::new(),
+            queue: Arc::new(Mutex::new(queue)),
+            globals,
+            queue_handle: qh,
+            default_output_name: "Unknown".into(),
+            events: VecDeque::new(),
+        };
+
+        for o in state.globals.contents().clone_list().iter() {
+            if o.interface == WlOutput::interface().name {
+                state.add_output(o.name, o.version);
+            }
+        }
+
+        state.dispatch();
+
+        Some(state)
+    }
+
+    fn add_output(&mut self, name: u32, version: u32) {
+        let wl_output: WlOutput =
+            self.globals
+                .registry()
+                .bind(name, version, &self.queue_handle, name);
+        self.xdg_output_mgr
+            .get_xdg_output(&wl_output, &self.queue_handle, name);
+        let output = WlxOutput {
+            wl_output,
+            id: name,
+            name: self.default_output_name.clone(),
+            make: self.default_output_name.clone(),
+            model: self.default_output_name.clone(),
+            size: (0, 0),
+            logical_pos: (0, 0),
+            logical_size: (0, 0),
+            transform: Transform::Normal,
+            done: false,
+        };
+
+        self.outputs.insert(name, output);
+    }
+
+    pub fn get_desktop_origin(&self) -> (i32, i32) {
+        let mut origin = (i32::MAX, i32::MAX);
+        for output in self.outputs.values() {
+            origin.0 = origin.0.min(output.logical_pos.0);
+            origin.1 = origin.1.min(output.logical_pos.1);
+        }
+        origin
+    }
+
+    /// Get the logical width and height of the desktop.
+    pub fn get_desktop_extent(&self) -> (i32, i32) {
+        let mut extent = (0, 0);
+        for output in self.outputs.values() {
+            extent.0 = extent.0.max(output.logical_pos.0 + output.logical_size.0);
+            extent.1 = extent.1.max(output.logical_pos.1 + output.logical_size.1);
+        }
+        let origin = self.get_desktop_origin();
+        (extent.0 - origin.0, extent.1 - origin.1)
+    }
+
+    pub fn iter_events(&mut self) -> impl Iterator<Item = OutputChangeEvent> + '_ {
+        self.events.drain(..)
+    }
+
+    /// Dispatch pending events and block until finished.
+    pub fn dispatch(&mut self) {
+        if let Ok(mut queue_mut) = self.queue.clone().lock() {
+            let _ = queue_mut.blocking_dispatch(self);
+        }
+    }
+
+    /// Dispatch pending events without blocking.
+    pub fn dispatch_pending(&mut self) {
+        if let Ok(mut queue_mut) = self.queue.clone().lock() {
+            if let Some(reader) = queue_mut.prepare_read() {
+                match reader.read() {
+                    Ok(n) => match queue_mut.dispatch_pending(self) {
+                        Ok(n2) => {
+                            log::debug!("Read {}, dispatched {} pending events", n, n2);
+                        }
+                        Err(err) => {
+                            log::warn!("Error while dispatching {} pending events: {:?}", n, err);
+                        }
+                    },
+                    Err(err) => {
+                        if let WaylandError::Io(ref e) = err {
+                            if e.kind() == std::io::ErrorKind::WouldBlock {
+                                return;
+                            }
+                        }
+                        log::warn!("Error while reading from event queue: {:?}", err);
+                    }
+                }
+            } else {
+                let _ = queue_mut.dispatch_pending(self);
+            }
+        }
+    }
+}
+
+pub(crate) fn wl_transform_to_frame_transform(transform: Transform) -> crate::frame::Transform {
+    match transform {
+        Transform::Normal => crate::frame::Transform::Normal,
+        Transform::_90 => crate::frame::Transform::Rotated90,
+        Transform::_180 => crate::frame::Transform::Rotated180,
+        Transform::_270 => crate::frame::Transform::Rotated270,
+        Transform::Flipped => crate::frame::Transform::Flipped,
+        Transform::Flipped90 => crate::frame::Transform::Flipped90,
+        Transform::Flipped180 => crate::frame::Transform::Flipped180,
+        Transform::Flipped270 => crate::frame::Transform::Flipped270,
+        _ => crate::frame::Transform::Undefined,
+    }
+}
+
+impl Dispatch<ZxdgOutputV1, u32> for WlxClient {
+    fn event(
+        state: &mut Self,
+        _proxy: &ZxdgOutputV1,
+        event: <ZxdgOutputV1 as Proxy>::Event,
+        data: &u32,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        fn finalize_output(output: &mut WlxOutput) {
+            if output.logical_size.0 < 0 {
+                output.logical_pos.0 += output.logical_size.0;
+                output.logical_size.0 *= -1;
+            }
+            if output.logical_size.1 < 0 {
+                output.logical_pos.1 += output.logical_size.1;
+                output.logical_size.1 *= -1;
+            }
+            if !output.done {
+                output.done = true;
+                debug!(
+                    "Discovered WlOutput {}; Size: {:?}; Logical Size: {:?}; Pos: {:?}",
+                    output.name, output.size, output.logical_size, output.logical_pos
+                );
+            }
+        }
+        match event {
+            zxdg_output_v1::Event::Name { name } => {
+                if let Some(output) = state.outputs.get_mut(*data) {
+                    output.name = name.into();
+                }
+            }
+            zxdg_output_v1::Event::LogicalPosition { x, y } => {
+                if let Some(output) = state.outputs.get_mut(*data) {
+                    output.logical_pos = (x, y);
+                    let was_done = output.done;
+                    if output.logical_size != (0, 0) {
+                        finalize_output(output);
+                    }
+                    if was_done {
+                        log::info!(
+                            "{}: Logical pos changed to {:?}",
+                            output.name,
+                            output.logical_pos,
+                        );
+                        state.events.push_back(OutputChangeEvent::Logical(*data));
+                    } else {
+                        state.events.push_back(OutputChangeEvent::Create(*data));
+                    }
+                }
+            }
+            zxdg_output_v1::Event::LogicalSize { width, height } => {
+                if let Some(output) = state.outputs.get_mut(*data) {
+                    output.logical_size = (width, height);
+                    let was_done = output.done;
+                    if output.logical_pos != (0, 0) {
+                        finalize_output(output);
+                    }
+                    if was_done {
+                        log::info!(
+                            "{}: Logical size changed to {:?}",
+                            output.name,
+                            output.logical_size,
+                        );
+                        state.events.push_back(OutputChangeEvent::Logical(*data));
+                    } else {
+                        state.events.push_back(OutputChangeEvent::Create(*data));
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<WlOutput, u32> for WlxClient {
+    fn event(
+        state: &mut Self,
+        _proxy: &WlOutput,
+        event: <WlOutput as Proxy>::Event,
+        data: &u32,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        match event {
+            wl_output::Event::Mode { width, height, .. } => {
+                if let Some(output) = state.outputs.get_mut(*data) {
+                    output.size = (width, height);
+                    if output.done {
+                        log::info!(
+                            "{}: Resolution changed {:?} -> {:?}",
+                            output.name,
+                            output.size,
+                            (width, height)
+                        );
+                        state.events.push_back(OutputChangeEvent::Physical(*data));
+                    }
+                }
+            }
+            wl_output::Event::Geometry {
+                make,
+                model,
+                transform,
+                ..
+            } => {
+                if let Some(output) = state.outputs.get_mut(*data) {
+                    let transform = transform.into_result().unwrap_or(Transform::Normal);
+                    let old_transform = output.transform;
+                    output.transform = transform;
+                    if output.done && old_transform != transform {
+                        log::info!(
+                            "{}: Transform changed {:?} -> {:?}",
+                            output.name,
+                            output.transform,
+                            transform
+                        );
+                        state.events.push_back(OutputChangeEvent::Physical(*data));
+                        state.events.push_back(OutputChangeEvent::Logical(*data));
+                    }
+                    output.make = make.into();
+                    output.model = model.into();
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+impl Dispatch<WlRegistry, GlobalListContents> for WlxClient {
+    fn event(
+        state: &mut Self,
+        _proxy: &WlRegistry,
+        event: <WlRegistry as Proxy>::Event,
+        _data: &GlobalListContents,
+        conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        match event {
+            wl_registry::Event::Global {
+                name,
+                interface,
+                version,
+            } => {
+                if interface == WlOutput::interface().name {
+                    state.add_output(name, version);
+                    let _ = conn.roundtrip();
+                }
+            }
+            wl_registry::Event::GlobalRemove { name } => {
+                if let Some(output) = state.outputs.remove(name) {
+                    log::info!("{}: Device removed", output.name);
+                    state.events.push_back(OutputChangeEvent::Destroy(name));
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+// Plumbing below
+
+impl Dispatch<ZxdgOutputManagerV1, ()> for WlxClient {
+    fn event(
+        _state: &mut Self,
+        _proxy: &ZxdgOutputManagerV1,
+        _event: <ZxdgOutputManagerV1 as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwlrExportDmabufManagerV1, ()> for WlxClient {
+    fn event(
+        _state: &mut Self,
+        _proxy: &ZwlrExportDmabufManagerV1,
+        _event: <ZwlrExportDmabufManagerV1 as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwlrScreencopyManagerV1, ()> for WlxClient {
+    fn event(
+        _state: &mut Self,
+        _proxy: &ZwlrScreencopyManagerV1,
+        _event: <ZwlrScreencopyManagerV1 as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<WlSeat, ()> for WlxClient {
+    fn event(
+        _state: &mut Self,
+        _proxy: &WlSeat,
+        _event: <WlSeat as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<WlShm, ()> for WlxClient {
+    fn event(
+        _state: &mut Self,
+        _proxy: &WlShm,
+        _event: <WlShm as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}

wlx-capture/src/wlr_dmabuf.rs

@@ -0,0 +1,243 @@
+use std::{
+    any::Any,
+    collections::VecDeque,
+    os::fd::{FromRawFd, IntoRawFd, OwnedFd, RawFd},
+    sync::mpsc,
+    thread::JoinHandle,
+};
+
+use smithay_client_toolkit::reexports::protocols_wlr::export_dmabuf::v1::client::zwlr_export_dmabuf_frame_v1::{self, ZwlrExportDmabufFrameV1};
+use wayland_client::{Connection, QueueHandle, Dispatch, Proxy};
+
+use crate::{
+    frame::{DmabufFrame, DrmFormat, FramePlane, WlxFrame},
+    wayland::{wl_transform_to_frame_transform, WlxClient},
+    WlxCapture,
+};
+
+use log::{debug, warn};
+
+struct CaptureData<U, R>
+where
+    U: Any,
+    R: Any,
+{
+    sender: mpsc::SyncSender<WlxFrame>,
+    receiver: mpsc::Receiver<WlxFrame>,
+    user_data: U,
+    receive_callback: fn(&U, WlxFrame) -> Option<R>,
+}
+
+pub struct WlrDmabufCapture<U, R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    output_id: u32,
+    wl: Option<Box<WlxClient>>,
+    handle: Option<JoinHandle<Box<WlxClient>>>,
+    data: Option<CaptureData<U, R>>,
+    fds: VecDeque<RawFd>,
+}
+
+impl<U, R> WlrDmabufCapture<U, R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    pub fn new(wl: WlxClient, output_id: u32) -> Self {
+        Self {
+            output_id,
+            wl: Some(Box::new(wl)),
+            handle: None,
+            data: None,
+            fds: VecDeque::new(),
+        }
+    }
+}
+
+impl<U, R> WlxCapture<U, R> for WlrDmabufCapture<U, R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    fn init(
+        &mut self,
+        _: &[DrmFormat],
+        user_data: U,
+        receive_callback: fn(&U, WlxFrame) -> Option<R>,
+    ) {
+        debug_assert!(self.wl.is_some());
+
+        let (sender, receiver) = std::sync::mpsc::sync_channel::<WlxFrame>(2);
+        self.data = Some(CaptureData {
+            sender,
+            receiver,
+            user_data,
+            receive_callback,
+        });
+    }
+    fn is_ready(&self) -> bool {
+        self.data.is_some()
+    }
+    fn supports_dmbuf(&self) -> bool {
+        true
+    }
+    fn receive(&mut self) -> Option<R> {
+        if let Some(data) = self.data.as_ref() {
+            if let Some(WlxFrame::Dmabuf(last)) = data.receiver.try_iter().last() {
+                // this is the only protocol that requires us to manually close the FD
+                while self.fds.len() > 6 * last.num_planes {
+                    // safe unwrap
+                    let _ = unsafe { OwnedFd::from_raw_fd(self.fds.pop_back().unwrap()) };
+                }
+                for p in 0..last.num_planes {
+                    if let Some(fd) = last.planes[p].fd {
+                        self.fds.push_front(fd);
+                    }
+                }
+                return (data.receive_callback)(&data.user_data, WlxFrame::Dmabuf(last));
+            }
+        }
+        None
+    }
+    fn pause(&mut self) {}
+    fn resume(&mut self) {
+        self.receive(); // clear old frames
+    }
+    fn request_new_frame(&mut self) {
+        if let Some(handle) = self.handle.take() {
+            if handle.is_finished() {
+                self.wl = Some(handle.join().unwrap()); // safe to unwrap because we checked is_finished
+            } else {
+                self.handle = Some(handle);
+                return;
+            }
+        }
+
+        let Some(wl) = self.wl.take() else {
+            return;
+        };
+
+        self.handle = Some(std::thread::spawn({
+            let sender = self
+                .data
+                .as_ref()
+                .expect("must call init once before request_new_frame")
+                .sender
+                .clone();
+            let output_id = self.output_id;
+            move || request_dmabuf_frame(wl, output_id, sender)
+        }));
+    }
+}
+
+/// Request a new DMA-Buf frame using the wlr-export-dmabuf protocol.
+fn request_dmabuf_frame(
+    client: Box<WlxClient>,
+    output_id: u32,
+    sender: mpsc::SyncSender<WlxFrame>,
+) -> Box<WlxClient> {
+    let Some(dmabuf_manager) = client.maybe_wlr_dmabuf_mgr.as_ref() else {
+        return client;
+    };
+
+    let Some(output) = client.outputs.get(output_id) else {
+        return client;
+    };
+
+    let transform = wl_transform_to_frame_transform(output.transform);
+
+    let (tx, rx) = mpsc::sync_channel::<zwlr_export_dmabuf_frame_v1::Event>(16);
+    let name = output.name.clone();
+
+    let _ = dmabuf_manager.capture_output(1, &output.wl_output, &client.queue_handle, tx.clone());
+
+    let mut client = client;
+    client.dispatch();
+
+    let mut frame = None;
+
+    rx.try_iter().for_each(|event| match event {
+        zwlr_export_dmabuf_frame_v1::Event::Frame {
+            width,
+            height,
+            format,
+            mod_high,
+            mod_low,
+            num_objects,
+            ..
+        } => {
+            let mut new_frame = DmabufFrame::default();
+            new_frame.format.width = width;
+            new_frame.format.height = height;
+            new_frame.format.fourcc.value = format;
+            new_frame.format.set_mod(mod_high, mod_low);
+            new_frame.format.transform = transform;
+            new_frame.num_planes = num_objects as _;
+            frame = Some(new_frame);
+        }
+        zwlr_export_dmabuf_frame_v1::Event::Object {
+            index,
+            fd,
+            offset,
+            stride,
+            ..
+        } => {
+            let Some(ref mut frame) = frame else {
+                return;
+            };
+            frame.planes[index as usize] = FramePlane {
+                fd: Some(fd.into_raw_fd()),
+                offset,
+                stride: stride as _,
+            };
+        }
+        zwlr_export_dmabuf_frame_v1::Event::Ready { .. } => {
+            let Some(frame) = frame.take() else {
+                return;
+            };
+            debug!("DMA-Buf frame captured");
+            let frame = WlxFrame::Dmabuf(frame);
+            match sender.try_send(frame) {
+                Ok(_) => (),
+                Err(mpsc::TrySendError::Full(_)) => (),
+                Err(mpsc::TrySendError::Disconnected(_)) => {
+                    log::warn!("{}: disconnected", &name);
+                }
+            }
+        }
+        zwlr_export_dmabuf_frame_v1::Event::Cancel { .. } => {
+            warn!("DMA-Buf frame capture cancelled");
+        }
+        _ => {}
+    });
+
+    client
+}
+
+impl Dispatch<ZwlrExportDmabufFrameV1, mpsc::SyncSender<zwlr_export_dmabuf_frame_v1::Event>>
+    for WlxClient
+{
+    fn event(
+        _state: &mut Self,
+        proxy: &ZwlrExportDmabufFrameV1,
+        event: <ZwlrExportDmabufFrameV1 as Proxy>::Event,
+        data: &mpsc::SyncSender<zwlr_export_dmabuf_frame_v1::Event>,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+        match event {
+            zwlr_export_dmabuf_frame_v1::Event::Ready { .. }
+            | zwlr_export_dmabuf_frame_v1::Event::Cancel { .. } => {
+                proxy.destroy();
+            }
+            _ => {}
+        }
+
+        let _ = data.send(event).or_else(|err| {
+            warn!("Failed to send DMA-Buf frame event: {}", err);
+            Ok::<(), mpsc::SendError<zwlr_export_dmabuf_frame_v1::Event>>(())
+        });
+    }
+}

wlx-capture/src/wlr_screencopy.rs

@@ -0,0 +1,383 @@
+use libc::{O_CREAT, O_RDWR, S_IRUSR, S_IWUSR};
+use std::{
+    any::Any,
+    ffi::CString,
+    os::fd::{BorrowedFd, RawFd},
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        mpsc::{self, SyncSender},
+    },
+    thread::JoinHandle,
+};
+use wayland_client::{
+    protocol::{wl_buffer::WlBuffer, wl_shm::Format, wl_shm_pool::WlShmPool},
+    Connection, Dispatch, Proxy, QueueHandle, WEnum,
+};
+
+use smithay_client_toolkit::reexports::protocols_wlr::screencopy::v1::client::zwlr_screencopy_frame_v1::{ZwlrScreencopyFrameV1, self};
+
+use crate::{
+    frame::{
+        DrmFormat, FourCC, FrameFormat, FramePlane, MemFdFrame, WlxFrame, DRM_FORMAT_ARGB8888,
+        DRM_FORMAT_XRGB8888,
+    },
+    wayland::{wl_transform_to_frame_transform, WlxClient},
+    WlxCapture,
+};
+
+struct BufData {
+    wl_buffer: WlBuffer,
+    wl_pool: WlShmPool,
+    fd: RawFd,
+}
+
+impl Drop for BufData {
+    fn drop(&mut self) {
+        self.wl_buffer.destroy();
+        self.wl_pool.destroy();
+        unsafe {
+            libc::close(self.fd);
+        }
+    }
+}
+
+enum ScreenCopyEvent {
+    Buffer {
+        data: BufData,
+        fourcc: FourCC,
+        width: u32,
+        height: u32,
+        stride: u32,
+    },
+    Ready,
+    Failed,
+}
+
+struct CaptureData<U, R>
+where
+    U: Any,
+    R: Any,
+{
+    sender: mpsc::SyncSender<R>,
+    receiver: mpsc::Receiver<R>,
+    user_data: U,
+    receive_callback: fn(&U, WlxFrame) -> Option<R>,
+}
+
+pub struct WlrScreencopyCapture<U, R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    output_id: u32,
+    wl: Option<Box<WlxClient>>,
+    handle: Option<JoinHandle<Box<WlxClient>>>,
+    data: Option<CaptureData<U, R>>,
+}
+
+impl<U, R> WlrScreencopyCapture<U, R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    pub fn new(wl: WlxClient, output_id: u32) -> Self {
+        Self {
+            output_id,
+            wl: Some(Box::new(wl)),
+            handle: None,
+            data: None,
+        }
+    }
+}
+
+impl<U, R> WlxCapture<U, R> for WlrScreencopyCapture<U, R>
+where
+    U: Any + Send + Clone,
+    R: Any + Send,
+{
+    fn init(
+        &mut self,
+        _: &[DrmFormat],
+        user_data: U,
+        receive_callback: fn(&U, WlxFrame) -> Option<R>,
+    ) {
+        debug_assert!(self.wl.is_some());
+
+        let (sender, receiver) = mpsc::sync_channel(2);
+        self.data = Some(CaptureData {
+            sender,
+            receiver,
+            user_data,
+            receive_callback,
+        });
+    }
+    fn is_ready(&self) -> bool {
+        self.data.is_some()
+    }
+    fn supports_dmbuf(&self) -> bool {
+        false // screencopy v1
+    }
+    fn receive(&mut self) -> Option<R> {
+        if let Some(data) = self.data.as_ref() {
+            data.receiver.try_iter().last()
+        } else {
+            None
+        }
+    }
+    fn pause(&mut self) {}
+    fn resume(&mut self) {
+        if self.data.is_none() {
+            return;
+        }
+        self.receive(); // clear old frames
+        self.request_new_frame();
+    }
+    fn request_new_frame(&mut self) {
+        let mut wait_for_damage = false;
+        if let Some(handle) = self.handle.take() {
+            if handle.is_finished() {
+                wait_for_damage = true;
+                self.wl = Some(handle.join().unwrap()); // safe to unwrap because we checked is_finished
+            } else {
+                self.handle = Some(handle);
+                return;
+            }
+        }
+
+        let Some(wl) = self.wl.take() else {
+            return;
+        };
+
+        let data = self
+            .data
+            .as_ref()
+            .expect("must call init once before request_new_frame");
+
+        self.handle = Some(std::thread::spawn({
+            let sender = data.sender.clone();
+            let user_data = data.user_data.clone();
+            let receive_callback = data.receive_callback;
+
+            let output_id = self.output_id;
+            move || {
+                request_screencopy_frame(
+                    wl,
+                    output_id,
+                    sender,
+                    user_data,
+                    receive_callback,
+                    wait_for_damage,
+                )
+            }
+        }));
+    }
+}
+
+/// Request a new DMA-Buf frame using the wlr-screencopy protocol.
+fn request_screencopy_frame<U, R>(
+    client: Box<WlxClient>,
+    output_id: u32,
+    sender: SyncSender<R>,
+    user_data: U,
+    receive_callback: fn(&U, WlxFrame) -> Option<R>,
+    wait_for_damage: bool,
+) -> Box<WlxClient>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    let Some(screencopy_manager) = client.maybe_wlr_screencopy_mgr.as_ref() else {
+        return client;
+    };
+
+    let Some(output) = client.outputs.get(output_id) else {
+        return client;
+    };
+
+    let transform = wl_transform_to_frame_transform(output.transform);
+
+    let (tx, rx) = mpsc::sync_channel::<ScreenCopyEvent>(16);
+
+    let proxy =
+        screencopy_manager.capture_output(1, &output.wl_output, &client.queue_handle, tx.clone());
+
+    let name = output.name.clone();
+
+    let mut client = client;
+    client.dispatch();
+
+    let mut frame_buffer = None;
+
+    'receiver: loop {
+        for event in rx.try_iter() {
+            match event {
+                ScreenCopyEvent::Buffer {
+                    data,
+                    fourcc,
+                    width,
+                    height,
+                    stride,
+                } => {
+                    let frame = MemFdFrame {
+                        format: FrameFormat {
+                            width,
+                            height,
+                            fourcc,
+                            transform,
+                            ..Default::default()
+                        },
+                        plane: FramePlane {
+                            fd: Some(data.fd),
+                            offset: 0,
+                            stride: stride as _,
+                        },
+                        ..Default::default()
+                    };
+                    log::trace!("{}: Received screencopy buffer, copying", name.as_ref());
+                    if wait_for_damage {
+                        proxy.copy_with_damage(&data.wl_buffer);
+                    } else {
+                        proxy.copy(&data.wl_buffer);
+                    }
+                    frame_buffer = Some((frame, data));
+                    client.dispatch();
+                }
+                ScreenCopyEvent::Ready => {
+                    if let Some((frame, buffer)) = frame_buffer {
+                        if let Some(r) = receive_callback(&user_data, WlxFrame::MemFd(frame)) {
+                            let _ = sender.send(r);
+                            log::trace!("{}: Frame ready", name.as_ref());
+                        }
+                        drop(buffer);
+                    }
+                    break 'receiver;
+                }
+                ScreenCopyEvent::Failed => {
+                    log::trace!("{}: Frame failed", name.as_ref());
+                    break 'receiver;
+                }
+            };
+        }
+    }
+
+    client
+}
+
+static FD_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+impl Dispatch<ZwlrScreencopyFrameV1, SyncSender<ScreenCopyEvent>> for WlxClient {
+    fn event(
+        state: &mut Self,
+        proxy: &ZwlrScreencopyFrameV1,
+        event: <ZwlrScreencopyFrameV1 as Proxy>::Event,
+        data: &SyncSender<ScreenCopyEvent>,
+        _conn: &Connection,
+        qhandle: &QueueHandle<Self>,
+    ) {
+        match event {
+            zwlr_screencopy_frame_v1::Event::Failed => {
+                let _ = data.send(ScreenCopyEvent::Failed);
+                proxy.destroy();
+            }
+            zwlr_screencopy_frame_v1::Event::Buffer {
+                format,
+                width,
+                height,
+                stride,
+            } => {
+                let WEnum::Value(shm_format) = format else {
+                    log::warn!("Unknown screencopy format");
+                    let _ = data.send(ScreenCopyEvent::Failed);
+                    proxy.destroy();
+                    return;
+                };
+
+                let Some(fourcc) = fourcc_from_wlshm(shm_format) else {
+                    log::warn!("Unsupported screencopy format");
+                    let _ = data.send(ScreenCopyEvent::Failed);
+                    proxy.destroy();
+                    return;
+                };
+
+                let fd_num = FD_COUNTER.fetch_add(1, Ordering::Relaxed);
+                let name = CString::new(format!("wlx-{}", fd_num)).unwrap(); // safe
+                let size = stride * height;
+                let fd = unsafe {
+                    let fd = libc::shm_open(name.as_ptr(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+                    libc::shm_unlink(name.as_ptr());
+                    libc::ftruncate(fd, size as _);
+                    fd
+                };
+
+                let borrowed_fd = unsafe { BorrowedFd::borrow_raw(fd) };
+
+                let wl_pool = state
+                    .wl_shm
+                    .create_pool(borrowed_fd, size as _, qhandle, ());
+
+                let wl_buffer = wl_pool.create_buffer(
+                    0,
+                    width as _,
+                    height as _,
+                    stride as _,
+                    shm_format,
+                    qhandle,
+                    (),
+                );
+
+                let _ = data.send(ScreenCopyEvent::Buffer {
+                    data: BufData {
+                        wl_buffer,
+                        wl_pool,
+                        fd,
+                    },
+                    fourcc,
+                    width,
+                    height,
+                    stride,
+                });
+            }
+            zwlr_screencopy_frame_v1::Event::Ready { .. } => {
+                let _ = data.send(ScreenCopyEvent::Ready);
+                proxy.destroy();
+            }
+            _ => {}
+        }
+    }
+}
+
+fn fourcc_from_wlshm(shm_format: Format) -> Option<FourCC> {
+    match shm_format {
+        Format::Argb8888 => Some(FourCC::from(DRM_FORMAT_ARGB8888)),
+        Format::Xrgb8888 => Some(FourCC::from(DRM_FORMAT_XRGB8888)),
+        Format::Abgr8888 => Some(FourCC::from(DRM_FORMAT_ARGB8888)),
+        Format::Xbgr8888 => Some(FourCC::from(DRM_FORMAT_XRGB8888)),
+        _ => None,
+    }
+}
+
+// Plumbing below
+
+impl Dispatch<WlShmPool, ()> for WlxClient {
+    fn event(
+        _state: &mut Self,
+        _proxy: &WlShmPool,
+        _event: <WlShmPool as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}
+
+impl Dispatch<WlBuffer, ()> for WlxClient {
+    fn event(
+        _state: &mut Self,
+        _proxy: &WlBuffer,
+        _event: <WlBuffer as Proxy>::Event,
+        _data: &(),
+        _conn: &Connection,
+        _qhandle: &QueueHandle<Self>,
+    ) {
+    }
+}

wlx-capture/src/xshm.rs

@@ -0,0 +1,178 @@
+use std::{
+    any::Any,
+    env,
+    error::Error,
+    sync::{
+        mpsc::{self},
+        Arc,
+    },
+};
+
+use rxscreen::monitor::Monitor;
+
+use crate::{
+    frame::{DrmFormat, FrameFormat, MemPtrFrame, MouseMeta, WlxFrame, DRM_FORMAT_XRGB8888},
+    WlxCapture,
+};
+
+pub struct XshmScreen {
+    pub name: Arc<str>,
+    pub monitor: Monitor,
+}
+
+pub struct XshmCapture<U, R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    pub screen: Arc<XshmScreen>,
+    sender: Option<mpsc::SyncSender<()>>,
+    receiver: Option<mpsc::Receiver<R>>,
+    _dummy: Option<Box<U>>,
+}
+
+impl<U, R> XshmCapture<U, R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    pub fn new(screen: Arc<XshmScreen>) -> Self {
+        Self {
+            screen,
+            sender: None,
+            receiver: None,
+            _dummy: None,
+        }
+    }
+}
+
+pub fn xshm_get_monitors() -> Result<Vec<Arc<XshmScreen>>, Box<dyn Error>> {
+    let display = env::var("DISPLAY").inspect_err(|e| log::info!("DISPLAY: {e:?}"))?;
+    let Ok(d) = rxscreen::Display::new(display) else {
+        return Err("X11: Failed to open display".into());
+    };
+    Ok(d.monitors()
+        .into_iter()
+        .enumerate()
+        .map(|x| {
+            Arc::new(XshmScreen {
+                name: x.1.name().replace("DisplayPort", "DP").into(),
+                monitor: x.1,
+            })
+        })
+        .collect())
+}
+
+impl<U, R> WlxCapture<U, R> for XshmCapture<U, R>
+where
+    U: Any + Send,
+    R: Any + Send,
+{
+    fn init(
+        &mut self,
+        _: &[DrmFormat],
+        user_data: U,
+        receive_callback: fn(&U, WlxFrame) -> Option<R>,
+    ) {
+        let (tx_frame, rx_frame) = std::sync::mpsc::sync_channel(4);
+        let (tx_cmd, rx_cmd) = std::sync::mpsc::sync_channel(2);
+        self.sender = Some(tx_cmd);
+        self.receiver = Some(rx_frame);
+
+        std::thread::spawn({
+            let monitor = self.screen.monitor.clone();
+            move || {
+                let display = env::var("DISPLAY").expect("DISPLAY not set");
+                let Ok(d) = rxscreen::Display::new(display) else {
+                    log::error!("{}: failed to open display", monitor.name());
+                    return;
+                };
+                let Ok(shm) = d.shm().monitor(&monitor).build() else {
+                    log::error!("{}: failed to create shm", monitor.name());
+                    return;
+                };
+
+                loop {
+                    match rx_cmd.recv() {
+                        Ok(_) => {
+                            if let Ok(image) = shm.capture() {
+                                let size = unsafe { image.as_bytes().len() };
+                                let memptr_frame = MemPtrFrame {
+                                    format: FrameFormat {
+                                        width: image.width() as _,
+                                        height: image.height() as _,
+                                        fourcc: DRM_FORMAT_XRGB8888.into(),
+                                        ..Default::default()
+                                    },
+                                    ptr: unsafe { image.as_ptr() as _ },
+                                    size,
+                                    mouse: d.root_mouse_position().and_then(|root_pos| {
+                                        monitor.mouse_to_local(root_pos).map(|(x, y)| MouseMeta {
+                                            x: (x as f32) / (image.width() as f32),
+                                            y: (y as f32) / (image.height() as f32),
+                                        })
+                                    }),
+                                };
+                                log::trace!("{}: captured frame", &monitor.name());
+
+                                let frame = WlxFrame::MemPtr(memptr_frame);
+                                if let Some(r) = receive_callback(&user_data, frame) {
+                                    match tx_frame.try_send(r) {
+                                        Ok(_) => (),
+                                        Err(mpsc::TrySendError::Full(_)) => {
+                                            log::debug!("{}: channel full", &monitor.name());
+                                        }
+                                        Err(mpsc::TrySendError::Disconnected(_)) => {
+                                            log::warn!(
+                                                "{}: capture thread channel closed (send)",
+                                                &monitor.name(),
+                                            );
+                                            break;
+                                        }
+                                    }
+                                }
+                            } else {
+                                log::debug!("{}: XShmGetImage failed", &monitor.name());
+                            }
+                        }
+                        Err(_) => {
+                            log::warn!("{}: capture thread channel closed (recv)", monitor.name());
+                            break;
+                        }
+                    }
+                }
+                log::warn!("{}: capture thread stopped", monitor.name());
+            }
+        });
+    }
+    fn is_ready(&self) -> bool {
+        self.receiver.is_some()
+    }
+    fn supports_dmbuf(&self) -> bool {
+        false
+    }
+    fn receive(&mut self) -> Option<R> {
+        if let Some(rx) = self.receiver.as_ref() {
+            return rx.try_iter().last();
+        }
+        None
+    }
+    fn pause(&mut self) {}
+    fn resume(&mut self) {
+        if let Some(rx) = self.receiver.as_ref() {
+            log::debug!(
+                "{}: dropped {} old frames before resuming",
+                &self.screen.name,
+                rx.try_iter().count()
+            );
+        }
+        self.request_new_frame();
+    }
+    fn request_new_frame(&mut self) {
+        if let Some(sender) = &self.sender {
+            if let Err(e) = sender.send(()) {
+                log::debug!("Failed to send frame request: {}", e);
+            }
+        }
+    }
+}