GrVkGpu.cpp File Reference

#include "src/gpu/ganesh/vk/GrVkGpu.h"
#include "include/core/SkTextureCompressionType.h"
#include "include/gpu/GrBackendSemaphore.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/ganesh/vk/GrVkBackendSemaphore.h"
#include "include/gpu/ganesh/vk/GrVkBackendSurface.h"
#include "include/gpu/vk/GrVkTypes.h"
#include "include/gpu/vk/VulkanBackendContext.h"
#include "include/gpu/vk/VulkanExtensions.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkRectMemcpy.h"
#include "src/core/SkCompressedDataUtils.h"
#include "src/core/SkMipmap.h"
#include "src/core/SkTraceEvent.h"
#include "src/gpu/DataUtils.h"
#include "src/gpu/ganesh/GrBackendUtils.h"
#include "src/gpu/ganesh/GrDataUtils.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrGeometryProcessor.h"
#include "src/gpu/ganesh/GrGpuResourceCacheAccess.h"
#include "src/gpu/ganesh/GrNativeRect.h"
#include "src/gpu/ganesh/GrPipeline.h"
#include "src/gpu/ganesh/GrPixmap.h"
#include "src/gpu/ganesh/GrRenderTarget.h"
#include "src/gpu/ganesh/GrResourceProvider.h"
#include "src/gpu/ganesh/GrTexture.h"
#include "src/gpu/ganesh/GrThreadSafePipelineBuilder.h"
#include "src/gpu/ganesh/SkGr.h"
#include "src/gpu/ganesh/image/SkImage_Ganesh.h"
#include "src/gpu/ganesh/surface/SkSurface_Ganesh.h"
#include "src/gpu/ganesh/vk/GrVkBuffer.h"
#include "src/gpu/ganesh/vk/GrVkCommandBuffer.h"
#include "src/gpu/ganesh/vk/GrVkCommandPool.h"
#include "src/gpu/ganesh/vk/GrVkFramebuffer.h"
#include "src/gpu/ganesh/vk/GrVkImage.h"
#include "src/gpu/ganesh/vk/GrVkOpsRenderPass.h"
#include "src/gpu/ganesh/vk/GrVkPipeline.h"
#include "src/gpu/ganesh/vk/GrVkPipelineState.h"
#include "src/gpu/ganesh/vk/GrVkRenderPass.h"
#include "src/gpu/ganesh/vk/GrVkResourceProvider.h"
#include "src/gpu/ganesh/vk/GrVkSemaphore.h"
#include "src/gpu/ganesh/vk/GrVkTexture.h"
#include "src/gpu/ganesh/vk/GrVkTextureRenderTarget.h"
#include "src/gpu/vk/VulkanInterface.h"
#include "src/gpu/vk/VulkanMemory.h"
#include "src/gpu/vk/VulkanUtilsPriv.h"
#include "include/gpu/vk/VulkanTypes.h"
#include "include/private/gpu/vk/SkiaVulkan.h"

Go to the source code of this file.

Macros
#define	VK_CALL(X)   GR_VK_CALL(this->vkInterface(), X)
#define	VK_CALL_RET(RET, X)   GR_VK_CALL_RESULT(this, RET, X)

Functions
static void	add_transfer_dst_buffer_mem_barrier (GrVkGpu *gpu, GrVkBuffer *dst, size_t offset, size_t size, bool after)
static size_t	fill_in_compressed_regions (GrStagingBufferManager *stagingBufferManager, TArray< VkBufferImageCopy > *regions, TArray< size_t > *individualMipOffsets, GrStagingBufferManager::Slice *slice, SkTextureCompressionType compression, VkFormat vkFormat, SkISize dimensions, skgpu::Mipmapped mipmapped)
static bool	check_image_info (const GrVkCaps &caps, const GrVkImageInfo &info, bool needsAllocation, uint32_t graphicsQueueIndex)
static bool	check_tex_image_info (const GrVkCaps &caps, const GrVkImageInfo &info)
static bool	check_rt_image_info (const GrVkCaps &caps, const GrVkImageInfo &info, bool resolveOnly)
bool	copy_src_data (char *mapPtr, VkFormat vkFormat, const TArray< size_t > &individualMipOffsets, const GrPixmap srcData[], int numMipLevels)
void	set_layout_and_queue_from_mutable_state (GrVkGpu *gpu, GrVkImage *image, VkImageLayout newLayout, uint32_t newQueueFamilyIndex)

Macro Definition Documentation

VK_CALL

#define VK_CALL

(

X

)

GR_VK_CALL(this->vkInterface(), X)

Definition at line 67 of file GrVkGpu.cpp.

VK_CALL_RET

#define VK_CALL_RET	(		RET,
			X
	)		GR_VK_CALL_RESULT(this, RET, X)

Definition at line 68 of file GrVkGpu.cpp.

Function Documentation

add_transfer_dst_buffer_mem_barrier()

static void add_transfer_dst_buffer_mem_barrier ( GrVkGpu *  gpu, GrVkBuffer *  dst, size_t  offset, size_t  size, bool  after  )

static

Definition at line 550 of file GrVkGpu.cpp.

                                                            {
    if (dst->intendedType() != GrGpuBufferType::kIndex &&
        dst->intendedType() != GrGpuBufferType::kVertex) {
        return;
    }
 
    VkAccessFlags srcAccessMask = dst->intendedType() == GrGpuBufferType::kIndex
                                          ? VK_ACCESS_INDEX_READ_BIT
                                          : VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
    VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
 
    VkPipelineStageFlagBits srcPipelineStageFlags = VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
    VkPipelineStageFlagBits dstPipelineStageFlags = VK_PIPELINE_STAGE_TRANSFER_BIT;
 
    if (after) {
        using std::swap;
        swap(srcAccessMask,         dstAccessMask        );
        swap(srcPipelineStageFlags, dstPipelineStageFlags);
    }
 
    VkBufferMemoryBarrier bufferMemoryBarrier = {
            VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,  // sType
            nullptr,                                  // pNext
            srcAccessMask,                            // srcAccessMask
            dstAccessMask,                            // dstAccessMask
            VK_QUEUE_FAMILY_IGNORED,                  // srcQueueFamilyIndex
            VK_QUEUE_FAMILY_IGNORED,                  // dstQueueFamilyIndex
            dst->vkBuffer(),                          // buffer
            offset,                                   // offset
            size,                                     // size
    };
 
    gpu->addBufferMemoryBarrier(srcPipelineStageFlags,
                                dstPipelineStageFlags,
                                /*byRegion=*/false,
                                &bufferMemoryBarrier);
}

check_image_info()

static bool check_image_info ( const GrVkCaps &  caps, const GrVkImageInfo &  info, bool  needsAllocation, uint32_t  graphicsQueueIndex  )

static

Definition at line 1275 of file GrVkGpu.cpp.

                                                          {
    if (VK_NULL_HANDLE == info.fImage) {
        return false;
    }
 
    if (VK_NULL_HANDLE == info.fAlloc.fMemory && needsAllocation) {
        return false;
    }
 
    if (info.fImageLayout == VK_IMAGE_LAYOUT_PRESENT_SRC_KHR && !caps.supportsSwapchain()) {
        return false;
    }
 
    if (info.fCurrentQueueFamily != VK_QUEUE_FAMILY_IGNORED &&
        info.fCurrentQueueFamily != VK_QUEUE_FAMILY_EXTERNAL &&
        info.fCurrentQueueFamily != VK_QUEUE_FAMILY_FOREIGN_EXT) {
        if (info.fSharingMode == VK_SHARING_MODE_EXCLUSIVE) {
            if (info.fCurrentQueueFamily != graphicsQueueIndex) {
                return false;
            }
        } else {
            return false;
        }
    }
 
    if (info.fYcbcrConversionInfo.isValid()) {
        if (!caps.supportsYcbcrConversion()) {
            return false;
        }
        if (info.fYcbcrConversionInfo.fExternalFormat != 0) {
            return true;
        }
    }
 
    // We currently require everything to be made with transfer bits set
    if (!SkToBool(info.fImageUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) ||
        !SkToBool(info.fImageUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)) {
        return false;
    }
 
    return true;
}

check_rt_image_info()

static bool check_rt_image_info ( const GrVkCaps &  caps, const GrVkImageInfo &  info, bool  resolveOnly  )

static

Definition at line 1363 of file GrVkGpu.cpp.

                                                                                                   {
    if (!caps.isFormatRenderable(info.fFormat, info.fSampleCount)) {
        return false;
    }
    if (!resolveOnly && !SkToBool(info.fImageUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) {
        return false;
    }
    return true;
}

check_tex_image_info()

static bool check_tex_image_info ( const GrVkCaps &  caps, const GrVkImageInfo &  info  )

static

Definition at line 1321 of file GrVkGpu.cpp.

                                                                                  {
    // We don't support directly importing multisampled textures for sampling from shaders.
    if (info.fSampleCount != 1) {
        return false;
    }
 
    if (info.fYcbcrConversionInfo.isValid() && info.fYcbcrConversionInfo.fExternalFormat != 0) {
        return true;
    }
    if (info.fImageTiling == VK_IMAGE_TILING_OPTIMAL) {
        if (!caps.isVkFormatTexturable(info.fFormat)) {
            return false;
        }
    } else if (info.fImageTiling == VK_IMAGE_TILING_LINEAR) {
        if (!caps.isVkFormatTexturableLinearly(info.fFormat)) {
            return false;
        }
    } else if (info.fImageTiling == VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT) {
        if (!caps.supportsDRMFormatModifiers()) {
            return false;
        }
        // To be technically correct we should query the vulkan support for VkFormat and
        // drmFormatModifier pairs to confirm the required feature support is there. However, we
        // currently don't have our caps and format tables set up to do this effeciently. So
        // instead we just rely on the client's passed in VkImageUsageFlags and assume they we set
        // up using valid features (checked below). In practice this should all be safe because
        // currently we are setting all drm format modifier textures to have a
        // GrTextureType::kExternal so we just really need to be able to read these video VkImage in
        // a shader. The video decoder isn't going to give us VkImages that don't support being
        // sampled.
    } else {
        SkUNREACHABLE;
    }
 
    // We currently require all textures to be made with sample support
    if (!SkToBool(info.fImageUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT)) {
        return false;
    }
 
    return true;
}

copy_src_data()

bool copy_src_data	(	char *	mapPtr,
		VkFormat	vkFormat,
		const TArray< size_t > &	individualMipOffsets,
		const GrPixmap	srcData[],
		int	numMipLevels
	)

Definition at line 1625 of file GrVkGpu.cpp.

                                     {
    SkASSERT(srcData && numMipLevels);
    SkASSERT(!skgpu::VkFormatIsCompressed(vkFormat));
    SkASSERT(individualMipOffsets.size() == numMipLevels);
    SkASSERT(mapPtr);
 
    size_t bytesPerPixel = skgpu::VkFormatBytesPerBlock(vkFormat);
 
    for (int level = 0; level < numMipLevels; ++level) {
        const size_t trimRB = srcData[level].info().width() * bytesPerPixel;
 
        SkRectMemcpy(mapPtr + individualMipOffsets[level], trimRB,
                     srcData[level].addr(), srcData[level].rowBytes(),
                     trimRB, srcData[level].height());
    }
    return true;
}

fill_in_compressed_regions()

static size_t fill_in_compressed_regions ( GrStagingBufferManager *  stagingBufferManager, TArray< VkBufferImageCopy > *  regions, TArray< size_t > *  individualMipOffsets, GrStagingBufferManager::Slice *  slice, SkTextureCompressionType  compression, VkFormat  vkFormat, SkISize  dimensions, skgpu::Mipmapped  mipmapped  )

static

Definition at line 881 of file GrVkGpu.cpp.

                                                                   {
    SkASSERT(compression != SkTextureCompressionType::kNone);
    int numMipLevels = 1;
    if (mipmapped == skgpu::Mipmapped::kYes) {
        numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
    }
 
    regions->reserve_exact(regions->size() + numMipLevels);
    individualMipOffsets->reserve_exact(individualMipOffsets->size() + numMipLevels);
 
    size_t bytesPerBlock = skgpu::VkFormatBytesPerBlock(vkFormat);
 
    size_t bufferSize = SkCompressedDataSize(
            compression, dimensions, individualMipOffsets, mipmapped == skgpu::Mipmapped::kYes);
    SkASSERT(individualMipOffsets->size() == numMipLevels);
 
    // Get a staging buffer slice to hold our mip data.
    // Vulkan requires offsets in the buffer to be aligned to multiple of the texel size and 4
    size_t alignment = bytesPerBlock;
    switch (alignment & 0b11) {
        case 0:                     break;   // alignment is already a multiple of 4.
        case 2:     alignment *= 2; break;   // alignment is a multiple of 2 but not 4.
        default:    alignment *= 4; break;   // alignment is not a multiple of 2.
    }
    *slice = stagingBufferManager->allocateStagingBufferSlice(bufferSize, alignment);
    if (!slice->fBuffer) {
        return 0;
    }
 
    for (int i = 0; i < numMipLevels; ++i) {
        VkBufferImageCopy& region = regions->push_back();
        memset(&region, 0, sizeof(VkBufferImageCopy));
        region.bufferOffset = slice->fOffset + (*individualMipOffsets)[i];
        SkISize revisedDimensions = skgpu::CompressedDimensions(compression, dimensions);
        region.bufferRowLength = revisedDimensions.width();
        region.bufferImageHeight = revisedDimensions.height();
        region.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, SkToU32(i), 0, 1};
        region.imageOffset = {0, 0, 0};
        region.imageExtent = {SkToU32(dimensions.width()),
                              SkToU32(dimensions.height()), 1};
 
        dimensions = {std::max(1, dimensions.width() /2),
                      std::max(1, dimensions.height()/2)};
    }
 
    return bufferSize;
}

set_layout_and_queue_from_mutable_state()

void set_layout_and_queue_from_mutable_state	(	GrVkGpu *	gpu,
		GrVkImage *	image,
		VkImageLayout	newLayout,
		uint32_t	newQueueFamilyIndex
	)

Definition at line 1899 of file GrVkGpu.cpp.

                                                                           {
    // Even though internally we use this helper for getting src access flags and stages they
    // can also be used for general dst flags since we don't know exactly what the client
    // plans on using the image for.
    if (newLayout == VK_IMAGE_LAYOUT_UNDEFINED) {
        newLayout = image->currentLayout();
    }
    VkPipelineStageFlags dstStage = GrVkImage::LayoutToPipelineSrcStageFlags(newLayout);
    VkAccessFlags dstAccess = GrVkImage::LayoutToSrcAccessMask(newLayout);
 
    uint32_t currentQueueFamilyIndex = image->currentQueueFamilyIndex();
    auto isSpecialQueue = [](uint32_t queueFamilyIndex) {
        return queueFamilyIndex == VK_QUEUE_FAMILY_EXTERNAL ||
               queueFamilyIndex == VK_QUEUE_FAMILY_FOREIGN_EXT;
    };
    if (isSpecialQueue(currentQueueFamilyIndex) && isSpecialQueue(newQueueFamilyIndex)) {
        // It is illegal to have both the new and old queue be special queue families (i.e. external
        // or foreign).
        return;
    }
 
    image->setImageLayoutAndQueueIndex(gpu, newLayout, dstAccess, dstStage, false,
                                       newQueueFamilyIndex);
}