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 "st_context.h"
  46 #include "st_format.h"
  47
  48 static GLuint
  49 format_bits(
  50    pipe_format_rgbazs_t  info,
  51    GLuint comp )
  52 {
  53    return pf_get_component_bits( (enum pipe_format) info, comp );
  54 }
  55
  56 static GLuint
  57 format_max_bits(
  58    pipe_format_rgbazs_t  info )
  59 {
  60    GLuint   size = format_bits( info, PIPE_FORMAT_COMP_R );
  61
  62    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_G ) );
  63    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_B ) );
  64    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_A ) );
  65    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_Z ) );
  66    size = MAX2( size, format_bits( info, PIPE_FORMAT_COMP_S ) );
  67    return size;
  68 }
  69
  70 static GLuint
  71 format_size(
  72    pipe_format_rgbazs_t  info )
  73 {
  74    return
  75       format_bits( info, PIPE_FORMAT_COMP_R ) +
  76       format_bits( info, PIPE_FORMAT_COMP_G ) +
  77       format_bits( info, PIPE_FORMAT_COMP_B ) +
  78       format_bits( info, PIPE_FORMAT_COMP_A ) +
  79       format_bits( info, PIPE_FORMAT_COMP_Z ) +
  80       format_bits( info, PIPE_FORMAT_COMP_S );
  81 }
  82
  83 /*
  84  * XXX temporary here
  85  */
  86 GLboolean
  87 st_get_format_info(enum pipe_format format, struct pipe_format_info *pinfo)
  88 {
  89    if (pf_layout(format) == PIPE_FORMAT_LAYOUT_RGBAZS) {
  90       pipe_format_rgbazs_t info;
  91
  92       info = format;
  93
  94 #if 0
  95       printf("%s\n", pf_name( format ) );
  96 #endif
  97
  98       /* Data type */
  99       if (format == PIPE_FORMAT_A1R5G5B5_UNORM || format == PIPE_FORMAT_R5G6B5_UNORM) {
 100          pinfo->datatype = GL_UNSIGNED_SHORT;
 101       }
 102       else {
 103          GLuint size;
 104
 105          size = format_max_bits( info );
 106          if (size == 8) {
 107             if (pf_type(info) == PIPE_FORMAT_TYPE_UNORM)
 108                pinfo->datatype = GL_UNSIGNED_BYTE;
 109             else
 110                pinfo->datatype = GL_BYTE;
 111          }
 112          else if (size == 16) {
 113             if (pf_type(info) == PIPE_FORMAT_TYPE_UNORM)
 114                pinfo->datatype = GL_UNSIGNED_SHORT;
 115             else
 116                pinfo->datatype = GL_SHORT;
 117          }
 118          else {
 119             assert( size <= 32 );
 120             if (pf_type(info) == PIPE_FORMAT_TYPE_UNORM)
 121                pinfo->datatype = GL_UNSIGNED_INT;
 122             else
 123                pinfo->datatype = GL_INT;
 124          }
 125       }
 126
 127       /* Component bits */
 128       pinfo->red_bits = format_bits( info, PIPE_FORMAT_COMP_R );
 129       pinfo->green_bits = format_bits( info, PIPE_FORMAT_COMP_G );
 130       pinfo->blue_bits = format_bits( info, PIPE_FORMAT_COMP_B );
 131       pinfo->alpha_bits = format_bits( info, PIPE_FORMAT_COMP_A );
 132       pinfo->depth_bits = format_bits( info, PIPE_FORMAT_COMP_Z );
 133       pinfo->stencil_bits = format_bits( info, PIPE_FORMAT_COMP_S );
 134       pinfo->luminance_bits = 0;
 135       pinfo->intensity_bits = 0;
 136
 137       /* Format size */
 138       pinfo->size = format_size( info ) / 8;
 139
 140       /* Luminance & Intensity bits */
 141       if( pf_swizzle_x(info) == PIPE_FORMAT_COMP_R &&
 142           pf_swizzle_y(info) == PIPE_FORMAT_COMP_R &&
 143           pf_swizzle_z(info) == PIPE_FORMAT_COMP_R ) {
 144          if( pf_swizzle_w(info) == PIPE_FORMAT_COMP_R ) {
 145             pinfo->intensity_bits = pinfo->red_bits;
 146          }
 147          else {
 148             pinfo->luminance_bits = pinfo->red_bits;
 149          }
 150          pinfo->red_bits = 0;
 151       }
 152
 153       /* Base format */
 154       if (pinfo->depth_bits) {
 155          if (pinfo->stencil_bits) {
 156             pinfo->base_format = GL_DEPTH_STENCIL_EXT;
 157          }
 158          else {
 159             pinfo->base_format = GL_DEPTH_COMPONENT;
 160          }
 161       }
 162       else if (pinfo->stencil_bits) {
 163          pinfo->base_format = GL_STENCIL_INDEX;
 164       }
 165       else {
 166          pinfo->base_format = GL_RGBA;
 167       }
 168    }
 169    else if (pf_layout(format) == PIPE_FORMAT_LAYOUT_YCBCR) {
 170       pinfo->base_format = GL_YCBCR_MESA;
 171       pinfo->datatype = GL_UNSIGNED_SHORT;
 172       pinfo->size = 2; /* two bytes per "texel" */
 173    }
 174    else {
 175       /* compressed format? */
 176       assert(0);
 177    }
 178
 179 #if 0
 180    printf(
 181       "ST_FORMAT: R(%u), G(%u), B(%u), A(%u), Z(%u), S(%u)\n",
 182       pinfo->red_bits,
 183       pinfo->green_bits,
 184       pinfo->blue_bits,
 185       pinfo->alpha_bits,
 186       pinfo->depth_bits,
 187       pinfo->stencil_bits );
 188 #endif
 189
 190    pinfo->format = format;
 191
 192    return GL_TRUE;
 193 }
 194
 195
 196 /**
 197  * Return bytes per pixel for the given format.
 198  */
 199 GLuint
 200 st_sizeof_format(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.size;
 208 }
 209
 210
 211 /**
 212  * Return bytes per pixel for the given format.
 213  */
 214 GLenum
 215 st_format_datatype(enum pipe_format format)
 216 {
 217    struct pipe_format_info info;
 218    if (!st_get_format_info( format, &info )) {
 219       assert( 0 );
 220       return 0;
 221    }
 222    return info.datatype;
 223 }
 224
 225
 226 enum pipe_format
 227 st_mesa_format_to_pipe_format(GLuint mesaFormat)
 228 {
 229    switch (mesaFormat) {
 230       /* fix this */
 231    case MESA_FORMAT_ARGB8888_REV:
 232    case MESA_FORMAT_ARGB8888:
 233       return PIPE_FORMAT_A8R8G8B8_UNORM;
 234    case MESA_FORMAT_ARGB1555:
 235       return PIPE_FORMAT_A1R5G5B5_UNORM;
 236    case MESA_FORMAT_ARGB4444:
 237       return PIPE_FORMAT_A4R4G4B4_UNORM;
 238    case MESA_FORMAT_RGB565:
 239       return PIPE_FORMAT_R5G6B5_UNORM;
 240    case MESA_FORMAT_AL88:
 241       return PIPE_FORMAT_A8L8_UNORM;
 242    case MESA_FORMAT_A8:
 243       return PIPE_FORMAT_A8_UNORM;
 244    case MESA_FORMAT_L8:
 245       return PIPE_FORMAT_L8_UNORM;
 246    case MESA_FORMAT_I8:
 247       return PIPE_FORMAT_I8_UNORM;
 248    case MESA_FORMAT_Z16:
 249       return PIPE_FORMAT_Z16_UNORM;
 250    case MESA_FORMAT_Z32:
 251       return PIPE_FORMAT_Z32_UNORM;
 252    case MESA_FORMAT_Z24_S8:
 253       return PIPE_FORMAT_Z24S8_UNORM;
 254    case MESA_FORMAT_S8_Z24:
 255       return PIPE_FORMAT_S8Z24_UNORM;
 256    case MESA_FORMAT_YCBCR:
 257       return PIPE_FORMAT_YCBCR;
 258 #if FEATURE_texture_s3tc
 259    case MESA_FORMAT_RGB_DXT1:
 260       return PIPE_FORMAT_DXT1_RGB;
 261    case MESA_FORMAT_RGBA_DXT1:
 262       return PIPE_FORMAT_DXT1_RGBA;
 263    case MESA_FORMAT_RGBA_DXT3:
 264       return PIPE_FORMAT_DXT3_RGBA;
 265    case MESA_FORMAT_RGBA_DXT5:
 266       return PIPE_FORMAT_DXT5_RGBA;
 267 #if FEATURE_EXT_texture_sRGB
 268    case MESA_FORMAT_SRGB_DXT1:
 269       return PIPE_FORMAT_DXT1_SRGB;
 270    case MESA_FORMAT_SRGBA_DXT1:
 271       return PIPE_FORMAT_DXT1_SRGBA;
 272    case MESA_FORMAT_SRGBA_DXT3:
 273       return PIPE_FORMAT_DXT3_SRGBA;
 274    case MESA_FORMAT_SRGBA_DXT5:
 275       return PIPE_FORMAT_DXT5_SRGBA;
 276 #endif
 277 #endif
 278 #if FEATURE_EXT_texture_sRGB
 279    case MESA_FORMAT_SLA8:
 280       return PIPE_FORMAT_A8L8_SRGB;
 281    case MESA_FORMAT_SL8:
 282       return PIPE_FORMAT_L8_SRGB;
 283    case MESA_FORMAT_SRGB8:
 284       return PIPE_FORMAT_R8G8B8_SRGB;
 285    case MESA_FORMAT_SRGBA8:
 286       return PIPE_FORMAT_R8G8B8A8_SRGB;
 287    case MESA_FORMAT_SARGB8:
 288       return PIPE_FORMAT_A8R8G8B8_SRGB;
 289 #endif
 290    default:
 291       assert(0);
 292       return 0;
 293    }
 294 }
 295
 296 /**
 297  * Find an RGBA format supported by the context/winsys.
 298  */
 299 static enum pipe_format
 300 default_rgba_format(struct pipe_screen *screen,
 301                     enum pipe_texture_target target,
 302                     unsigned tex_usage,
 303                     unsigned geom_flags)
 304 {
 305    static const enum pipe_format colorFormats[] = {
 306       PIPE_FORMAT_A8R8G8B8_UNORM,
 307       PIPE_FORMAT_B8G8R8A8_UNORM,
 308       PIPE_FORMAT_R8G8B8A8_UNORM,
 309       PIPE_FORMAT_R5G6B5_UNORM
 310    };
 311    uint i;
 312    for (i = 0; i < Elements(colorFormats); i++) {
 313       if (screen->is_format_supported( screen, colorFormats[i], target, tex_usage, geom_flags )) {
 314          return colorFormats[i];
 315       }
 316    }
 317    return PIPE_FORMAT_NONE;
 318 }
 319
 320 /**
 321  * Find an sRGBA format supported by the context/winsys.
 322  */
 323 static enum pipe_format
 324 default_srgba_format(struct pipe_screen *screen,
 325                     enum pipe_texture_target target,
 326                     unsigned tex_usage,
 327                     unsigned geom_flags)
 328 {
 329    static const enum pipe_format colorFormats[] = {
 330       PIPE_FORMAT_A8R8G8B8_SRGB,
 331       PIPE_FORMAT_B8G8R8A8_SRGB,
 332       PIPE_FORMAT_R8G8B8A8_SRGB,
 333    };
 334    uint i;
 335    for (i = 0; i < Elements(colorFormats); i++) {
 336       if (screen->is_format_supported( screen, colorFormats[i], target, tex_usage, geom_flags )) {
 337          return colorFormats[i];
 338       }
 339    }
 340    return PIPE_FORMAT_NONE;
 341 }
 342
 343 /**
 344  * Search list of formats for first RGBA format with >8 bits/channel.
 345  */
 346 static enum pipe_format
 347 default_deep_rgba_format(struct pipe_screen *screen,
 348                          enum pipe_texture_target target,
 349                          unsigned tex_usage,
 350                          unsigned geom_flags)
 351 {
 352    if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SNORM, target, tex_usage, geom_flags)) {
 353       return PIPE_FORMAT_R16G16B16A16_SNORM;
 354    }
 355    if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
 356       return default_rgba_format(screen, target, tex_usage, geom_flags);
 357    else
 358       return PIPE_FORMAT_NONE;
 359 }
 360
 361
 362 /**
 363  * Find an Z format supported by the context/winsys.
 364  */
 365 static enum pipe_format
 366 default_depth_format(struct pipe_screen *screen,
 367                      enum pipe_texture_target target,
 368                      unsigned tex_usage,
 369                      unsigned geom_flags)
 370 {
 371    static const enum pipe_format zFormats[] = {
 372       PIPE_FORMAT_Z16_UNORM,
 373       PIPE_FORMAT_Z32_UNORM,
 374       PIPE_FORMAT_S8Z24_UNORM,
 375       PIPE_FORMAT_Z24S8_UNORM
 376    };
 377    uint i;
 378    for (i = 0; i < Elements(zFormats); i++) {
 379       if (screen->is_format_supported( screen, zFormats[i], target, tex_usage, geom_flags )) {
 380          return zFormats[i];
 381       }
 382    }
 383    return PIPE_FORMAT_NONE;
 384 }
 385
 386
 387 /**
 388  * Given an OpenGL internalFormat value for a texture or surface, return
 389  * the best matching PIPE_FORMAT_x, or PIPE_FORMAT_NONE if there's no match.
 390  * \param target  one of PIPE_TEXTURE_x
 391  * \param tex_usage  either PIPE_TEXTURE_USAGE_RENDER_TARGET
 392  *                   or PIPE_TEXTURE_USAGE_SAMPLER
 393  */
 394 enum pipe_format
 395 st_choose_format(struct pipe_context *pipe, GLint internalFormat,
 396                  enum pipe_texture_target target, unsigned tex_usage)
 397 {
 398    struct pipe_screen *screen = pipe->screen;
 399    unsigned geom_flags = 0;
 400
 401    switch (internalFormat) {
 402    case 4:
 403    case GL_RGBA:
 404    case GL_COMPRESSED_RGBA:
 405    case 3:
 406    case GL_RGB:
 407    case GL_COMPRESSED_RGB:
 408    case GL_RGBA8:
 409    case GL_RGB10_A2:
 410    case GL_RGBA12:
 411       return default_rgba_format( screen, target, tex_usage, geom_flags );
 412    case GL_RGBA16:
 413       if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
 414          return default_deep_rgba_format( screen, target, tex_usage, geom_flags );
 415       else
 416          return default_rgba_format( screen, target, tex_usage, geom_flags );
 417
 418    case GL_RGBA4:
 419    case GL_RGBA2:
 420       if (screen->is_format_supported( screen, PIPE_FORMAT_A4R4G4B4_UNORM, target, tex_usage, geom_flags ))
 421          return PIPE_FORMAT_A4R4G4B4_UNORM;
 422       return default_rgba_format( screen, target, tex_usage, geom_flags );
 423
 424    case GL_RGB5_A1:
 425       if (screen->is_format_supported( screen, PIPE_FORMAT_A1R5G5B5_UNORM, target, tex_usage, geom_flags ))
 426          return PIPE_FORMAT_A1R5G5B5_UNORM;
 427       return default_rgba_format( screen, target, tex_usage, geom_flags );
 428
 429    case GL_RGB8:
 430    case GL_RGB10:
 431    case GL_RGB12:
 432    case GL_RGB16:
 433       return default_rgba_format( screen, target, tex_usage, geom_flags );
 434
 435    case GL_RGB5:
 436    case GL_RGB4:
 437    case GL_R3_G3_B2:
 438       if (screen->is_format_supported( screen, PIPE_FORMAT_A1R5G5B5_UNORM, target, tex_usage, geom_flags ))
 439          return PIPE_FORMAT_A1R5G5B5_UNORM;
 440       if (screen->is_format_supported( screen, PIPE_FORMAT_R5G6B5_UNORM, target, tex_usage, geom_flags ))
 441          return PIPE_FORMAT_R5G6B5_UNORM;
 442       return default_rgba_format( screen, target, tex_usage, geom_flags );
 443
 444    case GL_ALPHA:
 445    case GL_ALPHA4:
 446    case GL_ALPHA8:
 447    case GL_ALPHA12:
 448    case GL_ALPHA16:
 449    case GL_COMPRESSED_ALPHA:
 450       if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target, tex_usage, geom_flags ))
 451          return PIPE_FORMAT_A8_UNORM;
 452       return default_rgba_format( screen, target, tex_usage, geom_flags );
 453
 454    case 1:
 455    case GL_LUMINANCE:
 456    case GL_LUMINANCE4:
 457    case GL_LUMINANCE8:
 458    case GL_LUMINANCE12:
 459    case GL_LUMINANCE16:
 460    case GL_COMPRESSED_LUMINANCE:
 461       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target, tex_usage, geom_flags ))
 462          return PIPE_FORMAT_L8_UNORM;
 463       return default_rgba_format( screen, target, tex_usage, geom_flags );
 464
 465    case 2:
 466    case GL_LUMINANCE_ALPHA:
 467    case GL_LUMINANCE4_ALPHA4:
 468    case GL_LUMINANCE6_ALPHA2:
 469    case GL_LUMINANCE8_ALPHA8:
 470    case GL_LUMINANCE12_ALPHA4:
 471    case GL_LUMINANCE12_ALPHA12:
 472    case GL_LUMINANCE16_ALPHA16:
 473    case GL_COMPRESSED_LUMINANCE_ALPHA:
 474       if (screen->is_format_supported( screen, PIPE_FORMAT_A8L8_UNORM, target, tex_usage, geom_flags ))
 475          return PIPE_FORMAT_A8L8_UNORM;
 476       return default_rgba_format( screen, target, tex_usage, geom_flags );
 477
 478    case GL_INTENSITY:
 479    case GL_INTENSITY4:
 480    case GL_INTENSITY8:
 481    case GL_INTENSITY12:
 482    case GL_INTENSITY16:
 483    case GL_COMPRESSED_INTENSITY:
 484       if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target, tex_usage, geom_flags ))
 485          return PIPE_FORMAT_I8_UNORM;
 486       return default_rgba_format( screen, target, tex_usage, geom_flags );
 487
 488    case GL_YCBCR_MESA:
 489       if (screen->is_format_supported(screen, PIPE_FORMAT_YCBCR,
 490                                       target, tex_usage, geom_flags)) {
 491          return PIPE_FORMAT_YCBCR;
 492       }
 493       if (screen->is_format_supported(screen, PIPE_FORMAT_YCBCR_REV,
 494                                       target, tex_usage, geom_flags)) {
 495          return PIPE_FORMAT_YCBCR_REV;
 496       }
 497       return PIPE_FORMAT_NONE;
 498
 499    case GL_RGB_S3TC:
 500    case GL_RGB4_S3TC:
 501    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 502       return PIPE_FORMAT_DXT1_RGB;
 503
 504    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 505       return PIPE_FORMAT_DXT1_RGBA;
 506
 507    case GL_RGBA_S3TC:
 508    case GL_RGBA4_S3TC:
 509    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 510       return PIPE_FORMAT_DXT3_RGBA;
 511
 512    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 513       return PIPE_FORMAT_DXT5_RGBA;
 514
 515 #if 0
 516    case GL_COMPRESSED_RGB_FXT1_3DFX:
 517       return PIPE_FORMAT_RGB_FXT1;
 518    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 519       return PIPE_FORMAT_RGB_FXT1;
 520 #endif
 521
 522    case GL_DEPTH_COMPONENT16:
 523       if (screen->is_format_supported( screen, PIPE_FORMAT_Z16_UNORM, target, tex_usage, geom_flags ))
 524          return PIPE_FORMAT_Z16_UNORM;
 525       /* fall-through */
 526    case GL_DEPTH_COMPONENT24:
 527       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 528          return PIPE_FORMAT_S8Z24_UNORM;
 529       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 530          return PIPE_FORMAT_Z24S8_UNORM;
 531       /* fall-through */
 532    case GL_DEPTH_COMPONENT32:
 533       if (screen->is_format_supported( screen, PIPE_FORMAT_Z32_UNORM, target, tex_usage, geom_flags ))
 534          return PIPE_FORMAT_Z32_UNORM;
 535       /* fall-through */
 536    case GL_DEPTH_COMPONENT:
 537       return default_depth_format( screen, target, tex_usage, geom_flags );
 538
 539    case GL_STENCIL_INDEX:
 540    case GL_STENCIL_INDEX1_EXT:
 541    case GL_STENCIL_INDEX4_EXT:
 542    case GL_STENCIL_INDEX8_EXT:
 543    case GL_STENCIL_INDEX16_EXT:
 544       if (screen->is_format_supported( screen, PIPE_FORMAT_S8_UNORM, target, tex_usage, geom_flags ))
 545          return PIPE_FORMAT_S8_UNORM;
 546       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 547          return PIPE_FORMAT_S8Z24_UNORM;
 548       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 549          return PIPE_FORMAT_Z24S8_UNORM;
 550       return PIPE_FORMAT_NONE;
 551
 552    case GL_DEPTH_STENCIL_EXT:
 553    case GL_DEPTH24_STENCIL8_EXT:
 554       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 555          return PIPE_FORMAT_S8Z24_UNORM;
 556       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 557          return PIPE_FORMAT_Z24S8_UNORM;
 558       return PIPE_FORMAT_NONE;
 559
 560    case GL_SRGB_EXT:
 561    case GL_SRGB8_EXT:
 562    case GL_COMPRESSED_SRGB_EXT:
 563    case GL_COMPRESSED_SRGB_ALPHA_EXT:
 564    case GL_SRGB_ALPHA_EXT:
 565    case GL_SRGB8_ALPHA8_EXT:
 566       return default_srgba_format( screen, target, tex_usage, geom_flags );
 567    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 568       return PIPE_FORMAT_DXT1_SRGB;
 569    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 570       return PIPE_FORMAT_DXT1_SRGBA;
 571    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 572       return PIPE_FORMAT_DXT3_SRGBA;
 573    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 574       return PIPE_FORMAT_DXT5_SRGBA;
 575
 576    case GL_SLUMINANCE_ALPHA_EXT:
 577    case GL_SLUMINANCE8_ALPHA8_EXT:
 578    case GL_COMPRESSED_SLUMINANCE_EXT:
 579    case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 580       if (screen->is_format_supported( screen, PIPE_FORMAT_A8L8_SRGB, target, tex_usage, geom_flags ))
 581          return PIPE_FORMAT_A8L8_SRGB;
 582       return default_srgba_format( screen, target, tex_usage, geom_flags );
 583
 584    case GL_SLUMINANCE_EXT:
 585    case GL_SLUMINANCE8_EXT:
 586       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_SRGB, target, tex_usage, geom_flags ))
 587          return PIPE_FORMAT_L8_SRGB;
 588       return default_srgba_format( screen, target, tex_usage, geom_flags );
 589
 590    default:
 591       return PIPE_FORMAT_NONE;
 592    }
 593 }
 594
 595
 596 static GLboolean
 597 is_stencil_format(GLenum format)
 598 {
 599    switch (format) {
 600    case GL_STENCIL_INDEX:
 601    case GL_STENCIL_INDEX1_EXT:
 602    case GL_STENCIL_INDEX4_EXT:
 603    case GL_STENCIL_INDEX8_EXT:
 604    case GL_STENCIL_INDEX16_EXT:
 605    case GL_DEPTH_STENCIL_EXT:
 606    case GL_DEPTH24_STENCIL8_EXT:
 607       return GL_TRUE;
 608    default:
 609       return GL_FALSE;
 610    }
 611 }
 612
 613 /**
 614  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
 615  */
 616 enum pipe_format
 617 st_choose_renderbuffer_format(struct pipe_context *pipe, GLint internalFormat)
 618 {
 619    uint usage;
 620    if (is_stencil_format(internalFormat))
 621       usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
 622    else
 623       usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
 624    return st_choose_format(pipe, internalFormat, PIPE_TEXTURE_2D, usage);
 625 }
 626
 627
 628 static const struct gl_texture_format *
 629 translate_gallium_format_to_mesa_format(enum pipe_format format)
 630 {
 631    switch (format) {
 632    case PIPE_FORMAT_A8R8G8B8_UNORM:
 633       return &_mesa_texformat_argb8888;
 634    case PIPE_FORMAT_A1R5G5B5_UNORM:
 635       return &_mesa_texformat_argb1555;
 636    case PIPE_FORMAT_A4R4G4B4_UNORM:
 637       return &_mesa_texformat_argb4444;
 638    case PIPE_FORMAT_R5G6B5_UNORM:
 639       return &_mesa_texformat_rgb565;
 640    case PIPE_FORMAT_A8L8_UNORM:
 641       return &_mesa_texformat_al88;
 642    case PIPE_FORMAT_A8_UNORM:
 643       return &_mesa_texformat_a8;
 644    case PIPE_FORMAT_L8_UNORM:
 645       return &_mesa_texformat_l8;
 646    case PIPE_FORMAT_I8_UNORM:
 647       return &_mesa_texformat_i8;
 648    case PIPE_FORMAT_Z16_UNORM:
 649       return &_mesa_texformat_z16;
 650    case PIPE_FORMAT_Z32_UNORM:
 651       return &_mesa_texformat_z32;
 652    case PIPE_FORMAT_Z24S8_UNORM:
 653       return &_mesa_texformat_z24_s8;
 654    case PIPE_FORMAT_S8Z24_UNORM:
 655       return &_mesa_texformat_s8_z24;
 656    case PIPE_FORMAT_YCBCR:
 657       return &_mesa_texformat_ycbcr;
 658    case PIPE_FORMAT_YCBCR_REV:
 659       return &_mesa_texformat_ycbcr_rev;
 660 #if FEATURE_texture_s3tc
 661    case PIPE_FORMAT_DXT1_RGB:
 662       return &_mesa_texformat_rgb_dxt1;
 663    case PIPE_FORMAT_DXT1_RGBA:
 664       return &_mesa_texformat_rgba_dxt1;
 665    case PIPE_FORMAT_DXT3_RGBA:
 666       return &_mesa_texformat_rgba_dxt3;
 667    case PIPE_FORMAT_DXT5_RGBA:
 668       return &_mesa_texformat_rgba_dxt5;
 669 #if FEATURE_EXT_texture_sRGB
 670    case PIPE_FORMAT_DXT1_SRGB:
 671       return &_mesa_texformat_srgb_dxt1;
 672    case PIPE_FORMAT_DXT1_SRGBA:
 673       return &_mesa_texformat_srgba_dxt1;
 674    case PIPE_FORMAT_DXT3_SRGBA:
 675       return &_mesa_texformat_srgba_dxt3;
 676    case PIPE_FORMAT_DXT5_SRGBA:
 677       return &_mesa_texformat_srgba_dxt5;
 678 #endif
 679 #endif
 680 #if FEATURE_EXT_texture_sRGB
 681    case PIPE_FORMAT_A8L8_SRGB:
 682       return &_mesa_texformat_sla8;
 683    case PIPE_FORMAT_L8_SRGB:
 684       return &_mesa_texformat_sl8;
 685    case PIPE_FORMAT_R8G8B8_SRGB:
 686       return &_mesa_texformat_srgb8;
 687    case PIPE_FORMAT_R8G8B8A8_SRGB:
 688       return &_mesa_texformat_srgba8;
 689    case PIPE_FORMAT_A8R8G8B8_SRGB:
 690       return &_mesa_texformat_sargb8;
 691 #endif
 692    /* XXX add additional cases */
 693    default:
 694       assert(0);
 695       return NULL;
 696    }
 697 }
 698
 699
 700 /**
 701  * Called via ctx->Driver.chooseTextureFormat().
 702  */
 703 const struct gl_texture_format *
 704 st_ChooseTextureFormat(GLcontext *ctx, GLint internalFormat,
 705                        GLenum format, GLenum type)
 706 {
 707    enum pipe_format pFormat;
 708
 709    (void) format;
 710    (void) type;
 711
 712    pFormat = st_choose_format(ctx->st->pipe, internalFormat, PIPE_TEXTURE_2D,
 713                               PIPE_TEXTURE_USAGE_SAMPLER);
 714    if (pFormat == PIPE_FORMAT_NONE)
 715       return NULL;
 716
 717    return translate_gallium_format_to_mesa_format(pFormat);
 718 }