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