use std::os::fd::{AsRawFd as _, IntoRawFd as _};
use ash::vk;
use sync_wrapper::SyncWrapper;
use super::frame::{DRM_FORMAT_MOD_INVALID, DmaBufFormat, DmaBufFrame, DmaBufPlane};
pub(super) struct ImportedVulkanImage {
texture: wgpu::Texture,
device: ash::Device,
image: vk::Image,
queue_family_index: u32,
}
impl core::fmt::Debug for ImportedVulkanImage {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter
.debug_struct("ImportedVulkanImage")
.finish_non_exhaustive()
}
}
unsafe impl Send for ImportedVulkanImage {}
impl ImportedVulkanImage {
pub(super) const fn texture(&self) -> &wgpu::Texture {
&self.texture
}
pub(super) fn record_acquire(&self, encoder: &mut wgpu::CommandEncoder) {
unsafe {
encoder.as_hal_mut::<wgpu::hal::api::Vulkan, _, _>(|encoder| {
let encoder = encoder.expect("DMA-BUF command encoder is not Vulkan");
let acquire = vk::ImageMemoryBarrier::default()
.src_access_mask(vk::AccessFlags::MEMORY_WRITE)
.dst_access_mask(vk::AccessFlags::TRANSFER_READ)
.old_layout(vk::ImageLayout::GENERAL)
.new_layout(vk::ImageLayout::TRANSFER_SRC_OPTIMAL)
.src_queue_family_index(vk::QUEUE_FAMILY_EXTERNAL)
.dst_queue_family_index(self.queue_family_index)
.image(self.image)
.subresource_range(subresource_range());
self.device.cmd_pipeline_barrier(
encoder.raw_handle(),
vk::PipelineStageFlags::ALL_COMMANDS,
vk::PipelineStageFlags::TRANSFER,
vk::DependencyFlags::empty(),
&[],
&[],
&[acquire],
);
});
}
}
pub(super) fn record_release(&self, encoder: &mut wgpu::CommandEncoder) {
unsafe {
encoder.as_hal_mut::<wgpu::hal::api::Vulkan, _, _>(|encoder| {
let encoder = encoder.expect("DMA-BUF command encoder is not Vulkan");
let release = vk::ImageMemoryBarrier::default()
.src_access_mask(vk::AccessFlags::TRANSFER_READ)
.dst_access_mask(vk::AccessFlags::MEMORY_READ | vk::AccessFlags::MEMORY_WRITE)
.old_layout(vk::ImageLayout::TRANSFER_SRC_OPTIMAL)
.new_layout(vk::ImageLayout::GENERAL)
.src_queue_family_index(self.queue_family_index)
.dst_queue_family_index(vk::QUEUE_FAMILY_EXTERNAL)
.image(self.image)
.subresource_range(subresource_range());
self.device.cmd_pipeline_barrier(
encoder.raw_handle(),
vk::PipelineStageFlags::TRANSFER,
vk::PipelineStageFlags::ALL_COMMANDS,
vk::DependencyFlags::empty(),
&[],
&[],
&[release],
);
});
}
}
}
const fn subresource_range() -> vk::ImageSubresourceRange {
vk::ImageSubresourceRange {
aspect_mask: vk::ImageAspectFlags::COLOR,
base_mip_level: 0,
level_count: 1,
base_array_layer: 0,
layer_count: 1,
}
}
struct Retirement {
device: ash::Device,
image: vk::Image,
memory: vk::DeviceMemory,
}
impl Retirement {
fn retire(self) {
unsafe {
self.device.destroy_image(self.image, None);
self.device.free_memory(self.memory, None);
}
}
}
const fn hal_descriptor(frame: &DmaBufFrame) -> wgpu::hal::TextureDescriptor<'static> {
wgpu::hal::TextureDescriptor {
label: Some("wgpu_external_frame_dma_buf_import"),
size: wgpu::Extent3d {
width: frame.width,
height: frame.height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: frame.format.texture_format(),
usage: wgpu::TextureUses::COPY_SRC,
memory_flags: wgpu::hal::MemoryFlags::empty(),
view_formats: Vec::new(),
}
}
const fn wgpu_descriptor(frame: &DmaBufFrame) -> wgpu::TextureDescriptor<'static> {
wgpu::TextureDescriptor {
label: Some("wgpu_external_frame_dma_buf_import"),
size: wgpu::Extent3d {
width: frame.width,
height: frame.height,
depth_or_array_layers: 1,
},
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: frame.format.texture_format(),
usage: wgpu::TextureUsages::COPY_SRC,
view_formats: &[],
}
}
pub(super) fn import_dma_buf(
device: &wgpu::Device,
frame: &mut DmaBufFrame,
) -> ImportedVulkanImage {
let hal_device = unsafe {
device
.as_hal::<wgpu::hal::api::Vulkan>()
.expect("DMA-BUF Vulkan import requires a Vulkan device")
};
validate_import(&hal_device, frame.modifier);
let raw = hal_device.raw_device().clone();
let queue_family_index = hal_device.queue_family_index();
let plane = frame
.planes
.pop()
.expect("a packed DMA-BUF frame must contain one plane");
let image = create_import_image(&raw, frame, &plane);
let memory = import_image_memory(&hal_device, image, plane);
if let Err(error) = unsafe { raw.bind_image_memory(image, memory, 0) } {
unsafe {
raw.free_memory(memory, None);
raw.destroy_image(image, None);
}
panic!("failed to bind DMA-BUF Vulkan image memory: {error}");
}
let retirement = SyncWrapper::new(Retirement {
device: raw.clone(),
image,
memory,
});
let drop_callback: wgpu::hal::DropCallback = Box::new(move || retirement.into_inner().retire());
let hal_texture = unsafe {
hal_device.texture_from_raw(
image,
&hal_descriptor(frame),
Some(drop_callback),
wgpu::hal::vulkan::TextureMemory::External,
)
};
drop(hal_device);
let texture = unsafe {
device.create_texture_from_hal::<wgpu::hal::api::Vulkan>(
hal_texture,
&wgpu_descriptor(frame),
wgpu::TextureUses::COPY_SRC,
)
};
ImportedVulkanImage {
texture,
device: raw,
image,
queue_family_index,
}
}
fn validate_import(hal_device: &wgpu::hal::vulkan::Device, modifier: u64) {
assert!(
hal_device
.enabled_device_extensions()
.contains(&ash::khr::external_memory_fd::NAME),
"Vulkan device does not enable VK_KHR_external_memory_fd"
);
assert!(
hal_device
.enabled_device_extensions()
.contains(&ash::ext::external_memory_dma_buf::NAME),
"Vulkan device does not enable VK_EXT_external_memory_dma_buf"
);
assert!(
hal_device
.enabled_device_extensions()
.contains(&ash::ext::image_drm_format_modifier::NAME),
"Vulkan device does not enable VK_EXT_image_drm_format_modifier"
);
assert_ne!(
modifier, DRM_FORMAT_MOD_INVALID,
"Vulkan DMA-BUF import requires an explicit DRM format modifier"
);
}
fn create_import_image(raw: &ash::Device, frame: &DmaBufFrame, plane: &DmaBufPlane) -> vk::Image {
let handle_type = vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT;
let mut external = vk::ExternalMemoryImageCreateInfo::default().handle_types(handle_type);
let plane_layout = vk::SubresourceLayout {
offset: u64::from(plane.offset),
size: 0,
row_pitch: u64::from(plane.stride),
array_pitch: 0,
depth_pitch: 0,
};
let mut modifier = vk::ImageDrmFormatModifierExplicitCreateInfoEXT::default()
.drm_format_modifier(frame.modifier)
.plane_layouts(std::slice::from_ref(&plane_layout));
let create_info = vk::ImageCreateInfo::default()
.push_next(&mut external)
.push_next(&mut modifier)
.image_type(vk::ImageType::TYPE_2D)
.format(match frame.format {
DmaBufFormat::Bgra8 | DmaBufFormat::Bgrx8 => vk::Format::B8G8R8A8_UNORM,
DmaBufFormat::Rgba8 | DmaBufFormat::Rgbx8 => vk::Format::R8G8B8A8_UNORM,
})
.extent(vk::Extent3D {
width: frame.width,
height: frame.height,
depth: 1,
})
.mip_levels(1)
.array_layers(1)
.samples(vk::SampleCountFlags::TYPE_1)
.tiling(vk::ImageTiling::DRM_FORMAT_MODIFIER_EXT)
.usage(vk::ImageUsageFlags::TRANSFER_SRC)
.sharing_mode(vk::SharingMode::EXCLUSIVE)
.initial_layout(vk::ImageLayout::UNDEFINED);
unsafe { raw.create_image(&create_info, None) }
.unwrap_or_else(|error| panic!("failed to create Vulkan DMA-BUF import image: {error}"))
}
fn import_image_memory(
hal_device: &wgpu::hal::vulkan::Device,
image: vk::Image,
plane: DmaBufPlane,
) -> vk::DeviceMemory {
let raw = hal_device.raw_device();
let handle_type = vk::ExternalMemoryHandleTypeFlags::DMA_BUF_EXT;
let requirements = unsafe { raw.get_image_memory_requirements(image) };
let loader =
ash::khr::external_memory_fd::Device::new(hal_device.shared_instance().raw_instance(), raw);
let mut fd_properties = vk::MemoryFdPropertiesKHR::default();
unsafe {
loader
.get_memory_fd_properties(handle_type, plane.fd.as_raw_fd(), &mut fd_properties)
.unwrap_or_else(|error| {
raw.destroy_image(image, None);
panic!("failed to query DMA-BUF Vulkan memory properties: {error}")
});
}
let type_bits = requirements.memory_type_bits & fd_properties.memory_type_bits;
assert!(
type_bits != 0,
"the DMA-BUF is incompatible with every Vulkan memory type"
);
let memory_type_index = crate::vulkan_memory::select_memory_type(hal_device, type_bits);
let imported_fd = plane.fd.into_raw_fd();
let mut import = vk::ImportMemoryFdInfoKHR::default()
.handle_type(handle_type)
.fd(imported_fd);
let mut dedicated = vk::MemoryDedicatedAllocateInfo::default().image(image);
let allocation = vk::MemoryAllocateInfo::default()
.push_next(&mut import)
.push_next(&mut dedicated)
.allocation_size(requirements.size)
.memory_type_index(memory_type_index);
match unsafe { raw.allocate_memory(&allocation, None) } {
Ok(memory) => memory,
Err(error) => {
unsafe {
libc::close(imported_fd);
raw.destroy_image(image, None);
}
panic!("failed to import the DMA-BUF as Vulkan memory: {error}");
}
}
}