use std::os::fd::{AsRawFd as _, IntoRawFd as _, OwnedFd};
use ash::vk;
pub(super) struct BufferProperties {
pub(super) allocation_size: u64,
pub(super) memory_type_bits: u32,
pub(super) format: vk::Format,
pub(super) external_format: u64,
pub(super) suggested_model: vk::SamplerYcbcrModelConversion,
pub(super) suggested_range: vk::SamplerYcbcrRange,
pub(super) x_chroma_offset: vk::ChromaLocation,
pub(super) y_chroma_offset: vk::ChromaLocation,
}
pub(super) struct ImportedImage {
device: ash::Device,
image: vk::Image,
memory: Option<vk::DeviceMemory>,
acquire_semaphore: Option<vk::Semaphore>,
}
impl core::fmt::Debug for ImportedImage {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter
.debug_struct("ImportedImage")
.field("image", &self.image)
.field("memory", &self.memory)
.field("acquire_semaphore", &self.acquire_semaphore)
.finish_non_exhaustive()
}
}
impl ImportedImage {
pub(super) const fn image(&self) -> vk::Image {
self.image
}
pub(super) const fn acquire_semaphore(&self) -> Option<vk::Semaphore> {
self.acquire_semaphore
}
}
impl Drop for ImportedImage {
fn drop(&mut self) {
unsafe {
self.device.destroy_image(self.image, None);
if let Some(memory) = self.memory {
self.device.free_memory(memory, None);
}
if let Some(semaphore) = self.acquire_semaphore {
self.device.destroy_semaphore(semaphore, None);
}
}
}
}
pub(super) fn validate_device(hal_device: &wgpu::hal::vulkan::Device) {
for extension in super::DEVICE_EXTENSIONS {
assert!(
hal_device.enabled_device_extensions().contains(&extension),
"the Vulkan device does not enable {extension:?}; open it with \
`ahardware_buffer::request_device` or add `ahardware_buffer::DEVICE_EXTENSIONS`"
);
}
}
pub(super) fn buffer_properties(
hal_device: &wgpu::hal::vulkan::Device,
buffer: &ndk::hardware_buffer::HardwareBuffer,
) -> BufferProperties {
let loader = ash::android::external_memory_android_hardware_buffer::Device::new(
hal_device.shared_instance().raw_instance(),
hal_device.raw_device(),
);
let mut format_properties = vk::AndroidHardwareBufferFormatPropertiesANDROID::default();
let mut properties =
vk::AndroidHardwareBufferPropertiesANDROID::default().push_next(&mut format_properties);
unsafe {
loader
.get_android_hardware_buffer_properties(buffer.as_ptr().cast(), &mut properties)
.unwrap_or_else(|error| {
panic!("failed to query the AHardwareBuffer's Vulkan properties: {error}")
});
}
BufferProperties {
allocation_size: properties.allocation_size,
memory_type_bits: properties.memory_type_bits,
format: format_properties.format,
external_format: format_properties.external_format,
suggested_model: format_properties.suggested_ycbcr_model,
suggested_range: format_properties.suggested_ycbcr_range,
x_chroma_offset: format_properties.suggested_x_chroma_offset,
y_chroma_offset: format_properties.suggested_y_chroma_offset,
}
}
pub(super) enum ImageFormat {
Defined {
format: vk::Format,
multi_planar: bool,
},
External(u64),
}
pub(super) struct ImageShape {
pub(super) format: ImageFormat,
pub(super) width: u32,
pub(super) height: u32,
pub(super) mip_levels: u32,
pub(super) usage: vk::ImageUsageFlags,
}
pub(super) fn import_buffer(
hal_device: &wgpu::hal::vulkan::Device,
buffer: &ndk::hardware_buffer::HardwareBuffer,
properties: &BufferProperties,
shape: &ImageShape,
acquire_fence: Option<OwnedFd>,
) -> ImportedImage {
let raw = hal_device.raw_device();
let mut external = vk::ExternalMemoryImageCreateInfo::default()
.handle_types(vk::ExternalMemoryHandleTypeFlags::ANDROID_HARDWARE_BUFFER_ANDROID);
let (format, flags, external_format) = match shape.format {
ImageFormat::Defined {
format,
multi_planar: true,
} => (
format,
vk::ImageCreateFlags::MUTABLE_FORMAT | vk::ImageCreateFlags::EXTENDED_USAGE,
0,
),
ImageFormat::Defined {
format,
multi_planar: false,
} => (format, vk::ImageCreateFlags::empty(), 0),
ImageFormat::External(external_format) => (
vk::Format::UNDEFINED,
vk::ImageCreateFlags::empty(),
external_format,
),
};
let mut external_format = vk::ExternalFormatANDROID::default().external_format(external_format);
let create_info = vk::ImageCreateInfo::default()
.push_next(&mut external)
.push_next(&mut external_format)
.flags(flags)
.image_type(vk::ImageType::TYPE_2D)
.format(format)
.extent(vk::Extent3D {
width: shape.width,
height: shape.height,
depth: 1,
})
.mip_levels(shape.mip_levels)
.array_layers(1)
.samples(vk::SampleCountFlags::TYPE_1)
.tiling(vk::ImageTiling::OPTIMAL)
.usage(shape.usage)
.sharing_mode(vk::SharingMode::EXCLUSIVE)
.initial_layout(vk::ImageLayout::UNDEFINED);
let image = unsafe { raw.create_image(&create_info, None) }.unwrap_or_else(|error| {
panic!("failed to create the Vulkan image for an AHardwareBuffer: {error}")
});
let mut imported = ImportedImage {
device: raw.clone(),
image,
memory: None,
acquire_semaphore: None,
};
let memory_type_index =
crate::vulkan_memory::select_memory_type(hal_device, properties.memory_type_bits);
let mut import =
vk::ImportAndroidHardwareBufferInfoANDROID::default().buffer(buffer.as_ptr().cast());
let mut dedicated = vk::MemoryDedicatedAllocateInfo::default().image(image);
let allocation = vk::MemoryAllocateInfo::default()
.push_next(&mut import)
.push_next(&mut dedicated)
.allocation_size(properties.allocation_size)
.memory_type_index(memory_type_index);
let memory = unsafe { raw.allocate_memory(&allocation, None) }.unwrap_or_else(|error| {
panic!("failed to import the AHardwareBuffer as Vulkan memory: {error}")
});
imported.memory = Some(memory);
unsafe { raw.bind_image_memory(image, memory, 0) }.unwrap_or_else(|error| {
panic!("failed to bind the AHardwareBuffer's memory to its Vulkan image: {error}")
});
imported.acquire_semaphore = acquire_fence.map(|fence| import_acquire_fence(hal_device, fence));
imported
}
fn import_acquire_fence(hal_device: &wgpu::hal::vulkan::Device, fence: OwnedFd) -> vk::Semaphore {
let raw = hal_device.raw_device();
let semaphore = unsafe { raw.create_semaphore(&vk::SemaphoreCreateInfo::default(), None) }
.unwrap_or_else(|error| {
panic!("failed to create the semaphore for an AHardwareBuffer acquire fence: {error}")
});
let loader = ash::khr::external_semaphore_fd::Device::new(
hal_device.shared_instance().raw_instance(),
raw,
);
let import = vk::ImportSemaphoreFdInfoKHR::default()
.semaphore(semaphore)
.flags(vk::SemaphoreImportFlags::TEMPORARY)
.handle_type(vk::ExternalSemaphoreHandleTypeFlags::SYNC_FD)
.fd(fence.as_raw_fd());
match unsafe { loader.import_semaphore_fd(&import) } {
Ok(()) => {
let _transferred = fence.into_raw_fd();
semaphore
}
Err(error) => {
unsafe { raw.destroy_semaphore(semaphore, None) };
panic!("failed to import the AHardwareBuffer acquire fence: {error}")
}
}
}
pub(super) unsafe fn record_acquire(
device: &ash::Device,
encoder: &mut wgpu::hal::vulkan::CommandEncoder,
image: vk::Image,
queue_family_index: u32,
) {
let barrier = vk::ImageMemoryBarrier::default()
.src_access_mask(vk::AccessFlags::empty())
.dst_access_mask(vk::AccessFlags::SHADER_READ)
.old_layout(vk::ImageLayout::UNDEFINED)
.new_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
.src_queue_family_index(vk::QUEUE_FAMILY_FOREIGN_EXT)
.dst_queue_family_index(queue_family_index)
.image(image)
.subresource_range(
vk::ImageSubresourceRange::default()
.aspect_mask(vk::ImageAspectFlags::COLOR)
.base_mip_level(0)
.level_count(vk::REMAINING_MIP_LEVELS)
.base_array_layer(0)
.layer_count(1),
);
unsafe {
device.cmd_pipeline_barrier(
encoder.raw_handle(),
vk::PipelineStageFlags::ALL_COMMANDS,
vk::PipelineStageFlags::VERTEX_SHADER
| vk::PipelineStageFlags::FRAGMENT_SHADER
| vk::PipelineStageFlags::COMPUTE_SHADER,
vk::DependencyFlags::empty(),
&[],
&[],
&[barrier],
);
}
}