/src/skia/src/gpu/ganesh/vk/GrVkUtil.cpp

Source (jump to first uncovered line)
/*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "src/gpu/ganesh/vk/GrVkUtil.h"

#include "include/gpu/ganesh/GrDirectContext.h"
#include "src/core/SkTraceEvent.h"
#include "src/gpu/ganesh/GrDirectContextPriv.h"
#include "src/gpu/ganesh/GrShaderCaps.h"
#include "src/gpu/ganesh/vk/GrVkCaps.h"
#include "src/gpu/ganesh/vk/GrVkGpu.h"
#include "src/gpu/vk/VulkanUtilsPriv.h"
#include "src/sksl/SkSLProgramKind.h"
#include "src/sksl/codegen/SkSLNativeShader.h"

#include <string.h>
#include <cstdint>
#include <vector>

namespace skgpu {
class ShaderErrorHandler;
}

bool GrVkFormatIsSupported(VkFormat format) {
    switch (format) {
        case VK_FORMAT_R8G8B8A8_UNORM:
        case VK_FORMAT_B8G8R8A8_UNORM:
        case VK_FORMAT_R8G8B8A8_SRGB:
        case VK_FORMAT_R8G8B8_UNORM:
        case VK_FORMAT_R8G8_UNORM:
        case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
        case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
        case VK_FORMAT_R5G6B5_UNORM_PACK16:
        case VK_FORMAT_B5G6R5_UNORM_PACK16:
        case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
        case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
        case VK_FORMAT_R8_UNORM:
        case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
        case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
        case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
        case VK_FORMAT_R16G16B16A16_SFLOAT:
        case VK_FORMAT_R16_SFLOAT:
        case VK_FORMAT_R16_UNORM:
        case VK_FORMAT_R16G16_UNORM:
        case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
        case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
        case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
        case VK_FORMAT_R16G16B16A16_UNORM:
        case VK_FORMAT_R16G16_SFLOAT:
        case VK_FORMAT_S8_UINT:
        case VK_FORMAT_D24_UNORM_S8_UINT:
        case VK_FORMAT_D32_SFLOAT_S8_UINT:
            return true;
        default:
            return false;
    }
}

SkSL::ProgramKind vk_shader_stage_to_skiasl_kind(VkShaderStageFlagBits stage) {
    if (VK_SHADER_STAGE_VERTEX_BIT == stage) {
        return SkSL::ProgramKind::kVertex;
    }
    SkASSERT(VK_SHADER_STAGE_FRAGMENT_BIT == stage);
    return SkSL::ProgramKind::kFragment;
}

bool GrCompileVkShaderModule(GrVkGpu* gpu,
                             const std::string& shaderString,
                             VkShaderStageFlagBits stage,
                             VkShaderModule* shaderModule,
                             VkPipelineShaderStageCreateInfo* stageInfo,
                             const SkSL::ProgramSettings& settings,
                             SkSL::NativeShader* outSPIRV,
                             SkSL::Program::Interface* outInterface) {
    TRACE_EVENT0("skia.shaders", "CompileVkShaderModule");
    skgpu::ShaderErrorHandler* errorHandler = gpu->getContext()->priv().getShaderErrorHandler();
    if (!skgpu::SkSLToSPIRV(gpu->vkCaps().shaderCaps(),
                            shaderString,
                            vk_shader_stage_to_skiasl_kind(stage),
                            settings,
                            outSPIRV,
                            outInterface,
                            errorHandler)) {
        return false;
    }

    return GrInstallVkShaderModule(gpu, *outSPIRV, stage, shaderModule, stageInfo);
}

bool GrInstallVkShaderModule(GrVkGpu* gpu,
                             const SkSL::NativeShader& spirv,
                             VkShaderStageFlagBits stage,
                             VkShaderModule* shaderModule,
                             VkPipelineShaderStageCreateInfo* stageInfo) {
    TRACE_EVENT0("skia.shaders", "InstallVkShaderModule");
    VkShaderModuleCreateInfo moduleCreateInfo;
    memset(&moduleCreateInfo, 0, sizeof(VkShaderModuleCreateInfo));
    moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    moduleCreateInfo.pNext = nullptr;
    moduleCreateInfo.flags = 0;
    moduleCreateInfo.codeSize = spirv.fBinary.size() * sizeof(uint32_t);
    moduleCreateInfo.pCode = spirv.fBinary.data();

    VkResult err;
    GR_VK_CALL_RESULT(gpu, err, CreateShaderModule(gpu->device(), &moduleCreateInfo, nullptr,
                                                   shaderModule));
    if (err) {
        return false;
    }

    memset(stageInfo, 0, sizeof(VkPipelineShaderStageCreateInfo));
    stageInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    stageInfo->pNext = nullptr;
    stageInfo->flags = 0;
    stageInfo->stage = stage;
    stageInfo->module = *shaderModule;
    stageInfo->pName = "main";
    stageInfo->pSpecializationInfo = nullptr;

    return true;
}

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2015 Google Inc.
3		*
4		* Use of this source code is governed by a BSD-style license that can be
5		* found in the LICENSE file.
6		*/
7
8		#include "src/gpu/ganesh/vk/GrVkUtil.h"
9
10		#include "include/gpu/ganesh/GrDirectContext.h"
11		#include "src/core/SkTraceEvent.h"
12		#include "src/gpu/ganesh/GrDirectContextPriv.h"
13		#include "src/gpu/ganesh/GrShaderCaps.h"
14		#include "src/gpu/ganesh/vk/GrVkCaps.h"
15		#include "src/gpu/ganesh/vk/GrVkGpu.h"
16		#include "src/gpu/vk/VulkanUtilsPriv.h"
17		#include "src/sksl/SkSLProgramKind.h"
18		#include "src/sksl/codegen/SkSLNativeShader.h"
19
20		#include <string.h>
21		#include <cstdint>
22		#include <vector>
23
24		namespace skgpu {
25		class ShaderErrorHandler;
26		}
27
28	0	bool GrVkFormatIsSupported(VkFormat format) {
29	0	switch (format) {
30	0	case VK_FORMAT_R8G8B8A8_UNORM:
31	0	case VK_FORMAT_B8G8R8A8_UNORM:
32	0	case VK_FORMAT_R8G8B8A8_SRGB:
33	0	case VK_FORMAT_R8G8B8_UNORM:
34	0	case VK_FORMAT_R8G8_UNORM:
35	0	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
36	0	case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
37	0	case VK_FORMAT_R5G6B5_UNORM_PACK16:
38	0	case VK_FORMAT_B5G6R5_UNORM_PACK16:
39	0	case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
40	0	case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
41	0	case VK_FORMAT_R8_UNORM:
42	0	case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
43	0	case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
44	0	case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
45	0	case VK_FORMAT_R16G16B16A16_SFLOAT:
46	0	case VK_FORMAT_R16_SFLOAT:
47	0	case VK_FORMAT_R16_UNORM:
48	0	case VK_FORMAT_R16G16_UNORM:
49	0	case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
50	0	case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
51	0	case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
52	0	case VK_FORMAT_R16G16B16A16_UNORM:
53	0	case VK_FORMAT_R16G16_SFLOAT:
54	0	case VK_FORMAT_S8_UINT:
55	0	case VK_FORMAT_D24_UNORM_S8_UINT:
56	0	case VK_FORMAT_D32_SFLOAT_S8_UINT:
57	0	return true;
58	0	default:
59	0	return false;
60	0	}
61	0	}
62
63	0	SkSL::ProgramKind vk_shader_stage_to_skiasl_kind(VkShaderStageFlagBits stage) {
64	0	if (VK_SHADER_STAGE_VERTEX_BIT == stage) {
65	0	return SkSL::ProgramKind::kVertex;
66	0	}
67	0	SkASSERT(VK_SHADER_STAGE_FRAGMENT_BIT == stage);
68	0	return SkSL::ProgramKind::kFragment;
69	0	} Unexecuted instantiation: vk_shader_stage_to_skiasl_kind(VkShaderStageFlagBits) Unexecuted instantiation: vk_shader_stage_to_skiasl_kind(VkShaderStageFlagBits)
70
71		bool GrCompileVkShaderModule(GrVkGpu* gpu,
72		const std::string& shaderString,
73		VkShaderStageFlagBits stage,
74		VkShaderModule* shaderModule,
75		VkPipelineShaderStageCreateInfo* stageInfo,
76		const SkSL::ProgramSettings& settings,
77		SkSL::NativeShader* outSPIRV,
78	0	SkSL::Program::Interface* outInterface) {
79	0	TRACE_EVENT0("skia.shaders", "CompileVkShaderModule");
80	0	skgpu::ShaderErrorHandler* errorHandler = gpu->getContext()->priv().getShaderErrorHandler();
81	0	if (!skgpu::SkSLToSPIRV(gpu->vkCaps().shaderCaps(),
82	0	shaderString,
83	0	vk_shader_stage_to_skiasl_kind(stage),
84	0	settings,
85	0	outSPIRV,
86	0	outInterface,
87	0	errorHandler)) {
88	0	return false;
89	0	}
90
91	0	return GrInstallVkShaderModule(gpu, *outSPIRV, stage, shaderModule, stageInfo);
92	0	}
93
94		bool GrInstallVkShaderModule(GrVkGpu* gpu,
95		const SkSL::NativeShader& spirv,
96		VkShaderStageFlagBits stage,
97		VkShaderModule* shaderModule,
98	0	VkPipelineShaderStageCreateInfo* stageInfo) {
99	0	TRACE_EVENT0("skia.shaders", "InstallVkShaderModule");
100	0	VkShaderModuleCreateInfo moduleCreateInfo;
101	0	memset(&moduleCreateInfo, 0, sizeof(VkShaderModuleCreateInfo));
102	0	moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
103	0	moduleCreateInfo.pNext = nullptr;
104	0	moduleCreateInfo.flags = 0;
105	0	moduleCreateInfo.codeSize = spirv.fBinary.size() * sizeof(uint32_t);
106	0	moduleCreateInfo.pCode = spirv.fBinary.data();
107
108	0	VkResult err;
109	0	GR_VK_CALL_RESULT(gpu, err, CreateShaderModule(gpu->device(), &moduleCreateInfo, nullptr,
110	0	shaderModule));
111	0	if (err) {
112	0	return false;
113	0	}
114
115	0	memset(stageInfo, 0, sizeof(VkPipelineShaderStageCreateInfo));
116	0	stageInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
117	0	stageInfo->pNext = nullptr;
118	0	stageInfo->flags = 0;
119	0	stageInfo->stage = stage;
120	0	stageInfo->module = *shaderModule;
121	0	stageInfo->pName = "main";
122	0	stageInfo->pSpecializationInfo = nullptr;
123
124	0	return true;
125	0	} Unexecuted instantiation: GrInstallVkShaderModule(GrVkGpu, SkSL::NativeShader const&, VkShaderStageFlagBits, VkShaderModule_T, VkPipelineShaderStageCreateInfo) Unexecuted instantiation: GrInstallVkShaderModule(GrVkGpu, SkSL::NativeShader const&, VkShaderStageFlagBits, VkShaderModule_T, VkPipelineShaderStageCreateInfo)

Coverage Report

Created: 2025-06-24 08:20