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