| // Copyright 2016 The Fuchsia 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 "src/ui/lib/escher/impl/vulkan_utils.h" | |
| namespace escher { | |
| namespace impl { | |
| bool CheckImageCreateInfoValidity(vk::PhysicalDevice device, const vk::ImageCreateInfo& info) { | |
| vk::ImageFormatProperties image_format_properties; | |
| vk::Result get_format_properties_result = device.getImageFormatProperties( | |
| info.format, info.imageType, info.tiling, info.usage, info.flags, &image_format_properties); | |
| if (get_format_properties_result != vk::Result::eSuccess) { | |
| FX_LOGS(ERROR) << "CheckImageCreateInfoValidity(): Image format / type / tiling / usage / " | |
| "flags is not supported."; | |
| return false; | |
| } | |
| if (image_format_properties.maxMipLevels < info.mipLevels) { | |
| FX_LOGS(ERROR) << "CheckImageCreateInfoValidity(): mipLevels exceeds the maximum limit = " | |
| << image_format_properties.maxMipLevels; | |
| return false; | |
| } | |
| if (image_format_properties.maxExtent.width < info.extent.width || | |
| image_format_properties.maxExtent.height < info.extent.height || | |
| image_format_properties.maxExtent.depth < info.extent.depth) { | |
| FX_LOGS(ERROR) << "CheckImageCreateInfoValidity(): extent " | |
| << "(" << info.extent.width << ", " << info.extent.height << ", " | |
| << info.extent.depth << ")" | |
| << " exceeds the maximum limit" | |
| << "(" << image_format_properties.maxExtent.width << ", " | |
| << image_format_properties.maxExtent.height << ", " | |
| << image_format_properties.maxExtent.depth << ")"; | |
| return false; | |
| } | |
| if (image_format_properties.maxArrayLayers < info.arrayLayers) { | |
| FX_LOGS(ERROR) << "CheckImageCreateInfoValidity(): arrayLayers exceeds the maximum limit = " | |
| << image_format_properties.maxArrayLayers; | |
| return false; | |
| } | |
| if (!(image_format_properties.sampleCounts & info.samples)) { | |
| FX_LOGS(ERROR) << "CheckImageCreateInfoValidity(): samples is not supported. " | |
| << "Requested sample counts: " << vk::to_string(info.samples) << "; " | |
| << "Supported sample counts: " | |
| << vk::to_string(image_format_properties.sampleCounts); | |
| return false; | |
| } | |
| return true; | |
| } | |
| std::vector<vk::Format> GetSupportedDepthFormats(vk::PhysicalDevice device, | |
| std::vector<vk::Format> desired_formats) { | |
| std::vector<vk::Format> result; | |
| for (auto& fmt : desired_formats) { | |
| vk::FormatProperties props = device.getFormatProperties(fmt); | |
| if (props.optimalTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment) { | |
| result.push_back(fmt); | |
| } | |
| } | |
| return result; | |
| } | |
| std::set<size_t> GetSupportedColorSampleCounts(vk::SampleCountFlags flags) { | |
| const auto kSampleCountFlagBits = {vk::SampleCountFlagBits::e1, vk::SampleCountFlagBits::e2, | |
| vk::SampleCountFlagBits::e4, vk::SampleCountFlagBits::e8, | |
| vk::SampleCountFlagBits::e16, vk::SampleCountFlagBits::e32, | |
| vk::SampleCountFlagBits::e64}; | |
| std::set<size_t> result; | |
| for (const auto flag_bit : kSampleCountFlagBits) { | |
| if (flag_bit & flags) { | |
| result.insert(SampleCountFlagBitsToInt(flag_bit)); | |
| } | |
| } | |
| return result; | |
| } | |
| FormatResult GetSupportedDepthFormat(vk::PhysicalDevice device) { | |
| auto supported_formats = | |
| GetSupportedDepthFormats(device, {vk::Format::eD16Unorm, vk::Format::eD32Sfloat}); | |
| if (supported_formats.empty()) { | |
| auto undefined = vk::Format::eUndefined; | |
| return FormatResult(vk::Result::eErrorFeatureNotPresent, undefined); | |
| } else { | |
| return FormatResult(vk::Result::eSuccess, supported_formats[0]); | |
| } | |
| } | |
| FormatResult GetSupportedDepthStencilFormat(vk::PhysicalDevice device) { | |
| auto supported_formats = GetSupportedDepthFormats( | |
| device, | |
| {vk::Format::eD16UnormS8Uint, vk::Format::eD24UnormS8Uint, vk::Format::eD32SfloatS8Uint}); | |
| if (supported_formats.empty()) { | |
| auto undefined = vk::Format::eUndefined; | |
| return FormatResult(vk::Result::eErrorFeatureNotPresent, undefined); | |
| } else { | |
| return FormatResult(vk::Result::eSuccess, supported_formats[0]); | |
| } | |
| } | |
| uint32_t GetMemoryTypeIndex(vk::PhysicalDevice device, uint32_t type_bits, | |
| vk::MemoryPropertyFlags required_properties) { | |
| vk::PhysicalDeviceMemoryProperties props = device.getMemoryProperties(); | |
| for (uint32_t i = 0; i < props.memoryTypeCount; ++i) { | |
| if (type_bits & 1) { | |
| auto available_properties = props.memoryTypes[i].propertyFlags; | |
| if ((available_properties & required_properties) == required_properties) | |
| return i; | |
| } | |
| type_bits >>= 1; | |
| } | |
| return props.memoryTypeCount; | |
| } | |
| uint32_t GetMemoryTypeIndices(vk::PhysicalDevice device, uint32_t type_bits, | |
| vk::MemoryPropertyFlags required_flags) { | |
| vk::PhysicalDeviceMemoryProperties props = device.getMemoryProperties(); | |
| return GetMemoryTypeIndices(props, type_bits, required_flags); | |
| } | |
| uint32_t GetMemoryTypeIndices(const vk::PhysicalDeviceMemoryProperties& properties, | |
| uint32_t type_bits, vk::MemoryPropertyFlags required_flags) { | |
| uint32_t result = 0; | |
| for (uint32_t i = 0; i < properties.memoryTypeCount; ++i) { | |
| if (type_bits & 1) { | |
| auto available_flags = properties.memoryTypes[i].propertyFlags; | |
| if ((available_flags & required_flags) == required_flags) { | |
| result |= (1 << i); | |
| } | |
| } | |
| type_bits >>= 1; | |
| } | |
| return result; | |
| } | |
| // Return the sample-count corresponding to the specified flag-bits. | |
| uint32_t SampleCountFlagBitsToInt(vk::SampleCountFlagBits bits) { | |
| static_assert(VK_SAMPLE_COUNT_1_BIT == 1 && VK_SAMPLE_COUNT_2_BIT == 2 && | |
| VK_SAMPLE_COUNT_4_BIT == 4 && VK_SAMPLE_COUNT_8_BIT == 8 && | |
| VK_SAMPLE_COUNT_16_BIT == 16 && VK_SAMPLE_COUNT_32_BIT == 32 && | |
| VK_SAMPLE_COUNT_64_BIT == 64, | |
| "unexpected sample count values"); | |
| return static_cast<uint32_t>(bits); | |
| } | |
| // Return flag-bits corresponding to the specified sample count. Explode if | |
| // an invalid value is provided. | |
| vk::SampleCountFlagBits SampleCountFlagBitsFromInt(uint32_t sample_count) { | |
| switch (sample_count) { | |
| case 1: | |
| return vk::SampleCountFlagBits::e1; | |
| case 2: | |
| return vk::SampleCountFlagBits::e2; | |
| case 4: | |
| return vk::SampleCountFlagBits::e4; | |
| case 8: | |
| return vk::SampleCountFlagBits::e8; | |
| case 16: | |
| return vk::SampleCountFlagBits::e16; | |
| case 32: | |
| return vk::SampleCountFlagBits::e32; | |
| case 64: | |
| return vk::SampleCountFlagBits::e64; | |
| default: | |
| FX_CHECK(false); | |
| return vk::SampleCountFlagBits::e1; | |
| } | |
| } | |
| void ClipToRect(vk::Rect2D* clippee, const vk::Rect2D& clipper) { | |
| int32_t min_x = std::max(clippee->offset.x, clipper.offset.x); | |
| int32_t max_x = std::min((clippee->offset.x + clippee->extent.width), | |
| (clipper.offset.x + clipper.extent.width)); | |
| int32_t min_y = std::max(clippee->offset.y, clipper.offset.y); | |
| int32_t max_y = std::min((clippee->offset.y + clippee->extent.height), | |
| (clipper.offset.y + clipper.extent.height)); | |
| FX_CHECK(max_x >= min_x); | |
| FX_CHECK(max_y >= min_y); | |
| clippee->offset.x = min_x; | |
| clippee->offset.y = min_y; | |
| clippee->extent.width = static_cast<uint32_t>(max_x - min_x); | |
| clippee->extent.height = static_cast<uint32_t>(max_y - min_y); | |
| } | |
| vk::BufferImageCopy GetDefaultBufferImageCopy(size_t width, size_t height) { | |
| vk::BufferImageCopy result; | |
| result.bufferOffset = 0U; | |
| result.bufferRowLength = 0U; | |
| result.bufferImageHeight = 0U; | |
| result.imageSubresource.aspectMask = vk::ImageAspectFlagBits::eColor; | |
| result.imageSubresource.mipLevel = 0; | |
| result.imageSubresource.baseArrayLayer = 0; | |
| result.imageSubresource.layerCount = 1; | |
| result.imageOffset = vk::Offset3D(0U, 0U, 0U); | |
| result.imageExtent = | |
| vk::Extent3D(static_cast<uint32_t>(width), static_cast<uint32_t>(height), 1U); | |
| return result; | |
| } | |
| bool IsYuvConversionSupported(vk::PhysicalDevice device, vk::Format format) { | |
| auto properties = device.getFormatProperties(format); | |
| // Vulkan specs requires that: | |
| // The potential format features of the sampler YCbCr conversion must | |
| // support VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or | |
| // VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT. | |
| if (!(properties.optimalTilingFeatures & (vk::FormatFeatureFlagBits::eCositedChromaSamples | | |
| vk::FormatFeatureFlagBits::eMidpointChromaSamples))) { | |
| return false; | |
| } | |
| return true; | |
| } | |
| } // namespace impl | |
| } // namespace escher |