src/mesa/state_tracker/st_format.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   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 TUNGSTEN GRAPHICS 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/texstore.h"
  38 #include "main/image.h"
  39 #include "main/macros.h"
  40 #include "main/mfeatures.h"
  41
  42 #include "pipe/p_context.h"
  43 #include "pipe/p_defines.h"
  44 #include "pipe/p_screen.h"
  45 #include "util/u_format.h"
  46 #include "st_context.h"
  47 #include "st_format.h"
  48
  49
  50 static GLuint
  51 format_max_bits(enum pipe_format format)
  52 {
  53    GLuint size = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0);
  54
  55    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1));
  56    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2));
  57    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3));
  58    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0));
  59    size = MAX2(size, util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1));
  60    return size;
  61 }
  62
  63
  64 /**
  65  * Return basic GL datatype for the given gallium format.
  66  */
  67 GLenum
  68 st_format_datatype(enum pipe_format format)
  69 {
  70    const struct util_format_description *desc;
  71
  72    desc = util_format_description(format);
  73    assert(desc);
  74
  75    if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN) {
  76       if (format == PIPE_FORMAT_B5G5R5A1_UNORM ||
  77           format == PIPE_FORMAT_B5G6R5_UNORM) {
  78          return GL_UNSIGNED_SHORT;
  79       }
  80       else if (format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
  81                format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
  82                format == PIPE_FORMAT_Z24X8_UNORM ||
  83                format == PIPE_FORMAT_X8Z24_UNORM) {
  84          return GL_UNSIGNED_INT_24_8;
  85       }
  86       else {
  87          const GLuint size = format_max_bits(format);
  88          if (size == 8) {
  89             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
  90                return GL_UNSIGNED_BYTE;
  91             else
  92                return GL_BYTE;
  93          }
  94          else if (size == 16) {
  95             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
  96                return GL_UNSIGNED_SHORT;
  97             else
  98                return GL_SHORT;
  99          }
 100          else {
 101             assert( size <= 32 );
 102             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
 103                return GL_UNSIGNED_INT;
 104             else
 105                return GL_INT;
 106          }
 107       }
 108    }
 109    else if (format == PIPE_FORMAT_UYVY) {
 110       return GL_UNSIGNED_SHORT;
 111    }
 112    else if (format == PIPE_FORMAT_YUYV) {
 113       return GL_UNSIGNED_SHORT;
 114    }
 115    else {
 116       /* probably a compressed format, unsupported anyway */
 117       return GL_NONE;
 118    }
 119 }
 120
 121
 122 /**
 123  * Translate Mesa format to Gallium format.
 124  */
 125 enum pipe_format
 126 st_mesa_format_to_pipe_format(gl_format mesaFormat)
 127 {
 128    switch (mesaFormat) {
 129    case MESA_FORMAT_RGBA8888:
 130       return PIPE_FORMAT_A8B8G8R8_UNORM;
 131    case MESA_FORMAT_RGBA8888_REV:
 132       return PIPE_FORMAT_R8G8B8A8_UNORM;
 133    case MESA_FORMAT_ARGB8888:
 134       return PIPE_FORMAT_B8G8R8A8_UNORM;
 135    case MESA_FORMAT_ARGB8888_REV:
 136       return PIPE_FORMAT_A8R8G8B8_UNORM;
 137    case MESA_FORMAT_XRGB8888:
 138       return PIPE_FORMAT_B8G8R8X8_UNORM;
 139    case MESA_FORMAT_XRGB8888_REV:
 140       return PIPE_FORMAT_X8R8G8B8_UNORM;
 141    case MESA_FORMAT_ARGB1555:
 142       return PIPE_FORMAT_B5G5R5A1_UNORM;
 143    case MESA_FORMAT_ARGB4444:
 144       return PIPE_FORMAT_B4G4R4A4_UNORM;
 145    case MESA_FORMAT_RGB565:
 146       return PIPE_FORMAT_B5G6R5_UNORM;
 147    case MESA_FORMAT_RGB332:
 148       return PIPE_FORMAT_B2G3R3_UNORM;
 149    case MESA_FORMAT_ARGB2101010:
 150       return PIPE_FORMAT_B10G10R10A2_UNORM;
 151    case MESA_FORMAT_AL44:
 152       return PIPE_FORMAT_L4A4_UNORM;
 153    case MESA_FORMAT_AL88:
 154       return PIPE_FORMAT_L8A8_UNORM;
 155    case MESA_FORMAT_AL1616:
 156       return PIPE_FORMAT_L16A16_UNORM;
 157    case MESA_FORMAT_A8:
 158       return PIPE_FORMAT_A8_UNORM;
 159    case MESA_FORMAT_A16:
 160       return PIPE_FORMAT_A16_UNORM;
 161    case MESA_FORMAT_L8:
 162       return PIPE_FORMAT_L8_UNORM;
 163    case MESA_FORMAT_L16:
 164       return PIPE_FORMAT_L16_UNORM;
 165    case MESA_FORMAT_I8:
 166       return PIPE_FORMAT_I8_UNORM;
 167    case MESA_FORMAT_I16:
 168       return PIPE_FORMAT_I16_UNORM;
 169    case MESA_FORMAT_Z16:
 170       return PIPE_FORMAT_Z16_UNORM;
 171    case MESA_FORMAT_Z32:
 172       return PIPE_FORMAT_Z32_UNORM;
 173    case MESA_FORMAT_Z24_S8:
 174       return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
 175    case MESA_FORMAT_S8_Z24:
 176       return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
 177    case MESA_FORMAT_Z24_X8:
 178       return PIPE_FORMAT_X8Z24_UNORM;
 179    case MESA_FORMAT_X8_Z24:
 180       return PIPE_FORMAT_Z24X8_UNORM;
 181    case MESA_FORMAT_S8:
 182       return PIPE_FORMAT_S8_USCALED;
 183    case MESA_FORMAT_YCBCR:
 184       return PIPE_FORMAT_UYVY;
 185 #if FEATURE_texture_s3tc
 186    case MESA_FORMAT_RGB_DXT1:
 187       return PIPE_FORMAT_DXT1_RGB;
 188    case MESA_FORMAT_RGBA_DXT1:
 189       return PIPE_FORMAT_DXT1_RGBA;
 190    case MESA_FORMAT_RGBA_DXT3:
 191       return PIPE_FORMAT_DXT3_RGBA;
 192    case MESA_FORMAT_RGBA_DXT5:
 193       return PIPE_FORMAT_DXT5_RGBA;
 194 #if FEATURE_EXT_texture_sRGB
 195    case MESA_FORMAT_SRGB_DXT1:
 196       return PIPE_FORMAT_DXT1_SRGB;
 197    case MESA_FORMAT_SRGBA_DXT1:
 198       return PIPE_FORMAT_DXT1_SRGBA;
 199    case MESA_FORMAT_SRGBA_DXT3:
 200       return PIPE_FORMAT_DXT3_SRGBA;
 201    case MESA_FORMAT_SRGBA_DXT5:
 202       return PIPE_FORMAT_DXT5_SRGBA;
 203 #endif
 204 #endif
 205 #if FEATURE_EXT_texture_sRGB
 206    case MESA_FORMAT_SLA8:
 207       return PIPE_FORMAT_L8A8_SRGB;
 208    case MESA_FORMAT_SL8:
 209       return PIPE_FORMAT_L8_SRGB;
 210    case MESA_FORMAT_SRGB8:
 211       return PIPE_FORMAT_R8G8B8_SRGB;
 212    case MESA_FORMAT_SRGBA8:
 213       return PIPE_FORMAT_A8B8G8R8_SRGB;
 214    case MESA_FORMAT_SARGB8:
 215       return PIPE_FORMAT_B8G8R8A8_SRGB;
 216 #endif
 217    case MESA_FORMAT_RGBA_FLOAT32:
 218       return PIPE_FORMAT_R32G32B32A32_FLOAT;
 219    case MESA_FORMAT_RGBA_FLOAT16:
 220       return PIPE_FORMAT_R16G16B16A16_FLOAT;
 221    case MESA_FORMAT_RGB_FLOAT32:
 222       return PIPE_FORMAT_R32G32B32_FLOAT;
 223    case MESA_FORMAT_RGB_FLOAT16:
 224       return PIPE_FORMAT_R16G16B16_FLOAT;
 225    case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32:
 226       return PIPE_FORMAT_L32A32_FLOAT;
 227    case MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16:
 228       return PIPE_FORMAT_L16A16_FLOAT;
 229    case MESA_FORMAT_LUMINANCE_FLOAT32:
 230       return PIPE_FORMAT_L32_FLOAT;
 231    case MESA_FORMAT_LUMINANCE_FLOAT16:
 232       return PIPE_FORMAT_L16_FLOAT;
 233    case MESA_FORMAT_ALPHA_FLOAT32:
 234       return PIPE_FORMAT_A32_FLOAT;
 235    case MESA_FORMAT_ALPHA_FLOAT16:
 236       return PIPE_FORMAT_A16_FLOAT;
 237    case MESA_FORMAT_INTENSITY_FLOAT32:
 238       return PIPE_FORMAT_I32_FLOAT;
 239    case MESA_FORMAT_INTENSITY_FLOAT16:
 240       return PIPE_FORMAT_I16_FLOAT;
 241    case MESA_FORMAT_R_FLOAT32:
 242       return PIPE_FORMAT_R32_FLOAT;
 243    case MESA_FORMAT_R_FLOAT16:
 244       return PIPE_FORMAT_R16_FLOAT;
 245    case MESA_FORMAT_RG_FLOAT32:
 246       return PIPE_FORMAT_R32G32_FLOAT;
 247    case MESA_FORMAT_RG_FLOAT16:
 248       return PIPE_FORMAT_R16G16_FLOAT;
 249
 250    case MESA_FORMAT_R8:
 251       return PIPE_FORMAT_R8_UNORM;
 252    case MESA_FORMAT_R16:
 253       return PIPE_FORMAT_R16_UNORM;
 254    case MESA_FORMAT_RG88:
 255       return PIPE_FORMAT_R8G8_UNORM;
 256    case MESA_FORMAT_RG1616:
 257       return PIPE_FORMAT_R16G16_UNORM;
 258    case MESA_FORMAT_RGBA_16:
 259       return PIPE_FORMAT_R16G16B16A16_UNORM;
 260
 261    /* signed int formats */
 262    case MESA_FORMAT_RGBA_INT8:
 263       return PIPE_FORMAT_R8G8B8A8_SSCALED;
 264    case MESA_FORMAT_RGBA_INT16:
 265       return PIPE_FORMAT_R16G16B16A16_SSCALED;
 266    case MESA_FORMAT_RGBA_INT32:
 267       return PIPE_FORMAT_R32G32B32A32_SSCALED;
 268
 269    /* unsigned int formats */
 270    case MESA_FORMAT_RGBA_UINT8:
 271       return PIPE_FORMAT_R8G8B8A8_USCALED;
 272    case MESA_FORMAT_RGBA_UINT16:
 273       return PIPE_FORMAT_R16G16B16A16_USCALED;
 274    case MESA_FORMAT_RGBA_UINT32:
 275       return PIPE_FORMAT_R32G32B32A32_USCALED;
 276
 277    case MESA_FORMAT_RED_RGTC1:
 278       return PIPE_FORMAT_RGTC1_UNORM;
 279    case MESA_FORMAT_SIGNED_RED_RGTC1:
 280       return PIPE_FORMAT_RGTC1_SNORM;
 281    case MESA_FORMAT_RG_RGTC2:
 282       return PIPE_FORMAT_RGTC2_UNORM;
 283    case MESA_FORMAT_SIGNED_RG_RGTC2:
 284       return PIPE_FORMAT_RGTC2_SNORM;
 285
 286    case MESA_FORMAT_L_LATC1:
 287       return PIPE_FORMAT_LATC1_UNORM;
 288    case MESA_FORMAT_SIGNED_L_LATC1:
 289       return PIPE_FORMAT_LATC1_SNORM;
 290    case MESA_FORMAT_LA_LATC2:
 291       return PIPE_FORMAT_LATC2_UNORM;
 292    case MESA_FORMAT_SIGNED_LA_LATC2:
 293       return PIPE_FORMAT_LATC2_SNORM;
 294
 295    /* signed normalized formats */
 296    case MESA_FORMAT_SIGNED_R8:
 297       return PIPE_FORMAT_R8_SNORM;
 298    case MESA_FORMAT_SIGNED_RG88_REV:
 299       return PIPE_FORMAT_R8G8_SNORM;
 300    case MESA_FORMAT_SIGNED_RGBA8888_REV:
 301       return PIPE_FORMAT_R8G8B8A8_SNORM;
 302
 303    case MESA_FORMAT_SIGNED_A8:
 304       return PIPE_FORMAT_A8_SNORM;
 305    case MESA_FORMAT_SIGNED_L8:
 306       return PIPE_FORMAT_L8_SNORM;
 307    case MESA_FORMAT_SIGNED_AL88:
 308       return PIPE_FORMAT_L8A8_SNORM;
 309    case MESA_FORMAT_SIGNED_I8:
 310       return PIPE_FORMAT_I8_SNORM;
 311
 312    case MESA_FORMAT_SIGNED_R16:
 313       return PIPE_FORMAT_R16_SNORM;
 314    case MESA_FORMAT_SIGNED_GR1616:
 315       return PIPE_FORMAT_R16G16_SNORM;
 316    case MESA_FORMAT_SIGNED_RGBA_16:
 317       return PIPE_FORMAT_R16G16B16A16_SNORM;
 318
 319    case MESA_FORMAT_SIGNED_A16:
 320       return PIPE_FORMAT_A16_SNORM;
 321    case MESA_FORMAT_SIGNED_L16:
 322       return PIPE_FORMAT_L16_SNORM;
 323    case MESA_FORMAT_SIGNED_AL1616:
 324       return PIPE_FORMAT_L16A16_SNORM;
 325    case MESA_FORMAT_SIGNED_I16:
 326       return PIPE_FORMAT_I16_SNORM;
 327
 328    case MESA_FORMAT_RGB9_E5_FLOAT:
 329       return PIPE_FORMAT_R9G9B9E5_FLOAT;
 330    case MESA_FORMAT_R11_G11_B10_FLOAT:
 331       return PIPE_FORMAT_R11G11B10_FLOAT;
 332
 333    default:
 334       assert(0);
 335       return PIPE_FORMAT_NONE;
 336    }
 337 }
 338
 339
 340 /**
 341  * Translate Gallium format to Mesa format.
 342  */
 343 gl_format
 344 st_pipe_format_to_mesa_format(enum pipe_format format)
 345 {
 346    switch (format) {
 347    case PIPE_FORMAT_A8B8G8R8_UNORM:
 348       return MESA_FORMAT_RGBA8888;
 349    case PIPE_FORMAT_R8G8B8A8_UNORM:
 350       return MESA_FORMAT_RGBA8888_REV;
 351    case PIPE_FORMAT_B8G8R8A8_UNORM:
 352       return MESA_FORMAT_ARGB8888;
 353    case PIPE_FORMAT_A8R8G8B8_UNORM:
 354       return MESA_FORMAT_ARGB8888_REV;
 355    case PIPE_FORMAT_B8G8R8X8_UNORM:
 356       return MESA_FORMAT_XRGB8888;
 357    case PIPE_FORMAT_X8R8G8B8_UNORM:
 358       return MESA_FORMAT_XRGB8888_REV;
 359    case PIPE_FORMAT_B5G5R5A1_UNORM:
 360       return MESA_FORMAT_ARGB1555;
 361    case PIPE_FORMAT_B4G4R4A4_UNORM:
 362       return MESA_FORMAT_ARGB4444;
 363    case PIPE_FORMAT_B5G6R5_UNORM:
 364       return MESA_FORMAT_RGB565;
 365    case PIPE_FORMAT_B2G3R3_UNORM:
 366       return MESA_FORMAT_RGB332;
 367    case PIPE_FORMAT_B10G10R10A2_UNORM:
 368       return MESA_FORMAT_ARGB2101010;
 369    case PIPE_FORMAT_L4A4_UNORM:
 370       return MESA_FORMAT_AL44;
 371    case PIPE_FORMAT_L8A8_UNORM:
 372       return MESA_FORMAT_AL88;
 373    case PIPE_FORMAT_L16A16_UNORM:
 374       return MESA_FORMAT_AL1616;
 375    case PIPE_FORMAT_A8_UNORM:
 376       return MESA_FORMAT_A8;
 377    case PIPE_FORMAT_A16_UNORM:
 378       return MESA_FORMAT_A16;
 379    case PIPE_FORMAT_L8_UNORM:
 380       return MESA_FORMAT_L8;
 381    case PIPE_FORMAT_L16_UNORM:
 382       return MESA_FORMAT_L16;
 383    case PIPE_FORMAT_I8_UNORM:
 384       return MESA_FORMAT_I8;
 385    case PIPE_FORMAT_I16_UNORM:
 386       return MESA_FORMAT_I16;
 387    case PIPE_FORMAT_S8_USCALED:
 388       return MESA_FORMAT_S8;
 389
 390    case PIPE_FORMAT_R16G16B16A16_UNORM:
 391       return MESA_FORMAT_RGBA_16;
 392
 393    case PIPE_FORMAT_Z16_UNORM:
 394       return MESA_FORMAT_Z16;
 395    case PIPE_FORMAT_Z32_UNORM:
 396       return MESA_FORMAT_Z32;
 397    case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 398       return MESA_FORMAT_Z24_S8;
 399    case PIPE_FORMAT_X8Z24_UNORM:
 400       return MESA_FORMAT_Z24_X8;
 401    case PIPE_FORMAT_Z24X8_UNORM:
 402       return MESA_FORMAT_X8_Z24;
 403    case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 404       return MESA_FORMAT_S8_Z24;
 405
 406    case PIPE_FORMAT_UYVY:
 407       return MESA_FORMAT_YCBCR;
 408    case PIPE_FORMAT_YUYV:
 409       return MESA_FORMAT_YCBCR_REV;
 410
 411 #if FEATURE_texture_s3tc
 412    case PIPE_FORMAT_DXT1_RGB:
 413       return MESA_FORMAT_RGB_DXT1;
 414    case PIPE_FORMAT_DXT1_RGBA:
 415       return MESA_FORMAT_RGBA_DXT1;
 416    case PIPE_FORMAT_DXT3_RGBA:
 417       return MESA_FORMAT_RGBA_DXT3;
 418    case PIPE_FORMAT_DXT5_RGBA:
 419       return MESA_FORMAT_RGBA_DXT5;
 420 #if FEATURE_EXT_texture_sRGB
 421    case PIPE_FORMAT_DXT1_SRGB:
 422       return MESA_FORMAT_SRGB_DXT1;
 423    case PIPE_FORMAT_DXT1_SRGBA:
 424       return MESA_FORMAT_SRGBA_DXT1;
 425    case PIPE_FORMAT_DXT3_SRGBA:
 426       return MESA_FORMAT_SRGBA_DXT3;
 427    case PIPE_FORMAT_DXT5_SRGBA:
 428       return MESA_FORMAT_SRGBA_DXT5;
 429 #endif
 430 #endif
 431
 432 #if FEATURE_EXT_texture_sRGB
 433    case PIPE_FORMAT_L8A8_SRGB:
 434       return MESA_FORMAT_SLA8;
 435    case PIPE_FORMAT_L8_SRGB:
 436       return MESA_FORMAT_SL8;
 437    case PIPE_FORMAT_R8G8B8_SRGB:
 438       return MESA_FORMAT_SRGB8;
 439    case PIPE_FORMAT_A8B8G8R8_SRGB:
 440       return MESA_FORMAT_SRGBA8;
 441    case PIPE_FORMAT_B8G8R8A8_SRGB:
 442       return MESA_FORMAT_SARGB8;
 443 #endif
 444    case PIPE_FORMAT_R32G32B32A32_FLOAT:
 445       return MESA_FORMAT_RGBA_FLOAT32;
 446    case PIPE_FORMAT_R16G16B16A16_FLOAT:
 447       return MESA_FORMAT_RGBA_FLOAT16;
 448    case PIPE_FORMAT_R32G32B32_FLOAT:
 449       return MESA_FORMAT_RGB_FLOAT32;
 450    case PIPE_FORMAT_R16G16B16_FLOAT:
 451       return MESA_FORMAT_RGB_FLOAT16;
 452    case PIPE_FORMAT_L32A32_FLOAT:
 453       return MESA_FORMAT_LUMINANCE_ALPHA_FLOAT32;
 454    case PIPE_FORMAT_L16A16_FLOAT:
 455       return MESA_FORMAT_LUMINANCE_ALPHA_FLOAT16;
 456    case PIPE_FORMAT_L32_FLOAT:
 457       return MESA_FORMAT_LUMINANCE_FLOAT32;
 458    case PIPE_FORMAT_L16_FLOAT:
 459       return MESA_FORMAT_LUMINANCE_FLOAT16;
 460    case PIPE_FORMAT_A32_FLOAT:
 461       return MESA_FORMAT_ALPHA_FLOAT32;
 462    case PIPE_FORMAT_A16_FLOAT:
 463       return MESA_FORMAT_ALPHA_FLOAT16;
 464    case PIPE_FORMAT_I32_FLOAT:
 465       return MESA_FORMAT_INTENSITY_FLOAT32;
 466    case PIPE_FORMAT_I16_FLOAT:
 467       return MESA_FORMAT_INTENSITY_FLOAT16;
 468    case PIPE_FORMAT_R32_FLOAT:
 469       return MESA_FORMAT_R_FLOAT32;
 470    case PIPE_FORMAT_R16_FLOAT:
 471       return MESA_FORMAT_R_FLOAT16;
 472    case PIPE_FORMAT_R32G32_FLOAT:
 473       return MESA_FORMAT_RG_FLOAT32;
 474    case PIPE_FORMAT_R16G16_FLOAT:
 475       return MESA_FORMAT_RG_FLOAT16;
 476
 477    case PIPE_FORMAT_R8_UNORM:
 478       return MESA_FORMAT_R8;
 479    case PIPE_FORMAT_R16_UNORM:
 480       return MESA_FORMAT_R16;
 481    case PIPE_FORMAT_R8G8_UNORM:
 482       return MESA_FORMAT_RG88;
 483    case PIPE_FORMAT_R16G16_UNORM:
 484       return MESA_FORMAT_RG1616;
 485
 486    /* signed int formats */
 487    case PIPE_FORMAT_R8G8B8A8_SSCALED:
 488       return MESA_FORMAT_RGBA_INT8;
 489    case PIPE_FORMAT_R16G16B16A16_SSCALED:
 490       return MESA_FORMAT_RGBA_INT16;
 491    case PIPE_FORMAT_R32G32B32A32_SSCALED:
 492       return MESA_FORMAT_RGBA_INT32;
 493
 494    /* unsigned int formats */
 495    case PIPE_FORMAT_R8G8B8A8_USCALED:
 496       return MESA_FORMAT_RGBA_UINT8;
 497    case PIPE_FORMAT_R16G16B16A16_USCALED:
 498       return MESA_FORMAT_RGBA_UINT16;
 499    case PIPE_FORMAT_R32G32B32A32_USCALED:
 500       return MESA_FORMAT_RGBA_UINT32;
 501
 502    case PIPE_FORMAT_RGTC1_UNORM:
 503       return MESA_FORMAT_RED_RGTC1;
 504    case PIPE_FORMAT_RGTC1_SNORM:
 505       return MESA_FORMAT_SIGNED_RED_RGTC1;
 506    case PIPE_FORMAT_RGTC2_UNORM:
 507       return MESA_FORMAT_RG_RGTC2;
 508    case PIPE_FORMAT_RGTC2_SNORM:
 509       return MESA_FORMAT_SIGNED_RG_RGTC2;
 510
 511    case PIPE_FORMAT_LATC1_UNORM:
 512       return MESA_FORMAT_L_LATC1;
 513    case PIPE_FORMAT_LATC1_SNORM:
 514       return MESA_FORMAT_SIGNED_L_LATC1;
 515    case PIPE_FORMAT_LATC2_UNORM:
 516       return MESA_FORMAT_LA_LATC2;
 517    case PIPE_FORMAT_LATC2_SNORM:
 518       return MESA_FORMAT_SIGNED_LA_LATC2;
 519
 520    /* signed normalized formats */
 521    case PIPE_FORMAT_R8_SNORM:
 522       return MESA_FORMAT_SIGNED_R8;
 523    case PIPE_FORMAT_R8G8_SNORM:
 524       return MESA_FORMAT_SIGNED_RG88_REV;
 525    case PIPE_FORMAT_R8G8B8A8_SNORM:
 526       return MESA_FORMAT_SIGNED_RGBA8888_REV;
 527
 528    case PIPE_FORMAT_A8_SNORM:
 529       return MESA_FORMAT_SIGNED_A8;
 530    case PIPE_FORMAT_L8_SNORM:
 531       return MESA_FORMAT_SIGNED_L8;
 532    case PIPE_FORMAT_L8A8_SNORM:
 533       return MESA_FORMAT_SIGNED_AL88;
 534    case PIPE_FORMAT_I8_SNORM:
 535       return MESA_FORMAT_SIGNED_I8;
 536
 537    case PIPE_FORMAT_R16_SNORM:
 538       return MESA_FORMAT_SIGNED_R16;
 539    case PIPE_FORMAT_R16G16_SNORM:
 540       return MESA_FORMAT_SIGNED_GR1616;
 541    case PIPE_FORMAT_R16G16B16A16_SNORM:
 542       return MESA_FORMAT_SIGNED_RGBA_16;
 543
 544    case PIPE_FORMAT_A16_SNORM:
 545       return MESA_FORMAT_SIGNED_A16;
 546    case PIPE_FORMAT_L16_SNORM:
 547       return MESA_FORMAT_SIGNED_L16;
 548    case PIPE_FORMAT_L16A16_SNORM:
 549       return MESA_FORMAT_SIGNED_AL1616;
 550    case PIPE_FORMAT_I16_SNORM:
 551       return MESA_FORMAT_SIGNED_I16;
 552
 553    case PIPE_FORMAT_R9G9B9E5_FLOAT:
 554       return MESA_FORMAT_RGB9_E5_FLOAT;
 555    case PIPE_FORMAT_R11G11B10_FLOAT:
 556       return MESA_FORMAT_R11_G11_B10_FLOAT;
 557
 558    default:
 559       assert(0);
 560       return MESA_FORMAT_NONE;
 561    }
 562 }
 563
 564
 565 /**
 566  * Return first supported format from the given list.
 567  */
 568 static enum pipe_format
 569 find_supported_format(struct pipe_screen *screen,
 570                       const enum pipe_format formats[],
 571                       uint num_formats,
 572                       enum pipe_texture_target target,
 573                       unsigned sample_count,
 574                       unsigned tex_usage)
 575 {
 576    uint i;
 577    for (i = 0; i < num_formats; i++) {
 578       if (screen->is_format_supported(screen, formats[i], target,
 579                                       sample_count, tex_usage)) {
 580          return formats[i];
 581       }
 582    }
 583    return PIPE_FORMAT_NONE;
 584 }
 585
 586
 587 /**
 588  * Find an RGBA format supported by the context/winsys.
 589  */
 590 static enum pipe_format
 591 default_rgba_format(struct pipe_screen *screen,
 592                     enum pipe_texture_target target,
 593                     unsigned sample_count,
 594                     unsigned tex_usage)
 595 {
 596    static const enum pipe_format colorFormats[] = {
 597       PIPE_FORMAT_B8G8R8A8_UNORM,
 598       PIPE_FORMAT_A8R8G8B8_UNORM,
 599       PIPE_FORMAT_A8B8G8R8_UNORM,
 600       PIPE_FORMAT_B5G6R5_UNORM
 601    };
 602    return find_supported_format(screen, colorFormats, Elements(colorFormats),
 603                                 target, sample_count, tex_usage);
 604 }
 605
 606
 607 /**
 608  * Find an RGB format supported by the context/winsys.
 609  */
 610 static enum pipe_format
 611 default_rgb_format(struct pipe_screen *screen,
 612                    enum pipe_texture_target target,
 613                    unsigned sample_count,
 614                    unsigned tex_usage)
 615 {
 616    static const enum pipe_format colorFormats[] = {
 617       PIPE_FORMAT_B8G8R8X8_UNORM,
 618       PIPE_FORMAT_X8R8G8B8_UNORM,
 619       PIPE_FORMAT_X8B8G8R8_UNORM,
 620       PIPE_FORMAT_B8G8R8A8_UNORM,
 621       PIPE_FORMAT_A8R8G8B8_UNORM,
 622       PIPE_FORMAT_A8B8G8R8_UNORM,
 623       PIPE_FORMAT_B5G6R5_UNORM
 624    };
 625    return find_supported_format(screen, colorFormats, Elements(colorFormats),
 626                                 target, sample_count, tex_usage);
 627 }
 628
 629 /**
 630  * Find an sRGBA format supported by the context/winsys.
 631  */
 632 static enum pipe_format
 633 default_srgba_format(struct pipe_screen *screen,
 634                     enum pipe_texture_target target,
 635                     unsigned sample_count,
 636                     unsigned tex_usage)
 637 {
 638    static const enum pipe_format colorFormats[] = {
 639       PIPE_FORMAT_B8G8R8A8_SRGB,
 640       PIPE_FORMAT_A8R8G8B8_SRGB,
 641       PIPE_FORMAT_A8B8G8R8_SRGB,
 642    };
 643    return find_supported_format(screen, colorFormats, Elements(colorFormats),
 644                                 target, sample_count, tex_usage);
 645 }
 646
 647
 648 /**
 649  * Given an OpenGL internalFormat value for a texture or surface, return
 650  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
 651  * This is called during glTexImage2D, for example.
 652  *
 653  * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
 654  * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
 655  * we want render-to-texture ability.
 656  *
 657  * \param internalFormat  the user value passed to glTexImage2D
 658  * \param target  one of PIPE_TEXTURE_x
 659  * \param bindings  bitmask of PIPE_BIND_x flags.
 660  */
 661 enum pipe_format
 662 st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
 663                  enum pipe_texture_target target, unsigned sample_count,
 664                  unsigned bindings)
 665 {
 666
 667    switch (internalFormat) {
 668    case GL_RGB10:
 669    case GL_RGB10_A2:
 670       if (screen->is_format_supported( screen, PIPE_FORMAT_B10G10R10A2_UNORM,
 671                                        target, sample_count, bindings))
 672          return PIPE_FORMAT_B10G10R10A2_UNORM;
 673       /* Pass through. */
 674    case 4:
 675    case GL_RGBA:
 676    case GL_RGBA8:
 677       return default_rgba_format( screen, target, sample_count, bindings);
 678
 679    case GL_BGRA:
 680       if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM,
 681                                        target, sample_count, bindings))
 682          return PIPE_FORMAT_B8G8R8A8_UNORM;
 683       return default_rgba_format( screen, target, sample_count, bindings);
 684
 685    case 3:
 686    case GL_RGB:
 687    case GL_RGB8:
 688       return default_rgb_format( screen, target, sample_count, bindings);
 689
 690    case GL_RGB12:
 691    case GL_RGB16:
 692    case GL_RGBA12:
 693    case GL_RGBA16:
 694       if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,
 695                                              target, sample_count, bindings))
 696          return PIPE_FORMAT_R16G16B16A16_UNORM;
 697       return default_rgba_format( screen, target, sample_count, bindings);
 698
 699    case GL_RGBA4:
 700    case GL_RGBA2:
 701       if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,
 702                                        target, sample_count, bindings))
 703          return PIPE_FORMAT_B4G4R4A4_UNORM;
 704       return default_rgba_format( screen, target, sample_count, bindings);
 705
 706    case GL_RGB5_A1:
 707       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
 708                                        target, sample_count, bindings))
 709          return PIPE_FORMAT_B5G5R5A1_UNORM;
 710       return default_rgba_format( screen, target, sample_count, bindings);
 711
 712    case GL_R3_G3_B2:
 713       if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM,
 714                                        target, sample_count, bindings))
 715          return PIPE_FORMAT_B2G3R3_UNORM;
 716       /* Pass through. */
 717    case GL_RGB5:
 718    case GL_RGB4:
 719       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,
 720                                        target, sample_count, bindings))
 721          return PIPE_FORMAT_B5G6R5_UNORM;
 722       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
 723                                        target, sample_count, bindings))
 724          return PIPE_FORMAT_B5G5R5A1_UNORM;
 725       return default_rgba_format( screen, target, sample_count, bindings);
 726
 727    case GL_ALPHA12:
 728    case GL_ALPHA16:
 729       if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target,
 730                                        sample_count, bindings))
 731          return PIPE_FORMAT_A16_UNORM;
 732       /* Pass through. */
 733    case GL_ALPHA:
 734    case GL_ALPHA4:
 735    case GL_ALPHA8:
 736    case GL_COMPRESSED_ALPHA:
 737       if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,
 738                                        sample_count, bindings))
 739          return PIPE_FORMAT_A8_UNORM;
 740       return default_rgba_format( screen, target, sample_count, bindings);
 741
 742    case GL_LUMINANCE12:
 743    case GL_LUMINANCE16:
 744       if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target,
 745                                        sample_count, bindings))
 746          return PIPE_FORMAT_L16_UNORM;
 747       /* Pass through. */
 748    case 1:
 749    case GL_LUMINANCE:
 750    case GL_LUMINANCE4:
 751    case GL_LUMINANCE8:
 752       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,
 753                                        sample_count, bindings))
 754          return PIPE_FORMAT_L8_UNORM;
 755       return default_rgba_format( screen, target, sample_count, bindings);
 756
 757    case GL_LUMINANCE12_ALPHA4:
 758    case GL_LUMINANCE12_ALPHA12:
 759    case GL_LUMINANCE16_ALPHA16:
 760       if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target,
 761                                        sample_count, bindings))
 762          return PIPE_FORMAT_L16A16_UNORM;
 763       /* Pass through. */
 764    case 2:
 765    case GL_LUMINANCE_ALPHA:
 766    case GL_LUMINANCE6_ALPHA2:
 767    case GL_LUMINANCE8_ALPHA8:
 768       if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
 769                                        sample_count, bindings))
 770          return PIPE_FORMAT_L8A8_UNORM;
 771       return default_rgba_format( screen, target, sample_count, bindings);
 772
 773    case GL_LUMINANCE4_ALPHA4:
 774       if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target,
 775                                        sample_count, bindings))
 776          return PIPE_FORMAT_L4A4_UNORM;
 777       if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
 778                                        sample_count, bindings))
 779          return PIPE_FORMAT_L8A8_UNORM;
 780       return default_rgba_format( screen, target, sample_count, bindings);
 781
 782    case GL_INTENSITY12:
 783    case GL_INTENSITY16:
 784       if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target,
 785                                        sample_count, bindings))
 786          return PIPE_FORMAT_I16_UNORM;
 787       /* Pass through. */
 788    case GL_INTENSITY:
 789    case GL_INTENSITY4:
 790    case GL_INTENSITY8:
 791    case GL_COMPRESSED_INTENSITY:
 792       if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,
 793                                        sample_count, bindings))
 794          return PIPE_FORMAT_I8_UNORM;
 795       return default_rgba_format( screen, target, sample_count, bindings);
 796
 797    case GL_YCBCR_MESA:
 798       if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,
 799                                       sample_count, bindings)) {
 800          return PIPE_FORMAT_UYVY;
 801       }
 802       if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,
 803                                       sample_count, bindings)) {
 804          return PIPE_FORMAT_YUYV;
 805       }
 806       return PIPE_FORMAT_NONE;
 807
 808    case GL_COMPRESSED_RGB:
 809       /* can only sample from compressed formats */
 810       if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
 811          return PIPE_FORMAT_NONE;
 812       else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
 813                                            target, sample_count, bindings))
 814          return PIPE_FORMAT_DXT1_RGB;
 815       else
 816          return default_rgb_format(screen, target, sample_count, bindings);
 817
 818    case GL_COMPRESSED_RGBA:
 819       /* can only sample from compressed formats */
 820       if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
 821          return PIPE_FORMAT_NONE;
 822       else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
 823                                            target, sample_count, bindings))
 824          return PIPE_FORMAT_DXT3_RGBA;
 825       else
 826          return default_rgba_format(screen, target, sample_count, bindings);
 827
 828    case GL_RGB_S3TC:
 829    case GL_RGB4_S3TC:
 830    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 831       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
 832                                       target, sample_count, bindings))
 833          return PIPE_FORMAT_DXT1_RGB;
 834       else
 835          return PIPE_FORMAT_NONE;
 836
 837    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 838       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,
 839                                       target, sample_count, bindings))
 840          return PIPE_FORMAT_DXT1_RGBA;
 841       else
 842          return PIPE_FORMAT_NONE;
 843
 844    case GL_RGBA_S3TC:
 845    case GL_RGBA4_S3TC:
 846    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 847       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
 848                                       target, sample_count, bindings))
 849          return PIPE_FORMAT_DXT3_RGBA;
 850       else
 851          return PIPE_FORMAT_NONE;
 852
 853    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 854       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
 855                                       target, sample_count, bindings))
 856          return PIPE_FORMAT_DXT5_RGBA;
 857       else
 858          return PIPE_FORMAT_NONE;
 859
 860 #if 0
 861    case GL_COMPRESSED_RGB_FXT1_3DFX:
 862       return PIPE_FORMAT_RGB_FXT1;
 863    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 864       return PIPE_FORMAT_RGB_FXT1;
 865 #endif
 866
 867    case GL_DEPTH_COMPONENT16:
 868       if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,
 869                                       sample_count, bindings))
 870          return PIPE_FORMAT_Z16_UNORM;
 871       /* fall-through */
 872    case GL_DEPTH_COMPONENT24:
 873       if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 874                                       target, sample_count, bindings))
 875          return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
 876       if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
 877                                       target, sample_count, bindings))
 878          return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
 879       /* fall-through */
 880    case GL_DEPTH_COMPONENT32:
 881       if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,
 882                                       sample_count, bindings))
 883          return PIPE_FORMAT_Z32_UNORM;
 884       /* fall-through */
 885    case GL_DEPTH_COMPONENT:
 886       {
 887          static const enum pipe_format formats[] = {
 888             PIPE_FORMAT_Z32_UNORM,
 889             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 890             PIPE_FORMAT_S8_USCALED_Z24_UNORM,
 891             PIPE_FORMAT_Z16_UNORM
 892          };
 893          return find_supported_format(screen, formats, Elements(formats),
 894                                       target, sample_count, bindings);
 895       }
 896
 897    case GL_STENCIL_INDEX:
 898    case GL_STENCIL_INDEX1_EXT:
 899    case GL_STENCIL_INDEX4_EXT:
 900    case GL_STENCIL_INDEX8_EXT:
 901    case GL_STENCIL_INDEX16_EXT:
 902       {
 903          static const enum pipe_format formats[] = {
 904             PIPE_FORMAT_S8_USCALED,
 905             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 906             PIPE_FORMAT_S8_USCALED_Z24_UNORM
 907          };
 908          return find_supported_format(screen, formats, Elements(formats),
 909                                       target, sample_count, bindings);
 910       }
 911
 912    case GL_DEPTH_STENCIL_EXT:
 913    case GL_DEPTH24_STENCIL8_EXT:
 914       {
 915          static const enum pipe_format formats[] = {
 916             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 917             PIPE_FORMAT_S8_USCALED_Z24_UNORM
 918          };
 919          return find_supported_format(screen, formats, Elements(formats),
 920                                       target, sample_count, bindings);
 921       }
 922
 923    case GL_SRGB_EXT:
 924    case GL_SRGB8_EXT:
 925    case GL_SRGB_ALPHA_EXT:
 926    case GL_SRGB8_ALPHA8_EXT:
 927       return default_srgba_format( screen, target, sample_count, bindings);
 928
 929    case GL_COMPRESSED_SRGB_EXT:
 930    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 931       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target,
 932                                       sample_count, bindings))
 933          return PIPE_FORMAT_DXT1_SRGB;
 934       return default_srgba_format( screen, target, sample_count, bindings);
 935
 936    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 937       return PIPE_FORMAT_DXT1_SRGBA;
 938
 939    case GL_COMPRESSED_SRGB_ALPHA_EXT:
 940    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 941       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target,
 942                                       sample_count, bindings))
 943          return PIPE_FORMAT_DXT3_SRGBA;
 944       return default_srgba_format( screen, target, sample_count, bindings);
 945
 946    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 947       return PIPE_FORMAT_DXT5_SRGBA;
 948
 949    case GL_SLUMINANCE_ALPHA_EXT:
 950    case GL_SLUMINANCE8_ALPHA8_EXT:
 951    case GL_COMPRESSED_SLUMINANCE_EXT:
 952    case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 953       if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,
 954                                       sample_count, bindings))
 955          return PIPE_FORMAT_L8A8_SRGB;
 956       return default_srgba_format( screen, target, sample_count, bindings);
 957
 958    case GL_SLUMINANCE_EXT:
 959    case GL_SLUMINANCE8_EXT:
 960       if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,
 961                                       sample_count, bindings))
 962          return PIPE_FORMAT_L8_SRGB;
 963       return default_srgba_format( screen, target, sample_count, bindings);
 964
 965    /* prefer formats in order of data size, choosing 16-bit ones if equal sized */
 966    case GL_RGBA16F_ARB:
 967       {
 968          static const enum pipe_format formats[] = {
 969                PIPE_FORMAT_R16G16B16A16_FLOAT,
 970                PIPE_FORMAT_R32G32B32A32_FLOAT
 971          };
 972          return find_supported_format(screen, formats, Elements(formats),
 973                                       target, sample_count, bindings);
 974       }
 975    case GL_RGB16F_ARB:
 976       {
 977          static const enum pipe_format formats[] = {
 978                PIPE_FORMAT_R16G16B16_FLOAT,
 979                PIPE_FORMAT_R16G16B16A16_FLOAT,
 980                PIPE_FORMAT_R32G32B32_FLOAT,
 981                PIPE_FORMAT_R32G32B32A32_FLOAT
 982          };
 983          return find_supported_format(screen, formats, Elements(formats),
 984                                       target, sample_count, bindings);
 985       }
 986    case GL_LUMINANCE_ALPHA16F_ARB:
 987       {
 988          static const enum pipe_format formats[] = {
 989                PIPE_FORMAT_L16A16_FLOAT,
 990                PIPE_FORMAT_R16G16B16A16_FLOAT,
 991                PIPE_FORMAT_L32A32_FLOAT,
 992                PIPE_FORMAT_R32G32B32A32_FLOAT
 993          };
 994          return find_supported_format(screen, formats, Elements(formats),
 995                target, sample_count, bindings);
 996       }
 997    case GL_ALPHA16F_ARB:
 998       {
 999          static const enum pipe_format formats[] = {
1000                PIPE_FORMAT_A16_FLOAT,
1001                PIPE_FORMAT_L16A16_FLOAT,
1002                PIPE_FORMAT_A32_FLOAT,
1003                PIPE_FORMAT_R16G16B16A16_FLOAT,
1004                PIPE_FORMAT_L32A32_FLOAT,
1005                PIPE_FORMAT_R32G32B32A32_FLOAT
1006          };
1007          return find_supported_format(screen, formats, Elements(formats),
1008                target, sample_count, bindings);
1009       }
1010    case GL_INTENSITY16F_ARB:
1011       {
1012          static const enum pipe_format formats[] = {
1013                PIPE_FORMAT_I16_FLOAT,
1014                PIPE_FORMAT_L16A16_FLOAT,
1015                PIPE_FORMAT_I32_FLOAT,
1016                PIPE_FORMAT_R16G16B16A16_FLOAT,
1017                PIPE_FORMAT_L32A32_FLOAT,
1018                PIPE_FORMAT_R32G32B32A32_FLOAT
1019          };
1020          return find_supported_format(screen, formats, Elements(formats),
1021                target, sample_count, bindings);
1022       }
1023    case GL_LUMINANCE16F_ARB:
1024       {
1025          static const enum pipe_format formats[] = {
1026                PIPE_FORMAT_L16_FLOAT,
1027                PIPE_FORMAT_L16A16_FLOAT,
1028                PIPE_FORMAT_L32_FLOAT,
1029                PIPE_FORMAT_R16G16B16A16_FLOAT,
1030                PIPE_FORMAT_L32A32_FLOAT,
1031                PIPE_FORMAT_R32G32B32A32_FLOAT
1032          };
1033          return find_supported_format(screen, formats, Elements(formats),
1034                target, sample_count, bindings);
1035       }
1036    case GL_R16F:
1037       {
1038          static const enum pipe_format formats[] = {
1039                PIPE_FORMAT_R16_FLOAT,
1040                PIPE_FORMAT_R16G16_FLOAT,
1041                PIPE_FORMAT_R32_FLOAT,
1042                PIPE_FORMAT_R16G16B16A16_FLOAT,
1043                PIPE_FORMAT_R32G32_FLOAT,
1044                PIPE_FORMAT_R32G32B32A32_FLOAT
1045          };
1046          return find_supported_format(screen, formats, Elements(formats),
1047                target, sample_count, bindings);
1048       }
1049    case GL_RG16F:
1050       {
1051          static const enum pipe_format formats[] = {
1052                PIPE_FORMAT_R16G16_FLOAT,
1053                PIPE_FORMAT_R16G16B16A16_FLOAT,
1054                PIPE_FORMAT_R32G32_FLOAT,
1055                PIPE_FORMAT_R32G32B32A32_FLOAT
1056          };
1057          return find_supported_format(screen, formats, Elements(formats),
1058                target, sample_count, bindings);
1059       }
1060
1061    /* try a 32-bit format if available, otherwise fallback to a 16-bit one */
1062    case GL_RGBA32F_ARB:
1063       {
1064          static const enum pipe_format formats[] = {
1065                PIPE_FORMAT_R32G32B32A32_FLOAT,
1066                PIPE_FORMAT_R16G16B16A16_FLOAT
1067          };
1068          return find_supported_format(screen, formats, Elements(formats),
1069                                       target, sample_count, bindings);
1070       }
1071    case GL_RGB32F_ARB:
1072       {
1073          static const enum pipe_format formats[] = {
1074                PIPE_FORMAT_R32G32B32_FLOAT,
1075                PIPE_FORMAT_R32G32B32A32_FLOAT,
1076                PIPE_FORMAT_R16G16B16A16_FLOAT
1077          };
1078          return find_supported_format(screen, formats, Elements(formats),
1079                                       target, sample_count, bindings);
1080       }
1081    case GL_LUMINANCE_ALPHA32F_ARB:
1082       {
1083          static const enum pipe_format formats[] = {
1084                PIPE_FORMAT_L32A32_FLOAT,
1085                PIPE_FORMAT_R32G32B32A32_FLOAT,
1086                PIPE_FORMAT_L16A16_FLOAT,
1087                PIPE_FORMAT_R16G16B16A16_FLOAT
1088          };
1089          return find_supported_format(screen, formats, Elements(formats),
1090                target, sample_count, bindings);
1091       }
1092    case GL_ALPHA32F_ARB:
1093       {
1094          static const enum pipe_format formats[] = {
1095                PIPE_FORMAT_A32_FLOAT,
1096                PIPE_FORMAT_L32A32_FLOAT,
1097                PIPE_FORMAT_R32G32B32A32_FLOAT,
1098                PIPE_FORMAT_A16_FLOAT,
1099                PIPE_FORMAT_L16A16_FLOAT,
1100                PIPE_FORMAT_R16G16B16A16_FLOAT
1101          };
1102          return find_supported_format(screen, formats, Elements(formats),
1103                target, sample_count, bindings);
1104       }
1105    case GL_INTENSITY32F_ARB:
1106       {
1107          static const enum pipe_format formats[] = {
1108                PIPE_FORMAT_I32_FLOAT,
1109                PIPE_FORMAT_L32A32_FLOAT,
1110                PIPE_FORMAT_R32G32B32A32_FLOAT,
1111                PIPE_FORMAT_I16_FLOAT,
1112                PIPE_FORMAT_L16A16_FLOAT,
1113                PIPE_FORMAT_R16G16B16A16_FLOAT
1114          };
1115          return find_supported_format(screen, formats, Elements(formats),
1116                target, sample_count, bindings);
1117       }
1118    case GL_LUMINANCE32F_ARB:
1119       {
1120          static const enum pipe_format formats[] = {
1121                PIPE_FORMAT_L32_FLOAT,
1122                PIPE_FORMAT_L32A32_FLOAT,
1123                PIPE_FORMAT_R32G32B32A32_FLOAT,
1124                PIPE_FORMAT_L16_FLOAT,
1125                PIPE_FORMAT_L16A16_FLOAT,
1126                PIPE_FORMAT_R16G16B16A16_FLOAT
1127          };
1128          return find_supported_format(screen, formats, Elements(formats),
1129                target, sample_count, bindings);
1130       }
1131    case GL_R32F:
1132       {
1133          static const enum pipe_format formats[] = {
1134                PIPE_FORMAT_R32_FLOAT,
1135                PIPE_FORMAT_R32G32_FLOAT,
1136                PIPE_FORMAT_R32G32B32A32_FLOAT,
1137                PIPE_FORMAT_R16_FLOAT,
1138                PIPE_FORMAT_R16G16_FLOAT,
1139                PIPE_FORMAT_R16G16B16A16_FLOAT
1140          };
1141          return find_supported_format(screen, formats, Elements(formats),
1142                target, sample_count, bindings);
1143       }
1144    case GL_RG32F:
1145       {
1146          static const enum pipe_format formats[] = {
1147                PIPE_FORMAT_R32G32_FLOAT,
1148                PIPE_FORMAT_R32G32B32A32_FLOAT,
1149                PIPE_FORMAT_R16G16_FLOAT,
1150                PIPE_FORMAT_R16G16B16A16_FLOAT
1151          };
1152          return find_supported_format(screen, formats, Elements(formats),
1153                target, sample_count, bindings);
1154       }
1155
1156    case GL_RED:
1157    case GL_R8:
1158       if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
1159                                       sample_count, bindings))
1160               return PIPE_FORMAT_R8_UNORM;
1161       return PIPE_FORMAT_NONE;
1162    case GL_RG:
1163    case GL_RG8:
1164       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
1165                                       sample_count, bindings))
1166               return PIPE_FORMAT_R8G8_UNORM;
1167       return PIPE_FORMAT_NONE;
1168
1169    case GL_R16:
1170       if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,
1171                                       sample_count, bindings))
1172               return PIPE_FORMAT_R16_UNORM;
1173       return PIPE_FORMAT_NONE;
1174
1175    case GL_RG16:
1176       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,
1177                                       sample_count, bindings))
1178               return PIPE_FORMAT_R16G16_UNORM;
1179       return PIPE_FORMAT_NONE;
1180
1181    case GL_COMPRESSED_RED:
1182    case GL_COMPRESSED_RED_RGTC1:
1183       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,
1184                                       sample_count, bindings))
1185               return PIPE_FORMAT_RGTC1_UNORM;
1186       if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
1187                                       sample_count, bindings))
1188               return PIPE_FORMAT_R8_UNORM;
1189       return PIPE_FORMAT_NONE;
1190
1191    case GL_COMPRESSED_SIGNED_RED_RGTC1:
1192       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,
1193                                       sample_count, bindings))
1194               return PIPE_FORMAT_RGTC1_SNORM;
1195       return PIPE_FORMAT_NONE;
1196
1197    case GL_COMPRESSED_RG:
1198    case GL_COMPRESSED_RG_RGTC2:
1199       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,
1200                                       sample_count, bindings))
1201               return PIPE_FORMAT_RGTC2_UNORM;
1202       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
1203                                       sample_count, bindings))
1204               return PIPE_FORMAT_R8G8_UNORM;
1205       return PIPE_FORMAT_NONE;
1206
1207    case GL_COMPRESSED_SIGNED_RG_RGTC2:
1208       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,
1209                                       sample_count, bindings))
1210               return PIPE_FORMAT_RGTC2_SNORM;
1211       return PIPE_FORMAT_NONE;
1212
1213    case GL_COMPRESSED_LUMINANCE:
1214    case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
1215       if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM, target,
1216                                       sample_count, bindings))
1217               return PIPE_FORMAT_LATC1_UNORM;
1218       if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM, target,
1219                                       sample_count, bindings))
1220               return PIPE_FORMAT_L8_UNORM;
1221       return PIPE_FORMAT_NONE;
1222
1223    case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
1224       if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM, target,
1225                                       sample_count, bindings))
1226               return PIPE_FORMAT_LATC1_SNORM;
1227       return PIPE_FORMAT_NONE;
1228
1229    case GL_COMPRESSED_LUMINANCE_ALPHA:
1230    case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
1231    case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
1232       if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM, target,
1233                                       sample_count, bindings))
1234               return PIPE_FORMAT_LATC2_UNORM;
1235       if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_UNORM, target,
1236                                       sample_count, bindings))
1237               return PIPE_FORMAT_L8A8_UNORM;
1238       return PIPE_FORMAT_NONE;
1239
1240    case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
1241       if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM, target,
1242                                       sample_count, bindings))
1243               return PIPE_FORMAT_LATC2_SNORM;
1244       return PIPE_FORMAT_NONE;
1245
1246    /* signed/unsigned integer formats.
1247     * XXX Mesa only has formats for RGBA signed/unsigned integer formats.
1248     * If/when new formats are added this code should be updated.
1249     */
1250    case GL_RED_INTEGER_EXT:
1251    case GL_GREEN_INTEGER_EXT:
1252    case GL_BLUE_INTEGER_EXT:
1253    case GL_ALPHA_INTEGER_EXT:
1254    case GL_RGB_INTEGER_EXT:
1255    case GL_RGBA_INTEGER_EXT:
1256    case GL_BGR_INTEGER_EXT:
1257    case GL_BGRA_INTEGER_EXT:
1258    case GL_LUMINANCE_INTEGER_EXT:
1259    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
1260       /* fall-through */
1261    case GL_RGBA8I_EXT:
1262    case GL_RGB8I_EXT:
1263    case GL_ALPHA8I_EXT:
1264    case GL_INTENSITY8I_EXT:
1265    case GL_LUMINANCE8I_EXT:
1266    case GL_LUMINANCE_ALPHA8I_EXT:
1267       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,
1268                                       target,
1269                                       sample_count, bindings))
1270          return PIPE_FORMAT_R8G8B8A8_SSCALED;
1271       return PIPE_FORMAT_NONE;
1272    case GL_RGBA16I_EXT:
1273    case GL_RGB16I_EXT:
1274    case GL_ALPHA16I_EXT:
1275    case GL_INTENSITY16I_EXT:
1276    case GL_LUMINANCE16I_EXT:
1277    case GL_LUMINANCE_ALPHA16I_EXT:
1278       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,
1279                                       target,
1280                                       sample_count, bindings))
1281          return PIPE_FORMAT_R16G16B16A16_SSCALED;
1282       return PIPE_FORMAT_NONE;
1283    case GL_RGBA32I_EXT:
1284    case GL_RGB32I_EXT:
1285    case GL_ALPHA32I_EXT:
1286    case GL_INTENSITY32I_EXT:
1287    case GL_LUMINANCE32I_EXT:
1288    case GL_LUMINANCE_ALPHA32I_EXT:
1289       /* xxx */
1290       if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,
1291                                       target,
1292                                       sample_count, bindings))
1293          return PIPE_FORMAT_R32G32B32A32_SSCALED;
1294       return PIPE_FORMAT_NONE;
1295
1296    case GL_RGBA8UI_EXT:
1297    case GL_RGB8UI_EXT:
1298    case GL_ALPHA8UI_EXT:
1299    case GL_INTENSITY8UI_EXT:
1300    case GL_LUMINANCE8UI_EXT:
1301    case GL_LUMINANCE_ALPHA8UI_EXT:
1302       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,
1303                                       target,
1304                                       sample_count, bindings))
1305          return PIPE_FORMAT_R8G8B8A8_USCALED;
1306       return PIPE_FORMAT_NONE;
1307
1308    case GL_RGBA16UI_EXT:
1309    case GL_RGB16UI_EXT:
1310    case GL_ALPHA16UI_EXT:
1311    case GL_INTENSITY16UI_EXT:
1312    case GL_LUMINANCE16UI_EXT:
1313    case GL_LUMINANCE_ALPHA16UI_EXT:
1314       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,
1315                                       target,
1316                                       sample_count, bindings))
1317          return PIPE_FORMAT_R16G16B16A16_USCALED;
1318       return PIPE_FORMAT_NONE;
1319
1320    case GL_RGBA32UI_EXT:
1321    case GL_RGB32UI_EXT:
1322    case GL_ALPHA32UI_EXT:
1323    case GL_INTENSITY32UI_EXT:
1324    case GL_LUMINANCE32UI_EXT:
1325    case GL_LUMINANCE_ALPHA32UI_EXT:
1326       if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,
1327                                       target,
1328                                       sample_count, bindings))
1329          return PIPE_FORMAT_R32G32B32A32_USCALED;
1330       return PIPE_FORMAT_NONE;
1331
1332    /* signed normalized formats */
1333    case GL_RED_SNORM:
1334    case GL_R8_SNORM:
1335       {
1336          static const enum pipe_format formats[] = {
1337             PIPE_FORMAT_R8_SNORM,
1338             PIPE_FORMAT_R8G8_SNORM,
1339             PIPE_FORMAT_R8G8B8A8_SNORM,
1340          };
1341          return find_supported_format(screen, formats, Elements(formats),
1342                target, sample_count, bindings);
1343       }
1344
1345    case GL_R16_SNORM:
1346       {
1347          static const enum pipe_format formats[] = {
1348             PIPE_FORMAT_R16_SNORM,
1349             PIPE_FORMAT_R16G16_SNORM,
1350             PIPE_FORMAT_R16G16B16A16_SNORM,
1351             PIPE_FORMAT_R8_SNORM,
1352             PIPE_FORMAT_R8G8_SNORM,
1353             PIPE_FORMAT_R8G8B8A8_SNORM,
1354          };
1355          return find_supported_format(screen, formats, Elements(formats),
1356                target, sample_count, bindings);
1357       }
1358
1359    case GL_RG_SNORM:
1360    case GL_RG8_SNORM:
1361       {
1362          static const enum pipe_format formats[] = {
1363             PIPE_FORMAT_R8G8_SNORM,
1364             PIPE_FORMAT_R8G8B8A8_SNORM,
1365          };
1366          return find_supported_format(screen, formats, Elements(formats),
1367                target, sample_count, bindings);
1368       }
1369
1370    case GL_RG16_SNORM:
1371       {
1372          static const enum pipe_format formats[] = {
1373             PIPE_FORMAT_R16G16_SNORM,
1374             PIPE_FORMAT_R16G16B16A16_SNORM,
1375             PIPE_FORMAT_R8G8_SNORM,
1376             PIPE_FORMAT_R8G8B8A8_SNORM,
1377          };
1378          return find_supported_format(screen, formats, Elements(formats),
1379                target, sample_count, bindings);
1380       }
1381
1382    case GL_RGB_SNORM:
1383    case GL_RGB8_SNORM:
1384    case GL_RGBA_SNORM:
1385    case GL_RGBA8_SNORM:
1386       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SNORM,
1387                                       target,
1388                                       sample_count, bindings))
1389          return PIPE_FORMAT_R8G8B8A8_SNORM;
1390       return PIPE_FORMAT_NONE;
1391
1392    case GL_RGB16_SNORM:
1393    case GL_RGBA16_SNORM:
1394       {
1395          static const enum pipe_format formats[] = {
1396             PIPE_FORMAT_R16G16B16A16_SNORM,
1397             PIPE_FORMAT_R8G8B8A8_SNORM,
1398          };
1399          return find_supported_format(screen, formats, Elements(formats),
1400                target, sample_count, bindings);
1401       }
1402
1403
1404    case GL_ALPHA_SNORM:
1405    case GL_ALPHA8_SNORM:
1406       {
1407          static const enum pipe_format formats[] = {
1408             PIPE_FORMAT_A8_SNORM,
1409             PIPE_FORMAT_R8G8B8A8_SNORM,
1410          };
1411          return find_supported_format(screen, formats, Elements(formats),
1412                target, sample_count, bindings);
1413       }
1414
1415    case GL_ALPHA16_SNORM:
1416       {
1417          static const enum pipe_format formats[] = {
1418             PIPE_FORMAT_A16_SNORM,
1419             PIPE_FORMAT_R16G16B16A16_SNORM,
1420             PIPE_FORMAT_A8_SNORM,
1421             PIPE_FORMAT_R8G8B8A8_SNORM,
1422          };
1423          return find_supported_format(screen, formats, Elements(formats),
1424                target, sample_count, bindings);
1425       }
1426
1427    case GL_LUMINANCE_SNORM:
1428    case GL_LUMINANCE8_SNORM:
1429       {
1430          static const enum pipe_format formats[] = {
1431             PIPE_FORMAT_L8_SNORM,
1432             PIPE_FORMAT_R8G8B8A8_SNORM,
1433          };
1434          return find_supported_format(screen, formats, Elements(formats),
1435                target, sample_count, bindings);
1436       }
1437
1438    case GL_LUMINANCE16_SNORM:
1439       {
1440          static const enum pipe_format formats[] = {
1441             PIPE_FORMAT_L16_SNORM,
1442             PIPE_FORMAT_R16G16B16A16_SNORM,
1443             PIPE_FORMAT_L8_SNORM,
1444             PIPE_FORMAT_R8G8B8A8_SNORM,
1445          };
1446          return find_supported_format(screen, formats, Elements(formats),
1447                target, sample_count, bindings);
1448       }
1449
1450    case GL_LUMINANCE_ALPHA_SNORM:
1451    case GL_LUMINANCE8_ALPHA8_SNORM:
1452       {
1453          static const enum pipe_format formats[] = {
1454             PIPE_FORMAT_L8A8_SNORM,
1455             PIPE_FORMAT_R8G8B8A8_SNORM,
1456          };
1457          return find_supported_format(screen, formats, Elements(formats),
1458                target, sample_count, bindings);
1459       }
1460
1461    case GL_LUMINANCE16_ALPHA16_SNORM:
1462       {
1463          static const enum pipe_format formats[] = {
1464             PIPE_FORMAT_L16A16_SNORM,
1465             PIPE_FORMAT_R16G16B16A16_SNORM,
1466             PIPE_FORMAT_L8A8_SNORM,
1467             PIPE_FORMAT_R8G8B8A8_SNORM,
1468          };
1469          return find_supported_format(screen, formats, Elements(formats),
1470                target, sample_count, bindings);
1471       }
1472
1473    case GL_INTENSITY_SNORM:
1474    case GL_INTENSITY8_SNORM:
1475       {
1476          static const enum pipe_format formats[] = {
1477             PIPE_FORMAT_I8_SNORM,
1478             PIPE_FORMAT_R8G8B8A8_SNORM,
1479          };
1480          return find_supported_format(screen, formats, Elements(formats),
1481                target, sample_count, bindings);
1482       }
1483
1484    case GL_INTENSITY16_SNORM:
1485       {
1486          static const enum pipe_format formats[] = {
1487             PIPE_FORMAT_I16_SNORM,
1488             PIPE_FORMAT_R16G16B16A16_SNORM,
1489             PIPE_FORMAT_I8_SNORM,
1490             PIPE_FORMAT_R8G8B8A8_SNORM,
1491          };
1492          return find_supported_format(screen, formats, Elements(formats),
1493                target, sample_count, bindings);
1494       }
1495
1496    case GL_RGB9_E5:
1497       if (screen->is_format_supported(screen, PIPE_FORMAT_R9G9B9E5_FLOAT, target,
1498                                       sample_count, bindings)) {
1499          return PIPE_FORMAT_R9G9B9E5_FLOAT;
1500       }
1501       return PIPE_FORMAT_NONE;
1502
1503    case GL_R11F_G11F_B10F:
1504       if (screen->is_format_supported(screen, PIPE_FORMAT_R11G11B10_FLOAT, target,
1505                                       sample_count, bindings)) {
1506          return PIPE_FORMAT_R11G11B10_FLOAT;
1507       }
1508       return PIPE_FORMAT_NONE;
1509
1510    default:
1511       return PIPE_FORMAT_NONE;
1512    }
1513 }
1514
1515
1516 /**
1517  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
1518  */
1519 enum pipe_format
1520 st_choose_renderbuffer_format(struct pipe_screen *screen,
1521                               GLenum internalFormat, unsigned sample_count)
1522 {
1523    uint usage;
1524    if (_mesa_is_depth_or_stencil_format(internalFormat))
1525       usage = PIPE_BIND_DEPTH_STENCIL;
1526    else
1527       usage = PIPE_BIND_RENDER_TARGET;
1528    return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D,
1529                            sample_count, usage);
1530 }
1531
1532
1533 /**
1534  * Called via ctx->Driver.chooseTextureFormat().
1535  */
1536 gl_format
1537 st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,
1538                                   GLenum format, GLenum type, GLboolean renderable)
1539 {
1540    struct pipe_screen *screen = st_context(ctx)->pipe->screen;
1541    enum pipe_format pFormat;
1542    uint bindings;
1543
1544    (void) format;
1545    (void) type;
1546
1547    /* GL textures may wind up being render targets, but we don't know
1548     * that in advance.  Specify potential render target flags now.
1549     */
1550    bindings = PIPE_BIND_SAMPLER_VIEW;
1551    if (renderable == GL_TRUE) {
1552       if (_mesa_is_depth_format(internalFormat) ||
1553           _mesa_is_depth_or_stencil_format(internalFormat))
1554          bindings |= PIPE_BIND_DEPTH_STENCIL;
1555       else
1556          bindings |= PIPE_BIND_RENDER_TARGET;
1557    }
1558
1559    pFormat = st_choose_format(screen, internalFormat,
1560                               PIPE_TEXTURE_2D, 0, bindings);
1561
1562    if (pFormat == PIPE_FORMAT_NONE) {
1563       /* try choosing format again, this time without render target bindings */
1564       pFormat = st_choose_format(screen, internalFormat,
1565                                  PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);
1566    }
1567
1568    if (pFormat == PIPE_FORMAT_NONE) {
1569       /* no luck at all */
1570       return MESA_FORMAT_NONE;
1571    }
1572
1573    return st_pipe_format_to_mesa_format(pFormat);
1574 }
1575
1576 gl_format
1577 st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat,
1578                        GLenum format, GLenum type)
1579 {
1580    boolean want_renderable =
1581       internalFormat == 3 || internalFormat == 4 ||
1582       internalFormat == GL_RGB || internalFormat == GL_RGBA ||
1583       internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
1584       internalFormat == GL_BGRA;
1585
1586    return st_ChooseTextureFormat_renderable(ctx, internalFormat,
1587                                             format, type, want_renderable);
1588 }
1589
1590 /**
1591  * Test if a gallium format is equivalent to a GL format/type.
1592  */
1593 GLboolean
1594 st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)
1595 {
1596    switch (pFormat) {
1597    case PIPE_FORMAT_A8B8G8R8_UNORM:
1598       return format == GL_RGBA && type == GL_UNSIGNED_BYTE;
1599    case PIPE_FORMAT_A8R8G8B8_UNORM:
1600       return format == GL_BGRA && type == GL_UNSIGNED_BYTE;
1601    case PIPE_FORMAT_B5G6R5_UNORM:
1602       return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;
1603    /* XXX more combos... */
1604    default:
1605       return GL_FALSE;
1606    }
1607 }
1608
1609 GLboolean
1610 st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2)
1611 {
1612    if (format1 == format2)
1613       return GL_TRUE;
1614
1615    if (format1 == PIPE_FORMAT_B8G8R8A8_UNORM &&
1616        format2 == PIPE_FORMAT_B8G8R8X8_UNORM)
1617       return GL_TRUE;
1618
1619    if (format1 == PIPE_FORMAT_B8G8R8X8_UNORM &&
1620        format2 == PIPE_FORMAT_B8G8R8A8_UNORM)
1621       return GL_TRUE;
1622
1623    if (format1 == PIPE_FORMAT_A8B8G8R8_UNORM &&
1624        format2 == PIPE_FORMAT_X8B8G8R8_UNORM)
1625       return GL_TRUE;
1626
1627    if (format1 == PIPE_FORMAT_X8B8G8R8_UNORM &&
1628        format2 == PIPE_FORMAT_A8B8G8R8_UNORM)
1629       return GL_TRUE;
1630
1631    if (format1 == PIPE_FORMAT_A8R8G8B8_UNORM &&
1632        format2 == PIPE_FORMAT_X8R8G8B8_UNORM)
1633       return GL_TRUE;
1634
1635    if (format1 == PIPE_FORMAT_X8R8G8B8_UNORM &&
1636        format2 == PIPE_FORMAT_A8R8G8B8_UNORM)
1637       return GL_TRUE;
1638
1639    return GL_FALSE;
1640 }
1641
1642
1643
1644 /**
1645  * This is used for translating texture border color and the clear
1646  * color.  For example, the clear color is interpreted according to
1647  * the renderbuffer's base format.  For example, if clearing a
1648  * GL_LUMINANCE buffer, ClearColor[0] = luminance and ClearColor[1] =
1649  * alpha.  Similarly for texture border colors.
1650  */
1651 void
1652 st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,
1653                    GLfloat colorOut[4])
1654 {
1655    switch (baseFormat) {
1656    case GL_RED:
1657       colorOut[0] = colorIn[0];
1658       colorOut[1] = 0.0F;
1659       colorOut[2] = 0.0F;
1660       colorOut[3] = 1.0F;
1661       break;
1662    case GL_RG:
1663       colorOut[0] = colorIn[0];
1664       colorOut[1] = colorIn[1];
1665       colorOut[2] = 0.0F;
1666       colorOut[3] = 1.0F;
1667       break;
1668    case GL_RGB:
1669       colorOut[0] = colorIn[0];
1670       colorOut[1] = colorIn[1];
1671       colorOut[2] = colorIn[2];
1672       colorOut[3] = 1.0F;
1673       break;
1674    case GL_ALPHA:
1675       colorOut[0] = colorOut[1] = colorOut[2] = 0.0;
1676       colorOut[3] = colorIn[3];
1677       break;
1678    case GL_LUMINANCE:
1679       colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
1680       colorOut[3] = 1.0;
1681       break;
1682    case GL_LUMINANCE_ALPHA:
1683       colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
1684       colorOut[3] = colorIn[3];
1685       break;
1686    case GL_INTENSITY:
1687       colorOut[0] = colorOut[1] = colorOut[2] = colorOut[3] = colorIn[0];
1688       break;
1689    default:
1690       COPY_4V(colorOut, colorIn);
1691    }
1692 }