1 /* 2 * Copyright 2016 Red Hat. 3 * Copyright 2016 Bas Nieuwenhuizen 4 * 5 * Based on u_format.h which is: 6 * Copyright 2009-2010 Vmware, Inc. 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the next 15 * paragraph) shall be included in all copies or substantial portions of the 16 * Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 23 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 24 * IN THE SOFTWARE. 25 */ 26 27 #pragma once 28 29 #ifdef __cplusplus 30 extern "C" { 31 #endif 32 33 #include <assert.h> 34 #include <vulkan/vulkan.h> 35 #include <util/macros.h> 36 enum vk_format_layout { 37 /** 38 * Formats with vk_format_block::width == vk_format_block::height == 1 39 * that can be described as an ordinary data structure. 40 */ 41 VK_FORMAT_LAYOUT_PLAIN = 0, 42 43 /** 44 * Formats with sub-sampled channels. 45 * 46 * This is for formats like YVYU where there is less than one sample per 47 * pixel. 48 */ 49 VK_FORMAT_LAYOUT_SUBSAMPLED = 3, 50 51 /** 52 * S3 Texture Compression formats. 53 */ 54 VK_FORMAT_LAYOUT_S3TC = 4, 55 56 /** 57 * Red-Green Texture Compression formats. 58 */ 59 VK_FORMAT_LAYOUT_RGTC = 5, 60 61 /** 62 * Ericsson Texture Compression 63 */ 64 VK_FORMAT_LAYOUT_ETC = 6, 65 66 /** 67 * BC6/7 Texture Compression 68 */ 69 VK_FORMAT_LAYOUT_BPTC = 7, 70 71 /** 72 * ASTC 73 */ 74 VK_FORMAT_LAYOUT_ASTC = 8, 75 76 /** 77 * Everything else that doesn't fit in any of the above layouts. 78 */ 79 VK_FORMAT_LAYOUT_OTHER = 9 80 }; 81 82 struct vk_format_block 83 { 84 /** Block width in pixels */ 85 unsigned width; 86 87 /** Block height in pixels */ 88 unsigned height; 89 90 /** Block size in bits */ 91 unsigned bits; 92 }; 93 94 enum vk_format_type { 95 VK_FORMAT_TYPE_VOID = 0, 96 VK_FORMAT_TYPE_UNSIGNED = 1, 97 VK_FORMAT_TYPE_SIGNED = 2, 98 VK_FORMAT_TYPE_FIXED = 3, 99 VK_FORMAT_TYPE_FLOAT = 4 100 }; 101 102 103 enum vk_format_colorspace { 104 VK_FORMAT_COLORSPACE_RGB = 0, 105 VK_FORMAT_COLORSPACE_SRGB = 1, 106 VK_FORMAT_COLORSPACE_YUV = 2, 107 VK_FORMAT_COLORSPACE_ZS = 3 108 }; 109 110 struct vk_format_channel_description { 111 unsigned type:5; 112 unsigned normalized:1; 113 unsigned pure_integer:1; 114 unsigned scaled:1; 115 unsigned size:8; 116 unsigned shift:16; 117 }; 118 119 struct vk_format_description 120 { 121 VkFormat format; 122 const char *name; 123 const char *short_name; 124 125 struct vk_format_block block; 126 enum vk_format_layout layout; 127 128 unsigned nr_channels:3; 129 unsigned is_array:1; 130 unsigned is_bitmask:1; 131 unsigned is_mixed:1; 132 133 struct vk_format_channel_description channel[4]; 134 135 unsigned char swizzle[4]; 136 137 enum vk_format_colorspace colorspace; 138 }; 139 140 extern const struct vk_format_description vk_format_description_table[]; 141 142 const struct vk_format_description *vk_format_description(VkFormat format); 143 144 /** 145 * Return total bits needed for the pixel format per block. 146 */ 147 static inline unsigned 148 vk_format_get_blocksizebits(VkFormat format) 149 { 150 const struct vk_format_description *desc = vk_format_description(format); 151 152 assert(desc); 153 if (!desc) { 154 return 0; 155 } 156 157 return desc->block.bits; 158 } 159 160 /** 161 * Return bytes per block (not pixel) for the given format. 162 */ 163 static inline unsigned 164 vk_format_get_blocksize(VkFormat format) 165 { 166 unsigned bits = vk_format_get_blocksizebits(format); 167 unsigned bytes = bits / 8; 168 169 assert(bits % 8 == 0); 170 assert(bytes > 0); 171 if (bytes == 0) { 172 bytes = 1; 173 } 174 175 return bytes; 176 } 177 178 static inline unsigned 179 vk_format_get_blockwidth(VkFormat format) 180 { 181 const struct vk_format_description *desc = vk_format_description(format); 182 183 assert(desc); 184 if (!desc) { 185 return 1; 186 } 187 188 return desc->block.width; 189 } 190 191 static inline unsigned 192 vk_format_get_blockheight(VkFormat format) 193 { 194 const struct vk_format_description *desc = vk_format_description(format); 195 196 assert(desc); 197 if (!desc) { 198 return 1; 199 } 200 201 return desc->block.height; 202 } 203 204 /** 205 * Return the index of the first non-void channel 206 * -1 if no non-void channels 207 */ 208 static inline int 209 vk_format_get_first_non_void_channel(VkFormat format) 210 { 211 const struct vk_format_description *desc = vk_format_description(format); 212 int i; 213 214 for (i = 0; i < 4; i++) 215 if (desc->channel[i].type != VK_FORMAT_TYPE_VOID) 216 break; 217 218 if (i == 4) 219 return -1; 220 221 return i; 222 } 223 224 enum vk_swizzle { 225 VK_SWIZZLE_X, 226 VK_SWIZZLE_Y, 227 VK_SWIZZLE_Z, 228 VK_SWIZZLE_W, 229 VK_SWIZZLE_0, 230 VK_SWIZZLE_1, 231 VK_SWIZZLE_NONE, 232 VK_SWIZZLE_MAX, /**< Number of enums counter (must be last) */ 233 }; 234 235 static inline VkImageAspectFlags 236 vk_format_aspects(VkFormat format) 237 { 238 switch (format) { 239 case VK_FORMAT_UNDEFINED: 240 return 0; 241 242 case VK_FORMAT_S8_UINT: 243 return VK_IMAGE_ASPECT_STENCIL_BIT; 244 245 case VK_FORMAT_D16_UNORM_S8_UINT: 246 case VK_FORMAT_D24_UNORM_S8_UINT: 247 case VK_FORMAT_D32_SFLOAT_S8_UINT: 248 return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; 249 250 case VK_FORMAT_D16_UNORM: 251 case VK_FORMAT_X8_D24_UNORM_PACK32: 252 case VK_FORMAT_D32_SFLOAT: 253 return VK_IMAGE_ASPECT_DEPTH_BIT; 254 255 default: 256 return VK_IMAGE_ASPECT_COLOR_BIT; 257 } 258 } 259 260 static inline enum vk_swizzle 261 radv_swizzle_conv(VkComponentSwizzle component, const unsigned char chan[4], VkComponentSwizzle vk_swiz) 262 { 263 int x; 264 265 if (vk_swiz == VK_COMPONENT_SWIZZLE_IDENTITY) 266 vk_swiz = component; 267 switch (vk_swiz) { 268 case VK_COMPONENT_SWIZZLE_ZERO: 269 return VK_SWIZZLE_0; 270 case VK_COMPONENT_SWIZZLE_ONE: 271 return VK_SWIZZLE_1; 272 case VK_COMPONENT_SWIZZLE_R: 273 for (x = 0; x < 4; x++) 274 if (chan[x] == 0) 275 return x; 276 return VK_SWIZZLE_0; 277 case VK_COMPONENT_SWIZZLE_G: 278 for (x = 0; x < 4; x++) 279 if (chan[x] == 1) 280 return x; 281 return VK_SWIZZLE_0; 282 case VK_COMPONENT_SWIZZLE_B: 283 for (x = 0; x < 4; x++) 284 if (chan[x] == 2) 285 return x; 286 return VK_SWIZZLE_0; 287 case VK_COMPONENT_SWIZZLE_A: 288 for (x = 0; x < 4; x++) 289 if (chan[x] == 3) 290 return x; 291 return VK_SWIZZLE_1; 292 default: 293 unreachable("Illegal swizzle"); 294 } 295 } 296 297 static inline void vk_format_compose_swizzles(const VkComponentMapping *mapping, 298 const unsigned char swz[4], 299 enum vk_swizzle dst[4]) 300 { 301 dst[0] = radv_swizzle_conv(VK_COMPONENT_SWIZZLE_R, swz, mapping->r); 302 dst[1] = radv_swizzle_conv(VK_COMPONENT_SWIZZLE_G, swz, mapping->g); 303 dst[2] = radv_swizzle_conv(VK_COMPONENT_SWIZZLE_B, swz, mapping->b); 304 dst[3] = radv_swizzle_conv(VK_COMPONENT_SWIZZLE_A, swz, mapping->a); 305 } 306 307 static inline bool 308 vk_format_is_compressed(VkFormat format) 309 { 310 const struct vk_format_description *desc = vk_format_description(format); 311 312 assert(desc); 313 if (!desc) { 314 return false; 315 } 316 317 switch (desc->layout) { 318 case VK_FORMAT_LAYOUT_S3TC: 319 case VK_FORMAT_LAYOUT_RGTC: 320 case VK_FORMAT_LAYOUT_ETC: 321 case VK_FORMAT_LAYOUT_BPTC: 322 case VK_FORMAT_LAYOUT_ASTC: 323 /* XXX add other formats in the future */ 324 return true; 325 default: 326 return false; 327 } 328 } 329 330 static inline bool 331 vk_format_has_depth(const struct vk_format_description *desc) 332 { 333 return desc->colorspace == VK_FORMAT_COLORSPACE_ZS && 334 desc->swizzle[0] != VK_SWIZZLE_NONE; 335 } 336 337 static inline bool 338 vk_format_has_stencil(const struct vk_format_description *desc) 339 { 340 return desc->colorspace == VK_FORMAT_COLORSPACE_ZS && 341 desc->swizzle[1] != VK_SWIZZLE_NONE; 342 } 343 344 static inline bool 345 vk_format_is_depth_or_stencil(VkFormat format) 346 { 347 const struct vk_format_description *desc = vk_format_description(format); 348 349 assert(desc); 350 if (!desc) { 351 return false; 352 } 353 354 return vk_format_has_depth(desc) || 355 vk_format_has_stencil(desc); 356 } 357 358 static inline bool 359 vk_format_is_depth(VkFormat format) 360 { 361 const struct vk_format_description *desc = vk_format_description(format); 362 363 assert(desc); 364 if (!desc) { 365 return false; 366 } 367 368 return vk_format_has_depth(desc); 369 } 370 371 static inline bool 372 vk_format_is_color(VkFormat format) 373 { 374 return !vk_format_is_depth_or_stencil(format); 375 } 376 377 static inline VkFormat 378 vk_format_depth_only(VkFormat format) 379 { 380 switch (format) { 381 case VK_FORMAT_D16_UNORM_S8_UINT: 382 return VK_FORMAT_D16_UNORM; 383 case VK_FORMAT_D24_UNORM_S8_UINT: 384 return VK_FORMAT_X8_D24_UNORM_PACK32; 385 case VK_FORMAT_D32_SFLOAT_S8_UINT: 386 return VK_FORMAT_D32_SFLOAT; 387 default: 388 return format; 389 } 390 } 391 392 static inline bool 393 vk_format_is_int(VkFormat format) 394 { 395 const struct vk_format_description *desc = vk_format_description(format); 396 int channel = vk_format_get_first_non_void_channel(format); 397 398 return channel >= 0 && desc->channel[channel].pure_integer; 399 } 400 401 static inline VkFormat 402 vk_format_stencil_only(VkFormat format) 403 { 404 return VK_FORMAT_S8_UINT; 405 } 406 407 static inline unsigned 408 vk_format_get_component_bits(VkFormat format, 409 enum vk_format_colorspace colorspace, 410 unsigned component) 411 { 412 const struct vk_format_description *desc = vk_format_description(format); 413 enum vk_format_colorspace desc_colorspace; 414 415 assert(format); 416 if (!format) { 417 return 0; 418 } 419 420 assert(component < 4); 421 422 /* Treat RGB and SRGB as equivalent. */ 423 if (colorspace == VK_FORMAT_COLORSPACE_SRGB) { 424 colorspace = VK_FORMAT_COLORSPACE_RGB; 425 } 426 if (desc->colorspace == VK_FORMAT_COLORSPACE_SRGB) { 427 desc_colorspace = VK_FORMAT_COLORSPACE_RGB; 428 } else { 429 desc_colorspace = desc->colorspace; 430 } 431 432 if (desc_colorspace != colorspace) { 433 return 0; 434 } 435 436 switch (desc->swizzle[component]) { 437 case VK_SWIZZLE_X: 438 return desc->channel[0].size; 439 case VK_SWIZZLE_Y: 440 return desc->channel[1].size; 441 case VK_SWIZZLE_Z: 442 return desc->channel[2].size; 443 case VK_SWIZZLE_W: 444 return desc->channel[3].size; 445 default: 446 return 0; 447 } 448 } 449 #ifdef __cplusplus 450 } // extern "C" { 451 #endif 452
