src/mesa/state_tracker/st_format.c

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