vulkan/libvulkan/api.cpp

   1 /*
   2  * Copyright 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // The API layer of the loader defines Vulkan API and manages layers.  The
  18 // entrypoints are generated and defined in api_dispatch.cpp.  Most of them
  19 // simply find the dispatch table and jump.
  20 //
  21 // There are a few of them requiring manual code for things such as layer
  22 // discovery or chaining.  They call into functions defined in this file.
  23
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <algorithm>
  27 #include <mutex>
  28 #include <new>
  29 #include <utility>
  30 #include <cutils/properties.h>
  31 #include <log/log.h>
  32
  33 #include <vulkan/vk_layer_interface.h>
  34 #include "api.h"
  35 #include "driver.h"
  36 #include "layers_extensions.h"
  37
  38 namespace vulkan {
  39 namespace api {
  40
  41 namespace {
  42
  43 // Provide overridden layer names when there are implicit layers.  No effect
  44 // otherwise.
  45 class OverrideLayerNames {
  46    public:
  47     OverrideLayerNames(bool is_instance, const VkAllocationCallbacks& allocator)
  48         : is_instance_(is_instance),
  49           allocator_(allocator),
  50           scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
  51           names_(nullptr),
  52           name_count_(0),
  53           implicit_layers_() {
  54         implicit_layers_.result = VK_SUCCESS;
  55     }
  56
  57     ~OverrideLayerNames() {
  58         allocator_.pfnFree(allocator_.pUserData, names_);
  59         allocator_.pfnFree(allocator_.pUserData, implicit_layers_.elements);
  60         allocator_.pfnFree(allocator_.pUserData, implicit_layers_.name_pool);
  61     }
  62
  63     VkResult Parse(const char* const* names, uint32_t count) {
  64         AddImplicitLayers();
  65
  66         const auto& arr = implicit_layers_;
  67         if (arr.result != VK_SUCCESS)
  68             return arr.result;
  69
  70         // no need to override when there is no implicit layer
  71         if (!arr.count)
  72             return VK_SUCCESS;
  73
  74         names_ = AllocateNameArray(arr.count + count);
  75         if (!names_)
  76             return VK_ERROR_OUT_OF_HOST_MEMORY;
  77
  78         // add implicit layer names
  79         for (uint32_t i = 0; i < arr.count; i++)
  80             names_[i] = GetImplicitLayerName(i);
  81
  82         name_count_ = arr.count;
  83
  84         // add explicit layer names
  85         for (uint32_t i = 0; i < count; i++) {
  86             // ignore explicit layers that are also implicit
  87             if (IsImplicitLayer(names[i]))
  88                 continue;
  89
  90             names_[name_count_++] = names[i];
  91         }
  92
  93         return VK_SUCCESS;
  94     }
  95
  96     const char* const* Names() const { return names_; }
  97
  98     uint32_t Count() const { return name_count_; }
  99
 100    private:
 101     struct ImplicitLayer {
 102         int priority;
 103         size_t name_offset;
 104     };
 105
 106     struct ImplicitLayerArray {
 107         ImplicitLayer* elements;
 108         uint32_t max_count;
 109         uint32_t count;
 110
 111         char* name_pool;
 112         size_t max_pool_size;
 113         size_t pool_size;
 114
 115         VkResult result;
 116     };
 117
 118     void AddImplicitLayers() {
 119         if (!is_instance_ || !driver::Debuggable())
 120             return;
 121
 122         ParseDebugVulkanLayers();
 123         property_list(ParseDebugVulkanLayer, this);
 124
 125         // sort by priorities
 126         auto& arr = implicit_layers_;
 127         std::sort(arr.elements, arr.elements + arr.count,
 128                   [](const ImplicitLayer& a, const ImplicitLayer& b) {
 129                       return (a.priority < b.priority);
 130                   });
 131     }
 132
 133     void ParseDebugVulkanLayers() {
 134         // debug.vulkan.layers specifies colon-separated layer names
 135         char prop[PROPERTY_VALUE_MAX];
 136         if (!property_get("debug.vulkan.layers", prop, ""))
 137             return;
 138
 139         // assign negative/high priorities to them
 140         int prio = -PROPERTY_VALUE_MAX;
 141
 142         const char* p = prop;
 143         const char* delim;
 144         while ((delim = strchr(p, ':'))) {
 145             if (delim > p)
 146                 AddImplicitLayer(prio, p, static_cast<size_t>(delim - p));
 147
 148             prio++;
 149             p = delim + 1;
 150         }
 151
 152         if (p[0] != '\0')
 153             AddImplicitLayer(prio, p, strlen(p));
 154     }
 155
 156     static void ParseDebugVulkanLayer(const char* key,
 157                                       const char* val,
 158                                       void* user_data) {
 159         static const char prefix[] = "debug.vulkan.layer.";
 160         const size_t prefix_len = sizeof(prefix) - 1;
 161
 162         if (strncmp(key, prefix, prefix_len) || val[0] == '\0')
 163             return;
 164         key += prefix_len;
 165
 166         // debug.vulkan.layer.<priority>
 167         int priority = -1;
 168         if (key[0] >= '0' && key[0] <= '9')
 169             priority = atoi(key);
 170
 171         if (priority < 0) {
 172             ALOGW("Ignored implicit layer %s with invalid priority %s", val,
 173                   key);
 174             return;
 175         }
 176
 177         OverrideLayerNames& override_layers =
 178             *reinterpret_cast<OverrideLayerNames*>(user_data);
 179         override_layers.AddImplicitLayer(priority, val, strlen(val));
 180     }
 181
 182     void AddImplicitLayer(int priority, const char* name, size_t len) {
 183         if (!GrowImplicitLayerArray(1, 0))
 184             return;
 185
 186         auto& arr = implicit_layers_;
 187         auto& layer = arr.elements[arr.count++];
 188
 189         layer.priority = priority;
 190         layer.name_offset = AddImplicitLayerName(name, len);
 191
 192         ALOGV("Added implicit layer %s", GetImplicitLayerName(arr.count - 1));
 193     }
 194
 195     size_t AddImplicitLayerName(const char* name, size_t len) {
 196         if (!GrowImplicitLayerArray(0, len + 1))
 197             return 0;
 198
 199         // add the name to the pool
 200         auto& arr = implicit_layers_;
 201         size_t offset = arr.pool_size;
 202         char* dst = arr.name_pool + offset;
 203
 204         std::copy(name, name + len, dst);
 205         dst[len] = '\0';
 206
 207         arr.pool_size += len + 1;
 208
 209         return offset;
 210     }
 211
 212     bool GrowImplicitLayerArray(uint32_t layer_count, size_t name_size) {
 213         const uint32_t initial_max_count = 16;
 214         const size_t initial_max_pool_size = 512;
 215
 216         auto& arr = implicit_layers_;
 217
 218         // grow the element array if needed
 219         while (arr.count + layer_count > arr.max_count) {
 220             uint32_t new_max_count =
 221                 (arr.max_count) ? (arr.max_count << 1) : initial_max_count;
 222             void* new_mem = nullptr;
 223
 224             if (new_max_count > arr.max_count) {
 225                 new_mem = allocator_.pfnReallocation(
 226                     allocator_.pUserData, arr.elements,
 227                     sizeof(ImplicitLayer) * new_max_count,
 228                     alignof(ImplicitLayer), scope_);
 229             }
 230
 231             if (!new_mem) {
 232                 arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
 233                 arr.count = 0;
 234                 return false;
 235             }
 236
 237             arr.elements = reinterpret_cast<ImplicitLayer*>(new_mem);
 238             arr.max_count = new_max_count;
 239         }
 240
 241         // grow the name pool if needed
 242         while (arr.pool_size + name_size > arr.max_pool_size) {
 243             size_t new_max_pool_size = (arr.max_pool_size)
 244                                            ? (arr.max_pool_size << 1)
 245                                            : initial_max_pool_size;
 246             void* new_mem = nullptr;
 247
 248             if (new_max_pool_size > arr.max_pool_size) {
 249                 new_mem = allocator_.pfnReallocation(
 250                     allocator_.pUserData, arr.name_pool, new_max_pool_size,
 251                     alignof(char), scope_);
 252             }
 253
 254             if (!new_mem) {
 255                 arr.result = VK_ERROR_OUT_OF_HOST_MEMORY;
 256                 arr.pool_size = 0;
 257                 return false;
 258             }
 259
 260             arr.name_pool = reinterpret_cast<char*>(new_mem);
 261             arr.max_pool_size = new_max_pool_size;
 262         }
 263
 264         return true;
 265     }
 266
 267     const char* GetImplicitLayerName(uint32_t index) const {
 268         const auto& arr = implicit_layers_;
 269
 270         // this may return nullptr when arr.result is not VK_SUCCESS
 271         return implicit_layers_.name_pool + arr.elements[index].name_offset;
 272     }
 273
 274     bool IsImplicitLayer(const char* name) const {
 275         const auto& arr = implicit_layers_;
 276
 277         for (uint32_t i = 0; i < arr.count; i++) {
 278             if (strcmp(name, GetImplicitLayerName(i)) == 0)
 279                 return true;
 280         }
 281
 282         return false;
 283     }
 284
 285     const char** AllocateNameArray(uint32_t count) const {
 286         return reinterpret_cast<const char**>(allocator_.pfnAllocation(
 287             allocator_.pUserData, sizeof(const char*) * count,
 288             alignof(const char*), scope_));
 289     }
 290
 291     const bool is_instance_;
 292     const VkAllocationCallbacks& allocator_;
 293     const VkSystemAllocationScope scope_;
 294
 295     const char** names_;
 296     uint32_t name_count_;
 297
 298     ImplicitLayerArray implicit_layers_;
 299 };
 300
 301 // Provide overridden extension names when there are implicit extensions.
 302 // No effect otherwise.
 303 //
 304 // This is used only to enable VK_EXT_debug_report.
 305 class OverrideExtensionNames {
 306    public:
 307     OverrideExtensionNames(bool is_instance,
 308                            const VkAllocationCallbacks& allocator)
 309         : is_instance_(is_instance),
 310           allocator_(allocator),
 311           scope_(VK_SYSTEM_ALLOCATION_SCOPE_COMMAND),
 312           names_(nullptr),
 313           name_count_(0),
 314           install_debug_callback_(false) {}
 315
 316     ~OverrideExtensionNames() {
 317         allocator_.pfnFree(allocator_.pUserData, names_);
 318     }
 319
 320     VkResult Parse(const char* const* names, uint32_t count) {
 321         // this is only for debug.vulkan.enable_callback
 322         if (!EnableDebugCallback())
 323             return VK_SUCCESS;
 324
 325         names_ = AllocateNameArray(count + 1);
 326         if (!names_)
 327             return VK_ERROR_OUT_OF_HOST_MEMORY;
 328
 329         std::copy(names, names + count, names_);
 330
 331         name_count_ = count;
 332         names_[name_count_++] = "VK_EXT_debug_report";
 333
 334         install_debug_callback_ = true;
 335
 336         return VK_SUCCESS;
 337     }
 338
 339     const char* const* Names() const { return names_; }
 340
 341     uint32_t Count() const { return name_count_; }
 342
 343     bool InstallDebugCallback() const { return install_debug_callback_; }
 344
 345    private:
 346     bool EnableDebugCallback() const {
 347         return (is_instance_ && driver::Debuggable() &&
 348                 property_get_bool("debug.vulkan.enable_callback", false));
 349     }
 350
 351     const char** AllocateNameArray(uint32_t count) const {
 352         return reinterpret_cast<const char**>(allocator_.pfnAllocation(
 353             allocator_.pUserData, sizeof(const char*) * count,
 354             alignof(const char*), scope_));
 355     }
 356
 357     const bool is_instance_;
 358     const VkAllocationCallbacks& allocator_;
 359     const VkSystemAllocationScope scope_;
 360
 361     const char** names_;
 362     uint32_t name_count_;
 363     bool install_debug_callback_;
 364 };
 365
 366 // vkCreateInstance and vkCreateDevice helpers with support for layer
 367 // chaining.
 368 class LayerChain {
 369    public:
 370     struct ActiveLayer {
 371         LayerRef ref;
 372         union {
 373             VkLayerInstanceLink instance_link;
 374             VkLayerDeviceLink device_link;
 375         };
 376     };
 377
 378     static VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
 379                                    const VkAllocationCallbacks* allocator,
 380                                    VkInstance* instance_out);
 381
 382     static VkResult CreateDevice(VkPhysicalDevice physical_dev,
 383                                  const VkDeviceCreateInfo* create_info,
 384                                  const VkAllocationCallbacks* allocator,
 385                                  VkDevice* dev_out);
 386
 387     static void DestroyInstance(VkInstance instance,
 388                                 const VkAllocationCallbacks* allocator);
 389
 390     static void DestroyDevice(VkDevice dev,
 391                               const VkAllocationCallbacks* allocator);
 392
 393     static const ActiveLayer* GetActiveLayers(VkPhysicalDevice physical_dev,
 394                                               uint32_t& count);
 395
 396    private:
 397     LayerChain(bool is_instance,
 398                const driver::DebugReportLogger& logger,
 399                const VkAllocationCallbacks& allocator);
 400     ~LayerChain();
 401
 402     VkResult ActivateLayers(const char* const* layer_names,
 403                             uint32_t layer_count,
 404                             const char* const* extension_names,
 405                             uint32_t extension_count);
 406     VkResult ActivateLayers(VkPhysicalDevice physical_dev,
 407                             const char* const* layer_names,
 408                             uint32_t layer_count,
 409                             const char* const* extension_names,
 410                             uint32_t extension_count);
 411     ActiveLayer* AllocateLayerArray(uint32_t count) const;
 412     VkResult LoadLayer(ActiveLayer& layer, const char* name);
 413     void SetupLayerLinks();
 414
 415     bool Empty() const;
 416     void ModifyCreateInfo(VkInstanceCreateInfo& info);
 417     void ModifyCreateInfo(VkDeviceCreateInfo& info);
 418
 419     VkResult Create(const VkInstanceCreateInfo* create_info,
 420                     const VkAllocationCallbacks* allocator,
 421                     VkInstance* instance_out);
 422
 423     VkResult Create(VkPhysicalDevice physical_dev,
 424                     const VkDeviceCreateInfo* create_info,
 425                     const VkAllocationCallbacks* allocator,
 426                     VkDevice* dev_out);
 427
 428     VkResult ValidateExtensions(const char* const* extension_names,
 429                                 uint32_t extension_count);
 430     VkResult ValidateExtensions(VkPhysicalDevice physical_dev,
 431                                 const char* const* extension_names,
 432                                 uint32_t extension_count);
 433     VkExtensionProperties* AllocateDriverExtensionArray(uint32_t count) const;
 434     bool IsLayerExtension(const char* name) const;
 435     bool IsDriverExtension(const char* name) const;
 436
 437     template <typename DataType>
 438     void StealLayers(DataType& data);
 439
 440     static void DestroyLayers(ActiveLayer* layers,
 441                               uint32_t count,
 442                               const VkAllocationCallbacks& allocator);
 443
 444     static VKAPI_ATTR VkResult SetInstanceLoaderData(VkInstance instance,
 445                                                      void* object);
 446     static VKAPI_ATTR VkResult SetDeviceLoaderData(VkDevice device,
 447                                                    void* object);
 448
 449     static VKAPI_ATTR VkBool32
 450     DebugReportCallback(VkDebugReportFlagsEXT flags,
 451                         VkDebugReportObjectTypeEXT obj_type,
 452                         uint64_t obj,
 453                         size_t location,
 454                         int32_t msg_code,
 455                         const char* layer_prefix,
 456                         const char* msg,
 457                         void* user_data);
 458
 459     const bool is_instance_;
 460     const driver::DebugReportLogger& logger_;
 461     const VkAllocationCallbacks& allocator_;
 462
 463     OverrideLayerNames override_layers_;
 464     OverrideExtensionNames override_extensions_;
 465
 466     ActiveLayer* layers_;
 467     uint32_t layer_count_;
 468
 469     PFN_vkGetInstanceProcAddr get_instance_proc_addr_;
 470     PFN_vkGetDeviceProcAddr get_device_proc_addr_;
 471
 472     union {
 473         VkLayerInstanceCreateInfo instance_chain_info_[2];
 474         VkLayerDeviceCreateInfo device_chain_info_[2];
 475     };
 476
 477     VkExtensionProperties* driver_extensions_;
 478     uint32_t driver_extension_count_;
 479     std::bitset<driver::ProcHook::EXTENSION_COUNT> enabled_extensions_;
 480 };
 481
 482 LayerChain::LayerChain(bool is_instance,
 483                        const driver::DebugReportLogger& logger,
 484                        const VkAllocationCallbacks& allocator)
 485     : is_instance_(is_instance),
 486       logger_(logger),
 487       allocator_(allocator),
 488       override_layers_(is_instance, allocator),
 489       override_extensions_(is_instance, allocator),
 490       layers_(nullptr),
 491       layer_count_(0),
 492       get_instance_proc_addr_(nullptr),
 493       get_device_proc_addr_(nullptr),
 494       driver_extensions_(nullptr),
 495       driver_extension_count_(0) {
 496     enabled_extensions_.set(driver::ProcHook::EXTENSION_CORE);
 497 }
 498
 499 LayerChain::~LayerChain() {
 500     allocator_.pfnFree(allocator_.pUserData, driver_extensions_);
 501     DestroyLayers(layers_, layer_count_, allocator_);
 502 }
 503
 504 VkResult LayerChain::ActivateLayers(const char* const* layer_names,
 505                                     uint32_t layer_count,
 506                                     const char* const* extension_names,
 507                                     uint32_t extension_count) {
 508     VkResult result = override_layers_.Parse(layer_names, layer_count);
 509     if (result != VK_SUCCESS)
 510         return result;
 511
 512     result = override_extensions_.Parse(extension_names, extension_count);
 513     if (result != VK_SUCCESS)
 514         return result;
 515
 516     if (override_layers_.Count()) {
 517         layer_names = override_layers_.Names();
 518         layer_count = override_layers_.Count();
 519     }
 520
 521     if (!layer_count) {
 522         // point head of chain to the driver
 523         get_instance_proc_addr_ = driver::GetInstanceProcAddr;
 524
 525         return VK_SUCCESS;
 526     }
 527
 528     layers_ = AllocateLayerArray(layer_count);
 529     if (!layers_)
 530         return VK_ERROR_OUT_OF_HOST_MEMORY;
 531
 532     // load layers
 533     for (uint32_t i = 0; i < layer_count; i++) {
 534         result = LoadLayer(layers_[i], layer_names[i]);
 535         if (result != VK_SUCCESS)
 536             return result;
 537
 538         // count loaded layers for proper destructions on errors
 539         layer_count_++;
 540     }
 541
 542     SetupLayerLinks();
 543
 544     return VK_SUCCESS;
 545 }
 546
 547 VkResult LayerChain::ActivateLayers(VkPhysicalDevice physical_dev,
 548                                     const char* const* layer_names,
 549                                     uint32_t layer_count,
 550                                     const char* const* extension_names,
 551                                     uint32_t extension_count) {
 552     uint32_t instance_layer_count;
 553     const ActiveLayer* instance_layers =
 554         GetActiveLayers(physical_dev, instance_layer_count);
 555
 556     // log a message if the application device layer array is not empty nor an
 557     // exact match of the instance layer array.
 558     if (layer_count) {
 559         bool exact_match = (instance_layer_count == layer_count);
 560         if (exact_match) {
 561             for (uint32_t i = 0; i < instance_layer_count; i++) {
 562                 const Layer& l = *instance_layers[i].ref;
 563                 if (strcmp(GetLayerProperties(l).layerName, layer_names[i])) {
 564                     exact_match = false;
 565                     break;
 566                 }
 567             }
 568         }
 569
 570         if (!exact_match) {
 571             logger_.Warn(physical_dev,
 572                          "Device layers disagree with instance layers and are "
 573                          "overridden by instance layers");
 574         }
 575     }
 576
 577     VkResult result =
 578         override_extensions_.Parse(extension_names, extension_count);
 579     if (result != VK_SUCCESS)
 580         return result;
 581
 582     if (!instance_layer_count) {
 583         // point head of chain to the driver
 584         get_instance_proc_addr_ = driver::GetInstanceProcAddr;
 585         get_device_proc_addr_ = driver::GetDeviceProcAddr;
 586
 587         return VK_SUCCESS;
 588     }
 589
 590     layers_ = AllocateLayerArray(instance_layer_count);
 591     if (!layers_)
 592         return VK_ERROR_OUT_OF_HOST_MEMORY;
 593
 594     for (uint32_t i = 0; i < instance_layer_count; i++) {
 595         const Layer& l = *instance_layers[i].ref;
 596
 597         // no need to and cannot chain non-global layers
 598         if (!IsLayerGlobal(l))
 599             continue;
 600
 601         // this never fails
 602         new (&layers_[layer_count_++]) ActiveLayer{GetLayerRef(l), {}};
 603     }
 604
 605     // this may happen when all layers are non-global ones
 606     if (!layer_count_) {
 607         get_instance_proc_addr_ = driver::GetInstanceProcAddr;
 608         get_device_proc_addr_ = driver::GetDeviceProcAddr;
 609         return VK_SUCCESS;
 610     }
 611
 612     SetupLayerLinks();
 613
 614     return VK_SUCCESS;
 615 }
 616
 617 LayerChain::ActiveLayer* LayerChain::AllocateLayerArray(uint32_t count) const {
 618     VkSystemAllocationScope scope = (is_instance_)
 619                                         ? VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE
 620                                         : VK_SYSTEM_ALLOCATION_SCOPE_COMMAND;
 621
 622     return reinterpret_cast<ActiveLayer*>(allocator_.pfnAllocation(
 623         allocator_.pUserData, sizeof(ActiveLayer) * count, alignof(ActiveLayer),
 624         scope));
 625 }
 626
 627 VkResult LayerChain::LoadLayer(ActiveLayer& layer, const char* name) {
 628     const Layer* l = FindLayer(name);
 629     if (!l) {
 630         logger_.Err(VK_NULL_HANDLE, "Failed to find layer %s", name);
 631         return VK_ERROR_LAYER_NOT_PRESENT;
 632     }
 633
 634     new (&layer) ActiveLayer{GetLayerRef(*l), {}};
 635     if (!layer.ref) {
 636         ALOGW("Failed to open layer %s", name);
 637         layer.ref.~LayerRef();
 638         return VK_ERROR_LAYER_NOT_PRESENT;
 639     }
 640
 641     ALOGI("Loaded layer %s", name);
 642
 643     return VK_SUCCESS;
 644 }
 645
 646 void LayerChain::SetupLayerLinks() {
 647     if (is_instance_) {
 648         for (uint32_t i = 0; i < layer_count_; i++) {
 649             ActiveLayer& layer = layers_[i];
 650
 651             // point head of chain to the first layer
 652             if (i == 0)
 653                 get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
 654
 655             // point tail of chain to the driver
 656             if (i == layer_count_ - 1) {
 657                 layer.instance_link.pNext = nullptr;
 658                 layer.instance_link.pfnNextGetInstanceProcAddr =
 659                     driver::GetInstanceProcAddr;
 660                 break;
 661             }
 662
 663             const ActiveLayer& next = layers_[i + 1];
 664
 665             // const_cast as some naughty layers want to modify our links!
 666             layer.instance_link.pNext =
 667                 const_cast<VkLayerInstanceLink*>(&next.instance_link);
 668             layer.instance_link.pfnNextGetInstanceProcAddr =
 669                 next.ref.GetGetInstanceProcAddr();
 670         }
 671     } else {
 672         for (uint32_t i = 0; i < layer_count_; i++) {
 673             ActiveLayer& layer = layers_[i];
 674
 675             // point head of chain to the first layer
 676             if (i == 0) {
 677                 get_instance_proc_addr_ = layer.ref.GetGetInstanceProcAddr();
 678                 get_device_proc_addr_ = layer.ref.GetGetDeviceProcAddr();
 679             }
 680
 681             // point tail of chain to the driver
 682             if (i == layer_count_ - 1) {
 683                 layer.device_link.pNext = nullptr;
 684                 layer.device_link.pfnNextGetInstanceProcAddr =
 685                     driver::GetInstanceProcAddr;
 686                 layer.device_link.pfnNextGetDeviceProcAddr =
 687                     driver::GetDeviceProcAddr;
 688                 break;
 689             }
 690
 691             const ActiveLayer& next = layers_[i + 1];
 692
 693             // const_cast as some naughty layers want to modify our links!
 694             layer.device_link.pNext =
 695                 const_cast<VkLayerDeviceLink*>(&next.device_link);
 696             layer.device_link.pfnNextGetInstanceProcAddr =
 697                 next.ref.GetGetInstanceProcAddr();
 698             layer.device_link.pfnNextGetDeviceProcAddr =
 699                 next.ref.GetGetDeviceProcAddr();
 700         }
 701     }
 702 }
 703
 704 bool LayerChain::Empty() const {
 705     return (!layer_count_ && !override_layers_.Count() &&
 706             !override_extensions_.Count());
 707 }
 708
 709 void LayerChain::ModifyCreateInfo(VkInstanceCreateInfo& info) {
 710     if (layer_count_) {
 711         auto& link_info = instance_chain_info_[1];
 712         link_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
 713         link_info.pNext = info.pNext;
 714         link_info.function = VK_LAYER_FUNCTION_LINK;
 715         link_info.u.pLayerInfo = &layers_[0].instance_link;
 716
 717         auto& cb_info = instance_chain_info_[0];
 718         cb_info.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO;
 719         cb_info.pNext = &link_info;
 720         cb_info.function = VK_LAYER_FUNCTION_DATA_CALLBACK;
 721         cb_info.u.pfnSetInstanceLoaderData = SetInstanceLoaderData;
 722
 723         info.pNext = &cb_info;
 724     }
 725
 726     if (override_layers_.Count()) {
 727         info.enabledLayerCount = override_layers_.Count();
 728         info.ppEnabledLayerNames = override_layers_.Names();
 729     }
 730
 731     if (override_extensions_.Count()) {
 732         info.enabledExtensionCount = override_extensions_.Count();
 733         info.ppEnabledExtensionNames = override_extensions_.Names();
 734     }
 735 }
 736
 737 void LayerChain::ModifyCreateInfo(VkDeviceCreateInfo& info) {
 738     if (layer_count_) {
 739         auto& link_info = device_chain_info_[1];
 740         link_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
 741         link_info.pNext = info.pNext;
 742         link_info.function = VK_LAYER_FUNCTION_LINK;
 743         link_info.u.pLayerInfo = &layers_[0].device_link;
 744
 745         auto& cb_info = device_chain_info_[0];
 746         cb_info.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO;
 747         cb_info.pNext = &link_info;
 748         cb_info.function = VK_LAYER_FUNCTION_DATA_CALLBACK;
 749         cb_info.u.pfnSetDeviceLoaderData = SetDeviceLoaderData;
 750
 751         info.pNext = &cb_info;
 752     }
 753
 754     if (override_layers_.Count()) {
 755         info.enabledLayerCount = override_layers_.Count();
 756         info.ppEnabledLayerNames = override_layers_.Names();
 757     }
 758
 759     if (override_extensions_.Count()) {
 760         info.enabledExtensionCount = override_extensions_.Count();
 761         info.ppEnabledExtensionNames = override_extensions_.Names();
 762     }
 763 }
 764
 765 VkResult LayerChain::Create(const VkInstanceCreateInfo* create_info,
 766                             const VkAllocationCallbacks* allocator,
 767                             VkInstance* instance_out) {
 768     VkResult result = ValidateExtensions(create_info->ppEnabledExtensionNames,
 769                                          create_info->enabledExtensionCount);
 770     if (result != VK_SUCCESS)
 771         return result;
 772
 773     // call down the chain
 774     PFN_vkCreateInstance create_instance =
 775         reinterpret_cast<PFN_vkCreateInstance>(
 776             get_instance_proc_addr_(VK_NULL_HANDLE, "vkCreateInstance"));
 777     VkInstance instance;
 778     result = create_instance(create_info, allocator, &instance);
 779     if (result != VK_SUCCESS)
 780         return result;
 781
 782     // initialize InstanceData
 783     InstanceData& data = GetData(instance);
 784
 785     if (!InitDispatchTable(instance, get_instance_proc_addr_,
 786                            enabled_extensions_)) {
 787         if (data.dispatch.DestroyInstance)
 788             data.dispatch.DestroyInstance(instance, allocator);
 789
 790         return VK_ERROR_INITIALIZATION_FAILED;
 791     }
 792
 793     // install debug report callback
 794     if (override_extensions_.InstallDebugCallback()) {
 795         PFN_vkCreateDebugReportCallbackEXT create_debug_report_callback =
 796             reinterpret_cast<PFN_vkCreateDebugReportCallbackEXT>(
 797                 get_instance_proc_addr_(instance,
 798                                         "vkCreateDebugReportCallbackEXT"));
 799         data.destroy_debug_callback =
 800             reinterpret_cast<PFN_vkDestroyDebugReportCallbackEXT>(
 801                 get_instance_proc_addr_(instance,
 802                                         "vkDestroyDebugReportCallbackEXT"));
 803         if (!create_debug_report_callback || !data.destroy_debug_callback) {
 804             ALOGE("Broken VK_EXT_debug_report support");
 805             data.dispatch.DestroyInstance(instance, allocator);
 806             return VK_ERROR_INITIALIZATION_FAILED;
 807         }
 808
 809         VkDebugReportCallbackCreateInfoEXT debug_callback_info = {};
 810         debug_callback_info.sType =
 811             VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
 812         debug_callback_info.flags =
 813             VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
 814         debug_callback_info.pfnCallback = DebugReportCallback;
 815
 816         VkDebugReportCallbackEXT debug_callback;
 817         result = create_debug_report_callback(instance, &debug_callback_info,
 818                                               nullptr, &debug_callback);
 819         if (result != VK_SUCCESS) {
 820             ALOGE("Failed to install debug report callback");
 821             data.dispatch.DestroyInstance(instance, allocator);
 822             return VK_ERROR_INITIALIZATION_FAILED;
 823         }
 824
 825         data.debug_callback = debug_callback;
 826
 827         ALOGI("Installed debug report callback");
 828     }
 829
 830     StealLayers(data);
 831
 832     *instance_out = instance;
 833
 834     return VK_SUCCESS;
 835 }
 836
 837 VkResult LayerChain::Create(VkPhysicalDevice physical_dev,
 838                             const VkDeviceCreateInfo* create_info,
 839                             const VkAllocationCallbacks* allocator,
 840                             VkDevice* dev_out) {
 841     VkResult result =
 842         ValidateExtensions(physical_dev, create_info->ppEnabledExtensionNames,
 843                            create_info->enabledExtensionCount);
 844     if (result != VK_SUCCESS)
 845         return result;
 846
 847     // call down the chain
 848     PFN_vkCreateDevice create_device =
 849         GetData(physical_dev).dispatch.CreateDevice;
 850     VkDevice dev;
 851     result = create_device(physical_dev, create_info, allocator, &dev);
 852     if (result != VK_SUCCESS)
 853         return result;
 854
 855     // initialize DeviceData
 856     DeviceData& data = GetData(dev);
 857
 858     if (!InitDispatchTable(dev, get_device_proc_addr_, enabled_extensions_)) {
 859         if (data.dispatch.DestroyDevice)
 860             data.dispatch.DestroyDevice(dev, allocator);
 861
 862         return VK_ERROR_INITIALIZATION_FAILED;
 863     }
 864
 865     // no StealLayers so that active layers are destroyed with this
 866     // LayerChain
 867     *dev_out = dev;
 868
 869     return VK_SUCCESS;
 870 }
 871
 872 VkResult LayerChain::ValidateExtensions(const char* const* extension_names,
 873                                         uint32_t extension_count) {
 874     if (!extension_count)
 875         return VK_SUCCESS;
 876
 877     // query driver instance extensions
 878     uint32_t count;
 879     VkResult result =
 880         EnumerateInstanceExtensionProperties(nullptr, &count, nullptr);
 881     if (result == VK_SUCCESS && count) {
 882         driver_extensions_ = AllocateDriverExtensionArray(count);
 883         result = (driver_extensions_) ? EnumerateInstanceExtensionProperties(
 884                                             nullptr, &count, driver_extensions_)
 885                                       : VK_ERROR_OUT_OF_HOST_MEMORY;
 886     }
 887     if (result != VK_SUCCESS)
 888         return result;
 889
 890     driver_extension_count_ = count;
 891
 892     for (uint32_t i = 0; i < extension_count; i++) {
 893         const char* name = extension_names[i];
 894         if (!IsLayerExtension(name) && !IsDriverExtension(name)) {
 895             logger_.Err(VK_NULL_HANDLE,
 896                         "Failed to enable missing instance extension %s", name);
 897             return VK_ERROR_EXTENSION_NOT_PRESENT;
 898         }
 899
 900         auto ext_bit = driver::GetProcHookExtension(name);
 901         if (ext_bit != driver::ProcHook::EXTENSION_UNKNOWN)
 902             enabled_extensions_.set(ext_bit);
 903     }
 904
 905     return VK_SUCCESS;
 906 }
 907
 908 VkResult LayerChain::ValidateExtensions(VkPhysicalDevice physical_dev,
 909                                         const char* const* extension_names,
 910                                         uint32_t extension_count) {
 911     if (!extension_count)
 912         return VK_SUCCESS;
 913
 914     // query driver device extensions
 915     uint32_t count;
 916     VkResult result = EnumerateDeviceExtensionProperties(physical_dev, nullptr,
 917                                                          &count, nullptr);
 918     if (result == VK_SUCCESS && count) {
 919         driver_extensions_ = AllocateDriverExtensionArray(count);
 920         result = (driver_extensions_)
 921                      ? EnumerateDeviceExtensionProperties(
 922                            physical_dev, nullptr, &count, driver_extensions_)
 923                      : VK_ERROR_OUT_OF_HOST_MEMORY;
 924     }
 925     if (result != VK_SUCCESS)
 926         return result;
 927
 928     driver_extension_count_ = count;
 929
 930     for (uint32_t i = 0; i < extension_count; i++) {
 931         const char* name = extension_names[i];
 932         if (!IsLayerExtension(name) && !IsDriverExtension(name)) {
 933             logger_.Err(physical_dev,
 934                         "Failed to enable missing device extension %s", name);
 935             return VK_ERROR_EXTENSION_NOT_PRESENT;
 936         }
 937
 938         auto ext_bit = driver::GetProcHookExtension(name);
 939         if (ext_bit != driver::ProcHook::EXTENSION_UNKNOWN)
 940             enabled_extensions_.set(ext_bit);
 941     }
 942
 943     return VK_SUCCESS;
 944 }
 945
 946 VkExtensionProperties* LayerChain::AllocateDriverExtensionArray(
 947     uint32_t count) const {
 948     return reinterpret_cast<VkExtensionProperties*>(allocator_.pfnAllocation(
 949         allocator_.pUserData, sizeof(VkExtensionProperties) * count,
 950         alignof(VkExtensionProperties), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND));
 951 }
 952
 953 bool LayerChain::IsLayerExtension(const char* name) const {
 954     if (is_instance_) {
 955         for (uint32_t i = 0; i < layer_count_; i++) {
 956             const ActiveLayer& layer = layers_[i];
 957             if (FindLayerInstanceExtension(*layer.ref, name))
 958                 return true;
 959         }
 960     } else {
 961         for (uint32_t i = 0; i < layer_count_; i++) {
 962             const ActiveLayer& layer = layers_[i];
 963             if (FindLayerDeviceExtension(*layer.ref, name))
 964                 return true;
 965         }
 966     }
 967
 968     return false;
 969 }
 970
 971 bool LayerChain::IsDriverExtension(const char* name) const {
 972     for (uint32_t i = 0; i < driver_extension_count_; i++) {
 973         if (strcmp(driver_extensions_[i].extensionName, name) == 0)
 974             return true;
 975     }
 976
 977     return false;
 978 }
 979
 980 template <typename DataType>
 981 void LayerChain::StealLayers(DataType& data) {
 982     data.layers = layers_;
 983     data.layer_count = layer_count_;
 984
 985     layers_ = nullptr;
 986     layer_count_ = 0;
 987 }
 988
 989 void LayerChain::DestroyLayers(ActiveLayer* layers,
 990                                uint32_t count,
 991                                const VkAllocationCallbacks& allocator) {
 992     for (uint32_t i = 0; i < count; i++)
 993         layers[i].ref.~LayerRef();
 994
 995     allocator.pfnFree(allocator.pUserData, layers);
 996 }
 997
 998 VkResult LayerChain::SetInstanceLoaderData(VkInstance instance, void* object) {
 999     driver::InstanceDispatchable dispatchable =
1000         reinterpret_cast<driver::InstanceDispatchable>(object);
1001
1002     return (driver::SetDataInternal(dispatchable, &driver::GetData(instance)))
1003                ? VK_SUCCESS
1004                : VK_ERROR_INITIALIZATION_FAILED;
1005 }
1006
1007 VkResult LayerChain::SetDeviceLoaderData(VkDevice device, void* object) {
1008     driver::DeviceDispatchable dispatchable =
1009         reinterpret_cast<driver::DeviceDispatchable>(object);
1010
1011     return (driver::SetDataInternal(dispatchable, &driver::GetData(device)))
1012                ? VK_SUCCESS
1013                : VK_ERROR_INITIALIZATION_FAILED;
1014 }
1015
1016 VkBool32 LayerChain::DebugReportCallback(VkDebugReportFlagsEXT flags,
1017                                          VkDebugReportObjectTypeEXT obj_type,
1018                                          uint64_t obj,
1019                                          size_t location,
1020                                          int32_t msg_code,
1021                                          const char* layer_prefix,
1022                                          const char* msg,
1023                                          void* user_data) {
1024     int prio;
1025
1026     if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
1027         prio = ANDROID_LOG_ERROR;
1028     else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT |
1029                       VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
1030         prio = ANDROID_LOG_WARN;
1031     else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
1032         prio = ANDROID_LOG_INFO;
1033     else if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT)
1034         prio = ANDROID_LOG_DEBUG;
1035     else
1036         prio = ANDROID_LOG_UNKNOWN;
1037
1038     LOG_PRI(prio, LOG_TAG, "[%s] Code %d : %s", layer_prefix, msg_code, msg);
1039
1040     (void)obj_type;
1041     (void)obj;
1042     (void)location;
1043     (void)user_data;
1044
1045     return false;
1046 }
1047
1048 VkResult LayerChain::CreateInstance(const VkInstanceCreateInfo* create_info,
1049                                     const VkAllocationCallbacks* allocator,
1050                                     VkInstance* instance_out) {
1051     LayerChain chain(true, driver::DebugReportLogger(*create_info),
1052                      (allocator) ? *allocator : driver::GetDefaultAllocator());
1053
1054     VkResult result = chain.ActivateLayers(create_info->ppEnabledLayerNames,
1055                                            create_info->enabledLayerCount,
1056                                            create_info->ppEnabledExtensionNames,
1057                                            create_info->enabledExtensionCount);
1058     if (result != VK_SUCCESS)
1059         return result;
1060
1061     // use a local create info when the chain is not empty
1062     VkInstanceCreateInfo local_create_info;
1063     if (!chain.Empty()) {
1064         local_create_info = *create_info;
1065         chain.ModifyCreateInfo(local_create_info);
1066         create_info = &local_create_info;
1067     }
1068
1069     return chain.Create(create_info, allocator, instance_out);
1070 }
1071
1072 VkResult LayerChain::CreateDevice(VkPhysicalDevice physical_dev,
1073                                   const VkDeviceCreateInfo* create_info,
1074                                   const VkAllocationCallbacks* allocator,
1075                                   VkDevice* dev_out) {
1076     LayerChain chain(
1077         false, driver::Logger(physical_dev),
1078         (allocator) ? *allocator : driver::GetData(physical_dev).allocator);
1079
1080     VkResult result = chain.ActivateLayers(
1081         physical_dev, create_info->ppEnabledLayerNames,
1082         create_info->enabledLayerCount, create_info->ppEnabledExtensionNames,
1083         create_info->enabledExtensionCount);
1084     if (result != VK_SUCCESS)
1085         return result;
1086
1087     // use a local create info when the chain is not empty
1088     VkDeviceCreateInfo local_create_info;
1089     if (!chain.Empty()) {
1090         local_create_info = *create_info;
1091         chain.ModifyCreateInfo(local_create_info);
1092         create_info = &local_create_info;
1093     }
1094
1095     return chain.Create(physical_dev, create_info, allocator, dev_out);
1096 }
1097
1098 void LayerChain::DestroyInstance(VkInstance instance,
1099                                  const VkAllocationCallbacks* allocator) {
1100     InstanceData& data = GetData(instance);
1101
1102     if (data.debug_callback != VK_NULL_HANDLE)
1103         data.destroy_debug_callback(instance, data.debug_callback, allocator);
1104
1105     ActiveLayer* layers = reinterpret_cast<ActiveLayer*>(data.layers);
1106     uint32_t layer_count = data.layer_count;
1107
1108     VkAllocationCallbacks local_allocator;
1109     if (!allocator)
1110         local_allocator = driver::GetData(instance).allocator;
1111
1112     // this also destroys InstanceData
1113     data.dispatch.DestroyInstance(instance, allocator);
1114
1115     DestroyLayers(layers, layer_count,
1116                   (allocator) ? *allocator : local_allocator);
1117 }
1118
1119 void LayerChain::DestroyDevice(VkDevice device,
1120                                const VkAllocationCallbacks* allocator) {
1121     DeviceData& data = GetData(device);
1122     // this also destroys DeviceData
1123     data.dispatch.DestroyDevice(device, allocator);
1124 }
1125
1126 const LayerChain::ActiveLayer* LayerChain::GetActiveLayers(
1127     VkPhysicalDevice physical_dev,
1128     uint32_t& count) {
1129     count = GetData(physical_dev).layer_count;
1130     return reinterpret_cast<const ActiveLayer*>(GetData(physical_dev).layers);
1131 }
1132
1133 // ----------------------------------------------------------------------------
1134
1135 bool EnsureInitialized() {
1136     static std::once_flag once_flag;
1137     static bool initialized;
1138
1139     std::call_once(once_flag, []() {
1140         if (driver::OpenHAL()) {
1141             DiscoverLayers();
1142             initialized = true;
1143         }
1144     });
1145
1146     return initialized;
1147 }
1148
1149 }  // anonymous namespace
1150
1151 VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo,
1152                         const VkAllocationCallbacks* pAllocator,
1153                         VkInstance* pInstance) {
1154     if (!EnsureInitialized())
1155         return VK_ERROR_INITIALIZATION_FAILED;
1156
1157     return LayerChain::CreateInstance(pCreateInfo, pAllocator, pInstance);
1158 }
1159
1160 void DestroyInstance(VkInstance instance,
1161                      const VkAllocationCallbacks* pAllocator) {
1162     if (instance != VK_NULL_HANDLE)
1163         LayerChain::DestroyInstance(instance, pAllocator);
1164 }
1165
1166 VkResult CreateDevice(VkPhysicalDevice physicalDevice,
1167                       const VkDeviceCreateInfo* pCreateInfo,
1168                       const VkAllocationCallbacks* pAllocator,
1169                       VkDevice* pDevice) {
1170     return LayerChain::CreateDevice(physicalDevice, pCreateInfo, pAllocator,
1171                                     pDevice);
1172 }
1173
1174 void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
1175     if (device != VK_NULL_HANDLE)
1176         LayerChain::DestroyDevice(device, pAllocator);
1177 }
1178
1179 VkResult EnumerateInstanceLayerProperties(uint32_t* pPropertyCount,
1180                                           VkLayerProperties* pProperties) {
1181     if (!EnsureInitialized())
1182         return VK_ERROR_INITIALIZATION_FAILED;
1183
1184     uint32_t count = GetLayerCount();
1185
1186     if (!pProperties) {
1187         *pPropertyCount = count;
1188         return VK_SUCCESS;
1189     }
1190
1191     uint32_t copied = std::min(*pPropertyCount, count);
1192     for (uint32_t i = 0; i < copied; i++)
1193         pProperties[i] = GetLayerProperties(GetLayer(i));
1194     *pPropertyCount = copied;
1195
1196     return (copied == count) ? VK_SUCCESS : VK_INCOMPLETE;
1197 }
1198
1199 VkResult EnumerateInstanceExtensionProperties(
1200     const char* pLayerName,
1201     uint32_t* pPropertyCount,
1202     VkExtensionProperties* pProperties) {
1203     if (!EnsureInitialized())
1204         return VK_ERROR_INITIALIZATION_FAILED;
1205
1206     if (pLayerName) {
1207         const Layer* layer = FindLayer(pLayerName);
1208         if (!layer)
1209             return VK_ERROR_LAYER_NOT_PRESENT;
1210
1211         uint32_t count;
1212         const VkExtensionProperties* props =
1213             GetLayerInstanceExtensions(*layer, count);
1214
1215         if (!pProperties || *pPropertyCount > count)
1216             *pPropertyCount = count;
1217         if (pProperties)
1218             std::copy(props, props + *pPropertyCount, pProperties);
1219
1220         return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
1221     }
1222
1223     // TODO how about extensions from implicitly enabled layers?
1224     return vulkan::driver::EnumerateInstanceExtensionProperties(
1225         nullptr, pPropertyCount, pProperties);
1226 }
1227
1228 VkResult EnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
1229                                         uint32_t* pPropertyCount,
1230                                         VkLayerProperties* pProperties) {
1231     uint32_t count;
1232     const LayerChain::ActiveLayer* layers =
1233         LayerChain::GetActiveLayers(physicalDevice, count);
1234
1235     if (!pProperties) {
1236         *pPropertyCount = count;
1237         return VK_SUCCESS;
1238     }
1239
1240     uint32_t copied = std::min(*pPropertyCount, count);
1241     for (uint32_t i = 0; i < copied; i++)
1242         pProperties[i] = GetLayerProperties(*layers[i].ref);
1243     *pPropertyCount = copied;
1244
1245     return (copied == count) ? VK_SUCCESS : VK_INCOMPLETE;
1246 }
1247
1248 VkResult EnumerateDeviceExtensionProperties(
1249     VkPhysicalDevice physicalDevice,
1250     const char* pLayerName,
1251     uint32_t* pPropertyCount,
1252     VkExtensionProperties* pProperties) {
1253     if (pLayerName) {
1254         // EnumerateDeviceLayerProperties enumerates active layers for
1255         // backward compatibility.  The extension query here should work for
1256         // all layers.
1257         const Layer* layer = FindLayer(pLayerName);
1258         if (!layer)
1259             return VK_ERROR_LAYER_NOT_PRESENT;
1260
1261         uint32_t count;
1262         const VkExtensionProperties* props =
1263             GetLayerDeviceExtensions(*layer, count);
1264
1265         if (!pProperties || *pPropertyCount > count)
1266             *pPropertyCount = count;
1267         if (pProperties)
1268             std::copy(props, props + *pPropertyCount, pProperties);
1269
1270         return *pPropertyCount < count ? VK_INCOMPLETE : VK_SUCCESS;
1271     }
1272
1273     // TODO how about extensions from implicitly enabled layers?
1274     const InstanceData& data = GetData(physicalDevice);
1275     return data.dispatch.EnumerateDeviceExtensionProperties(
1276         physicalDevice, nullptr, pPropertyCount, pProperties);
1277 }
1278
1279 }  // namespace api
1280 }  // namespace vulkan