vulkan.rs

//! Color conversion and pixel exporting using Vulkan.
//!
//! Capturing loop:
//! - Blit back buffer contents into the Vulkan image.
//! - Run a compute pipeline to accumulate into a sampling Vulkan image (R16G16B16A16_UNORM).
//! - Run a compute pipeline to convert the colors to YUV into a host-visible buffer.
//! - Map the buffer, write contents to pipe.

use std::{
    ffi::CStr,
    mem,
    os::{
        raw::{c_char, c_void},
        unix::io::RawFd,
    },
    slice, str,
};

use ash::{
    extensions::{ext::DebugUtils, khr::ExternalMemoryFd},
    version::{DeviceV1_0, EntryV1_0, InstanceV1_0},
    vk,
};

pub struct Vulkan {
    width: u32,
    height: u32,
    #[allow(unused)] // Required to keep the library loaded.
    entry: ash::Entry,
    instance: ash::Instance,
    debug_utils: DebugUtils,
    debug_messenger: vk::DebugUtilsMessengerEXT,
    queue_family_index: u32,
    device: ash::Device,
    command_pool: vk::CommandPool,
    command_buffer: vk::CommandBuffer,
    queue: vk::Queue,
    image_frame: vk::Image,
    image_frame_memory: vk::DeviceMemory,
    image_frame_memory_size: u64,
    external_memory_fd: ExternalMemoryFd,
    image_sample: vk::Image,
    image_sample_memory: vk::DeviceMemory,
    semaphore: vk::Semaphore,
    external_semaphore_fd_fn: vk::KhrExternalSemaphoreFdFn,
    buffer: vk::Buffer,
    buffer_memory: vk::DeviceMemory,
    sampler_sample: vk::Sampler,
    sampler_frame: vk::Sampler,
    image_view_sample: vk::ImageView,
    image_view_frame: vk::ImageView,
    descriptor_set_layout_color_conversion: vk::DescriptorSetLayout,
    descriptor_pool: vk::DescriptorPool,
    descriptor_set_color_conversion: vk::DescriptorSet,
    shader_module: vk::ShaderModule,
    pipeline_layout: vk::PipelineLayout,
    pipeline: vk::Pipeline,
}

impl Drop for Vulkan {
    fn drop(&mut self) {
        unsafe {
            self.device.destroy_pipeline(self.pipeline, None);
            self.device
                .destroy_pipeline_layout(self.pipeline_layout, None);
            self.device.destroy_shader_module(self.shader_module, None);
            self.device
                .destroy_descriptor_pool(self.descriptor_pool, None);
            self.device
                .destroy_descriptor_set_layout(self.descriptor_set_layout_color_conversion, None);
            self.device.free_memory(self.buffer_memory, None);
            self.device.destroy_buffer(self.buffer, None);
            self.device.destroy_semaphore(self.semaphore, None);
            self.device.destroy_image_view(self.image_view_sample, None);
            self.device.destroy_sampler(self.sampler_sample, None);
            self.device.free_memory(self.image_sample_memory, None);
            self.device.destroy_image(self.image_sample, None);
            self.device.destroy_image_view(self.image_view_frame, None);
            self.device.destroy_sampler(self.sampler_frame, None);
            self.device.free_memory(self.image_frame_memory, None);
            self.device.destroy_image(self.image_frame, None);
            self.device
                .free_command_buffers(self.command_pool, &[self.command_buffer]);
            self.device.destroy_command_pool(self.command_pool, None);
            self.device.destroy_device(None);
            self.debug_utils
                .destroy_debug_utils_messenger(self.debug_messenger, None);
            self.instance.destroy_instance(None);
        }
    }
}

impl Vulkan {
    pub fn image_frame_memory_fd(&self) -> RawFd {
        let create_info = vk::MemoryGetFdInfoKHR::builder()
            .memory(self.image_frame_memory)
            .handle_type(vk::ExternalMemoryHandleTypeFlags::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD)
            .build();
        unsafe { self.external_memory_fd.get_memory_fd(&create_info).unwrap() }
    }

    pub fn image_frame_memory_size(&self) -> u64 {
        self.image_frame_memory_size
    }

    pub fn semaphore_fd(&self) -> RawFd {
        let create_info = vk::SemaphoreGetFdInfoKHR::builder()
            .semaphore(self.semaphore)
            .handle_type(
                vk::ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD,
            )
            .build();
        let mut semaphore_fd = -1;
        let rv = unsafe {
            self.external_semaphore_fd_fn.get_semaphore_fd_khr(
                self.device.handle(),
                &create_info,
                &mut semaphore_fd,
            )
        };
        if rv != vk::Result::SUCCESS {
            panic!(rv)
        }
        semaphore_fd
    }

    pub unsafe fn release_image_and_signal_semaphore(&self) {
        let begin_info = vk::CommandBufferBeginInfo::builder()
            .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT)
            .build();
        self.device
            .begin_command_buffer(self.command_buffer, &begin_info)
            .unwrap();

        let image_memory_barrier = vk::ImageMemoryBarrier::builder()
            .src_access_mask(vk::AccessFlags::empty())
            .dst_access_mask(vk::AccessFlags::empty())
            .old_layout(vk::ImageLayout::UNDEFINED)
            .new_layout(vk::ImageLayout::GENERAL)
            .src_queue_family_index(self.queue_family_index)
            .dst_queue_family_index(vk::QUEUE_FAMILY_EXTERNAL)
            .image(self.image_frame)
            .subresource_range(vk::ImageSubresourceRange {
                aspect_mask: vk::ImageAspectFlags::COLOR,
                base_mip_level: 0,
                level_count: 1,
                base_array_layer: 0,
                layer_count: 1,
            })
            .build();

        self.device.cmd_pipeline_barrier(
            self.command_buffer,
            vk::PipelineStageFlags::COMPUTE_SHADER,
            vk::PipelineStageFlags::BOTTOM_OF_PIPE,
            vk::DependencyFlags::empty(),
            &[],
            &[],
            &[image_memory_barrier],
        );

        self.device.end_command_buffer(self.command_buffer).unwrap();

        let submit_info = vk::SubmitInfo::builder()
            .command_buffers(&[self.command_buffer])
            .signal_semaphores(&[self.semaphore])
            .build();
        self.device
            .queue_submit(self.queue, &[submit_info], vk::Fence::null())
            .unwrap();
    }

    pub unsafe fn acquire_image_and_sample(&self) {
        let begin_info = vk::CommandBufferBeginInfo::builder()
            .flags(vk::CommandBufferUsageFlags::ONE_TIME_SUBMIT)
            .build();
        self.device
            .begin_command_buffer(self.command_buffer, &begin_info)
            .unwrap();

        // let image_frame_memory_barrier = vk::ImageMemoryBarrier::builder()
        //     .src_access_mask(vk::AccessFlags::empty())
        //     .dst_access_mask(vk::AccessFlags::empty())
        //     .old_layout(vk::ImageLayout::TRANSFER_SRC_OPTIMAL)
        //     .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_frame)
        //     .subresource_range(vk::ImageSubresourceRange {
        //         aspect_mask: vk::ImageAspectFlags::COLOR,
        //         base_mip_level: 0,
        //         level_count: 1,
        //         base_array_layer: 0,
        //         layer_count: 1,
        //     })
        //     .build();

        // let image_sample_memory_barrier = vk::ImageMemoryBarrier::builder()
        //     .src_access_mask(vk::AccessFlags::empty())
        //     .dst_access_mask(vk::AccessFlags::TRANSFER_WRITE)
        //     .old_layout(vk::ImageLayout::UNDEFINED)
        //     .new_layout(vk::ImageLayout::TRANSFER_DST_OPTIMAL)
        //     .src_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
        //     .dst_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
        //     .image(self.image_sample)
        //     .subresource_range(vk::ImageSubresourceRange {
        //         aspect_mask: vk::ImageAspectFlags::COLOR,
        //         base_mip_level: 0,
        //         level_count: 1,
        //         base_array_layer: 0,
        //         layer_count: 1,
        //     })
        //     .build();

        // self.device.cmd_pipeline_barrier(
        //     self.command_buffer,
        //     vk::PipelineStageFlags::TOP_OF_PIPE,
        //     vk::PipelineStageFlags::TRANSFER,
        //     vk::DependencyFlags::empty(),
        //     &[],
        //     &[],
        //     // &[image_frame_memory_barrier, image_sample_memory_barrier],
        //     // &[image_frame_memory_barrier],
        //     &[],
        // );

        // let image_blit = vk::ImageBlit::builder()
        //     .src_subresource(
        //         vk::ImageSubresourceLayers::builder()
        //             .aspect_mask(vk::ImageAspectFlags::COLOR)
        //             .layer_count(1)
        //             .build(),
        //     )
        //     .src_offsets([
        //         vk::Offset3D::default(),
        //         vk::Offset3D::builder()
        //             .x(self.width as i32)
        //             .y(self.height as i32)
        //             .z(1)
        //             .build(),
        //     ])
        //     .dst_subresource(
        //         vk::ImageSubresourceLayers::builder()
        //             .aspect_mask(vk::ImageAspectFlags::COLOR)
        //             .layer_count(1)
        //             .build(),
        //     )
        //     .dst_offsets([
        //         vk::Offset3D::default(),
        //         vk::Offset3D::builder()
        //             .x(self.width as i32)
        //             .y(self.height as i32)
        //             .z(1)
        //             .build(),
        //     ])
        //     .build();
        //
        // self.device.cmd_blit_image(
        //     self.command_buffer,
        //     self.image_frame,
        //     vk::ImageLayout::TRANSFER_SRC_OPTIMAL,
        //     self.image_sample,
        //     vk::ImageLayout::TRANSFER_DST_OPTIMAL,
        //     &[image_blit],
        //     vk::Filter::NEAREST,
        // );

        // let image_sample_memory_barrier = vk::ImageMemoryBarrier::builder()
        //     .src_access_mask(vk::AccessFlags::TRANSFER_WRITE)
        //     .dst_access_mask(vk::AccessFlags::SHADER_READ)
        //     .old_layout(vk::ImageLayout::TRANSFER_DST_OPTIMAL)
        //     .new_layout(vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL)
        //     .src_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
        //     .dst_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
        //     .image(self.image_sample)
        //     .subresource_range(vk::ImageSubresourceRange {
        //         aspect_mask: vk::ImageAspectFlags::COLOR,
        //         base_mip_level: 0,
        //         level_count: 1,
        //         base_array_layer: 0,
        //         layer_count: 1,
        //     })
        //     .build();
        //
        // self.device.cmd_pipeline_barrier(
        //     self.command_buffer,
        //     vk::PipelineStageFlags::TRANSFER,
        //     vk::PipelineStageFlags::COMPUTE_SHADER,
        //     vk::DependencyFlags::empty(),
        //     &[],
        //     &[],
        //     &[image_sample_memory_barrier],
        // );

        // self.device.cmd_bind_pipeline(
        //     self.command_buffer,
        //     vk::PipelineBindPoint::COMPUTE,
        //     self.pipeline,
        // );
        // self.device.cmd_bind_descriptor_sets(
        //     self.command_buffer,
        //     vk::PipelineBindPoint::COMPUTE,
        //     self.pipeline_layout,
        //     0,
        //     &[self.descriptor_set_color_conversion],
        //     &[],
        // );
        //
        // self.device.cmd_dispatch(
        //     self.command_buffer,
        //     (self.width + 4 - 1) / 4,
        //     (self.height + 4 - 1) / 4,
        //     1,
        // );
        //
        // let buffer_memory_barrier = vk::BufferMemoryBarrier::builder()
        //     .src_access_mask(vk::AccessFlags::SHADER_WRITE)
        //     .dst_access_mask(vk::AccessFlags::HOST_READ)
        //     .src_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
        //     .dst_queue_family_index(vk::QUEUE_FAMILY_IGNORED)
        //     .buffer(self.buffer)
        //     .offset(0)
        //     .size(vk::WHOLE_SIZE)
        //     .build();
        //
        // self.device.cmd_pipeline_barrier(
        //     self.command_buffer,
        //     vk::PipelineStageFlags::COMPUTE_SHADER,
        //     vk::PipelineStageFlags::HOST,
        //     vk::DependencyFlags::empty(),
        //     &[],
        //     &[buffer_memory_barrier],
        //     &[],
        // );

        self.device.end_command_buffer(self.command_buffer).unwrap();

        // let create_info = vk::FenceCreateInfo::default();
        // let fence = self.device.create_fence(&create_info, None).unwrap();

        let submit_info = vk::SubmitInfo::builder()
            // .wait_semaphores(&[self.semaphore])
            // .wait_dst_stage_mask(&[vk::PipelineStageFlags::ALL_COMMANDS])
            .command_buffers(&[self.command_buffer])
            .build();
        self.device
        //     .queue_submit(self.queue, &[submit_info], fence)
            .queue_submit(self.queue, &[submit_info], vk::Fence::null())
            .unwrap();

        // self.device
        //     .wait_for_fences(&[fence], true, u64::max_value())
        //     .unwrap();

        // let pixels = self
        //     .device
        //     .map_memory(
        //         self.buffer_memory,
        //         0,
        //         vk::WHOLE_SIZE,
        //         vk::MemoryMapFlags::empty(),
        //     )
        //     .unwrap();

        // let mapped_memory_range = vk::MappedMemoryRange::builder()
        //     .memory(self.buffer_memory)
        //     .size(vk::WHOLE_SIZE)
        //     .build();
        // self.device
        //     .invalidate_mapped_memory_ranges(&[mapped_memory_range])
        //     .unwrap();
        //
        // // Save into a file.
        // {
        //     let pixels: &[u8] = slice::from_raw_parts(
        //         pixels.cast(),
        //         self.width as usize * self.height as usize / 2 * 3,
        //     );
        //     std::fs::write("image.yuv", pixels).unwrap();
        //     // image::save_buffer(
        //     //     "image.png",
        //     //     pixels,
        //     //     self.width,
        //     //     self.height,
        //     //     image::ColorType::Rgb8,
        //     // )
        //     // .unwrap();
        // }
        //
        // self.device.unmap_memory(self.buffer_memory);

        // Cleanup.
        // self.device.destroy_fence(fence, None);
    }
}

pub fn init(width: u32, height: u32) -> Vulkan {
    assert!(width % 2 == 0 && height % 2 == 0); // TODO: handle weird resolutions.

    // Entry, instance.
    let entry = ash::Entry::new().unwrap();
    let app_info = vk::ApplicationInfo {
        api_version: vk::make_version(1, 2, 0),
        ..Default::default()
    };
    let create_info = vk::InstanceCreateInfo::builder()
        .application_info(&app_info)
        .enabled_extension_names(&[DebugUtils::name().as_ptr()])
        // .enabled_layer_names(&[b"VK_LAYER_KHRONOS_validation\0".as_ptr().cast()])
        .build();
    let instance = unsafe { entry.create_instance(&create_info, None).unwrap() };

    // Debug utils.
    let debug_utils = DebugUtils::new(&entry, &instance);
    let create_info = vk::DebugUtilsMessengerCreateInfoEXT {
        message_severity: vk::DebugUtilsMessageSeverityFlagsEXT::WARNING
            | vk::DebugUtilsMessageSeverityFlagsEXT::ERROR,
        message_type: vk::DebugUtilsMessageTypeFlagsEXT::all(),
        pfn_user_callback: Some(debug_utils_callback),
        ..Default::default()
    };
    let debug_messenger = unsafe {
        debug_utils
            .create_debug_utils_messenger(&create_info, None)
            .unwrap()
    };

    // Physical device.
    let physical_devices = unsafe { instance.enumerate_physical_devices().unwrap() };
    let mut physical_device_index = 0;
    debug!("physical devices:");
    for (i, &device) in physical_devices.iter().enumerate() {
        let properties = unsafe { instance.get_physical_device_properties(device) };
        debug!("\t{}: [{:?}] {}", i, properties.device_type, unsafe {
            make_str(properties.device_name.as_ptr())
        });

        if properties.device_type == vk::PhysicalDeviceType::DISCRETE_GPU {
            physical_device_index = i;
        }
    }

    debug!("choosing physical device {}", physical_device_index);
    let physical_device = physical_devices[physical_device_index];

    // Memory properties.
    let memory_properties =
        unsafe { instance.get_physical_device_memory_properties(physical_device) };

    // Queue family index.
    let queue_family_properties =
        unsafe { instance.get_physical_device_queue_family_properties(physical_device) };
    let queue_family_index = queue_family_properties
        .into_iter()
        .enumerate()
        .find(|(_, properties)| properties.queue_flags.contains(vk::QueueFlags::COMPUTE))
        .map(|(i, _)| i)
        .unwrap() as u32;

    // Logical device.
    let create_info = vk::DeviceCreateInfo::builder()
        .queue_create_infos(&[vk::DeviceQueueCreateInfo::builder()
            .queue_family_index(queue_family_index)
            .queue_priorities(&[1.])
            .build()])
        .enabled_extension_names(&[
            ExternalMemoryFd::name().as_ptr(),
            vk::KhrExternalSemaphoreFdFn::name().as_ptr(),
        ])
        .push_next(
            &mut vk::PhysicalDevice8BitStorageFeatures::builder().storage_buffer8_bit_access(true),
        )
        .build();
    let device = unsafe {
        instance
            .create_device(physical_device, &create_info, None)
            .unwrap()
    };

    // Command pool.
    let create_info = vk::CommandPoolCreateInfo::builder()
        .queue_family_index(queue_family_index)
        .flags(vk::CommandPoolCreateFlags::RESET_COMMAND_BUFFER)
        .build();
    let command_pool = unsafe { device.create_command_pool(&create_info, None).unwrap() };

    // Command buffer.
    let create_info = vk::CommandBufferAllocateInfo::builder()
        .command_pool(command_pool)
        .level(vk::CommandBufferLevel::PRIMARY)
        .command_buffer_count(1)
        .build();
    let command_buffer = unsafe { device.allocate_command_buffers(&create_info).unwrap() }[0];

    // Queue.
    let queue = unsafe { device.get_device_queue(queue_family_index, 0) };

    // Image for the OpenGL frame.
    let create_info = vk::ImageCreateInfo {
        image_type: vk::ImageType::TYPE_2D,
        format: vk::Format::R8G8B8A8_UNORM,
        extent: vk::Extent3D {
            width,
            height,
            depth: 1,
        },
        mip_levels: 1,
        array_layers: 1,
        samples: vk::SampleCountFlags::TYPE_1,
        tiling: vk::ImageTiling::OPTIMAL,
        // Required for exporting to OpenGL.
        usage: vk::ImageUsageFlags::TRANSFER_SRC
            | vk::ImageUsageFlags::TRANSFER_DST
            | vk::ImageUsageFlags::SAMPLED
            | vk::ImageUsageFlags::STORAGE
            | vk::ImageUsageFlags::COLOR_ATTACHMENT
            | vk::ImageUsageFlags::INPUT_ATTACHMENT,
        sharing_mode: vk::SharingMode::EXCLUSIVE,
        ..Default::default()
    };
    let image_frame = unsafe { device.create_image(&create_info, None).unwrap() };

    let image_frame_memory_requirements =
        unsafe { device.get_image_memory_requirements(image_frame) };
    let image_frame_memory_type_index = find_memorytype_index(
        &image_frame_memory_requirements,
        &memory_properties,
        vk::MemoryPropertyFlags::DEVICE_LOCAL,
    )
    .unwrap();
    let create_info = vk::MemoryAllocateInfo::builder()
        .allocation_size(image_frame_memory_requirements.size)
        .memory_type_index(image_frame_memory_type_index)
        .push_next(
            &mut vk::ExportMemoryAllocateInfo::builder()
                .handle_types(
                    vk::ExternalMemoryHandleTypeFlags::EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD,
                )
                .build(),
        )
        .push_next(
            &mut vk::MemoryDedicatedAllocateInfo::builder()
                .image(image_frame)
                .build(),
        )
        .build();
    let image_frame_memory = unsafe { device.allocate_memory(&create_info, None).unwrap() };
    unsafe {
        device
            .bind_image_memory(image_frame, image_frame_memory, 0)
            .unwrap()
    };

    // External memory.
    let external_memory_fd = ExternalMemoryFd::new(&instance, &device);

    // Sampler for the image for the OpenGL frame.
    let create_info = vk::SamplerCreateInfo::builder()
        .address_mode_u(vk::SamplerAddressMode::CLAMP_TO_EDGE)
        .address_mode_v(vk::SamplerAddressMode::CLAMP_TO_EDGE)
        .address_mode_w(vk::SamplerAddressMode::CLAMP_TO_EDGE)
        .unnormalized_coordinates(true);
    let sampler_frame = unsafe { device.create_sampler(&create_info, None).unwrap() };

    // Image view for the image for the OpenGL frame.
    let create_info = vk::ImageViewCreateInfo::builder()
        .image(image_frame)
        .view_type(vk::ImageViewType::TYPE_2D)
        .format(vk::Format::R8G8B8A8_UNORM)
        .subresource_range(vk::ImageSubresourceRange {
            aspect_mask: vk::ImageAspectFlags::COLOR,
            base_mip_level: 0,
            level_count: 1,
            base_array_layer: 0,
            layer_count: 1,
        });
    let image_view_frame = unsafe { device.create_image_view(&create_info, None).unwrap() };

    // Image for the sampling buffer.
    let create_info = vk::ImageCreateInfo {
        image_type: vk::ImageType::TYPE_2D,
        format: vk::Format::R16G16B16A16_UNORM,
        extent: vk::Extent3D {
            width,
            height,
            depth: 1,
        },
        mip_levels: 1,
        array_layers: 1,
        samples: vk::SampleCountFlags::TYPE_1,
        tiling: vk::ImageTiling::OPTIMAL,
        usage: vk::ImageUsageFlags::STORAGE // For updating during the sampling stage.
            | vk::ImageUsageFlags::TRANSFER_DST | vk::ImageUsageFlags::TRANSFER_SRC
            | vk::ImageUsageFlags::SAMPLED, // For reading during YUV conversion.
        sharing_mode: vk::SharingMode::EXCLUSIVE,
        ..Default::default()
    };
    let image_sample = unsafe { device.create_image(&create_info, None).unwrap() };

    let image_sample_memory_requirements =
        unsafe { device.get_image_memory_requirements(image_sample) };
    let image_sample_memory_type_index = find_memorytype_index(
        &image_sample_memory_requirements,
        &memory_properties,
        vk::MemoryPropertyFlags::DEVICE_LOCAL,
    )
    .unwrap();
    let create_info = vk::MemoryAllocateInfo::builder()
        .allocation_size(image_sample_memory_requirements.size)
        .memory_type_index(image_sample_memory_type_index)
        .build();
    let image_sample_memory = unsafe { device.allocate_memory(&create_info, None).unwrap() };
    unsafe {
        device
            .bind_image_memory(image_sample, image_sample_memory, 0)
            .unwrap()
    };

    // Sampler for the image for the sampling buffer.
    let create_info = vk::SamplerCreateInfo::builder()
        .address_mode_u(vk::SamplerAddressMode::CLAMP_TO_EDGE)
        .address_mode_v(vk::SamplerAddressMode::CLAMP_TO_EDGE)
        .address_mode_w(vk::SamplerAddressMode::CLAMP_TO_EDGE)
        .unnormalized_coordinates(true);
    let sampler_sample = unsafe { device.create_sampler(&create_info, None).unwrap() };

    // Image view for the image for the sampling buffer.
    let create_info = vk::ImageViewCreateInfo::builder()
        .image(image_sample)
        .view_type(vk::ImageViewType::TYPE_2D)
        .format(vk::Format::R16G16B16A16_UNORM)
        .subresource_range(vk::ImageSubresourceRange {
            aspect_mask: vk::ImageAspectFlags::COLOR,
            base_mip_level: 0,
            level_count: 1,
            base_array_layer: 0,
            layer_count: 1,
        });
    let image_view_sample = unsafe { device.create_image_view(&create_info, None).unwrap() };

    // Semaphore.
    let create_info = vk::SemaphoreCreateInfo::builder()
        .push_next(
            &mut vk::ExportSemaphoreCreateInfo::builder()
                .handle_types(
                    vk::ExternalSemaphoreHandleTypeFlags::EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD,
                )
                .build(),
        )
        .build();
    let semaphore = unsafe { device.create_semaphore(&create_info, None).unwrap() };

    // Export semaphore.
    let external_semaphore_fd_fn = vk::KhrExternalSemaphoreFdFn::load(|name| unsafe {
        mem::transmute(instance.get_device_proc_addr(device.handle(), name.as_ptr()))
    });

    // Buffer for reading image pixels.
    let create_info = vk::BufferCreateInfo::builder()
        .size(width as u64 * height as u64 / 2 * 3) // Full-res Y + quarter-res U, V.
        .usage(vk::BufferUsageFlags::STORAGE_BUFFER)
        .sharing_mode(vk::SharingMode::EXCLUSIVE)
        .build();
    let buffer = unsafe { device.create_buffer(&create_info, None).unwrap() };

    let buffer_memory_requirements = unsafe { device.get_buffer_memory_requirements(buffer) };
    let buffer_memory_type_index = find_memorytype_index(
        &buffer_memory_requirements,
        &memory_properties,
        vk::MemoryPropertyFlags::HOST_VISIBLE,
    )
    .unwrap();
    let create_info = vk::MemoryAllocateInfo::builder()
        .allocation_size(buffer_memory_requirements.size)
        .memory_type_index(buffer_memory_type_index)
        .build();
    let buffer_memory = unsafe { device.allocate_memory(&create_info, None).unwrap() };
    unsafe { device.bind_buffer_memory(buffer, buffer_memory, 0).unwrap() };

    // Descriptor set layout for the color conversion shader.
    let create_info = vk::DescriptorSetLayoutCreateInfo::builder()
        .bindings(&[
            vk::DescriptorSetLayoutBinding::builder()
                .binding(0)
                .descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
                .descriptor_count(1)
                .stage_flags(vk::ShaderStageFlags::COMPUTE)
                .immutable_samplers(&[sampler_sample])
                .build(),
            vk::DescriptorSetLayoutBinding::builder()
                .binding(1)
                .descriptor_type(vk::DescriptorType::STORAGE_BUFFER)
                .descriptor_count(1)
                .stage_flags(vk::ShaderStageFlags::COMPUTE)
                .build(),
        ])
        .build();
    let descriptor_set_layout_color_conversion = unsafe {
        device
            .create_descriptor_set_layout(&create_info, None)
            .unwrap()
    };

    // Descriptor pool.
    let create_info = vk::DescriptorPoolCreateInfo::builder()
        .max_sets(1)
        .pool_sizes(&[
            vk::DescriptorPoolSize {
                ty: vk::DescriptorType::COMBINED_IMAGE_SAMPLER,
                descriptor_count: 1,
            },
            vk::DescriptorPoolSize {
                ty: vk::DescriptorType::STORAGE_BUFFER,
                descriptor_count: 1,
            },
        ])
        .build();
    let descriptor_pool = unsafe { device.create_descriptor_pool(&create_info, None).unwrap() };

    // Descriptor set.
    let create_info = vk::DescriptorSetAllocateInfo::builder()
        .descriptor_pool(descriptor_pool)
        .set_layouts(&[descriptor_set_layout_color_conversion])
        .build();
    let descriptor_set_color_conversion =
        unsafe { device.allocate_descriptor_sets(&create_info).unwrap()[0] };

    unsafe {
        device.update_descriptor_sets(
            &[
                vk::WriteDescriptorSet::builder()
                    .dst_set(descriptor_set_color_conversion)
                    .dst_binding(0)
                    .descriptor_type(vk::DescriptorType::COMBINED_IMAGE_SAMPLER)
                    .image_info(&[vk::DescriptorImageInfo {
                        sampler: sampler_sample,
                        image_view: image_view_sample,
                        image_layout: vk::ImageLayout::SHADER_READ_ONLY_OPTIMAL,
                    }])
                    .build(),
                vk::WriteDescriptorSet::builder()
                    .dst_set(descriptor_set_color_conversion)
                    .dst_binding(1)
                    .descriptor_type(vk::DescriptorType::STORAGE_BUFFER)
                    .buffer_info(&[vk::DescriptorBufferInfo {
                        buffer,
                        offset: 0,
                        range: vk::WHOLE_SIZE,
                    }])
                    .build(),
            ],
            &[],
        )
    };

    // Shader.
    let shader_code = include_bytes!("color_conversion.spv");
    assert_eq!(shader_code.len() % 4, 0);
    let shader_code =
        unsafe { slice::from_raw_parts(shader_code.as_ptr().cast(), shader_code.len() / 4) };

    let create_info = vk::ShaderModuleCreateInfo::builder().code(shader_code);
    let shader_module = unsafe { device.create_shader_module(&create_info, None).unwrap() };

    // Pipeline.
    let create_info = vk::PipelineLayoutCreateInfo::builder()
        .set_layouts(&[descriptor_set_layout_color_conversion])
        .build();
    let pipeline_layout = unsafe { device.create_pipeline_layout(&create_info, None).unwrap() };

    let create_info = vk::ComputePipelineCreateInfo::builder()
        .stage(
            vk::PipelineShaderStageCreateInfo::builder()
                .stage(vk::ShaderStageFlags::COMPUTE)
                .module(shader_module)
                .name(unsafe { CStr::from_ptr(b"main\0".as_ptr().cast()) })
                .build(),
        )
        .layout(pipeline_layout)
        .build();
    let pipeline = unsafe {
        device
            .create_compute_pipelines(vk::PipelineCache::null(), &[create_info], None)
            .unwrap()[0]
    };

    Vulkan {
        width,
        height,
        entry,
        instance,
        debug_utils,
        debug_messenger,
        queue_family_index,
        device,
        command_pool,
        command_buffer,
        queue,
        image_frame,
        image_frame_memory,
        image_frame_memory_size: image_frame_memory_requirements.size,
        external_memory_fd,
        sampler_frame,
        image_view_frame,
        image_sample,
        image_sample_memory,
        sampler_sample,
        image_view_sample,
        semaphore,
        external_semaphore_fd_fn,
        buffer,
        buffer_memory,
        descriptor_set_layout_color_conversion,
        descriptor_pool,
        descriptor_set_color_conversion,
        shader_module,
        pipeline_layout,
        pipeline,
    }
}

unsafe fn make_str<'a>(bytes: *const c_char) -> &'a str {
    str::from_utf8_unchecked(CStr::from_ptr(bytes).to_bytes())
}

unsafe extern "system" fn debug_utils_callback(
    message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
    message_types: vk::DebugUtilsMessageTypeFlagsEXT,
    p_callback_data: *const vk::DebugUtilsMessengerCallbackDataEXT,
    _p_user_data: *mut c_void,
) -> vk::Bool32 {
    info!(
        "{:?} {:?} {}",
        message_severity,
        message_types,
        make_str((*p_callback_data).p_message)
    );
    vk::FALSE
}

// https://github.com/MaikKlein/ash/blob/8d7dfee763733a17f4644397458b7391696a990c/examples/src/lib.rs#L239-L272
fn find_memorytype_index(
    memory_req: &vk::MemoryRequirements,
    memory_prop: &vk::PhysicalDeviceMemoryProperties,
    flags: vk::MemoryPropertyFlags,
) -> Option<u32> {
    // Try to find an exactly matching memory flag
    let best_suitable_index =
        find_memorytype_index_f(memory_req, memory_prop, flags, |property_flags, flags| {
            property_flags == flags
        });
    if best_suitable_index.is_some() {
        return best_suitable_index;
    }
    // Otherwise find a memory flag that works
    find_memorytype_index_f(memory_req, memory_prop, flags, |property_flags, flags| {
        property_flags & flags == flags
    })
}

fn find_memorytype_index_f<F: Fn(vk::MemoryPropertyFlags, vk::MemoryPropertyFlags) -> bool>(
    memory_req: &vk::MemoryRequirements,
    memory_prop: &vk::PhysicalDeviceMemoryProperties,
    flags: vk::MemoryPropertyFlags,
    f: F,
) -> Option<u32> {
    let mut memory_type_bits = memory_req.memory_type_bits;
    for (index, ref memory_type) in memory_prop.memory_types.iter().enumerate() {
        if memory_type_bits & 1 == 1 && f(memory_type.property_flags, flags) {
            return Some(index as u32);
        }
        memory_type_bits >>= 1;
    }
    None
}