blob: 5325d6d52418c48de9e6137828be9a65a677a550 [file] [log] [blame]
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "vulkan_device.h"
#include <limits>
#include <map>
#include <vector>
#include "flutter/vulkan/procs/vulkan_proc_table.h"
#include "third_party/skia/include/gpu/vk/GrVkBackendContext.h"
#include "vulkan_surface.h"
#include "vulkan_utilities.h"
namespace vulkan {
constexpr auto kVulkanInvalidGraphicsQueueIndex =
std::numeric_limits<uint32_t>::max();
static uint32_t FindGraphicsQueueIndex(
const std::vector<VkQueueFamilyProperties>& properties) {
for (uint32_t i = 0, count = static_cast<uint32_t>(properties.size());
i < count; i++) {
if (properties[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
return i;
}
}
return kVulkanInvalidGraphicsQueueIndex;
}
VulkanDevice::VulkanDevice(VulkanProcTable& p_vk,
VulkanHandle<VkPhysicalDevice> physical_device,
bool enable_validation_layers)
: vk(p_vk),
physical_device_(std::move(physical_device)),
graphics_queue_index_(std::numeric_limits<uint32_t>::max()),
valid_(false) {
if (!physical_device_ || !vk.AreInstanceProcsSetup()) {
return;
}
graphics_queue_index_ = FindGraphicsQueueIndex(GetQueueFamilyProperties());
if (graphics_queue_index_ == kVulkanInvalidGraphicsQueueIndex) {
FML_DLOG(INFO) << "Could not find the graphics queue index.";
return;
}
const float priorities[1] = {1.0f};
const VkDeviceQueueCreateInfo queue_create = {
.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.queueFamilyIndex = graphics_queue_index_,
.queueCount = 1,
.pQueuePriorities = priorities,
};
const char* extensions[] = {
#if FML_OS_ANDROID
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
#endif
#if OS_FUCHSIA
VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME,
VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
VK_FUCHSIA_EXTERNAL_MEMORY_EXTENSION_NAME,
VK_FUCHSIA_EXTERNAL_SEMAPHORE_EXTENSION_NAME,
VK_FUCHSIA_BUFFER_COLLECTION_EXTENSION_NAME,
#endif
};
auto enabled_layers =
DeviceLayersToEnable(vk, physical_device_, enable_validation_layers);
const char* layers[enabled_layers.size()];
for (size_t i = 0; i < enabled_layers.size(); i++) {
layers[i] = enabled_layers[i].c_str();
}
const VkDeviceCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
.queueCreateInfoCount = 1,
.pQueueCreateInfos = &queue_create,
.enabledLayerCount = static_cast<uint32_t>(enabled_layers.size()),
.ppEnabledLayerNames = layers,
.enabledExtensionCount = sizeof(extensions) / sizeof(const char*),
.ppEnabledExtensionNames = extensions,
.pEnabledFeatures = nullptr,
};
VkDevice device = VK_NULL_HANDLE;
if (VK_CALL_LOG_ERROR(vk.CreateDevice(physical_device_, &create_info, nullptr,
&device)) != VK_SUCCESS) {
FML_DLOG(INFO) << "Could not create device.";
return;
}
device_ = VulkanHandle<VkDevice>{
device, [this](VkDevice device) { vk.DestroyDevice(device, nullptr); }};
if (!vk.SetupDeviceProcAddresses(device_)) {
FML_DLOG(INFO) << "Could not set up device proc addresses.";
return;
}
VkQueue queue = VK_NULL_HANDLE;
vk.GetDeviceQueue(device_, graphics_queue_index_, 0, &queue);
if (queue == VK_NULL_HANDLE) {
FML_DLOG(INFO) << "Could not get the device queue handle.";
return;
}
queue_ = VulkanHandle<VkQueue>(queue);
if (!InitializeCommandPool()) {
return;
}
valid_ = true;
}
VulkanDevice::VulkanDevice(VulkanProcTable& p_vk,
VulkanHandle<VkPhysicalDevice> physical_device,
VulkanHandle<VkDevice> device,
uint32_t queue_family_index,
VulkanHandle<VkQueue> queue)
: vk(p_vk),
physical_device_(std::move(physical_device)),
device_(std::move(device)),
queue_(std::move(queue)),
graphics_queue_index_(queue_family_index),
valid_(false) {
if (!physical_device_ || !vk.AreInstanceProcsSetup()) {
return;
}
if (!InitializeCommandPool()) {
return;
}
valid_ = true;
}
bool VulkanDevice::InitializeCommandPool() {
const VkCommandPoolCreateInfo command_pool_create_info = {
.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
.pNext = nullptr,
.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
.queueFamilyIndex = 0,
};
VkCommandPool command_pool = VK_NULL_HANDLE;
if (VK_CALL_LOG_ERROR(vk.CreateCommandPool(device_, &command_pool_create_info,
nullptr, &command_pool)) !=
VK_SUCCESS) {
FML_DLOG(INFO) << "Could not create the command pool.";
return false;
}
command_pool_ = VulkanHandle<VkCommandPool>{
command_pool, [this](VkCommandPool pool) {
vk.DestroyCommandPool(device_, pool, nullptr);
}};
return true;
}
VulkanDevice::~VulkanDevice() {
FML_ALLOW_UNUSED_LOCAL(WaitIdle());
}
bool VulkanDevice::IsValid() const {
return valid_;
}
bool VulkanDevice::WaitIdle() const {
return VK_CALL_LOG_ERROR(vk.DeviceWaitIdle(device_)) == VK_SUCCESS;
}
const VulkanHandle<VkDevice>& VulkanDevice::GetHandle() const {
return device_;
}
void VulkanDevice::ReleaseDeviceOwnership() {
device_.ReleaseOwnership();
}
const VulkanHandle<VkPhysicalDevice>& VulkanDevice::GetPhysicalDeviceHandle()
const {
return physical_device_;
}
const VulkanHandle<VkQueue>& VulkanDevice::GetQueueHandle() const {
return queue_;
}
const VulkanHandle<VkCommandPool>& VulkanDevice::GetCommandPool() const {
return command_pool_;
}
uint32_t VulkanDevice::GetGraphicsQueueIndex() const {
return graphics_queue_index_;
}
bool VulkanDevice::GetSurfaceCapabilities(
const VulkanSurface& surface,
VkSurfaceCapabilitiesKHR* capabilities) const {
#if FML_OS_ANDROID
if (!surface.IsValid() || capabilities == nullptr) {
return false;
}
bool success =
VK_CALL_LOG_ERROR(vk.GetPhysicalDeviceSurfaceCapabilitiesKHR(
physical_device_, surface.Handle(), capabilities)) == VK_SUCCESS;
if (!success) {
return false;
}
// Check if the physical device surface capabilities are valid. If so, there
// is nothing more to do.
if (capabilities->currentExtent.width != 0xFFFFFFFF &&
capabilities->currentExtent.height != 0xFFFFFFFF) {
return true;
}
// Ask the native surface for its size as a fallback.
SkISize size = surface.GetSize();
if (size.width() == 0 || size.height() == 0) {
return false;
}
capabilities->currentExtent.width = size.width();
capabilities->currentExtent.height = size.height();
return true;
#else
return false;
#endif
}
bool VulkanDevice::GetPhysicalDeviceFeatures(
VkPhysicalDeviceFeatures* features) const {
if (features == nullptr || !physical_device_) {
return false;
}
vk.GetPhysicalDeviceFeatures(physical_device_, features);
return true;
}
bool VulkanDevice::GetPhysicalDeviceFeaturesSkia(uint32_t* sk_features) const {
if (sk_features == nullptr) {
return false;
}
VkPhysicalDeviceFeatures features;
if (!GetPhysicalDeviceFeatures(&features)) {
return false;
}
uint32_t flags = 0;
if (features.geometryShader) {
flags |= kGeometryShader_GrVkFeatureFlag;
}
if (features.dualSrcBlend) {
flags |= kDualSrcBlend_GrVkFeatureFlag;
}
if (features.sampleRateShading) {
flags |= kSampleRateShading_GrVkFeatureFlag;
}
*sk_features = flags;
return true;
}
std::vector<VkQueueFamilyProperties> VulkanDevice::GetQueueFamilyProperties()
const {
uint32_t count = 0;
vk.GetPhysicalDeviceQueueFamilyProperties(physical_device_, &count, nullptr);
std::vector<VkQueueFamilyProperties> properties;
properties.resize(count, {});
vk.GetPhysicalDeviceQueueFamilyProperties(physical_device_, &count,
properties.data());
return properties;
}
int VulkanDevice::ChooseSurfaceFormat(
const VulkanSurface& surface,
const std::vector<VkFormat>& desired_formats,
VkSurfaceFormatKHR* format) const {
#if FML_OS_ANDROID
if (!surface.IsValid() || format == nullptr) {
return -1;
}
uint32_t format_count = 0;
if (VK_CALL_LOG_ERROR(vk.GetPhysicalDeviceSurfaceFormatsKHR(
physical_device_, surface.Handle(), &format_count, nullptr)) !=
VK_SUCCESS) {
return -1;
}
if (format_count == 0) {
return -1;
}
std::vector<VkSurfaceFormatKHR> formats;
formats.resize(format_count);
if (VK_CALL_LOG_ERROR(vk.GetPhysicalDeviceSurfaceFormatsKHR(
physical_device_, surface.Handle(), &format_count, formats.data())) !=
VK_SUCCESS) {
return -1;
}
std::map<VkFormat, VkSurfaceFormatKHR> supported_formats;
for (uint32_t i = 0; i < format_count; i++) {
supported_formats[formats[i].format] = formats[i];
}
// Try to find the first supported format in the list of desired formats.
for (size_t i = 0; i < desired_formats.size(); ++i) {
auto found = supported_formats.find(desired_formats[i]);
if (found != supported_formats.end()) {
*format = found->second;
return static_cast<int>(i);
}
}
#endif
return -1;
}
bool VulkanDevice::ChoosePresentMode(const VulkanSurface& surface,
VkPresentModeKHR* present_mode) const {
if (!surface.IsValid() || present_mode == nullptr) {
return false;
}
// https://github.com/LunarG/VulkanSamples/issues/98 indicates that
// VK_PRESENT_MODE_FIFO_KHR is preferable on mobile platforms. The problems
// mentioned in the ticket w.r.t the application being faster that the refresh
// rate of the screen should not be faced by any Flutter platforms as they are
// powered by Vsync pulses instead of depending the submit to block.
// However, for platforms that don't have VSync providers set up, it is better
// to fall back to FIFO. For platforms that do have VSync providers, there
// should be little difference. In case there is a need for a mode other than
// FIFO, availability checks must be performed here before returning the
// result. FIFO is always present.
*present_mode = VK_PRESENT_MODE_FIFO_KHR;
return true;
}
bool VulkanDevice::QueueSubmit(
std::vector<VkPipelineStageFlags> wait_dest_pipeline_stages,
const std::vector<VkSemaphore>& wait_semaphores,
const std::vector<VkSemaphore>& signal_semaphores,
const std::vector<VkCommandBuffer>& command_buffers,
const VulkanHandle<VkFence>& fence) const {
if (wait_semaphores.size() != wait_dest_pipeline_stages.size()) {
return false;
}
const VkSubmitInfo submit_info = {
.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
.pNext = nullptr,
.waitSemaphoreCount = static_cast<uint32_t>(wait_semaphores.size()),
.pWaitSemaphores = wait_semaphores.data(),
.pWaitDstStageMask = wait_dest_pipeline_stages.data(),
.commandBufferCount = static_cast<uint32_t>(command_buffers.size()),
.pCommandBuffers = command_buffers.data(),
.signalSemaphoreCount = static_cast<uint32_t>(signal_semaphores.size()),
.pSignalSemaphores = signal_semaphores.data(),
};
if (VK_CALL_LOG_ERROR(vk.QueueSubmit(queue_, 1, &submit_info, fence)) !=
VK_SUCCESS) {
return false;
}
return true;
}
} // namespace vulkan