projects / mesa.git / blob
? search:


6cff0a5384e7f6ec78b07449525e2cf5062f71e1
[mesa.git] / src / amd / vulkan / radv_formats.c
1 /*
2 * Copyright © 2016 Red Hat.
3 * Copyright © 2016 Bas Nieuwenhuizen
4 *
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:
11 *
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
14 * Software.
15 *
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
22 * IN THE SOFTWARE.
23 */
24
25 #include "radv_private.h"
26
27 #include "vk_format.h"
28 #include "sid.h"
29 #include "r600d_common.h"
30
31 #include "util/vk_util.h"
32 #include "util/u_half.h"
33 #include "util/format_srgb.h"
34 #include "util/format_r11g11b10f.h"
35
36 uint32_t radv_translate_buffer_dataformat(const struct vk_format_description *desc,
37 int first_non_void)
38 {
39 unsigned type;
40 int i;
41
42 if (desc->format == VK_FORMAT_B10G11R11_UFLOAT_PACK32)
43 return V_008F0C_BUF_DATA_FORMAT_10_11_11;
44
45 if (first_non_void < 0)
46 return V_008F0C_BUF_DATA_FORMAT_INVALID;
47 type = desc->channel[first_non_void].type;
48
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;
57
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;
62 }
63
64 switch (desc->channel[first_non_void].size) {
65 case 8:
66 switch (desc->nr_channels) {
67 case 1:
68 return V_008F0C_BUF_DATA_FORMAT_8;
69 case 2:
70 return V_008F0C_BUF_DATA_FORMAT_8_8;
71 case 4:
72 return V_008F0C_BUF_DATA_FORMAT_8_8_8_8;
73 }
74 break;
75 case 16:
76 switch (desc->nr_channels) {
77 case 1:
78 return V_008F0C_BUF_DATA_FORMAT_16;
79 case 2:
80 return V_008F0C_BUF_DATA_FORMAT_16_16;
81 case 4:
82 return V_008F0C_BUF_DATA_FORMAT_16_16_16_16;
83 }
84 break;
85 case 32:
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.'
89 */
90 if (type != VK_FORMAT_TYPE_FLOAT &&
91 !desc->channel[first_non_void].pure_integer)
92 return V_008F0C_BUF_DATA_FORMAT_INVALID;
93
94 switch (desc->nr_channels) {
95 case 1:
96 return V_008F0C_BUF_DATA_FORMAT_32;
97 case 2:
98 return V_008F0C_BUF_DATA_FORMAT_32_32;
99 case 3:
100 return V_008F0C_BUF_DATA_FORMAT_32_32_32;
101 case 4:
102 return V_008F0C_BUF_DATA_FORMAT_32_32_32_32;
103 }
104 break;
105 }
106
107 return V_008F0C_BUF_DATA_FORMAT_INVALID;
108 }
109
110 uint32_t radv_translate_buffer_numformat(const struct vk_format_description *desc,
111 int first_non_void)
112 {
113 if (desc->format == VK_FORMAT_B10G11R11_UFLOAT_PACK32)
114 return V_008F0C_BUF_NUM_FORMAT_FLOAT;
115
116 if (first_non_void < 0)
117 return ~0;
118
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;
125 else
126 return V_008F0C_BUF_NUM_FORMAT_SSCALED;
127 break;
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;
133 else
134 return V_008F0C_BUF_NUM_FORMAT_USCALED;
135 break;
136 case VK_FORMAT_TYPE_FLOAT:
137 default:
138 return V_008F0C_BUF_NUM_FORMAT_FLOAT;
139 }
140 }
141
142 uint32_t radv_translate_tex_dataformat(VkFormat format,
143 const struct vk_format_description *desc,
144 int first_non_void)
145 {
146 bool uniform = true;
147 int i;
148
149 if (!desc)
150 return ~0;
151 /* Colorspace (return non-RGB formats directly). */
152 switch (desc->colorspace) {
153 /* Depth stencil formats */
154 case VK_FORMAT_COLORSPACE_ZS:
155 switch (format) {
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;
167 default:
168 goto out_unknown;
169 }
170
171 case VK_FORMAT_COLORSPACE_YUV:
172 goto out_unknown; /* TODO */
173
174 case VK_FORMAT_COLORSPACE_SRGB:
175 if (desc->nr_channels != 4 && desc->nr_channels != 1)
176 goto out_unknown;
177 break;
178
179 default:
180 break;
181 }
182
183 if (desc->layout == VK_FORMAT_LAYOUT_RGTC) {
184 switch(format) {
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;
191 default:
192 break;
193 }
194 }
195
196 if (desc->layout == VK_FORMAT_LAYOUT_S3TC) {
197 switch(format) {
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;
209 default:
210 break;
211 }
212 }
213
214 if (desc->layout == VK_FORMAT_LAYOUT_BPTC) {
215 switch(format) {
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;
222 default:
223 break;
224 }
225 }
226
227 if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) {
228 return V_008F14_IMG_DATA_FORMAT_5_9_9_9;
229 } else if (format == VK_FORMAT_B10G11R11_UFLOAT_PACK32) {
230 return V_008F14_IMG_DATA_FORMAT_10_11_11;
231 }
232
233 /* R8G8Bx_SNORM - TODO CxV8U8 */
234
235 /* hw cannot support mixed formats (except depth/stencil, since only
236 * depth is read).*/
237 if (desc->is_mixed && desc->colorspace != VK_FORMAT_COLORSPACE_ZS)
238 goto out_unknown;
239
240 /* See whether the components are of the same size. */
241 for (i = 1; i < desc->nr_channels; i++) {
242 uniform = uniform && desc->channel[0].size == desc->channel[i].size;
243 }
244
245 /* Non-uniform formats. */
246 if (!uniform) {
247 switch(desc->nr_channels) {
248 case 3:
249 if (desc->channel[0].size == 5 &&
250 desc->channel[1].size == 6 &&
251 desc->channel[2].size == 5) {
252 return V_008F14_IMG_DATA_FORMAT_5_6_5;
253 }
254 goto out_unknown;
255 case 4:
256 if (desc->channel[0].size == 5 &&
257 desc->channel[1].size == 5 &&
258 desc->channel[2].size == 5 &&
259 desc->channel[3].size == 1) {
260 return V_008F14_IMG_DATA_FORMAT_1_5_5_5;
261 }
262 if (desc->channel[0].size == 1 &&
263 desc->channel[1].size == 5 &&
264 desc->channel[2].size == 5 &&
265 desc->channel[3].size == 5) {
266 return V_008F14_IMG_DATA_FORMAT_5_5_5_1;
267 }
268 if (desc->channel[0].size == 10 &&
269 desc->channel[1].size == 10 &&
270 desc->channel[2].size == 10 &&
271 desc->channel[3].size == 2) {
272 /* Closed VK driver does this also no 2/10/10/10 snorm */
273 if (desc->channel[0].type == VK_FORMAT_TYPE_SIGNED &&
274 desc->channel[0].normalized)
275 goto out_unknown;
276 return V_008F14_IMG_DATA_FORMAT_2_10_10_10;
277 }
278 goto out_unknown;
279 }
280 goto out_unknown;
281 }
282
283 if (first_non_void < 0 || first_non_void > 3)
284 goto out_unknown;
285
286 /* uniform formats */
287 switch (desc->channel[first_non_void].size) {
288 case 4:
289 switch (desc->nr_channels) {
290 #if 0 /* Not supported for render targets */
291 case 2:
292 return V_008F14_IMG_DATA_FORMAT_4_4;
293 #endif
294 case 4:
295 return V_008F14_IMG_DATA_FORMAT_4_4_4_4;
296 }
297 break;
298 case 8:
299 switch (desc->nr_channels) {
300 case 1:
301 return V_008F14_IMG_DATA_FORMAT_8;
302 case 2:
303 return V_008F14_IMG_DATA_FORMAT_8_8;
304 case 4:
305 return V_008F14_IMG_DATA_FORMAT_8_8_8_8;
306 }
307 break;
308 case 16:
309 switch (desc->nr_channels) {
310 case 1:
311 return V_008F14_IMG_DATA_FORMAT_16;
312 case 2:
313 return V_008F14_IMG_DATA_FORMAT_16_16;
314 case 4:
315 return V_008F14_IMG_DATA_FORMAT_16_16_16_16;
316 }
317 break;
318 case 32:
319 switch (desc->nr_channels) {
320 case 1:
321 return V_008F14_IMG_DATA_FORMAT_32;
322 case 2:
323 return V_008F14_IMG_DATA_FORMAT_32_32;
324 #if 0 /* Not supported for render targets */
325 case 3:
326 return V_008F14_IMG_DATA_FORMAT_32_32_32;
327 #endif
328 case 4:
329 return V_008F14_IMG_DATA_FORMAT_32_32_32_32;
330 }
331 }
332
333 out_unknown:
334 /* R600_ERR("Unable to handle texformat %d %s\n", format, vk_format_name(format)); */
335 return ~0;
336 }
337
338 uint32_t radv_translate_tex_numformat(VkFormat format,
339 const struct vk_format_description *desc,
340 int first_non_void)
341 {
342 switch (format) {
343 case VK_FORMAT_D24_UNORM_S8_UINT:
344 return V_008F14_IMG_NUM_FORMAT_UNORM;
345 default:
346 if (first_non_void < 0) {
347 if (vk_format_is_compressed(format)) {
348 switch (format) {
349 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
350 case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
351 case VK_FORMAT_BC2_SRGB_BLOCK:
352 case VK_FORMAT_BC3_SRGB_BLOCK:
353 case VK_FORMAT_BC7_SRGB_BLOCK:
354 return V_008F14_IMG_NUM_FORMAT_SRGB;
355 case VK_FORMAT_BC4_SNORM_BLOCK:
356 case VK_FORMAT_BC5_SNORM_BLOCK:
357 case VK_FORMAT_BC6H_SFLOAT_BLOCK:
358 return V_008F14_IMG_NUM_FORMAT_SNORM;
359 default:
360 return V_008F14_IMG_NUM_FORMAT_UNORM;
361 }
362 } else if (desc->layout == VK_FORMAT_LAYOUT_SUBSAMPLED) {
363 return V_008F14_IMG_NUM_FORMAT_UNORM;
364 } else {
365 return V_008F14_IMG_NUM_FORMAT_FLOAT;
366 }
367 } else if (desc->colorspace == VK_FORMAT_COLORSPACE_SRGB) {
368 return V_008F14_IMG_NUM_FORMAT_SRGB;
369 } else {
370 switch (desc->channel[first_non_void].type) {
371 case VK_FORMAT_TYPE_FLOAT:
372 return V_008F14_IMG_NUM_FORMAT_FLOAT;
373 case VK_FORMAT_TYPE_SIGNED:
374 if (desc->channel[first_non_void].normalized)
375 return V_008F14_IMG_NUM_FORMAT_SNORM;
376 else if (desc->channel[first_non_void].pure_integer)
377 return V_008F14_IMG_NUM_FORMAT_SINT;
378 else
379 return V_008F14_IMG_NUM_FORMAT_SSCALED;
380 case VK_FORMAT_TYPE_UNSIGNED:
381 if (desc->channel[first_non_void].normalized)
382 return V_008F14_IMG_NUM_FORMAT_UNORM;
383 else if (desc->channel[first_non_void].pure_integer)
384 return V_008F14_IMG_NUM_FORMAT_UINT;
385 else
386 return V_008F14_IMG_NUM_FORMAT_USCALED;
387 default:
388 return V_008F14_IMG_NUM_FORMAT_UNORM;
389 }
390 }
391 }
392 }
393
394 uint32_t radv_translate_color_numformat(VkFormat format,
395 const struct vk_format_description *desc,
396 int first_non_void)
397 {
398 unsigned ntype;
399 if (first_non_void == -1 || desc->channel[first_non_void].type == VK_FORMAT_TYPE_FLOAT)
400 ntype = V_028C70_NUMBER_FLOAT;
401 else {
402 ntype = V_028C70_NUMBER_UNORM;
403 if (desc->colorspace == VK_FORMAT_COLORSPACE_SRGB)
404 ntype = V_028C70_NUMBER_SRGB;
405 else if (desc->channel[first_non_void].type == VK_FORMAT_TYPE_SIGNED) {
406 if (desc->channel[first_non_void].pure_integer) {
407 ntype = V_028C70_NUMBER_SINT;
408 } else if (desc->channel[first_non_void].normalized) {
409 ntype = V_028C70_NUMBER_SNORM;
410 } else
411 ntype = ~0u;
412 } else if (desc->channel[first_non_void].type == VK_FORMAT_TYPE_UNSIGNED) {
413 if (desc->channel[first_non_void].pure_integer) {
414 ntype = V_028C70_NUMBER_UINT;
415 } else if (desc->channel[first_non_void].normalized) {
416 ntype = V_028C70_NUMBER_UNORM;
417 } else
418 ntype = ~0u;
419 }
420 }
421 return ntype;
422 }
423
424 static bool radv_is_sampler_format_supported(VkFormat format, bool *linear_sampling)
425 {
426 const struct vk_format_description *desc = vk_format_description(format);
427 uint32_t num_format;
428 if (!desc || format == VK_FORMAT_UNDEFINED)
429 return false;
430 num_format = radv_translate_tex_numformat(format, desc,
431 vk_format_get_first_non_void_channel(format));
432
433 if (num_format == V_008F14_IMG_NUM_FORMAT_USCALED ||
434 num_format == V_008F14_IMG_NUM_FORMAT_SSCALED)
435 return false;
436
437 if (num_format == V_008F14_IMG_NUM_FORMAT_UNORM ||
438 num_format == V_008F14_IMG_NUM_FORMAT_SNORM ||
439 num_format == V_008F14_IMG_NUM_FORMAT_FLOAT ||
440 num_format == V_008F14_IMG_NUM_FORMAT_SRGB)
441 *linear_sampling = true;
442 else
443 *linear_sampling = false;
444 return radv_translate_tex_dataformat(format, vk_format_description(format),
445 vk_format_get_first_non_void_channel(format)) != ~0U;
446 }
447
448
449 static bool radv_is_storage_image_format_supported(struct radv_physical_device *physical_device,
450 VkFormat format)
451 {
452 const struct vk_format_description *desc = vk_format_description(format);
453 unsigned data_format, num_format;
454 if (!desc || format == VK_FORMAT_UNDEFINED)
455 return false;
456
457 data_format = radv_translate_tex_dataformat(format, desc,
458 vk_format_get_first_non_void_channel(format));
459 num_format = radv_translate_tex_numformat(format, desc,
460 vk_format_get_first_non_void_channel(format));
461
462 if(data_format == ~0 || num_format == ~0)
463 return false;
464
465 /* Extracted from the GCN3 ISA document. */
466 switch(num_format) {
467 case V_008F14_IMG_NUM_FORMAT_UNORM:
468 case V_008F14_IMG_NUM_FORMAT_SNORM:
469 case V_008F14_IMG_NUM_FORMAT_UINT:
470 case V_008F14_IMG_NUM_FORMAT_SINT:
471 case V_008F14_IMG_NUM_FORMAT_FLOAT:
472 break;
473 default:
474 return false;
475 }
476
477 switch(data_format) {
478 case V_008F14_IMG_DATA_FORMAT_8:
479 case V_008F14_IMG_DATA_FORMAT_16:
480 case V_008F14_IMG_DATA_FORMAT_8_8:
481 case V_008F14_IMG_DATA_FORMAT_32:
482 case V_008F14_IMG_DATA_FORMAT_16_16:
483 case V_008F14_IMG_DATA_FORMAT_10_11_11:
484 case V_008F14_IMG_DATA_FORMAT_11_11_10:
485 case V_008F14_IMG_DATA_FORMAT_10_10_10_2:
486 case V_008F14_IMG_DATA_FORMAT_2_10_10_10:
487 case V_008F14_IMG_DATA_FORMAT_8_8_8_8:
488 case V_008F14_IMG_DATA_FORMAT_32_32:
489 case V_008F14_IMG_DATA_FORMAT_16_16_16_16:
490 case V_008F14_IMG_DATA_FORMAT_32_32_32_32:
491 case V_008F14_IMG_DATA_FORMAT_5_6_5:
492 case V_008F14_IMG_DATA_FORMAT_1_5_5_5:
493 case V_008F14_IMG_DATA_FORMAT_5_5_5_1:
494 case V_008F14_IMG_DATA_FORMAT_4_4_4_4:
495 /* TODO: FMASK formats. */
496 return true;
497 default:
498 return false;
499 }
500 }
501
502 static bool radv_is_buffer_format_supported(VkFormat format, bool *scaled)
503 {
504 const struct vk_format_description *desc = vk_format_description(format);
505 unsigned data_format, num_format;
506 if (!desc || format == VK_FORMAT_UNDEFINED)
507 return false;
508
509 data_format = radv_translate_buffer_dataformat(desc,
510 vk_format_get_first_non_void_channel(format));
511 num_format = radv_translate_buffer_numformat(desc,
512 vk_format_get_first_non_void_channel(format));
513
514 *scaled = (num_format == V_008F0C_BUF_NUM_FORMAT_SSCALED) || (num_format == V_008F0C_BUF_NUM_FORMAT_USCALED);
515 return data_format != V_008F0C_BUF_DATA_FORMAT_INVALID &&
516 num_format != ~0;
517 }
518
519 bool radv_is_colorbuffer_format_supported(VkFormat format, bool *blendable)
520 {
521 const struct vk_format_description *desc = vk_format_description(format);
522 uint32_t color_format = radv_translate_colorformat(format);
523 uint32_t color_swap = radv_translate_colorswap(format, false);
524 uint32_t color_num_format = radv_translate_color_numformat(format,
525 desc,
526 vk_format_get_first_non_void_channel(format));
527
528 if (color_num_format == V_028C70_NUMBER_UINT || color_num_format == V_028C70_NUMBER_SINT ||
529 color_format == V_028C70_COLOR_8_24 || color_format == V_028C70_COLOR_24_8 ||
530 color_format == V_028C70_COLOR_X24_8_32_FLOAT) {
531 *blendable = false;
532 } else
533 *blendable = true;
534 return color_format != V_028C70_COLOR_INVALID &&
535 color_swap != ~0U &&
536 color_num_format != ~0;
537 }
538
539 static bool radv_is_zs_format_supported(VkFormat format)
540 {
541 return radv_translate_dbformat(format) != V_028040_Z_INVALID || format == VK_FORMAT_S8_UINT;
542 }
543
544 static void
545 radv_physical_device_get_format_properties(struct radv_physical_device *physical_device,
546 VkFormat format,
547 VkFormatProperties *out_properties)
548 {
549 VkFormatFeatureFlags linear = 0, tiled = 0, buffer = 0;
550 const struct vk_format_description *desc = vk_format_description(format);
551 bool blendable;
552 bool scaled = false;
553 if (!desc) {
554 out_properties->linearTilingFeatures = linear;
555 out_properties->optimalTilingFeatures = tiled;
556 out_properties->bufferFeatures = buffer;
557 return;
558 }
559
560 if (radv_is_storage_image_format_supported(physical_device, format)) {
561 tiled |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
562 linear |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
563 }
564
565 if (radv_is_buffer_format_supported(format, &scaled)) {
566 buffer |= VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
567 if (!scaled)
568 buffer |= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT |
569 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
570 }
571
572 if (vk_format_is_depth_or_stencil(format)) {
573 if (radv_is_zs_format_supported(format)) {
574 tiled |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
575 tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
576 tiled |= VK_FORMAT_FEATURE_BLIT_SRC_BIT |
577 VK_FORMAT_FEATURE_BLIT_DST_BIT;
578 tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
579 VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
580 }
581 } else {
582 bool linear_sampling;
583 if (radv_is_sampler_format_supported(format, &linear_sampling)) {
584 linear |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
585 VK_FORMAT_FEATURE_BLIT_SRC_BIT;
586 tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
587 VK_FORMAT_FEATURE_BLIT_SRC_BIT;
588 if (linear_sampling) {
589 linear |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
590 tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
591 }
592 }
593 if (radv_is_colorbuffer_format_supported(format, &blendable)) {
594 linear |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
595 tiled |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
596 if (blendable) {
597 linear |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
598 tiled |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
599 }
600 }
601 if (tiled && util_is_power_of_two(vk_format_get_blocksize(format)) && !scaled) {
602 tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
603 VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
604 }
605 }
606
607 if (linear && util_is_power_of_two(vk_format_get_blocksize(format)) && !scaled) {
608 linear |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR |
609 VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
610 }
611
612 if (format == VK_FORMAT_R32_UINT || format == VK_FORMAT_R32_SINT) {
613 buffer |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
614 linear |= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT;
615 tiled |= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT;
616 }
617
618 out_properties->linearTilingFeatures = linear;
619 out_properties->optimalTilingFeatures = tiled;
620 out_properties->bufferFeatures = buffer;
621 }
622
623 uint32_t radv_translate_colorformat(VkFormat format)
624 {
625 const struct vk_format_description *desc = vk_format_description(format);
626
627 #define HAS_SIZE(x,y,z,w) \
628 (desc->channel[0].size == (x) && desc->channel[1].size == (y) && \
629 desc->channel[2].size == (z) && desc->channel[3].size == (w))
630
631 if (format == VK_FORMAT_B10G11R11_UFLOAT_PACK32) /* isn't plain */
632 return V_028C70_COLOR_10_11_11;
633
634 if (desc->layout != VK_FORMAT_LAYOUT_PLAIN)
635 return V_028C70_COLOR_INVALID;
636
637 /* hw cannot support mixed formats (except depth/stencil, since
638 * stencil is not written to). */
639 if (desc->is_mixed && desc->colorspace != VK_FORMAT_COLORSPACE_ZS)
640 return V_028C70_COLOR_INVALID;
641
642 switch (desc->nr_channels) {
643 case 1:
644 switch (desc->channel[0].size) {
645 case 8:
646 return V_028C70_COLOR_8;
647 case 16:
648 return V_028C70_COLOR_16;
649 case 32:
650 return V_028C70_COLOR_32;
651 }
652 break;
653 case 2:
654 if (desc->channel[0].size == desc->channel[1].size) {
655 switch (desc->channel[0].size) {
656 case 8:
657 return V_028C70_COLOR_8_8;
658 case 16:
659 return V_028C70_COLOR_16_16;
660 case 32:
661 return V_028C70_COLOR_32_32;
662 }
663 } else if (HAS_SIZE(8,24,0,0)) {
664 return V_028C70_COLOR_24_8;
665 } else if (HAS_SIZE(24,8,0,0)) {
666 return V_028C70_COLOR_8_24;
667 }
668 break;
669 case 3:
670 if (HAS_SIZE(5,6,5,0)) {
671 return V_028C70_COLOR_5_6_5;
672 } else if (HAS_SIZE(32,8,24,0)) {
673 return V_028C70_COLOR_X24_8_32_FLOAT;
674 }
675 break;
676 case 4:
677 if (desc->channel[0].size == desc->channel[1].size &&
678 desc->channel[0].size == desc->channel[2].size &&
679 desc->channel[0].size == desc->channel[3].size) {
680 switch (desc->channel[0].size) {
681 case 4:
682 return V_028C70_COLOR_4_4_4_4;
683 case 8:
684 return V_028C70_COLOR_8_8_8_8;
685 case 16:
686 return V_028C70_COLOR_16_16_16_16;
687 case 32:
688 return V_028C70_COLOR_32_32_32_32;
689 }
690 } else if (HAS_SIZE(5,5,5,1)) {
691 return V_028C70_COLOR_1_5_5_5;
692 } else if (HAS_SIZE(1,5,5,5)) {
693 return V_028C70_COLOR_5_5_5_1;
694 } else if (HAS_SIZE(10,10,10,2)) {
695 return V_028C70_COLOR_2_10_10_10;
696 }
697 break;
698 }
699 return V_028C70_COLOR_INVALID;
700 }
701
702 uint32_t radv_colorformat_endian_swap(uint32_t colorformat)
703 {
704 if (0/*SI_BIG_ENDIAN*/) {
705 switch(colorformat) {
706 /* 8-bit buffers. */
707 case V_028C70_COLOR_8:
708 return V_028C70_ENDIAN_NONE;
709
710 /* 16-bit buffers. */
711 case V_028C70_COLOR_5_6_5:
712 case V_028C70_COLOR_1_5_5_5:
713 case V_028C70_COLOR_4_4_4_4:
714 case V_028C70_COLOR_16:
715 case V_028C70_COLOR_8_8:
716 return V_028C70_ENDIAN_8IN16;
717
718 /* 32-bit buffers. */
719 case V_028C70_COLOR_8_8_8_8:
720 case V_028C70_COLOR_2_10_10_10:
721 case V_028C70_COLOR_8_24:
722 case V_028C70_COLOR_24_8:
723 case V_028C70_COLOR_16_16:
724 return V_028C70_ENDIAN_8IN32;
725
726 /* 64-bit buffers. */
727 case V_028C70_COLOR_16_16_16_16:
728 return V_028C70_ENDIAN_8IN16;
729
730 case V_028C70_COLOR_32_32:
731 return V_028C70_ENDIAN_8IN32;
732
733 /* 128-bit buffers. */
734 case V_028C70_COLOR_32_32_32_32:
735 return V_028C70_ENDIAN_8IN32;
736 default:
737 return V_028C70_ENDIAN_NONE; /* Unsupported. */
738 }
739 } else {
740 return V_028C70_ENDIAN_NONE;
741 }
742 }
743
744 uint32_t radv_translate_dbformat(VkFormat format)
745 {
746 switch (format) {
747 case VK_FORMAT_D16_UNORM:
748 case VK_FORMAT_D16_UNORM_S8_UINT:
749 return V_028040_Z_16;
750 case VK_FORMAT_D32_SFLOAT:
751 case VK_FORMAT_D32_SFLOAT_S8_UINT:
752 return V_028040_Z_32_FLOAT;
753 default:
754 return V_028040_Z_INVALID;
755 }
756 }
757
758 unsigned radv_translate_colorswap(VkFormat format, bool do_endian_swap)
759 {
760 const struct vk_format_description *desc = vk_format_description(format);
761
762 #define HAS_SWIZZLE(chan,swz) (desc->swizzle[chan] == VK_SWIZZLE_##swz)
763
764 if (format == VK_FORMAT_B10G11R11_UFLOAT_PACK32)
765 return V_0280A0_SWAP_STD;
766
767 if (desc->layout != VK_FORMAT_LAYOUT_PLAIN)
768 return ~0U;
769
770 switch (desc->nr_channels) {
771 case 1:
772 if (HAS_SWIZZLE(0,X))
773 return V_0280A0_SWAP_STD; /* X___ */
774 else if (HAS_SWIZZLE(3,X))
775 return V_0280A0_SWAP_ALT_REV; /* ___X */
776 break;
777 case 2:
778 if ((HAS_SWIZZLE(0,X) && HAS_SWIZZLE(1,Y)) ||
779 (HAS_SWIZZLE(0,X) && HAS_SWIZZLE(1,NONE)) ||
780 (HAS_SWIZZLE(0,NONE) && HAS_SWIZZLE(1,Y)))
781 return V_0280A0_SWAP_STD; /* XY__ */
782 else if ((HAS_SWIZZLE(0,Y) && HAS_SWIZZLE(1,X)) ||
783 (HAS_SWIZZLE(0,Y) && HAS_SWIZZLE(1,NONE)) ||
784 (HAS_SWIZZLE(0,NONE) && HAS_SWIZZLE(1,X)))
785 /* YX__ */
786 return (do_endian_swap ? V_0280A0_SWAP_STD : V_0280A0_SWAP_STD_REV);
787 else if (HAS_SWIZZLE(0,X) && HAS_SWIZZLE(3,Y))
788 return V_0280A0_SWAP_ALT; /* X__Y */
789 else if (HAS_SWIZZLE(0,Y) && HAS_SWIZZLE(3,X))
790 return V_0280A0_SWAP_ALT_REV; /* Y__X */
791 break;
792 case 3:
793 if (HAS_SWIZZLE(0,X))
794 return (do_endian_swap ? V_0280A0_SWAP_STD_REV : V_0280A0_SWAP_STD);
795 else if (HAS_SWIZZLE(0,Z))
796 return V_0280A0_SWAP_STD_REV; /* ZYX */
797 break;
798 case 4:
799 /* check the middle channels, the 1st and 4th channel can be NONE */
800 if (HAS_SWIZZLE(1,Y) && HAS_SWIZZLE(2,Z)) {
801 return V_0280A0_SWAP_STD; /* XYZW */
802 } else if (HAS_SWIZZLE(1,Z) && HAS_SWIZZLE(2,Y)) {
803 return V_0280A0_SWAP_STD_REV; /* WZYX */
804 } else if (HAS_SWIZZLE(1,Y) && HAS_SWIZZLE(2,X)) {
805 return V_0280A0_SWAP_ALT; /* ZYXW */
806 } else if (HAS_SWIZZLE(1,Z) && HAS_SWIZZLE(2,W)) {
807 /* YZWX */
808 if (desc->is_array)
809 return V_0280A0_SWAP_ALT_REV;
810 else
811 return (do_endian_swap ? V_0280A0_SWAP_ALT : V_0280A0_SWAP_ALT_REV);
812 }
813 break;
814 }
815 return ~0U;
816 }
817
818 bool radv_format_pack_clear_color(VkFormat format,
819 uint32_t clear_vals[2],
820 VkClearColorValue *value)
821 {
822 uint8_t r = 0, g = 0, b = 0, a = 0;
823 const struct vk_format_description *desc = vk_format_description(format);
824
825 if (vk_format_get_component_bits(format, VK_FORMAT_COLORSPACE_RGB, 0) <= 8) {
826 if (desc->colorspace == VK_FORMAT_COLORSPACE_RGB) {
827 r = float_to_ubyte(value->float32[0]);
828 g = float_to_ubyte(value->float32[1]);
829 b = float_to_ubyte(value->float32[2]);
830 a = float_to_ubyte(value->float32[3]);
831 } else if (desc->colorspace == VK_FORMAT_COLORSPACE_SRGB) {
832 r = util_format_linear_float_to_srgb_8unorm(value->float32[0]);
833 g = util_format_linear_float_to_srgb_8unorm(value->float32[1]);
834 b = util_format_linear_float_to_srgb_8unorm(value->float32[2]);
835 a = float_to_ubyte(value->float32[3]);
836 }
837 }
838 switch (format) {
839 case VK_FORMAT_R8_UNORM:
840 case VK_FORMAT_R8_SRGB:
841 clear_vals[0] = r;
842 clear_vals[1] = 0;
843 break;
844 case VK_FORMAT_R8G8_UNORM:
845 case VK_FORMAT_R8G8_SRGB:
846 clear_vals[0] = r | g << 8;
847 clear_vals[1] = 0;
848 break;
849 case VK_FORMAT_R8G8B8A8_SRGB:
850 case VK_FORMAT_R8G8B8A8_UNORM:
851 clear_vals[0] = r | g << 8 | b << 16 | a << 24;
852 clear_vals[1] = 0;
853 break;
854 case VK_FORMAT_B8G8R8A8_SRGB:
855 case VK_FORMAT_B8G8R8A8_UNORM:
856 clear_vals[0] = b | g << 8 | r << 16 | a << 24;
857 clear_vals[1] = 0;
858 break;
859 case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
860 case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
861 clear_vals[0] = r | g << 8 | b << 16 | a << 24;
862 clear_vals[1] = 0;
863 break;
864 case VK_FORMAT_R8_UINT:
865 clear_vals[0] = value->uint32[0] & 0xff;
866 clear_vals[1] = 0;
867 break;
868 case VK_FORMAT_R8_SINT:
869 clear_vals[0] = value->int32[0] & 0xff;
870 clear_vals[1] = 0;
871 break;
872 case VK_FORMAT_R16_UINT:
873 clear_vals[0] = value->uint32[0] & 0xffff;
874 clear_vals[1] = 0;
875 break;
876 case VK_FORMAT_R8G8_UINT:
877 clear_vals[0] = value->uint32[0] & 0xff;
878 clear_vals[0] |= (value->uint32[1] & 0xff) << 8;
879 clear_vals[1] = 0;
880 break;
881 case VK_FORMAT_R8G8_SINT:
882 clear_vals[0] = value->int32[0] & 0xff;
883 clear_vals[0] |= (value->int32[1] & 0xff) << 8;
884 clear_vals[1] = 0;
885 break;
886 case VK_FORMAT_R8G8B8A8_UINT:
887 clear_vals[0] = value->uint32[0] & 0xff;
888 clear_vals[0] |= (value->uint32[1] & 0xff) << 8;
889 clear_vals[0] |= (value->uint32[2] & 0xff) << 16;
890 clear_vals[0] |= (value->uint32[3] & 0xff) << 24;
891 clear_vals[1] = 0;
892 break;
893 case VK_FORMAT_R8G8B8A8_SINT:
894 clear_vals[0] = value->int32[0] & 0xff;
895 clear_vals[0] |= (value->int32[1] & 0xff) << 8;
896 clear_vals[0] |= (value->int32[2] & 0xff) << 16;
897 clear_vals[0] |= (value->int32[3] & 0xff) << 24;
898 clear_vals[1] = 0;
899 break;
900 case VK_FORMAT_A8B8G8R8_UINT_PACK32:
901 clear_vals[0] = value->uint32[0] & 0xff;
902 clear_vals[0] |= (value->uint32[1] & 0xff) << 8;
903 clear_vals[0] |= (value->uint32[2] & 0xff) << 16;
904 clear_vals[0] |= (value->uint32[3] & 0xff) << 24;
905 clear_vals[1] = 0;
906 break;
907 case VK_FORMAT_R16G16_UINT:
908 clear_vals[0] = value->uint32[0] & 0xffff;
909 clear_vals[0] |= (value->uint32[1] & 0xffff) << 16;
910 clear_vals[1] = 0;
911 break;
912 case VK_FORMAT_R16G16B16A16_UINT:
913 clear_vals[0] = value->uint32[0] & 0xffff;
914 clear_vals[0] |= (value->uint32[1] & 0xffff) << 16;
915 clear_vals[1] = value->uint32[2] & 0xffff;
916 clear_vals[1] |= (value->uint32[3] & 0xffff) << 16;
917 break;
918 case VK_FORMAT_R32_UINT:
919 clear_vals[0] = value->uint32[0];
920 clear_vals[1] = 0;
921 break;
922 case VK_FORMAT_R32G32_UINT:
923 clear_vals[0] = value->uint32[0];
924 clear_vals[1] = value->uint32[1];
925 break;
926 case VK_FORMAT_R32_SINT:
927 clear_vals[0] = value->int32[0];
928 clear_vals[1] = 0;
929 break;
930 case VK_FORMAT_R16_SFLOAT:
931 clear_vals[0] = util_float_to_half(value->float32[0]);
932 clear_vals[1] = 0;
933 break;
934 case VK_FORMAT_R16G16_SFLOAT:
935 clear_vals[0] = util_float_to_half(value->float32[0]);
936 clear_vals[0] |= (uint32_t)util_float_to_half(value->float32[1]) << 16;
937 clear_vals[1] = 0;
938 break;
939 case VK_FORMAT_R16G16B16A16_SFLOAT:
940 clear_vals[0] = util_float_to_half(value->float32[0]);
941 clear_vals[0] |= (uint32_t)util_float_to_half(value->float32[1]) << 16;
942 clear_vals[1] = util_float_to_half(value->float32[2]);
943 clear_vals[1] |= (uint32_t)util_float_to_half(value->float32[3]) << 16;
944 break;
945 case VK_FORMAT_R16_UNORM:
946 clear_vals[0] = ((uint16_t)util_iround(CLAMP(value->float32[0], 0.0f, 1.0f) * 0xffff)) & 0xffff;
947 clear_vals[1] = 0;
948 break;
949 case VK_FORMAT_R16G16_UNORM:
950 clear_vals[0] = ((uint16_t)util_iround(CLAMP(value->float32[0], 0.0f, 1.0f) * 0xffff)) & 0xffff;
951 clear_vals[0] |= ((uint16_t)util_iround(CLAMP(value->float32[1], 0.0f, 1.0f) * 0xffff)) << 16;
952 clear_vals[1] = 0;
953 break;
954 case VK_FORMAT_R16G16B16A16_UNORM:
955 clear_vals[0] = ((uint16_t)util_iround(CLAMP(value->float32[0], 0.0f, 1.0f) * 0xffff)) & 0xffff;
956 clear_vals[0] |= ((uint16_t)util_iround(CLAMP(value->float32[1], 0.0f, 1.0f) * 0xffff)) << 16;
957 clear_vals[1] = ((uint16_t)util_iround(CLAMP(value->float32[2], 0.0f, 1.0f) * 0xffff)) & 0xffff;
958 clear_vals[1] |= ((uint16_t)util_iround(CLAMP(value->float32[3], 0.0f, 1.0f) * 0xffff)) << 16;
959 break;
960 case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
961 clear_vals[0] = ((uint16_t)util_iround(CLAMP(value->float32[0], 0.0f, 1.0f) * 0x3ff)) & 0x3ff;
962 clear_vals[0] |= (((uint16_t)util_iround(CLAMP(value->float32[1], 0.0f, 1.0f) * 0x3ff)) & 0x3ff) << 10;
963 clear_vals[0] |= (((uint16_t)util_iround(CLAMP(value->float32[2], 0.0f, 1.0f) * 0x3ff)) & 0x3ff) << 20;
964 clear_vals[0] |= (((uint16_t)util_iround(CLAMP(value->float32[3], 0.0f, 1.0f) * 0x3)) & 0x3) << 30;
965 clear_vals[1] = 0;
966 return true;
967 case VK_FORMAT_R32G32_SFLOAT:
968 clear_vals[0] = fui(value->float32[0]);
969 clear_vals[1] = fui(value->float32[1]);
970 break;
971 case VK_FORMAT_R32_SFLOAT:
972 clear_vals[1] = 0;
973 clear_vals[0] = fui(value->float32[0]);
974 break;
975 case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
976 clear_vals[0] = float3_to_r11g11b10f(value->float32);
977 clear_vals[1] = 0;
978 break;
979 default:
980 fprintf(stderr, "failed to fast clear %d\n", format);
981 return false;
982 }
983 return true;
984 }
985
986 void radv_GetPhysicalDeviceFormatProperties(
987 VkPhysicalDevice physicalDevice,
988 VkFormat format,
989 VkFormatProperties* pFormatProperties)
990 {
991 RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
992
993 radv_physical_device_get_format_properties(physical_device,
994 format,
995 pFormatProperties);
996 }
997
998 void radv_GetPhysicalDeviceFormatProperties2KHR(
999 VkPhysicalDevice physicalDevice,
1000 VkFormat format,
1001 VkFormatProperties2KHR* pFormatProperties)
1002 {
1003 RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
1004
1005 radv_physical_device_get_format_properties(physical_device,
1006 format,
1007 &pFormatProperties->formatProperties);
1008 }
1009
1010 static VkResult radv_get_image_format_properties(struct radv_physical_device *physical_device,
1011 const VkPhysicalDeviceImageFormatInfo2KHR *info,
1012 VkImageFormatProperties *pImageFormatProperties)
1013
1014 {
1015 VkFormatProperties format_props;
1016 VkFormatFeatureFlags format_feature_flags;
1017 VkExtent3D maxExtent;
1018 uint32_t maxMipLevels;
1019 uint32_t maxArraySize;
1020 VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT;
1021
1022 radv_physical_device_get_format_properties(physical_device, info->format,
1023 &format_props);
1024 if (info->tiling == VK_IMAGE_TILING_LINEAR) {
1025 format_feature_flags = format_props.linearTilingFeatures;
1026 } else if (info->tiling == VK_IMAGE_TILING_OPTIMAL) {
1027 format_feature_flags = format_props.optimalTilingFeatures;
1028 } else {
1029 unreachable("bad VkImageTiling");
1030 }
1031
1032 if (format_feature_flags == 0)
1033 goto unsupported;
1034
1035 switch (info->type) {
1036 default:
1037 unreachable("bad vkimage type\n");
1038 case VK_IMAGE_TYPE_1D:
1039 maxExtent.width = 16384;
1040 maxExtent.height = 1;
1041 maxExtent.depth = 1;
1042 maxMipLevels = 15; /* log2(maxWidth) + 1 */
1043 maxArraySize = 2048;
1044 break;
1045 case VK_IMAGE_TYPE_2D:
1046 maxExtent.width = 16384;
1047 maxExtent.height = 16384;
1048 maxExtent.depth = 1;
1049 maxMipLevels = 15; /* log2(maxWidth) + 1 */
1050 maxArraySize = 2048;
1051 break;
1052 case VK_IMAGE_TYPE_3D:
1053 maxExtent.width = 2048;
1054 maxExtent.height = 2048;
1055 maxExtent.depth = 2048;
1056 maxMipLevels = 12; /* log2(maxWidth) + 1 */
1057 maxArraySize = 1;
1058 break;
1059 }
1060
1061 if (info->tiling == VK_IMAGE_TILING_OPTIMAL &&
1062 info->type == VK_IMAGE_TYPE_2D &&
1063 (format_feature_flags & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
1064 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) &&
1065 !(info->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) &&
1066 !(info->usage & VK_IMAGE_USAGE_STORAGE_BIT)) {
1067 sampleCounts |= VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT | VK_SAMPLE_COUNT_8_BIT;
1068 }
1069
1070 if (info->usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
1071 if (!(format_feature_flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
1072 goto unsupported;
1073 }
1074 }
1075
1076 if (info->usage & VK_IMAGE_USAGE_STORAGE_BIT) {
1077 if (!(format_feature_flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) {
1078 goto unsupported;
1079 }
1080 }
1081
1082 if (info->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
1083 if (!(format_feature_flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
1084 goto unsupported;
1085 }
1086 }
1087
1088 if (info->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
1089 if (!(format_feature_flags & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
1090 goto unsupported;
1091 }
1092 }
1093
1094 *pImageFormatProperties = (VkImageFormatProperties) {
1095 .maxExtent = maxExtent,
1096 .maxMipLevels = maxMipLevels,
1097 .maxArrayLayers = maxArraySize,
1098 .sampleCounts = sampleCounts,
1099
1100 /* FINISHME: Accurately calculate
1101 * VkImageFormatProperties::maxResourceSize.
1102 */
1103 .maxResourceSize = UINT32_MAX,
1104 };
1105
1106 return VK_SUCCESS;
1107 unsupported:
1108 *pImageFormatProperties = (VkImageFormatProperties) {
1109 .maxExtent = { 0, 0, 0 },
1110 .maxMipLevels = 0,
1111 .maxArrayLayers = 0,
1112 .sampleCounts = 0,
1113 .maxResourceSize = 0,
1114 };
1115
1116 return VK_ERROR_FORMAT_NOT_SUPPORTED;
1117 }
1118
1119 VkResult radv_GetPhysicalDeviceImageFormatProperties(
1120 VkPhysicalDevice physicalDevice,
1121 VkFormat format,
1122 VkImageType type,
1123 VkImageTiling tiling,
1124 VkImageUsageFlags usage,
1125 VkImageCreateFlags createFlags,
1126 VkImageFormatProperties* pImageFormatProperties)
1127 {
1128 RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
1129
1130 const VkPhysicalDeviceImageFormatInfo2KHR info = {
1131 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
1132 .pNext = NULL,
1133 .format = format,
1134 .type = type,
1135 .tiling = tiling,
1136 .usage = usage,
1137 .flags = createFlags,
1138 };
1139
1140 return radv_get_image_format_properties(physical_device, &info,
1141 pImageFormatProperties);
1142 }
1143
1144 static void
1145 get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo,
1146 VkExternalMemoryPropertiesKHX *external_properties)
1147 {
1148 VkExternalMemoryFeatureFlagBitsKHX flags = 0;
1149 VkExternalMemoryHandleTypeFlagsKHX export_flags = 0;
1150 VkExternalMemoryHandleTypeFlagsKHX compat_flags = 0;
1151 switch (pImageFormatInfo->type) {
1152 case VK_IMAGE_TYPE_2D:
1153 flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX;
1154 compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX;
1155 break;
1156 default:
1157 break;
1158 }
1159
1160 *external_properties = (VkExternalMemoryPropertiesKHX) {
1161 .externalMemoryFeatures = flags,
1162 .exportFromImportedHandleTypes = export_flags,
1163 .compatibleHandleTypes = compat_flags,
1164 };
1165 }
1166
1167 VkResult radv_GetPhysicalDeviceImageFormatProperties2KHR(
1168 VkPhysicalDevice physicalDevice,
1169 const VkPhysicalDeviceImageFormatInfo2KHR *base_info,
1170 VkImageFormatProperties2KHR *base_props)
1171 {
1172 RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
1173 const VkPhysicalDeviceExternalImageFormatInfoKHX *external_info = NULL;
1174 VkExternalImageFormatPropertiesKHX *external_props = NULL;
1175 VkResult result;
1176
1177 result = radv_get_image_format_properties(physical_device, base_info,
1178 &base_props->imageFormatProperties);
1179 if (result != VK_SUCCESS)
1180 return result;
1181
1182 /* Extract input structs */
1183 vk_foreach_struct_const(s, base_info->pNext) {
1184 switch (s->sType) {
1185 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHX:
1186 external_info = (const void *) s;
1187 break;
1188 default:
1189 break;
1190 }
1191 }
1192
1193 /* Extract output structs */
1194 vk_foreach_struct(s, base_props->pNext) {
1195 switch (s->sType) {
1196 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHX:
1197 external_props = (void *) s;
1198 break;
1199 default:
1200 break;
1201 }
1202 }
1203
1204 /* From the Vulkan 1.0.42 spec:
1205 *
1206 * If handleType is 0, vkGetPhysicalDeviceImageFormatProperties2KHR will
1207 * behave as if VkPhysicalDeviceExternalImageFormatInfoKHX was not
1208 * present and VkExternalImageFormatPropertiesKHX will be ignored.
1209 */
1210 if (external_info && external_info->handleType != 0) {
1211 switch (external_info->handleType) {
1212 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX:
1213 get_external_image_format_properties(base_info, &external_props->externalMemoryProperties);
1214 break;
1215 default:
1216 /* From the Vulkan 1.0.42 spec:
1217 *
1218 * If handleType is not compatible with the [parameters] specified
1219 * in VkPhysicalDeviceImageFormatInfo2KHR, then
1220 * vkGetPhysicalDeviceImageFormatProperties2KHR returns
1221 * VK_ERROR_FORMAT_NOT_SUPPORTED.
1222 */
1223 result = vk_errorf(VK_ERROR_FORMAT_NOT_SUPPORTED,
1224 "unsupported VkExternalMemoryTypeFlagBitsKHX 0x%x",
1225 external_info->handleType);
1226 goto fail;
1227 }
1228 }
1229
1230 return VK_SUCCESS;
1231
1232 fail:
1233 if (result == VK_ERROR_FORMAT_NOT_SUPPORTED) {
1234 /* From the Vulkan 1.0.42 spec:
1235 *
1236 * If the combination of parameters to
1237 * vkGetPhysicalDeviceImageFormatProperties2KHR is not supported by
1238 * the implementation for use in vkCreateImage, then all members of
1239 * imageFormatProperties will be filled with zero.
1240 */
1241 base_props->imageFormatProperties = (VkImageFormatProperties) {0};
1242 }
1243
1244 return result;
1245 }
1246
1247 void radv_GetPhysicalDeviceSparseImageFormatProperties(
1248 VkPhysicalDevice physicalDevice,
1249 VkFormat format,
1250 VkImageType type,
1251 uint32_t samples,
1252 VkImageUsageFlags usage,
1253 VkImageTiling tiling,
1254 uint32_t* pNumProperties,
1255 VkSparseImageFormatProperties* pProperties)
1256 {
1257 /* Sparse images are not yet supported. */
1258 *pNumProperties = 0;
1259 }
1260
1261 void radv_GetPhysicalDeviceSparseImageFormatProperties2KHR(
1262 VkPhysicalDevice physicalDevice,
1263 const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo,
1264 uint32_t *pPropertyCount,
1265 VkSparseImageFormatProperties2KHR* pProperties)
1266 {
1267 /* Sparse images are not yet supported. */
1268 *pPropertyCount = 0;
1269 }
1270
1271 void radv_GetPhysicalDeviceExternalBufferPropertiesKHX(
1272 VkPhysicalDevice physicalDevice,
1273 const VkPhysicalDeviceExternalBufferInfoKHX *pExternalBufferInfo,
1274 VkExternalBufferPropertiesKHX *pExternalBufferProperties)
1275 {
1276 VkExternalMemoryFeatureFlagBitsKHX flags = 0;
1277 VkExternalMemoryHandleTypeFlagsKHX export_flags = 0;
1278 VkExternalMemoryHandleTypeFlagsKHX compat_flags = 0;
1279 switch(pExternalBufferInfo->handleType) {
1280 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX:
1281 flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHX |
1282 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHX |
1283 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHX;
1284 compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHX;
1285 break;
1286 default:
1287 break;
1288 }
1289 pExternalBufferProperties->externalMemoryProperties = (VkExternalMemoryPropertiesKHX) {
1290 .externalMemoryFeatures = flags,
1291 .exportFromImportedHandleTypes = export_flags,
1292 .compatibleHandleTypes = compat_flags,
1293 };
1294 }