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_screen *screen, GLenum internalFormat,
 396                  enum pipe_texture_target target, unsigned tex_usage)
 397 {
 398    unsigned geom_flags = 0;
 399
 400    switch (internalFormat) {
 401    case 4:
 402    case GL_RGBA:
 403    case GL_COMPRESSED_RGBA:
 404    case 3:
 405    case GL_RGB:
 406    case GL_COMPRESSED_RGB:
 407    case GL_RGBA8:
 408    case GL_RGB10_A2:
 409    case GL_RGBA12:
 410       return default_rgba_format( screen, target, tex_usage, geom_flags );
 411    case GL_RGBA16:
 412       if (tex_usage & PIPE_TEXTURE_USAGE_RENDER_TARGET)
 413          return default_deep_rgba_format( screen, target, tex_usage, geom_flags );
 414       else
 415          return default_rgba_format( screen, target, tex_usage, geom_flags );
 416
 417    case GL_RGBA4:
 418    case GL_RGBA2:
 419       if (screen->is_format_supported( screen, PIPE_FORMAT_A4R4G4B4_UNORM, target, tex_usage, geom_flags ))
 420          return PIPE_FORMAT_A4R4G4B4_UNORM;
 421       return default_rgba_format( screen, target, tex_usage, geom_flags );
 422
 423    case GL_RGB5_A1:
 424       if (screen->is_format_supported( screen, PIPE_FORMAT_A1R5G5B5_UNORM, target, tex_usage, geom_flags ))
 425          return PIPE_FORMAT_A1R5G5B5_UNORM;
 426       return default_rgba_format( screen, target, tex_usage, geom_flags );
 427
 428    case GL_RGB8:
 429    case GL_RGB10:
 430    case GL_RGB12:
 431    case GL_RGB16:
 432       return default_rgba_format( screen, target, tex_usage, geom_flags );
 433
 434    case GL_RGB5:
 435    case GL_RGB4:
 436    case GL_R3_G3_B2:
 437       if (screen->is_format_supported( screen, PIPE_FORMAT_R5G6B5_UNORM, target, tex_usage, geom_flags ))
 438          return PIPE_FORMAT_R5G6B5_UNORM;
 439       if (screen->is_format_supported( screen, PIPE_FORMAT_A1R5G5B5_UNORM, target, tex_usage, geom_flags ))
 440          return PIPE_FORMAT_A1R5G5B5_UNORM;
 441       return default_rgba_format( screen, target, tex_usage, geom_flags );
 442
 443    case GL_ALPHA:
 444    case GL_ALPHA4:
 445    case GL_ALPHA8:
 446    case GL_ALPHA12:
 447    case GL_ALPHA16:
 448    case GL_COMPRESSED_ALPHA:
 449       if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target, tex_usage, geom_flags ))
 450          return PIPE_FORMAT_A8_UNORM;
 451       return default_rgba_format( screen, target, tex_usage, geom_flags );
 452
 453    case 1:
 454    case GL_LUMINANCE:
 455    case GL_LUMINANCE4:
 456    case GL_LUMINANCE8:
 457    case GL_LUMINANCE12:
 458    case GL_LUMINANCE16:
 459    case GL_COMPRESSED_LUMINANCE:
 460       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target, tex_usage, geom_flags ))
 461          return PIPE_FORMAT_L8_UNORM;
 462       return default_rgba_format( screen, target, tex_usage, geom_flags );
 463
 464    case 2:
 465    case GL_LUMINANCE_ALPHA:
 466    case GL_LUMINANCE4_ALPHA4:
 467    case GL_LUMINANCE6_ALPHA2:
 468    case GL_LUMINANCE8_ALPHA8:
 469    case GL_LUMINANCE12_ALPHA4:
 470    case GL_LUMINANCE12_ALPHA12:
 471    case GL_LUMINANCE16_ALPHA16:
 472    case GL_COMPRESSED_LUMINANCE_ALPHA:
 473       if (screen->is_format_supported( screen, PIPE_FORMAT_A8L8_UNORM, target, tex_usage, geom_flags ))
 474          return PIPE_FORMAT_A8L8_UNORM;
 475       return default_rgba_format( screen, target, tex_usage, geom_flags );
 476
 477    case GL_INTENSITY:
 478    case GL_INTENSITY4:
 479    case GL_INTENSITY8:
 480    case GL_INTENSITY12:
 481    case GL_INTENSITY16:
 482    case GL_COMPRESSED_INTENSITY:
 483       if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target, tex_usage, geom_flags ))
 484          return PIPE_FORMAT_I8_UNORM;
 485       return default_rgba_format( screen, target, tex_usage, geom_flags );
 486
 487    case GL_YCBCR_MESA:
 488       if (screen->is_format_supported(screen, PIPE_FORMAT_YCBCR,
 489                                       target, tex_usage, geom_flags)) {
 490          return PIPE_FORMAT_YCBCR;
 491       }
 492       if (screen->is_format_supported(screen, PIPE_FORMAT_YCBCR_REV,
 493                                       target, tex_usage, geom_flags)) {
 494          return PIPE_FORMAT_YCBCR_REV;
 495       }
 496       return PIPE_FORMAT_NONE;
 497
 498    case GL_RGB_S3TC:
 499    case GL_RGB4_S3TC:
 500    case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
 501       return PIPE_FORMAT_DXT1_RGB;
 502
 503    case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
 504       return PIPE_FORMAT_DXT1_RGBA;
 505
 506    case GL_RGBA_S3TC:
 507    case GL_RGBA4_S3TC:
 508    case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
 509       return PIPE_FORMAT_DXT3_RGBA;
 510
 511    case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
 512       return PIPE_FORMAT_DXT5_RGBA;
 513
 514 #if 0
 515    case GL_COMPRESSED_RGB_FXT1_3DFX:
 516       return PIPE_FORMAT_RGB_FXT1;
 517    case GL_COMPRESSED_RGBA_FXT1_3DFX:
 518       return PIPE_FORMAT_RGB_FXT1;
 519 #endif
 520
 521    case GL_DEPTH_COMPONENT16:
 522       if (screen->is_format_supported( screen, PIPE_FORMAT_Z16_UNORM, target, tex_usage, geom_flags ))
 523          return PIPE_FORMAT_Z16_UNORM;
 524       /* fall-through */
 525    case GL_DEPTH_COMPONENT24:
 526       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 527          return PIPE_FORMAT_S8Z24_UNORM;
 528       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 529          return PIPE_FORMAT_Z24S8_UNORM;
 530       /* fall-through */
 531    case GL_DEPTH_COMPONENT32:
 532       if (screen->is_format_supported( screen, PIPE_FORMAT_Z32_UNORM, target, tex_usage, geom_flags ))
 533          return PIPE_FORMAT_Z32_UNORM;
 534       /* fall-through */
 535    case GL_DEPTH_COMPONENT:
 536       return default_depth_format( screen, target, tex_usage, geom_flags );
 537
 538    case GL_STENCIL_INDEX:
 539    case GL_STENCIL_INDEX1_EXT:
 540    case GL_STENCIL_INDEX4_EXT:
 541    case GL_STENCIL_INDEX8_EXT:
 542    case GL_STENCIL_INDEX16_EXT:
 543       if (screen->is_format_supported( screen, PIPE_FORMAT_S8_UNORM, target, tex_usage, geom_flags ))
 544          return PIPE_FORMAT_S8_UNORM;
 545       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 546          return PIPE_FORMAT_S8Z24_UNORM;
 547       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 548          return PIPE_FORMAT_Z24S8_UNORM;
 549       return PIPE_FORMAT_NONE;
 550
 551    case GL_DEPTH_STENCIL_EXT:
 552    case GL_DEPTH24_STENCIL8_EXT:
 553       if (screen->is_format_supported( screen, PIPE_FORMAT_S8Z24_UNORM, target, tex_usage, geom_flags ))
 554          return PIPE_FORMAT_S8Z24_UNORM;
 555       if (screen->is_format_supported( screen, PIPE_FORMAT_Z24S8_UNORM, target, tex_usage, geom_flags ))
 556          return PIPE_FORMAT_Z24S8_UNORM;
 557       return PIPE_FORMAT_NONE;
 558
 559    case GL_SRGB_EXT:
 560    case GL_SRGB8_EXT:
 561    case GL_COMPRESSED_SRGB_EXT:
 562    case GL_COMPRESSED_SRGB_ALPHA_EXT:
 563    case GL_SRGB_ALPHA_EXT:
 564    case GL_SRGB8_ALPHA8_EXT:
 565       return default_srgba_format( screen, target, tex_usage, geom_flags );
 566    case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
 567       return PIPE_FORMAT_DXT1_SRGB;
 568    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
 569       return PIPE_FORMAT_DXT1_SRGBA;
 570    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
 571       return PIPE_FORMAT_DXT3_SRGBA;
 572    case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
 573       return PIPE_FORMAT_DXT5_SRGBA;
 574
 575    case GL_SLUMINANCE_ALPHA_EXT:
 576    case GL_SLUMINANCE8_ALPHA8_EXT:
 577    case GL_COMPRESSED_SLUMINANCE_EXT:
 578    case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
 579       if (screen->is_format_supported( screen, PIPE_FORMAT_A8L8_SRGB, target, tex_usage, geom_flags ))
 580          return PIPE_FORMAT_A8L8_SRGB;
 581       return default_srgba_format( screen, target, tex_usage, geom_flags );
 582
 583    case GL_SLUMINANCE_EXT:
 584    case GL_SLUMINANCE8_EXT:
 585       if (screen->is_format_supported( screen, PIPE_FORMAT_L8_SRGB, target, tex_usage, geom_flags ))
 586          return PIPE_FORMAT_L8_SRGB;
 587       return default_srgba_format( screen, target, tex_usage, geom_flags );
 588
 589    default:
 590       return PIPE_FORMAT_NONE;
 591    }
 592 }
 593
 594
 595 static GLboolean
 596 is_depth_or_stencil_format(GLenum internalFormat)
 597 {
 598    switch (internalFormat) {
 599    case GL_DEPTH_COMPONENT:
 600    case GL_DEPTH_COMPONENT16:
 601    case GL_DEPTH_COMPONENT24:
 602    case GL_DEPTH_COMPONENT32:
 603    case GL_STENCIL_INDEX:
 604    case GL_STENCIL_INDEX1_EXT:
 605    case GL_STENCIL_INDEX4_EXT:
 606    case GL_STENCIL_INDEX8_EXT:
 607    case GL_STENCIL_INDEX16_EXT:
 608    case GL_DEPTH_STENCIL_EXT:
 609    case GL_DEPTH24_STENCIL8_EXT:
 610       return GL_TRUE;
 611    default:
 612       return GL_FALSE;
 613    }
 614 }
 615
 616 /**
 617  * Called by FBO code to choose a PIPE_FORMAT_ for drawing surfaces.
 618  */
 619 enum pipe_format
 620 st_choose_renderbuffer_format(struct pipe_screen *screen,
 621                               GLenum internalFormat)
 622 {
 623    uint usage;
 624    if (is_depth_or_stencil_format(internalFormat))
 625       usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
 626    else
 627       usage = PIPE_TEXTURE_USAGE_RENDER_TARGET;
 628    return st_choose_format(screen, internalFormat, PIPE_TEXTURE_2D, usage);
 629 }
 630
 631
 632 static const struct gl_texture_format *
 633 translate_gallium_format_to_mesa_format(enum pipe_format format)
 634 {
 635    switch (format) {
 636    case PIPE_FORMAT_A8R8G8B8_UNORM:
 637       return &_mesa_texformat_argb8888;
 638    case PIPE_FORMAT_A1R5G5B5_UNORM:
 639       return &_mesa_texformat_argb1555;
 640    case PIPE_FORMAT_A4R4G4B4_UNORM:
 641       return &_mesa_texformat_argb4444;
 642    case PIPE_FORMAT_R5G6B5_UNORM:
 643       return &_mesa_texformat_rgb565;
 644    case PIPE_FORMAT_A8L8_UNORM:
 645       return &_mesa_texformat_al88;
 646    case PIPE_FORMAT_A8_UNORM:
 647       return &_mesa_texformat_a8;
 648    case PIPE_FORMAT_L8_UNORM:
 649       return &_mesa_texformat_l8;
 650    case PIPE_FORMAT_I8_UNORM:
 651       return &_mesa_texformat_i8;
 652    case PIPE_FORMAT_Z16_UNORM:
 653       return &_mesa_texformat_z16;
 654    case PIPE_FORMAT_Z32_UNORM:
 655       return &_mesa_texformat_z32;
 656    case PIPE_FORMAT_Z24S8_UNORM:
 657       return &_mesa_texformat_z24_s8;
 658    case PIPE_FORMAT_S8Z24_UNORM:
 659       return &_mesa_texformat_s8_z24;
 660    case PIPE_FORMAT_YCBCR:
 661       return &_mesa_texformat_ycbcr;
 662    case PIPE_FORMAT_YCBCR_REV:
 663       return &_mesa_texformat_ycbcr_rev;
 664 #if FEATURE_texture_s3tc
 665    case PIPE_FORMAT_DXT1_RGB:
 666       return &_mesa_texformat_rgb_dxt1;
 667    case PIPE_FORMAT_DXT1_RGBA:
 668       return &_mesa_texformat_rgba_dxt1;
 669    case PIPE_FORMAT_DXT3_RGBA:
 670       return &_mesa_texformat_rgba_dxt3;
 671    case PIPE_FORMAT_DXT5_RGBA:
 672       return &_mesa_texformat_rgba_dxt5;
 673 #if FEATURE_EXT_texture_sRGB
 674    case PIPE_FORMAT_DXT1_SRGB:
 675       return &_mesa_texformat_srgb_dxt1;
 676    case PIPE_FORMAT_DXT1_SRGBA:
 677       return &_mesa_texformat_srgba_dxt1;
 678    case PIPE_FORMAT_DXT3_SRGBA:
 679       return &_mesa_texformat_srgba_dxt3;
 680    case PIPE_FORMAT_DXT5_SRGBA:
 681       return &_mesa_texformat_srgba_dxt5;
 682 #endif
 683 #endif
 684 #if FEATURE_EXT_texture_sRGB
 685    case PIPE_FORMAT_A8L8_SRGB:
 686       return &_mesa_texformat_sla8;
 687    case PIPE_FORMAT_L8_SRGB:
 688       return &_mesa_texformat_sl8;
 689    case PIPE_FORMAT_R8G8B8_SRGB:
 690       return &_mesa_texformat_srgb8;
 691    case PIPE_FORMAT_R8G8B8A8_SRGB:
 692       return &_mesa_texformat_srgba8;
 693    case PIPE_FORMAT_A8R8G8B8_SRGB:
 694       return &_mesa_texformat_sargb8;
 695 #endif
 696    /* XXX add additional cases */
 697    default:
 698       assert(0);
 699       return NULL;
 700    }
 701 }
 702
 703
 704 /**
 705  * Called via ctx->Driver.chooseTextureFormat().
 706  */
 707 const struct gl_texture_format *
 708 st_ChooseTextureFormat(GLcontext *ctx, GLint internalFormat,
 709                        GLenum format, GLenum type)
 710 {
 711    enum pipe_format pFormat;
 712
 713    (void) format;
 714    (void) type;
 715
 716    pFormat = st_choose_format(ctx->st->pipe->screen, internalFormat,
 717                               PIPE_TEXTURE_2D, PIPE_TEXTURE_USAGE_SAMPLER);
 718    if (pFormat == PIPE_FORMAT_NONE)
 719       return NULL;
 720
 721    return translate_gallium_format_to_mesa_format(pFormat);
 722 }
 723
 724
 725 /**
 726  * Test if a gallium format is equivalent to a GL format/type.
 727  */
 728 GLboolean
 729 st_equal_formats(enum pipe_format pFormat, GLenum format, GLenum type)
 730 {
 731    switch (pFormat) {
 732    case PIPE_FORMAT_R8G8B8A8_UNORM:
 733       return format == GL_RGBA && type == GL_UNSIGNED_BYTE;
 734    case PIPE_FORMAT_B8G8R8A8_UNORM:
 735       return format == GL_BGRA && type == GL_UNSIGNED_BYTE;
 736    case PIPE_FORMAT_R5G6B5_UNORM:
 737       return format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5;
 738    /* XXX more combos... */
 739    default:
 740       return GL_FALSE;
 741    }
 742 }