src/mesa/state_tracker/st_format.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 VMware, Inc.
   4  * Copyright (c) 2008-2010 VMware, Inc.
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  22  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  23  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  24  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  25  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29
  30 /**
  31  * Mesa / Gallium format conversion and format selection code.
  32  * \author Brian Paul
  33  */
  34
  35 #include "main/imports.h"
  36 #include "main/context.h"
  37 #include "main/enums.h"
  38 #include "main/formats.h"
  39 #include "main/glformats.h"
  40 #include "main/texgetimage.h"
  41 #include "main/teximage.h"
  42 #include "main/texstore.h"
  43 #include "main/image.h"
  44 #include "main/macros.h"
  45 #include "main/formatquery.h"
  46
  47 #include "pipe/p_context.h"
  48 #include "pipe/p_defines.h"
  49 #include "pipe/p_screen.h"
  50 #include "util/u_format.h"
  51 #include "st_cb_texture.h"
  52 #include "st_context.h"
  53 #include "st_format.h"
  54
  55
  56 /**
  57  * Translate Mesa format to Gallium format.
  58  */
  59 enum pipe_format
  60 st_mesa_format_to_pipe_format(struct st_context *st, mesa_format mesaFormat)
  61 {
  62    switch (mesaFormat) {
  63    case MESA_FORMAT_A8B8G8R8_UNORM:
  64       return PIPE_FORMAT_ABGR8888_UNORM;
  65    case MESA_FORMAT_R8G8B8A8_UNORM:
  66       return PIPE_FORMAT_RGBA8888_UNORM;
  67    case MESA_FORMAT_B8G8R8A8_UNORM:
  68       return PIPE_FORMAT_BGRA8888_UNORM;
  69    case MESA_FORMAT_A8R8G8B8_UNORM:
  70       return PIPE_FORMAT_ARGB8888_UNORM;
  71    case MESA_FORMAT_X8B8G8R8_UNORM:
  72       return PIPE_FORMAT_XBGR8888_UNORM;
  73    case MESA_FORMAT_R8G8B8X8_UNORM:
  74       return PIPE_FORMAT_RGBX8888_UNORM;
  75    case MESA_FORMAT_B8G8R8X8_UNORM:
  76       return PIPE_FORMAT_BGRX8888_UNORM;
  77    case MESA_FORMAT_X8R8G8B8_UNORM:
  78       return PIPE_FORMAT_XRGB8888_UNORM;
  79    case MESA_FORMAT_B5G5R5A1_UNORM:
  80       return PIPE_FORMAT_B5G5R5A1_UNORM;
  81    case MESA_FORMAT_B4G4R4A4_UNORM:
  82       return PIPE_FORMAT_B4G4R4A4_UNORM;
  83    case MESA_FORMAT_B5G6R5_UNORM:
  84       return PIPE_FORMAT_B5G6R5_UNORM;
  85    case MESA_FORMAT_B2G3R3_UNORM:
  86       return PIPE_FORMAT_B2G3R3_UNORM;
  87    case MESA_FORMAT_B10G10R10A2_UNORM:
  88       return PIPE_FORMAT_B10G10R10A2_UNORM;
  89    case MESA_FORMAT_R10G10B10A2_UNORM:
  90       return PIPE_FORMAT_R10G10B10A2_UNORM;
  91    case MESA_FORMAT_L4A4_UNORM:
  92       return PIPE_FORMAT_L4A4_UNORM;
  93    case MESA_FORMAT_L8A8_UNORM:
  94       return PIPE_FORMAT_LA88_UNORM;
  95    case MESA_FORMAT_A8L8_UNORM:
  96       return PIPE_FORMAT_AL88_UNORM;
  97    case MESA_FORMAT_L16A16_UNORM:
  98       return PIPE_FORMAT_LA1616_UNORM;
  99    case MESA_FORMAT_A16L16_UNORM:
 100       return PIPE_FORMAT_AL1616_UNORM;
 101    case MESA_FORMAT_A_UNORM8:
 102       return PIPE_FORMAT_A8_UNORM;
 103    case MESA_FORMAT_A_UNORM16:
 104       return PIPE_FORMAT_A16_UNORM;
 105    case MESA_FORMAT_L_UNORM8:
 106       return PIPE_FORMAT_L8_UNORM;
 107    case MESA_FORMAT_L_UNORM16:
 108       return PIPE_FORMAT_L16_UNORM;
 109    case MESA_FORMAT_I_UNORM8:
 110       return PIPE_FORMAT_I8_UNORM;
 111    case MESA_FORMAT_I_UNORM16:
 112       return PIPE_FORMAT_I16_UNORM;
 113    case MESA_FORMAT_Z_UNORM16:
 114       return PIPE_FORMAT_Z16_UNORM;
 115    case MESA_FORMAT_Z_UNORM32:
 116       return PIPE_FORMAT_Z32_UNORM;
 117    case MESA_FORMAT_S8_UINT_Z24_UNORM:
 118       return PIPE_FORMAT_S8_UINT_Z24_UNORM;
 119    case MESA_FORMAT_Z24_UNORM_S8_UINT:
 120       return PIPE_FORMAT_Z24_UNORM_S8_UINT;
 121    case MESA_FORMAT_X8_UINT_Z24_UNORM:
 122       return PIPE_FORMAT_X8Z24_UNORM;
 123    case MESA_FORMAT_Z24_UNORM_X8_UINT:
 124       return PIPE_FORMAT_Z24X8_UNORM;
 125    case MESA_FORMAT_S_UINT8:
 126       return PIPE_FORMAT_S8_UINT;
 127    case MESA_FORMAT_Z_FLOAT32:
 128       return PIPE_FORMAT_Z32_FLOAT;
 129    case MESA_FORMAT_Z32_FLOAT_S8X24_UINT:
 130       return PIPE_FORMAT_Z32_FLOAT_S8X24_UINT;
 131    case MESA_FORMAT_YCBCR:
 132       return PIPE_FORMAT_UYVY;
 133    case MESA_FORMAT_YCBCR_REV:
 134       return PIPE_FORMAT_YUYV;
 135    case MESA_FORMAT_RGB_DXT1:
 136       return PIPE_FORMAT_DXT1_RGB;
 137    case MESA_FORMAT_RGBA_DXT1:
 138       return PIPE_FORMAT_DXT1_RGBA;
 139    case MESA_FORMAT_RGBA_DXT3:
 140       return PIPE_FORMAT_DXT3_RGBA;
 141    case MESA_FORMAT_RGBA_DXT5:
 142       return PIPE_FORMAT_DXT5_RGBA;
 143    case MESA_FORMAT_SRGB_DXT1:
 144       return PIPE_FORMAT_DXT1_SRGB;
 145    case MESA_FORMAT_SRGBA_DXT1:
 146       return PIPE_FORMAT_DXT1_SRGBA;
 147    case MESA_FORMAT_SRGBA_DXT3:
 148       return PIPE_FORMAT_DXT3_SRGBA;
 149    case MESA_FORMAT_SRGBA_DXT5:
 150       return PIPE_FORMAT_DXT5_SRGBA;
 151    case MESA_FORMAT_L8A8_SRGB:
 152       return PIPE_FORMAT_LA88_SRGB;
 153    case MESA_FORMAT_A8L8_SRGB:
 154       return PIPE_FORMAT_AL88_SRGB;
 155    case MESA_FORMAT_L_SRGB8:
 156       return PIPE_FORMAT_L8_SRGB;
 157    case MESA_FORMAT_BGR_SRGB8:
 158       return PIPE_FORMAT_R8G8B8_SRGB;
 159    case MESA_FORMAT_A8B8G8R8_SRGB:
 160       return PIPE_FORMAT_ABGR8888_SRGB;
 161    case MESA_FORMAT_R8G8B8A8_SRGB:
 162       return PIPE_FORMAT_RGBA8888_SRGB;
 163    case MESA_FORMAT_B8G8R8A8_SRGB:
 164       return PIPE_FORMAT_BGRA8888_SRGB;
 165    case MESA_FORMAT_A8R8G8B8_SRGB:
 166       return PIPE_FORMAT_ARGB8888_SRGB;
 167    case MESA_FORMAT_RGBA_FLOAT32:
 168       return PIPE_FORMAT_R32G32B32A32_FLOAT;
 169    case MESA_FORMAT_RGBA_FLOAT16:
 170       return PIPE_FORMAT_R16G16B16A16_FLOAT;
 171    case MESA_FORMAT_RGB_FLOAT32:
 172       return PIPE_FORMAT_R32G32B32_FLOAT;
 173    case MESA_FORMAT_RGB_FLOAT16:
 174       return PIPE_FORMAT_R16G16B16_FLOAT;
 175    case MESA_FORMAT_LA_FLOAT32:
 176       return PIPE_FORMAT_L32A32_FLOAT;
 177    case MESA_FORMAT_LA_FLOAT16:
 178       return PIPE_FORMAT_L16A16_FLOAT;
 179    case MESA_FORMAT_L_FLOAT32:
 180       return PIPE_FORMAT_L32_FLOAT;
 181    case MESA_FORMAT_L_FLOAT16:
 182       return PIPE_FORMAT_L16_FLOAT;
 183    case MESA_FORMAT_A_FLOAT32:
 184       return PIPE_FORMAT_A32_FLOAT;
 185    case MESA_FORMAT_A_FLOAT16:
 186       return PIPE_FORMAT_A16_FLOAT;
 187    case MESA_FORMAT_I_FLOAT32:
 188       return PIPE_FORMAT_I32_FLOAT;
 189    case MESA_FORMAT_I_FLOAT16:
 190       return PIPE_FORMAT_I16_FLOAT;
 191    case MESA_FORMAT_R_FLOAT32:
 192       return PIPE_FORMAT_R32_FLOAT;
 193    case MESA_FORMAT_R_FLOAT16:
 194       return PIPE_FORMAT_R16_FLOAT;
 195    case MESA_FORMAT_RG_FLOAT32:
 196       return PIPE_FORMAT_R32G32_FLOAT;
 197    case MESA_FORMAT_RG_FLOAT16:
 198       return PIPE_FORMAT_R16G16_FLOAT;
 199
 200    case MESA_FORMAT_R_UNORM8:
 201       return PIPE_FORMAT_R8_UNORM;
 202    case MESA_FORMAT_R_UNORM16:
 203       return PIPE_FORMAT_R16_UNORM;
 204    case MESA_FORMAT_R8G8_UNORM:
 205       return PIPE_FORMAT_RG88_UNORM;
 206    case MESA_FORMAT_G8R8_UNORM:
 207       return PIPE_FORMAT_GR88_UNORM;
 208    case MESA_FORMAT_R16G16_UNORM:
 209       return PIPE_FORMAT_RG1616_UNORM;
 210    case MESA_FORMAT_G16R16_UNORM:
 211       return PIPE_FORMAT_GR1616_UNORM;
 212    case MESA_FORMAT_RGBA_UNORM16:
 213       return PIPE_FORMAT_R16G16B16A16_UNORM;
 214
 215    /* signed int formats */
 216    case MESA_FORMAT_A_UINT8:
 217       return PIPE_FORMAT_A8_UINT;
 218    case MESA_FORMAT_A_UINT16:
 219       return PIPE_FORMAT_A16_UINT;
 220    case MESA_FORMAT_A_UINT32:
 221       return PIPE_FORMAT_A32_UINT;
 222
 223    case MESA_FORMAT_A_SINT8:
 224       return PIPE_FORMAT_A8_SINT;
 225    case MESA_FORMAT_A_SINT16:
 226       return PIPE_FORMAT_A16_SINT;
 227    case MESA_FORMAT_A_SINT32:
 228       return PIPE_FORMAT_A32_SINT;
 229
 230    case MESA_FORMAT_I_UINT8:
 231       return PIPE_FORMAT_I8_UINT;
 232    case MESA_FORMAT_I_UINT16:
 233       return PIPE_FORMAT_I16_UINT;
 234    case MESA_FORMAT_I_UINT32:
 235       return PIPE_FORMAT_I32_UINT;
 236
 237    case MESA_FORMAT_I_SINT8:
 238       return PIPE_FORMAT_I8_SINT;
 239    case MESA_FORMAT_I_SINT16:
 240       return PIPE_FORMAT_I16_SINT;
 241    case MESA_FORMAT_I_SINT32:
 242       return PIPE_FORMAT_I32_SINT;
 243
 244    case MESA_FORMAT_L_UINT8:
 245       return PIPE_FORMAT_L8_UINT;
 246    case MESA_FORMAT_L_UINT16:
 247       return PIPE_FORMAT_L16_UINT;
 248    case MESA_FORMAT_L_UINT32:
 249       return PIPE_FORMAT_L32_UINT;
 250
 251    case MESA_FORMAT_L_SINT8:
 252       return PIPE_FORMAT_L8_SINT;
 253    case MESA_FORMAT_L_SINT16:
 254       return PIPE_FORMAT_L16_SINT;
 255    case MESA_FORMAT_L_SINT32:
 256       return PIPE_FORMAT_L32_SINT;
 257
 258    case MESA_FORMAT_LA_UINT8:
 259       return PIPE_FORMAT_L8A8_UINT;
 260    case MESA_FORMAT_LA_UINT16:
 261       return PIPE_FORMAT_L16A16_UINT;
 262    case MESA_FORMAT_LA_UINT32:
 263       return PIPE_FORMAT_L32A32_UINT;
 264
 265    case MESA_FORMAT_LA_SINT8:
 266       return PIPE_FORMAT_L8A8_SINT;
 267    case MESA_FORMAT_LA_SINT16:
 268       return PIPE_FORMAT_L16A16_SINT;
 269    case MESA_FORMAT_LA_SINT32:
 270       return PIPE_FORMAT_L32A32_SINT;
 271
 272    case MESA_FORMAT_R_SINT8:
 273       return PIPE_FORMAT_R8_SINT;
 274    case MESA_FORMAT_RG_SINT8:
 275       return PIPE_FORMAT_R8G8_SINT;
 276    case MESA_FORMAT_RGB_SINT8:
 277       return PIPE_FORMAT_R8G8B8_SINT;
 278    case MESA_FORMAT_RGBA_SINT8:
 279       return PIPE_FORMAT_R8G8B8A8_SINT;
 280    case MESA_FORMAT_R_SINT16:
 281       return PIPE_FORMAT_R16_SINT;
 282    case MESA_FORMAT_RG_SINT16:
 283       return PIPE_FORMAT_R16G16_SINT;
 284    case MESA_FORMAT_RGB_SINT16:
 285       return PIPE_FORMAT_R16G16B16_SINT;
 286    case MESA_FORMAT_RGBA_SINT16:
 287       return PIPE_FORMAT_R16G16B16A16_SINT;
 288    case MESA_FORMAT_R_SINT32:
 289       return PIPE_FORMAT_R32_SINT;
 290    case MESA_FORMAT_RG_SINT32:
 291       return PIPE_FORMAT_R32G32_SINT;
 292    case MESA_FORMAT_RGB_SINT32:
 293       return PIPE_FORMAT_R32G32B32_SINT;
 294    case MESA_FORMAT_RGBA_SINT32:
 295       return PIPE_FORMAT_R32G32B32A32_SINT;
 296
 297    /* unsigned int formats */
 298    case MESA_FORMAT_R_UINT8:
 299       return PIPE_FORMAT_R8_UINT;
 300    case MESA_FORMAT_RG_UINT8:
 301       return PIPE_FORMAT_R8G8_UINT;
 302    case MESA_FORMAT_RGB_UINT8:
 303       return PIPE_FORMAT_R8G8B8_UINT;
 304    case MESA_FORMAT_RGBA_UINT8:
 305       return PIPE_FORMAT_R8G8B8A8_UINT;
 306    case MESA_FORMAT_R_UINT16:
 307       return PIPE_FORMAT_R16_UINT;
 308    case MESA_FORMAT_RG_UINT16:
 309       return PIPE_FORMAT_R16G16_UINT;
 310    case MESA_FORMAT_RGB_UINT16:
 311       return PIPE_FORMAT_R16G16B16_UINT;
 312    case MESA_FORMAT_RGBA_UINT16:
 313       return PIPE_FORMAT_R16G16B16A16_UINT;
 314    case MESA_FORMAT_R_UINT32:
 315       return PIPE_FORMAT_R32_UINT;
 316    case MESA_FORMAT_RG_UINT32:
 317       return PIPE_FORMAT_R32G32_UINT;
 318    case MESA_FORMAT_RGB_UINT32:
 319       return PIPE_FORMAT_R32G32B32_UINT;
 320    case MESA_FORMAT_RGBA_UINT32:
 321       return PIPE_FORMAT_R32G32B32A32_UINT;
 322
 323    case MESA_FORMAT_R_RGTC1_UNORM:
 324       return PIPE_FORMAT_RGTC1_UNORM;
 325    case MESA_FORMAT_R_RGTC1_SNORM:
 326       return PIPE_FORMAT_RGTC1_SNORM;
 327    case MESA_FORMAT_RG_RGTC2_UNORM:
 328       return PIPE_FORMAT_RGTC2_UNORM;
 329    case MESA_FORMAT_RG_RGTC2_SNORM:
 330       return PIPE_FORMAT_RGTC2_SNORM;
 331
 332    case MESA_FORMAT_L_LATC1_UNORM:
 333       return PIPE_FORMAT_LATC1_UNORM;
 334    case MESA_FORMAT_L_LATC1_SNORM:
 335       return PIPE_FORMAT_LATC1_SNORM;
 336    case MESA_FORMAT_LA_LATC2_UNORM:
 337       return PIPE_FORMAT_LATC2_UNORM;
 338    case MESA_FORMAT_LA_LATC2_SNORM:
 339       return PIPE_FORMAT_LATC2_SNORM;
 340
 341    /* The destination RGBA format mustn't be changed, because it's also
 342     * a destination format of the unpack/decompression function. */
 343    case MESA_FORMAT_ETC1_RGB8:
 344       return st->has_etc1 ? PIPE_FORMAT_ETC1_RGB8 : PIPE_FORMAT_R8G8B8A8_UNORM;
 345
 346    case MESA_FORMAT_BPTC_RGBA_UNORM:
 347       return PIPE_FORMAT_BPTC_RGBA_UNORM;
 348    case MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM:
 349       return PIPE_FORMAT_BPTC_SRGBA;
 350    case MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT:
 351       return PIPE_FORMAT_BPTC_RGB_FLOAT;
 352    case MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT:
 353       return PIPE_FORMAT_BPTC_RGB_UFLOAT;
 354
 355    /* signed normalized formats */
 356    case MESA_FORMAT_R_SNORM8:
 357       return PIPE_FORMAT_R8_SNORM;
 358    case MESA_FORMAT_R8G8_SNORM:
 359       return PIPE_FORMAT_RG88_SNORM;
 360    case MESA_FORMAT_G8R8_SNORM:
 361       return PIPE_FORMAT_GR88_SNORM;
 362    case MESA_FORMAT_R8G8B8A8_SNORM:
 363       return PIPE_FORMAT_RGBA8888_SNORM;
 364    case MESA_FORMAT_A8B8G8R8_SNORM:
 365       return PIPE_FORMAT_ABGR8888_SNORM;
 366
 367    case MESA_FORMAT_A_SNORM8:
 368       return PIPE_FORMAT_A8_SNORM;
 369    case MESA_FORMAT_L_SNORM8:
 370       return PIPE_FORMAT_L8_SNORM;
 371    case MESA_FORMAT_L8A8_SNORM:
 372       return PIPE_FORMAT_LA88_SNORM;
 373    case MESA_FORMAT_A8L8_SNORM:
 374       return PIPE_FORMAT_AL88_SNORM;
 375    case MESA_FORMAT_I_SNORM8:
 376       return PIPE_FORMAT_I8_SNORM;
 377
 378    case MESA_FORMAT_R_SNORM16:
 379       return PIPE_FORMAT_R16_SNORM;
 380    case MESA_FORMAT_R16G16_SNORM:
 381       return PIPE_FORMAT_RG1616_SNORM;
 382    case MESA_FORMAT_G16R16_SNORM:
 383       return PIPE_FORMAT_GR1616_SNORM;
 384    case MESA_FORMAT_RGBA_SNORM16:
 385       return PIPE_FORMAT_R16G16B16A16_SNORM;
 386
 387    case MESA_FORMAT_A_SNORM16:
 388       return PIPE_FORMAT_A16_SNORM;
 389    case MESA_FORMAT_L_SNORM16:
 390       return PIPE_FORMAT_L16_SNORM;
 391    case MESA_FORMAT_LA_SNORM16:
 392       return PIPE_FORMAT_L16A16_SNORM;
 393    case MESA_FORMAT_I_SNORM16:
 394       return PIPE_FORMAT_I16_SNORM;
 395
 396    case MESA_FORMAT_R9G9B9E5_FLOAT:
 397       return PIPE_FORMAT_R9G9B9E5_FLOAT;
 398    case MESA_FORMAT_R11G11B10_FLOAT:
 399       return PIPE_FORMAT_R11G11B10_FLOAT;
 400    case MESA_FORMAT_B10G10R10A2_UINT:
 401       return PIPE_FORMAT_B10G10R10A2_UINT;
 402    case MESA_FORMAT_R10G10B10A2_UINT:
 403       return PIPE_FORMAT_R10G10B10A2_UINT;
 404
 405    case MESA_FORMAT_B4G4R4X4_UNORM:
 406       return PIPE_FORMAT_B4G4R4X4_UNORM;
 407    case MESA_FORMAT_B5G5R5X1_UNORM:
 408       return PIPE_FORMAT_B5G5R5X1_UNORM;
 409    case MESA_FORMAT_R8G8B8X8_SNORM:
 410       return PIPE_FORMAT_RGBX8888_SNORM;
 411    case MESA_FORMAT_X8B8G8R8_SNORM:
 412       return PIPE_FORMAT_XBGR8888_SNORM;
 413    case MESA_FORMAT_R8G8B8X8_SRGB:
 414       return PIPE_FORMAT_RGBX8888_SRGB;
 415    case MESA_FORMAT_X8B8G8R8_SRGB:
 416       return PIPE_FORMAT_XBGR8888_SRGB;
 417    case MESA_FORMAT_RGBX_UINT8:
 418       return PIPE_FORMAT_R8G8B8X8_UINT;
 419    case MESA_FORMAT_RGBX_SINT8:
 420       return PIPE_FORMAT_R8G8B8X8_SINT;
 421    case MESA_FORMAT_B10G10R10X2_UNORM:
 422       return PIPE_FORMAT_B10G10R10X2_UNORM;
 423    case MESA_FORMAT_RGBX_UNORM16:
 424       return PIPE_FORMAT_R16G16B16X16_UNORM;
 425    case MESA_FORMAT_RGBX_SNORM16:
 426       return PIPE_FORMAT_R16G16B16X16_SNORM;
 427    case MESA_FORMAT_RGBX_FLOAT16:
 428       return PIPE_FORMAT_R16G16B16X16_FLOAT;
 429    case MESA_FORMAT_RGBX_UINT16:
 430       return PIPE_FORMAT_R16G16B16X16_UINT;
 431    case MESA_FORMAT_RGBX_SINT16:
 432       return PIPE_FORMAT_R16G16B16X16_SINT;
 433    case MESA_FORMAT_RGBX_FLOAT32:
 434       return PIPE_FORMAT_R32G32B32X32_FLOAT;
 435    case MESA_FORMAT_RGBX_UINT32:
 436       return PIPE_FORMAT_R32G32B32X32_UINT;
 437    case MESA_FORMAT_RGBX_SINT32:
 438       return PIPE_FORMAT_R32G32B32X32_SINT;
 439
 440    case MESA_FORMAT_B8G8R8X8_SRGB:
 441       return PIPE_FORMAT_BGRX8888_SRGB;
 442    case MESA_FORMAT_X8R8G8B8_SRGB:
 443       return PIPE_FORMAT_XRGB8888_SRGB;
 444
 445    /* ETC2 formats are emulated as uncompressed ones.
 446     * The destination formats mustn't be changed, because they are also
 447     * destination formats of the unpack/decompression function. */
 448    case MESA_FORMAT_ETC2_RGB8:
 449       return st->has_etc2 ? PIPE_FORMAT_ETC2_RGB8 : PIPE_FORMAT_R8G8B8A8_UNORM;
 450    case MESA_FORMAT_ETC2_SRGB8:
 451       return st->has_etc2 ? PIPE_FORMAT_ETC2_SRGB8 : PIPE_FORMAT_B8G8R8A8_SRGB;
 452    case MESA_FORMAT_ETC2_RGBA8_EAC:
 453       return st->has_etc2 ? PIPE_FORMAT_ETC2_RGBA8 : PIPE_FORMAT_R8G8B8A8_UNORM;
 454    case MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC:
 455       return st->has_etc2 ? PIPE_FORMAT_ETC2_SRGBA8 : PIPE_FORMAT_B8G8R8A8_SRGB;
 456    case MESA_FORMAT_ETC2_R11_EAC:
 457       return st->has_etc2 ? PIPE_FORMAT_ETC2_R11_UNORM : PIPE_FORMAT_R16_UNORM;
 458    case MESA_FORMAT_ETC2_RG11_EAC:
 459       return st->has_etc2 ? PIPE_FORMAT_ETC2_RG11_UNORM : PIPE_FORMAT_R16G16_UNORM;
 460    case MESA_FORMAT_ETC2_SIGNED_R11_EAC:
 461       return st->has_etc2 ? PIPE_FORMAT_ETC2_R11_SNORM : PIPE_FORMAT_R16_SNORM;
 462    case MESA_FORMAT_ETC2_SIGNED_RG11_EAC:
 463       return st->has_etc2 ? PIPE_FORMAT_ETC2_RG11_SNORM : PIPE_FORMAT_R16G16_SNORM;
 464    case MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
 465       return st->has_etc2 ? PIPE_FORMAT_ETC2_RGB8A1 : PIPE_FORMAT_R8G8B8A8_UNORM;
 466    case MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
 467       return st->has_etc2 ? PIPE_FORMAT_ETC2_SRGB8A1 : PIPE_FORMAT_B8G8R8A8_SRGB;
 468
 469    case MESA_FORMAT_RGBA_ASTC_4x4:
 470       return PIPE_FORMAT_ASTC_4x4;
 471    case MESA_FORMAT_RGBA_ASTC_5x4:
 472       return PIPE_FORMAT_ASTC_5x4;
 473    case MESA_FORMAT_RGBA_ASTC_5x5:
 474       return PIPE_FORMAT_ASTC_5x5;
 475    case MESA_FORMAT_RGBA_ASTC_6x5:
 476       return PIPE_FORMAT_ASTC_6x5;
 477    case MESA_FORMAT_RGBA_ASTC_6x6:
 478       return PIPE_FORMAT_ASTC_6x6;
 479    case MESA_FORMAT_RGBA_ASTC_8x5:
 480       return PIPE_FORMAT_ASTC_8x5;
 481    case MESA_FORMAT_RGBA_ASTC_8x6:
 482       return PIPE_FORMAT_ASTC_8x6;
 483    case MESA_FORMAT_RGBA_ASTC_8x8:
 484       return PIPE_FORMAT_ASTC_8x8;
 485    case MESA_FORMAT_RGBA_ASTC_10x5:
 486       return PIPE_FORMAT_ASTC_10x5;
 487    case MESA_FORMAT_RGBA_ASTC_10x6:
 488       return PIPE_FORMAT_ASTC_10x6;
 489    case MESA_FORMAT_RGBA_ASTC_10x8:
 490       return PIPE_FORMAT_ASTC_10x8;
 491    case MESA_FORMAT_RGBA_ASTC_10x10:
 492       return PIPE_FORMAT_ASTC_10x10;
 493    case MESA_FORMAT_RGBA_ASTC_12x10:
 494       return PIPE_FORMAT_ASTC_12x10;
 495    case MESA_FORMAT_RGBA_ASTC_12x12:
 496       return PIPE_FORMAT_ASTC_12x12;
 497
 498    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4:
 499       return PIPE_FORMAT_ASTC_4x4_SRGB;
 500    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4:
 501       return PIPE_FORMAT_ASTC_5x4_SRGB;
 502    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5:
 503       return PIPE_FORMAT_ASTC_5x5_SRGB;
 504    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5:
 505       return PIPE_FORMAT_ASTC_6x5_SRGB;
 506    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6:
 507       return PIPE_FORMAT_ASTC_6x6_SRGB;
 508    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5:
 509       return PIPE_FORMAT_ASTC_8x5_SRGB;
 510    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6:
 511       return PIPE_FORMAT_ASTC_8x6_SRGB;
 512    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8:
 513       return PIPE_FORMAT_ASTC_8x8_SRGB;
 514    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5:
 515       return PIPE_FORMAT_ASTC_10x5_SRGB;
 516    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6:
 517       return PIPE_FORMAT_ASTC_10x6_SRGB;
 518    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8:
 519       return PIPE_FORMAT_ASTC_10x8_SRGB;
 520    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10:
 521       return PIPE_FORMAT_ASTC_10x10_SRGB;
 522    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10:
 523       return PIPE_FORMAT_ASTC_12x10_SRGB;
 524    case MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12:
 525       return PIPE_FORMAT_ASTC_12x12_SRGB;
 526
 527    default:
 528       return PIPE_FORMAT_NONE;
 529    }
 530 }
 531
 532
 533 /**
 534  * Translate Gallium format to Mesa format.
 535  */
 536 mesa_format
 537 st_pipe_format_to_mesa_format(enum pipe_format format)
 538 {
 539    switch (format) {
 540    case PIPE_FORMAT_ABGR8888_UNORM:
 541       return MESA_FORMAT_A8B8G8R8_UNORM;
 542    case PIPE_FORMAT_RGBA8888_UNORM:
 543       return MESA_FORMAT_R8G8B8A8_UNORM;
 544    case PIPE_FORMAT_BGRA8888_UNORM:
 545       return MESA_FORMAT_B8G8R8A8_UNORM;
 546    case PIPE_FORMAT_ARGB8888_UNORM:
 547       return MESA_FORMAT_A8R8G8B8_UNORM;
 548    case PIPE_FORMAT_XBGR8888_UNORM:
 549       return MESA_FORMAT_X8B8G8R8_UNORM;
 550    case PIPE_FORMAT_RGBX8888_UNORM:
 551       return MESA_FORMAT_R8G8B8X8_UNORM;
 552    case PIPE_FORMAT_BGRX8888_UNORM:
 553       return MESA_FORMAT_B8G8R8X8_UNORM;
 554    case PIPE_FORMAT_XRGB8888_UNORM:
 555       return MESA_FORMAT_X8R8G8B8_UNORM;
 556    case PIPE_FORMAT_B5G5R5A1_UNORM:
 557       return MESA_FORMAT_B5G5R5A1_UNORM;
 558    case PIPE_FORMAT_B4G4R4A4_UNORM:
 559       return MESA_FORMAT_B4G4R4A4_UNORM;
 560    case PIPE_FORMAT_B5G6R5_UNORM:
 561       return MESA_FORMAT_B5G6R5_UNORM;
 562    case PIPE_FORMAT_B2G3R3_UNORM:
 563       return MESA_FORMAT_B2G3R3_UNORM;
 564    case PIPE_FORMAT_B10G10R10A2_UNORM:
 565       return MESA_FORMAT_B10G10R10A2_UNORM;
 566    case PIPE_FORMAT_R10G10B10A2_UNORM:
 567       return MESA_FORMAT_R10G10B10A2_UNORM;
 568    case PIPE_FORMAT_L4A4_UNORM:
 569       return MESA_FORMAT_L4A4_UNORM;
 570    case PIPE_FORMAT_LA88_UNORM:
 571       return MESA_FORMAT_L8A8_UNORM;
 572    case PIPE_FORMAT_AL88_UNORM:
 573       return MESA_FORMAT_A8L8_UNORM;
 574    case PIPE_FORMAT_LA1616_UNORM:
 575       return MESA_FORMAT_L16A16_UNORM;
 576    case PIPE_FORMAT_AL1616_UNORM:
 577       return MESA_FORMAT_A16L16_UNORM;
 578    case PIPE_FORMAT_A8_UNORM:
 579       return MESA_FORMAT_A_UNORM8;
 580    case PIPE_FORMAT_A16_UNORM:
 581       return MESA_FORMAT_A_UNORM16;
 582    case PIPE_FORMAT_L8_UNORM:
 583       return MESA_FORMAT_L_UNORM8;
 584    case PIPE_FORMAT_L16_UNORM:
 585       return MESA_FORMAT_L_UNORM16;
 586    case PIPE_FORMAT_I8_UNORM:
 587       return MESA_FORMAT_I_UNORM8;
 588    case PIPE_FORMAT_I16_UNORM:
 589       return MESA_FORMAT_I_UNORM16;
 590    case PIPE_FORMAT_S8_UINT:
 591       return MESA_FORMAT_S_UINT8;
 592
 593    case PIPE_FORMAT_R16G16B16A16_UNORM:
 594       return MESA_FORMAT_RGBA_UNORM16;
 595
 596    case PIPE_FORMAT_Z16_UNORM:
 597       return MESA_FORMAT_Z_UNORM16;
 598    case PIPE_FORMAT_Z32_UNORM:
 599       return MESA_FORMAT_Z_UNORM32;
 600    case PIPE_FORMAT_S8_UINT_Z24_UNORM:
 601       return MESA_FORMAT_S8_UINT_Z24_UNORM;
 602    case PIPE_FORMAT_X8Z24_UNORM:
 603       return MESA_FORMAT_X8_UINT_Z24_UNORM;
 604    case PIPE_FORMAT_Z24X8_UNORM:
 605       return MESA_FORMAT_Z24_UNORM_X8_UINT;
 606    case PIPE_FORMAT_Z24_UNORM_S8_UINT:
 607       return MESA_FORMAT_Z24_UNORM_S8_UINT;
 608    case PIPE_FORMAT_Z32_FLOAT:
 609       return MESA_FORMAT_Z_FLOAT32;
 610    case PIPE_FORMAT_Z32_FLOAT_S8X24_UINT:
 611       return MESA_FORMAT_Z32_FLOAT_S8X24_UINT;
 612
 613    case PIPE_FORMAT_UYVY:
 614       return MESA_FORMAT_YCBCR;
 615    case PIPE_FORMAT_YUYV:
 616       return MESA_FORMAT_YCBCR_REV;
 617
 618    case PIPE_FORMAT_DXT1_RGB:
 619       return MESA_FORMAT_RGB_DXT1;
 620    case PIPE_FORMAT_DXT1_RGBA:
 621       return MESA_FORMAT_RGBA_DXT1;
 622    case PIPE_FORMAT_DXT3_RGBA:
 623       return MESA_FORMAT_RGBA_DXT3;
 624    case PIPE_FORMAT_DXT5_RGBA:
 625       return MESA_FORMAT_RGBA_DXT5;
 626    case PIPE_FORMAT_DXT1_SRGB:
 627       return MESA_FORMAT_SRGB_DXT1;
 628    case PIPE_FORMAT_DXT1_SRGBA:
 629       return MESA_FORMAT_SRGBA_DXT1;
 630    case PIPE_FORMAT_DXT3_SRGBA:
 631       return MESA_FORMAT_SRGBA_DXT3;
 632    case PIPE_FORMAT_DXT5_SRGBA:
 633       return MESA_FORMAT_SRGBA_DXT5;
 634    case PIPE_FORMAT_LA88_SRGB:
 635       return MESA_FORMAT_L8A8_SRGB;
 636    case PIPE_FORMAT_AL88_SRGB:
 637       return MESA_FORMAT_A8L8_SRGB;
 638    case PIPE_FORMAT_L8_SRGB:
 639       return MESA_FORMAT_L_SRGB8;
 640    case PIPE_FORMAT_R8G8B8_SRGB:
 641       return MESA_FORMAT_BGR_SRGB8;
 642    case PIPE_FORMAT_ABGR8888_SRGB:
 643       return MESA_FORMAT_A8B8G8R8_SRGB;
 644    case PIPE_FORMAT_RGBA8888_SRGB:
 645       return MESA_FORMAT_R8G8B8A8_SRGB;
 646    case PIPE_FORMAT_BGRA8888_SRGB:
 647       return MESA_FORMAT_B8G8R8A8_SRGB;
 648    case PIPE_FORMAT_ARGB8888_SRGB:
 649       return MESA_FORMAT_A8R8G8B8_SRGB;
 650    case PIPE_FORMAT_R32G32B32A32_FLOAT:
 651       return MESA_FORMAT_RGBA_FLOAT32;
 652    case PIPE_FORMAT_R16G16B16A16_FLOAT:
 653       return MESA_FORMAT_RGBA_FLOAT16;
 654    case PIPE_FORMAT_R32G32B32_FLOAT:
 655       return MESA_FORMAT_RGB_FLOAT32;
 656    case PIPE_FORMAT_R16G16B16_FLOAT:
 657       return MESA_FORMAT_RGB_FLOAT16;
 658    case PIPE_FORMAT_L32A32_FLOAT:
 659       return MESA_FORMAT_LA_FLOAT32;
 660    case PIPE_FORMAT_L16A16_FLOAT:
 661       return MESA_FORMAT_LA_FLOAT16;
 662    case PIPE_FORMAT_L32_FLOAT:
 663       return MESA_FORMAT_L_FLOAT32;
 664    case PIPE_FORMAT_L16_FLOAT:
 665       return MESA_FORMAT_L_FLOAT16;
 666    case PIPE_FORMAT_A32_FLOAT:
 667       return MESA_FORMAT_A_FLOAT32;
 668    case PIPE_FORMAT_A16_FLOAT:
 669       return MESA_FORMAT_A_FLOAT16;
 670    case PIPE_FORMAT_I32_FLOAT:
 671       return MESA_FORMAT_I_FLOAT32;
 672    case PIPE_FORMAT_I16_FLOAT:
 673       return MESA_FORMAT_I_FLOAT16;
 674    case PIPE_FORMAT_R32_FLOAT:
 675       return MESA_FORMAT_R_FLOAT32;
 676    case PIPE_FORMAT_R16_FLOAT:
 677       return MESA_FORMAT_R_FLOAT16;
 678    case PIPE_FORMAT_R32G32_FLOAT:
 679       return MESA_FORMAT_RG_FLOAT32;
 680    case PIPE_FORMAT_R16G16_FLOAT:
 681       return MESA_FORMAT_RG_FLOAT16;
 682
 683    case PIPE_FORMAT_R8_UNORM:
 684       return MESA_FORMAT_R_UNORM8;
 685    case PIPE_FORMAT_R16_UNORM:
 686       return MESA_FORMAT_R_UNORM16;
 687    case PIPE_FORMAT_RG88_UNORM:
 688       return MESA_FORMAT_R8G8_UNORM;
 689    case PIPE_FORMAT_GR88_UNORM:
 690       return MESA_FORMAT_G8R8_UNORM;
 691    case PIPE_FORMAT_RG1616_UNORM:
 692       return MESA_FORMAT_R16G16_UNORM;
 693    case PIPE_FORMAT_GR1616_UNORM:
 694       return MESA_FORMAT_G16R16_UNORM;
 695
 696    case PIPE_FORMAT_A8_UINT:
 697       return MESA_FORMAT_A_UINT8;
 698    case PIPE_FORMAT_A16_UINT:
 699       return MESA_FORMAT_A_UINT16;
 700    case PIPE_FORMAT_A32_UINT:
 701       return MESA_FORMAT_A_UINT32;
 702    case PIPE_FORMAT_A8_SINT:
 703       return MESA_FORMAT_A_SINT8;
 704    case PIPE_FORMAT_A16_SINT:
 705       return MESA_FORMAT_A_SINT16;
 706    case PIPE_FORMAT_A32_SINT:
 707       return MESA_FORMAT_A_SINT32;
 708
 709    case PIPE_FORMAT_I8_UINT:
 710       return MESA_FORMAT_I_UINT8;
 711    case PIPE_FORMAT_I16_UINT:
 712       return MESA_FORMAT_I_UINT16;
 713    case PIPE_FORMAT_I32_UINT:
 714       return MESA_FORMAT_I_UINT32;
 715    case PIPE_FORMAT_I8_SINT:
 716       return MESA_FORMAT_I_SINT8;
 717    case PIPE_FORMAT_I16_SINT:
 718       return MESA_FORMAT_I_SINT16;
 719    case PIPE_FORMAT_I32_SINT:
 720       return MESA_FORMAT_I_SINT32;
 721
 722   case PIPE_FORMAT_L8_UINT:
 723       return MESA_FORMAT_L_UINT8;
 724    case PIPE_FORMAT_L16_UINT:
 725       return MESA_FORMAT_L_UINT16;
 726    case PIPE_FORMAT_L32_UINT:
 727       return MESA_FORMAT_L_UINT32;
 728    case PIPE_FORMAT_L8_SINT:
 729       return MESA_FORMAT_L_SINT8;
 730    case PIPE_FORMAT_L16_SINT:
 731       return MESA_FORMAT_L_SINT16;
 732    case PIPE_FORMAT_L32_SINT:
 733       return MESA_FORMAT_L_SINT32;
 734
 735    case PIPE_FORMAT_L8A8_UINT:
 736       return MESA_FORMAT_LA_UINT8;
 737    case PIPE_FORMAT_L16A16_UINT:
 738       return MESA_FORMAT_LA_UINT16;
 739    case PIPE_FORMAT_L32A32_UINT:
 740       return MESA_FORMAT_LA_UINT32;
 741    case PIPE_FORMAT_L8A8_SINT:
 742       return MESA_FORMAT_LA_SINT8;
 743    case PIPE_FORMAT_L16A16_SINT:
 744       return MESA_FORMAT_LA_SINT16;
 745    case PIPE_FORMAT_L32A32_SINT:
 746       return MESA_FORMAT_LA_SINT32;
 747
 748    case PIPE_FORMAT_R8_SINT:
 749       return MESA_FORMAT_R_SINT8;
 750    case PIPE_FORMAT_R8G8_SINT:
 751       return MESA_FORMAT_RG_SINT8;
 752    case PIPE_FORMAT_R8G8B8_SINT:
 753       return MESA_FORMAT_RGB_SINT8;
 754    case PIPE_FORMAT_R8G8B8A8_SINT:
 755       return MESA_FORMAT_RGBA_SINT8;
 756
 757    case PIPE_FORMAT_R16_SINT:
 758       return MESA_FORMAT_R_SINT16;
 759    case PIPE_FORMAT_R16G16_SINT:
 760       return MESA_FORMAT_RG_SINT16;
 761    case PIPE_FORMAT_R16G16B16_SINT:
 762       return MESA_FORMAT_RGB_SINT16;
 763    case PIPE_FORMAT_R16G16B16A16_SINT:
 764       return MESA_FORMAT_RGBA_SINT16;
 765
 766    case PIPE_FORMAT_R32_SINT:
 767       return MESA_FORMAT_R_SINT32;
 768    case PIPE_FORMAT_R32G32_SINT:
 769       return MESA_FORMAT_RG_SINT32;
 770    case PIPE_FORMAT_R32G32B32_SINT:
 771       return MESA_FORMAT_RGB_SINT32;
 772    case PIPE_FORMAT_R32G32B32A32_SINT:
 773       return MESA_FORMAT_RGBA_SINT32;
 774
 775    /* unsigned int formats */
 776    case PIPE_FORMAT_R8_UINT:
 777       return MESA_FORMAT_R_UINT8;
 778    case PIPE_FORMAT_R8G8_UINT:
 779       return MESA_FORMAT_RG_UINT8;
 780    case PIPE_FORMAT_R8G8B8_UINT:
 781       return MESA_FORMAT_RGB_UINT8;
 782    case PIPE_FORMAT_R8G8B8A8_UINT:
 783       return MESA_FORMAT_RGBA_UINT8;
 784
 785    case PIPE_FORMAT_R16_UINT:
 786       return MESA_FORMAT_R_UINT16;
 787    case PIPE_FORMAT_R16G16_UINT:
 788       return MESA_FORMAT_RG_UINT16;
 789    case PIPE_FORMAT_R16G16B16_UINT:
 790       return MESA_FORMAT_RGB_UINT16;
 791    case PIPE_FORMAT_R16G16B16A16_UINT:
 792       return MESA_FORMAT_RGBA_UINT16;
 793
 794    case PIPE_FORMAT_R32_UINT:
 795       return MESA_FORMAT_R_UINT32;
 796    case PIPE_FORMAT_R32G32_UINT:
 797       return MESA_FORMAT_RG_UINT32;
 798    case PIPE_FORMAT_R32G32B32_UINT:
 799       return MESA_FORMAT_RGB_UINT32;
 800    case PIPE_FORMAT_R32G32B32A32_UINT:
 801       return MESA_FORMAT_RGBA_UINT32;
 802
 803    case PIPE_FORMAT_RGTC1_UNORM:
 804       return MESA_FORMAT_R_RGTC1_UNORM;
 805    case PIPE_FORMAT_RGTC1_SNORM:
 806       return MESA_FORMAT_R_RGTC1_SNORM;
 807    case PIPE_FORMAT_RGTC2_UNORM:
 808       return MESA_FORMAT_RG_RGTC2_UNORM;
 809    case PIPE_FORMAT_RGTC2_SNORM:
 810       return MESA_FORMAT_RG_RGTC2_SNORM;
 811
 812    case PIPE_FORMAT_LATC1_UNORM:
 813       return MESA_FORMAT_L_LATC1_UNORM;
 814    case PIPE_FORMAT_LATC1_SNORM:
 815       return MESA_FORMAT_L_LATC1_SNORM;
 816    case PIPE_FORMAT_LATC2_UNORM:
 817       return MESA_FORMAT_LA_LATC2_UNORM;
 818    case PIPE_FORMAT_LATC2_SNORM:
 819       return MESA_FORMAT_LA_LATC2_SNORM;
 820
 821    case PIPE_FORMAT_ETC1_RGB8:
 822       return MESA_FORMAT_ETC1_RGB8;
 823
 824    case PIPE_FORMAT_BPTC_RGBA_UNORM:
 825       return MESA_FORMAT_BPTC_RGBA_UNORM;
 826    case PIPE_FORMAT_BPTC_SRGBA:
 827       return MESA_FORMAT_BPTC_SRGB_ALPHA_UNORM;
 828    case PIPE_FORMAT_BPTC_RGB_FLOAT:
 829       return MESA_FORMAT_BPTC_RGB_SIGNED_FLOAT;
 830    case PIPE_FORMAT_BPTC_RGB_UFLOAT:
 831       return MESA_FORMAT_BPTC_RGB_UNSIGNED_FLOAT;
 832
 833    /* signed normalized formats */
 834    case PIPE_FORMAT_R8_SNORM:
 835       return MESA_FORMAT_R_SNORM8;
 836    case PIPE_FORMAT_RG88_SNORM:
 837       return MESA_FORMAT_R8G8_SNORM;
 838    case PIPE_FORMAT_GR88_SNORM:
 839       return MESA_FORMAT_G8R8_SNORM;
 840    case PIPE_FORMAT_RGBA8888_SNORM:
 841       return MESA_FORMAT_R8G8B8A8_SNORM;
 842    case PIPE_FORMAT_ABGR8888_SNORM:
 843       return MESA_FORMAT_A8B8G8R8_SNORM;
 844
 845    case PIPE_FORMAT_A8_SNORM:
 846       return MESA_FORMAT_A_SNORM8;
 847    case PIPE_FORMAT_L8_SNORM:
 848       return MESA_FORMAT_L_SNORM8;
 849    case PIPE_FORMAT_LA88_SNORM:
 850       return MESA_FORMAT_L8A8_SNORM;
 851    case PIPE_FORMAT_AL88_SNORM:
 852       return MESA_FORMAT_A8L8_SNORM;
 853    case PIPE_FORMAT_I8_SNORM:
 854       return MESA_FORMAT_I_SNORM8;
 855
 856    case PIPE_FORMAT_R16_SNORM:
 857       return MESA_FORMAT_R_SNORM16;
 858    case PIPE_FORMAT_RG1616_SNORM:
 859       return MESA_FORMAT_R16G16_SNORM;
 860    case PIPE_FORMAT_GR1616_SNORM:
 861       return MESA_FORMAT_G16R16_SNORM;
 862    case PIPE_FORMAT_R16G16B16A16_SNORM:
 863       return MESA_FORMAT_RGBA_SNORM16;
 864
 865    case PIPE_FORMAT_A16_SNORM:
 866       return MESA_FORMAT_A_SNORM16;
 867    case PIPE_FORMAT_L16_SNORM:
 868       return MESA_FORMAT_L_SNORM16;
 869    case PIPE_FORMAT_L16A16_SNORM:
 870       return MESA_FORMAT_LA_SNORM16;
 871    case PIPE_FORMAT_I16_SNORM:
 872       return MESA_FORMAT_I_SNORM16;
 873
 874    case PIPE_FORMAT_R9G9B9E5_FLOAT:
 875       return MESA_FORMAT_R9G9B9E5_FLOAT;
 876    case PIPE_FORMAT_R11G11B10_FLOAT:
 877       return MESA_FORMAT_R11G11B10_FLOAT;
 878
 879    case PIPE_FORMAT_B10G10R10A2_UINT:
 880       return MESA_FORMAT_B10G10R10A2_UINT;
 881    case PIPE_FORMAT_R10G10B10A2_UINT:
 882       return MESA_FORMAT_R10G10B10A2_UINT;
 883
 884    case PIPE_FORMAT_B4G4R4X4_UNORM:
 885       return MESA_FORMAT_B4G4R4X4_UNORM;
 886    case PIPE_FORMAT_B5G5R5X1_UNORM:
 887       return MESA_FORMAT_B5G5R5X1_UNORM;
 888    case PIPE_FORMAT_RGBX8888_SNORM:
 889       return MESA_FORMAT_R8G8B8X8_SNORM;
 890    case PIPE_FORMAT_XBGR8888_SNORM:
 891       return MESA_FORMAT_X8B8G8R8_SNORM;
 892    case PIPE_FORMAT_RGBX8888_SRGB:
 893       return MESA_FORMAT_R8G8B8X8_SRGB;
 894    case PIPE_FORMAT_XBGR8888_SRGB:
 895       return MESA_FORMAT_X8B8G8R8_SRGB;
 896    case PIPE_FORMAT_R8G8B8X8_UINT:
 897       return MESA_FORMAT_RGBX_UINT8;
 898    case PIPE_FORMAT_R8G8B8X8_SINT:
 899       return MESA_FORMAT_RGBX_SINT8;
 900    case PIPE_FORMAT_B10G10R10X2_UNORM:
 901       return MESA_FORMAT_B10G10R10X2_UNORM;
 902    case PIPE_FORMAT_R16G16B16X16_UNORM:
 903       return MESA_FORMAT_RGBX_UNORM16;
 904    case PIPE_FORMAT_R16G16B16X16_SNORM:
 905       return MESA_FORMAT_RGBX_SNORM16;
 906    case PIPE_FORMAT_R16G16B16X16_FLOAT:
 907       return MESA_FORMAT_RGBX_FLOAT16;
 908    case PIPE_FORMAT_R16G16B16X16_UINT:
 909       return MESA_FORMAT_RGBX_UINT16;
 910    case PIPE_FORMAT_R16G16B16X16_SINT:
 911       return MESA_FORMAT_RGBX_SINT16;
 912    case PIPE_FORMAT_R32G32B32X32_FLOAT:
 913       return MESA_FORMAT_RGBX_FLOAT32;
 914    case PIPE_FORMAT_R32G32B32X32_UINT:
 915       return MESA_FORMAT_RGBX_UINT32;
 916    case PIPE_FORMAT_R32G32B32X32_SINT:
 917       return MESA_FORMAT_RGBX_SINT32;
 918
 919    case PIPE_FORMAT_BGRX8888_SRGB:
 920       return MESA_FORMAT_B8G8R8X8_SRGB;
 921    case PIPE_FORMAT_XRGB8888_SRGB:
 922       return MESA_FORMAT_X8R8G8B8_SRGB;
 923
 924    case PIPE_FORMAT_ETC2_RGB8:
 925       return MESA_FORMAT_ETC2_RGB8;
 926    case PIPE_FORMAT_ETC2_SRGB8:
 927       return MESA_FORMAT_ETC2_SRGB8;
 928    case PIPE_FORMAT_ETC2_RGB8A1:
 929       return MESA_FORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1;
 930    case PIPE_FORMAT_ETC2_SRGB8A1:
 931       return MESA_FORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1;
 932    case PIPE_FORMAT_ETC2_RGBA8:
 933       return MESA_FORMAT_ETC2_RGBA8_EAC;
 934    case PIPE_FORMAT_ETC2_SRGBA8:
 935       return MESA_FORMAT_ETC2_SRGB8_ALPHA8_EAC;
 936    case PIPE_FORMAT_ETC2_R11_UNORM:
 937       return MESA_FORMAT_ETC2_R11_EAC;
 938    case PIPE_FORMAT_ETC2_R11_SNORM:
 939       return MESA_FORMAT_ETC2_SIGNED_R11_EAC;
 940    case PIPE_FORMAT_ETC2_RG11_UNORM:
 941       return MESA_FORMAT_ETC2_RG11_EAC;
 942    case PIPE_FORMAT_ETC2_RG11_SNORM:
 943       return MESA_FORMAT_ETC2_SIGNED_RG11_EAC;
 944
 945    case PIPE_FORMAT_ASTC_4x4:
 946       return MESA_FORMAT_RGBA_ASTC_4x4;
 947    case PIPE_FORMAT_ASTC_5x4:
 948       return MESA_FORMAT_RGBA_ASTC_5x4;
 949    case PIPE_FORMAT_ASTC_5x5:
 950       return MESA_FORMAT_RGBA_ASTC_5x5;
 951    case PIPE_FORMAT_ASTC_6x5:
 952       return MESA_FORMAT_RGBA_ASTC_6x5;
 953    case PIPE_FORMAT_ASTC_6x6:
 954       return MESA_FORMAT_RGBA_ASTC_6x6;
 955    case PIPE_FORMAT_ASTC_8x5:
 956       return MESA_FORMAT_RGBA_ASTC_8x5;
 957    case PIPE_FORMAT_ASTC_8x6:
 958       return MESA_FORMAT_RGBA_ASTC_8x6;
 959    case PIPE_FORMAT_ASTC_8x8:
 960       return MESA_FORMAT_RGBA_ASTC_8x8;
 961    case PIPE_FORMAT_ASTC_10x5:
 962       return MESA_FORMAT_RGBA_ASTC_10x5;
 963    case PIPE_FORMAT_ASTC_10x6:
 964       return MESA_FORMAT_RGBA_ASTC_10x6;
 965    case PIPE_FORMAT_ASTC_10x8:
 966       return MESA_FORMAT_RGBA_ASTC_10x8;
 967    case PIPE_FORMAT_ASTC_10x10:
 968       return MESA_FORMAT_RGBA_ASTC_10x10;
 969    case PIPE_FORMAT_ASTC_12x10:
 970       return MESA_FORMAT_RGBA_ASTC_12x10;
 971    case PIPE_FORMAT_ASTC_12x12:
 972       return MESA_FORMAT_RGBA_ASTC_12x12;
 973
 974    case PIPE_FORMAT_ASTC_4x4_SRGB:
 975       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_4x4;
 976    case PIPE_FORMAT_ASTC_5x4_SRGB:
 977       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x4;
 978    case PIPE_FORMAT_ASTC_5x5_SRGB:
 979       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5;
 980    case PIPE_FORMAT_ASTC_6x5_SRGB:
 981       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x5;
 982    case PIPE_FORMAT_ASTC_6x6_SRGB:
 983       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_6x6;
 984    case PIPE_FORMAT_ASTC_8x5_SRGB:
 985       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x5;
 986    case PIPE_FORMAT_ASTC_8x6_SRGB:
 987       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x6;
 988    case PIPE_FORMAT_ASTC_8x8_SRGB:
 989       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_8x8;
 990    case PIPE_FORMAT_ASTC_10x5_SRGB:
 991       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x5;
 992    case PIPE_FORMAT_ASTC_10x6_SRGB:
 993       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x6;
 994    case PIPE_FORMAT_ASTC_10x8_SRGB:
 995       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x8;
 996    case PIPE_FORMAT_ASTC_10x10_SRGB:
 997       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_10x10;
 998    case PIPE_FORMAT_ASTC_12x10_SRGB:
 999       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x10;
1000    case PIPE_FORMAT_ASTC_12x12_SRGB:
1001       return MESA_FORMAT_SRGB8_ALPHA8_ASTC_12x12;
1002
1003    default:
1004       return MESA_FORMAT_NONE;
1005    }
1006 }
1007
1008
1009 /**
1010  * Debug only: check that the two functions above correctly map
1011  * Mesa formats to Gallium formats and back again.
1012  */
1013 static void
1014 test_format_conversion(struct st_context *st)
1015 {
1016    GLuint i;
1017
1018    /* test all Mesa formats */
1019    for (i = 1; i < MESA_FORMAT_COUNT; i++) {
1020       enum pipe_format pf;
1021
1022       /* ETC formats are translated differently, skip them. */
1023       if (_mesa_is_format_etc2(i))
1024          continue;
1025       if (i == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)
1026          continue;
1027
1028       pf = st_mesa_format_to_pipe_format(st, i);
1029       if (pf != PIPE_FORMAT_NONE) {
1030          mesa_format mf = st_pipe_format_to_mesa_format(pf);
1031          assert(mf == i);
1032       }
1033    }
1034
1035    /* Test all Gallium formats */
1036    for (i = 1; i < PIPE_FORMAT_COUNT; i++) {
1037       mesa_format mf = st_pipe_format_to_mesa_format(i);
1038
1039       /* ETC formats are translated differently, skip them. */
1040       if (i == PIPE_FORMAT_ETC1_RGB8 && !st->has_etc1)
1041          continue;
1042
1043       if (_mesa_is_format_etc2(mf) && !st->has_etc2)
1044          continue;
1045
1046       if (mf != MESA_FORMAT_NONE) {
1047          enum pipe_format pf = st_mesa_format_to_pipe_format(st, mf);
1048          assert(pf == i);
1049       }
1050    }
1051 }
1052
1053
1054 /**
1055  * Map GL texture formats to Gallium pipe formats.
1056  */
1057 struct format_mapping
1058 {
1059    GLenum glFormats[18];       /**< list of GLenum formats, 0-terminated */
1060    enum pipe_format pipeFormats[13]; /**< list of pipe formats, 0-terminated */
1061 };
1062
1063
1064 #define DEFAULT_RGBA_FORMATS \
1065       PIPE_FORMAT_B8G8R8A8_UNORM, \
1066       PIPE_FORMAT_R8G8B8A8_UNORM, \
1067       PIPE_FORMAT_A8R8G8B8_UNORM, \
1068       PIPE_FORMAT_A8B8G8R8_UNORM, \
1069       0
1070
1071 #define DEFAULT_RGB_FORMATS \
1072       PIPE_FORMAT_B8G8R8X8_UNORM, \
1073       PIPE_FORMAT_R8G8B8X8_UNORM, \
1074       PIPE_FORMAT_X8R8G8B8_UNORM, \
1075       PIPE_FORMAT_X8B8G8R8_UNORM, \
1076       PIPE_FORMAT_B5G6R5_UNORM, \
1077       DEFAULT_RGBA_FORMATS
1078
1079 #define DEFAULT_SRGBA_FORMATS \
1080       PIPE_FORMAT_B8G8R8A8_SRGB, \
1081       PIPE_FORMAT_R8G8B8A8_SRGB, \
1082       PIPE_FORMAT_A8R8G8B8_SRGB, \
1083       PIPE_FORMAT_A8B8G8R8_SRGB, \
1084       0
1085
1086 #define DEFAULT_DEPTH_FORMATS \
1087       PIPE_FORMAT_Z24X8_UNORM, \
1088       PIPE_FORMAT_X8Z24_UNORM, \
1089       PIPE_FORMAT_Z16_UNORM, \
1090       PIPE_FORMAT_Z24_UNORM_S8_UINT, \
1091       PIPE_FORMAT_S8_UINT_Z24_UNORM, \
1092       0
1093
1094 #define DEFAULT_SNORM8_RGBA_FORMATS \
1095       PIPE_FORMAT_R8G8B8A8_SNORM, \
1096       0
1097
1098 #define DEFAULT_UNORM16_RGBA_FORMATS \
1099       PIPE_FORMAT_R16G16B16A16_UNORM, \
1100       DEFAULT_RGBA_FORMATS
1101
1102
1103 /**
1104  * This table maps OpenGL texture format enums to Gallium pipe_format enums.
1105  * Multiple GL enums might map to multiple pipe_formats.
1106  * The first pipe format in the list that's supported is the one that's chosen.
1107  */
1108 static const struct format_mapping format_map[] = {
1109    /* Basic RGB, RGBA formats */
1110    {
1111       { GL_RGB10, 0 },
1112       { PIPE_FORMAT_B10G10R10X2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM,
1113         PIPE_FORMAT_R10G10B10A2_UNORM, DEFAULT_RGB_FORMATS }
1114    },
1115    {
1116       { GL_RGB10_A2, 0 },
1117       { PIPE_FORMAT_R10G10B10A2_UNORM, PIPE_FORMAT_B10G10R10A2_UNORM,
1118         DEFAULT_RGBA_FORMATS }
1119    },
1120    {
1121       { 4, GL_RGBA, GL_RGBA8, 0 },
1122       { PIPE_FORMAT_R8G8B8A8_UNORM, DEFAULT_RGBA_FORMATS }
1123    },
1124    {
1125       { GL_BGRA, 0 },
1126       { DEFAULT_RGBA_FORMATS }
1127    },
1128    {
1129       { 3, GL_RGB, GL_RGB8, 0 },
1130       { PIPE_FORMAT_R8G8B8X8_UNORM, DEFAULT_RGB_FORMATS }
1131    },
1132    {
1133       { GL_RGB12, GL_RGB16, 0 },
1134       { PIPE_FORMAT_R16G16B16X16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
1135         DEFAULT_RGB_FORMATS }
1136    },
1137    {
1138       { GL_RGBA12, GL_RGBA16, 0 },
1139       { PIPE_FORMAT_R16G16B16A16_UNORM, DEFAULT_RGBA_FORMATS }
1140    },
1141    {
1142       { GL_RGBA4, GL_RGBA2, 0 },
1143       { PIPE_FORMAT_B4G4R4A4_UNORM, DEFAULT_RGBA_FORMATS }
1144    },
1145    {
1146       { GL_RGB5_A1, 0 },
1147       { PIPE_FORMAT_B5G5R5A1_UNORM, DEFAULT_RGBA_FORMATS }
1148    },
1149    {
1150       { GL_R3_G3_B2, 0 },
1151       { PIPE_FORMAT_B2G3R3_UNORM, PIPE_FORMAT_B5G6R5_UNORM,
1152         PIPE_FORMAT_B5G5R5A1_UNORM, DEFAULT_RGB_FORMATS }
1153    },
1154    {
1155       { GL_RGB4 },
1156       { PIPE_FORMAT_B4G4R4X4_UNORM, PIPE_FORMAT_B4G4R4A4_UNORM,
1157         DEFAULT_RGB_FORMATS }
1158    },
1159    {
1160       { GL_RGB5 },
1161       { PIPE_FORMAT_B5G5R5X1_UNORM, PIPE_FORMAT_B5G5R5A1_UNORM,
1162         DEFAULT_RGB_FORMATS }
1163    },
1164    {
1165       { GL_RGB565 },
1166       { PIPE_FORMAT_B5G6R5_UNORM, DEFAULT_RGB_FORMATS }
1167    },
1168
1169    /* basic Alpha formats */
1170    {
1171       { GL_ALPHA12, GL_ALPHA16, 0 },
1172       { PIPE_FORMAT_A16_UNORM, PIPE_FORMAT_A8_UNORM,
1173         DEFAULT_RGBA_FORMATS }
1174    },
1175    {
1176       { GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_COMPRESSED_ALPHA, 0 },
1177       { PIPE_FORMAT_A8_UNORM, DEFAULT_RGBA_FORMATS }
1178    },
1179
1180    /* basic Luminance formats */
1181    {
1182       { GL_LUMINANCE12, GL_LUMINANCE16, 0 },
1183       { PIPE_FORMAT_L16_UNORM, PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS }
1184    },
1185    {
1186       { 1, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, 0 },
1187       { PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS }
1188    },
1189
1190    /* basic Luminance/Alpha formats */
1191    {
1192       { GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12,
1193         GL_LUMINANCE16_ALPHA16, 0},
1194       { PIPE_FORMAT_L16A16_UNORM, PIPE_FORMAT_L8A8_UNORM,
1195         DEFAULT_RGBA_FORMATS }
1196    },
1197    {
1198       { 2, GL_LUMINANCE_ALPHA, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, 0 },
1199       { PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
1200    },
1201    {
1202       { GL_LUMINANCE4_ALPHA4, 0 },
1203       { PIPE_FORMAT_L4A4_UNORM, PIPE_FORMAT_L8A8_UNORM,
1204         DEFAULT_RGBA_FORMATS }
1205    },
1206
1207    /* basic Intensity formats */
1208    {
1209       { GL_INTENSITY12, GL_INTENSITY16, 0 },
1210       { PIPE_FORMAT_I16_UNORM, PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
1211    },
1212    {
1213       { GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8,
1214         GL_COMPRESSED_INTENSITY, 0 },
1215       { PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
1216    },
1217
1218    /* YCbCr */
1219    {
1220       { GL_YCBCR_MESA, 0 },
1221       { PIPE_FORMAT_UYVY, PIPE_FORMAT_YUYV, 0 }
1222    },
1223
1224    /* compressed formats */ /* XXX PIPE_BIND_SAMPLER_VIEW only */
1225    {
1226       { GL_COMPRESSED_RGB, 0 },
1227       { PIPE_FORMAT_DXT1_RGB, DEFAULT_RGB_FORMATS }
1228    },
1229    {
1230       { GL_COMPRESSED_RGBA, 0 },
1231       { PIPE_FORMAT_DXT5_RGBA, DEFAULT_RGBA_FORMATS }
1232    },
1233    {
1234       { GL_RGB_S3TC, GL_RGB4_S3TC, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0 },
1235       { PIPE_FORMAT_DXT1_RGB, 0 }
1236    },
1237    {
1238       { GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0 },
1239       { PIPE_FORMAT_DXT1_RGBA, 0 }
1240    },
1241    {
1242       { GL_RGBA_S3TC, GL_RGBA4_S3TC, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0 },
1243       { PIPE_FORMAT_DXT3_RGBA, 0 }
1244    },
1245    {
1246       { GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0 },
1247       { PIPE_FORMAT_DXT5_RGBA, 0 }
1248    },
1249
1250 #if 0
1251    {
1252       { GL_COMPRESSED_RGB_FXT1_3DFX, 0 },
1253       { PIPE_FORMAT_RGB_FXT1, 0 }
1254    },
1255    {
1256       { GL_COMPRESSED_RGBA_FXT1_3DFX, 0 },
1257       { PIPE_FORMAT_RGBA_FXT1, 0 }
1258    },
1259 #endif
1260
1261    /* Depth formats */
1262    {
1263       { GL_DEPTH_COMPONENT16, 0 },
1264       { PIPE_FORMAT_Z16_UNORM, DEFAULT_DEPTH_FORMATS }
1265    },
1266    {
1267       { GL_DEPTH_COMPONENT24, 0 },
1268       { PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_X8Z24_UNORM,
1269         DEFAULT_DEPTH_FORMATS }
1270    },
1271    {
1272       { GL_DEPTH_COMPONENT32, 0 },
1273       { PIPE_FORMAT_Z32_UNORM, DEFAULT_DEPTH_FORMATS }
1274    },
1275    {
1276       { GL_DEPTH_COMPONENT, 0 },
1277       { DEFAULT_DEPTH_FORMATS }
1278    },
1279    {
1280       { GL_DEPTH_COMPONENT32F, 0 },
1281       { PIPE_FORMAT_Z32_FLOAT, 0 }
1282    },
1283
1284    /* stencil formats */
1285    {
1286       { GL_STENCIL_INDEX, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX4_EXT,
1287         GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX16_EXT, 0 },
1288       {
1289          PIPE_FORMAT_S8_UINT, PIPE_FORMAT_Z24_UNORM_S8_UINT,
1290          PIPE_FORMAT_S8_UINT_Z24_UNORM, 0
1291       }
1292    },
1293
1294    /* Depth / Stencil formats */
1295    {
1296       { GL_DEPTH_STENCIL_EXT, GL_DEPTH24_STENCIL8_EXT, 0 },
1297       { PIPE_FORMAT_Z24_UNORM_S8_UINT, PIPE_FORMAT_S8_UINT_Z24_UNORM, 0 }
1298    },
1299    {
1300       { GL_DEPTH32F_STENCIL8, 0 },
1301       { PIPE_FORMAT_Z32_FLOAT_S8X24_UINT, 0 }
1302    },
1303
1304    /* sRGB formats */
1305    {
1306       { GL_SRGB_EXT, GL_SRGB8_EXT, 0 },
1307       { PIPE_FORMAT_R8G8B8X8_SRGB, PIPE_FORMAT_B8G8R8X8_SRGB,
1308         DEFAULT_SRGBA_FORMATS }
1309    },
1310    {
1311       { GL_SRGB_ALPHA_EXT, GL_SRGB8_ALPHA8_EXT, 0 },
1312       { DEFAULT_SRGBA_FORMATS }
1313    },
1314    {
1315       { GL_COMPRESSED_SRGB_EXT, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, 0 },
1316       { PIPE_FORMAT_DXT1_SRGB, PIPE_FORMAT_R8G8B8X8_SRGB,
1317         PIPE_FORMAT_B8G8R8X8_SRGB, DEFAULT_SRGBA_FORMATS }
1318    },
1319    {
1320       { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0 },
1321       { PIPE_FORMAT_DXT1_SRGBA, 0 }
1322    },
1323    {
1324       { GL_COMPRESSED_SRGB_ALPHA_EXT,
1325         GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0 },
1326       { PIPE_FORMAT_DXT3_SRGBA, DEFAULT_SRGBA_FORMATS }
1327    },
1328    {
1329       { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0 },
1330       { PIPE_FORMAT_DXT5_SRGBA, 0 }
1331    },
1332    {
1333       { GL_SLUMINANCE_ALPHA_EXT, GL_SLUMINANCE8_ALPHA8_EXT,
1334         GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, 0 },
1335       { PIPE_FORMAT_L8A8_SRGB, DEFAULT_SRGBA_FORMATS }
1336    },
1337    {
1338       { GL_SLUMINANCE_EXT, GL_SLUMINANCE8_EXT, GL_COMPRESSED_SLUMINANCE_EXT,
1339         0 },
1340       { PIPE_FORMAT_L8_SRGB, DEFAULT_SRGBA_FORMATS }
1341    },
1342
1343    /* 16-bit float formats */
1344    {
1345       { GL_RGBA16F_ARB, 0 },
1346       { PIPE_FORMAT_R16G16B16A16_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1347    },
1348    {
1349       { GL_RGB16F_ARB, 0 },
1350       { PIPE_FORMAT_R16G16B16_FLOAT, PIPE_FORMAT_R16G16B16X16_FLOAT,
1351         PIPE_FORMAT_R16G16B16A16_FLOAT,
1352         PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1353    },
1354    {
1355       { GL_LUMINANCE_ALPHA16F_ARB, 0 },
1356       { PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1357         PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1358    },
1359    {
1360       { GL_ALPHA16F_ARB, 0 },
1361       { PIPE_FORMAT_A16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1362         PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1363         PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1364    },
1365    {
1366       { GL_INTENSITY16F_ARB, 0 },
1367       { PIPE_FORMAT_I16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1368         PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1369         PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1370    },
1371    {
1372       { GL_LUMINANCE16F_ARB, 0 },
1373       { PIPE_FORMAT_L16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1374         PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1375         PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1376    },
1377    {
1378       { GL_R16F, 0 },
1379       { PIPE_FORMAT_R16_FLOAT, PIPE_FORMAT_R16G16_FLOAT,
1380         PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1381         PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1382    },
1383    {
1384       { GL_RG16F, 0 },
1385       { PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1386         PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1387    },
1388
1389    /* 32-bit float formats */
1390    {
1391       { GL_RGBA32F_ARB, 0 },
1392       { PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1393    },
1394    {
1395       { GL_RGB32F_ARB, 0 },
1396       { PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32X32_FLOAT,
1397         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1398    },
1399    {
1400       { GL_LUMINANCE_ALPHA32F_ARB, 0 },
1401       { PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1402    },
1403    {
1404       { GL_ALPHA32F_ARB, 0 },
1405       { PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1406         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1407    },
1408    {
1409       { GL_INTENSITY32F_ARB, 0 },
1410       { PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1411         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1412    },
1413    {
1414       { GL_LUMINANCE32F_ARB, 0 },
1415       { PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1416         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1417    },
1418    {
1419       { GL_R32F, 0 },
1420       { PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32_FLOAT,
1421         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1422    },
1423    {
1424       { GL_RG32F, 0 },
1425       { PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1426    },
1427
1428    /* R, RG formats */
1429    {
1430       { GL_RED, GL_R8, 0 },
1431       { PIPE_FORMAT_R8_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1432    },
1433    {
1434       { GL_RG, GL_RG8, 0 },
1435       { PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1436    },
1437    {
1438       { GL_R16, 0 },
1439       { PIPE_FORMAT_R16_UNORM, PIPE_FORMAT_R16G16_UNORM,
1440         DEFAULT_UNORM16_RGBA_FORMATS }
1441    },
1442    {
1443       { GL_RG16, 0 },
1444       { PIPE_FORMAT_R16G16_UNORM, DEFAULT_UNORM16_RGBA_FORMATS }
1445    },
1446
1447    /* compressed R, RG formats */
1448    {
1449       { GL_COMPRESSED_RED, GL_COMPRESSED_RED_RGTC1, 0 },
1450       { PIPE_FORMAT_RGTC1_UNORM, PIPE_FORMAT_R8_UNORM, DEFAULT_RGBA_FORMATS }
1451    },
1452    {
1453       { GL_COMPRESSED_SIGNED_RED_RGTC1, 0 },
1454       { PIPE_FORMAT_RGTC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1455    },
1456    {
1457       { GL_COMPRESSED_RG, GL_COMPRESSED_RG_RGTC2, 0 },
1458       { PIPE_FORMAT_RGTC2_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1459    },
1460    {
1461       { GL_COMPRESSED_SIGNED_RG_RGTC2, 0 },
1462       { PIPE_FORMAT_RGTC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1463    },
1464    {
1465       { GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_LATC1_EXT, 0 },
1466       { PIPE_FORMAT_LATC1_UNORM, PIPE_FORMAT_L8_UNORM, DEFAULT_RGBA_FORMATS }
1467    },
1468    {
1469       { GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, 0 },
1470       { PIPE_FORMAT_LATC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1471    },
1472    {
1473       { GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT,
1474         GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0 },
1475       { PIPE_FORMAT_LATC2_UNORM, PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
1476    },
1477    {
1478       { GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, 0 },
1479       { PIPE_FORMAT_LATC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1480    },
1481
1482    /* ETC1 */
1483    {
1484       { GL_ETC1_RGB8_OES, 0 },
1485       { PIPE_FORMAT_ETC1_RGB8, 0 }
1486    },
1487
1488    /* ETC2 */
1489    {
1490       { GL_COMPRESSED_RGB8_ETC2, 0 },
1491       { PIPE_FORMAT_ETC2_RGB8, 0 }
1492    },
1493    {
1494       { GL_COMPRESSED_SRGB8_ETC2, 0 },
1495       { PIPE_FORMAT_ETC2_SRGB8, 0 }
1496    },
1497    {
1498       { GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0 },
1499       { PIPE_FORMAT_ETC2_RGB8A1, 0 }
1500    },
1501    {
1502       { GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0 },
1503       { PIPE_FORMAT_ETC2_SRGB8A1, 0 }
1504    },
1505    {
1506       { GL_COMPRESSED_RGBA8_ETC2_EAC, 0 },
1507       { PIPE_FORMAT_ETC2_RGBA8, 0 }
1508    },
1509    {
1510       { GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 0 },
1511       { PIPE_FORMAT_ETC2_SRGBA8, 0 }
1512    },
1513    {
1514       { GL_COMPRESSED_R11_EAC, 0 },
1515       { PIPE_FORMAT_ETC2_R11_UNORM, 0 }
1516    },
1517    {
1518       { GL_COMPRESSED_SIGNED_R11_EAC, 0 },
1519       { PIPE_FORMAT_ETC2_R11_SNORM, 0 }
1520    },
1521    {
1522       { GL_COMPRESSED_RG11_EAC, 0 },
1523       { PIPE_FORMAT_ETC2_RG11_UNORM, 0 }
1524    },
1525    {
1526       { GL_COMPRESSED_SIGNED_RG11_EAC, 0 },
1527       { PIPE_FORMAT_ETC2_RG11_SNORM, 0 }
1528    },
1529
1530    /* BPTC */
1531    {
1532       { GL_COMPRESSED_RGBA_BPTC_UNORM, 0 },
1533       { PIPE_FORMAT_BPTC_RGBA_UNORM, 0 },
1534    },
1535    {
1536       { GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, 0 },
1537       { PIPE_FORMAT_BPTC_SRGBA, 0 },
1538    },
1539    {
1540       { GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, 0 },
1541       { PIPE_FORMAT_BPTC_RGB_FLOAT, 0 },
1542    },
1543    {
1544       { GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, 0 },
1545       { PIPE_FORMAT_BPTC_RGB_UFLOAT, 0 },
1546    },
1547
1548    /* ASTC */
1549    {
1550       { GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 0 },
1551       { PIPE_FORMAT_ASTC_4x4, 0},
1552    },
1553    {
1554       { GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 0 },
1555       { PIPE_FORMAT_ASTC_5x4, 0},
1556    },
1557    {
1558       { GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 0 },
1559       { PIPE_FORMAT_ASTC_5x5, 0},
1560    },
1561    {
1562       { GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 0 },
1563       { PIPE_FORMAT_ASTC_6x5, 0},
1564    },
1565    {
1566       { GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 0 },
1567       { PIPE_FORMAT_ASTC_6x6, 0},
1568    },
1569    {
1570       { GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 0 },
1571       { PIPE_FORMAT_ASTC_8x5, 0},
1572    },
1573    {
1574       { GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 0 },
1575       { PIPE_FORMAT_ASTC_8x6, 0},
1576    },
1577    {
1578       { GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 0 },
1579       { PIPE_FORMAT_ASTC_8x8, 0},
1580    },
1581    {
1582       { GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 0 },
1583       { PIPE_FORMAT_ASTC_10x5, 0},
1584    },
1585    {
1586       { GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 0 },
1587       { PIPE_FORMAT_ASTC_10x6, 0},
1588    },
1589    {
1590       { GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 0 },
1591       { PIPE_FORMAT_ASTC_10x8, 0},
1592    },
1593    {
1594       { GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 0 },
1595       { PIPE_FORMAT_ASTC_10x10, 0},
1596    },
1597    {
1598       { GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 0 },
1599       { PIPE_FORMAT_ASTC_12x10, 0},
1600    },
1601    {
1602       { GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 0 },
1603       { PIPE_FORMAT_ASTC_12x12, 0},
1604    },
1605
1606    {
1607       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0 },
1608       { PIPE_FORMAT_ASTC_4x4_SRGB, 0},
1609    },
1610    {
1611       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0 },
1612       { PIPE_FORMAT_ASTC_5x4_SRGB, 0},
1613    },
1614    {
1615       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0 },
1616       { PIPE_FORMAT_ASTC_5x5_SRGB, 0},
1617    },
1618    {
1619       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0 },
1620       { PIPE_FORMAT_ASTC_6x5_SRGB, 0},
1621    },
1622    {
1623       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0 },
1624       { PIPE_FORMAT_ASTC_6x6_SRGB, 0},
1625    },
1626    {
1627       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0 },
1628       { PIPE_FORMAT_ASTC_8x5_SRGB, 0},
1629    },
1630    {
1631       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0 },
1632       { PIPE_FORMAT_ASTC_8x6_SRGB, 0},
1633    },
1634    {
1635       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0 },
1636       { PIPE_FORMAT_ASTC_8x8_SRGB, 0},
1637    },
1638    {
1639       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0 },
1640       { PIPE_FORMAT_ASTC_10x5_SRGB, 0},
1641    },
1642    {
1643       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0 },
1644       { PIPE_FORMAT_ASTC_10x6_SRGB, 0},
1645    },
1646    {
1647       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0 },
1648       { PIPE_FORMAT_ASTC_10x8_SRGB, 0},
1649    },
1650    {
1651       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0 },
1652       { PIPE_FORMAT_ASTC_10x10_SRGB, 0},
1653    },
1654    {
1655       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0 },
1656       { PIPE_FORMAT_ASTC_12x10_SRGB, 0},
1657    },
1658    {
1659       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0 },
1660       { PIPE_FORMAT_ASTC_12x12_SRGB, 0},
1661    },
1662
1663    /* signed/unsigned integer formats.
1664     */
1665    {
1666       { GL_RGBA_INTEGER_EXT,
1667         GL_BGRA_INTEGER_EXT,
1668         GL_RGBA8I_EXT, 0 },
1669       { PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1670    },
1671    {
1672       { GL_RGB_INTEGER_EXT,
1673         GL_BGR_INTEGER_EXT,
1674         GL_RGB8I_EXT,
1675         GL_BLUE_INTEGER_EXT, 0 },
1676       { PIPE_FORMAT_R8G8B8_SINT, PIPE_FORMAT_R8G8B8X8_SINT,
1677         PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1678    },
1679    {
1680       { GL_ALPHA_INTEGER_EXT,
1681         GL_ALPHA8I_EXT, 0 },
1682       { PIPE_FORMAT_A8_SINT, 0 }
1683    },
1684    {
1685       { GL_ALPHA16I_EXT, 0 },
1686       { PIPE_FORMAT_A16_SINT, 0 }
1687    },
1688    {
1689       { GL_ALPHA32I_EXT, 0 },
1690       { PIPE_FORMAT_A32_SINT, 0 }
1691    },
1692    {
1693       { GL_ALPHA8UI_EXT, 0 },
1694       { PIPE_FORMAT_A8_UINT, 0 }
1695    },
1696    {
1697       { GL_ALPHA16UI_EXT, 0 },
1698       { PIPE_FORMAT_A16_UINT, 0 }
1699    },
1700    {
1701       { GL_ALPHA32UI_EXT, 0 },
1702       { PIPE_FORMAT_A32_UINT, 0 }
1703    },
1704    {
1705       { GL_INTENSITY8I_EXT, 0 },
1706       { PIPE_FORMAT_I8_SINT, 0 }
1707    },
1708    {
1709       { GL_INTENSITY16I_EXT, 0 },
1710       { PIPE_FORMAT_I16_SINT, 0 }
1711    },
1712    {
1713       { GL_INTENSITY32I_EXT, 0 },
1714       { PIPE_FORMAT_I32_SINT, 0 }
1715    },
1716    {
1717       { GL_INTENSITY8UI_EXT, 0 },
1718       { PIPE_FORMAT_I8_UINT, 0 }
1719    },
1720    {
1721       { GL_INTENSITY16UI_EXT, 0 },
1722       { PIPE_FORMAT_I16_UINT, 0 }
1723    },
1724    {
1725       { GL_INTENSITY32UI_EXT, 0 },
1726       { PIPE_FORMAT_I32_UINT, 0 }
1727    },
1728    {
1729       { GL_LUMINANCE8I_EXT, 0 },
1730       { PIPE_FORMAT_L8_SINT, 0 }
1731    },
1732    {
1733       { GL_LUMINANCE16I_EXT, 0 },
1734       { PIPE_FORMAT_L16_SINT, 0 }
1735    },
1736    {
1737       { GL_LUMINANCE32I_EXT, 0 },
1738       { PIPE_FORMAT_L32_SINT, 0 }
1739    },
1740    {
1741       { GL_LUMINANCE_INTEGER_EXT,
1742         GL_LUMINANCE8UI_EXT, 0 },
1743       { PIPE_FORMAT_L8_UINT, 0 }
1744    },
1745    {
1746       { GL_LUMINANCE16UI_EXT, 0 },
1747       { PIPE_FORMAT_L16_UINT, 0 }
1748    },
1749    {
1750       { GL_LUMINANCE32UI_EXT, 0 },
1751       { PIPE_FORMAT_L32_UINT, 0 }
1752    },
1753    {
1754       { GL_LUMINANCE_ALPHA_INTEGER_EXT,
1755         GL_LUMINANCE_ALPHA8I_EXT, 0 },
1756       { PIPE_FORMAT_L8A8_SINT, 0 }
1757    },
1758    {
1759       { GL_LUMINANCE_ALPHA16I_EXT, 0 },
1760       { PIPE_FORMAT_L16A16_SINT, 0 }
1761    },
1762    {
1763       { GL_LUMINANCE_ALPHA32I_EXT, 0 },
1764       { PIPE_FORMAT_L32A32_SINT, 0 }
1765    },
1766    {
1767       { GL_LUMINANCE_ALPHA8UI_EXT, 0 },
1768       { PIPE_FORMAT_L8A8_UINT, 0 }
1769    },
1770    {
1771       { GL_LUMINANCE_ALPHA16UI_EXT, 0 },
1772       { PIPE_FORMAT_L16A16_UINT, 0 }
1773    },
1774    {
1775       { GL_LUMINANCE_ALPHA32UI_EXT, 0 },
1776       { PIPE_FORMAT_L32A32_UINT, 0 }
1777    },
1778    {
1779       { GL_RGB16I_EXT, 0 },
1780       { PIPE_FORMAT_R16G16B16_SINT, PIPE_FORMAT_R16G16B16X16_SINT,
1781         PIPE_FORMAT_R16G16B16A16_SINT, 0 },
1782    },
1783    {
1784       { GL_RGBA16I_EXT, 0 },
1785       { PIPE_FORMAT_R16G16B16A16_SINT, 0 },
1786    },
1787    {
1788       { GL_RGB32I_EXT, 0 },
1789       { PIPE_FORMAT_R32G32B32_SINT, PIPE_FORMAT_R32G32B32X32_SINT,
1790         PIPE_FORMAT_R32G32B32A32_SINT, 0 },
1791    },
1792    {
1793       { GL_RGBA32I_EXT, 0 },
1794       { PIPE_FORMAT_R32G32B32A32_SINT, 0 }
1795    },
1796    {
1797       { GL_RGBA8UI_EXT, 0 },
1798       { PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1799    },
1800    {
1801       { GL_RGB8UI_EXT, 0 },
1802       { PIPE_FORMAT_R8G8B8_UINT, PIPE_FORMAT_R8G8B8X8_UINT,
1803         PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1804    },
1805    {
1806       { GL_RGB16UI_EXT, 0 },
1807       { PIPE_FORMAT_R16G16B16_UINT, PIPE_FORMAT_R16G16B16X16_UINT,
1808         PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1809    },
1810    {
1811       { GL_RGBA16UI_EXT, 0 },
1812       { PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1813    },
1814    {
1815       { GL_RGB32UI_EXT, 0},
1816       { PIPE_FORMAT_R32G32B32_UINT, PIPE_FORMAT_R32G32B32X32_UINT,
1817         PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1818    },
1819    {
1820       { GL_RGBA32UI_EXT, 0},
1821       { PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1822    },
1823    {
1824      { GL_R8I, GL_RED_INTEGER_EXT, 0},
1825      { PIPE_FORMAT_R8_SINT, 0},
1826    },
1827    {
1828      { GL_R16I, 0},
1829      { PIPE_FORMAT_R16_SINT, 0},
1830    },
1831    {
1832      { GL_R32I, 0},
1833      { PIPE_FORMAT_R32_SINT, 0},
1834    },
1835   {
1836      { GL_R8UI, 0},
1837      { PIPE_FORMAT_R8_UINT, 0},
1838    },
1839    {
1840      { GL_R16UI, 0},
1841      { PIPE_FORMAT_R16_UINT, 0},
1842    },
1843    {
1844      { GL_R32UI, 0},
1845      { PIPE_FORMAT_R32_UINT, 0},
1846    },
1847    {
1848      { GL_RG8I, GL_GREEN_INTEGER_EXT, 0},
1849      { PIPE_FORMAT_R8G8_SINT, 0},
1850    },
1851    {
1852      { GL_RG16I, 0},
1853      { PIPE_FORMAT_R16G16_SINT, 0},
1854    },
1855    {
1856      { GL_RG32I, 0},
1857      { PIPE_FORMAT_R32G32_SINT, 0},
1858    },
1859   {
1860      { GL_RG8UI, 0},
1861      { PIPE_FORMAT_R8G8_UINT, 0},
1862    },
1863    {
1864      { GL_RG16UI, 0},
1865      { PIPE_FORMAT_R16G16_UINT, 0},
1866    },
1867    {
1868      { GL_RG32UI, 0},
1869      { PIPE_FORMAT_R32G32_UINT, 0},
1870    },
1871    /* signed normalized formats */
1872    {
1873       { GL_RED_SNORM, GL_R8_SNORM, 0 },
1874       { PIPE_FORMAT_R8_SNORM, PIPE_FORMAT_R8G8_SNORM,
1875         PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1876    },
1877    {
1878       { GL_R16_SNORM, 0 },
1879       { PIPE_FORMAT_R16_SNORM,
1880         PIPE_FORMAT_R16G16_SNORM,
1881         PIPE_FORMAT_R16G16B16A16_SNORM,
1882         PIPE_FORMAT_R8_SNORM,
1883         PIPE_FORMAT_R8G8_SNORM,
1884         PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1885    },
1886    {
1887       { GL_RG_SNORM, GL_RG8_SNORM, 0 },
1888       { PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1889    },
1890    {
1891       { GL_RG16_SNORM, 0 },
1892       { PIPE_FORMAT_R16G16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1893         PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1894    },
1895    {
1896       { GL_RGB_SNORM, GL_RGB8_SNORM, 0 },
1897       { PIPE_FORMAT_R8G8B8X8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1898    },
1899    {
1900       { GL_RGBA_SNORM, GL_RGBA8_SNORM, 0 },
1901       { PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1902    },
1903    {
1904       { GL_RGB16_SNORM, 0 },
1905       { PIPE_FORMAT_R16G16B16X16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1906         PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1907    },
1908    {
1909       { GL_RGBA16_SNORM, 0 },
1910       { PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1911    },
1912    {
1913       { GL_ALPHA_SNORM, GL_ALPHA8_SNORM, 0 },
1914       { PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1915    },
1916    {
1917       { GL_ALPHA16_SNORM, 0 },
1918       { PIPE_FORMAT_A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1919         PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1920    },
1921    {
1922       { GL_LUMINANCE_SNORM, GL_LUMINANCE8_SNORM, 0 },
1923       { PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1924    },
1925    {
1926       { GL_LUMINANCE16_SNORM, 0 },
1927       { PIPE_FORMAT_L16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1928         PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1929    },
1930    {
1931       { GL_LUMINANCE_ALPHA_SNORM, GL_LUMINANCE8_ALPHA8_SNORM, 0 },
1932       { PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1933    },
1934    {
1935       { GL_LUMINANCE16_ALPHA16_SNORM, 0 },
1936       { PIPE_FORMAT_L16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1937         PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1938    },
1939    {
1940       { GL_INTENSITY_SNORM, GL_INTENSITY8_SNORM, 0 },
1941       { PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1942    },
1943    {
1944       { GL_INTENSITY16_SNORM, 0 },
1945       { PIPE_FORMAT_I16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1946         PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1947    },
1948    {
1949       { GL_RGB9_E5, 0 },
1950       { PIPE_FORMAT_R9G9B9E5_FLOAT, 0 }
1951    },
1952    {
1953       { GL_R11F_G11F_B10F, 0 },
1954       { PIPE_FORMAT_R11G11B10_FLOAT, 0 }
1955    },
1956    {
1957       { GL_RGB10_A2UI, 0 },
1958       { PIPE_FORMAT_R10G10B10A2_UINT, PIPE_FORMAT_B10G10R10A2_UINT, 0 }
1959    },
1960 };
1961
1962
1963 /**
1964  * Return first supported format from the given list.
1965  * \param allow_dxt  indicates whether it's OK to return a DXT format.
1966  */
1967 static enum pipe_format
1968 find_supported_format(struct pipe_screen *screen,
1969                       const enum pipe_format formats[],
1970                       enum pipe_texture_target target,
1971                       unsigned sample_count,
1972                       unsigned tex_usage,
1973                       boolean allow_dxt)
1974 {
1975    uint i;
1976    for (i = 0; formats[i]; i++) {
1977       if (screen->is_format_supported(screen, formats[i], target,
1978                                       sample_count, tex_usage)) {
1979          if (!allow_dxt && util_format_is_s3tc(formats[i])) {
1980             /* we can't return a dxt format, continue searching */
1981             continue;
1982          }
1983
1984          return formats[i];
1985       }
1986    }
1987    return PIPE_FORMAT_NONE;
1988 }
1989
1990 struct exact_format_mapping
1991 {
1992    GLenum format;
1993    GLenum type;
1994    enum pipe_format pformat;
1995 };
1996
1997 static const struct exact_format_mapping rgba8888_tbl[] =
1998 {
1999    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_ABGR8888_UNORM },
2000    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_ABGR8888_UNORM },
2001    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_RGBA8888_UNORM },
2002    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_RGBA8888_UNORM },
2003    { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_ARGB8888_UNORM },
2004    { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_BGRA8888_UNORM },
2005    { GL_RGBA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_R8G8B8A8_UNORM },
2006    { GL_ABGR_EXT, GL_UNSIGNED_BYTE,               PIPE_FORMAT_A8B8G8R8_UNORM },
2007    { GL_BGRA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_B8G8R8A8_UNORM },
2008    { 0,           0,                              0                          }
2009 };
2010
2011 static const struct exact_format_mapping rgbx8888_tbl[] =
2012 {
2013    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_XBGR8888_UNORM },
2014    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_XBGR8888_UNORM },
2015    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_RGBX8888_UNORM },
2016    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_RGBX8888_UNORM },
2017    { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_XRGB8888_UNORM },
2018    { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_BGRX8888_UNORM },
2019    { GL_RGBA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_R8G8B8X8_UNORM },
2020    { GL_ABGR_EXT, GL_UNSIGNED_BYTE,               PIPE_FORMAT_X8B8G8R8_UNORM },
2021    { GL_BGRA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_B8G8R8X8_UNORM },
2022    { 0,           0,                              0                          }
2023 };
2024
2025 /**
2026  * For unsized/base internal formats, we may choose a convenient effective
2027  * internal format for {format, type}. If one exists, return that, otherwise
2028  * return PIPE_FORMAT_NONE.
2029  */
2030 static enum pipe_format
2031 find_exact_format(GLint internalFormat, GLenum format, GLenum type)
2032 {
2033    uint i;
2034    const struct exact_format_mapping* tbl;
2035
2036    if (format == GL_NONE || type == GL_NONE)
2037       return PIPE_FORMAT_NONE;
2038
2039    switch (internalFormat) {
2040    case 4:
2041    case GL_RGBA:
2042       tbl = rgba8888_tbl;
2043       break;
2044    case 3:
2045    case GL_RGB:
2046       tbl = rgbx8888_tbl;
2047       break;
2048    default:
2049       return PIPE_FORMAT_NONE;
2050    }
2051
2052    for (i = 0; tbl[i].format; i++)
2053       if (tbl[i].format == format && tbl[i].type == type)
2054          return tbl[i].pformat;
2055
2056    return PIPE_FORMAT_NONE;
2057 }
2058
2059 /**
2060  * Given an OpenGL internalFormat value for a texture or surface, return
2061  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
2062  * This is called during glTexImage2D, for example.
2063  *
2064  * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
2065  * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
2066  * we want render-to-texture ability.
2067  *
2068  * \param internalFormat  the user value passed to glTexImage2D
2069  * \param target  one of PIPE_TEXTURE_x
2070  * \param bindings  bitmask of PIPE_BIND_x flags.
2071  * \param allow_dxt  indicates whether it's OK to return a DXT format.  This
2072  *                   only matters when internalFormat names a generic or
2073  *                   specific compressed format.  And that should only happen
2074  *                   when we're getting called from gl[Copy]TexImage().
2075  */
2076 enum pipe_format
2077 st_choose_format(struct st_context *st, GLenum internalFormat,
2078                  GLenum format, GLenum type,
2079                  enum pipe_texture_target target, unsigned sample_count,
2080                  unsigned bindings, boolean allow_dxt)
2081 {
2082    struct pipe_screen *screen = st->pipe->screen;
2083    unsigned i;
2084    int j;
2085    enum pipe_format pf;
2086
2087 #ifdef DEBUG
2088    {
2089       static boolean firstCall = TRUE;
2090       if (firstCall) {
2091          test_format_conversion(st);
2092          firstCall = FALSE;
2093       }
2094    }
2095 #else
2096    (void) test_format_conversion;
2097 #endif
2098
2099    /* can't render to compressed formats at this time */
2100    if (_mesa_is_compressed_format(st->ctx, internalFormat)
2101        && (bindings & ~PIPE_BIND_SAMPLER_VIEW)) {
2102       return PIPE_FORMAT_NONE;
2103    }
2104
2105    /* search for exact matches */
2106    pf = find_exact_format(internalFormat, format, type);
2107    if (pf != PIPE_FORMAT_NONE &&
2108        screen->is_format_supported(screen, pf,
2109                                    target, sample_count, bindings))
2110       return pf;
2111
2112    /* search table for internalFormat */
2113    for (i = 0; i < ARRAY_SIZE(format_map); i++) {
2114       const struct format_mapping *mapping = &format_map[i];
2115       for (j = 0; mapping->glFormats[j]; j++) {
2116          if (mapping->glFormats[j] == internalFormat) {
2117             /* Found the desired internal format.  Find first pipe format
2118              * which is supported by the driver.
2119              */
2120             return find_supported_format(screen, mapping->pipeFormats,
2121                                          target, sample_count, bindings,
2122                                          allow_dxt);
2123          }
2124       }
2125    }
2126
2127    _mesa_problem(NULL, "unhandled format!\n");
2128    return PIPE_FORMAT_NONE;
2129 }
2130
2131
2132 /**
2133  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
2134  */
2135 enum pipe_format
2136 st_choose_renderbuffer_format(struct st_context *st,
2137                               GLenum internalFormat, unsigned sample_count)
2138 {
2139    uint usage;
2140    if (_mesa_is_depth_or_stencil_format(internalFormat))
2141       usage = PIPE_BIND_DEPTH_STENCIL;
2142    else
2143       usage = PIPE_BIND_RENDER_TARGET;
2144    return st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
2145                            PIPE_TEXTURE_2D, sample_count, usage, FALSE);
2146 }
2147
2148
2149 /**
2150  * Given an OpenGL user-requested format and type, and swapBytes state,
2151  * return the format which exactly matches those parameters, so that
2152  * a memcpy-based transfer can be done.
2153  *
2154  * If no format is supported, return PIPE_FORMAT_NONE.
2155  */
2156 enum pipe_format
2157 st_choose_matching_format(struct st_context *st, unsigned bind,
2158                           GLenum format, GLenum type, GLboolean swapBytes)
2159 {
2160    struct pipe_screen *screen = st->pipe->screen;
2161    mesa_format mesa_format;
2162
2163    for (mesa_format = 1; mesa_format < MESA_FORMAT_COUNT; mesa_format++) {
2164       if (_mesa_get_format_color_encoding(mesa_format) == GL_SRGB) {
2165          continue;
2166       }
2167       if (_mesa_get_format_bits(mesa_format, GL_TEXTURE_INTENSITY_SIZE) > 0) {
2168          /* If `format` is GL_RED/GL_RED_INTEGER, then we might match some
2169           * intensity formats, which we don't want.
2170           */
2171          continue;
2172       }
2173
2174       if (_mesa_format_matches_format_and_type(mesa_format, format, type,
2175                                                swapBytes, NULL)) {
2176          enum pipe_format format =
2177             st_mesa_format_to_pipe_format(st, mesa_format);
2178
2179          if (format &&
2180              screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0,
2181                                          bind)) {
2182             return format;
2183          }
2184          /* It's unlikely to find 2 matching Mesa formats. */
2185          break;
2186       }
2187    }
2188    return PIPE_FORMAT_NONE;
2189 }
2190
2191
2192 /**
2193  * Called via ctx->Driver.ChooseTextureFormat().
2194  */
2195 mesa_format
2196 st_ChooseTextureFormat(struct gl_context *ctx, GLenum target,
2197                        GLint internalFormat,
2198                        GLenum format, GLenum type)
2199 {
2200    struct st_context *st = st_context(ctx);
2201    enum pipe_format pFormat;
2202    mesa_format mFormat;
2203    unsigned bindings;
2204    bool is_renderbuffer = false;
2205    enum pipe_texture_target pTarget;
2206
2207    if (target == GL_RENDERBUFFER) {
2208       pTarget = PIPE_TEXTURE_2D;
2209       is_renderbuffer = true;
2210    } else {
2211       pTarget = gl_target_to_pipe(target);
2212    }
2213
2214    if (target == GL_TEXTURE_1D || target == GL_TEXTURE_1D_ARRAY) {
2215       /* We don't do compression for these texture targets because of
2216        * difficulty with sub-texture updates on non-block boundaries, etc.
2217        * So change the internal format request to an uncompressed format.
2218        */
2219       internalFormat =
2220         _mesa_generic_compressed_format_to_uncompressed_format(internalFormat);
2221    }
2222
2223    /* GL textures may wind up being render targets, but we don't know
2224     * that in advance.  Specify potential render target flags now for formats
2225     * that we know should always be renderable.
2226     */
2227    bindings = PIPE_BIND_SAMPLER_VIEW;
2228    if (_mesa_is_depth_or_stencil_format(internalFormat))
2229       bindings |= PIPE_BIND_DEPTH_STENCIL;
2230    else if (is_renderbuffer || internalFormat == 3 || internalFormat == 4 ||
2231             internalFormat == GL_RGB || internalFormat == GL_RGBA ||
2232             internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
2233             internalFormat == GL_BGRA ||
2234             internalFormat == GL_RGB16F ||
2235             internalFormat == GL_RGBA16F ||
2236             internalFormat == GL_RGB32F ||
2237             internalFormat == GL_RGBA32F)
2238          bindings |= PIPE_BIND_RENDER_TARGET;
2239
2240    /* GLES allows the driver to choose any format which matches
2241     * the format+type combo, because GLES only supports unsized internal
2242     * formats and expects the driver to choose whatever suits it.
2243     */
2244    if (_mesa_is_gles(ctx)) {
2245       GLenum baseFormat = _mesa_base_tex_format(ctx, internalFormat);
2246       GLenum basePackFormat = _mesa_base_pack_format(format);
2247       GLenum iformat = internalFormat;
2248
2249       /* Treat GL_BGRA as GL_RGBA. */
2250       if (iformat == GL_BGRA)
2251          iformat = GL_RGBA;
2252
2253       /* Check if the internalformat is unsized and compatible
2254        * with the "format".
2255        */
2256       if (iformat == baseFormat && iformat == basePackFormat) {
2257          pFormat = st_choose_matching_format(st, bindings, format, type,
2258                                              ctx->Unpack.SwapBytes);
2259
2260          if (pFormat != PIPE_FORMAT_NONE)
2261             return st_pipe_format_to_mesa_format(pFormat);
2262
2263          if (!is_renderbuffer) {
2264             /* try choosing format again, this time without render target bindings */
2265             pFormat = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW,
2266                                                 format, type,
2267                                                 ctx->Unpack.SwapBytes);
2268             if (pFormat != PIPE_FORMAT_NONE)
2269                return st_pipe_format_to_mesa_format(pFormat);
2270          }
2271       }
2272    }
2273
2274    pFormat = st_choose_format(st, internalFormat, format, type,
2275                               pTarget, 0, bindings, ctx->Mesa_DXTn);
2276
2277    if (pFormat == PIPE_FORMAT_NONE && !is_renderbuffer) {
2278       /* try choosing format again, this time without render target bindings */
2279       pFormat = st_choose_format(st, internalFormat, format, type,
2280                                  pTarget, 0, PIPE_BIND_SAMPLER_VIEW,
2281                                  ctx->Mesa_DXTn);
2282    }
2283
2284    if (pFormat == PIPE_FORMAT_NONE) {
2285       /* no luck at all */
2286       return MESA_FORMAT_NONE;
2287    }
2288
2289    mFormat = st_pipe_format_to_mesa_format(pFormat);
2290
2291    /* Debugging aid */
2292    if (0) {
2293       debug_printf("%s(intFormat=%s, format=%s, type=%s) -> %s, %s\n",
2294                    __func__,
2295                    _mesa_enum_to_string(internalFormat),
2296                    _mesa_enum_to_string(format),
2297                    _mesa_enum_to_string(type),
2298                    util_format_name(pFormat),
2299                    _mesa_get_format_name(mFormat));
2300    }
2301
2302    return mFormat;
2303 }
2304
2305
2306 /**
2307  * Called via ctx->Driver.QueryInternalFormat().
2308  */
2309 static size_t
2310 st_QuerySamplesForFormat(struct gl_context *ctx, GLenum target,
2311                          GLenum internalFormat, int samples[16])
2312 {
2313    struct st_context *st = st_context(ctx);
2314    enum pipe_format format;
2315    unsigned i, bind, num_sample_counts = 0;
2316
2317    (void) target;
2318
2319    if (_mesa_is_depth_or_stencil_format(internalFormat))
2320       bind = PIPE_BIND_DEPTH_STENCIL;
2321    else
2322       bind = PIPE_BIND_RENDER_TARGET;
2323
2324    /* If an sRGB framebuffer is unsupported, sRGB formats behave like linear
2325     * formats.
2326     */
2327    if (!ctx->Extensions.EXT_framebuffer_sRGB) {
2328       internalFormat = _mesa_get_linear_internalformat(internalFormat);
2329    }
2330
2331    /* Set sample counts in descending order. */
2332    for (i = 16; i > 1; i--) {
2333       format = st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
2334                                 PIPE_TEXTURE_2D, i, bind, FALSE);
2335
2336       if (format != PIPE_FORMAT_NONE) {
2337          samples[num_sample_counts++] = i;
2338       }
2339    }
2340
2341    if (!num_sample_counts) {
2342       samples[num_sample_counts++] = 1;
2343    }
2344
2345    return num_sample_counts;
2346 }
2347
2348 /**
2349  * ARB_internalformat_query2 driver hook.
2350  */
2351 void
2352 st_QueryInternalFormat(struct gl_context *ctx, GLenum target,
2353                        GLenum internalFormat, GLenum pname, GLint *params)
2354 {
2355    struct st_context *st = st_context(ctx);
2356    /* The API entry-point gives us a temporary params buffer that is non-NULL
2357     * and guaranteed to have at least 16 elements.
2358     */
2359    assert(params != NULL);
2360
2361    switch (pname) {
2362    case GL_SAMPLES:
2363       st_QuerySamplesForFormat(ctx, target, internalFormat, params);
2364       break;
2365
2366    case GL_NUM_SAMPLE_COUNTS: {
2367       size_t num_samples;
2368       num_samples = st_QuerySamplesForFormat(ctx, target, internalFormat,
2369                                              params);
2370       params[0] = (GLint) num_samples;
2371       break;
2372    }
2373    case GL_INTERNALFORMAT_PREFERRED: {
2374       params[0] = GL_NONE;
2375
2376       /* We need to resolve an internal format that is compatible with
2377        * the passed internal format, and optimal to the driver. By now,
2378        * we just validate that the passed internal format is supported by
2379        * the driver, and if so return the same internal format, otherwise
2380        * return GL_NONE.
2381        */
2382       uint usage;
2383       if (_mesa_is_depth_or_stencil_format(internalFormat))
2384          usage = PIPE_BIND_DEPTH_STENCIL;
2385       else
2386          usage = PIPE_BIND_RENDER_TARGET;
2387       enum pipe_format pformat = st_choose_format(st,
2388                                                   internalFormat,
2389                                                   GL_NONE,
2390                                                   GL_NONE,
2391                                                   PIPE_TEXTURE_2D, 1,
2392                                                   usage, FALSE);
2393       if (pformat)
2394          params[0] = internalFormat;
2395       break;
2396    }
2397    default:
2398       /* For the rest of the pnames, we call back the Mesa's default
2399        * function for drivers that don't implement ARB_internalformat_query2.
2400        */
2401       _mesa_query_internal_format_default(ctx, target, internalFormat, pname,
2402                                           params);
2403    }
2404 }
2405
2406 /**
2407  * This is used for translating texture border color and the clear
2408  * color.  For example, the clear color is interpreted according to
2409  * the renderbuffer's base format.  For example, if clearing a
2410  * GL_LUMINANCE buffer, we'll return colorOut[0] = colorOut[1] =
2411  * colorOut[2] = colorIn[0].
2412  * Similarly for texture border colors.
2413  */
2414 void
2415 st_translate_color(const union gl_color_union *colorIn,
2416                    union pipe_color_union *colorOut,
2417                    GLenum baseFormat, GLboolean is_integer)
2418 {
2419    if (is_integer) {
2420       const int *in = colorIn->i;
2421       int *out = colorOut->i;
2422
2423       switch (baseFormat) {
2424       case GL_RED:
2425          out[0] = in[0];
2426          out[1] = 0;
2427          out[2] = 0;
2428          out[3] = 1;
2429          break;
2430       case GL_RG:
2431          out[0] = in[0];
2432          out[1] = in[1];
2433          out[2] = 0;
2434          out[3] = 1;
2435          break;
2436       case GL_RGB:
2437          out[0] = in[0];
2438          out[1] = in[1];
2439          out[2] = in[2];
2440          out[3] = 1;
2441          break;
2442       case GL_ALPHA:
2443          out[0] = out[1] = out[2] = 0;
2444          out[3] = in[3];
2445          break;
2446       case GL_LUMINANCE:
2447          out[0] = out[1] = out[2] = in[0];
2448          out[3] = 1;
2449          break;
2450       case GL_LUMINANCE_ALPHA:
2451          out[0] = out[1] = out[2] = in[0];
2452          out[3] = in[3];
2453          break;
2454       case GL_INTENSITY:
2455          out[0] = out[1] = out[2] = out[3] = in[0];
2456          break;
2457       default:
2458          COPY_4V(out, in);
2459       }
2460    }
2461    else {
2462       const float *in = colorIn->f;
2463       float *out = colorOut->f;
2464
2465       switch (baseFormat) {
2466       case GL_RED:
2467          out[0] = in[0];
2468          out[1] = 0.0F;
2469          out[2] = 0.0F;
2470          out[3] = 1.0F;
2471          break;
2472       case GL_RG:
2473          out[0] = in[0];
2474          out[1] = in[1];
2475          out[2] = 0.0F;
2476          out[3] = 1.0F;
2477          break;
2478       case GL_RGB:
2479          out[0] = in[0];
2480          out[1] = in[1];
2481          out[2] = in[2];
2482          out[3] = 1.0F;
2483          break;
2484       case GL_ALPHA:
2485          out[0] = out[1] = out[2] = 0.0F;
2486          out[3] = in[3];
2487          break;
2488       case GL_LUMINANCE:
2489          out[0] = out[1] = out[2] = in[0];
2490          out[3] = 1.0F;
2491          break;
2492       case GL_LUMINANCE_ALPHA:
2493          out[0] = out[1] = out[2] = in[0];
2494          out[3] = in[3];
2495          break;
2496       case GL_INTENSITY:
2497          out[0] = out[1] = out[2] = out[3] = in[0];
2498          break;
2499       default:
2500          COPY_4V(out, in);
2501       }
2502    }
2503 }