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