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