use core::ops::Deref;
use std::collections::HashMap;
use std::io::Cursor;
use std::sync::Arc;
use ash::vk;
use wgpu::hal::Device as _;
use super::frame::FrameParts;
use super::vulkan::{self, BufferProperties, ImageFormat, ImageShape};
use super::{HardwareBufferImportError, HardwareBufferUsage, Retirement, Ycbcr420Planes};
use crate::YcbcrEncoding;
pub(super) const LUMA_FORMAT: (wgpu::TextureFormat, vk::Format) =
(wgpu::TextureFormat::R8Unorm, vk::Format::R8_UNORM);
pub(super) const CHROMA_FORMAT: (wgpu::TextureFormat, vk::Format) =
(wgpu::TextureFormat::Rg8Unorm, vk::Format::R8G8_UNORM);
const VERTEX_SPIRV: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/ycbcr_planes.vert.spv"));
const FRAGMENT_SPIRV: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/ycbcr_planes.frag.spv"));
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ConversionFormat {
Defined(i32),
External(u64),
}
impl ConversionFormat {
const fn of(properties: &BufferProperties) -> Self {
match properties.format {
vk::Format::UNDEFINED => Self::External(properties.external_format),
format => Self::Defined(format.as_raw()),
}
}
const fn vk_format(self) -> vk::Format {
match self {
Self::Defined(format) => vk::Format::from_raw(format),
Self::External(_) => vk::Format::UNDEFINED,
}
}
}
impl core::fmt::Display for ConversionFormat {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::Defined(format) => {
write!(
formatter,
"Vulkan format {:?}",
vk::Format::from_raw(*format)
)
}
Self::External(format) => write!(formatter, "external format {format:#x}"),
}
}
}
pub(super) fn import(
device: &wgpu::Device,
queue: &wgpu::Queue,
converter: &mut Converter,
hal_device: impl Deref<Target = wgpu::hal::vulkan::Device>,
parts: FrameParts,
properties: &BufferProperties,
encoding: YcbcrEncoding,
) -> Result<Ycbcr420Planes, HardwareBufferImportError> {
let FrameParts {
buffer,
description,
acquire_fence,
mut lease,
} = parts;
assert!(
description.width.is_multiple_of(2)
&& description.height.is_multiple_of(2)
&& !description
.usage
.contains(HardwareBufferUsage::GPU_MIPMAP_COMPLETE),
"a 4:2:0 YCbCr AHardwareBuffer must be a single mip level of even extent, but this one \
is {}x{} with usage {:?}",
description.width,
description.height,
description.usage,
);
let extent = vk::Extent2D {
width: description.width,
height: description.height,
};
let pipeline = converter.pipeline(properties);
let binding = SourceBinding::allocate(&pipeline)?;
let imported = vulkan::import_buffer(
&hal_device,
buffer.buffer(),
properties,
&ImageShape {
format: match pipeline.key.format {
ConversionFormat::Defined(format) => ImageFormat::Defined {
format: vk::Format::from_raw(format),
multi_planar: false,
},
ConversionFormat::External(external) => ImageFormat::External(external),
},
width: extent.width,
height: extent.height,
mip_levels: 1,
usage: vk::ImageUsageFlags::SAMPLED,
},
acquire_fence,
);
let luma = PlaneTexture::new(&hal_device, LUMA_FORMAT.0, extent.width, extent.height);
let chroma = PlaneTexture::new(
&hal_device,
CHROMA_FORMAT.0,
extent.width / 2,
extent.height / 2,
);
let frame = ConversionFrame::new(
pipeline,
binding,
&ConversionTargets {
source: imported.image(),
luma: luma.image,
chroma: chroma.image,
extent,
},
);
let source = imported.image();
let acquire_semaphore = imported.acquire_semaphore();
let raw_device = hal_device.raw_device().clone();
let queue_family_index = hal_device.queue_family_index();
drop(hal_device);
let luma = luma.into_wgpu(device);
let chroma = chroma.into_wgpu(device);
if let Some(lease) = lease.as_mut() {
lease.presented();
}
let conversion = super::record_raw(device, "wgpu_external_frame_ycbcr_conversion", |encoder| {
unsafe {
vulkan::record_acquire(&raw_device, encoder, source, queue_family_index);
frame.record(encoder.raw_handle());
}
});
let retirement = Retirement {
imported,
buffer,
lease,
};
conversion.on_submitted_work_done(move || {
drop(frame);
retirement.retire();
});
super::submit(
device,
queue,
conversion,
&[&luma, &chroma],
acquire_semaphore,
);
Ok(Ycbcr420Planes {
luma: luma.create_view(&wgpu::TextureViewDescriptor::default()),
chroma: chroma.create_view(&wgpu::TextureViewDescriptor::default()),
encoding,
})
}
struct PlaneTexture {
texture: wgpu::hal::vulkan::Texture,
image: vk::Image,
format: wgpu::TextureFormat,
size: wgpu::Extent3d,
}
impl PlaneTexture {
const LABEL: Option<&'static str> = Some("wgpu_external_frame_ycbcr_plane");
const USAGE: wgpu::TextureUsages = wgpu::TextureUsages::TEXTURE_BINDING
.union(wgpu::TextureUsages::COPY_SRC)
.union(wgpu::TextureUsages::RENDER_ATTACHMENT);
fn new(
hal_device: &wgpu::hal::vulkan::Device,
format: wgpu::TextureFormat,
width: u32,
height: u32,
) -> Self {
let size = wgpu::Extent3d {
width,
height,
depth_or_array_layers: 1,
};
let descriptor = wgpu::hal::TextureDescriptor {
label: Self::LABEL,
size,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format,
usage: wgpu::TextureUses::RESOURCE
| wgpu::TextureUses::COPY_SRC
| wgpu::TextureUses::COLOR_TARGET,
memory_flags: wgpu::hal::MemoryFlags::empty(),
view_formats: Vec::new(),
};
let texture = unsafe { hal_device.create_texture(&descriptor) }.unwrap_or_else(|error| {
panic!("failed to create a {format:?} YCbCr plane texture: {error}")
});
let image = unsafe { texture.raw_handle() };
Self {
texture,
image,
format,
size,
}
}
fn into_wgpu(self, device: &wgpu::Device) -> wgpu::Texture {
unsafe {
device.create_texture_from_hal::<wgpu::hal::api::Vulkan>(
self.texture,
&wgpu::TextureDescriptor {
label: Self::LABEL,
size: self.size,
mip_level_count: 1,
sample_count: 1,
dimension: wgpu::TextureDimension::D2,
format: self.format,
usage: Self::USAGE,
view_formats: &[],
},
wgpu::TextureUses::RESOURCE,
)
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct ConversionKey {
format: ConversionFormat,
x_chroma_offset: vk::ChromaLocation,
y_chroma_offset: vk::ChromaLocation,
}
pub(super) struct Converter {
shared: Arc<Shared>,
pipelines: HashMap<ConversionKey, Arc<ConversionPipeline>>,
}
impl core::fmt::Debug for Converter {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter
.debug_struct("Converter")
.field("pipelines", &self.pipelines.keys().collect::<Vec<_>>())
.finish_non_exhaustive()
}
}
impl Converter {
pub(super) fn new(hal_device: &wgpu::hal::vulkan::Device) -> Self {
Self {
shared: Arc::new(Shared::new(
hal_device.raw_device(),
combined_image_sampler_descriptor_count(hal_device),
)),
pipelines: HashMap::new(),
}
}
pub(super) fn pipeline(&mut self, properties: &BufferProperties) -> Arc<ConversionPipeline> {
let key = ConversionKey {
format: ConversionFormat::of(properties),
x_chroma_offset: properties.x_chroma_offset,
y_chroma_offset: properties.y_chroma_offset,
};
Arc::clone(
self.pipelines.entry(key).or_insert_with(|| {
Arc::new(ConversionPipeline::new(Arc::clone(&self.shared), key))
}),
)
}
}
struct Shared {
device: ash::Device,
descriptor_count: u32,
vertex: vk::ShaderModule,
fragment: vk::ShaderModule,
luma_pass: vk::RenderPass,
chroma_pass: vk::RenderPass,
}
impl Shared {
fn new(device: &ash::Device, descriptor_count: u32) -> Self {
let vertex = shader_module(device, VERTEX_SPIRV);
let fragment = shader_module(device, FRAGMENT_SPIRV);
Self {
device: device.clone(),
descriptor_count,
vertex,
fragment,
luma_pass: plane_render_pass(device, LUMA_FORMAT.1),
chroma_pass: plane_render_pass(device, CHROMA_FORMAT.1),
}
}
}
impl Drop for Shared {
fn drop(&mut self) {
unsafe {
self.device.destroy_render_pass(self.chroma_pass, None);
self.device.destroy_render_pass(self.luma_pass, None);
self.device.destroy_shader_module(self.fragment, None);
self.device.destroy_shader_module(self.vertex, None);
}
}
}
fn combined_image_sampler_descriptor_count(hal_device: &wgpu::hal::vulkan::Device) -> u32 {
const PLANES_420: u32 = 3;
let instance = hal_device.shared_instance().raw_instance();
let physical_device = hal_device.raw_physical_device();
let extensions = unsafe { instance.enumerate_device_extension_properties(physical_device) }
.unwrap_or_else(|error| {
panic!("failed to enumerate the Vulkan device's extensions: {error}")
});
let has_maintenance6 = extensions
.iter()
.any(|extension| extension.extension_name_as_c_str() == Ok(ash::khr::maintenance6::NAME));
if !has_maintenance6 {
return PLANES_420;
}
let mut maintenance6 = vk::PhysicalDeviceMaintenance6PropertiesKHR::default();
let mut properties = vk::PhysicalDeviceProperties2::default().push_next(&mut maintenance6);
unsafe { instance.get_physical_device_properties2(physical_device, &mut properties) };
let count = maintenance6.max_combined_image_sampler_descriptor_count;
assert_ne!(
count, 0,
"the Vulkan driver reports a maxCombinedImageSamplerDescriptorCount of 0"
);
count
}
fn shader_module(device: &ash::Device, spirv: &[u8]) -> vk::ShaderModule {
let code = ash::util::read_spv(&mut Cursor::new(spirv))
.expect("the build script emits whole SPIR-V words");
let create_info = vk::ShaderModuleCreateInfo::default().code(&code);
unsafe { device.create_shader_module(&create_info, None) }.unwrap_or_else(|error| {
panic!("failed to create the YCbCr conversion shader module: {error}")
})
}
fn plane_render_pass(device: &ash::Device, format: vk::Format) -> vk::RenderPass {
let attachment = vk::AttachmentDescription::default()
.format(format)
.samples(vk::SampleCountFlags::TYPE_1)
.load_op(vk::AttachmentLoadOp::DONT_CARE)
.store_op(vk::AttachmentStoreOp::STORE)
.stencil_load_op(vk::AttachmentLoadOp::DONT_CARE)
.stencil_store_op(vk::AttachmentStoreOp::DONT_CARE)
.initial_layout(vk::ImageLayout::UNDEFINED)
.final_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
let color = vk::AttachmentReference::default()
.attachment(0)
.layout(vk::ImageLayout::COLOR_ATTACHMENT_OPTIMAL);
let subpass = vk::SubpassDescription::default()
.pipeline_bind_point(vk::PipelineBindPoint::GRAPHICS)
.color_attachments(core::slice::from_ref(&color));
let dependencies = [
vk::SubpassDependency::default()
.src_subpass(vk::SUBPASS_EXTERNAL)
.dst_subpass(0)
.src_stage_mask(vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT)
.dst_stage_mask(vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT)
.src_access_mask(vk::AccessFlags::empty())
.dst_access_mask(vk::AccessFlags::COLOR_ATTACHMENT_WRITE),
vk::SubpassDependency::default()
.src_subpass(0)
.dst_subpass(vk::SUBPASS_EXTERNAL)
.src_stage_mask(vk::PipelineStageFlags::COLOR_ATTACHMENT_OUTPUT)
.dst_stage_mask(
vk::PipelineStageFlags::VERTEX_SHADER
| vk::PipelineStageFlags::FRAGMENT_SHADER
| vk::PipelineStageFlags::COMPUTE_SHADER,
)
.src_access_mask(vk::AccessFlags::COLOR_ATTACHMENT_WRITE)
.dst_access_mask(vk::AccessFlags::SHADER_READ),
];
let create_info = vk::RenderPassCreateInfo::default()
.attachments(core::slice::from_ref(&attachment))
.subpasses(core::slice::from_ref(&subpass))
.dependencies(&dependencies);
unsafe { device.create_render_pass(&create_info, None) }.unwrap_or_else(|error| {
panic!("failed to create the YCbCr conversion render pass: {error}")
})
}
pub(super) struct ConversionPipeline {
shared: Arc<Shared>,
key: ConversionKey,
conversion: vk::SamplerYcbcrConversion,
sampler: vk::Sampler,
set_layout: vk::DescriptorSetLayout,
layout: vk::PipelineLayout,
luma: vk::Pipeline,
chroma: vk::Pipeline,
}
impl ConversionPipeline {
fn new(shared: Arc<Shared>, key: ConversionKey) -> Self {
let device = &shared.device;
let mut external_format =
vk::ExternalFormatANDROID::default().external_format(match key.format {
ConversionFormat::Defined(_) => 0,
ConversionFormat::External(external) => external,
});
let conversion_info = vk::SamplerYcbcrConversionCreateInfo::default()
.push_next(&mut external_format)
.format(key.format.vk_format())
.ycbcr_model(vk::SamplerYcbcrModelConversion::RGB_IDENTITY)
.ycbcr_range(vk::SamplerYcbcrRange::ITU_FULL)
.components(vk::ComponentMapping::default())
.x_chroma_offset(key.x_chroma_offset)
.y_chroma_offset(key.y_chroma_offset)
.chroma_filter(vk::Filter::NEAREST)
.force_explicit_reconstruction(false);
let conversion = unsafe { device.create_sampler_ycbcr_conversion(&conversion_info, None) }
.unwrap_or_else(|error| {
panic!(
"failed to create the VkSamplerYcbcrConversion for the {}: {error}",
key.format
)
});
let mut conversion_binding =
vk::SamplerYcbcrConversionInfo::default().conversion(conversion);
let sampler_info = vk::SamplerCreateInfo::default()
.push_next(&mut conversion_binding)
.mag_filter(vk::Filter::NEAREST)
.min_filter(vk::Filter::NEAREST)
.mipmap_mode(vk::SamplerMipmapMode::NEAREST)
.address_mode_u(vk::SamplerAddressMode::CLAMP_TO_EDGE)
.address_mode_v(vk::SamplerAddressMode::CLAMP_TO_EDGE)
.address_mode_w(vk::SamplerAddressMode::CLAMP_TO_EDGE)
.anisotropy_enable(false)
.compare_enable(false)
.unnormalized_coordinates(false);
let sampler =
unsafe { device.create_sampler(&sampler_info, None) }.unwrap_or_else(|error| {
panic!("failed to create the YCbCr conversion sampler: {error}")
});
let binding = vk::DescriptorSetLayoutBinding::default()
.binding(0)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.stage_flags(vk::ShaderStageFlags::FRAGMENT)
.immutable_samplers(core::slice::from_ref(&sampler));
let set_layout_info =
vk::DescriptorSetLayoutCreateInfo::default().bindings(core::slice::from_ref(&binding));
let set_layout = unsafe { device.create_descriptor_set_layout(&set_layout_info, None) }
.unwrap_or_else(|error| {
panic!("failed to create the YCbCr conversion descriptor set layout: {error}")
});
let layout_info =
vk::PipelineLayoutCreateInfo::default().set_layouts(core::slice::from_ref(&set_layout));
let layout =
unsafe { device.create_pipeline_layout(&layout_info, None) }.unwrap_or_else(|error| {
panic!("failed to create the YCbCr conversion pipeline layout: {error}")
});
let [luma, chroma] = plane_pipelines(&shared, layout);
Self {
shared,
key,
conversion,
sampler,
set_layout,
layout,
luma,
chroma,
}
}
}
impl Drop for ConversionPipeline {
fn drop(&mut self) {
let device = &self.shared.device;
unsafe {
device.destroy_pipeline(self.chroma, None);
device.destroy_pipeline(self.luma, None);
device.destroy_pipeline_layout(self.layout, None);
device.destroy_descriptor_set_layout(self.set_layout, None);
device.destroy_sampler(self.sampler, None);
device.destroy_sampler_ycbcr_conversion(self.conversion, None);
}
}
}
fn plane_pipelines(shared: &Shared, layout: vk::PipelineLayout) -> [vk::Pipeline; 2] {
let specialization_entry = vk::SpecializationMapEntry::default()
.constant_id(0)
.offset(0)
.size(size_of::<vk::Bool32>());
let luma_constant = vk::FALSE.to_ne_bytes();
let chroma_constant = vk::TRUE.to_ne_bytes();
let luma_specialization = vk::SpecializationInfo::default()
.map_entries(core::slice::from_ref(&specialization_entry))
.data(&luma_constant);
let chroma_specialization = vk::SpecializationInfo::default()
.map_entries(core::slice::from_ref(&specialization_entry))
.data(&chroma_constant);
let stages = |specialization| {
[
vk::PipelineShaderStageCreateInfo::default()
.stage(vk::ShaderStageFlags::VERTEX)
.module(shared.vertex)
.name(c"main"),
vk::PipelineShaderStageCreateInfo::default()
.stage(vk::ShaderStageFlags::FRAGMENT)
.module(shared.fragment)
.name(c"main")
.specialization_info(specialization),
]
};
let luma_stages = stages(&luma_specialization);
let chroma_stages = stages(&chroma_specialization);
let vertex_input = vk::PipelineVertexInputStateCreateInfo::default();
let input_assembly = vk::PipelineInputAssemblyStateCreateInfo::default()
.topology(vk::PrimitiveTopology::TRIANGLE_LIST);
let viewport = vk::PipelineViewportStateCreateInfo::default()
.viewport_count(1)
.scissor_count(1);
let rasterization = vk::PipelineRasterizationStateCreateInfo::default()
.polygon_mode(vk::PolygonMode::FILL)
.cull_mode(vk::CullModeFlags::NONE)
.front_face(vk::FrontFace::COUNTER_CLOCKWISE)
.line_width(1.0);
let multisample = vk::PipelineMultisampleStateCreateInfo::default()
.rasterization_samples(vk::SampleCountFlags::TYPE_1);
let luma_blend = vk::PipelineColorBlendAttachmentState::default()
.color_write_mask(vk::ColorComponentFlags::R);
let chroma_blend = vk::PipelineColorBlendAttachmentState::default()
.color_write_mask(vk::ColorComponentFlags::R | vk::ColorComponentFlags::G);
let luma_blend_state = vk::PipelineColorBlendStateCreateInfo::default()
.attachments(core::slice::from_ref(&luma_blend));
let chroma_blend_state = vk::PipelineColorBlendStateCreateInfo::default()
.attachments(core::slice::from_ref(&chroma_blend));
let dynamic_states = [vk::DynamicState::VIEWPORT, vk::DynamicState::SCISSOR];
let dynamic = vk::PipelineDynamicStateCreateInfo::default().dynamic_states(&dynamic_states);
let common = vk::GraphicsPipelineCreateInfo::default()
.vertex_input_state(&vertex_input)
.input_assembly_state(&input_assembly)
.viewport_state(&viewport)
.rasterization_state(&rasterization)
.multisample_state(&multisample)
.dynamic_state(&dynamic)
.layout(layout)
.subpass(0);
let create_infos = [
common
.stages(&luma_stages)
.color_blend_state(&luma_blend_state)
.render_pass(shared.luma_pass),
common
.stages(&chroma_stages)
.color_blend_state(&chroma_blend_state)
.render_pass(shared.chroma_pass),
];
let pipelines = unsafe {
shared
.device
.create_graphics_pipelines(vk::PipelineCache::null(), &create_infos, None)
}
.unwrap_or_else(|(_, error)| {
panic!("failed to create the YCbCr conversion pipelines: {error}")
});
pipelines
.try_into()
.expect("two create infos yield two pipelines")
}
pub(super) struct ConversionTargets {
pub(super) source: vk::Image,
pub(super) luma: vk::Image,
pub(super) chroma: vk::Image,
pub(super) extent: vk::Extent2D,
}
struct SourceBinding {
shared: Arc<Shared>,
pool: vk::DescriptorPool,
set: vk::DescriptorSet,
}
impl SourceBinding {
fn allocate(pipeline: &ConversionPipeline) -> Result<Self, HardwareBufferImportError> {
let shared = &pipeline.shared;
let device = &shared.device;
let size = vk::DescriptorPoolSize {
ty: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
descriptor_count: shared.descriptor_count,
};
let pool_info = vk::DescriptorPoolCreateInfo::default()
.max_sets(1)
.pool_sizes(core::slice::from_ref(&size));
let pool =
unsafe { device.create_descriptor_pool(&pool_info, None) }.unwrap_or_else(|error| {
panic!("failed to create the YCbCr conversion descriptor pool: {error}")
});
let mut binding = Self {
shared: Arc::clone(shared),
pool,
set: vk::DescriptorSet::null(),
};
let allocate_info = vk::DescriptorSetAllocateInfo::default()
.descriptor_pool(pool)
.set_layouts(core::slice::from_ref(&pipeline.set_layout));
match unsafe { device.allocate_descriptor_sets(&allocate_info) } {
Ok(sets) => {
binding.set = sets[0];
Ok(binding)
}
Err(vk::Result::ERROR_OUT_OF_POOL_MEMORY | vk::Result::ERROR_FRAGMENTED_POOL) => {
Err(HardwareBufferImportError::ConversionDescriptorPool {
format: pipeline.key.format,
descriptor_count: shared.descriptor_count,
})
}
Err(error) => panic!(
"failed to allocate the YCbCr conversion descriptor set for the {}: {error}",
pipeline.key.format
),
}
}
}
impl Drop for SourceBinding {
fn drop(&mut self) {
unsafe { self.shared.device.destroy_descriptor_pool(self.pool, None) };
}
}
pub(super) struct ConversionFrame {
pipeline: Arc<ConversionPipeline>,
binding: SourceBinding,
extent: vk::Extent2D,
source_view: vk::ImageView,
luma_view: vk::ImageView,
chroma_view: vk::ImageView,
luma_framebuffer: vk::Framebuffer,
chroma_framebuffer: vk::Framebuffer,
}
impl ConversionFrame {
fn new(
pipeline: Arc<ConversionPipeline>,
binding: SourceBinding,
targets: &ConversionTargets,
) -> Self {
let device = &pipeline.shared.device;
let mut conversion_binding =
vk::SamplerYcbcrConversionInfo::default().conversion(pipeline.conversion);
let source_view_info = vk::ImageViewCreateInfo::default()
.push_next(&mut conversion_binding)
.image(targets.source)
.view_type(vk::ImageViewType::TYPE_2D)
.format(pipeline.key.format.vk_format())
.components(vk::ComponentMapping::default())
.subresource_range(color_subresource());
let source_view = unsafe { device.create_image_view(&source_view_info, None) }
.unwrap_or_else(|error| {
panic!("failed to create the view of an external-format AHardwareBuffer: {error}")
});
let image_info = vk::DescriptorImageInfo::default()
.image_view(source_view)
.image_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL);
let write = vk::WriteDescriptorSet::default()
.dst_set(binding.set)
.dst_binding(0)
.descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
.image_info(core::slice::from_ref(&image_info));
unsafe { device.update_descriptor_sets(core::slice::from_ref(&write), &[]) };
let mut frame = Self {
binding,
extent: targets.extent,
source_view,
luma_view: vk::ImageView::null(),
chroma_view: vk::ImageView::null(),
luma_framebuffer: vk::Framebuffer::null(),
chroma_framebuffer: vk::Framebuffer::null(),
pipeline,
};
let chroma_extent = vk::Extent2D {
width: targets.extent.width / 2,
height: targets.extent.height / 2,
};
frame.luma_view = frame.plane_view(targets.luma, LUMA_FORMAT.1);
frame.chroma_view = frame.plane_view(targets.chroma, CHROMA_FORMAT.1);
frame.luma_framebuffer = frame.framebuffer(
frame.pipeline.shared.luma_pass,
frame.luma_view,
targets.extent,
);
frame.chroma_framebuffer = frame.framebuffer(
frame.pipeline.shared.chroma_pass,
frame.chroma_view,
chroma_extent,
);
frame
}
fn device(&self) -> &ash::Device {
&self.pipeline.shared.device
}
fn plane_view(&self, image: vk::Image, format: vk::Format) -> vk::ImageView {
let create_info = vk::ImageViewCreateInfo::default()
.image(image)
.view_type(vk::ImageViewType::TYPE_2D)
.format(format)
.components(vk::ComponentMapping::default())
.subresource_range(color_subresource());
unsafe { self.device().create_image_view(&create_info, None) }.unwrap_or_else(|error| {
panic!("failed to create the view of a YCbCr plane texture: {error}")
})
}
fn framebuffer(
&self,
render_pass: vk::RenderPass,
view: vk::ImageView,
extent: vk::Extent2D,
) -> vk::Framebuffer {
let create_info = vk::FramebufferCreateInfo::default()
.render_pass(render_pass)
.attachments(core::slice::from_ref(&view))
.width(extent.width)
.height(extent.height)
.layers(1);
unsafe { self.device().create_framebuffer(&create_info, None) }.unwrap_or_else(|error| {
panic!("failed to create the framebuffer of a YCbCr plane: {error}")
})
}
pub(super) unsafe fn record(&self, command_buffer: vk::CommandBuffer) {
let chroma_extent = vk::Extent2D {
width: self.extent.width / 2,
height: self.extent.height / 2,
};
unsafe {
self.device().cmd_bind_descriptor_sets(
command_buffer,
vk::PipelineBindPoint::GRAPHICS,
self.pipeline.layout,
0,
core::slice::from_ref(&self.binding.set),
&[],
);
self.record_plane(
command_buffer,
self.luma_framebuffer,
self.pipeline.shared.luma_pass,
self.pipeline.luma,
self.extent,
);
self.record_plane(
command_buffer,
self.chroma_framebuffer,
self.pipeline.shared.chroma_pass,
self.pipeline.chroma,
chroma_extent,
);
}
}
unsafe fn record_plane(
&self,
command_buffer: vk::CommandBuffer,
framebuffer: vk::Framebuffer,
render_pass: vk::RenderPass,
pipeline: vk::Pipeline,
extent: vk::Extent2D,
) {
let device = self.device();
let area = vk::Rect2D::default().extent(extent);
let begin = vk::RenderPassBeginInfo::default()
.render_pass(render_pass)
.framebuffer(framebuffer)
.render_area(area);
#[expect(
clippy::cast_precision_loss,
reason = "a Vulkan image extent is far below the 2^24 an f32 holds exactly"
)]
let viewport = vk::Viewport::default()
.width(extent.width as f32)
.height(extent.height as f32)
.max_depth(1.0);
unsafe {
device.cmd_begin_render_pass(command_buffer, &begin, vk::SubpassContents::INLINE);
device.cmd_bind_pipeline(command_buffer, vk::PipelineBindPoint::GRAPHICS, pipeline);
device.cmd_set_viewport(command_buffer, 0, &[viewport]);
device.cmd_set_scissor(command_buffer, 0, &[area]);
device.cmd_draw(command_buffer, 3, 1, 0, 0);
device.cmd_end_render_pass(command_buffer);
}
}
}
impl Drop for ConversionFrame {
fn drop(&mut self) {
let device = self.device();
unsafe {
device.destroy_framebuffer(self.chroma_framebuffer, None);
device.destroy_framebuffer(self.luma_framebuffer, None);
device.destroy_image_view(self.chroma_view, None);
device.destroy_image_view(self.luma_view, None);
device.destroy_image_view(self.source_view, None);
}
}
}
const fn color_subresource() -> vk::ImageSubresourceRange {
vk::ImageSubresourceRange {
aspect_mask: vk::ImageAspectFlags::COLOR,
base_mip_level: 0,
level_count: 1,
base_array_layer: 0,
layer_count: 1,
}
}