src/mesa/state_tracker/st_format.c

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