anv_formats.c revision 9f464c52
1/* 2 * Copyright © 2015 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 */ 23 24#include "anv_private.h" 25#include "drm-uapi/drm_fourcc.h" 26#include "vk_enum_to_str.h" 27#include "vk_format_info.h" 28#include "vk_util.h" 29 30/* 31 * gcc-4 and earlier don't allow compound literals where a constant 32 * is required in -std=c99/gnu99 mode, so we can't use ISL_SWIZZLE() 33 * here. -std=c89/gnu89 would allow it, but we depend on c99 features 34 * so using -std=c89/gnu89 is not an option. Starting from gcc-5 35 * compound literals can also be considered constant in -std=c99/gnu99 36 * mode. 37 */ 38#define _ISL_SWIZZLE(r, g, b, a) { \ 39 ISL_CHANNEL_SELECT_##r, \ 40 ISL_CHANNEL_SELECT_##g, \ 41 ISL_CHANNEL_SELECT_##b, \ 42 ISL_CHANNEL_SELECT_##a, \ 43} 44 45#define RGBA _ISL_SWIZZLE(RED, GREEN, BLUE, ALPHA) 46#define BGRA _ISL_SWIZZLE(BLUE, GREEN, RED, ALPHA) 47#define RGB1 _ISL_SWIZZLE(RED, GREEN, BLUE, ONE) 48 49#define swiz_fmt1(__vk_fmt, __hw_fmt, __swizzle) \ 50 [VK_ENUM_OFFSET(__vk_fmt)] = { \ 51 .planes = { \ 52 { .isl_format = __hw_fmt, .swizzle = __swizzle, \ 53 .denominator_scales = { 1, 1, }, \ 54 .aspect = VK_IMAGE_ASPECT_COLOR_BIT, \ 55 }, \ 56 }, \ 57 .vk_format = __vk_fmt, \ 58 .n_planes = 1, \ 59 } 60 61#define fmt1(__vk_fmt, __hw_fmt) \ 62 swiz_fmt1(__vk_fmt, __hw_fmt, RGBA) 63 64#define d_fmt(__vk_fmt, __hw_fmt) \ 65 [VK_ENUM_OFFSET(__vk_fmt)] = { \ 66 .planes = { \ 67 { .isl_format = __hw_fmt, .swizzle = RGBA, \ 68 .denominator_scales = { 1, 1, }, \ 69 .aspect = VK_IMAGE_ASPECT_DEPTH_BIT, \ 70 }, \ 71 }, \ 72 .vk_format = __vk_fmt, \ 73 .n_planes = 1, \ 74 } 75 76#define s_fmt(__vk_fmt, __hw_fmt) \ 77 [VK_ENUM_OFFSET(__vk_fmt)] = { \ 78 .planes = { \ 79 { .isl_format = __hw_fmt, .swizzle = RGBA, \ 80 .denominator_scales = { 1, 1, }, \ 81 .aspect = VK_IMAGE_ASPECT_STENCIL_BIT, \ 82 }, \ 83 }, \ 84 .vk_format = __vk_fmt, \ 85 .n_planes = 1, \ 86 } 87 88#define ds_fmt2(__vk_fmt, __fmt1, __fmt2) \ 89 [VK_ENUM_OFFSET(__vk_fmt)] = { \ 90 .planes = { \ 91 { .isl_format = __fmt1, .swizzle = RGBA, \ 92 .denominator_scales = { 1, 1, }, \ 93 .aspect = VK_IMAGE_ASPECT_DEPTH_BIT, \ 94 }, \ 95 { .isl_format = __fmt2, .swizzle = RGBA, \ 96 .denominator_scales = { 1, 1, }, \ 97 .aspect = VK_IMAGE_ASPECT_STENCIL_BIT, \ 98 }, \ 99 }, \ 100 .vk_format = __vk_fmt, \ 101 .n_planes = 2, \ 102 } 103 104#define fmt_unsupported(__vk_fmt) \ 105 [VK_ENUM_OFFSET(__vk_fmt)] = { \ 106 .planes = { \ 107 { .isl_format = ISL_FORMAT_UNSUPPORTED, }, \ 108 }, \ 109 .vk_format = VK_FORMAT_UNDEFINED, \ 110 } 111 112#define y_plane(__plane, __hw_fmt, __swizzle, __ycbcr_swizzle, dhs, dvs) \ 113 { .isl_format = __hw_fmt, \ 114 .swizzle = __swizzle, \ 115 .ycbcr_swizzle = __ycbcr_swizzle, \ 116 .denominator_scales = { dhs, dvs, }, \ 117 .has_chroma = false, \ 118 .aspect = VK_IMAGE_ASPECT_PLANE_0_BIT, /* Y plane is always plane 0 */ \ 119 } 120 121#define chroma_plane(__plane, __hw_fmt, __swizzle, __ycbcr_swizzle, dhs, dvs) \ 122 { .isl_format = __hw_fmt, \ 123 .swizzle = __swizzle, \ 124 .ycbcr_swizzle = __ycbcr_swizzle, \ 125 .denominator_scales = { dhs, dvs, }, \ 126 .has_chroma = true, \ 127 .aspect = VK_IMAGE_ASPECT_PLANE_ ## __plane ## _BIT, \ 128 } 129 130#define ycbcr_fmt(__vk_fmt, __n_planes, ...) \ 131 [VK_ENUM_OFFSET(__vk_fmt)] = { \ 132 .planes = { \ 133 __VA_ARGS__, \ 134 }, \ 135 .vk_format = __vk_fmt, \ 136 .n_planes = __n_planes, \ 137 .can_ycbcr = true, \ 138 } 139 140/* HINT: For array formats, the ISL name should match the VK name. For 141 * packed formats, they should have the channels in reverse order from each 142 * other. The reason for this is that, for packed formats, the ISL (and 143 * bspec) names are in LSB -> MSB order while VK formats are MSB -> LSB. 144 */ 145static const struct anv_format main_formats[] = { 146 fmt_unsupported(VK_FORMAT_UNDEFINED), 147 fmt_unsupported(VK_FORMAT_R4G4_UNORM_PACK8), 148 fmt1(VK_FORMAT_R4G4B4A4_UNORM_PACK16, ISL_FORMAT_A4B4G4R4_UNORM), 149 swiz_fmt1(VK_FORMAT_B4G4R4A4_UNORM_PACK16, ISL_FORMAT_A4B4G4R4_UNORM, BGRA), 150 fmt1(VK_FORMAT_R5G6B5_UNORM_PACK16, ISL_FORMAT_B5G6R5_UNORM), 151 swiz_fmt1(VK_FORMAT_B5G6R5_UNORM_PACK16, ISL_FORMAT_B5G6R5_UNORM, BGRA), 152 fmt1(VK_FORMAT_R5G5B5A1_UNORM_PACK16, ISL_FORMAT_A1B5G5R5_UNORM), 153 fmt_unsupported(VK_FORMAT_B5G5R5A1_UNORM_PACK16), 154 fmt1(VK_FORMAT_A1R5G5B5_UNORM_PACK16, ISL_FORMAT_B5G5R5A1_UNORM), 155 fmt1(VK_FORMAT_R8_UNORM, ISL_FORMAT_R8_UNORM), 156 fmt1(VK_FORMAT_R8_SNORM, ISL_FORMAT_R8_SNORM), 157 fmt1(VK_FORMAT_R8_USCALED, ISL_FORMAT_R8_USCALED), 158 fmt1(VK_FORMAT_R8_SSCALED, ISL_FORMAT_R8_SSCALED), 159 fmt1(VK_FORMAT_R8_UINT, ISL_FORMAT_R8_UINT), 160 fmt1(VK_FORMAT_R8_SINT, ISL_FORMAT_R8_SINT), 161 swiz_fmt1(VK_FORMAT_R8_SRGB, ISL_FORMAT_L8_UNORM_SRGB, 162 _ISL_SWIZZLE(RED, ZERO, ZERO, ONE)), 163 fmt1(VK_FORMAT_R8G8_UNORM, ISL_FORMAT_R8G8_UNORM), 164 fmt1(VK_FORMAT_R8G8_SNORM, ISL_FORMAT_R8G8_SNORM), 165 fmt1(VK_FORMAT_R8G8_USCALED, ISL_FORMAT_R8G8_USCALED), 166 fmt1(VK_FORMAT_R8G8_SSCALED, ISL_FORMAT_R8G8_SSCALED), 167 fmt1(VK_FORMAT_R8G8_UINT, ISL_FORMAT_R8G8_UINT), 168 fmt1(VK_FORMAT_R8G8_SINT, ISL_FORMAT_R8G8_SINT), 169 fmt_unsupported(VK_FORMAT_R8G8_SRGB), /* L8A8_UNORM_SRGB */ 170 fmt1(VK_FORMAT_R8G8B8_UNORM, ISL_FORMAT_R8G8B8_UNORM), 171 fmt1(VK_FORMAT_R8G8B8_SNORM, ISL_FORMAT_R8G8B8_SNORM), 172 fmt1(VK_FORMAT_R8G8B8_USCALED, ISL_FORMAT_R8G8B8_USCALED), 173 fmt1(VK_FORMAT_R8G8B8_SSCALED, ISL_FORMAT_R8G8B8_SSCALED), 174 fmt1(VK_FORMAT_R8G8B8_UINT, ISL_FORMAT_R8G8B8_UINT), 175 fmt1(VK_FORMAT_R8G8B8_SINT, ISL_FORMAT_R8G8B8_SINT), 176 fmt1(VK_FORMAT_R8G8B8_SRGB, ISL_FORMAT_R8G8B8_UNORM_SRGB), 177 fmt1(VK_FORMAT_R8G8B8A8_UNORM, ISL_FORMAT_R8G8B8A8_UNORM), 178 fmt1(VK_FORMAT_R8G8B8A8_SNORM, ISL_FORMAT_R8G8B8A8_SNORM), 179 fmt1(VK_FORMAT_R8G8B8A8_USCALED, ISL_FORMAT_R8G8B8A8_USCALED), 180 fmt1(VK_FORMAT_R8G8B8A8_SSCALED, ISL_FORMAT_R8G8B8A8_SSCALED), 181 fmt1(VK_FORMAT_R8G8B8A8_UINT, ISL_FORMAT_R8G8B8A8_UINT), 182 fmt1(VK_FORMAT_R8G8B8A8_SINT, ISL_FORMAT_R8G8B8A8_SINT), 183 fmt1(VK_FORMAT_R8G8B8A8_SRGB, ISL_FORMAT_R8G8B8A8_UNORM_SRGB), 184 fmt1(VK_FORMAT_A8B8G8R8_UNORM_PACK32, ISL_FORMAT_R8G8B8A8_UNORM), 185 fmt1(VK_FORMAT_A8B8G8R8_SNORM_PACK32, ISL_FORMAT_R8G8B8A8_SNORM), 186 fmt1(VK_FORMAT_A8B8G8R8_USCALED_PACK32, ISL_FORMAT_R8G8B8A8_USCALED), 187 fmt1(VK_FORMAT_A8B8G8R8_SSCALED_PACK32, ISL_FORMAT_R8G8B8A8_SSCALED), 188 fmt1(VK_FORMAT_A8B8G8R8_UINT_PACK32, ISL_FORMAT_R8G8B8A8_UINT), 189 fmt1(VK_FORMAT_A8B8G8R8_SINT_PACK32, ISL_FORMAT_R8G8B8A8_SINT), 190 fmt1(VK_FORMAT_A8B8G8R8_SRGB_PACK32, ISL_FORMAT_R8G8B8A8_UNORM_SRGB), 191 fmt1(VK_FORMAT_A2R10G10B10_UNORM_PACK32, ISL_FORMAT_B10G10R10A2_UNORM), 192 fmt1(VK_FORMAT_A2R10G10B10_SNORM_PACK32, ISL_FORMAT_B10G10R10A2_SNORM), 193 fmt1(VK_FORMAT_A2R10G10B10_USCALED_PACK32, ISL_FORMAT_B10G10R10A2_USCALED), 194 fmt1(VK_FORMAT_A2R10G10B10_SSCALED_PACK32, ISL_FORMAT_B10G10R10A2_SSCALED), 195 fmt1(VK_FORMAT_A2R10G10B10_UINT_PACK32, ISL_FORMAT_B10G10R10A2_UINT), 196 fmt1(VK_FORMAT_A2R10G10B10_SINT_PACK32, ISL_FORMAT_B10G10R10A2_SINT), 197 fmt1(VK_FORMAT_A2B10G10R10_UNORM_PACK32, ISL_FORMAT_R10G10B10A2_UNORM), 198 fmt1(VK_FORMAT_A2B10G10R10_SNORM_PACK32, ISL_FORMAT_R10G10B10A2_SNORM), 199 fmt1(VK_FORMAT_A2B10G10R10_USCALED_PACK32, ISL_FORMAT_R10G10B10A2_USCALED), 200 fmt1(VK_FORMAT_A2B10G10R10_SSCALED_PACK32, ISL_FORMAT_R10G10B10A2_SSCALED), 201 fmt1(VK_FORMAT_A2B10G10R10_UINT_PACK32, ISL_FORMAT_R10G10B10A2_UINT), 202 fmt1(VK_FORMAT_A2B10G10R10_SINT_PACK32, ISL_FORMAT_R10G10B10A2_SINT), 203 fmt1(VK_FORMAT_R16_UNORM, ISL_FORMAT_R16_UNORM), 204 fmt1(VK_FORMAT_R16_SNORM, ISL_FORMAT_R16_SNORM), 205 fmt1(VK_FORMAT_R16_USCALED, ISL_FORMAT_R16_USCALED), 206 fmt1(VK_FORMAT_R16_SSCALED, ISL_FORMAT_R16_SSCALED), 207 fmt1(VK_FORMAT_R16_UINT, ISL_FORMAT_R16_UINT), 208 fmt1(VK_FORMAT_R16_SINT, ISL_FORMAT_R16_SINT), 209 fmt1(VK_FORMAT_R16_SFLOAT, ISL_FORMAT_R16_FLOAT), 210 fmt1(VK_FORMAT_R16G16_UNORM, ISL_FORMAT_R16G16_UNORM), 211 fmt1(VK_FORMAT_R16G16_SNORM, ISL_FORMAT_R16G16_SNORM), 212 fmt1(VK_FORMAT_R16G16_USCALED, ISL_FORMAT_R16G16_USCALED), 213 fmt1(VK_FORMAT_R16G16_SSCALED, ISL_FORMAT_R16G16_SSCALED), 214 fmt1(VK_FORMAT_R16G16_UINT, ISL_FORMAT_R16G16_UINT), 215 fmt1(VK_FORMAT_R16G16_SINT, ISL_FORMAT_R16G16_SINT), 216 fmt1(VK_FORMAT_R16G16_SFLOAT, ISL_FORMAT_R16G16_FLOAT), 217 fmt1(VK_FORMAT_R16G16B16_UNORM, ISL_FORMAT_R16G16B16_UNORM), 218 fmt1(VK_FORMAT_R16G16B16_SNORM, ISL_FORMAT_R16G16B16_SNORM), 219 fmt1(VK_FORMAT_R16G16B16_USCALED, ISL_FORMAT_R16G16B16_USCALED), 220 fmt1(VK_FORMAT_R16G16B16_SSCALED, ISL_FORMAT_R16G16B16_SSCALED), 221 fmt1(VK_FORMAT_R16G16B16_UINT, ISL_FORMAT_R16G16B16_UINT), 222 fmt1(VK_FORMAT_R16G16B16_SINT, ISL_FORMAT_R16G16B16_SINT), 223 fmt1(VK_FORMAT_R16G16B16_SFLOAT, ISL_FORMAT_R16G16B16_FLOAT), 224 fmt1(VK_FORMAT_R16G16B16A16_UNORM, ISL_FORMAT_R16G16B16A16_UNORM), 225 fmt1(VK_FORMAT_R16G16B16A16_SNORM, ISL_FORMAT_R16G16B16A16_SNORM), 226 fmt1(VK_FORMAT_R16G16B16A16_USCALED, ISL_FORMAT_R16G16B16A16_USCALED), 227 fmt1(VK_FORMAT_R16G16B16A16_SSCALED, ISL_FORMAT_R16G16B16A16_SSCALED), 228 fmt1(VK_FORMAT_R16G16B16A16_UINT, ISL_FORMAT_R16G16B16A16_UINT), 229 fmt1(VK_FORMAT_R16G16B16A16_SINT, ISL_FORMAT_R16G16B16A16_SINT), 230 fmt1(VK_FORMAT_R16G16B16A16_SFLOAT, ISL_FORMAT_R16G16B16A16_FLOAT), 231 fmt1(VK_FORMAT_R32_UINT, ISL_FORMAT_R32_UINT), 232 fmt1(VK_FORMAT_R32_SINT, ISL_FORMAT_R32_SINT), 233 fmt1(VK_FORMAT_R32_SFLOAT, ISL_FORMAT_R32_FLOAT), 234 fmt1(VK_FORMAT_R32G32_UINT, ISL_FORMAT_R32G32_UINT), 235 fmt1(VK_FORMAT_R32G32_SINT, ISL_FORMAT_R32G32_SINT), 236 fmt1(VK_FORMAT_R32G32_SFLOAT, ISL_FORMAT_R32G32_FLOAT), 237 fmt1(VK_FORMAT_R32G32B32_UINT, ISL_FORMAT_R32G32B32_UINT), 238 fmt1(VK_FORMAT_R32G32B32_SINT, ISL_FORMAT_R32G32B32_SINT), 239 fmt1(VK_FORMAT_R32G32B32_SFLOAT, ISL_FORMAT_R32G32B32_FLOAT), 240 fmt1(VK_FORMAT_R32G32B32A32_UINT, ISL_FORMAT_R32G32B32A32_UINT), 241 fmt1(VK_FORMAT_R32G32B32A32_SINT, ISL_FORMAT_R32G32B32A32_SINT), 242 fmt1(VK_FORMAT_R32G32B32A32_SFLOAT, ISL_FORMAT_R32G32B32A32_FLOAT), 243 fmt1(VK_FORMAT_R64_UINT, ISL_FORMAT_R64_PASSTHRU), 244 fmt1(VK_FORMAT_R64_SINT, ISL_FORMAT_R64_PASSTHRU), 245 fmt1(VK_FORMAT_R64_SFLOAT, ISL_FORMAT_R64_PASSTHRU), 246 fmt1(VK_FORMAT_R64G64_UINT, ISL_FORMAT_R64G64_PASSTHRU), 247 fmt1(VK_FORMAT_R64G64_SINT, ISL_FORMAT_R64G64_PASSTHRU), 248 fmt1(VK_FORMAT_R64G64_SFLOAT, ISL_FORMAT_R64G64_PASSTHRU), 249 fmt1(VK_FORMAT_R64G64B64_UINT, ISL_FORMAT_R64G64B64_PASSTHRU), 250 fmt1(VK_FORMAT_R64G64B64_SINT, ISL_FORMAT_R64G64B64_PASSTHRU), 251 fmt1(VK_FORMAT_R64G64B64_SFLOAT, ISL_FORMAT_R64G64B64_PASSTHRU), 252 fmt1(VK_FORMAT_R64G64B64A64_UINT, ISL_FORMAT_R64G64B64A64_PASSTHRU), 253 fmt1(VK_FORMAT_R64G64B64A64_SINT, ISL_FORMAT_R64G64B64A64_PASSTHRU), 254 fmt1(VK_FORMAT_R64G64B64A64_SFLOAT, ISL_FORMAT_R64G64B64A64_PASSTHRU), 255 fmt1(VK_FORMAT_B10G11R11_UFLOAT_PACK32, ISL_FORMAT_R11G11B10_FLOAT), 256 fmt1(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, ISL_FORMAT_R9G9B9E5_SHAREDEXP), 257 258 d_fmt(VK_FORMAT_D16_UNORM, ISL_FORMAT_R16_UNORM), 259 d_fmt(VK_FORMAT_X8_D24_UNORM_PACK32, ISL_FORMAT_R24_UNORM_X8_TYPELESS), 260 d_fmt(VK_FORMAT_D32_SFLOAT, ISL_FORMAT_R32_FLOAT), 261 s_fmt(VK_FORMAT_S8_UINT, ISL_FORMAT_R8_UINT), 262 fmt_unsupported(VK_FORMAT_D16_UNORM_S8_UINT), 263 ds_fmt2(VK_FORMAT_D24_UNORM_S8_UINT, ISL_FORMAT_R24_UNORM_X8_TYPELESS, ISL_FORMAT_R8_UINT), 264 ds_fmt2(VK_FORMAT_D32_SFLOAT_S8_UINT, ISL_FORMAT_R32_FLOAT, ISL_FORMAT_R8_UINT), 265 266 swiz_fmt1(VK_FORMAT_BC1_RGB_UNORM_BLOCK, ISL_FORMAT_BC1_UNORM, RGB1), 267 swiz_fmt1(VK_FORMAT_BC1_RGB_SRGB_BLOCK, ISL_FORMAT_BC1_UNORM_SRGB, RGB1), 268 fmt1(VK_FORMAT_BC1_RGBA_UNORM_BLOCK, ISL_FORMAT_BC1_UNORM), 269 fmt1(VK_FORMAT_BC1_RGBA_SRGB_BLOCK, ISL_FORMAT_BC1_UNORM_SRGB), 270 fmt1(VK_FORMAT_BC2_UNORM_BLOCK, ISL_FORMAT_BC2_UNORM), 271 fmt1(VK_FORMAT_BC2_SRGB_BLOCK, ISL_FORMAT_BC2_UNORM_SRGB), 272 fmt1(VK_FORMAT_BC3_UNORM_BLOCK, ISL_FORMAT_BC3_UNORM), 273 fmt1(VK_FORMAT_BC3_SRGB_BLOCK, ISL_FORMAT_BC3_UNORM_SRGB), 274 fmt1(VK_FORMAT_BC4_UNORM_BLOCK, ISL_FORMAT_BC4_UNORM), 275 fmt1(VK_FORMAT_BC4_SNORM_BLOCK, ISL_FORMAT_BC4_SNORM), 276 fmt1(VK_FORMAT_BC5_UNORM_BLOCK, ISL_FORMAT_BC5_UNORM), 277 fmt1(VK_FORMAT_BC5_SNORM_BLOCK, ISL_FORMAT_BC5_SNORM), 278 fmt1(VK_FORMAT_BC6H_UFLOAT_BLOCK, ISL_FORMAT_BC6H_UF16), 279 fmt1(VK_FORMAT_BC6H_SFLOAT_BLOCK, ISL_FORMAT_BC6H_SF16), 280 fmt1(VK_FORMAT_BC7_UNORM_BLOCK, ISL_FORMAT_BC7_UNORM), 281 fmt1(VK_FORMAT_BC7_SRGB_BLOCK, ISL_FORMAT_BC7_UNORM_SRGB), 282 fmt1(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, ISL_FORMAT_ETC2_RGB8), 283 fmt1(VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, ISL_FORMAT_ETC2_SRGB8), 284 fmt1(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, ISL_FORMAT_ETC2_RGB8_PTA), 285 fmt1(VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, ISL_FORMAT_ETC2_SRGB8_PTA), 286 fmt1(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, ISL_FORMAT_ETC2_EAC_RGBA8), 287 fmt1(VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, ISL_FORMAT_ETC2_EAC_SRGB8_A8), 288 fmt1(VK_FORMAT_EAC_R11_UNORM_BLOCK, ISL_FORMAT_EAC_R11), 289 fmt1(VK_FORMAT_EAC_R11_SNORM_BLOCK, ISL_FORMAT_EAC_SIGNED_R11), 290 fmt1(VK_FORMAT_EAC_R11G11_UNORM_BLOCK, ISL_FORMAT_EAC_RG11), 291 fmt1(VK_FORMAT_EAC_R11G11_SNORM_BLOCK, ISL_FORMAT_EAC_SIGNED_RG11), 292 fmt1(VK_FORMAT_ASTC_4x4_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_4X4_U8SRGB), 293 fmt1(VK_FORMAT_ASTC_5x4_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_5X4_U8SRGB), 294 fmt1(VK_FORMAT_ASTC_5x5_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_5X5_U8SRGB), 295 fmt1(VK_FORMAT_ASTC_6x5_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_6X5_U8SRGB), 296 fmt1(VK_FORMAT_ASTC_6x6_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_6X6_U8SRGB), 297 fmt1(VK_FORMAT_ASTC_8x5_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_8X5_U8SRGB), 298 fmt1(VK_FORMAT_ASTC_8x6_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_8X6_U8SRGB), 299 fmt1(VK_FORMAT_ASTC_8x8_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_8X8_U8SRGB), 300 fmt1(VK_FORMAT_ASTC_10x5_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_10X5_U8SRGB), 301 fmt1(VK_FORMAT_ASTC_10x6_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_10X6_U8SRGB), 302 fmt1(VK_FORMAT_ASTC_10x8_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_10X8_U8SRGB), 303 fmt1(VK_FORMAT_ASTC_10x10_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_10X10_U8SRGB), 304 fmt1(VK_FORMAT_ASTC_12x10_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_12X10_U8SRGB), 305 fmt1(VK_FORMAT_ASTC_12x12_SRGB_BLOCK, ISL_FORMAT_ASTC_LDR_2D_12X12_U8SRGB), 306 fmt1(VK_FORMAT_ASTC_4x4_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_4X4_FLT16), 307 fmt1(VK_FORMAT_ASTC_5x4_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_5X4_FLT16), 308 fmt1(VK_FORMAT_ASTC_5x5_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_5X5_FLT16), 309 fmt1(VK_FORMAT_ASTC_6x5_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_6X5_FLT16), 310 fmt1(VK_FORMAT_ASTC_6x6_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_6X6_FLT16), 311 fmt1(VK_FORMAT_ASTC_8x5_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_8X5_FLT16), 312 fmt1(VK_FORMAT_ASTC_8x6_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_8X6_FLT16), 313 fmt1(VK_FORMAT_ASTC_8x8_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_8X8_FLT16), 314 fmt1(VK_FORMAT_ASTC_10x5_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_10X5_FLT16), 315 fmt1(VK_FORMAT_ASTC_10x6_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_10X6_FLT16), 316 fmt1(VK_FORMAT_ASTC_10x8_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_10X8_FLT16), 317 fmt1(VK_FORMAT_ASTC_10x10_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_10X10_FLT16), 318 fmt1(VK_FORMAT_ASTC_12x10_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_12X10_FLT16), 319 fmt1(VK_FORMAT_ASTC_12x12_UNORM_BLOCK, ISL_FORMAT_ASTC_LDR_2D_12X12_FLT16), 320 fmt_unsupported(VK_FORMAT_B8G8R8_UNORM), 321 fmt_unsupported(VK_FORMAT_B8G8R8_SNORM), 322 fmt_unsupported(VK_FORMAT_B8G8R8_USCALED), 323 fmt_unsupported(VK_FORMAT_B8G8R8_SSCALED), 324 fmt_unsupported(VK_FORMAT_B8G8R8_UINT), 325 fmt_unsupported(VK_FORMAT_B8G8R8_SINT), 326 fmt_unsupported(VK_FORMAT_B8G8R8_SRGB), 327 fmt1(VK_FORMAT_B8G8R8A8_UNORM, ISL_FORMAT_B8G8R8A8_UNORM), 328 fmt_unsupported(VK_FORMAT_B8G8R8A8_SNORM), 329 fmt_unsupported(VK_FORMAT_B8G8R8A8_USCALED), 330 fmt_unsupported(VK_FORMAT_B8G8R8A8_SSCALED), 331 fmt_unsupported(VK_FORMAT_B8G8R8A8_UINT), 332 fmt_unsupported(VK_FORMAT_B8G8R8A8_SINT), 333 fmt1(VK_FORMAT_B8G8R8A8_SRGB, ISL_FORMAT_B8G8R8A8_UNORM_SRGB), 334}; 335 336static const struct anv_format ycbcr_formats[] = { 337 ycbcr_fmt(VK_FORMAT_G8B8G8R8_422_UNORM, 1, 338 y_plane(0, ISL_FORMAT_YCRCB_SWAPUV, RGBA, _ISL_SWIZZLE(BLUE, GREEN, RED, ZERO), 1, 1)), 339 ycbcr_fmt(VK_FORMAT_B8G8R8G8_422_UNORM, 1, 340 y_plane(0, ISL_FORMAT_YCRCB_SWAPUVY, RGBA, _ISL_SWIZZLE(BLUE, GREEN, RED, ZERO), 1, 1)), 341 ycbcr_fmt(VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, 3, 342 y_plane(0, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 343 chroma_plane(1, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(BLUE, ZERO, ZERO, ZERO), 2, 2), 344 chroma_plane(2, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(RED, ZERO, ZERO, ZERO), 2, 2)), 345 ycbcr_fmt(VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, 2, 346 y_plane(0, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 347 chroma_plane(1, ISL_FORMAT_R8G8_UNORM, RGBA, _ISL_SWIZZLE(BLUE, RED, ZERO, ZERO), 2, 2)), 348 ycbcr_fmt(VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, 3, 349 y_plane(0, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 350 chroma_plane(1, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(BLUE, ZERO, ZERO, ZERO), 2, 1), 351 chroma_plane(2, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(RED, ZERO, ZERO, ZERO), 2, 1)), 352 ycbcr_fmt(VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, 2, 353 y_plane(0, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 354 chroma_plane(1, ISL_FORMAT_R8G8_UNORM, RGBA, _ISL_SWIZZLE(BLUE, RED, ZERO, ZERO), 2, 1)), 355 ycbcr_fmt(VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, 3, 356 y_plane(0, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 357 chroma_plane(1, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(BLUE, ZERO, ZERO, ZERO), 1, 1), 358 chroma_plane(2, ISL_FORMAT_R8_UNORM, RGBA, _ISL_SWIZZLE(RED, ZERO, ZERO, ZERO), 1, 1)), 359 360 fmt_unsupported(VK_FORMAT_R10X6_UNORM_PACK16), 361 fmt_unsupported(VK_FORMAT_R10X6G10X6_UNORM_2PACK16), 362 fmt_unsupported(VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16), 363 fmt_unsupported(VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16), 364 fmt_unsupported(VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16), 365 fmt_unsupported(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16), 366 fmt_unsupported(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16), 367 fmt_unsupported(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16), 368 fmt_unsupported(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16), 369 fmt_unsupported(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16), 370 fmt_unsupported(VK_FORMAT_R12X4_UNORM_PACK16), 371 fmt_unsupported(VK_FORMAT_R12X4G12X4_UNORM_2PACK16), 372 fmt_unsupported(VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16), 373 fmt_unsupported(VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16), 374 fmt_unsupported(VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16), 375 fmt_unsupported(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16), 376 fmt_unsupported(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16), 377 fmt_unsupported(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16), 378 fmt_unsupported(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16), 379 fmt_unsupported(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16), 380 /* TODO: it is possible to enable the following 2 formats, but that 381 * requires further refactoring of how we handle multiplanar formats. 382 */ 383 fmt_unsupported(VK_FORMAT_G16B16G16R16_422_UNORM), 384 fmt_unsupported(VK_FORMAT_B16G16R16G16_422_UNORM), 385 386 ycbcr_fmt(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, 3, 387 y_plane(0, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 388 chroma_plane(1, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(BLUE, ZERO, ZERO, ZERO), 2, 2), 389 chroma_plane(2, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(RED, ZERO, ZERO, ZERO), 2, 2)), 390 ycbcr_fmt(VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, 2, 391 y_plane(0, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 392 chroma_plane(1, ISL_FORMAT_R16G16_UNORM, RGBA, _ISL_SWIZZLE(BLUE, RED, ZERO, ZERO), 2, 2)), 393 ycbcr_fmt(VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, 3, 394 y_plane(0, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 395 chroma_plane(1, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(BLUE, ZERO, ZERO, ZERO), 2, 1), 396 chroma_plane(2, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(RED, ZERO, ZERO, ZERO), 2, 1)), 397 ycbcr_fmt(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, 2, 398 y_plane(0, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 399 chroma_plane(1, ISL_FORMAT_R16G16_UNORM, RGBA, _ISL_SWIZZLE(BLUE, RED, ZERO, ZERO), 2, 1)), 400 ycbcr_fmt(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, 3, 401 y_plane(0, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(GREEN, ZERO, ZERO, ZERO), 1, 1), 402 chroma_plane(1, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(BLUE, ZERO, ZERO, ZERO), 1, 1), 403 chroma_plane(2, ISL_FORMAT_R16_UNORM, RGBA, _ISL_SWIZZLE(RED, ZERO, ZERO, ZERO), 1, 1)), 404}; 405 406#undef _fmt 407#undef swiz_fmt1 408#undef fmt1 409#undef fmt 410 411static const struct { 412 const struct anv_format *formats; 413 uint32_t n_formats; 414} anv_formats[] = { 415 [0] = { .formats = main_formats, 416 .n_formats = ARRAY_SIZE(main_formats), }, 417 [_VK_KHR_sampler_ycbcr_conversion_number] = { .formats = ycbcr_formats, 418 .n_formats = ARRAY_SIZE(ycbcr_formats), }, 419}; 420 421const struct anv_format * 422anv_get_format(VkFormat vk_format) 423{ 424 uint32_t enum_offset = VK_ENUM_OFFSET(vk_format); 425 uint32_t ext_number = VK_ENUM_EXTENSION(vk_format); 426 427 if (ext_number >= ARRAY_SIZE(anv_formats) || 428 enum_offset >= anv_formats[ext_number].n_formats) 429 return NULL; 430 431 const struct anv_format *format = 432 &anv_formats[ext_number].formats[enum_offset]; 433 if (format->planes[0].isl_format == ISL_FORMAT_UNSUPPORTED) 434 return NULL; 435 436 return format; 437} 438 439/** 440 * Exactly one bit must be set in \a aspect. 441 */ 442struct anv_format_plane 443anv_get_format_plane(const struct gen_device_info *devinfo, VkFormat vk_format, 444 VkImageAspectFlagBits aspect, VkImageTiling tiling) 445{ 446 const struct anv_format *format = anv_get_format(vk_format); 447 const struct anv_format_plane unsupported = { 448 .isl_format = ISL_FORMAT_UNSUPPORTED, 449 }; 450 451 if (format == NULL) 452 return unsupported; 453 454 uint32_t plane = anv_image_aspect_to_plane(vk_format_aspects(vk_format), aspect); 455 struct anv_format_plane plane_format = format->planes[plane]; 456 if (plane_format.isl_format == ISL_FORMAT_UNSUPPORTED) 457 return unsupported; 458 459 if (aspect & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { 460 assert(vk_format_aspects(vk_format) & 461 (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)); 462 return plane_format; 463 } 464 465 assert((aspect & ~VK_IMAGE_ASPECT_ANY_COLOR_BIT_ANV) == 0); 466 467 const struct isl_format_layout *isl_layout = 468 isl_format_get_layout(plane_format.isl_format); 469 470 /* On Ivy Bridge we don't even have enough 24 and 48-bit formats that we 471 * can reliably do texture upload with BLORP so just don't claim support 472 * for any of them. 473 */ 474 if (devinfo->gen == 7 && !devinfo->is_haswell && 475 (isl_layout->bpb == 24 || isl_layout->bpb == 48)) 476 return unsupported; 477 478 if (tiling == VK_IMAGE_TILING_OPTIMAL && 479 !util_is_power_of_two_or_zero(isl_layout->bpb)) { 480 /* Tiled formats *must* be power-of-two because we need up upload 481 * them with the render pipeline. For 3-channel formats, we fix 482 * this by switching them over to RGBX or RGBA formats under the 483 * hood. 484 */ 485 enum isl_format rgbx = isl_format_rgb_to_rgbx(plane_format.isl_format); 486 if (rgbx != ISL_FORMAT_UNSUPPORTED && 487 isl_format_supports_rendering(devinfo, rgbx)) { 488 plane_format.isl_format = rgbx; 489 } else { 490 plane_format.isl_format = 491 isl_format_rgb_to_rgba(plane_format.isl_format); 492 plane_format.swizzle = ISL_SWIZZLE(RED, GREEN, BLUE, ONE); 493 } 494 } 495 496 /* The B4G4R4A4 format isn't available prior to Broadwell so we have to fall 497 * back to a format with a more complex swizzle. 498 */ 499 if (vk_format == VK_FORMAT_B4G4R4A4_UNORM_PACK16 && devinfo->gen < 8) { 500 plane_format.isl_format = ISL_FORMAT_B4G4R4A4_UNORM; 501 plane_format.swizzle = ISL_SWIZZLE(GREEN, RED, ALPHA, BLUE); 502 } 503 504 return plane_format; 505} 506 507// Format capabilities 508 509VkFormatFeatureFlags 510anv_get_image_format_features(const struct gen_device_info *devinfo, 511 VkFormat vk_format, 512 const struct anv_format *anv_format, 513 VkImageTiling vk_tiling) 514{ 515 VkFormatFeatureFlags flags = 0; 516 517 if (anv_format == NULL) 518 return 0; 519 520 const VkImageAspectFlags aspects = vk_format_aspects(vk_format); 521 522 if (aspects & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) { 523 if (vk_tiling == VK_IMAGE_TILING_LINEAR) 524 return 0; 525 526 flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; 527 528 if (aspects == VK_IMAGE_ASPECT_DEPTH_BIT || devinfo->gen >= 8) 529 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; 530 531 if ((aspects & VK_IMAGE_ASPECT_DEPTH_BIT) && devinfo->gen >= 9) 532 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT; 533 534 flags |= VK_FORMAT_FEATURE_BLIT_SRC_BIT | 535 VK_FORMAT_FEATURE_BLIT_DST_BIT | 536 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | 537 VK_FORMAT_FEATURE_TRANSFER_DST_BIT; 538 539 return flags; 540 } 541 542 const struct anv_format_plane plane_format = 543 anv_get_format_plane(devinfo, vk_format, VK_IMAGE_ASPECT_COLOR_BIT, 544 vk_tiling); 545 546 if (plane_format.isl_format == ISL_FORMAT_UNSUPPORTED) 547 return 0; 548 549 struct anv_format_plane base_plane_format = plane_format; 550 if (vk_tiling == VK_IMAGE_TILING_OPTIMAL) { 551 base_plane_format = anv_get_format_plane(devinfo, vk_format, 552 VK_IMAGE_ASPECT_COLOR_BIT, 553 VK_IMAGE_TILING_LINEAR); 554 } 555 556 enum isl_format base_isl_format = base_plane_format.isl_format; 557 558 /* ASTC textures must be in Y-tiled memory */ 559 if (vk_tiling == VK_IMAGE_TILING_LINEAR && 560 isl_format_get_layout(plane_format.isl_format)->txc == ISL_TXC_ASTC) 561 return 0; 562 563 /* ASTC requires nasty workarounds on BSW so we just disable it for now. 564 * 565 * TODO: Figure out the ASTC workarounds and re-enable on BSW. 566 */ 567 if (devinfo->gen < 9 && 568 isl_format_get_layout(plane_format.isl_format)->txc == ISL_TXC_ASTC) 569 return 0; 570 571 if (isl_format_supports_sampling(devinfo, plane_format.isl_format)) { 572 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; 573 574 if (devinfo->gen >= 9) 575 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT; 576 577 if (isl_format_supports_filtering(devinfo, plane_format.isl_format)) 578 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT; 579 } 580 581 /* We can render to swizzled formats. However, if the alpha channel is 582 * moved, then blending won't work correctly. The PRM tells us 583 * straight-up not to render to such a surface. 584 */ 585 if (isl_format_supports_rendering(devinfo, plane_format.isl_format) && 586 plane_format.swizzle.a == ISL_CHANNEL_SELECT_ALPHA) { 587 flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; 588 589 if (isl_format_supports_alpha_blending(devinfo, plane_format.isl_format)) 590 flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT; 591 } 592 593 /* Load/store is determined based on base format. This prevents RGB 594 * formats from showing up as load/store capable. 595 */ 596 if (isl_is_storage_image_format(base_isl_format)) 597 flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; 598 599 if (base_isl_format == ISL_FORMAT_R32_SINT || 600 base_isl_format == ISL_FORMAT_R32_UINT) 601 flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT; 602 603 if (flags) { 604 flags |= VK_FORMAT_FEATURE_BLIT_SRC_BIT | 605 VK_FORMAT_FEATURE_BLIT_DST_BIT | 606 VK_FORMAT_FEATURE_TRANSFER_SRC_BIT | 607 VK_FORMAT_FEATURE_TRANSFER_DST_BIT; 608 } 609 610 /* XXX: We handle 3-channel formats by switching them out for RGBX or 611 * RGBA formats behind-the-scenes. This works fine for textures 612 * because the upload process will fill in the extra channel. 613 * We could also support it for render targets, but it will take 614 * substantially more work and we have enough RGBX formats to handle 615 * what most clients will want. 616 */ 617 if (vk_tiling == VK_IMAGE_TILING_OPTIMAL && 618 base_isl_format != ISL_FORMAT_UNSUPPORTED && 619 !util_is_power_of_two_or_zero(isl_format_layouts[base_isl_format].bpb) && 620 isl_format_rgb_to_rgbx(base_isl_format) == ISL_FORMAT_UNSUPPORTED) { 621 flags &= ~VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; 622 flags &= ~VK_FORMAT_FEATURE_BLIT_DST_BIT; 623 } 624 625 if (anv_format->can_ycbcr) { 626 /* The sampler doesn't have support for mid point when it handles YUV on 627 * its own. 628 */ 629 if (isl_format_is_yuv(anv_format->planes[0].isl_format)) { 630 /* TODO: We've disabled linear implicit reconstruction with the 631 * sampler. The failures show a slightly out of range values on the 632 * bottom left of the sampled image. 633 */ 634 flags |= VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT; 635 } else { 636 flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT | 637 VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT | 638 VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT; 639 } 640 641 /* We can support cosited chroma locations when handle planes with our 642 * own shader snippets. 643 */ 644 for (unsigned p = 0; p < anv_format->n_planes; p++) { 645 if (anv_format->planes[p].denominator_scales[0] > 1 || 646 anv_format->planes[p].denominator_scales[1] > 1) { 647 flags |= VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT; 648 break; 649 } 650 } 651 652 if (anv_format->n_planes > 1) 653 flags |= VK_FORMAT_FEATURE_DISJOINT_BIT; 654 655 const VkFormatFeatureFlags disallowed_ycbcr_image_features = 656 VK_FORMAT_FEATURE_BLIT_SRC_BIT | 657 VK_FORMAT_FEATURE_BLIT_DST_BIT | 658 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | 659 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT | 660 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; 661 662 flags &= ~disallowed_ycbcr_image_features; 663 } 664 665 return flags; 666} 667 668static VkFormatFeatureFlags 669get_buffer_format_features(const struct gen_device_info *devinfo, 670 VkFormat vk_format, 671 const struct anv_format *anv_format) 672{ 673 VkFormatFeatureFlags flags = 0; 674 675 if (anv_format == NULL) 676 return 0; 677 678 const enum isl_format isl_format = anv_format->planes[0].isl_format; 679 680 if (isl_format == ISL_FORMAT_UNSUPPORTED) 681 return 0; 682 683 if (anv_format->n_planes > 1) 684 return 0; 685 686 if (anv_format->can_ycbcr) 687 return 0; 688 689 if (vk_format_is_depth_or_stencil(vk_format)) 690 return 0; 691 692 if (isl_format_supports_sampling(devinfo, isl_format) && 693 !isl_format_is_compressed(isl_format)) 694 flags |= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT; 695 696 if (isl_format_supports_vertex_fetch(devinfo, isl_format)) 697 flags |= VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT; 698 699 if (isl_is_storage_image_format(isl_format)) 700 flags |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT; 701 702 if (isl_format == ISL_FORMAT_R32_SINT || isl_format == ISL_FORMAT_R32_UINT) 703 flags |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT; 704 705 return flags; 706} 707 708static void 709get_wsi_format_modifier_properties_list(const struct anv_physical_device *physical_device, 710 VkFormat vk_format, 711 struct wsi_format_modifier_properties_list *list) 712{ 713 const struct anv_format *anv_format = anv_get_format(vk_format); 714 715 VK_OUTARRAY_MAKE(out, list->modifier_properties, &list->modifier_count); 716 717 /* This is a simplified list where all the modifiers are available */ 718 assert(vk_format == VK_FORMAT_B8G8R8_SRGB || 719 vk_format == VK_FORMAT_B8G8R8_UNORM || 720 vk_format == VK_FORMAT_B8G8R8A8_SRGB || 721 vk_format == VK_FORMAT_B8G8R8A8_UNORM); 722 723 uint64_t modifiers[] = { 724 DRM_FORMAT_MOD_LINEAR, 725 I915_FORMAT_MOD_X_TILED, 726 I915_FORMAT_MOD_Y_TILED, 727 I915_FORMAT_MOD_Y_TILED_CCS, 728 }; 729 730 for (uint32_t i = 0; i < ARRAY_SIZE(modifiers); i++) { 731 const struct isl_drm_modifier_info *mod_info = 732 isl_drm_modifier_get_info(modifiers[i]); 733 734 if (mod_info->aux_usage == ISL_AUX_USAGE_CCS_E && 735 !isl_format_supports_ccs_e(&physical_device->info, 736 anv_format->planes[0].isl_format)) 737 continue; 738 739 vk_outarray_append(&out, mod_props) { 740 mod_props->modifier = modifiers[i]; 741 if (isl_drm_modifier_has_aux(modifiers[i])) 742 mod_props->modifier_plane_count = 2; 743 else 744 mod_props->modifier_plane_count = anv_format->n_planes; 745 } 746 } 747} 748 749void anv_GetPhysicalDeviceFormatProperties( 750 VkPhysicalDevice physicalDevice, 751 VkFormat vk_format, 752 VkFormatProperties* pFormatProperties) 753{ 754 ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); 755 const struct gen_device_info *devinfo = &physical_device->info; 756 const struct anv_format *anv_format = anv_get_format(vk_format); 757 758 *pFormatProperties = (VkFormatProperties) { 759 .linearTilingFeatures = 760 anv_get_image_format_features(devinfo, vk_format, anv_format, 761 VK_IMAGE_TILING_LINEAR), 762 .optimalTilingFeatures = 763 anv_get_image_format_features(devinfo, vk_format, anv_format, 764 VK_IMAGE_TILING_OPTIMAL), 765 .bufferFeatures = 766 get_buffer_format_features(devinfo, vk_format, anv_format), 767 }; 768} 769 770void anv_GetPhysicalDeviceFormatProperties2( 771 VkPhysicalDevice physicalDevice, 772 VkFormat format, 773 VkFormatProperties2* pFormatProperties) 774{ 775 ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); 776 anv_GetPhysicalDeviceFormatProperties(physicalDevice, format, 777 &pFormatProperties->formatProperties); 778 779 vk_foreach_struct(ext, pFormatProperties->pNext) { 780 /* Use unsigned since some cases are not in the VkStructureType enum. */ 781 switch ((unsigned)ext->sType) { 782 case VK_STRUCTURE_TYPE_WSI_FORMAT_MODIFIER_PROPERTIES_LIST_MESA: 783 get_wsi_format_modifier_properties_list(physical_device, format, 784 (void *)ext); 785 break; 786 default: 787 anv_debug_ignored_stype(ext->sType); 788 break; 789 } 790 } 791} 792 793static VkResult 794anv_get_image_format_properties( 795 struct anv_physical_device *physical_device, 796 const VkPhysicalDeviceImageFormatInfo2 *info, 797 VkImageFormatProperties *pImageFormatProperties, 798 VkSamplerYcbcrConversionImageFormatProperties *pYcbcrImageFormatProperties) 799{ 800 VkFormatFeatureFlags format_feature_flags; 801 VkExtent3D maxExtent; 802 uint32_t maxMipLevels; 803 uint32_t maxArraySize; 804 VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT; 805 const struct gen_device_info *devinfo = &physical_device->info; 806 const struct anv_format *format = anv_get_format(info->format); 807 808 if (format == NULL) 809 goto unsupported; 810 811 assert(format->vk_format == info->format); 812 format_feature_flags = anv_get_image_format_features(devinfo, info->format, 813 format, info->tiling); 814 815 switch (info->type) { 816 default: 817 unreachable("bad VkImageType"); 818 case VK_IMAGE_TYPE_1D: 819 maxExtent.width = 16384; 820 maxExtent.height = 1; 821 maxExtent.depth = 1; 822 maxMipLevels = 15; /* log2(maxWidth) + 1 */ 823 maxArraySize = 2048; 824 sampleCounts = VK_SAMPLE_COUNT_1_BIT; 825 break; 826 case VK_IMAGE_TYPE_2D: 827 /* FINISHME: Does this really differ for cube maps? The documentation 828 * for RENDER_SURFACE_STATE suggests so. 829 */ 830 maxExtent.width = 16384; 831 maxExtent.height = 16384; 832 maxExtent.depth = 1; 833 maxMipLevels = 15; /* log2(maxWidth) + 1 */ 834 maxArraySize = 2048; 835 break; 836 case VK_IMAGE_TYPE_3D: 837 maxExtent.width = 2048; 838 maxExtent.height = 2048; 839 maxExtent.depth = 2048; 840 maxMipLevels = 12; /* log2(maxWidth) + 1 */ 841 maxArraySize = 1; 842 break; 843 } 844 845 /* Our hardware doesn't support 1D compressed textures. 846 * From the SKL PRM, RENDER_SURFACE_STATE::SurfaceFormat: 847 * * This field cannot be a compressed (BC*, DXT*, FXT*, ETC*, EAC*) format 848 * if the Surface Type is SURFTYPE_1D. 849 * * This field cannot be ASTC format if the Surface Type is SURFTYPE_1D. 850 */ 851 if (info->type == VK_IMAGE_TYPE_1D && 852 isl_format_is_compressed(format->planes[0].isl_format)) { 853 goto unsupported; 854 } 855 856 if (info->tiling == VK_IMAGE_TILING_OPTIMAL && 857 info->type == VK_IMAGE_TYPE_2D && 858 (format_feature_flags & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | 859 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) && 860 !(info->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) && 861 !(info->usage & VK_IMAGE_USAGE_STORAGE_BIT)) { 862 sampleCounts = isl_device_get_sample_counts(&physical_device->isl_dev); 863 } 864 865 if (info->usage & (VK_IMAGE_USAGE_TRANSFER_SRC_BIT | 866 VK_IMAGE_USAGE_TRANSFER_DST_BIT)) { 867 /* Accept transfers on anything we can sample from or renderer to. */ 868 if (!(format_feature_flags & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | 869 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT | 870 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT))) { 871 goto unsupported; 872 } 873 } 874 875 if (info->usage & VK_IMAGE_USAGE_SAMPLED_BIT) { 876 if (!(format_feature_flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) { 877 goto unsupported; 878 } 879 } 880 881 if (info->usage & VK_IMAGE_USAGE_STORAGE_BIT) { 882 if (!(format_feature_flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) { 883 goto unsupported; 884 } 885 } 886 887 if (info->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) { 888 if (!(format_feature_flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) { 889 goto unsupported; 890 } 891 } 892 893 if (info->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) { 894 if (!(format_feature_flags & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) { 895 goto unsupported; 896 } 897 } 898 899 if (info->usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT) { 900 /* Nothing to check. */ 901 } 902 903 if (info->usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) { 904 /* Ignore this flag because it was removed from the 905 * provisional_I_20150910 header. 906 */ 907 } 908 909 /* From the bspec section entitled "Surface Layout and Tiling", 910 * pre-gen9 has a 2 GB limitation of the size in bytes, 911 * gen9 and gen10 have a 256 GB limitation and gen11+ 912 * has a 16 TB limitation. 913 */ 914 uint64_t maxResourceSize = 0; 915 if (devinfo->gen < 9) 916 maxResourceSize = (uint64_t) 1 << 31; 917 else if (devinfo->gen < 11) 918 maxResourceSize = (uint64_t) 1 << 38; 919 else 920 maxResourceSize = (uint64_t) 1 << 44; 921 922 *pImageFormatProperties = (VkImageFormatProperties) { 923 .maxExtent = maxExtent, 924 .maxMipLevels = maxMipLevels, 925 .maxArrayLayers = maxArraySize, 926 .sampleCounts = sampleCounts, 927 928 /* FINISHME: Accurately calculate 929 * VkImageFormatProperties::maxResourceSize. 930 */ 931 .maxResourceSize = maxResourceSize, 932 }; 933 934 if (pYcbcrImageFormatProperties) { 935 pYcbcrImageFormatProperties->combinedImageSamplerDescriptorCount = 936 format->n_planes; 937 } 938 939 return VK_SUCCESS; 940 941unsupported: 942 *pImageFormatProperties = (VkImageFormatProperties) { 943 .maxExtent = { 0, 0, 0 }, 944 .maxMipLevels = 0, 945 .maxArrayLayers = 0, 946 .sampleCounts = 0, 947 .maxResourceSize = 0, 948 }; 949 950 return VK_ERROR_FORMAT_NOT_SUPPORTED; 951} 952 953VkResult anv_GetPhysicalDeviceImageFormatProperties( 954 VkPhysicalDevice physicalDevice, 955 VkFormat format, 956 VkImageType type, 957 VkImageTiling tiling, 958 VkImageUsageFlags usage, 959 VkImageCreateFlags createFlags, 960 VkImageFormatProperties* pImageFormatProperties) 961{ 962 ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); 963 964 const VkPhysicalDeviceImageFormatInfo2 info = { 965 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, 966 .pNext = NULL, 967 .format = format, 968 .type = type, 969 .tiling = tiling, 970 .usage = usage, 971 .flags = createFlags, 972 }; 973 974 return anv_get_image_format_properties(physical_device, &info, 975 pImageFormatProperties, NULL); 976} 977 978static const VkExternalMemoryProperties prime_fd_props = { 979 /* If we can handle external, then we can both import and export it. */ 980 .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT | 981 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, 982 /* For the moment, let's not support mixing and matching */ 983 .exportFromImportedHandleTypes = 984 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT | 985 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, 986 .compatibleHandleTypes = 987 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT | 988 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT, 989}; 990 991static const VkExternalMemoryProperties userptr_props = { 992 .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, 993 .exportFromImportedHandleTypes = 0, 994 .compatibleHandleTypes = 995 VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, 996}; 997 998static const VkExternalMemoryProperties android_buffer_props = { 999 .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT | 1000 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, 1001 .exportFromImportedHandleTypes = 1002 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, 1003 .compatibleHandleTypes = 1004 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, 1005}; 1006 1007 1008static const VkExternalMemoryProperties android_image_props = { 1009 .externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT | 1010 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | 1011 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, 1012 .exportFromImportedHandleTypes = 1013 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, 1014 .compatibleHandleTypes = 1015 VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, 1016}; 1017 1018VkResult anv_GetPhysicalDeviceImageFormatProperties2( 1019 VkPhysicalDevice physicalDevice, 1020 const VkPhysicalDeviceImageFormatInfo2* base_info, 1021 VkImageFormatProperties2* base_props) 1022{ 1023 ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); 1024 const VkPhysicalDeviceExternalImageFormatInfo *external_info = NULL; 1025 VkExternalImageFormatProperties *external_props = NULL; 1026 VkSamplerYcbcrConversionImageFormatProperties *ycbcr_props = NULL; 1027 struct VkAndroidHardwareBufferUsageANDROID *android_usage = NULL; 1028 VkResult result; 1029 1030 /* Extract input structs */ 1031 vk_foreach_struct_const(s, base_info->pNext) { 1032 switch (s->sType) { 1033 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: 1034 external_info = (const void *) s; 1035 break; 1036 default: 1037 anv_debug_ignored_stype(s->sType); 1038 break; 1039 } 1040 } 1041 1042 /* Extract output structs */ 1043 vk_foreach_struct(s, base_props->pNext) { 1044 switch (s->sType) { 1045 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: 1046 external_props = (void *) s; 1047 break; 1048 case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: 1049 ycbcr_props = (void *) s; 1050 break; 1051 case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: 1052 android_usage = (void *) s; 1053 break; 1054 default: 1055 anv_debug_ignored_stype(s->sType); 1056 break; 1057 } 1058 } 1059 1060 result = anv_get_image_format_properties(physical_device, base_info, 1061 &base_props->imageFormatProperties, ycbcr_props); 1062 if (result != VK_SUCCESS) 1063 goto fail; 1064 1065 bool ahw_supported = 1066 physical_device->supported_extensions.ANDROID_external_memory_android_hardware_buffer; 1067 1068 if (ahw_supported && android_usage) { 1069 android_usage->androidHardwareBufferUsage = 1070 anv_ahw_usage_from_vk_usage(base_info->flags, 1071 base_info->usage); 1072 1073 /* Limit maxArrayLayers to 1 for AHardwareBuffer based images for now. */ 1074 base_props->imageFormatProperties.maxArrayLayers = 1; 1075 } 1076 1077 /* From the Vulkan 1.0.42 spec: 1078 * 1079 * If handleType is 0, vkGetPhysicalDeviceImageFormatProperties2 will 1080 * behave as if VkPhysicalDeviceExternalImageFormatInfo was not 1081 * present and VkExternalImageFormatProperties will be ignored. 1082 */ 1083 if (external_info && external_info->handleType != 0) { 1084 switch (external_info->handleType) { 1085 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: 1086 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: 1087 if (external_props) 1088 external_props->externalMemoryProperties = prime_fd_props; 1089 break; 1090 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: 1091 if (external_props) 1092 external_props->externalMemoryProperties = userptr_props; 1093 break; 1094 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID: 1095 if (ahw_supported && external_props) { 1096 external_props->externalMemoryProperties = android_image_props; 1097 break; 1098 } 1099 /* fallthrough if ahw not supported */ 1100 default: 1101 /* From the Vulkan 1.0.42 spec: 1102 * 1103 * If handleType is not compatible with the [parameters] specified 1104 * in VkPhysicalDeviceImageFormatInfo2, then 1105 * vkGetPhysicalDeviceImageFormatProperties2 returns 1106 * VK_ERROR_FORMAT_NOT_SUPPORTED. 1107 */ 1108 result = vk_errorf(physical_device->instance, physical_device, 1109 VK_ERROR_FORMAT_NOT_SUPPORTED, 1110 "unsupported VkExternalMemoryTypeFlagBits 0x%x", 1111 external_info->handleType); 1112 goto fail; 1113 } 1114 } 1115 1116 return VK_SUCCESS; 1117 1118 fail: 1119 if (result == VK_ERROR_FORMAT_NOT_SUPPORTED) { 1120 /* From the Vulkan 1.0.42 spec: 1121 * 1122 * If the combination of parameters to 1123 * vkGetPhysicalDeviceImageFormatProperties2 is not supported by 1124 * the implementation for use in vkCreateImage, then all members of 1125 * imageFormatProperties will be filled with zero. 1126 */ 1127 base_props->imageFormatProperties = (VkImageFormatProperties) {}; 1128 } 1129 1130 return result; 1131} 1132 1133void anv_GetPhysicalDeviceSparseImageFormatProperties( 1134 VkPhysicalDevice physicalDevice, 1135 VkFormat format, 1136 VkImageType type, 1137 uint32_t samples, 1138 VkImageUsageFlags usage, 1139 VkImageTiling tiling, 1140 uint32_t* pNumProperties, 1141 VkSparseImageFormatProperties* pProperties) 1142{ 1143 /* Sparse images are not yet supported. */ 1144 *pNumProperties = 0; 1145} 1146 1147void anv_GetPhysicalDeviceSparseImageFormatProperties2( 1148 VkPhysicalDevice physicalDevice, 1149 const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, 1150 uint32_t* pPropertyCount, 1151 VkSparseImageFormatProperties2* pProperties) 1152{ 1153 /* Sparse images are not yet supported. */ 1154 *pPropertyCount = 0; 1155} 1156 1157void anv_GetPhysicalDeviceExternalBufferProperties( 1158 VkPhysicalDevice physicalDevice, 1159 const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, 1160 VkExternalBufferProperties* pExternalBufferProperties) 1161{ 1162 /* The Vulkan 1.0.42 spec says "handleType must be a valid 1163 * VkExternalMemoryHandleTypeFlagBits value" in 1164 * VkPhysicalDeviceExternalBufferInfo. This differs from 1165 * VkPhysicalDeviceExternalImageFormatInfo, which surprisingly permits 1166 * handleType == 0. 1167 */ 1168 assert(pExternalBufferInfo->handleType != 0); 1169 1170 /* All of the current flags are for sparse which we don't support yet. 1171 * Even when we do support it, doing sparse on external memory sounds 1172 * sketchy. Also, just disallowing flags is the safe option. 1173 */ 1174 if (pExternalBufferInfo->flags) 1175 goto unsupported; 1176 1177 ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice); 1178 1179 switch (pExternalBufferInfo->handleType) { 1180 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: 1181 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: 1182 pExternalBufferProperties->externalMemoryProperties = prime_fd_props; 1183 return; 1184 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: 1185 pExternalBufferProperties->externalMemoryProperties = userptr_props; 1186 return; 1187 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID: 1188 if (physical_device->supported_extensions.ANDROID_external_memory_android_hardware_buffer) { 1189 pExternalBufferProperties->externalMemoryProperties = android_buffer_props; 1190 return; 1191 } 1192 /* fallthrough if ahw not supported */ 1193 default: 1194 goto unsupported; 1195 } 1196 1197 unsupported: 1198 /* From the Vulkan 1.1.113 spec: 1199 * 1200 * compatibleHandleTypes must include at least handleType. 1201 */ 1202 pExternalBufferProperties->externalMemoryProperties = 1203 (VkExternalMemoryProperties) { 1204 .compatibleHandleTypes = pExternalBufferInfo->handleType, 1205 }; 1206} 1207 1208VkResult anv_CreateSamplerYcbcrConversion( 1209 VkDevice _device, 1210 const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, 1211 const VkAllocationCallbacks* pAllocator, 1212 VkSamplerYcbcrConversion* pYcbcrConversion) 1213{ 1214 ANV_FROM_HANDLE(anv_device, device, _device); 1215 struct anv_ycbcr_conversion *conversion; 1216 1217 /* Search for VkExternalFormatANDROID and resolve the format. */ 1218 struct anv_format *ext_format = NULL; 1219 const struct VkExternalFormatANDROID *ext_info = 1220 vk_find_struct_const(pCreateInfo->pNext, EXTERNAL_FORMAT_ANDROID); 1221 1222 uint64_t format = ext_info ? ext_info->externalFormat : 0; 1223 if (format) { 1224 assert(pCreateInfo->format == VK_FORMAT_UNDEFINED); 1225 ext_format = (struct anv_format *) (uintptr_t) format; 1226 } 1227 1228 assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO); 1229 1230 conversion = vk_alloc2(&device->alloc, pAllocator, sizeof(*conversion), 8, 1231 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); 1232 if (!conversion) 1233 return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY); 1234 1235 memset(conversion, 0, sizeof(*conversion)); 1236 1237 conversion->format = anv_get_format(pCreateInfo->format); 1238 conversion->ycbcr_model = pCreateInfo->ycbcrModel; 1239 conversion->ycbcr_range = pCreateInfo->ycbcrRange; 1240 1241 /* The Vulkan 1.1.95 spec says "When creating an external format conversion, 1242 * the value of components if ignored." 1243 */ 1244 if (!ext_format) { 1245 conversion->mapping[0] = pCreateInfo->components.r; 1246 conversion->mapping[1] = pCreateInfo->components.g; 1247 conversion->mapping[2] = pCreateInfo->components.b; 1248 conversion->mapping[3] = pCreateInfo->components.a; 1249 } 1250 1251 conversion->chroma_offsets[0] = pCreateInfo->xChromaOffset; 1252 conversion->chroma_offsets[1] = pCreateInfo->yChromaOffset; 1253 conversion->chroma_filter = pCreateInfo->chromaFilter; 1254 1255 /* Setup external format. */ 1256 if (ext_format) 1257 conversion->format = ext_format; 1258 1259 bool has_chroma_subsampled = false; 1260 for (uint32_t p = 0; p < conversion->format->n_planes; p++) { 1261 if (conversion->format->planes[p].has_chroma && 1262 (conversion->format->planes[p].denominator_scales[0] > 1 || 1263 conversion->format->planes[p].denominator_scales[1] > 1)) 1264 has_chroma_subsampled = true; 1265 } 1266 conversion->chroma_reconstruction = has_chroma_subsampled && 1267 (conversion->chroma_offsets[0] == VK_CHROMA_LOCATION_COSITED_EVEN || 1268 conversion->chroma_offsets[1] == VK_CHROMA_LOCATION_COSITED_EVEN); 1269 1270 *pYcbcrConversion = anv_ycbcr_conversion_to_handle(conversion); 1271 1272 return VK_SUCCESS; 1273} 1274 1275void anv_DestroySamplerYcbcrConversion( 1276 VkDevice _device, 1277 VkSamplerYcbcrConversion YcbcrConversion, 1278 const VkAllocationCallbacks* pAllocator) 1279{ 1280 ANV_FROM_HANDLE(anv_device, device, _device); 1281 ANV_FROM_HANDLE(anv_ycbcr_conversion, conversion, YcbcrConversion); 1282 1283 if (!conversion) 1284 return; 1285 1286 vk_free2(&device->alloc, pAllocator, conversion); 1287} 1288