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