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