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_R8:
 218       return PIPE_FORMAT_R8_UNORM;
 219    case MESA_FORMAT_R16:
 220       return PIPE_FORMAT_R16_UNORM;
 221    case MESA_FORMAT_RG88:
 222       return PIPE_FORMAT_R8G8_UNORM;
 223    case MESA_FORMAT_RG1616:
 224       return PIPE_FORMAT_R16G16_UNORM;
 225    case MESA_FORMAT_RGBA_16:
 226       return PIPE_FORMAT_R16G16B16A16_UNORM;
 227
 228    /* signed int formats */
 229    case MESA_FORMAT_RGBA_INT8:
 230       return PIPE_FORMAT_R8G8B8A8_SSCALED;
 231    case MESA_FORMAT_RGBA_INT16:
 232       return PIPE_FORMAT_R16G16B16A16_SSCALED;
 233    case MESA_FORMAT_RGBA_INT32:
 234       return PIPE_FORMAT_R32G32B32A32_SSCALED;
 235
 236    /* unsigned int formats */
 237    case MESA_FORMAT_RGBA_UINT8:
 238       return PIPE_FORMAT_R8G8B8A8_USCALED;
 239    case MESA_FORMAT_RGBA_UINT16:
 240       return PIPE_FORMAT_R16G16B16A16_USCALED;
 241    case MESA_FORMAT_RGBA_UINT32:
 242       return PIPE_FORMAT_R32G32B32A32_USCALED;
 243
 244    case MESA_FORMAT_RED_RGTC1:
 245       return PIPE_FORMAT_RGTC1_UNORM;
 246    case MESA_FORMAT_SIGNED_RED_RGTC1:
 247       return PIPE_FORMAT_RGTC1_SNORM;
 248    case MESA_FORMAT_RG_RGTC2:
 249       return PIPE_FORMAT_RGTC2_UNORM;
 250    case MESA_FORMAT_SIGNED_RG_RGTC2:
 251       return PIPE_FORMAT_RGTC2_SNORM;
 252
 253    case MESA_FORMAT_L_LATC1:
 254       return PIPE_FORMAT_LATC1_UNORM;
 255    case MESA_FORMAT_SIGNED_L_LATC1:
 256       return PIPE_FORMAT_LATC1_SNORM;
 257    case MESA_FORMAT_LA_LATC2:
 258       return PIPE_FORMAT_LATC2_UNORM;
 259    case MESA_FORMAT_SIGNED_LA_LATC2:
 260       return PIPE_FORMAT_LATC2_SNORM;
 261
 262    default:
 263       assert(0);
 264       return PIPE_FORMAT_NONE;
 265    }
 266 }
 267
 268
 269 /**
 270  * Translate Gallium format to Mesa format.
 271  */
 272 gl_format
 273 st_pipe_format_to_mesa_format(enum pipe_format format)
 274 {
 275    switch (format) {
 276    case PIPE_FORMAT_A8B8G8R8_UNORM:
 277       return MESA_FORMAT_RGBA8888;
 278    case PIPE_FORMAT_R8G8B8A8_UNORM:
 279       return MESA_FORMAT_RGBA8888_REV;
 280    case PIPE_FORMAT_B8G8R8A8_UNORM:
 281       return MESA_FORMAT_ARGB8888;
 282    case PIPE_FORMAT_A8R8G8B8_UNORM:
 283       return MESA_FORMAT_ARGB8888_REV;
 284    case PIPE_FORMAT_B8G8R8X8_UNORM:
 285       return MESA_FORMAT_XRGB8888;
 286    case PIPE_FORMAT_X8R8G8B8_UNORM:
 287       return MESA_FORMAT_XRGB8888_REV;
 288    case PIPE_FORMAT_B5G5R5A1_UNORM:
 289       return MESA_FORMAT_ARGB1555;
 290    case PIPE_FORMAT_B4G4R4A4_UNORM:
 291       return MESA_FORMAT_ARGB4444;
 292    case PIPE_FORMAT_B5G6R5_UNORM:
 293       return MESA_FORMAT_RGB565;
 294    case PIPE_FORMAT_B2G3R3_UNORM:
 295       return MESA_FORMAT_RGB332;
 296    case PIPE_FORMAT_B10G10R10A2_UNORM:
 297       return MESA_FORMAT_ARGB2101010;
 298    case PIPE_FORMAT_L4A4_UNORM:
 299       return MESA_FORMAT_AL44;
 300    case PIPE_FORMAT_L8A8_UNORM:
 301       return MESA_FORMAT_AL88;
 302    case PIPE_FORMAT_L16A16_UNORM:
 303       return MESA_FORMAT_AL1616;
 304    case PIPE_FORMAT_A8_UNORM:
 305       return MESA_FORMAT_A8;
 306    case PIPE_FORMAT_A16_UNORM:
 307       return MESA_FORMAT_A16;
 308    case PIPE_FORMAT_L8_UNORM:
 309       return MESA_FORMAT_L8;
 310    case PIPE_FORMAT_L16_UNORM:
 311       return MESA_FORMAT_L16;
 312    case PIPE_FORMAT_I8_UNORM:
 313       return MESA_FORMAT_I8;
 314    case PIPE_FORMAT_I16_UNORM:
 315       return MESA_FORMAT_I16;
 316    case PIPE_FORMAT_S8_USCALED:
 317       return MESA_FORMAT_S8;
 318
 319    case PIPE_FORMAT_R16G16B16A16_UNORM:
 320       return MESA_FORMAT_RGBA_16;
 321    case PIPE_FORMAT_R16G16B16A16_SNORM:
 322       return MESA_FORMAT_SIGNED_RGBA_16;
 323
 324    case PIPE_FORMAT_Z16_UNORM:
 325       return MESA_FORMAT_Z16;
 326    case PIPE_FORMAT_Z32_UNORM:
 327       return MESA_FORMAT_Z32;
 328    case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
 329       return MESA_FORMAT_Z24_S8;
 330    case PIPE_FORMAT_X8Z24_UNORM:
 331       return MESA_FORMAT_Z24_X8;
 332    case PIPE_FORMAT_Z24X8_UNORM:
 333       return MESA_FORMAT_X8_Z24;
 334    case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
 335       return MESA_FORMAT_S8_Z24;
 336
 337    case PIPE_FORMAT_UYVY:
 338       return MESA_FORMAT_YCBCR;
 339    case PIPE_FORMAT_YUYV:
 340       return MESA_FORMAT_YCBCR_REV;
 341
 342 #if FEATURE_texture_s3tc
 343    case PIPE_FORMAT_DXT1_RGB:
 344       return MESA_FORMAT_RGB_DXT1;
 345    case PIPE_FORMAT_DXT1_RGBA:
 346       return MESA_FORMAT_RGBA_DXT1;
 347    case PIPE_FORMAT_DXT3_RGBA:
 348       return MESA_FORMAT_RGBA_DXT3;
 349    case PIPE_FORMAT_DXT5_RGBA:
 350       return MESA_FORMAT_RGBA_DXT5;
 351 #if FEATURE_EXT_texture_sRGB
 352    case PIPE_FORMAT_DXT1_SRGB:
 353       return MESA_FORMAT_SRGB_DXT1;
 354    case PIPE_FORMAT_DXT1_SRGBA:
 355       return MESA_FORMAT_SRGBA_DXT1;
 356    case PIPE_FORMAT_DXT3_SRGBA:
 357       return MESA_FORMAT_SRGBA_DXT3;
 358    case PIPE_FORMAT_DXT5_SRGBA:
 359       return MESA_FORMAT_SRGBA_DXT5;
 360 #endif
 361 #endif
 362
 363 #if FEATURE_EXT_texture_sRGB
 364    case PIPE_FORMAT_L8A8_SRGB:
 365       return MESA_FORMAT_SLA8;
 366    case PIPE_FORMAT_L8_SRGB:
 367       return MESA_FORMAT_SL8;
 368    case PIPE_FORMAT_R8G8B8_SRGB:
 369       return MESA_FORMAT_SRGB8;
 370    case PIPE_FORMAT_A8B8G8R8_SRGB:
 371       return MESA_FORMAT_SRGBA8;
 372    case PIPE_FORMAT_B8G8R8A8_SRGB:
 373       return MESA_FORMAT_SARGB8;
 374 #endif
 375
 376    case PIPE_FORMAT_R8_UNORM:
 377       return MESA_FORMAT_R8;
 378    case PIPE_FORMAT_R16_UNORM:
 379       return MESA_FORMAT_R16;
 380    case PIPE_FORMAT_R8G8_UNORM:
 381       return MESA_FORMAT_RG88;
 382    case PIPE_FORMAT_R16G16_UNORM:
 383       return MESA_FORMAT_RG1616;
 384
 385    /* signed int formats */
 386    case PIPE_FORMAT_R8G8B8A8_SSCALED:
 387       return MESA_FORMAT_RGBA_INT8;
 388    case PIPE_FORMAT_R16G16B16A16_SSCALED:
 389       return MESA_FORMAT_RGBA_INT16;
 390    case PIPE_FORMAT_R32G32B32A32_SSCALED:
 391       return MESA_FORMAT_RGBA_INT32;
 392
 393    /* unsigned int formats */
 394    case PIPE_FORMAT_R8G8B8A8_USCALED:
 395       return MESA_FORMAT_RGBA_UINT8;
 396    case PIPE_FORMAT_R16G16B16A16_USCALED:
 397       return MESA_FORMAT_RGBA_UINT16;
 398    case PIPE_FORMAT_R32G32B32A32_USCALED:
 399       return MESA_FORMAT_RGBA_UINT32;
 400
 401    case PIPE_FORMAT_RGTC1_UNORM:
 402       return MESA_FORMAT_RED_RGTC1;
 403    case PIPE_FORMAT_RGTC1_SNORM:
 404       return MESA_FORMAT_SIGNED_RED_RGTC1;
 405    case PIPE_FORMAT_RGTC2_UNORM:
 406       return MESA_FORMAT_RG_RGTC2;
 407    case PIPE_FORMAT_RGTC2_SNORM:
 408       return MESA_FORMAT_SIGNED_RG_RGTC2;
 409
 410    case PIPE_FORMAT_LATC1_UNORM:
 411       return MESA_FORMAT_L_LATC1;
 412    case PIPE_FORMAT_LATC1_SNORM:
 413       return MESA_FORMAT_SIGNED_L_LATC1;
 414    case PIPE_FORMAT_LATC2_UNORM:
 415       return MESA_FORMAT_LA_LATC2;
 416    case PIPE_FORMAT_LATC2_SNORM:
 417       return MESA_FORMAT_SIGNED_LA_LATC2;
 418
 419    default:
 420       assert(0);
 421       return MESA_FORMAT_NONE;
 422    }
 423 }
 424
 425
 426 /**
 427  * Return first supported format from the given list.
 428  */
 429 static enum pipe_format
 430 find_supported_format(struct pipe_screen *screen,
 431                       const enum pipe_format formats[],
 432                       uint num_formats,
 433                       enum pipe_texture_target target,
 434                       unsigned sample_count,
 435                       unsigned tex_usage,
 436                       unsigned geom_flags)
 437 {
 438    uint i;
 439    for (i = 0; i < num_formats; i++) {
 440       if (screen->is_format_supported(screen, formats[i], target,
 441                                       sample_count, tex_usage, geom_flags)) {
 442          return formats[i];
 443       }
 444    }
 445    return PIPE_FORMAT_NONE;
 446 }
 447
 448
 449 /**
 450  * Find an RGBA format supported by the context/winsys.
 451  */
 452 static enum pipe_format
 453 default_rgba_format(struct pipe_screen *screen,
 454                     enum pipe_texture_target target,
 455                     unsigned sample_count,
 456                     unsigned tex_usage,
 457                     unsigned geom_flags)
 458 {
 459    static const enum pipe_format colorFormats[] = {
 460       PIPE_FORMAT_B8G8R8A8_UNORM,
 461       PIPE_FORMAT_A8R8G8B8_UNORM,
 462       PIPE_FORMAT_A8B8G8R8_UNORM,
 463       PIPE_FORMAT_B5G6R5_UNORM
 464    };
 465    return find_supported_format(screen, colorFormats, Elements(colorFormats),
 466                                 target, sample_count, tex_usage, geom_flags);
 467 }
 468
 469
 470 /**
 471  * Find an RGB format supported by the context/winsys.
 472  */
 473 static enum pipe_format
 474 default_rgb_format(struct pipe_screen *screen,
 475                    enum pipe_texture_target target,
 476                    unsigned sample_count,
 477                    unsigned tex_usage,
 478                    unsigned geom_flags)
 479 {
 480    static const enum pipe_format colorFormats[] = {
 481       PIPE_FORMAT_B8G8R8X8_UNORM,
 482       PIPE_FORMAT_X8R8G8B8_UNORM,
 483       PIPE_FORMAT_X8B8G8R8_UNORM,
 484       PIPE_FORMAT_B8G8R8A8_UNORM,
 485       PIPE_FORMAT_A8R8G8B8_UNORM,
 486       PIPE_FORMAT_A8B8G8R8_UNORM,
 487       PIPE_FORMAT_B5G6R5_UNORM
 488    };
 489    return find_supported_format(screen, colorFormats, Elements(colorFormats),
 490                                 target, sample_count, tex_usage, geom_flags);
 491 }
 492
 493 /**
 494  * Find an sRGBA format supported by the context/winsys.
 495  */
 496 static enum pipe_format
 497 default_srgba_format(struct pipe_screen *screen,
 498                     enum pipe_texture_target target,
 499                     unsigned sample_count,
 500                     unsigned tex_usage,
 501                     unsigned geom_flags)
 502 {
 503    static const enum pipe_format colorFormats[] = {
 504       PIPE_FORMAT_B8G8R8A8_SRGB,
 505       PIPE_FORMAT_A8R8G8B8_SRGB,
 506       PIPE_FORMAT_A8B8G8R8_SRGB,
 507    };
 508    return find_supported_format(screen, colorFormats, Elements(colorFormats),
 509                                 target, sample_count, tex_usage, geom_flags);
 510 }
 511
 512
 513 /**
 514  * Given an OpenGL internalFormat value for a texture or surface, return
 515  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
 516  * This is called during glTexImage2D, for example.
 517  *
 518  * The bindings parameter typically has PIPE_BIND_SAMPLER_VIEW set, plus
 519  * either PIPE_BINDING_RENDER_TARGET or PIPE_BINDING_DEPTH_STENCIL if
 520  * we want render-to-texture ability.
 521  *
 522  * \param internalFormat  the user value passed to glTexImage2D
 523  * \param target  one of PIPE_TEXTURE_x
 524  * \param bindings  bitmask of PIPE_BIND_x flags.
 525  */
 526 enum pipe_format
 527 st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
 528                  enum pipe_texture_target target, unsigned sample_count,
 529                  unsigned bindings)
 530 {
 531    unsigned geom_flags = 0; /* we don't care about POT vs. NPOT here, yet */
 532
 533    switch (internalFormat) {
 534    case GL_RGB10:
 535    case GL_RGB10_A2:
 536       if (screen->is_format_supported( screen, PIPE_FORMAT_B10G10R10A2_UNORM,
 537                                        target, sample_count, bindings,
 538                                        geom_flags ))
 539          return PIPE_FORMAT_B10G10R10A2_UNORM;
 540       /* Pass through. */
 541    case 4:
 542    case GL_RGBA:
 543    case GL_RGBA8:
 544       return default_rgba_format( screen, target, sample_count, bindings,
 545                                   geom_flags );
 546
 547    case GL_BGRA:
 548       if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM,
 549                                        target, sample_count, bindings,
 550                                        geom_flags ))
 551          return PIPE_FORMAT_B8G8R8A8_UNORM;
 552       return default_rgba_format( screen, target, sample_count, bindings,
 553                                   geom_flags );
 554
 555    case 3:
 556    case GL_RGB:
 557    case GL_RGB8:
 558       return default_rgb_format( screen, target, sample_count, bindings,
 559                                  geom_flags );
 560
 561    case GL_RGB12:
 562    case GL_RGB16:
 563    case GL_RGBA12:
 564    case GL_RGBA16:
 565       if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,
 566                                              target, sample_count, bindings,
 567                                              geom_flags ))
 568          return PIPE_FORMAT_R16G16B16A16_UNORM;
 569       return default_rgba_format( screen, target, sample_count, bindings,
 570                                   geom_flags );
 571
 572    case GL_RGBA4:
 573    case GL_RGBA2:
 574       if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,
 575                                        target, sample_count, bindings,
 576                                        geom_flags ))
 577          return PIPE_FORMAT_B4G4R4A4_UNORM;
 578       return default_rgba_format( screen, target, sample_count, bindings,
 579                                   geom_flags );
 580
 581    case GL_RGB5_A1:
 582       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
 583                                        target, sample_count, bindings,
 584                                        geom_flags ))
 585          return PIPE_FORMAT_B5G5R5A1_UNORM;
 586       return default_rgba_format( screen, target, sample_count, bindings,
 587                                   geom_flags );
 588
 589    case GL_R3_G3_B2:
 590       if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM,
 591                                        target, sample_count, bindings,
 592                                        geom_flags ))
 593          return PIPE_FORMAT_B2G3R3_UNORM;
 594       /* Pass through. */
 595    case GL_RGB5:
 596    case GL_RGB4:
 597       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,
 598                                        target, sample_count, bindings,
 599                                        geom_flags ))
 600          return PIPE_FORMAT_B5G6R5_UNORM;
 601       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
 602                                        target, sample_count, bindings,
 603                                        geom_flags ))
 604          return PIPE_FORMAT_B5G5R5A1_UNORM;
 605       return default_rgba_format( screen, target, sample_count, bindings,
 606                                   geom_flags );
 607
 608    case GL_ALPHA12:
 609    case GL_ALPHA16:
 610       if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target,
 611                                        sample_count, bindings, geom_flags ))
 612          return PIPE_FORMAT_A16_UNORM;
 613       /* Pass through. */
 614    case GL_ALPHA:
 615    case GL_ALPHA4:
 616    case GL_ALPHA8:
 617    case GL_COMPRESSED_ALPHA:
 618       if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,
 619                                        sample_count, bindings, geom_flags ))
 620          return PIPE_FORMAT_A8_UNORM;
 621       return default_rgba_format( screen, target, sample_count, bindings,
 622                                   geom_flags );
 623
 624    case GL_LUMINANCE12:
 625    case GL_LUMINANCE16:
 626       if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target,
 627                                        sample_count, bindings, geom_flags ))
 628          return PIPE_FORMAT_L16_UNORM;
 629       /* Pass through. */
 630    case 1:
 631    case GL_LUMINANCE:
 632    case GL_LUMINANCE4:
 633    case GL_LUMINANCE8:
 634       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,
 635                                        sample_count, bindings, geom_flags ))
 636          return PIPE_FORMAT_L8_UNORM;
 637       return default_rgba_format( screen, target, sample_count, bindings,
 638                                   geom_flags );
 639
 640    case GL_LUMINANCE12_ALPHA4:
 641    case GL_LUMINANCE12_ALPHA12:
 642    case GL_LUMINANCE16_ALPHA16:
 643       if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target,
 644                                        sample_count, bindings, geom_flags ))
 645          return PIPE_FORMAT_L16A16_UNORM;
 646       /* Pass through. */
 647    case 2:
 648    case GL_LUMINANCE_ALPHA:
 649    case GL_LUMINANCE6_ALPHA2:
 650    case GL_LUMINANCE8_ALPHA8:
 651       if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
 652                                        sample_count, bindings, geom_flags ))
 653          return PIPE_FORMAT_L8A8_UNORM;
 654       return default_rgba_format( screen, target, sample_count, bindings,
 655                                   geom_flags );
 656
 657    case GL_LUMINANCE4_ALPHA4:
 658       if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target,
 659                                        sample_count, bindings, geom_flags ))
 660          return PIPE_FORMAT_L4A4_UNORM;
 661       if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
 662                                        sample_count, bindings, geom_flags ))
 663          return PIPE_FORMAT_L8A8_UNORM;
 664       return default_rgba_format( screen, target, sample_count, bindings,
 665                                   geom_flags );
 666
 667    case GL_INTENSITY12:
 668    case GL_INTENSITY16:
 669       if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target,
 670                                        sample_count, bindings, geom_flags ))
 671          return PIPE_FORMAT_I16_UNORM;
 672       /* Pass through. */
 673    case GL_INTENSITY:
 674    case GL_INTENSITY4:
 675    case GL_INTENSITY8:
 676    case GL_COMPRESSED_INTENSITY:
 677       if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,
 678                                        sample_count, bindings, geom_flags ))
 679          return PIPE_FORMAT_I8_UNORM;
 680       return default_rgba_format( screen, target, sample_count, bindings,
 681                                   geom_flags );
 682
 683    case GL_YCBCR_MESA:
 684       if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,
 685                                       sample_count, bindings, geom_flags)) {
 686          return PIPE_FORMAT_UYVY;
 687       }
 688       if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,
 689                                       sample_count, bindings, geom_flags)) {
 690          return PIPE_FORMAT_YUYV;
 691       }
 692       return PIPE_FORMAT_NONE;
 693
 694    case GL_COMPRESSED_RGB:
 695       /* can only sample from compressed formats */
 696       if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
 697          return PIPE_FORMAT_NONE;
 698       else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
 699                                            target, sample_count, bindings,
 700                                            geom_flags))
 701          return PIPE_FORMAT_DXT1_RGB;
 702       else
 703          return default_rgb_format(screen, target, sample_count, bindings,
 704                                    geom_flags);
 705
 706    case GL_COMPRESSED_RGBA:
 707       /* can only sample from compressed formats */
 708       if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
 709          return PIPE_FORMAT_NONE;
 710       else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
 711                                            target, sample_count, bindings,
 712                                            geom_flags))
 713          return PIPE_FORMAT_DXT3_RGBA;
 714       else
 715          return default_rgba_format(screen, target, sample_count, bindings,
 716                                     geom_flags);
 717
 718    case GL_RGB_S3TC:
 719    case GL_RGB4_S3TC:
 720    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 721       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
 722                                       target, sample_count, bindings,
 723                                       geom_flags))
 724          return PIPE_FORMAT_DXT1_RGB;
 725       else
 726          return PIPE_FORMAT_NONE;
 727
 728    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 729       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,
 730                                       target, sample_count, bindings,
 731                                       geom_flags))
 732          return PIPE_FORMAT_DXT1_RGBA;
 733       else
 734          return PIPE_FORMAT_NONE;
 735
 736    case GL_RGBA_S3TC:
 737    case GL_RGBA4_S3TC:
 738    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 739       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
 740                                       target, sample_count, bindings,
 741                                       geom_flags))
 742          return PIPE_FORMAT_DXT3_RGBA;
 743       else
 744          return PIPE_FORMAT_NONE;
 745
 746    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 747       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
 748                                       target, sample_count, bindings,
 749                                       geom_flags))
 750          return PIPE_FORMAT_DXT5_RGBA;
 751       else
 752          return PIPE_FORMAT_NONE;
 753
 754 #if 0
 755    case GL_COMPRESSED_RGB_FXT1_3DFX:
 756       return PIPE_FORMAT_RGB_FXT1;
 757    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 758       return PIPE_FORMAT_RGB_FXT1;
 759 #endif
 760
 761    case GL_DEPTH_COMPONENT16:
 762       if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,
 763                                       sample_count, bindings, geom_flags))
 764          return PIPE_FORMAT_Z16_UNORM;
 765       /* fall-through */
 766    case GL_DEPTH_COMPONENT24:
 767       if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 768                                       target, sample_count, bindings, geom_flags))
 769          return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
 770       if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
 771                                       target, sample_count, bindings, geom_flags))
 772          return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
 773       /* fall-through */
 774    case GL_DEPTH_COMPONENT32:
 775       if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,
 776                                       sample_count, bindings, geom_flags))
 777          return PIPE_FORMAT_Z32_UNORM;
 778       /* fall-through */
 779    case GL_DEPTH_COMPONENT:
 780       {
 781          static const enum pipe_format formats[] = {
 782             PIPE_FORMAT_Z32_UNORM,
 783             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 784             PIPE_FORMAT_S8_USCALED_Z24_UNORM,
 785             PIPE_FORMAT_Z16_UNORM
 786          };
 787          return find_supported_format(screen, formats, Elements(formats),
 788                                       target, sample_count, bindings, geom_flags);
 789       }
 790
 791    case GL_STENCIL_INDEX:
 792    case GL_STENCIL_INDEX1_EXT:
 793    case GL_STENCIL_INDEX4_EXT:
 794    case GL_STENCIL_INDEX8_EXT:
 795    case GL_STENCIL_INDEX16_EXT:
 796       {
 797          static const enum pipe_format formats[] = {
 798             PIPE_FORMAT_S8_USCALED,
 799             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 800             PIPE_FORMAT_S8_USCALED_Z24_UNORM
 801          };
 802          return find_supported_format(screen, formats, Elements(formats),
 803                                       target, sample_count, bindings, geom_flags);
 804       }
 805
 806    case GL_DEPTH_STENCIL_EXT:
 807    case GL_DEPTH24_STENCIL8_EXT:
 808       {
 809          static const enum pipe_format formats[] = {
 810             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 811             PIPE_FORMAT_S8_USCALED_Z24_UNORM
 812          };
 813          return find_supported_format(screen, formats, Elements(formats),
 814                                       target, sample_count, bindings, geom_flags);
 815       }
 816
 817    case GL_SRGB_EXT:
 818    case GL_SRGB8_EXT:
 819    case GL_SRGB_ALPHA_EXT:
 820    case GL_SRGB8_ALPHA8_EXT:
 821       return default_srgba_format( screen, target, sample_count, bindings,
 822                                    geom_flags );
 823
 824    case GL_COMPRESSED_SRGB_EXT:
 825    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 826       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target,
 827                                       sample_count, bindings, geom_flags))
 828          return PIPE_FORMAT_DXT1_SRGB;
 829       return default_srgba_format( screen, target, sample_count, bindings,
 830                                    geom_flags );
 831
 832    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 833       return PIPE_FORMAT_DXT1_SRGBA;
 834
 835    case GL_COMPRESSED_SRGB_ALPHA_EXT:
 836    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 837       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target,
 838                                       sample_count, bindings, geom_flags))
 839          return PIPE_FORMAT_DXT3_SRGBA;
 840       return default_srgba_format( screen, target, sample_count, bindings,
 841                                    geom_flags );
 842
 843    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 844       return PIPE_FORMAT_DXT5_SRGBA;
 845
 846    case GL_SLUMINANCE_ALPHA_EXT:
 847    case GL_SLUMINANCE8_ALPHA8_EXT:
 848    case GL_COMPRESSED_SLUMINANCE_EXT:
 849    case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 850       if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,
 851                                       sample_count, bindings, geom_flags))
 852          return PIPE_FORMAT_L8A8_SRGB;
 853       return default_srgba_format( screen, target, sample_count, bindings,
 854                                    geom_flags );
 855
 856    case GL_SLUMINANCE_EXT:
 857    case GL_SLUMINANCE8_EXT:
 858       if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,
 859                                       sample_count, bindings, geom_flags))
 860          return PIPE_FORMAT_L8_SRGB;
 861       return default_srgba_format( screen, target, sample_count, bindings,
 862                                    geom_flags );
 863
 864    case GL_RED:
 865    case GL_R8:
 866       if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
 867                                       sample_count, bindings, geom_flags))
 868               return PIPE_FORMAT_R8_UNORM;
 869       return PIPE_FORMAT_NONE;
 870    case GL_RG:
 871    case GL_RG8:
 872       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
 873                                       sample_count, bindings, geom_flags))
 874               return PIPE_FORMAT_R8G8_UNORM;
 875       return PIPE_FORMAT_NONE;
 876
 877    case GL_R16:
 878       if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,
 879                                       sample_count, bindings, geom_flags))
 880               return PIPE_FORMAT_R16_UNORM;
 881       return PIPE_FORMAT_NONE;
 882
 883    case GL_RG16:
 884       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,
 885                                       sample_count, bindings, geom_flags))
 886               return PIPE_FORMAT_R16G16_UNORM;
 887       return PIPE_FORMAT_NONE;
 888
 889    case GL_COMPRESSED_RED:
 890    case GL_COMPRESSED_RED_RGTC1:
 891       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,
 892                                       sample_count, bindings, geom_flags))
 893               return PIPE_FORMAT_RGTC1_UNORM;
 894       if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
 895                                       sample_count, bindings, geom_flags))
 896               return PIPE_FORMAT_R8_UNORM;
 897       return PIPE_FORMAT_NONE;
 898
 899    case GL_COMPRESSED_SIGNED_RED_RGTC1:
 900       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,
 901                                       sample_count, bindings, geom_flags))
 902               return PIPE_FORMAT_RGTC1_SNORM;
 903       return PIPE_FORMAT_NONE;
 904
 905    case GL_COMPRESSED_RG:
 906    case GL_COMPRESSED_RG_RGTC2:
 907       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,
 908                                       sample_count, bindings, geom_flags))
 909               return PIPE_FORMAT_RGTC2_UNORM;
 910       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
 911                                       sample_count, bindings, geom_flags))
 912               return PIPE_FORMAT_R8G8_UNORM;
 913       return PIPE_FORMAT_NONE;
 914
 915    case GL_COMPRESSED_SIGNED_RG_RGTC2:
 916       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,
 917                                       sample_count, bindings, geom_flags))
 918               return PIPE_FORMAT_RGTC2_SNORM;
 919       return PIPE_FORMAT_NONE;
 920
 921    case GL_COMPRESSED_LUMINANCE:
 922    case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
 923       if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM, target,
 924                                       sample_count, bindings, geom_flags))
 925               return PIPE_FORMAT_LATC1_UNORM;
 926       if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM, target,
 927                                       sample_count, bindings, geom_flags))
 928               return PIPE_FORMAT_L8_UNORM;
 929       return PIPE_FORMAT_NONE;
 930
 931    case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
 932       if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM, target,
 933                                       sample_count, bindings, geom_flags))
 934               return PIPE_FORMAT_LATC1_SNORM;
 935       return PIPE_FORMAT_NONE;
 936
 937    case GL_COMPRESSED_LUMINANCE_ALPHA:
 938    case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
 939    case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
 940       if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM, target,
 941                                       sample_count, bindings, geom_flags))
 942               return PIPE_FORMAT_LATC2_UNORM;
 943       if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_UNORM, target,
 944                                       sample_count, bindings, geom_flags))
 945               return PIPE_FORMAT_L8A8_UNORM;
 946       return PIPE_FORMAT_NONE;
 947
 948    case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
 949       if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM, target,
 950                                       sample_count, bindings, geom_flags))
 951               return PIPE_FORMAT_LATC2_SNORM;
 952       return PIPE_FORMAT_NONE;
 953
 954    /* signed/unsigned integer formats.
 955     * XXX Mesa only has formats for RGBA signed/unsigned integer formats.
 956     * If/when new formats are added this code should be updated.
 957     */
 958    case GL_RED_INTEGER_EXT:
 959    case GL_GREEN_INTEGER_EXT:
 960    case GL_BLUE_INTEGER_EXT:
 961    case GL_ALPHA_INTEGER_EXT:
 962    case GL_RGB_INTEGER_EXT:
 963    case GL_RGBA_INTEGER_EXT:
 964    case GL_BGR_INTEGER_EXT:
 965    case GL_BGRA_INTEGER_EXT:
 966    case GL_LUMINANCE_INTEGER_EXT:
 967    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 968       /* fall-through */
 969    case GL_RGBA8I_EXT:
 970    case GL_RGB8I_EXT:
 971    case GL_ALPHA8I_EXT:
 972    case GL_INTENSITY8I_EXT:
 973    case GL_LUMINANCE8I_EXT:
 974    case GL_LUMINANCE_ALPHA8I_EXT:
 975       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,
 976                                       target,
 977                                       sample_count, bindings, geom_flags))
 978          return PIPE_FORMAT_R8G8B8A8_SSCALED;
 979       return PIPE_FORMAT_NONE;
 980    case GL_RGBA16I_EXT:
 981    case GL_RGB16I_EXT:
 982    case GL_ALPHA16I_EXT:
 983    case GL_INTENSITY16I_EXT:
 984    case GL_LUMINANCE16I_EXT:
 985    case GL_LUMINANCE_ALPHA16I_EXT:
 986       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,
 987                                       target,
 988                                       sample_count, bindings, geom_flags))
 989          return PIPE_FORMAT_R16G16B16A16_SSCALED;
 990       return PIPE_FORMAT_NONE;
 991    case GL_RGBA32I_EXT:
 992    case GL_RGB32I_EXT:
 993    case GL_ALPHA32I_EXT:
 994    case GL_INTENSITY32I_EXT:
 995    case GL_LUMINANCE32I_EXT:
 996    case GL_LUMINANCE_ALPHA32I_EXT:
 997       /* xxx */
 998       if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,
 999                                       target,
1000                                       sample_count, bindings, geom_flags))
1001          return PIPE_FORMAT_R32G32B32A32_SSCALED;
1002       return PIPE_FORMAT_NONE;
1003
1004    case GL_RGBA8UI_EXT:
1005    case GL_RGB8UI_EXT:
1006    case GL_ALPHA8UI_EXT:
1007    case GL_INTENSITY8UI_EXT:
1008    case GL_LUMINANCE8UI_EXT:
1009    case GL_LUMINANCE_ALPHA8UI_EXT:
1010       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,
1011                                       target,
1012                                       sample_count, bindings, geom_flags))
1013          return PIPE_FORMAT_R8G8B8A8_USCALED;
1014       return PIPE_FORMAT_NONE;
1015
1016    case GL_RGBA16UI_EXT:
1017    case GL_RGB16UI_EXT:
1018    case GL_ALPHA16UI_EXT:
1019    case GL_INTENSITY16UI_EXT:
1020    case GL_LUMINANCE16UI_EXT:
1021    case GL_LUMINANCE_ALPHA16UI_EXT:
1022       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,
1023                                       target,
1024                                       sample_count, bindings, geom_flags))
1025          return PIPE_FORMAT_R16G16B16A16_USCALED;
1026       return PIPE_FORMAT_NONE;
1027
1028    case GL_RGBA32UI_EXT:
1029    case GL_RGB32UI_EXT:
1030    case GL_ALPHA32UI_EXT:
1031    case GL_INTENSITY32UI_EXT:
1032    case GL_LUMINANCE32UI_EXT:
1033    case GL_LUMINANCE_ALPHA32UI_EXT:
1034       if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,
1035                                       target,
1036                                       sample_count, bindings, geom_flags))
1037          return PIPE_FORMAT_R32G32B32A32_USCALED;
1038       return PIPE_FORMAT_NONE;
1039
1040    default:
1041       return PIPE_FORMAT_NONE;
1042    }
1043 }
1044
1045
1046 /**
1047  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
1048  */
1049 enum pipe_format
1050 st_choose_renderbuffer_format(struct pipe_screen *screen,
1051                               GLenum internalFormat, unsigned sample_count)
1052 {
1053    uint usage;
1054    if (_mesa_is_depth_or_stencil_format(internalFormat))
1055       usage = PIPE_BIND_DEPTH_STENCIL;
1056    else
1057       usage = PIPE_BIND_RENDER_TARGET;
1058    return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D,
1059                            sample_count, usage);
1060 }
1061
1062
1063 /**
1064  * Called via ctx->Driver.chooseTextureFormat().
1065  */
1066 gl_format
1067 st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,
1068                                   GLenum format, GLenum type, GLboolean renderable)
1069 {
1070    struct pipe_screen *screen = st_context(ctx)->pipe->screen;
1071    enum pipe_format pFormat;
1072    uint bindings;
1073
1074    (void) format;
1075    (void) type;
1076
1077    /* GL textures may wind up being render targets, but we don't know
1078     * that in advance.  Specify potential render target flags now.
1079     */
1080    bindings = PIPE_BIND_SAMPLER_VIEW;
1081    if (renderable == GL_TRUE) {
1082       if (_mesa_is_depth_format(internalFormat) ||
1083           _mesa_is_depth_or_stencil_format(internalFormat))
1084          bindings |= PIPE_BIND_DEPTH_STENCIL;
1085       else
1086          bindings |= PIPE_BIND_RENDER_TARGET;
1087    }
1088
1089    pFormat = st_choose_format(screen, internalFormat,
1090                               PIPE_TEXTURE_2D, 0, bindings);
1091
1092    if (pFormat == PIPE_FORMAT_NONE) {
1093       /* try choosing format again, this time without render target bindings */
1094       pFormat = st_choose_format(screen, internalFormat,
1095                                  PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);
1096    }
1097
1098    if (pFormat == PIPE_FORMAT_NONE) {
1099       /* no luck at all */
1100       return MESA_FORMAT_NONE;
1101    }
1102
1103    return st_pipe_format_to_mesa_format(pFormat);
1104 }
1105
1106 gl_format
1107 st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat,
1108                        GLenum format, GLenum type)
1109 {
1110    boolean want_renderable =
1111       internalFormat == 3 || internalFormat == 4 ||
1112       internalFormat == GL_RGB || internalFormat == GL_RGBA ||
1113       internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
1114       internalFormat == GL_BGRA;
1115
1116    return st_ChooseTextureFormat_renderable(ctx, internalFormat,
1117                                             format, type, want_renderable);
1118 }
1119
1120 /**
1121  * Test if a gallium format is equivalent to a GL format/type.
1122  */
1123 GLboolean
1124 st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)
1125 {
1126    switch (pFormat) {
1127    case PIPE_FORMAT_A8B8G8R8_UNORM:
1128       return format == GL_RGBA && type == GL_UNSIGNED_BYTE;
1129    case PIPE_FORMAT_A8R8G8B8_UNORM:
1130       return format == GL_BGRA && type == GL_UNSIGNED_BYTE;
1131    case PIPE_FORMAT_B5G6R5_UNORM:
1132       return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;
1133    /* XXX more combos... */
1134    default:
1135       return GL_FALSE;
1136    }
1137 }
1138
1139 GLboolean
1140 st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2)
1141 {
1142    if (format1 == format2)
1143       return GL_TRUE;
1144
1145    if (format1 == PIPE_FORMAT_B8G8R8A8_UNORM &&
1146        format2 == PIPE_FORMAT_B8G8R8X8_UNORM)
1147       return GL_TRUE;
1148
1149    if (format1 == PIPE_FORMAT_B8G8R8X8_UNORM &&
1150        format2 == PIPE_FORMAT_B8G8R8A8_UNORM)
1151       return GL_TRUE;
1152
1153    if (format1 == PIPE_FORMAT_A8B8G8R8_UNORM &&
1154        format2 == PIPE_FORMAT_X8B8G8R8_UNORM)
1155       return GL_TRUE;
1156
1157    if (format1 == PIPE_FORMAT_X8B8G8R8_UNORM &&
1158        format2 == PIPE_FORMAT_A8B8G8R8_UNORM)
1159       return GL_TRUE;
1160
1161    if (format1 == PIPE_FORMAT_A8R8G8B8_UNORM &&
1162        format2 == PIPE_FORMAT_X8R8G8B8_UNORM)
1163       return GL_TRUE;
1164
1165    if (format1 == PIPE_FORMAT_X8R8G8B8_UNORM &&
1166        format2 == PIPE_FORMAT_A8R8G8B8_UNORM)
1167       return GL_TRUE;
1168
1169    return GL_FALSE;
1170 }
1171
1172
1173
1174 /**
1175  * This is used for translating texture border color and the clear
1176  * color.  For example, the clear color is interpreted according to
1177  * the renderbuffer's base format.  For example, if clearing a
1178  * GL_LUMINANCE buffer, ClearColor[0] = luminance and ClearColor[1] =
1179  * alpha.  Similarly for texture border colors.
1180  */
1181 void
1182 st_translate_color(const GLfloat colorIn[4], GLenum baseFormat,
1183                    GLfloat colorOut[4])
1184 {
1185    switch (baseFormat) {
1186    case GL_RED:
1187       colorOut[0] = colorIn[0];
1188       colorOut[1] = 0.0F;
1189       colorOut[2] = 0.0F;
1190       colorOut[3] = 1.0F;
1191       break;
1192    case GL_RG:
1193       colorOut[0] = colorIn[0];
1194       colorOut[1] = colorIn[1];
1195       colorOut[2] = 0.0F;
1196       colorOut[3] = 1.0F;
1197       break;
1198    case GL_RGB:
1199       colorOut[0] = colorIn[0];
1200       colorOut[1] = colorIn[1];
1201       colorOut[2] = colorIn[2];
1202       colorOut[3] = 1.0F;
1203       break;
1204    case GL_ALPHA:
1205       colorOut[0] = colorOut[1] = colorOut[2] = 0.0;
1206       colorOut[3] = colorIn[3];
1207       break;
1208    case GL_LUMINANCE:
1209       colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
1210       colorOut[3] = 1.0;
1211       break;
1212    case GL_LUMINANCE_ALPHA:
1213       colorOut[0] = colorOut[1] = colorOut[2] = colorIn[0];
1214       colorOut[3] = colorIn[3];
1215       break;
1216    case GL_INTENSITY:
1217       colorOut[0] = colorOut[1] = colorOut[2] = colorOut[3] = colorIn[0];
1218       break;
1219    default:
1220       COPY_4V(colorOut, colorIn);
1221    }
1222 }