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 GL_BGRA:
 515       if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM,
 516                                        target, sample_count, bindings,
 517                                        geom_flags ))
 518          return PIPE_FORMAT_B8G8R8A8_UNORM;
 519       return default_rgba_format( screen, target, sample_count, bindings,
 520                                   geom_flags );
 521
 522    case 3:
 523    case GL_RGB:
 524    case GL_RGB8:
 525       return default_rgb_format( screen, target, sample_count, bindings,
 526                                  geom_flags );
 527
 528    case GL_RGB12:
 529    case GL_RGB16:
 530    case GL_RGBA12:
 531    case GL_RGBA16:
 532       if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,
 533                                              target, sample_count, bindings,
 534                                              geom_flags ))
 535          return PIPE_FORMAT_R16G16B16A16_UNORM;
 536       return default_rgba_format( screen, target, sample_count, bindings,
 537                                   geom_flags );
 538
 539    case GL_RGBA4:
 540    case GL_RGBA2:
 541       if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,
 542                                        target, sample_count, bindings,
 543                                        geom_flags ))
 544          return PIPE_FORMAT_B4G4R4A4_UNORM;
 545       return default_rgba_format( screen, target, sample_count, bindings,
 546                                   geom_flags );
 547
 548    case GL_RGB5_A1:
 549       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
 550                                        target, sample_count, bindings,
 551                                        geom_flags ))
 552          return PIPE_FORMAT_B5G5R5A1_UNORM;
 553       return default_rgba_format( screen, target, sample_count, bindings,
 554                                   geom_flags );
 555
 556    case GL_R3_G3_B2:
 557       if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM,
 558                                        target, sample_count, bindings,
 559                                        geom_flags ))
 560          return PIPE_FORMAT_B2G3R3_UNORM;
 561       /* Pass through. */
 562    case GL_RGB5:
 563    case GL_RGB4:
 564       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,
 565                                        target, sample_count, bindings,
 566                                        geom_flags ))
 567          return PIPE_FORMAT_B5G6R5_UNORM;
 568       if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
 569                                        target, sample_count, bindings,
 570                                        geom_flags ))
 571          return PIPE_FORMAT_B5G5R5A1_UNORM;
 572       return default_rgba_format( screen, target, sample_count, bindings,
 573                                   geom_flags );
 574
 575    case GL_ALPHA12:
 576    case GL_ALPHA16:
 577       if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target,
 578                                        sample_count, bindings, geom_flags ))
 579          return PIPE_FORMAT_A16_UNORM;
 580       /* Pass through. */
 581    case GL_ALPHA:
 582    case GL_ALPHA4:
 583    case GL_ALPHA8:
 584    case GL_COMPRESSED_ALPHA:
 585       if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,
 586                                        sample_count, bindings, geom_flags ))
 587          return PIPE_FORMAT_A8_UNORM;
 588       return default_rgba_format( screen, target, sample_count, bindings,
 589                                   geom_flags );
 590
 591    case GL_LUMINANCE12:
 592    case GL_LUMINANCE16:
 593       if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target,
 594                                        sample_count, bindings, geom_flags ))
 595          return PIPE_FORMAT_L16_UNORM;
 596       /* Pass through. */
 597    case 1:
 598    case GL_LUMINANCE:
 599    case GL_LUMINANCE4:
 600    case GL_LUMINANCE8:
 601    case GL_COMPRESSED_LUMINANCE:
 602       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,
 603                                        sample_count, bindings, geom_flags ))
 604          return PIPE_FORMAT_L8_UNORM;
 605       return default_rgba_format( screen, target, sample_count, bindings,
 606                                   geom_flags );
 607
 608    case GL_LUMINANCE12_ALPHA4:
 609    case GL_LUMINANCE12_ALPHA12:
 610    case GL_LUMINANCE16_ALPHA16:
 611       if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target,
 612                                        sample_count, bindings, geom_flags ))
 613          return PIPE_FORMAT_L16A16_UNORM;
 614       /* Pass through. */
 615    case 2:
 616    case GL_LUMINANCE_ALPHA:
 617    case GL_LUMINANCE6_ALPHA2:
 618    case GL_LUMINANCE8_ALPHA8:
 619    case GL_COMPRESSED_LUMINANCE_ALPHA:
 620       if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
 621                                        sample_count, bindings, geom_flags ))
 622          return PIPE_FORMAT_L8A8_UNORM;
 623       return default_rgba_format( screen, target, sample_count, bindings,
 624                                   geom_flags );
 625
 626    case GL_LUMINANCE4_ALPHA4:
 627       if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target,
 628                                        sample_count, bindings, geom_flags ))
 629          return PIPE_FORMAT_L4A4_UNORM;
 630       if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
 631                                        sample_count, bindings, geom_flags ))
 632          return PIPE_FORMAT_L8A8_UNORM;
 633       return default_rgba_format( screen, target, sample_count, bindings,
 634                                   geom_flags );
 635
 636    case GL_INTENSITY12:
 637    case GL_INTENSITY16:
 638       if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target,
 639                                        sample_count, bindings, geom_flags ))
 640          return PIPE_FORMAT_I16_UNORM;
 641       /* Pass through. */
 642    case GL_INTENSITY:
 643    case GL_INTENSITY4:
 644    case GL_INTENSITY8:
 645    case GL_COMPRESSED_INTENSITY:
 646       if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,
 647                                        sample_count, bindings, geom_flags ))
 648          return PIPE_FORMAT_I8_UNORM;
 649       return default_rgba_format( screen, target, sample_count, bindings,
 650                                   geom_flags );
 651
 652    case GL_YCBCR_MESA:
 653       if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,
 654                                       sample_count, bindings, geom_flags)) {
 655          return PIPE_FORMAT_UYVY;
 656       }
 657       if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,
 658                                       sample_count, bindings, geom_flags)) {
 659          return PIPE_FORMAT_YUYV;
 660       }
 661       return PIPE_FORMAT_NONE;
 662
 663    case GL_COMPRESSED_RED:
 664    case GL_COMPRESSED_RG:
 665    case GL_COMPRESSED_RGB:
 666       /* can only sample from compressed formats */
 667       if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
 668          return PIPE_FORMAT_NONE;
 669       else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
 670                                            target, sample_count, bindings,
 671                                            geom_flags))
 672          return PIPE_FORMAT_DXT1_RGB;
 673       else
 674          return default_rgb_format(screen, target, sample_count, bindings,
 675                                    geom_flags);
 676
 677    case GL_COMPRESSED_RGBA:
 678       /* can only sample from compressed formats */
 679       if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
 680          return PIPE_FORMAT_NONE;
 681       else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
 682                                            target, sample_count, bindings,
 683                                            geom_flags))
 684          return PIPE_FORMAT_DXT3_RGBA;
 685       else
 686          return default_rgba_format(screen, target, sample_count, bindings,
 687                                     geom_flags);
 688
 689    case GL_RGB_S3TC:
 690    case GL_RGB4_S3TC:
 691    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 692       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
 693                                       target, sample_count, bindings,
 694                                       geom_flags))
 695          return PIPE_FORMAT_DXT1_RGB;
 696       else
 697          return PIPE_FORMAT_NONE;
 698
 699    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 700       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,
 701                                       target, sample_count, bindings,
 702                                       geom_flags))
 703          return PIPE_FORMAT_DXT1_RGBA;
 704       else
 705          return PIPE_FORMAT_NONE;
 706
 707    case GL_RGBA_S3TC:
 708    case GL_RGBA4_S3TC:
 709    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 710       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 PIPE_FORMAT_NONE;
 716
 717    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 718       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
 719                                       target, sample_count, bindings,
 720                                       geom_flags))
 721          return PIPE_FORMAT_DXT5_RGBA;
 722       else
 723          return PIPE_FORMAT_NONE;
 724
 725 #if 0
 726    case GL_COMPRESSED_RGB_FXT1_3DFX:
 727       return PIPE_FORMAT_RGB_FXT1;
 728    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 729       return PIPE_FORMAT_RGB_FXT1;
 730 #endif
 731
 732    case GL_DEPTH_COMPONENT16:
 733       if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,
 734                                       sample_count, bindings, geom_flags))
 735          return PIPE_FORMAT_Z16_UNORM;
 736       /* fall-through */
 737    case GL_DEPTH_COMPONENT24:
 738       if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 739                                       target, sample_count, bindings, geom_flags))
 740          return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
 741       if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
 742                                       target, sample_count, bindings, geom_flags))
 743          return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
 744       /* fall-through */
 745    case GL_DEPTH_COMPONENT32:
 746       if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,
 747                                       sample_count, bindings, geom_flags))
 748          return PIPE_FORMAT_Z32_UNORM;
 749       /* fall-through */
 750    case GL_DEPTH_COMPONENT:
 751       {
 752          static const enum pipe_format formats[] = {
 753             PIPE_FORMAT_Z32_UNORM,
 754             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 755             PIPE_FORMAT_S8_USCALED_Z24_UNORM,
 756             PIPE_FORMAT_Z16_UNORM
 757          };
 758          return find_supported_format(screen, formats, Elements(formats),
 759                                       target, sample_count, bindings, geom_flags);
 760       }
 761
 762    case GL_STENCIL_INDEX:
 763    case GL_STENCIL_INDEX1_EXT:
 764    case GL_STENCIL_INDEX4_EXT:
 765    case GL_STENCIL_INDEX8_EXT:
 766    case GL_STENCIL_INDEX16_EXT:
 767       {
 768          static const enum pipe_format formats[] = {
 769             PIPE_FORMAT_S8_USCALED,
 770             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 771             PIPE_FORMAT_S8_USCALED_Z24_UNORM
 772          };
 773          return find_supported_format(screen, formats, Elements(formats),
 774                                       target, sample_count, bindings, geom_flags);
 775       }
 776
 777    case GL_DEPTH_STENCIL_EXT:
 778    case GL_DEPTH24_STENCIL8_EXT:
 779       {
 780          static const enum pipe_format formats[] = {
 781             PIPE_FORMAT_Z24_UNORM_S8_USCALED,
 782             PIPE_FORMAT_S8_USCALED_Z24_UNORM
 783          };
 784          return find_supported_format(screen, formats, Elements(formats),
 785                                       target, sample_count, bindings, geom_flags);
 786       }
 787
 788    case GL_SRGB_EXT:
 789    case GL_SRGB8_EXT:
 790    case GL_SRGB_ALPHA_EXT:
 791    case GL_SRGB8_ALPHA8_EXT:
 792       return default_srgba_format( screen, target, sample_count, bindings,
 793                                    geom_flags );
 794
 795    case GL_COMPRESSED_SRGB_EXT:
 796    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 797       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target,
 798                                       sample_count, bindings, geom_flags))
 799          return PIPE_FORMAT_DXT1_SRGB;
 800       return default_srgba_format( screen, target, sample_count, bindings,
 801                                    geom_flags );
 802
 803    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 804       return PIPE_FORMAT_DXT1_SRGBA;
 805
 806    case GL_COMPRESSED_SRGB_ALPHA_EXT:
 807    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 808       if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target,
 809                                       sample_count, bindings, geom_flags))
 810          return PIPE_FORMAT_DXT3_SRGBA;
 811       return default_srgba_format( screen, target, sample_count, bindings,
 812                                    geom_flags );
 813
 814    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 815       return PIPE_FORMAT_DXT5_SRGBA;
 816
 817    case GL_SLUMINANCE_ALPHA_EXT:
 818    case GL_SLUMINANCE8_ALPHA8_EXT:
 819    case GL_COMPRESSED_SLUMINANCE_EXT:
 820    case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 821       if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,
 822                                       sample_count, bindings, geom_flags))
 823          return PIPE_FORMAT_L8A8_SRGB;
 824       return default_srgba_format( screen, target, sample_count, bindings,
 825                                    geom_flags );
 826
 827    case GL_SLUMINANCE_EXT:
 828    case GL_SLUMINANCE8_EXT:
 829       if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,
 830                                       sample_count, bindings, geom_flags))
 831          return PIPE_FORMAT_L8_SRGB;
 832       return default_srgba_format( screen, target, sample_count, bindings,
 833                                    geom_flags );
 834
 835    case GL_RED:
 836    case GL_R8:
 837       if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
 838                                       sample_count, bindings, geom_flags))
 839               return PIPE_FORMAT_R8_UNORM;
 840       return PIPE_FORMAT_NONE;
 841    case GL_RG:
 842    case GL_RG8:
 843       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
 844                                       sample_count, bindings, geom_flags))
 845               return PIPE_FORMAT_R8G8_UNORM;
 846       return PIPE_FORMAT_NONE;
 847
 848    case GL_R16:
 849       if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,
 850                                       sample_count, bindings, geom_flags))
 851               return PIPE_FORMAT_R16_UNORM;
 852       return PIPE_FORMAT_NONE;
 853
 854    case GL_RG16:
 855       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,
 856                                       sample_count, bindings, geom_flags))
 857               return PIPE_FORMAT_R16G16_UNORM;
 858       return PIPE_FORMAT_NONE;
 859
 860    case GL_COMPRESSED_RED_RGTC1:
 861       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,
 862                                       sample_count, bindings, geom_flags))
 863               return PIPE_FORMAT_RGTC1_UNORM;
 864       return PIPE_FORMAT_NONE;
 865
 866    case GL_COMPRESSED_SIGNED_RED_RGTC1:
 867       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,
 868                                       sample_count, bindings, geom_flags))
 869               return PIPE_FORMAT_RGTC1_SNORM;
 870       return PIPE_FORMAT_NONE;
 871
 872    case GL_COMPRESSED_RG_RGTC2:
 873       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,
 874                                       sample_count, bindings, geom_flags))
 875               return PIPE_FORMAT_RGTC2_UNORM;
 876       return PIPE_FORMAT_NONE;
 877
 878    case GL_COMPRESSED_SIGNED_RG_RGTC2:
 879       if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,
 880                                       sample_count, bindings, geom_flags))
 881               return PIPE_FORMAT_RGTC2_SNORM;
 882       return PIPE_FORMAT_NONE;
 883
 884    /* signed/unsigned integer formats.
 885     * XXX Mesa only has formats for RGBA signed/unsigned integer formats.
 886     * If/when new formats are added this code should be updated.
 887     */
 888    case GL_RED_INTEGER_EXT:
 889    case GL_GREEN_INTEGER_EXT:
 890    case GL_BLUE_INTEGER_EXT:
 891    case GL_ALPHA_INTEGER_EXT:
 892    case GL_RGB_INTEGER_EXT:
 893    case GL_RGBA_INTEGER_EXT:
 894    case GL_BGR_INTEGER_EXT:
 895    case GL_BGRA_INTEGER_EXT:
 896    case GL_LUMINANCE_INTEGER_EXT:
 897    case GL_LUMINANCE_ALPHA_INTEGER_EXT:
 898       /* fall-through */
 899    case GL_RGBA8I_EXT:
 900    case GL_RGB8I_EXT:
 901    case GL_ALPHA8I_EXT:
 902    case GL_INTENSITY8I_EXT:
 903    case GL_LUMINANCE8I_EXT:
 904    case GL_LUMINANCE_ALPHA8I_EXT:
 905       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,
 906                                       target,
 907                                       sample_count, bindings, geom_flags))
 908          return PIPE_FORMAT_R8G8B8A8_SSCALED;
 909       return PIPE_FORMAT_NONE;
 910    case GL_RGBA16I_EXT:
 911    case GL_RGB16I_EXT:
 912    case GL_ALPHA16I_EXT:
 913    case GL_INTENSITY16I_EXT:
 914    case GL_LUMINANCE16I_EXT:
 915    case GL_LUMINANCE_ALPHA16I_EXT:
 916       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,
 917                                       target,
 918                                       sample_count, bindings, geom_flags))
 919          return PIPE_FORMAT_R16G16B16A16_SSCALED;
 920       return PIPE_FORMAT_NONE;
 921    case GL_RGBA32I_EXT:
 922    case GL_RGB32I_EXT:
 923    case GL_ALPHA32I_EXT:
 924    case GL_INTENSITY32I_EXT:
 925    case GL_LUMINANCE32I_EXT:
 926    case GL_LUMINANCE_ALPHA32I_EXT:
 927       /* xxx */
 928       if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,
 929                                       target,
 930                                       sample_count, bindings, geom_flags))
 931          return PIPE_FORMAT_R32G32B32A32_SSCALED;
 932       return PIPE_FORMAT_NONE;
 933
 934    case GL_RGBA8UI_EXT:
 935    case GL_RGB8UI_EXT:
 936    case GL_ALPHA8UI_EXT:
 937    case GL_INTENSITY8UI_EXT:
 938    case GL_LUMINANCE8UI_EXT:
 939    case GL_LUMINANCE_ALPHA8UI_EXT:
 940       if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,
 941                                       target,
 942                                       sample_count, bindings, geom_flags))
 943          return PIPE_FORMAT_R8G8B8A8_USCALED;
 944       return PIPE_FORMAT_NONE;
 945
 946    case GL_RGBA16UI_EXT:
 947    case GL_RGB16UI_EXT:
 948    case GL_ALPHA16UI_EXT:
 949    case GL_INTENSITY16UI_EXT:
 950    case GL_LUMINANCE16UI_EXT:
 951    case GL_LUMINANCE_ALPHA16UI_EXT:
 952       if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,
 953                                       target,
 954                                       sample_count, bindings, geom_flags))
 955          return PIPE_FORMAT_R16G16B16A16_USCALED;
 956       return PIPE_FORMAT_NONE;
 957
 958    case GL_RGBA32UI_EXT:
 959    case GL_RGB32UI_EXT:
 960    case GL_ALPHA32UI_EXT:
 961    case GL_INTENSITY32UI_EXT:
 962    case GL_LUMINANCE32UI_EXT:
 963    case GL_LUMINANCE_ALPHA32UI_EXT:
 964       if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,
 965                                       target,
 966                                       sample_count, bindings, geom_flags))
 967          return PIPE_FORMAT_R32G32B32A32_USCALED;
 968       return PIPE_FORMAT_NONE;
 969
 970    default:
 971       return PIPE_FORMAT_NONE;
 972    }
 973 }
 974
 975
 976 /**
 977  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
 978  */
 979 enum pipe_format
 980 st_choose_renderbuffer_format(struct pipe_screen *screen,
 981                               GLenum internalFormat, unsigned sample_count)
 982 {
 983    uint usage;
 984    if (_mesa_is_depth_or_stencil_format(internalFormat))
 985       usage = PIPE_BIND_DEPTH_STENCIL;
 986    else
 987       usage = PIPE_BIND_RENDER_TARGET;
 988    return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D,
 989                            sample_count, usage);
 990 }
 991
 992
 993 /**
 994  * Called via ctx->Driver.chooseTextureFormat().
 995  */
 996 gl_format
 997 st_ChooseTextureFormat_renderable(struct gl_context *ctx, GLint internalFormat,
 998                                   GLenum format, GLenum type, GLboolean renderable)
 999 {
1000    struct pipe_screen *screen = st_context(ctx)->pipe->screen;
1001    enum pipe_format pFormat;
1002    uint bindings;
1003
1004    (void) format;
1005    (void) type;
1006
1007    /* GL textures may wind up being render targets, but we don't know
1008     * that in advance.  Specify potential render target flags now.
1009     */
1010    bindings = PIPE_BIND_SAMPLER_VIEW;
1011    if (renderable == GL_TRUE) {
1012       if (_mesa_is_depth_format(internalFormat) ||
1013           _mesa_is_depth_or_stencil_format(internalFormat))
1014          bindings |= PIPE_BIND_DEPTH_STENCIL;
1015       else
1016          bindings |= PIPE_BIND_RENDER_TARGET;
1017    }
1018
1019    pFormat = st_choose_format(screen, internalFormat,
1020                               PIPE_TEXTURE_2D, 0, bindings);
1021
1022    if (pFormat == PIPE_FORMAT_NONE) {
1023       /* try choosing format again, this time without render target bindings */
1024       pFormat = st_choose_format(screen, internalFormat,
1025                                  PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW);
1026    }
1027
1028    if (pFormat == PIPE_FORMAT_NONE) {
1029       /* no luck at all */
1030       return MESA_FORMAT_NONE;
1031    }
1032
1033    return st_pipe_format_to_mesa_format(pFormat);
1034 }
1035
1036 gl_format
1037 st_ChooseTextureFormat(struct gl_context *ctx, GLint internalFormat,
1038                        GLenum format, GLenum type)
1039 {
1040    boolean want_renderable =
1041       internalFormat == 3 || internalFormat == 4 ||
1042       internalFormat == GL_RGB || internalFormat == GL_RGBA ||
1043       internalFormat == GL_RGB8 || internalFormat == GL_RGBA8 ||
1044       internalFormat == GL_BGRA;
1045
1046    return st_ChooseTextureFormat_renderable(ctx, internalFormat,
1047                                             format, type, want_renderable);
1048 }
1049
1050 /**
1051  * Test if a gallium format is equivalent to a GL format/type.
1052  */
1053 GLboolean
1054 st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)
1055 {
1056    switch (pFormat) {
1057    case PIPE_FORMAT_A8B8G8R8_UNORM:
1058       return format == GL_RGBA && type == GL_UNSIGNED_BYTE;
1059    case PIPE_FORMAT_A8R8G8B8_UNORM:
1060       return format == GL_BGRA && type == GL_UNSIGNED_BYTE;
1061    case PIPE_FORMAT_B5G6R5_UNORM:
1062       return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;
1063    /* XXX more combos... */
1064    default:
1065       return GL_FALSE;
1066    }
1067 }
1068
1069 GLboolean
1070 st_sampler_compat_formats(enum pipe_format format1, enum pipe_format format2)
1071 {
1072    if (format1 == format2)
1073       return GL_TRUE;
1074
1075    if (format1 == PIPE_FORMAT_B8G8R8A8_UNORM &&
1076        format2 == PIPE_FORMAT_B8G8R8X8_UNORM)
1077       return GL_TRUE;
1078
1079    if (format1 == PIPE_FORMAT_B8G8R8X8_UNORM &&
1080        format2 == PIPE_FORMAT_B8G8R8A8_UNORM)
1081       return GL_TRUE;
1082
1083    if (format1 == PIPE_FORMAT_A8B8G8R8_UNORM &&
1084        format2 == PIPE_FORMAT_X8B8G8R8_UNORM)
1085       return GL_TRUE;
1086
1087    if (format1 == PIPE_FORMAT_X8B8G8R8_UNORM &&
1088        format2 == PIPE_FORMAT_A8B8G8R8_UNORM)
1089       return GL_TRUE;
1090
1091    if (format1 == PIPE_FORMAT_A8R8G8B8_UNORM &&
1092        format2 == PIPE_FORMAT_X8R8G8B8_UNORM)
1093       return GL_TRUE;
1094
1095    if (format1 == PIPE_FORMAT_X8R8G8B8_UNORM &&
1096        format2 == PIPE_FORMAT_A8R8G8B8_UNORM)
1097       return GL_TRUE;
1098
1099    return GL_FALSE;
1100 }