projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
radv: remove a few more unnecessary KHR suffixes
[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
30 #include "vk_util.h"
31
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 (desc->layout == VK_FORMAT_LAYOUT_ETC) {
228 switch (format) {
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;
244 default:
245 break;
246 }
247 }
248
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;
253 }
254
255 /* R8G8Bx_SNORM - TODO CxV8U8 */
256
257 /* hw cannot support mixed formats (except depth/stencil, since only
258 * depth is read).*/
259 if (desc->is_mixed && desc->colorspace != VK_FORMAT_COLORSPACE_ZS)
260 goto out_unknown;
261
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;
265 }
266
267 /* Non-uniform formats. */
268 if (!uniform) {
269 switch(desc->nr_channels) {
270 case 3:
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;
275 }
276 goto out_unknown;
277 case 4:
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;
283 }
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;
289 }
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)
297 goto out_unknown;
298 return V_008F14_IMG_DATA_FORMAT_2_10_10_10;
299 }
300 goto out_unknown;
301 }
302 goto out_unknown;
303 }
304
305 if (first_non_void < 0 || first_non_void > 3)
306 goto out_unknown;
307
308 /* uniform formats */
309 switch (desc->channel[first_non_void].size) {
310 case 4:
311 switch (desc->nr_channels) {
312 #if 0 /* Not supported for render targets */
313 case 2:
314 return V_008F14_IMG_DATA_FORMAT_4_4;
315 #endif
316 case 4:
317 return V_008F14_IMG_DATA_FORMAT_4_4_4_4;
318 }
319 break;
320 case 8:
321 switch (desc->nr_channels) {
322 case 1:
323 return V_008F14_IMG_DATA_FORMAT_8;
324 case 2:
325 return V_008F14_IMG_DATA_FORMAT_8_8;
326 case 4:
327 return V_008F14_IMG_DATA_FORMAT_8_8_8_8;
328 }
329 break;
330 case 16:
331 switch (desc->nr_channels) {
332 case 1:
333 return V_008F14_IMG_DATA_FORMAT_16;
334 case 2:
335 return V_008F14_IMG_DATA_FORMAT_16_16;
336 case 4:
337 return V_008F14_IMG_DATA_FORMAT_16_16_16_16;
338 }
339 break;
340 case 32:
341 switch (desc->nr_channels) {
342 case 1:
343 return V_008F14_IMG_DATA_FORMAT_32;
344 case 2:
345 return V_008F14_IMG_DATA_FORMAT_32_32;
346 case 3:
347 return V_008F14_IMG_DATA_FORMAT_32_32_32;
348 case 4:
349 return V_008F14_IMG_DATA_FORMAT_32_32_32_32;
350 }
351 }
352
353 out_unknown:
354 /* R600_ERR("Unable to handle texformat %d %s\n", format, vk_format_name(format)); */
355 return ~0;
356 }
357
358 uint32_t radv_translate_tex_numformat(VkFormat format,
359 const struct vk_format_description *desc,
360 int first_non_void)
361 {
362 switch (format) {
363 case VK_FORMAT_D24_UNORM_S8_UINT:
364 return V_008F14_IMG_NUM_FORMAT_UNORM;
365 default:
366 if (first_non_void < 0) {
367 if (vk_format_is_compressed(format)) {
368 switch (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;
384 default:
385 return V_008F14_IMG_NUM_FORMAT_UNORM;
386 }
387 } else if (desc->layout == VK_FORMAT_LAYOUT_SUBSAMPLED) {
388 return V_008F14_IMG_NUM_FORMAT_UNORM;
389 } else {
390 return V_008F14_IMG_NUM_FORMAT_FLOAT;
391 }
392 } else if (desc->colorspace == VK_FORMAT_COLORSPACE_SRGB) {
393 return V_008F14_IMG_NUM_FORMAT_SRGB;
394 } else {
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;
403 else
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;
410 else
411 return V_008F14_IMG_NUM_FORMAT_USCALED;
412 default:
413 return V_008F14_IMG_NUM_FORMAT_UNORM;
414 }
415 }
416 }
417 }
418
419 uint32_t radv_translate_color_numformat(VkFormat format,
420 const struct vk_format_description *desc,
421 int first_non_void)
422 {
423 unsigned ntype;
424 if (first_non_void == -1 || desc->channel[first_non_void].type == VK_FORMAT_TYPE_FLOAT)
425 ntype = V_028C70_NUMBER_FLOAT;
426 else {
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;
435 } else
436 ntype = ~0u;
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;
442 } else
443 ntype = ~0u;
444 }
445 }
446 return ntype;
447 }
448
449 static bool radv_is_sampler_format_supported(VkFormat format, bool *linear_sampling)
450 {
451 const struct vk_format_description *desc = vk_format_description(format);
452 uint32_t num_format;
453 if (!desc || format == VK_FORMAT_UNDEFINED)
454 return false;
455 num_format = radv_translate_tex_numformat(format, desc,
456 vk_format_get_first_non_void_channel(format));
457
458 if (num_format == V_008F14_IMG_NUM_FORMAT_USCALED ||
459 num_format == V_008F14_IMG_NUM_FORMAT_SSCALED)
460 return false;
461
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;
467 else
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;
471 }
472
473
474 static bool radv_is_storage_image_format_supported(struct radv_physical_device *physical_device,
475 VkFormat format)
476 {
477 const struct vk_format_description *desc = vk_format_description(format);
478 unsigned data_format, num_format;
479 if (!desc || format == VK_FORMAT_UNDEFINED)
480 return false;
481
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));
486
487 if(data_format == ~0 || num_format == ~0)
488 return false;
489
490 /* Extracted from the GCN3 ISA document. */
491 switch(num_format) {
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:
497 break;
498 default:
499 return false;
500 }
501
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. */
521 return true;
522 default:
523 return false;
524 }
525 }
526
527 static bool radv_is_buffer_format_supported(VkFormat format, bool *scaled)
528 {
529 const struct vk_format_description *desc = vk_format_description(format);
530 unsigned data_format, num_format;
531 if (!desc || format == VK_FORMAT_UNDEFINED)
532 return false;
533
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));
538
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 &&
541 num_format != ~0;
542 }
543
544 bool radv_is_colorbuffer_format_supported(VkFormat format, bool *blendable)
545 {
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,
550 desc,
551 vk_format_get_first_non_void_channel(format));
552
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) {
556 *blendable = false;
557 } else
558 *blendable = true;
559 return color_format != V_028C70_COLOR_INVALID &&
560 color_swap != ~0U &&
561 color_num_format != ~0;
562 }
563
564 static bool radv_is_zs_format_supported(VkFormat format)
565 {
566 return radv_translate_dbformat(format) != V_028040_Z_INVALID || format == VK_FORMAT_S8_UINT;
567 }
568
569 static bool radv_is_filter_minmax_format_supported(VkFormat format)
570 {
571 /* From the Vulkan spec 1.1.71:
572 *
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."
577 */
578 /* TODO: enable more formats. */
579 switch (format) {
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:
592 return true;
593 default:
594 return false;
595 }
596 }
597
598 static void
599 radv_physical_device_get_format_properties(struct radv_physical_device *physical_device,
600 VkFormat format,
601 VkFormatProperties *out_properties)
602 {
603 VkFormatFeatureFlags linear = 0, tiled = 0, buffer = 0;
604 const struct vk_format_description *desc = vk_format_description(format);
605 bool blendable;
606 bool scaled = false;
607 if (!desc) {
608 out_properties->linearTilingFeatures = linear;
609 out_properties->optimalTilingFeatures = tiled;
610 out_properties->bufferFeatures = buffer;
611 return;
612 }
613
614 if (desc->layout == VK_FORMAT_LAYOUT_ETC &&
615 physical_device->rad_info.family != CHIP_VEGA10 &&
616 physical_device->rad_info.family != CHIP_RAVEN &&
617 physical_device->rad_info.family != CHIP_STONEY) {
618 out_properties->linearTilingFeatures = linear;
619 out_properties->optimalTilingFeatures = tiled;
620 out_properties->bufferFeatures = buffer;
621 return;
622 }
623
624 if (radv_is_storage_image_format_supported(physical_device, format)) {
625 tiled |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
626 linear |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
627 }
628
629 if (radv_is_buffer_format_supported(format, &scaled)) {
630 buffer |= VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
631 if (!scaled)
632 buffer |= VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT |
633 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
634 }
635
636 if (vk_format_is_depth_or_stencil(format)) {
637 if (radv_is_zs_format_supported(format)) {
638 tiled |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
639 tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
640 tiled |= VK_FORMAT_FEATURE_BLIT_SRC_BIT |
641 VK_FORMAT_FEATURE_BLIT_DST_BIT;
642 tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
643 VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
644
645 if (radv_is_filter_minmax_format_supported(format))
646 tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
647
648 /* Don't support blitting surfaces with depth/stencil. */
649 if (vk_format_is_depth(format) && vk_format_is_stencil(format))
650 tiled &= ~VK_FORMAT_FEATURE_BLIT_DST_BIT;
651
652 /* Don't support linear depth surfaces */
653 linear = 0;
654 }
655 } else {
656 bool linear_sampling;
657 if (radv_is_sampler_format_supported(format, &linear_sampling)) {
658 linear |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
659 VK_FORMAT_FEATURE_BLIT_SRC_BIT;
660 tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
661 VK_FORMAT_FEATURE_BLIT_SRC_BIT;
662
663 if (radv_is_filter_minmax_format_supported(format))
664 tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT;
665
666 if (linear_sampling) {
667 linear |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
668 tiled |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
669 }
670
671 /* Don't support blitting for R32G32B32 formats. */
672 if (format == VK_FORMAT_R32G32B32_SFLOAT ||
673 format == VK_FORMAT_R32G32B32_UINT ||
674 format == VK_FORMAT_R32G32B32_SINT) {
675 linear &= ~VK_FORMAT_FEATURE_BLIT_SRC_BIT;
676 }
677 }
678 if (radv_is_colorbuffer_format_supported(format, &blendable)) {
679 linear |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
680 tiled |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_BLIT_DST_BIT;
681 if (blendable) {
682 linear |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
683 tiled |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
684 }
685 }
686 if (tiled && !scaled) {
687 tiled |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
688 VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
689 }
690
691 /* Tiled formatting does not support NPOT pixel sizes */
692 if (!util_is_power_of_two_or_zero(vk_format_get_blocksize(format)))
693 tiled = 0;
694 }
695
696 if (linear && !scaled) {
697 linear |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
698 VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
699 }
700
701 if (format == VK_FORMAT_R32_UINT || format == VK_FORMAT_R32_SINT) {
702 buffer |= VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
703 linear |= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT;
704 tiled |= VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT;
705 }
706
707 switch(format) {
708 case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
709 case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
710 case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
711 case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
712 case VK_FORMAT_A2R10G10B10_SINT_PACK32:
713 case VK_FORMAT_A2B10G10R10_SINT_PACK32:
714 if (physical_device->rad_info.chip_class <= VI &&
715 physical_device->rad_info.family != CHIP_STONEY) {
716 buffer &= ~(VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT |
717 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT);
718 linear = 0;
719 tiled = 0;
720 }
721 break;
722 default:
723 break;
724 }
725
726 out_properties->linearTilingFeatures = linear;
727 out_properties->optimalTilingFeatures = tiled;
728 out_properties->bufferFeatures = buffer;
729 }
730
731 uint32_t radv_translate_colorformat(VkFormat format)
732 {
733 const struct vk_format_description *desc = vk_format_description(format);
734
735 #define HAS_SIZE(x,y,z,w) \
736 (desc->channel[0].size == (x) && desc->channel[1].size == (y) && \
737 desc->channel[2].size == (z) && desc->channel[3].size == (w))
738
739 if (format == VK_FORMAT_B10G11R11_UFLOAT_PACK32) /* isn't plain */
740 return V_028C70_COLOR_10_11_11;
741
742 if (desc->layout != VK_FORMAT_LAYOUT_PLAIN)
743 return V_028C70_COLOR_INVALID;
744
745 /* hw cannot support mixed formats (except depth/stencil, since
746 * stencil is not written to). */
747 if (desc->is_mixed && desc->colorspace != VK_FORMAT_COLORSPACE_ZS)
748 return V_028C70_COLOR_INVALID;
749
750 switch (desc->nr_channels) {
751 case 1:
752 switch (desc->channel[0].size) {
753 case 8:
754 return V_028C70_COLOR_8;
755 case 16:
756 return V_028C70_COLOR_16;
757 case 32:
758 return V_028C70_COLOR_32;
759 }
760 break;
761 case 2:
762 if (desc->channel[0].size == desc->channel[1].size) {
763 switch (desc->channel[0].size) {
764 case 8:
765 return V_028C70_COLOR_8_8;
766 case 16:
767 return V_028C70_COLOR_16_16;
768 case 32:
769 return V_028C70_COLOR_32_32;
770 }
771 } else if (HAS_SIZE(8,24,0,0)) {
772 return V_028C70_COLOR_24_8;
773 } else if (HAS_SIZE(24,8,0,0)) {
774 return V_028C70_COLOR_8_24;
775 }
776 break;
777 case 3:
778 if (HAS_SIZE(5,6,5,0)) {
779 return V_028C70_COLOR_5_6_5;
780 } else if (HAS_SIZE(32,8,24,0)) {
781 return V_028C70_COLOR_X24_8_32_FLOAT;
782 }
783 break;
784 case 4:
785 if (desc->channel[0].size == desc->channel[1].size &&
786 desc->channel[0].size == desc->channel[2].size &&
787 desc->channel[0].size == desc->channel[3].size) {
788 switch (desc->channel[0].size) {
789 case 4:
790 return V_028C70_COLOR_4_4_4_4;
791 case 8:
792 return V_028C70_COLOR_8_8_8_8;
793 case 16:
794 return V_028C70_COLOR_16_16_16_16;
795 case 32:
796 return V_028C70_COLOR_32_32_32_32;
797 }
798 } else if (HAS_SIZE(5,5,5,1)) {
799 return V_028C70_COLOR_1_5_5_5;
800 } else if (HAS_SIZE(1,5,5,5)) {
801 return V_028C70_COLOR_5_5_5_1;
802 } else if (HAS_SIZE(10,10,10,2)) {
803 return V_028C70_COLOR_2_10_10_10;
804 }
805 break;
806 }
807 return V_028C70_COLOR_INVALID;
808 }
809
810 uint32_t radv_colorformat_endian_swap(uint32_t colorformat)
811 {
812 if (0/*SI_BIG_ENDIAN*/) {
813 switch(colorformat) {
814 /* 8-bit buffers. */
815 case V_028C70_COLOR_8:
816 return V_028C70_ENDIAN_NONE;
817
818 /* 16-bit buffers. */
819 case V_028C70_COLOR_5_6_5:
820 case V_028C70_COLOR_1_5_5_5:
821 case V_028C70_COLOR_4_4_4_4:
822 case V_028C70_COLOR_16:
823 case V_028C70_COLOR_8_8:
824 return V_028C70_ENDIAN_8IN16;
825
826 /* 32-bit buffers. */
827 case V_028C70_COLOR_8_8_8_8:
828 case V_028C70_COLOR_2_10_10_10:
829 case V_028C70_COLOR_8_24:
830 case V_028C70_COLOR_24_8:
831 case V_028C70_COLOR_16_16:
832 return V_028C70_ENDIAN_8IN32;
833
834 /* 64-bit buffers. */
835 case V_028C70_COLOR_16_16_16_16:
836 return V_028C70_ENDIAN_8IN16;
837
838 case V_028C70_COLOR_32_32:
839 return V_028C70_ENDIAN_8IN32;
840
841 /* 128-bit buffers. */
842 case V_028C70_COLOR_32_32_32_32:
843 return V_028C70_ENDIAN_8IN32;
844 default:
845 return V_028C70_ENDIAN_NONE; /* Unsupported. */
846 }
847 } else {
848 return V_028C70_ENDIAN_NONE;
849 }
850 }
851
852 uint32_t radv_translate_dbformat(VkFormat format)
853 {
854 switch (format) {
855 case VK_FORMAT_D16_UNORM:
856 case VK_FORMAT_D16_UNORM_S8_UINT:
857 return V_028040_Z_16;
858 case VK_FORMAT_D32_SFLOAT:
859 case VK_FORMAT_D32_SFLOAT_S8_UINT:
860 return V_028040_Z_32_FLOAT;
861 default:
862 return V_028040_Z_INVALID;
863 }
864 }
865
866 unsigned radv_translate_colorswap(VkFormat format, bool do_endian_swap)
867 {
868 const struct vk_format_description *desc = vk_format_description(format);
869
870 #define HAS_SWIZZLE(chan,swz) (desc->swizzle[chan] == VK_SWIZZLE_##swz)
871
872 if (format == VK_FORMAT_B10G11R11_UFLOAT_PACK32)
873 return V_028C70_SWAP_STD;
874
875 if (desc->layout != VK_FORMAT_LAYOUT_PLAIN)
876 return ~0U;
877
878 switch (desc->nr_channels) {
879 case 1:
880 if (HAS_SWIZZLE(0,X))
881 return V_028C70_SWAP_STD; /* X___ */
882 else if (HAS_SWIZZLE(3,X))
883 return V_028C70_SWAP_ALT_REV; /* ___X */
884 break;
885 case 2:
886 if ((HAS_SWIZZLE(0,X) && HAS_SWIZZLE(1,Y)) ||
887 (HAS_SWIZZLE(0,X) && HAS_SWIZZLE(1,NONE)) ||
888 (HAS_SWIZZLE(0,NONE) && HAS_SWIZZLE(1,Y)))
889 return V_028C70_SWAP_STD; /* XY__ */
890 else if ((HAS_SWIZZLE(0,Y) && HAS_SWIZZLE(1,X)) ||
891 (HAS_SWIZZLE(0,Y) && HAS_SWIZZLE(1,NONE)) ||
892 (HAS_SWIZZLE(0,NONE) && HAS_SWIZZLE(1,X)))
893 /* YX__ */
894 return (do_endian_swap ? V_028C70_SWAP_STD : V_028C70_SWAP_STD_REV);
895 else if (HAS_SWIZZLE(0,X) && HAS_SWIZZLE(3,Y))
896 return V_028C70_SWAP_ALT; /* X__Y */
897 else if (HAS_SWIZZLE(0,Y) && HAS_SWIZZLE(3,X))
898 return V_028C70_SWAP_ALT_REV; /* Y__X */
899 break;
900 case 3:
901 if (HAS_SWIZZLE(0,X))
902 return (do_endian_swap ? V_028C70_SWAP_STD_REV : V_028C70_SWAP_STD);
903 else if (HAS_SWIZZLE(0,Z))
904 return V_028C70_SWAP_STD_REV; /* ZYX */
905 break;
906 case 4:
907 /* check the middle channels, the 1st and 4th channel can be NONE */
908 if (HAS_SWIZZLE(1,Y) && HAS_SWIZZLE(2,Z)) {
909 return V_028C70_SWAP_STD; /* XYZW */
910 } else if (HAS_SWIZZLE(1,Z) && HAS_SWIZZLE(2,Y)) {
911 return V_028C70_SWAP_STD_REV; /* WZYX */
912 } else if (HAS_SWIZZLE(1,Y) && HAS_SWIZZLE(2,X)) {
913 return V_028C70_SWAP_ALT; /* ZYXW */
914 } else if (HAS_SWIZZLE(1,Z) && HAS_SWIZZLE(2,W)) {
915 /* YZWX */
916 if (desc->is_array)
917 return V_028C70_SWAP_ALT_REV;
918 else
919 return (do_endian_swap ? V_028C70_SWAP_ALT : V_028C70_SWAP_ALT_REV);
920 }
921 break;
922 }
923 return ~0U;
924 }
925
926 bool radv_format_pack_clear_color(VkFormat format,
927 uint32_t clear_vals[2],
928 VkClearColorValue *value)
929 {
930 const struct vk_format_description *desc = vk_format_description(format);
931
932 if (format == VK_FORMAT_B10G11R11_UFLOAT_PACK32) {
933 clear_vals[0] = float3_to_r11g11b10f(value->float32);
934 clear_vals[1] = 0;
935 return true;
936 }
937
938 if (desc->layout != VK_FORMAT_LAYOUT_PLAIN) {
939 fprintf(stderr, "failed to fast clear for non-plain format %d\n", format);
940 return false;
941 }
942
943 if (!util_is_power_of_two_or_zero(desc->block.bits)) {
944 fprintf(stderr, "failed to fast clear for NPOT format %d\n", format);
945 return false;
946 }
947
948 if (desc->block.bits > 64) {
949 /*
950 * We have a 128 bits format, check if the first 3 components are the same.
951 * Every elements has to be 32 bits since we don't support 64-bit formats,
952 * and we can skip swizzling checks as alpha always comes last for these and
953 * we do not care about the rest as they have to be the same.
954 */
955 if (desc->channel[0].type == VK_FORMAT_TYPE_FLOAT) {
956 if (value->float32[0] != value->float32[1] ||
957 value->float32[0] != value->float32[2])
958 return false;
959 } else {
960 if (value->uint32[0] != value->uint32[1] ||
961 value->uint32[0] != value->uint32[2])
962 return false;
963 }
964 clear_vals[0] = value->uint32[0];
965 clear_vals[1] = value->uint32[3];
966 return true;
967 }
968 uint64_t clear_val = 0;
969
970 for (unsigned c = 0; c < 4; ++c) {
971 if (desc->swizzle[c] >= 4)
972 continue;
973
974 const struct vk_format_channel_description *channel = &desc->channel[desc->swizzle[c]];
975 assert(channel->size);
976
977 uint64_t v = 0;
978 if (channel->pure_integer) {
979 v = value->uint32[c] & ((1ULL << channel->size) - 1);
980 } else if (channel->normalized) {
981 if (channel->type == VK_FORMAT_TYPE_UNSIGNED &&
982 desc->swizzle[c] < 3 &&
983 desc->colorspace == VK_FORMAT_COLORSPACE_SRGB) {
984 assert(channel->size == 8);
985
986 v = util_format_linear_float_to_srgb_8unorm(value->float32[c]);
987 } else if (channel->type == VK_FORMAT_TYPE_UNSIGNED) {
988 v = MAX2(MIN2(value->float32[c], 1.0f), 0.0f) * ((1ULL << channel->size) - 1);
989 } else {
990 v = MAX2(MIN2(value->float32[c], 1.0f), -1.0f) * ((1ULL << (channel->size - 1)) - 1);
991 }
992 } else if (channel->type == VK_FORMAT_TYPE_FLOAT) {
993 if (channel->size == 32) {
994 memcpy(&v, &value->float32[c], 4);
995 } else if(channel->size == 16) {
996 v = util_float_to_half(value->float32[c]);
997 } else {
998 fprintf(stderr, "failed to fast clear for unhandled float size in format %d\n", format);
999 return false;
1000 }
1001 } else {
1002 fprintf(stderr, "failed to fast clear for unhandled component type in format %d\n", format);
1003 return false;
1004 }
1005 clear_val |= (v & ((1ULL << channel->size) - 1)) << channel->shift;
1006 }
1007
1008 clear_vals[0] = clear_val;
1009 clear_vals[1] = clear_val >> 32;
1010
1011 return true;
1012 }
1013
1014 void radv_GetPhysicalDeviceFormatProperties(
1015 VkPhysicalDevice physicalDevice,
1016 VkFormat format,
1017 VkFormatProperties* pFormatProperties)
1018 {
1019 RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
1020
1021 radv_physical_device_get_format_properties(physical_device,
1022 format,
1023 pFormatProperties);
1024 }
1025
1026 void radv_GetPhysicalDeviceFormatProperties2(
1027 VkPhysicalDevice physicalDevice,
1028 VkFormat format,
1029 VkFormatProperties2* pFormatProperties)
1030 {
1031 RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
1032
1033 radv_physical_device_get_format_properties(physical_device,
1034 format,
1035 &pFormatProperties->formatProperties);
1036 }
1037
1038 static VkResult radv_get_image_format_properties(struct radv_physical_device *physical_device,
1039 const VkPhysicalDeviceImageFormatInfo2 *info,
1040 VkImageFormatProperties *pImageFormatProperties)
1041
1042 {
1043 VkFormatProperties format_props;
1044 VkFormatFeatureFlags format_feature_flags;
1045 VkExtent3D maxExtent;
1046 uint32_t maxMipLevels;
1047 uint32_t maxArraySize;
1048 VkSampleCountFlags sampleCounts = VK_SAMPLE_COUNT_1_BIT;
1049
1050 radv_physical_device_get_format_properties(physical_device, info->format,
1051 &format_props);
1052 if (info->tiling == VK_IMAGE_TILING_LINEAR) {
1053 format_feature_flags = format_props.linearTilingFeatures;
1054 } else if (info->tiling == VK_IMAGE_TILING_OPTIMAL) {
1055 format_feature_flags = format_props.optimalTilingFeatures;
1056 } else {
1057 unreachable("bad VkImageTiling");
1058 }
1059
1060 if (format_feature_flags == 0)
1061 goto unsupported;
1062
1063 if (info->type != VK_IMAGE_TYPE_2D && vk_format_is_depth_or_stencil(info->format))
1064 goto unsupported;
1065
1066 switch (info->type) {
1067 default:
1068 unreachable("bad vkimage type\n");
1069 case VK_IMAGE_TYPE_1D:
1070 maxExtent.width = 16384;
1071 maxExtent.height = 1;
1072 maxExtent.depth = 1;
1073 maxMipLevels = 15; /* log2(maxWidth) + 1 */
1074 maxArraySize = 2048;
1075 break;
1076 case VK_IMAGE_TYPE_2D:
1077 maxExtent.width = 16384;
1078 maxExtent.height = 16384;
1079 maxExtent.depth = 1;
1080 maxMipLevels = 15; /* log2(maxWidth) + 1 */
1081 maxArraySize = 2048;
1082 break;
1083 case VK_IMAGE_TYPE_3D:
1084 maxExtent.width = 2048;
1085 maxExtent.height = 2048;
1086 maxExtent.depth = 2048;
1087 maxMipLevels = 12; /* log2(maxWidth) + 1 */
1088 maxArraySize = 1;
1089 break;
1090 }
1091
1092 if (info->tiling == VK_IMAGE_TILING_OPTIMAL &&
1093 info->type == VK_IMAGE_TYPE_2D &&
1094 (format_feature_flags & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
1095 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) &&
1096 !(info->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)) {
1097 sampleCounts |= VK_SAMPLE_COUNT_2_BIT | VK_SAMPLE_COUNT_4_BIT | VK_SAMPLE_COUNT_8_BIT;
1098 }
1099
1100 if (info->tiling == VK_IMAGE_TILING_LINEAR &&
1101 (info->format == VK_FORMAT_R32G32B32_SFLOAT ||
1102 info->format == VK_FORMAT_R32G32B32_SINT ||
1103 info->format == VK_FORMAT_R32G32B32_UINT)) {
1104 /* R32G32B32 is a weird format and the driver currently only
1105 * supports the barely minimum.
1106 * TODO: Implement more if we really need to.
1107 */
1108 if (info->type == VK_IMAGE_TYPE_3D)
1109 goto unsupported;
1110 maxArraySize = 1;
1111 maxMipLevels = 1;
1112 }
1113
1114
1115 /* We can't create 3d compressed 128bpp images that can be rendered to on GFX9 */
1116 if (physical_device->rad_info.chip_class >= GFX9 &&
1117 info->type == VK_IMAGE_TYPE_3D &&
1118 vk_format_get_blocksizebits(info->format) == 128 &&
1119 vk_format_is_compressed(info->format) &&
1120 (info->flags & VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT) &&
1121 ((info->flags & VK_IMAGE_CREATE_EXTENDED_USAGE_BIT) ||
1122 (info->usage & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT))) {
1123 goto unsupported;
1124 }
1125
1126 if (info->usage & VK_IMAGE_USAGE_SAMPLED_BIT) {
1127 if (!(format_feature_flags & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
1128 goto unsupported;
1129 }
1130 }
1131
1132 if (info->usage & VK_IMAGE_USAGE_STORAGE_BIT) {
1133 if (!(format_feature_flags & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT)) {
1134 goto unsupported;
1135 }
1136 }
1137
1138 if (info->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) {
1139 if (!(format_feature_flags & VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT)) {
1140 goto unsupported;
1141 }
1142 }
1143
1144 if (info->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) {
1145 if (!(format_feature_flags & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)) {
1146 goto unsupported;
1147 }
1148 }
1149
1150 if (info->usage & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
1151 if (!(format_feature_flags & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT)) {
1152 goto unsupported;
1153 }
1154 }
1155
1156 if (info->usage & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
1157 if (!(format_feature_flags & VK_FORMAT_FEATURE_TRANSFER_DST_BIT)) {
1158 goto unsupported;
1159 }
1160 }
1161
1162 if (info->usage & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT) {
1163 if (!(format_feature_flags & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
1164 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))) {
1165 goto unsupported;
1166 }
1167 }
1168
1169 *pImageFormatProperties = (VkImageFormatProperties) {
1170 .maxExtent = maxExtent,
1171 .maxMipLevels = maxMipLevels,
1172 .maxArrayLayers = maxArraySize,
1173 .sampleCounts = sampleCounts,
1174
1175 /* FINISHME: Accurately calculate
1176 * VkImageFormatProperties::maxResourceSize.
1177 */
1178 .maxResourceSize = UINT32_MAX,
1179 };
1180
1181 return VK_SUCCESS;
1182 unsupported:
1183 *pImageFormatProperties = (VkImageFormatProperties) {
1184 .maxExtent = { 0, 0, 0 },
1185 .maxMipLevels = 0,
1186 .maxArrayLayers = 0,
1187 .sampleCounts = 0,
1188 .maxResourceSize = 0,
1189 };
1190
1191 return VK_ERROR_FORMAT_NOT_SUPPORTED;
1192 }
1193
1194 VkResult radv_GetPhysicalDeviceImageFormatProperties(
1195 VkPhysicalDevice physicalDevice,
1196 VkFormat format,
1197 VkImageType type,
1198 VkImageTiling tiling,
1199 VkImageUsageFlags usage,
1200 VkImageCreateFlags createFlags,
1201 VkImageFormatProperties* pImageFormatProperties)
1202 {
1203 RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
1204
1205 const VkPhysicalDeviceImageFormatInfo2 info = {
1206 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
1207 .pNext = NULL,
1208 .format = format,
1209 .type = type,
1210 .tiling = tiling,
1211 .usage = usage,
1212 .flags = createFlags,
1213 };
1214
1215 return radv_get_image_format_properties(physical_device, &info,
1216 pImageFormatProperties);
1217 }
1218
1219 static void
1220 get_external_image_format_properties(const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo,
1221 VkExternalMemoryHandleTypeFlagBits handleType,
1222 VkExternalMemoryProperties *external_properties)
1223 {
1224 VkExternalMemoryFeatureFlagBits flags = 0;
1225 VkExternalMemoryHandleTypeFlags export_flags = 0;
1226 VkExternalMemoryHandleTypeFlags compat_flags = 0;
1227 switch (handleType) {
1228 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
1229 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
1230 switch (pImageFormatInfo->type) {
1231 case VK_IMAGE_TYPE_2D:
1232 flags = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT|VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
1233 compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
1234 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
1235 break;
1236 default:
1237 break;
1238 }
1239 break;
1240 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
1241 flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
1242 compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
1243 break;
1244 default:
1245 break;
1246 }
1247
1248 *external_properties = (VkExternalMemoryProperties) {
1249 .externalMemoryFeatures = flags,
1250 .exportFromImportedHandleTypes = export_flags,
1251 .compatibleHandleTypes = compat_flags,
1252 };
1253 }
1254
1255 VkResult radv_GetPhysicalDeviceImageFormatProperties2(
1256 VkPhysicalDevice physicalDevice,
1257 const VkPhysicalDeviceImageFormatInfo2 *base_info,
1258 VkImageFormatProperties2 *base_props)
1259 {
1260 RADV_FROM_HANDLE(radv_physical_device, physical_device, physicalDevice);
1261 const VkPhysicalDeviceExternalImageFormatInfo *external_info = NULL;
1262 VkExternalImageFormatProperties *external_props = NULL;
1263 VkResult result;
1264
1265 result = radv_get_image_format_properties(physical_device, base_info,
1266 &base_props->imageFormatProperties);
1267 if (result != VK_SUCCESS)
1268 return result;
1269
1270 /* Extract input structs */
1271 vk_foreach_struct_const(s, base_info->pNext) {
1272 switch (s->sType) {
1273 case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO:
1274 external_info = (const void *) s;
1275 break;
1276 default:
1277 break;
1278 }
1279 }
1280
1281 /* Extract output structs */
1282 vk_foreach_struct(s, base_props->pNext) {
1283 switch (s->sType) {
1284 case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES:
1285 external_props = (void *) s;
1286 break;
1287 default:
1288 break;
1289 }
1290 }
1291
1292 /* From the Vulkan 1.0.97 spec:
1293 *
1294 * If handleType is 0, vkGetPhysicalDeviceImageFormatProperties2 will
1295 * behave as if VkPhysicalDeviceExternalImageFormatInfo was not
1296 * present and VkExternalImageFormatProperties will be ignored.
1297 */
1298 if (external_info && external_info->handleType != 0) {
1299 switch (external_info->handleType) {
1300 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
1301 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
1302 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
1303 get_external_image_format_properties(base_info, external_info->handleType,
1304 &external_props->externalMemoryProperties);
1305 break;
1306 default:
1307 /* From the Vulkan 1.0.97 spec:
1308 *
1309 * If handleType is not compatible with the [parameters] specified
1310 * in VkPhysicalDeviceImageFormatInfo2, then
1311 * vkGetPhysicalDeviceImageFormatProperties2 returns
1312 * VK_ERROR_FORMAT_NOT_SUPPORTED.
1313 */
1314 result = vk_errorf(physical_device->instance, VK_ERROR_FORMAT_NOT_SUPPORTED,
1315 "unsupported VkExternalMemoryTypeFlagBitsKHR 0x%x",
1316 external_info->handleType);
1317 goto fail;
1318 }
1319 }
1320
1321 return VK_SUCCESS;
1322
1323 fail:
1324 if (result == VK_ERROR_FORMAT_NOT_SUPPORTED) {
1325 /* From the Vulkan 1.0.97 spec:
1326 *
1327 * If the combination of parameters to
1328 * vkGetPhysicalDeviceImageFormatProperties2 is not supported by
1329 * the implementation for use in vkCreateImage, then all members of
1330 * imageFormatProperties will be filled with zero.
1331 */
1332 base_props->imageFormatProperties = (VkImageFormatProperties) {0};
1333 }
1334
1335 return result;
1336 }
1337
1338 void radv_GetPhysicalDeviceSparseImageFormatProperties(
1339 VkPhysicalDevice physicalDevice,
1340 VkFormat format,
1341 VkImageType type,
1342 uint32_t samples,
1343 VkImageUsageFlags usage,
1344 VkImageTiling tiling,
1345 uint32_t* pNumProperties,
1346 VkSparseImageFormatProperties* pProperties)
1347 {
1348 /* Sparse images are not yet supported. */
1349 *pNumProperties = 0;
1350 }
1351
1352 void radv_GetPhysicalDeviceSparseImageFormatProperties2(
1353 VkPhysicalDevice physicalDevice,
1354 const VkPhysicalDeviceSparseImageFormatInfo2 *pFormatInfo,
1355 uint32_t *pPropertyCount,
1356 VkSparseImageFormatProperties2 *pProperties)
1357 {
1358 /* Sparse images are not yet supported. */
1359 *pPropertyCount = 0;
1360 }
1361
1362 void radv_GetPhysicalDeviceExternalBufferProperties(
1363 VkPhysicalDevice physicalDevice,
1364 const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo,
1365 VkExternalBufferProperties *pExternalBufferProperties)
1366 {
1367 VkExternalMemoryFeatureFlagBits flags = 0;
1368 VkExternalMemoryHandleTypeFlags export_flags = 0;
1369 VkExternalMemoryHandleTypeFlags compat_flags = 0;
1370 switch(pExternalBufferInfo->handleType) {
1371 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
1372 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT:
1373 flags = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT |
1374 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
1375 compat_flags = export_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT |
1376 VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT;
1377 break;
1378 case VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT:
1379 flags = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
1380 compat_flags = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT;
1381 break;
1382 default:
1383 break;
1384 }
1385 pExternalBufferProperties->externalMemoryProperties = (VkExternalMemoryProperties) {
1386 .externalMemoryFeatures = flags,
1387 .exportFromImportedHandleTypes = export_flags,
1388 .compatibleHandleTypes = compat_flags,
1389 };
1390 }
1391
1392 /* DCC channel type categories within which formats can be reinterpreted
1393 * while keeping the same DCC encoding. The swizzle must also match. */
1394 enum dcc_channel_type {
1395 dcc_channel_float32,
1396 dcc_channel_uint32,
1397 dcc_channel_sint32,
1398 dcc_channel_float16,
1399 dcc_channel_uint16,
1400 dcc_channel_sint16,
1401 dcc_channel_uint_10_10_10_2,
1402 dcc_channel_uint8,
1403 dcc_channel_sint8,
1404 dcc_channel_incompatible,
1405 };
1406
1407 /* Return the type of DCC encoding. */
1408 static enum dcc_channel_type
1409 radv_get_dcc_channel_type(const struct vk_format_description *desc)
1410 {
1411 int i;
1412
1413 /* Find the first non-void channel. */
1414 for (i = 0; i < desc->nr_channels; i++)
1415 if (desc->channel[i].type != VK_FORMAT_TYPE_VOID)
1416 break;
1417 if (i == desc->nr_channels)
1418 return dcc_channel_incompatible;
1419
1420 switch (desc->channel[i].size) {
1421 case 32:
1422 if (desc->channel[i].type == VK_FORMAT_TYPE_FLOAT)
1423 return dcc_channel_float32;
1424 if (desc->channel[i].type == VK_FORMAT_TYPE_UNSIGNED)
1425 return dcc_channel_uint32;
1426 return dcc_channel_sint32;
1427 case 16:
1428 if (desc->channel[i].type == VK_FORMAT_TYPE_FLOAT)
1429 return dcc_channel_float16;
1430 if (desc->channel[i].type == VK_FORMAT_TYPE_UNSIGNED)
1431 return dcc_channel_uint16;
1432 return dcc_channel_sint16;
1433 case 10:
1434 return dcc_channel_uint_10_10_10_2;
1435 case 8:
1436 if (desc->channel[i].type == VK_FORMAT_TYPE_UNSIGNED)
1437 return dcc_channel_uint8;
1438 return dcc_channel_sint8;
1439 default:
1440 return dcc_channel_incompatible;
1441 }
1442 }
1443
1444 /* Return if it's allowed to reinterpret one format as another with DCC enabled. */
1445 bool radv_dcc_formats_compatible(VkFormat format1,
1446 VkFormat format2)
1447 {
1448 const struct vk_format_description *desc1, *desc2;
1449 enum dcc_channel_type type1, type2;
1450 int i;
1451
1452 if (format1 == format2)
1453 return true;
1454
1455 desc1 = vk_format_description(format1);
1456 desc2 = vk_format_description(format2);
1457
1458 if (desc1->nr_channels != desc2->nr_channels)
1459 return false;
1460
1461 /* Swizzles must be the same. */
1462 for (i = 0; i < desc1->nr_channels; i++)
1463 if (desc1->swizzle[i] <= VK_SWIZZLE_W &&
1464 desc2->swizzle[i] <= VK_SWIZZLE_W &&
1465 desc1->swizzle[i] != desc2->swizzle[i])
1466 return false;
1467
1468 type1 = radv_get_dcc_channel_type(desc1);
1469 type2 = radv_get_dcc_channel_type(desc2);
1470
1471 return type1 != dcc_channel_incompatible &&
1472 type2 != dcc_channel_incompatible &&
1473 type1 == type2;
1474 }
1475