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 }