1/* 2 * Copyright © 2019 Red Hat. 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 */ 23 24#pragma once 25#include <stdlib.h> 26#include <stdio.h> 27#include <stdbool.h> 28#include <string.h> 29#include <assert.h> 30#include <stdint.h> 31 32#include "util/macros.h" 33#include "util/list.h" 34#include "util/u_dynarray.h" 35#include "util/simple_mtx.h" 36#include "util/u_queue.h" 37 38#include "compiler/shader_enums.h" 39#include "pipe/p_screen.h" 40#include "pipe/p_state.h" 41#include "cso_cache/cso_context.h" 42#include "nir.h" 43 44/* Pre-declarations needed for WSI entrypoints */ 45struct wl_surface; 46struct wl_display; 47typedef struct xcb_connection_t xcb_connection_t; 48typedef uint32_t xcb_visualid_t; 49typedef uint32_t xcb_window_t; 50 51#define VK_PROTOTYPES 52#include <vulkan/vulkan.h> 53#include <vulkan/vk_icd.h> 54 55#include "lvp_entrypoints.h" 56#include "vk_device.h" 57#include "vk_instance.h" 58#include "vk_image.h" 59#include "vk_log.h" 60#include "vk_physical_device.h" 61#include "vk_shader_module.h" 62#include "vk_util.h" 63#include "vk_format.h" 64#include "vk_cmd_queue.h" 65#include "vk_command_buffer.h" 66#include "vk_queue.h" 67 68#include "wsi_common.h" 69 70#include <assert.h> 71#ifdef __cplusplus 72extern "C" { 73#endif 74 75#define MAX_SETS 8 76#define MAX_PUSH_CONSTANTS_SIZE 128 77#define MAX_PUSH_DESCRIPTORS 32 78 79#ifdef _WIN32 80#define lvp_printflike(a, b) 81#else 82#define lvp_printflike(a, b) __attribute__((__format__(__printf__, a, b))) 83#endif 84 85int lvp_get_instance_entrypoint_index(const char *name); 86int lvp_get_device_entrypoint_index(const char *name); 87int lvp_get_physical_device_entrypoint_index(const char *name); 88 89const char *lvp_get_instance_entry_name(int index); 90const char *lvp_get_physical_device_entry_name(int index); 91const char *lvp_get_device_entry_name(int index); 92 93bool lvp_instance_entrypoint_is_enabled(int index, uint32_t core_version, 94 const struct vk_instance_extension_table *instance); 95bool lvp_physical_device_entrypoint_is_enabled(int index, uint32_t core_version, 96 const struct vk_instance_extension_table *instance); 97bool lvp_device_entrypoint_is_enabled(int index, uint32_t core_version, 98 const struct vk_instance_extension_table *instance, 99 const struct vk_device_extension_table *device); 100 101#define LVP_DEBUG_ALL_ENTRYPOINTS (1 << 0) 102 103void __lvp_finishme(const char *file, int line, const char *format, ...) 104 lvp_printflike(3, 4); 105 106#define lvp_finishme(format, ...) \ 107 __lvp_finishme(__FILE__, __LINE__, format, ##__VA_ARGS__); 108 109#define stub_return(v) \ 110 do { \ 111 lvp_finishme("stub %s", __func__); \ 112 return (v); \ 113 } while (0) 114 115#define stub() \ 116 do { \ 117 lvp_finishme("stub %s", __func__); \ 118 return; \ 119 } while (0) 120 121#define LVP_STAGE_MASK ((1 << MESA_SHADER_STAGES) - 1) 122 123#define lvp_foreach_stage(stage, stage_bits) \ 124 for (gl_shader_stage stage, \ 125 __tmp = (gl_shader_stage)((stage_bits) & LVP_STAGE_MASK); \ 126 stage = ffs(__tmp) - 1, __tmp; \ 127 __tmp &= ~(1 << (stage))) 128 129struct lvp_physical_device { 130 struct vk_physical_device vk; 131 132 struct pipe_loader_device *pld; 133 struct pipe_screen *pscreen; 134 uint32_t max_images; 135 136 struct wsi_device wsi_device; 137}; 138 139struct lvp_instance { 140 struct vk_instance vk; 141 142 uint32_t apiVersion; 143 int physicalDeviceCount; 144 struct lvp_physical_device physicalDevice; 145 146 uint64_t debug_flags; 147 148 struct pipe_loader_device *devs; 149 int num_devices; 150}; 151 152VkResult lvp_init_wsi(struct lvp_physical_device *physical_device); 153void lvp_finish_wsi(struct lvp_physical_device *physical_device); 154 155bool lvp_physical_device_extension_supported(struct lvp_physical_device *dev, 156 const char *name); 157 158struct lvp_queue { 159 struct vk_queue vk; 160 struct lvp_device * device; 161 struct pipe_context *ctx; 162 struct cso_context *cso; 163 bool shutdown; 164 uint64_t timeline; 165 struct util_queue queue; 166 simple_mtx_t last_lock; 167 uint64_t last_finished; 168 uint64_t last_fence_timeline; 169 struct pipe_fence_handle *last_fence; 170 volatile int count; 171}; 172 173struct lvp_semaphore_wait { 174 struct lvp_semaphore *sema; 175 uint64_t wait; 176}; 177 178struct lvp_queue_work { 179 struct list_head list; 180 uint32_t cmd_buffer_count; 181 uint32_t timeline_count; 182 uint32_t wait_count; 183 uint64_t timeline; 184 struct lvp_fence *fence; 185 struct lvp_cmd_buffer **cmd_buffers; 186 struct lvp_semaphore_timeline **timelines; 187 VkSemaphore *waits; 188 uint64_t *wait_vals; 189}; 190 191struct lvp_pipeline_cache { 192 struct vk_object_base base; 193 struct lvp_device * device; 194 VkAllocationCallbacks alloc; 195}; 196 197struct lvp_device { 198 struct vk_device vk; 199 200 struct lvp_queue queue; 201 struct lvp_instance * instance; 202 struct lvp_physical_device *physical_device; 203 struct pipe_screen *pscreen; 204}; 205 206void lvp_device_get_cache_uuid(void *uuid); 207 208enum lvp_device_memory_type { 209 LVP_DEVICE_MEMORY_TYPE_DEFAULT, 210 LVP_DEVICE_MEMORY_TYPE_USER_PTR, 211 LVP_DEVICE_MEMORY_TYPE_OPAQUE_FD, 212}; 213 214struct lvp_device_memory { 215 struct vk_object_base base; 216 struct pipe_memory_allocation *pmem; 217 uint32_t type_index; 218 VkDeviceSize map_size; 219 void * map; 220 enum lvp_device_memory_type memory_type; 221 int backed_fd; 222}; 223 224struct lvp_image { 225 struct vk_image vk; 226 VkDeviceSize size; 227 uint32_t alignment; 228 struct pipe_memory_allocation *pmem; 229 unsigned memory_offset; 230 struct pipe_resource *bo; 231}; 232 233static inline uint32_t 234lvp_get_layerCount(const struct lvp_image *image, 235 const VkImageSubresourceRange *range) 236{ 237 return range->layerCount == VK_REMAINING_ARRAY_LAYERS ? 238 image->bo->array_size - range->baseArrayLayer : range->layerCount; 239} 240 241static inline uint32_t 242lvp_get_levelCount(const struct lvp_image *image, 243 const VkImageSubresourceRange *range) 244{ 245 return range->levelCount == VK_REMAINING_MIP_LEVELS ? 246 (image->bo->last_level + 1) - range->baseMipLevel : range->levelCount; 247} 248 249struct lvp_image_view { 250 struct vk_object_base base; 251 const struct lvp_image *image; /**< VkImageViewCreateInfo::image */ 252 253 VkImageViewType view_type; 254 VkFormat format; 255 enum pipe_format pformat; 256 VkComponentMapping components; 257 VkImageSubresourceRange subresourceRange; 258 259 struct pipe_surface *surface; /* have we created a pipe surface for this? */ 260}; 261 262struct lvp_subpass_attachment { 263 uint32_t attachment; 264 VkImageLayout layout; 265 bool in_render_loop; 266}; 267 268struct lvp_subpass { 269 uint32_t attachment_count; 270 struct lvp_subpass_attachment * attachments; 271 272 uint32_t input_count; 273 uint32_t color_count; 274 struct lvp_subpass_attachment * input_attachments; 275 struct lvp_subpass_attachment * color_attachments; 276 struct lvp_subpass_attachment * resolve_attachments; 277 struct lvp_subpass_attachment * depth_stencil_attachment; 278 struct lvp_subpass_attachment * ds_resolve_attachment; 279 VkResolveModeFlagBits depth_resolve_mode; 280 VkResolveModeFlagBits stencil_resolve_mode; 281 282 /** Subpass has at least one color resolve attachment */ 283 bool has_color_resolve; 284 285 /** Subpass has at least one color attachment */ 286 bool has_color_att; 287 288 VkSampleCountFlagBits max_sample_count; 289 290 uint32_t view_mask; 291}; 292 293struct lvp_render_pass_attachment { 294 VkFormat format; 295 uint32_t samples; 296 VkAttachmentLoadOp load_op; 297 VkAttachmentLoadOp stencil_load_op; 298 VkImageLayout initial_layout; 299 VkImageLayout final_layout; 300 301 /* The subpass id in which the attachment will be used first/last. */ 302 uint32_t first_subpass_idx; 303 uint32_t last_subpass_idx; 304}; 305 306struct lvp_render_pass { 307 struct vk_object_base base; 308 uint32_t attachment_count; 309 uint32_t subpass_count; 310 struct lvp_subpass_attachment * subpass_attachments; 311 struct lvp_render_pass_attachment * attachments; 312 bool has_color_attachment; 313 bool has_zs_attachment; 314 struct lvp_subpass subpasses[0]; 315}; 316 317struct lvp_sampler { 318 struct vk_object_base base; 319 VkSamplerCreateInfo create_info; 320 union pipe_color_union border_color; 321 VkSamplerReductionMode reduction_mode; 322 uint32_t state[4]; 323}; 324 325struct lvp_framebuffer { 326 struct vk_object_base base; 327 uint32_t width; 328 uint32_t height; 329 uint32_t layers; 330 331 bool imageless; 332 uint32_t attachment_count; 333 struct lvp_image_view * attachments[0]; 334}; 335 336struct lvp_descriptor_set_binding_layout { 337 uint16_t descriptor_index; 338 /* Number of array elements in this binding */ 339 VkDescriptorType type; 340 uint16_t array_size; 341 bool valid; 342 343 int16_t dynamic_index; 344 struct { 345 int16_t const_buffer_index; 346 int16_t shader_buffer_index; 347 int16_t sampler_index; 348 int16_t sampler_view_index; 349 int16_t image_index; 350 } stage[MESA_SHADER_STAGES]; 351 352 /* Immutable samplers (or NULL if no immutable samplers) */ 353 struct lvp_sampler **immutable_samplers; 354}; 355 356struct lvp_descriptor_set_layout { 357 struct vk_object_base base; 358 359 const VkAllocationCallbacks *alloc; 360 /* Descriptor set layouts can be destroyed at almost any time */ 361 uint32_t ref_cnt; 362 363 /* Number of bindings in this descriptor set */ 364 uint16_t binding_count; 365 366 /* Total size of the descriptor set with room for all array entries */ 367 uint16_t size; 368 369 /* Shader stages affected by this descriptor set */ 370 uint16_t shader_stages; 371 372 struct { 373 uint16_t const_buffer_count; 374 uint16_t shader_buffer_count; 375 uint16_t sampler_count; 376 uint16_t sampler_view_count; 377 uint16_t image_count; 378 } stage[MESA_SHADER_STAGES]; 379 380 /* Number of dynamic offsets used by this descriptor set */ 381 uint16_t dynamic_offset_count; 382 383 /* Bindings in this descriptor set */ 384 struct lvp_descriptor_set_binding_layout binding[0]; 385}; 386 387void lvp_descriptor_set_layout_destroy(struct lvp_device *device, 388 struct lvp_descriptor_set_layout *layout); 389 390static inline void 391lvp_descriptor_set_layout_ref(struct lvp_descriptor_set_layout *layout) 392{ 393 assert(layout && layout->ref_cnt >= 1); 394 p_atomic_inc(&layout->ref_cnt); 395} 396 397static inline void 398lvp_descriptor_set_layout_unref(struct lvp_device *device, 399 struct lvp_descriptor_set_layout *layout) 400{ 401 assert(layout && layout->ref_cnt >= 1); 402 if (p_atomic_dec_zero(&layout->ref_cnt)) 403 lvp_descriptor_set_layout_destroy(device, layout); 404} 405 406union lvp_descriptor_info { 407 struct { 408 struct lvp_sampler *sampler; 409 struct lvp_image_view *iview; 410 VkImageLayout image_layout; 411 }; 412 struct { 413 struct lvp_buffer *buffer; 414 VkDeviceSize offset; 415 VkDeviceSize range; 416 }; 417 struct lvp_buffer_view *buffer_view; 418}; 419 420struct lvp_descriptor { 421 VkDescriptorType type; 422 423 union lvp_descriptor_info info; 424}; 425 426struct lvp_descriptor_set { 427 struct vk_object_base base; 428 struct lvp_descriptor_set_layout *layout; 429 struct list_head link; 430 struct lvp_descriptor descriptors[0]; 431}; 432 433struct lvp_descriptor_pool { 434 struct vk_object_base base; 435 VkDescriptorPoolCreateFlags flags; 436 uint32_t max_sets; 437 438 struct list_head sets; 439}; 440 441struct lvp_descriptor_update_template { 442 struct vk_object_base base; 443 uint32_t entry_count; 444 uint32_t set; 445 VkDescriptorUpdateTemplateType type; 446 VkPipelineBindPoint bind_point; 447 struct lvp_pipeline_layout *pipeline_layout; 448 VkDescriptorUpdateTemplateEntry entry[0]; 449}; 450 451VkResult 452lvp_descriptor_set_create(struct lvp_device *device, 453 struct lvp_descriptor_set_layout *layout, 454 struct lvp_descriptor_set **out_set); 455 456void 457lvp_descriptor_set_destroy(struct lvp_device *device, 458 struct lvp_descriptor_set *set); 459 460struct lvp_pipeline_layout { 461 struct vk_object_base base; 462 struct { 463 struct lvp_descriptor_set_layout *layout; 464 uint32_t dynamic_offset_start; 465 } set[MAX_SETS]; 466 467 uint32_t num_sets; 468 uint32_t push_constant_size; 469 struct { 470 bool has_dynamic_offsets; 471 } stage[MESA_SHADER_STAGES]; 472}; 473 474struct lvp_pipeline { 475 struct vk_object_base base; 476 struct lvp_device * device; 477 struct lvp_pipeline_layout * layout; 478 479 void *mem_ctx; 480 bool is_compute_pipeline; 481 bool force_min_sample; 482 nir_shader *pipeline_nir[MESA_SHADER_STAGES]; 483 void *shader_cso[PIPE_SHADER_TYPES]; 484 VkGraphicsPipelineCreateInfo graphics_create_info; 485 VkComputePipelineCreateInfo compute_create_info; 486 uint32_t line_stipple_factor; 487 uint16_t line_stipple_pattern; 488 bool line_stipple_enable; 489 bool line_smooth; 490 bool disable_multisample; 491 bool line_rectangular; 492 bool gs_output_lines; 493 bool provoking_vertex_last; 494}; 495 496struct lvp_event { 497 struct vk_object_base base; 498 volatile uint64_t event_storage; 499}; 500 501struct lvp_fence { 502 struct vk_object_base base; 503 uint64_t timeline; 504 struct util_queue_fence fence; 505 struct pipe_fence_handle *handle; 506 bool signalled; 507}; 508 509struct lvp_semaphore_timeline { 510 struct lvp_semaphore_timeline *next; 511 uint64_t signal; //api 512 uint64_t timeline; //queue 513 struct pipe_fence_handle *fence; 514}; 515 516struct lvp_semaphore { 517 struct vk_object_base base; 518 bool is_timeline; 519 uint64_t current; 520 simple_mtx_t lock; 521 mtx_t submit_lock; 522 cnd_t submit; 523 void *mem; 524 struct util_dynarray links; 525 struct lvp_semaphore_timeline *timeline; 526 struct lvp_semaphore_timeline *latest; 527}; 528 529struct lvp_buffer { 530 struct vk_object_base base; 531 532 VkDeviceSize size; 533 534 VkBufferUsageFlags usage; 535 VkDeviceSize offset; 536 537 struct pipe_memory_allocation *pmem; 538 struct pipe_resource *bo; 539 uint64_t total_size; 540}; 541 542struct lvp_buffer_view { 543 struct vk_object_base base; 544 VkFormat format; 545 enum pipe_format pformat; 546 struct lvp_buffer *buffer; 547 uint32_t offset; 548 uint64_t range; 549}; 550 551struct lvp_query_pool { 552 struct vk_object_base base; 553 VkQueryType type; 554 uint32_t count; 555 VkQueryPipelineStatisticFlags pipeline_stats; 556 enum pipe_query_type base_type; 557 struct pipe_query *queries[0]; 558}; 559 560struct lvp_cmd_pool { 561 struct vk_object_base base; 562 VkAllocationCallbacks alloc; 563 struct list_head cmd_buffers; 564 struct list_head free_cmd_buffers; 565}; 566 567 568enum lvp_cmd_buffer_status { 569 LVP_CMD_BUFFER_STATUS_INVALID, 570 LVP_CMD_BUFFER_STATUS_INITIAL, 571 LVP_CMD_BUFFER_STATUS_RECORDING, 572 LVP_CMD_BUFFER_STATUS_EXECUTABLE, 573 LVP_CMD_BUFFER_STATUS_PENDING, 574}; 575 576struct lvp_cmd_buffer { 577 struct vk_command_buffer vk; 578 579 struct lvp_device * device; 580 581 VkCommandBufferLevel level; 582 enum lvp_cmd_buffer_status status; 583 struct lvp_cmd_pool * pool; 584 struct list_head pool_link; 585 586 struct vk_cmd_queue queue; 587 588 uint8_t push_constants[MAX_PUSH_CONSTANTS_SIZE]; 589}; 590 591 592#define LVP_FROM_HANDLE(__lvp_type, __name, __handle) \ 593 struct __lvp_type *__name = __lvp_type ## _from_handle(__handle) 594 595VK_DEFINE_HANDLE_CASTS(lvp_cmd_buffer, vk.base, VkCommandBuffer, 596 VK_OBJECT_TYPE_COMMAND_BUFFER) 597VK_DEFINE_HANDLE_CASTS(lvp_device, vk.base, VkDevice, VK_OBJECT_TYPE_DEVICE) 598VK_DEFINE_HANDLE_CASTS(lvp_instance, vk.base, VkInstance, VK_OBJECT_TYPE_INSTANCE) 599VK_DEFINE_HANDLE_CASTS(lvp_physical_device, vk.base, VkPhysicalDevice, 600 VK_OBJECT_TYPE_PHYSICAL_DEVICE) 601VK_DEFINE_HANDLE_CASTS(lvp_queue, vk.base, VkQueue, VK_OBJECT_TYPE_QUEUE) 602 603 VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_cmd_pool, base,VkCommandPool, 604 VK_OBJECT_TYPE_COMMAND_POOL) 605VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_buffer, base, VkBuffer, 606 VK_OBJECT_TYPE_BUFFER) 607VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_buffer_view, base, VkBufferView, 608 VK_OBJECT_TYPE_BUFFER_VIEW) 609VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_descriptor_pool, base, VkDescriptorPool, 610 VK_OBJECT_TYPE_DESCRIPTOR_POOL) 611VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_descriptor_set, base, VkDescriptorSet, 612 VK_OBJECT_TYPE_DESCRIPTOR_SET) 613VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_descriptor_set_layout, base, VkDescriptorSetLayout, 614 VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT) 615VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_descriptor_update_template, base, VkDescriptorUpdateTemplate, 616 VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE) 617VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_device_memory, base, VkDeviceMemory, 618 VK_OBJECT_TYPE_DEVICE_MEMORY) 619VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_event, base, VkEvent, VK_OBJECT_TYPE_EVENT) 620VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_framebuffer, base, VkFramebuffer, 621 VK_OBJECT_TYPE_FRAMEBUFFER) 622VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_image, vk.base, VkImage, VK_OBJECT_TYPE_IMAGE) 623VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_image_view, base, VkImageView, 624 VK_OBJECT_TYPE_IMAGE_VIEW); 625VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_pipeline_cache, base, VkPipelineCache, 626 VK_OBJECT_TYPE_PIPELINE_CACHE) 627VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_pipeline, base, VkPipeline, 628 VK_OBJECT_TYPE_PIPELINE) 629VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_pipeline_layout, base, VkPipelineLayout, 630 VK_OBJECT_TYPE_PIPELINE_LAYOUT) 631VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_query_pool, base, VkQueryPool, 632 VK_OBJECT_TYPE_QUERY_POOL) 633VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_render_pass, base, VkRenderPass, 634 VK_OBJECT_TYPE_RENDER_PASS) 635VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_sampler, base, VkSampler, 636 VK_OBJECT_TYPE_SAMPLER) 637VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_fence, base, VkFence, VK_OBJECT_TYPE_FENCE); 638VK_DEFINE_NONDISP_HANDLE_CASTS(lvp_semaphore, base, VkSemaphore, 639 VK_OBJECT_TYPE_SEMAPHORE); 640 641struct lvp_attachment_state { 642 VkImageAspectFlags pending_clear_aspects; 643 VkClearValue clear_value; 644}; 645 646struct lvp_write_descriptor { 647 uint32_t dst_binding; 648 uint32_t dst_array_element; 649 uint32_t descriptor_count; 650 VkDescriptorType descriptor_type; 651}; 652 653struct lvp_cmd_push_descriptor_set { 654 VkPipelineBindPoint bind_point; 655 struct lvp_pipeline_layout *layout; 656 uint32_t set; 657 uint32_t descriptor_write_count; 658 struct lvp_write_descriptor *descriptors; 659 union lvp_descriptor_info *infos; 660}; 661 662VkResult lvp_execute_cmds(struct lvp_device *device, 663 struct lvp_queue *queue, 664 struct lvp_cmd_buffer *cmd_buffer); 665 666struct lvp_image *lvp_swapchain_get_image(VkSwapchainKHR swapchain, 667 uint32_t index); 668 669static inline enum pipe_format 670lvp_vk_format_to_pipe_format(VkFormat format) 671{ 672 /* Some formats cause problems with CTS right now.*/ 673 if (format == VK_FORMAT_R4G4B4A4_UNORM_PACK16 || 674 format == VK_FORMAT_R5G5B5A1_UNORM_PACK16 || 675 format == VK_FORMAT_R8_SRGB || 676 format == VK_FORMAT_R8G8_SRGB || 677 format == VK_FORMAT_R64G64B64A64_SFLOAT || 678 format == VK_FORMAT_R64_SFLOAT || 679 format == VK_FORMAT_R64G64_SFLOAT || 680 format == VK_FORMAT_R64G64B64_SFLOAT || 681 format == VK_FORMAT_A2R10G10B10_SINT_PACK32 || 682 format == VK_FORMAT_A2B10G10R10_SINT_PACK32 || 683 format == VK_FORMAT_G8B8G8R8_422_UNORM || 684 format == VK_FORMAT_B8G8R8G8_422_UNORM || 685 format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM || 686 format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM || 687 format == VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM || 688 format == VK_FORMAT_G8_B8R8_2PLANE_422_UNORM || 689 format == VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM || 690 format == VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM || 691 format == VK_FORMAT_G16_B16R16_2PLANE_420_UNORM || 692 format == VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM || 693 format == VK_FORMAT_G16_B16R16_2PLANE_422_UNORM || 694 format == VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM || 695 format == VK_FORMAT_D16_UNORM_S8_UINT) 696 return PIPE_FORMAT_NONE; 697 698 return vk_format_to_pipe_format(format); 699} 700 701void 702queue_thread_noop(void *data, void *gdata, int thread_index); 703#ifdef __cplusplus 704} 705#endif 706