src/freedreno/vulkan/tu_descriptor_set.c

   1 /*
   2  * Copyright © 2016 Red Hat.
   3  * Copyright © 2016 Bas Nieuwenhuizen
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  22  * IN THE SOFTWARE.
  23  */
  24 #include <assert.h>
  25 #include <fcntl.h>
  26 #include <stdbool.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29
  30 #include "tu_private.h"
  31 #include "util/mesa-sha1.h"
  32 #include "vk_util.h"
  33
  34 static int
  35 binding_compare(const void *av, const void *bv)
  36 {
  37    const VkDescriptorSetLayoutBinding *a =
  38      (const VkDescriptorSetLayoutBinding *)av;
  39    const VkDescriptorSetLayoutBinding *b =
  40      (const VkDescriptorSetLayoutBinding *)bv;
  41
  42    return (a->binding < b->binding) ? -1 : (a->binding > b->binding) ? 1 : 0;
  43 }
  44
  45 static VkDescriptorSetLayoutBinding *
  46 create_sorted_bindings(const VkDescriptorSetLayoutBinding *bindings,
  47                        unsigned count)
  48 {
  49    VkDescriptorSetLayoutBinding *sorted_bindings =
  50      malloc(count * sizeof(VkDescriptorSetLayoutBinding));
  51    if (!sorted_bindings)
  52       return NULL;
  53
  54    memcpy(
  55      sorted_bindings, bindings, count * sizeof(VkDescriptorSetLayoutBinding));
  56
  57    qsort(sorted_bindings,
  58          count,
  59          sizeof(VkDescriptorSetLayoutBinding),
  60          binding_compare);
  61
  62    return sorted_bindings;
  63 }
  64
  65 VkResult
  66 tu_CreateDescriptorSetLayout(
  67   VkDevice _device,
  68   const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
  69   const VkAllocationCallbacks *pAllocator,
  70   VkDescriptorSetLayout *pSetLayout)
  71 {
  72    TU_FROM_HANDLE(tu_device, device, _device);
  73    struct tu_descriptor_set_layout *set_layout;
  74
  75    assert(pCreateInfo->sType ==
  76           VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
  77    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *variable_flags =
  78      vk_find_struct_const(pCreateInfo->pNext,
  79                           DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
  80
  81    uint32_t max_binding = 0;
  82    uint32_t immutable_sampler_count = 0;
  83    for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
  84       max_binding = MAX2(max_binding, pCreateInfo->pBindings[j].binding);
  85       if (pCreateInfo->pBindings[j].pImmutableSamplers)
  86          immutable_sampler_count += pCreateInfo->pBindings[j].descriptorCount;
  87    }
  88
  89    uint32_t samplers_offset =
  90      sizeof(struct tu_descriptor_set_layout) +
  91      (max_binding + 1) * sizeof(set_layout->binding[0]);
  92    size_t size =
  93      samplers_offset + immutable_sampler_count * 4 * sizeof(uint32_t);
  94
  95    set_layout = vk_alloc2(
  96      &device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
  97    if (!set_layout)
  98       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
  99
 100    set_layout->flags = pCreateInfo->flags;
 101
 102    /* We just allocate all the samplers at the end of the struct */
 103    uint32_t *samplers = (uint32_t *)&set_layout->binding[max_binding + 1];
 104
 105    VkDescriptorSetLayoutBinding *bindings =
 106      create_sorted_bindings(pCreateInfo->pBindings, pCreateInfo->bindingCount);
 107    if (!bindings) {
 108       vk_free2(&device->alloc, pAllocator, set_layout);
 109       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 110    }
 111
 112    set_layout->binding_count = max_binding + 1;
 113    set_layout->shader_stages = 0;
 114    set_layout->dynamic_shader_stages = 0;
 115    set_layout->has_immutable_samplers = false;
 116    set_layout->size = 0;
 117
 118    memset(
 119      set_layout->binding, 0, size - sizeof(struct tu_descriptor_set_layout));
 120
 121    uint32_t buffer_count = 0;
 122    uint32_t dynamic_offset_count = 0;
 123
 124    for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
 125       const VkDescriptorSetLayoutBinding *binding = bindings + j;
 126       uint32_t b = binding->binding;
 127       uint32_t alignment;
 128       unsigned binding_buffer_count = 0;
 129
 130       switch (binding->descriptorType) {
 131          case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 132          case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 133             assert(!(pCreateInfo->flags &
 134                      VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
 135             set_layout->binding[b].dynamic_offset_count = 1;
 136             set_layout->dynamic_shader_stages |= binding->stageFlags;
 137             set_layout->binding[b].size = 0;
 138             binding_buffer_count = 1;
 139             alignment = 1;
 140             break;
 141          case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 142          case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 143          case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 144          case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 145             set_layout->binding[b].size = 16;
 146             binding_buffer_count = 1;
 147             alignment = 16;
 148             break;
 149          case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 150          case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
 151          case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 152             /* main descriptor + fmask descriptor */
 153             set_layout->binding[b].size = 64;
 154             binding_buffer_count = 1;
 155             alignment = 32;
 156             break;
 157          case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
 158             /* main descriptor + fmask descriptor + sampler */
 159             set_layout->binding[b].size = 96;
 160             binding_buffer_count = 1;
 161             alignment = 32;
 162             break;
 163          case VK_DESCRIPTOR_TYPE_SAMPLER:
 164             set_layout->binding[b].size = 16;
 165             alignment = 16;
 166             break;
 167          default:
 168             unreachable("unknown descriptor type\n");
 169             break;
 170       }
 171
 172       set_layout->size = align(set_layout->size, alignment);
 173       set_layout->binding[b].type = binding->descriptorType;
 174       set_layout->binding[b].array_size = binding->descriptorCount;
 175       set_layout->binding[b].offset = set_layout->size;
 176       set_layout->binding[b].buffer_offset = buffer_count;
 177       set_layout->binding[b].dynamic_offset_offset = dynamic_offset_count;
 178
 179       if (variable_flags && binding->binding < variable_flags->bindingCount &&
 180           (variable_flags->pBindingFlags[binding->binding] &
 181            VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) {
 182          assert(!binding->pImmutableSamplers); /* Terribly ill defined  how many
 183                                                   samplers are valid */
 184          assert(binding->binding == max_binding);
 185
 186          set_layout->has_variable_descriptors = true;
 187       }
 188
 189       if (binding->pImmutableSamplers) {
 190          set_layout->binding[b].immutable_samplers_offset = samplers_offset;
 191          set_layout->has_immutable_samplers = true;
 192       }
 193
 194       set_layout->size +=
 195         binding->descriptorCount * set_layout->binding[b].size;
 196       buffer_count += binding->descriptorCount * binding_buffer_count;
 197       dynamic_offset_count +=
 198         binding->descriptorCount * set_layout->binding[b].dynamic_offset_count;
 199       set_layout->shader_stages |= binding->stageFlags;
 200    }
 201
 202    free(bindings);
 203
 204    set_layout->buffer_count = buffer_count;
 205    set_layout->dynamic_offset_count = dynamic_offset_count;
 206
 207    *pSetLayout = tu_descriptor_set_layout_to_handle(set_layout);
 208
 209    return VK_SUCCESS;
 210 }
 211
 212 void
 213 tu_DestroyDescriptorSetLayout(VkDevice _device,
 214                                VkDescriptorSetLayout _set_layout,
 215                                const VkAllocationCallbacks *pAllocator)
 216 {
 217    TU_FROM_HANDLE(tu_device, device, _device);
 218    TU_FROM_HANDLE(tu_descriptor_set_layout, set_layout, _set_layout);
 219
 220    if (!set_layout)
 221       return;
 222
 223    vk_free2(&device->alloc, pAllocator, set_layout);
 224 }
 225
 226 void
 227 tu_GetDescriptorSetLayoutSupport(
 228   VkDevice device,
 229   const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
 230   VkDescriptorSetLayoutSupport *pSupport)
 231 {
 232    VkDescriptorSetLayoutBinding *bindings =
 233      create_sorted_bindings(pCreateInfo->pBindings, pCreateInfo->bindingCount);
 234    if (!bindings) {
 235       pSupport->supported = false;
 236       return;
 237    }
 238
 239    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *variable_flags =
 240      vk_find_struct_const(pCreateInfo->pNext,
 241                           DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
 242    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *variable_count =
 243      vk_find_struct(
 244        (void *)pCreateInfo->pNext,
 245        DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT);
 246    if (variable_count) {
 247       variable_count->maxVariableDescriptorCount = 0;
 248    }
 249
 250    bool supported = true;
 251    uint64_t size = 0;
 252    for (uint32_t i = 0; i < pCreateInfo->bindingCount; i++) {
 253       const VkDescriptorSetLayoutBinding *binding = bindings + i;
 254
 255       uint64_t descriptor_size = 0;
 256       uint64_t descriptor_alignment = 1;
 257       switch (binding->descriptorType) {
 258          case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 259          case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 260             break;
 261          case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 262          case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 263          case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 264          case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 265             descriptor_size = 16;
 266             descriptor_alignment = 16;
 267             break;
 268          case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 269          case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
 270          case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 271             descriptor_size = 64;
 272             descriptor_alignment = 32;
 273             break;
 274          case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
 275             descriptor_size = 96;
 276             descriptor_alignment = 32;
 277             break;
 278          case VK_DESCRIPTOR_TYPE_SAMPLER:
 279             descriptor_size = 16;
 280             descriptor_alignment = 16;
 281             break;
 282          default:
 283             unreachable("unknown descriptor type\n");
 284             break;
 285       }
 286
 287       if (size && !align_u64(size, descriptor_alignment)) {
 288          supported = false;
 289       }
 290       size = align_u64(size, descriptor_alignment);
 291
 292       uint64_t max_count = UINT64_MAX;
 293       if (descriptor_size)
 294          max_count = (UINT64_MAX - size) / descriptor_size;
 295
 296       if (max_count < binding->descriptorCount) {
 297          supported = false;
 298       }
 299       if (variable_flags && binding->binding < variable_flags->bindingCount &&
 300           variable_count &&
 301           (variable_flags->pBindingFlags[binding->binding] &
 302            VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) {
 303          variable_count->maxVariableDescriptorCount =
 304            MIN2(UINT32_MAX, max_count);
 305       }
 306       size += binding->descriptorCount * descriptor_size;
 307    }
 308
 309    free(bindings);
 310
 311    pSupport->supported = supported;
 312 }
 313
 314 /*
 315  * Pipeline layouts.  These have nothing to do with the pipeline.  They are
 316  * just multiple descriptor set layouts pasted together.
 317  */
 318
 319 VkResult
 320 tu_CreatePipelineLayout(VkDevice _device,
 321                          const VkPipelineLayoutCreateInfo *pCreateInfo,
 322                          const VkAllocationCallbacks *pAllocator,
 323                          VkPipelineLayout *pPipelineLayout)
 324 {
 325    TU_FROM_HANDLE(tu_device, device, _device);
 326    struct tu_pipeline_layout *layout;
 327    struct mesa_sha1 ctx;
 328
 329    assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
 330
 331    layout = vk_alloc2(&device->alloc,
 332                       pAllocator,
 333                       sizeof(*layout),
 334                       8,
 335                       VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
 336    if (layout == NULL)
 337       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 338
 339    layout->num_sets = pCreateInfo->setLayoutCount;
 340
 341    unsigned dynamic_offset_count = 0;
 342
 343    _mesa_sha1_init(&ctx);
 344    for (uint32_t set = 0; set < pCreateInfo->setLayoutCount; set++) {
 345       TU_FROM_HANDLE(
 346         tu_descriptor_set_layout, set_layout, pCreateInfo->pSetLayouts[set]);
 347       layout->set[set].layout = set_layout;
 348
 349       layout->set[set].dynamic_offset_start = dynamic_offset_count;
 350       for (uint32_t b = 0; b < set_layout->binding_count; b++) {
 351          dynamic_offset_count += set_layout->binding[b].array_size *
 352                                  set_layout->binding[b].dynamic_offset_count;
 353          if (set_layout->binding[b].immutable_samplers_offset)
 354             _mesa_sha1_update(
 355               &ctx,
 356               tu_immutable_samplers(set_layout, set_layout->binding + b),
 357               set_layout->binding[b].array_size * 4 * sizeof(uint32_t));
 358       }
 359       _mesa_sha1_update(&ctx,
 360                         set_layout->binding,
 361                         sizeof(set_layout->binding[0]) *
 362                           set_layout->binding_count);
 363    }
 364
 365    layout->dynamic_offset_count = dynamic_offset_count;
 366    layout->push_constant_size = 0;
 367
 368    for (unsigned i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) {
 369       const VkPushConstantRange *range = pCreateInfo->pPushConstantRanges + i;
 370       layout->push_constant_size =
 371         MAX2(layout->push_constant_size, range->offset + range->size);
 372    }
 373
 374    layout->push_constant_size = align(layout->push_constant_size, 16);
 375    _mesa_sha1_update(
 376      &ctx, &layout->push_constant_size, sizeof(layout->push_constant_size));
 377    _mesa_sha1_final(&ctx, layout->sha1);
 378    *pPipelineLayout = tu_pipeline_layout_to_handle(layout);
 379
 380    return VK_SUCCESS;
 381 }
 382
 383 void
 384 tu_DestroyPipelineLayout(VkDevice _device,
 385                           VkPipelineLayout _pipelineLayout,
 386                           const VkAllocationCallbacks *pAllocator)
 387 {
 388    TU_FROM_HANDLE(tu_device, device, _device);
 389    TU_FROM_HANDLE(tu_pipeline_layout, pipeline_layout, _pipelineLayout);
 390
 391    if (!pipeline_layout)
 392       return;
 393    vk_free2(&device->alloc, pAllocator, pipeline_layout);
 394 }
 395
 396 #define EMPTY 1
 397
 398 VkResult
 399 tu_CreateDescriptorPool(VkDevice _device,
 400                          const VkDescriptorPoolCreateInfo *pCreateInfo,
 401                          const VkAllocationCallbacks *pAllocator,
 402                          VkDescriptorPool *pDescriptorPool)
 403 {
 404    TU_FROM_HANDLE(tu_device, device, _device);
 405    struct tu_descriptor_pool *pool;
 406
 407    return VK_SUCCESS;
 408 }
 409
 410 void
 411 tu_DestroyDescriptorPool(VkDevice _device,
 412                           VkDescriptorPool _pool,
 413                           const VkAllocationCallbacks *pAllocator)
 414 {
 415 }
 416
 417 VkResult
 418 tu_ResetDescriptorPool(VkDevice _device,
 419                         VkDescriptorPool descriptorPool,
 420                         VkDescriptorPoolResetFlags flags)
 421 {
 422    TU_FROM_HANDLE(tu_device, device, _device);
 423    TU_FROM_HANDLE(tu_descriptor_pool, pool, descriptorPool);
 424
 425    return VK_SUCCESS;
 426 }
 427
 428 VkResult
 429 tu_AllocateDescriptorSets(VkDevice _device,
 430                            const VkDescriptorSetAllocateInfo *pAllocateInfo,
 431                            VkDescriptorSet *pDescriptorSets)
 432 {
 433    TU_FROM_HANDLE(tu_device, device, _device);
 434    TU_FROM_HANDLE(tu_descriptor_pool, pool, pAllocateInfo->descriptorPool);
 435
 436    return VK_SUCCESS;
 437 }
 438
 439 VkResult
 440 tu_FreeDescriptorSets(VkDevice _device,
 441                        VkDescriptorPool descriptorPool,
 442                        uint32_t count,
 443                        const VkDescriptorSet *pDescriptorSets)
 444 {
 445    TU_FROM_HANDLE(tu_device, device, _device);
 446    TU_FROM_HANDLE(tu_descriptor_pool, pool, descriptorPool);
 447
 448    return VK_SUCCESS;
 449 }
 450
 451 void
 452 tu_update_descriptor_sets(struct tu_device *device,
 453                            struct tu_cmd_buffer *cmd_buffer,
 454                            VkDescriptorSet dstSetOverride,
 455                            uint32_t descriptorWriteCount,
 456                            const VkWriteDescriptorSet *pDescriptorWrites,
 457                            uint32_t descriptorCopyCount,
 458                            const VkCopyDescriptorSet *pDescriptorCopies)
 459 {
 460 }
 461
 462 void
 463 tu_UpdateDescriptorSets(VkDevice _device,
 464                          uint32_t descriptorWriteCount,
 465                          const VkWriteDescriptorSet *pDescriptorWrites,
 466                          uint32_t descriptorCopyCount,
 467                          const VkCopyDescriptorSet *pDescriptorCopies)
 468 {
 469    TU_FROM_HANDLE(tu_device, device, _device);
 470
 471    tu_update_descriptor_sets(device,
 472                               NULL,
 473                               VK_NULL_HANDLE,
 474                               descriptorWriteCount,
 475                               pDescriptorWrites,
 476                               descriptorCopyCount,
 477                               pDescriptorCopies);
 478 }
 479
 480 VkResult
 481 tu_CreateDescriptorUpdateTemplate(
 482   VkDevice _device,
 483   const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo,
 484   const VkAllocationCallbacks *pAllocator,
 485   VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate)
 486 {
 487    TU_FROM_HANDLE(tu_device, device, _device);
 488    TU_FROM_HANDLE(
 489      tu_descriptor_set_layout, set_layout, pCreateInfo->descriptorSetLayout);
 490    const uint32_t entry_count = pCreateInfo->descriptorUpdateEntryCount;
 491    const size_t size =
 492      sizeof(struct tu_descriptor_update_template) +
 493      sizeof(struct tu_descriptor_update_template_entry) * entry_count;
 494    struct tu_descriptor_update_template *templ;
 495    uint32_t i;
 496
 497    templ = vk_alloc2(
 498      &device->alloc, pAllocator, size, 8, VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
 499    if (!templ)
 500       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 501
 502    *pDescriptorUpdateTemplate = tu_descriptor_update_template_to_handle(templ);
 503    return VK_SUCCESS;
 504 }
 505
 506 void
 507 tu_DestroyDescriptorUpdateTemplate(
 508   VkDevice _device,
 509   VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
 510   const VkAllocationCallbacks *pAllocator)
 511 {
 512    TU_FROM_HANDLE(tu_device, device, _device);
 513    TU_FROM_HANDLE(
 514      tu_descriptor_update_template, templ, descriptorUpdateTemplate);
 515
 516    if (!templ)
 517       return;
 518
 519    vk_free2(&device->alloc, pAllocator, templ);
 520 }
 521
 522 void
 523 tu_update_descriptor_set_with_template(
 524   struct tu_device *device,
 525   struct tu_cmd_buffer *cmd_buffer,
 526   struct tu_descriptor_set *set,
 527   VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
 528   const void *pData)
 529 {
 530    TU_FROM_HANDLE(
 531      tu_descriptor_update_template, templ, descriptorUpdateTemplate);
 532 }
 533
 534 void
 535 tu_UpdateDescriptorSetWithTemplate(
 536   VkDevice _device,
 537   VkDescriptorSet descriptorSet,
 538   VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
 539   const void *pData)
 540 {
 541    TU_FROM_HANDLE(tu_device, device, _device);
 542    TU_FROM_HANDLE(tu_descriptor_set, set, descriptorSet);
 543
 544    tu_update_descriptor_set_with_template(
 545      device, NULL, set, descriptorUpdateTemplate, pData);
 546 }
 547
 548 VkResult
 549 tu_CreateSamplerYcbcrConversion(
 550   VkDevice device,
 551   const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
 552   const VkAllocationCallbacks *pAllocator,
 553   VkSamplerYcbcrConversion *pYcbcrConversion)
 554 {
 555    *pYcbcrConversion = VK_NULL_HANDLE;
 556    return VK_SUCCESS;
 557 }
 558
 559 void
 560 tu_DestroySamplerYcbcrConversion(VkDevice device,
 561                                   VkSamplerYcbcrConversion ycbcrConversion,
 562                                   const VkAllocationCallbacks *pAllocator)
 563 {
 564    /* Do nothing. */
 565 }