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_R8G8B8A8_UNORM, \
1066       PIPE_FORMAT_B8G8R8A8_UNORM, \
1067       PIPE_FORMAT_A8R8G8B8_UNORM, \
1068       PIPE_FORMAT_A8B8G8R8_UNORM, \
1069       0
1070
1071 #define DEFAULT_RGB_FORMATS \
1072       PIPE_FORMAT_R8G8B8X8_UNORM, \
1073       PIPE_FORMAT_B8G8R8X8_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_R8G8B8A8_SRGB, \
1081       PIPE_FORMAT_B8G8R8A8_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_R16G16B16A16_UNORM,
1173         PIPE_FORMAT_A8_UNORM, 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_R16G16B16A16_UNORM,
1184         PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS }
1185    },
1186    {
1187       { 1, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, 0 },
1188       { PIPE_FORMAT_L8_UNORM, DEFAULT_RGB_FORMATS }
1189    },
1190
1191    /* basic Luminance/Alpha formats */
1192    {
1193       { GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12,
1194         GL_LUMINANCE16_ALPHA16, 0},
1195       { PIPE_FORMAT_L16A16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
1196         PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
1197    },
1198    {
1199       { 2, GL_LUMINANCE_ALPHA, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, 0 },
1200       { PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
1201    },
1202    {
1203       { GL_LUMINANCE4_ALPHA4, 0 },
1204       { PIPE_FORMAT_L4A4_UNORM, PIPE_FORMAT_L8A8_UNORM,
1205         DEFAULT_RGBA_FORMATS }
1206    },
1207
1208    /* basic Intensity formats */
1209    {
1210       { GL_INTENSITY12, GL_INTENSITY16, 0 },
1211       { PIPE_FORMAT_I16_UNORM, PIPE_FORMAT_R16G16B16A16_UNORM,
1212         PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
1213    },
1214    {
1215       { GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8,
1216         GL_COMPRESSED_INTENSITY, 0 },
1217       { PIPE_FORMAT_I8_UNORM, DEFAULT_RGBA_FORMATS }
1218    },
1219
1220    /* YCbCr */
1221    {
1222       { GL_YCBCR_MESA, 0 },
1223       { PIPE_FORMAT_UYVY, PIPE_FORMAT_YUYV, 0 }
1224    },
1225
1226    /* compressed formats */ /* XXX PIPE_BIND_SAMPLER_VIEW only */
1227    {
1228       { GL_COMPRESSED_RGB, 0 },
1229       { PIPE_FORMAT_DXT1_RGB, DEFAULT_RGB_FORMATS }
1230    },
1231    {
1232       { GL_COMPRESSED_RGBA, 0 },
1233       { PIPE_FORMAT_DXT5_RGBA, DEFAULT_RGBA_FORMATS }
1234    },
1235    {
1236       { GL_RGB_S3TC, GL_RGB4_S3TC, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 0 },
1237       { PIPE_FORMAT_DXT1_RGB, 0 }
1238    },
1239    {
1240       { GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 0 },
1241       { PIPE_FORMAT_DXT1_RGBA, 0 }
1242    },
1243    {
1244       { GL_RGBA_S3TC, GL_RGBA4_S3TC, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 0 },
1245       { PIPE_FORMAT_DXT3_RGBA, 0 }
1246    },
1247    {
1248       { GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 0 },
1249       { PIPE_FORMAT_DXT5_RGBA, 0 }
1250    },
1251
1252 #if 0
1253    {
1254       { GL_COMPRESSED_RGB_FXT1_3DFX, 0 },
1255       { PIPE_FORMAT_RGB_FXT1, 0 }
1256    },
1257    {
1258       { GL_COMPRESSED_RGBA_FXT1_3DFX, 0 },
1259       { PIPE_FORMAT_RGBA_FXT1, 0 }
1260    },
1261 #endif
1262
1263    /* Depth formats */
1264    {
1265       { GL_DEPTH_COMPONENT16, 0 },
1266       { PIPE_FORMAT_Z16_UNORM, DEFAULT_DEPTH_FORMATS }
1267    },
1268    {
1269       { GL_DEPTH_COMPONENT24, 0 },
1270       { PIPE_FORMAT_Z24X8_UNORM, PIPE_FORMAT_X8Z24_UNORM,
1271         DEFAULT_DEPTH_FORMATS }
1272    },
1273    {
1274       { GL_DEPTH_COMPONENT32, 0 },
1275       { PIPE_FORMAT_Z32_UNORM, DEFAULT_DEPTH_FORMATS }
1276    },
1277    {
1278       { GL_DEPTH_COMPONENT, 0 },
1279       { DEFAULT_DEPTH_FORMATS }
1280    },
1281    {
1282       { GL_DEPTH_COMPONENT32F, 0 },
1283       { PIPE_FORMAT_Z32_FLOAT, 0 }
1284    },
1285
1286    /* stencil formats */
1287    {
1288       { GL_STENCIL_INDEX, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX4_EXT,
1289         GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX16_EXT, 0 },
1290       {
1291          PIPE_FORMAT_S8_UINT, PIPE_FORMAT_Z24_UNORM_S8_UINT,
1292          PIPE_FORMAT_S8_UINT_Z24_UNORM, 0
1293       }
1294    },
1295
1296    /* Depth / Stencil formats */
1297    {
1298       { GL_DEPTH_STENCIL_EXT, GL_DEPTH24_STENCIL8_EXT, 0 },
1299       { PIPE_FORMAT_Z24_UNORM_S8_UINT, PIPE_FORMAT_S8_UINT_Z24_UNORM, 0 }
1300    },
1301    {
1302       { GL_DEPTH32F_STENCIL8, 0 },
1303       { PIPE_FORMAT_Z32_FLOAT_S8X24_UINT, 0 }
1304    },
1305
1306    /* sRGB formats */
1307    {
1308       { GL_SRGB_EXT, GL_SRGB8_EXT, 0 },
1309       { PIPE_FORMAT_R8G8B8X8_SRGB, PIPE_FORMAT_B8G8R8X8_SRGB,
1310         DEFAULT_SRGBA_FORMATS }
1311    },
1312    {
1313       { GL_SRGB_ALPHA_EXT, GL_SRGB8_ALPHA8_EXT, 0 },
1314       { PIPE_FORMAT_R8G8B8A8_SRGB, DEFAULT_SRGBA_FORMATS }
1315    },
1316    {
1317       { GL_COMPRESSED_SRGB_EXT, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, 0 },
1318       { PIPE_FORMAT_DXT1_SRGB, PIPE_FORMAT_R8G8B8X8_SRGB,
1319         PIPE_FORMAT_B8G8R8X8_SRGB, DEFAULT_SRGBA_FORMATS }
1320    },
1321    {
1322       { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, 0 },
1323       { PIPE_FORMAT_DXT1_SRGBA, 0 }
1324    },
1325    {
1326       { GL_COMPRESSED_SRGB_ALPHA_EXT,
1327         GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, 0 },
1328       { PIPE_FORMAT_DXT3_SRGBA, DEFAULT_SRGBA_FORMATS }
1329    },
1330    {
1331       { GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, 0 },
1332       { PIPE_FORMAT_DXT5_SRGBA, 0 }
1333    },
1334    {
1335       { GL_SLUMINANCE_ALPHA_EXT, GL_SLUMINANCE8_ALPHA8_EXT,
1336         GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, 0 },
1337       { PIPE_FORMAT_L8A8_SRGB, DEFAULT_SRGBA_FORMATS }
1338    },
1339    {
1340       { GL_SLUMINANCE_EXT, GL_SLUMINANCE8_EXT, GL_COMPRESSED_SLUMINANCE_EXT,
1341         0 },
1342       { PIPE_FORMAT_L8_SRGB, DEFAULT_SRGBA_FORMATS }
1343    },
1344
1345    /* 16-bit float formats */
1346    {
1347       { GL_RGBA16F_ARB, 0 },
1348       { PIPE_FORMAT_R16G16B16A16_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1349    },
1350    {
1351       { GL_RGB16F_ARB, 0 },
1352       { PIPE_FORMAT_R16G16B16_FLOAT, PIPE_FORMAT_R16G16B16X16_FLOAT,
1353         PIPE_FORMAT_R16G16B16A16_FLOAT,
1354         PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1355    },
1356    {
1357       { GL_LUMINANCE_ALPHA16F_ARB, 0 },
1358       { PIPE_FORMAT_L16A16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1359         PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1360    },
1361    {
1362       { GL_ALPHA16F_ARB, 0 },
1363       { PIPE_FORMAT_A16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1364         PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1365         PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1366    },
1367    {
1368       { GL_INTENSITY16F_ARB, 0 },
1369       { PIPE_FORMAT_I16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1370         PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1371         PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1372    },
1373    {
1374       { GL_LUMINANCE16F_ARB, 0 },
1375       { PIPE_FORMAT_L16_FLOAT, PIPE_FORMAT_L16A16_FLOAT,
1376         PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1377         PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1378    },
1379    {
1380       { GL_R16F, 0 },
1381       { PIPE_FORMAT_R16_FLOAT, PIPE_FORMAT_R16G16_FLOAT,
1382         PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1383         PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1384    },
1385    {
1386       { GL_RG16F, 0 },
1387       { PIPE_FORMAT_R16G16_FLOAT, PIPE_FORMAT_R16G16B16A16_FLOAT,
1388         PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1389    },
1390
1391    /* 32-bit float formats */
1392    {
1393       { GL_RGBA32F_ARB, 0 },
1394       { PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1395    },
1396    {
1397       { GL_RGB32F_ARB, 0 },
1398       { PIPE_FORMAT_R32G32B32_FLOAT, PIPE_FORMAT_R32G32B32X32_FLOAT,
1399         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1400    },
1401    {
1402       { GL_LUMINANCE_ALPHA32F_ARB, 0 },
1403       { PIPE_FORMAT_L32A32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1404    },
1405    {
1406       { GL_ALPHA32F_ARB, 0 },
1407       { PIPE_FORMAT_A32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1408         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1409    },
1410    {
1411       { GL_INTENSITY32F_ARB, 0 },
1412       { PIPE_FORMAT_I32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1413         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1414    },
1415    {
1416       { GL_LUMINANCE32F_ARB, 0 },
1417       { PIPE_FORMAT_L32_FLOAT, PIPE_FORMAT_L32A32_FLOAT,
1418         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1419    },
1420    {
1421       { GL_R32F, 0 },
1422       { PIPE_FORMAT_R32_FLOAT, PIPE_FORMAT_R32G32_FLOAT,
1423         PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1424    },
1425    {
1426       { GL_RG32F, 0 },
1427       { PIPE_FORMAT_R32G32_FLOAT, PIPE_FORMAT_R32G32B32A32_FLOAT, 0 }
1428    },
1429
1430    /* R, RG formats */
1431    {
1432       { GL_RED, GL_R8, 0 },
1433       { PIPE_FORMAT_R8_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1434    },
1435    {
1436       { GL_RG, GL_RG8, 0 },
1437       { PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1438    },
1439    {
1440       { GL_R16, 0 },
1441       { PIPE_FORMAT_R16_UNORM, PIPE_FORMAT_R16G16_UNORM,
1442         DEFAULT_UNORM16_RGBA_FORMATS }
1443    },
1444    {
1445       { GL_RG16, 0 },
1446       { PIPE_FORMAT_R16G16_UNORM, DEFAULT_UNORM16_RGBA_FORMATS }
1447    },
1448
1449    /* compressed R, RG formats */
1450    {
1451       { GL_COMPRESSED_RED, GL_COMPRESSED_RED_RGTC1, 0 },
1452       { PIPE_FORMAT_RGTC1_UNORM, PIPE_FORMAT_R8_UNORM, DEFAULT_RGBA_FORMATS }
1453    },
1454    {
1455       { GL_COMPRESSED_SIGNED_RED_RGTC1, 0 },
1456       { PIPE_FORMAT_RGTC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1457    },
1458    {
1459       { GL_COMPRESSED_RG, GL_COMPRESSED_RG_RGTC2, 0 },
1460       { PIPE_FORMAT_RGTC2_UNORM, PIPE_FORMAT_R8G8_UNORM, DEFAULT_RGBA_FORMATS }
1461    },
1462    {
1463       { GL_COMPRESSED_SIGNED_RG_RGTC2, 0 },
1464       { PIPE_FORMAT_RGTC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1465    },
1466    {
1467       { GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_LATC1_EXT, 0 },
1468       { PIPE_FORMAT_LATC1_UNORM, PIPE_FORMAT_L8_UNORM, DEFAULT_RGBA_FORMATS }
1469    },
1470    {
1471       { GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT, 0 },
1472       { PIPE_FORMAT_LATC1_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1473    },
1474    {
1475       { GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT,
1476         GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI, 0 },
1477       { PIPE_FORMAT_LATC2_UNORM, PIPE_FORMAT_L8A8_UNORM, DEFAULT_RGBA_FORMATS }
1478    },
1479    {
1480       { GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT, 0 },
1481       { PIPE_FORMAT_LATC2_SNORM, DEFAULT_SNORM8_RGBA_FORMATS }
1482    },
1483
1484    /* ETC1 */
1485    {
1486       { GL_ETC1_RGB8_OES, 0 },
1487       { PIPE_FORMAT_ETC1_RGB8, 0 }
1488    },
1489
1490    /* ETC2 */
1491    {
1492       { GL_COMPRESSED_RGB8_ETC2, 0 },
1493       { PIPE_FORMAT_ETC2_RGB8, 0 }
1494    },
1495    {
1496       { GL_COMPRESSED_SRGB8_ETC2, 0 },
1497       { PIPE_FORMAT_ETC2_SRGB8, 0 }
1498    },
1499    {
1500       { GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0 },
1501       { PIPE_FORMAT_ETC2_RGB8A1, 0 }
1502    },
1503    {
1504       { GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, 0 },
1505       { PIPE_FORMAT_ETC2_SRGB8A1, 0 }
1506    },
1507    {
1508       { GL_COMPRESSED_RGBA8_ETC2_EAC, 0 },
1509       { PIPE_FORMAT_ETC2_RGBA8, 0 }
1510    },
1511    {
1512       { GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, 0 },
1513       { PIPE_FORMAT_ETC2_SRGBA8, 0 }
1514    },
1515    {
1516       { GL_COMPRESSED_R11_EAC, 0 },
1517       { PIPE_FORMAT_ETC2_R11_UNORM, 0 }
1518    },
1519    {
1520       { GL_COMPRESSED_SIGNED_R11_EAC, 0 },
1521       { PIPE_FORMAT_ETC2_R11_SNORM, 0 }
1522    },
1523    {
1524       { GL_COMPRESSED_RG11_EAC, 0 },
1525       { PIPE_FORMAT_ETC2_RG11_UNORM, 0 }
1526    },
1527    {
1528       { GL_COMPRESSED_SIGNED_RG11_EAC, 0 },
1529       { PIPE_FORMAT_ETC2_RG11_SNORM, 0 }
1530    },
1531
1532    /* BPTC */
1533    {
1534       { GL_COMPRESSED_RGBA_BPTC_UNORM, 0 },
1535       { PIPE_FORMAT_BPTC_RGBA_UNORM, 0 },
1536    },
1537    {
1538       { GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, 0 },
1539       { PIPE_FORMAT_BPTC_SRGBA, 0 },
1540    },
1541    {
1542       { GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, 0 },
1543       { PIPE_FORMAT_BPTC_RGB_FLOAT, 0 },
1544    },
1545    {
1546       { GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, 0 },
1547       { PIPE_FORMAT_BPTC_RGB_UFLOAT, 0 },
1548    },
1549
1550    /* ASTC */
1551    {
1552       { GL_COMPRESSED_RGBA_ASTC_4x4_KHR, 0 },
1553       { PIPE_FORMAT_ASTC_4x4, 0},
1554    },
1555    {
1556       { GL_COMPRESSED_RGBA_ASTC_5x4_KHR, 0 },
1557       { PIPE_FORMAT_ASTC_5x4, 0},
1558    },
1559    {
1560       { GL_COMPRESSED_RGBA_ASTC_5x5_KHR, 0 },
1561       { PIPE_FORMAT_ASTC_5x5, 0},
1562    },
1563    {
1564       { GL_COMPRESSED_RGBA_ASTC_6x5_KHR, 0 },
1565       { PIPE_FORMAT_ASTC_6x5, 0},
1566    },
1567    {
1568       { GL_COMPRESSED_RGBA_ASTC_6x6_KHR, 0 },
1569       { PIPE_FORMAT_ASTC_6x6, 0},
1570    },
1571    {
1572       { GL_COMPRESSED_RGBA_ASTC_8x5_KHR, 0 },
1573       { PIPE_FORMAT_ASTC_8x5, 0},
1574    },
1575    {
1576       { GL_COMPRESSED_RGBA_ASTC_8x6_KHR, 0 },
1577       { PIPE_FORMAT_ASTC_8x6, 0},
1578    },
1579    {
1580       { GL_COMPRESSED_RGBA_ASTC_8x8_KHR, 0 },
1581       { PIPE_FORMAT_ASTC_8x8, 0},
1582    },
1583    {
1584       { GL_COMPRESSED_RGBA_ASTC_10x5_KHR, 0 },
1585       { PIPE_FORMAT_ASTC_10x5, 0},
1586    },
1587    {
1588       { GL_COMPRESSED_RGBA_ASTC_10x6_KHR, 0 },
1589       { PIPE_FORMAT_ASTC_10x6, 0},
1590    },
1591    {
1592       { GL_COMPRESSED_RGBA_ASTC_10x8_KHR, 0 },
1593       { PIPE_FORMAT_ASTC_10x8, 0},
1594    },
1595    {
1596       { GL_COMPRESSED_RGBA_ASTC_10x10_KHR, 0 },
1597       { PIPE_FORMAT_ASTC_10x10, 0},
1598    },
1599    {
1600       { GL_COMPRESSED_RGBA_ASTC_12x10_KHR, 0 },
1601       { PIPE_FORMAT_ASTC_12x10, 0},
1602    },
1603    {
1604       { GL_COMPRESSED_RGBA_ASTC_12x12_KHR, 0 },
1605       { PIPE_FORMAT_ASTC_12x12, 0},
1606    },
1607
1608    {
1609       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, 0 },
1610       { PIPE_FORMAT_ASTC_4x4_SRGB, 0},
1611    },
1612    {
1613       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, 0 },
1614       { PIPE_FORMAT_ASTC_5x4_SRGB, 0},
1615    },
1616    {
1617       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, 0 },
1618       { PIPE_FORMAT_ASTC_5x5_SRGB, 0},
1619    },
1620    {
1621       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, 0 },
1622       { PIPE_FORMAT_ASTC_6x5_SRGB, 0},
1623    },
1624    {
1625       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, 0 },
1626       { PIPE_FORMAT_ASTC_6x6_SRGB, 0},
1627    },
1628    {
1629       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, 0 },
1630       { PIPE_FORMAT_ASTC_8x5_SRGB, 0},
1631    },
1632    {
1633       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, 0 },
1634       { PIPE_FORMAT_ASTC_8x6_SRGB, 0},
1635    },
1636    {
1637       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, 0 },
1638       { PIPE_FORMAT_ASTC_8x8_SRGB, 0},
1639    },
1640    {
1641       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, 0 },
1642       { PIPE_FORMAT_ASTC_10x5_SRGB, 0},
1643    },
1644    {
1645       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, 0 },
1646       { PIPE_FORMAT_ASTC_10x6_SRGB, 0},
1647    },
1648    {
1649       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, 0 },
1650       { PIPE_FORMAT_ASTC_10x8_SRGB, 0},
1651    },
1652    {
1653       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, 0 },
1654       { PIPE_FORMAT_ASTC_10x10_SRGB, 0},
1655    },
1656    {
1657       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, 0 },
1658       { PIPE_FORMAT_ASTC_12x10_SRGB, 0},
1659    },
1660    {
1661       { GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, 0 },
1662       { PIPE_FORMAT_ASTC_12x12_SRGB, 0},
1663    },
1664
1665    /* signed/unsigned integer formats.
1666     */
1667    {
1668       { GL_RGBA_INTEGER_EXT,
1669         GL_BGRA_INTEGER_EXT,
1670         GL_RGBA8I_EXT, 0 },
1671       { PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1672    },
1673    {
1674       { GL_RGB_INTEGER_EXT,
1675         GL_BGR_INTEGER_EXT,
1676         GL_RGB8I_EXT,
1677         GL_BLUE_INTEGER_EXT, 0 },
1678       { PIPE_FORMAT_R8G8B8_SINT, PIPE_FORMAT_R8G8B8X8_SINT,
1679         PIPE_FORMAT_R8G8B8A8_SINT, 0 }
1680    },
1681    {
1682       { GL_ALPHA_INTEGER_EXT,
1683         GL_ALPHA8I_EXT, 0 },
1684       { PIPE_FORMAT_A8_SINT, 0 }
1685    },
1686    {
1687       { GL_ALPHA16I_EXT, 0 },
1688       { PIPE_FORMAT_A16_SINT, 0 }
1689    },
1690    {
1691       { GL_ALPHA32I_EXT, 0 },
1692       { PIPE_FORMAT_A32_SINT, 0 }
1693    },
1694    {
1695       { GL_ALPHA8UI_EXT, 0 },
1696       { PIPE_FORMAT_A8_UINT, 0 }
1697    },
1698    {
1699       { GL_ALPHA16UI_EXT, 0 },
1700       { PIPE_FORMAT_A16_UINT, 0 }
1701    },
1702    {
1703       { GL_ALPHA32UI_EXT, 0 },
1704       { PIPE_FORMAT_A32_UINT, 0 }
1705    },
1706    {
1707       { GL_INTENSITY8I_EXT, 0 },
1708       { PIPE_FORMAT_I8_SINT, 0 }
1709    },
1710    {
1711       { GL_INTENSITY16I_EXT, 0 },
1712       { PIPE_FORMAT_I16_SINT, 0 }
1713    },
1714    {
1715       { GL_INTENSITY32I_EXT, 0 },
1716       { PIPE_FORMAT_I32_SINT, 0 }
1717    },
1718    {
1719       { GL_INTENSITY8UI_EXT, 0 },
1720       { PIPE_FORMAT_I8_UINT, 0 }
1721    },
1722    {
1723       { GL_INTENSITY16UI_EXT, 0 },
1724       { PIPE_FORMAT_I16_UINT, 0 }
1725    },
1726    {
1727       { GL_INTENSITY32UI_EXT, 0 },
1728       { PIPE_FORMAT_I32_UINT, 0 }
1729    },
1730    {
1731       { GL_LUMINANCE8I_EXT, 0 },
1732       { PIPE_FORMAT_L8_SINT, 0 }
1733    },
1734    {
1735       { GL_LUMINANCE16I_EXT, 0 },
1736       { PIPE_FORMAT_L16_SINT, 0 }
1737    },
1738    {
1739       { GL_LUMINANCE32I_EXT, 0 },
1740       { PIPE_FORMAT_L32_SINT, 0 }
1741    },
1742    {
1743       { GL_LUMINANCE_INTEGER_EXT,
1744         GL_LUMINANCE8UI_EXT, 0 },
1745       { PIPE_FORMAT_L8_UINT, 0 }
1746    },
1747    {
1748       { GL_LUMINANCE16UI_EXT, 0 },
1749       { PIPE_FORMAT_L16_UINT, 0 }
1750    },
1751    {
1752       { GL_LUMINANCE32UI_EXT, 0 },
1753       { PIPE_FORMAT_L32_UINT, 0 }
1754    },
1755    {
1756       { GL_LUMINANCE_ALPHA_INTEGER_EXT,
1757         GL_LUMINANCE_ALPHA8I_EXT, 0 },
1758       { PIPE_FORMAT_L8A8_SINT, 0 }
1759    },
1760    {
1761       { GL_LUMINANCE_ALPHA16I_EXT, 0 },
1762       { PIPE_FORMAT_L16A16_SINT, 0 }
1763    },
1764    {
1765       { GL_LUMINANCE_ALPHA32I_EXT, 0 },
1766       { PIPE_FORMAT_L32A32_SINT, 0 }
1767    },
1768    {
1769       { GL_LUMINANCE_ALPHA8UI_EXT, 0 },
1770       { PIPE_FORMAT_L8A8_UINT, 0 }
1771    },
1772    {
1773       { GL_LUMINANCE_ALPHA16UI_EXT, 0 },
1774       { PIPE_FORMAT_L16A16_UINT, 0 }
1775    },
1776    {
1777       { GL_LUMINANCE_ALPHA32UI_EXT, 0 },
1778       { PIPE_FORMAT_L32A32_UINT, 0 }
1779    },
1780    {
1781       { GL_RGB16I_EXT, 0 },
1782       { PIPE_FORMAT_R16G16B16_SINT, PIPE_FORMAT_R16G16B16X16_SINT,
1783         PIPE_FORMAT_R16G16B16A16_SINT, 0 },
1784    },
1785    {
1786       { GL_RGBA16I_EXT, 0 },
1787       { PIPE_FORMAT_R16G16B16A16_SINT, 0 },
1788    },
1789    {
1790       { GL_RGB32I_EXT, 0 },
1791       { PIPE_FORMAT_R32G32B32_SINT, PIPE_FORMAT_R32G32B32X32_SINT,
1792         PIPE_FORMAT_R32G32B32A32_SINT, 0 },
1793    },
1794    {
1795       { GL_RGBA32I_EXT, 0 },
1796       { PIPE_FORMAT_R32G32B32A32_SINT, 0 }
1797    },
1798    {
1799       { GL_RGBA8UI_EXT, 0 },
1800       { PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1801    },
1802    {
1803       { GL_RGB8UI_EXT, 0 },
1804       { PIPE_FORMAT_R8G8B8_UINT, PIPE_FORMAT_R8G8B8X8_UINT,
1805         PIPE_FORMAT_R8G8B8A8_UINT, 0 }
1806    },
1807    {
1808       { GL_RGB16UI_EXT, 0 },
1809       { PIPE_FORMAT_R16G16B16_UINT, PIPE_FORMAT_R16G16B16X16_UINT,
1810         PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1811    },
1812    {
1813       { GL_RGBA16UI_EXT, 0 },
1814       { PIPE_FORMAT_R16G16B16A16_UINT, 0 }
1815    },
1816    {
1817       { GL_RGB32UI_EXT, 0},
1818       { PIPE_FORMAT_R32G32B32_UINT, PIPE_FORMAT_R32G32B32X32_UINT,
1819         PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1820    },
1821    {
1822       { GL_RGBA32UI_EXT, 0},
1823       { PIPE_FORMAT_R32G32B32A32_UINT, 0 }
1824    },
1825    {
1826      { GL_R8I, GL_RED_INTEGER_EXT, 0},
1827      { PIPE_FORMAT_R8_SINT, 0},
1828    },
1829    {
1830      { GL_R16I, 0},
1831      { PIPE_FORMAT_R16_SINT, 0},
1832    },
1833    {
1834      { GL_R32I, 0},
1835      { PIPE_FORMAT_R32_SINT, 0},
1836    },
1837   {
1838      { GL_R8UI, 0},
1839      { PIPE_FORMAT_R8_UINT, 0},
1840    },
1841    {
1842      { GL_R16UI, 0},
1843      { PIPE_FORMAT_R16_UINT, 0},
1844    },
1845    {
1846      { GL_R32UI, 0},
1847      { PIPE_FORMAT_R32_UINT, 0},
1848    },
1849    {
1850      { GL_RG8I, GL_GREEN_INTEGER_EXT, 0},
1851      { PIPE_FORMAT_R8G8_SINT, 0},
1852    },
1853    {
1854      { GL_RG16I, 0},
1855      { PIPE_FORMAT_R16G16_SINT, 0},
1856    },
1857    {
1858      { GL_RG32I, 0},
1859      { PIPE_FORMAT_R32G32_SINT, 0},
1860    },
1861   {
1862      { GL_RG8UI, 0},
1863      { PIPE_FORMAT_R8G8_UINT, 0},
1864    },
1865    {
1866      { GL_RG16UI, 0},
1867      { PIPE_FORMAT_R16G16_UINT, 0},
1868    },
1869    {
1870      { GL_RG32UI, 0},
1871      { PIPE_FORMAT_R32G32_UINT, 0},
1872    },
1873    /* signed normalized formats */
1874    {
1875       { GL_RED_SNORM, GL_R8_SNORM, 0 },
1876       { PIPE_FORMAT_R8_SNORM, PIPE_FORMAT_R8G8_SNORM,
1877         PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1878    },
1879    {
1880       { GL_R16_SNORM, 0 },
1881       { PIPE_FORMAT_R16_SNORM,
1882         PIPE_FORMAT_R16G16_SNORM,
1883         PIPE_FORMAT_R16G16B16A16_SNORM,
1884         PIPE_FORMAT_R8_SNORM,
1885         PIPE_FORMAT_R8G8_SNORM,
1886         PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1887    },
1888    {
1889       { GL_RG_SNORM, GL_RG8_SNORM, 0 },
1890       { PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1891    },
1892    {
1893       { GL_RG16_SNORM, 0 },
1894       { PIPE_FORMAT_R16G16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1895         PIPE_FORMAT_R8G8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1896    },
1897    {
1898       { GL_RGB_SNORM, GL_RGB8_SNORM, 0 },
1899       { PIPE_FORMAT_R8G8B8X8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1900    },
1901    {
1902       { GL_RGBA_SNORM, GL_RGBA8_SNORM, 0 },
1903       { PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1904    },
1905    {
1906       { GL_RGB16_SNORM, 0 },
1907       { PIPE_FORMAT_R16G16B16X16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1908         PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1909    },
1910    {
1911       { GL_RGBA16_SNORM, 0 },
1912       { PIPE_FORMAT_R16G16B16A16_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1913    },
1914    {
1915       { GL_ALPHA_SNORM, GL_ALPHA8_SNORM, 0 },
1916       { PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1917    },
1918    {
1919       { GL_ALPHA16_SNORM, 0 },
1920       { PIPE_FORMAT_A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1921         PIPE_FORMAT_A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1922    },
1923    {
1924       { GL_LUMINANCE_SNORM, GL_LUMINANCE8_SNORM, 0 },
1925       { PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1926    },
1927    {
1928       { GL_LUMINANCE16_SNORM, 0 },
1929       { PIPE_FORMAT_L16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1930         PIPE_FORMAT_L8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1931    },
1932    {
1933       { GL_LUMINANCE_ALPHA_SNORM, GL_LUMINANCE8_ALPHA8_SNORM, 0 },
1934       { PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1935    },
1936    {
1937       { GL_LUMINANCE16_ALPHA16_SNORM, 0 },
1938       { PIPE_FORMAT_L16A16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1939         PIPE_FORMAT_L8A8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1940    },
1941    {
1942       { GL_INTENSITY_SNORM, GL_INTENSITY8_SNORM, 0 },
1943       { PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1944    },
1945    {
1946       { GL_INTENSITY16_SNORM, 0 },
1947       { PIPE_FORMAT_I16_SNORM, PIPE_FORMAT_R16G16B16A16_SNORM,
1948         PIPE_FORMAT_I8_SNORM, PIPE_FORMAT_R8G8B8A8_SNORM, 0 }
1949    },
1950    {
1951       { GL_RGB9_E5, 0 },
1952       { PIPE_FORMAT_R9G9B9E5_FLOAT, 0 }
1953    },
1954    {
1955       { GL_R11F_G11F_B10F, 0 },
1956       { PIPE_FORMAT_R11G11B10_FLOAT, 0 }
1957    },
1958    {
1959       { GL_RGB10_A2UI, 0 },
1960       { PIPE_FORMAT_R10G10B10A2_UINT, PIPE_FORMAT_B10G10R10A2_UINT, 0 }
1961    },
1962 };
1963
1964
1965 /**
1966  * Return first supported format from the given list.
1967  * \param allow_dxt  indicates whether it's OK to return a DXT format.
1968  */
1969 static enum pipe_format
1970 find_supported_format(struct pipe_screen *screen,
1971                       const enum pipe_format formats[],
1972                       enum pipe_texture_target target,
1973                       unsigned sample_count,
1974                       unsigned tex_usage,
1975                       boolean allow_dxt)
1976 {
1977    uint i;
1978    for (i = 0; formats[i]; i++) {
1979       if (screen->is_format_supported(screen, formats[i], target,
1980                                       sample_count, tex_usage)) {
1981          if (!allow_dxt && util_format_is_s3tc(formats[i])) {
1982             /* we can't return a dxt format, continue searching */
1983             continue;
1984          }
1985
1986          return formats[i];
1987       }
1988    }
1989    return PIPE_FORMAT_NONE;
1990 }
1991
1992 struct exact_format_mapping
1993 {
1994    GLenum format;
1995    GLenum type;
1996    enum pipe_format pformat;
1997 };
1998
1999 static const struct exact_format_mapping rgba8888_tbl[] =
2000 {
2001    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_ABGR8888_UNORM },
2002    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_ABGR8888_UNORM },
2003    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_RGBA8888_UNORM },
2004    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_RGBA8888_UNORM },
2005    { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_ARGB8888_UNORM },
2006    { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_BGRA8888_UNORM },
2007    { GL_RGBA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_R8G8B8A8_UNORM },
2008    { GL_ABGR_EXT, GL_UNSIGNED_BYTE,               PIPE_FORMAT_A8B8G8R8_UNORM },
2009    { GL_BGRA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_B8G8R8A8_UNORM },
2010    { 0,           0,                              0                          }
2011 };
2012
2013 static const struct exact_format_mapping rgbx8888_tbl[] =
2014 {
2015    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_XBGR8888_UNORM },
2016    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_XBGR8888_UNORM },
2017    { GL_RGBA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_RGBX8888_UNORM },
2018    { GL_ABGR_EXT, GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_RGBX8888_UNORM },
2019    { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8,        PIPE_FORMAT_XRGB8888_UNORM },
2020    { GL_BGRA,     GL_UNSIGNED_INT_8_8_8_8_REV,    PIPE_FORMAT_BGRX8888_UNORM },
2021    { GL_RGBA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_R8G8B8X8_UNORM },
2022    { GL_ABGR_EXT, GL_UNSIGNED_BYTE,               PIPE_FORMAT_X8B8G8R8_UNORM },
2023    { GL_BGRA,     GL_UNSIGNED_BYTE,               PIPE_FORMAT_B8G8R8X8_UNORM },
2024    { 0,           0,                              0                          }
2025 };
2026
2027 /**
2028  * For unsized/base internal formats, we may choose a convenient effective
2029  * internal format for {format, type}. If one exists, return that, otherwise
2030  * return PIPE_FORMAT_NONE.
2031  */
2032 static enum pipe_format
2033 find_exact_format(GLint internalFormat, GLenum format, GLenum type)
2034 {
2035    uint i;
2036    const struct exact_format_mapping* tbl;
2037
2038    if (format == GL_NONE || type == GL_NONE)
2039       return PIPE_FORMAT_NONE;
2040
2041    switch (internalFormat) {
2042    case 4:
2043    case GL_RGBA:
2044       tbl = rgba8888_tbl;
2045       break;
2046    case 3:
2047    case GL_RGB:
2048       tbl = rgbx8888_tbl;
2049       break;
2050    default:
2051       return PIPE_FORMAT_NONE;
2052    }
2053
2054    for (i = 0; tbl[i].format; i++)
2055       if (tbl[i].format == format && tbl[i].type == type)
2056          return tbl[i].pformat;
2057
2058    return PIPE_FORMAT_NONE;
2059 }
2060
2061 /**
2062  * Given an OpenGL internalFormat value for a texture or surface, return
2063  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
2064  * This is called during glTexImage2D, for example.
2065  *
2066  * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
2067  * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
2068  * we want render-to-texture ability.
2069  *
2070  * \param internalFormat  the user value passed to glTexImage2D
2071  * \param target  one of PIPE_TEXTURE_x
2072  * \param bindings  bitmask of PIPE_BIND_x flags.
2073  * \param allow_dxt  indicates whether it's OK to return a DXT format.  This
2074  *                   only matters when internalFormat names a generic or
2075  *                   specific compressed format.  And that should only happen
2076  *                   when we're getting called from gl[Copy]TexImage().
2077  */
2078 enum pipe_format
2079 st_choose_format(struct st_context *st, GLenum internalFormat,
2080                  GLenum format, GLenum type,
2081                  enum pipe_texture_target target, unsigned sample_count,
2082                  unsigned bindings, boolean allow_dxt)
2083 {
2084    struct pipe_screen *screen = st->pipe->screen;
2085    unsigned i;
2086    int j;
2087    enum pipe_format pf;
2088
2089 #ifdef DEBUG
2090    {
2091       static boolean firstCall = TRUE;
2092       if (firstCall) {
2093          test_format_conversion(st);
2094          firstCall = FALSE;
2095       }
2096    }
2097 #else
2098    (void) test_format_conversion;
2099 #endif
2100
2101    /* can't render to compressed formats at this time */
2102    if (_mesa_is_compressed_format(st->ctx, internalFormat)
2103        && (bindings & ~PIPE_BIND_SAMPLER_VIEW)) {
2104       return PIPE_FORMAT_NONE;
2105    }
2106
2107    /* search for exact matches */
2108    pf = find_exact_format(internalFormat, format, type);
2109    if (pf != PIPE_FORMAT_NONE &&
2110        screen->is_format_supported(screen, pf,
2111                                    target, sample_count, bindings))
2112       return pf;
2113
2114    /* search table for internalFormat */
2115    for (i = 0; i < ARRAY_SIZE(format_map); i++) {
2116       const struct format_mapping *mapping = &format_map[i];
2117       for (j = 0; mapping->glFormats[j]; j++) {
2118          if (mapping->glFormats[j] == internalFormat) {
2119             /* Found the desired internal format.  Find first pipe format
2120              * which is supported by the driver.
2121              */
2122             return find_supported_format(screen, mapping->pipeFormats,
2123                                          target, sample_count, bindings,
2124                                          allow_dxt);
2125          }
2126       }
2127    }
2128
2129    _mesa_problem(NULL, "unhandled format!\n");
2130    return PIPE_FORMAT_NONE;
2131 }
2132
2133
2134 /**
2135  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
2136  */
2137 enum pipe_format
2138 st_choose_renderbuffer_format(struct st_context *st,
2139                               GLenum internalFormat, unsigned sample_count)
2140 {
2141    uint usage;
2142    if (_mesa_is_depth_or_stencil_format(internalFormat))
2143       usage = PIPE_BIND_DEPTH_STENCIL;
2144    else
2145       usage = PIPE_BIND_RENDER_TARGET;
2146    return st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
2147                            PIPE_TEXTURE_2D, sample_count, usage, FALSE);
2148 }
2149
2150
2151 /**
2152  * Given an OpenGL user-requested format and type, and swapBytes state,
2153  * return the format which exactly matches those parameters, so that
2154  * a memcpy-based transfer can be done.
2155  *
2156  * If no format is supported, return PIPE_FORMAT_NONE.
2157  */
2158 enum pipe_format
2159 st_choose_matching_format(struct st_context *st, unsigned bind,
2160                           GLenum format, GLenum type, GLboolean swapBytes)
2161 {
2162    struct pipe_screen *screen = st->pipe->screen;
2163    mesa_format mesa_format;
2164
2165    for (mesa_format = 1; mesa_format < MESA_FORMAT_COUNT; mesa_format++) {
2166       if (_mesa_get_format_color_encoding(mesa_format) == GL_SRGB) {
2167          continue;
2168       }
2169       if (_mesa_get_format_bits(mesa_format, GL_TEXTURE_INTENSITY_SIZE) > 0) {
2170          /* If `format` is GL_RED/GL_RED_INTEGER, then we might match some
2171           * intensity formats, which we don't want.
2172           */
2173          continue;
2174       }
2175
2176       if (_mesa_format_matches_format_and_type(mesa_format, format, type,
2177                                                swapBytes, NULL)) {
2178          enum pipe_format format =
2179             st_mesa_format_to_pipe_format(st, mesa_format);
2180
2181          if (format &&
2182              screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0,
2183                                          bind)) {
2184             return format;
2185          }
2186          /* It's unlikely to find 2 matching Mesa formats. */
2187          break;
2188       }
2189    }
2190    return PIPE_FORMAT_NONE;
2191 }
2192
2193
2194 /**
2195  * Called via ctx->Driver.ChooseTextureFormat().
2196  */
2197 mesa_format
2198 st_ChooseTextureFormat(struct gl_context *ctx, GLenum target,
2199                        GLint internalFormat,
2200                        GLenum format, GLenum type)
2201 {
2202    struct st_context *st = st_context(ctx);
2203    enum pipe_format pFormat;
2204    mesa_format mFormat;
2205    unsigned bindings;
2206    bool is_renderbuffer = false;
2207    enum pipe_texture_target pTarget;
2208
2209    if (target == GL_RENDERBUFFER) {
2210       pTarget = PIPE_TEXTURE_2D;
2211       is_renderbuffer = true;
2212    } else {
2213       pTarget = gl_target_to_pipe(target);
2214    }
2215
2216    if (target == GL_TEXTURE_1D || target == GL_TEXTURE_1D_ARRAY) {
2217       /* We don't do compression for these texture targets because of
2218        * difficulty with sub-texture updates on non-block boundaries, etc.
2219        * So change the internal format request to an uncompressed format.
2220        */
2221       internalFormat =
2222         _mesa_generic_compressed_format_to_uncompressed_format(internalFormat);
2223    }
2224
2225    /* GL textures may wind up being render targets, but we don't know
2226     * that in advance.  Specify potential render target flags now for formats
2227     * that we know should always be renderable.
2228     */
2229    bindings = PIPE_BIND_SAMPLER_VIEW;
2230    if (_mesa_is_depth_or_stencil_format(internalFormat))
2231       bindings |= PIPE_BIND_DEPTH_STENCIL;
2232    else if (is_renderbuffer || internalFormat == 3 || internalFormat == 4 ||
2233             internalFormat == GL_RGB || internalFormat == GL_RGBA ||
2234             internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
2235             internalFormat == GL_BGRA ||
2236             internalFormat == GL_RGB16F ||
2237             internalFormat == GL_RGBA16F ||
2238             internalFormat == GL_RGB32F ||
2239             internalFormat == GL_RGBA32F)
2240          bindings |= PIPE_BIND_RENDER_TARGET;
2241
2242    /* GLES allows the driver to choose any format which matches
2243     * the format+type combo, because GLES only supports unsized internal
2244     * formats and expects the driver to choose whatever suits it.
2245     */
2246    if (_mesa_is_gles(ctx)) {
2247       GLenum baseFormat = _mesa_base_tex_format(ctx, internalFormat);
2248       GLenum basePackFormat = _mesa_base_pack_format(format);
2249       GLenum iformat = internalFormat;
2250
2251       /* Treat GL_BGRA as GL_RGBA. */
2252       if (iformat == GL_BGRA)
2253          iformat = GL_RGBA;
2254
2255       /* Check if the internalformat is unsized and compatible
2256        * with the "format".
2257        */
2258       if (iformat == baseFormat && iformat == basePackFormat) {
2259          pFormat = st_choose_matching_format(st, bindings, format, type,
2260                                              ctx->Unpack.SwapBytes);
2261
2262          if (pFormat != PIPE_FORMAT_NONE)
2263             return st_pipe_format_to_mesa_format(pFormat);
2264
2265          if (!is_renderbuffer) {
2266             /* try choosing format again, this time without render target bindings */
2267             pFormat = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW,
2268                                                 format, type,
2269                                                 ctx->Unpack.SwapBytes);
2270             if (pFormat != PIPE_FORMAT_NONE)
2271                return st_pipe_format_to_mesa_format(pFormat);
2272          }
2273       }
2274    }
2275
2276    pFormat = st_choose_format(st, internalFormat, format, type,
2277                               pTarget, 0, bindings, ctx->Mesa_DXTn);
2278
2279    if (pFormat == PIPE_FORMAT_NONE && !is_renderbuffer) {
2280       /* try choosing format again, this time without render target bindings */
2281       pFormat = st_choose_format(st, internalFormat, format, type,
2282                                  pTarget, 0, PIPE_BIND_SAMPLER_VIEW,
2283                                  ctx->Mesa_DXTn);
2284    }
2285
2286    if (pFormat == PIPE_FORMAT_NONE) {
2287       /* no luck at all */
2288       return MESA_FORMAT_NONE;
2289    }
2290
2291    mFormat = st_pipe_format_to_mesa_format(pFormat);
2292
2293    /* Debugging aid */
2294    if (0) {
2295       debug_printf("%s(intFormat=%s, format=%s, type=%s) -> %s, %s\n",
2296                    __func__,
2297                    _mesa_enum_to_string(internalFormat),
2298                    _mesa_enum_to_string(format),
2299                    _mesa_enum_to_string(type),
2300                    util_format_name(pFormat),
2301                    _mesa_get_format_name(mFormat));
2302    }
2303
2304    return mFormat;
2305 }
2306
2307
2308 /**
2309  * Called via ctx->Driver.QueryInternalFormat().
2310  */
2311 static size_t
2312 st_QuerySamplesForFormat(struct gl_context *ctx, GLenum target,
2313                          GLenum internalFormat, int samples[16])
2314 {
2315    struct st_context *st = st_context(ctx);
2316    enum pipe_format format;
2317    unsigned i, bind, num_sample_counts = 0;
2318
2319    (void) target;
2320
2321    if (_mesa_is_depth_or_stencil_format(internalFormat))
2322       bind = PIPE_BIND_DEPTH_STENCIL;
2323    else
2324       bind = PIPE_BIND_RENDER_TARGET;
2325
2326    /* If an sRGB framebuffer is unsupported, sRGB formats behave like linear
2327     * formats.
2328     */
2329    if (!ctx->Extensions.EXT_framebuffer_sRGB) {
2330       internalFormat = _mesa_get_linear_internalformat(internalFormat);
2331    }
2332
2333    /* Set sample counts in descending order. */
2334    for (i = 16; i > 1; i--) {
2335       format = st_choose_format(st, internalFormat, GL_NONE, GL_NONE,
2336                                 PIPE_TEXTURE_2D, i, bind, FALSE);
2337
2338       if (format != PIPE_FORMAT_NONE) {
2339          samples[num_sample_counts++] = i;
2340       }
2341    }
2342
2343    if (!num_sample_counts) {
2344       samples[num_sample_counts++] = 1;
2345    }
2346
2347    return num_sample_counts;
2348 }
2349
2350 /**
2351  * ARB_internalformat_query2 driver hook.
2352  */
2353 void
2354 st_QueryInternalFormat(struct gl_context *ctx, GLenum target,
2355                        GLenum internalFormat, GLenum pname, GLint *params)
2356 {
2357    struct st_context *st = st_context(ctx);
2358    /* The API entry-point gives us a temporary params buffer that is non-NULL
2359     * and guaranteed to have at least 16 elements.
2360     */
2361    assert(params != NULL);
2362
2363    switch (pname) {
2364    case GL_SAMPLES:
2365       st_QuerySamplesForFormat(ctx, target, internalFormat, params);
2366       break;
2367
2368    case GL_NUM_SAMPLE_COUNTS: {
2369       size_t num_samples;
2370       num_samples = st_QuerySamplesForFormat(ctx, target, internalFormat,
2371                                              params);
2372       params[0] = (GLint) num_samples;
2373       break;
2374    }
2375    case GL_INTERNALFORMAT_PREFERRED: {
2376       params[0] = GL_NONE;
2377
2378       /* We need to resolve an internal format that is compatible with
2379        * the passed internal format, and optimal to the driver. By now,
2380        * we just validate that the passed internal format is supported by
2381        * the driver, and if so return the same internal format, otherwise
2382        * return GL_NONE.
2383        */
2384       uint usage;
2385       if (_mesa_is_depth_or_stencil_format(internalFormat))
2386          usage = PIPE_BIND_DEPTH_STENCIL;
2387       else
2388          usage = PIPE_BIND_RENDER_TARGET;
2389       enum pipe_format pformat = st_choose_format(st,
2390                                                   internalFormat,
2391                                                   GL_NONE,
2392                                                   GL_NONE,
2393                                                   PIPE_TEXTURE_2D, 1,
2394                                                   usage, FALSE);
2395       if (pformat)
2396          params[0] = internalFormat;
2397       break;
2398    }
2399    default:
2400       /* For the rest of the pnames, we call back the Mesa's default
2401        * function for drivers that don't implement ARB_internalformat_query2.
2402        */
2403       _mesa_query_internal_format_default(ctx, target, internalFormat, pname,
2404                                           params);
2405    }
2406 }
2407
2408 /**
2409  * This is used for translating texture border color and the clear
2410  * color.  For example, the clear color is interpreted according to
2411  * the renderbuffer's base format.  For example, if clearing a
2412  * GL_LUMINANCE buffer, we'll return colorOut[0] = colorOut[1] =
2413  * colorOut[2] = colorIn[0].
2414  * Similarly for texture border colors.
2415  */
2416 void
2417 st_translate_color(const union gl_color_union *colorIn,
2418                    union pipe_color_union *colorOut,
2419                    GLenum baseFormat, GLboolean is_integer)
2420 {
2421    if (is_integer) {
2422       const int *in = colorIn->i;
2423       int *out = colorOut->i;
2424
2425       switch (baseFormat) {
2426       case GL_RED:
2427          out[0] = in[0];
2428          out[1] = 0;
2429          out[2] = 0;
2430          out[3] = 1;
2431          break;
2432       case GL_RG:
2433          out[0] = in[0];
2434          out[1] = in[1];
2435          out[2] = 0;
2436          out[3] = 1;
2437          break;
2438       case GL_RGB:
2439          out[0] = in[0];
2440          out[1] = in[1];
2441          out[2] = in[2];
2442          out[3] = 1;
2443          break;
2444       case GL_ALPHA:
2445          out[0] = out[1] = out[2] = 0;
2446          out[3] = in[3];
2447          break;
2448       case GL_LUMINANCE:
2449          out[0] = out[1] = out[2] = in[0];
2450          out[3] = 1;
2451          break;
2452       case GL_LUMINANCE_ALPHA:
2453          out[0] = out[1] = out[2] = in[0];
2454          out[3] = in[3];
2455          break;
2456       case GL_INTENSITY:
2457          out[0] = out[1] = out[2] = out[3] = in[0];
2458          break;
2459       default:
2460          COPY_4V(out, in);
2461       }
2462    }
2463    else {
2464       const float *in = colorIn->f;
2465       float *out = colorOut->f;
2466
2467       switch (baseFormat) {
2468       case GL_RED:
2469          out[0] = in[0];
2470          out[1] = 0.0F;
2471          out[2] = 0.0F;
2472          out[3] = 1.0F;
2473          break;
2474       case GL_RG:
2475          out[0] = in[0];
2476          out[1] = in[1];
2477          out[2] = 0.0F;
2478          out[3] = 1.0F;
2479          break;
2480       case GL_RGB:
2481          out[0] = in[0];
2482          out[1] = in[1];
2483          out[2] = in[2];
2484          out[3] = 1.0F;
2485          break;
2486       case GL_ALPHA:
2487          out[0] = out[1] = out[2] = 0.0F;
2488          out[3] = in[3];
2489          break;
2490       case GL_LUMINANCE:
2491          out[0] = out[1] = out[2] = in[0];
2492          out[3] = 1.0F;
2493          break;
2494       case GL_LUMINANCE_ALPHA:
2495          out[0] = out[1] = out[2] = in[0];
2496          out[3] = in[3];
2497          break;
2498       case GL_INTENSITY:
2499          out[0] = out[1] = out[2] = out[3] = in[0];
2500          break;
2501       default:
2502          COPY_4V(out, in);
2503       }
2504    }
2505 }