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
  22  * DEALINGS IN THE SOFTWARE.
  23  */
  24 #include "tu_private.h"
  25
  26 #include <assert.h>
  27 #include <fcntl.h>
  28 #include <stdbool.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31
  32 #include "util/mesa-sha1.h"
  33 #include "vk_util.h"
  34
  35 static int
  36 binding_compare(const void *av, const void *bv)
  37 {
  38    const VkDescriptorSetLayoutBinding *a =
  39       (const VkDescriptorSetLayoutBinding *) av;
  40    const VkDescriptorSetLayoutBinding *b =
  41       (const VkDescriptorSetLayoutBinding *) bv;
  42
  43    return (a->binding < b->binding) ? -1 : (a->binding > b->binding) ? 1 : 0;
  44 }
  45
  46 static VkDescriptorSetLayoutBinding *
  47 create_sorted_bindings(const VkDescriptorSetLayoutBinding *bindings,
  48                        unsigned count)
  49 {
  50    VkDescriptorSetLayoutBinding *sorted_bindings =
  51       malloc(count * sizeof(VkDescriptorSetLayoutBinding));
  52    if (!sorted_bindings)
  53       return NULL;
  54
  55    memcpy(sorted_bindings, bindings,
  56           count * sizeof(VkDescriptorSetLayoutBinding));
  57
  58    qsort(sorted_bindings, count, sizeof(VkDescriptorSetLayoutBinding),
  59          binding_compare);
  60
  61    return sorted_bindings;
  62 }
  63
  64 VkResult
  65 tu_CreateDescriptorSetLayout(
  66    VkDevice _device,
  67    const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
  68    const VkAllocationCallbacks *pAllocator,
  69    VkDescriptorSetLayout *pSetLayout)
  70 {
  71    TU_FROM_HANDLE(tu_device, device, _device);
  72    struct tu_descriptor_set_layout *set_layout;
  73
  74    assert(pCreateInfo->sType ==
  75           VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
  76    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *variable_flags =
  77       vk_find_struct_const(
  78          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(&device->alloc, pAllocator, size, 8,
  96                           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    (void) samplers; /* TODO: Use me */
 105
 106    VkDescriptorSetLayoutBinding *bindings = create_sorted_bindings(
 107       pCreateInfo->pBindings, pCreateInfo->bindingCount);
 108    if (!bindings) {
 109       vk_free2(&device->alloc, pAllocator, set_layout);
 110       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 111    }
 112
 113    set_layout->binding_count = max_binding + 1;
 114    set_layout->shader_stages = 0;
 115    set_layout->dynamic_shader_stages = 0;
 116    set_layout->has_immutable_samplers = false;
 117    set_layout->size = 0;
 118
 119    memset(set_layout->binding, 0,
 120           size - sizeof(struct tu_descriptor_set_layout));
 121
 122    uint32_t buffer_count = 0;
 123    uint32_t dynamic_offset_count = 0;
 124
 125    for (uint32_t j = 0; j < pCreateInfo->bindingCount; j++) {
 126       const VkDescriptorSetLayoutBinding *binding = bindings + j;
 127       uint32_t b = binding->binding;
 128       uint32_t alignment;
 129       unsigned binding_buffer_count = 0;
 130
 131       switch (binding->descriptorType) {
 132       case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 133       case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 134          assert(!(pCreateInfo->flags &
 135                   VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR));
 136          set_layout->binding[b].dynamic_offset_count = 1;
 137          set_layout->dynamic_shader_stages |= binding->stageFlags;
 138          set_layout->binding[b].size = 0;
 139          binding_buffer_count = 1;
 140          alignment = 1;
 141          break;
 142       case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 143       case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 144       case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 145       case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 146          set_layout->binding[b].size = 16;
 147          binding_buffer_count = 1;
 148          alignment = 16;
 149          break;
 150       case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 151       case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
 152       case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 153          /* main descriptor + fmask descriptor */
 154          set_layout->binding[b].size = 64;
 155          binding_buffer_count = 1;
 156          alignment = 32;
 157          break;
 158       case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
 159          /* main descriptor + fmask descriptor + sampler */
 160          set_layout->binding[b].size = 96;
 161          binding_buffer_count = 1;
 162          alignment = 32;
 163          break;
 164       case VK_DESCRIPTOR_TYPE_SAMPLER:
 165          set_layout->binding[b].size = 16;
 166          alignment = 16;
 167          break;
 168       default:
 169          unreachable("unknown descriptor type\n");
 170          break;
 171       }
 172
 173       set_layout->size = align(set_layout->size, alignment);
 174       set_layout->binding[b].type = binding->descriptorType;
 175       set_layout->binding[b].array_size = binding->descriptorCount;
 176       set_layout->binding[b].offset = set_layout->size;
 177       set_layout->binding[b].buffer_offset = buffer_count;
 178       set_layout->binding[b].dynamic_offset_offset = dynamic_offset_count;
 179
 180       if (variable_flags && binding->binding < variable_flags->bindingCount &&
 181           (variable_flags->pBindingFlags[binding->binding] &
 182            VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) {
 183          assert(!binding->pImmutableSamplers); /* Terribly ill defined  how
 184                                                   many samplers are valid */
 185          assert(binding->binding == max_binding);
 186
 187          set_layout->has_variable_descriptors = true;
 188       }
 189
 190       if (binding->pImmutableSamplers) {
 191          set_layout->binding[b].immutable_samplers_offset = samplers_offset;
 192          set_layout->has_immutable_samplers = true;
 193       }
 194
 195       set_layout->size +=
 196          binding->descriptorCount * set_layout->binding[b].size;
 197       buffer_count += binding->descriptorCount * binding_buffer_count;
 198       dynamic_offset_count += binding->descriptorCount *
 199                               set_layout->binding[b].dynamic_offset_count;
 200       set_layout->shader_stages |= binding->stageFlags;
 201    }
 202
 203    free(bindings);
 204
 205    set_layout->buffer_count = buffer_count;
 206    set_layout->dynamic_offset_count = dynamic_offset_count;
 207
 208    *pSetLayout = tu_descriptor_set_layout_to_handle(set_layout);
 209
 210    return VK_SUCCESS;
 211 }
 212
 213 void
 214 tu_DestroyDescriptorSetLayout(VkDevice _device,
 215                               VkDescriptorSetLayout _set_layout,
 216                               const VkAllocationCallbacks *pAllocator)
 217 {
 218    TU_FROM_HANDLE(tu_device, device, _device);
 219    TU_FROM_HANDLE(tu_descriptor_set_layout, set_layout, _set_layout);
 220
 221    if (!set_layout)
 222       return;
 223
 224    vk_free2(&device->alloc, pAllocator, set_layout);
 225 }
 226
 227 void
 228 tu_GetDescriptorSetLayoutSupport(
 229    VkDevice device,
 230    const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
 231    VkDescriptorSetLayoutSupport *pSupport)
 232 {
 233    VkDescriptorSetLayoutBinding *bindings = create_sorted_bindings(
 234       pCreateInfo->pBindings, pCreateInfo->bindingCount);
 235    if (!bindings) {
 236       pSupport->supported = false;
 237       return;
 238    }
 239
 240    const VkDescriptorSetLayoutBindingFlagsCreateInfoEXT *variable_flags =
 241       vk_find_struct_const(
 242          pCreateInfo->pNext,
 243          DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT);
 244    VkDescriptorSetVariableDescriptorCountLayoutSupportEXT *variable_count =
 245       vk_find_struct(
 246          (void *) pCreateInfo->pNext,
 247          DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT);
 248    if (variable_count) {
 249       variable_count->maxVariableDescriptorCount = 0;
 250    }
 251
 252    bool supported = true;
 253    uint64_t size = 0;
 254    for (uint32_t i = 0; i < pCreateInfo->bindingCount; i++) {
 255       const VkDescriptorSetLayoutBinding *binding = bindings + i;
 256
 257       uint64_t descriptor_size = 0;
 258       uint64_t descriptor_alignment = 1;
 259       switch (binding->descriptorType) {
 260       case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
 261       case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
 262          break;
 263       case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
 264       case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
 265       case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
 266       case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
 267          descriptor_size = 16;
 268          descriptor_alignment = 16;
 269          break;
 270       case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
 271       case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
 272       case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
 273          descriptor_size = 64;
 274          descriptor_alignment = 32;
 275          break;
 276       case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
 277          descriptor_size = 96;
 278          descriptor_alignment = 32;
 279          break;
 280       case VK_DESCRIPTOR_TYPE_SAMPLER:
 281          descriptor_size = 16;
 282          descriptor_alignment = 16;
 283          break;
 284       default:
 285          unreachable("unknown descriptor type\n");
 286          break;
 287       }
 288
 289       if (size && !align_u64(size, descriptor_alignment)) {
 290          supported = false;
 291       }
 292       size = align_u64(size, descriptor_alignment);
 293
 294       uint64_t max_count = UINT64_MAX;
 295       if (descriptor_size)
 296          max_count = (UINT64_MAX - size) / descriptor_size;
 297
 298       if (max_count < binding->descriptorCount) {
 299          supported = false;
 300       }
 301       if (variable_flags && binding->binding < variable_flags->bindingCount &&
 302           variable_count &&
 303           (variable_flags->pBindingFlags[binding->binding] &
 304            VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT)) {
 305          variable_count->maxVariableDescriptorCount =
 306             MIN2(UINT32_MAX, max_count);
 307       }
 308       size += binding->descriptorCount * descriptor_size;
 309    }
 310
 311    free(bindings);
 312
 313    pSupport->supported = supported;
 314 }
 315
 316 /*
 317  * Pipeline layouts.  These have nothing to do with the pipeline.  They are
 318  * just multiple descriptor set layouts pasted together.
 319  */
 320
 321 VkResult
 322 tu_CreatePipelineLayout(VkDevice _device,
 323                         const VkPipelineLayoutCreateInfo *pCreateInfo,
 324                         const VkAllocationCallbacks *pAllocator,
 325                         VkPipelineLayout *pPipelineLayout)
 326 {
 327    TU_FROM_HANDLE(tu_device, device, _device);
 328    struct tu_pipeline_layout *layout;
 329    struct mesa_sha1 ctx;
 330
 331    assert(pCreateInfo->sType ==
 332           VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO);
 333
 334    layout = vk_alloc2(&device->alloc, pAllocator, sizeof(*layout), 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(tu_descriptor_set_layout, set_layout,
 346                      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(
 360          &ctx, set_layout->binding,
 361          sizeof(set_layout->binding[0]) * set_layout->binding_count);
 362    }
 363
 364    layout->dynamic_offset_count = dynamic_offset_count;
 365    layout->push_constant_size = 0;
 366
 367    for (unsigned i = 0; i < pCreateInfo->pushConstantRangeCount; ++i) {
 368       const VkPushConstantRange *range = pCreateInfo->pPushConstantRanges + i;
 369       layout->push_constant_size =
 370          MAX2(layout->push_constant_size, range->offset + range->size);
 371    }
 372
 373    layout->push_constant_size = align(layout->push_constant_size, 16);
 374    _mesa_sha1_update(&ctx, &layout->push_constant_size,
 375                      sizeof(layout->push_constant_size));
 376    _mesa_sha1_final(&ctx, layout->sha1);
 377    *pPipelineLayout = tu_pipeline_layout_to_handle(layout);
 378
 379    return VK_SUCCESS;
 380 }
 381
 382 void
 383 tu_DestroyPipelineLayout(VkDevice _device,
 384                          VkPipelineLayout _pipelineLayout,
 385                          const VkAllocationCallbacks *pAllocator)
 386 {
 387    TU_FROM_HANDLE(tu_device, device, _device);
 388    TU_FROM_HANDLE(tu_pipeline_layout, pipeline_layout, _pipelineLayout);
 389
 390    if (!pipeline_layout)
 391       return;
 392    vk_free2(&device->alloc, pAllocator, pipeline_layout);
 393 }
 394
 395 #define EMPTY 1
 396
 397 VkResult
 398 tu_CreateDescriptorPool(VkDevice _device,
 399                         const VkDescriptorPoolCreateInfo *pCreateInfo,
 400                         const VkAllocationCallbacks *pAllocator,
 401                         VkDescriptorPool *pDescriptorPool)
 402 {
 403    TU_FROM_HANDLE(tu_device, device, _device);
 404    tu_use_args(device);
 405    tu_stub();
 406    return VK_SUCCESS;
 407 }
 408
 409 void
 410 tu_DestroyDescriptorPool(VkDevice _device,
 411                          VkDescriptorPool _pool,
 412                          const VkAllocationCallbacks *pAllocator)
 413 {
 414 }
 415
 416 VkResult
 417 tu_ResetDescriptorPool(VkDevice _device,
 418                        VkDescriptorPool descriptorPool,
 419                        VkDescriptorPoolResetFlags flags)
 420 {
 421    TU_FROM_HANDLE(tu_device, device, _device);
 422    TU_FROM_HANDLE(tu_descriptor_pool, pool, descriptorPool);
 423
 424    tu_use_args(device, pool);
 425    tu_stub();
 426    return VK_SUCCESS;
 427 }
 428
 429 VkResult
 430 tu_AllocateDescriptorSets(VkDevice _device,
 431                           const VkDescriptorSetAllocateInfo *pAllocateInfo,
 432                           VkDescriptorSet *pDescriptorSets)
 433 {
 434    TU_FROM_HANDLE(tu_device, device, _device);
 435    TU_FROM_HANDLE(tu_descriptor_pool, pool, pAllocateInfo->descriptorPool);
 436
 437    tu_use_args(device, pool);
 438    tu_stub();
 439    return VK_SUCCESS;
 440 }
 441
 442 VkResult
 443 tu_FreeDescriptorSets(VkDevice _device,
 444                       VkDescriptorPool descriptorPool,
 445                       uint32_t count,
 446                       const VkDescriptorSet *pDescriptorSets)
 447 {
 448    TU_FROM_HANDLE(tu_device, device, _device);
 449    TU_FROM_HANDLE(tu_descriptor_pool, pool, descriptorPool);
 450
 451    tu_use_args(device, pool);
 452    tu_stub();
 453    return VK_SUCCESS;
 454 }
 455
 456 void
 457 tu_update_descriptor_sets(struct tu_device *device,
 458                           struct tu_cmd_buffer *cmd_buffer,
 459                           VkDescriptorSet dstSetOverride,
 460                           uint32_t descriptorWriteCount,
 461                           const VkWriteDescriptorSet *pDescriptorWrites,
 462                           uint32_t descriptorCopyCount,
 463                           const VkCopyDescriptorSet *pDescriptorCopies)
 464 {
 465 }
 466
 467 void
 468 tu_UpdateDescriptorSets(VkDevice _device,
 469                         uint32_t descriptorWriteCount,
 470                         const VkWriteDescriptorSet *pDescriptorWrites,
 471                         uint32_t descriptorCopyCount,
 472                         const VkCopyDescriptorSet *pDescriptorCopies)
 473 {
 474    TU_FROM_HANDLE(tu_device, device, _device);
 475
 476    tu_update_descriptor_sets(device, NULL, VK_NULL_HANDLE,
 477                              descriptorWriteCount, pDescriptorWrites,
 478                              descriptorCopyCount, pDescriptorCopies);
 479 }
 480
 481 VkResult
 482 tu_CreateDescriptorUpdateTemplate(
 483    VkDevice _device,
 484    const VkDescriptorUpdateTemplateCreateInfoKHR *pCreateInfo,
 485    const VkAllocationCallbacks *pAllocator,
 486    VkDescriptorUpdateTemplateKHR *pDescriptorUpdateTemplate)
 487 {
 488    TU_FROM_HANDLE(tu_device, device, _device);
 489    TU_FROM_HANDLE(tu_descriptor_set_layout, set_layout,
 490                   pCreateInfo->descriptorSetLayout);
 491    const uint32_t entry_count = pCreateInfo->descriptorUpdateEntryCount;
 492    const size_t size =
 493       sizeof(struct tu_descriptor_update_template) +
 494       sizeof(struct tu_descriptor_update_template_entry) * entry_count;
 495    struct tu_descriptor_update_template *templ;
 496
 497    templ = vk_alloc2(&device->alloc, pAllocator, size, 8,
 498                      VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
 499    if (!templ)
 500       return vk_error(device->instance, VK_ERROR_OUT_OF_HOST_MEMORY);
 501
 502    *pDescriptorUpdateTemplate =
 503       tu_descriptor_update_template_to_handle(templ);
 504
 505    tu_use_args(set_layout);
 506    tu_stub();
 507    return VK_SUCCESS;
 508 }
 509
 510 void
 511 tu_DestroyDescriptorUpdateTemplate(
 512    VkDevice _device,
 513    VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
 514    const VkAllocationCallbacks *pAllocator)
 515 {
 516    TU_FROM_HANDLE(tu_device, device, _device);
 517    TU_FROM_HANDLE(tu_descriptor_update_template, templ,
 518                   descriptorUpdateTemplate);
 519
 520    if (!templ)
 521       return;
 522
 523    vk_free2(&device->alloc, pAllocator, templ);
 524 }
 525
 526 void
 527 tu_update_descriptor_set_with_template(
 528    struct tu_device *device,
 529    struct tu_cmd_buffer *cmd_buffer,
 530    struct tu_descriptor_set *set,
 531    VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
 532    const void *pData)
 533 {
 534    TU_FROM_HANDLE(tu_descriptor_update_template, templ,
 535                   descriptorUpdateTemplate);
 536    tu_use_args(templ);
 537 }
 538
 539 void
 540 tu_UpdateDescriptorSetWithTemplate(
 541    VkDevice _device,
 542    VkDescriptorSet descriptorSet,
 543    VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate,
 544    const void *pData)
 545 {
 546    TU_FROM_HANDLE(tu_device, device, _device);
 547    TU_FROM_HANDLE(tu_descriptor_set, set, descriptorSet);
 548
 549    tu_update_descriptor_set_with_template(device, NULL, set,
 550                                           descriptorUpdateTemplate, pData);
 551 }
 552
 553 VkResult
 554 tu_CreateSamplerYcbcrConversion(
 555    VkDevice device,
 556    const VkSamplerYcbcrConversionCreateInfo *pCreateInfo,
 557    const VkAllocationCallbacks *pAllocator,
 558    VkSamplerYcbcrConversion *pYcbcrConversion)
 559 {
 560    *pYcbcrConversion = VK_NULL_HANDLE;
 561    return VK_SUCCESS;
 562 }
 563
 564 void
 565 tu_DestroySamplerYcbcrConversion(VkDevice device,
 566                                  VkSamplerYcbcrConversion ycbcrConversion,
 567                                  const VkAllocationCallbacks *pAllocator)
 568 {
 569    /* Do nothing. */
 570 }