use std::ffi::CStr;
use ash::vk;
pub const DEVICE_EXTENSIONS: [&CStr; 3] = [
ash::android::external_memory_android_hardware_buffer::NAME,
ash::ext::queue_family_foreign::NAME,
ash::khr::external_semaphore_fd::NAME,
];
#[derive(Debug)]
pub struct DeviceRequirements {
sampler_ycbcr_conversion: vk::PhysicalDeviceSamplerYcbcrConversionFeatures<'static>,
}
impl DeviceRequirements {
pub fn new(adapter: &wgpu::hal::vulkan::Adapter) -> Result<Self, DeviceRequestError> {
let capabilities = adapter.physical_device_capabilities();
let api_version = capabilities.properties().api_version;
if api_version < vk::API_VERSION_1_1 {
return Err(DeviceRequestError::VulkanVersion {
major: vk::api_version_major(api_version),
minor: vk::api_version_minor(api_version),
});
}
if let Some(missing) = DEVICE_EXTENSIONS
.into_iter()
.find(|extension| !capabilities.supports_extension(extension))
{
return Err(DeviceRequestError::MissingExtension(missing));
}
if !supports_sampler_ycbcr_conversion(adapter) {
return Err(DeviceRequestError::MissingFeature("samplerYcbcrConversion"));
}
Ok(Self {
sampler_ycbcr_conversion: vk::PhysicalDeviceSamplerYcbcrConversionFeatures::default(),
})
}
pub fn add_to<'pnext>(
&'pnext mut self,
arguments: &mut wgpu::hal::vulkan::CreateDeviceCallbackArgs<'_, 'pnext, '_>,
) {
for extension in DEVICE_EXTENSIONS {
if !arguments.extensions.contains(&extension) {
arguments.extensions.push(extension);
}
}
self.sampler_ycbcr_conversion.sampler_ycbcr_conversion = vk::TRUE;
*arguments.create_info = arguments
.create_info
.push_next(&mut self.sampler_ycbcr_conversion);
}
}
#[derive(Debug, thiserror::Error)]
pub enum DeviceRequestError {
#[error(
"AHardwareBuffer import needs Vulkan 1.1, but the adapter reports Vulkan {major}.{minor}"
)]
VulkanVersion {
major: u32,
minor: u32,
},
#[error("the Vulkan adapter does not support the device extension {0:?}")]
MissingExtension(&'static CStr),
#[error("the Vulkan adapter does not support the device feature {0}")]
MissingFeature(&'static str),
#[error("the adapter does not support the requested features {0:?}")]
UnsupportedFeatures(wgpu::Features),
#[error(
"experimental features {0:?} were requested, but experimental features are not enabled"
)]
ExperimentalFeaturesNotEnabled(wgpu::Features),
#[error("the requested limit {name} = {requested} exceeds the adapter's {allowed}")]
LimitExceeded {
name: &'static str,
requested: u64,
allowed: u64,
},
#[error("Vulkan failed to create the device: {0}")]
Open(#[source] wgpu::hal::DeviceError),
#[error(transparent)]
Create(#[from] wgpu::RequestDeviceError),
}
pub fn request_device(
adapter: &wgpu::Adapter,
descriptor: &wgpu::DeviceDescriptor<'_>,
) -> Result<(wgpu::Device, wgpu::Queue), DeviceRequestError> {
check_descriptor(adapter, descriptor)?;
let hal_adapter = unsafe {
adapter
.as_hal::<wgpu::hal::api::Vulkan>()
.expect("AHardwareBuffer import requires a Vulkan adapter")
};
let mut requirements = DeviceRequirements::new(&hal_adapter)?;
let open_device = unsafe {
hal_adapter.open_with_callback(
descriptor.required_features,
&descriptor.required_limits,
&descriptor.memory_hints,
Some(Box::new(|mut arguments| {
requirements.add_to(&mut arguments);
})),
)
}
.map_err(DeviceRequestError::Open)?;
drop(hal_adapter);
let device = unsafe { adapter.create_device_from_hal(open_device, descriptor) }?;
Ok(device)
}
fn supports_sampler_ycbcr_conversion(hal_adapter: &wgpu::hal::vulkan::Adapter) -> bool {
let mut ycbcr = vk::PhysicalDeviceSamplerYcbcrConversionFeatures::default();
let mut features = vk::PhysicalDeviceFeatures2::default().push_next(&mut ycbcr);
unsafe {
hal_adapter
.shared_instance()
.raw_instance()
.get_physical_device_features2(hal_adapter.raw_physical_device(), &mut features);
}
ycbcr.sampler_ycbcr_conversion == vk::TRUE
}
fn check_descriptor(
adapter: &wgpu::Adapter,
descriptor: &wgpu::DeviceDescriptor<'_>,
) -> Result<(), DeviceRequestError> {
let unsupported = descriptor.required_features - adapter.features();
if !unsupported.is_empty() {
return Err(DeviceRequestError::UnsupportedFeatures(unsupported));
}
let experimental = descriptor
.required_features
.intersection(wgpu::Features::all_experimental_mask());
if !experimental.is_empty() && !descriptor.experimental_features.is_enabled() {
return Err(DeviceRequestError::ExperimentalFeaturesNotEnabled(
experimental,
));
}
let mut exceeded = None;
descriptor.required_limits.check_limits_with_fail_fn(
&adapter.limits(),
true,
|name, requested, allowed| {
exceeded.get_or_insert(DeviceRequestError::LimitExceeded {
name,
requested,
allowed,
});
},
);
exceeded.map_or(Ok(()), Err)
}