vkjson: Partial GPDP2 support

Enable the GPDP2 instance extension when present, and provide the
instance and enabled instance extensions to VkJsonGetDevice so it can
use device extensions that dispatch on VkPhysicalDevice.

Test: adb shell cmd gpu vkjson
      bit CtsGraphicsTestCases:.VulkanFeaturesTest
Bug: 34745152
Change-Id: Iceb9b6a074660c2cd2797c9eaa020952d5160711

2 files changed, 72 insertions, 16 deletions

diff --git a/libs/vkjson/vkjson.h b/libs/vkjson/vkjson.h
index b70375049..24e1979bd 100644
--- a/libs/vkjson/vkjson.h
+++ b/libs/vkjson/vkjson.h
@@ -65,7 +65,10 @@ bool VkJsonInstanceFromJson(const std::string& json,
                             VkJsonInstance* instance,
                             std::string* errors);
 
-VkJsonDevice VkJsonGetDevice(VkPhysicalDevice device);
+VkJsonDevice VkJsonGetDevice(VkInstance instance,
+                             VkPhysicalDevice device,
+                             uint32_t instanceExtensionCount,
+                             const char* const* instanceExtensions);
 std::string VkJsonDeviceToJson(const VkJsonDevice& device);
 bool VkJsonDeviceFromJson(const std::string& json,
                           VkJsonDevice* device,
@@ -81,7 +84,7 @@ bool VkJsonImageFormatPropertiesFromJson(const std::string& json,
 typedef VkJsonDevice VkJsonAllProperties;
 inline VkJsonAllProperties VkJsonGetAllProperties(
     VkPhysicalDevice physicalDevice) {
-  return VkJsonGetDevice(physicalDevice);
+  return VkJsonGetDevice(VK_NULL_HANDLE, physicalDevice, 0, nullptr);
 }
 inline std::string VkJsonAllPropertiesToJson(
     const VkJsonAllProperties& properties) {
diff --git a/libs/vkjson/vkjson_instance.cc b/libs/vkjson/vkjson_instance.cc
index 7784d5392..22b037703 100644
--- a/libs/vkjson/vkjson_instance.cc
+++ b/libs/vkjson/vkjson_instance.cc
@@ -24,6 +24,9 @@
 #include <utility>
 
 namespace {
+const char* kSupportedInstanceExtensions[] = {
+    "VK_KHR_get_physical_device_properties2"};
+
 bool EnumerateExtensions(const char* layer_name,
                          std::vector<VkExtensionProperties>* extensions) {
   VkResult result;
@@ -39,21 +42,39 @@ bool EnumerateExtensions(const char* layer_name,
   return true;
 }
 
+bool HasExtension(const char* extension_name,
+                  uint32_t count,
+                  const char* const* extensions) {
+  return std::find_if(extensions, extensions + count,
+                      [extension_name](const char* extension) {
+                        return strcmp(extension, extension_name) == 0;
+                      }) != extensions + count;
+}
+
+bool HasExtension(const char* extension_name,
+                  const std::vector<VkExtensionProperties>& extensions) {
+  return std::find_if(extensions.cbegin(), extensions.cend(),
+                      [extension_name](const VkExtensionProperties& extension) {
+                        return strcmp(extension.extensionName,
+                                      extension_name) == 0;
+                      }) != extensions.cend();
+}
 }  // anonymous namespace
 
-VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) {
+VkJsonDevice VkJsonGetDevice(VkInstance instance,
+                             VkPhysicalDevice physical_device,
+                             uint32_t instance_extension_count,
+                             const char* const* instance_extensions) {
   VkJsonDevice device;
-  vkGetPhysicalDeviceProperties(physical_device, &device.properties);
-  vkGetPhysicalDeviceFeatures(physical_device, &device.features);
-  vkGetPhysicalDeviceMemoryProperties(physical_device, &device.memory);
 
-  uint32_t queue_family_count = 0;
-  vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count,
-                                           nullptr);
-  if (queue_family_count > 0) {
-    device.queues.resize(queue_family_count);
-    vkGetPhysicalDeviceQueueFamilyProperties(
-        physical_device, &queue_family_count, device.queues.data());
+  PFN_vkGetPhysicalDeviceFeatures2KHR vkpGetPhysicalDeviceFeatures2KHR =
+      nullptr;
+  if (instance != VK_NULL_HANDLE &&
+      HasExtension("VK_KHR_get_physical_device_properties2",
+                   instance_extension_count, instance_extensions)) {
+    vkpGetPhysicalDeviceFeatures2KHR =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2KHR>(
+            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR"));
   }
 
   // Only device extensions.
@@ -75,6 +96,30 @@ VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) {
                                      device.layers.data());
   }
 
+  vkGetPhysicalDeviceProperties(physical_device, &device.properties);
+  if (HasExtension("VK_KHR_get_physical_device_properties2",
+                   instance_extension_count, instance_extensions)) {
+    VkPhysicalDeviceFeatures2KHR features = {
+        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,
+        nullptr,
+        {}  // features
+    };
+    vkpGetPhysicalDeviceFeatures2KHR(physical_device, &features);
+    device.features = features.features;
+  } else {
+    vkGetPhysicalDeviceFeatures(physical_device, &device.features);
+  }
+  vkGetPhysicalDeviceMemoryProperties(physical_device, &device.memory);
+
+  uint32_t queue_family_count = 0;
+  vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count,
+                                           nullptr);
+  if (queue_family_count > 0) {
+    device.queues.resize(queue_family_count);
+    vkGetPhysicalDeviceQueueFamilyProperties(
+        physical_device, &queue_family_count, device.queues.data());
+  }
+
   VkFormatProperties format_properties = {};
   for (VkFormat format = VK_FORMAT_R4G4_UNORM_PACK8;
        format <= VK_FORMAT_END_RANGE;
@@ -116,6 +161,12 @@ VkJsonInstance VkJsonGetInstance() {
   if (!EnumerateExtensions(nullptr, &instance.extensions))
     return VkJsonInstance();
 
+  std::vector<const char*> instance_extensions;
+  for (const auto extension : kSupportedInstanceExtensions) {
+    if (HasExtension(extension, instance.extensions))
+      instance_extensions.push_back(extension);
+  }
+
   const VkApplicationInfo app_info = {VK_STRUCTURE_TYPE_APPLICATION_INFO,
                                       nullptr,
                                       "vkjson_info",
@@ -130,8 +181,8 @@ VkJsonInstance VkJsonGetInstance() {
       &app_info,
       0,
       nullptr,
-      0,
-      nullptr};
+      static_cast<uint32_t>(instance_extensions.size()),
+      instance_extensions.data()};
   VkInstance vkinstance;
   result = vkCreateInstance(&instance_info, nullptr, &vkinstance);
   if (result != VK_SUCCESS)
@@ -152,7 +203,9 @@ VkJsonInstance VkJsonGetInstance() {
 
   instance.devices.reserve(devices.size());
   for (auto device : devices)
-    instance.devices.emplace_back(VkJsonGetDevice(device));
+    instance.devices.emplace_back(VkJsonGetDevice(vkinstance, device,
+                                                  instance_extensions.size(),
+                                                  instance_extensions.data()));
 
   vkDestroyInstance(vkinstance, nullptr);
   return instance;