1 /* 2 * Copyright 2020 Google LLC 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/GrBackendUtils.h" 9 10 #include "src/gpu/ganesh/GrDataUtils.h" 11 12 #ifdef SK_GL 13 #include "src/gpu/ganesh/gl/GrGLUtil.h" 14 #endif 15 16 #ifdef SK_VULKAN 17 #include "src/gpu/ganesh/vk/GrVkUtil.h" 18 #include "src/gpu/vk/VulkanUtilsPriv.h" 19 #endif 20 21 #ifdef SK_DIRECT3D 22 #include "src/gpu/ganesh/d3d/GrD3DUtil.h" 23 #endif 24 25 #ifdef SK_METAL 26 #include "src/gpu/ganesh/mtl/GrMtlCppUtil.h" 27 #endif 28 29 #ifdef SK_DAWN 30 #include "src/gpu/ganesh/dawn/GrDawnUtil.h" 31 #endif 32 GrBackendFormatToCompressionType(const GrBackendFormat & format)33SkImage::CompressionType GrBackendFormatToCompressionType(const GrBackendFormat& format) { 34 switch (format.backend()) { 35 case GrBackendApi::kOpenGL: { 36 #ifdef SK_GL 37 GrGLFormat glFormat = format.asGLFormat(); 38 switch (glFormat) { 39 case GrGLFormat::kCOMPRESSED_ETC1_RGB8: 40 case GrGLFormat::kCOMPRESSED_RGB8_ETC2: 41 return SkImage::CompressionType::kETC2_RGB8_UNORM; 42 case GrGLFormat::kCOMPRESSED_RGB8_BC1: 43 return SkImage::CompressionType::kBC1_RGB8_UNORM; 44 case GrGLFormat::kCOMPRESSED_RGBA8_BC1: 45 return SkImage::CompressionType::kBC1_RGBA8_UNORM; 46 default: 47 return SkImage::CompressionType::kNone; 48 } 49 #else 50 break; 51 #endif 52 } 53 case GrBackendApi::kVulkan: { 54 #ifdef SK_VULKAN 55 VkFormat vkFormat; 56 SkAssertResult(format.asVkFormat(&vkFormat)); 57 switch (vkFormat) { 58 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: 59 return SkImage::CompressionType::kETC2_RGB8_UNORM; 60 case VK_FORMAT_BC1_RGB_UNORM_BLOCK: 61 return SkImage::CompressionType::kBC1_RGB8_UNORM; 62 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: 63 return SkImage::CompressionType::kBC1_RGBA8_UNORM; 64 default: 65 return SkImage::CompressionType::kNone; 66 } 67 #else 68 break; 69 #endif 70 } 71 case GrBackendApi::kMetal: { 72 #ifdef SK_METAL 73 return GrMtlBackendFormatToCompressionType(format); 74 #else 75 break; 76 #endif 77 } 78 case GrBackendApi::kDirect3D: { 79 #ifdef SK_DIRECT3D 80 DXGI_FORMAT dxgiFormat; 81 SkAssertResult(format.asDxgiFormat(&dxgiFormat)); 82 switch (dxgiFormat) { 83 case DXGI_FORMAT_BC1_UNORM: 84 return SkImage::CompressionType::kBC1_RGBA8_UNORM; 85 default: 86 return SkImage::CompressionType::kNone; 87 } 88 #else 89 break; 90 #endif 91 } 92 case GrBackendApi::kDawn: { 93 return SkImage::CompressionType::kNone; 94 } 95 case GrBackendApi::kMock: { 96 return format.asMockCompressionType(); 97 } 98 } 99 return SkImage::CompressionType::kNone; 100 } 101 GrBackendFormatBytesPerBlock(const GrBackendFormat & format)102size_t GrBackendFormatBytesPerBlock(const GrBackendFormat& format) { 103 switch (format.backend()) { 104 case GrBackendApi::kOpenGL: { 105 #ifdef SK_GL 106 GrGLFormat glFormat = format.asGLFormat(); 107 return GrGLFormatBytesPerBlock(glFormat); 108 #else 109 break; 110 #endif 111 } 112 case GrBackendApi::kVulkan: { 113 #ifdef SK_VULKAN 114 VkFormat vkFormat; 115 SkAssertResult(format.asVkFormat(&vkFormat)); 116 return skgpu::VkFormatBytesPerBlock(vkFormat); 117 #else 118 break; 119 #endif 120 } 121 case GrBackendApi::kMetal: { 122 #ifdef SK_METAL 123 return GrMtlBackendFormatBytesPerBlock(format); 124 #else 125 break; 126 #endif 127 } 128 case GrBackendApi::kDirect3D: { 129 #ifdef SK_DIRECT3D 130 DXGI_FORMAT dxgiFormat; 131 SkAssertResult(format.asDxgiFormat(&dxgiFormat)); 132 return GrDxgiFormatBytesPerBlock(dxgiFormat); 133 #else 134 break; 135 #endif 136 } 137 case GrBackendApi::kDawn: { 138 #ifdef SK_DAWN 139 wgpu::TextureFormat dawnFormat; 140 SkAssertResult(format.asDawnFormat(&dawnFormat)); 141 return GrDawnBytesPerBlock(dawnFormat); 142 #else 143 break; 144 #endif 145 } 146 case GrBackendApi::kMock: { 147 SkImage::CompressionType compression = format.asMockCompressionType(); 148 if (compression != SkImage::CompressionType::kNone) { 149 return GrCompressedRowBytes(compression, 1); 150 } else if (format.isMockStencilFormat()) { 151 static constexpr int kMockStencilSize = 4; 152 return kMockStencilSize; 153 } 154 return GrColorTypeBytesPerPixel(format.asMockColorType()); 155 } 156 } 157 return 0; 158 } 159 GrBackendFormatBytesPerPixel(const GrBackendFormat & format)160size_t GrBackendFormatBytesPerPixel(const GrBackendFormat& format) { 161 if (GrBackendFormatToCompressionType(format) != SkImage::CompressionType::kNone) { 162 return 0; 163 } 164 return GrBackendFormatBytesPerBlock(format); 165 } 166 GrBackendFormatStencilBits(const GrBackendFormat & format)167int GrBackendFormatStencilBits(const GrBackendFormat& format) { 168 switch (format.backend()) { 169 case GrBackendApi::kOpenGL: { 170 #ifdef SK_GL 171 GrGLFormat glFormat = format.asGLFormat(); 172 return GrGLFormatStencilBits(glFormat); 173 #else 174 break; 175 #endif 176 } 177 case GrBackendApi::kVulkan: { 178 #ifdef SK_VULKAN 179 VkFormat vkFormat; 180 SkAssertResult(format.asVkFormat(&vkFormat)); 181 return skgpu::VkFormatStencilBits(vkFormat); 182 #else 183 break; 184 #endif 185 } 186 case GrBackendApi::kMetal: { 187 #ifdef SK_METAL 188 return GrMtlBackendFormatStencilBits(format); 189 #else 190 break; 191 #endif 192 } 193 case GrBackendApi::kDirect3D: { 194 #ifdef SK_DIRECT3D 195 DXGI_FORMAT dxgiFormat; 196 SkAssertResult(format.asDxgiFormat(&dxgiFormat)); 197 return GrDxgiFormatStencilBits(dxgiFormat); 198 #else 199 break; 200 #endif 201 } 202 case GrBackendApi::kDawn: { 203 #ifdef SK_DAWN 204 wgpu::TextureFormat dawnFormat; 205 SkAssertResult(format.asDawnFormat(&dawnFormat)); 206 return GrDawnFormatStencilBits(dawnFormat); 207 #else 208 break; 209 #endif 210 } 211 case GrBackendApi::kMock: { 212 if (format.isMockStencilFormat()) { 213 static constexpr int kMockStencilBits = 8; 214 return kMockStencilBits; 215 } 216 } 217 } 218 return 0; 219 } 220