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