tsv integration, split binaries

1 files changed, 141 insertions, 0 deletions

diff --git a/src/gpu.rs b/src/gpu.rs
new file mode 100644
index 0000000..e6529f9
--- /dev/null
+++ b/src/gpu.rs
@@ -0,0 +1,141 @@
+use std::time::Duration;
+
+use ash::vk;
+use texture_share_vk_base::vk_device::VkDevice;
+use texture_share_vk_base::vk_entry::VkEntry;
+use texture_share_vk_base::vk_instance::VkInstance;
+use texture_share_vk_base::vk_setup::VkSetup;
+use texture_share_vk_client::VkClient;
+
+const TSV_SERVER_EXECUTABLE: &str = "/usr/bin/texture-share-vk-server";
+const TSV_SERVER_SOCKET_PATH: &str = "/tmp/vk_server/vk_server.sock";
+const TSV_SERVER_LOCK_PATH: &str = "/tmp/vk_server/vk_server.lock";
+const TSV_SHMEM_PREFIX: &str = "shmem_img_";
+
+/// Creates a wgpu instance configured for Vulkan.
+pub fn create_instance() -> wgpu::Instance {
+    wgpu::Instance::new(wgpu::InstanceDescriptor {
+        backends: wgpu::Backends::VULKAN,
+        flags: wgpu::InstanceFlags::default(),
+        backend_options: wgpu::BackendOptions::default(),
+        memory_budget_thresholds: wgpu::MemoryBudgetThresholds::default(),
+        display: None,
+    })
+}
+
+/// Requests a wgpu adapter, optionally compatible with a surface.
+pub fn create_adapter(
+    instance: &wgpu::Instance,
+    surface: Option<&wgpu::Surface<'_>>,
+) -> wgpu::Adapter {
+    pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+        power_preference: wgpu::PowerPreference::HighPerformance,
+        compatible_surface: surface,
+        force_fallback_adapter: false,
+    }))
+    .expect("find vulkan adapter")
+}
+
+/// Requests a wgpu device + queue.
+pub fn create_device(adapter: &wgpu::Adapter) -> (wgpu::Device, wgpu::Queue) {
+    pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+        label: Some("device"),
+        ..Default::default()
+    }))
+    .expect("create device")
+}
+
+/// Builds a texture-share-vk VkSetup by importing raw Vulkan handles from a wgpu device.
+/// The returned VkSetup does NOT own the Vulkan objects (import_only = true).
+fn import_vk_setup(device: &wgpu::Device) -> VkSetup {
+    // Extract raw handles from the wgpu HAL device
+    let (raw_instance, raw_device, raw_physical_device, raw_queue, queue_family_index, queue_index) = unsafe {
+        let hal = device
+            .as_hal::<wgpu_hal::api::Vulkan>()
+            .expect("vulkan HAL device");
+
+        let instance_shared = hal.shared_instance();
+        let raw_instance = instance_shared.raw_instance().handle();
+        let raw_device = hal.raw_device().handle();
+        let raw_physical_device = hal.raw_physical_device();
+        let raw_queue = hal.raw_queue();
+        let queue_family_index = hal.queue_family_index();
+        let queue_index = hal.queue_index();
+
+        (
+            raw_instance,
+            raw_device,
+            raw_physical_device,
+            raw_queue,
+            queue_family_index,
+            queue_index,
+        )
+    };
+
+    let vk_entry = Box::new(VkEntry::new().expect("vulkan entry"));
+    let vk_instance =
+        VkInstance::import_vk(Some(vk_entry), raw_instance, true).expect("import vulkan instance");
+    let vk_device = VkDevice::import_vk(
+        &vk_instance,
+        raw_device,
+        raw_physical_device,
+        raw_queue,
+        queue_family_index,
+        queue_index,
+        true,
+    )
+    .expect("import vulkan device");
+
+    VkSetup::new(vk_instance, vk_device)
+}
+
+/// Creates a VkClient connected to the texture-share-vk server,
+/// launching the server if needed.
+pub fn create_tsv_client(device: &wgpu::Device) -> VkClient {
+    let vk_setup = import_vk_setup(device);
+    let timeout = Duration::from_secs(2);
+
+    VkClient::new_with_server_launch(
+        TSV_SERVER_SOCKET_PATH,
+        Box::new(vk_setup),
+        Duration::from_secs(1),
+        TSV_SERVER_EXECUTABLE,
+        TSV_SERVER_LOCK_PATH,
+        TSV_SERVER_SOCKET_PATH,
+        TSV_SHMEM_PREFIX,
+        timeout,
+        timeout,
+        timeout,
+        timeout,
+        timeout,
+    )
+    .expect("connect to texture-share-vk server")
+}
+
+/// Image format for texture-share-vk, matching RGBA8.
+pub const TSV_FORMAT: texture_share_vk_base::ipc::platform::img_data::ImgFormat =
+    texture_share_vk_base::ipc::platform::img_data::ImgFormat::R8G8B8A8;
+
+/// Extracts the raw vk::Image handle from a wgpu Texture.
+///
+/// # Safety
+/// The returned handle must not outlive the texture.
+pub unsafe fn raw_image(texture: &wgpu::Texture) -> vk::Image {
+    let hal = texture
+        .as_hal::<wgpu_hal::api::Vulkan>()
+        .expect("vulkan HAL texture");
+    hal.raw_handle()
+}
+
+/// Creates a vk::Fence on the VkClient's device.
+pub fn create_fence(client: &VkClient) -> vk::Fence {
+    let device = &client.get_vk_setup().device.device;
+    let create_info = vk::FenceCreateInfo::default();
+    unsafe { device.create_fence(&create_info, None) }.expect("create fence")
+}
+
+/// Destroys a vk::Fence.
+pub fn destroy_fence(client: &VkClient, fence: vk::Fence) {
+    let device = &client.get_vk_setup().device.device;
+    unsafe { device.destroy_fence(fence, None) };
+}