use std::os::fd::{AsRawFd as _, OwnedFd};
const DRM_FORMAT_ARGB8888: u32 = u32::from_le_bytes(*b"AR24");
const DRM_FORMAT_XRGB8888: u32 = u32::from_le_bytes(*b"XR24");
const DRM_FORMAT_ABGR8888: u32 = u32::from_le_bytes(*b"AB24");
const DRM_FORMAT_XBGR8888: u32 = u32::from_le_bytes(*b"XB24");
pub const DRM_FORMAT_MOD_INVALID: u64 = u64::MAX;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum DmaBufFormat {
Bgra8,
Bgrx8,
Rgba8,
Rgbx8,
}
impl DmaBufFormat {
#[must_use]
pub fn from_fourcc(value: u32) -> Self {
match value {
DRM_FORMAT_ARGB8888 => Self::Bgra8,
DRM_FORMAT_XRGB8888 => Self::Bgrx8,
DRM_FORMAT_ABGR8888 => Self::Rgba8,
DRM_FORMAT_XBGR8888 => Self::Rgbx8,
_ => panic!("unsupported DMA-BUF DRM fourcc 0x{value:08x}"),
}
}
#[must_use]
pub const fn fourcc(self) -> u32 {
match self {
Self::Bgra8 => DRM_FORMAT_ARGB8888,
Self::Bgrx8 => DRM_FORMAT_XRGB8888,
Self::Rgba8 => DRM_FORMAT_ABGR8888,
Self::Rgbx8 => DRM_FORMAT_XBGR8888,
}
}
#[must_use]
pub const fn texture_format(self) -> wgpu::TextureFormat {
match self {
Self::Bgra8 | Self::Bgrx8 => wgpu::TextureFormat::Bgra8Unorm,
Self::Rgba8 | Self::Rgbx8 => wgpu::TextureFormat::Rgba8Unorm,
}
}
#[must_use]
pub const fn force_opaque(self) -> bool {
matches!(self, Self::Bgrx8 | Self::Rgbx8)
}
}
#[derive(Debug)]
pub struct DmaBufPlane {
pub fd: OwnedFd,
pub offset: u32,
pub stride: u32,
}
pub trait DmaBufLease: core::fmt::Debug + Send {
fn presented(&mut self);
fn release(self: Box<Self>, release_fence: Option<OwnedFd>);
}
#[derive(Debug)]
pub struct DmaBufFrame {
pub width: u32,
pub height: u32,
pub format: DmaBufFormat,
pub modifier: u64,
pub planes: Vec<DmaBufPlane>,
pub rendering_fence: Option<OwnedFd>,
visible: Option<(u32, u32)>,
lease: Option<Box<dyn DmaBufLease>>,
}
impl DmaBufFrame {
#[must_use]
pub fn new(
width: u32,
height: u32,
format: DmaBufFormat,
modifier: u64,
planes: Vec<DmaBufPlane>,
rendering_fence: Option<OwnedFd>,
) -> Self {
assert!(width > 0 && height > 0, "DMA-BUF frame must be non-zero");
assert_eq!(
planes.len(),
1,
"DMA-BUF frames require one packed 32-bit plane"
);
Self {
width,
height,
format,
modifier,
planes,
rendering_fence,
visible: None,
lease: None,
}
}
#[must_use]
pub fn with_lease(mut self, lease: Box<dyn DmaBufLease>) -> Self {
assert!(
self.lease.is_none(),
"a DMA-BUF frame carries at most one buffer lease"
);
self.lease = Some(lease);
self
}
#[must_use]
pub fn with_visible_size(mut self, width: u32, height: u32) -> Self {
assert!(
width > 0 && height > 0 && width <= self.width && height <= self.height,
"a DMA-BUF frame's visible size must be non-zero and within the buffer"
);
self.visible = Some((width, height));
self
}
#[must_use]
pub fn visible_size(&self) -> (u32, u32) {
self.visible.unwrap_or((self.width, self.height))
}
#[must_use]
pub fn is_render_ready(&self) -> bool {
let Some(fence) = &self.rendering_fence else {
return true;
};
let mut descriptor = libc::pollfd {
fd: fence.as_raw_fd(),
events: libc::POLLIN,
revents: 0,
};
let result = unsafe { libc::poll(&raw mut descriptor, 1, 0) };
assert!(result >= 0, "failed to poll the DMA-BUF rendering fence");
result == 1
}
pub fn presented(&mut self) {
if let Some(lease) = self.lease.as_mut() {
lease.presented();
}
}
pub fn release(self, release_fence: Option<OwnedFd>) {
match self.lease {
Some(lease) => lease.release(release_fence),
None => assert!(
release_fence.is_none(),
"an unleased DMA-BUF frame does not accept a release fence"
),
}
}
}