OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2016 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "gpu/vulkan/vulkan_implementation.h" |
| 6 |
| 7 #include <string> |
| 8 #include <vector> |
| 9 #include <vulkan/vulkan.h> |
| 10 |
| 11 #include "base/macros.h" |
| 12 |
| 13 #if defined(VK_USE_PLATFORM_XLIB_KHR) |
| 14 #include "ui/gfx/x/x11_types.h" |
| 15 #endif // defined(VK_USE_PLATFORM_XLIB_KHR) |
| 16 |
| 17 namespace gpu { |
| 18 |
| 19 struct VulkanInstance { |
| 20 VulkanInstance() : valid(false) {} |
| 21 |
| 22 void Initialize() { |
| 23 valid = InitializeVulkanInstance() && InitializeVulkanDevice(); |
| 24 } |
| 25 |
| 26 bool InitializeVulkanInstance() { |
| 27 VkResult status = VK_SUCCESS; |
| 28 |
| 29 VkApplicationInfo app_info = {}; |
| 30 app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; |
| 31 app_info.pApplicationName = "Chromium"; |
| 32 app_info.apiVersion = VK_MAKE_VERSION(1, 0, 2); |
| 33 |
| 34 const char* instance_extensions[] = { |
| 35 VK_KHR_SURFACE_EXTENSION_NAME, |
| 36 |
| 37 #if defined(VK_USE_PLATFORM_XLIB_KHR) |
| 38 VK_KHR_XLIB_SURFACE_EXTENSION_NAME, |
| 39 #endif // defined(VK_USE_PLATFORM_XLIB_KHR) |
| 40 }; |
| 41 |
| 42 VkInstanceCreateInfo instance_create_info = {}; |
| 43 instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; |
| 44 instance_create_info.pApplicationInfo = &app_info; |
| 45 instance_create_info.ppEnabledExtensionNames = instance_extensions; |
| 46 instance_create_info.enabledExtensionCount = arraysize(instance_extensions); |
| 47 |
| 48 status = vkCreateInstance(&instance_create_info, nullptr, &vk_instance); |
| 49 DCHECK_EQ(VK_SUCCESS, status); |
| 50 if (VK_SUCCESS != status) |
| 51 return false; |
| 52 |
| 53 return true; |
| 54 } |
| 55 |
| 56 bool InitializeVulkanDevice() { |
| 57 VkResult status = VK_SUCCESS; |
| 58 |
| 59 uint32_t device_count = 0; |
| 60 status = vkEnumeratePhysicalDevices(vk_instance, &device_count, nullptr); |
| 61 if (VK_SUCCESS != status || device_count == 0) |
| 62 return false; |
| 63 |
| 64 std::vector<VkPhysicalDevice> devices(device_count); |
| 65 status = |
| 66 vkEnumeratePhysicalDevices(vk_instance, &device_count, devices.data()); |
| 67 if (VK_SUCCESS != status) { |
| 68 LOG(ERROR) << "vkEnumeratePhysicalDevices() failed: " << status; |
| 69 return false; |
| 70 } |
| 71 |
| 72 // TODO(dyen): Enable this once vkGetPhysicalDeviceXlibPresentationSupportKHR() |
| 73 // is properly supported in the driver. |
| 74 #if 0 && defined(VK_USE_PLATFORM_XLIB_KHR) |
| 75 Display* xdisplay = gfx::GetXDisplay(); |
| 76 VisualID visual_id = |
| 77 XVisualIDFromVisual(DefaultVisual(xdisplay, DefaultScreen(xdisplay))); |
| 78 #endif // defined(VK_USE_PLATFORM_XLIB_KHR) |
| 79 |
| 80 int device_index = -1; |
| 81 int queue_index = -1; |
| 82 for (size_t i = 0; i < devices.size(); ++i) { |
| 83 const VkPhysicalDevice& device = devices[i]; |
| 84 uint32_t queue_count = 0; |
| 85 vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, nullptr); |
| 86 if (queue_count) { |
| 87 std::vector<VkQueueFamilyProperties> queue_properties(queue_count); |
| 88 vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, |
| 89 queue_properties.data()); |
| 90 for (size_t n = 0; n < queue_properties.size(); ++n) { |
| 91 if ((queue_properties[n].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0) |
| 92 continue; |
| 93 |
| 94 // TODO(dyen): Enable this once vkGetPhysicalDeviceXlibPresentationSupportKHR() |
| 95 // is properly supported in the driver. |
| 96 #if 1 |
| 97 #elif defined(VK_USE_PLATFORM_XLIB_KHR) |
| 98 if (!vkGetPhysicalDeviceXlibPresentationSupportKHR( |
| 99 device, n, xdisplay, visual_id)) { |
| 100 continue; |
| 101 } |
| 102 #else |
| 103 #error Non-Supported Vulkan implementation. |
| 104 #endif |
| 105 |
| 106 queue_index = static_cast<int>(n); |
| 107 break; |
| 108 } |
| 109 |
| 110 if (-1 != queue_index) { |
| 111 device_index = static_cast<int>(i); |
| 112 break; |
| 113 } |
| 114 } |
| 115 } |
| 116 |
| 117 if (queue_index == -1) |
| 118 return false; |
| 119 |
| 120 float queue_priority = 0.0f; |
| 121 VkDeviceQueueCreateInfo queue_create_info = {}; |
| 122 queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; |
| 123 queue_create_info.queueFamilyIndex = queue_index; |
| 124 queue_create_info.queueCount = 1; |
| 125 queue_create_info.pQueuePriorities = &queue_priority; |
| 126 |
| 127 const char* device_extensions[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME}; |
| 128 |
| 129 VkDeviceCreateInfo device_create_info = {}; |
| 130 device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; |
| 131 device_create_info.queueCreateInfoCount = 1; |
| 132 device_create_info.pQueueCreateInfos = &queue_create_info; |
| 133 device_create_info.enabledExtensionCount = arraysize(device_extensions); |
| 134 device_create_info.ppEnabledExtensionNames = device_extensions; |
| 135 |
| 136 status = vkCreateDevice(devices[device_index], &device_create_info, nullptr, |
| 137 &vk_device); |
| 138 if (VK_SUCCESS != status) |
| 139 return false; |
| 140 |
| 141 vkGetDeviceQueue(vk_device, queue_index, 0, &vk_queue); |
| 142 |
| 143 return true; |
| 144 } |
| 145 |
| 146 bool valid; |
| 147 VkInstance vk_instance; |
| 148 VkDevice vk_device; |
| 149 VkQueue vk_queue; |
| 150 }; |
| 151 |
| 152 static VulkanInstance* vulkan_instance = nullptr; |
| 153 |
| 154 bool InitializeVulkan() { |
| 155 DCHECK(!vulkan_instance); |
| 156 vulkan_instance = new VulkanInstance; |
| 157 vulkan_instance->Initialize(); |
| 158 return vulkan_instance->valid; |
| 159 } |
| 160 |
| 161 VkInstance GetVulkanInstance() { |
| 162 DCHECK(vulkan_instance); |
| 163 DCHECK(vulkan_instance->valid); |
| 164 return vulkan_instance->vk_instance; |
| 165 } |
| 166 |
| 167 VkDevice GetVulkanDevice() { |
| 168 DCHECK(vulkan_instance); |
| 169 DCHECK(vulkan_instance->valid); |
| 170 return vulkan_instance->vk_device; |
| 171 } |
| 172 |
| 173 VkQueue GetVulkanQueue() { |
| 174 DCHECK(vulkan_instance); |
| 175 DCHECK(vulkan_instance->valid); |
| 176 return vulkan_instance->vk_queue; |
| 177 } |
| 178 |
| 179 } // namespace gpu |
OLD | NEW |