src/mesa/state_tracker/st_format.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * Copyright (c) 2008 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  * Texture Image-related functions.
  32  * \author Brian Paul
  33  */
  34
  35 #include "main/imports.h"
  36 #include "main/context.h"
  37 #include "main/texstore.h"
  38 #include "main/enums.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 static GLuint
  63 format_size(enum pipe_format format)
  64 {
  65    return
  66       util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0) +
  67       util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1) +
  68       util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2) +
  69       util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3) +
  70       util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0) +
  71       util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1);
  72 }
  73
  74 /*
  75  * XXX temporary here
  76  */
  77 GLboolean
  78 st_get_format_info(enum pipe_format format, struct pipe_format_info *pinfo)
  79 {
  80    const struct util_format_description *desc;
  81
  82    desc = util_format_description(format);
  83    assert(desc);
  84
  85    if (desc->layout == UTIL_FORMAT_LAYOUT_PLAIN) {
  86 #if 0
  87       printf("%s\n", util_format_name( format ) );
  88 #endif
  89
  90       /* Data type */
  91       if (format == PIPE_FORMAT_A1R5G5B5_UNORM || format == PIPE_FORMAT_R5G6B5_UNORM) {
  92          pinfo->datatype = GL_UNSIGNED_SHORT;
  93       }
  94       else if (format == PIPE_FORMAT_S8Z24_UNORM ||
  95                format == PIPE_FORMAT_Z24S8_UNORM) {
  96          pinfo->datatype = GL_UNSIGNED_INT_24_8;
  97       }
  98       else {
  99          const GLuint size = format_max_bits(format);
 100          if (size == 8) {
 101             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
 102                pinfo->datatype = GL_UNSIGNED_BYTE;
 103             else
 104                pinfo->datatype = GL_BYTE;
 105          }
 106          else if (size == 16) {
 107             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
 108                pinfo->datatype = GL_UNSIGNED_SHORT;
 109             else
 110                pinfo->datatype = GL_SHORT;
 111          }
 112          else {
 113             assert( size <= 32 );
 114             if (desc->channel[0].type == UTIL_FORMAT_TYPE_UNSIGNED)
 115                pinfo->datatype = GL_UNSIGNED_INT;
 116             else
 117                pinfo->datatype = GL_INT;
 118          }
 119       }
 120
 121       /* Component bits */
 122       pinfo->red_bits = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 0);
 123       pinfo->green_bits = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 1);
 124       pinfo->blue_bits = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 2);
 125       pinfo->alpha_bits = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_RGB, 3);
 126       pinfo->depth_bits = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 0);
 127       pinfo->stencil_bits = util_format_get_component_bits(format, UTIL_FORMAT_COLORSPACE_ZS, 1);
 128       pinfo->luminance_bits = 0;
 129       pinfo->intensity_bits = 0;
 130
 131       /* Format size */
 132       pinfo->size = format_size(format) / 8;
 133
 134       /* Luminance & Intensity bits */
 135       if (desc->swizzle[0] == UTIL_FORMAT_SWIZZLE_X &&
 136           desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_X &&
 137           desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_X) {
 138          if (desc->swizzle[3] == UTIL_FORMAT_SWIZZLE_X) {
 139             pinfo->intensity_bits = pinfo->red_bits;
 140          }
 141          else {
 142             pinfo->luminance_bits = pinfo->red_bits;
 143          }
 144          pinfo->red_bits = 0;
 145       }
 146
 147       pinfo->mesa_format = st_pipe_format_to_mesa_format(format);
 148    }
 149    else if (format == PIPE_FORMAT_YCBCR) {
 150       pinfo->mesa_format = MESA_FORMAT_YCBCR;
 151       pinfo->datatype = GL_UNSIGNED_SHORT;
 152       pinfo->size = 2; /* two bytes per "texel" */
 153    }
 154    else if (format == PIPE_FORMAT_YCBCR_REV) {
 155       pinfo->mesa_format = MESA_FORMAT_YCBCR_REV;
 156       pinfo->datatype = GL_UNSIGNED_SHORT;
 157       pinfo->size = 2; /* two bytes per "texel" */
 158    }
 159    else {
 160       /* compressed format? */
 161       assert(0);
 162    }
 163
 164 #if 0
 165    printf(
 166       "ST_FORMAT: R(%u), G(%u), B(%u), A(%u), Z(%u), S(%u)\n",
 167       pinfo->red_bits,
 168       pinfo->green_bits,
 169       pinfo->blue_bits,
 170       pinfo->alpha_bits,
 171       pinfo->depth_bits,
 172       pinfo->stencil_bits );
 173 #endif
 174
 175    pinfo->format = format;
 176
 177    return GL_TRUE;
 178 }
 179
 180
 181 /**
 182  * Return bytes per pixel for the given format.
 183  */
 184 GLuint
 185 st_sizeof_format(enum pipe_format format)
 186 {
 187    struct pipe_format_info info;
 188    if (!st_get_format_info( format, &info )) {
 189       assert( 0 );
 190       return 0;
 191    }
 192    return info.size;
 193 }
 194
 195
 196 /**
 197  * Return bytes per pixel for the given format.
 198  */
 199 GLenum
 200 st_format_datatype(enum pipe_format format)
 201 {
 202    struct pipe_format_info info;
 203    if (!st_get_format_info( format, &info )) {
 204       assert( 0 );
 205       return 0;
 206    }
 207    return info.datatype;
 208 }
 209
 210
 211 enum pipe_format
 212 st_mesa_format_to_pipe_format(gl_format mesaFormat)
 213 {
 214    switch (mesaFormat) {
 215       /* fix this */
 216    case MESA_FORMAT_ARGB8888_REV:
 217    case MESA_FORMAT_ARGB8888:
 218       return PIPE_FORMAT_A8R8G8B8_UNORM;
 219    case MESA_FORMAT_XRGB8888:
 220       return PIPE_FORMAT_X8R8G8B8_UNORM;
 221    case MESA_FORMAT_ARGB1555:
 222       return PIPE_FORMAT_A1R5G5B5_UNORM;
 223    case MESA_FORMAT_ARGB4444:
 224       return PIPE_FORMAT_A4R4G4B4_UNORM;
 225    case MESA_FORMAT_RGB565:
 226       return PIPE_FORMAT_R5G6B5_UNORM;
 227    case MESA_FORMAT_AL88:
 228       return PIPE_FORMAT_A8L8_UNORM;
 229    case MESA_FORMAT_A8:
 230       return PIPE_FORMAT_A8_UNORM;
 231    case MESA_FORMAT_L8:
 232       return PIPE_FORMAT_L8_UNORM;
 233    case MESA_FORMAT_I8:
 234       return PIPE_FORMAT_I8_UNORM;
 235    case MESA_FORMAT_Z16:
 236       return PIPE_FORMAT_Z16_UNORM;
 237    case MESA_FORMAT_Z32:
 238       return PIPE_FORMAT_Z32_UNORM;
 239    case MESA_FORMAT_Z24_S8:
 240       return PIPE_FORMAT_Z24S8_UNORM;
 241    case MESA_FORMAT_S8_Z24:
 242       return PIPE_FORMAT_S8Z24_UNORM;
 243    case MESA_FORMAT_YCBCR:
 244       return PIPE_FORMAT_YCBCR;
 245 #if FEATURE_texture_s3tc
 246    case MESA_FORMAT_RGB_DXT1:
 247       return PIPE_FORMAT_DXT1_RGB;
 248    case MESA_FORMAT_RGBA_DXT1:
 249       return PIPE_FORMAT_DXT1_RGBA;
 250    case MESA_FORMAT_RGBA_DXT3:
 251       return PIPE_FORMAT_DXT3_RGBA;
 252    case MESA_FORMAT_RGBA_DXT5:
 253       return PIPE_FORMAT_DXT5_RGBA;
 254 #if FEATURE_EXT_texture_sRGB
 255    case MESA_FORMAT_SRGB_DXT1:
 256       return PIPE_FORMAT_DXT1_SRGB;
 257    case MESA_FORMAT_SRGBA_DXT1:
 258       return PIPE_FORMAT_DXT1_SRGBA;
 259    case MESA_FORMAT_SRGBA_DXT3:
 260       return PIPE_FORMAT_DXT3_SRGBA;
 261    case MESA_FORMAT_SRGBA_DXT5:
 262       return PIPE_FORMAT_DXT5_SRGBA;
 263 #endif
 264 #endif
 265 #if FEATURE_EXT_texture_sRGB
 266    case MESA_FORMAT_SLA8:
 267       return PIPE_FORMAT_A8L8_SRGB;
 268    case MESA_FORMAT_SL8:
 269       return PIPE_FORMAT_L8_SRGB;
 270    case MESA_FORMAT_SRGB8:
 271       return PIPE_FORMAT_R8G8B8_SRGB;
 272    case MESA_FORMAT_SRGBA8:
 273       return PIPE_FORMAT_R8G8B8A8_SRGB;
 274    case MESA_FORMAT_SARGB8:
 275       return PIPE_FORMAT_A8R8G8B8_SRGB;
 276 #endif
 277    default:
 278       assert(0);
 279       return 0;
 280    }
 281 }
 282
 283
 284 gl_format
 285 st_pipe_format_to_mesa_format(enum pipe_format pipeFormat)
 286 {
 287    switch (pipeFormat) {
 288    case PIPE_FORMAT_A8R8G8B8_UNORM:
 289       return MESA_FORMAT_ARGB8888;
 290    case PIPE_FORMAT_X8R8G8B8_UNORM:
 291       return MESA_FORMAT_XRGB8888;
 292    case PIPE_FORMAT_B8G8R8A8_UNORM:
 293       return MESA_FORMAT_ARGB8888_REV;
 294    case PIPE_FORMAT_B8G8R8X8_UNORM:
 295       return MESA_FORMAT_XRGB8888_REV;
 296    case PIPE_FORMAT_A1R5G5B5_UNORM:
 297       return MESA_FORMAT_ARGB1555;
 298    case PIPE_FORMAT_A4R4G4B4_UNORM:
 299       return MESA_FORMAT_ARGB4444;
 300    case PIPE_FORMAT_R5G6B5_UNORM:
 301       return MESA_FORMAT_RGB565;
 302    case PIPE_FORMAT_A8L8_UNORM:
 303       return MESA_FORMAT_AL88;
 304    case PIPE_FORMAT_A8_UNORM:
 305       return MESA_FORMAT_A8;
 306    case PIPE_FORMAT_L8_UNORM:
 307       return MESA_FORMAT_L8;
 308    case PIPE_FORMAT_I8_UNORM:
 309       return MESA_FORMAT_I8;
 310    case PIPE_FORMAT_Z16_UNORM:
 311       return MESA_FORMAT_Z16;
 312    case PIPE_FORMAT_Z32_UNORM:
 313       return MESA_FORMAT_Z32;
 314    case PIPE_FORMAT_Z24X8_UNORM:
 315       return MESA_FORMAT_Z24_X8;
 316    case PIPE_FORMAT_Z24S8_UNORM:
 317       return MESA_FORMAT_Z24_S8;
 318    case PIPE_FORMAT_X8Z24_UNORM:
 319       return MESA_FORMAT_X8_Z24;
 320    case PIPE_FORMAT_S8Z24_UNORM:
 321       return MESA_FORMAT_S8_Z24;
 322    case PIPE_FORMAT_S8_UNORM:
 323       return MESA_FORMAT_S8;
 324
 325    case PIPE_FORMAT_YCBCR:
 326       return MESA_FORMAT_YCBCR;
 327    case PIPE_FORMAT_R16G16B16A16_SNORM:
 328       return MESA_FORMAT_SIGNED_RGBA_16;
 329
 330 #if FEATURE_texture_s3tc
 331    case PIPE_FORMAT_DXT1_RGB:
 332       return MESA_FORMAT_RGB_DXT1;
 333    case PIPE_FORMAT_DXT1_RGBA:
 334       return MESA_FORMAT_RGBA_DXT1;
 335    case PIPE_FORMAT_DXT3_RGBA:
 336       return MESA_FORMAT_RGBA_DXT3;
 337    case PIPE_FORMAT_DXT5_RGBA:
 338       return MESA_FORMAT_RGBA_DXT5;
 339 #if FEATURE_EXT_texture_sRGB
 340    case PIPE_FORMAT_DXT1_SRGB:
 341       return MESA_FORMAT_SRGB_DXT1;
 342    case PIPE_FORMAT_DXT1_SRGBA:
 343       return MESA_FORMAT_SRGBA_DXT1;
 344    case PIPE_FORMAT_DXT3_SRGBA:
 345       return MESA_FORMAT_SRGBA_DXT3;
 346    case PIPE_FORMAT_DXT5_SRGBA:
 347       return MESA_FORMAT_SRGBA_DXT5;
 348 #endif
 349 #endif
 350 #if FEATURE_EXT_texture_sRGB
 351    case PIPE_FORMAT_A8L8_SRGB:
 352       return MESA_FORMAT_SLA8;
 353    case PIPE_FORMAT_L8_SRGB:
 354       return MESA_FORMAT_SL8;
 355    case PIPE_FORMAT_R8G8B8_SRGB:
 356       return MESA_FORMAT_SRGB8;
 357    case PIPE_FORMAT_R8G8B8A8_SRGB:
 358       return MESA_FORMAT_SRGBA8;
 359    case PIPE_FORMAT_A8R8G8B8_SRGB:
 360       return MESA_FORMAT_SARGB8;
 361 #endif
 362    default:
 363       assert(0);
 364       return 0;
 365    }
 366 }
 367
 368
 369 /**
 370  * Find an RGBA format supported by the context/winsys.
 371  */
 372 static enum pipe_format
 373 default_rgba_format(struct pipe_screen *screen,
 374                     enum pipe_texture_target target,
 375                     unsigned tex_usage,
 376                     unsigned geom_flags)
 377 {
 378    static const enum pipe_format colorFormats[] = {
 379       PIPE_FORMAT_A8R8G8B8_UNORM,
 380       PIPE_FORMAT_B8G8R8A8_UNORM,
 381       PIPE_FORMAT_R8G8B8A8_UNORM,
 382       PIPE_FORMAT_R5G6B5_UNORM
 383    };
 384    uint i;
 385    for (i = 0; i < Elements(colorFormats); i++) {
 386       if (screen->is_format_supported( screen, colorFormats[i], target, tex_usage, geom_flags )) {
 387          return colorFormats[i];
 388       }
 389    }
 390    return PIPE_FORMAT_NONE;
 391 }
 392
 393 /**
 394  * Find an RGB format supported by the context/winsys.
 395  */
 396 static enum pipe_format
 397 default_rgb_format(struct pipe_screen *screen,
 398                    enum pipe_texture_target target,
 399                    unsigned tex_usage,
 400                    unsigned geom_flags)
 401 {
 402    static const enum pipe_format colorFormats[] = {
 403       PIPE_FORMAT_X8R8G8B8_UNORM,
 404       PIPE_FORMAT_B8G8R8X8_UNORM,
 405       PIPE_FORMAT_R8G8B8X8_UNORM,
 406       PIPE_FORMAT_A8R8G8B8_UNORM,
 407       PIPE_FORMAT_B8G8R8A8_UNORM,
 408       PIPE_FORMAT_R8G8B8A8_UNORM,
 409       PIPE_FORMAT_R5G6B5_UNORM
 410    };
 411    uint i;
 412    for (i = 0; i < Elements(colorFormats); i++) {
 413       if (screen->is_format_supported( screen, colorFormats[i], target, tex_usage, geom_flags )) {
 414          return colorFormats[i];
 415       }
 416    }
 417    return PIPE_FORMAT_NONE;
 418 }
 419
 420 /**
 421  * Find an sRGBA format supported by the context/winsys.
 422  */
 423 static enum pipe_format
 424 default_srgba_format(struct pipe_screen *screen,
 425                     enum pipe_texture_target target,
 426                     unsigned tex_usage,
 427                     unsigned geom_flags)
 428 {
 429    static const enum pipe_format colorFormats[] = {
 430       PIPE_FORMAT_A8R8G8B8_SRGB,
 431       PIPE_FORMAT_B8G8R8A8_SRGB,
 432       PIPE_FORMAT_R8G8B8A8_SRGB,
 433    };
 434    uint i;
 435    for (i = 0; i < Elements(colorFormats); i++) {
 436       if (screen->is_format_supported( screen, colorFormats[i], target, tex_usage, geom_flags )) {
 437          return colorFormats[i];
 438       }
 439    }
 440    return PIPE_FORMAT_NONE;
 441 }
 442
 443 /**
 444  * Search list of formats for first RGBA format with >8 bits/channel.
 445  */
 446 static enum pipe_format
 447 default_deep_rgba_format(struct pipe_screen *screen,
 448                          enum pipe_texture_target target,
 449                          unsigned tex_usage,
 450                          unsigned geom_flags)
 451 {
 452    if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SNORM, target, tex_usage, geom_flags)) {
 453       return PIPE_FORMAT_R16G16B16A16_SNORM;
 454    }
 455    if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
 456       return default_rgba_format(screen, target, tex_usage, geom_flags);
 457    else
 458       return PIPE_FORMAT_NONE;
 459 }
 460
 461
 462 /**
 463  * Find an Z format supported by the context/winsys.
 464  */
 465 static enum pipe_format
 466 default_depth_format(struct pipe_screen *screen,
 467                      enum pipe_texture_target target,
 468                      unsigned tex_usage,
 469                      unsigned geom_flags)
 470 {
 471    static const enum pipe_format zFormats[] = {
 472       PIPE_FORMAT_Z16_UNORM,
 473       PIPE_FORMAT_Z32_UNORM,
 474       PIPE_FORMAT_S8Z24_UNORM,
 475       PIPE_FORMAT_Z24S8_UNORM
 476    };
 477    uint i;
 478    for (i = 0; i < Elements(zFormats); i++) {
 479       if (screen->is_format_supported( screen, zFormats[i], target, tex_usage, geom_flags )) {
 480          return zFormats[i];
 481       }
 482    }
 483    return PIPE_FORMAT_NONE;
 484 }
 485
 486
 487 /**
 488  * Given an OpenGL internalFormat value for a texture or surface, return
 489  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
 490  * \param target  one of PIPE_TEXTURE_x
 491  * \param tex_usage  either PIPE_TEXTURE_USAGE_RENDER_TARGET
 492  *                   or PIPE_TEXTURE_USAGE_SAMPLER
 493  */
 494 enum pipe_format
 495 st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
 496                  enum pipe_texture_target target, unsigned tex_usage)
 497 {
 498    unsigned geom_flags = 0;
 499
 500    switch (internalFormat) {
 501    case 4:
 502    case GL_RGBA:
 503    case GL_COMPRESSED_RGBA:
 504    case GL_RGBA8:
 505    case GL_RGB10_A2:
 506    case GL_RGBA12:
 507       return default_rgba_format( screen, target, tex_usage, geom_flags );
 508    case 3:
 509    case GL_RGB:
 510    case GL_COMPRESSED_RGB:
 511       return default_rgb_format( screen, target, tex_usage, geom_flags );
 512    case GL_RGBA16:
 513       if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
 514          return default_deep_rgba_format( screen, target, tex_usage, geom_flags );
 515       else
 516          return default_rgba_format( screen, target, tex_usage, geom_flags );
 517
 518    case GL_RGBA4:
 519    case GL_RGBA2:
 520       if (screen->is_format_supported( screen, PIPE_FORMAT_A4R4G4B4_UNORM, target, tex_usage, geom_flags ))
 521          return PIPE_FORMAT_A4R4G4B4_UNORM;
 522       return default_rgba_format( screen, target, tex_usage, geom_flags );
 523
 524    case GL_RGB5_A1:
 525       if (screen->is_format_supported( screen, PIPE_FORMAT_A1R5G5B5_UNORM, target, tex_usage, geom_flags ))
 526          return PIPE_FORMAT_A1R5G5B5_UNORM;
 527       return default_rgba_format( screen, target, tex_usage, geom_flags );
 528
 529    case GL_RGB8:
 530    case GL_RGB10:
 531    case GL_RGB12:
 532    case GL_RGB16:
 533       return default_rgb_format( screen, target, tex_usage, geom_flags );
 534
 535    case GL_RGB5:
 536    case GL_RGB4:
 537    case GL_R3_G3_B2:
 538       if (screen->is_format_supported( screen, PIPE_FORMAT_R5G6B5_UNORM, target, tex_usage, geom_flags ))
 539          return PIPE_FORMAT_R5G6B5_UNORM;
 540       if (screen->is_format_supported( screen, PIPE_FORMAT_A1R5G5B5_UNORM, target, tex_usage, geom_flags ))
 541          return PIPE_FORMAT_A1R5G5B5_UNORM;
 542       return default_rgba_format( screen, target, tex_usage, geom_flags );
 543
 544    case GL_ALPHA:
 545    case GL_ALPHA4:
 546    case GL_ALPHA8:
 547    case GL_ALPHA12:
 548    case GL_ALPHA16:
 549    case GL_COMPRESSED_ALPHA:
 550       if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target, tex_usage, geom_flags ))
 551          return PIPE_FORMAT_A8_UNORM;
 552       return default_rgba_format( screen, target, tex_usage, geom_flags );
 553
 554    case 1:
 555    case GL_LUMINANCE:
 556    case GL_LUMINANCE4:
 557    case GL_LUMINANCE8:
 558    case GL_LUMINANCE12:
 559    case GL_LUMINANCE16:
 560    case GL_COMPRESSED_LUMINANCE:
 561       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target, tex_usage, geom_flags ))
 562          return PIPE_FORMAT_L8_UNORM;
 563       return default_rgba_format( screen, target, tex_usage, geom_flags );
 564
 565    case 2:
 566    case GL_LUMINANCE_ALPHA:
 567    case GL_LUMINANCE4_ALPHA4:
 568    case GL_LUMINANCE6_ALPHA2:
 569    case GL_LUMINANCE8_ALPHA8:
 570    case GL_LUMINANCE12_ALPHA4:
 571    case GL_LUMINANCE12_ALPHA12:
 572    case GL_LUMINANCE16_ALPHA16:
 573    case GL_COMPRESSED_LUMINANCE_ALPHA:
 574       if (screen->is_format_supported( screen, PIPE_FORMAT_A8L8_UNORM, target, tex_usage, geom_flags ))
 575          return PIPE_FORMAT_A8L8_UNORM;
 576       return default_rgba_format( screen, target, tex_usage, geom_flags );
 577
 578    case GL_INTENSITY:
 579    case GL_INTENSITY4:
 580    case GL_INTENSITY8:
 581    case GL_INTENSITY12:
 582    case GL_INTENSITY16:
 583    case GL_COMPRESSED_INTENSITY:
 584       if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target, tex_usage, geom_flags ))
 585          return PIPE_FORMAT_I8_UNORM;
 586       return default_rgba_format( screen, target, tex_usage, geom_flags );
 587
 588    case GL_YCBCR_MESA:
 589       if (screen->is_format_supported(screen, PIPE_FORMAT_YCBCR,
 590                                       target, tex_usage, geom_flags)) {
 591          return PIPE_FORMAT_YCBCR;
 592       }
 593       if (screen->is_format_supported(screen, PIPE_FORMAT_YCBCR_REV,
 594                                       target, tex_usage, geom_flags)) {
 595          return PIPE_FORMAT_YCBCR_REV;
 596       }
 597       return PIPE_FORMAT_NONE;
 598
 599    case GL_RGB_S3TC:
 600    case GL_RGB4_S3TC:
 601    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 602       return PIPE_FORMAT_DXT1_RGB;
 603
 604    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 605       return PIPE_FORMAT_DXT1_RGBA;
 606
 607    case GL_RGBA_S3TC:
 608    case GL_RGBA4_S3TC:
 609    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 610       return PIPE_FORMAT_DXT3_RGBA;
 611
 612    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 613       return PIPE_FORMAT_DXT5_RGBA;
 614
 615 #if 0
 616    case GL_COMPRESSED_RGB_FXT1_3DFX:
 617       return PIPE_FORMAT_RGB_FXT1;
 618    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 619       return PIPE_FORMAT_RGB_FXT1;
 620 #endif
 621
 622    case GL_DEPTH_COMPONENT16:
 623       if (screen->is_format_supported( screen, PIPE_FORMAT_Z16_UNORM, target, tex_usage, geom_flags ))
 624          return PIPE_FORMAT_Z16_UNORM;
 625       /* fall-through */
 626    case GL_DEPTH_COMPONENT24:
 627       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 628          return PIPE_FORMAT_S8Z24_UNORM;
 629       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 630          return PIPE_FORMAT_Z24S8_UNORM;
 631       /* fall-through */
 632    case GL_DEPTH_COMPONENT32:
 633       if (screen->is_format_supported( screen, PIPE_FORMAT_Z32_UNORM, target, tex_usage, geom_flags ))
 634          return PIPE_FORMAT_Z32_UNORM;
 635       /* fall-through */
 636    case GL_DEPTH_COMPONENT:
 637       return default_depth_format( screen, target, tex_usage, geom_flags );
 638
 639    case GL_STENCIL_INDEX:
 640    case GL_STENCIL_INDEX1_EXT:
 641    case GL_STENCIL_INDEX4_EXT:
 642    case GL_STENCIL_INDEX8_EXT:
 643    case GL_STENCIL_INDEX16_EXT:
 644       if (screen->is_format_supported( screen, PIPE_FORMAT_S8_UNORM, target, tex_usage, geom_flags ))
 645          return PIPE_FORMAT_S8_UNORM;
 646       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 647          return PIPE_FORMAT_S8Z24_UNORM;
 648       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 649          return PIPE_FORMAT_Z24S8_UNORM;
 650       return PIPE_FORMAT_NONE;
 651
 652    case GL_DEPTH_STENCIL_EXT:
 653    case GL_DEPTH24_STENCIL8_EXT:
 654       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 655          return PIPE_FORMAT_S8Z24_UNORM;
 656       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 657          return PIPE_FORMAT_Z24S8_UNORM;
 658       return PIPE_FORMAT_NONE;
 659
 660    case GL_SRGB_EXT:
 661    case GL_SRGB8_EXT:
 662    case GL_COMPRESSED_SRGB_EXT:
 663    case GL_COMPRESSED_SRGB_ALPHA_EXT:
 664    case GL_SRGB_ALPHA_EXT:
 665    case GL_SRGB8_ALPHA8_EXT:
 666       return default_srgba_format( screen, target, tex_usage, geom_flags );
 667    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 668       return PIPE_FORMAT_DXT1_SRGB;
 669    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 670       return PIPE_FORMAT_DXT1_SRGBA;
 671    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 672       return PIPE_FORMAT_DXT3_SRGBA;
 673    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 674       return PIPE_FORMAT_DXT5_SRGBA;
 675
 676    case GL_SLUMINANCE_ALPHA_EXT:
 677    case GL_SLUMINANCE8_ALPHA8_EXT:
 678    case GL_COMPRESSED_SLUMINANCE_EXT:
 679    case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 680       if (screen->is_format_supported( screen, PIPE_FORMAT_A8L8_SRGB, target, tex_usage, geom_flags ))
 681          return PIPE_FORMAT_A8L8_SRGB;
 682       return default_srgba_format( screen, target, tex_usage, geom_flags );
 683
 684    case GL_SLUMINANCE_EXT:
 685    case GL_SLUMINANCE8_EXT:
 686       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_SRGB, target, tex_usage, geom_flags ))
 687          return PIPE_FORMAT_L8_SRGB;
 688       return default_srgba_format( screen, target, tex_usage, geom_flags );
 689
 690    default:
 691       return PIPE_FORMAT_NONE;
 692    }
 693 }
 694
 695
 696 static GLboolean
 697 is_depth_or_stencil_format(GLenum internalFormat)
 698 {
 699    switch (internalFormat) {
 700    case GL_DEPTH_COMPONENT:
 701    case GL_DEPTH_COMPONENT16:
 702    case GL_DEPTH_COMPONENT24:
 703    case GL_DEPTH_COMPONENT32:
 704    case GL_STENCIL_INDEX:
 705    case GL_STENCIL_INDEX1_EXT:
 706    case GL_STENCIL_INDEX4_EXT:
 707    case GL_STENCIL_INDEX8_EXT:
 708    case GL_STENCIL_INDEX16_EXT:
 709    case GL_DEPTH_STENCIL_EXT:
 710    case GL_DEPTH24_STENCIL8_EXT:
 711       return GL_TRUE;
 712    default:
 713       return GL_FALSE;
 714    }
 715 }
 716
 717 /**
 718  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
 719  */
 720 enum pipe_format
 721 st_choose_renderbuffer_format(struct pipe_screen *screen,
 722                               GLenum internalFormat)
 723 {
 724    uint usage;
 725    if (is_depth_or_stencil_format(internalFormat))
 726       usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
 727    else
 728       usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
 729    return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D, usage);
 730 }
 731
 732
 733 static gl_format
 734 translate_gallium_format_to_mesa_format(enum pipe_format format)
 735 {
 736    switch (format) {
 737    case PIPE_FORMAT_A8R8G8B8_UNORM:
 738       return MESA_FORMAT_ARGB8888;
 739    case PIPE_FORMAT_X8R8G8B8_UNORM:
 740       return MESA_FORMAT_XRGB8888;
 741    case PIPE_FORMAT_A1R5G5B5_UNORM:
 742       return MESA_FORMAT_ARGB1555;
 743    case PIPE_FORMAT_A4R4G4B4_UNORM:
 744       return MESA_FORMAT_ARGB4444;
 745    case PIPE_FORMAT_R5G6B5_UNORM:
 746       return MESA_FORMAT_RGB565;
 747    case PIPE_FORMAT_A8L8_UNORM:
 748       return MESA_FORMAT_AL88;
 749    case PIPE_FORMAT_A8_UNORM:
 750       return MESA_FORMAT_A8;
 751    case PIPE_FORMAT_L8_UNORM:
 752       return MESA_FORMAT_L8;
 753    case PIPE_FORMAT_I8_UNORM:
 754       return MESA_FORMAT_I8;
 755    case PIPE_FORMAT_Z16_UNORM:
 756       return MESA_FORMAT_Z16;
 757    case PIPE_FORMAT_Z32_UNORM:
 758       return MESA_FORMAT_Z32;
 759    case PIPE_FORMAT_Z24S8_UNORM:
 760       return MESA_FORMAT_Z24_S8;
 761    case PIPE_FORMAT_X8Z24_UNORM:
 762       return MESA_FORMAT_X8_Z24;
 763    case PIPE_FORMAT_S8Z24_UNORM:
 764       return MESA_FORMAT_S8_Z24;
 765    case PIPE_FORMAT_YCBCR:
 766       return MESA_FORMAT_YCBCR;
 767    case PIPE_FORMAT_YCBCR_REV:
 768       return MESA_FORMAT_YCBCR_REV;
 769 #if FEATURE_texture_s3tc
 770    case PIPE_FORMAT_DXT1_RGB:
 771       return MESA_FORMAT_RGB_DXT1;
 772    case PIPE_FORMAT_DXT1_RGBA:
 773       return MESA_FORMAT_RGBA_DXT1;
 774    case PIPE_FORMAT_DXT3_RGBA:
 775       return MESA_FORMAT_RGBA_DXT3;
 776    case PIPE_FORMAT_DXT5_RGBA:
 777       return MESA_FORMAT_RGBA_DXT5;
 778 #if FEATURE_EXT_texture_sRGB
 779    case PIPE_FORMAT_DXT1_SRGB:
 780       return MESA_FORMAT_SRGB_DXT1;
 781    case PIPE_FORMAT_DXT1_SRGBA:
 782       return MESA_FORMAT_SRGBA_DXT1;
 783    case PIPE_FORMAT_DXT3_SRGBA:
 784       return MESA_FORMAT_SRGBA_DXT3;
 785    case PIPE_FORMAT_DXT5_SRGBA:
 786       return MESA_FORMAT_SRGBA_DXT5;
 787 #endif
 788 #endif
 789 #if FEATURE_EXT_texture_sRGB
 790    case PIPE_FORMAT_A8L8_SRGB:
 791       return MESA_FORMAT_SLA8;
 792    case PIPE_FORMAT_L8_SRGB:
 793       return MESA_FORMAT_SL8;
 794    case PIPE_FORMAT_R8G8B8_SRGB:
 795       return MESA_FORMAT_SRGB8;
 796    case PIPE_FORMAT_R8G8B8A8_SRGB:
 797       return MESA_FORMAT_SRGBA8;
 798    case PIPE_FORMAT_A8R8G8B8_SRGB:
 799       return MESA_FORMAT_SARGB8;
 800 #endif
 801    /* XXX add additional cases */
 802    default:
 803       assert(0);
 804       return MESA_FORMAT_NONE;
 805    }
 806 }
 807
 808
 809 /**
 810  * Called via ctx->Driver.chooseTextureFormat().
 811  */
 812 gl_format
 813 st_ChooseTextureFormat(GLcontext *ctx, GLint internalFormat,
 814                        GLenum format, GLenum type)
 815 {
 816    enum pipe_format pFormat;
 817
 818    (void) format;
 819    (void) type;
 820
 821    pFormat = st_choose_format(ctx->st->pipe->screen, internalFormat,
 822                               PIPE_TEXTURE_2D, PIPE_TEXTURE_USAGE_SAMPLER);
 823    if (pFormat == PIPE_FORMAT_NONE)
 824       return MESA_FORMAT_NONE;
 825
 826    return translate_gallium_format_to_mesa_format(pFormat);
 827 }
 828
 829
 830 /**
 831  * Test if a gallium format is equivalent to a GL format/type.
 832  */
 833 GLboolean
 834 st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)
 835 {
 836    switch (pFormat) {
 837    case PIPE_FORMAT_R8G8B8A8_UNORM:
 838       return format == GL_RGBA && type == GL_UNSIGNED_BYTE;
 839    case PIPE_FORMAT_B8G8R8A8_UNORM:
 840       return format == GL_BGRA && type == GL_UNSIGNED_BYTE;
 841    case PIPE_FORMAT_R5G6B5_UNORM:
 842       return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;
 843    /* XXX more combos... */
 844    default:
 845       return GL_FALSE;
 846    }
 847 }