VulkanTypes.h

Go to the documentation of this file.

/*
 * Copyright 2022 Google LLC.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef skgpu_VulkanTypes_DEFINED
#define skgpu_VulkanTypes_DEFINED
 
#include "include/core/SkTypes.h"
#include "include/private/gpu/vk/SkiaVulkan.h"
 
#include <cstddef>
#include <functional>
#include <string>
#include <vector>
 
#ifndef VK_VERSION_1_1
#error Skia requires the use of Vulkan 1.1 headers
#endif
 
namespace skgpu {
 
using VulkanGetProc = std::function<PFN_vkVoidFunction(
        const char*, // function name
        VkInstance,  // instance or VK_NULL_HANDLE
        VkDevice     // device or VK_NULL_HANDLE
        )>;
 
typedef intptr_t VulkanBackendMemory;
 
/**
 * Types for interacting with Vulkan resources created externally to Skia.
 */
struct VulkanAlloc {
    // can be VK_NULL_HANDLE iff is an RT and is borrowed
    VkDeviceMemory      fMemory = VK_NULL_HANDLE;
    VkDeviceSize        fOffset = 0;
    VkDeviceSize        fSize = 0;  // this can be indeterminate iff Tex uses borrow semantics
    uint32_t            fFlags = 0;
    // handle to memory allocated via skgpu::VulkanMemoryAllocator.
    VulkanBackendMemory fBackendMemory = 0;
 
    enum Flag {
        kNoncoherent_Flag     = 0x1,   // memory must be flushed to device after mapping
        kMappable_Flag        = 0x2,   // memory is able to be mapped.
        kLazilyAllocated_Flag = 0x4,   // memory was created with lazy allocation
    };
 
    bool operator==(const VulkanAlloc& that) const {
        return fMemory == that.fMemory && fOffset == that.fOffset && fSize == that.fSize &&
               fFlags == that.fFlags && fUsesSystemHeap == that.fUsesSystemHeap;
    }
 
private:
    bool fUsesSystemHeap = false;
};
 
// Used to pass in the necessary information to create a VkSamplerYcbcrConversion object for an
// VkExternalFormatANDROID.
struct VulkanYcbcrConversionInfo {
    bool operator==(const VulkanYcbcrConversionInfo& that) const {
        // Invalid objects are not required to have all other fields initialized or matching.
        if (!this->isValid() && !that.isValid()) {
            return true;
        }
 
        // Note that we do not need to check for fFormatFeatures equality. This is because the
        // Vulkan spec dictates that Android hardware buffers with the same external format must
        // have the same support for key features. See
        // https://docs.vulkan.org/spec/latest/chapters/memory.html#_android_hardware_buffer_external_memory
        // for more details.
        return this->fFormat                      == that.fFormat                      &&
               this->fExternalFormat              == that.fExternalFormat              &&
               this->fYcbcrModel                  == that.fYcbcrModel                  &&
               this->fYcbcrRange                  == that.fYcbcrRange                  &&
               this->fXChromaOffset               == that.fXChromaOffset               &&
               this->fYChromaOffset               == that.fYChromaOffset               &&
               this->fChromaFilter                == that.fChromaFilter                &&
               this->fForceExplicitReconstruction == that.fForceExplicitReconstruction &&
               this->fComponents.r                == that.fComponents.r                &&
               this->fComponents.g                == that.fComponents.g                &&
               this->fComponents.b                == that.fComponents.b                &&
               this->fComponents.a                == that.fComponents.a;
    }
    bool operator!=(const VulkanYcbcrConversionInfo& that) const { return !(*this == that); }
 
    bool isValid() const {
        return fYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY ||
               fExternalFormat != 0;
    }
 
    uint32_t nonFormatInfoAsUInt32() const {
        static_assert(kComponentAShift + kComponentBits <= 32);
 
        SkASSERT(fYcbcrModel                  < (1u << kYcbcrModelBits        ));
        SkASSERT(fYcbcrRange                  < (1u << kYcbcrRangeBits        ));
        SkASSERT(fXChromaOffset               < (1u << kXChromaOffsetBits     ));
        SkASSERT(fYChromaOffset               < (1u << kYChromaOffsetBits     ));
        SkASSERT(fChromaFilter                < (1u << kChromaFilterBits      ));
        SkASSERT(fForceExplicitReconstruction < (1u << kForceExplicitReconBits));
        SkASSERT(fComponents.r                < (1u << kComponentBits         ));
        SkASSERT(fComponents.g                < (1u << kComponentBits         ));
        SkASSERT(fComponents.b                < (1u << kComponentBits         ));
        SkASSERT(fComponents.a                < (1u << kComponentBits         ));
 
        bool usesExternalFormat = fFormat == VK_FORMAT_UNDEFINED;
 
        return ((static_cast<uint32_t>(usesExternalFormat          ) << kUsesExternalFormatShift) |
                (static_cast<uint32_t>(fYcbcrModel                 ) << kYcbcrModelShift        ) |
                (static_cast<uint32_t>(fYcbcrRange                 ) << kYcbcrRangeShift        ) |
                (static_cast<uint32_t>(fXChromaOffset              ) << kXChromaOffsetShift     ) |
                (static_cast<uint32_t>(fYChromaOffset              ) << kYChromaOffsetShift     ) |
                (static_cast<uint32_t>(fChromaFilter               ) << kChromaFilterShift      ) |
                (static_cast<uint32_t>(fForceExplicitReconstruction) << kForceExplicitReconShift) |
                (static_cast<uint32_t>(fComponents.r               ) << kComponentRShift        ) |
                (static_cast<uint32_t>(fComponents.g               ) << kComponentGShift        ) |
                (static_cast<uint32_t>(fComponents.b               ) << kComponentBShift        ) |
                (static_cast<uint32_t>(fComponents.a               ) << kComponentAShift        ));
    }
 
    // Format of the source image. Must be set to VK_FORMAT_UNDEFINED for external images or
    // a valid image format otherwise.
    VkFormat fFormat = VK_FORMAT_UNDEFINED;
 
    // The external format. Must be non-zero for external images, zero otherwise.
    // Should be compatible to be used in a VkExternalFormatANDROID struct.
    uint64_t fExternalFormat = 0;
 
    VkSamplerYcbcrModelConversion fYcbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
    VkSamplerYcbcrRange fYcbcrRange           = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
    VkChromaLocation fXChromaOffset           = VK_CHROMA_LOCATION_COSITED_EVEN;
    VkChromaLocation fYChromaOffset           = VK_CHROMA_LOCATION_COSITED_EVEN;
    VkFilter fChromaFilter                    = VK_FILTER_NEAREST;
    VkBool32 fForceExplicitReconstruction     = false;
 
    // For external images format features here should be those returned by a call to
    // vkAndroidHardwareBufferFormatPropertiesANDROID
    VkFormatFeatureFlags fFormatFeatures = 0;
 
    // This is ignored when fExternalFormat is non-zero.
    VkComponentMapping fComponents            = {VK_COMPONENT_SWIZZLE_IDENTITY,
                                                 VK_COMPONENT_SWIZZLE_IDENTITY,
                                                 VK_COMPONENT_SWIZZLE_IDENTITY,
                                                 VK_COMPONENT_SWIZZLE_IDENTITY};
 
    static constexpr int kUsesExternalFormatBits  = 1;
    static constexpr int kYcbcrModelBits          = 3;
    static constexpr int kYcbcrRangeBits          = 1;
    static constexpr int kXChromaOffsetBits       = 1;
    static constexpr int kYChromaOffsetBits       = 1;
    static constexpr int kChromaFilterBits        = 1;
    static constexpr int kForceExplicitReconBits  = 1;
    static constexpr int kComponentBits           = 3;
 
    static constexpr int kUsesExternalFormatShift = 0;
    static constexpr int kYcbcrModelShift         = kUsesExternalFormatShift +
                                                    kUsesExternalFormatBits;
    static constexpr int kYcbcrRangeShift         = kYcbcrModelShift         + kYcbcrModelBits;
    static constexpr int kXChromaOffsetShift      = kYcbcrRangeShift         + kYcbcrRangeBits;
    static constexpr int kYChromaOffsetShift      = kXChromaOffsetShift      + kXChromaOffsetBits;
    static constexpr int kChromaFilterShift       = kYChromaOffsetShift      + kYChromaOffsetBits;
    static constexpr int kForceExplicitReconShift = kChromaFilterShift       + kChromaFilterBits;
    static constexpr int kComponentRShift         = kForceExplicitReconShift + kComponentBits;
    static constexpr int kComponentGShift         = kComponentRShift         + kComponentBits;
    static constexpr int kComponentBShift         = kComponentGShift         + kComponentBits;
    static constexpr int kComponentAShift         = kComponentBShift         + kComponentBits;
};
 
typedef void* VulkanDeviceLostContext;
typedef void (*VulkanDeviceLostProc)(VulkanDeviceLostContext faultContext,
                                     const std::string& description,
                                     const std::vector<VkDeviceFaultAddressInfoEXT>& addressInfos,
                                     const std::vector<VkDeviceFaultVendorInfoEXT>& vendorInfos,
                                     const std::vector<std::byte>& vendorBinaryData);
 
} // namespace skgpu
 
#endif // skgpu_VulkanTypes_DEFINED