2 * Copyright © 2016 Red Hat.
3 * Copyright © 2016 Bas Nieuwenhuizen
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
12 * The above copyright notice and this permission notice (including the next
13 * paragraph) shall be included in all copies or substantial portions of the
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
25 #include "radv_private.h"
27 #include "vk_format.h"
32 #include "util/u_half.h"
33 #include "util/format_srgb.h"
34 #include "util/format_r11g11b10f.h"
36 uint32_t radv_translate_buffer_dataformat(const struct vk_format_description
*desc
,
42 if (desc
->format
== VK_FORMAT_B10G11R11_UFLOAT_PACK32
)
43 return V_008F0C_BUF_DATA_FORMAT_10_11_11
;
45 if (first_non_void
< 0)
46 return V_008F0C_BUF_DATA_FORMAT_INVALID
;
47 type
= desc
->channel
[first_non_void
].type
;
49 if (type
== VK_FORMAT_TYPE_FIXED
)
50 return V_008F0C_BUF_DATA_FORMAT_INVALID
;
51 if (desc
->nr_channels
== 4 &&
52 desc
->channel
[0].size
== 10 &&
53 desc
->channel
[1].size
== 10 &&
54 desc
->channel
[2].size
== 10 &&
55 desc
->channel
[3].size
== 2)
56 return V_008F0C_BUF_DATA_FORMAT_2_10_10_10
;
58 /* See whether the components are of the same size. */
59 for (i
= 0; i
< desc
->nr_channels
; i
++) {
60 if (desc
->channel
[first_non_void
].size
!= desc
->channel
[i
].size
)
61 return V_008F0C_BUF_DATA_FORMAT_INVALID
;
64 switch (desc
->channel
[first_non_void
].size
) {
66 switch (desc
->nr_channels
) {
68 return V_008F0C_BUF_DATA_FORMAT_8
;
70 return V_008F0C_BUF_DATA_FORMAT_8_8
;
72 return V_008F0C_BUF_DATA_FORMAT_8_8_8_8
;
76 switch (desc
->nr_channels
) {
78 return V_008F0C_BUF_DATA_FORMAT_16
;
80 return V_008F0C_BUF_DATA_FORMAT_16_16
;
82 return V_008F0C_BUF_DATA_FORMAT_16_16_16_16
;
86 /* From the Southern Islands ISA documentation about MTBUF:
87 * 'Memory reads of data in memory that is 32 or 64 bits do not
88 * undergo any format conversion.'
90 if (type
!= VK_FORMAT_TYPE_FLOAT
&&
91 !desc
->channel
[first_non_void
].pure_integer
)
92 return V_008F0C_BUF_DATA_FORMAT_INVALID
;
94 switch (desc
->nr_channels
) {
96 return V_008F0C_BUF_DATA_FORMAT_32
;
98 return V_008F0C_BUF_DATA_FORMAT_32_32
;
100 return V_008F0C_BUF_DATA_FORMAT_32_32_32
;
102 return V_008F0C_BUF_DATA_FORMAT_32_32_32_32
;
107 return V_008F0C_BUF_DATA_FORMAT_INVALID
;
110 uint32_t radv_translate_buffer_numformat(const struct vk_format_description
*desc
,
113 if (desc
->format
== VK_FORMAT_B10G11R11_UFLOAT_PACK32
)
114 return V_008F0C_BUF_NUM_FORMAT_FLOAT
;
116 if (first_non_void
< 0)
119 switch (desc
->channel
[first_non_void
].type
) {
120 case VK_FORMAT_TYPE_SIGNED
:
121 if (desc
->channel
[first_non_void
].normalized
)
122 return V_008F0C_BUF_NUM_FORMAT_SNORM
;
123 else if (desc
->channel
[first_non_void
].pure_integer
)
124 return V_008F0C_BUF_NUM_FORMAT_SINT
;
126 return V_008F0C_BUF_NUM_FORMAT_SSCALED
;
128 case VK_FORMAT_TYPE_UNSIGNED
:
129 if (desc
->channel
[first_non_void
].normalized
)
130 return V_008F0C_BUF_NUM_FORMAT_UNORM
;
131 else if (desc
->channel
[first_non_void
].pure_integer
)
132 return V_008F0C_BUF_NUM_FORMAT_UINT
;
134 return V_008F0C_BUF_NUM_FORMAT_USCALED
;
136 case VK_FORMAT_TYPE_FLOAT
:
138 return V_008F0C_BUF_NUM_FORMAT_FLOAT
;
142 uint32_t radv_translate_tex_dataformat(VkFormat format
,
143 const struct vk_format_description
*desc
,
151 /* Colorspace (return non-RGB formats directly). */
152 switch (desc
->colorspace
) {
153 /* Depth stencil formats */
154 case VK_FORMAT_COLORSPACE_ZS
:
156 case VK_FORMAT_D16_UNORM
:
157 return V_008F14_IMG_DATA_FORMAT_16
;
158 case VK_FORMAT_D24_UNORM_S8_UINT
:
159 case VK_FORMAT_X8_D24_UNORM_PACK32
:
160 return V_008F14_IMG_DATA_FORMAT_8_24
;
161 case VK_FORMAT_S8_UINT
:
162 return V_008F14_IMG_DATA_FORMAT_8
;
163 case VK_FORMAT_D32_SFLOAT
:
164 return V_008F14_IMG_DATA_FORMAT_32
;
165 case VK_FORMAT_D32_SFLOAT_S8_UINT
:
166 return V_008F14_IMG_DATA_FORMAT_X24_8_32
;
171 case VK_FORMAT_COLORSPACE_YUV
:
172 goto out_unknown
; /* TODO */
174 case VK_FORMAT_COLORSPACE_SRGB
:
175 if (desc
->nr_channels
!= 4 && desc
->nr_channels
!= 1)
183 if (desc
->layout
== VK_FORMAT_LAYOUT_RGTC
) {
185 case VK_FORMAT_BC4_UNORM_BLOCK
:
186 case VK_FORMAT_BC4_SNORM_BLOCK
:
187 return V_008F14_IMG_DATA_FORMAT_BC4
;
188 case VK_FORMAT_BC5_UNORM_BLOCK
:
189 case VK_FORMAT_BC5_SNORM_BLOCK
:
190 return V_008F14_IMG_DATA_FORMAT_BC5
;
196 if (desc
->layout
== VK_FORMAT_LAYOUT_S3TC
) {
198 case VK_FORMAT_BC1_RGB_UNORM_BLOCK
:
199 case VK_FORMAT_BC1_RGB_SRGB_BLOCK
:
200 case VK_FORMAT_BC1_RGBA_UNORM_BLOCK
:
201 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK
:
202 return V_008F14_IMG_DATA_FORMAT_BC1
;
203 case VK_FORMAT_BC2_UNORM_BLOCK
:
204 case VK_FORMAT_BC2_SRGB_BLOCK
:
205 return V_008F14_IMG_DATA_FORMAT_BC2
;
206 case VK_FORMAT_BC3_UNORM_BLOCK
:
207 case VK_FORMAT_BC3_SRGB_BLOCK
:
208 return V_008F14_IMG_DATA_FORMAT_BC3
;
214 if (desc
->layout
== VK_FORMAT_LAYOUT_BPTC
) {
216 case VK_FORMAT_BC6H_UFLOAT_BLOCK
:
217 case VK_FORMAT_BC6H_SFLOAT_BLOCK
:
218 return V_008F14_IMG_DATA_FORMAT_BC6
;
219 case VK_FORMAT_BC7_UNORM_BLOCK
:
220 case VK_FORMAT_BC7_SRGB_BLOCK
:
221 return V_008F14_IMG_DATA_FORMAT_BC7
;
227 if (desc
->layout
== VK_FORMAT_LAYOUT_ETC
) {
229 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
:
230 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
:
231 return V_008F14_IMG_DATA_FORMAT_ETC2_RGB
;
232 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
:
233 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
:
234 return V_008F14_IMG_DATA_FORMAT_ETC2_RGBA1
;
235 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
:
236 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
:
237 return V_008F14_IMG_DATA_FORMAT_ETC2_RGBA
;
238 case VK_FORMAT_EAC_R11_UNORM_BLOCK
:
239 case VK_FORMAT_EAC_R11_SNORM_BLOCK
:
240 return V_008F14_IMG_DATA_FORMAT_ETC2_R
;
241 case VK_FORMAT_EAC_R11G11_UNORM_BLOCK
:
242 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK
:
243 return V_008F14_IMG_DATA_FORMAT_ETC2_RG
;
249 if (format
== VK_FORMAT_E5B9G9R9_UFLOAT_PACK32
) {
250 return V_008F14_IMG_DATA_FORMAT_5_9_9_9
;
251 } else if (format
== VK_FORMAT_B10G11R11_UFLOAT_PACK32
) {
252 return V_008F14_IMG_DATA_FORMAT_10_11_11
;
255 /* R8G8Bx_SNORM - TODO CxV8U8 */
257 /* hw cannot support mixed formats (except depth/stencil, since only
259 if (desc
->is_mixed
&& desc
->colorspace
!= VK_FORMAT_COLORSPACE_ZS
)
262 /* See whether the components are of the same size. */
263 for (i
= 1; i
< desc
->nr_channels
; i
++) {
264 uniform
= uniform
&& desc
->channel
[0].size
== desc
->channel
[i
].size
;
267 /* Non-uniform formats. */
269 switch(desc
->nr_channels
) {
271 if (desc
->channel
[0].size
== 5 &&
272 desc
->channel
[1].size
== 6 &&
273 desc
->channel
[2].size
== 5) {
274 return V_008F14_IMG_DATA_FORMAT_5_6_5
;
278 if (desc
->channel
[0].size
== 5 &&
279 desc
->channel
[1].size
== 5 &&
280 desc
->channel
[2].size
== 5 &&
281 desc
->channel
[3].size
== 1) {
282 return V_008F14_IMG_DATA_FORMAT_1_5_5_5
;
284 if (desc
->channel
[0].size
== 1 &&
285 desc
->channel
[1].size
== 5 &&
286 desc
->channel
[2].size
== 5 &&
287 desc
->channel
[3].size
== 5) {
288 return V_008F14_IMG_DATA_FORMAT_5_5_5_1
;
290 if (desc
->channel
[0].size
== 10 &&
291 desc
->channel
[1].size
== 10 &&
292 desc
->channel
[2].size
== 10 &&
293 desc
->channel
[3].size
== 2) {
294 /* Closed VK driver does this also no 2/10/10/10 snorm */
295 if (desc
->channel
[0].type
== VK_FORMAT_TYPE_SIGNED
&&
296 desc
->channel
[0].normalized
)
298 return V_008F14_IMG_DATA_FORMAT_2_10_10_10
;
305 if (first_non_void
< 0 || first_non_void
> 3)
308 /* uniform formats */
309 switch (desc
->channel
[first_non_void
].size
) {
311 switch (desc
->nr_channels
) {
312 #if 0 /* Not supported for render targets */
314 return V_008F14_IMG_DATA_FORMAT_4_4
;
317 return V_008F14_IMG_DATA_FORMAT_4_4_4_4
;
321 switch (desc
->nr_channels
) {
323 return V_008F14_IMG_DATA_FORMAT_8
;
325 return V_008F14_IMG_DATA_FORMAT_8_8
;
327 return V_008F14_IMG_DATA_FORMAT_8_8_8_8
;
331 switch (desc
->nr_channels
) {
333 return V_008F14_IMG_DATA_FORMAT_16
;
335 return V_008F14_IMG_DATA_FORMAT_16_16
;
337 return V_008F14_IMG_DATA_FORMAT_16_16_16_16
;
341 switch (desc
->nr_channels
) {
343 return V_008F14_IMG_DATA_FORMAT_32
;
345 return V_008F14_IMG_DATA_FORMAT_32_32
;
347 return V_008F14_IMG_DATA_FORMAT_32_32_32
;
349 return V_008F14_IMG_DATA_FORMAT_32_32_32_32
;
354 /* R600_ERR("Unable to handle texformat %d %s\n", format, vk_format_name(format)); */
358 uint32_t radv_translate_tex_numformat(VkFormat format
,
359 const struct vk_format_description
*desc
,
363 case VK_FORMAT_D24_UNORM_S8_UINT
:
364 return V_008F14_IMG_NUM_FORMAT_UNORM
;
366 if (first_non_void
< 0) {
367 if (vk_format_is_compressed(format
)) {
369 case VK_FORMAT_BC1_RGB_SRGB_BLOCK
:
370 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK
:
371 case VK_FORMAT_BC2_SRGB_BLOCK
:
372 case VK_FORMAT_BC3_SRGB_BLOCK
:
373 case VK_FORMAT_BC7_SRGB_BLOCK
:
374 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
:
375 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
:
376 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
:
377 return V_008F14_IMG_NUM_FORMAT_SRGB
;
378 case VK_FORMAT_BC4_SNORM_BLOCK
:
379 case VK_FORMAT_BC5_SNORM_BLOCK
:
380 case VK_FORMAT_BC6H_SFLOAT_BLOCK
:
381 case VK_FORMAT_EAC_R11_SNORM_BLOCK
:
382 case VK_FORMAT_EAC_R11G11_SNORM_BLOCK
:
383 return V_008F14_IMG_NUM_FORMAT_SNORM
;
385 return V_008F14_IMG_NUM_FORMAT_UNORM
;
387 } else if (desc
->layout
== VK_FORMAT_LAYOUT_SUBSAMPLED
) {
388 return V_008F14_IMG_NUM_FORMAT_UNORM
;
390 return V_008F14_IMG_NUM_FORMAT_FLOAT
;
392 } else if (desc
->colorspace
== VK_FORMAT_COLORSPACE_SRGB
) {
393 return V_008F14_IMG_NUM_FORMAT_SRGB
;
395 switch (desc
->channel
[first_non_void
].type
) {
396 case VK_FORMAT_TYPE_FLOAT
:
397 return V_008F14_IMG_NUM_FORMAT_FLOAT
;
398 case VK_FORMAT_TYPE_SIGNED
:
399 if (desc
->channel
[first_non_void
].normalized
)
400 return V_008F14_IMG_NUM_FORMAT_SNORM
;
401 else if (desc
->channel
[first_non_void
].pure_integer
)
402 return V_008F14_IMG_NUM_FORMAT_SINT
;
404 return V_008F14_IMG_NUM_FORMAT_SSCALED
;
405 case VK_FORMAT_TYPE_UNSIGNED
:
406 if (desc
->channel
[first_non_void
].normalized
)
407 return V_008F14_IMG_NUM_FORMAT_UNORM
;
408 else if (desc
->channel
[first_non_void
].pure_integer
)
409 return V_008F14_IMG_NUM_FORMAT_UINT
;
411 return V_008F14_IMG_NUM_FORMAT_USCALED
;
413 return V_008F14_IMG_NUM_FORMAT_UNORM
;
419 uint32_t radv_translate_color_numformat(VkFormat format
,
420 const struct vk_format_description
*desc
,
424 if (first_non_void
== -1 || desc
->channel
[first_non_void
].type
== VK_FORMAT_TYPE_FLOAT
)
425 ntype
= V_028C70_NUMBER_FLOAT
;
427 ntype
= V_028C70_NUMBER_UNORM
;
428 if (desc
->colorspace
== VK_FORMAT_COLORSPACE_SRGB
)
429 ntype
= V_028C70_NUMBER_SRGB
;
430 else if (desc
->channel
[first_non_void
].type
== VK_FORMAT_TYPE_SIGNED
) {
431 if (desc
->channel
[first_non_void
].pure_integer
) {
432 ntype
= V_028C70_NUMBER_SINT
;
433 } else if (desc
->channel
[first_non_void
].normalized
) {
434 ntype
= V_028C70_NUMBER_SNORM
;
437 } else if (desc
->channel
[first_non_void
].type
== VK_FORMAT_TYPE_UNSIGNED
) {
438 if (desc
->channel
[first_non_void
].pure_integer
) {
439 ntype
= V_028C70_NUMBER_UINT
;
440 } else if (desc
->channel
[first_non_void
].normalized
) {
441 ntype
= V_028C70_NUMBER_UNORM
;
449 static bool radv_is_sampler_format_supported(VkFormat format
, bool *linear_sampling
)
451 const struct vk_format_description
*desc
= vk_format_description(format
);
453 if (!desc
|| format
== VK_FORMAT_UNDEFINED
)
455 num_format
= radv_translate_tex_numformat(format
, desc
,
456 vk_format_get_first_non_void_channel(format
));
458 if (num_format
== V_008F14_IMG_NUM_FORMAT_USCALED
||
459 num_format
== V_008F14_IMG_NUM_FORMAT_SSCALED
)
462 if (num_format
== V_008F14_IMG_NUM_FORMAT_UNORM
||
463 num_format
== V_008F14_IMG_NUM_FORMAT_SNORM
||
464 num_format
== V_008F14_IMG_NUM_FORMAT_FLOAT
||
465 num_format
== V_008F14_IMG_NUM_FORMAT_SRGB
)
466 *linear_sampling
= true;
468 *linear_sampling
= false;
469 return radv_translate_tex_dataformat(format
, vk_format_description(format
),
470 vk_format_get_first_non_void_channel(format
)) != ~0U;
474 static bool radv_is_storage_image_format_supported(struct radv_physical_device
*physical_device
,
477 const struct vk_format_description
*desc
= vk_format_description(format
);
478 unsigned data_format
, num_format
;
479 if (!desc
|| format
== VK_FORMAT_UNDEFINED
)
482 data_format
= radv_translate_tex_dataformat(format
, desc
,
483 vk_format_get_first_non_void_channel(format
));
484 num_format
= radv_translate_tex_numformat(format
, desc
,
485 vk_format_get_first_non_void_channel(format
));
487 if(data_format
== ~0 || num_format
== ~0)
490 /* Extracted from the GCN3 ISA document. */
492 case V_008F14_IMG_NUM_FORMAT_UNORM
:
493 case V_008F14_IMG_NUM_FORMAT_SNORM
:
494 case V_008F14_IMG_NUM_FORMAT_UINT
:
495 case V_008F14_IMG_NUM_FORMAT_SINT
:
496 case V_008F14_IMG_NUM_FORMAT_FLOAT
:
502 switch(data_format
) {
503 case V_008F14_IMG_DATA_FORMAT_8
:
504 case V_008F14_IMG_DATA_FORMAT_16
:
505 case V_008F14_IMG_DATA_FORMAT_8_8
:
506 case V_008F14_IMG_DATA_FORMAT_32
:
507 case V_008F14_IMG_DATA_FORMAT_16_16
:
508 case V_008F14_IMG_DATA_FORMAT_10_11_11
:
509 case V_008F14_IMG_DATA_FORMAT_11_11_10
:
510 case V_008F14_IMG_DATA_FORMAT_10_10_10_2
:
511 case V_008F14_IMG_DATA_FORMAT_2_10_10_10
:
512 case V_008F14_IMG_DATA_FORMAT_8_8_8_8
:
513 case V_008F14_IMG_DATA_FORMAT_32_32
:
514 case V_008F14_IMG_DATA_FORMAT_16_16_16_16
:
515 case V_008F14_IMG_DATA_FORMAT_32_32_32_32
:
516 case V_008F14_IMG_DATA_FORMAT_5_6_5
:
517 case V_008F14_IMG_DATA_FORMAT_1_5_5_5
:
518 case V_008F14_IMG_DATA_FORMAT_5_5_5_1
:
519 case V_008F14_IMG_DATA_FORMAT_4_4_4_4
:
520 /* TODO: FMASK formats. */
527 static bool radv_is_buffer_format_supported(VkFormat format
, bool *scaled
)
529 const struct vk_format_description
*desc
= vk_format_description(format
);
530 unsigned data_format
, num_format
;
531 if (!desc
|| format
== VK_FORMAT_UNDEFINED
)
534 data_format
= radv_translate_buffer_dataformat(desc
,
535 vk_format_get_first_non_void_channel(format
));
536 num_format
= radv_translate_buffer_numformat(desc
,
537 vk_format_get_first_non_void_channel(format
));
539 *scaled
= (num_format
== V_008F0C_BUF_NUM_FORMAT_SSCALED
) || (num_format
== V_008F0C_BUF_NUM_FORMAT_USCALED
);
540 return data_format
!= V_008F0C_BUF_DATA_FORMAT_INVALID
&&
544 bool radv_is_colorbuffer_format_supported(VkFormat format
, bool *blendable
)
546 const struct vk_format_description
*desc
= vk_format_description(format
);
547 uint32_t color_format
= radv_translate_colorformat(format
);
548 uint32_t color_swap
= radv_translate_colorswap(format
, false);
549 uint32_t color_num_format
= radv_translate_color_numformat(format
,
551 vk_format_get_first_non_void_channel(format
));
553 if (color_num_format
== V_028C70_NUMBER_UINT
|| color_num_format
== V_028C70_NUMBER_SINT
||
554 color_format
== V_028C70_COLOR_8_24
|| color_format
== V_028C70_COLOR_24_8
||
555 color_format
== V_028C70_COLOR_X24_8_32_FLOAT
) {
559 return color_format
!= V_028C70_COLOR_INVALID
&&
561 color_num_format
!= ~0;
564 static bool radv_is_zs_format_supported(VkFormat format
)
566 return radv_translate_dbformat(format
) != V_028040_Z_INVALID
|| format
== VK_FORMAT_S8_UINT
;
569 static bool radv_is_filter_minmax_format_supported(VkFormat format
)
571 /* From the Vulkan spec 1.1.71:
573 * "The following formats must support the
574 * VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT feature with
575 * VK_IMAGE_TILING_OPTIMAL, if they support
576 * VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT."
578 /* TODO: enable more formats. */
580 case VK_FORMAT_R8_UNORM
:
581 case VK_FORMAT_R8_SNORM
:
582 case VK_FORMAT_R16_UNORM
:
583 case VK_FORMAT_R16_SNORM
:
584 case VK_FORMAT_R16_SFLOAT
:
585 case VK_FORMAT_R32_SFLOAT
:
586 case VK_FORMAT_D16_UNORM
:
587 case VK_FORMAT_X8_D24_UNORM_PACK32
:
588 case VK_FORMAT_D32_SFLOAT
:
589 case VK_FORMAT_D16_UNORM_S8_UINT
:
590 case VK_FORMAT_D24_UNORM_S8_UINT
:
591 case VK_FORMAT_D32_SFLOAT_S8_UINT
:
599 radv_device_supports_etc(struct radv_physical_device
*physical_device
)
601 return physical_device
->rad_info
.family
== CHIP_VEGA10
||
602 physical_device
->rad_info
.family
== CHIP_RAVEN
||
603 physical_device
->rad_info
.family
== CHIP_STONEY
;
607 radv_physical_device_get_format_properties(struct radv_physical_device
*physical_device
,
609 VkFormatProperties
*out_properties
)
611 VkFormatFeatureFlags linear
= 0, tiled
= 0, buffer
= 0;
612 const struct vk_format_description
*desc
= vk_format_description(format
);
616 out_properties
->linearTilingFeatures
= linear
;
617 out_properties
->optimalTilingFeatures
= tiled
;
618 out_properties
->bufferFeatures
= buffer
;
622 if (desc
->layout
== VK_FORMAT_LAYOUT_ETC
&&
623 !radv_device_supports_etc(physical_device
)) {
624 out_properties
->linearTilingFeatures
= linear
;
625 out_properties
->optimalTilingFeatures
= tiled
;
626 out_properties
->bufferFeatures
= buffer
;
630 if (radv_is_storage_image_format_supported(physical_device
, format
)) {
631 tiled
|= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
;
632 linear
|= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
;
635 if (radv_is_buffer_format_supported(format
, &scaled
)) {
636 buffer
|= VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT
;
638 buffer
|= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
639 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
;
642 if (vk_format_is_depth_or_stencil(format
)) {
643 if (radv_is_zs_format_supported(format
)) {
644 tiled
|= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
;
645 tiled
|= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
;
646 tiled
|= VK_FORMAT_FEATURE_BLIT_SRC_BIT
|
647 VK_FORMAT_FEATURE_BLIT_DST_BIT
;
648 tiled
|= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
649 VK_FORMAT_FEATURE_TRANSFER_DST_BIT
;
651 if (radv_is_filter_minmax_format_supported(format
))
652 tiled
|= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT
;
654 /* Don't support blitting surfaces with depth/stencil. */
655 if (vk_format_is_depth(format
) && vk_format_is_stencil(format
))
656 tiled
&= ~VK_FORMAT_FEATURE_BLIT_DST_BIT
;
658 /* Don't support linear depth surfaces */
662 bool linear_sampling
;
663 if (radv_is_sampler_format_supported(format
, &linear_sampling
)) {
664 linear
|= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
|
665 VK_FORMAT_FEATURE_BLIT_SRC_BIT
;
666 tiled
|= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
|
667 VK_FORMAT_FEATURE_BLIT_SRC_BIT
;
669 if (radv_is_filter_minmax_format_supported(format
))
670 tiled
|= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT
;
672 if (linear_sampling
) {
673 linear
|= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
;
674 tiled
|= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
;
677 /* Don't support blitting for R32G32B32 formats. */
678 if (format
== VK_FORMAT_R32G32B32_SFLOAT
||
679 format
== VK_FORMAT_R32G32B32_UINT
||
680 format
== VK_FORMAT_R32G32B32_SINT
) {
681 linear
&= ~VK_FORMAT_FEATURE_BLIT_SRC_BIT
;
684 if (radv_is_colorbuffer_format_supported(format
, &blendable
)) {
685 linear
|= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
| VK_FORMAT_FEATURE_BLIT_DST_BIT
;
686 tiled
|= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
| VK_FORMAT_FEATURE_BLIT_DST_BIT
;
688 linear
|= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
;
689 tiled
|= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT
;
692 if (tiled
&& !scaled
) {
693 tiled
|= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
694 VK_FORMAT_FEATURE_TRANSFER_DST_BIT
;
697 /* Tiled formatting does not support NPOT pixel sizes */
698 if (!util_is_power_of_two_or_zero(vk_format_get_blocksize(format
)))
702 if (linear
&& !scaled
) {
703 linear
|= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
|
704 VK_FORMAT_FEATURE_TRANSFER_DST_BIT
;
707 if (format
== VK_FORMAT_R32_UINT
|| format
== VK_FORMAT_R32_SINT
) {
708 buffer
|= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT
;
709 linear
|= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
;
710 tiled
|= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT
;
714 case VK_FORMAT_A2R10G10B10_SNORM_PACK32
:
715 case VK_FORMAT_A2B10G10R10_SNORM_PACK32
:
716 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32
:
717 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32
:
718 case VK_FORMAT_A2R10G10B10_SINT_PACK32
:
719 case VK_FORMAT_A2B10G10R10_SINT_PACK32
:
720 if (physical_device
->rad_info
.chip_class
<= VI
&&
721 physical_device
->rad_info
.family
!= CHIP_STONEY
) {
722 buffer
&= ~(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT
|
723 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT
);
732 out_properties
->linearTilingFeatures
= linear
;
733 out_properties
->optimalTilingFeatures
= tiled
;
734 out_properties
->bufferFeatures
= buffer
;
737 uint32_t radv_translate_colorformat(VkFormat format
)
739 const struct vk_format_description
*desc
= vk_format_description(format
);
741 #define HAS_SIZE(x,y,z,w) \
742 (desc->channel[0].size == (x) && desc->channel[1].size == (y) && \
743 desc->channel[2].size == (z) && desc->channel[3].size == (w))
745 if (format
== VK_FORMAT_B10G11R11_UFLOAT_PACK32
) /* isn't plain */
746 return V_028C70_COLOR_10_11_11
;
748 if (desc
->layout
!= VK_FORMAT_LAYOUT_PLAIN
)
749 return V_028C70_COLOR_INVALID
;
751 /* hw cannot support mixed formats (except depth/stencil, since
752 * stencil is not written to). */
753 if (desc
->is_mixed
&& desc
->colorspace
!= VK_FORMAT_COLORSPACE_ZS
)
754 return V_028C70_COLOR_INVALID
;
756 switch (desc
->nr_channels
) {
758 switch (desc
->channel
[0].size
) {
760 return V_028C70_COLOR_8
;
762 return V_028C70_COLOR_16
;
764 return V_028C70_COLOR_32
;
768 if (desc
->channel
[0].size
== desc
->channel
[1].size
) {
769 switch (desc
->channel
[0].size
) {
771 return V_028C70_COLOR_8_8
;
773 return V_028C70_COLOR_16_16
;
775 return V_028C70_COLOR_32_32
;
777 } else if (HAS_SIZE(8,24,0,0)) {
778 return V_028C70_COLOR_24_8
;
779 } else if (HAS_SIZE(24,8,0,0)) {
780 return V_028C70_COLOR_8_24
;
784 if (HAS_SIZE(5,6,5,0)) {
785 return V_028C70_COLOR_5_6_5
;
786 } else if (HAS_SIZE(32,8,24,0)) {
787 return V_028C70_COLOR_X24_8_32_FLOAT
;
791 if (desc
->channel
[0].size
== desc
->channel
[1].size
&&
792 desc
->channel
[0].size
== desc
->channel
[2].size
&&
793 desc
->channel
[0].size
== desc
->channel
[3].size
) {
794 switch (desc
->channel
[0].size
) {
796 return V_028C70_COLOR_4_4_4_4
;
798 return V_028C70_COLOR_8_8_8_8
;
800 return V_028C70_COLOR_16_16_16_16
;
802 return V_028C70_COLOR_32_32_32_32
;
804 } else if (HAS_SIZE(5,5,5,1)) {
805 return V_028C70_COLOR_1_5_5_5
;
806 } else if (HAS_SIZE(1,5,5,5)) {
807 return V_028C70_COLOR_5_5_5_1
;
808 } else if (HAS_SIZE(10,10,10,2)) {
809 return V_028C70_COLOR_2_10_10_10
;
813 return V_028C70_COLOR_INVALID
;
816 uint32_t radv_colorformat_endian_swap(uint32_t colorformat
)
818 if (0/*SI_BIG_ENDIAN*/) {
819 switch(colorformat
) {
821 case V_028C70_COLOR_8
:
822 return V_028C70_ENDIAN_NONE
;
824 /* 16-bit buffers. */
825 case V_028C70_COLOR_5_6_5
:
826 case V_028C70_COLOR_1_5_5_5
:
827 case V_028C70_COLOR_4_4_4_4
:
828 case V_028C70_COLOR_16
:
829 case V_028C70_COLOR_8_8
:
830 return V_028C70_ENDIAN_8IN16
;
832 /* 32-bit buffers. */
833 case V_028C70_COLOR_8_8_8_8
:
834 case V_028C70_COLOR_2_10_10_10
:
835 case V_028C70_COLOR_8_24
:
836 case V_028C70_COLOR_24_8
:
837 case V_028C70_COLOR_16_16
:
838 return V_028C70_ENDIAN_8IN32
;
840 /* 64-bit buffers. */
841 case V_028C70_COLOR_16_16_16_16
:
842 return V_028C70_ENDIAN_8IN16
;
844 case V_028C70_COLOR_32_32
:
845 return V_028C70_ENDIAN_8IN32
;
847 /* 128-bit buffers. */
848 case V_028C70_COLOR_32_32_32_32
:
849 return V_028C70_ENDIAN_8IN32
;
851 return V_028C70_ENDIAN_NONE
; /* Unsupported. */
854 return V_028C70_ENDIAN_NONE
;
858 uint32_t radv_translate_dbformat(VkFormat format
)
861 case VK_FORMAT_D16_UNORM
:
862 case VK_FORMAT_D16_UNORM_S8_UINT
:
863 return V_028040_Z_16
;
864 case VK_FORMAT_D32_SFLOAT
:
865 case VK_FORMAT_D32_SFLOAT_S8_UINT
:
866 return V_028040_Z_32_FLOAT
;
868 return V_028040_Z_INVALID
;
872 unsigned radv_translate_colorswap(VkFormat format
, bool do_endian_swap
)
874 const struct vk_format_description
*desc
= vk_format_description(format
);
876 #define HAS_SWIZZLE(chan,swz) (desc->swizzle[chan] == VK_SWIZZLE_##swz)
878 if (format
== VK_FORMAT_B10G11R11_UFLOAT_PACK32
)
879 return V_028C70_SWAP_STD
;
881 if (desc
->layout
!= VK_FORMAT_LAYOUT_PLAIN
)
884 switch (desc
->nr_channels
) {
886 if (HAS_SWIZZLE(0,X
))
887 return V_028C70_SWAP_STD
; /* X___ */
888 else if (HAS_SWIZZLE(3,X
))
889 return V_028C70_SWAP_ALT_REV
; /* ___X */
892 if ((HAS_SWIZZLE(0,X
) && HAS_SWIZZLE(1,Y
)) ||
893 (HAS_SWIZZLE(0,X
) && HAS_SWIZZLE(1,NONE
)) ||
894 (HAS_SWIZZLE(0,NONE
) && HAS_SWIZZLE(1,Y
)))
895 return V_028C70_SWAP_STD
; /* XY__ */
896 else if ((HAS_SWIZZLE(0,Y
) && HAS_SWIZZLE(1,X
)) ||
897 (HAS_SWIZZLE(0,Y
) && HAS_SWIZZLE(1,NONE
)) ||
898 (HAS_SWIZZLE(0,NONE
) && HAS_SWIZZLE(1,X
)))
900 return (do_endian_swap
? V_028C70_SWAP_STD
: V_028C70_SWAP_STD_REV
);
901 else if (HAS_SWIZZLE(0,X
) && HAS_SWIZZLE(3,Y
))
902 return V_028C70_SWAP_ALT
; /* X__Y */
903 else if (HAS_SWIZZLE(0,Y
) && HAS_SWIZZLE(3,X
))
904 return V_028C70_SWAP_ALT_REV
; /* Y__X */
907 if (HAS_SWIZZLE(0,X
))
908 return (do_endian_swap
? V_028C70_SWAP_STD_REV
: V_028C70_SWAP_STD
);
909 else if (HAS_SWIZZLE(0,Z
))
910 return V_028C70_SWAP_STD_REV
; /* ZYX */
913 /* check the middle channels, the 1st and 4th channel can be NONE */
914 if (HAS_SWIZZLE(1,Y
) && HAS_SWIZZLE(2,Z
)) {
915 return V_028C70_SWAP_STD
; /* XYZW */
916 } else if (HAS_SWIZZLE(1,Z
) && HAS_SWIZZLE(2,Y
)) {
917 return V_028C70_SWAP_STD_REV
; /* WZYX */
918 } else if (HAS_SWIZZLE(1,Y
) && HAS_SWIZZLE(2,X
)) {
919 return V_028C70_SWAP_ALT
; /* ZYXW */
920 } else if (HAS_SWIZZLE(1,Z
) && HAS_SWIZZLE(2,W
)) {
923 return V_028C70_SWAP_ALT_REV
;
925 return (do_endian_swap
? V_028C70_SWAP_ALT
: V_028C70_SWAP_ALT_REV
);
932 bool radv_format_pack_clear_color(VkFormat format
,
933 uint32_t clear_vals
[2],
934 VkClearColorValue
*value
)
936 const struct vk_format_description
*desc
= vk_format_description(format
);
938 if (format
== VK_FORMAT_B10G11R11_UFLOAT_PACK32
) {
939 clear_vals
[0] = float3_to_r11g11b10f(value
->float32
);
944 if (desc
->layout
!= VK_FORMAT_LAYOUT_PLAIN
) {
945 fprintf(stderr
, "failed to fast clear for non-plain format %d\n", format
);
949 if (!util_is_power_of_two_or_zero(desc
->block
.bits
)) {
950 fprintf(stderr
, "failed to fast clear for NPOT format %d\n", format
);
954 if (desc
->block
.bits
> 64) {
956 * We have a 128 bits format, check if the first 3 components are the same.
957 * Every elements has to be 32 bits since we don't support 64-bit formats,
958 * and we can skip swizzling checks as alpha always comes last for these and
959 * we do not care about the rest as they have to be the same.
961 if (desc
->channel
[0].type
== VK_FORMAT_TYPE_FLOAT
) {
962 if (value
->float32
[0] != value
->float32
[1] ||
963 value
->float32
[0] != value
->float32
[2])
966 if (value
->uint32
[0] != value
->uint32
[1] ||
967 value
->uint32
[0] != value
->uint32
[2])
970 clear_vals
[0] = value
->uint32
[0];
971 clear_vals
[1] = value
->uint32
[3];
974 uint64_t clear_val
= 0;
976 for (unsigned c
= 0; c
< 4; ++c
) {
977 if (desc
->swizzle
[c
] >= 4)
980 const struct vk_format_channel_description
*channel
= &desc
->channel
[desc
->swizzle
[c
]];
981 assert(channel
->size
);
984 if (channel
->pure_integer
) {
985 v
= value
->uint32
[c
] & ((1ULL << channel
->size
) - 1);
986 } else if (channel
->normalized
) {
987 if (channel
->type
== VK_FORMAT_TYPE_UNSIGNED
&&
988 desc
->swizzle
[c
] < 3 &&
989 desc
->colorspace
== VK_FORMAT_COLORSPACE_SRGB
) {
990 assert(channel
->size
== 8);
992 v
= util_format_linear_float_to_srgb_8unorm(value
->float32
[c
]);
993 } else if (channel
->type
== VK_FORMAT_TYPE_UNSIGNED
) {
994 v
= MAX2(MIN2(value
->float32
[c
], 1.0f
), 0.0f
) * ((1ULL << channel
->size
) - 1);
996 v
= MAX2(MIN2(value
->float32
[c
], 1.0f
), -1.0f
) * ((1ULL << (channel
->size
- 1)) - 1);
998 } else if (channel
->type
== VK_FORMAT_TYPE_FLOAT
) {
999 if (channel
->size
== 32) {
1000 memcpy(&v
, &value
->float32
[c
], 4);
1001 } else if(channel
->size
== 16) {
1002 v
= util_float_to_half(value
->float32
[c
]);
1004 fprintf(stderr
, "failed to fast clear for unhandled float size in format %d\n", format
);
1008 fprintf(stderr
, "failed to fast clear for unhandled component type in format %d\n", format
);
1011 clear_val
|= (v
& ((1ULL << channel
->size
) - 1)) << channel
->shift
;
1014 clear_vals
[0] = clear_val
;
1015 clear_vals
[1] = clear_val
>> 32;
1020 void radv_GetPhysicalDeviceFormatProperties(
1021 VkPhysicalDevice physicalDevice
,
1023 VkFormatProperties
* pFormatProperties
)
1025 RADV_FROM_HANDLE(radv_physical_device
, physical_device
, physicalDevice
);
1027 radv_physical_device_get_format_properties(physical_device
,
1032 void radv_GetPhysicalDeviceFormatProperties2(
1033 VkPhysicalDevice physicalDevice
,
1035 VkFormatProperties2
* pFormatProperties
)
1037 RADV_FROM_HANDLE(radv_physical_device
, physical_device
, physicalDevice
);
1039 radv_physical_device_get_format_properties(physical_device
,
1041 &pFormatProperties
->formatProperties
);
1044 static VkResult
radv_get_image_format_properties(struct radv_physical_device
*physical_device
,
1045 const VkPhysicalDeviceImageFormatInfo2
*info
,
1046 VkImageFormatProperties
*pImageFormatProperties
)
1049 VkFormatProperties format_props
;
1050 VkFormatFeatureFlags format_feature_flags
;
1051 VkExtent3D maxExtent
;
1052 uint32_t maxMipLevels
;
1053 uint32_t maxArraySize
;
1054 VkSampleCountFlags sampleCounts
= VK_SAMPLE_COUNT_1_BIT
;
1056 radv_physical_device_get_format_properties(physical_device
, info
->format
,
1058 if (info
->tiling
== VK_IMAGE_TILING_LINEAR
) {
1059 format_feature_flags
= format_props
.linearTilingFeatures
;
1060 } else if (info
->tiling
== VK_IMAGE_TILING_OPTIMAL
) {
1061 format_feature_flags
= format_props
.optimalTilingFeatures
;
1063 unreachable("bad VkImageTiling");
1066 if (format_feature_flags
== 0)
1069 if (info
->type
!= VK_IMAGE_TYPE_2D
&& vk_format_is_depth_or_stencil(info
->format
))
1072 switch (info
->type
) {
1074 unreachable("bad vkimage type\n");
1075 case VK_IMAGE_TYPE_1D
:
1076 maxExtent
.width
= 16384;
1077 maxExtent
.height
= 1;
1078 maxExtent
.depth
= 1;
1079 maxMipLevels
= 15; /* log2(maxWidth) + 1 */
1080 maxArraySize
= 2048;
1082 case VK_IMAGE_TYPE_2D
:
1083 maxExtent
.width
= 16384;
1084 maxExtent
.height
= 16384;
1085 maxExtent
.depth
= 1;
1086 maxMipLevels
= 15; /* log2(maxWidth) + 1 */
1087 maxArraySize
= 2048;
1089 case VK_IMAGE_TYPE_3D
:
1090 maxExtent
.width
= 2048;
1091 maxExtent
.height
= 2048;
1092 maxExtent
.depth
= 2048;
1093 maxMipLevels
= 12; /* log2(maxWidth) + 1 */
1098 if (info
->tiling
== VK_IMAGE_TILING_OPTIMAL
&&
1099 info
->type
== VK_IMAGE_TYPE_2D
&&
1100 (format_feature_flags
& (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
|
1101 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
)) &&
1102 !(info
->flags
& VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT
)) {
1103 sampleCounts
|= VK_SAMPLE_COUNT_2_BIT
| VK_SAMPLE_COUNT_4_BIT
| VK_SAMPLE_COUNT_8_BIT
;
1106 if (info
->tiling
== VK_IMAGE_TILING_LINEAR
&&
1107 (info
->format
== VK_FORMAT_R32G32B32_SFLOAT
||
1108 info
->format
== VK_FORMAT_R32G32B32_SINT
||
1109 info
->format
== VK_FORMAT_R32G32B32_UINT
)) {
1110 /* R32G32B32 is a weird format and the driver currently only
1111 * supports the barely minimum.
1112 * TODO: Implement more if we really need to.
1114 if (info
->type
== VK_IMAGE_TYPE_3D
)
1121 /* We can't create 3d compressed 128bpp images that can be rendered to on GFX9 */
1122 if (physical_device
->rad_info
.chip_class
>= GFX9
&&
1123 info
->type
== VK_IMAGE_TYPE_3D
&&
1124 vk_format_get_blocksizebits(info
->format
) == 128 &&
1125 vk_format_is_compressed(info
->format
) &&
1126 (info
->flags
& VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT
) &&
1127 ((info
->flags
& VK_IMAGE_CREATE_EXTENDED_USAGE_BIT
) ||
1128 (info
->usage
& VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
))) {
1132 if (info
->usage
& VK_IMAGE_USAGE_SAMPLED_BIT
) {
1133 if (!(format_feature_flags
& VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
)) {
1138 if (info
->usage
& VK_IMAGE_USAGE_STORAGE_BIT
) {
1139 if (!(format_feature_flags
& VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
)) {
1144 if (info
->usage
& VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT
) {
1145 if (!(format_feature_flags
& VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
)) {
1150 if (info
->usage
& VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT
) {
1151 if (!(format_feature_flags
& VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
)) {
1156 if (info
->usage
& VK_IMAGE_USAGE_TRANSFER_SRC_BIT
) {
1157 if (!(format_feature_flags
& VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
)) {
1162 if (info
->usage
& VK_IMAGE_USAGE_TRANSFER_DST_BIT
) {
1163 if (!(format_feature_flags
& VK_FORMAT_FEATURE_TRANSFER_DST_BIT
)) {
1168 if (info
->usage
& VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT
) {
1169 if (!(format_feature_flags
& (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT
|
1170 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
))) {
1175 *pImageFormatProperties
= (VkImageFormatProperties
) {
1176 .maxExtent
= maxExtent
,
1177 .maxMipLevels
= maxMipLevels
,
1178 .maxArrayLayers
= maxArraySize
,
1179 .sampleCounts
= sampleCounts
,
1181 /* FINISHME: Accurately calculate
1182 * VkImageFormatProperties::maxResourceSize.
1184 .maxResourceSize
= UINT32_MAX
,
1189 *pImageFormatProperties
= (VkImageFormatProperties
) {
1190 .maxExtent
= { 0, 0, 0 },
1192 .maxArrayLayers
= 0,
1194 .maxResourceSize
= 0,
1197 return VK_ERROR_FORMAT_NOT_SUPPORTED
;
1200 VkResult
radv_GetPhysicalDeviceImageFormatProperties(
1201 VkPhysicalDevice physicalDevice
,
1204 VkImageTiling tiling
,
1205 VkImageUsageFlags usage
,
1206 VkImageCreateFlags createFlags
,
1207 VkImageFormatProperties
* pImageFormatProperties
)
1209 RADV_FROM_HANDLE(radv_physical_device
, physical_device
, physicalDevice
);
1211 const VkPhysicalDeviceImageFormatInfo2 info
= {
1212 .sType
= VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2
,
1218 .flags
= createFlags
,
1221 return radv_get_image_format_properties(physical_device
, &info
,
1222 pImageFormatProperties
);
1226 get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2
*pImageFormatInfo
,
1227 VkExternalMemoryHandleTypeFlagBits handleType
,
1228 VkExternalMemoryProperties
*external_properties
)
1230 VkExternalMemoryFeatureFlagBits flags
= 0;
1231 VkExternalMemoryHandleTypeFlags export_flags
= 0;
1232 VkExternalMemoryHandleTypeFlags compat_flags
= 0;
1233 switch (handleType
) {
1234 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
:
1235 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
:
1236 switch (pImageFormatInfo
->type
) {
1237 case VK_IMAGE_TYPE_2D
:
1238 flags
= VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT
|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT
|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
;
1239 compat_flags
= export_flags
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
|
1240 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
;
1246 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT
:
1247 flags
= VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
;
1248 compat_flags
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT
;
1254 *external_properties
= (VkExternalMemoryProperties
) {
1255 .externalMemoryFeatures
= flags
,
1256 .exportFromImportedHandleTypes
= export_flags
,
1257 .compatibleHandleTypes
= compat_flags
,
1261 VkResult
radv_GetPhysicalDeviceImageFormatProperties2(
1262 VkPhysicalDevice physicalDevice
,
1263 const VkPhysicalDeviceImageFormatInfo2
*base_info
,
1264 VkImageFormatProperties2
*base_props
)
1266 RADV_FROM_HANDLE(radv_physical_device
, physical_device
, physicalDevice
);
1267 const VkPhysicalDeviceExternalImageFormatInfo
*external_info
= NULL
;
1268 VkExternalImageFormatProperties
*external_props
= NULL
;
1271 result
= radv_get_image_format_properties(physical_device
, base_info
,
1272 &base_props
->imageFormatProperties
);
1273 if (result
!= VK_SUCCESS
)
1276 /* Extract input structs */
1277 vk_foreach_struct_const(s
, base_info
->pNext
) {
1279 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO
:
1280 external_info
= (const void *) s
;
1287 /* Extract output structs */
1288 vk_foreach_struct(s
, base_props
->pNext
) {
1290 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES
:
1291 external_props
= (void *) s
;
1298 /* From the Vulkan 1.0.97 spec:
1300 * If handleType is 0, vkGetPhysicalDeviceImageFormatProperties2 will
1301 * behave as if VkPhysicalDeviceExternalImageFormatInfo was not
1302 * present and VkExternalImageFormatProperties will be ignored.
1304 if (external_info
&& external_info
->handleType
!= 0) {
1305 switch (external_info
->handleType
) {
1306 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
:
1307 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
:
1308 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT
:
1309 get_external_image_format_properties(base_info
, external_info
->handleType
,
1310 &external_props
->externalMemoryProperties
);
1313 /* From the Vulkan 1.0.97 spec:
1315 * If handleType is not compatible with the [parameters] specified
1316 * in VkPhysicalDeviceImageFormatInfo2, then
1317 * vkGetPhysicalDeviceImageFormatProperties2 returns
1318 * VK_ERROR_FORMAT_NOT_SUPPORTED.
1320 result
= vk_errorf(physical_device
->instance
, VK_ERROR_FORMAT_NOT_SUPPORTED
,
1321 "unsupported VkExternalMemoryTypeFlagBitsKHR 0x%x",
1322 external_info
->handleType
);
1330 if (result
== VK_ERROR_FORMAT_NOT_SUPPORTED
) {
1331 /* From the Vulkan 1.0.97 spec:
1333 * If the combination of parameters to
1334 * vkGetPhysicalDeviceImageFormatProperties2 is not supported by
1335 * the implementation for use in vkCreateImage, then all members of
1336 * imageFormatProperties will be filled with zero.
1338 base_props
->imageFormatProperties
= (VkImageFormatProperties
) {0};
1344 void radv_GetPhysicalDeviceSparseImageFormatProperties(
1345 VkPhysicalDevice physicalDevice
,
1349 VkImageUsageFlags usage
,
1350 VkImageTiling tiling
,
1351 uint32_t* pNumProperties
,
1352 VkSparseImageFormatProperties
* pProperties
)
1354 /* Sparse images are not yet supported. */
1355 *pNumProperties
= 0;
1358 void radv_GetPhysicalDeviceSparseImageFormatProperties2(
1359 VkPhysicalDevice physicalDevice
,
1360 const VkPhysicalDeviceSparseImageFormatInfo2
*pFormatInfo
,
1361 uint32_t *pPropertyCount
,
1362 VkSparseImageFormatProperties2
*pProperties
)
1364 /* Sparse images are not yet supported. */
1365 *pPropertyCount
= 0;
1368 void radv_GetPhysicalDeviceExternalBufferProperties(
1369 VkPhysicalDevice physicalDevice
,
1370 const VkPhysicalDeviceExternalBufferInfo
*pExternalBufferInfo
,
1371 VkExternalBufferProperties
*pExternalBufferProperties
)
1373 VkExternalMemoryFeatureFlagBits flags
= 0;
1374 VkExternalMemoryHandleTypeFlags export_flags
= 0;
1375 VkExternalMemoryHandleTypeFlags compat_flags
= 0;
1376 switch(pExternalBufferInfo
->handleType
) {
1377 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
:
1378 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
:
1379 flags
= VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT
|
1380 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
;
1381 compat_flags
= export_flags
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
|
1382 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT
;
1384 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT
:
1385 flags
= VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
;
1386 compat_flags
= VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT
;
1391 pExternalBufferProperties
->externalMemoryProperties
= (VkExternalMemoryProperties
) {
1392 .externalMemoryFeatures
= flags
,
1393 .exportFromImportedHandleTypes
= export_flags
,
1394 .compatibleHandleTypes
= compat_flags
,
1398 /* DCC channel type categories within which formats can be reinterpreted
1399 * while keeping the same DCC encoding. The swizzle must also match. */
1400 enum dcc_channel_type
{
1401 dcc_channel_float32
,
1404 dcc_channel_float16
,
1407 dcc_channel_uint_10_10_10_2
,
1410 dcc_channel_incompatible
,
1413 /* Return the type of DCC encoding. */
1414 static enum dcc_channel_type
1415 radv_get_dcc_channel_type(const struct vk_format_description
*desc
)
1419 /* Find the first non-void channel. */
1420 for (i
= 0; i
< desc
->nr_channels
; i
++)
1421 if (desc
->channel
[i
].type
!= VK_FORMAT_TYPE_VOID
)
1423 if (i
== desc
->nr_channels
)
1424 return dcc_channel_incompatible
;
1426 switch (desc
->channel
[i
].size
) {
1428 if (desc
->channel
[i
].type
== VK_FORMAT_TYPE_FLOAT
)
1429 return dcc_channel_float32
;
1430 if (desc
->channel
[i
].type
== VK_FORMAT_TYPE_UNSIGNED
)
1431 return dcc_channel_uint32
;
1432 return dcc_channel_sint32
;
1434 if (desc
->channel
[i
].type
== VK_FORMAT_TYPE_FLOAT
)
1435 return dcc_channel_float16
;
1436 if (desc
->channel
[i
].type
== VK_FORMAT_TYPE_UNSIGNED
)
1437 return dcc_channel_uint16
;
1438 return dcc_channel_sint16
;
1440 return dcc_channel_uint_10_10_10_2
;
1442 if (desc
->channel
[i
].type
== VK_FORMAT_TYPE_UNSIGNED
)
1443 return dcc_channel_uint8
;
1444 return dcc_channel_sint8
;
1446 return dcc_channel_incompatible
;
1450 /* Return if it's allowed to reinterpret one format as another with DCC enabled. */
1451 bool radv_dcc_formats_compatible(VkFormat format1
,
1454 const struct vk_format_description
*desc1
, *desc2
;
1455 enum dcc_channel_type type1
, type2
;
1458 if (format1
== format2
)
1461 desc1
= vk_format_description(format1
);
1462 desc2
= vk_format_description(format2
);
1464 if (desc1
->nr_channels
!= desc2
->nr_channels
)
1467 /* Swizzles must be the same. */
1468 for (i
= 0; i
< desc1
->nr_channels
; i
++)
1469 if (desc1
->swizzle
[i
] <= VK_SWIZZLE_W
&&
1470 desc2
->swizzle
[i
] <= VK_SWIZZLE_W
&&
1471 desc1
->swizzle
[i
] != desc2
->swizzle
[i
])
1474 type1
= radv_get_dcc_channel_type(desc1
);
1475 type2
= radv_get_dcc_channel_type(desc2
);
1477 return type1
!= dcc_channel_incompatible
&&
1478 type2
!= dcc_channel_incompatible
&&